pgindent run on all C files. Java run to follow. initdb/regression

tests pass.

818 files changed, 21811 insertions, 20618 deletions

diff --git a/contrib/array/array_iterator.h b/contrib/array/array_iterator.h
index 68da385c9a..7889fdc0b2 100644
--- a/contrib/array/array_iterator.h
+++ b/contrib/array/array_iterator.h
@@ -34,7 +34,6 @@ int32		array_all_int4le(ArrayType *array, int4 value);
 
 int32		array_oideq(ArrayType *array, Oid value);
 int32		array_all_oidne(ArrayType *array, Oid value);
-
 #endif
 
 /*
diff --git a/contrib/btree_gist/btree_gist.c b/contrib/btree_gist/btree_gist.c
index 999d199ff2..4235c0a5d9 100644
--- a/contrib/btree_gist/btree_gist.c
+++ b/contrib/btree_gist/btree_gist.c
@@ -8,43 +8,46 @@
 #include "utils/geo_decls.h"
 #include "utils/elog.h"
 
-typedef int (*CMPFUNC)(const void *a, const void *b);
-typedef void (*BINARY_UNION)(Datum*, char*);
+typedef int (*CMPFUNC) (const void *a, const void *b);
+typedef void (*BINARY_UNION) (Datum *, char *);
 
-typedef struct intkey {
-	int4	lower;
-	int4	upper;
-} INT4KEY; 
+typedef struct intkey
+{
+	int4		lower;
+	int4		upper;
+}			INT4KEY;
 
-typedef struct tskey {
-        Timestamp       lower;
-        Timestamp       upper;
-} TSKEY;
+typedef struct tskey
+{
+	Timestamp	lower;
+	Timestamp	upper;
+}			TSKEY;
 
 /* used for sorting */
-typedef struct rix {
-    int index;
-    char *r;
-} RIX;
+typedef struct rix
+{
+	int			index;
+	char	   *r;
+}			RIX;
 
 /*
 ** int4key in/out
 */
 PG_FUNCTION_INFO_V1(int4key_in);
 PG_FUNCTION_INFO_V1(int4key_out);
-Datum	int4key_in(PG_FUNCTION_ARGS);
-Datum	int4key_out(PG_FUNCTION_ARGS);
+Datum		int4key_in(PG_FUNCTION_ARGS);
+Datum		int4key_out(PG_FUNCTION_ARGS);
 
 /*
 ** tskey in/out
 */
 PG_FUNCTION_INFO_V1(tskey_in);
 PG_FUNCTION_INFO_V1(tskey_out);
-Datum	tskey_in(PG_FUNCTION_ARGS);
-Datum	tskey_out(PG_FUNCTION_ARGS);
+Datum		tskey_in(PG_FUNCTION_ARGS);
+Datum		tskey_out(PG_FUNCTION_ARGS);
 
 /*
-** int4 ops 
+** int4 ops
 */
 PG_FUNCTION_INFO_V1(gint4_compress);
 PG_FUNCTION_INFO_V1(gint4_union);
@@ -53,15 +56,15 @@ PG_FUNCTION_INFO_V1(gint4_consistent);
 PG_FUNCTION_INFO_V1(gint4_penalty);
 PG_FUNCTION_INFO_V1(gint4_same);
 
-Datum	gint4_compress(PG_FUNCTION_ARGS);
-Datum	gint4_union(PG_FUNCTION_ARGS);
-Datum	gint4_picksplit(PG_FUNCTION_ARGS);
-Datum	gint4_consistent(PG_FUNCTION_ARGS);
-Datum	gint4_penalty(PG_FUNCTION_ARGS);
-Datum	gint4_same(PG_FUNCTION_ARGS);
+Datum		gint4_compress(PG_FUNCTION_ARGS);
+Datum		gint4_union(PG_FUNCTION_ARGS);
+Datum		gint4_picksplit(PG_FUNCTION_ARGS);
+Datum		gint4_consistent(PG_FUNCTION_ARGS);
+Datum		gint4_penalty(PG_FUNCTION_ARGS);
+Datum		gint4_same(PG_FUNCTION_ARGS);
 
 static void gint4_binary_union(Datum *r1, char *r2);
-static int int4key_cmp(const void *a, const void *b);
+static int	int4key_cmp(const void *a, const void *b);
 
 /*
 ** timestamp ops
@@ -73,51 +76,51 @@ PG_FUNCTION_INFO_V1(gts_consistent);
 PG_FUNCTION_INFO_V1(gts_penalty);
 PG_FUNCTION_INFO_V1(gts_same);
 
-Datum   gts_compress(PG_FUNCTION_ARGS);
-Datum   gts_union(PG_FUNCTION_ARGS);
-Datum   gts_picksplit(PG_FUNCTION_ARGS);
-Datum   gts_consistent(PG_FUNCTION_ARGS);
-Datum   gts_penalty(PG_FUNCTION_ARGS);
-Datum   gts_same(PG_FUNCTION_ARGS);
+Datum		gts_compress(PG_FUNCTION_ARGS);
+Datum		gts_union(PG_FUNCTION_ARGS);
+Datum		gts_picksplit(PG_FUNCTION_ARGS);
+Datum		gts_consistent(PG_FUNCTION_ARGS);
+Datum		gts_penalty(PG_FUNCTION_ARGS);
+Datum		gts_same(PG_FUNCTION_ARGS);
 
 static void gts_binary_union(Datum *r1, char *r2);
-static int tskey_cmp(const void *a, const void *b);
+static int	tskey_cmp(const void *a, const void *b);
 
 /* define for comparison */
 #define TSGE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_ge, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_ge, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSGT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_gt, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_gt, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSEQ( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_eq, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_eq, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSLT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_lt, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_lt, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSLE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_le, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_le, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 
 /*
 ** Common btree-function (for all ops)
 */
-static GIST_SPLITVEC * btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, 
-	BINARY_UNION bu, CMPFUNC cmp);
+static GIST_SPLITVEC *btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
+				BINARY_UNION bu, CMPFUNC cmp);
 
 PG_FUNCTION_INFO_V1(btree_decompress);
-Datum btree_decompress(PG_FUNCTION_ARGS);
+Datum		btree_decompress(PG_FUNCTION_ARGS);
 
 /**************************************************
  * int4 ops
@@ -126,334 +129,364 @@ Datum btree_decompress(PG_FUNCTION_ARGS);
 Datum
 gint4_compress(PG_FUNCTION_ARGS)
 {
-	GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
-	GISTENTRY *retval;
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	GISTENTRY  *retval;
+
+	if (entry->leafkey)
+	{
+		INT4KEY    *r = palloc(sizeof(INT4KEY));
 
-	if ( entry->leafkey) {
-		INT4KEY *r = palloc(sizeof(INT4KEY));
 		retval = palloc(sizeof(GISTENTRY));
 		r->lower = r->upper = (entry->key);
-		
+
 		gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
-			entry->offset, sizeof(INT4KEY),FALSE);
+					  entry->offset, sizeof(INT4KEY), FALSE);
 
-	} else {
-		retval = entry;
 	}
-	PG_RETURN_POINTER( retval );
+	else
+		retval = entry;
+	PG_RETURN_POINTER(retval);
 }
 
-Datum 
+Datum
 gint4_consistent(PG_FUNCTION_ARGS)
 {
-    GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
-    int4 query       = PG_GETARG_INT32(1);
-    INT4KEY *kkk= (INT4KEY *)DatumGetPointer(entry->key);
-    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
-    bool retval;
-
-    switch(strategy) {
-	case BTLessEqualStrategyNumber:
-		retval = ( query >= kkk->lower );
-		break;
-	case BTLessStrategyNumber:
-		if (GIST_LEAF(entry)) 
-			retval = ( query >  kkk->lower  );
-		else 
-			retval = ( query >= kkk->lower ); 
-		break;
-	case BTEqualStrategyNumber:
-    		/* in leaf page kkk->lower always = kkk->upper */
-		if (GIST_LEAF(entry)) 
-			retval = ( query == kkk->lower );
-		else 
-			retval = ( kkk->lower <= query && query <= kkk->upper ); 
-		break;
-	case BTGreaterStrategyNumber:
-		if (GIST_LEAF(entry)) 
-			retval = ( query <  kkk->upper  );
-		else 
-			retval = ( query <= kkk->upper ); 
-		break;
-	case BTGreaterEqualStrategyNumber:
-		retval = ( query <= kkk->upper );
-		break;
-	default:
-		retval = FALSE;
-    }
-    PG_RETURN_BOOL(retval);
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	int4		query = PG_GETARG_INT32(1);
+	INT4KEY    *kkk = (INT4KEY *) DatumGetPointer(entry->key);
+	StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+	bool		retval;
+
+	switch (strategy)
+	{
+		case BTLessEqualStrategyNumber:
+			retval = (query >= kkk->lower);
+			break;
+		case BTLessStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = (query > kkk->lower);
+			else
+				retval = (query >= kkk->lower);
+			break;
+		case BTEqualStrategyNumber:
+			/* in leaf page kkk->lower always = kkk->upper */
+			if (GIST_LEAF(entry))
+				retval = (query == kkk->lower);
+			else
+				retval = (kkk->lower <= query && query <= kkk->upper);
+			break;
+		case BTGreaterStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = (query < kkk->upper);
+			else
+				retval = (query <= kkk->upper);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			retval = (query <= kkk->upper);
+			break;
+		default:
+			retval = FALSE;
+	}
+	PG_RETURN_BOOL(retval);
 }
 
 Datum
 gint4_union(PG_FUNCTION_ARGS)
 {
-    bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
-    int i, numranges;
-    INT4KEY *cur, *out=palloc(sizeof(INT4KEY));
-
-    numranges  = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); 
-    *(int*) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
-
-    cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) );
-    out->lower = cur->lower;
-    out->upper = cur->upper;
-
-    for (i = 1; i < numranges; i++) {
-	cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
-	if ( out->lower > cur->lower ) out->lower = cur->lower;	
-	if ( out->upper < cur->upper ) out->upper = cur->upper;	
-    }
+	bytea	   *entryvec = (bytea *) PG_GETARG_POINTER(0);
+	int			i,
+				numranges;
+	INT4KEY    *cur,
+			   *out = palloc(sizeof(INT4KEY));
+
+	numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+	*(int *) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
+
+	cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
+	out->lower = cur->lower;
+	out->upper = cur->upper;
+
+	for (i = 1; i < numranges; i++)
+	{
+		cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
+		if (out->lower > cur->lower)
+			out->lower = cur->lower;
+		if (out->upper < cur->upper)
+			out->upper = cur->upper;
+	}
 
-    PG_RETURN_POINTER( out );
+	PG_RETURN_POINTER(out);
 }
 
 Datum
 gint4_penalty(PG_FUNCTION_ARGS)
 {
-    INT4KEY *origentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); 
-    INT4KEY *newentry  = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key );
-    float *result = (float*) PG_GETARG_POINTER(2);
- 
-    *result = Max( newentry->upper - origentry->upper, 0 ) + 
-	      Max( origentry->lower - newentry->lower, 0 );
-
-    PG_RETURN_POINTER( result );
+	INT4KEY    *origentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
+	INT4KEY    *newentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
+
+	*result = Max(newentry->upper - origentry->upper, 0) +
+		Max(origentry->lower - newentry->lower, 0);
+
+	PG_RETURN_POINTER(result);
 }
 
 Datum
 gint4_picksplit(PG_FUNCTION_ARGS)
 {
-    PG_RETURN_POINTER( btree_picksplit(
-	(bytea*)PG_GETARG_POINTER(0),
-	(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
-	gint4_binary_union,
-	int4key_cmp
-    ) );
+	PG_RETURN_POINTER(btree_picksplit(
+									  (bytea *) PG_GETARG_POINTER(0),
+								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									  gint4_binary_union,
+									  int4key_cmp
+									  ));
 }
 
 Datum
 gint4_same(PG_FUNCTION_ARGS)
 {
-  INT4KEY *b1 = (INT4KEY*) PG_GETARG_POINTER(0);
-  INT4KEY *b2 = (INT4KEY*) PG_GETARG_POINTER(1);
-  bool *result = (bool*) PG_GETARG_POINTER(2);
+	INT4KEY    *b1 = (INT4KEY *) PG_GETARG_POINTER(0);
+	INT4KEY    *b2 = (INT4KEY *) PG_GETARG_POINTER(1);
+	bool	   *result = (bool *) PG_GETARG_POINTER(2);
 
-  *result = ( b1->lower == b2->lower && b1->upper == b2->upper ) ? TRUE : FALSE;
-  PG_RETURN_POINTER(result);
+	*result = (b1->lower == b2->lower && b1->upper == b2->upper) ? TRUE : FALSE;
+	PG_RETURN_POINTER(result);
 }
 
-static void 
+static void
 gint4_binary_union(Datum *r1, char *r2)
 {
-    INT4KEY *b1;
-    INT4KEY *b2 = (INT4KEY*) r2;
-    if ( ! DatumGetPointer( *r1 ) ) {
-	*r1 = PointerGetDatum( palloc( sizeof(INT4KEY) ) );
-	b1 = (INT4KEY*)DatumGetPointer( *r1 ); 
-	b1->upper = b2->upper;
-	b1->lower = b2->lower;
-    } else { 
-	b1 = (INT4KEY*)DatumGetPointer( *r1 ); 
-
-	b1->lower = ( b1->lower > b2->lower ) ?
-		b2->lower : b1->lower;
-	b1->upper = ( b1->upper > b2->upper ) ?
-		b1->upper : b2->upper;
-    }
+	INT4KEY    *b1;
+	INT4KEY    *b2 = (INT4KEY *) r2;
+
+	if (!DatumGetPointer(*r1))
+	{
+		*r1 = PointerGetDatum(palloc(sizeof(INT4KEY)));
+		b1 = (INT4KEY *) DatumGetPointer(*r1);
+		b1->upper = b2->upper;
+		b1->lower = b2->lower;
+	}
+	else
+	{
+		b1 = (INT4KEY *) DatumGetPointer(*r1);
+
+		b1->lower = (b1->lower > b2->lower) ?
+			b2->lower : b1->lower;
+		b1->upper = (b1->upper > b2->upper) ?
+			b1->upper : b2->upper;
+	}
 }
 
 
-static int 
-int4key_cmp(const void *a, const void *b) {
-	return ( ((INT4KEY*)(((RIX*)a)->r))->lower - ((INT4KEY*)(((RIX*)b)->r))->lower );
+static int
+int4key_cmp(const void *a, const void *b)
+{
+	return (((INT4KEY *) (((RIX *) a)->r))->lower - ((INT4KEY *) (((RIX *) b)->r))->lower);
 }
 
 /**************************************************
  * timestamp ops
- **************************************************/  
+ **************************************************/
 
 Datum
 gts_compress(PG_FUNCTION_ARGS)
 {
-	GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
-	GISTENTRY *retval;
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	GISTENTRY  *retval;
+
+	if (entry->leafkey)
+	{
+		TSKEY	   *r = (TSKEY *) palloc(sizeof(TSKEY));
 
-	if ( entry->leafkey) {
-		TSKEY *r = (TSKEY *)palloc( sizeof(TSKEY) );
 		retval = palloc(sizeof(GISTENTRY));
-		if ( entry->key ) {
-			r->lower = r->upper = *(Timestamp*)(entry->key);
+		if (entry->key)
+		{
+			r->lower = r->upper = *(Timestamp *) (entry->key);
 
 			gistentryinit(*retval, PointerGetDatum(r),
 						  entry->rel, entry->page,
 						  entry->offset, sizeof(TSKEY), FALSE);
 
-		} else {
+		}
+		else
+		{
 			gistentryinit(*retval, PointerGetDatum(NULL),
 						  entry->rel, entry->page,
 						  entry->offset, 0, FALSE);
-		} 
-	} else {
-		retval = entry;
+		}
 	}
-	PG_RETURN_POINTER( retval );
+	else
+		retval = entry;
+	PG_RETURN_POINTER(retval);
 }
 
-Datum 
+Datum
 gts_consistent(PG_FUNCTION_ARGS)
 {
-    GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
-    Timestamp *query       = (Timestamp *)PG_GETARG_POINTER(1);
-    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
-    bool retval;
-    TSKEY *key;
-    /*
-    ** if entry is not leaf, use gbox_internal_consistent,
-    ** else use gbox_leaf_consistent
-    */
-    if ( ! entry->key )
-	return FALSE;
-    key = (TSKEY*) DatumGetPointer(entry->key);
-
-    switch(strategy) {
-	case BTLessEqualStrategyNumber:
-		retval = TSGE( query, &(key->lower) );
-		break;
-	case BTLessStrategyNumber:
-		if (GIST_LEAF(entry))
-			retval = TSGT( query, &(key->lower) );
-		else 
-			retval = TSGE( query, &(key->lower) );
-		break;
-	case BTEqualStrategyNumber:
-    		/* in leaf page key->lower always = key->upper */
-		if (GIST_LEAF(entry)) 
-			retval = TSEQ( query, &(key->lower));
-		else 
-			retval = ( TSLE( &(key->lower), query ) && TSLE( query, &(key->upper) ) ); 
-		break;
-	case BTGreaterStrategyNumber:
-		if (GIST_LEAF(entry))
-			retval = TSLT( query, &(key->upper) );
-		else 
-			retval = TSLE( query, &(key->upper) );
-		break;
-	case BTGreaterEqualStrategyNumber:
-		retval = TSLE( query, &(key->upper) );
-		break;
-	default:
-		retval = FALSE;
-    }
-    PG_RETURN_BOOL(retval);
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	Timestamp  *query = (Timestamp *) PG_GETARG_POINTER(1);
+	StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+	bool		retval;
+	TSKEY	   *key;
+
+	/*
+	 * * if entry is not leaf, use gbox_internal_consistent, * else use
+	 * gbox_leaf_consistent
+	 */
+	if (!entry->key)
+		return FALSE;
+	key = (TSKEY *) DatumGetPointer(entry->key);
+
+	switch (strategy)
+	{
+		case BTLessEqualStrategyNumber:
+			retval = TSGE(query, &(key->lower));
+			break;
+		case BTLessStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = TSGT(query, &(key->lower));
+			else
+				retval = TSGE(query, &(key->lower));
+			break;
+		case BTEqualStrategyNumber:
+			/* in leaf page key->lower always = key->upper */
+			if (GIST_LEAF(entry))
+				retval = TSEQ(query, &(key->lower));
+			else
+				retval = (TSLE(&(key->lower), query) && TSLE(query, &(key->upper)));
+			break;
+		case BTGreaterStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = TSLT(query, &(key->upper));
+			else
+				retval = TSLE(query, &(key->upper));
+			break;
+		case BTGreaterEqualStrategyNumber:
+			retval = TSLE(query, &(key->upper));
+			break;
+		default:
+			retval = FALSE;
+	}
+	PG_RETURN_BOOL(retval);
 }
 
 Datum
 gts_union(PG_FUNCTION_ARGS)
 {
-    bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
-    int i, numranges;
-    TSKEY *cur, *out=palloc(sizeof(TSKEY));
-
-    numranges  = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); 
-    *(int*) PG_GETARG_POINTER(1) = sizeof(TSKEY);
-
-    cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) );
-    out->lower = cur->lower;
-    out->upper = cur->upper;
-
-    for (i = 1; i < numranges; i++) {
-	cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
-	if ( TSGT( &out->lower, &cur->lower ) ) out->lower = cur->lower;	
-	if ( TSLT( &out->upper, &cur->upper ) ) out->upper = cur->upper;	
-    }
+	bytea	   *entryvec = (bytea *) PG_GETARG_POINTER(0);
+	int			i,
+				numranges;
+	TSKEY	   *cur,
+			   *out = palloc(sizeof(TSKEY));
+
+	numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+	*(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
+
+	cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
+	out->lower = cur->lower;
+	out->upper = cur->upper;
+
+	for (i = 1; i < numranges; i++)
+	{
+		cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
+		if (TSGT(&out->lower, &cur->lower))
+			out->lower = cur->lower;
+		if (TSLT(&out->upper, &cur->upper))
+			out->upper = cur->upper;
+	}
 
-    PG_RETURN_POINTER( out );
+	PG_RETURN_POINTER(out);
 }
 
 Datum
 gts_penalty(PG_FUNCTION_ARGS)
 {
-    TSKEY *origentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); 
-    TSKEY *newentry  = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key );
-    float *result = (float*) PG_GETARG_POINTER(2);
-    Interval *intr;
+	TSKEY	   *origentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
+	TSKEY	   *newentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
+	Interval   *intr;
 
-    intr = DatumGetIntervalP( DirectFunctionCall2(
-			timestamp_mi,
-                        TimestampGetDatum( newentry->upper ),
-                        TimestampGetDatum( origentry->upper )) );
+	intr = DatumGetIntervalP(DirectFunctionCall2(
+												 timestamp_mi,
+									  TimestampGetDatum(newentry->upper),
+								   TimestampGetDatum(origentry->upper)));
 
 	/* see interval_larger */
-    *result = Max( intr->time+intr->month * (30.0 * 86400),0 ); 
-    pfree( intr );
- 
-    intr = DatumGetIntervalP( DirectFunctionCall2(
-			timestamp_mi,
-                        TimestampGetDatum( origentry->lower ),
-                        TimestampGetDatum( newentry->lower )) );
+	*result = Max(intr->time + intr->month * (30.0 * 86400), 0);
+	pfree(intr);
+
+	intr = DatumGetIntervalP(DirectFunctionCall2(
+												 timestamp_mi,
+									 TimestampGetDatum(origentry->lower),
+									TimestampGetDatum(newentry->lower)));
 
 	/* see interval_larger */
-    *result += Max( intr->time+intr->month * (30.0 * 86400),0 ); 
-    pfree( intr ); 
- 
-    PG_RETURN_POINTER( result );
+	*result += Max(intr->time + intr->month * (30.0 * 86400), 0);
+	pfree(intr);
+
+	PG_RETURN_POINTER(result);
 }
 
 Datum
 gts_picksplit(PG_FUNCTION_ARGS)
 {
-    PG_RETURN_POINTER( btree_picksplit(
-	(bytea*)PG_GETARG_POINTER(0),
-	(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
-	gts_binary_union,
-	tskey_cmp
-    ) );
+	PG_RETURN_POINTER(btree_picksplit(
+									  (bytea *) PG_GETARG_POINTER(0),
+								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									  gts_binary_union,
+									  tskey_cmp
+									  ));
 }
 
 Datum
 gts_same(PG_FUNCTION_ARGS)
 {
-  TSKEY *b1 = (TSKEY*) PG_GETARG_POINTER(0);
-  TSKEY *b2 = (TSKEY*) PG_GETARG_POINTER(1);
-
-  bool *result = (bool*) PG_GETARG_POINTER(2);
-  if ( b1 && b2 )
-	*result = ( TSEQ( &(b1->lower), &(b2->lower) )  && TSEQ( &(b1->upper), &(b2->upper) ) ) ? TRUE : FALSE;
-  else
-	*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE; 
-  PG_RETURN_POINTER(result);
+	TSKEY	   *b1 = (TSKEY *) PG_GETARG_POINTER(0);
+	TSKEY	   *b2 = (TSKEY *) PG_GETARG_POINTER(1);
+
+	bool	   *result = (bool *) PG_GETARG_POINTER(2);
+
+	if (b1 && b2)
+		*result = (TSEQ(&(b1->lower), &(b2->lower)) && TSEQ(&(b1->upper), &(b2->upper))) ? TRUE : FALSE;
+	else
+		*result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
+	PG_RETURN_POINTER(result);
 }
 
-static void 
+static void
 gts_binary_union(Datum *r1, char *r2)
 {
-    TSKEY *b1;
-    TSKEY *b2 = (TSKEY*) r2;
-
-    if ( ! DatumGetPointer( *r1 ) ) {
-	*r1 = PointerGetDatum( palloc( sizeof(TSKEY) ) );
-	b1 = (TSKEY*)DatumGetPointer( *r1 ); 
-	b1->upper = b2->upper;
-	b1->lower = b2->lower;
-    } else { 
-	b1 = (TSKEY*)DatumGetPointer( *r1 ); 
-
-	b1->lower = ( TSGT( &b1->lower, &b2->lower) ) ?
-		b2->lower : b1->lower;
-	b1->upper = ( TSGT( &b1->upper, &b2->upper) ) ?
-		b1->upper : b2->upper;
-    }
+	TSKEY	   *b1;
+	TSKEY	   *b2 = (TSKEY *) r2;
+
+	if (!DatumGetPointer(*r1))
+	{
+		*r1 = PointerGetDatum(palloc(sizeof(TSKEY)));
+		b1 = (TSKEY *) DatumGetPointer(*r1);
+		b1->upper = b2->upper;
+		b1->lower = b2->lower;
+	}
+	else
+	{
+		b1 = (TSKEY *) DatumGetPointer(*r1);
+
+		b1->lower = (TSGT(&b1->lower, &b2->lower)) ?
+			b2->lower : b1->lower;
+		b1->upper = (TSGT(&b1->upper, &b2->upper)) ?
+			b1->upper : b2->upper;
+	}
 }
 
-static int 
-tskey_cmp(const void *a, const void *b) {
-    return DatumGetInt32(
-	DirectFunctionCall2(
-            timestamp_cmp,
-            TimestampGetDatum( ((TSKEY*)(((RIX*)a)->r))->lower ),
-            TimestampGetDatum( ((TSKEY*)(((RIX*)b)->r))->lower )
-        )
-   );
+static int
+tskey_cmp(const void *a, const void *b)
+{
+	return DatumGetInt32(
+						 DirectFunctionCall2(
+											 timestamp_cmp,
+				  TimestampGetDatum(((TSKEY *) (((RIX *) a)->r))->lower),
+				   TimestampGetDatum(((TSKEY *) (((RIX *) b)->r))->lower)
+											 )
+	);
 }
 
 /**************************************************
@@ -466,43 +499,48 @@ tskey_cmp(const void *a, const void *b) {
 static GIST_SPLITVEC *
 btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
 {
-    OffsetNumber i;
-    RIX *array;
-    OffsetNumber maxoff;
-    int nbytes;
-
-    maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1;
-    nbytes =  (maxoff + 2) * sizeof(OffsetNumber);
-    v->spl_left = (OffsetNumber *) palloc(nbytes);
-    v->spl_right = (OffsetNumber *) palloc(nbytes);
-    v->spl_nleft = 0;
-    v->spl_nright = 0;
-    v->spl_ldatum = PointerGetDatum( 0 );
-    v->spl_rdatum = PointerGetDatum( 0 );
-    array = (RIX*)palloc( sizeof(RIX) * (maxoff+1) );
-  
-    /* copy the data into RIXes, and sort the RIXes */
-    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
-	array[i].index = i;
-	array[i].r=(char *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
-    }
-    qsort((void*)&array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
-	 sizeof(RIX), cmp);
-  
-    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
-        if (i <= (maxoff - FirstOffsetNumber + 1)/2) {
-            v->spl_left[ v->spl_nleft ] = array[i].index;
-            v->spl_nleft++;
-	    (*bu)( &v->spl_ldatum, array[i].r );
-        } else {
-            v->spl_right[ v->spl_nright ] = array[i].index;
-            v->spl_nright++;
-	    (*bu)( &v->spl_rdatum, array[i].r );
-        }
-    }
-    pfree(array);
-
-    return( v );
+	OffsetNumber i;
+	RIX		   *array;
+	OffsetNumber maxoff;
+	int			nbytes;
+
+	maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
+	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
+	v->spl_left = (OffsetNumber *) palloc(nbytes);
+	v->spl_right = (OffsetNumber *) palloc(nbytes);
+	v->spl_nleft = 0;
+	v->spl_nright = 0;
+	v->spl_ldatum = PointerGetDatum(0);
+	v->spl_rdatum = PointerGetDatum(0);
+	array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
+
+	/* copy the data into RIXes, and sort the RIXes */
+	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+	{
+		array[i].index = i;
+		array[i].r = (char *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
+	}
+	qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
+		  sizeof(RIX), cmp);
+
+	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+	{
+		if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
+		{
+			v->spl_left[v->spl_nleft] = array[i].index;
+			v->spl_nleft++;
+			(*bu) (&v->spl_ldatum, array[i].r);
+		}
+		else
+		{
+			v->spl_right[v->spl_nright] = array[i].index;
+			v->spl_nright++;
+			(*bu) (&v->spl_rdatum, array[i].r);
+		}
+	}
+	pfree(array);
+
+	return (v);
 }
 
 /*
@@ -512,38 +550,44 @@ btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
 Datum
 btree_decompress(PG_FUNCTION_ARGS)
 {
-    PG_RETURN_POINTER(PG_GETARG_POINTER(0));
+	PG_RETURN_POINTER(PG_GETARG_POINTER(0));
 }
 
 
 /**************************************************
  * In/Out for keys, not really needed
  **************************************************/
-Datum	
-int4key_in(PG_FUNCTION_ARGS) {
-	INT4KEY *key = palloc(sizeof(INT4KEY));
+Datum
+int4key_in(PG_FUNCTION_ARGS)
+{
+	INT4KEY    *key = palloc(sizeof(INT4KEY));
 
-	if ( sscanf( PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2 ) 
+	if (sscanf(PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2)
 		elog(ERROR, "Error in input format");
- 
-	PG_RETURN_POINTER( key );
+
+	PG_RETURN_POINTER(key);
 }
 
-Datum	int4key_out(PG_FUNCTION_ARGS) {
-	INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0);
-	char *str=palloc(sizeof(char)*22);
-	sprintf(str,"%d|%d", key->lower, key->upper);
-	PG_RETURN_POINTER( str ); 
+Datum
+int4key_out(PG_FUNCTION_ARGS)
+{
+	INT4KEY    *key = (INT4KEY *) PG_GETARG_POINTER(0);
+	char	   *str = palloc(sizeof(char) * 22);
+
+	sprintf(str, "%d|%d", key->lower, key->upper);
+	PG_RETURN_POINTER(str);
 }
 
 Datum
-tskey_in(PG_FUNCTION_ARGS) {
+tskey_in(PG_FUNCTION_ARGS)
+{
 	elog(ERROR, "Not implemented");
-	PG_RETURN_POINTER( NULL );
+	PG_RETURN_POINTER(NULL);
 }
 
 Datum
-tskey_out(PG_FUNCTION_ARGS) {
+tskey_out(PG_FUNCTION_ARGS)
+{
 	elog(ERROR, "Not implemented");
-	PG_RETURN_POINTER( NULL );
+	PG_RETURN_POINTER(NULL);
 }
diff --git a/contrib/chkpass/chkpass.c b/contrib/chkpass/chkpass.c
index 2c5974162b..c7c3197c92 100644
--- a/contrib/chkpass/chkpass.c
+++ b/contrib/chkpass/chkpass.c
@@ -4,7 +4,7 @@
  * darcy@druid.net
  * http://www.druid.net/darcy/
  *
- * $Id: chkpass.c,v 1.4 2001/05/30 02:11:46 darcy Exp $
+ * $Id: chkpass.c,v 1.5 2001/10/25 05:49:19 momjian Exp $
  * best viewed with tabs set to 4
  */
 
@@ -31,7 +31,7 @@
 
 typedef struct chkpass
 {
-	char	password[16];
+	char		password[16];
 }			chkpass;
 
 /*
@@ -62,12 +62,12 @@ PG_FUNCTION_INFO_V1(chkpass_in)
 Datum
 chkpass_in(PG_FUNCTION_ARGS)
 {
-	char       *str = PG_GETARG_CSTRING(0);
-	chkpass	   *result;
+	char	   *str = PG_GETARG_CSTRING(0);
+	chkpass    *result;
 	char		mysalt[4];
-	static bool	random_initialized = false;
+	static bool random_initialized = false;
 	static char salt_chars[] =
-		"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
 	/* special case to let us enter encrypted passwords */
 	if (*str == ':')
@@ -81,7 +81,7 @@ chkpass_in(PG_FUNCTION_ARGS)
 	if (verify_pass(str) != 0)
 	{
 		elog(ERROR, "chkpass_in: purported CHKPASS \"%s\" is a weak password",
-		     str);
+			 str);
 		PG_RETURN_POINTER(NULL);
 	}
 
@@ -159,17 +159,18 @@ Datum
 chkpass_eq(PG_FUNCTION_ARGS)
 {
 	chkpass    *a1 = (chkpass *) PG_GETARG_POINTER(0);
-	text       *a2 = (text *) PG_GETARG_TEXT_P(1);
-	char        str[10];
-	int         sz = 8;
+	text	   *a2 = (text *) PG_GETARG_TEXT_P(1);
+	char		str[10];
+	int			sz = 8;
 
 	if (!a1 || !a2)
 		PG_RETURN_BOOL(0);
 
-	if (a2->vl_len < 12) sz = a2->vl_len - 4;
+	if (a2->vl_len < 12)
+		sz = a2->vl_len - 4;
 	strncpy(str, a2->vl_dat, sz);
 	str[sz] = 0;
-	PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) == 0);
+	PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) == 0);
 }
 
 PG_FUNCTION_INFO_V1(chkpass_ne)
@@ -177,14 +178,15 @@ Datum
 chkpass_ne(PG_FUNCTION_ARGS)
 {
 	chkpass    *a1 = (chkpass *) PG_GETARG_POINTER(0);
-	text       *a2 = (text *) PG_GETARG_TEXT_P(1);
-	char        str[10];
-	int         sz = 8;
+	text	   *a2 = (text *) PG_GETARG_TEXT_P(1);
+	char		str[10];
+	int			sz = 8;
 
-	if (!a1 || !a2) PG_RETURN_BOOL(0);
-	if (a2->vl_len < 12) sz = a2->vl_len - 4;
+	if (!a1 || !a2)
+		PG_RETURN_BOOL(0);
+	if (a2->vl_len < 12)
+		sz = a2->vl_len - 4;
 	strncpy(str, a2->vl_dat, sz);
 	str[sz] = 0;
-	PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) != 0);
+	PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) != 0);
 }
-
diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c
index 72f6e5a069..c97e86d3b4 100644
--- a/contrib/cube/cube.c
+++ b/contrib/cube/cube.c
@@ -166,7 +166,6 @@ g_cube_consistent(GISTENTRY *entry,
 				  NDBOX * query,
 				  StrategyNumber strategy)
 {
-
 	/*
 	 * if entry is not leaf, use g_cube_internal_consistent, else use
 	 * g_cube_leaf_consistent
@@ -206,7 +205,7 @@ g_cube_union(bytea *entryvec, int *sizep)
 	for (i = 1; i < numranges; i++)
 	{
 		out = g_cube_binary_union(tmp, (NDBOX *)
-								  DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i]).key),
+		   DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i]).key),
 								  sizep);
 		if (i > 1)
 			pfree(tmp);
@@ -220,13 +219,13 @@ g_cube_union(bytea *entryvec, int *sizep)
 ** GiST Compress and Decompress methods for boxes
 ** do not do anything.
 */
-GISTENTRY  *
+GISTENTRY *
 g_cube_compress(GISTENTRY *entry)
 {
 	return (entry);
 }
 
-GISTENTRY  *
+GISTENTRY *
 g_cube_decompress(GISTENTRY *entry)
 {
 	return (entry);
@@ -365,7 +364,6 @@ g_cube_picksplit(bytea *entryvec,
 	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
@@ -1001,7 +999,6 @@ cube_contains(NDBOX * box_a, NDBOX * box_b)
 
 	if (a->dim < b->dim)
 	{
-
 		/*
 		 * the further comparisons will make sense if the excess
 		 * dimensions of (b) were zeroes
diff --git a/contrib/dbase/dbf.c b/contrib/dbase/dbf.c
index 9ed0c475d1..053e9adffb 100644
--- a/contrib/dbase/dbf.c
+++ b/contrib/dbase/dbf.c
@@ -21,159 +21,171 @@
 
 /* open a dbf-file, get it's field-info and store this information */
 
-dbhead *dbf_open(u_char *file, int flags) {
-	int				file_no;
-	dbhead			*dbh;
-	f_descr			*fields;
-	dbf_header		*head;
-	dbf_field		*fieldc;
+dbhead *
+dbf_open(u_char *file, int flags)
+{
+	int			file_no;
+	dbhead	   *dbh;
+	f_descr    *fields;
+	dbf_header *head;
+	dbf_field  *fieldc;
 	int			t;
 
-	if ((dbh = (dbhead *)malloc(sizeof(dbhead))) == NULL) {
-		return (dbhead *)DBF_ERROR;
-	}
+	if ((dbh = (dbhead *) malloc(sizeof(dbhead))) == NULL)
+		return (dbhead *) DBF_ERROR;
 
-	if ((head = (dbf_header *)malloc(sizeof(dbf_header))) == NULL) {
+	if ((head = (dbf_header *) malloc(sizeof(dbf_header))) == NULL)
+	{
 		free(dbh);
-		return (dbhead *)DBF_ERROR;
+		return (dbhead *) DBF_ERROR;
 	}
 
-	if ((fieldc = (dbf_field *)malloc(sizeof(dbf_field))) == NULL) {
+	if ((fieldc = (dbf_field *) malloc(sizeof(dbf_field))) == NULL)
+	{
 		free(head);
 		free(dbh);
-		return (dbhead *)DBF_ERROR;
+		return (dbhead *) DBF_ERROR;
 	}
 
-	if ((file_no = open(file, flags)) == -1) {
+	if ((file_no = open(file, flags)) == -1)
+	{
 		free(fieldc);
 		free(head);
 		free(dbh);
-		return (dbhead *)DBF_ERROR;
+		return (dbhead *) DBF_ERROR;
 	}
 
 /* read in the disk-header */
 
-	if (read(file_no, head, sizeof(dbf_header)) == -1) {
+	if (read(file_no, head, sizeof(dbf_header)) == -1)
+	{
 		close(file_no);
 		free(fieldc);
 		free(head);
 		free(dbh);
-		return (dbhead *)DBF_ERROR;
+		return (dbhead *) DBF_ERROR;
 	}
 
-	if (!(head->dbh_dbt & DBH_NORMAL)) {
-        close(file_no);
-        free(fieldc);
-        free(head);
-        free(dbh);
-        return (dbhead *)DBF_ERROR;
+	if (!(head->dbh_dbt & DBH_NORMAL))
+	{
+		close(file_no);
+		free(fieldc);
+		free(head);
+		free(dbh);
+		return (dbhead *) DBF_ERROR;
 	}
 
 	dbh->db_fd = file_no;
-	if (head->dbh_dbt & DBH_MEMO) {
+	if (head->dbh_dbt & DBH_MEMO)
 		dbh->db_memo = 1;
-	} else {
+	else
 		dbh->db_memo = 0;
-	}
 	dbh->db_year = head->dbh_year;
 	dbh->db_month = head->dbh_month;
 	dbh->db_day = head->dbh_day;
-	dbh->db_hlen = get_short((u_char *)&head->dbh_hlen);
-	dbh->db_records = get_long((u_char *)&head->dbh_records);
+	dbh->db_hlen = get_short((u_char *) &head->dbh_hlen);
+	dbh->db_records = get_long((u_char *) &head->dbh_records);
 	dbh->db_currec = 0;
-	dbh->db_rlen = get_short((u_char *)&head->dbh_rlen);
+	dbh->db_rlen = get_short((u_char *) &head->dbh_rlen);
 	dbh->db_nfields = (dbh->db_hlen - sizeof(dbf_header)) / sizeof(dbf_field);
 
-								/* dbh->db_hlen - sizeof(dbf_header) isn't the
-									correct size, cos dbh->hlen is in fact
-									a little more cos of the 0x0D (and
-									possibly another byte, 0x4E, I have
-									seen this somewhere). Because of rounding
-									everything turns out right :) */
-
-	if ((fields = (f_descr *)calloc(dbh->db_nfields, sizeof(f_descr)))
-		== NULL) {
-                close(file_no);
-                free(fieldc);
-                free(head);
-                free(dbh);
-                return (dbhead *)DBF_ERROR;
+	/*
+	 * dbh->db_hlen - sizeof(dbf_header) isn't the correct size, cos
+	 * dbh->hlen is in fact a little more cos of the 0x0D (and possibly
+	 * another byte, 0x4E, I have seen this somewhere). Because of
+	 * rounding everything turns out right :)
+	 */
+
+	if ((fields = (f_descr *) calloc(dbh->db_nfields, sizeof(f_descr)))
+		== NULL)
+	{
+		close(file_no);
+		free(fieldc);
+		free(head);
+		free(dbh);
+		return (dbhead *) DBF_ERROR;
 	}
 
-	for (t = 0; t < dbh->db_nfields; t++) {
+	for (t = 0; t < dbh->db_nfields; t++)
+	{
 /* Maybe I have calculated the number of fields incorrectly. This can happen
    when programs reserve lots of space at the end of the header for future
-   expansion. This will catch this situation */ 
-		if (fields[t].db_name[0] == 0x0D) {
+   expansion. This will catch this situation */
+		if (fields[t].db_name[0] == 0x0D)
+		{
 			dbh->db_nfields = t;
 			break;
 		}
 		read(file_no, fieldc, sizeof(dbf_field));
 		strncpy(fields[t].db_name, fieldc->dbf_name, DBF_NAMELEN);
-		fields[t].db_type = fieldc->dbf_type;	
+		fields[t].db_type = fieldc->dbf_type;
 		fields[t].db_flen = fieldc->dbf_flen;
-		fields[t].db_dec  = fieldc->dbf_dec;
+		fields[t].db_dec = fieldc->dbf_dec;
 	}
 
 	dbh->db_offset = dbh->db_hlen;
 	dbh->db_fields = fields;
 
-	if ((dbh->db_buff = (u_char *)malloc(dbh->db_rlen)) == NULL) {
-            return (dbhead *)DBF_ERROR;
-    }
+	if ((dbh->db_buff = (u_char *) malloc(dbh->db_rlen)) == NULL)
+		return (dbhead *) DBF_ERROR;
 
-    free(fieldc);
-    free(head);
+	free(fieldc);
+	free(head);
 
 	return dbh;
 }
 
-int	dbf_write_head(dbhead *dbh) {
+int
+dbf_write_head(dbhead * dbh)
+{
 	dbf_header	head;
-	time_t now;
-	struct tm *dbf_time;
+	time_t		now;
+	struct tm  *dbf_time;
 
-	if (lseek(dbh->db_fd, 0, SEEK_SET) == -1) {
+	if (lseek(dbh->db_fd, 0, SEEK_SET) == -1)
 		return DBF_ERROR;
-	}
 
 /* fill up the diskheader */
 
 /* Set dataarea of head to '\0' */
-	memset(&head,'\0',sizeof(dbf_header));
+	memset(&head, '\0', sizeof(dbf_header));
 
 	head.dbh_dbt = DBH_NORMAL;
-	if (dbh->db_memo) head.dbh_dbt = DBH_MEMO;
+	if (dbh->db_memo)
+		head.dbh_dbt = DBH_MEMO;
 
-	now = time((time_t *)NULL); 
+	now = time((time_t *) NULL);
 	dbf_time = localtime(&now);
 	head.dbh_year = dbf_time->tm_year;
-	head.dbh_month = dbf_time->tm_mon + 1; /* Months since January + 1 */
+	head.dbh_month = dbf_time->tm_mon + 1;		/* Months since January +
+												 * 1 */
 	head.dbh_day = dbf_time->tm_mday;
 
 	put_long(head.dbh_records, dbh->db_records);
 	put_short(head.dbh_hlen, dbh->db_hlen);
 	put_short(head.dbh_rlen, dbh->db_rlen);
-	
+
 	if (write(dbh->db_fd, &head, sizeof(dbf_header)) != sizeof(dbf_header))
 		return DBF_ERROR;
 
 	return 0;
 }
 
-int dbf_put_fields(dbhead *dbh) {
+int
+dbf_put_fields(dbhead * dbh)
+{
 	dbf_field	field;
 	u_long		t;
 	u_char		end = 0x0D;
 
-	if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1) {
+	if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1)
 		return DBF_ERROR;
-	}
 
 /* Set dataarea of field to '\0' */
-	memset(&field,'\0',sizeof(dbf_field));
+	memset(&field, '\0', sizeof(dbf_field));
 
-	for (t = 0; t < dbh->db_nfields; t++) {
+	for (t = 0; t < dbh->db_nfields; t++)
+	{
 		strncpy(field.dbf_name, dbh->db_fields[t].db_name, DBF_NAMELEN - 1);
 		field.dbf_type = dbh->db_fields[t].db_type;
 		field.dbf_flen = dbh->db_fields[t].db_flen;
@@ -189,16 +201,18 @@ int dbf_put_fields(dbhead *dbh) {
 	return 0;
 }
 
-int dbf_add_field(dbhead *dbh, u_char *name, u_char type,
-								u_char length, u_char dec) {
-f_descr	*ptr;
-u_char	*foo;
-u_long	size, field_no;
+int
+dbf_add_field(dbhead * dbh, u_char *name, u_char type,
+			  u_char length, u_char dec)
+{
+	f_descr    *ptr;
+	u_char	   *foo;
+	u_long		size,
+				field_no;
 
 	size = (dbh->db_nfields + 1) * sizeof(f_descr);
-	if (!(ptr = (f_descr *) realloc(dbh->db_fields, size))) {
+	if (!(ptr = (f_descr *) realloc(dbh->db_fields, size)))
 		return DBF_ERROR;
-	}
 	dbh->db_fields = ptr;
 
 	field_no = dbh->db_nfields;
@@ -211,71 +225,81 @@ u_long	size, field_no;
 	dbh->db_hlen += sizeof(dbf_field);
 	dbh->db_rlen += length;
 
-	if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen))) {
+	if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen)))
 		return DBF_ERROR;
-	}
 
 	dbh->db_buff = foo;
 
 	return 0;
 }
 
-dbhead *dbf_open_new(u_char *name, int flags) {
-dbhead	*dbh;
+dbhead *
+dbf_open_new(u_char *name, int flags)
+{
+	dbhead	   *dbh;
 
-	if (!(dbh = (dbhead *)malloc(sizeof(dbhead)))) {
-		return (dbhead *)DBF_ERROR;
-	}
+	if (!(dbh = (dbhead *) malloc(sizeof(dbhead))))
+		return (dbhead *) DBF_ERROR;
 
-	if (flags & O_CREAT) {
-		if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1) {
+	if (flags & O_CREAT)
+	{
+		if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1)
+		{
 			free(dbh);
-			return (dbhead *)DBF_ERROR;
+			return (dbhead *) DBF_ERROR;
 		}
-	} else {
-		if ((dbh->db_fd = open(name, flags)) == -1) {
+	}
+	else
+	{
+		if ((dbh->db_fd = open(name, flags)) == -1)
+		{
 			free(dbh);
-			return (dbhead *)DBF_ERROR;
+			return (dbhead *) DBF_ERROR;
 		}
 	}
-		
+
 
 	dbh->db_offset = 0;
 	dbh->db_memo = 0;
 	dbh->db_year = 0;
 	dbh->db_month = 0;
-	dbh->db_day	= 0;
+	dbh->db_day = 0;
 	dbh->db_hlen = sizeof(dbf_header) + 1;
 	dbh->db_records = 0;
 	dbh->db_currec = 0;
 	dbh->db_rlen = 1;
 	dbh->db_nfields = 0;
 	dbh->db_buff = NULL;
-	dbh->db_fields = (f_descr *)NULL;
+	dbh->db_fields = (f_descr *) NULL;
 
 	return dbh;
 }
-	
-void dbf_close(dbhead *dbh) {
-	int t;
+
+void
+dbf_close(dbhead * dbh)
+{
+	int			t;
 
 	close(dbh->db_fd);
 
-	for (t = 0; t < dbh->db_nfields; t++) {
+	for (t = 0; t < dbh->db_nfields; t++)
 		free(&dbh->db_fields[t]);
-	}
 
-	if (dbh->db_buff != NULL) {
+	if (dbh->db_buff != NULL)
 		free(dbh->db_buff);
-	}
 
 	free(dbh);
 }
-	
-int dbf_get_record(dbhead *dbh, field *fields,  u_long rec) {
-	u_char  *data;
-	int     t, i, offset;
-	u_char  *dbffield, *end;
+
+int
+dbf_get_record(dbhead * dbh, field * fields, u_long rec)
+{
+	u_char	   *data;
+	int			t,
+				i,
+				offset;
+	u_char	   *dbffield,
+			   *end;
 
 /* calculate at which offset we have to read. *DON'T* forget the
    0x0D which seperates field-descriptions from records!
@@ -284,112 +308,133 @@ int dbf_get_record(dbhead *dbh, field *fields,  u_long rec) {
 */
 	offset = dbh->db_hlen + (rec * dbh->db_rlen);
 
-	if (lseek(dbh->db_fd, offset, SEEK_SET) == -1) {
+	if (lseek(dbh->db_fd, offset, SEEK_SET) == -1)
+	{
 		lseek(dbh->db_fd, 0, SEEK_SET);
 		dbh->db_offset = 0;
 		return DBF_ERROR;
 	}
 
-	dbh->db_offset 	= offset;
-	dbh->db_currec	= rec;
+	dbh->db_offset = offset;
+	dbh->db_currec = rec;
 	data = dbh->db_buff;
 
-    read(dbh->db_fd, data, dbh->db_rlen);
-
-    if (data[0] == DBF_DELETED) {
-            return DBF_DELETED;
-    }
-
-    dbffield = &data[1];
-    for (t = 0; t < dbh->db_nfields; t++) {
-            strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
-            fields[t].db_type = dbh->db_fields[t].db_type;
-            fields[t].db_flen = dbh->db_fields[t].db_flen;
-            fields[t].db_dec  = dbh->db_fields[t].db_dec;
-
-            if (fields[t].db_type == 'C') {
-				end = &dbffield[fields[t].db_flen - 1 ];
-				i = fields[t].db_flen;
-                while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) {
-       	          	end--;
-					i--;
-                }
-				strncpy(fields[t].db_contents, dbffield, i);
-                fields[t].db_contents[i] = '\0';
-            } else {
-				end = dbffield;
-				i = fields[t].db_flen;
-                while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) {
-					end++;
-					i--;
-				}
-				strncpy(fields[t].db_contents, end, i);
-				fields[t].db_contents[i] = '\0';
-            }
+	read(dbh->db_fd, data, dbh->db_rlen);
+
+	if (data[0] == DBF_DELETED)
+		return DBF_DELETED;
+
+	dbffield = &data[1];
+	for (t = 0; t < dbh->db_nfields; t++)
+	{
+		strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
+		fields[t].db_type = dbh->db_fields[t].db_type;
+		fields[t].db_flen = dbh->db_fields[t].db_flen;
+		fields[t].db_dec = dbh->db_fields[t].db_dec;
+
+		if (fields[t].db_type == 'C')
+		{
+			end = &dbffield[fields[t].db_flen - 1];
+			i = fields[t].db_flen;
+			while ((i > 0) && ((*end < 0x21) || (*end > 0x7E)))
+			{
+				end--;
+				i--;
+			}
+			strncpy(fields[t].db_contents, dbffield, i);
+			fields[t].db_contents[i] = '\0';
+		}
+		else
+		{
+			end = dbffield;
+			i = fields[t].db_flen;
+			while ((i > 0) && ((*end < 0x21) || (*end > 0x7E)))
+			{
+				end++;
+				i--;
+			}
+			strncpy(fields[t].db_contents, end, i);
+			fields[t].db_contents[i] = '\0';
+		}
 
-            dbffield += fields[t].db_flen;
+		dbffield += fields[t].db_flen;
 	}
 
-    dbh->db_offset += dbh->db_rlen;
+	dbh->db_offset += dbh->db_rlen;
 
 	return DBF_VALID;
 }
 
-field *dbf_build_record(dbhead *dbh) {
-	int t;
-	field	*fields;
+field *
+dbf_build_record(dbhead * dbh)
+{
+	int			t;
+	field	   *fields;
 
-	if (!(fields = (field *)calloc(dbh->db_nfields, sizeof(field)))) {
-		return (field *)DBF_ERROR;
-	}
-	
-	for ( t = 0; t < dbh->db_nfields; t++) {
+	if (!(fields = (field *) calloc(dbh->db_nfields, sizeof(field))))
+		return (field *) DBF_ERROR;
+
+	for (t = 0; t < dbh->db_nfields; t++)
+	{
 		if (!(fields[t].db_contents =
-			(u_char *)malloc(dbh->db_fields[t].db_flen + 1))) {
-			for (t = 0; t < dbh->db_nfields; t++) {
-				if (fields[t].db_contents != 0) {
+			  (u_char *) malloc(dbh->db_fields[t].db_flen + 1)))
+		{
+			for (t = 0; t < dbh->db_nfields; t++)
+			{
+				if (fields[t].db_contents != 0)
+				{
 					free(fields[t].db_contents);
 					free(fields);
 				}
-				return (field *)DBF_ERROR;
+				return (field *) DBF_ERROR;
 			}
 		}
 		strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
 		fields[t].db_type = dbh->db_fields[t].db_type;
 		fields[t].db_flen = dbh->db_fields[t].db_flen;
-		fields[t].db_dec  = dbh->db_fields[t].db_dec;
+		fields[t].db_dec = dbh->db_fields[t].db_dec;
 	}
 
 	return fields;
 }
 
-void dbf_free_record(dbhead *dbh, field *rec) {
-	int t;
+void
+dbf_free_record(dbhead * dbh, field * rec)
+{
+	int			t;
 
-	for ( t = 0; t < dbh->db_nfields; t++) {
+	for (t = 0; t < dbh->db_nfields; t++)
 		free(rec[t].db_contents);
-	}
 
 	free(rec);
 }
 
-int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
-	u_long	offset, new, idx, t, h, length;
-	u_char	*data, end = 0x1a;
-	double	fl;
-	u_char	foo[128], format[32];
-
-/*	offset:	offset in file for this record
+int
+dbf_put_record(dbhead * dbh, field * rec, u_long where)
+{
+	u_long		offset,
+				new,
+				idx,
+				t,
+				h,
+				length;
+	u_char	   *data,
+				end = 0x1a;
+	double		fl;
+	u_char		foo[128],
+				format[32];
+
+/*	offset: offset in file for this record
 	new:	real offset after lseek
 	idx:	index to which place we are inside the 'hardcore'-data for this
 			record
 	t:		field-counter
 	data:	the hardcore-data that is put on disk
 	h:		index into the field-part in the hardcore-data
-	length:	length of the data to copy
+	length: length of the data to copy
 	fl:		a float used to get the right precision with real numbers
 	foo:	copy of db_contents when field is not 'C'
-	format:	sprintf format-string to get the right precision with real numbers
+	format: sprintf format-string to get the right precision with real numbers
 
 	NOTE: this declaration of 'foo' can cause overflow when the contents-field
 	is longer the 127 chars (which is highly unlikely, cos it is not used
@@ -399,16 +444,17 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
 	DO A SEEK_END WITH 0!!!!!! USE -1 !!!!!!!!!!
 */
 
-	if (where > dbh->db_records) {
-		if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1) {
+	if (where > dbh->db_records)
+	{
+		if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1)
 			return DBF_ERROR;
-		}
 		dbh->db_records++;
-	} else {
+	}
+	else
+	{
 		offset = dbh->db_hlen + (where * dbh->db_rlen);
-		if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1) {
+		if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1)
 			return DBF_ERROR;
-		}
 	}
 
 	dbh->db_offset = new;
@@ -416,49 +462,54 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) {
 	data = dbh->db_buff;
 
 /* Set dataarea of data to ' ' (space) */
-	memset(data,' ',dbh->db_rlen);
+	memset(data, ' ', dbh->db_rlen);
 
 /*	data[0] = DBF_VALID; */
 
 	idx = 1;
-	for (t = 0; t < dbh->db_nfields; t++) {
+	for (t = 0; t < dbh->db_nfields; t++)
+	{
 /* if field is empty, don't do a thing */
-	  if (rec[t].db_contents[0] != '\0') {
+		if (rec[t].db_contents[0] != '\0')
+		{
 /*	Handle text */
-		if (rec[t].db_type == 'C') {
-			if (strlen(rec[t].db_contents) > rec[t].db_flen) {
-				length = rec[t].db_flen;
-			} else {
-				length = strlen(rec[t].db_contents);
+			if (rec[t].db_type == 'C')
+			{
+				if (strlen(rec[t].db_contents) > rec[t].db_flen)
+					length = rec[t].db_flen;
+				else
+					length = strlen(rec[t].db_contents);
+				strncpy(data + idx, rec[t].db_contents, length);
 			}
-			strncpy(data+idx, rec[t].db_contents, length);
-		} else {
+			else
+			{
 /* Handle the rest */
 /* Numeric is special, because of real numbers */
-			if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0)) {
-				fl = atof(rec[t].db_contents);
-				sprintf(format, "%%.%df", rec[t].db_dec); 
-				sprintf(foo, format, fl);
-			} else {
-				strcpy(foo, rec[t].db_contents);
-			}
-			if (strlen(foo) > rec[t].db_flen) {
-				length = rec[t].db_flen;
-			} else {
-				length = strlen(foo);
+				if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0))
+				{
+					fl = atof(rec[t].db_contents);
+					sprintf(format, "%%.%df", rec[t].db_dec);
+					sprintf(foo, format, fl);
+				}
+				else
+					strcpy(foo, rec[t].db_contents);
+				if (strlen(foo) > rec[t].db_flen)
+					length = rec[t].db_flen;
+				else
+					length = strlen(foo);
+				h = rec[t].db_flen - length;
+				strncpy(data + idx + h, foo, length);
 			}
-			h = rec[t].db_flen - length;
-			strncpy(data+idx+h, foo, length);
 		}
-	  }
-	  idx += rec[t].db_flen;
+		idx += rec[t].db_flen;
 	}
 
 	if (write(dbh->db_fd, data, dbh->db_rlen) != dbh->db_rlen)
 		return DBF_ERROR;
 
 /* There's a 0x1A at the end of a dbf-file */
-	if (where == dbh->db_records) {
+	if (where == dbh->db_records)
+	{
 		if (write(dbh->db_fd, &end, 1) != 1)
 			return DBF_ERROR;
 	}
diff --git a/contrib/dbase/dbf.h b/contrib/dbase/dbf.h
index a6e92517ea..b54093bace 100644
--- a/contrib/dbase/dbf.h
+++ b/contrib/dbase/dbf.h
@@ -26,7 +26,7 @@
 
 /* maximum fieldname-length */
 
-#define DBF_NAMELEN	11
+#define DBF_NAMELEN 11
 
 /* magic-cookies for the file */
 
@@ -37,89 +37,93 @@
 
 #define DBF_ERROR	-1
 #define DBF_VALID	0x20
-#define DBF_DELETED	0x2A
+#define DBF_DELETED 0x2A
 
 /* diskheader */
 
-typedef struct {
-	u_char	dbh_dbt;		/* indentification field */
-	u_char	dbh_year;		/* last modification-date */
-	u_char	dbh_month;
-	u_char	dbh_day;
-	u_char	dbh_records[4];	/* number of records */
-	u_char	dbh_hlen[2];	/* length of this header */
-	u_char	dbh_rlen[2];	/* length of a record */
-	u_char	dbh_stub[20];	/* misc stuff we don't need */
-} dbf_header;
+typedef struct
+{
+	u_char		dbh_dbt;		/* indentification field */
+	u_char		dbh_year;		/* last modification-date */
+	u_char		dbh_month;
+	u_char		dbh_day;
+	u_char		dbh_records[4]; /* number of records */
+	u_char		dbh_hlen[2];	/* length of this header */
+	u_char		dbh_rlen[2];	/* length of a record */
+	u_char		dbh_stub[20];	/* misc stuff we don't need */
+}			dbf_header;
 
 /* disk field-description */
 
-typedef struct {
-	u_char	dbf_name[DBF_NAMELEN];	/* field-name terminated with \0 */
-	u_char	dbf_type;				/* field-type */
-	u_char	dbf_reserved[4];		/* some reserved stuff */
-	u_char	dbf_flen;				/* field-length */
-	u_char	dbf_dec;				/* number of decimal positions if
-					  			       type is 'N' */
-	u_char	dbf_stub[14];			/* stuff we don't need */
-} dbf_field;
+typedef struct
+{
+	u_char		dbf_name[DBF_NAMELEN];	/* field-name terminated with \0 */
+	u_char		dbf_type;		/* field-type */
+	u_char		dbf_reserved[4];		/* some reserved stuff */
+	u_char		dbf_flen;		/* field-length */
+	u_char		dbf_dec;		/* number of decimal positions if type is
+								 * 'N' */
+	u_char		dbf_stub[14];	/* stuff we don't need */
+}			dbf_field;
 
 /* memory field-description */
 
-typedef struct {
-	u_char	db_name[DBF_NAMELEN];	/* field-name terminated with \0 */
-	u_char	db_type;		/* field-type */
-	u_char	db_flen;		/* field-length */
-	u_char	db_dec;			/* number of decimal positions */
-} f_descr;
+typedef struct
+{
+	u_char		db_name[DBF_NAMELEN];	/* field-name terminated with \0 */
+	u_char		db_type;		/* field-type */
+	u_char		db_flen;		/* field-length */
+	u_char		db_dec;			/* number of decimal positions */
+}			f_descr;
 
 /* memory dfb-header */
 
-typedef struct {
-	int	db_fd;				/* file-descriptor */
-	u_long	db_offset;		/* current offset in file */
-	u_char	db_memo;		/* memo-file present */
-	u_char	db_year;		/* last update as YYMMDD */
-	u_char	db_month;
-	u_char	db_day;
-	u_long	db_hlen;		/* length of the diskheader, for
-							   calculating the offsets */
-	u_long	db_records;		/* number of records */
-	u_long	db_currec;		/* current record-number starting
-					   		   at 0 */
-	u_short	db_rlen;		/* length of the record */
-	u_char	db_nfields;		/* number of fields */
-	u_char	*db_buff;		/* record-buffer to save malloc()'s */
-	f_descr	*db_fields;		/* pointer to an array of field-
-					   	       descriptions */
-} dbhead;
+typedef struct
+{
+	int			db_fd;			/* file-descriptor */
+	u_long		db_offset;		/* current offset in file */
+	u_char		db_memo;		/* memo-file present */
+	u_char		db_year;		/* last update as YYMMDD */
+	u_char		db_month;
+	u_char		db_day;
+	u_long		db_hlen;		/* length of the diskheader, for
+								 * calculating the offsets */
+	u_long		db_records;		/* number of records */
+	u_long		db_currec;		/* current record-number starting at 0 */
+	u_short		db_rlen;		/* length of the record */
+	u_char		db_nfields;		/* number of fields */
+	u_char	   *db_buff;		/* record-buffer to save malloc()'s */
+	f_descr    *db_fields;		/* pointer to an array of field-
+								 * descriptions */
+}			dbhead;
 
 /* structure that contains everything a user wants from a field, including
    the contents (in ASCII). Warning! db_flen may be bigger than the actual
    length of db_name! This is because a field doesn't have to be completely
    filled */
- 
-typedef struct {
-	u_char	db_name[DBF_NAMELEN];	/* field-name terminated with \0 */
-	u_char	db_type;		/* field-type */
-	u_char	db_flen;		/* field-length */
-	u_char	db_dec;			/* number of decimal positions */
-	u_char*	db_contents;	/* contents of the field in ASCII */
-} field;
+
+typedef struct
+{
+	u_char		db_name[DBF_NAMELEN];	/* field-name terminated with \0 */
+	u_char		db_type;		/* field-type */
+	u_char		db_flen;		/* field-length */
+	u_char		db_dec;			/* number of decimal positions */
+	u_char	   *db_contents;	/* contents of the field in ASCII */
+}			field;
 
 /* prototypes for functions */
 
-extern dbhead*	dbf_open(u_char *file ,int flags);
-extern int	dbf_write_head(dbhead *dbh);
-extern int	dbf_put_fields(dbhead *dbh);
-extern int	dbf_add_field(dbhead *dbh, u_char *name, u_char type,
-										u_char length, u_char dec);
-extern dbhead * dbf_open_new(u_char *name, int flags);
-extern void	dbf_close(dbhead *dbh);
-extern int	dbf_get_record(dbhead *dbh, field *fields, u_long rec);
-extern field*	dbf_build_record(dbhead *dbh);
-extern void	dbf_free_record(dbhead *dbh, field* fields);
-extern int dbf_put_record(dbhead *dbh, field *rec, u_long where);
+extern dbhead *dbf_open(u_char *file, int flags);
+extern int	dbf_write_head(dbhead * dbh);
+extern int	dbf_put_fields(dbhead * dbh);
+extern int dbf_add_field(dbhead * dbh, u_char *name, u_char type,
+			  u_char length, u_char dec);
+extern dbhead *dbf_open_new(u_char *name, int flags);
+extern void dbf_close(dbhead * dbh);
+extern int	dbf_get_record(dbhead * dbh, field * fields, u_long rec);
+extern field *dbf_build_record(dbhead * dbh);
+extern void dbf_free_record(dbhead * dbh, field * fields);
+extern int	dbf_put_record(dbhead * dbh, field * rec, u_long where);
 
 /*********************************************************************
 
@@ -131,5 +135,4 @@ extern long get_long(u_char *cp);
 extern void put_long(u_char *cp, long lval);
 extern short get_short(u_char *cp);
 extern void put_short(u_char *cp, short lval);
-
-#endif	/* _DBF_H */
+#endif	 /* _DBF_H */
diff --git a/contrib/dbase/dbf2pg.c b/contrib/dbase/dbf2pg.c
index 839bb7211f..e2393de542 100644
--- a/contrib/dbase/dbf2pg.c
+++ b/contrib/dbase/dbf2pg.c
@@ -22,146 +22,178 @@
 #include "libpq-fe.h"
 #include "dbf.h"
 
-int	verbose = 0, upper = 0, lower = 0, create = 0, fieldlow = 0;
-int del = 0;
-unsigned int begin = 0, end = 0;
+int			verbose = 0,
+			upper = 0,
+			lower = 0,
+			create = 0,
+			fieldlow = 0;
+int			del = 0;
+unsigned int begin = 0,
+			end = 0;
 unsigned int t_block = 0;
 
 #ifdef HAVE_ICONV_H
-char *charset_from=NULL;
-char *charset_to="ISO-8859-1";
-iconv_t iconv_d;
-char convert_charset_buff[8192];
+char	   *charset_from = NULL;
+char	   *charset_to = "ISO-8859-1";
+iconv_t		iconv_d;
+char		convert_charset_buff[8192];
 #endif
 
-char	*host = NULL;
-char 	*dbase = "test";
-char 	*table = "test";
-char	*username = NULL;
-char	*password = NULL;
-char	*subarg = NULL;
-char	escape_buff[8192];
+char	   *host = NULL;
+char	   *dbase = "test";
+char	   *table = "test";
+char	   *username = NULL;
+char	   *password = NULL;
+char	   *subarg = NULL;
+char		escape_buff[8192];
 
-void do_substitute(char *subarg, dbhead *dbh);
+void		do_substitute(char *subarg, dbhead * dbh);
 inline void strtoupper(char *string);
 
 inline void strtolower(char *string);
-void do_create(PGconn *, char*, dbhead*);
-void do_inserts(PGconn *, char*, dbhead*);
-int check_table(PGconn *, char*);
+void		do_create(PGconn *, char *, dbhead *);
+void		do_inserts(PGconn *, char *, dbhead *);
+int			check_table(PGconn *, char *);
+
+char	   *Escape(char *);
 
-char *Escape(char*);
 #ifdef HAVE_ICONV_H
-char *convert_charset(char *string);
+char	   *convert_charset(char *string);
 #endif
-void usage(void);
+void		usage(void);
 unsigned int isinteger(char *);
 
-char *simple_prompt(const char *prompt, int maxlen, bool echo);
+char	   *simple_prompt(const char *prompt, int maxlen, bool echo);
 
 
-unsigned int isinteger(char *buff) {
-	char *i=buff;
+unsigned int
+isinteger(char *buff)
+{
+	char	   *i = buff;
 
-	while (*i != '\0') {
-		if (i==buff)
+	while (*i != '\0')
+	{
+		if (i == buff)
 			if ((*i == '-') ||
-				(*i == '+')) {
-				i++; continue;
+				(*i == '+'))
+			{
+				i++;
+				continue;
 			}
-		if (!isdigit((int)*i)) return 0;
+		if (!isdigit((int) *i))
+			return 0;
 		i++;
 	}
 	return 1;
 }
 
-inline void strtoupper(char *string) {
-	while(*string != '\0') {
+inline void
+strtoupper(char *string)
+{
+	while (*string != '\0')
+	{
 		*string = toupper(*string);
 		string++;
 	}
 }
 
-inline void strtolower(char *string) {
-	while(*string != '\0') {
+inline void
+strtolower(char *string)
+{
+	while (*string != '\0')
+	{
 		*string = tolower(*string);
 		string++;
 	}
 }
 
 /* FIXME: should this check for overflow? */
-char *Escape(char *string) {
-    char    *foo, *bar;
-
-    foo = escape_buff;
-
-    bar = string;
-    while (*bar != '\0') {
-        if ((*bar == '\t') ||
-        	(*bar == '\n') ||
-        	(*bar == '\\')) {
-            *foo++ = '\\';
-        }
-        *foo++ = *bar++;
-    }
-    *foo = '\0';
-
-    return escape_buff;
-}
+char *
+Escape(char *string)
+{
+	char	   *foo,
+			   *bar;
 
-#ifdef HAVE_ICONV_H
-char *convert_charset(char *string) {
-	size_t in_size, out_size, nconv;
-	char *in_ptr,*out_ptr;
+	foo = escape_buff;
 
-	in_size=strlen(string)+1;
-	out_size=sizeof(convert_charset_buff);
-	in_ptr=string;
-	out_ptr=convert_charset_buff;
+	bar = string;
+	while (*bar != '\0')
+	{
+		if ((*bar == '\t') ||
+			(*bar == '\n') ||
+			(*bar == '\\'))
+			*foo++ = '\\';
+		*foo++ = *bar++;
+	}
+	*foo = '\0';
+
+	return escape_buff;
+}
 
-	iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset state information */
-	while(in_size>0)
+#ifdef HAVE_ICONV_H
+char *
+convert_charset(char *string)
+{
+	size_t		in_size,
+				out_size,
+				nconv;
+	char	   *in_ptr,
+			   *out_ptr;
+
+	in_size = strlen(string) + 1;
+	out_size = sizeof(convert_charset_buff);
+	in_ptr = string;
+	out_ptr = convert_charset_buff;
+
+	iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size);		/* necessary to reset
+																 * state information */
+	while (in_size > 0)
 	{
 		nconv = iconv(iconv_d, &in_ptr, &in_size, &out_ptr, &out_size);
-		if(nconv == (size_t) -1)
+		if (nconv == (size_t) -1)
 		{
 			printf("WARNING: cannot convert charset of string \"%s\".\n",
-				string);
-			strcpy(convert_charset_buff,string);
+				   string);
+			strcpy(convert_charset_buff, string);
 			return convert_charset_buff;
 		}
 	}
-	*out_ptr = 0; /* terminate output string */
+	*out_ptr = 0;				/* terminate output string */
 	return convert_charset_buff;
 }
 #endif
 
-int check_table(PGconn *conn, char *table) {
-	char		*q = "select relname from pg_class where "
-					"relkind='r' and relname !~* '^pg'";
-	PGresult	*res;
-	int 		i = 0;
+int
+check_table(PGconn *conn, char *table)
+{
+	char	   *q = "select relname from pg_class where "
+	"relkind='r' and relname !~* '^pg'";
+	PGresult   *res;
+	int			i = 0;
 
-	if (!(res = PQexec(conn, q))) {
+	if (!(res = PQexec(conn, q)))
+	{
 		printf("%s\n", PQerrorMessage(conn));
 		return 0;
 	}
 
-	for (i = 0; i < PQntuples(res); i++) {
-		if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname")))) {
+	for (i = 0; i < PQntuples(res); i++)
+	{
+		if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname"))))
 			return 1;
-		}
 	}
 
 	return 0;
 }
 
-void usage(void){
+void
+usage(void)
+{
 	printf("dbf2pg\n"
-"usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n"
-"              [-B transaction_size] [-F charset_from [-T charset_to]]\n"
-"              [-s oldname=newname[,oldname=newname[...]]] [-d dbase]\n"
-"              [-t table] [-c | -D] [-f] [-v[v]] dbf-file\n");
+		   "usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n"
+		   "              [-B transaction_size] [-F charset_from [-T charset_to]]\n"
+		   "              [-s oldname=newname[,oldname=newname[...]]] [-d dbase]\n"
+		   "              [-t table] [-c | -D] [-f] [-v[v]] dbf-file\n");
 }
 
 /* patch submitted by Jeffrey Y. Sue <jysue@aloha.net> */
@@ -169,66 +201,80 @@ void usage(void){
 /* Mainly for avoiding conflicts between fieldnames and SQL-reserved */
 /* keywords */
 
-void do_substitute(char *subarg, dbhead *dbh)
+void
+do_substitute(char *subarg, dbhead * dbh)
 {
-      /* NOTE: subarg is modified in this function */
-      int i,bad;
-      char *p,*oldname,*newname;
-      if (!subarg) {
-              return;
-      }
-      if (verbose>1) {
-              printf("Substituting new field names\n");
-      }
-      /* use strstr instead of strtok because of possible empty tokens */
-      oldname = subarg;
-      while (oldname && strlen(oldname) && (p=strstr(oldname,"=")) ) {
-              *p = '\0';      /* mark end of oldname */
-              newname = ++p;  /* point past \0 of oldname */
-              if (strlen(newname)) {  /* if not an empty string */
-                      p = strstr(newname,",");
-                      if (p) {
-                              *p = '\0';      /* mark end of newname */
-                              p++;    /* point past where the comma was */
-                      }
-              }
-              if (strlen(newname)>=DBF_NAMELEN) {
-                      printf("Truncating new field name %s to %d chars\n",
-                              newname,DBF_NAMELEN-1);
-                      newname[DBF_NAMELEN-1] = '\0';
-              }
-              bad = 1;
-              for (i=0;i<dbh->db_nfields;i++) {
-                      if (strcmp(dbh->db_fields[i].db_name,oldname)==0) {
-                              bad = 0;
-                              strcpy(dbh->db_fields[i].db_name,newname);
-                              if (verbose>1) {
-                                      printf("Substitute old:%s new:%s\n",
-                                              oldname,newname);
-                              }
-                              break;
-                      }
-              }
-              if (bad) {
-                      printf("Warning: old field name %s not found\n",
-                              oldname);
-              }
-              oldname = p;
-      }
-} /* do_substitute */
-
-void do_create(PGconn *conn, char *table, dbhead *dbh) {
-	char		*query;
-	char 		t[20];
-	int			i, length;
-	PGresult	*res;
-
-	if (verbose > 1) {
-		printf("Building CREATE-clause\n");
+	/* NOTE: subarg is modified in this function */
+	int			i,
+				bad;
+	char	   *p,
+			   *oldname,
+			   *newname;
+
+	if (!subarg)
+		return;
+	if (verbose > 1)
+		printf("Substituting new field names\n");
+	/* use strstr instead of strtok because of possible empty tokens */
+	oldname = subarg;
+	while (oldname && strlen(oldname) && (p = strstr(oldname, "=")))
+	{
+		*p = '\0';				/* mark end of oldname */
+		newname = ++p;			/* point past \0 of oldname */
+		if (strlen(newname))
+		{						/* if not an empty string */
+			p = strstr(newname, ",");
+			if (p)
+			{
+				*p = '\0';		/* mark end of newname */
+				p++;			/* point past where the comma was */
+			}
+		}
+		if (strlen(newname) >= DBF_NAMELEN)
+		{
+			printf("Truncating new field name %s to %d chars\n",
+				   newname, DBF_NAMELEN - 1);
+			newname[DBF_NAMELEN - 1] = '\0';
+		}
+		bad = 1;
+		for (i = 0; i < dbh->db_nfields; i++)
+		{
+			if (strcmp(dbh->db_fields[i].db_name, oldname) == 0)
+			{
+				bad = 0;
+				strcpy(dbh->db_fields[i].db_name, newname);
+				if (verbose > 1)
+				{
+					printf("Substitute old:%s new:%s\n",
+						   oldname, newname);
+				}
+				break;
+			}
+		}
+		if (bad)
+		{
+			printf("Warning: old field name %s not found\n",
+				   oldname);
+		}
+		oldname = p;
 	}
+}	/* do_substitute */
 
-	if (!(query = (char *)malloc(
-			(dbh->db_nfields * 40) + 29 + strlen(table)))) {
+void
+do_create(PGconn *conn, char *table, dbhead * dbh)
+{
+	char	   *query;
+	char		t[20];
+	int			i,
+				length;
+	PGresult   *res;
+
+	if (verbose > 1)
+		printf("Building CREATE-clause\n");
+
+	if (!(query = (char *) malloc(
+						   (dbh->db_nfields * 40) + 29 + strlen(table))))
+	{
 		fprintf(stderr, "Memory allocation error in function do_create\n");
 		PQfinish(conn);
 		close(dbh->db_fd);
@@ -238,61 +284,65 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) {
 
 	sprintf(query, "CREATE TABLE %s (", table);
 	length = strlen(query);
-	for ( i = 0; i < dbh->db_nfields; i++) {
-              if (!strlen(dbh->db_fields[i].db_name)) {
-                      continue;
-                      /* skip field if length of name == 0 */
-              }
-		if ((strlen(query) != length)) {
-                        strcat(query, ",");
-                }
-
-				if (fieldlow)
-					strtolower(dbh->db_fields[i].db_name);
-
-                strcat(query, dbh->db_fields[i].db_name);
-                switch(dbh->db_fields[i].db_type) {
-						case 'D':
-								strcat(query, " date");
-								break;
-                        case 'C':
-								if (dbh->db_fields[i].db_flen > 1) {
-									strcat(query, " varchar");
-									sprintf(t, "(%d)",
-											dbh->db_fields[i].db_flen);
-									strcat(query, t);
-								} else {
-	                                strcat(query, " char");
-								}
-                                break;
-                        case 'N':
-                                if (dbh->db_fields[i].db_dec != 0) {
-                                        strcat(query, " real");
-                                } else {
-                                        strcat(query, " int");
-                                }
-                                break;
-                        case 'L':
-                                strcat(query, " char");
-                                break;
-                }
+	for (i = 0; i < dbh->db_nfields; i++)
+	{
+		if (!strlen(dbh->db_fields[i].db_name))
+		{
+			continue;
+			/* skip field if length of name == 0 */
+		}
+		if ((strlen(query) != length))
+			strcat(query, ",");
+
+		if (fieldlow)
+			strtolower(dbh->db_fields[i].db_name);
+
+		strcat(query, dbh->db_fields[i].db_name);
+		switch (dbh->db_fields[i].db_type)
+		{
+			case 'D':
+				strcat(query, " date");
+				break;
+			case 'C':
+				if (dbh->db_fields[i].db_flen > 1)
+				{
+					strcat(query, " varchar");
+					sprintf(t, "(%d)",
+							dbh->db_fields[i].db_flen);
+					strcat(query, t);
+				}
+				else
+					strcat(query, " char");
+				break;
+			case 'N':
+				if (dbh->db_fields[i].db_dec != 0)
+					strcat(query, " real");
+				else
+					strcat(query, " int");
+				break;
+			case 'L':
+				strcat(query, " char");
+				break;
+		}
 	}
 
 	strcat(query, ")");
 
-	if (verbose > 1) {
+	if (verbose > 1)
+	{
 		printf("Sending create-clause\n");
 		printf("%s\n", query);
 	}
 
-	if ((res = PQexec(conn, query)) == NULL) {
+	if ((res = PQexec(conn, query)) == NULL)
+	{
 		fprintf(stderr, "Error creating table!\n");
 		fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
-                close(dbh->db_fd);
-                free(dbh);
-				free(query);
-                PQfinish(conn);
-                exit(1);
+		close(dbh->db_fd);
+		free(dbh);
+		free(query);
+		PQfinish(conn);
+		exit(1);
 	}
 
 	PQclear(res);
@@ -300,148 +350,179 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) {
 }
 
 /* FIXME: can be optimized to not use strcat, but it is worth the effort? */
-void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
-	PGresult	*res;
-	field		*fields;
-	int			i, h, result;
-	char		*query, *foo;
+void
+do_inserts(PGconn *conn, char *table, dbhead * dbh)
+{
+	PGresult   *res;
+	field	   *fields;
+	int			i,
+				h,
+				result;
+	char	   *query,
+			   *foo;
 	char		pgdate[10];
 
-	if (verbose > 1) {
+	if (verbose > 1)
 		printf("Inserting records\n");
-	}
 
-	h = 2; /* 2 because of terminating \n\0 */
+	h = 2;						/* 2 because of terminating \n\0 */
 
-	for ( i = 0 ; i < dbh->db_nfields ; i++ ) {
+	for (i = 0; i < dbh->db_nfields; i++)
+	{
 		h += dbh->db_fields[i].db_flen > 2 ?
-					dbh->db_fields[i].db_flen :
-					2; /* account for possible NULL values (\N) */
-		h += 1; /* the delimiter */
+			dbh->db_fields[i].db_flen :
+			2;					/* account for possible NULL values (\N) */
+		h += 1;					/* the delimiter */
 	}
 
-	/* make sure we can build the COPY query, note that we don't need to just
- 	add this value, since the COPY query is a separate query (see below) */
-	if (h < 17+strlen(table)) h = 17+strlen(table);
+	/*
+	 * make sure we can build the COPY query, note that we don't need to
+	 * just add this value, since the COPY query is a separate query (see
+	 * below)
+	 */
+	if (h < 17 + strlen(table))
+		h = 17 + strlen(table);
 
-	if (!(query = (char *)malloc(h))) {
+	if (!(query = (char *) malloc(h)))
+	{
 		PQfinish(conn);
 		fprintf(stderr,
-			"Memory allocation error in function do_inserts (query)\n");
+			 "Memory allocation error in function do_inserts (query)\n");
 		close(dbh->db_fd);
 		free(dbh);
 		exit(1);
 	}
 
-	if ((fields = dbf_build_record(dbh)) == (field *)DBF_ERROR) {
-        fprintf(stderr,
-            "Couldn't allocate memory for record in do_insert\n");
+	if ((fields = dbf_build_record(dbh)) == (field *) DBF_ERROR)
+	{
+		fprintf(stderr,
+				"Couldn't allocate memory for record in do_insert\n");
 		PQfinish(conn);
-        free(query);
-        dbf_close(dbh);
-        exit(1);
-    }
-		
-	if (end == 0)              /* "end" is a user option, if not specified, */
-		end = dbh->db_records; /* then all records are processed. */
-
-	if (t_block == 0) /* user not specified transaction block size */
-		t_block = end-begin; /* then we set it to be the full data */
-		
-	for (i = begin; i < end; i++) {
+		free(query);
+		dbf_close(dbh);
+		exit(1);
+	}
+
+	if (end == 0)				/* "end" is a user option, if not
+								 * specified, */
+		end = dbh->db_records;	/* then all records are processed. */
+
+	if (t_block == 0)			/* user not specified transaction block
+								 * size */
+		t_block = end - begin;	/* then we set it to be the full data */
+
+	for (i = begin; i < end; i++)
+	{
 		/* we need to start a new transaction and COPY statement */
-		if (((i-begin) % t_block) == 0) {
+		if (((i - begin) % t_block) == 0)
+		{
 			if (verbose > 1)
 				fprintf(stderr, "Transaction: START\n");
 			res = PQexec(conn, "BEGIN");
-			if (res == NULL) {
+			if (res == NULL)
+			{
 				fprintf(stderr, "Error starting transaction!\n");
 				fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
-                exit(1);
+				exit(1);
 			}
 			sprintf(query, "COPY %s FROM stdin", table);
 			res = PQexec(conn, query);
-			if (res == NULL) {
+			if (res == NULL)
+			{
 				fprintf(stderr, "Error starting COPY!\n");
 				fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
-                exit(1);
+				exit(1);
 			}
 		}
 
 		/* build line and submit */
-		result = dbf_get_record(dbh, fields,  i);
-		if (result == DBF_VALID) {
+		result = dbf_get_record(dbh, fields, i);
+		if (result == DBF_VALID)
+		{
 			query[0] = '\0';
-			for (h = 0; h < dbh->db_nfields; h++) {
-				if (!strlen(fields[h].db_name)) {
+			for (h = 0; h < dbh->db_nfields; h++)
+			{
+				if (!strlen(fields[h].db_name))
 					continue;
-				}
 
-				if (h!=0) /* not for the first field! */
-					strcat(query, "\t"); /* COPY statement field separator */
+				if (h != 0)		/* not for the first field! */
+					strcat(query, "\t");		/* COPY statement field
+												 * separator */
 
-				if (upper) {
-				   strtoupper(fields[h].db_contents);
-				}
-				if (lower) {
+				if (upper)
+					strtoupper(fields[h].db_contents);
+				if (lower)
 					strtolower(fields[h].db_contents);
-				}
 
 				foo = fields[h].db_contents;
 #ifdef HAVE_ICONV_H
-				if(charset_from)
+				if (charset_from)
 					foo = convert_charset(foo);
 #endif
 				foo = Escape(foo);
 
 				/* handle the date first - liuk */
-				if(fields[h].db_type=='D') {	
-					if((strlen(foo)==8) && isinteger(foo)) {
-						sprintf(pgdate,"%c%c%c%c-%c%c-%c%c",
-							foo[0],foo[1],foo[2],foo[3],
-							foo[4],foo[5],foo[6],foo[7]);
-						strcat(query,pgdate);
-					} else {
-						/* empty field must be inserted as NULL value in this
- 						   way */
-						strcat(query,"\\N");
+				if (fields[h].db_type == 'D')
+				{
+					if ((strlen(foo) == 8) && isinteger(foo))
+					{
+						sprintf(pgdate, "%c%c%c%c-%c%c-%c%c",
+								foo[0], foo[1], foo[2], foo[3],
+								foo[4], foo[5], foo[6], foo[7]);
+						strcat(query, pgdate);
+					}
+					else
+					{
+						/*
+						 * empty field must be inserted as NULL value in
+						 * this way
+						 */
+						strcat(query, "\\N");
 					}
 				}
 				else if ((fields[h].db_type == 'N') &&
-					(fields[h].db_dec == 0)){
-					if (isinteger(foo)) {
+						 (fields[h].db_dec == 0))
+				{
+					if (isinteger(foo))
 						strcat(query, foo);
-					} else {
+					else
+					{
 						strcat(query, "\\N");
 						if (verbose)
 							fprintf(stderr, "Illegal numeric value found "
-											"in record %d, field \"%s\"\n",
-											i, fields[h].db_name);
+									"in record %d, field \"%s\"\n",
+									i, fields[h].db_name);
 					}
-				} else {
+				}
+				else
+				{
 					strcat(query, foo); /* must be character */
 				}
 			}
 			strcat(query, "\n");
 
-			if ((verbose > 1) && (( i % 100) == 0)) {/* Only show every 100 */
-				printf("Inserting record %d\n", i);  /* records. */
+			if ((verbose > 1) && ((i % 100) == 0))
+			{					/* Only show every 100 */
+				printf("Inserting record %d\n", i);		/* records. */
 			}
 			PQputline(conn, query);
 
 		}
 		/* we need to end this copy and transaction */
-		if (((i-begin) % t_block) == t_block-1) {
+		if (((i - begin) % t_block) == t_block - 1)
+		{
 			if (verbose > 1)
 				fprintf(stderr, "Transaction: END\n");
 			PQputline(conn, "\\.\n");
-			if (PQendcopy(conn) != 0) {
+			if (PQendcopy(conn) != 0)
+			{
 				fprintf(stderr, "Something went wrong while copying. Check "
-								"your tables!\n");
+						"your tables!\n");
 				exit(1);
 			}
 			res = PQexec(conn, "END");
-			if (res == NULL) {
+			if (res == NULL)
+			{
 				fprintf(stderr, "Error committing work!\n");
 				fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
 				exit(1);
@@ -451,17 +532,20 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) {
 
 	/* last row copied in, end copy and transaction */
 	/* remember, i is now 1 greater then when we left the loop */
-	if (((i-begin) % t_block) != 0) {
+	if (((i - begin) % t_block) != 0)
+	{
 		if (verbose > 1)
 			fprintf(stderr, "Transaction: END\n");
 		PQputline(conn, "\\.\n");
 
-		if (PQendcopy(conn) != 0) {
+		if (PQendcopy(conn) != 0)
+		{
 			fprintf(stderr, "Something went wrong while copying. Check "
-							"your tables!\n");
+					"your tables!\n");
 		}
 		res = PQexec(conn, "END");
-		if (res == NULL) {
+		if (res == NULL)
+		{
 			fprintf(stderr, "Error committing work!\n");
 			fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
 			exit(1);
@@ -492,7 +576,9 @@ simple_prompt(const char *prompt, int maxlen, bool echo)
 {
 	int			length;
 	char	   *destination;
-	FILE *termin, *termout;
+	FILE	   *termin,
+			   *termout;
+
 #ifdef HAVE_TERMIOS_H
 	struct termios t_orig,
 				t;
@@ -505,8 +591,8 @@ simple_prompt(const char *prompt, int maxlen, bool echo)
 	prompt_state = true;		/* disable SIGINT */
 
 	/*
-	 * Do not try to collapse these into one "w+" mode file.
-	 * Doesn't work on some platforms (eg, HPUX 10.20).
+	 * Do not try to collapse these into one "w+" mode file. Doesn't work
+	 * on some platforms (eg, HPUX 10.20).
 	 */
 	termin = fopen("/dev/tty", "r");
 	termout = fopen("/dev/tty", "w");
@@ -529,7 +615,7 @@ simple_prompt(const char *prompt, int maxlen, bool echo)
 		tcsetattr(fileno(termin), TCSAFLUSH, &t);
 	}
 #endif
-	
+
 	if (prompt)
 	{
 		fputs(gettext(prompt), termout);
@@ -579,19 +665,23 @@ simple_prompt(const char *prompt, int maxlen, bool echo)
 }
 
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-	PGconn 		*conn;
+	PGconn	   *conn;
 	int			i;
-	extern int 	optind;
-	extern char	*optarg;
-	char		*query;
-	dbhead		*dbh;
+	extern int	optind;
+	extern char *optarg;
+	char	   *query;
+	dbhead	   *dbh;
 
-	while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF) {
-		switch (i) {
+	while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF)
+	{
+		switch (i)
+		{
 			case 'D':
-				if (create) {
+				if (create)
+				{
 					usage();
 					printf("Can't use -c and -D at the same time!\n");
 					exit(1);
@@ -599,32 +689,34 @@ int main(int argc, char **argv)
 				del = 1;
 				break;
 			case 'W':
-				password=simple_prompt("Password: ",100,0);
+				password = simple_prompt("Password: ", 100, 0);
 				break;
 			case 'f':
-				fieldlow=1;
+				fieldlow = 1;
 				break;
 			case 'v':
 				verbose++;
 				break;
 			case 'c':
-				if (del) {
+				if (del)
+				{
 					usage();
 					printf("Can't use -c and -D at the same time!\n");
 					exit(1);
 				}
-				create=1;
+				create = 1;
 				break;
 			case 'l':
-				lower=1;
+				lower = 1;
 				break;
 			case 'u':
-				if (lower) {
+				if (lower)
+				{
 					usage();
 					printf("Can't use -u and -l at the same time!\n");
 					exit(1);
 				}
-				upper=1;
+				upper = 1;
 				break;
 			case 'b':
 				begin = atoi(optarg);
@@ -633,28 +725,28 @@ int main(int argc, char **argv)
 				end = atoi(optarg);
 				break;
 			case 'h':
-				host = (char *)strdup(optarg);
+				host = (char *) strdup(optarg);
 				break;
 			case 'd':
-				dbase = (char *)strdup(optarg);
+				dbase = (char *) strdup(optarg);
 				break;
 			case 't':
-				table = (char *)strdup(optarg);
-                break;
+				table = (char *) strdup(optarg);
+				break;
 			case 's':
-				subarg = (char *)strdup(optarg);
+				subarg = (char *) strdup(optarg);
 				break;
 			case 'B':
 				t_block = atoi(optarg);
 				break;
 			case 'U':
-				username = (char *)strdup(optarg);
+				username = (char *) strdup(optarg);
 				break;
 			case 'F':
-				charset_from = (char *)strdup(optarg);
+				charset_from = (char *) strdup(optarg);
 				break;
 			case 'T':
-				charset_to = (char *)strdup(optarg);
+				charset_to = (char *) strdup(optarg);
 				break;
 			case ':':
 				usage();
@@ -663,7 +755,11 @@ int main(int argc, char **argv)
 				break;
 			case '?':
 				usage();
-				/* FIXME: Ivan thinks this is bad: printf("unknown argument: %s\n", argv[0]); */
+
+				/*
+				 * FIXME: Ivan thinks this is bad: printf("unknown
+				 * argument: %s\n", argv[0]);
+				 */
 				exit(1);
 				break;
 			default:
@@ -674,80 +770,83 @@ int main(int argc, char **argv)
 	argc -= optind;
 	argv = &argv[optind];
 
-	if (argc != 1) {
+	if (argc != 1)
+	{
 		usage();
-		if(username)
+		if (username)
 			free(username);
-		if(password)
+		if (password)
 			free(password);
 		exit(1);
 	}
 
 #ifdef HAVE_ICONV_H
-	if(charset_from)
+	if (charset_from)
 	{
-		if(verbose>1)
+		if (verbose > 1)
 			printf("Setting conversion from charset \"%s\" to \"%s\".\n",
-				charset_from,charset_to);
-		iconv_d = iconv_open(charset_to,charset_from);
-		if(iconv_d == (iconv_t) -1)
+				   charset_from, charset_to);
+		iconv_d = iconv_open(charset_to, charset_from);
+		if (iconv_d == (iconv_t) - 1)
 		{
 			printf("Cannot convert from charset \"%s\" to charset \"%s\".\n",
-				charset_from,charset_to);
+				   charset_from, charset_to);
 			exit(1);
 		}
 	}
 #endif
 
-	if (verbose > 1) {
+	if (verbose > 1)
 		printf("Opening dbf-file\n");
-	}
 
-	if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *)-1) {
+	if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *) - 1)
+	{
 		fprintf(stderr, "Couldn't open xbase-file %s\n", argv[0]);
-		if(username)
+		if (username)
 			free(username);
-		if(password)
+		if (password)
 			free(password);
-		if(charset_from)
+		if (charset_from)
 			iconv_close(iconv_d);
 		exit(1);
 	}
 
 	if (fieldlow)
-		for ( i = 0 ; i < dbh->db_nfields ; i++ )
-				strtolower(dbh->db_fields[i].db_name);
+		for (i = 0; i < dbh->db_nfields; i++)
+			strtolower(dbh->db_fields[i].db_name);
 
-	if (verbose) {
+	if (verbose)
+	{
 		printf("dbf-file: %s, PG-dbase: %s, PG-table: %s\n", argv[0],
-																 dbase,
-																 table);
+			   dbase,
+			   table);
 		printf("Number of records: %ld\n", dbh->db_records);
 		printf("NAME:\t\tLENGTH:\t\tTYPE:\n");
 		printf("-------------------------------------\n");
-		for (i = 0; i < dbh->db_nfields ; i++) {
-			printf("%-12s\t%7d\t\t%5c\n",dbh->db_fields[i].db_name,
-									 dbh->db_fields[i].db_flen,
-									 dbh->db_fields[i].db_type);
+		for (i = 0; i < dbh->db_nfields; i++)
+		{
+			printf("%-12s\t%7d\t\t%5c\n", dbh->db_fields[i].db_name,
+				   dbh->db_fields[i].db_flen,
+				   dbh->db_fields[i].db_type);
 		}
 	}
 
-	if (verbose > 1) {
+	if (verbose > 1)
 		printf("Making connection to PG-server\n");
-	}
 
-	conn = PQsetdbLogin(host,NULL,NULL,NULL, dbase, username, password);
-	if (PQstatus(conn) != CONNECTION_OK) {
+	conn = PQsetdbLogin(host, NULL, NULL, NULL, dbase, username, password);
+	if (PQstatus(conn) != CONNECTION_OK)
+	{
 		fprintf(stderr, "Couldn't get a connection with the ");
 		fprintf(stderr, "designated host!\n");
 		fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn));
 		close(dbh->db_fd);
 		free(dbh);
-		if(username)
+		if (username)
 			free(username);
-		if(password)
+		if (password)
 			free(password);
-		if(charset_from)
+		if (charset_from)
 			iconv_close(iconv_d);
 		exit(1);
 	}
@@ -756,55 +855,60 @@ int main(int argc, char **argv)
 	do_substitute(subarg, dbh);
 
 /* create table if specified, else check if target table exists */
-	if (!create) {
-		if (!check_table(conn, table)) {
+	if (!create)
+	{
+		if (!check_table(conn, table))
+		{
 			printf("Table does not exist!\n");
-			if(username)
+			if (username)
 				free(username);
-			if(password)
+			if (password)
 				free(password);
-			if(charset_from)
+			if (charset_from)
 				iconv_close(iconv_d);
 			exit(1);
 		}
-		if (del) {
-			if (!(query = (char *)malloc(13 + strlen(table)))) {
+		if (del)
+		{
+			if (!(query = (char *) malloc(13 + strlen(table))))
+			{
 				printf("Memory-allocation error in main (delete)!\n");
 				close(dbh->db_fd);
 				free(dbh);
 				PQfinish(conn);
-				if(username)
+				if (username)
 					free(username);
-				if(password)
+				if (password)
 					free(password);
-				if(charset_from)
+				if (charset_from)
 					iconv_close(iconv_d);
 				exit(1);
 			}
-			if (verbose > 1) {
+			if (verbose > 1)
 				printf("Deleting from original table\n");
-			}
 			sprintf(query, "DELETE FROM %s", table);
 			PQexec(conn, query);
 			free(query);
 		}
-	} else {
-		if (!(query = (char *)malloc(12 + strlen(table)))) {
+	}
+	else
+	{
+		if (!(query = (char *) malloc(12 + strlen(table))))
+		{
 			printf("Memory-allocation error in main (drop)!\n");
 			close(dbh->db_fd);
 			free(dbh);
 			PQfinish(conn);
-			if(username)
+			if (username)
 				free(username);
-			if(password)
+			if (password)
 				free(password);
-			if(charset_from)
+			if (charset_from)
 				iconv_close(iconv_d);
 			exit(1);
 		}
-		if (verbose > 1) {
+		if (verbose > 1)
 			printf("Dropping original table (if one exists)\n");
-		}
 		sprintf(query, "DROP TABLE %s", table);
 		PQexec(conn, query);
 		free(query);
@@ -819,18 +923,17 @@ int main(int argc, char **argv)
 	PQexec(conn, "SET DATESTYLE TO 'ISO';");
 	do_inserts(conn, table, dbh);
 
-	if (verbose > 1) {
+	if (verbose > 1)
 		printf("Closing up....\n");
-	}
 
-    close(dbh->db_fd);
-    free(dbh);
-    PQfinish(conn);
-	if(username)
+	close(dbh->db_fd);
+	free(dbh);
+	PQfinish(conn);
+	if (username)
 		free(username);
-	if(password)
+	if (password)
 		free(password);
-	if(charset_from)
+	if (charset_from)
 		iconv_close(iconv_d);
 	exit(0);
 }
diff --git a/contrib/dbase/endian.c b/contrib/dbase/endian.c
index 55c53d8980..5bc6a186a0 100644
--- a/contrib/dbase/endian.c
+++ b/contrib/dbase/endian.c
@@ -5,41 +5,45 @@
 /*
  * routine to change little endian long to host long
  */
-long get_long(u_char *cp)
+long
+get_long(u_char *cp)
 {
-        long ret;
+	long		ret;
 
-        ret = *cp++;
-        ret += ((*cp++)<<8);
-        ret += ((*cp++)<<16);
-        ret += ((*cp++)<<24);
+	ret = *cp++;
+	ret += ((*cp++) << 8);
+	ret += ((*cp++) << 16);
+	ret += ((*cp++) << 24);
 
-        return ret;
+	return ret;
 }
 
-void put_long(u_char *cp, long lval)
+void
+put_long(u_char *cp, long lval)
 {
-        cp[0] = lval & 0xff;
-        cp[1] = (lval >> 8) & 0xff;
-        cp[2] = (lval >> 16) & 0xff;
-        cp[3] = (lval >> 24) & 0xff;
+	cp[0] = lval & 0xff;
+	cp[1] = (lval >> 8) & 0xff;
+	cp[2] = (lval >> 16) & 0xff;
+	cp[3] = (lval >> 24) & 0xff;
 }
 
 /*
  * routine to change little endian short to host short
  */
-short get_short(u_char *cp)
+short
+get_short(u_char *cp)
 {
-        short ret;
+	short		ret;
 
-        ret = *cp++;
-        ret += ((*cp++)<<8);
+	ret = *cp++;
+	ret += ((*cp++) << 8);
 
-        return ret;
+	return ret;
 }
 
-void put_short(u_char *cp, short sval)
+void
+put_short(u_char *cp, short sval)
 {
-        cp[0] = sval & 0xff;
-        cp[1] = (sval >> 8) & 0xff;
+	cp[0] = sval & 0xff;
+	cp[1] = (sval >> 8) & 0xff;
 }
diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c
index e858cfd0ba..4ab1315fa7 100644
--- a/contrib/dblink/dblink.c
+++ b/contrib/dblink/dblink.c
@@ -4,18 +4,18 @@
  * Functions returning results from a remote database
  *
  * Copyright (c) Joseph Conway <joe.conway@mail.com>, 2001;
- * 
+ *
  * Permission to use, copy, modify, and distribute this software and its
  * documentation for any purpose, without fee, and without a written agreement
  * is hereby granted, provided that the above copyright notice and this
  * paragraph and the following two paragraphs appear in all copies.
- * 
+ *
  * IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
  * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
  * THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
@@ -30,29 +30,28 @@ PG_FUNCTION_INFO_V1(dblink);
 Datum
 dblink(PG_FUNCTION_ARGS)
 {
-	PGconn			*conn = NULL;
-	PGresult		*res = NULL;
-	dblink_results	*results;
-	char			*optstr;
-	char			*sqlstatement;
-	char			*curstr = "DECLARE mycursor CURSOR FOR ";
-	char			*execstatement;
-	char			*msg;
-	int				ntuples = 0;
-	ReturnSetInfo 	*rsi;
-
-	if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) {
+	PGconn	   *conn = NULL;
+	PGresult   *res = NULL;
+	dblink_results *results;
+	char	   *optstr;
+	char	   *sqlstatement;
+	char	   *curstr = "DECLARE mycursor CURSOR FOR ";
+	char	   *execstatement;
+	char	   *msg;
+	int			ntuples = 0;
+	ReturnSetInfo *rsi;
+
+	if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
 		elog(ERROR, "dblink: NULL arguments are not permitted");
-	}
 
-	if (fcinfo->resultinfo == NULL || ! IsA(fcinfo->resultinfo, ReturnSetInfo)) {
+	if (fcinfo->resultinfo == NULL || !IsA(fcinfo->resultinfo, ReturnSetInfo))
 		elog(ERROR, "dblink: function called in context that does not accept a set result");
-	}
 
 	optstr = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
 	sqlstatement = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
 
-	if (fcinfo->flinfo->fn_extra == NULL) {
+	if (fcinfo->flinfo->fn_extra == NULL)
+	{
 
 		conn = PQconnectdb(optstr);
 		if (PQstatus(conn) == CONNECTION_BAD)
@@ -73,13 +72,14 @@ dblink(PG_FUNCTION_ARGS)
 		PQclear(res);
 
 		execstatement = (char *) palloc(strlen(curstr) + strlen(sqlstatement) + 1);
-		if (execstatement != NULL) {
+		if (execstatement != NULL)
+		{
 			strcpy(execstatement, curstr);
 			strcat(execstatement, sqlstatement);
 			strcat(execstatement, "\0");
-		} else {
-			elog(ERROR, "dblink: insufficient memory" );
 		}
+		else
+			elog(ERROR, "dblink: insufficient memory");
 
 		res = PQexec(conn, execstatement);
 		if (!res || (PQresultStatus(res) != PGRES_COMMAND_OK && PQresultStatus(res) != PGRES_TUPLES_OK))
@@ -88,23 +88,27 @@ dblink(PG_FUNCTION_ARGS)
 			PQclear(res);
 			PQfinish(conn);
 			elog(ERROR, "dblink: sql error: %s", msg);
-		} else {
+		}
+		else
+		{
 			/*
 			 * got results, start fetching them
 			 */
-		    PQclear(res);
+			PQclear(res);
 
-		    res = PQexec(conn, "FETCH ALL in mycursor");
-		    if (!res || PQresultStatus(res) != PGRES_TUPLES_OK) {
+			res = PQexec(conn, "FETCH ALL in mycursor");
+			if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
+			{
 				msg = pstrdup(PQerrorMessage(conn));
 				PQclear(res);
 				PQfinish(conn);
 				elog(ERROR, "dblink: sql error: %s", msg);
-		    }
+			}
 
 			ntuples = PQntuples(res);
 
-			if (ntuples > 0) {
+			if (ntuples > 0)
+			{
 
 				results = init_dblink_results(fcinfo->flinfo->fn_mcxt);
 				results->tup_num = 0;
@@ -116,44 +120,48 @@ dblink(PG_FUNCTION_ARGS)
 				results = NULL;
 				results = fcinfo->flinfo->fn_extra;
 
-			    /* close the cursor */
-			    res = PQexec(conn, "CLOSE mycursor");
-			    PQclear(res);
+				/* close the cursor */
+				res = PQexec(conn, "CLOSE mycursor");
+				PQclear(res);
 
-			    /* commit the transaction */
-			    res = PQexec(conn, "COMMIT");
-			    PQclear(res);
+				/* commit the transaction */
+				res = PQexec(conn, "COMMIT");
+				PQclear(res);
 
-			    /* close the connection to the database and cleanup */
-			    PQfinish(conn);
+				/* close the connection to the database and cleanup */
+				PQfinish(conn);
 
-				rsi = (ReturnSetInfo *)fcinfo->resultinfo;
+				rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 				rsi->isDone = ExprMultipleResult;
 
 				PG_RETURN_POINTER(results);
 
-			} else {
+			}
+			else
+			{
 
-			    PQclear(res);
+				PQclear(res);
 
-			    /* close the cursor */
-			    res = PQexec(conn, "CLOSE mycursor");
-			    PQclear(res);
+				/* close the cursor */
+				res = PQexec(conn, "CLOSE mycursor");
+				PQclear(res);
 
-			    /* commit the transaction */
-			    res = PQexec(conn, "COMMIT");
-			    PQclear(res);
+				/* commit the transaction */
+				res = PQexec(conn, "COMMIT");
+				PQclear(res);
 
-			    /* close the connection to the database and cleanup */
-			    PQfinish(conn);
+				/* close the connection to the database and cleanup */
+				PQfinish(conn);
 
-				rsi = (ReturnSetInfo *)fcinfo->resultinfo;
-				rsi->isDone = ExprEndResult ;
+				rsi = (ReturnSetInfo *) fcinfo->resultinfo;
+				rsi->isDone = ExprEndResult;
 
 				PG_RETURN_NULL();
 			}
 		}
-	} else {
+	}
+	else
+	{
 		/*
 		 * check for more results
 		 */
@@ -162,29 +170,30 @@ dblink(PG_FUNCTION_ARGS)
 		results->tup_num++;
 		ntuples = PQntuples(results->res);
 
-		if (results->tup_num < ntuples) {
-
+		if (results->tup_num < ntuples)
+		{
 			/*
 			 * fetch them if available
 			 */
 
-			rsi = (ReturnSetInfo *)fcinfo->resultinfo;
+			rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 			rsi->isDone = ExprMultipleResult;
 
 			PG_RETURN_POINTER(results);
 
-		} else {
-
+		}
+		else
+		{
 			/*
 			 * or if no more, clean things up
 			 */
 
 			results = fcinfo->flinfo->fn_extra;
 
-		    PQclear(results->res);
+			PQclear(results->res);
 
-			rsi = (ReturnSetInfo *)fcinfo->resultinfo;
-			rsi->isDone = ExprEndResult ;
+			rsi = (ReturnSetInfo *) fcinfo->resultinfo;
+			rsi->isDone = ExprEndResult;
 
 			PG_RETURN_NULL();
 		}
@@ -204,48 +213,48 @@ PG_FUNCTION_INFO_V1(dblink_tok);
 Datum
 dblink_tok(PG_FUNCTION_ARGS)
 {
-	dblink_results	*results;
-	int				fldnum;
-	text			*result_text;
-	char			*result;
-	int				nfields = 0;
-	int				text_len = 0;
-
-	if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) {
+	dblink_results *results;
+	int			fldnum;
+	text	   *result_text;
+	char	   *result;
+	int			nfields = 0;
+	int			text_len = 0;
+
+	if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
 		elog(ERROR, "dblink: NULL arguments are not permitted");
-	}
 
 	results = (dblink_results *) PG_GETARG_POINTER(0);
-	if (results == NULL) {
+	if (results == NULL)
 		elog(ERROR, "dblink: function called with invalid result pointer");
-	}
 
 	fldnum = PG_GETARG_INT32(1);
-	if (fldnum < 0) {
+	if (fldnum < 0)
 		elog(ERROR, "dblink: field number < 0 not permitted");
-	}
 
 	nfields = PQnfields(results->res);
-	if (fldnum > (nfields - 1)) {
+	if (fldnum > (nfields - 1))
 		elog(ERROR, "dblink: field number %d does not exist", fldnum);
-	}
 
-	if (PQgetisnull(results->res, results->tup_num, fldnum) == 1) {
+	if (PQgetisnull(results->res, results->tup_num, fldnum) == 1)
+	{
 
 		PG_RETURN_NULL();
 
-	} else {
+	}
+	else
+	{
 
 		text_len = PQgetlength(results->res, results->tup_num, fldnum);
 
 		result = (char *) palloc(text_len + 1);
 
-		if (result != NULL) {
+		if (result != NULL)
+		{
 			strcpy(result, PQgetvalue(results->res, results->tup_num, fldnum));
 			strcat(result, "\0");
-		} else {
-			elog(ERROR, "dblink: insufficient memory" );
 		}
+		else
+			elog(ERROR, "dblink: insufficient memory");
 
 		result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(result)));
 
@@ -267,8 +276,8 @@ dblink_tok(PG_FUNCTION_ARGS)
 dblink_results *
 init_dblink_results(MemoryContext fn_mcxt)
 {
-	MemoryContext	oldcontext;
-	dblink_results	*retval;
+	MemoryContext oldcontext;
+	dblink_results *retval;
 
 	oldcontext = MemoryContextSwitchTo(fn_mcxt);
 
diff --git a/contrib/dblink/dblink.h b/contrib/dblink/dblink.h
index 1b2a48e9fb..f4de437e3d 100644
--- a/contrib/dblink/dblink.h
+++ b/contrib/dblink/dblink.h
@@ -4,18 +4,18 @@
  * Functions returning results from a remote database
  *
  * Copyright (c) Joseph Conway <joe.conway@mail.com>, 2001;
- * 
+ *
  * Permission to use, copy, modify, and distribute this software and its
  * documentation for any purpose, without fee, and without a written agreement
  * is hereby granted, provided that the above copyright notice and this
  * paragraph and the following two paragraphs appear in all copies.
- * 
+ *
  * IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
  * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
  * THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
@@ -52,9 +52,9 @@ typedef struct
 	/*
 	 * the actual query results
 	 */
-	PGresult	*res;
+	PGresult   *res;
 
-} dblink_results;
+}			dblink_results;
 
 /*
  * External declarations
@@ -66,5 +66,4 @@ extern Datum dblink_tok(PG_FUNCTION_ARGS);
  * Internal declarations
  */
 dblink_results *init_dblink_results(MemoryContext fn_mcxt);
-
 #endif	 /* DBLINK_H */
diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c
index 8fd568d720..a259e4b08b 100644
--- a/contrib/fulltextindex/fti.c
+++ b/contrib/fulltextindex/fti.c
@@ -6,52 +6,52 @@
 #include "commands/trigger.h"
 
 /*
- *  Trigger function accepts variable number of arguments:
+ *	Trigger function accepts variable number of arguments:
  *
  *		1. relation in which to store the substrings
  *		2. fields to extract substrings from
  *
- *  The relation in which to insert *must* have the following layout:
+ *	The relation in which to insert *must* have the following layout:
  *
  *		string		varchar(#)
  *		id			oid
  *
- *   where # is the largest size of the varchar columns being indexed
+ *	 where # is the largest size of the varchar columns being indexed
  *
  *	Example:
  *
- *  -- Create the SQL function based on the compiled shared object
- *  create function fti() returns opaque as
- *    '/usr/local/pgsql/lib/contrib/fti.so' language 'C';
+ *	-- Create the SQL function based on the compiled shared object
+ *	create function fti() returns opaque as
+ *	  '/usr/local/pgsql/lib/contrib/fti.so' language 'C';
  *
- *  -- Create the FTI table
- *  create table product_fti (string varchar(255), id oid);
+ *	-- Create the FTI table
+ *	create table product_fti (string varchar(255), id oid);
  *
- *  -- Create an index to assist string matches
- *  create index product_fti_string_idx on product_fti (string);
+ *	-- Create an index to assist string matches
+ *	create index product_fti_string_idx on product_fti (string);
  *
- *  -- Create an index to assist trigger'd deletes
- *  create index product_fti_id_idx on product_fti (id);
+ *	-- Create an index to assist trigger'd deletes
+ *	create index product_fti_id_idx on product_fti (id);
  *
- *  -- Create an index on the product oid column to assist joins 
- *  -- between the fti table and the product table
- *  create index product_oid_idx on product (oid);
+ *	-- Create an index on the product oid column to assist joins
+ *	-- between the fti table and the product table
+ *	create index product_oid_idx on product (oid);
  *
- *  -- Create the trigger to perform incremental changes to the full text index.
- *  create trigger product_fti_trig after update or insert or delete on product
- *  for each row execute procedure fti(product_fti, title, artist);
- *								       ^^^^^^^^^^^
- *								       table where full text index is stored
- *											        ^^^^^^^^^^^^^
- *											        columns to index in the base table
+ *	-- Create the trigger to perform incremental changes to the full text index.
+ *	create trigger product_fti_trig after update or insert or delete on product
+ *	for each row execute procedure fti(product_fti, title, artist);
+ *									   ^^^^^^^^^^^
+ *									   table where full text index is stored
+ *													^^^^^^^^^^^^^
+ *													columns to index in the base table
  *
- *  After populating 'product', try something like:
+ *	After populating 'product', try something like:
  *
- *  SELECT DISTINCT(p.*) FROM product p, product_fti f1, product_fti f2 WHERE
+ *	SELECT DISTINCT(p.*) FROM product p, product_fti f1, product_fti f2 WHERE
  *	f1.string ~ '^slippery' AND f2.string ~ '^wet' AND p.oid=f1.id AND p.oid=f2.id;
  *
- *  To check that your indicies are being used correctly, make sure you
- *  EXPLAIN SELECT ... your test query above.
+ *	To check that your indicies are being used correctly, make sure you
+ *	EXPLAIN SELECT ... your test query above.
  *
  * CHANGELOG
  * ---------
@@ -76,14 +76,14 @@
  * TODO
  * ----
  *
- *   prevent generating duplicate words for an oid in the fti table
- *   save a plan for deletes
- *   create a function that will make the index *after* we have populated
- *   the main table (probably first delete all contents to be sure there's
- *   nothing in it, then re-populate the fti-table)
+ *	 prevent generating duplicate words for an oid in the fti table
+ *	 save a plan for deletes
+ *	 create a function that will make the index *after* we have populated
+ *	 the main table (probably first delete all contents to be sure there's
+ *	 nothing in it, then re-populate the fti-table)
  *
- *   can we do something with operator overloading or a seperate function
- *   that can build the final query automatigally?
+ *	 can we do something with operator overloading or a seperate function
+ *	 that can build the final query automatigally?
  */
 
 #define MAX_FTI_QUERY_LENGTH 8192
@@ -103,16 +103,15 @@ char	   *StopWords[] = {		/* list of words to skip in indexing */
 	"the",
 	"yes"
 };
-
-#endif /* USE_STOP_WORDS */
+#endif	 /* USE_STOP_WORDS */
 
 /* stuff for caching query-plans, stolen from contrib/spi/\*.c */
 typedef struct
 {
-	char	*ident;
-	int		nplans;
-	void	**splan;
-} EPlan;
+	char	   *ident;
+	int			nplans;
+	void	  **splan;
+}			EPlan;
 
 static EPlan *InsertPlans = NULL;
 static EPlan *DeletePlans = NULL;
@@ -201,13 +200,11 @@ fti(PG_FUNCTION_ARGS)
 		Oid		   *argtypes;
 		Datum		values[1];
 		EPlan	   *plan;
-		int i;
+		int			i;
 
 		snprintf(query, MAX_FTI_QUERY_LENGTH, "D%s", indexname);
 		for (i = 1; i < nargs; i++)
-		{
 			snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]);
-		}
 
 		plan = find_plan(query, &DeletePlans, &nDeletePlans);
 		if (plan->nplans <= 0)
@@ -238,23 +235,21 @@ fti(PG_FUNCTION_ARGS)
 
 	if (isinsert)
 	{
-		char		*substring;
-		char		*column;
-		void		*pplan;
-		Oid			*argtypes;
+		char	   *substring;
+		char	   *column;
+		void	   *pplan;
+		Oid		   *argtypes;
 		Datum		values[2];
 		int			colnum;
-		struct	varlena *data;
-		EPlan		*plan;
-		int 		i;
-		char		*buff;
-		char		*string;
+		struct varlena *data;
+		EPlan	   *plan;
+		int			i;
+		char	   *buff;
+		char	   *string;
 
 		snprintf(query, MAX_FTI_QUERY_LENGTH, "I%s", indexname);
 		for (i = 1; i < nargs; i++)
-		{
 			snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]);
-		}
 
 		plan = find_plan(query, &InsertPlans, &nInsertPlans);
 
@@ -269,7 +264,7 @@ fti(PG_FUNCTION_ARGS)
 
 			/* prepare plan to gain speed */
 			snprintf(query, MAX_FTI_QUERY_LENGTH, "INSERT INTO %s (string, id) VALUES ($1, $2)",
-					indexname);
+					 indexname);
 			pplan = SPI_prepare(query, 2, argtypes);
 			if (!pplan)
 				elog(ERROR, "Full Text Indexing: SPI_prepare: Returned NULL in insert");
@@ -303,7 +298,7 @@ fti(PG_FUNCTION_ARGS)
 					string++;
 				}
 
-				data = (struct varlena *) palloc(sizeof(int32) + strlen(column) + 1);
+				data = (struct varlena *) palloc(sizeof(int32) + strlen(column) +1);
 				buff = palloc(strlen(column) + 1);
 				/* saves lots of calls in while-loop and in breakup() */
 
@@ -348,7 +343,6 @@ breakup(char *string, char *substring)
 
 	while (cur_pos > string)	/* don't read before start of 'string' */
 	{
-
 		/*
 		 * skip pieces at the end of a string that are not alfa-numeric
 		 * (ie. 'string$%^&', last_start first points to '&', and after
@@ -409,7 +403,7 @@ is_stopword(char *text)
 		else
 			StopHigh = StopMiddle;
 	}
-#endif /* USE_STOP_WORDS */
+#endif	 /* USE_STOP_WORDS */
 
 	return (false);
 }
diff --git a/contrib/fuzzystrmatch/fuzzystrmatch.c b/contrib/fuzzystrmatch/fuzzystrmatch.c
index d6ec0f5c30..94b9e9de77 100644
--- a/contrib/fuzzystrmatch/fuzzystrmatch.c
+++ b/contrib/fuzzystrmatch/fuzzystrmatch.c
@@ -24,13 +24,13 @@
  * documentation for any purpose, without fee, and without a written agreement
  * is hereby granted, provided that the above copyright notice and this
  * paragraph and the following two paragraphs appear in all copies.
- * 
+ *
  * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
  * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
  * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
@@ -50,23 +50,22 @@ PG_FUNCTION_INFO_V1(levenshtein);
 Datum
 levenshtein(PG_FUNCTION_ARGS)
 {
-	char			*str_s;
-	char			*str_s0;
-	char			*str_t;
-	int				cols = 0;
-	int				rows = 0;
-	int				*u_cells;
-	int				*l_cells;
-	int				*tmp;
-	int				i;
-	int				j;
+	char	   *str_s;
+	char	   *str_s0;
+	char	   *str_t;
+	int			cols = 0;
+	int			rows = 0;
+	int		   *u_cells;
+	int		   *l_cells;
+	int		   *tmp;
+	int			i;
+	int			j;
 
 	/*
-	 * Fetch the arguments.
-	 * str_s is referred to as the "source"
-	 * cols = length of source + 1 to allow for the initialization column
-	 * str_t is referred to as the "target", rows = length of target + 1 
-	 * rows = length of target + 1 to allow for the initialization row
+	 * Fetch the arguments. str_s is referred to as the "source" cols =
+	 * length of source + 1 to allow for the initialization column str_t
+	 * is referred to as the "target", rows = length of target + 1 rows =
+	 * length of target + 1 to allow for the initialization row
 	 */
 	str_s = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
 	str_t = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1))));
@@ -75,18 +74,19 @@ levenshtein(PG_FUNCTION_ARGS)
 	rows = strlen(str_t) + 1;
 
 	/*
-	 * Restrict the length of the strings being compared to something reasonable
-	 * because we will have to perform rows * cols calcualtions. If longer strings need to be
-	 * compared, increase MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for
-	 * speed and memory usage).
+	 * Restrict the length of the strings being compared to something
+	 * reasonable because we will have to perform rows * cols
+	 * calcualtions. If longer strings need to be compared, increase
+	 * MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for speed
+	 * and memory usage).
 	 */
 	if ((cols > MAX_LEVENSHTEIN_STRLEN + 1) || (rows > MAX_LEVENSHTEIN_STRLEN + 1))
 		elog(ERROR, "levenshtein: Arguments may not exceed %d characters in length", MAX_LEVENSHTEIN_STRLEN);
 
 	/*
-	 * If either rows or cols is 0, the answer is the other value.
-	 * This makes sense since it would take that many insertions
-	 * the build a matching string
+	 * If either rows or cols is 0, the answer is the other value. This
+	 * makes sense since it would take that many insertions the build a
+	 * matching string
 	 */
 
 	if (cols == 0)
@@ -96,8 +96,9 @@ levenshtein(PG_FUNCTION_ARGS)
 		PG_RETURN_INT32(cols);
 
 	/*
-	 * Allocate two vectors of integers. One will be used for the "upper" row,
-	 * the other for the "lower" row. Initialize the "upper" row to 0..cols
+	 * Allocate two vectors of integers. One will be used for the "upper"
+	 * row, the other for the "lower" row. Initialize the "upper" row to
+	 * 0..cols
 	 */
 	u_cells = palloc(sizeof(int) * cols);
 	for (i = 0; i < cols; i++)
@@ -106,33 +107,35 @@ levenshtein(PG_FUNCTION_ARGS)
 	l_cells = palloc(sizeof(int) * cols);
 
 	/*
-	 * Use str_s0 to "rewind" the pointer to str_s in the nested for loop below
+	 * Use str_s0 to "rewind" the pointer to str_s in the nested for loop
+	 * below
 	 */
 	str_s0 = str_s;
 
 	/*
-	 * Loop throught the rows, starting at row 1. Row 0 is used for the initial
-	 * "upper" row.
+	 * Loop throught the rows, starting at row 1. Row 0 is used for the
+	 * initial "upper" row.
 	 */
 	for (j = 1; j < rows; j++)
 	{
 		/*
-		 * We'll always start with col 1,
-		 * and initialize lower row col 0 to j
+		 * We'll always start with col 1, and initialize lower row col 0
+		 * to j
 		 */
 		l_cells[0] = j;
 
 		for (i = 1; i < cols; i++)
 		{
-			int		c = 0;
-			int		c1 = 0;
-			int		c2 = 0;
-			int		c3 = 0;
+			int			c = 0;
+			int			c1 = 0;
+			int			c2 = 0;
+			int			c3 = 0;
 
 			/*
-			 * The "cost" value is 0 if the character at the current col position
-			 * in the source string, matches the character at the current row position
-			 * in the target string; cost is 1 otherwise.
+			 * The "cost" value is 0 if the character at the current col
+			 * position in the source string, matches the character at the
+			 * current row position in the target string; cost is 1
+			 * otherwise.
 			 */
 			c = ((CHAREQ(str_s, str_t)) ? 0 : 1);
 
@@ -152,8 +155,7 @@ levenshtein(PG_FUNCTION_ARGS)
 			c3 = u_cells[i - 1] + c;
 
 			/*
-			 * The lower right cell is set to the minimum
-			 * of c1, c2, c3
+			 * The lower right cell is set to the minimum of c1, c2, c3
 			 */
 			l_cells[i] = (c1 < c2 ? c1 : c2) < c3 ? (c1 < c2 ? c1 : c2) : c3;
 
@@ -164,8 +166,8 @@ levenshtein(PG_FUNCTION_ARGS)
 		}
 
 		/*
-		 * Lower row now becomes the upper row, and the upper row
-		 * gets reused as the new lower row.
+		 * Lower row now becomes the upper row, and the upper row gets
+		 * reused as the new lower row.
 		 */
 		tmp = u_cells;
 		u_cells = l_cells;
@@ -183,8 +185,8 @@ levenshtein(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Because the final value (at position row, col) was swapped from
-	 * the lower row to the upper row, that's where we'll find it.
+	 * Because the final value (at position row, col) was swapped from the
+	 * lower row to the upper row, that's where we'll find it.
 	 */
 	PG_RETURN_INT32(u_cells[cols - 1]);
 }
@@ -199,10 +201,10 @@ Datum
 metaphone(PG_FUNCTION_ARGS)
 {
 	int			reqlen;
-	char		*str_i;
+	char	   *str_i;
 	size_t		str_i_len;
-	char		*metaph;
-	text		*result_text;
+	char	   *metaph;
+	text	   *result_text;
 	int			retval;
 
 	str_i = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0))));
@@ -240,7 +242,7 @@ metaphone(PG_FUNCTION_ARGS)
 }
 
 
-/* 
+/*
  * Original code by Michael G Schwern starts here.
  * Code slightly modified for use as PostgreSQL
  * function (palloc, etc). Original includes
@@ -255,26 +257,28 @@ metaphone(PG_FUNCTION_ARGS)
 /* Look at the current letter in the word */
 #define Curr_Letter (toupper(word[w_idx]))
 /* Go N letters back. */
-#define Look_Back_Letter(n)	(w_idx >= n ? toupper(word[w_idx-n]) : '\0') 
+#define Look_Back_Letter(n) (w_idx >= n ? toupper(word[w_idx-n]) : '\0')
 /* Previous letter.  I dunno, should this return null on failure? */
 #define Prev_Letter (Look_Back_Letter(1))
 /* Look two letters down.  It makes sure you don't walk off the string. */
 #define After_Next_Letter	(Next_Letter != '\0' ? toupper(word[w_idx+2]) \
-											     : '\0')
+												 : '\0')
 #define Look_Ahead_Letter(n) (toupper(Lookahead(word+w_idx, n)))
 
-					     
+
 /* Allows us to safely look ahead an arbitrary # of letters */
 /* I probably could have just used strlen... */
-char Lookahead(char * word, int how_far) {
-	char letter_ahead = '\0';  /* null by default */
-	int idx;
-	for(idx = 0;  word[idx] != '\0' && idx < how_far;  idx++);
-		/* Edge forward in the string... */
-		
-	letter_ahead = word[idx];  /* idx will be either == to how_far or
-								* at the end of the string
-								*/
+char
+Lookahead(char *word, int how_far)
+{
+	char		letter_ahead = '\0';	/* null by default */
+	int			idx;
+
+	for (idx = 0; word[idx] != '\0' && idx < how_far; idx++);
+	/* Edge forward in the string... */
+
+	letter_ahead = word[idx];	/* idx will be either == to how_far or at
+								 * the end of the string */
 	return letter_ahead;
 }
 
@@ -282,29 +286,30 @@ char Lookahead(char * word, int how_far) {
 /* phonize one letter */
 #define Phonize(c)	do {(*phoned_word)[p_idx++] = c;} while (0)
 /* Slap a null character on the end of the phoned word */
-#define End_Phoned_Word	do {(*phoned_word)[p_idx] = '\0';} while (0)
+#define End_Phoned_Word do {(*phoned_word)[p_idx] = '\0';} while (0)
 /* How long is the phoned word? */
 #define Phone_Len	(p_idx)
 
 /* Note is a letter is a 'break' in the word */
-#define Isbreak(c)  (!isalpha(c))
-
-
-int _metaphone (
-	/* IN */
-	char * 	word,
-	int 	max_phonemes,
-	/* OUT */
-	char ** phoned_word 
-) {
-	int	w_idx 	= 0;	/* point in the phonization we're at. */
-	int p_idx 	= 0;	/* end of the phoned phrase */
-	
+#define Isbreak(c)	(!isalpha(c))
+
+
+int
+_metaphone(
+ /* IN */
+		   char *word,
+		   int max_phonemes,
+ /* OUT */
+		   char **phoned_word
+)
+{
+	int			w_idx = 0;		/* point in the phonization we're at. */
+	int			p_idx = 0;		/* end of the phoned phrase */
+
 	/*-- Parameter checks --*/
 
 	/*
-	 * Shouldn't be necessary, but left these here anyway
-	 * jec Aug 3, 2001
+	 * Shouldn't be necessary, but left these here anyway jec Aug 3, 2001
 	 */
 
 	/* Negative phoneme length is meaningless */
@@ -314,13 +319,16 @@ int _metaphone (
 	/* Empty/null string is meaningless */
 	if ((word == NULL) || !(strlen(word) > 0))
 		elog(ERROR, "metaphone: Input string length must be > 0");
-	
+
 	/*-- Allocate memory for our phoned_phrase --*/
-	if (max_phonemes == 0) {	/* Assume largest possible */
-		*phoned_word = palloc(sizeof(char) * strlen(word) + 1);
+	if (max_phonemes == 0)
+	{							/* Assume largest possible */
+		*phoned_word = palloc(sizeof(char) * strlen(word) +1);
 		if (!*phoned_word)
 			return META_ERROR;
-	} else {
+	}
+	else
+	{
 		*phoned_word = palloc(sizeof(char) * max_phonemes + 1);
 		if (!*phoned_word)
 			return META_ERROR;
@@ -328,62 +336,70 @@ int _metaphone (
 
 	/*-- The first phoneme has to be processed specially. --*/
 	/* Find our first letter */
-	for( ;  !isalpha(Curr_Letter);  w_idx++ ) {
+	for (; !isalpha(Curr_Letter); w_idx++)
+	{
 		/* On the off chance we were given nothing but crap... */
-		if( Curr_Letter == '\0' ) {
+		if (Curr_Letter == '\0')
+		{
 			End_Phoned_Word
-			return META_SUCCESS; /* For testing */
+				return META_SUCCESS;	/* For testing */
 		}
-	}	
-	
-	switch (Curr_Letter) {
-		/* AE becomes E */
+	}
+
+	switch (Curr_Letter)
+	{
+			/* AE becomes E */
 		case 'A':
-			if( Next_Letter == 'E' ) {
+			if (Next_Letter == 'E')
+			{
 				Phonize('E');
-				w_idx+=2;
+				w_idx += 2;
 			}
 			/* Remember, preserve vowels at the beginning */
-			else {
+			else
+			{
 				Phonize('A');
 				w_idx++;
 			}
 			break;
-		/* [GKP]N becomes N */
+			/* [GKP]N becomes N */
 		case 'G':
 		case 'K':
 		case 'P':
-			if( Next_Letter == 'N' ) {
+			if (Next_Letter == 'N')
+			{
 				Phonize('N');
-				w_idx+=2;
+				w_idx += 2;
 			}
 			break;
-		/* WH becomes H, 
-		   WR becomes R 
-		   W if followed by a vowel */
+
+			/*
+			 * WH becomes H, WR becomes R W if followed by a vowel
+			 */
 		case 'W':
-			if( Next_Letter == 'H' ||
-			    Next_Letter == 'R' ) 
+			if (Next_Letter == 'H' ||
+				Next_Letter == 'R')
 			{
-			  Phonize(Next_Letter);
-			  w_idx+=2;
+				Phonize(Next_Letter);
+				w_idx += 2;
 			}
-			else if ( isvowel(Next_Letter) ) {
-			  Phonize('W');
-			  w_idx+=2;
+			else if (isvowel(Next_Letter))
+			{
+				Phonize('W');
+				w_idx += 2;
 			}
 			/* else ignore */
 			break;
-		/* X becomes S */
+			/* X becomes S */
 		case 'X':
 			Phonize('S');
 			w_idx++;
 			break;
-		/* Vowels are kept */
-		/* We did A already
-		case 'A':
-		case 'a':
-		*/
+			/* Vowels are kept */
+
+			/*
+			 * We did A already case 'A': case 'a':
+			 */
 		case 'E':
 		case 'I':
 		case 'O':
@@ -395,220 +411,235 @@ int _metaphone (
 			/* do nothing */
 			break;
 	}
-	
-	
-	
+
+
+
 	/* On to the metaphoning */
-	for(;  Curr_Letter != '\0' && 
-	        (max_phonemes == 0 || Phone_Len < max_phonemes);  
-	    w_idx++) {
-		/* How many letters to skip because an eariler encoding handled 	
-		 * multiple letters */
-		unsigned short int skip_letter = 0;	
-								
-
-		/* THOUGHT:  It would be nice if, rather than having things like...
-		 * well, SCI.  For SCI you encode the S, then have to remember
-		 * to skip the C.  So the phonome SCI invades both S and C.  It would
-		 * be better, IMHO, to skip the C from the S part of the encoding.
-		 * Hell, I'm trying it.
+	for (; Curr_Letter != '\0' &&
+		 (max_phonemes == 0 || Phone_Len < max_phonemes);
+		 w_idx++)
+	{
+		/*
+		 * How many letters to skip because an eariler encoding handled
+		 * multiple letters
 		 */
-	
+		unsigned short int skip_letter = 0;
+
+
+		/*
+		 * THOUGHT:  It would be nice if, rather than having things
+		 * like... well, SCI.  For SCI you encode the S, then have to
+		 * remember to skip the C.	So the phonome SCI invades both S and
+		 * C.  It would be better, IMHO, to skip the C from the S part of
+		 * the encoding. Hell, I'm trying it.
+		 */
+
 		/* Ignore non-alphas */
-		if( !isalpha(Curr_Letter) )
+		if (!isalpha(Curr_Letter))
 			continue;
-			
+
 		/* Drop duplicates, except CC */
-		if( Curr_Letter == Prev_Letter &&
-			Curr_Letter != 'C' )
+		if (Curr_Letter == Prev_Letter &&
+			Curr_Letter != 'C')
 			continue;
-		
-		switch (Curr_Letter) {
-			/* B -> B unless in MB */
+
+		switch (Curr_Letter)
+		{
+				/* B -> B unless in MB */
 			case 'B':
-				if( Prev_Letter != 'M' )
+				if (Prev_Letter != 'M')
 					Phonize('B');
 				break;
-			/* 'sh' if -CIA- or -CH, but not SCH, except SCHW.
-			 * (SCHW is handled in S)
-			 *  S if -CI-, -CE- or -CY-
-			 *  dropped if -SCI-, SCE-, -SCY- (handed in S)
-			 *  else K
-			 */
+
+				/*
+				 * 'sh' if -CIA- or -CH, but not SCH, except SCHW. (SCHW
+				 * is handled in S) S if -CI-, -CE- or -CY- dropped if
+				 * -SCI-, SCE-, -SCY- (handed in S) else K
+				 */
 			case 'C':
-				if( MAKESOFT(Next_Letter) ) {	/* C[IEY] */
-					if( After_Next_Letter == 'A' &&
-						Next_Letter == 'I' ) { /* CIA */
+				if (MAKESOFT(Next_Letter))
+				{				/* C[IEY] */
+					if (After_Next_Letter == 'A' &&
+						Next_Letter == 'I')
+					{			/* CIA */
 						Phonize(SH);
 					}
 					/* SC[IEY] */
-					else if ( Prev_Letter == 'S' ) {
-					  /* Dropped */
-					}
-					else {
-					  Phonize('S');
+					else if (Prev_Letter == 'S')
+					{
+						/* Dropped */
 					}
+					else
+						Phonize('S');
 				}
-				else if ( Next_Letter == 'H' ) {
+				else if (Next_Letter == 'H')
+				{
 #ifndef USE_TRADITIONAL_METAPHONE
-					if( After_Next_Letter == 'R' ||
-						Prev_Letter == 'S' ) { /* Christ, School */
+					if (After_Next_Letter == 'R' ||
+						Prev_Letter == 'S')
+					{			/* Christ, School */
 						Phonize('K');
 					}
-					else {
+					else
 						Phonize(SH);
-					}
 #else
 					Phonize(SH);
 #endif
 					skip_letter++;
 				}
-				else {
+				else
 					Phonize('K');
-				}
 				break;
-			/* J if in -DGE-, -DGI- or -DGY-
-			 * else T
-			 */
+
+				/*
+				 * J if in -DGE-, -DGI- or -DGY- else T
+				 */
 			case 'D':
-				if( Next_Letter == 'G' &&
-					MAKESOFT(After_Next_Letter) ) {
+				if (Next_Letter == 'G' &&
+					MAKESOFT(After_Next_Letter))
+				{
 					Phonize('J');
 					skip_letter++;
 				}
 				else
 					Phonize('T');
 				break;
-			/* F if in -GH and not B--GH, D--GH, -H--GH, -H---GH
-			 * else dropped if -GNED, -GN, 
-			 * else dropped if -DGE-, -DGI- or -DGY- (handled in D)
-			 * else J if in -GE-, -GI, -GY and not GG
-			 * else K
-			 */
+
+				/*
+				 * F if in -GH and not B--GH, D--GH, -H--GH, -H---GH else
+				 * dropped if -GNED, -GN, else dropped if -DGE-, -DGI- or
+				 * -DGY- (handled in D) else J if in -GE-, -GI, -GY and
+				 * not GG else K
+				 */
 			case 'G':
-				if( Next_Letter == 'H' ) {
-					if( !( NOGHTOF(Look_Back_Letter(3)) ||
-						   Look_Back_Letter(4) == 'H' ) ) {
+				if (Next_Letter == 'H')
+				{
+					if (!(NOGHTOF(Look_Back_Letter(3)) ||
+						  Look_Back_Letter(4) == 'H'))
+					{
 						Phonize('F');
 						skip_letter++;
 					}
-					else {
+					else
+					{
 						/* silent */
 					}
 				}
-				else if( Next_Letter == 'N' ) {
-					if( Isbreak(After_Next_Letter) ||
-						( After_Next_Letter == 'E' &&
-						  Look_Ahead_Letter(3) == 'D' ) ) {
+				else if (Next_Letter == 'N')
+				{
+					if (Isbreak(After_Next_Letter) ||
+						(After_Next_Letter == 'E' &&
+						 Look_Ahead_Letter(3) == 'D'))
+					{
 						/* dropped */
 					}
 					else
 						Phonize('K');
 				}
-				else if( MAKESOFT(Next_Letter) &&
-						 Prev_Letter != 'G' ) {
+				else if (MAKESOFT(Next_Letter) &&
+						 Prev_Letter != 'G')
 					Phonize('J');
-				}
-				else {
+				else
 					Phonize('K');
-				}
 				break;
-			/* H if before a vowel and not after C,G,P,S,T */
+				/* H if before a vowel and not after C,G,P,S,T */
 			case 'H':
-				if( isvowel(Next_Letter) &&
-					!AFFECTH(Prev_Letter) )
+				if (isvowel(Next_Letter) &&
+					!AFFECTH(Prev_Letter))
 					Phonize('H');
 				break;
-			/* dropped if after C
-			 * else K
-			 */
+
+				/*
+				 * dropped if after C else K
+				 */
 			case 'K':
-				if( Prev_Letter != 'C' )
+				if (Prev_Letter != 'C')
 					Phonize('K');
 				break;
-			/* F if before H
-			 * else P
-			 */
+
+				/*
+				 * F if before H else P
+				 */
 			case 'P':
-				if( Next_Letter == 'H' ) {
+				if (Next_Letter == 'H')
 					Phonize('F');
-				}
-				else {
+				else
 					Phonize('P');
-				}
 				break;
-			/* K
-			 */
+
+				/*
+				 * K
+				 */
 			case 'Q':
 				Phonize('K');
 				break;
-			/* 'sh' in -SH-, -SIO- or -SIA- or -SCHW-
-			 * else S
-			 */
+
+				/*
+				 * 'sh' in -SH-, -SIO- or -SIA- or -SCHW- else S
+				 */
 			case 'S':
-				if( Next_Letter == 'I' &&
-					( After_Next_Letter == 'O' ||
-					  After_Next_Letter == 'A' ) ) {
+				if (Next_Letter == 'I' &&
+					(After_Next_Letter == 'O' ||
+					 After_Next_Letter == 'A'))
 					Phonize(SH);
-				}
-				else if ( Next_Letter == 'H' ) {
+				else if (Next_Letter == 'H')
+				{
 					Phonize(SH);
 					skip_letter++;
 				}
 #ifndef USE_TRADITIONAL_METAPHONE
-				else if ( Next_Letter == 'C' &&
-					  Look_Ahead_Letter(2) == 'H' &&
-					  Look_Ahead_Letter(3) == 'W' ) {
+				else if (Next_Letter == 'C' &&
+						 Look_Ahead_Letter(2) == 'H' &&
+						 Look_Ahead_Letter(3) == 'W')
+				{
 					Phonize(SH);
 					skip_letter += 2;
 				}
 #endif
-				else {
+				else
 					Phonize('S');
-				}
 				break;
-			/* 'sh' in -TIA- or -TIO-
-			 * else 'th' before H
-			 * else T
-			 */
+
+				/*
+				 * 'sh' in -TIA- or -TIO- else 'th' before H else T
+				 */
 			case 'T':
-				if( Next_Letter == 'I' &&
-					( After_Next_Letter == 'O' ||
-					  After_Next_Letter == 'A' ) ) {
+				if (Next_Letter == 'I' &&
+					(After_Next_Letter == 'O' ||
+					 After_Next_Letter == 'A'))
 					Phonize(SH);
-				}
-				else if ( Next_Letter == 'H' ) {
+				else if (Next_Letter == 'H')
+				{
 					Phonize(TH);
 					skip_letter++;
 				}
-				else {
+				else
 					Phonize('T');
-				}
 				break;
-			/* F */
+				/* F */
 			case 'V':
 				Phonize('F');
 				break;
-			/* W before a vowel, else dropped */
+				/* W before a vowel, else dropped */
 			case 'W':
-				if( isvowel(Next_Letter) )
+				if (isvowel(Next_Letter))
 					Phonize('W');
 				break;
-			/* KS */
+				/* KS */
 			case 'X':
 				Phonize('K');
 				Phonize('S');
 				break;
-			/* Y if followed by a vowel */
+				/* Y if followed by a vowel */
 			case 'Y':
-				if( isvowel(Next_Letter) )
+				if (isvowel(Next_Letter))
 					Phonize('Y');
 				break;
-			/* S */
+				/* S */
 			case 'Z':
 				Phonize('S');
 				break;
-			/* No transformation */
+				/* No transformation */
 			case 'F':
 			case 'J':
 			case 'L':
@@ -620,15 +651,15 @@ int _metaphone (
 			default:
 				/* nothing */
 				break;
-		} /* END SWITCH */
-		
+		}						/* END SWITCH */
+
 		w_idx += skip_letter;
-	} /* END FOR */
-	
+	}							/* END FOR */
+
 	End_Phoned_Word;
-	
-	return(META_SUCCESS);
-} /* END metaphone */
+
+	return (META_SUCCESS);
+}	/* END metaphone */
 
 
 /*
diff --git a/contrib/fuzzystrmatch/fuzzystrmatch.h b/contrib/fuzzystrmatch/fuzzystrmatch.h
index 9a9be1e9a0..9c53981843 100644
--- a/contrib/fuzzystrmatch/fuzzystrmatch.h
+++ b/contrib/fuzzystrmatch/fuzzystrmatch.h
@@ -24,13 +24,13 @@
  * documentation for any purpose, without fee, and without a written agreement
  * is hereby granted, provided that the above copyright notice and this
  * paragraph and the following two paragraphs appear in all copies.
- * 
+ *
  * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
  * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
  * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
@@ -88,7 +88,7 @@ static const char *soundex_table = "01230120022455012623010202";
  */
 #define MAX_METAPHONE_STRLEN		255
 
-/* 
+/*
  * Original code by Michael G Schwern starts here.
  * Code slightly modified for use as PostgreSQL
  * function (combined *.h into here).
@@ -96,26 +96,26 @@ static const char *soundex_table = "01230120022455012623010202";
 
 /**************************************************************************
 	metaphone -- Breaks english phrases down into their phonemes.
-	
+
 	Input
-		word			-- 	An english word to be phonized
-		max_phonemes 	-- 	How many phonemes to calculate.  If 0, then it
+		word			--	An english word to be phonized
+		max_phonemes	--	How many phonemes to calculate.  If 0, then it
 							will phonize the entire phrase.
-		phoned_word  	-- 	The final phonized word.  (We'll allocate the
+		phoned_word		--	The final phonized word.  (We'll allocate the
 							memory.)
 	Output
 		error	--	A simple error flag, returns TRUE or FALSE
-		
-	NOTES:  ALL non-alpha characters are ignored, this includes whitespace,
+
+	NOTES:	ALL non-alpha characters are ignored, this includes whitespace,
 	although non-alpha characters will break up phonemes.
 ****************************************************************************/
 
 
 /**************************************************************************
 	my constants -- constants I like
-	
+
 	Probably redundant.
-	
+
 ***************************************************************************/
 
 #define META_ERROR			FALSE
@@ -123,22 +123,23 @@ static const char *soundex_table = "01230120022455012623010202";
 #define META_FAILURE		FALSE
 
 
-/*  I add modifications to the traditional metaphone algorithm that you
+/*	I add modifications to the traditional metaphone algorithm that you
 	might find in books.  Define this if you want metaphone to behave
 	traditionally */
 #undef USE_TRADITIONAL_METAPHONE
 
 /* Special encodings */
-#define  SH 	'X'
+#define  SH		'X'
 #define  TH		'0'
 
-char Lookahead(char * word, int how_far);
-int _metaphone (
-	/* IN */
-	char * 	word,
-	int 	max_phonemes,
-	/* OUT */
-	char **	phoned_word
+char		Lookahead(char *word, int how_far);
+int
+_metaphone(
+ /* IN */
+		   char *word,
+		   int max_phonemes,
+ /* OUT */
+		   char **phoned_word
 );
 
 /* Metachar.h ... little bits about characters for metaphone */
@@ -146,9 +147,9 @@ int _metaphone (
 
 /*-- Character encoding array & accessing macros --*/
 /* Stolen directly out of the book... */
-char _codes[26] = {
-	1,16,4,16,9,2,4,16,9,2,0,2,2,2,1,4,0,2,4,4,1,0,0,0,8,0
-/*  a  b c  d e f g  h i j k l m n o p q r s t u v w x y z */
+char		_codes[26] = {
+	1, 16, 4, 16, 9, 2, 4, 16, 9, 2, 0, 2, 2, 2, 1, 4, 0, 2, 4, 4, 1, 0, 0, 0, 8, 0
+/*	a  b c	d e f g  h i j k l m n o p q r s t u v w x y z */
 };
 
 
@@ -157,16 +158,15 @@ char _codes[26] = {
 #define isvowel(c)	(ENCODE(c) & 1)		/* AEIOU */
 
 /* These letters are passed through unchanged */
-#define NOCHANGE(c)	(ENCODE(c) & 2) 	/* FJMNR */
+#define NOCHANGE(c) (ENCODE(c) & 2)		/* FJMNR */
 
 /* These form dipthongs when preceding H */
-#define AFFECTH(c)	(ENCODE(c) & 4) 	/* CGPST */
+#define AFFECTH(c)	(ENCODE(c) & 4)		/* CGPST */
 
 /* These make C and G soft */
-#define MAKESOFT(c)	(ENCODE(c) & 8) 	/* EIY */
+#define MAKESOFT(c) (ENCODE(c) & 8)		/* EIY */
 
 /* These prevent GH from becoming F */
-#define NOGHTOF(c)	(ENCODE(c) & 16) 	/* BDH */
-
+#define NOGHTOF(c)	(ENCODE(c) & 16)	/* BDH */
 
 #endif	 /* FUZZYSTRMATCH_H */
diff --git a/contrib/lo/lo.c b/contrib/lo/lo.c
index 1dcdc35850..431756e9a7 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.8 2001/03/22 03:59:09 momjian Exp $
+ *	$Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.9 2001/10/25 05:49:19 momjian Exp $
  *
  */
 
@@ -33,8 +33,8 @@ typedef Oid Blob;
  */
 
 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		*/
+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		   */
 
@@ -64,7 +64,6 @@ lo_in(char *str)
 	}
 	else
 	{
-
 		/*
 		 * There is no Oid passed, so create a new one
 		 */
@@ -140,7 +139,7 @@ lo_manage(PG_FUNCTION_ARGS)
 	TupleDesc	tupdesc;		/* Tuple Descriptor				*/
 	HeapTuple	rettuple;		/* Tuple to be returned			*/
 	bool		isdelete;		/* are we deleting?				*/
-	HeapTuple	newtuple = NULL;/* The new value for tuple		*/
+	HeapTuple	newtuple = NULL;		/* The new value for tuple		*/
 	HeapTuple	trigtuple;		/* The original value of tuple	*/
 
 	if (!CALLED_AS_TRIGGER(fcinfo))
diff --git a/contrib/mSQL-interface/mpgsql.c b/contrib/mSQL-interface/mpgsql.c
index 5b35fe1638..8b59485471 100644
--- a/contrib/mSQL-interface/mpgsql.c
+++ b/contrib/mSQL-interface/mpgsql.c
@@ -229,7 +229,7 @@ msqlGetSequenceInfo(int a, char *b)
 {
 }
 
-m_field    *
+m_field *
 msqlFetchField(m_result * mr)
 {
 	m_field    *m = (m_field *) mr->fieldCursor;
@@ -242,7 +242,7 @@ msqlFetchField(m_result * mr)
 	return NULL;
 }
 
-m_result   *
+m_result *
 msqlListDBs(int a)
 {
 	m_result   *m;
@@ -256,7 +256,7 @@ msqlListDBs(int a)
 		return NULL;
 }
 
-m_result   *
+m_result *
 msqlListTables(int a)
 {
 	m_result   *m;
@@ -272,13 +272,13 @@ msqlListTables(int a)
 		return NULL;
 }
 
-m_result   *
+m_result *
 msqlListFields(int a, char *b)
 {
 
 }
 
-m_result   *
+m_result *
 msqlListIndex(int a, char *b, char *c)
 {
 	m_result   *m;
@@ -294,7 +294,7 @@ msqlListIndex(int a, char *b, char *c)
 		return NULL;
 }
 
-m_result   *
+m_result *
 msqlStoreResult(void)
 {
 	if (queryres)
diff --git a/contrib/miscutil/misc_utils.h b/contrib/miscutil/misc_utils.h
index f4577f49de..0fb07012df 100644
--- a/contrib/miscutil/misc_utils.h
+++ b/contrib/miscutil/misc_utils.h
@@ -6,5 +6,4 @@ int			unlisten(char *relname);
 int			max(int x, int y);
 int			min(int x, int y);
 int			active_listeners(text *relname);
-
 #endif
diff --git a/contrib/pg_controldata/pg_controldata.c b/contrib/pg_controldata/pg_controldata.c
index bf7209cb29..1cbd352caf 100644
--- a/contrib/pg_controldata/pg_controldata.c
+++ b/contrib/pg_controldata/pg_controldata.c
@@ -6,7 +6,7 @@
  * copyright (c) Oliver Elphick <olly@lfix.co.uk>, 2001;
  * licence: BSD
  *
- * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.4 2001/09/06 10:49:29 petere Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.5 2001/10/25 05:49:19 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";
diff --git a/contrib/pg_dumplo/lo_export.c b/contrib/pg_dumplo/lo_export.c
index ef62549791..adb216fee2 100644
--- a/contrib/pg_dumplo/lo_export.c
+++ b/contrib/pg_dumplo/lo_export.c
@@ -1,7 +1,7 @@
 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.7 2001/03/22 06:16:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.8 2001/10/25 05:49:19 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
@@ -32,14 +32,14 @@ load_lolist(LODumpMaster * pgLO)
 	int			i;
 	int			n;
 
-	/* 
+	/*
 	 * Now find any candidate tables who have columns of type oid.
 	 *
 	 * NOTE: System tables including pg_largeobject will be ignored.
 	 * Otherwise we'd end up dumping all LOs, referenced or not.
 	 *
-	 * 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.
 	 */
 	pgLO->res = PQexec(pgLO->conn,
 					   "SELECT c.relname, a.attname "
@@ -107,8 +107,7 @@ pglo_export(LODumpMaster * pgLO)
 
 	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",
diff --git a/contrib/pg_dumplo/lo_import.c b/contrib/pg_dumplo/lo_import.c
index a75e905be1..aec2aa0cee 100644
--- a/contrib/pg_dumplo/lo_import.c
+++ b/contrib/pg_dumplo/lo_import.c
@@ -1,7 +1,7 @@
 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.5 2001/03/22 06:16:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
@@ -50,7 +50,7 @@ pglo_import(LODumpMaster * pgLO)
 
 		sprintf(lo_path, "%s/%s", pgLO->space, path);
 
-		/* 
+		/*
 		 * Import LO
 		 */
 		if ((new_oid = lo_import(pgLO->conn, lo_path)) == 0)
@@ -78,7 +78,7 @@ pglo_import(LODumpMaster * pgLO)
 
 		pgLO->counter++;
 
-		/* 
+		/*
 		 * UPDATE oid in tab
 		 */
 		sprintf(Qbuff, "UPDATE \"%s\" SET \"%s\"=%u WHERE \"%s\"=%u",
diff --git a/contrib/pg_dumplo/main.c b/contrib/pg_dumplo/main.c
index 211753b605..45f5dc6312 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.8 2001/03/22 06:16:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.9 2001/10/25 05:49:19 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
@@ -152,7 +152,7 @@ main(int argc, char **argv)
 		exit(RE_ERROR);
 	}
 
-	/* 
+	/*
 	 * Check space
 	 */
 	if (!pgLO->space && !pgLO->action == ACTION_SHOW)
@@ -170,7 +170,7 @@ main(int argc, char **argv)
 		exit(RE_ERROR);
 	}
 
-	/* 
+	/*
 	 * Make connection
 	 */
 	pgLO->conn = PQsetdbLogin(pgLO->host, NULL, NULL, NULL, pgLO->db,
@@ -186,7 +186,7 @@ main(int argc, char **argv)
 	pgLO->user = PQuser(pgLO->conn);
 
 
-	/* 
+	/*
 	 * Init index file
 	 */
 	if (pgLO->action != ACTION_SHOW)
@@ -304,7 +304,6 @@ usage()
 		 "-q                           run quietly\n"
 		 "-w                           not dump, but show all LO in DB\n"
 		);						/* puts() */
-
 #endif
 
 	puts(
diff --git a/contrib/pg_dumplo/pg_dumplo.h b/contrib/pg_dumplo/pg_dumplo.h
index 3ab25495cb..1c76cfb624 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.4 2001/03/22 03:59:10 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.5 2001/10/25 05:49:19 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------
@@ -64,11 +64,11 @@ typedef struct
 
 typedef enum
 {
-	ACTION_NONE,
-	ACTION_SHOW,
-	ACTION_EXPORT_ATTR,
-	ACTION_EXPORT_ALL,
-	ACTION_IMPORT
+				ACTION_NONE,
+				ACTION_SHOW,
+				ACTION_EXPORT_ATTR,
+				ACTION_EXPORT_ALL,
+				ACTION_IMPORT
 }			PGLODUMP_ACTIONS;
 
 extern char *progname;
@@ -78,5 +78,4 @@ 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 */
diff --git a/contrib/pg_resetxlog/pg_resetxlog.c b/contrib/pg_resetxlog/pg_resetxlog.c
index 20db41ccf4..b6981345e2 100644
--- a/contrib/pg_resetxlog/pg_resetxlog.c
+++ b/contrib/pg_resetxlog/pg_resetxlog.c
@@ -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.7 2001/10/25 00:55:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.8 2001/10/25 05:49:19 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -147,7 +147,6 @@ ReadControlFile(void)
 
 	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
@@ -412,7 +411,6 @@ CheckControlVersion0(char *buffer, int len)
 						  (char *) malloc(_INTL_MAXLOGRECSZ));
 	if (record == NULL)
 	{
-
 		/*
 		 * We have to guess at the checkpoint contents.
 		 */
@@ -493,7 +491,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;
@@ -617,7 +615,6 @@ GuessControlValues(void)
 {
 #ifdef USE_LOCALE
 	char	   *localeptr;
-
 #endif
 
 	/*
diff --git a/contrib/pgbench/pgbench.c b/contrib/pgbench/pgbench.c
index 5fc18fe688..c8aa0c14b7 100644
--- a/contrib/pgbench/pgbench.c
+++ b/contrib/pgbench/pgbench.c
@@ -1,5 +1,5 @@
 /*
- * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.11 2001/10/24 08:07:22 ishii Exp $
+ * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.12 2001/10/25 05:49:19 momjian Exp $
  *
  * pgbench: a simple TPC-B like benchmark program for PostgreSQL
  * written by Tatsuo Ishii
@@ -39,7 +39,6 @@
 
 /* for getrlimit */
 #include <sys/resource.h>
-
 #endif	 /* WIN32 */
 
 /********************************************************************
@@ -67,7 +66,8 @@ int			tps = 1;
 
 int			remains;			/* number of remained clients */
 
-int			is_connect;			/* establish connection  for each transactoin */
+int			is_connect;			/* establish connection  for each
+								 * transactoin */
 
 char	   *pghost = "";
 char	   *pgport = NULL;
@@ -107,31 +107,32 @@ getrand(int min, int max)
 }
 
 /* set up a connection to the backend */
-static PGconn *doConnect()
+static PGconn *
+doConnect()
 {
-    PGconn *con;
-
-    con = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName,
-				login, pwd);
-    if (con == NULL)
-    {
-	fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
-	fprintf(stderr, "Memory allocatin problem?\n");
-	return(NULL);
-    }
-    
-    if (PQstatus(con) == CONNECTION_BAD)
-    {
-	fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
-
-	if (PQerrorMessage(con))
-	    fprintf(stderr, "%s", PQerrorMessage(con));
-	else
-	    fprintf(stderr, "No explanation from the backend\n");
+	PGconn	   *con;
+
+	con = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName,
+					   login, pwd);
+	if (con == NULL)
+	{
+		fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
+		fprintf(stderr, "Memory allocatin problem?\n");
+		return (NULL);
+	}
+
+	if (PQstatus(con) == CONNECTION_BAD)
+	{
+		fprintf(stderr, "Connection to database '%s' failed.\n", dbName);
+
+		if (PQerrorMessage(con))
+			fprintf(stderr, "%s", PQerrorMessage(con));
+		else
+			fprintf(stderr, "No explanation from the backend\n");
 
-	return(NULL);
-    }
-    return (con);
+		return (NULL);
+	}
+	return (con);
 }
 
 /* throw away response from backend */
@@ -162,7 +163,7 @@ check(CState * state, PGresult *res, int n, int good)
 		st->con = NULL;
 		return (-1);
 	}
-	return (0);	/* OK */
+	return (0);					/* OK */
 }
 
 /* process a transaction */
@@ -242,8 +243,8 @@ doOne(CState * state, int n, int debug)
 
 				if (is_connect)
 				{
-				    PQfinish(st->con);
-				    st->con = NULL;
+					PQfinish(st->con);
+					st->con = NULL;
 				}
 
 				if (++st->cnt >= nxacts)
@@ -251,8 +252,8 @@ doOne(CState * state, int n, int debug)
 					remains--;	/* I've done */
 					if (st->con != NULL)
 					{
-					    PQfinish(st->con);
-					    st->con = NULL;
+						PQfinish(st->con);
+						st->con = NULL;
 					}
 					return;
 				}
@@ -267,15 +268,15 @@ doOne(CState * state, int n, int debug)
 
 	if (st->con == NULL)
 	{
-	    if ((st->con = doConnect()) == NULL)
-	    {
-		fprintf(stderr, "Client %d aborted in establishing connection.\n",
-			n);
-		remains--;		/* I've aborted */
-		PQfinish(st->con);
-		st->con = NULL;
-		return;
-	    }
+		if ((st->con = doConnect()) == NULL)
+		{
+			fprintf(stderr, "Client %d aborted in establishing connection.\n",
+					n);
+			remains--;			/* I've aborted */
+			PQfinish(st->con);
+			st->con = NULL;
+			return;
+		}
 	}
 
 	switch (st->state)
@@ -358,8 +359,8 @@ doSelectOnly(CState * state, int n, int debug)
 
 				if (is_connect)
 				{
-				    PQfinish(st->con);
-				    st->con = NULL;
+					PQfinish(st->con);
+					st->con = NULL;
 				}
 
 				if (++st->cnt >= nxacts)
@@ -367,8 +368,8 @@ doSelectOnly(CState * state, int n, int debug)
 					remains--;	/* I've done */
 					if (st->con != NULL)
 					{
-					    PQfinish(st->con);
-					    st->con = NULL;
+						PQfinish(st->con);
+						st->con = NULL;
 					}
 					return;
 				}
@@ -383,15 +384,15 @@ doSelectOnly(CState * state, int n, int debug)
 
 	if (st->con == NULL)
 	{
-	    if ((st->con = doConnect()) == NULL)
-	    {
-		fprintf(stderr, "Client %d aborted in establishing connection.\n",
-			n);
-		remains--;		/* I've aborted */
-		PQfinish(st->con);
-		st->con = NULL;
-		return;
-	    }
+		if ((st->con = doConnect()) == NULL)
+		{
+			fprintf(stderr, "Client %d aborted in establishing connection.\n",
+					n);
+			remains--;			/* I've aborted */
+			PQfinish(st->con);
+			st->con = NULL;
+			return;
+		}
 	}
 
 	switch (st->state)
@@ -450,7 +451,7 @@ init()
 	int			i;
 
 	if ((con = doConnect()) == NULL)
-	    exit(1);
+		exit(1);
 
 	for (i = 0; i < (sizeof(DDLs) / sizeof(char *)); i++)
 	{
@@ -532,29 +533,30 @@ init()
 		if (j % 10000 == 0)
 		{
 			/*
-			 * every 10000 tuples, we commit the copy command.
-			 * this should avoid generating too much WAL logs
+			 * every 10000 tuples, we commit the copy command. this should
+			 * avoid generating too much WAL logs
 			 */
 			fprintf(stderr, "%d tuples done.\n", j);
 			if (PQputline(con, "\\.\n"))
 			{
-			    fprintf(stderr, "very last PQputline failed\n");
-			    exit(1);
+				fprintf(stderr, "very last PQputline failed\n");
+				exit(1);
 			}
 
 			if (PQendcopy(con))
 			{
-			    fprintf(stderr, "PQendcopy failed\n");
-			    exit(1);
+				fprintf(stderr, "PQendcopy failed\n");
+				exit(1);
 			}
+
 			/*
 			 * do a checkpoint to purge the old WAL logs
 			 */
 			res = PQexec(con, "checkpoint");
 			if (PQresultStatus(res) != PGRES_COMMAND_OK)
 			{
-			    fprintf(stderr, "%s", PQerrorMessage(con));
-			    exit(1);
+				fprintf(stderr, "%s", PQerrorMessage(con));
+				exit(1);
 			}
 		}
 	}
@@ -634,7 +636,6 @@ main(int argc, char **argv)
 
 #ifndef __CYGWIN__
 	struct rlimit rlim;
-
 #endif
 
 	PGconn	   *con;
@@ -691,9 +692,9 @@ main(int argc, char **argv)
 				}
 #endif	 /* #ifndef __CYGWIN__ */
 				break;
-		        case 'C':
-			      is_connect = 1;
-			      break;
+			case 'C':
+				is_connect = 1;
+				break;
 			case 's':
 				tps = atoi(optarg);
 				if (tps <= 0)
@@ -734,7 +735,7 @@ main(int argc, char **argv)
 
 	if (is_init_mode)
 	{
-	        init();
+		init();
 		exit(0);
 	}
 
@@ -749,7 +750,7 @@ main(int argc, char **argv)
 	/* opening connection... */
 	con = doConnect();
 	if (con == NULL)
-	    exit(1);
+		exit(1);
 
 	if (PQstatus(con) == CONNECTION_BAD)
 	{
@@ -836,12 +837,12 @@ main(int argc, char **argv)
 
 	if (is_connect == 0)
 	{
-	    /* make connections to the database */
-	    for (i = 0; i < nclients; i++)
-	    {
-		if ((state[i].con = doConnect()) == NULL)
-		    exit(1);
-	    }
+		/* make connections to the database */
+		for (i = 0; i < nclients; i++)
+		{
+			if ((state[i].con = doConnect()) == NULL)
+				exit(1);
+		}
 	}
 
 	/* time after connections set up */
diff --git a/contrib/pgcrypto/blf.c b/contrib/pgcrypto/blf.c
index 28d44d9de9..aae5b6033a 100644
--- a/contrib/pgcrypto/blf.c
+++ b/contrib/pgcrypto/blf.c
@@ -11,15 +11,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.
  * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Niels Provos.
+ *	  must display the following acknowledgement:
+ *		This product includes software developed by Niels Provos.
  * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
+ *	  derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
@@ -46,338 +46,354 @@
 #undef inline
 #ifdef __GNUC__
 #define inline __inline
-#else				/* !__GNUC__ */
+#else							/* !__GNUC__ */
 #define inline
-#endif				/* !__GNUC__ */
+#endif	 /* !__GNUC__ */
 
 /* Function for Feistel Networks */
 
-#define F(s, x) ((((s)[        (((x)>>24)&0xFF)]  \
+#define F(s, x) ((((s)[		   (((x)>>24)&0xFF)]  \
 		 + (s)[0x100 + (((x)>>16)&0xFF)]) \
 		 ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \
-		 + (s)[0x300 + ( (x)     &0xFF)])
+		 + (s)[0x300 + ( (x)	 &0xFF)])
 
 #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
 
 void
-Blowfish_encipher(blf_ctx *c, uint32 *x)
+Blowfish_encipher(blf_ctx * c, uint32 *x)
 {
-	uint32 Xl;
-	uint32 Xr;
-	uint32 *s = c->S[0];
-	uint32 *p = c->P;
+	uint32		Xl;
+	uint32		Xr;
+	uint32	   *s = c->S[0];
+	uint32	   *p = c->P;
 
 	Xl = x[0];
 	Xr = x[1];
 
 	Xl ^= p[0];
-	BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
-	BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
-	BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
-	BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
-	BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
-	BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
-	BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
-	BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
+	BLFRND(s, p, Xr, Xl, 1);
+	BLFRND(s, p, Xl, Xr, 2);
+	BLFRND(s, p, Xr, Xl, 3);
+	BLFRND(s, p, Xl, Xr, 4);
+	BLFRND(s, p, Xr, Xl, 5);
+	BLFRND(s, p, Xl, Xr, 6);
+	BLFRND(s, p, Xr, Xl, 7);
+	BLFRND(s, p, Xl, Xr, 8);
+	BLFRND(s, p, Xr, Xl, 9);
+	BLFRND(s, p, Xl, Xr, 10);
+	BLFRND(s, p, Xr, Xl, 11);
+	BLFRND(s, p, Xl, Xr, 12);
+	BLFRND(s, p, Xr, Xl, 13);
+	BLFRND(s, p, Xl, Xr, 14);
+	BLFRND(s, p, Xr, Xl, 15);
+	BLFRND(s, p, Xl, Xr, 16);
 
 	x[0] = Xr ^ p[17];
 	x[1] = Xl;
 }
 
 void
-Blowfish_decipher(blf_ctx *c, uint32 *x)
+Blowfish_decipher(blf_ctx * c, uint32 *x)
 {
-	uint32 Xl;
-	uint32 Xr;
-	uint32 *s = c->S[0];
-	uint32 *p = c->P;
+	uint32		Xl;
+	uint32		Xr;
+	uint32	   *s = c->S[0];
+	uint32	   *p = c->P;
 
 	Xl = x[0];
 	Xr = x[1];
 
 	Xl ^= p[17];
-	BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
-	BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
-	BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
-	BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
-	BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
-	BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
-	BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
-	BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
+	BLFRND(s, p, Xr, Xl, 16);
+	BLFRND(s, p, Xl, Xr, 15);
+	BLFRND(s, p, Xr, Xl, 14);
+	BLFRND(s, p, Xl, Xr, 13);
+	BLFRND(s, p, Xr, Xl, 12);
+	BLFRND(s, p, Xl, Xr, 11);
+	BLFRND(s, p, Xr, Xl, 10);
+	BLFRND(s, p, Xl, Xr, 9);
+	BLFRND(s, p, Xr, Xl, 8);
+	BLFRND(s, p, Xl, Xr, 7);
+	BLFRND(s, p, Xr, Xl, 6);
+	BLFRND(s, p, Xl, Xr, 5);
+	BLFRND(s, p, Xr, Xl, 4);
+	BLFRND(s, p, Xl, Xr, 3);
+	BLFRND(s, p, Xr, Xl, 2);
+	BLFRND(s, p, Xl, Xr, 1);
 
 	x[0] = Xr ^ p[0];
 	x[1] = Xl;
 }
 
 void
-Blowfish_initstate(blf_ctx *c)
+Blowfish_initstate(blf_ctx * c)
 {
 
 /* P-box and S-box tables initialized with digits of Pi */
 
 	const blf_ctx initstate =
 
-	{ {
-		{
-			0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
-			0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
-			0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
-			0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
-			0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
-			0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
-			0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
-			0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
-			0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
-			0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
-			0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
-			0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
-			0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
-			0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
-			0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
-			0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
-			0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
-			0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
-			0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
-			0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
-			0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
-			0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
-			0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
-			0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
-			0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
-			0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
-			0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
-			0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
-			0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
-			0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
-			0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
-			0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
-			0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
-			0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
-			0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
-			0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
-			0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
-			0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
-			0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
-			0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
-			0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
-			0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
-			0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
-			0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
-			0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
-			0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
-			0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
-			0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
-			0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
-			0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
-			0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
-			0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
-			0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
-			0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
-			0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
-			0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
-			0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
-			0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
-			0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
-			0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
-			0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
-			0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
-			0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
-		0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
-		{
-			0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
-			0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
-			0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
-			0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
-			0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
-			0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
-			0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
-			0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
-			0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
-			0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
-			0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
-			0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
-			0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
-			0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
-			0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
-			0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
-			0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
-			0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
-			0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
-			0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
-			0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
-			0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
-			0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
-			0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
-			0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
-			0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
-			0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
-			0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
-			0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
-			0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
-			0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
-			0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
-			0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
-			0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
-			0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
-			0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
-			0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
-			0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
-			0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
-			0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
-			0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
-			0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
-			0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
-			0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
-			0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
-			0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
-			0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
-			0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
-			0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
-			0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
-			0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
-			0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
-			0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
-			0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
-			0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
-			0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
-			0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
-			0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
-			0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
-			0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
-			0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
-			0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
-			0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
-		0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
-		{
-			0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
-			0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
-			0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
-			0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
-			0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
-			0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
-			0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
-			0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
-			0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
-			0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
-			0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
-			0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
-			0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
-			0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
-			0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
-			0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
-			0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
-			0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
-			0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
-			0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
-			0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
-			0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
-			0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
-			0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
-			0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
-			0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
-			0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
-			0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
-			0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
-			0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
-			0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
-			0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
-			0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
-			0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
-			0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
-			0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
-			0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
-			0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
-			0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
-			0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
-			0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
-			0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
-			0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
-			0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
-			0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
-			0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
-			0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
-			0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
-			0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
-			0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
-			0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
-			0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
-			0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
-			0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
-			0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
-			0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
-			0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
-			0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
-			0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
-			0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
-			0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
-			0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
-			0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
-		0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
-		{
-			0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
-			0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
-			0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
-			0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
-			0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
-			0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
-			0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
-			0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
-			0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
-			0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
-			0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
-			0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
-			0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
-			0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
-			0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
-			0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
-			0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
-			0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
-			0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
-			0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
-			0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
-			0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
-			0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
-			0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
-			0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
-			0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
-			0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
-			0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
-			0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
-			0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
-			0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
-			0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
-			0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
-			0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
-			0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
-			0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
-			0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
-			0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
-			0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
-			0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
-			0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
-			0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
-			0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
-			0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
-			0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
-			0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
-			0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
-			0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
-			0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
-			0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
-			0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
-			0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
-			0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
-			0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
-			0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
-			0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
-			0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
-			0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
-			0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
-			0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
-			0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
-			0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
-			0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
-		0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
+	{{
+			{
+				0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+				0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+				0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+				0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+				0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+				0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+				0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+				0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+				0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+				0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+				0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+				0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+				0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+				0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+				0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+				0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+				0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+				0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+				0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+				0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+				0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+				0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+				0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+				0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+				0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+				0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+				0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+				0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+				0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+				0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+				0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+				0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+				0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+				0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+				0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+				0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+				0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+				0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+				0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+				0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+				0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+				0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+				0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+				0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+				0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+				0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+				0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+				0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+				0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+				0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+				0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+				0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+				0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+				0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+				0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+				0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+				0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+				0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+				0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+				0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+				0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+				0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+				0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+			0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
+			{
+				0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+				0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+				0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+				0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+				0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+				0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+				0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+				0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+				0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+				0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+				0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+				0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+				0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+				0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+				0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+				0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+				0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+				0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+				0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+				0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+				0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+				0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+				0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+				0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+				0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+				0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+				0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+				0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+				0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+				0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+				0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+				0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+				0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+				0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+				0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+				0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+				0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+				0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+				0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+				0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+				0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+				0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+				0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+				0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+				0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+				0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+				0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+				0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+				0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+				0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+				0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+				0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+				0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+				0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+				0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+				0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+				0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+				0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+				0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+				0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+				0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+				0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+				0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+			0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
+			{
+				0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+				0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+				0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+				0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+				0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+				0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+				0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+				0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+				0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+				0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+				0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+				0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+				0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+				0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+				0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+				0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+				0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+				0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+				0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+				0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+				0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+				0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+				0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+				0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+				0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+				0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+				0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+				0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+				0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+				0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+				0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+				0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+				0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+				0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+				0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+				0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+				0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+				0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+				0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+				0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+				0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+				0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+				0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+				0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+				0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+				0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+				0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+				0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+				0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+				0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+				0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+				0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+				0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+				0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+				0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+				0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+				0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+				0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+				0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+				0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+				0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+				0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+				0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+			0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
+			{
+				0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+				0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+				0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+				0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+				0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+				0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+				0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+				0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+				0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+				0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+				0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+				0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+				0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+				0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+				0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+				0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+				0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+				0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+				0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+				0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+				0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+				0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+				0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+				0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+				0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+				0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+				0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+				0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+				0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+				0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+				0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+				0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+				0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+				0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+				0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+				0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+				0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+				0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+				0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+				0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+				0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+				0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+				0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+				0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+				0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+				0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+				0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+				0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+				0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+				0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+				0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+				0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+				0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+				0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+				0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+				0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+				0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+				0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+				0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+				0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+				0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+				0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+				0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+			0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
 	},
 	{
 		0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
@@ -385,7 +401,7 @@ Blowfish_initstate(blf_ctx *c)
 		0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
 		0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
 		0x9216d5d9, 0x8979fb1b
-	} };
+	}};
 
 	*c = initstate;
 
@@ -394,14 +410,15 @@ Blowfish_initstate(blf_ctx *c)
 uint32
 Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current)
 {
-	uint8 i;
-	uint16 j;
-	uint32 temp;
+	uint8		i;
+	uint16		j;
+	uint32		temp;
 
 	temp = 0x00000000;
 	j = *current;
 
-	for (i = 0; i < 4; i++, j++) {
+	for (i = 0; i < 4; i++, j++)
+	{
 		if (j >= databytes)
 			j = 0;
 		temp = (temp << 8) | data[j];
@@ -412,16 +429,17 @@ Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current)
 }
 
 void
-Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
+Blowfish_expand0state(blf_ctx * c, const uint8 *key, uint16 keybytes)
 {
-	uint16 i;
-	uint16 j;
-	uint16 k;
-	uint32 temp;
-	uint32 data[2];
+	uint16		i;
+	uint16		j;
+	uint16		k;
+	uint32		temp;
+	uint32		data[2];
 
 	j = 0;
-	for (i = 0; i < BLF_N + 2; i++) {
+	for (i = 0; i < BLF_N + 2; i++)
+	{
 		/* Extract 4 int8 to 1 int32 from keystream */
 		temp = Blowfish_stream2word(key, keybytes, &j);
 		c->P[i] = c->P[i] ^ temp;
@@ -430,15 +448,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
 	j = 0;
 	data[0] = 0x00000000;
 	data[1] = 0x00000000;
-	for (i = 0; i < BLF_N + 2; i += 2) {
+	for (i = 0; i < BLF_N + 2; i += 2)
+	{
 		Blowfish_encipher(c, data);
 
 		c->P[i] = data[0];
 		c->P[i + 1] = data[1];
 	}
 
-	for (i = 0; i < 4; i++) {
-		for (k = 0; k < 256; k += 2) {
+	for (i = 0; i < 4; i++)
+	{
+		for (k = 0; k < 256; k += 2)
+		{
 			Blowfish_encipher(c, data);
 
 			c->S[i][k] = data[0];
@@ -449,17 +470,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes)
 
 
 void
-Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
-		     const uint8 *key, uint16 keybytes)
+Blowfish_expandstate(blf_ctx * c, const uint8 *data, uint16 databytes,
+					 const uint8 *key, uint16 keybytes)
 {
-	uint16 i;
-	uint16 j;
-	uint16 k;
-	uint32 temp;
-	uint32 d[2];
+	uint16		i;
+	uint16		j;
+	uint16		k;
+	uint32		temp;
+	uint32		d[2];
 
 	j = 0;
-	for (i = 0; i < BLF_N + 2; i++) {
+	for (i = 0; i < BLF_N + 2; i++)
+	{
 		/* Extract 4 int8 to 1 int32 from keystream */
 		temp = Blowfish_stream2word(key, keybytes, &j);
 		c->P[i] = c->P[i] ^ temp;
@@ -468,7 +490,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
 	j = 0;
 	d[0] = 0x00000000;
 	d[1] = 0x00000000;
-	for (i = 0; i < BLF_N + 2; i += 2) {
+	for (i = 0; i < BLF_N + 2; i += 2)
+	{
 		d[0] ^= Blowfish_stream2word(data, databytes, &j);
 		d[1] ^= Blowfish_stream2word(data, databytes, &j);
 		Blowfish_encipher(c, d);
@@ -477,9 +500,11 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
 		c->P[i + 1] = d[1];
 	}
 
-	for (i = 0; i < 4; i++) {
-		for (k = 0; k < 256; k += 2) {
-			d[0]^= Blowfish_stream2word(data, databytes, &j);
+	for (i = 0; i < 4; i++)
+	{
+		for (k = 0; k < 256; k += 2)
+		{
+			d[0] ^= Blowfish_stream2word(data, databytes, &j);
 			d[1] ^= Blowfish_stream2word(data, databytes, &j);
 			Blowfish_encipher(c, d);
 
@@ -491,7 +516,7 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes,
 }
 
 void
-blf_key(blf_ctx *c, const uint8 *k, uint16 len)
+blf_key(blf_ctx * c, const uint8 *k, uint16 len)
 {
 	/* Initalize S-boxes and subkeys with Pi */
 	Blowfish_initstate(c);
@@ -501,38 +526,43 @@ blf_key(blf_ctx *c, const uint8 *k, uint16 len)
 }
 
 void
-blf_enc(blf_ctx *c, uint32 *data, uint16 blocks)
+blf_enc(blf_ctx * c, uint32 *data, uint16 blocks)
 {
-	uint32 *d;
-	uint16 i;
+	uint32	   *d;
+	uint16		i;
 
 	d = data;
-	for (i = 0; i < blocks; i++) {
+	for (i = 0; i < blocks; i++)
+	{
 		Blowfish_encipher(c, d);
 		d += 2;
 	}
 }
 
 void
-blf_dec(blf_ctx *c, uint32 *data, uint16 blocks)
+blf_dec(blf_ctx * c, uint32 *data, uint16 blocks)
 {
-	uint32 *d;
-	uint16 i;
+	uint32	   *d;
+	uint16		i;
 
 	d = data;
-	for (i = 0; i < blocks; i++) {
+	for (i = 0; i < blocks; i++)
+	{
 		Blowfish_decipher(c, d);
 		d += 2;
 	}
 }
 
 void
-blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len)
+blf_ecb_encrypt(blf_ctx * c, uint8 *data, uint32 len)
 {
-	uint32 l, r, d[2];
-	uint32 i;
+	uint32		l,
+				r,
+				d[2];
+	uint32		i;
 
-	for (i = 0; i < len; i += 8) {
+	for (i = 0; i < len; i += 8)
+	{
 		l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
 		r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
 		d[0] = l;
@@ -553,12 +583,15 @@ blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len)
 }
 
 void
-blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len)
+blf_ecb_decrypt(blf_ctx * c, uint8 *data, uint32 len)
 {
-	uint32 l, r, d[2];
-	uint32 i;
+	uint32		l,
+				r,
+				d[2];
+	uint32		i;
 
-	for (i = 0; i < len; i += 8) {
+	for (i = 0; i < len; i += 8)
+	{
 		l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
 		r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
 		d[0] = l;
@@ -579,12 +612,16 @@ blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len)
 }
 
 void
-blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len)
+blf_cbc_encrypt(blf_ctx * c, uint8 *iv, uint8 *data, uint32 len)
 {
-	uint32 l, r, d[2];
-	uint32 i, j;
+	uint32		l,
+				r,
+				d[2];
+	uint32		i,
+				j;
 
-	for (i = 0; i < len; i += 8) {
+	for (i = 0; i < len; i += 8)
+	{
 		for (j = 0; j < 8; j++)
 			data[j] ^= iv[j];
 		l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
@@ -608,15 +645,19 @@ blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len)
 }
 
 void
-blf_cbc_decrypt(blf_ctx *c, uint8 *iva, uint8 *data, uint32 len)
+blf_cbc_decrypt(blf_ctx * c, uint8 *iva, uint8 *data, uint32 len)
 {
-	uint32 l, r, d[2];
-	uint8 *iv;
-	uint32 i, j;
+	uint32		l,
+				r,
+				d[2];
+	uint8	   *iv;
+	uint32		i,
+				j;
 
 	iv = data + len - 16;
 	data = data + len - 8;
-	for (i = len - 8; i >= 8; i -= 8) {
+	for (i = len - 8; i >= 8; i -= 8)
+	{
 		l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
 		r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
 		d[0] = l;
diff --git a/contrib/pgcrypto/blf.h b/contrib/pgcrypto/blf.h
index daf9703b77..37d4021803 100644
--- a/contrib/pgcrypto/blf.h
+++ b/contrib/pgcrypto/blf.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $	*/
+/*	$OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $ */
 
 /*
  * Blowfish - a fast block cipher designed by Bruce Schneier
@@ -10,15 +10,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.
  * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Niels Provos.
+ *	  must display the following acknowledgement:
+ *		This product includes software developed by Niels Provos.
  * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
+ *	  derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
@@ -42,14 +42,15 @@
  * of the key affect all cipherbits.
  */
 
-#define BLF_N	16			/* Number of Subkeys */
-#define BLF_MAXKEYLEN ((BLF_N-2)*4)	/* 448 bits */
+#define BLF_N	16				/* Number of Subkeys */
+#define BLF_MAXKEYLEN ((BLF_N-2)*4)		/* 448 bits */
 
 /* Blowfish context */
-typedef struct BlowfishContext {
-	uint32 S[4][256];	/* S-Boxes */
-	uint32 P[BLF_N + 2];	/* Subkeys */
-} blf_ctx;
+typedef struct BlowfishContext
+{
+	uint32		S[4][256];		/* S-Boxes */
+	uint32		P[BLF_N + 2];	/* Subkeys */
+}			blf_ctx;
 
 /* Raw access to customized Blowfish
  *	blf_key is just:
@@ -57,26 +58,25 @@ typedef struct BlowfishContext {
  *	Blowfish_expand0state( state, key, keylen )
  */
 
-void Blowfish_encipher (blf_ctx *, uint32 *);
-void Blowfish_decipher (blf_ctx *, uint32 *);
-void Blowfish_initstate (blf_ctx *);
-void Blowfish_expand0state (blf_ctx *, const uint8 *, uint16);
-void Blowfish_expandstate
-    (blf_ctx *, const uint8 *, uint16, const uint8 *, uint16);
+void		Blowfish_encipher(blf_ctx *, uint32 *);
+void		Blowfish_decipher(blf_ctx *, uint32 *);
+void		Blowfish_initstate(blf_ctx *);
+void		Blowfish_expand0state(blf_ctx *, const uint8 *, uint16);
+void		Blowfish_expandstate
+			(blf_ctx *, const uint8 *, uint16, const uint8 *, uint16);
 
 /* Standard Blowfish */
 
-void blf_key (blf_ctx *, const uint8 *, uint16);
-void blf_enc (blf_ctx *, uint32 *, uint16);
-void blf_dec (blf_ctx *, uint32 *, uint16);
+void		blf_key(blf_ctx *, const uint8 *, uint16);
+void		blf_enc(blf_ctx *, uint32 *, uint16);
+void		blf_dec(blf_ctx *, uint32 *, uint16);
 
 /* Converts uint8 to uint32 */
-uint32 Blowfish_stream2word (const uint8 *, uint16, uint16 *);
+uint32		Blowfish_stream2word(const uint8 *, uint16, uint16 *);
 
-void blf_ecb_encrypt (blf_ctx *, uint8 *, uint32);
-void blf_ecb_decrypt (blf_ctx *, uint8 *, uint32);
-
-void blf_cbc_encrypt (blf_ctx *, uint8 *, uint8 *, uint32);
-void blf_cbc_decrypt (blf_ctx *, uint8 *, uint8 *, uint32);
+void		blf_ecb_encrypt(blf_ctx *, uint8 *, uint32);
+void		blf_ecb_decrypt(blf_ctx *, uint8 *, uint32);
 
+void		blf_cbc_encrypt(blf_ctx *, uint8 *, uint8 *, uint32);
+void		blf_cbc_decrypt(blf_ctx *, uint8 *, uint8 *, uint32);
 #endif
diff --git a/contrib/pgcrypto/crypt-blowfish.c b/contrib/pgcrypto/crypt-blowfish.c
index d60807f241..3bc8e19fa9 100644
--- a/contrib/pgcrypto/crypt-blowfish.c
+++ b/contrib/pgcrypto/crypt-blowfish.c
@@ -57,10 +57,11 @@ typedef unsigned int BF_word;
 
 typedef BF_word BF_key[BF_N + 2];
 
-typedef struct {
-	BF_word S[4][0x100];
-	BF_key P;
-} BF_ctx;
+typedef struct
+{
+	BF_word		S[4][0x100];
+	BF_key		P;
+}			BF_ctx;
 
 /*
  * Magic IV for 64 Blowfish encryptions that we do at the end.
@@ -347,7 +348,7 @@ static BF_ctx BF_init_state = {
 };
 
 static unsigned char BF_itoa64[64 + 1] =
-	"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 
 static unsigned char BF_atoi64[0x60] = {
 	64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1,
@@ -367,22 +368,30 @@ do { \
 	(dst) = tmp; \
 } while (0)
 
-static int BF_decode(BF_word *dst, const char *src, int size)
+static int
+BF_decode(BF_word * dst, const char *src, int size)
 {
-	unsigned char *dptr = (unsigned char *)dst;
+	unsigned char *dptr = (unsigned char *) dst;
 	unsigned char *end = dptr + size;
-	unsigned char *sptr = (unsigned char *)src;
-	unsigned int tmp, c1, c2, c3, c4;
-
-	do {
+	unsigned char *sptr = (unsigned char *) src;
+	unsigned int tmp,
+				c1,
+				c2,
+				c3,
+				c4;
+
+	do
+	{
 		BF_safe_atoi64(c1, *sptr++);
 		BF_safe_atoi64(c2, *sptr++);
 		*dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);
-		if (dptr >= end) break;
+		if (dptr >= end)
+			break;
 
 		BF_safe_atoi64(c3, *sptr++);
 		*dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2);
-		if (dptr >= end) break;
+		if (dptr >= end)
+			break;
 
 		BF_safe_atoi64(c4, *sptr++);
 		*dptr++ = ((c3 & 0x03) << 6) | c4;
@@ -391,18 +400,22 @@ static int BF_decode(BF_word *dst, const char *src, int size)
 	return 0;
 }
 
-static void BF_encode(char *dst, const BF_word *src, int size)
+static void
+BF_encode(char *dst, const BF_word * src, int size)
 {
-	unsigned char *sptr = (unsigned char *)src;
+	unsigned char *sptr = (unsigned char *) src;
 	unsigned char *end = sptr + size;
-	unsigned char *dptr = (unsigned char *)dst;
-	unsigned int c1, c2;
+	unsigned char *dptr = (unsigned char *) dst;
+	unsigned int c1,
+				c2;
 
-	do {
+	do
+	{
 		c1 = *sptr++;
 		*dptr++ = BF_itoa64[c1 >> 2];
 		c1 = (c1 & 0x03) << 4;
-		if (sptr >= end) {
+		if (sptr >= end)
+		{
 			*dptr++ = BF_itoa64[c1];
 			break;
 		}
@@ -411,7 +424,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
 		c1 |= c2 >> 4;
 		*dptr++ = BF_itoa64[c1];
 		c1 = (c2 & 0x0f) << 2;
-		if (sptr >= end) {
+		if (sptr >= end)
+		{
 			*dptr++ = BF_itoa64[c1];
 			break;
 		}
@@ -423,18 +437,20 @@ static void BF_encode(char *dst, const BF_word *src, int size)
 	} while (sptr < end);
 }
 
-static void BF_swap(BF_word *x, int count)
+static void
+BF_swap(BF_word * x, int count)
 {
-	static int endianness_check = 1;
-	char *is_little_endian = (char *)&endianness_check;
-	BF_word tmp;
+	static int	endianness_check = 1;
+	char	   *is_little_endian = (char *) &endianness_check;
+	BF_word		tmp;
 
 	if (*is_little_endian)
-	do {
-		tmp = *x;
-		tmp = (tmp << 16) | (tmp >> 16);
-		*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
-	} while (--count);
+		do
+		{
+			tmp = *x;
+			tmp = (tmp << 16) | (tmp >> 16);
+			*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
+		} while (--count);
 }
 
 #if BF_SCALE
@@ -504,7 +520,8 @@ static void BF_swap(BF_word *x, int count)
 
 #if BF_ASM
 
-extern void _BF_body_r(BF_ctx *ctx);
+extern void _BF_body_r(BF_ctx * ctx);
+
 #define BF_body() \
 	_BF_body_r(&data.ctx);
 
@@ -527,22 +544,28 @@ extern void _BF_body_r(BF_ctx *ctx);
 		*(ptr - 2) = L; \
 		*(ptr - 1) = R; \
 	} while (ptr < &data.ctx.S[3][0xFF]);
-
 #endif
 
-static void BF_set_key(const char *key, BF_key expanded, BF_key initial)
+static void
+BF_set_key(const char *key, BF_key expanded, BF_key initial)
 {
 	const char *ptr = key;
-	int i, j;
-	BF_word tmp;
+	int			i,
+				j;
+	BF_word		tmp;
 
-	for (i = 0; i < BF_N + 2; i++) {
+	for (i = 0; i < BF_N + 2; i++)
+	{
 		tmp = 0;
-		for (j = 0; j < 4; j++) {
+		for (j = 0; j < 4; j++)
+		{
 			tmp <<= 8;
 			tmp |= *ptr;
 
-			if (!*ptr) ptr = key; else ptr++;
+			if (!*ptr)
+				ptr = key;
+			else
+				ptr++;
 		}
 
 		expanded[i] = tmp;
@@ -550,41 +573,51 @@ static void BF_set_key(const char *key, BF_key expanded, BF_key initial)
 	}
 }
 
-char *_crypt_blowfish_rn(const char *key, const char *setting,
-	char *output, int size)
+char *
+_crypt_blowfish_rn(const char *key, const char *setting,
+				   char *output, int size)
 {
-	struct {
-		BF_ctx ctx;
-		BF_key expanded_key;
-		union {
-			BF_word salt[4];
-			BF_word output[6];
-		} binary;
-	} data;
-	BF_word L, R;
-	BF_word tmp1, tmp2, tmp3, tmp4;
-	BF_word *ptr;
-	BF_word count;
-	int i;
-
-	if (size < 7 + 22 + 31 + 1) {
+	struct
+	{
+		BF_ctx		ctx;
+		BF_key		expanded_key;
+		union
+		{
+			BF_word		salt[4];
+			BF_word		output[6];
+		}			binary;
+	}			data;
+	BF_word		L,
+				R;
+	BF_word		tmp1,
+				tmp2,
+				tmp3,
+				tmp4;
+	BF_word    *ptr;
+	BF_word		count;
+	int			i;
+
+	if (size < 7 + 22 + 31 + 1)
+	{
 		__set_errno(ERANGE);
 		return NULL;
 	}
 
 	if (setting[0] != '$' ||
-	    setting[1] != '2' ||
-	    setting[2] != 'a' ||
-	    setting[3] != '$' ||
-	    setting[4] < '0' || setting[4] > '3' ||
-	    setting[5] < '0' || setting[5] > '9' ||
-	    setting[6] != '$') {
+		setting[1] != '2' ||
+		setting[2] != 'a' ||
+		setting[3] != '$' ||
+		setting[4] < '0' || setting[4] > '3' ||
+		setting[5] < '0' || setting[5] > '9' ||
+		setting[6] != '$')
+	{
 		__set_errno(EINVAL);
 		return NULL;
 	}
 
-	count = (BF_word)1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
-	if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16)) {
+	count = (BF_word) 1 << ((setting[4] - '0') * 10 + (setting[5] - '0'));
+	if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16))
+	{
 		memset(data.binary.salt, 0, sizeof(data.binary.salt));
 		__set_errno(EINVAL);
 		return NULL;
@@ -596,7 +629,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
 	memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S));
 
 	L = R = 0;
-	for (i = 0; i < BF_N + 2; i += 2) {
+	for (i = 0; i < BF_N + 2; i += 2)
+	{
 		L ^= data.binary.salt[i & 2];
 		R ^= data.binary.salt[(i & 2) + 1];
 		BF_ENCRYPT;
@@ -605,7 +639,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
 	}
 
 	ptr = data.ctx.S[0];
-	do {
+	do
+	{
 		ptr += 4;
 		L ^= data.binary.salt[(BF_N + 2) & 3];
 		R ^= data.binary.salt[(BF_N + 3) & 3];
@@ -620,7 +655,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
 		*(ptr - 1) = R;
 	} while (ptr < &data.ctx.S[3][0xFF]);
 
-	do {
+	do
+	{
 		data.ctx.P[0] ^= data.expanded_key[0];
 		data.ctx.P[1] ^= data.expanded_key[1];
 		data.ctx.P[2] ^= data.expanded_key[2];
@@ -668,12 +704,14 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
 		BF_body();
 	} while (--count);
 
-	for (i = 0; i < 6; i += 2) {
+	for (i = 0; i < 6; i += 2)
+	{
 		L = BF_magic_w[i];
 		R = BF_magic_w[i + 1];
 
 		count = 64;
-		do {
+		do
+		{
 			BF_ENCRYPT;
 		} while (--count);
 
@@ -683,7 +721,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
 
 	memcpy(output, setting, 7 + 22 - 1);
 	output[7 + 22 - 1] = BF_itoa64[(int)
-		BF_atoi64[(int)setting[7 + 22 - 1] - 0x20] & 0x30];
+					 BF_atoi64[(int) setting[7 + 22 - 1] - 0x20] & 0x30];
 
 /* This has to be bug-compatible with the original implementation, so
  * only encode 23 of the 24 bytes. :-) */
@@ -698,4 +736,3 @@ char *_crypt_blowfish_rn(const char *key, const char *setting,
 
 	return output;
 }
-
diff --git a/contrib/pgcrypto/crypt-des.c b/contrib/pgcrypto/crypt-des.c
index de6b1865e3..eacb192ad0 100644
--- a/contrib/pgcrypto/crypt-des.c
+++ b/contrib/pgcrypto/crypt-des.c
@@ -244,8 +244,8 @@ des_init()
 		}
 
 	/*
-	 * Convert the inverted S-boxes into 4 arrays of 8 bits.
-	 * Each will handle 12 bits of the S-box input.
+	 * Convert the inverted S-boxes into 4 arrays of 8 bits. Each will
+	 * handle 12 bits of the S-box input.
 	 */
 	for (b = 0; b < 4; b++)
 		for (i = 0; i < 64; i++)
@@ -409,10 +409,9 @@ des_setkey(const char *key)
 		&& rawkey1 == old_rawkey1)
 	{
 		/*
-		 * Already setup for this key.
-		 * This optimisation fails on a zero key (which is weak and
-		 * has bad parity anyway) in order to simplify the starting
-		 * conditions.
+		 * Already setup for this key. This optimisation fails on a zero
+		 * key (which is weak and has bad parity anyway) in order to
+		 * simplify the starting conditions.
 		 */
 		return (0);
 	}
@@ -420,7 +419,7 @@ des_setkey(const char *key)
 	old_rawkey1 = rawkey1;
 
 	/*
-	 *	Do key permutation and split into two 28-bit subkeys.
+	 * Do key permutation and split into two 28-bit subkeys.
 	 */
 	k0 = key_perm_maskl[0][rawkey0 >> 25]
 		| key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
@@ -438,8 +437,9 @@ des_setkey(const char *key)
 		| key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
 		| key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
 		| key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
+
 	/*
-	 *	Rotate subkeys and do compression permutation.
+	 * Rotate subkeys and do compression permutation.
 	 */
 	shifts = 0;
 	for (round = 0; round < 16; round++)
@@ -476,10 +476,10 @@ des_setkey(const char *key)
 }
 
 static int
-do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
+do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count)
 {
 	/*
-	 *	l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
+	 * l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
 	 */
 	uint32		l,
 				r,
@@ -513,7 +513,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
 	}
 
 	/*
-	 *	Do initial permutation (IP).
+	 * Do initial permutation (IP).
 	 */
 	l = ip_maskl[0][l_in >> 24]
 		| ip_maskl[1][(l_in >> 16) & 0xff]
@@ -556,21 +556,24 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
 				| ((r & 0x000001f8) << 3)
 				| ((r & 0x0000001f) << 1)
 				| ((r & 0x80000000) >> 31);
+
 			/*
-			 * Do salting for crypt() and friends, and
-			 * XOR with the permuted key.
+			 * Do salting for crypt() and friends, and XOR with the
+			 * permuted key.
 			 */
 			f = (r48l ^ r48r) & saltbits;
 			r48l ^= f ^ *kl++;
 			r48r ^= f ^ *kr++;
+
 			/*
-			 * Do sbox lookups (which shrink it back to 32 bits)
-			 * and do the pbox permutation at the same time.
+			 * Do sbox lookups (which shrink it back to 32 bits) and do
+			 * the pbox permutation at the same time.
 			 */
 			f = psbox[0][m_sbox[0][r48l >> 12]]
 				| psbox[1][m_sbox[1][r48l & 0xfff]]
 				| psbox[2][m_sbox[2][r48r >> 12]]
 				| psbox[3][m_sbox[3][r48r & 0xfff]];
+
 			/*
 			 * Now that we've permuted things, complete f().
 			 */
@@ -581,6 +584,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count)
 		r = l;
 		l = f;
 	}
+
 	/*
 	 * Do final permutation (inverse of IP).
 	 */
@@ -654,8 +658,8 @@ px_crypt_des(const char *key, const char *setting)
 
 
 	/*
-	 * Copy the key, shifting each character up by one bit
-	 * and padding with zeros.
+	 * Copy the key, shifting each character up by one bit and padding
+	 * with zeros.
 	 */
 	q = (uint8 *) keybuf;
 	while (q - (uint8 *) keybuf - 8)
@@ -670,9 +674,8 @@ px_crypt_des(const char *key, const char *setting)
 	if (*setting == _PASSWORD_EFMT1)
 	{
 		/*
-		 * "new"-style:
-		 *	setting - underscore, 4 bytes of count, 4 bytes of salt
-		 *	key - unlimited characters
+		 * "new"-style: setting - underscore, 4 bytes of count, 4 bytes of
+		 * salt key - unlimited characters
 		 */
 		for (i = 1, count = 0L; i < 5; i++)
 			count |= ascii_to_bin(setting[i]) << (i - 1) * 6;
@@ -687,6 +690,7 @@ px_crypt_des(const char *key, const char *setting)
 			 */
 			if (des_cipher((uint8 *) keybuf, (uint8 *) keybuf, 0L, 1))
 				return (NULL);
+
 			/*
 			 * And XOR with the next 8 characters of the key.
 			 */
@@ -700,11 +704,10 @@ px_crypt_des(const char *key, const char *setting)
 		strncpy(output, setting, 9);
 
 		/*
-		 * Double check that we weren't given a short setting.
-		 * If we were, the above code will probably have created
-		 * wierd values for count and salt, but we don't really care.
-		 * Just make sure the output string doesn't have an extra
-		 * NUL in it.
+		 * Double check that we weren't given a short setting. If we were,
+		 * the above code will probably have created wierd values for
+		 * count and salt, but we don't really care. Just make sure the
+		 * output string doesn't have an extra NUL in it.
 		 */
 		output[9] = '\0';
 		p = output + strlen(output);
@@ -713,9 +716,7 @@ px_crypt_des(const char *key, const char *setting)
 #endif	 /* !DISABLE_XDES */
 	{
 		/*
-		 * "old"-style:
-		 *	setting - 2 bytes of salt
-		 *	key - up to 8 characters
+		 * "old"-style: setting - 2 bytes of salt key - up to 8 characters
 		 */
 		count = 25;
 
@@ -723,22 +724,24 @@ px_crypt_des(const char *key, const char *setting)
 			| ascii_to_bin(setting[0]);
 
 		output[0] = setting[0];
+
 		/*
-		 * If the encrypted password that the salt was extracted from
-		 * is only 1 character long, the salt will be corrupted.  We
-		 * need to ensure that the output string doesn't have an extra
-		 * NUL in it!
+		 * If the encrypted password that the salt was extracted from is
+		 * only 1 character long, the salt will be corrupted.  We need to
+		 * ensure that the output string doesn't have an extra NUL in it!
 		 */
 		output[1] = setting[1] ? setting[1] : output[0];
 
 		p = output + 2;
 	}
 	setup_salt(salt);
+
 	/*
 	 * Do it.
 	 */
 	if (do_des(0L, 0L, &r0, &r1, count))
 		return (NULL);
+
 	/*
 	 * Now encode the result...
 	 */
diff --git a/contrib/pgcrypto/crypt-gensalt.c b/contrib/pgcrypto/crypt-gensalt.c
index 6913826842..9c017b0e4d 100644
--- a/contrib/pgcrypto/crypt-gensalt.c
+++ b/contrib/pgcrypto/crypt-gensalt.c
@@ -7,7 +7,7 @@
  * entirely in crypt_blowfish.c.
  *
  * Put bcrypt generator also here as crypt-blowfish.c
- * may not be compiled always.        -- marko
+ * may not be compiled always.		  -- marko
  */
 
 #include "postgres.h"
@@ -22,48 +22,55 @@
 typedef unsigned int BF_word;
 
 unsigned char _crypt_itoa64[64 + 1] =
-	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
-char *_crypt_gensalt_traditional_rn(unsigned long count,
-	const char *input, int size, char *output, int output_size)
+char *
+_crypt_gensalt_traditional_rn(unsigned long count,
+			  const char *input, int size, char *output, int output_size)
 {
-	if (size < 2 || output_size < 2 + 1 || (count && count != 25)) {
-		if (output_size > 0) output[0] = '\0';
+	if (size < 2 || output_size < 2 + 1 || (count && count != 25))
+	{
+		if (output_size > 0)
+			output[0] = '\0';
 		__set_errno((output_size < 2 + 1) ? ERANGE : EINVAL);
 		return NULL;
 	}
 
-	output[0] = _crypt_itoa64[(unsigned int)input[0] & 0x3f];
-	output[1] = _crypt_itoa64[(unsigned int)input[1] & 0x3f];
+	output[0] = _crypt_itoa64[(unsigned int) input[0] & 0x3f];
+	output[1] = _crypt_itoa64[(unsigned int) input[1] & 0x3f];
 	output[2] = '\0';
 
 	return output;
 }
 
-char *_crypt_gensalt_extended_rn(unsigned long count,
-	const char *input, int size, char *output, int output_size)
+char *
+_crypt_gensalt_extended_rn(unsigned long count,
+			  const char *input, int size, char *output, int output_size)
 {
 	unsigned long value;
 
 /* Even iteration counts make it easier to detect weak DES keys from a look
  * at the hash, so they should be avoided */
 	if (size < 3 || output_size < 1 + 4 + 4 + 1 ||
-	    (count && (count > 0xffffff || !(count & 1)))) {
-		if (output_size > 0) output[0] = '\0';
+		(count && (count > 0xffffff || !(count & 1))))
+	{
+		if (output_size > 0)
+			output[0] = '\0';
 		__set_errno((output_size < 1 + 4 + 4 + 1) ? ERANGE : EINVAL);
 		return NULL;
 	}
 
-	if (!count) count = 725;
+	if (!count)
+		count = 725;
 
 	output[0] = '_';
 	output[1] = _crypt_itoa64[count & 0x3f];
 	output[2] = _crypt_itoa64[(count >> 6) & 0x3f];
 	output[3] = _crypt_itoa64[(count >> 12) & 0x3f];
 	output[4] = _crypt_itoa64[(count >> 18) & 0x3f];
-	value = (unsigned long)input[0] |
-		((unsigned long)input[1] << 8) |
-		((unsigned long)input[2] << 16);
+	value = (unsigned long) input[0] |
+		((unsigned long) input[1] << 8) |
+		((unsigned long) input[2] << 16);
 	output[5] = _crypt_itoa64[value & 0x3f];
 	output[6] = _crypt_itoa64[(value >> 6) & 0x3f];
 	output[7] = _crypt_itoa64[(value >> 12) & 0x3f];
@@ -73,13 +80,16 @@ char *_crypt_gensalt_extended_rn(unsigned long count,
 	return output;
 }
 
-char *_crypt_gensalt_md5_rn(unsigned long count,
-	const char *input, int size, char *output, int output_size)
+char *
+_crypt_gensalt_md5_rn(unsigned long count,
+			  const char *input, int size, char *output, int output_size)
 {
 	unsigned long value;
 
-	if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) {
-		if (output_size > 0) output[0] = '\0';
+	if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000))
+	{
+		if (output_size > 0)
+			output[0] = '\0';
 		__set_errno((output_size < 3 + 4 + 1) ? ERANGE : EINVAL);
 		return NULL;
 	}
@@ -87,19 +97,20 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
 	output[0] = '$';
 	output[1] = '1';
 	output[2] = '$';
-	value = (unsigned long)input[0] |
-		((unsigned long)input[1] << 8) |
-		((unsigned long)input[2] << 16);
+	value = (unsigned long) input[0] |
+		((unsigned long) input[1] << 8) |
+		((unsigned long) input[2] << 16);
 	output[3] = _crypt_itoa64[value & 0x3f];
 	output[4] = _crypt_itoa64[(value >> 6) & 0x3f];
 	output[5] = _crypt_itoa64[(value >> 12) & 0x3f];
 	output[6] = _crypt_itoa64[(value >> 18) & 0x3f];
 	output[7] = '\0';
 
-	if (size >= 6 && output_size >= 3 + 4 + 4 + 1) {
-		value = (unsigned long)input[3] |
-			((unsigned long)input[4] << 8) |
-			((unsigned long)input[5] << 16);
+	if (size >= 6 && output_size >= 3 + 4 + 4 + 1)
+	{
+		value = (unsigned long) input[3] |
+			((unsigned long) input[4] << 8) |
+			((unsigned long) input[5] << 16);
 		output[7] = _crypt_itoa64[value & 0x3f];
 		output[8] = _crypt_itoa64[(value >> 6) & 0x3f];
 		output[9] = _crypt_itoa64[(value >> 12) & 0x3f];
@@ -113,20 +124,24 @@ char *_crypt_gensalt_md5_rn(unsigned long count,
 
 
 static unsigned char BF_itoa64[64 + 1] =
-	"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 
-static void BF_encode(char *dst, const BF_word *src, int size)
+static void
+BF_encode(char *dst, const BF_word * src, int size)
 {
-	unsigned char *sptr = (unsigned char *)src;
+	unsigned char *sptr = (unsigned char *) src;
 	unsigned char *end = sptr + size;
-	unsigned char *dptr = (unsigned char *)dst;
-	unsigned int c1, c2;
+	unsigned char *dptr = (unsigned char *) dst;
+	unsigned int c1,
+				c2;
 
-	do {
+	do
+	{
 		c1 = *sptr++;
 		*dptr++ = BF_itoa64[c1 >> 2];
 		c1 = (c1 & 0x03) << 4;
-		if (sptr >= end) {
+		if (sptr >= end)
+		{
 			*dptr++ = BF_itoa64[c1];
 			break;
 		}
@@ -135,7 +150,8 @@ static void BF_encode(char *dst, const BF_word *src, int size)
 		c1 |= c2 >> 4;
 		*dptr++ = BF_itoa64[c1];
 		c1 = (c2 & 0x0f) << 2;
-		if (sptr >= end) {
+		if (sptr >= end)
+		{
 			*dptr++ = BF_itoa64[c1];
 			break;
 		}
@@ -147,17 +163,21 @@ static void BF_encode(char *dst, const BF_word *src, int size)
 	} while (sptr < end);
 }
 
-char *_crypt_gensalt_blowfish_rn(unsigned long count,
-	const char *input, int size, char *output, int output_size)
+char *
+_crypt_gensalt_blowfish_rn(unsigned long count,
+			  const char *input, int size, char *output, int output_size)
 {
 	if (size < 16 || output_size < 7 + 22 + 1 ||
-	    (count && (count < 4 || count > 31))) {
-		if (output_size > 0) output[0] = '\0';
+		(count && (count < 4 || count > 31)))
+	{
+		if (output_size > 0)
+			output[0] = '\0';
 		__set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL);
 		return NULL;
 	}
 
-	if (!count) count = 5;
+	if (!count)
+		count = 5;
 
 	output[0] = '$';
 	output[1] = '2';
@@ -167,9 +187,8 @@ char *_crypt_gensalt_blowfish_rn(unsigned long count,
 	output[5] = '0' + count % 10;
 	output[6] = '$';
 
-	BF_encode(&output[7], (BF_word *)input, 16);
+	BF_encode(&output[7], (BF_word *) input, 16);
 	output[7 + 22] = '\0';
 
 	return output;
 }
-
diff --git a/contrib/pgcrypto/crypt-md5.c b/contrib/pgcrypto/crypt-md5.c
index 02fba69496..7b45bb2151 100644
--- a/contrib/pgcrypto/crypt-md5.c
+++ b/contrib/pgcrypto/crypt-md5.c
@@ -9,7 +9,7 @@
  * $FreeBSD: src/lib/libcrypt/crypt-md5.c,v 1.5 1999/12/17 20:21:45 peter Exp $
  *
  */
-/* $Id: crypt-md5.c,v 1.1 2001/08/21 01:32:01 momjian Exp $ */
+/* $Id: crypt-md5.c,v 1.2 2001/10/25 05:49:19 momjian Exp $ */
 
 #include <postgres.h>
 #include "px.h"
@@ -23,12 +23,9 @@
 char *
 px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
 {
-	static char *magic = "$1$"; /*
-					 * This string is magic for
-					 * this algorithm.	Having
-					 * it this way, we can get
-					 * get better later on
-					 */
+	static char *magic = "$1$"; /* This string is magic for this
+								 * algorithm.  Having it this way, we can
+								 * get get better later on */
 	static char *p;
 	static const char *sp,
 			   *ep;
@@ -43,7 +40,7 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
 
 	if (!passwd || dstlen < 120)
 		return NULL;
-	
+
 	/* Refine the Salt first */
 	sp = salt;
 
@@ -99,9 +96,9 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen)
 	px_md_finish(ctx, final);
 
 	/*
-	 * and now, just to make sure things don't run too fast
-	 * On a 60 Mhz Pentium this takes 34 msec, so you would
-	 * need 30 seconds to build a 1000 entry dictionary...
+	 * and now, just to make sure things don't run too fast On a 60 Mhz
+	 * Pentium this takes 34 msec, so you would need 30 seconds to build a
+	 * 1000 entry dictionary...
 	 */
 	for (i = 0; i < 1000; i++)
 	{
diff --git a/contrib/pgcrypto/internal.c b/contrib/pgcrypto/internal.c
index 421f5f1739..00ff81e5b7 100644
--- a/contrib/pgcrypto/internal.c
+++ b/contrib/pgcrypto/internal.c
@@ -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.5 2001/10/15 19:12:48 tgl Exp $
+ * $Id: internal.c,v 1.6 2001/10/25 05:49:19 momjian Exp $
  */
 
 
@@ -61,11 +61,18 @@ static struct int_digest
 {
 	char	   *name;
 	void		(*init) (PX_MD * h);
-} int_digest_list[] =
+}			int_digest_list[] =
+
 {
-	{ "md5", init_md5 },
-	{ "sha1", init_sha1 },
-	{ NULL, NULL }
+	{
+		"md5", init_md5
+	},
+	{
+		"sha1", init_sha1
+	},
+	{
+		NULL, NULL
+	}
 };