Standard pgindent run for 8.1.

770 files changed, 33742 insertions, 31915 deletions

diff --git a/contrib/btree_gist/btree_cash.c b/contrib/btree_gist/btree_cash.c
index cef6103734..13f8200fb7 100644
--- a/contrib/btree_gist/btree_cash.c
+++ b/contrib/btree_gist/btree_cash.c
@@ -125,10 +125,10 @@ Datum
 gbt_cash_penalty(PG_FUNCTION_ARGS)
 {
 	cashKEY    *origentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
-	cashKEY    *newentry  = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
-	float	      *result = (float *) PG_GETARG_POINTER(2);
+	cashKEY    *newentry = (cashKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
 
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 
 	PG_RETURN_POINTER(result);
 
@@ -138,8 +138,8 @@ Datum
 gbt_cash_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_date.c b/contrib/btree_gist/btree_date.c
index d3ce33c717..b14888889d 100644
--- a/contrib/btree_gist/btree_date.c
+++ b/contrib/btree_gist/btree_date.c
@@ -148,15 +148,15 @@ gbt_date_penalty(PG_FUNCTION_ARGS)
 
 	diff = DatumGetInt32(DirectFunctionCall2(
 											 date_mi,
-										DateADTGetDatum(newentry->upper),
-									 DateADTGetDatum(origentry->upper)));
+											 DateADTGetDatum(newentry->upper),
+										 DateADTGetDatum(origentry->upper)));
 
 	res = Max(diff, 0);
 
 	diff = DatumGetInt32(DirectFunctionCall2(
 											 date_mi,
-									   DateADTGetDatum(origentry->lower),
-									  DateADTGetDatum(newentry->lower)));
+										   DateADTGetDatum(origentry->lower),
+										  DateADTGetDatum(newentry->lower)));
 
 	res += Max(diff, 0);
 
@@ -166,8 +166,8 @@ gbt_date_penalty(PG_FUNCTION_ARGS)
 	{
 		diff = DatumGetInt32(DirectFunctionCall2(
 												 date_mi,
-									   DateADTGetDatum(origentry->upper),
-									 DateADTGetDatum(origentry->lower)));
+										   DateADTGetDatum(origentry->upper),
+										 DateADTGetDatum(origentry->lower)));
 		*result += FLT_MIN;
 		*result += (float) (res / ((double) (res + diff)));
 		*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
@@ -181,8 +181,8 @@ Datum
 gbt_date_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_float4.c b/contrib/btree_gist/btree_float4.c
index 9d6c174773..a4c941f835 100644
--- a/contrib/btree_gist/btree_float4.c
+++ b/contrib/btree_gist/btree_float4.c
@@ -127,7 +127,7 @@ gbt_float4_penalty(PG_FUNCTION_ARGS)
 	float4KEY  *newentry = (float4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 	float	   *result = (float *) PG_GETARG_POINTER(2);
 
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 
 	PG_RETURN_POINTER(result);
 
@@ -137,8 +137,8 @@ Datum
 gbt_float4_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_float8.c b/contrib/btree_gist/btree_float8.c
index 7345d37b21..1b87b4ee1b 100644
--- a/contrib/btree_gist/btree_float8.c
+++ b/contrib/btree_gist/btree_float8.c
@@ -129,7 +129,7 @@ gbt_float8_penalty(PG_FUNCTION_ARGS)
 	float8KEY  *newentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 	float	   *result = (float *) PG_GETARG_POINTER(2);
 
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 
 	PG_RETURN_POINTER(result);
 
@@ -139,8 +139,8 @@ Datum
 gbt_float8_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_inet.c b/contrib/btree_gist/btree_inet.c
index 3719d3bb1a..5f27a007f5 100644
--- a/contrib/btree_gist/btree_inet.c
+++ b/contrib/btree_gist/btree_inet.c
@@ -194,8 +194,8 @@ gbt_inet_penalty(PG_FUNCTION_ARGS)
 	inetKEY    *newentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 	float	   *result = (float *) PG_GETARG_POINTER(2);
 
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
-	
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
+
 	PG_RETURN_POINTER(result);
 
 }
@@ -204,8 +204,8 @@ Datum
 gbt_inet_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_int2.c b/contrib/btree_gist/btree_int2.c
index 8bbdb1d802..5e2a66526e 100644
--- a/contrib/btree_gist/btree_int2.c
+++ b/contrib/btree_gist/btree_int2.c
@@ -128,10 +128,10 @@ Datum
 gbt_int2_penalty(PG_FUNCTION_ARGS)
 {
 	int16KEY   *origentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
-	int16KEY    *newentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
-	float	      *result = (float *) PG_GETARG_POINTER(2);
+	int16KEY   *newentry = (int16KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
 
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 
 	PG_RETURN_POINTER(result);
 }
@@ -140,8 +140,8 @@ Datum
 gbt_int2_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_int4.c b/contrib/btree_gist/btree_int4.c
index 43a4cbe6be..6a69b85bdd 100644
--- a/contrib/btree_gist/btree_int4.c
+++ b/contrib/btree_gist/btree_int4.c
@@ -126,10 +126,10 @@ Datum
 gbt_int4_penalty(PG_FUNCTION_ARGS)
 {
 	int32KEY   *origentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
-	int32KEY    *newentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
-	float	      *result = (float *) PG_GETARG_POINTER(2);
-        
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
+	int32KEY   *newentry = (int32KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
+
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 
 	PG_RETURN_POINTER(result);
 }
@@ -138,8 +138,8 @@ Datum
 gbt_int4_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_int8.c b/contrib/btree_gist/btree_int8.c
index 7de02dbca7..83275f2c7a 100644
--- a/contrib/btree_gist/btree_int8.c
+++ b/contrib/btree_gist/btree_int8.c
@@ -125,11 +125,11 @@ Datum
 gbt_int8_penalty(PG_FUNCTION_ARGS)
 {
 	int64KEY   *origentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
-	int64KEY    *newentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
-	float	      *result = (float *) PG_GETARG_POINTER(2);
+	int64KEY   *newentry = (int64KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
+
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
-	
 	PG_RETURN_POINTER(result);
 }
 
@@ -137,8 +137,8 @@ Datum
 gbt_int8_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_interval.c b/contrib/btree_gist/btree_interval.c
index 3c671a3f04..b7776295a0 100644
--- a/contrib/btree_gist/btree_interval.c
+++ b/contrib/btree_gist/btree_interval.c
@@ -63,8 +63,8 @@ gbt_intvkey_cmp(const void *a, const void *b)
 {
 	return DatumGetInt32(
 						 DirectFunctionCall2(interval_cmp,
-									  IntervalPGetDatum(((Nsrt *) a)->t),
-									   IntervalPGetDatum(((Nsrt *) b)->t)
+										  IntervalPGetDatum(((Nsrt *) a)->t),
+										   IntervalPGetDatum(((Nsrt *) b)->t)
 											 )
 		);
 }
@@ -78,7 +78,7 @@ intr2num(const Interval *i)
 
 /*
  * INTERVALSIZE should be the actual size-on-disk of an Interval, as shown
- * in pg_type.  This might be less than sizeof(Interval) if the compiler
+ * in pg_type.	This might be less than sizeof(Interval) if the compiler
  * insists on adding alignment padding at the end of the struct.
  */
 #define INTERVALSIZE 16
@@ -202,7 +202,7 @@ gbt_intv_penalty(PG_FUNCTION_ARGS)
 	inew[0] = intr2num(&newentry->lower);
 	inew[1] = intr2num(&newentry->upper);
 
-	penalty_num(result,iorg[0],iorg[1],inew[0],inew[1]);
+	penalty_num(result, iorg[0], iorg[1], inew[0], inew[1]);
 
 	PG_RETURN_POINTER(result);
 
@@ -212,8 +212,8 @@ Datum
 gbt_intv_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_macaddr.c b/contrib/btree_gist/btree_macaddr.c
index ee56f0fac1..52cf4cb1d4 100644
--- a/contrib/btree_gist/btree_macaddr.c
+++ b/contrib/btree_gist/btree_macaddr.c
@@ -63,8 +63,8 @@ gbt_macadkey_cmp(const void *a, const void *b)
 	return DatumGetInt32(
 						 DirectFunctionCall2(
 											 macaddr_cmp,
-									PointerGetDatum(&((Nsrt *) a)->t[0]),
-									 PointerGetDatum(&((Nsrt *) b)->t[0])
+										PointerGetDatum(&((Nsrt *) a)->t[0]),
+										 PointerGetDatum(&((Nsrt *) b)->t[0])
 											 )
 		);
 }
@@ -157,7 +157,7 @@ gbt_macad_penalty(PG_FUNCTION_ARGS)
 	inew[0] = mac_2_uint64(&newentry->lower);
 	inew[1] = mac_2_uint64(&newentry->upper);
 
-	penalty_num(result,iorg[0],iorg[1],inew[0],inew[1]);
+	penalty_num(result, iorg[0], iorg[1], inew[0], inew[1]);
 
 	PG_RETURN_POINTER(result);
 
@@ -167,8 +167,8 @@ Datum
 gbt_macad_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_oid.c b/contrib/btree_gist/btree_oid.c
index d76d876372..979d728a73 100644
--- a/contrib/btree_gist/btree_oid.c
+++ b/contrib/btree_gist/btree_oid.c
@@ -129,7 +129,7 @@ gbt_oid_penalty(PG_FUNCTION_ARGS)
 	oidKEY	   *newentry = (oidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 	float	   *result = (float *) PG_GETARG_POINTER(2);
 
-	penalty_num(result,origentry->lower,origentry->upper,newentry->lower,newentry->upper);
+	penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 
 	PG_RETURN_POINTER(result);
 }
@@ -138,8 +138,8 @@ Datum
 gbt_oid_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_text.c b/contrib/btree_gist/btree_text.c
index 1275df6aef..6ab77f86ae 100644
--- a/contrib/btree_gist/btree_text.c
+++ b/contrib/btree_gist/btree_text.c
@@ -87,7 +87,7 @@ gbt_text_compress(PG_FUNCTION_ARGS)
 {
 	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 
-	if ( tinfo.eml == 0 )
+	if (tinfo.eml == 0)
 	{
 		tinfo.eml = pg_database_encoding_max_length();
 	}
@@ -102,7 +102,7 @@ gbt_bpchar_compress(PG_FUNCTION_ARGS)
 	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 	GISTENTRY  *retval;
 
-	if ( tinfo.eml == 0 )
+	if (tinfo.eml == 0)
 	{
 		tinfo.eml = pg_database_encoding_max_length();
 	}
@@ -111,7 +111,7 @@ gbt_bpchar_compress(PG_FUNCTION_ARGS)
 	{
 
 		Datum		d = DirectFunctionCall1(rtrim1, entry->key);
-		GISTENTRY  	trim;
+		GISTENTRY	trim;
 
 		gistentryinit(trim, d,
 					  entry->rel, entry->page,
@@ -136,7 +136,7 @@ gbt_text_consistent(PG_FUNCTION_ARGS)
 	bool		retval = FALSE;
 	GBT_VARKEY_R r = gbt_var_key_readable(key);
 
-	if ( tinfo.eml == 0 )
+	if (tinfo.eml == 0)
 	{
 		tinfo.eml = pg_database_encoding_max_length();
 	}
@@ -158,7 +158,7 @@ gbt_bpchar_consistent(PG_FUNCTION_ARGS)
 	bool		retval;
 	GBT_VARKEY_R r = gbt_var_key_readable(key);
 
-	if ( tinfo.eml == 0 )
+	if (tinfo.eml == 0)
 	{
 		tinfo.eml = pg_database_encoding_max_length();
 	}
diff --git a/contrib/btree_gist/btree_time.c b/contrib/btree_gist/btree_time.c
index 02f2664349..c6a5697af0 100644
--- a/contrib/btree_gist/btree_time.c
+++ b/contrib/btree_gist/btree_time.c
@@ -36,7 +36,7 @@ static bool
 gbt_timegt(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(time_gt, PointerGetDatum(a), PointerGetDatum(b))
+		 DirectFunctionCall2(time_gt, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -44,7 +44,7 @@ static bool
 gbt_timege(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(time_ge, PointerGetDatum(a), PointerGetDatum(b))
+		 DirectFunctionCall2(time_ge, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -52,7 +52,7 @@ static bool
 gbt_timeeq(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(time_eq, PointerGetDatum(a), PointerGetDatum(b))
+		 DirectFunctionCall2(time_eq, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -60,7 +60,7 @@ static bool
 gbt_timele(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(time_le, PointerGetDatum(a), PointerGetDatum(b))
+		 DirectFunctionCall2(time_le, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -68,7 +68,7 @@ static bool
 gbt_timelt(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(time_lt, PointerGetDatum(a), PointerGetDatum(b))
+		 DirectFunctionCall2(time_lt, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -212,15 +212,15 @@ gbt_time_penalty(PG_FUNCTION_ARGS)
 
 	intr = DatumGetIntervalP(DirectFunctionCall2(
 												 time_mi_time,
-										P_TimeADTGetDatum(newentry->upper),
-									 P_TimeADTGetDatum(origentry->upper)));
+										  P_TimeADTGetDatum(newentry->upper),
+									   P_TimeADTGetDatum(origentry->upper)));
 	res = INTERVAL_TO_SEC(intr);
 	res = Max(res, 0);
 
 	intr = DatumGetIntervalP(DirectFunctionCall2(
 												 time_mi_time,
-									   P_TimeADTGetDatum(origentry->lower),
-									  P_TimeADTGetDatum(newentry->lower)));
+										 P_TimeADTGetDatum(origentry->lower),
+										P_TimeADTGetDatum(newentry->lower)));
 	res2 = INTERVAL_TO_SEC(intr);
 	res2 = Max(res2, 0);
 
@@ -232,8 +232,8 @@ gbt_time_penalty(PG_FUNCTION_ARGS)
 	{
 		intr = DatumGetIntervalP(DirectFunctionCall2(
 													 time_mi_time,
-									   P_TimeADTGetDatum(origentry->upper),
-									 P_TimeADTGetDatum(origentry->lower)));
+										 P_TimeADTGetDatum(origentry->upper),
+									   P_TimeADTGetDatum(origentry->lower)));
 		*result += FLT_MIN;
 		*result += (float) (res / (res + INTERVAL_TO_SEC(intr)));
 		*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
@@ -247,8 +247,8 @@ Datum
 gbt_time_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_ts.c b/contrib/btree_gist/btree_ts.c
index 119c45093e..9f305119d8 100644
--- a/contrib/btree_gist/btree_ts.c
+++ b/contrib/btree_gist/btree_ts.c
@@ -32,13 +32,13 @@ Datum		gbt_ts_penalty(PG_FUNCTION_ARGS);
 Datum		gbt_ts_same(PG_FUNCTION_ARGS);
 
 
-#define P_TimestampGetDatum(x)  PointerGetDatum( &(x) )
+#define P_TimestampGetDatum(x)	PointerGetDatum( &(x) )
 
 static bool
 gbt_tsgt(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(timestamp_gt, PointerGetDatum(a), PointerGetDatum(b))
+	DirectFunctionCall2(timestamp_gt, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -46,7 +46,7 @@ static bool
 gbt_tsge(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(timestamp_ge, PointerGetDatum(a), PointerGetDatum(b))
+	DirectFunctionCall2(timestamp_ge, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -54,7 +54,7 @@ static bool
 gbt_tseq(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(timestamp_eq, PointerGetDatum(a), PointerGetDatum(b))
+	DirectFunctionCall2(timestamp_eq, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -62,7 +62,7 @@ static bool
 gbt_tsle(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(timestamp_le, PointerGetDatum(a), PointerGetDatum(b))
+	DirectFunctionCall2(timestamp_le, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -70,7 +70,7 @@ static bool
 gbt_tslt(const void *a, const void *b)
 {
 	return DatumGetBool(
-						DirectFunctionCall2(timestamp_lt, PointerGetDatum(a), PointerGetDatum(b))
+	DirectFunctionCall2(timestamp_lt, PointerGetDatum(a), PointerGetDatum(b))
 		);
 }
 
@@ -114,7 +114,7 @@ tstz_to_ts_gmt(Timestamp *gmt, TimestampTz *ts)
 	*gmt = *ts;
 	DecodeSpecial(0, "gmt", &val);
 
-	if ( *ts < DT_NOEND  && *ts > DT_NOBEGIN )
+	if (*ts < DT_NOEND && *ts > DT_NOBEGIN)
 	{
 		tz = val * 60;
 
@@ -217,10 +217,10 @@ gbt_ts_union(PG_FUNCTION_ARGS)
 
 
 #define penalty_check_max_float(val) do { \
-        if ( val > FLT_MAX ) \
-                val = FLT_MAX; \
-        if ( val < -FLT_MAX ) \
-                val = -FLT_MAX; \
+		if ( val > FLT_MAX ) \
+				val = FLT_MAX; \
+		if ( val < -FLT_MAX ) \
+				val = -FLT_MAX; \
 } while(false);
 
 
@@ -232,24 +232,24 @@ gbt_ts_penalty(PG_FUNCTION_ARGS)
 	tsKEY	   *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 	float	   *result = (float *) PG_GETARG_POINTER(2);
 
-	double orgdbl[2],
-				 newdbl[2];
+	double		orgdbl[2],
+				newdbl[2];
 
 	/*
-		We are allways using "double" timestamps here.
-		Precision should be good enough.
-	*/
-	orgdbl[0] = ( (double) origentry->lower ) ;
-	orgdbl[1] = ( (double) origentry->upper ) ;
-	newdbl[0] = ( (double) newentry->lower  ) ;
-	newdbl[1] = ( (double) newentry->upper  ) ;
+	 * We are allways using "double" timestamps here. Precision should be good
+	 * enough.
+	 */
+	orgdbl[0] = ((double) origentry->lower);
+	orgdbl[1] = ((double) origentry->upper);
+	newdbl[0] = ((double) newentry->lower);
+	newdbl[1] = ((double) newentry->upper);
 
-	penalty_check_max_float( orgdbl[0] );
-	penalty_check_max_float( orgdbl[1] );
-	penalty_check_max_float( newdbl[0] );
-	penalty_check_max_float( newdbl[1] );
+	penalty_check_max_float(orgdbl[0]);
+	penalty_check_max_float(orgdbl[1]);
+	penalty_check_max_float(newdbl[0]);
+	penalty_check_max_float(newdbl[1]);
 
-	penalty_num(result,orgdbl[0],orgdbl[1],newdbl[0],newdbl[1]);
+	penalty_num(result, orgdbl[0], orgdbl[1], newdbl[0], newdbl[1]);
 
 	PG_RETURN_POINTER(result);
 
@@ -260,8 +260,8 @@ Datum
 gbt_ts_picksplit(PG_FUNCTION_ARGS)
 {
 	PG_RETURN_POINTER(gbt_num_picksplit(
-								(GistEntryVector *) PG_GETARG_POINTER(0),
-								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									(GistEntryVector *) PG_GETARG_POINTER(0),
+									  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 										&tinfo
 										));
 }
diff --git a/contrib/btree_gist/btree_utils_num.h b/contrib/btree_gist/btree_utils_num.h
index 94d4bf7437..322c5759e4 100644
--- a/contrib/btree_gist/btree_utils_num.h
+++ b/contrib/btree_gist/btree_utils_num.h
@@ -48,17 +48,17 @@ typedef struct
  * Note: The factor 0.49 in following macro avoids floating point overflows
 */
 #define penalty_num(result,olower,oupper,nlower,nupper) do { \
-  double    tmp = 0.0F; \
-  (*(result))   = 0.0F; \
+  double	tmp = 0.0F; \
+  (*(result))	= 0.0F; \
   if ( (nupper) > (oupper) ) \
 	  tmp += ( ((double)nupper)*0.49F - ((double)oupper)*0.49F ); \
   if (	(olower) > (nlower)  ) \
 	  tmp += ( ((double)olower)*0.49F - ((double)nlower)*0.49F ); \
   if (tmp > 0.0F) \
   { \
-    (*(result)) += FLT_MIN; \
-    (*(result)) += (float) ( ((double)(tmp)) / ( (double)(tmp) + ( ((double)(oupper))*0.49F - ((double)(olower))*0.49F ) ) ); \
-    (*(result)) *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); \
+	(*(result)) += FLT_MIN; \
+	(*(result)) += (float) ( ((double)(tmp)) / ( (double)(tmp) + ( ((double)(oupper))*0.49F - ((double)(olower))*0.49F ) ) ); \
+	(*(result)) *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); \
   } \
 } while (0);
 
diff --git a/contrib/btree_gist/btree_utils_var.c b/contrib/btree_gist/btree_utils_var.c
index 8de39bb327..20a1e427f2 100644
--- a/contrib/btree_gist/btree_utils_var.c
+++ b/contrib/btree_gist/btree_utils_var.c
@@ -4,14 +4,14 @@
 #include "utils/builtins.h"
 
 PG_FUNCTION_INFO_V1(gbt_var_decompress);
-Datum           gbt_var_decompress(PG_FUNCTION_ARGS);
+Datum		gbt_var_decompress(PG_FUNCTION_ARGS);
 
 
 Datum
 gbt_var_decompress(PG_FUNCTION_ARGS)
 {
 	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
-	GBT_VARKEY   *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
+	GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
 
 	if (key != (GBT_VARKEY *) DatumGetPointer(entry->key))
 	{
@@ -92,45 +92,47 @@ static int32
 gbt_var_node_cp_len(const GBT_VARKEY * node, const gbtree_vinfo * tinfo)
 {
 
-	GBT_VARKEY_R        r = gbt_var_key_readable(node);
-	int32               i = 0;
-	int32               l = 0;
-	int32           t1len = VARSIZE(r.lower) - VARHDRSZ ;
-	int32           t2len = VARSIZE(r.upper) - VARHDRSZ ;
-	int32              ml = Min(t1len, t2len);
+	GBT_VARKEY_R r = gbt_var_key_readable(node);
+	int32		i = 0;
+	int32		l = 0;
+	int32		t1len = VARSIZE(r.lower) - VARHDRSZ;
+	int32		t2len = VARSIZE(r.upper) - VARHDRSZ;
+	int32		ml = Min(t1len, t2len);
 
-	char     *p1 = VARDATA(r.lower);
-	char     *p2 = VARDATA(r.upper);
+	char	   *p1 = VARDATA(r.lower);
+	char	   *p2 = VARDATA(r.upper);
 
-	if ( ml == 0 )
-	  return 0;
+	if (ml == 0)
+		return 0;
 
-	while ( i < ml )
+	while (i < ml)
 	{
-	  if ( tinfo->eml > 1 && l == 0 )
-	  {
-
-	    if ( ( l = pg_mblen(p1) ) != pg_mblen(p2) )
-	    {
-	      return i;
-	    }
-	  }
-	  if (*p1 != *p2)
-	  {
-	    if( tinfo->eml > 1 )
-	    {
-	      return (i-l+1);
-	    } else {
-	      return i;
-	    }
-	  }
-
-	  p1++;
-	  p2++;
-	  l--;
-	  i++;
+		if (tinfo->eml > 1 && l == 0)
+		{
+
+			if ((l = pg_mblen(p1)) != pg_mblen(p2))
+			{
+				return i;
+			}
+		}
+		if (*p1 != *p2)
+		{
+			if (tinfo->eml > 1)
+			{
+				return (i - l + 1);
+			}
+			else
+			{
+				return i;
+			}
+		}
+
+		p1++;
+		p2++;
+		l--;
+		i++;
 	}
-	return (ml); /* lower == upper */
+	return (ml);				/* lower == upper */
 }
 
 
@@ -141,35 +143,37 @@ static bool
 gbt_bytea_pf_match(const bytea *pf, const bytea *query, const gbtree_vinfo * tinfo)
 {
 
-	bool    out  = FALSE;
-	int32              k = 0;
-	int32   qlen = VARSIZE(query) - VARHDRSZ ;
-	int32   nlen = VARSIZE(pf) - VARHDRSZ ;
+	bool		out = FALSE;
+	int32		k = 0;
+	int32		qlen = VARSIZE(query) - VARHDRSZ;
+	int32		nlen = VARSIZE(pf) - VARHDRSZ;
 
 	if (nlen <= qlen)
 	{
-	  char     *q = VARDATA(query);
-	  char     *n = VARDATA(pf);
-
-	  if ( tinfo->eml > 1 )
-	  {
-	    out = ( varstr_cmp(q, nlen, n, nlen) == 0 );
-	  } else {
-	    out = TRUE;
-	    for (k = 0; k < nlen; k++)
-	    {
-	      if (*n != *q)
-	      {
-	        out = FALSE;
-	        break;
-	      }
-	      if (k < (nlen - 1))
-	      {
-	        q++;
-	        n++;
-	      }
-	    }
-	  }
+		char	   *q = VARDATA(query);
+		char	   *n = VARDATA(pf);
+
+		if (tinfo->eml > 1)
+		{
+			out = (varstr_cmp(q, nlen, n, nlen) == 0);
+		}
+		else
+		{
+			out = TRUE;
+			for (k = 0; k < nlen; k++)
+			{
+				if (*n != *q)
+				{
+					out = FALSE;
+					break;
+				}
+				if (k < (nlen - 1))
+				{
+					q++;
+					n++;
+				}
+			}
+		}
 	}
 
 	return out;
@@ -184,10 +188,10 @@ static bool
 gbt_var_node_pf_match(const GBT_VARKEY_R * node, const bytea *query, const gbtree_vinfo * tinfo)
 {
 
-	return ( tinfo->trnc && (
-			gbt_bytea_pf_match(node->lower, query, tinfo) ||
-			gbt_bytea_pf_match(node->upper, query, tinfo)
-		) );
+	return (tinfo->trnc && (
+							gbt_bytea_pf_match(node->lower, query, tinfo) ||
+							gbt_bytea_pf_match(node->upper, query, tinfo)
+							));
 
 }
 
@@ -201,18 +205,18 @@ gbt_var_node_truncate(const GBT_VARKEY * node, int32 cpf_length, const gbtree_vi
 {
 	GBT_VARKEY *out = NULL;
 	GBT_VARKEY_R r = gbt_var_key_readable(node);
-	int32   len1 = VARSIZE(r.lower) - VARHDRSZ;
-	int32   len2 = VARSIZE(r.upper) - VARHDRSZ;
-	int32     si = 0;
+	int32		len1 = VARSIZE(r.lower) - VARHDRSZ;
+	int32		len2 = VARSIZE(r.upper) - VARHDRSZ;
+	int32		si = 0;
 
-	len1 = Min(len1,(cpf_length + 1));
-	len2 = Min(len2,(cpf_length + 1));
+	len1 = Min(len1, (cpf_length + 1));
+	len2 = Min(len2, (cpf_length + 1));
 
 	si = 2 * VARHDRSZ + INTALIGN(VARHDRSZ + len1) + len2;
 	out = (GBT_VARKEY *) palloc(si);
 	out->vl_len = si;
-	memcpy((void *) &(((char *) out)[VARHDRSZ]), (void *) r.lower, len1 + VARHDRSZ );
-	memcpy((void *) &(((char *) out)[VARHDRSZ + INTALIGN(VARHDRSZ + len1)]), (void *) r.upper, len2 + VARHDRSZ );
+	memcpy((void *) &(((char *) out)[VARHDRSZ]), (void *) r.lower, len1 + VARHDRSZ);
+	memcpy((void *) &(((char *) out)[VARHDRSZ + INTALIGN(VARHDRSZ + len1)]), (void *) r.upper, len2 + VARHDRSZ);
 
 	*((int32 *) &(((char *) out)[VARHDRSZ])) = len1 + VARHDRSZ;
 	*((int32 *) &(((char *) out)[VARHDRSZ + INTALIGN(VARHDRSZ + len1)])) = len2 + VARHDRSZ;
@@ -568,8 +572,8 @@ gbt_var_consistent(
 			else
 				retval = (
 						  (
-					(*tinfo->f_cmp) (key->lower, (bytea *) query) <= 0 &&
-						   (*tinfo->f_cmp) ((bytea *) query, (void *) key->upper) <= 0
+						(*tinfo->f_cmp) (key->lower, (bytea *) query) <= 0 &&
+				  (*tinfo->f_cmp) ((bytea *) query, (void *) key->upper) <= 0
 						   ) || gbt_var_node_pf_match(key, query, tinfo)
 					);
 			break;
diff --git a/contrib/btree_gist/btree_utils_var.h b/contrib/btree_gist/btree_utils_var.h
index e4d48d3910..9b7be0de0d 100644
--- a/contrib/btree_gist/btree_utils_var.h
+++ b/contrib/btree_gist/btree_utils_var.h
@@ -28,7 +28,8 @@ typedef struct
 	/* Attribs */
 
 	enum gbtree_type t;			/* data type */
-	int32		eml;			/* cached pg_database_encoding_max_length (0: undefined) */
+	int32		eml;			/* cached pg_database_encoding_max_length (0:
+								 * undefined) */
 	bool		trnc;			/* truncate (=compress) key */
 
 	/* Methods */
diff --git a/contrib/chkpass/chkpass.c b/contrib/chkpass/chkpass.c
index 92cc24dc12..ddd61081b4 100644
--- a/contrib/chkpass/chkpass.c
+++ b/contrib/chkpass/chkpass.c
@@ -90,8 +90,8 @@ chkpass_in(PG_FUNCTION_ARGS)
 
 	mysalt[0] = salt_chars[random() & 0x3f];
 	mysalt[1] = salt_chars[random() & 0x3f];
-	mysalt[2] = 0;				/* technically the terminator is not
-								 * necessary but I like to play safe */
+	mysalt[2] = 0;				/* technically the terminator is not necessary
+								 * but I like to play safe */
 	strcpy(result->password, crypt(str, mysalt));
 	PG_RETURN_POINTER(result);
 }
diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c
index cc6e1a39fe..fca03f02d7 100644
--- a/contrib/cube/cube.c
+++ b/contrib/cube/cube.c
@@ -115,7 +115,7 @@ NDBOX *
 cube(text *str)
 {
 	return cube_in(DatumGetCString(DirectFunctionCall1(textout,
-												 PointerGetDatum(str))));
+													 PointerGetDatum(str))));
 }
 
 char *
@@ -219,7 +219,7 @@ g_cube_union(GistEntryVector *entryvec, int *sizep)
 	for (i = 1; i < entryvec->n; i++)
 	{
 		out = g_cube_binary_union(tmp, (NDBOX *)
-								DatumGetPointer(entryvec->vector[i].key),
+								  DatumGetPointer(entryvec->vector[i].key),
 								  sizep);
 		tmp = out;
 	}
@@ -329,8 +329,7 @@ g_cube_picksplit(GistEntryVector *entryvec,
 			size_waste = size_union - size_inter;
 
 			/*
-			 * are these a more promising split than what we've already
-			 * seen?
+			 * are these a more promising split than what we've already seen?
 			 */
 
 			if (size_waste > waste || firsttime)
@@ -356,24 +355,24 @@ g_cube_picksplit(GistEntryVector *entryvec,
 	rt_cube_size(datum_r, &size_r);
 
 	/*
-	 * Now split up the regions between the two seeds.	An important
-	 * property of this split algorithm is that the split vector v has the
-	 * indices of items to be split in order in its left and right
-	 * vectors.  We exploit this property by doing a merge in the code
-	 * that actually splits the page.
+	 * Now split up the regions between the two seeds.	An important property
+	 * of this split algorithm is that the split vector v has the indices of
+	 * items to be split in order in its left and right vectors.  We exploit
+	 * this property by doing a merge in the code that actually splits the
+	 * page.
 	 *
-	 * For efficiency, we also place the new index tuple in this loop. This
-	 * is handled at the very end, when we have placed all the existing
-	 * tuples and i == maxoff + 1.
+	 * For efficiency, we also place the new index tuple in this loop. This is
+	 * handled at the very end, when we have placed all the existing tuples
+	 * and i == maxoff + 1.
 	 */
 
 	maxoff = OffsetNumberNext(maxoff);
 	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
 	{
 		/*
-		 * If we've already decided where to place this item, just put it
-		 * on the right list.  Otherwise, we need to figure out which page
-		 * needs the least enlargement in order to store the item.
+		 * If we've already decided where to place this item, just put it on
+		 * the right list.	Otherwise, we need to figure out which page needs
+		 * the least enlargement in order to store the item.
 		 */
 
 		if (i == seed_1)
@@ -542,8 +541,8 @@ cube_union(NDBOX * a, NDBOX * b)
 	}
 
 	/*
-	 * use the potentially smaller of the two boxes (b) to fill in the
-	 * result, padding absent dimensions with zeroes
+	 * use the potentially smaller of the two boxes (b) to fill in the result,
+	 * padding absent dimensions with zeroes
 	 */
 	for (i = 0; i < b->dim; i++)
 	{
@@ -562,7 +561,7 @@ cube_union(NDBOX * a, NDBOX * b)
 		result->x[i] =
 			Min(Min(a->x[i], a->x[i + a->dim]), result->x[i]);
 		result->x[i + a->dim] = Max(Max(a->x[i],
-							   a->x[i + a->dim]), result->x[i + a->dim]);
+								   a->x[i + a->dim]), result->x[i + a->dim]);
 	}
 
 	return (result);
@@ -620,12 +619,11 @@ cube_inter(NDBOX * a, NDBOX * b)
 		result->x[i] =
 			Max(Min(a->x[i], a->x[i + a->dim]), result->x[i]);
 		result->x[i + a->dim] = Min(Max(a->x[i],
-							   a->x[i + a->dim]), result->x[i + a->dim]);
+								   a->x[i + a->dim]), result->x[i + a->dim]);
 	}
 
 	/*
-	 * Is it OK to return a non-null intersection for non-overlapping
-	 * boxes?
+	 * Is it OK to return a non-null intersection for non-overlapping boxes?
 	 */
 	return (result);
 }
@@ -713,8 +711,8 @@ cube_cmp(NDBOX * a, NDBOX * b)
 		}
 
 		/*
-		 * if all common dimensions are equal, the cube with more
-		 * dimensions wins
+		 * if all common dimensions are equal, the cube with more dimensions
+		 * wins
 		 */
 		return 1;
 	}
@@ -736,8 +734,8 @@ cube_cmp(NDBOX * a, NDBOX * b)
 		}
 
 		/*
-		 * if all common dimensions are equal, the cube with more
-		 * dimensions wins
+		 * if all common dimensions are equal, the cube with more dimensions
+		 * wins
 		 */
 		return -1;
 	}
@@ -797,10 +795,9 @@ cube_contains(NDBOX * a, NDBOX * b)
 	if (a->dim < b->dim)
 	{
 		/*
-		 * the further comparisons will make sense if the excess
-		 * dimensions of (b) were zeroes Since both UL and UR coordinates
-		 * must be zero, we can check them all without worrying about
-		 * which is which.
+		 * the further comparisons will make sense if the excess dimensions of
+		 * (b) were zeroes Since both UL and UR coordinates must be zero, we
+		 * can check them all without worrying about which is which.
 		 */
 		for (i = a->dim; i < b->dim; i++)
 		{
diff --git a/contrib/dbase/dbf.c b/contrib/dbase/dbf.c
index 6a13aac972..4c79a07d60 100644
--- a/contrib/dbase/dbf.c
+++ b/contrib/dbase/dbf.c
@@ -88,10 +88,10 @@ dbf_open(char *file, int flags)
 	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 :)
+	 * 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)))
@@ -155,8 +155,7 @@ dbf_write_head(dbhead * dbh)
 	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);
diff --git a/contrib/dbase/dbf.h b/contrib/dbase/dbf.h
index 9a5a2bee83..d9c88ed35b 100644
--- a/contrib/dbase/dbf.h
+++ b/contrib/dbase/dbf.h
@@ -9,7 +9,7 @@
 #define _DBF_H
 
 #ifdef _WIN32
-#include <gmon.h>			/* we need it to define u_char type */
+#include <gmon.h>				/* we need it to define u_char type */
 #endif
 #include <sys/types.h>
 
@@ -64,8 +64,7 @@ typedef struct
 	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_dec;		/* number of decimal positions if type is 'N' */
 	u_char		dbf_stub[14];	/* stuff we don't need */
 }	dbf_field;
 
@@ -89,15 +88,14 @@ typedef struct
 	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_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 */
+	f_descr    *db_fields;		/* pointer to an array of field- descriptions */
 }	dbhead;
 
 /* structure that contains everything a user wants from a field, including
diff --git a/contrib/dbase/dbf2pg.c b/contrib/dbase/dbf2pg.c
index c3e50dc4ac..7d42798dbe 100644
--- a/contrib/dbase/dbf2pg.c
+++ b/contrib/dbase/dbf2pg.c
@@ -169,7 +169,7 @@ 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"
+	"              [-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");
 }
@@ -251,7 +251,7 @@ do_create(PGconn *conn, char *table, dbhead * dbh)
 		printf("Building CREATE-clause\n");
 
 	if (!(query = (char *) malloc(
-						   (dbh->db_nfields * 40) + 29 + strlen(table))))
+							   (dbh->db_nfields * 40) + 29 + strlen(table))))
 	{
 		fprintf(stderr, "Memory allocation error in function do_create\n");
 		PQfinish(conn);
@@ -359,9 +359,8 @@ do_inserts(PGconn *conn, char *table, dbhead * dbh)
 	}
 
 	/*
-	 * 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)
+	 * 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);
@@ -370,7 +369,7 @@ do_inserts(PGconn *conn, char *table, dbhead * dbh)
 	{
 		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);
@@ -386,12 +385,10 @@ do_inserts(PGconn *conn, char *table, dbhead * dbh)
 		exit(1);
 	}
 
-	if (end == 0)				/* "end" is a user option, if not
-								 * specified, */
+	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 */
+	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++)
@@ -426,9 +423,8 @@ do_inserts(PGconn *conn, char *table, dbhead * dbh)
 			j = 0;				/* counter for fields in the output */
 			for (h = 0; h < dbh->db_nfields; h++)
 			{
-				if (!strlen(fields[h].db_name)) /* When the new fieldname
-												 * is empty, the field is
-												 * skipped */
+				if (!strlen(fields[h].db_name)) /* When the new fieldname is
+												 * empty, the field is skipped */
 					continue;
 				else
 					j++;
@@ -639,8 +635,8 @@ main(int argc, char **argv)
 				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;
diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c
index c1d70ebf22..c11b15860a 100644
--- a/contrib/dblink/dblink.c
+++ b/contrib/dblink/dblink.c
@@ -60,10 +60,9 @@
 
 typedef struct remoteConn
 {
-	PGconn	   *conn;				/* Hold the remote connection */
-	int			autoXactCursors;	/* Indicates the number of open cursors,
-									 * non-zero means we opened the xact
-									 * ourselves */
+	PGconn	   *conn;			/* Hold the remote connection */
+	int			autoXactCursors;/* Indicates the number of open cursors,
+								 * non-zero means we opened the xact ourselves */
 }	remoteConn;
 
 /*
@@ -71,7 +70,7 @@ typedef struct remoteConn
  */
 static remoteConn *getConnectionByName(const char *name);
 static HTAB *createConnHash(void);
-static void createNewConnection(const char *name, remoteConn *rconn);
+static void createNewConnection(const char *name, remoteConn * rconn);
 static void deleteConnection(const char *name);
 static char **get_pkey_attnames(Oid relid, int16 *numatts);
 static char *get_sql_insert(Oid relid, int2vector *pkattnums, int16 pknumatts, char **src_pkattvals, char **tgt_pkattvals);
@@ -224,9 +223,9 @@ dblink_connect(PG_FUNCTION_ARGS)
 			pfree(rconn);
 
 		ereport(ERROR,
-		   (errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
-			errmsg("could not establish connection"),
-			errdetail("%s", msg)));
+				(errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
+				 errmsg("could not establish connection"),
+				 errdetail("%s", msg)));
 	}
 
 	if (connname)
@@ -514,8 +513,7 @@ dblink_fetch(PG_FUNCTION_ARGS)
 		funcctx = SRF_FIRSTCALL_INIT();
 
 		/*
-		 * switch to memory context appropriate for multiple function
-		 * calls
+		 * switch to memory context appropriate for multiple function calls
 		 */
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -664,8 +662,7 @@ dblink_record(PG_FUNCTION_ARGS)
 		funcctx = SRF_FIRSTCALL_INIT();
 
 		/*
-		 * switch to memory context appropriate for multiple function
-		 * calls
+		 * switch to memory context appropriate for multiple function calls
 		 */
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -730,8 +727,8 @@ dblink_record(PG_FUNCTION_ARGS)
 							   TEXTOID, -1, 0);
 
 			/*
-			 * and save a copy of the command status string to return as
-			 * our result tuple
+			 * and save a copy of the command status string to return as our
+			 * result tuple
 			 */
 			sql_cmd_status = PQcmdStatus(res);
 			funcctx->max_calls = 1;
@@ -766,8 +763,8 @@ dblink_record(PG_FUNCTION_ARGS)
 					/* failed to determine actual type of RECORD */
 					ereport(ERROR,
 							(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-							 errmsg("function returning record called in context "
-									"that cannot accept type record")));
+						errmsg("function returning record called in context "
+							   "that cannot accept type record")));
 					break;
 				default:
 					/* result type isn't composite */
@@ -935,8 +932,8 @@ dblink_exec(PG_FUNCTION_ARGS)
 	{
 		PQclear(res);
 		ereport(ERROR,
-			  (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
-			   errmsg("statement returning results not allowed")));
+				(errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
+				 errmsg("statement returning results not allowed")));
 	}
 
 	/* if needed, close the connection to the database and cleanup */
@@ -975,8 +972,7 @@ dblink_get_pkey(PG_FUNCTION_ARGS)
 		funcctx = SRF_FIRSTCALL_INIT();
 
 		/*
-		 * switch to memory context appropriate for multiple function
-		 * calls
+		 * switch to memory context appropriate for multiple function calls
 		 */
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -989,8 +985,7 @@ dblink_get_pkey(PG_FUNCTION_ARGS)
 							GET_STR(PG_GETARG_TEXT_P(0)))));
 
 		/*
-		 * need a tuple descriptor representing one INT and one TEXT
-		 * column
+		 * need a tuple descriptor representing one INT and one TEXT column
 		 */
 		tupdesc = CreateTemplateTupleDesc(2, false);
 		TupleDescInitEntry(tupdesc, (AttrNumber) 1, "position",
@@ -999,8 +994,8 @@ dblink_get_pkey(PG_FUNCTION_ARGS)
 						   TEXTOID, -1, 0);
 
 		/*
-		 * Generate attribute metadata needed later to produce tuples from
-		 * raw C strings
+		 * Generate attribute metadata needed later to produce tuples from raw
+		 * C strings
 		 */
 		attinmeta = TupleDescGetAttInMetadata(tupdesc);
 		funcctx->attinmeta = attinmeta;
@@ -1145,8 +1140,8 @@ dblink_build_sql_insert(PG_FUNCTION_ARGS)
 	tgt_pkattvals_arry = PG_GETARG_ARRAYTYPE_P(4);
 
 	/*
-	 * Source array is made up of key values that will be used to locate
-	 * the tuple of interest from the local system.
+	 * Source array is made up of key values that will be used to locate the
+	 * tuple of interest from the local system.
 	 */
 	src_ndim = ARR_NDIM(src_pkattvals_arry);
 	src_dim = ARR_DIMS(src_pkattvals_arry);
@@ -1158,8 +1153,8 @@ dblink_build_sql_insert(PG_FUNCTION_ARGS)
 	if (src_nitems != pknumatts)
 		ereport(ERROR,
 				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
-			 errmsg("source key array length must match number of key " \
-					"attributes")));
+				 errmsg("source key array length must match number of key " \
+						"attributes")));
 
 	/*
 	 * get array of pointers to c-strings from the input source array
@@ -1178,8 +1173,8 @@ dblink_build_sql_insert(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Target array is made up of key values that will be used to build
-	 * the SQL string for use on the remote system.
+	 * Target array is made up of key values that will be used to build the
+	 * SQL string for use on the remote system.
 	 */
 	tgt_ndim = ARR_NDIM(tgt_pkattvals_arry);
 	tgt_dim = ARR_DIMS(tgt_pkattvals_arry);
@@ -1191,8 +1186,8 @@ dblink_build_sql_insert(PG_FUNCTION_ARGS)
 	if (tgt_nitems != pknumatts)
 		ereport(ERROR,
 				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
-			 errmsg("target key array length must match number of key " \
-					"attributes")));
+				 errmsg("target key array length must match number of key " \
+						"attributes")));
 
 	/*
 	 * get array of pointers to c-strings from the input target array
@@ -1291,8 +1286,8 @@ dblink_build_sql_delete(PG_FUNCTION_ARGS)
 	tgt_pkattvals_arry = PG_GETARG_ARRAYTYPE_P(3);
 
 	/*
-	 * Target array is made up of key values that will be used to build
-	 * the SQL string for use on the remote system.
+	 * Target array is made up of key values that will be used to build the
+	 * SQL string for use on the remote system.
 	 */
 	tgt_ndim = ARR_NDIM(tgt_pkattvals_arry);
 	tgt_dim = ARR_DIMS(tgt_pkattvals_arry);
@@ -1304,8 +1299,8 @@ dblink_build_sql_delete(PG_FUNCTION_ARGS)
 	if (tgt_nitems != pknumatts)
 		ereport(ERROR,
 				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
-			 errmsg("target key array length must match number of key " \
-					"attributes")));
+				 errmsg("target key array length must match number of key " \
+						"attributes")));
 
 	/*
 	 * get array of pointers to c-strings from the input target array
@@ -1414,8 +1409,8 @@ dblink_build_sql_update(PG_FUNCTION_ARGS)
 	tgt_pkattvals_arry = PG_GETARG_ARRAYTYPE_P(4);
 
 	/*
-	 * Source array is made up of key values that will be used to locate
-	 * the tuple of interest from the local system.
+	 * Source array is made up of key values that will be used to locate the
+	 * tuple of interest from the local system.
 	 */
 	src_ndim = ARR_NDIM(src_pkattvals_arry);
 	src_dim = ARR_DIMS(src_pkattvals_arry);
@@ -1427,8 +1422,8 @@ dblink_build_sql_update(PG_FUNCTION_ARGS)
 	if (src_nitems != pknumatts)
 		ereport(ERROR,
 				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
-			 errmsg("source key array length must match number of key " \
-					"attributes")));
+				 errmsg("source key array length must match number of key " \
+						"attributes")));
 
 	/*
 	 * get array of pointers to c-strings from the input source array
@@ -1447,8 +1442,8 @@ dblink_build_sql_update(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Target array is made up of key values that will be used to build
-	 * the SQL string for use on the remote system.
+	 * Target array is made up of key values that will be used to build the
+	 * SQL string for use on the remote system.
 	 */
 	tgt_ndim = ARR_NDIM(tgt_pkattvals_arry);
 	tgt_dim = ARR_DIMS(tgt_pkattvals_arry);
@@ -1460,8 +1455,8 @@ dblink_build_sql_update(PG_FUNCTION_ARGS)
 	if (tgt_nitems != pknumatts)
 		ereport(ERROR,
 				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
-			 errmsg("target key array length must match number of key " \
-					"attributes")));
+				 errmsg("target key array length must match number of key " \
+						"attributes")));
 
 	/*
 	 * get array of pointers to c-strings from the input target array
@@ -1610,7 +1605,7 @@ get_sql_insert(Oid relid, int2vector *pkattnums, int16 pknumatts, char **src_pka
 			appendStringInfo(str, ",");
 
 		appendStringInfo(str, "%s",
-				  quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
+					  quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
 		needComma = true;
 	}
 
@@ -1688,7 +1683,7 @@ get_sql_delete(Oid relid, int2vector *pkattnums, int16 pknumatts, char **tgt_pka
 			appendStringInfo(str, " AND ");
 
 		appendStringInfo(str, "%s",
-		quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
+		   quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
 
 		if (tgt_pkattvals != NULL)
 			val = pstrdup(tgt_pkattvals[i]);
@@ -1756,7 +1751,7 @@ get_sql_update(Oid relid, int2vector *pkattnums, int16 pknumatts, char **src_pka
 			appendStringInfo(str, ", ");
 
 		appendStringInfo(str, "%s = ",
-				  quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
+					  quote_ident_cstr(NameStr(tupdesc->attrs[i]->attname)));
 
 		if (tgt_pkattvals != NULL)
 			key = get_attnum_pk_pos(pkattnums, pknumatts, i + 1);
@@ -1788,7 +1783,7 @@ get_sql_update(Oid relid, int2vector *pkattnums, int16 pknumatts, char **src_pka
 			appendStringInfo(str, " AND ");
 
 		appendStringInfo(str, "%s",
-		quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
+		   quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
 
 		if (tgt_pkattvals != NULL)
 			val = pstrdup(tgt_pkattvals[i]);
@@ -1894,8 +1889,8 @@ get_tuple_of_interest(Oid relid, int2vector *pkattnums, int16 pknumatts, char **
 		elog(ERROR, "SPI connect failure - returned %d", ret);
 
 	/*
-	 * Build sql statement to look up tuple of interest Use src_pkattvals
-	 * as the criteria.
+	 * Build sql statement to look up tuple of interest Use src_pkattvals as
+	 * the criteria.
 	 */
 	appendStringInfo(str, "SELECT * FROM %s WHERE ", relname);
 
@@ -1907,7 +1902,7 @@ get_tuple_of_interest(Oid relid, int2vector *pkattnums, int16 pknumatts, char **
 			appendStringInfo(str, " AND ");
 
 		appendStringInfo(str, "%s",
-		quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
+		   quote_ident_cstr(NameStr(tupdesc->attrs[pkattnum - 1]->attname)));
 
 		val = pstrdup(src_pkattvals[i]);
 		if (val != NULL)
@@ -2045,7 +2040,7 @@ createConnHash(void)
 }
 
 static void
-createNewConnection(const char *name, remoteConn *rconn)
+createNewConnection(const char *name, remoteConn * rconn)
 {
 	remoteConnHashEnt *hentry;
 	bool		found;
diff --git a/contrib/dbmirror/pending.c b/contrib/dbmirror/pending.c
index 9d10afaadb..753dec19ed 100644
--- a/contrib/dbmirror/pending.c
+++ b/contrib/dbmirror/pending.c
@@ -115,7 +115,7 @@ recordchange(PG_FUNCTION_ARGS)
 		if (SPI_connect() < 0)
 		{
 			ereport(ERROR, (errcode(ERRCODE_CONNECTION_FAILURE),
-			  errmsg("dbmirror:recordchange could not connect to SPI")));
+				  errmsg("dbmirror:recordchange could not connect to SPI")));
 			return -1;
 		}
 		trigdata = (TriggerData *) fcinfo->context;
@@ -155,7 +155,7 @@ recordchange(PG_FUNCTION_ARGS)
 		else
 		{
 			ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
-					 errmsg("dbmirror:recordchange Unknown operation")));
+						 errmsg("dbmirror:recordchange Unknown operation")));
 
 		}
 
@@ -219,7 +219,7 @@ storePending(char *cpTableName, HeapTuple tBeforeTuple,
 	vpPlan = SPI_prepare(cpQueryBase, 3, taPlanArgTypes);
 	if (vpPlan == NULL)
 		ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
-				   errmsg("dbmirror:storePending error creating plan")));
+						errmsg("dbmirror:storePending error creating plan")));
 
 
 	saPlanData[0] = PointerGetDatum(cpTableName);
@@ -662,7 +662,7 @@ saveSequenceUpdate(Oid relid, int64 nextValue, bool iscalled)
 	if (SPI_connect() < 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
-				 errmsg("dbmirror:savesequenceupdate could not connect to SPI")));
+			errmsg("dbmirror:savesequenceupdate could not connect to SPI")));
 
 	insertPlan = SPI_prepare(insertQuery, 2, insertArgTypes);
 	insertDataPlan = SPI_prepare(insertDataQuery, 1, insertDataArgTypes);
diff --git a/contrib/earthdistance/earthdistance.c b/contrib/earthdistance/earthdistance.c
index 28ce40378c..f91eeb5392 100644
--- a/contrib/earthdistance/earthdistance.c
+++ b/contrib/earthdistance/earthdistance.c
@@ -67,7 +67,7 @@ geo_distance(Point *pt1, Point *pt2)
 		longdiff = TWO_PI - longdiff;
 
 	sino = sqrt(sin(fabs(lat1 - lat2) / 2.) * sin(fabs(lat1 - lat2) / 2.) +
-		cos(lat1) * cos(lat2) * sin(longdiff / 2.) * sin(longdiff / 2.));
+			cos(lat1) * cos(lat2) * sin(longdiff / 2.) * sin(longdiff / 2.));
 	if (sino > 1.)
 		sino = 1.;
 	*resultp = 2. * EARTH_RADIUS * asin(sino);
diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c
index e5095ff1a1..a3ac6da586 100644
--- a/contrib/fulltextindex/fti.c
+++ b/contrib/fulltextindex/fti.c
@@ -339,8 +339,8 @@ fti(PG_FUNCTION_ARGS)
 					ret = SPI_execp(*(plan->splan), values, NULL, 0);
 					if (ret != SPI_OK_INSERT)
 						ereport(ERROR,
-							(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
-							 errmsg("error executing insert")));
+								(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
+								 errmsg("error executing insert")));
 				}
 				pfree(buff);
 				pfree(data);
@@ -367,9 +367,8 @@ 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
-		 * this to 'g'
+		 * skip pieces at the end of a string that are not alfa-numeric (ie.
+		 * 'string$%^&', last_start first points to '&', and after this to 'g'
 		 */
 		if (!isalnum((unsigned char) *last_start))
 		{
@@ -379,8 +378,7 @@ breakup(char *string, char *substring)
 			cur_pos = last_start;
 		}
 
-		cur_pos--;				/* substrings are at minimum 2 characters
-								 * long */
+		cur_pos--;				/* substrings are at minimum 2 characters long */
 
 		if (isalnum((unsigned char) *cur_pos))
 		{
diff --git a/contrib/fuzzystrmatch/dmetaphone.c b/contrib/fuzzystrmatch/dmetaphone.c
index e9f3f7aed3..820cced856 100644
--- a/contrib/fuzzystrmatch/dmetaphone.c
+++ b/contrib/fuzzystrmatch/dmetaphone.c
@@ -48,7 +48,7 @@
 
 
 /*
- * $Revision: 1.5 $
+ * $Revision: 1.6 $
  * $Id$
  */
 
@@ -154,10 +154,10 @@ dmetaphone(PG_FUNCTION_ARGS)
 	alen = VARSIZE(arg) - VARHDRSZ;
 
 	/*
-	 * Postgres' string values might not have trailing nuls. The VARSIZE
-	 * will not include the nul in any case so we copy things out and add
-	 * a trailing nul. When we copy back we ignore the nul (and we don't
-	 * make space for it).
+	 * Postgres' string values might not have trailing nuls. The VARSIZE will
+	 * not include the nul in any case so we copy things out and add a
+	 * trailing nul. When we copy back we ignore the nul (and we don't make
+	 * space for it).
 	 */
 
 	aptr = palloc(alen + 1);
@@ -236,7 +236,6 @@ dmetaphone_alt(PG_FUNCTION_ARGS)
  */
 
 #define META_FREE(x)			/* pfree((x)) */
-
 #else							/* not defined DMETAPHONE_MAIN */
 
 /* use the standard malloc library when not running in PostgreSQL */
@@ -512,8 +511,8 @@ DoubleMetaphone(char *str, char **codes)
 					&& StringAt(original, (current - 1), 3, "ACH", "")
 					&& ((GetAt(original, current + 2) != 'I')
 						&& ((GetAt(original, current + 2) != 'E')
-						|| StringAt(original, (current - 2), 6, "BACHER",
-									"MACHER", ""))))
+							|| StringAt(original, (current - 2), 6, "BACHER",
+										"MACHER", ""))))
 				{
 					MetaphAdd(primary, "K");
 					MetaphAdd(secondary, "K");
@@ -582,9 +581,9 @@ DoubleMetaphone(char *str, char **codes)
 					/*
 					 * e.g., 'wachtler', 'wechsler', but not 'tichner'
 					 */
-						&& StringAt(original, (current + 2), 1, "L", "R",
-									"N", "M", "B", "H", "F", "V", "W",
-									" ", "")))
+							&& StringAt(original, (current + 2), 1, "L", "R",
+										"N", "M", "B", "H", "F", "V", "W",
+										" ", "")))
 					{
 						MetaphAdd(primary, "K");
 						MetaphAdd(secondary, "K");
@@ -639,14 +638,14 @@ DoubleMetaphone(char *str, char **codes)
 				{
 					/* 'bellocchio' but not 'bacchus' */
 					if (StringAt(original, (current + 2), 1, "I", "E", "H", "")
-					  && !StringAt(original, (current + 2), 2, "HU", ""))
+						&& !StringAt(original, (current + 2), 2, "HU", ""))
 					{
 						/* 'accident', 'accede' 'succeed' */
 						if (
 							((current == 1)
 							 && (GetAt(original, current - 1) == 'A'))
-						 || StringAt(original, (current - 1), 5, "UCCEE",
-									 "UCCES", ""))
+							|| StringAt(original, (current - 1), 5, "UCCEE",
+										"UCCES", ""))
 						{
 							MetaphAdd(primary, "KS");
 							MetaphAdd(secondary, "KS");
@@ -787,8 +786,8 @@ DoubleMetaphone(char *str, char **codes)
 					}
 
 					/*
-					 * Parker's rule (with some further refinements) -
-					 * e.g., 'hugh'
+					 * Parker's rule (with some further refinements) - e.g.,
+					 * 'hugh'
 					 */
 					if (
 						((current > 1)
@@ -873,9 +872,9 @@ DoubleMetaphone(char *str, char **codes)
 				/* -ges-,-gep-,-gel-, -gie- at beginning */
 				if ((current == 0)
 					&& ((GetAt(original, current + 1) == 'Y')
-					  || StringAt(original, (current + 1), 2, "ES", "EP",
-								"EB", "EL", "EY", "IB", "IL", "IN", "IE",
-								  "EI", "ER", "")))
+						|| StringAt(original, (current + 1), 2, "ES", "EP",
+									"EB", "EL", "EY", "IB", "IL", "IN", "IE",
+									"EI", "ER", "")))
 				{
 					MetaphAdd(primary, "K");
 					MetaphAdd(secondary, "J");
@@ -1002,7 +1001,7 @@ DoubleMetaphone(char *str, char **codes)
 						else
 						{
 							if (!StringAt(original, (current + 1), 1, "L", "T",
-										"K", "S", "N", "M", "B", "Z", "")
+										  "K", "S", "N", "M", "B", "Z", "")
 								&& !StringAt(original, (current - 1), 1,
 											 "S", "K", "L", ""))
 							{
@@ -1035,10 +1034,10 @@ DoubleMetaphone(char *str, char **codes)
 					if (((current == (length - 3))
 						 && StringAt(original, (current - 1), 4, "ILLO",
 									 "ILLA", "ALLE", ""))
-					|| ((StringAt(original, (last - 1), 2, "AS", "OS", "")
-						 || StringAt(original, last, 1, "A", "O", ""))
-						&& StringAt(original, (current - 1), 4,
-									"ALLE", "")))
+						|| ((StringAt(original, (last - 1), 2, "AS", "OS", "")
+							 || StringAt(original, last, 1, "A", "O", ""))
+							&& StringAt(original, (current - 1), 4,
+										"ALLE", "")))
 					{
 						MetaphAdd(primary, "L");
 						MetaphAdd(secondary, "");
@@ -1056,7 +1055,7 @@ DoubleMetaphone(char *str, char **codes)
 			case 'M':
 				if ((StringAt(original, (current - 1), 3, "UMB", "")
 					 && (((current + 1) == last)
-					  || StringAt(original, (current + 2), 2, "ER", "")))
+						 || StringAt(original, (current + 2), 2, "ER", "")))
 				/* 'dumb','thumb' */
 					|| (GetAt(original, current + 1) == 'M'))
 					current += 2;
@@ -1113,7 +1112,7 @@ DoubleMetaphone(char *str, char **codes)
 				if ((current == last)
 					&& !SlavoGermanic(original)
 					&& StringAt(original, (current - 2), 2, "IE", "")
-				&& !StringAt(original, (current - 4), 2, "ME", "MA", ""))
+					&& !StringAt(original, (current - 4), 2, "ME", "MA", ""))
 				{
 					MetaphAdd(primary, "");
 					MetaphAdd(secondary, "R");
@@ -1152,8 +1151,8 @@ DoubleMetaphone(char *str, char **codes)
 				{
 					/* germanic */
 					if (StringAt
-					 (original, (current + 1), 4, "HEIM", "HOEK", "HOLM",
-					  "HOLZ", ""))
+						(original, (current + 1), 4, "HEIM", "HOEK", "HOLM",
+						 "HOLZ", ""))
 					{
 						MetaphAdd(primary, "S");
 						MetaphAdd(secondary, "S");
@@ -1187,8 +1186,8 @@ DoubleMetaphone(char *str, char **codes)
 
 				/*
 				 * german & anglicisations, e.g. 'smith' match 'schmidt',
-				 * 'snider' match 'schneider' also, -sz- in slavic
-				 * language although in hungarian it is pronounced 's'
+				 * 'snider' match 'schneider' also, -sz- in slavic language
+				 * although in hungarian it is pronounced 's'
 				 */
 				if (((current == 0)
 					 && StringAt(original, (current + 1), 1,
@@ -1264,7 +1263,7 @@ DoubleMetaphone(char *str, char **codes)
 
 				/* french e.g. 'resnais', 'artois' */
 				if ((current == last)
-				 && StringAt(original, (current - 2), 2, "AI", "OI", ""))
+					&& StringAt(original, (current - 2), 2, "AI", "OI", ""))
 				{
 					MetaphAdd(primary, "");
 					MetaphAdd(secondary, "S");
@@ -1365,8 +1364,8 @@ DoubleMetaphone(char *str, char **codes)
 
 				/* Arnow should match Arnoff */
 				if (((current == last) && IsVowel(original, current - 1))
-				|| StringAt(original, (current - 1), 5, "EWSKI", "EWSKY",
-							"OWSKI", "OWSKY", "")
+					|| StringAt(original, (current - 1), 5, "EWSKI", "EWSKY",
+								"OWSKI", "OWSKY", "")
 					|| StringAt(original, 0, 3, "SCH", ""))
 				{
 					MetaphAdd(primary, "");
@@ -1442,8 +1441,8 @@ DoubleMetaphone(char *str, char **codes)
 		}
 
 		/*
-		 * printf("PRIMARY: %s\n", primary->str); printf("SECONDARY:
-		 * %s\n", secondary->str);
+		 * printf("PRIMARY: %s\n", primary->str); printf("SECONDARY: %s\n",
+		 * secondary->str);
 		 */
 	}
 
diff --git a/contrib/fuzzystrmatch/fuzzystrmatch.c b/contrib/fuzzystrmatch/fuzzystrmatch.c
index 8ffc02ffa3..e76e5038c2 100644
--- a/contrib/fuzzystrmatch/fuzzystrmatch.c
+++ b/contrib/fuzzystrmatch/fuzzystrmatch.c
@@ -65,10 +65,10 @@ levenshtein(PG_FUNCTION_ARGS)
 	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))));
@@ -78,10 +78,9 @@ levenshtein(PG_FUNCTION_ARGS)
 
 	/*
 	 * Restrict the length of the strings being compared to something
-	 * reasonable because we will have to perform rows * cols
-	 * calculations. If longer strings need to be compared, increase
-	 * MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for speed
-	 * and memory usage).
+	 * reasonable because we will have to perform rows * cols calculations. 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))
 		ereport(ERROR,
@@ -90,9 +89,9 @@ levenshtein(PG_FUNCTION_ARGS)
 						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)
@@ -102,9 +101,8 @@ 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++)
@@ -119,14 +117,13 @@ levenshtein(PG_FUNCTION_ARGS)
 	str_s0 = str_s;
 
 	/*
-	 * Loop through the rows, starting at row 1. Row 0 is used for the
-	 * initial "upper" row.
+	 * Loop through 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;
 
@@ -140,8 +137,7 @@ levenshtein(PG_FUNCTION_ARGS)
 			/*
 			 * 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.
+			 * current row position in the target string; cost is 1 otherwise.
 			 */
 			c = ((CHAREQ(str_s, str_t)) ? 0 : 1);
 
@@ -172,8 +168,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;
@@ -301,8 +297,8 @@ Lookahead(char *word, int how_far)
 	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 */
+	letter_ahead = word[idx];	/* idx will be either == to how_far or at the
+								 * end of the string */
 	return letter_ahead;
 }
 
@@ -453,11 +449,11 @@ _metaphone(
 
 
 		/*
-		 * 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.
+		 * 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 */
@@ -478,9 +474,9 @@ _metaphone(
 				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))
@@ -534,8 +530,8 @@ _metaphone(
 				/*
 				 * 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
+				 * -DGY- (handled in D) else J if in -GE-, -GI, -GY and not GG
+				 * else K
 				 */
 			case 'G':
 				if (Next_Letter == 'H')
@@ -761,14 +757,17 @@ PG_FUNCTION_INFO_V1(difference);
 Datum
 difference(PG_FUNCTION_ARGS)
 {
-	char sndx1[SOUNDEX_LEN+1], sndx2[SOUNDEX_LEN+1];
-	int i, result;
+	char		sndx1[SOUNDEX_LEN + 1],
+				sndx2[SOUNDEX_LEN + 1];
+	int			i,
+				result;
 
 	_soundex(_textout(PG_GETARG_TEXT_P(0)), sndx1);
 	_soundex(_textout(PG_GETARG_TEXT_P(1)), sndx2);
 
 	result = 0;
-	for (i=0; i<SOUNDEX_LEN; i++) {
+	for (i = 0; i < SOUNDEX_LEN; i++)
+	{
 		if (sndx1[i] == sndx2[i])
 			result++;
 	}
diff --git a/contrib/intagg/int_aggregate.c b/contrib/intagg/int_aggregate.c
index f4391b4699..3c7bb7ff87 100644
--- a/contrib/intagg/int_aggregate.c
+++ b/contrib/intagg/int_aggregate.c
@@ -59,8 +59,8 @@ typedef struct callContext
 #define START_NUM	8			/* initial size of arrays */
 #define PGARRAY_SIZE(n) (sizeof(PGARRAY) + (((n)-1)*sizeof(int4)))
 
-static PGARRAY *GetPGArray(PGARRAY *p, AggState *aggstate, bool fAdd);
-static PGARRAY *ShrinkPGArray(PGARRAY *p);
+static PGARRAY *GetPGArray(PGARRAY * p, AggState *aggstate, bool fAdd);
+static PGARRAY *ShrinkPGArray(PGARRAY * p);
 
 Datum		int_agg_state(PG_FUNCTION_ARGS);
 Datum		int_agg_final_array(PG_FUNCTION_ARGS);
@@ -77,7 +77,7 @@ PG_FUNCTION_INFO_V1(int_enum);
  * ie the Agg node's aggcontext.
  */
 static PGARRAY *
-GetPGArray(PGARRAY *p, AggState *aggstate, bool fAdd)
+GetPGArray(PGARRAY * p, AggState *aggstate, bool fAdd)
 {
 	if (!p)
 	{
@@ -97,7 +97,7 @@ GetPGArray(PGARRAY *p, AggState *aggstate, bool fAdd)
 		/* Ensure array has space for another item */
 		if (p->items >= p->lower)
 		{
-			PGARRAY	   *pn;
+			PGARRAY    *pn;
 			int			n = p->lower * 2;
 			int			cbNew = PGARRAY_SIZE(n);
 
@@ -117,9 +117,10 @@ GetPGArray(PGARRAY *p, AggState *aggstate, bool fAdd)
  * memory allocation context
  */
 static PGARRAY *
-ShrinkPGArray(PGARRAY *p)
+ShrinkPGArray(PGARRAY * p)
 {
 	PGARRAY    *pnew;
+
 	/* get target size */
 	int			cb = PGARRAY_SIZE(p->items);
 
@@ -158,11 +159,11 @@ int_agg_state(PG_FUNCTION_ARGS)
 
 	if (!PG_ARGISNULL(1))
 	{
-		int4	value = PG_GETARG_INT32(1);
+		int4		value = PG_GETARG_INT32(1);
 
-		if (!p)		/* internal error */
+		if (!p)					/* internal error */
 			elog(ERROR, "no aggregate storage");
-		else if (p->items >= p->lower)		/* internal error */
+		else if (p->items >= p->lower)	/* internal error */
 			elog(ERROR, "aggregate storage too small");
 		else
 			p->array[p->items++] = value;
@@ -212,7 +213,7 @@ int_enum(PG_FUNCTION_ARGS)
 	if (!rsi || !IsA(rsi, ReturnSetInfo))
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-		 errmsg("int_enum called in context that cannot accept a set")));
+			 errmsg("int_enum called in context that cannot accept a set")));
 
 	if (!p)
 	{
@@ -223,7 +224,7 @@ int_enum(PG_FUNCTION_ARGS)
 	if (!fcinfo->flinfo->fn_extra)
 	{
 		/* Allocate working state */
-		MemoryContext	oldcontext;
+		MemoryContext oldcontext;
 
 		oldcontext = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
 
@@ -250,7 +251,8 @@ int_enum(PG_FUNCTION_ARGS)
 		fcinfo->flinfo->fn_extra = (void *) pc;
 		MemoryContextSwitchTo(oldcontext);
 	}
-	else	/* use existing working state */
+	else
+		/* use existing working state */
 		pc = (CTX *) fcinfo->flinfo->fn_extra;
 
 	/* Are we done yet? */
diff --git a/contrib/intarray/_int_gist.c b/contrib/intarray/_int_gist.c
index 2d5e82a459..4f777bc40b 100644
--- a/contrib/intarray/_int_gist.c
+++ b/contrib/intarray/_int_gist.c
@@ -38,8 +38,8 @@ g_int_consistent(PG_FUNCTION_ARGS)
 
 	if (strategy == BooleanSearchStrategy)
 		PG_RETURN_BOOL(execconsistent((QUERYTYPE *) query,
-							   (ArrayType *) DatumGetPointer(entry->key),
-				  ISLEAFKEY((ArrayType *) DatumGetPointer(entry->key))));
+								   (ArrayType *) DatumGetPointer(entry->key),
+					  ISLEAFKEY((ArrayType *) DatumGetPointer(entry->key))));
 
 	/* XXX are we sure it's safe to scribble on the query object here? */
 	/* XXX what about toasted input? */
@@ -73,7 +73,7 @@ g_int_consistent(PG_FUNCTION_ARGS)
 		case RTContainedByStrategyNumber:
 			if (GIST_LEAF(entry))
 				retval = inner_int_contains(query,
-							  (ArrayType *) DatumGetPointer(entry->key));
+								  (ArrayType *) DatumGetPointer(entry->key));
 			else
 				retval = inner_int_overlap((ArrayType *) DatumGetPointer(entry->key),
 										   query);
@@ -134,7 +134,7 @@ g_int_compress(PG_FUNCTION_ARGS)
 		r->flags |= LEAFKEY;
 		retval = palloc(sizeof(GISTENTRY));
 		gistentryinit(*retval, PointerGetDatum(r),
-			  entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
+				  entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
 
 		PG_RETURN_POINTER(retval);
 	}
@@ -175,7 +175,7 @@ g_int_compress(PG_FUNCTION_ARGS)
 		r = resize_intArrayType(r, len);
 		retval = palloc(sizeof(GISTENTRY));
 		gistentryinit(*retval, PointerGetDatum(r),
-			  entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
+				  entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
 		PG_RETURN_POINTER(retval);
 	}
 	else
@@ -211,7 +211,7 @@ g_int_decompress(PG_FUNCTION_ARGS)
 		{
 			retval = palloc(sizeof(GISTENTRY));
 			gistentryinit(*retval, PointerGetDatum(in),
-			 entry->rel, entry->page, entry->offset, VARSIZE(in), FALSE);
+				 entry->rel, entry->page, entry->offset, VARSIZE(in), FALSE);
 
 			PG_RETURN_POINTER(retval);
 		}
@@ -233,7 +233,7 @@ g_int_decompress(PG_FUNCTION_ARGS)
 		pfree(in);
 	retval = palloc(sizeof(GISTENTRY));
 	gistentryinit(*retval, PointerGetDatum(r),
-			  entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
+				  entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
 
 	PG_RETURN_POINTER(retval);
 }
@@ -378,8 +378,7 @@ g_int_picksplit(PG_FUNCTION_ARGS)
 				pfree(inter_d);
 
 			/*
-			 * are these a more promising split that what we've already
-			 * seen?
+			 * are these a more promising split that what we've already seen?
 			 */
 
 			if (size_waste > waste || firsttime)
@@ -430,15 +429,15 @@ g_int_picksplit(PG_FUNCTION_ARGS)
 	qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
 
 	/*
-	 * Now split up the regions between the two seeds.	An important
-	 * property of this split algorithm is that the split vector v has the
-	 * indices of items to be split in order in its left and right
-	 * vectors.  We exploit this property by doing a merge in the code
-	 * that actually splits the page.
+	 * Now split up the regions between the two seeds.	An important property
+	 * of this split algorithm is that the split vector v has the indices of
+	 * items to be split in order in its left and right vectors.  We exploit
+	 * this property by doing a merge in the code that actually splits the
+	 * page.
 	 *
-	 * For efficiency, we also place the new index tuple in this loop. This
-	 * is handled at the very end, when we have placed all the existing
-	 * tuples and i == maxoff + 1.
+	 * For efficiency, we also place the new index tuple in this loop. This is
+	 * handled at the very end, when we have placed all the existing tuples
+	 * and i == maxoff + 1.
 	 */
 
 
@@ -447,9 +446,9 @@ g_int_picksplit(PG_FUNCTION_ARGS)
 		i = costvector[j].pos;
 
 		/*
-		 * If we've already decided where to place this item, just put it
-		 * on the right list.  Otherwise, we need to figure out which page
-		 * needs the least enlargement in order to store the item.
+		 * If we've already decided where to place this item, just put it on
+		 * the right list.	Otherwise, we need to figure out which page needs
+		 * the least enlargement in order to store the item.
 		 */
 
 		if (i == seed_1)
diff --git a/contrib/intarray/_int_op.c b/contrib/intarray/_int_op.c
index 9f30bb2173..70951bfd47 100644
--- a/contrib/intarray/_int_op.c
+++ b/contrib/intarray/_int_op.c
@@ -24,8 +24,8 @@ _int_contained(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(DatumGetBool(
 								DirectFunctionCall2(
 													_int_contains,
-								   PointerGetDatum(PG_GETARG_POINTER(1)),
-									PointerGetDatum(PG_GETARG_POINTER(0))
+									   PointerGetDatum(PG_GETARG_POINTER(1)),
+										PointerGetDatum(PG_GETARG_POINTER(0))
 													)
 								));
 }
@@ -54,8 +54,8 @@ _int_different(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(!DatumGetBool(
 								 DirectFunctionCall2(
 													 _int_same,
-								   PointerGetDatum(PG_GETARG_POINTER(0)),
-									PointerGetDatum(PG_GETARG_POINTER(1))
+									   PointerGetDatum(PG_GETARG_POINTER(0)),
+										PointerGetDatum(PG_GETARG_POINTER(1))
 													 )
 								 ));
 }
diff --git a/contrib/intarray/_intbig_gist.c b/contrib/intarray/_intbig_gist.c
index 07a051dd50..237281aec5 100644
--- a/contrib/intarray/_intbig_gist.c
+++ b/contrib/intarray/_intbig_gist.c
@@ -487,7 +487,7 @@ g_intbig_consistent(PG_FUNCTION_ARGS)
 	if (strategy == BooleanSearchStrategy)
 	{
 		PG_RETURN_BOOL(signconsistent((QUERYTYPE *) query,
-									GETSIGN(DatumGetPointer(entry->key)),
+									  GETSIGN(DatumGetPointer(entry->key)),
 									  false));
 	}
 
diff --git a/contrib/ltree/_ltree_op.c b/contrib/ltree/_ltree_op.c
index 3890769ce1..729d19c082 100644
--- a/contrib/ltree/_ltree_op.c
+++ b/contrib/ltree/_ltree_op.c
@@ -53,7 +53,7 @@ array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree ** found)
 	while (num > 0)
 	{
 		if (DatumGetBool(DirectFunctionCall2(callback,
-						 PointerGetDatum(item), PointerGetDatum(param))))
+							 PointerGetDatum(item), PointerGetDatum(param))))
 		{
 
 			if (found)
diff --git a/contrib/ltree/lquery_op.c b/contrib/ltree/lquery_op.c
index 81a1b788aa..54466a5b6b 100644
--- a/contrib/ltree/lquery_op.c
+++ b/contrib/ltree/lquery_op.c
@@ -101,7 +101,7 @@ checkLevel(lquery_level * curq, ltree_level * curt)
 		else if (
 				 (
 				  curvar->len == curt->len ||
-				(curt->len > curvar->len && (curvar->flag & LVAR_ANYEND))
+				  (curt->len > curvar->len && (curvar->flag & LVAR_ANYEND))
 				  ) &&
 				 (*cmpptr) (curvar->name, curt->name, curvar->len) == 0)
 		{
@@ -332,7 +332,7 @@ lt_q_regex(PG_FUNCTION_ARGS)
 	while (num > 0)
 	{
 		if (DatumGetBool(DirectFunctionCall2(ltq_regex,
-						 PointerGetDatum(tree), PointerGetDatum(query))))
+							 PointerGetDatum(tree), PointerGetDatum(query))))
 		{
 
 			res = true;
diff --git a/contrib/ltree/ltree.h b/contrib/ltree/ltree.h
index 2057751cfe..0400db8b77 100644
--- a/contrib/ltree/ltree.h
+++ b/contrib/ltree/ltree.h
@@ -157,7 +157,7 @@ bool ltree_execute(ITEM * curitem, void *checkval,
 int			ltree_compare(const ltree * a, const ltree * b);
 bool		inner_isparent(const ltree * c, const ltree * p);
 bool compare_subnode(ltree_level * t, char *q, int len,
-		int (*cmpptr) (const char *, const char *, size_t), bool anyend);
+			int (*cmpptr) (const char *, const char *, size_t), bool anyend);
 ltree	   *lca_inner(ltree ** a, int len);
 
 #define PG_GETARG_LTREE(x)	((ltree*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
diff --git a/contrib/ltree/ltree_gist.c b/contrib/ltree/ltree_gist.c
index 693244d9da..7e7ede0285 100644
--- a/contrib/ltree/ltree_gist.c
+++ b/contrib/ltree/ltree_gist.c
@@ -647,9 +647,9 @@ ltree_consistent(PG_FUNCTION_ARGS)
 				res = (ltree_compare((ltree *) query, LTG_NODE(key)) == 0);
 			else
 				res = (
-				   ltree_compare((ltree *) query, LTG_GETLNODE(key)) >= 0
+					   ltree_compare((ltree *) query, LTG_GETLNODE(key)) >= 0
 					   &&
-				   ltree_compare((ltree *) query, LTG_GETRNODE(key)) <= 0
+					   ltree_compare((ltree *) query, LTG_GETRNODE(key)) <= 0
 					);
 			break;
 		case BTGreaterEqualStrategyNumber:
@@ -677,8 +677,8 @@ ltree_consistent(PG_FUNCTION_ARGS)
 		case 13:
 			if (GIST_LEAF(entry))
 				res = DatumGetBool(DirectFunctionCall2(ltq_regex,
-										  PointerGetDatum(LTG_NODE(key)),
-										PointerGetDatum((lquery *) query)
+											  PointerGetDatum(LTG_NODE(key)),
+											PointerGetDatum((lquery *) query)
 													   ));
 			else
 				res = (gist_qe(key, (lquery *) query) && gist_between(key, (lquery *) query));
@@ -687,8 +687,8 @@ ltree_consistent(PG_FUNCTION_ARGS)
 		case 15:
 			if (GIST_LEAF(entry))
 				res = DatumGetBool(DirectFunctionCall2(ltxtq_exec,
-										  PointerGetDatum(LTG_NODE(key)),
-										PointerGetDatum((lquery *) query)
+											  PointerGetDatum(LTG_NODE(key)),
+											PointerGetDatum((lquery *) query)
 													   ));
 			else
 				res = gist_qtxt(key, (ltxtquery *) query);
@@ -697,8 +697,8 @@ ltree_consistent(PG_FUNCTION_ARGS)
 		case 17:
 			if (GIST_LEAF(entry))
 				res = DatumGetBool(DirectFunctionCall2(lt_q_regex,
-										  PointerGetDatum(LTG_NODE(key)),
-									 PointerGetDatum((ArrayType *) query)
+											  PointerGetDatum(LTG_NODE(key)),
+										 PointerGetDatum((ArrayType *) query)
 													   ));
 			else
 				res = arrq_cons(key, (ArrayType *) query);
diff --git a/contrib/ltree/ltree_io.c b/contrib/ltree/ltree_io.c
index d0a8c20903..ccc6fc8ff7 100644
--- a/contrib/ltree/ltree_io.c
+++ b/contrib/ltree/ltree_io.c
@@ -82,7 +82,7 @@ ltree_in(PG_FUNCTION_ARGS)
 							 errmsg("name of level is too long"),
 							 errdetail("name length is %d, must " \
 									   "be < 256, in position %d",
-								 lptr->len, (int) (lptr->start - buf))));
+									 lptr->len, (int) (lptr->start - buf))));
 
 				totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
 				lptr++;
@@ -284,7 +284,7 @@ lquery_in(PG_FUNCTION_ARGS)
 							 errmsg("name of level is too long"),
 							 errdetail("name length is %d, must " \
 									   "be < 256, in position %d",
-								 lptr->len, (int) (lptr->start - buf))));
+									 lptr->len, (int) (lptr->start - buf))));
 
 				state = LQPRS_WAITVAR;
 			}
@@ -300,7 +300,7 @@ lquery_in(PG_FUNCTION_ARGS)
 							 errmsg("name of level is too long"),
 							 errdetail("name length is %d, must " \
 									   "be < 256, in position %d",
-								 lptr->len, (int) (lptr->start - buf))));
+									 lptr->len, (int) (lptr->start - buf))));
 
 				state = LQPRS_WAITLEVEL;
 				curqlevel = NEXTLEV(curqlevel);
diff --git a/contrib/mSQL-interface/mpgsql.c b/contrib/mSQL-interface/mpgsql.c
index cd3daba337..1f43f61ea1 100644
--- a/contrib/mSQL-interface/mpgsql.c
+++ b/contrib/mSQL-interface/mpgsql.c
@@ -264,7 +264,7 @@ msqlListTables(int a)
 	char		tbuf[BUFSIZ];
 
 	snprintf(tbuf, BUFSIZ,
-		"select relname from pg_class where relkind='r' and relowner=%d",
+			 "select relname from pg_class where relkind='r' and relowner=%d",
 			 geteuid());
 	if (msqlQuery(a, tbuf) > 0)
 	{
@@ -288,7 +288,7 @@ msqlListIndex(int a, char *b, char *c)
 	char		tbuf[BUFSIZ];
 
 	snprintf(tbuf, BUFSIZ,
-		"select relname from pg_class where relkind='i' and relowner=%d",
+			 "select relname from pg_class where relkind='i' and relowner=%d",
 			 geteuid());
 	if (msqlQuery(a, tbuf) > 0)
 	{
diff --git a/contrib/oid2name/oid2name.c b/contrib/oid2name/oid2name.c
index 9bea98b507..069c1708d6 100644
--- a/contrib/oid2name/oid2name.c
+++ b/contrib/oid2name/oid2name.c
@@ -17,10 +17,10 @@
 /* an extensible array to keep track of elements to show */
 typedef struct
 {
-	char  **array;
-	int		num;
-	int		alloc;
-} eary;
+	char	  **array;
+	int			num;
+	int			alloc;
+}	eary;
 
 /* these are the opts structures for command line params */
 struct options
@@ -36,19 +36,19 @@ struct options
 	bool		extended;
 	bool		tablespaces;
 
-	char		*dbname;
-	char		*hostname;
-	char		*port;
-	char		*username;
-	char		*password;
+	char	   *dbname;
+	char	   *hostname;
+	char	   *port;
+	char	   *username;
+	char	   *password;
 };
 
 /* function prototypes */
 void		get_opts(int, char **, struct options *);
 void	   *myalloc(size_t size);
 char	   *mystrdup(const char *str);
-void		add_one_elt(char *eltname, eary *eary);
-char	   *get_comma_elts(eary *eary);
+void		add_one_elt(char *eltname, eary * eary);
+char	   *get_comma_elts(eary * eary);
 PGconn	   *sql_conn(struct options *);
 int			sql_exec(PGconn *, const char *sql, bool quiet);
 void		sql_exec_dumpalldbs(PGconn *, struct options *);
@@ -95,7 +95,7 @@ get_opts(int argc, char **argv, struct options * my_opts)
 				add_one_elt(optarg, my_opts->oids);
 				break;
 
-				/* specify one filenode to show*/
+				/* specify one filenode to show */
 			case 'f':
 				add_one_elt(optarg, my_opts->filenodes);
 				break;
@@ -149,23 +149,23 @@ get_opts(int argc, char **argv, struct options * my_opts)
 			case '?':
 			case 'h':
 				fprintf(stderr,
-"Usage: oid2name [-s|-d database] [-S][-i][-q][-x] [-t table|-o oid|-f file] ...\n"
-"        default action        show all database Oids\n"
-"        -d database           database to connect to\n"
-"        -s                    show all tablespaces\n"
-"        -S                    show system objects too\n"
-"        -i                    show indexes and sequences too\n"
-"        -x                    extended (show additional columns)\n"
-"        -q                    quiet (don't show headers)\n"
-"        -t <table>            show info for table named <table>\n"
-"        -o <oid>              show info for table with Oid <oid>\n"
-"        -f <filenode>         show info for table with filenode <filenode>\n"
-"        -H host               connect to remote host\n"
-"        -p port               host port to connect to\n"
-"        -U username           username to connect with\n"
-"        -P password           password for username\n"
-"                              (see also $PGPASSWORD and ~/.pgpass)\n"
-);
+						"Usage: oid2name [-s|-d database] [-S][-i][-q][-x] [-t table|-o oid|-f file] ...\n"
+					 "        default action        show all database Oids\n"
+					 "        -d database           database to connect to\n"
+						"        -s                    show all tablespaces\n"
+					"        -S                    show system objects too\n"
+						"        -i                    show indexes and sequences too\n"
+						"        -x                    extended (show additional columns)\n"
+				 "        -q                    quiet (don't show headers)\n"
+						"        -t <table>            show info for table named <table>\n"
+						"        -o <oid>              show info for table with Oid <oid>\n"
+						"        -f <filenode>         show info for table with filenode <filenode>\n"
+					 "        -H host               connect to remote host\n"
+					"        -p port               host port to connect to\n"
+				   "        -U username           username to connect with\n"
+					  "        -P password           password for username\n"
+						"                              (see also $PGPASSWORD and ~/.pgpass)\n"
+					);
 				exit(1);
 				break;
 		}
@@ -175,7 +175,8 @@ get_opts(int argc, char **argv, struct options * my_opts)
 void *
 myalloc(size_t size)
 {
-	void *ptr = malloc(size);
+	void	   *ptr = malloc(size);
+
 	if (!ptr)
 	{
 		fprintf(stderr, "out of memory");
@@ -187,7 +188,8 @@ myalloc(size_t size)
 char *
 mystrdup(const char *str)
 {
-	char *result = strdup(str);
+	char	   *result = strdup(str);
+
 	if (!result)
 	{
 		fprintf(stderr, "out of memory");
@@ -202,7 +204,7 @@ mystrdup(const char *str)
  * Add one element to a (possibly empty) eary struct.
  */
 void
-add_one_elt(char *eltname, eary *eary)
+add_one_elt(char *eltname, eary * eary)
 {
 	if (eary->alloc == 0)
 	{
@@ -233,11 +235,12 @@ add_one_elt(char *eltname, eary *eary)
  * SQL statement.
  */
 char *
-get_comma_elts(eary *eary)
+get_comma_elts(eary * eary)
 {
-	char *ret,
-		 *ptr;
-	int i, length = 0;
+	char	   *ret,
+			   *ptr;
+	int			i,
+				length = 0;
 
 	if (eary->num == 0)
 		return mystrdup("");
@@ -272,9 +275,9 @@ sql_conn(struct options * my_opts)
 
 	/* login */
 	conn = PQsetdbLogin(my_opts->hostname,
-			            my_opts->port,
-						NULL,  /* options */
-						NULL,  /* tty */
+						my_opts->port,
+						NULL,	/* options */
+						NULL,	/* tty */
 						my_opts->dbname,
 						my_opts->username,
 						my_opts->password);
@@ -303,7 +306,9 @@ sql_exec(PGconn *conn, const char *todo, bool quiet)
 
 	int			nfields;
 	int			nrows;
-	int			i, j, l;
+	int			i,
+				j,
+				l;
 	int		   *length;
 	char	   *pad;
 
@@ -334,7 +339,7 @@ sql_exec(PGconn *conn, const char *todo, bool quiet)
 	{
 		for (j = 0; j < nfields; j++)
 		{
-		   	l = strlen(PQgetvalue(res, i, j));
+			l = strlen(PQgetvalue(res, i, j));
 			if (l > length[j])
 				length[j] = strlen(PQgetvalue(res, i, j));
 		}
@@ -372,36 +377,36 @@ sql_exec(PGconn *conn, const char *todo, bool quiet)
 }
 
 /*
- * Dump all databases.  There are no system objects to worry about.
+ * Dump all databases.	There are no system objects to worry about.
  */
 void
-sql_exec_dumpalldbs(PGconn *conn, struct options *opts)
+sql_exec_dumpalldbs(PGconn *conn, struct options * opts)
 {
 	char		todo[1024];
 
 	/* get the oid and database name from the system pg_database table */
 	snprintf(todo, sizeof(todo),
 			 "SELECT d.oid AS \"Oid\", datname AS \"Database Name\", "
-			 "spcname AS \"Tablespace\" FROM pg_database d JOIN pg_tablespace t ON "
+	  "spcname AS \"Tablespace\" FROM pg_database d JOIN pg_tablespace t ON "
 			 "(dattablespace = t.oid) ORDER BY 2");
 
 	sql_exec(conn, todo, opts->quiet);
 }
 
-/* 
+/*
  * Dump all tables, indexes and sequences in the current database.
  */
 void
-sql_exec_dumpalltables(PGconn *conn, struct options *opts)
+sql_exec_dumpalltables(PGconn *conn, struct options * opts)
 {
 	char		todo[1024];
 	char	   *addfields = ",c.oid AS \"Oid\", nspname AS \"Schema\", spcname as \"Tablespace\" ";
 
 	snprintf(todo, sizeof(todo),
-			 "SELECT relfilenode as \"Filenode\", relname as \"Table Name\" %s "
+		  "SELECT relfilenode as \"Filenode\", relname as \"Table Name\" %s "
 			 "FROM pg_class c "
-			 "	LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace "
-			 "	LEFT JOIN pg_catalog.pg_database d ON d.datname = current_database(),"
+		   "	LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace "
+	"	LEFT JOIN pg_catalog.pg_database d ON d.datname = current_database(),"
 			 "	pg_catalog.pg_tablespace t "
 			 "WHERE relkind IN ('r'%s) AND "
 			 "	%s"
@@ -412,7 +417,7 @@ sql_exec_dumpalltables(PGconn *conn, struct options *opts)
 			 "ORDER BY relname",
 			 opts->extended ? addfields : "",
 			 opts->indexes ? ", 'i', 'S', 't'" : "",
- 			 opts->systables ? "" : "n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') AND");
+			 opts->systables ? "" : "n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema') AND");
 
 	sql_exec(conn, todo, opts->quiet);
 }
@@ -422,11 +427,14 @@ sql_exec_dumpalltables(PGconn *conn, struct options *opts)
  * given objects in the current database.
  */
 void
-sql_exec_searchtables(PGconn *conn, struct options *opts)
+sql_exec_searchtables(PGconn *conn, struct options * opts)
 {
 	char	   *todo;
-	char	   *qualifiers, *ptr;
-	char	   *comma_oids, *comma_filenodes, *comma_tables;
+	char	   *qualifiers,
+			   *ptr;
+	char	   *comma_oids,
+			   *comma_filenodes,
+			   *comma_tables;
 	bool		written = false;
 	char	   *addfields = ",c.oid AS \"Oid\", nspname AS \"Schema\", spcname as \"Tablespace\" ";
 
@@ -465,9 +473,9 @@ sql_exec_searchtables(PGconn *conn, struct options *opts)
 	/* now build the query */
 	todo = (char *) myalloc(650 + strlen(qualifiers));
 	snprintf(todo, 650 + strlen(qualifiers),
-			 "SELECT relfilenode as \"Filenode\", relname as \"Table Name\" %s\n"
+		 "SELECT relfilenode as \"Filenode\", relname as \"Table Name\" %s\n"
 			 "FROM pg_class c \n"
-			 "	LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \n"
+		 "	LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \n"
 			 "	LEFT JOIN pg_catalog.pg_database d ON d.datname = current_database(),\n"
 			 "	pg_catalog.pg_tablespace t \n"
 			 "WHERE relkind IN ('r', 'i', 'S', 't') AND \n"
@@ -486,9 +494,9 @@ sql_exec_searchtables(PGconn *conn, struct options *opts)
 }
 
 void
-sql_exec_dumpalltbspc(PGconn *conn, struct options *opts)
+sql_exec_dumpalltbspc(PGconn *conn, struct options * opts)
 {
-	char	todo[1024];
+	char		todo[1024];
 
 	snprintf(todo, sizeof(todo),
 			 "SELECT oid AS \"Oid\", spcname as \"Tablespace Name\"\n"
diff --git a/contrib/pg_buffercache/pg_buffercache_pages.c b/contrib/pg_buffercache/pg_buffercache_pages.c
index 0bc014342d..22bb8e537b 100644
--- a/contrib/pg_buffercache/pg_buffercache_pages.c
+++ b/contrib/pg_buffercache/pg_buffercache_pages.c
@@ -1,7 +1,7 @@
 /*-------------------------------------------------------------------------
  *
  * pg_buffercache_pages.c
- *    display some contents of the buffer cache
+ *	  display some contents of the buffer cache
  *
  *	  $PostgreSQL$
  *-------------------------------------------------------------------------
@@ -17,11 +17,11 @@
 #define NUM_BUFFERCACHE_PAGES_ELEM	6
 
 #if defined(WIN32) || defined(__CYGWIN__)
-extern DLLIMPORT BufferDesc	*BufferDescriptors;
-extern DLLIMPORT volatile uint32	InterruptHoldoffCount;
+extern DLLIMPORT BufferDesc *BufferDescriptors;
+extern DLLIMPORT volatile uint32 InterruptHoldoffCount;
 #endif
 
-Datum	pg_buffercache_pages(PG_FUNCTION_ARGS);
+Datum		pg_buffercache_pages(PG_FUNCTION_ARGS);
 
 
 /*
@@ -34,24 +34,24 @@ typedef struct
 	Oid			relfilenode;
 	Oid			reltablespace;
 	Oid			reldatabase;
-	BlockNumber	blocknum;
+	BlockNumber blocknum;
 	bool		isvalid;
 	bool		isdirty;
 
-} BufferCachePagesRec;
+}	BufferCachePagesRec;
 
 
 /*
  * Function context for data persisting over repeated calls.
  */
-typedef struct 
+typedef struct
 {
 
-	AttInMetadata		*attinmeta;
-	BufferCachePagesRec	*record;
-	char				*values[NUM_BUFFERCACHE_PAGES_ELEM];
+	AttInMetadata *attinmeta;
+	BufferCachePagesRec *record;
+	char	   *values[NUM_BUFFERCACHE_PAGES_ELEM];
 
-} BufferCachePagesContext;
+}	BufferCachePagesContext;
 
 
 /*
@@ -63,44 +63,44 @@ Datum
 pg_buffercache_pages(PG_FUNCTION_ARGS)
 {
 
-	FuncCallContext		*funcctx;
-	Datum				result;
-	MemoryContext		oldcontext;
-	BufferCachePagesContext	*fctx;		/* User function context. */
-	TupleDesc			tupledesc;
-	HeapTuple			tuple;
+	FuncCallContext *funcctx;
+	Datum		result;
+	MemoryContext oldcontext;
+	BufferCachePagesContext *fctx;		/* User function context. */
+	TupleDesc	tupledesc;
+	HeapTuple	tuple;
 
 	if (SRF_IS_FIRSTCALL())
 	{
 		uint32		i;
-		volatile BufferDesc	*bufHdr;
+		volatile BufferDesc *bufHdr;
 
 		funcctx = SRF_FIRSTCALL_INIT();
 
 		/* Switch context when allocating stuff to be used in later calls */
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
-		
+
 		/* Construct a tuple to return. */
 		tupledesc = CreateTemplateTupleDesc(NUM_BUFFERCACHE_PAGES_ELEM, false);
 		TupleDescInitEntry(tupledesc, (AttrNumber) 1, "bufferid",
-									INT4OID, -1, 0);
+						   INT4OID, -1, 0);
 		TupleDescInitEntry(tupledesc, (AttrNumber) 2, "relfilenode",
-									OIDOID, -1, 0);
+						   OIDOID, -1, 0);
 		TupleDescInitEntry(tupledesc, (AttrNumber) 3, "reltablespace",
-									OIDOID, -1, 0);
+						   OIDOID, -1, 0);
 		TupleDescInitEntry(tupledesc, (AttrNumber) 4, "reldatabase",
-									OIDOID, -1, 0);
+						   OIDOID, -1, 0);
 		TupleDescInitEntry(tupledesc, (AttrNumber) 5, "relblocknumber",
-									INT8OID, -1, 0);
+						   INT8OID, -1, 0);
 		TupleDescInitEntry(tupledesc, (AttrNumber) 6, "isdirty",
-									BOOLOID, -1, 0);
+						   BOOLOID, -1, 0);
 
 		/* Generate attribute metadata needed later to produce tuples */
 		funcctx->attinmeta = TupleDescGetAttInMetadata(tupledesc);
 
-		/* 
-		 * Create a function context for cross-call persistence 
-		 * and initialize the buffer counters.
+		/*
+		 * Create a function context for cross-call persistence and initialize
+		 * the buffer counters.
 		 */
 		fctx = (BufferCachePagesContext *) palloc(sizeof(BufferCachePagesContext));
 		funcctx->max_calls = NBuffers;
@@ -118,12 +118,12 @@ pg_buffercache_pages(PG_FUNCTION_ARGS)
 		fctx->values[4] = (char *) palloc(3 * sizeof(uint32) + 1);
 		fctx->values[5] = (char *) palloc(2);
 
-		
+
 		/* Return to original context when allocating transient memory */
 		MemoryContextSwitchTo(oldcontext);
 
 
-		/* 
+		/*
 		 * Lock Buffer map and scan though all the buffers, saving the
 		 * relevant fields in the fctx->record structure.
 		 */
@@ -140,7 +140,7 @@ pg_buffercache_pages(PG_FUNCTION_ARGS)
 			fctx->record[i].reldatabase = bufHdr->tag.rnode.dbNode;
 			fctx->record[i].blocknum = bufHdr->tag.blockNum;
 
-			if (bufHdr->flags & BM_DIRTY) 
+			if (bufHdr->flags & BM_DIRTY)
 				fctx->record[i].isdirty = true;
 			else
 				fctx->record[i].isdirty = false;
@@ -159,34 +159,34 @@ pg_buffercache_pages(PG_FUNCTION_ARGS)
 	}
 
 	funcctx = SRF_PERCALL_SETUP();
-	
+
 	/* Get the saved state */
 	fctx = funcctx->user_fctx;
 
 
 	if (funcctx->call_cntr < funcctx->max_calls)
 	{
-		uint32 		i = funcctx->call_cntr;
-		char		*values[NUM_BUFFERCACHE_PAGES_ELEM];
+		uint32		i = funcctx->call_cntr;
+		char	   *values[NUM_BUFFERCACHE_PAGES_ELEM];
 		int			j;
-		
-		/* 
-		 * Use a temporary values array, initially pointing to
-		 * fctx->values, so it can be reassigned w/o losing the storage
-		 * for subsequent calls.
+
+		/*
+		 * Use a temporary values array, initially pointing to fctx->values,
+		 * so it can be reassigned w/o losing the storage for subsequent
+		 * calls.
 		 */
 		for (j = 0; j < NUM_BUFFERCACHE_PAGES_ELEM; j++)
 		{
 			values[j] = fctx->values[j];
 		}
-		
+
 
 		/*
-		 * Set all fields except the bufferid to null if the buffer is
-		 * unused or not valid.
+		 * Set all fields except the bufferid to null if the buffer is unused
+		 * or not valid.
 		 */
 		if (fctx->record[i].blocknum == InvalidBlockNumber ||
-			fctx->record[i].isvalid == false )
+			fctx->record[i].isvalid == false)
 		{
 
 			sprintf(values[0], "%u", fctx->record[i].bufferid);
@@ -205,7 +205,7 @@ pg_buffercache_pages(PG_FUNCTION_ARGS)
 			sprintf(values[2], "%u", fctx->record[i].reltablespace);
 			sprintf(values[3], "%u", fctx->record[i].reldatabase);
 			sprintf(values[4], "%u", fctx->record[i].blocknum);
-			if (fctx->record[i].isdirty) 
+			if (fctx->record[i].isdirty)
 			{
 				strcpy(values[5], "t");
 			}
@@ -213,7 +213,7 @@ pg_buffercache_pages(PG_FUNCTION_ARGS)
 			{
 				strcpy(values[5], "f");
 			}
-	
+
 		}
 
 
@@ -228,4 +228,3 @@ pg_buffercache_pages(PG_FUNCTION_ARGS)
 		SRF_RETURN_DONE(funcctx);
 
 }
-
diff --git a/contrib/pg_trgm/trgm_op.c b/contrib/pg_trgm/trgm_op.c
index 57fb944a56..407b317f28 100644
--- a/contrib/pg_trgm/trgm_op.c
+++ b/contrib/pg_trgm/trgm_op.c
@@ -300,8 +300,8 @@ similarity_op(PG_FUNCTION_ARGS)
 {
 	float4		res = DatumGetFloat4(DirectFunctionCall2(
 														 similarity,
-													  PG_GETARG_DATUM(0),
-													   PG_GETARG_DATUM(1)
+														 PG_GETARG_DATUM(0),
+														 PG_GETARG_DATUM(1)
 														 ));
 
 	PG_RETURN_BOOL(res >= trgm_limit);
diff --git a/contrib/pgbench/pgbench.c b/contrib/pgbench/pgbench.c
index 9d67d52a68..6bac4c6692 100644
--- a/contrib/pgbench/pgbench.c
+++ b/contrib/pgbench/pgbench.c
@@ -55,8 +55,7 @@ extern int	optind;
 #define MAXCLIENTS 1024			/* max number of clients allowed */
 
 int			nclients = 1;		/* default number of simulated clients */
-int			nxacts = 10;		/* default number of transactions per
-								 * clients */
+int			nxacts = 10;		/* default number of transactions per clients */
 
 /*
  * scaling factor. for example, tps = 10 will make 1000000 tuples of
@@ -78,8 +77,7 @@ bool		use_log;			/* log transaction latencies to a file */
 
 int			remains;			/* number of remaining clients */
 
-int			is_connect;			/* establish connection  for each
-								 * transaction */
+int			is_connect;			/* establish connection  for each transaction */
 
 char	   *pghost = "";
 char	   *pgport = NULL;
@@ -92,8 +90,8 @@ char	   *dbName;
 /* variable definitions */
 typedef struct
 {
-	char	   *name;	/* variable name */
-	char	   *value;	/* its value */
+	char	   *name;			/* variable name */
+	char	   *value;			/* its value */
 }	Variable;
 
 /*
@@ -107,8 +105,8 @@ typedef struct
 	int			state;			/* state No. */
 	int			cnt;			/* xacts count */
 	int			ecnt;			/* error count */
-	int			listen;			/* 0 indicates that an async query has
-								 * been sent */
+	int			listen;			/* 0 indicates that an async query has been
+								 * sent */
 	Variable   *variables;		/* array of variable definitions */
 	int			nvariables;
 	struct timeval txn_begin;	/* used for measuring latencies */
@@ -124,48 +122,48 @@ typedef struct
 
 typedef struct
 {
-	int			type;	/* command type (SQL_COMMAND or META_COMMAND) */
-	int			argc;	/* number of commands */
-	char	  *argv[MAX_ARGS];	/* command list */
+	int			type;			/* command type (SQL_COMMAND or META_COMMAND) */
+	int			argc;			/* number of commands */
+	char	   *argv[MAX_ARGS]; /* command list */
 }	Command;
 
 #define MAX_FILES		128		/* max number of SQL script files allowed */
 
-Command	**sql_files[MAX_FILES];	/* SQL script files */
-int num_files;	/* its number */
+Command   **sql_files[MAX_FILES];		/* SQL script files */
+int			num_files;			/* its number */
 
 /* default scenario */
 static char *tpc_b = {
-"\\setrandom aid 1 100000\n"
-"\\setrandom bid 1 1\n"
-"\\setrandom tid 1 10\n"
-"\\setrandom delta 1 10000\n"
-"BEGIN;\n"
-"UPDATE accounts SET abalance = abalance + :delta WHERE aid = :aid;\n"
-"SELECT abalance FROM accounts WHERE aid = :aid;\n"
-"UPDATE tellers SET tbalance = tbalance + :delta WHERE tid = :tid;\n"
-"UPDATE branches SET bbalance = bbalance + :delta WHERE bid = :bid;\n"
-"INSERT INTO history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);\n"
-"END;\n"
+	"\\setrandom aid 1 100000\n"
+	"\\setrandom bid 1 1\n"
+	"\\setrandom tid 1 10\n"
+	"\\setrandom delta 1 10000\n"
+	"BEGIN;\n"
+	"UPDATE accounts SET abalance = abalance + :delta WHERE aid = :aid;\n"
+	"SELECT abalance FROM accounts WHERE aid = :aid;\n"
+	"UPDATE tellers SET tbalance = tbalance + :delta WHERE tid = :tid;\n"
+	"UPDATE branches SET bbalance = bbalance + :delta WHERE bid = :bid;\n"
+	"INSERT INTO history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);\n"
+	"END;\n"
 };
 
 /* -N case */
 static char *simple_update = {
-"\\setrandom aid 1 100000\n"
-"\\setrandom bid 1 1\n"
-"\\setrandom tid 1 10\n"
-"\\setrandom delta 1 10000\n"
-"BEGIN;\n"
-"UPDATE accounts SET abalance = abalance + :delta WHERE aid = :aid;\n"
-"SELECT abalance FROM accounts WHERE aid = :aid;\n"
-"INSERT INTO history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);\n"
-"END;\n"
+	"\\setrandom aid 1 100000\n"
+	"\\setrandom bid 1 1\n"
+	"\\setrandom tid 1 10\n"
+	"\\setrandom delta 1 10000\n"
+	"BEGIN;\n"
+	"UPDATE accounts SET abalance = abalance + :delta WHERE aid = :aid;\n"
+	"SELECT abalance FROM accounts WHERE aid = :aid;\n"
+	"INSERT INTO history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);\n"
+	"END;\n"
 };
 
 /* -S case */
 static char *select_only = {
-"\\setrandom aid 1 100000\n"
-"SELECT abalance FROM accounts WHERE aid = :aid;\n"
+	"\\setrandom aid 1 100000\n"
+	"SELECT abalance FROM accounts WHERE aid = :aid;\n"
 };
 
 static void
@@ -262,7 +260,7 @@ compareVariables(const void *v1, const void *v2)
 static char *
 getVariable(CState * st, char *name)
 {
-	Variable		key = { name }, *var;
+	Variable	key = {name}, *var;
 
 	/* On some versions of Solaris, bsearch of zero items dumps core */
 	if (st->nvariables <= 0)
@@ -282,7 +280,7 @@ getVariable(CState * st, char *name)
 static int
 putVariable(CState * st, char *name, char *value)
 {
-	Variable		key = { name }, *var;
+	Variable	key = {name}, *var;
 
 	/* On some versions of Solaris, bsearch of zero items dumps core */
 	if (st->nvariables > 0)
@@ -300,7 +298,7 @@ putVariable(CState * st, char *name, char *value)
 
 		if (st->variables)
 			newvars = (Variable *) realloc(st->variables,
-								(st->nvariables + 1) * sizeof(Variable));
+									(st->nvariables + 1) * sizeof(Variable));
 		else
 			newvars = (Variable *) malloc(sizeof(Variable));
 
@@ -341,15 +339,19 @@ putVariable(CState * st, char *name, char *value)
 static char *
 assignVariables(CState * st, char *sql)
 {
-	int			i, j;
-	char	   *p, *name, *val;
+	int			i,
+				j;
+	char	   *p,
+			   *name,
+			   *val;
 	void	   *tmp;
 
 	i = 0;
 	while ((p = strchr(&sql[i], ':')) != NULL)
 	{
 		i = j = p - sql;
-		do {
+		do
+		{
 			i++;
 		} while (isalnum((unsigned char) sql[i]) || sql[i] == '_');
 		if (i == j + 1)
@@ -403,7 +405,7 @@ doCustom(CState * state, int n, int debug)
 {
 	PGresult   *res;
 	CState	   *st = &state[n];
-	Command		**commands;
+	Command   **commands;
 
 	commands = sql_files[st->use_file];
 
@@ -414,20 +416,19 @@ doCustom(CState * state, int n, int debug)
 			if (debug)
 				fprintf(stderr, "client %d receiving\n", n);
 			if (!PQconsumeInput(st->con))
-			{						/* there's something wrong */
+			{					/* there's something wrong */
 				fprintf(stderr, "Client %d aborted in state %d. Probably the backend died while processing.\n", n, st->state);
-				remains--;			/* I've aborted */
+				remains--;		/* I've aborted */
 				PQfinish(st->con);
 				st->con = NULL;
 				return;
 			}
 			if (PQisBusy(st->con))
-				return;				/* don't have the whole result yet */
+				return;			/* don't have the whole result yet */
 		}
 
 		/*
-		 * transaction finished: record the time it took in the
-		 * log
+		 * transaction finished: record the time it took in the log
 		 */
 		if (use_log && commands[st->state + 1] == NULL)
 		{
@@ -468,7 +469,7 @@ doCustom(CState * state, int n, int debug)
 
 			if (++st->cnt >= nxacts)
 			{
-				remains--;	/* I've done */
+				remains--;		/* I've done */
 				if (st->con != NULL)
 				{
 					PQfinish(st->con);
@@ -483,7 +484,7 @@ doCustom(CState * state, int n, int debug)
 		if (commands[st->state] == NULL)
 		{
 			st->state = 0;
-			st->use_file = getrand(0, num_files-1);
+			st->use_file = getrand(0, num_files - 1);
 		}
 	}
 
@@ -525,13 +526,14 @@ doCustom(CState * state, int n, int debug)
 		}
 		else
 		{
-			st->listen = 1;			/* flags that should be listened */
+			st->listen = 1;		/* flags that should be listened */
 		}
 		free(sql);
 	}
 	else if (commands[st->state]->type == META_COMMAND)
 	{
-		int			argc = commands[st->state]->argc, i;
+		int			argc = commands[st->state]->argc,
+					i;
 		char	  **argv = commands[st->state]->argv;
 
 		if (debug)
@@ -748,28 +750,29 @@ init(void)
 	PQfinish(con);
 }
 
-static Command*
+static Command *
 process_commands(char *buf)
 {
 	const char	delim[] = " \f\n\r\t\v";
 
-	Command	  *my_commands;
+	Command    *my_commands;
 	int			j;
-	char		*p, *tok;
+	char	   *p,
+			   *tok;
 
 	if ((p = strchr(buf, '\n')) != NULL)
-	  *p = '\0';
+		*p = '\0';
 
 	p = buf;
 	while (isspace((unsigned char) *p))
-	  p++;
+		p++;
 
 	if (*p == '\0' || strncmp(p, "--", 2) == 0)
 	{
 		return NULL;
 	}
 
-	my_commands = (Command *)malloc(sizeof(Command));
+	my_commands = (Command *) malloc(sizeof(Command));
 	if (my_commands == NULL)
 	{
 		return NULL;
@@ -794,10 +797,11 @@ process_commands(char *buf)
 			j++;
 			tok = strtok(NULL, delim);
 		}
-		
+
 		if (strcasecmp(my_commands->argv[0], "setrandom") == 0)
 		{
-			int			min, max;
+			int			min,
+						max;
 
 			if (my_commands->argc < 4)
 			{
@@ -806,8 +810,8 @@ process_commands(char *buf)
 			}
 
 			for (j = 4; j < my_commands->argc; j++)
-			  fprintf(stderr, "%s: extra argument \"%s\" ignored\n",
-					  my_commands->argv[0], my_commands->argv[j]);
+				fprintf(stderr, "%s: extra argument \"%s\" ignored\n",
+						my_commands->argv[0], my_commands->argv[j]);
 
 			if ((min = atoi(my_commands->argv[2])) < 0)
 			{
@@ -825,7 +829,7 @@ process_commands(char *buf)
 		}
 		else
 		{
-			fprintf(stderr, "invalid command %s\n",	my_commands->argv[0]);
+			fprintf(stderr, "invalid command %s\n", my_commands->argv[0]);
 			return NULL;
 		}
 	}
@@ -847,11 +851,11 @@ process_file(char *filename)
 {
 #define COMMANDS_ALLOC_NUM 128
 
-	Command	  **my_commands;
+	Command   **my_commands;
 	FILE	   *fd;
 	int			lineno;
 	char		buf[BUFSIZ];
-	int	alloc_num;
+	int			alloc_num;
 
 	if (num_files >= MAX_FILES)
 	{
@@ -860,7 +864,7 @@ process_file(char *filename)
 	}
 
 	alloc_num = COMMANDS_ALLOC_NUM;
-	my_commands = (Command **)malloc(sizeof(Command **)*alloc_num);
+	my_commands = (Command **) malloc(sizeof(Command **) * alloc_num);
 	if (my_commands == NULL)
 		return false;
 
@@ -876,7 +880,7 @@ process_file(char *filename)
 
 	while (fgets(buf, sizeof(buf), fd) != NULL)
 	{
-		Command *commands;
+		Command    *commands;
 
 		commands = process_commands(buf);
 		if (commands == NULL)
@@ -913,25 +917,25 @@ process_builtin(char *tb)
 {
 #define COMMANDS_ALLOC_NUM 128
 
-	Command	  **my_commands;
+	Command   **my_commands;
 	int			lineno;
 	char		buf[BUFSIZ];
-	int	alloc_num;
+	int			alloc_num;
 
 	if (*tb == '\0')
 		return NULL;
 
 	alloc_num = COMMANDS_ALLOC_NUM;
-	my_commands = malloc(sizeof(Command **)*alloc_num);
+	my_commands = malloc(sizeof(Command **) * alloc_num);
 	if (my_commands == NULL)
 		return NULL;
 
 	lineno = 0;
 
-	for(;;)
+	for (;;)
 	{
-		char *p;
-		Command *commands;
+		char	   *p;
+		Command    *commands;
 
 		p = buf;
 		while (*tb && *tb != '\n')
@@ -1016,20 +1020,18 @@ main(int argc, char **argv)
 {
 	int			c;
 	int			is_init_mode = 0;		/* initialize mode? */
-	int			is_no_vacuum = 0;		/* no vacuum at all before
-										 * testing? */
+	int			is_no_vacuum = 0;		/* no vacuum at all before testing? */
 	int			is_full_vacuum = 0;		/* do full vacuum before testing? */
 	int			debug = 0;		/* debug flag */
-	int			ttype = 0;		/* transaction type. 0: TPC-B, 1: SELECT
-								 * only, 2: skip update of branches and
-								 * tellers */
+	int			ttype = 0;		/* transaction type. 0: TPC-B, 1: SELECT only,
+								 * 2: skip update of branches and tellers */
 	char	   *filename = NULL;
 
 	static CState *state;		/* status of clients */
 
 	struct timeval tv1;			/* start up time */
-	struct timeval tv2;			/* after establishing all connections to
-								 * the backend */
+	struct timeval tv2;			/* after establishing all connections to the
+								 * backend */
 	struct timeval tv3;			/* end time */
 
 	int			i;
@@ -1105,7 +1107,8 @@ main(int argc, char **argv)
 					fprintf(stderr, "Use limit/ulimt to increase the limit before using pgbench.\n");
 					exit(1);
 				}
-#endif   /* #if !(defined(__CYGWIN__) || defined(__MINGW32__)) */
+#endif   /* #if !(defined(__CYGWIN__) ||
+								 * defined(__MINGW32__)) */
 				break;
 			case 'C':
 				is_connect = 1;
@@ -1305,35 +1308,35 @@ main(int argc, char **argv)
 	/* process bultin SQL scripts */
 	switch (ttype)
 	{
-		char buf[128];
+			char		buf[128];
 
 		case 0:
 			sql_files[0] = process_builtin(tpc_b);
-			snprintf(buf, sizeof(buf), "%d", 100000*tps);
+			snprintf(buf, sizeof(buf), "%d", 100000 * tps);
 			sql_files[0][0]->argv[3] = strdup(buf);
-			snprintf(buf, sizeof(buf), "%d", 1*tps);
+			snprintf(buf, sizeof(buf), "%d", 1 * tps);
 			sql_files[0][1]->argv[3] = strdup(buf);
-			snprintf(buf, sizeof(buf), "%d", 10*tps);
+			snprintf(buf, sizeof(buf), "%d", 10 * tps);
 			sql_files[0][2]->argv[3] = strdup(buf);
-			snprintf(buf, sizeof(buf), "%d", 10000*tps);
+			snprintf(buf, sizeof(buf), "%d", 10000 * tps);
 			sql_files[0][3]->argv[3] = strdup(buf);
 			num_files = 1;
 			break;
 		case 1:
 			sql_files[0] = process_builtin(select_only);
-			snprintf(buf, sizeof(buf), "%d", 100000*tps);
+			snprintf(buf, sizeof(buf), "%d", 100000 * tps);
 			sql_files[0][0]->argv[3] = strdup(buf);
 			num_files = 1;
 			break;
 		case 2:
 			sql_files[0] = process_builtin(simple_update);
-			snprintf(buf, sizeof(buf), "%d", 100000*tps);
+			snprintf(buf, sizeof(buf), "%d", 100000 * tps);
 			sql_files[0][0]->argv[3] = strdup(buf);
-			snprintf(buf, sizeof(buf), "%d", 1*tps);
+			snprintf(buf, sizeof(buf), "%d", 1 * tps);
 			sql_files[0][1]->argv[3] = strdup(buf);
-			snprintf(buf, sizeof(buf), "%d", 10*tps);
+			snprintf(buf, sizeof(buf), "%d", 10 * tps);
 			sql_files[0][2]->argv[3] = strdup(buf);
-			snprintf(buf, sizeof(buf), "%d", 10000*tps);
+			snprintf(buf, sizeof(buf), "%d", 10000 * tps);
 			sql_files[0][3]->argv[3] = strdup(buf);
 			num_files = 1;
 			break;
@@ -1344,7 +1347,7 @@ main(int argc, char **argv)
 	/* send start up queries in async manner */
 	for (i = 0; i < nclients; i++)
 	{
-		state[i].use_file = getrand(0, num_files-1);
+		state[i].use_file = getrand(0, num_files - 1);
 		doCustom(state, i, debug);
 	}
 
@@ -1366,9 +1369,9 @@ main(int argc, char **argv)
 		maxsock = -1;
 		for (i = 0; i < nclients; i++)
 		{
-			Command **commands = sql_files[state[i].use_file];
+			Command   **commands = sql_files[state[i].use_file];
 
-			if (state[i].con &&	commands[state[i].state]->type != META_COMMAND)
+			if (state[i].con && commands[state[i].state]->type != META_COMMAND)
 			{
 				int			sock = PQsocket(state[i].con);
 
@@ -1396,7 +1399,7 @@ main(int argc, char **argv)
 				exit(1);
 			}
 			else if (nsocks == 0)
-			{						/* timeout */
+			{					/* timeout */
 				fprintf(stderr, "select timeout\n");
 				for (i = 0; i < nclients; i++)
 				{
@@ -1410,10 +1413,10 @@ main(int argc, char **argv)
 		/* ok, backend returns reply */
 		for (i = 0; i < nclients; i++)
 		{
-			Command **commands = sql_files[state[i].use_file];
+			Command   **commands = sql_files[state[i].use_file];
 
 			if (state[i].con && (FD_ISSET(PQsocket(state[i].con), &input_mask)
-								 || commands[state[i].state]->type == META_COMMAND))
+						  || commands[state[i].state]->type == META_COMMAND))
 			{
 				doCustom(state, i, debug);
 			}
diff --git a/contrib/pgcrypto/crypt-blowfish.c b/contrib/pgcrypto/crypt-blowfish.c
index a882cf4c87..42a694b62f 100644
--- a/contrib/pgcrypto/crypt-blowfish.c
+++ b/contrib/pgcrypto/crypt-blowfish.c
@@ -520,7 +520,6 @@ extern void _BF_body_r(BF_ctx * ctx);
 
 #define BF_body() \
 	_BF_body_r(&data.ctx);
-
 #else
 
 #define BF_body() \
@@ -712,7 +711,7 @@ _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. :-) */
diff --git a/contrib/pgcrypto/crypt-des.c b/contrib/pgcrypto/crypt-des.c
index 2a6a1f8aff..dcd875c965 100644
--- a/contrib/pgcrypto/crypt-des.c
+++ b/contrib/pgcrypto/crypt-des.c
@@ -246,8 +246,8 @@ des_init(void)
 		}
 
 	/*
-	 * 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++)
@@ -267,8 +267,8 @@ des_init(void)
 	}
 
 	/*
-	 * Invert the key permutation and initialise the inverted key
-	 * compression permutation.
+	 * Invert the key permutation and initialise the inverted key compression
+	 * permutation.
 	 */
 	for (i = 0; i < 56; i++)
 	{
@@ -284,8 +284,8 @@ des_init(void)
 		inv_comp_perm[comp_perm[i] - 1] = i;
 
 	/*
-	 * Set up the OR-mask arrays for the initial and final permutations,
-	 * and for the key initial and compression permutations.
+	 * Set up the OR-mask arrays for the initial and final permutations, and
+	 * for the key initial and compression permutations.
 	 */
 	for (k = 0; k < 8; k++)
 	{
@@ -347,8 +347,8 @@ des_init(void)
 	}
 
 	/*
-	 * Invert the P-box permutation, and convert into OR-masks for
-	 * handling the output of the S-box arrays setup above.
+	 * Invert the P-box permutation, and convert into OR-masks for handling
+	 * the output of the S-box arrays setup above.
 	 */
 	for (i = 0; i < 32; i++)
 		un_pbox[pbox[i] - 1] = i;
@@ -411,9 +411,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);
 	}
@@ -560,16 +560,16 @@ do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count)
 				| ((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]]
@@ -660,8 +660,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)
@@ -706,10 +706,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);
@@ -728,9 +728,9 @@ px_crypt_des(const char *key, const char *setting)
 		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];
 
diff --git a/contrib/pgcrypto/crypt-gensalt.c b/contrib/pgcrypto/crypt-gensalt.c
index 8713b99a16..656ab03ef7 100644
--- a/contrib/pgcrypto/crypt-gensalt.c
+++ b/contrib/pgcrypto/crypt-gensalt.c
@@ -22,7 +22,7 @@ unsigned char _crypt_itoa64[64 + 1] =
 
 char *
 _crypt_gensalt_traditional_rn(unsigned long count,
-			  const char *input, int size, char *output, int output_size)
+				  const char *input, int size, char *output, int output_size)
 {
 	if (size < 2 || output_size < 2 + 1 || (count && count != 25))
 	{
@@ -40,7 +40,7 @@ _crypt_gensalt_traditional_rn(unsigned long count,
 
 char *
 _crypt_gensalt_extended_rn(unsigned long count,
-			  const char *input, int size, char *output, int output_size)
+				  const char *input, int size, char *output, int output_size)
 {
 	unsigned long value;
 
@@ -76,7 +76,7 @@ _crypt_gensalt_extended_rn(unsigned long count,
 
 char *
 _crypt_gensalt_md5_rn(unsigned long count,
-			  const char *input, int size, char *output, int output_size)
+				  const char *input, int size, char *output, int output_size)
 {
 	unsigned long value;
 
@@ -158,7 +158,7 @@ BF_encode(char *dst, const BF_word * src, int size)
 
 char *
 _crypt_gensalt_blowfish_rn(unsigned long count,
-			  const char *input, int size, char *output, int output_size)
+				  const char *input, int size, char *output, int output_size)
 {
 	if (size < 16 || output_size < 7 + 22 + 1 ||
 		(count && (count < 4 || count > 31)))
diff --git a/contrib/pgcrypto/crypt-md5.c b/contrib/pgcrypto/crypt-md5.c
index 8364565646..5455665a44 100644
--- a/contrib/pgcrypto/crypt-md5.c
+++ b/contrib/pgcrypto/crypt-md5.c
@@ -24,9 +24,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;
diff --git a/contrib/pgcrypto/fortuna.c b/contrib/pgcrypto/fortuna.c
index 163deefbd2..77204f96bf 100644
--- a/contrib/pgcrypto/fortuna.c
+++ b/contrib/pgcrypto/fortuna.c
@@ -43,16 +43,16 @@
  * Why Fortuna-like: There does not seem to be any definitive reference
  * on Fortuna in the net.  Instead this implementation is based on
  * following references:
- * 
+ *
  * http://en.wikipedia.org/wiki/Fortuna_(PRNG)
- *   - Wikipedia article
+ *	 - Wikipedia article
  * http://jlcooke.ca/random/
- *   - Jean-Luc Cooke Fortuna-based /dev/random driver for Linux.
+ *	 - Jean-Luc Cooke Fortuna-based /dev/random driver for Linux.
  */
 
 /*
  * There is some confusion about whether and how to carry forward
- * the state of the pools.  Seems like original Fortuna does not
+ * the state of the pools.	Seems like original Fortuna does not
  * do it, resetting hash after each request.  I guess expecting
  * feeding to happen more often that requesting.   This is absolutely
  * unsuitable for pgcrypto, as nothing asynchronous happens here.
@@ -76,7 +76,7 @@
  * How many pools.
  *
  * Original Fortuna uses 32 pools, that means 32'th pool is
- * used not earlier than in 13th year.  This is a waste in
+ * used not earlier than in 13th year.	This is a waste in
  * pgcrypto, as we have very low-frequancy seeding.  Here
  * is preferable to have all entropy usable in reasonable time.
  *
@@ -89,12 +89,12 @@
 #define NUM_POOLS		23
 
 /* in microseconds */
-#define RESEED_INTERVAL	100000 /* 0.1 sec */
+#define RESEED_INTERVAL 100000	/* 0.1 sec */
 
 /* for one big request, reseed after this many bytes */
 #define RESEED_BYTES	(1024*1024)
 
-/* 
+/*
  * Skip reseed if pool 0 has less than this many
  * bytes added since last reseed.
  */
@@ -114,17 +114,18 @@
 #define MD_CTX			SHA256_CTX
 #define CIPH_CTX		rijndael_ctx
 
-struct fortuna_state {
-	uint8			counter[CIPH_BLOCK];
-	uint8			result[CIPH_BLOCK];
-	uint8			key[BLOCK];
-	MD_CTX			pool[NUM_POOLS];
-	CIPH_CTX		ciph;
-	unsigned		reseed_count;
-	struct timeval	last_reseed_time;
-	unsigned		pool0_bytes;
-	unsigned		rnd_pos;
-	int				counter_init;
+struct fortuna_state
+{
+	uint8		counter[CIPH_BLOCK];
+	uint8		result[CIPH_BLOCK];
+	uint8		key[BLOCK];
+	MD_CTX		pool[NUM_POOLS];
+	CIPH_CTX	ciph;
+	unsigned	reseed_count;
+	struct timeval last_reseed_time;
+	unsigned	pool0_bytes;
+	unsigned	rnd_pos;
+	int			counter_init;
 };
 typedef struct fortuna_state FState;
 
@@ -137,29 +138,35 @@ typedef struct fortuna_state FState;
  * - No memory allocations.
  */
 
-static void ciph_init(CIPH_CTX *ctx, const uint8 *key, int klen)
+static void
+ciph_init(CIPH_CTX * ctx, const uint8 *key, int klen)
 {
-	rijndael_set_key(ctx, (const uint32 *)key, klen, 1);
+	rijndael_set_key(ctx, (const uint32 *) key, klen, 1);
 }
 
-static void ciph_encrypt(CIPH_CTX *ctx, const uint8 *in, uint8 *out)
+static void
+ciph_encrypt(CIPH_CTX * ctx, const uint8 *in, uint8 *out)
 {
-	rijndael_encrypt(ctx, (const uint32 *)in, (uint32 *)out);
+	rijndael_encrypt(ctx, (const uint32 *) in, (uint32 *) out);
 }
 
-static void md_init(MD_CTX *ctx)
+static void
+md_init(MD_CTX * ctx)
 {
 	SHA256_Init(ctx);
 }
 
-static void md_update(MD_CTX *ctx, const uint8 *data, int len)
+static void
+md_update(MD_CTX * ctx, const uint8 *data, int len)
 {
 	SHA256_Update(ctx, data, len);
 }
 
-static void md_result(MD_CTX *ctx, uint8 *dst)
+static void
+md_result(MD_CTX * ctx, uint8 *dst)
 {
-	SHA256_CTX tmp;
+	SHA256_CTX	tmp;
+
 	memcpy(&tmp, ctx, sizeof(*ctx));
 	SHA256_Final(dst, &tmp);
 	memset(&tmp, 0, sizeof(tmp));
@@ -168,9 +175,11 @@ static void md_result(MD_CTX *ctx, uint8 *dst)
 /*
  * initialize state
  */
-static void init_state(FState *st)
+static void
+init_state(FState * st)
 {
-	int i;
+	int			i;
+
 	memset(st, 0, sizeof(*st));
 	for (i = 0; i < NUM_POOLS; i++)
 		md_init(&st->pool[i]);
@@ -180,9 +189,11 @@ static void init_state(FState *st)
  * Endianess does not matter.
  * It just needs to change without repeating.
  */
-static void inc_counter(FState *st)
+static void
+inc_counter(FState * st)
 {
-	uint32 *val = (uint32*)st->counter;
+	uint32	   *val = (uint32 *) st->counter;
+
 	if (++val[0])
 		return;
 	if (++val[1])
@@ -195,7 +206,8 @@ static void inc_counter(FState *st)
 /*
  * This is called 'cipher in counter mode'.
  */
-static void encrypt_counter(FState *st, uint8 *dst)
+static void
+encrypt_counter(FState * st, uint8 *dst)
 {
 	ciph_encrypt(&st->ciph, st->counter, dst);
 	inc_counter(st);
@@ -206,12 +218,13 @@ static void encrypt_counter(FState *st, uint8 *dst)
  * The time between reseed must be at least RESEED_INTERVAL
  * microseconds.
  */
-static int too_often(FState *st)
+static int
+too_often(FState * st)
 {
-	int ok;
+	int			ok;
 	struct timeval tv;
 	struct timeval *last = &st->last_reseed_time;
-	
+
 	gettimeofday(&tv, NULL);
 
 	ok = 0;
@@ -229,19 +242,19 @@ static int too_often(FState *st)
 /*
  * generate new key from all the pools
  */
-static void reseed(FState *st)
+static void
+reseed(FState * st)
 {
-	unsigned k;
-	unsigned n;
-	MD_CTX key_md;
-	uint8 buf[BLOCK];
+	unsigned	k;
+	unsigned	n;
+	MD_CTX		key_md;
+	uint8		buf[BLOCK];
 
 	/* set pool as empty */
 	st->pool0_bytes = 0;
 
 	/*
-	 * Both #0 and #1 reseed would use only pool 0.
-	 * Just skip #0 then.
+	 * Both #0 and #1 reseed would use only pool 0. Just skip #0 then.
 	 */
 	n = ++st->reseed_count;
 
@@ -249,7 +262,8 @@ static void reseed(FState *st)
 	 * The goal: use k-th pool only 1/(2^k) of the time.
 	 */
 	md_init(&key_md);
-	for (k = 0; k < NUM_POOLS; k++) {
+	for (k = 0; k < NUM_POOLS; k++)
+	{
 		md_result(&st->pool[k], buf);
 		md_update(&key_md, buf, BLOCK);
 
@@ -272,11 +286,12 @@ static void reseed(FState *st)
 }
 
 /*
- * Pick a random pool.  This uses key bytes as random source.
+ * Pick a random pool.	This uses key bytes as random source.
  */
-static unsigned get_rand_pool(FState *st)
+static unsigned
+get_rand_pool(FState * st)
 {
-	unsigned rnd;
+	unsigned	rnd;
 
 	/*
 	 * This slightly prefers lower pools - thats OK.
@@ -293,11 +308,12 @@ static unsigned get_rand_pool(FState *st)
 /*
  * update pools
  */
-static void add_entropy(FState *st, const uint8 *data, unsigned len)
+static void
+add_entropy(FState * st, const uint8 *data, unsigned len)
 {
-	unsigned pos;
-	uint8 hash[BLOCK];
-	MD_CTX md;
+	unsigned	pos;
+	uint8		hash[BLOCK];
+	MD_CTX		md;
 
 	/* hash given data */
 	md_init(&md);
@@ -305,14 +321,13 @@ static void add_entropy(FState *st, const uint8 *data, unsigned len)
 	md_result(&md, hash);
 
 	/*
-	 * Make sure the pool 0 is initialized,
-	 * then update randomly.
+	 * Make sure the pool 0 is initialized, then update randomly.
 	 */
 	if (st->reseed_count == 0 && st->pool0_bytes < POOL0_FILL)
 		pos = 0;
 	else
 		pos = get_rand_pool(st);
-	md_update( &st->pool[pos], hash, BLOCK);
+	md_update(&st->pool[pos], hash, BLOCK);
 
 	if (pos == 0)
 		st->pool0_bytes += len;
@@ -324,7 +339,8 @@ static void add_entropy(FState *st, const uint8 *data, unsigned len)
 /*
  * Just take 2 next blocks as new key
  */
-static void rekey(FState *st)
+static void
+rekey(FState * st)
 {
 	encrypt_counter(st, st->key);
 	encrypt_counter(st, st->key + CIPH_BLOCK);
@@ -336,7 +352,8 @@ static void rekey(FState *st)
  * In case it does not, slow down the attacker by initialising
  * the couter to random value.
  */
-static void init_counter(FState *st)
+static void
+init_counter(FState * st)
 {
 	/* Use next block as counter. */
 	encrypt_counter(st, st->counter);
@@ -348,10 +365,11 @@ static void init_counter(FState *st)
 	st->counter_init = 1;
 }
 
-static void extract_data(FState *st, unsigned count, uint8 *dst)
+static void
+extract_data(FState * st, unsigned count, uint8 *dst)
 {
-	unsigned n;
-	unsigned block_nr = 0;
+	unsigned	n;
+	unsigned	block_nr = 0;
 
 	/* Can we reseed? */
 	if (st->pool0_bytes >= POOL0_FILL && !too_often(st))
@@ -361,7 +379,8 @@ static void extract_data(FState *st, unsigned count, uint8 *dst)
 	if (!st->counter_init)
 		init_counter(st);
 
-	while (count > 0) {
+	while (count > 0)
+	{
 		/* produce bytes */
 		encrypt_counter(st, st->result);
 
@@ -391,9 +410,10 @@ static void extract_data(FState *st, unsigned count, uint8 *dst)
  */
 
 static FState main_state;
-static int init_done = 0;
+static int	init_done = 0;
 
-void fortuna_add_entropy(const uint8 *data, unsigned len)
+void
+fortuna_add_entropy(const uint8 *data, unsigned len)
 {
 	if (!init_done)
 	{
@@ -405,7 +425,8 @@ void fortuna_add_entropy(const uint8 *data, unsigned len)
 	add_entropy(&main_state, data, len);
 }
 
-void fortuna_get_bytes(unsigned len, uint8 *dst)
+void
+fortuna_get_bytes(unsigned len, uint8 *dst)
 {
 	if (!init_done)
 	{
@@ -416,4 +437,3 @@ void fortuna_get_bytes(unsigned len, uint8 *dst)
 		return;
 	extract_data(&main_state, len, dst);
 }
-
diff --git a/contrib/pgcrypto/fortuna.h b/contrib/pgcrypto/fortuna.h
index a1efca6705..03e91a2e25 100644
--- a/contrib/pgcrypto/fortuna.h
+++ b/contrib/pgcrypto/fortuna.h
@@ -32,8 +32,7 @@
 #ifndef __FORTUNA_H
 #define __FORTUNA_H
 
-void fortuna_get_bytes(unsigned len, uint8 *dst);
-void fortuna_add_entropy(const uint8 *data, unsigned len);
+void		fortuna_get_bytes(unsigned len, uint8 *dst);
+void		fortuna_add_entropy(const uint8 *data, unsigned len);
 
 #endif
-
diff --git a/contrib/pgcrypto/internal.c b/contrib/pgcrypto/internal.c
index d9f4a86e36..c395c9309d 100644
--- a/contrib/pgcrypto/internal.c
+++ b/contrib/pgcrypto/internal.c
@@ -52,7 +52,7 @@
 /*
  * The chance is x/256 that the reseed happens.
  */
-#define SYSTEM_RESEED_CHANCE		(4)	/* 256/4 * 10min ~ 10h */
+#define SYSTEM_RESEED_CHANCE		(4) /* 256/4 * 10min ~ 10h */
 
 /*
  * If this much time has passed, force reseed.
@@ -88,13 +88,13 @@ struct int_digest
 };
 
 static const struct int_digest
-int_digest_list[] = {
-	{ "md5", init_md5 },
-	{ "sha1", init_sha1 },
-	{ "sha256", init_sha256 },
-	{ "sha384", init_sha384 },
-	{ "sha512", init_sha512 },
-	{ NULL, NULL }
+			int_digest_list[] = {
+	{"md5", init_md5},
+	{"sha1", init_sha1},
+	{"sha256", init_sha256},
+	{"sha384", init_sha384},
+	{"sha512", init_sha512},
+	{NULL, NULL}
 };
 
 /* MD5 */
@@ -210,7 +210,7 @@ int_sha256_block_len(PX_MD * h)
 static void
 int_sha256_update(PX_MD * h, const uint8 *data, unsigned dlen)
 {
-	SHA256_CTX   *ctx = (SHA256_CTX *) h->p.ptr;
+	SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 
 	SHA256_Update(ctx, data, dlen);
 }
@@ -218,7 +218,7 @@ int_sha256_update(PX_MD * h, const uint8 *data, unsigned dlen)
 static void
 int_sha256_reset(PX_MD * h)
 {
-	SHA256_CTX   *ctx = (SHA256_CTX *) h->p.ptr;
+	SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 
 	SHA256_Init(ctx);
 }
@@ -226,7 +226,7 @@ int_sha256_reset(PX_MD * h)
 static void
 int_sha256_finish(PX_MD * h, uint8 *dst)
 {
-	SHA256_CTX   *ctx = (SHA256_CTX *) h->p.ptr;
+	SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 
 	SHA256_Final(dst, ctx);
 }
@@ -234,12 +234,13 @@ int_sha256_finish(PX_MD * h, uint8 *dst)
 static void
 int_sha256_free(PX_MD * h)
 {
-	SHA256_CTX   *ctx = (SHA256_CTX *) h->p.ptr;
+	SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
 
 	memset(ctx, 0, sizeof(*ctx));
 	px_free(ctx);
 	px_free(h);
 }
+
 /* SHA384 */
 
 static unsigned
@@ -257,7 +258,7 @@ int_sha384_block_len(PX_MD * h)
 static void
 int_sha384_update(PX_MD * h, const uint8 *data, unsigned dlen)
 {
-	SHA384_CTX   *ctx = (SHA384_CTX *) h->p.ptr;
+	SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 
 	SHA384_Update(ctx, data, dlen);
 }
@@ -265,7 +266,7 @@ int_sha384_update(PX_MD * h, const uint8 *data, unsigned dlen)
 static void
 int_sha384_reset(PX_MD * h)
 {
-	SHA384_CTX   *ctx = (SHA384_CTX *) h->p.ptr;
+	SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 
 	SHA384_Init(ctx);
 }
@@ -273,7 +274,7 @@ int_sha384_reset(PX_MD * h)
 static void
 int_sha384_finish(PX_MD * h, uint8 *dst)
 {
-	SHA384_CTX   *ctx = (SHA384_CTX *) h->p.ptr;
+	SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 
 	SHA384_Final(dst, ctx);
 }
@@ -281,7 +282,7 @@ int_sha384_finish(PX_MD * h, uint8 *dst)
 static void
 int_sha384_free(PX_MD * h)
 {
-	SHA384_CTX   *ctx = (SHA384_CTX *) h->p.ptr;
+	SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
 
 	memset(ctx, 0, sizeof(*ctx));
 	px_free(ctx);
@@ -305,7 +306,7 @@ int_sha512_block_len(PX_MD * h)
 static void
 int_sha512_update(PX_MD * h, const uint8 *data, unsigned dlen)
 {
-	SHA512_CTX   *ctx = (SHA512_CTX *) h->p.ptr;
+	SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 
 	SHA512_Update(ctx, data, dlen);
 }
@@ -313,7 +314,7 @@ int_sha512_update(PX_MD * h, const uint8 *data, unsigned dlen)
 static void
 int_sha512_reset(PX_MD * h)
 {
-	SHA512_CTX   *ctx = (SHA512_CTX *) h->p.ptr;
+	SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 
 	SHA512_Init(ctx);
 }
@@ -321,7 +322,7 @@ int_sha512_reset(PX_MD * h)
 static void
 int_sha512_finish(PX_MD * h, uint8 *dst)
 {
-	SHA512_CTX   *ctx = (SHA512_CTX *) h->p.ptr;
+	SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 
 	SHA512_Final(dst, ctx);
 }
@@ -329,7 +330,7 @@ int_sha512_finish(PX_MD * h, uint8 *dst)
 static void
 int_sha512_free(PX_MD * h)
 {
-	SHA512_CTX   *ctx = (SHA512_CTX *) h->p.ptr;
+	SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
 
 	memset(ctx, 0, sizeof(*ctx));
 	px_free(ctx);
@@ -381,7 +382,7 @@ init_sha1(PX_MD * md)
 static void
 init_sha256(PX_MD * md)
 {
-	SHA256_CTX   *ctx;
+	SHA256_CTX *ctx;
 
 	ctx = px_alloc(sizeof(*ctx));
 	memset(ctx, 0, sizeof(*ctx));
@@ -401,7 +402,7 @@ init_sha256(PX_MD * md)
 static void
 init_sha384(PX_MD * md)
 {
-	SHA384_CTX   *ctx;
+	SHA384_CTX *ctx;
 
 	ctx = px_alloc(sizeof(*ctx));
 	memset(ctx, 0, sizeof(*ctx));
@@ -421,7 +422,7 @@ init_sha384(PX_MD * md)
 static void
 init_sha512(PX_MD * md)
 {
-	SHA512_CTX   *ctx;
+	SHA512_CTX *ctx;
 
 	ctx = px_alloc(sizeof(*ctx));
 	memset(ctx, 0, sizeof(*ctx));
@@ -752,12 +753,12 @@ struct int_cipher
 };
 
 static const struct int_cipher
-int_ciphers[] = {
-	{ "bf-cbc", bf_cbc_load },
-	{ "bf-ecb", bf_ecb_load },
-	{ "aes-128-cbc", rj_128_cbc },
-	{ "aes-128-ecb", rj_128_ecb },
-	{ NULL, NULL }
+			int_ciphers[] = {
+	{"bf-cbc", bf_cbc_load},
+	{"bf-ecb", bf_ecb_load},
+	{"aes-128-cbc", rj_128_cbc},
+	{"aes-128-ecb", rj_128_ecb},
+	{NULL, NULL}
 };
 
 static const PX_Alias int_aliases[] = {
@@ -828,7 +829,7 @@ px_find_cipher(const char *name, PX_Cipher ** res)
 int
 px_get_pseudo_random_bytes(uint8 *dst, unsigned count)
 {
-	int         i;
+	int			i;
 
 	for (i = 0; i < count; i++)
 		*dst++ = random();
@@ -838,12 +839,13 @@ px_get_pseudo_random_bytes(uint8 *dst, unsigned count)
 static time_t seed_time = 0;
 static time_t check_time = 0;
 
-static void system_reseed(void)
+static void
+system_reseed(void)
 {
-	uint8 buf[1024];
-	int n;
-	time_t t;
-	int skip = 1;
+	uint8		buf[1024];
+	int			n;
+	time_t		t;
+	int			skip = 1;
 
 	t = time(NULL);
 
@@ -890,4 +892,3 @@ px_add_entropy(const uint8 *data, unsigned count)
 	fortuna_add_entropy(data, count);
 	return 0;
 }
-
diff --git a/contrib/pgcrypto/mbuf.c b/contrib/pgcrypto/mbuf.c
index c7a8a632da..2103609a0e 100644
--- a/contrib/pgcrypto/mbuf.c
+++ b/contrib/pgcrypto/mbuf.c
@@ -166,7 +166,8 @@ mbuf_grab(MBuf * mbuf, int len, uint8 **data_p)
 	return len;
 }
 
-int mbuf_rewind(MBuf *mbuf)
+int
+mbuf_rewind(MBuf * mbuf)
 {
 	mbuf->read_pos = mbuf->data;
 	return 0;
@@ -175,7 +176,7 @@ int mbuf_rewind(MBuf *mbuf)
 int
 mbuf_steal_data(MBuf * mbuf, uint8 **data_p)
 {
-	int len = mbuf_size(mbuf);
+	int			len = mbuf_size(mbuf);
 
 	mbuf->no_write = 1;
 	mbuf->own_data = 0;
@@ -193,7 +194,7 @@ mbuf_steal_data(MBuf * mbuf, uint8 **data_p)
 
 struct PullFilter
 {
-	PullFilter	   *src;
+	PullFilter *src;
 	const PullFilterOps *op;
 	int			buflen;
 	uint8	   *buf;
@@ -204,7 +205,7 @@ struct PullFilter
 int
 pullf_create(PullFilter ** pf_p, const PullFilterOps * op, void *init_arg, PullFilter * src)
 {
-	PullFilter	   *pf;
+	PullFilter *pf;
 	void	   *priv;
 	int			res;
 
@@ -260,13 +261,14 @@ pullf_free(PullFilter * pf)
 int
 pullf_read(PullFilter * pf, int len, uint8 **data_p)
 {
-	int res;
+	int			res;
+
 	if (pf->op->pull)
 	{
 		if (pf->buflen && len > pf->buflen)
 			len = pf->buflen;
 		res = pf->op->pull(pf->priv, pf->src, len, data_p,
-				pf->buf, pf->buflen);
+						   pf->buf, pf->buflen);
 	}
 	else
 		res = pullf_read(pf->src, len, data_p);
@@ -276,8 +278,9 @@ pullf_read(PullFilter * pf, int len, uint8 **data_p)
 int
 pullf_read_max(PullFilter * pf, int len, uint8 **data_p, uint8 *tmpbuf)
 {
-	int res, total;
-	uint8 *tmp;
+	int			res,
+				total;
+	uint8	   *tmp;
 
 	res = pullf_read(pf, len, data_p);
 	if (res <= 0 || res == len)
@@ -288,8 +291,9 @@ pullf_read_max(PullFilter * pf, int len, uint8 **data_p, uint8 *tmpbuf)
 	*data_p = tmpbuf;
 	len -= res;
 	total = res;
-	
-	while (len > 0) {
+
+	while (len > 0)
+	{
 		res = pullf_read(pf, len, &tmp);
 		if (res < 0)
 		{
@@ -308,10 +312,12 @@ pullf_read_max(PullFilter * pf, int len, uint8 **data_p, uint8 *tmpbuf)
 /*
  * caller wants exatly len bytes and dont bother with references
  */
-int pullf_read_fixed(PullFilter *src, int len, uint8 *dst)
+int
+pullf_read_fixed(PullFilter * src, int len, uint8 *dst)
 {
-	int res;
-	uint8 *p;
+	int			res;
+	uint8	   *p;
+
 	res = pullf_read_max(src, len, &p, dst);
 	if (res < 0)
 		return res;
@@ -330,9 +336,10 @@ int pullf_read_fixed(PullFilter *src, int len, uint8 *dst)
  */
 static int
 pull_from_mbuf(void *arg, PullFilter * src, int len,
-		uint8 **data_p, uint8 *buf, int buflen)
+			   uint8 **data_p, uint8 *buf, int buflen)
 {
 	MBuf	   *mbuf = arg;
+
 	return mbuf_grab(mbuf, len, data_p);
 }
 
@@ -364,7 +371,7 @@ struct PushFilter
 int
 pushf_create(PushFilter ** mp_p, const PushFilterOps * op, void *init_arg, PushFilter * next)
 {
-	PushFilter	   *mp;
+	PushFilter *mp;
 	void	   *priv;
 	int			res;
 
@@ -419,7 +426,7 @@ pushf_free(PushFilter * mp)
 void
 pushf_free_all(PushFilter * mp)
 {
-	PushFilter	   *tmp;
+	PushFilter *tmp;
 
 	while (mp)
 	{
@@ -549,8 +556,8 @@ static const struct PushFilterOps mbuf_filter = {
 	NULL, push_into_mbuf, NULL, NULL
 };
 
-int pushf_create_mbuf_writer(PushFilter **res, MBuf *dst)
+int
+pushf_create_mbuf_writer(PushFilter ** res, MBuf * dst)
 {
 	return pushf_create(res, &mbuf_filter, dst, NULL);
 }
-
diff --git a/contrib/pgcrypto/mbuf.h b/contrib/pgcrypto/mbuf.h
index 6dd284f23b..3dae0770a9 100644
--- a/contrib/pgcrypto/mbuf.h
+++ b/contrib/pgcrypto/mbuf.h
@@ -40,32 +40,36 @@ typedef struct PullFilterOps PullFilterOps;
 
 struct PushFilterOps
 {
-	/* should return needed buffer size, 0- no buffering, <0 on error
-	 * if NULL, no buffering, and priv=init_arg
+	/*
+	 * should return needed buffer size, 0- no buffering, <0 on error if NULL,
+	 * no buffering, and priv=init_arg
 	 */
 	int			(*init) (PushFilter * next, void *init_arg, void **priv_p);
-	/* send data to next.  should consume all?
-	 * if null, it will be simply copied (in-place)
-	 * returns 0 on error
+
+	/*
+	 * send data to next.  should consume all? if null, it will be simply
+	 * copied (in-place) returns 0 on error
 	 */
 	int			(*push) (PushFilter * next, void *priv,
-							const uint8 *src, int len);
+									 const uint8 *src, int len);
 	int			(*flush) (PushFilter * next, void *priv);
 	void		(*free) (void *priv);
 };
 
 struct PullFilterOps
 {
-	/* should return needed buffer size, 0- no buffering, <0 on error
-	 * if NULL, no buffering, and priv=init_arg
+	/*
+	 * should return needed buffer size, 0- no buffering, <0 on error if NULL,
+	 * no buffering, and priv=init_arg
 	 */
 	int			(*init) (void **priv_p, void *init_arg, PullFilter * src);
-	/* request data from src, put result ptr to data_p
-	 * can use ptr from src or use buf as work area
-	 * if NULL in-place copy
+
+	/*
+	 * request data from src, put result ptr to data_p can use ptr from src or
+	 * use buf as work area if NULL in-place copy
 	 */
 	int			(*pull) (void *priv, PullFilter * src, int len,
-							uint8 **data_p, uint8 *buf, int buflen);
+									 uint8 **data_p, uint8 *buf, int buflen);
 	void		(*free) (void *priv);
 };
 
@@ -86,8 +90,8 @@ int			mbuf_free(MBuf * mbuf);
 /*
  * Push filter
  */
-int			pushf_create(PushFilter ** res, const PushFilterOps * ops, void *init_arg,
-						 PushFilter * next);
+int pushf_create(PushFilter ** res, const PushFilterOps * ops, void *init_arg,
+			 PushFilter * next);
 int			pushf_write(PushFilter * mp, const uint8 *data, int len);
 void		pushf_free_all(PushFilter * mp);
 void		pushf_free(PushFilter * mp);
@@ -98,13 +102,13 @@ int			pushf_create_mbuf_writer(PushFilter ** mp_p, MBuf * mbuf);
 /*
  * Pull filter
  */
-int			pullf_create(PullFilter ** res, const PullFilterOps * ops,
-						void *init_arg, PullFilter * src);
+int pullf_create(PullFilter ** res, const PullFilterOps * ops,
+			 void *init_arg, PullFilter * src);
 int			pullf_read(PullFilter * mp, int len, uint8 **data_p);
-int			pullf_read_max(PullFilter * mp, int len,
-						uint8 **data_p, uint8 *tmpbuf);
+int pullf_read_max(PullFilter * mp, int len,
+			   uint8 **data_p, uint8 *tmpbuf);
 void		pullf_free(PullFilter * mp);
-int			pullf_read_fixed(PullFilter *src, int len, uint8 *dst);
+int			pullf_read_fixed(PullFilter * src, int len, uint8 *dst);
 
 int			pullf_create_mbuf_reader(PullFilter ** pf_p, MBuf * mbuf);
 
@@ -118,4 +122,3 @@ int			pullf_create_mbuf_reader(PullFilter ** pf_p, MBuf * mbuf);
 	} while (0)
 
 #endif   /* __PX_MBUF_H */
-
diff --git a/contrib/pgcrypto/md5.h b/contrib/pgcrypto/md5.h
index 4817951f1a..3be106e7a3 100644
--- a/contrib/pgcrypto/md5.h
+++ b/contrib/pgcrypto/md5.h
@@ -1,4 +1,4 @@
-/*	$PostgreSQL$	*/
+/*	$PostgreSQL$ */
 /*	   $KAME$	   */
 
 /*
diff --git a/contrib/pgcrypto/openssl.c b/contrib/pgcrypto/openssl.c
index 6a5db0f3ba..dc36510b67 100644
--- a/contrib/pgcrypto/openssl.c
+++ b/contrib/pgcrypto/openssl.c
@@ -47,14 +47,13 @@
 #define MAX_IV		(128/8)
 
 /*
- * Does OpenSSL support AES? 
+ * Does OpenSSL support AES?
  */
 #if OPENSSL_VERSION_NUMBER >= 0x00907000L
 
 /* Yes, it does. */
 #include <openssl/aes.h>
-
-#else	/* old OPENSSL */
+#else							/* old OPENSSL */
 
 /*
  * No, it does not.  So use included rijndael code to emulate it.
@@ -91,8 +90,7 @@
 			memcpy(iv, (src) + (len) - 16, 16); \
 		} \
 	} while (0)
-
-#endif	/* old OPENSSL */
+#endif   /* old OPENSSL */
 
 /*
  * Compatibility with older OpenSSL API for DES.
@@ -157,8 +155,8 @@ digest_finish(PX_MD * h, uint8 *dst)
 	EVP_DigestFinal(ctx, dst, NULL);
 
 	/*
-	 * Some builds of 0.9.7x clear all of ctx in EVP_DigestFinal.
-	 * Fix it by reinitializing ctx.
+	 * Some builds of 0.9.7x clear all of ctx in EVP_DigestFinal. Fix it by
+	 * reinitializing ctx.
 	 */
 	EVP_DigestInit(ctx, md);
 }
@@ -246,7 +244,9 @@ typedef struct
 		}			des;
 		struct
 		{
-			DES_key_schedule k1, k2, k3;
+			DES_key_schedule k1,
+						k2,
+						k3;
 		}			des3;
 		CAST_KEY	cast_key;
 		AES_KEY		aes_key;
@@ -597,12 +597,12 @@ ossl_aes_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
 	ossldata   *od = c->ptr;
 	unsigned	bs = gen_ossl_block_size(c);
 
-	if (klen <= 128/8)
-		od->klen = 128/8;
-	else if (klen <= 192/8)
-		od->klen = 192/8;
-	else if (klen <= 256/8)
-		od->klen = 256/8;
+	if (klen <= 128 / 8)
+		od->klen = 128 / 8;
+	else if (klen <= 192 / 8)
+		od->klen = 192 / 8;
+	else if (klen <= 256 / 8)
+		od->klen = 256 / 8;
 	else
 		return PXE_KEY_TOO_BIG;
 
@@ -825,7 +825,8 @@ static int	openssl_random_init = 0;
  * OpenSSL random should re-feeded occasionally. From /dev/urandom
  * preferably.
  */
-static void init_openssl_rand(void)
+static void
+init_openssl_rand(void)
 {
 	if (RAND_get_rand_method() == NULL)
 		RAND_set_rand_method(RAND_SSLeay());
@@ -871,4 +872,3 @@ px_add_entropy(const uint8 *data, unsigned count)
 	RAND_add(data, count, 0);
 	return 0;
 }
-
diff --git a/contrib/pgcrypto/pgcrypto.c b/contrib/pgcrypto/pgcrypto.c
index 76d7b5f57a..6ac59f12fa 100644
--- a/contrib/pgcrypto/pgcrypto.c
+++ b/contrib/pgcrypto/pgcrypto.c
@@ -244,7 +244,7 @@ pg_gen_salt_rounds(PG_FUNCTION_ARGS)
 	if (len < 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-			 errmsg("gen_salt: %s", px_strerror(len))));
+				 errmsg("gen_salt: %s", px_strerror(len))));
 
 	res = (text *) palloc(len + VARHDRSZ);
 	VARATT_SIZEP(res) = len + VARHDRSZ;
diff --git a/contrib/pgcrypto/pgp-armor.c b/contrib/pgcrypto/pgp-armor.c
index 8c6ecf836e..b2e3ce00b0 100644
--- a/contrib/pgcrypto/pgp-armor.c
+++ b/contrib/pgcrypto/pgp-armor.c
@@ -40,7 +40,7 @@
  */
 
 static const unsigned char _base64[] =
-	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 static int
 b64_encode(const uint8 *src, unsigned len, uint8 *dst)
@@ -96,13 +96,13 @@ static int
 b64_decode(const uint8 *src, unsigned len, uint8 *dst)
 {
 	const uint8 *srcend = src + len,
-		*s = src;
+			   *s = src;
 	uint8	   *p = dst;
 	char		c;
 	unsigned	b = 0;
 	unsigned long buf = 0;
 	int			pos = 0,
-		end = 0;
+				end = 0;
 
 	while (s < srcend)
 	{
@@ -242,11 +242,13 @@ static const uint8 *
 find_str(const uint8 *data, const uint8 *data_end, const char *str, int strlen)
 {
 	const uint8 *p = data;
+
 	if (!strlen)
 		return NULL;
 	if (data_end - data < strlen)
 		return NULL;
-	while (p < data_end) {
+	while (p < data_end)
+	{
 		p = memchr(p, str[0], data_end - p);
 		if (p == NULL)
 			return NULL;
@@ -261,7 +263,7 @@ find_str(const uint8 *data, const uint8 *data_end, const char *str, int strlen)
 
 static int
 find_header(const uint8 *data, const uint8 *datend,
-		const uint8 **start_p, int is_end)
+			const uint8 **start_p, int is_end)
 {
 	const uint8 *p = data;
 	static const char *start_sep = "-----BEGIN";
@@ -285,7 +287,7 @@ find_header(const uint8 *data, const uint8 *datend,
 	/* check if header text ok */
 	for (; p < datend && *p != '-'; p++)
 	{
-		/* various junk can be there, but definitely not line-feed  */
+		/* various junk can be there, but definitely not line-feed	*/
 		if (*p >= ' ')
 			continue;
 		return PXE_PGP_CORRUPT_ARMOR;
@@ -313,7 +315,8 @@ pgp_armor_decode(const uint8 *src, unsigned len, uint8 *dst)
 	const uint8 *p = src;
 	const uint8 *data_end = src + len;
 	long		crc;
-	const uint8 *base64_start, *armor_end;
+	const uint8 *base64_start,
+			   *armor_end;
 	const uint8 *base64_end = NULL;
 	uint8		buf[4];
 	int			hlen;
@@ -329,7 +332,7 @@ pgp_armor_decode(const uint8 *src, unsigned len, uint8 *dst)
 	hlen = find_header(p, data_end, &armor_end, 1);
 	if (hlen <= 0)
 		goto out;
-	
+
 	/* skip comments - find empty line */
 	while (p < armor_end && *p != '\n' && *p != '\r')
 	{
@@ -341,7 +344,7 @@ pgp_armor_decode(const uint8 *src, unsigned len, uint8 *dst)
 		p++;
 	}
 	base64_start = p;
-	
+
 	/* find crc pos */
 	for (p = armor_end; p >= base64_start; p--)
 		if (*p == '=')
@@ -355,7 +358,7 @@ pgp_armor_decode(const uint8 *src, unsigned len, uint8 *dst)
 	/* decode crc */
 	if (b64_decode(p + 1, 4, buf) != 3)
 		goto out;
-	crc = (((long)buf[0]) << 16) + (((long)buf[1]) << 8) + (long)buf[2];
+	crc = (((long) buf[0]) << 16) + (((long) buf[1]) << 8) + (long) buf[2];
 
 	/* decode data */
 	res = b64_decode(base64_start, base64_end - base64_start, dst);
@@ -378,4 +381,3 @@ pgp_armor_dec_len(unsigned len)
 {
 	return b64_dec_len(len);
 }
-
diff --git a/contrib/pgcrypto/pgp-cfb.c b/contrib/pgcrypto/pgp-cfb.c
index 55d8557850..16d0428839 100644
--- a/contrib/pgcrypto/pgp-cfb.c
+++ b/contrib/pgcrypto/pgp-cfb.c
@@ -35,7 +35,7 @@
 #include "px.h"
 #include "pgp.h"
 
-typedef int (*mix_data_t)(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
+typedef int (*mix_data_t) (PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
 
 struct PGP_CFB
 {
@@ -50,12 +50,12 @@ struct PGP_CFB
 };
 
 int
-pgp_cfb_create(PGP_CFB **ctx_p, int algo, const uint8 *key, int key_len,
-		int resync, uint8 *iv)
+pgp_cfb_create(PGP_CFB ** ctx_p, int algo, const uint8 *key, int key_len,
+			   int resync, uint8 *iv)
 {
-	int res;
-	PX_Cipher *ciph;
-	PGP_CFB *ctx;
+	int			res;
+	PX_Cipher  *ciph;
+	PGP_CFB    *ctx;
 
 	res = pgp_load_cipher(algo, &ciph);
 	if (res < 0)
@@ -82,7 +82,7 @@ pgp_cfb_create(PGP_CFB **ctx_p, int algo, const uint8 *key, int key_len,
 }
 
 void
-pgp_cfb_free(PGP_CFB *ctx)
+pgp_cfb_free(PGP_CFB * ctx)
 {
 	px_cipher_free(ctx->ciph);
 	memset(ctx, 0, sizeof(*ctx));
@@ -90,12 +90,13 @@ pgp_cfb_free(PGP_CFB *ctx)
 }
 
 /*
- * Data processing for normal CFB.  (PGP_PKT_SYMENCRYPTED_DATA_MDC)
+ * Data processing for normal CFB.	(PGP_PKT_SYMENCRYPTED_DATA_MDC)
  */
 static int
-mix_encrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
+mix_encrypt_normal(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
 {
-	int i;
+	int			i;
+
 	for (i = ctx->pos; i < ctx->pos + len; i++)
 		*dst++ = ctx->encbuf[i] = ctx->fre[i] ^ (*data++);
 	ctx->pos += len;
@@ -103,9 +104,10 @@ mix_encrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
 }
 
 static int
-mix_decrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
+mix_decrypt_normal(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
 {
-	int i;
+	int			i;
+
 	for (i = ctx->pos; i < ctx->pos + len; i++)
 	{
 		ctx->encbuf[i] = *data++;
@@ -122,9 +124,11 @@ mix_decrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
  * thus its all concentrated here.
  */
 static int
-mix_encrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
+mix_encrypt_resync(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
 {
-	int i,n;
+	int			i,
+				n;
+
 	/* block #2 is 2 bytes long */
 	if (ctx->block_no == 2)
 	{
@@ -152,9 +156,11 @@ mix_encrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
 }
 
 static int
-mix_decrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
+mix_decrypt_resync(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
 {
-	int i,n;
+	int			i,
+				n;
+
 	/* block #2 is 2 bytes long */
 	if (ctx->block_no == 2)
 	{
@@ -190,11 +196,11 @@ mix_decrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
  * common code for both encrypt and decrypt.
  */
 static int
-cfb_process(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst,
-		mix_data_t mix_data)
+cfb_process(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst,
+			mix_data_t mix_data)
 {
-	int n;
-	int res;
+	int			n;
+	int			res;
 
 	while (len > 0 && ctx->pos > 0)
 	{
@@ -243,16 +249,17 @@ cfb_process(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst,
  */
 
 int
-pgp_cfb_encrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
+pgp_cfb_encrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
 {
-	mix_data_t mix = ctx->resync ? mix_encrypt_resync : mix_encrypt_normal;
+	mix_data_t	mix = ctx->resync ? mix_encrypt_resync : mix_encrypt_normal;
+
 	return cfb_process(ctx, data, len, dst, mix);
 }
 
 int
-pgp_cfb_decrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
+pgp_cfb_decrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
 {
-	mix_data_t mix = ctx->resync ? mix_decrypt_resync : mix_decrypt_normal;
+	mix_data_t	mix = ctx->resync ? mix_decrypt_resync : mix_decrypt_normal;
+
 	return cfb_process(ctx, data, len, dst, mix);
 }
-
diff --git a/contrib/pgcrypto/pgp-compress.c b/contrib/pgcrypto/pgp-compress.c
index 55839848ac..ceb6fdf3cf 100644
--- a/contrib/pgcrypto/pgp-compress.c
+++ b/contrib/pgcrypto/pgp-compress.c
@@ -180,12 +180,12 @@ compress_free(void *priv)
 }
 
 static const PushFilterOps
-compress_filter = {
+			compress_filter = {
 	compress_init, compress_process, compress_flush, compress_free
 };
 
 int
-pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
+pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst)
 {
 	return pushf_create(res, &compress_filter, ctx, dst);
 }
@@ -195,8 +195,8 @@ pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
  */
 struct DecomprData
 {
-	int			buf_len;  /* = ZIP_OUT_BUF */
-	int			buf_data; /* available data */
+	int			buf_len;		/* = ZIP_OUT_BUF */
+	int			buf_data;		/* available data */
 	uint8	   *pos;
 	z_stream	stream;
 	int			eof;
@@ -204,14 +204,14 @@ struct DecomprData
 };
 
 static int
-decompress_init(void **priv_p, void *arg, PullFilter *src)
+decompress_init(void **priv_p, void *arg, PullFilter * src)
 {
 	PGP_Context *ctx = arg;
 	struct DecomprData *dec;
-	int res;
+	int			res;
 
 	if (ctx->compress_algo != PGP_COMPR_ZLIB
-			&& ctx->compress_algo != PGP_COMPR_ZIP)
+		&& ctx->compress_algo != PGP_COMPR_ZIP)
 		return PXE_PGP_UNSUPPORTED_COMPR;
 
 	dec = px_alloc(sizeof(*dec));
@@ -232,15 +232,16 @@ decompress_init(void **priv_p, void *arg, PullFilter *src)
 		px_debug("decompress_init: inflateInit error");
 		return PXE_PGP_COMPRESSION_ERROR;
 	}
-	
+
 	return 0;
 }
 
-static int decompress_read(void *priv, PullFilter *src, int len,
-			uint8 **data_p, uint8 *buf, int buflen)
+static int
+decompress_read(void *priv, PullFilter * src, int len,
+				uint8 **data_p, uint8 *buf, int buflen)
 {
-	int res;
-	int flush;
+	int			res;
+	int			flush;
 	struct DecomprData *dec = priv;
 
 restart:
@@ -256,24 +257,26 @@ restart:
 
 	if (dec->eof)
 		return 0;
-	
-	if (dec->stream.avail_in == 0) {
-		uint8 *tmp;
+
+	if (dec->stream.avail_in == 0)
+	{
+		uint8	   *tmp;
+
 		res = pullf_read(src, 8192, &tmp);
 		if (res < 0)
 			return res;
 		dec->stream.next_in = tmp;
 		dec->stream.avail_in = res;
 	}
-	
+
 	dec->stream.next_out = dec->buf;
 	dec->stream.avail_out = dec->buf_len;
 	dec->pos = dec->buf;
 
 	/*
-	 * Z_SYNC_FLUSH is tell zlib to output as much as possible.
-	 * It should do it anyway (Z_NO_FLUSH), but seems to reserve
-	 * the right not to.  So lets follow the API.
+	 * Z_SYNC_FLUSH is tell zlib to output as much as possible. It should do
+	 * it anyway (Z_NO_FLUSH), but seems to reserve the right not to.  So lets
+	 * follow the API.
 	 */
 	flush = dec->stream.avail_in ? Z_SYNC_FLUSH : Z_FINISH;
 	res = inflate(&dec->stream, flush);
@@ -289,39 +292,38 @@ restart:
 	goto restart;
 }
 
-static void decompress_free(void *priv)
+static void
+decompress_free(void *priv)
 {
 	struct DecomprData *dec = priv;
+
 	inflateEnd(&dec->stream);
 	memset(dec, 0, sizeof(*dec));
 	px_free(dec);
 }
 
 static const PullFilterOps
-decompress_filter = {
+			decompress_filter = {
 	decompress_init, decompress_read, decompress_free
 };
 
 int
-pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
+pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src)
 {
 	return pullf_create(res, &decompress_filter, ctx, src);
 }
-
-#else /* DISABLE_ZLIB */
+#else							/* DISABLE_ZLIB */
 
 int
-pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
+pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst)
 {
 	return PXE_PGP_UNSUPPORTED_COMPR;
 }
 
 int
-pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
+pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src)
 {
 	return PXE_PGP_UNSUPPORTED_COMPR;
 }
 
 #endif
-
-
diff --git a/contrib/pgcrypto/pgp-decrypt.c b/contrib/pgcrypto/pgp-decrypt.c
index 9facb17b8c..99a9344dc0 100644
--- a/contrib/pgcrypto/pgp-decrypt.c
+++ b/contrib/pgcrypto/pgp-decrypt.c
@@ -80,7 +80,7 @@ parse_new_len(PullFilter * src, int *len_p)
 		len = 1 << (b & 0x1F);
 		pkttype = PKT_STREAM;
 	}
-	
+
 	if (len < 0 || len > MAX_CHUNK)
 	{
 		px_debug("parse_new_len: weird length");
@@ -130,7 +130,7 @@ pgp_parse_pkt_hdr(PullFilter * src, uint8 *tag, int *len_p, int allow_ctx)
 {
 	int			lentype;
 	int			res;
-	uint8		*p;
+	uint8	   *p;
 
 	/* EOF is normal here, thus we dont use GETBYTE */
 	res = pullf_read(src, 1, &p);
@@ -165,15 +165,17 @@ pgp_parse_pkt_hdr(PullFilter * src, uint8 *tag, int *len_p, int allow_ctx)
 /*
  * Packet reader
  */
-struct PktData {
-	int type;
-	int len;
+struct PktData
+{
+	int			type;
+	int			len;
 };
 
-static int pktreader_pull(void *priv, PullFilter *src, int len,
-		uint8 **data_p, uint8 *buf, int buflen)
+static int
+pktreader_pull(void *priv, PullFilter * src, int len,
+			   uint8 **data_p, uint8 *buf, int buflen)
 {
-	int res;
+	int			res;
 	struct PktData *pkt = priv;
 
 	/* PKT_CONTEXT means: whatever there is */
@@ -207,6 +209,7 @@ static void
 pktreader_free(void *priv)
 {
 	struct PktData *pkt = priv;
+
 	memset(pkt, 0, sizeof(*pkt));
 	px_free(pkt);
 }
@@ -217,11 +220,12 @@ static struct PullFilterOps pktreader_filter = {
 
 /* needs helper function to pass several parameters */
 int
-pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
-				  int pkttype, PGP_Context *ctx)
+pgp_create_pkt_reader(PullFilter ** pf_p, PullFilter * src, int len,
+					  int pkttype, PGP_Context * ctx)
 {
-	int res;
+	int			res;
 	struct PktData *pkt = px_alloc(sizeof(*pkt));
+
 	pkt->type = pkttype;
 	pkt->len = len;
 	res = pullf_create(pf_p, &pktreader_filter, pkt, src);
@@ -234,13 +238,14 @@ pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
  * Prefix check filter
  */
 
-static int prefix_init(void **priv_p, void *arg, PullFilter *src)
+static int
+prefix_init(void **priv_p, void *arg, PullFilter * src)
 {
 	PGP_Context *ctx = arg;
-	int len;
-	int res;
-	uint8 *buf;
-	uint8 tmpbuf[PGP_MAX_BLOCK + 2];
+	int			len;
+	int			res;
+	uint8	   *buf;
+	uint8		tmpbuf[PGP_MAX_BLOCK + 2];
 
 	len = pgp_get_cipher_block_size(ctx->cipher_algo);
 	if (len > sizeof(tmpbuf))
@@ -259,20 +264,19 @@ static int prefix_init(void **priv_p, void *arg, PullFilter *src)
 	if (buf[len - 2] != buf[len] || buf[len - 1] != buf[len + 1])
 	{
 		px_debug("prefix_init: corrupt prefix");
+
 		/*
-		 * The original purpose of the 2-byte check was
-		 * to show user a friendly "wrong key" message.
-		 * This made following possible:
+		 * The original purpose of the 2-byte check was to show user a
+		 * friendly "wrong key" message. This made following possible:
 		 *
-		 *   "An Attack on CFB Mode Encryption As Used By OpenPGP"
-		 *   by Serge Mister and Robert Zuccherato
+		 * "An Attack on CFB Mode Encryption As Used By OpenPGP" by Serge Mister
+		 * and Robert Zuccherato
 		 *
-		 * To avoid being 'oracle', we delay reporting, which
-		 * basically means we prefer to run into corrupt packet
-		 * header.
+		 * To avoid being 'oracle', we delay reporting, which basically means we
+		 * prefer to run into corrupt packet header.
 		 *
-		 * We _could_ throw PXE_PGP_CORRUPT_DATA here, but
-		 * there is possibility of attack via timing, so we don't.
+		 * We _could_ throw PXE_PGP_CORRUPT_DATA here, but there is possibility
+		 * of attack via timing, so we don't.
 		 */
 		ctx->corrupt_prefix = 1;
 	}
@@ -289,9 +293,10 @@ static struct PullFilterOps prefix_filter = {
  * Decrypt filter
  */
 
-static int decrypt_init(void **priv_p, void *arg, PullFilter *src)
+static int
+decrypt_init(void **priv_p, void *arg, PullFilter * src)
 {
-	PGP_CFB *cfb = arg;
+	PGP_CFB    *cfb = arg;
 
 	*priv_p = cfb;
 
@@ -299,15 +304,17 @@ static int decrypt_init(void **priv_p, void *arg, PullFilter *src)
 	return 4096;
 }
 
-static int decrypt_read(void *priv, PullFilter *src, int len,
-		uint8 **data_p, uint8 *buf, int buflen)
+static int
+decrypt_read(void *priv, PullFilter * src, int len,
+			 uint8 **data_p, uint8 *buf, int buflen)
 {
-	PGP_CFB *cfb = priv;
-	uint8 *tmp;
-	int res;
+	PGP_CFB    *cfb = priv;
+	uint8	   *tmp;
+	int			res;
 
 	res = pullf_read(src, len, &tmp);
-	if (res > 0) {
+	if (res > 0)
+	{
 		pgp_cfb_decrypt(cfb, tmp, res, buf);
 		*data_p = buf;
 	}
@@ -323,28 +330,33 @@ struct PullFilterOps pgp_decrypt_filter = {
  * MDC hasher filter
  */
 
-static int mdc_init(void **priv_p, void *arg, PullFilter *src)
+static int
+mdc_init(void **priv_p, void *arg, PullFilter * src)
 {
 	PGP_Context *ctx = arg;
+
 	*priv_p = ctx;
 	return pgp_load_digest(PGP_DIGEST_SHA1, &ctx->mdc_ctx);
 }
 
-static void mdc_free(void *priv)
+static void
+mdc_free(void *priv)
 {
 	PGP_Context *ctx = priv;
+
 	if (ctx->use_mdcbuf_filter)
 		return;
 	px_md_free(ctx->mdc_ctx);
 	ctx->mdc_ctx = NULL;
 }
 
-static int mdc_finish(PGP_Context *ctx, PullFilter *src,
-		int len, uint8 **data_p)
+static int
+mdc_finish(PGP_Context * ctx, PullFilter * src,
+		   int len, uint8 **data_p)
 {
-	int res;
-	uint8 hash[20];
-	uint8 tmpbuf[22];
+	int			res;
+	uint8		hash[20];
+	uint8		tmpbuf[22];
 
 	if (len + 1 > sizeof(tmpbuf))
 		return PXE_BUG;
@@ -362,7 +374,7 @@ static int mdc_finish(PGP_Context *ctx, PullFilter *src,
 		}
 		return 0;
 	}
-	
+
 	/* safety check */
 	if (ctx->in_mdc_pkt > 1)
 	{
@@ -370,14 +382,14 @@ static int mdc_finish(PGP_Context *ctx, PullFilter *src,
 		return PXE_PGP_CORRUPT_DATA;
 	}
 	ctx->in_mdc_pkt++;
-	
+
 	/* is the packet sane? */
 	if (res != 20)
 	{
 		px_debug("mdc_finish: read failed, res=%d", res);
 		return PXE_PGP_CORRUPT_DATA;
 	}
-	
+
 	/*
 	 * ok, we got the hash, now check
 	 */
@@ -394,10 +406,11 @@ static int mdc_finish(PGP_Context *ctx, PullFilter *src,
 	return len;
 }
 
-static int mdc_read(void *priv, PullFilter *src, int len,
-		uint8 **data_p, uint8 *buf, int buflen)
+static int
+mdc_read(void *priv, PullFilter * src, int len,
+		 uint8 **data_p, uint8 *buf, int buflen)
 {
-	int res;
+	int			res;
 	PGP_Context *ctx = priv;
 
 	/* skip this filter? */
@@ -434,18 +447,20 @@ static struct PullFilterOps mdc_filter = {
  * packet, which is silly.
  */
 #define MDCBUF_LEN 8192
-struct MDCBufData {
+struct MDCBufData
+{
 	PGP_Context *ctx;
-	int eof;
-	int buflen;
-	int avail;
-	uint8 *pos;
-	int mdc_avail;
-	uint8 mdc_buf[22];
-	uint8 buf[MDCBUF_LEN];
+	int			eof;
+	int			buflen;
+	int			avail;
+	uint8	   *pos;
+	int			mdc_avail;
+	uint8		mdc_buf[22];
+	uint8		buf[MDCBUF_LEN];
 };
 
-static int mdcbuf_init(void **priv_p, void *arg, PullFilter *src)
+static int
+mdcbuf_init(void **priv_p, void *arg, PullFilter * src)
 {
 	PGP_Context *ctx = arg;
 	struct MDCBufData *st;
@@ -462,10 +477,11 @@ static int mdcbuf_init(void **priv_p, void *arg, PullFilter *src)
 	return 0;
 }
 
-static int mdcbuf_finish(struct MDCBufData *st)
+static int
+mdcbuf_finish(struct MDCBufData * st)
 {
-	uint8 hash[20];
-	int res;
+	uint8		hash[20];
+	int			res;
 
 	st->eof = 1;
 
@@ -486,25 +502,29 @@ static int mdcbuf_finish(struct MDCBufData *st)
 	return res;
 }
 
-static void mdcbuf_load_data(struct MDCBufData *st, uint8 *src, int len)
+static void
+mdcbuf_load_data(struct MDCBufData * st, uint8 *src, int len)
 {
-	uint8 *dst = st->pos + st->avail;
+	uint8	   *dst = st->pos + st->avail;
+
 	memcpy(dst, src, len);
 	px_md_update(st->ctx->mdc_ctx, src, len);
 	st->avail += len;
 }
 
-static void mdcbuf_load_mdc(struct MDCBufData *st, uint8 *src, int len)
+static void
+mdcbuf_load_mdc(struct MDCBufData * st, uint8 *src, int len)
 {
 	memmove(st->mdc_buf + st->mdc_avail, src, len);
 	st->mdc_avail += len;
 }
 
-static int mdcbuf_refill(struct MDCBufData *st, PullFilter *src)
+static int
+mdcbuf_refill(struct MDCBufData * st, PullFilter * src)
 {
-	uint8 *data;
-	int res;
-	int need;
+	uint8	   *data;
+	int			res;
+	int			need;
 
 	/* put avail data in start */
 	if (st->avail > 0 && st->pos != st->buf)
@@ -530,7 +550,8 @@ static int mdcbuf_refill(struct MDCBufData *st, PullFilter *src)
 	}
 	else
 	{
-		int canmove = st->mdc_avail + res - 22;
+		int			canmove = st->mdc_avail + res - 22;
+
 		if (canmove > 0)
 		{
 			mdcbuf_load_data(st, st->mdc_buf, canmove);
@@ -542,11 +563,12 @@ static int mdcbuf_refill(struct MDCBufData *st, PullFilter *src)
 	return 0;
 }
 
-static int mdcbuf_read(void *priv, PullFilter *src, int len,
-		uint8 **data_p, uint8 *buf, int buflen)
+static int
+mdcbuf_read(void *priv, PullFilter * src, int len,
+			uint8 **data_p, uint8 *buf, int buflen)
 {
 	struct MDCBufData *st = priv;
-	int res;
+	int			res;
 
 	if (!st->eof && len > st->avail)
 	{
@@ -568,6 +590,7 @@ static void
 mdcbuf_free(void *priv)
 {
 	struct MDCBufData *st = priv;
+
 	px_md_free(st->ctx->mdc_ctx);
 	st->ctx->mdc_ctx = NULL;
 	memset(st, 0, sizeof(*st));
@@ -583,29 +606,30 @@ static struct PullFilterOps mdcbuf_filter = {
  * Decrypt separate session key
  */
 static int
-decrypt_key(PGP_Context *ctx, const uint8 *src, int len)
+decrypt_key(PGP_Context * ctx, const uint8 *src, int len)
 {
-	int res;
-	uint8 algo;
-	PGP_CFB *cfb;
-	
+	int			res;
+	uint8		algo;
+	PGP_CFB    *cfb;
+
 	res = pgp_cfb_create(&cfb, ctx->s2k_cipher_algo,
-			ctx->s2k.key, ctx->s2k.key_len, 0, NULL);
+						 ctx->s2k.key, ctx->s2k.key_len, 0, NULL);
 	if (res < 0)
 		return res;
 
 	pgp_cfb_decrypt(cfb, src, 1, &algo);
-	src ++;
-	len --;
+	src++;
+	len--;
 
 	pgp_cfb_decrypt(cfb, src, len, ctx->sess_key);
 	pgp_cfb_free(cfb);
 	ctx->sess_key_len = len;
 	ctx->cipher_algo = algo;
 
-	if (pgp_get_cipher_key_size(algo) != len) {
+	if (pgp_get_cipher_key_size(algo) != len)
+	{
 		px_debug("sesskey bad len: algo=%d, expected=%d, got=%d",
-				algo, pgp_get_cipher_key_size(algo), len);
+				 algo, pgp_get_cipher_key_size(algo), len);
 		return PXE_PGP_CORRUPT_DATA;
 	}
 	return 0;
@@ -643,7 +667,7 @@ parse_symenc_sesskey(PGP_Context * ctx, PullFilter * src)
 	 * generate key from password
 	 */
 	res = pgp_s2k_process(&ctx->s2k, ctx->s2k_cipher_algo,
-			ctx->sym_key, ctx->sym_key_len);
+						  ctx->sym_key, ctx->sym_key_len);
 	if (res < 0)
 		return res;
 
@@ -684,21 +708,23 @@ parse_symenc_sesskey(PGP_Context * ctx, PullFilter * src)
 }
 
 static int
-copy_crlf(MBuf *dst, uint8 *data, int len, int *got_cr)
+copy_crlf(MBuf * dst, uint8 *data, int len, int *got_cr)
 {
-	uint8 *data_end = data + len;
-	uint8 tmpbuf[1024];
-	uint8 *tmp_end = tmpbuf + sizeof(tmpbuf);
-	uint8 *p;
-	int res;
+	uint8	   *data_end = data + len;
+	uint8		tmpbuf[1024];
+	uint8	   *tmp_end = tmpbuf + sizeof(tmpbuf);
+	uint8	   *p;
+	int			res;
 
 	p = tmpbuf;
-	if (*got_cr) {
+	if (*got_cr)
+	{
 		if (*data != '\n')
 			*p++ = '\r';
 		*got_cr = 0;
 	}
-	while (data < data_end) {
+	while (data < data_end)
+	{
 		if (*data == '\r')
 		{
 			if (data + 1 < data_end)
@@ -779,8 +805,9 @@ parse_literal_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
 	ctx->unicode_mode = (type == 'u') ? 1 : 0;
 
 	/* read data */
-	while (1) {
-		res = pullf_read(pkt, 32*1024, &buf);
+	while (1)
+	{
+		res = pullf_read(pkt, 32 * 1024, &buf);
 		if (res <= 0)
 			break;
 
@@ -797,8 +824,8 @@ parse_literal_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
 }
 
 /* process_data_packets and parse_compressed_data call each other */
-static int	process_data_packets(PGP_Context * ctx, MBuf * dst,
-			PullFilter * src, int allow_compr, int need_mdc);
+static int process_data_packets(PGP_Context * ctx, MBuf * dst,
+					 PullFilter * src, int allow_compr, int need_mdc);
 
 static int
 parse_compressed_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
@@ -822,7 +849,7 @@ parse_compressed_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
 			if (res >= 0)
 			{
 				res = process_data_packets(ctx, dst, pf_decompr,
-											NO_COMPR, NO_MDC);
+										   NO_COMPR, NO_MDC);
 				pullf_free(pf_decompr);
 			}
 			break;
@@ -850,7 +877,7 @@ process_data_packets(PGP_Context * ctx, MBuf * dst, PullFilter * src,
 	int			got_data = 0;
 	int			got_mdc = 0;
 	PullFilter *pkt = NULL;
-	uint8 *tmp;
+	uint8	   *tmp;
 
 	while (1)
 	{
@@ -951,12 +978,12 @@ static int
 parse_symenc_data(PGP_Context * ctx, PullFilter * pkt, MBuf * dst)
 {
 	int			res;
-	PGP_CFB	*cfb = NULL;
+	PGP_CFB    *cfb = NULL;
 	PullFilter *pf_decrypt = NULL;
 	PullFilter *pf_prefix = NULL;
 
 	res = pgp_cfb_create(&cfb, ctx->cipher_algo,
-			ctx->sess_key, ctx->sess_key_len, 1, NULL);
+						 ctx->sess_key, ctx->sess_key_len, 1, NULL);
 	if (res < 0)
 		goto out;
 
@@ -985,11 +1012,11 @@ static int
 parse_symenc_mdc_data(PGP_Context * ctx, PullFilter * pkt, MBuf * dst)
 {
 	int			res;
-	PGP_CFB	*cfb = NULL;
+	PGP_CFB    *cfb = NULL;
 	PullFilter *pf_decrypt = NULL;
 	PullFilter *pf_prefix = NULL;
 	PullFilter *pf_mdc = NULL;
-	uint8 ver;
+	uint8		ver;
 
 	GETBYTE(pkt, ver);
 	if (ver != 1)
@@ -999,7 +1026,7 @@ parse_symenc_mdc_data(PGP_Context * ctx, PullFilter * pkt, MBuf * dst)
 	}
 
 	res = pgp_cfb_create(&cfb, ctx->cipher_algo,
-			ctx->sess_key, ctx->sess_key_len, 0, NULL);
+						 ctx->sess_key, ctx->sess_key_len, 0, NULL);
 	if (res < 0)
 		goto out;
 
@@ -1034,49 +1061,52 @@ out:
  * skip over packet contents
  */
 int
-pgp_skip_packet(PullFilter *pkt)
+pgp_skip_packet(PullFilter * pkt)
 {
-	int res = 1;
-	uint8 *tmp;
-  	while (res > 0)
-		res = pullf_read(pkt, 32*1024, &tmp);
-	return res < 0 ? res : 0;				 
+	int			res = 1;
+	uint8	   *tmp;
+
+	while (res > 0)
+		res = pullf_read(pkt, 32 * 1024, &tmp);
+	return res < 0 ? res : 0;
 }
 
 /*
  * expect to be at packet end, any data is error
  */
 int
-pgp_expect_packet_end(PullFilter *pkt)
+pgp_expect_packet_end(PullFilter * pkt)
 {
-	int res = 1;
-	uint8 *tmp;
-  	while (res > 0)
+	int			res = 1;
+	uint8	   *tmp;
+
+	while (res > 0)
 	{
-		res = pullf_read(pkt, 32*1024, &tmp);
+		res = pullf_read(pkt, 32 * 1024, &tmp);
 		if (res > 0)
 		{
 			px_debug("pgp_expect_packet_end: got data");
 			return PXE_PGP_CORRUPT_DATA;
 		}
 	}
-	return res < 0 ? res : 0;				 
+	return res < 0 ? res : 0;
 }
 
 int
 pgp_decrypt(PGP_Context * ctx, MBuf * msrc, MBuf * mdst)
 {
-	int res;
+	int			res;
 	PullFilter *src = NULL;
 	PullFilter *pkt = NULL;
-	uint8 tag;
-	int len;
-	int got_key = 0;
-	int got_data = 0;
+	uint8		tag;
+	int			len;
+	int			got_key = 0;
+	int			got_data = 0;
 
 	res = pullf_create_mbuf_reader(&src, msrc);
 
-	while (res >= 0) {
+	while (res >= 0)
+	{
 		res = pgp_parse_pkt_hdr(src, &tag, &len, NO_CTX_SIZE);
 		if (res <= 0)
 			break;
@@ -1086,7 +1116,8 @@ pgp_decrypt(PGP_Context * ctx, MBuf * msrc, MBuf * mdst)
 			break;
 
 		res = PXE_PGP_CORRUPT_DATA;
-		switch (tag) {
+		switch (tag)
+		{
 			case PGP_PKT_MARKER:
 				res = pgp_skip_packet(pkt);
 				break;
@@ -1097,10 +1128,11 @@ pgp_decrypt(PGP_Context * ctx, MBuf * msrc, MBuf * mdst)
 				break;
 			case PGP_PKT_SYMENCRYPTED_SESSKEY:
 				if (got_key)
-					/* Theoretically, there could be several keys,
-					 * both public and symmetric, all of which
-					 * encrypt same session key.  Decrypt should try
-					 * with each one, before failing.
+
+					/*
+					 * Theoretically, there could be several keys, both public
+					 * and symmetric, all of which encrypt same session key.
+					 * Decrypt should try with each one, before failing.
 					 */
 					px_debug("pgp_decrypt: using first of several keys");
 				else
@@ -1154,4 +1186,3 @@ pgp_decrypt(PGP_Context * ctx, MBuf * msrc, MBuf * mdst)
 
 	return res;
 }
-
diff --git a/contrib/pgcrypto/pgp-encrypt.c b/contrib/pgcrypto/pgp-encrypt.c
index e439cedfe6..882e00a752 100644
--- a/contrib/pgcrypto/pgp-encrypt.c
+++ b/contrib/pgcrypto/pgp-encrypt.c
@@ -65,9 +65,11 @@ render_newlen(uint8 *h, int len)
 	return h;
 }
 
-static int write_tag_only(PushFilter *dst, int tag)
+static int
+write_tag_only(PushFilter * dst, int tag)
 {
-	uint8 hdr = 0xC0 | tag;
+	uint8		hdr = 0xC0 | tag;
+
 	return pushf_write(dst, &hdr, 1);
 }
 
@@ -121,7 +123,7 @@ mdc_flush(PushFilter * dst, void *priv)
 	 * create mdc pkt
 	 */
 	pkt[0] = 0xD3;
-	pkt[1] = 0x14; /* MDC_DIGEST_LEN */
+	pkt[1] = 0x14;				/* MDC_DIGEST_LEN */
 	px_md_update(md, pkt, 2);
 	px_md_finish(md, pkt + 2);
 
@@ -150,7 +152,7 @@ static const PushFilterOps mdc_filter = {
 struct EncStat
 {
 	PGP_CFB    *ciph;
-	uint8	    buf[ENCBUF];
+	uint8		buf[ENCBUF];
 };
 
 static int
@@ -158,28 +160,29 @@ encrypt_init(PushFilter * next, void *init_arg, void **priv_p)
 {
 	struct EncStat *st;
 	PGP_Context *ctx = init_arg;
-	PGP_CFB *ciph;
-	int resync = 1;
-	int res;
+	PGP_CFB    *ciph;
+	int			resync = 1;
+	int			res;
 
 	/* should we use newer packet format? */
 	if (ctx->disable_mdc == 0)
 	{
-		uint8 ver = 1;
+		uint8		ver = 1;
+
 		resync = 0;
 		res = pushf_write(next, &ver, 1);
 		if (res < 0)
 			return res;
 	}
 	res = pgp_cfb_create(&ciph, ctx->cipher_algo,
-			ctx->sess_key, ctx->sess_key_len, resync, NULL);
+						 ctx->sess_key, ctx->sess_key_len, resync, NULL);
 	if (res < 0)
 		return res;
 
 	st = px_alloc(sizeof(*st));
 	memset(st, 0, sizeof(*st));
 	st->ciph = ciph;
-	
+
 	*priv_p = st;
 	return ENCBUF;
 }
@@ -189,11 +192,12 @@ encrypt_process(PushFilter * next, void *priv, const uint8 *data, int len)
 {
 	int			res;
 	struct EncStat *st = priv;
-	int avail = len;
+	int			avail = len;
 
 	while (avail > 0)
 	{
-		int tmplen = avail > ENCBUF ? ENCBUF : avail;
+		int			tmplen = avail > ENCBUF ? ENCBUF : avail;
+
 		res = pgp_cfb_encrypt(st->ciph, data, tmplen, st->buf);
 		if (res < 0)
 			return res;
@@ -303,9 +307,11 @@ static const PushFilterOps pkt_stream_filter = {
 	pkt_stream_init, pkt_stream_process, pkt_stream_flush, pkt_stream_free
 };
 
-int pgp_create_pkt_writer(PushFilter *dst, int tag, PushFilter **res_p)
+int
+pgp_create_pkt_writer(PushFilter * dst, int tag, PushFilter ** res_p)
 {
-	int res;
+	int			res;
+
 	res = write_tag_only(dst, tag);
 	if (res < 0)
 		return res;
@@ -320,17 +326,19 @@ int pgp_create_pkt_writer(PushFilter *dst, int tag, PushFilter **res_p)
 static int
 crlf_process(PushFilter * dst, void *priv, const uint8 *data, int len)
 {
-	const uint8 * data_end = data + len;
-	const uint8 * p2, * p1 = data;
-	int line_len;
-	static const uint8 crlf[] = { '\r', '\n' };
-	int res = 0;
+	const uint8 *data_end = data + len;
+	const uint8 *p2,
+			   *p1 = data;
+	int			line_len;
+	static const uint8 crlf[] = {'\r', '\n'};
+	int			res = 0;
+
 	while (p1 < data_end)
 	{
 		p2 = memchr(p1, '\n', data_end - p1);
 		if (p2 == NULL)
 			p2 = data_end;
-		
+
 		line_len = p2 - p1;
 
 		/* write data */
@@ -363,13 +371,13 @@ static const PushFilterOps crlf_filter = {
  * Initialize literal data packet
  */
 static int
-init_litdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
+init_litdata_packet(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
 {
 	int			res;
 	int			hdrlen;
 	uint8		hdr[6];
 	uint32		t;
-	PushFilter	*pkt;
+	PushFilter *pkt;
 	int			type;
 
 	/*
@@ -382,10 +390,10 @@ init_litdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
 		type = 'b';
 
 	/*
-	 * Store the creation time into packet.
-	 * The goal is to have as few known bytes as possible.
+	 * Store the creation time into packet. The goal is to have as few known
+	 * bytes as possible.
 	 */
-	t = (uint32)time(NULL);
+	t = (uint32) time(NULL);
 
 	hdr[0] = type;
 	hdr[1] = 0;
@@ -418,10 +426,10 @@ init_litdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
  * Initialize compression filter
  */
 static int
-init_compress(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
+init_compress(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
 {
-	int res;
-	uint8 type = ctx->compress_algo;
+	int			res;
+	uint8		type = ctx->compress_algo;
 	PushFilter *pkt;
 
 	res = write_tag_only(dst, PGP_PKT_COMPRESSED_DATA);
@@ -446,7 +454,7 @@ init_compress(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
  * Initialize encdata packet
  */
 static int
-init_encdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
+init_encdata_packet(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
 {
 	int			res;
 	int			tag;
@@ -467,7 +475,7 @@ init_encdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
  * write prefix
  */
 static int
-write_prefix(PGP_Context *ctx, PushFilter * dst)
+write_prefix(PGP_Context * ctx, PushFilter * dst)
 {
 	uint8		prefix[PGP_MAX_BLOCK + 2];
 	int			res,
@@ -491,17 +499,17 @@ write_prefix(PGP_Context *ctx, PushFilter * dst)
  */
 
 static int
-symencrypt_sesskey(PGP_Context *ctx, uint8 *dst)
+symencrypt_sesskey(PGP_Context * ctx, uint8 *dst)
 {
-	int res;
-	PGP_CFB *cfb;
-	uint8 algo = ctx->cipher_algo;
+	int			res;
+	PGP_CFB    *cfb;
+	uint8		algo = ctx->cipher_algo;
 
 	res = pgp_cfb_create(&cfb, ctx->s2k_cipher_algo,
-			ctx->s2k.key, ctx->s2k.key_len, 0, NULL);
+						 ctx->s2k.key, ctx->s2k.key_len, 0, NULL);
 	if (res < 0)
 		return res;
-	
+
 	pgp_cfb_encrypt(cfb, &algo, 1, dst);
 	pgp_cfb_encrypt(cfb, ctx->sess_key, ctx->sess_key_len, dst + 1);
 
@@ -511,12 +519,12 @@ symencrypt_sesskey(PGP_Context *ctx, uint8 *dst)
 
 /* 5.3: Symmetric-Key Encrypted Session-Key */
 static int
-write_symenc_sesskey(PGP_Context *ctx, PushFilter *dst)
+write_symenc_sesskey(PGP_Context * ctx, PushFilter * dst)
 {
 	uint8		pkt[256];
 	int			pktlen;
 	int			res;
-	uint8		*p = pkt;
+	uint8	   *p = pkt;
 
 	*p++ = 4;					/* 5.3 - version number  */
 	*p++ = ctx->s2k_cipher_algo;
@@ -564,13 +572,14 @@ init_s2k_key(PGP_Context * ctx)
 		return res;
 
 	return pgp_s2k_process(&ctx->s2k, ctx->s2k_cipher_algo,
-			ctx->sym_key, ctx->sym_key_len);
+						   ctx->sym_key, ctx->sym_key_len);
 }
 
 static int
-init_sess_key(PGP_Context *ctx)
+init_sess_key(PGP_Context * ctx)
 {
-	int res;
+	int			res;
+
 	if (ctx->use_sess_key || ctx->pub_key)
 	{
 		ctx->sess_key_len = pgp_get_cipher_key_size(ctx->cipher_algo);
@@ -596,7 +605,8 @@ pgp_encrypt(PGP_Context * ctx, MBuf * src, MBuf * dst)
 	int			res;
 	int			len;
 	uint8	   *buf;
-	PushFilter *pf, *pf_tmp;
+	PushFilter *pf,
+			   *pf_tmp;
 
 	/*
 	 * do we have any key
@@ -618,7 +628,7 @@ pgp_encrypt(PGP_Context * ctx, MBuf * src, MBuf * dst)
 		if (res < 0)
 			goto out;
 	}
-	
+
 	res = init_sess_key(ctx);
 	if (res < 0)
 		goto out;
@@ -674,7 +684,7 @@ pgp_encrypt(PGP_Context * ctx, MBuf * src, MBuf * dst)
 		goto out;
 	pf = pf_tmp;
 
-	
+
 	/* text conversion? */
 	if (ctx->text_mode && ctx->convert_crlf)
 	{
@@ -696,4 +706,3 @@ out:
 	pushf_free_all(pf);
 	return res;
 }
-
diff --git a/contrib/pgcrypto/pgp-info.c b/contrib/pgcrypto/pgp-info.c
index 192f4aba31..6f9868ebaa 100644
--- a/contrib/pgcrypto/pgp-info.c
+++ b/contrib/pgcrypto/pgp-info.c
@@ -34,9 +34,10 @@
 #include "mbuf.h"
 #include "pgp.h"
 
-static int read_pubkey_keyid(PullFilter *pkt, uint8 *keyid_buf)
+static int
+read_pubkey_keyid(PullFilter * pkt, uint8 *keyid_buf)
 {
-	int res;
+	int			res;
 	PGP_PubKey *pk = NULL;
 
 	res = _pgp_read_public_key(pkt, &pk);
@@ -66,10 +67,11 @@ err:
 	return res;
 }
 
-static int read_pubenc_keyid(PullFilter *pkt, uint8 *keyid_buf)
+static int
+read_pubenc_keyid(PullFilter * pkt, uint8 *keyid_buf)
 {
-	uint8 ver;
-	int res;
+	uint8		ver;
+	int			res;
 
 	GETBYTE(pkt, ver);
 	if (ver != 3)
@@ -87,45 +89,50 @@ static const char hextbl[] = "0123456789ABCDEF";
 static int
 print_key(uint8 *keyid, char *dst)
 {
-	int i;
-	unsigned c;
-	for (i = 0; i < 8; i++) {
+	int			i;
+	unsigned	c;
+
+	for (i = 0; i < 8; i++)
+	{
 		c = keyid[i];
 		*dst++ = hextbl[(c >> 4) & 0x0F];
 		*dst++ = hextbl[c & 0x0F];
 	}
 	*dst = 0;
-	return 8*2;
+	return 8 * 2;
 }
 
-static const uint8 any_key[] = 
-{ 0, 0, 0, 0,  0, 0, 0, 0 };
+static const uint8 any_key[] =
+{0, 0, 0, 0, 0, 0, 0, 0};
 
 /*
  * dst should have room for 17 bytes
  */
 int
-pgp_get_keyid(MBuf *pgp_data, char *dst)
+pgp_get_keyid(MBuf * pgp_data, char *dst)
 {
-	int res;
+	int			res;
 	PullFilter *src;
 	PullFilter *pkt = NULL;
-	int len;
-	uint8 tag;
-	int got_pub_key=0, got_symenc_key=0, got_pubenc_key=0;
-	int got_data=0;
-	uint8 keyid_buf[8];
-	int got_main_key=0;
+	int			len;
+	uint8		tag;
+	int			got_pub_key = 0,
+				got_symenc_key = 0,
+				got_pubenc_key = 0;
+	int			got_data = 0;
+	uint8		keyid_buf[8];
+	int			got_main_key = 0;
 
 
 	res = pullf_create_mbuf_reader(&src, pgp_data);
 	if (res < 0)
 		return res;
 
-	while (1) {
+	while (1)
+	{
 		res = pgp_parse_pkt_hdr(src, &tag, &len, 0);
 		if (res <= 0)
-			break;				
+			break;
 		res = pgp_create_pkt_reader(&pkt, src, len, res, NULL);
 		if (res < 0)
 			break;
@@ -226,4 +233,3 @@ pgp_get_keyid(MBuf *pgp_data, char *dst)
 
 	return res;
 }
-
diff --git a/contrib/pgcrypto/pgp-mpi-internal.c b/contrib/pgcrypto/pgp-mpi-internal.c
index 65e394b4be..6206241588 100644
--- a/contrib/pgcrypto/pgp-mpi-internal.c
+++ b/contrib/pgcrypto/pgp-mpi-internal.c
@@ -35,27 +35,27 @@
 #include "pgp.h"
 
 int
-pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
-		PGP_MPI **c1_p, PGP_MPI **c2_p)
+pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * _m,
+					PGP_MPI ** c1_p, PGP_MPI ** c2_p)
 {
 	return PXE_PGP_NO_BIGNUM;
 }
 
 int
-pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
-		PGP_MPI **msg_p)
+pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * _c1, PGP_MPI * _c2,
+					PGP_MPI ** msg_p)
 {
 	return PXE_PGP_NO_BIGNUM;
 }
 
-int pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *m, PGP_MPI **c)
+int
+pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * m, PGP_MPI ** c)
 {
 	return PXE_PGP_NO_BIGNUM;
 }
 
-int pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *c, PGP_MPI **m)
+int
+pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * c, PGP_MPI ** m)
 {
 	return PXE_PGP_NO_BIGNUM;
 }
-
-
diff --git a/contrib/pgcrypto/pgp-mpi-openssl.c b/contrib/pgcrypto/pgp-mpi-openssl.c
index f52e8cff05..a06ed22bf7 100644
--- a/contrib/pgcrypto/pgp-mpi-openssl.c
+++ b/contrib/pgcrypto/pgp-mpi-openssl.c
@@ -37,15 +37,16 @@
 #include "pgp.h"
 
 static BIGNUM *
-mpi_to_bn(PGP_MPI *n)
+mpi_to_bn(PGP_MPI * n)
 {
-	BIGNUM *bn = BN_bin2bn(n->data, n->bytes, NULL);
+	BIGNUM	   *bn = BN_bin2bn(n->data, n->bytes, NULL);
+
 	if (!bn)
 		return NULL;
 	if (BN_num_bits(bn) != n->bits)
 	{
 		px_debug("mpi_to_bn: bignum conversion failed: mpi=%d, bn=%d",
-				n->bits, BN_num_bits(bn));
+				 n->bits, BN_num_bits(bn));
 		BN_clear_free(bn);
 		return NULL;
 	}
@@ -55,8 +56,8 @@ mpi_to_bn(PGP_MPI *n)
 static PGP_MPI *
 bn_to_mpi(BIGNUM *bn)
 {
-	int res;
-	PGP_MPI *n;
+	int			res;
+	PGP_MPI    *n;
 
 	res = pgp_mpi_alloc(BN_num_bits(bn), &n);
 	if (res < 0)
@@ -65,7 +66,7 @@ bn_to_mpi(BIGNUM *bn)
 	if (BN_num_bytes(bn) != n->bytes)
 	{
 		px_debug("bn_to_mpi: bignum conversion failed: bn=%d, mpi=%d",
-				BN_num_bytes(bn), n->bytes);
+				 BN_num_bytes(bn), n->bytes);
 		pgp_mpi_free(n);
 		return NULL;
 	}
@@ -81,7 +82,7 @@ bn_to_mpi(BIGNUM *bn)
  *
  * Until I research it further, I just mimic gpg behaviour.
  * It has a special mapping table, for values <= 5120,
- * above that it uses 'arbitrary high number'.  Following
+ * above that it uses 'arbitrary high number'.	Following
  * algorihm hovers 10-70 bits above gpg values.  And for
  * larger p, it uses gpg's algorihm.
  *
@@ -98,20 +99,20 @@ decide_k_bits(int p_bits)
 }
 
 int
-pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
-		PGP_MPI **c1_p, PGP_MPI **c2_p)
+pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * _m,
+					PGP_MPI ** c1_p, PGP_MPI ** c2_p)
 {
-	int res = PXE_PGP_MATH_FAILED;
-	int k_bits;
-	BIGNUM *m = mpi_to_bn(_m);
-	BIGNUM *p = mpi_to_bn(pk->pub.elg.p);
-	BIGNUM *g = mpi_to_bn(pk->pub.elg.g);
-	BIGNUM *y = mpi_to_bn(pk->pub.elg.y);
-	BIGNUM *k = BN_new();
-	BIGNUM *yk = BN_new();
-	BIGNUM *c1 = BN_new();
-	BIGNUM *c2 = BN_new();
-	BN_CTX *tmp = BN_CTX_new();
+	int			res = PXE_PGP_MATH_FAILED;
+	int			k_bits;
+	BIGNUM	   *m = mpi_to_bn(_m);
+	BIGNUM	   *p = mpi_to_bn(pk->pub.elg.p);
+	BIGNUM	   *g = mpi_to_bn(pk->pub.elg.g);
+	BIGNUM	   *y = mpi_to_bn(pk->pub.elg.y);
+	BIGNUM	   *k = BN_new();
+	BIGNUM	   *yk = BN_new();
+	BIGNUM	   *c1 = BN_new();
+	BIGNUM	   *c2 = BN_new();
+	BN_CTX	   *tmp = BN_CTX_new();
 
 	if (!m || !p || !g || !y || !k || !yk || !c1 || !c2 || !tmp)
 		goto err;
@@ -124,8 +125,7 @@ pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
 		goto err;
 
 	/*
-	 * c1 = g^k
-	 * c2 = m * y^k
+	 * c1 = g^k c2 = m * y^k
 	 */
 	if (!BN_mod_exp(c1, g, k, p, tmp))
 		goto err;
@@ -140,35 +140,44 @@ pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
 	if (*c1_p && *c2_p)
 		res = 0;
 err:
-	if (tmp) BN_CTX_free(tmp);
-	if (c2) BN_clear_free(c2);
-	if (c1) BN_clear_free(c1);
-	if (yk) BN_clear_free(yk);
-	if (k) BN_clear_free(k);
-	if (y) BN_clear_free(y);
-	if (g) BN_clear_free(g);
-	if (p) BN_clear_free(p);
-	if (m) BN_clear_free(m);
+	if (tmp)
+		BN_CTX_free(tmp);
+	if (c2)
+		BN_clear_free(c2);
+	if (c1)
+		BN_clear_free(c1);
+	if (yk)
+		BN_clear_free(yk);
+	if (k)
+		BN_clear_free(k);
+	if (y)
+		BN_clear_free(y);
+	if (g)
+		BN_clear_free(g);
+	if (p)
+		BN_clear_free(p);
+	if (m)
+		BN_clear_free(m);
 	return res;
 }
 
 int
-pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
-		PGP_MPI **msg_p)
+pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * _c1, PGP_MPI * _c2,
+					PGP_MPI ** msg_p)
 {
-	int res = PXE_PGP_MATH_FAILED;
-	BIGNUM *c1 = mpi_to_bn(_c1);
-	BIGNUM *c2 = mpi_to_bn(_c2);
-	BIGNUM *p = mpi_to_bn(pk->pub.elg.p);
-	BIGNUM *x = mpi_to_bn(pk->sec.elg.x);
-	BIGNUM *c1x = BN_new();
-	BIGNUM *div = BN_new();
-	BIGNUM *m = BN_new();
-	BN_CTX *tmp = BN_CTX_new();
+	int			res = PXE_PGP_MATH_FAILED;
+	BIGNUM	   *c1 = mpi_to_bn(_c1);
+	BIGNUM	   *c2 = mpi_to_bn(_c2);
+	BIGNUM	   *p = mpi_to_bn(pk->pub.elg.p);
+	BIGNUM	   *x = mpi_to_bn(pk->sec.elg.x);
+	BIGNUM	   *c1x = BN_new();
+	BIGNUM	   *div = BN_new();
+	BIGNUM	   *m = BN_new();
+	BN_CTX	   *tmp = BN_CTX_new();
 
 	if (!c1 || !c2 || !p || !x || !c1x || !div || !m || !tmp)
 		goto err;
-	
+
 	/*
 	 * m = c2 / (c1^x)
 	 */
@@ -184,26 +193,34 @@ pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
 	if (*msg_p)
 		res = 0;
 err:
-	if (tmp) BN_CTX_free(tmp);
-	if (m) BN_clear_free(m);
-	if (div) BN_clear_free(div);
-	if (c1x) BN_clear_free(c1x);
-	if (x) BN_clear_free(x);
-	if (p) BN_clear_free(p);
-	if (c2) BN_clear_free(c2);
-	if (c1) BN_clear_free(c1);
+	if (tmp)
+		BN_CTX_free(tmp);
+	if (m)
+		BN_clear_free(m);
+	if (div)
+		BN_clear_free(div);
+	if (c1x)
+		BN_clear_free(c1x);
+	if (x)
+		BN_clear_free(x);
+	if (p)
+		BN_clear_free(p);
+	if (c2)
+		BN_clear_free(c2);
+	if (c1)
+		BN_clear_free(c1);
 	return res;
 }
 
 int
-pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *_m, PGP_MPI **c_p)
+pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * _m, PGP_MPI ** c_p)
 {
-	int res = PXE_PGP_MATH_FAILED;
-	BIGNUM *m = mpi_to_bn(_m);
-	BIGNUM *e = mpi_to_bn(pk->pub.rsa.e);
-	BIGNUM *n = mpi_to_bn(pk->pub.rsa.n);
-	BIGNUM *c = BN_new();
-	BN_CTX *tmp = BN_CTX_new();
+	int			res = PXE_PGP_MATH_FAILED;
+	BIGNUM	   *m = mpi_to_bn(_m);
+	BIGNUM	   *e = mpi_to_bn(pk->pub.rsa.e);
+	BIGNUM	   *n = mpi_to_bn(pk->pub.rsa.n);
+	BIGNUM	   *c = BN_new();
+	BN_CTX	   *tmp = BN_CTX_new();
 
 	if (!m || !e || !n || !c || !tmp)
 		goto err;
@@ -218,23 +235,28 @@ pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *_m, PGP_MPI **c_p)
 	if (*c_p)
 		res = 0;
 err:
-	if (tmp) BN_CTX_free(tmp);
-	if (c) BN_clear_free(c);
-	if (n) BN_clear_free(n);
-	if (e) BN_clear_free(e);
-	if (m) BN_clear_free(m);
+	if (tmp)
+		BN_CTX_free(tmp);
+	if (c)
+		BN_clear_free(c);
+	if (n)
+		BN_clear_free(n);
+	if (e)
+		BN_clear_free(e);
+	if (m)
+		BN_clear_free(m);
 	return res;
 }
 
 int
-pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *_c, PGP_MPI **m_p)
+pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * _c, PGP_MPI ** m_p)
 {
-	int res = PXE_PGP_MATH_FAILED;
-	BIGNUM *c = mpi_to_bn(_c);
-	BIGNUM *d = mpi_to_bn(pk->sec.rsa.d);
-	BIGNUM *n = mpi_to_bn(pk->pub.rsa.n);
-	BIGNUM *m = BN_new();
-	BN_CTX *tmp = BN_CTX_new();
+	int			res = PXE_PGP_MATH_FAILED;
+	BIGNUM	   *c = mpi_to_bn(_c);
+	BIGNUM	   *d = mpi_to_bn(pk->sec.rsa.d);
+	BIGNUM	   *n = mpi_to_bn(pk->pub.rsa.n);
+	BIGNUM	   *m = BN_new();
+	BN_CTX	   *tmp = BN_CTX_new();
 
 	if (!m || !d || !n || !c || !tmp)
 		goto err;
@@ -249,11 +271,15 @@ pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *_c, PGP_MPI **m_p)
 	if (*m_p)
 		res = 0;
 err:
-	if (tmp) BN_CTX_free(tmp);
-	if (m) BN_clear_free(m);
-	if (n) BN_clear_free(n);
-	if (d) BN_clear_free(d);
-	if (c) BN_clear_free(c);
+	if (tmp)
+		BN_CTX_free(tmp);
+	if (m)
+		BN_clear_free(m);
+	if (n)
+		BN_clear_free(n);
+	if (d)
+		BN_clear_free(d);
+	if (c)
+		BN_clear_free(c);
 	return res;
 }
-
diff --git a/contrib/pgcrypto/pgp-mpi.c b/contrib/pgcrypto/pgp-mpi.c
index 3617c09e9e..cd45f333cf 100644
--- a/contrib/pgcrypto/pgp-mpi.c
+++ b/contrib/pgcrypto/pgp-mpi.c
@@ -34,10 +34,12 @@
 #include "mbuf.h"
 #include "pgp.h"
 
-int pgp_mpi_alloc(int bits, PGP_MPI **mpi)
+int
+pgp_mpi_alloc(int bits, PGP_MPI ** mpi)
 {
-	PGP_MPI *n;
-	int len = (bits + 7) / 8;
+	PGP_MPI    *n;
+	int			len = (bits + 7) / 8;
+
 	if (bits < 0 || bits > 0xFFFF)
 	{
 		px_debug("pgp_mpi_alloc: unreasonable request: bits=%d", bits);
@@ -46,15 +48,16 @@ int pgp_mpi_alloc(int bits, PGP_MPI **mpi)
 	n = px_alloc(sizeof(*n) + len);
 	n->bits = bits;
 	n->bytes = len;
-	n->data = (uint8*)(n) + sizeof(*n);
+	n->data = (uint8 *) (n) + sizeof(*n);
 	*mpi = n;
 	return 0;
 }
 
-int pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi)
+int
+pgp_mpi_create(uint8 *data, int bits, PGP_MPI ** mpi)
 {
-	int res;
-	PGP_MPI *n;
+	int			res;
+	PGP_MPI    *n;
 
 	res = pgp_mpi_alloc(bits, &n);
 	if (res < 0)
@@ -64,7 +67,8 @@ int pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi)
 	return 0;
 }
 
-int pgp_mpi_free(PGP_MPI *mpi)
+int
+pgp_mpi_free(PGP_MPI * mpi)
 {
 	if (mpi == NULL)
 		return 0;
@@ -73,17 +77,18 @@ int pgp_mpi_free(PGP_MPI *mpi)
 	return 0;
 }
 
-int pgp_mpi_read(PullFilter *src, PGP_MPI **mpi)
+int
+pgp_mpi_read(PullFilter * src, PGP_MPI ** mpi)
 {
-	int res;
-	uint8 hdr[2];
-	int bits;
-	PGP_MPI *n;
+	int			res;
+	uint8		hdr[2];
+	int			bits;
+	PGP_MPI    *n;
 
 	res = pullf_read_fixed(src, 2, hdr);
 	if (res < 0)
 		return res;
-	bits = ((unsigned)hdr[0] << 8) + hdr[1];
+	bits = ((unsigned) hdr[0] << 8) + hdr[1];
 
 	res = pgp_mpi_alloc(bits, &n);
 	if (res < 0)
@@ -97,10 +102,11 @@ int pgp_mpi_read(PullFilter *src, PGP_MPI **mpi)
 	return res;
 }
 
-int pgp_mpi_write(PushFilter *dst, PGP_MPI *n)
+int
+pgp_mpi_write(PushFilter * dst, PGP_MPI * n)
 {
-	int res;
-	uint8 buf[2];
+	int			res;
+	uint8		buf[2];
 
 	buf[0] = n->bits >> 8;
 	buf[1] = n->bits & 0xFF;
@@ -110,9 +116,10 @@ int pgp_mpi_write(PushFilter *dst, PGP_MPI *n)
 	return res;
 }
 
-int pgp_mpi_hash(PX_MD *md, PGP_MPI *n)
+int
+pgp_mpi_hash(PX_MD * md, PGP_MPI * n)
 {
-	uint8 buf[2];
+	uint8		buf[2];
 
 	buf[0] = n->bits >> 8;
 	buf[1] = n->bits & 0xFF;
@@ -122,9 +129,10 @@ int pgp_mpi_hash(PX_MD *md, PGP_MPI *n)
 	return 0;
 }
 
-unsigned pgp_mpi_cksum(unsigned cksum, PGP_MPI *n)
+unsigned
+pgp_mpi_cksum(unsigned cksum, PGP_MPI * n)
 {
-	int i;
+	int			i;
 
 	cksum += n->bits >> 8;
 	cksum += n->bits & 0xFF;
@@ -133,4 +141,3 @@ unsigned pgp_mpi_cksum(unsigned cksum, PGP_MPI *n)
 
 	return cksum & 0xFFFF;
 }
-
diff --git a/contrib/pgcrypto/pgp-pgsql.c b/contrib/pgcrypto/pgp-pgsql.c
index 9e651da28f..a7d6a93ed5 100644
--- a/contrib/pgcrypto/pgp-pgsql.c
+++ b/contrib/pgcrypto/pgp-pgsql.c
@@ -42,20 +42,20 @@
 /*
  * public functions
  */
-Datum pgp_sym_encrypt_text(PG_FUNCTION_ARGS);
-Datum pgp_sym_encrypt_bytea(PG_FUNCTION_ARGS);
-Datum pgp_sym_decrypt_text(PG_FUNCTION_ARGS);
-Datum pgp_sym_decrypt_bytea(PG_FUNCTION_ARGS);
+Datum		pgp_sym_encrypt_text(PG_FUNCTION_ARGS);
+Datum		pgp_sym_encrypt_bytea(PG_FUNCTION_ARGS);
+Datum		pgp_sym_decrypt_text(PG_FUNCTION_ARGS);
+Datum		pgp_sym_decrypt_bytea(PG_FUNCTION_ARGS);
 
-Datum pgp_pub_encrypt_text(PG_FUNCTION_ARGS);
-Datum pgp_pub_encrypt_bytea(PG_FUNCTION_ARGS);
-Datum pgp_pub_decrypt_text(PG_FUNCTION_ARGS);
-Datum pgp_pub_decrypt_bytea(PG_FUNCTION_ARGS);
+Datum		pgp_pub_encrypt_text(PG_FUNCTION_ARGS);
+Datum		pgp_pub_encrypt_bytea(PG_FUNCTION_ARGS);
+Datum		pgp_pub_decrypt_text(PG_FUNCTION_ARGS);
+Datum		pgp_pub_decrypt_bytea(PG_FUNCTION_ARGS);
 
-Datum pgp_key_id_w(PG_FUNCTION_ARGS);
+Datum		pgp_key_id_w(PG_FUNCTION_ARGS);
 
-Datum pg_armor(PG_FUNCTION_ARGS);
-Datum pg_dearmor(PG_FUNCTION_ARGS);
+Datum		pg_armor(PG_FUNCTION_ARGS);
+Datum		pg_dearmor(PG_FUNCTION_ARGS);
 
 /* function headers */
 
@@ -89,9 +89,10 @@ PG_FUNCTION_INFO_V1(pg_dearmor);
 /*
  * Mix a block of data into RNG.
  */
-static void add_block_entropy(PX_MD *md, text *data)
+static void
+add_block_entropy(PX_MD * md, text *data)
 {
-	uint8 sha1[20];
+	uint8		sha1[20];
 
 	px_md_reset(md);
 	px_md_update(md, (uint8 *) VARDATA(data), VARSIZE(data) - VARHDRSZ);
@@ -103,13 +104,14 @@ static void add_block_entropy(PX_MD *md, text *data)
 }
 
 /*
- * Mix user data into RNG.  It is for user own interests to have
+ * Mix user data into RNG.	It is for user own interests to have
  * RNG state shuffled.
  */
-static void add_entropy(text *data1,  text *data2, text *data3)
+static void
+add_entropy(text *data1, text *data2, text *data3)
 {
-	PX_MD *md;
-	uint8 rnd[3];
+	PX_MD	   *md;
+	uint8		rnd[3];
 
 	if (!data1 && !data2 && !data3)
 		return;
@@ -122,9 +124,9 @@ static void add_entropy(text *data1,  text *data2, text *data3)
 
 	/*
 	 * Try to make the feeding unpredictable.
-	 * 
-	 * Prefer data over keys, as it's rather likely
-	 * that key is same in several calls.
+	 *
+	 * Prefer data over keys, as it's rather likely that key is same in several
+	 * calls.
 	 */
 
 	/* chance: 7/8 */
@@ -146,14 +148,15 @@ static void add_entropy(text *data1,  text *data2, text *data3)
 /*
  * returns src in case of no conversion or error
  */
-static text *convert_charset(text *src, int cset_from, int cset_to)
+static text *
+convert_charset(text *src, int cset_from, int cset_to)
 {
-	int src_len = VARSIZE(src) - VARHDRSZ;
-	int dst_len;
+	int			src_len = VARSIZE(src) - VARHDRSZ;
+	int			dst_len;
 	unsigned char *dst;
 	unsigned char *csrc = (unsigned char *) VARDATA(src);
-	text *res;
-	
+	text	   *res;
+
 	dst = pg_do_encoding_conversion(csrc, src_len, cset_from, cset_to);
 	if (dst == csrc)
 		return src;
@@ -166,12 +169,14 @@ static text *convert_charset(text *src, int cset_from, int cset_to)
 	return res;
 }
 
-static text *convert_from_utf8(text *src)
+static text *
+convert_from_utf8(text *src)
 {
 	return convert_charset(src, PG_UTF8, GetDatabaseEncoding());
 }
 
-static text *convert_to_utf8(text *src)
+static text *
+convert_to_utf8(text *src)
 {
 	return convert_charset(src, GetDatabaseEncoding(), PG_UTF8);
 }
@@ -186,20 +191,22 @@ clear_and_pfree(text *p)
 /*
  * expect-* arguments storage
  */
-struct debug_expect {
-	int debug;
-	int expect;
-	int cipher_algo;
-	int s2k_mode;
-	int s2k_cipher_algo;
-	int s2k_digest_algo;
-	int compress_algo;
-	int use_sess_key;
-	int disable_mdc;
-	int unicode_mode;
+struct debug_expect
+{
+	int			debug;
+	int			expect;
+	int			cipher_algo;
+	int			s2k_mode;
+	int			s2k_cipher_algo;
+	int			s2k_digest_algo;
+	int			compress_algo;
+	int			use_sess_key;
+	int			disable_mdc;
+	int			unicode_mode;
 };
 
-static void fill_expect(struct debug_expect *ex, int text_mode)
+static void
+fill_expect(struct debug_expect * ex, int text_mode)
 {
 	ex->debug = 0;
 	ex->expect = 0;
@@ -222,7 +229,8 @@ static void fill_expect(struct debug_expect *ex, int text_mode)
 		if (ex->arg >= 0 && ex->arg != ctx->arg) EX_MSG(arg); \
 	} while (0)
 
-static void check_expect(PGP_Context *ctx, struct debug_expect *ex)
+static void
+check_expect(PGP_Context * ctx, struct debug_expect * ex)
 {
 	EX_CHECK(cipher_algo);
 	EX_CHECK(s2k_mode);
@@ -235,15 +243,18 @@ static void check_expect(PGP_Context *ctx, struct debug_expect *ex)
 	EX_CHECK(unicode_mode);
 }
 
-static void show_debug(const char *msg)
+static void
+show_debug(const char *msg)
 {
 	ereport(NOTICE, (errmsg("dbg: %s", msg)));
 }
 
-static int set_arg(PGP_Context *ctx, char *key, char*val,
-		struct debug_expect *ex)
+static int
+set_arg(PGP_Context * ctx, char *key, char *val,
+		struct debug_expect * ex)
 {
-	int res = 0;
+	int			res = 0;
+
 	if (strcmp(key, "cipher-algo") == 0)
 		res = pgp_set_cipher_algo(ctx, val);
 	else if (strcmp(key, "disable-mdc") == 0)
@@ -314,11 +325,12 @@ static int set_arg(PGP_Context *ctx, char *key, char*val,
 }
 
 /*
- * Find next word.  Handle ',' and '=' as words.  Skip whitespace.
+ * Find next word.	Handle ',' and '=' as words.  Skip whitespace.
  * Put word info into res_p, res_len.
  * Returns ptr to next word.
  */
-static char *getword(char *p, char **res_p, int *res_len)
+static char *
+getword(char *p, char **res_p, int *res_len)
 {
 	/* whitespace at start */
 	while (*p && (*p == ' ' || *p == '\t' || *p == '\n'))
@@ -330,12 +342,12 @@ static char *getword(char *p, char **res_p, int *res_len)
 		p++;
 	else
 		while (*p && !(*p == ' ' || *p == '\t' || *p == '\n'
-					|| *p == '=' || *p == ','))
+					   || *p == '=' || *p == ','))
 			p++;
 
 	/* word end */
 	*res_len = p - *res_p;
-	
+
 	/* whitespace at end */
 	while (*p && (*p == ' ' || *p == '\t' || *p == '\n'))
 		p++;
@@ -346,11 +358,15 @@ static char *getword(char *p, char **res_p, int *res_len)
 /*
  * Convert to lowercase asciiz string.
  */
-static char *downcase_convert(const uint8 *s, int len)
+static char *
+downcase_convert(const uint8 *s, int len)
 {
-	int c, i;
-	char *res = palloc(len + 1);
-	for (i = 0; i < len; i++) {
+	int			c,
+				i;
+	char	   *res = palloc(len + 1);
+
+	for (i = 0; i < len; i++)
+	{
 		c = s[i];
 		if (c >= 'A' && c <= 'Z')
 			c += 'a' - 'A';
@@ -360,14 +376,17 @@ static char *downcase_convert(const uint8 *s, int len)
 	return res;
 }
 
-static int parse_args(PGP_Context *ctx, uint8 *args, int arg_len,
-		struct debug_expect *ex)
+static int
+parse_args(PGP_Context * ctx, uint8 *args, int arg_len,
+		   struct debug_expect * ex)
 {
-	char *str = downcase_convert(args, arg_len);
-	char *key, *val;
-	int key_len, val_len;
-	int res = 0;
-	char *p = str;
+	char	   *str = downcase_convert(args, arg_len);
+	char	   *key,
+			   *val;
+	int			key_len,
+				val_len;
+	int			res = 0;
+	char	   *p = str;
 
 	while (*p)
 	{
@@ -403,10 +422,10 @@ create_mbuf_from_vardata(text *data)
 }
 
 static void
-init_work(PGP_Context **ctx_p, int is_text,
-		text *args, struct debug_expect *ex)
+init_work(PGP_Context ** ctx_p, int is_text,
+		  text *args, struct debug_expect * ex)
 {
-	int err = pgp_init(ctx_p);
+	int			err = pgp_init(ctx_p);
 
 	fill_expect(ex, is_text);
 
@@ -429,17 +448,18 @@ init_work(PGP_Context **ctx_p, int is_text,
 
 static bytea *
 encrypt_internal(int is_pubenc, int is_text,
-		text *data, text *key, text *args)
+				 text *data, text *key, text *args)
 {
-	MBuf *src, *dst;
-	uint8	tmp[VARHDRSZ];
-	uint8 *restmp;
-	bytea *res;
-	int res_len;
+	MBuf	   *src,
+			   *dst;
+	uint8		tmp[VARHDRSZ];
+	uint8	   *restmp;
+	bytea	   *res;
+	int			res_len;
 	PGP_Context *ctx;
-	int err;
+	int			err;
 	struct debug_expect ex;
-	text *tmp_data = NULL;
+	text	   *tmp_data = NULL;
 
 	/*
 	 * Add data and key info RNG.
@@ -470,15 +490,16 @@ encrypt_internal(int is_pubenc, int is_text,
 	 */
 	if (is_pubenc)
 	{
-		MBuf *kbuf = create_mbuf_from_vardata(key);
+		MBuf	   *kbuf = create_mbuf_from_vardata(key);
+
 		err = pgp_set_pubkey(ctx, kbuf,
-				NULL, 0, 0);
+							 NULL, 0, 0);
 		mbuf_free(kbuf);
 	}
 	else
 		err = pgp_set_symkey(ctx, (uint8 *) VARDATA(key),
 							 VARSIZE(key) - VARHDRSZ);
-	
+
 	/*
 	 * encrypt
 	 */
@@ -520,17 +541,18 @@ encrypt_internal(int is_pubenc, int is_text,
 
 static bytea *
 decrypt_internal(int is_pubenc, int need_text, text *data,
-		text *key, text *keypsw, text *args)
+				 text *key, text *keypsw, text *args)
 {
-	int err;
-	MBuf *src = NULL, *dst = NULL;
-	uint8	tmp[VARHDRSZ];
-	uint8 *restmp;
-	bytea *res;
-	int res_len;
+	int			err;
+	MBuf	   *src = NULL,
+			   *dst = NULL;
+	uint8		tmp[VARHDRSZ];
+	uint8	   *restmp;
+	bytea	   *res;
+	int			res_len;
 	PGP_Context *ctx = NULL;
 	struct debug_expect ex;
-	int got_unicode = 0;
+	int			got_unicode = 0;
 
 
 	init_work(&ctx, need_text, args, &ex);
@@ -543,15 +565,16 @@ decrypt_internal(int is_pubenc, int need_text, text *data,
 	 * reserve room for header
 	 */
 	mbuf_append(dst, tmp, VARHDRSZ);
-	
+
 	/*
 	 * set key
 	 */
 	if (is_pubenc)
 	{
-		uint8 *psw = NULL;
-		int psw_len = 0;
-		MBuf *kbuf;
+		uint8	   *psw = NULL;
+		int			psw_len = 0;
+		MBuf	   *kbuf;
+
 		if (keypsw)
 		{
 			psw = (uint8 *) VARDATA(keypsw);
@@ -608,7 +631,8 @@ out:
 
 	if (need_text && got_unicode)
 	{
-		text *utf = convert_from_utf8(res);
+		text	   *utf = convert_from_utf8(res);
+
 		if (utf != res)
 		{
 			clear_and_pfree(res);
@@ -927,4 +951,3 @@ pgp_key_id_w(PG_FUNCTION_ARGS)
 	PG_FREE_IF_COPY(data, 0);
 	PG_RETURN_TEXT_P(res);
 }
-
diff --git a/contrib/pgcrypto/pgp-pubdec.c b/contrib/pgcrypto/pgp-pubdec.c
index f5836c351d..4819761bbb 100644
--- a/contrib/pgcrypto/pgp-pubdec.c
+++ b/contrib/pgcrypto/pgp-pubdec.c
@@ -35,24 +35,25 @@
 #include "pgp.h"
 
 /*
- * padded msg = 02 || PS || 00 || M 
+ * padded msg = 02 || PS || 00 || M
  * PS - pad bytes
  * M - msg
  */
 static uint8 *
 check_eme_pkcs1_v15(uint8 *data, int len)
 {
-	uint8 *data_end = data + len;
-	uint8 *p = data;
-	int rnd = 0;
+	uint8	   *data_end = data + len;
+	uint8	   *p = data;
+	int			rnd = 0;
 
 	if (len < 1 + 8 + 1)
 		return NULL;
 
 	if (*p++ != 2)
 		return NULL;
-	
-	while (p < data_end && *p) {
+
+	while (p < data_end && *p)
+	{
 		p++;
 		rnd++;
 	}
@@ -73,8 +74,9 @@ check_eme_pkcs1_v15(uint8 *data, int len)
 static int
 control_cksum(uint8 *msg, int msglen)
 {
-	int i;
-	unsigned my_cksum, got_cksum;
+	int			i;
+	unsigned	my_cksum,
+				got_cksum;
 
 	if (msglen < 3)
 		return PXE_PGP_WRONG_KEY;
@@ -83,8 +85,9 @@ control_cksum(uint8 *msg, int msglen)
 	for (i = 1; i < msglen - 2; i++)
 		my_cksum += msg[i];
 	my_cksum &= 0xFFFF;
-	got_cksum = ((unsigned)(msg[msglen-2]) << 8) + msg[msglen-1];
-	if (my_cksum != got_cksum) {
+	got_cksum = ((unsigned) (msg[msglen - 2]) << 8) + msg[msglen - 1];
+	if (my_cksum != got_cksum)
+	{
 		px_debug("pubenc cksum failed");
 		return PXE_PGP_WRONG_KEY;
 	}
@@ -92,11 +95,11 @@ control_cksum(uint8 *msg, int msglen)
 }
 
 static int
-decrypt_elgamal(PGP_PubKey *pk, PullFilter *pkt, PGP_MPI **m_p)
+decrypt_elgamal(PGP_PubKey * pk, PullFilter * pkt, PGP_MPI ** m_p)
 {
-	int res;
-	PGP_MPI *c1 = NULL;
-	PGP_MPI *c2 = NULL;
+	int			res;
+	PGP_MPI    *c1 = NULL;
+	PGP_MPI    *c2 = NULL;
 
 	if (pk->algo != PGP_PUB_ELG_ENCRYPT)
 		return PXE_PGP_WRONG_KEY;
@@ -119,13 +122,13 @@ out:
 }
 
 static int
-decrypt_rsa(PGP_PubKey *pk, PullFilter *pkt, PGP_MPI **m_p)
+decrypt_rsa(PGP_PubKey * pk, PullFilter * pkt, PGP_MPI ** m_p)
 {
-	int res;
-	PGP_MPI *c;
+	int			res;
+	PGP_MPI    *c;
 
 	if (pk->algo != PGP_PUB_RSA_ENCRYPT
-			&& pk->algo != PGP_PUB_RSA_ENCRYPT_SIGN)
+		&& pk->algo != PGP_PUB_RSA_ENCRYPT_SIGN)
 		return PXE_PGP_WRONG_KEY;
 
 	/* read rsa encrypted data */
@@ -142,28 +145,30 @@ decrypt_rsa(PGP_PubKey *pk, PullFilter *pkt, PGP_MPI **m_p)
 
 /* key id is missing - user is expected to try all keys */
 static const uint8
-any_key[] = {0, 0, 0, 0, 0, 0, 0, 0};
+			any_key[] = {0, 0, 0, 0, 0, 0, 0, 0};
 
 int
-pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt)
+pgp_parse_pubenc_sesskey(PGP_Context * ctx, PullFilter * pkt)
 {
-	int ver;
-	int algo;
-	int res;
-	uint8 key_id[8];
+	int			ver;
+	int			algo;
+	int			res;
+	uint8		key_id[8];
 	PGP_PubKey *pk;
-	uint8 *msg;
-	int msglen;
-	PGP_MPI *m;
+	uint8	   *msg;
+	int			msglen;
+	PGP_MPI    *m;
 
 	pk = ctx->pub_key;
-	if (pk == NULL) {
+	if (pk == NULL)
+	{
 		px_debug("no pubkey?");
 		return PXE_BUG;
 	}
 
 	GETBYTE(pkt, ver);
-	if (ver != 3) {
+	if (ver != 3)
+	{
 		px_debug("unknown pubenc_sesskey pkt ver=%d", ver);
 		return PXE_PGP_CORRUPT_DATA;
 	}
@@ -175,7 +180,7 @@ pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt)
 	if (res < 0)
 		return res;
 	if (memcmp(key_id, any_key, 8) != 0
-	 && memcmp(key_id, pk->key_id, 8) != 0)
+		&& memcmp(key_id, pk->key_id, 8) != 0)
 	{
 		px_debug("key_id's does not match");
 		return PXE_PGP_WRONG_KEY;
@@ -204,7 +209,8 @@ pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt)
 	 * extract message
 	 */
 	msg = check_eme_pkcs1_v15(m->data, m->bytes);
-	if (msg == NULL) {
+	if (msg == NULL)
+	{
 		px_debug("check_eme_pkcs1_v15 failed");
 		res = PXE_PGP_WRONG_KEY;
 		goto out;
@@ -228,5 +234,3 @@ out:
 		return res;
 	return pgp_expect_packet_end(pkt);
 }
-
-
diff --git a/contrib/pgcrypto/pgp-pubenc.c b/contrib/pgcrypto/pgp-pubenc.c
index 6452583a7b..321d2c379d 100644
--- a/contrib/pgcrypto/pgp-pubenc.c
+++ b/contrib/pgcrypto/pgp-pubenc.c
@@ -1,6 +1,6 @@
 /*
  * pgp-pubenc.c
- *    Encrypt session key with public key.
+ *	  Encrypt session key with public key.
  *
  * Copyright (c) 2005 Marko Kreen
  * All rights reserved.
@@ -40,9 +40,10 @@
 static int
 pad_eme_pkcs1_v15(uint8 *data, int data_len, int res_len, uint8 **res_p)
 {
-	int res;
-	uint8 *buf, *p;
-	int pad_len = res_len - 2 - data_len;
+	int			res;
+	uint8	   *buf,
+			   *p;
+	int			pad_len = res_len - 2 - data_len;
 
 	if (pad_len < 8)
 		return PXE_BUG;
@@ -76,7 +77,7 @@ pad_eme_pkcs1_v15(uint8 *data, int data_len, int res_len, uint8 **res_p)
 		px_free(buf);
 		return res;
 	}
-			
+
 	buf[pad_len + 1] = 0;
 	memcpy(buf + pad_len + 2, data, data_len);
 	*res_p = buf;
@@ -85,19 +86,20 @@ pad_eme_pkcs1_v15(uint8 *data, int data_len, int res_len, uint8 **res_p)
 }
 
 static int
-create_secmsg(PGP_Context *ctx, PGP_MPI **msg_p, int full_bytes)
+create_secmsg(PGP_Context * ctx, PGP_MPI ** msg_p, int full_bytes)
 {
-	uint8 *secmsg;
-	int res, i;
-	unsigned cksum = 0;
-	int klen = ctx->sess_key_len;
-	uint8 *padded = NULL;
-	PGP_MPI *m = NULL;
+	uint8	   *secmsg;
+	int			res,
+				i;
+	unsigned	cksum = 0;
+	int			klen = ctx->sess_key_len;
+	uint8	   *padded = NULL;
+	PGP_MPI    *m = NULL;
 
 	/* calc checksum */
 	for (i = 0; i < klen; i++)
 		cksum += ctx->sess_key[i];
-	
+
 	/*
 	 * create "secret message"
 	 */
@@ -114,7 +116,8 @@ create_secmsg(PGP_Context *ctx, PGP_MPI **msg_p, int full_bytes)
 	if (res >= 0)
 	{
 		/* first byte will be 0x02 */
-		int full_bits = full_bytes * 8 - 6;
+		int			full_bits = full_bytes * 8 - 6;
+
 		res = pgp_mpi_create(padded, full_bits, &m);
 	}
 
@@ -133,10 +136,12 @@ create_secmsg(PGP_Context *ctx, PGP_MPI **msg_p, int full_bytes)
 }
 
 static int
-encrypt_and_write_elgamal(PGP_Context *ctx, PGP_PubKey *pk, PushFilter *pkt)
+encrypt_and_write_elgamal(PGP_Context * ctx, PGP_PubKey * pk, PushFilter * pkt)
 {
-	int res;
-	PGP_MPI *m = NULL, *c1 = NULL, *c2 = NULL;
+	int			res;
+	PGP_MPI    *m = NULL,
+			   *c1 = NULL,
+			   *c2 = NULL;
 
 	/* create padded msg */
 	res = create_secmsg(ctx, &m, pk->pub.elg.p->bytes - 1);
@@ -162,10 +167,11 @@ err:
 }
 
 static int
-encrypt_and_write_rsa(PGP_Context *ctx, PGP_PubKey *pk, PushFilter *pkt)
+encrypt_and_write_rsa(PGP_Context * ctx, PGP_PubKey * pk, PushFilter * pkt)
 {
-	int res;
-	PGP_MPI *m = NULL, *c = NULL;
+	int			res;
+	PGP_MPI    *m = NULL,
+			   *c = NULL;
 
 	/* create padded msg */
 	res = create_secmsg(ctx, &m, pk->pub.rsa.n->bytes - 1);
@@ -186,15 +192,17 @@ err:
 	return res;
 }
 
-int pgp_write_pubenc_sesskey(PGP_Context *ctx, PushFilter *dst)
+int
+pgp_write_pubenc_sesskey(PGP_Context * ctx, PushFilter * dst)
 {
-	int res;
+	int			res;
 	PGP_PubKey *pk = ctx->pub_key;
-	uint8 ver = 3;
+	uint8		ver = 3;
 	PushFilter *pkt = NULL;
-	uint8 algo = pk->algo;
+	uint8		algo = pk->algo;
 
-	if (pk == NULL) {
+	if (pk == NULL)
+	{
 		px_debug("no pubkey?\n");
 		return PXE_BUG;
 	}
@@ -238,5 +246,3 @@ err:
 
 	return res;
 }
-
-
diff --git a/contrib/pgcrypto/pgp-pubkey.c b/contrib/pgcrypto/pgp-pubkey.c
index 5f69de7224..2c1311134d 100644
--- a/contrib/pgcrypto/pgp-pubkey.c
+++ b/contrib/pgcrypto/pgp-pubkey.c
@@ -34,16 +34,19 @@
 #include "mbuf.h"
 #include "pgp.h"
 
-int pgp_key_alloc(PGP_PubKey **pk_p)
+int
+pgp_key_alloc(PGP_PubKey ** pk_p)
 {
 	PGP_PubKey *pk;
+
 	pk = px_alloc(sizeof(*pk));
 	memset(pk, 0, sizeof(*pk));
 	*pk_p = pk;
 	return 0;
 }
 
-void pgp_key_free(PGP_PubKey *pk)
+void
+pgp_key_free(PGP_PubKey * pk)
 {
 	if (pk == NULL)
 		return;
@@ -79,13 +82,13 @@ void pgp_key_free(PGP_PubKey *pk)
 }
 
 static int
-calc_key_id(PGP_PubKey *pk)
+calc_key_id(PGP_PubKey * pk)
 {
-	int res;
-	PX_MD *md;
-	int len;
-	uint8 hdr[3];
-	uint8 hash[20];
+	int			res;
+	PX_MD	   *md;
+	int			len;
+	uint8		hdr[3];
+	uint8		hash[20];
 
 	res = pgp_load_digest(PGP_DIGEST_SHA1, &md);
 	if (res < 0)
@@ -121,7 +124,7 @@ calc_key_id(PGP_PubKey *pk)
 	px_md_update(md, &pk->ver, 1);
 	px_md_update(md, pk->time, 4);
 	px_md_update(md, &pk->algo, 1);
-	
+
 	switch (pk->algo)
 	{
 		case PGP_PUB_ELG_ENCRYPT:
@@ -152,9 +155,10 @@ calc_key_id(PGP_PubKey *pk)
 	return 0;
 }
 
-int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p)
+int
+_pgp_read_public_key(PullFilter * pkt, PGP_PubKey ** pk_p)
 {
-	int res;
+	int			res;
 	PGP_PubKey *pk;
 
 	res = pgp_key_alloc(&pk);
@@ -163,11 +167,12 @@ int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p)
 
 	/* get version */
 	GETBYTE(pkt, pk->ver);
-	if (pk->ver != 4) {
+	if (pk->ver != 4)
+	{
 		res = PXE_PGP_NOT_V4_KEYPKT;
 		goto out;
 	}
-	
+
 	/* read time */
 	res = pullf_read_fixed(pkt, 4, pk->time);
 	if (res < 0)
@@ -176,16 +181,21 @@ int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p)
 	/* pubkey algorithm */
 	GETBYTE(pkt, pk->algo);
 
-	switch (pk->algo) {
+	switch (pk->algo)
+	{
 		case PGP_PUB_DSA_SIGN:
 			res = pgp_mpi_read(pkt, &pk->pub.dsa.p);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->pub.dsa.q);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->pub.dsa.g);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->pub.dsa.y);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 
 			res = calc_key_id(pk);
 			break;
@@ -194,9 +204,11 @@ int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p)
 		case PGP_PUB_RSA_ENCRYPT:
 		case PGP_PUB_RSA_ENCRYPT_SIGN:
 			res = pgp_mpi_read(pkt, &pk->pub.rsa.n);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->pub.rsa.e);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 
 			res = calc_key_id(pk);
 
@@ -206,11 +218,14 @@ int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p)
 
 		case PGP_PUB_ELG_ENCRYPT:
 			res = pgp_mpi_read(pkt, &pk->pub.elg.p);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->pub.elg.g);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->pub.elg.y);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 
 			res = calc_key_id(pk);
 
@@ -236,12 +251,12 @@ out:
 #define HIDE_SHA1 254
 
 static int
-check_key_sha1(PullFilter *src, PGP_PubKey *pk)
+check_key_sha1(PullFilter * src, PGP_PubKey * pk)
 {
-	int res;
-	uint8 got_sha1[20];
-	uint8 my_sha1[20];
-	PX_MD *md;
+	int			res;
+	uint8		got_sha1[20];
+	uint8		my_sha1[20];
+	PX_MD	   *md;
 
 	res = pullf_read_fixed(src, 20, got_sha1);
 	if (res < 0)
@@ -282,17 +297,18 @@ err:
 }
 
 static int
-check_key_cksum(PullFilter *src, PGP_PubKey *pk)
+check_key_cksum(PullFilter * src, PGP_PubKey * pk)
 {
-	int res;
-	unsigned got_cksum, my_cksum = 0;
-	uint8 buf[2];
+	int			res;
+	unsigned	got_cksum,
+				my_cksum = 0;
+	uint8		buf[2];
 
 	res = pullf_read_fixed(src, 2, buf);
 	if (res < 0)
 		return res;
 
-	got_cksum = ((unsigned)buf[0] << 8) + buf[1];
+	got_cksum = ((unsigned) buf[0] << 8) + buf[1];
 	switch (pk->algo)
 	{
 		case PGP_PUB_ELG_ENCRYPT:
@@ -318,17 +334,19 @@ check_key_cksum(PullFilter *src, PGP_PubKey *pk)
 	return 0;
 }
 
-static int process_secret_key(PullFilter *pkt, PGP_PubKey **pk_p,
-		const uint8 *key, int key_len)
+static int
+process_secret_key(PullFilter * pkt, PGP_PubKey ** pk_p,
+				   const uint8 *key, int key_len)
 {
-	int res;
-	int hide_type;
-	int cipher_algo;
-	int bs;
-	uint8 iv[512];
-	PullFilter *pf_decrypt = NULL, *pf_key;
-	PGP_CFB *cfb = NULL;
-	PGP_S2K s2k;
+	int			res;
+	int			hide_type;
+	int			cipher_algo;
+	int			bs;
+	uint8		iv[512];
+	PullFilter *pf_decrypt = NULL,
+			   *pf_key;
+	PGP_CFB    *cfb = NULL;
+	PGP_S2K		s2k;
 	PGP_PubKey *pk;
 
 	/* first read public key part */
@@ -340,7 +358,8 @@ static int process_secret_key(PullFilter *pkt, PGP_PubKey **pk_p,
 	 * is secret key encrypted?
 	 */
 	GETBYTE(pkt, hide_type);
-	if (hide_type == HIDE_SHA1 || hide_type == HIDE_CKSUM) {
+	if (hide_type == HIDE_SHA1 || hide_type == HIDE_CKSUM)
+	{
 		if (key == NULL)
 			return PXE_PGP_NEED_SECRET_PSW;
 		GETBYTE(pkt, cipher_algo);
@@ -351,15 +370,17 @@ static int process_secret_key(PullFilter *pkt, PGP_PubKey **pk_p,
 		res = pgp_s2k_process(&s2k, cipher_algo, key, key_len);
 		if (res < 0)
 			return res;
-				
+
 		bs = pgp_get_cipher_block_size(cipher_algo);
-		if (bs == 0) {
+		if (bs == 0)
+		{
 			px_debug("unknown cipher algo=%d", cipher_algo);
 			return PXE_PGP_UNSUPPORTED_CIPHER;
 		}
 		res = pullf_read_fixed(pkt, bs, iv);
 		if (res < 0)
 			return res;
+
 		/*
 		 * create decrypt filter
 		 */
@@ -370,26 +391,35 @@ static int process_secret_key(PullFilter *pkt, PGP_PubKey **pk_p,
 		if (res < 0)
 			return res;
 		pf_key = pf_decrypt;
-	} else if (hide_type == HIDE_CLEAR) {
+	}
+	else if (hide_type == HIDE_CLEAR)
+	{
 		pf_key = pkt;
-	} else {
+	}
+	else
+	{
 		px_debug("unknown hide type");
 		return PXE_PGP_KEYPKT_CORRUPT;
 	}
 
 	/* read secret key */
-	switch (pk->algo) {
+	switch (pk->algo)
+	{
 		case PGP_PUB_RSA_SIGN:
 		case PGP_PUB_RSA_ENCRYPT:
 		case PGP_PUB_RSA_ENCRYPT_SIGN:
 			res = pgp_mpi_read(pkt, &pk->sec.rsa.d);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->sec.rsa.p);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->sec.rsa.q);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			res = pgp_mpi_read(pkt, &pk->sec.rsa.u);
-			if (res < 0) break;
+			if (res < 0)
+				break;
 			break;
 		case PGP_PUB_ELG_ENCRYPT:
 			res = pgp_mpi_read(pf_key, &pk->sec.elg.x);
@@ -426,31 +456,33 @@ static int process_secret_key(PullFilter *pkt, PGP_PubKey **pk_p,
 }
 
 static int
-internal_read_key(PullFilter *src, PGP_PubKey **pk_p,
-					const uint8 *psw, int psw_len, int pubtype)
+internal_read_key(PullFilter * src, PGP_PubKey ** pk_p,
+				  const uint8 *psw, int psw_len, int pubtype)
 {
 	PullFilter *pkt = NULL;
-	int res;
-	uint8 tag;
-	int len;
+	int			res;
+	uint8		tag;
+	int			len;
 	PGP_PubKey *enc_key = NULL;
 	PGP_PubKey *pk = NULL;
-	int got_main_key = 0;
+	int			got_main_key = 0;
 
 	/*
 	 * Search for encryption key.
 	 *
 	 * Error out on anything fancy.
 	 */
-	while (1) {
+	while (1)
+	{
 		res = pgp_parse_pkt_hdr(src, &tag, &len, 0);
 		if (res <= 0)
 			break;
 		res = pgp_create_pkt_reader(&pkt, src, len, res, NULL);
 		if (res < 0)
 			break;
-		
-		switch (tag) {
+
+		switch (tag)
+		{
 			case PGP_PKT_PUBLIC_KEY:
 			case PGP_PKT_SECRET_KEY:
 				if (got_main_key)
@@ -489,7 +521,7 @@ internal_read_key(PullFilter *src, PGP_PubKey **pk_p,
 				res = PXE_PGP_UNEXPECTED_PKT;
 		}
 		pullf_free(pkt);
-	   	pkt = NULL;
+		pkt = NULL;
 
 		if (pk != NULL)
 		{
@@ -531,10 +563,10 @@ internal_read_key(PullFilter *src, PGP_PubKey **pk_p,
 }
 
 int
-pgp_set_pubkey(PGP_Context *ctx, MBuf *keypkt, 
-		const uint8 *key, int key_len, int pubtype)
+pgp_set_pubkey(PGP_Context * ctx, MBuf * keypkt,
+			   const uint8 *key, int key_len, int pubtype)
 {
-	int res;
+	int			res;
 	PullFilter *src;
 	PGP_PubKey *pk = NULL;
 
@@ -550,4 +582,3 @@ pgp_set_pubkey(PGP_Context *ctx, MBuf *keypkt,
 
 	return res < 0 ? res : 0;
 }
-
diff --git a/contrib/pgcrypto/pgp-s2k.c b/contrib/pgcrypto/pgp-s2k.c
index e75b2c3d69..205d701b5e 100644
--- a/contrib/pgcrypto/pgp-s2k.c
+++ b/contrib/pgcrypto/pgp-s2k.c
@@ -36,7 +36,7 @@
 #include "pgp.h"
 
 static int
-calc_s2k_simple(PGP_S2K * s2k, PX_MD *md, const uint8 *key,
+calc_s2k_simple(PGP_S2K * s2k, PX_MD * md, const uint8 *key,
 				unsigned key_len)
 {
 	unsigned	md_bs,
@@ -81,7 +81,7 @@ calc_s2k_simple(PGP_S2K * s2k, PX_MD *md, const uint8 *key,
 }
 
 static int
-calc_s2k_salted(PGP_S2K * s2k, PX_MD *md, const uint8 *key, unsigned key_len)
+calc_s2k_salted(PGP_S2K * s2k, PX_MD * md, const uint8 *key, unsigned key_len)
 {
 	unsigned	md_bs,
 				md_rlen;
@@ -126,8 +126,8 @@ calc_s2k_salted(PGP_S2K * s2k, PX_MD *md, const uint8 *key, unsigned key_len)
 }
 
 static int
-calc_s2k_iter_salted(PGP_S2K * s2k, PX_MD *md, const uint8 *key,
-					unsigned key_len)
+calc_s2k_iter_salted(PGP_S2K * s2k, PX_MD * md, const uint8 *key,
+					 unsigned key_len)
 {
 	unsigned	md_bs,
 				md_rlen;
@@ -200,7 +200,7 @@ calc_s2k_iter_salted(PGP_S2K * s2k, PX_MD *md, const uint8 *key,
 
 /*
  * Decide S2K_ISALTED iteration count
- * 
+ *
  * Too small: weak
  * Too big: slow
  * gpg defaults to 96 => 65536 iters
@@ -213,15 +213,16 @@ decide_count(unsigned rand_byte)
 }
 
 int
-pgp_s2k_fill(PGP_S2K *s2k, int mode,int digest_algo)
+pgp_s2k_fill(PGP_S2K * s2k, int mode, int digest_algo)
 {
-	int res = 0;
-	uint8 tmp;
+	int			res = 0;
+	uint8		tmp;
 
 	s2k->mode = mode;
 	s2k->digest_algo = digest_algo;
 
-	switch (s2k->mode) {
+	switch (s2k->mode)
+	{
 		case 0:
 			break;
 		case 1:
@@ -243,13 +244,14 @@ pgp_s2k_fill(PGP_S2K *s2k, int mode,int digest_algo)
 }
 
 int
-pgp_s2k_read(PullFilter *src, PGP_S2K *s2k)
+pgp_s2k_read(PullFilter * src, PGP_S2K * s2k)
 {
-	int res = 0;
+	int			res = 0;
 
 	GETBYTE(src, s2k->mode);
 	GETBYTE(src, s2k->digest_algo);
-	switch (s2k->mode) {
+	switch (s2k->mode)
+	{
 		case 0:
 			break;
 		case 1:
@@ -267,10 +269,11 @@ pgp_s2k_read(PullFilter *src, PGP_S2K *s2k)
 	return res;
 }
 
-int pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int key_len)
+int
+pgp_s2k_process(PGP_S2K * s2k, int cipher, const uint8 *key, int key_len)
 {
-	int res;
-	PX_MD *md;
+	int			res;
+	PX_MD	   *md;
 
 	s2k->key_len = pgp_get_cipher_key_size(cipher);
 	if (s2k->key_len <= 0)
@@ -280,7 +283,8 @@ int pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int key_len)
 	if (res < 0)
 		return res;
 
-	switch (s2k->mode) {
+	switch (s2k->mode)
+	{
 		case 0:
 			res = calc_s2k_simple(s2k, md, key, key_len);
 			break;
@@ -296,4 +300,3 @@ int pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int key_len)
 	px_md_free(md);
 	return res;
 }
-
diff --git a/contrib/pgcrypto/pgp.c b/contrib/pgcrypto/pgp.c
index 0bd681a781..77486e41c6 100644
--- a/contrib/pgcrypto/pgp.c
+++ b/contrib/pgcrypto/pgp.c
@@ -62,8 +62,8 @@ struct cipher_info
 	const char *name;
 	int			code;
 	const char *int_name;
-	int key_len;
-	int block_len;
+	int			key_len;
+	int			block_len;
 };
 
 static const struct digest_info digest_list[] = {
@@ -78,15 +78,15 @@ static const struct digest_info digest_list[] = {
 };
 
 static const struct cipher_info cipher_list[] = {
-	{"3des", PGP_SYM_DES3, "3des-ecb", 192/8, 64/8},
-	{"cast5", PGP_SYM_CAST5, "cast5-ecb", 128/8, 64/8},
-	{"bf", PGP_SYM_BLOWFISH, "bf-ecb", 128/8, 64/8},
-	{"blowfish", PGP_SYM_BLOWFISH, "bf-ecb", 128/8, 64/8},
-	{"aes", PGP_SYM_AES_128, "aes-ecb", 128/8, 128/8},
-	{"aes128", PGP_SYM_AES_128, "aes-ecb", 128/8, 128/8},
-	{"aes192", PGP_SYM_AES_192, "aes-ecb", 192/8, 128/8},
-	{"aes256", PGP_SYM_AES_256, "aes-ecb", 256/8, 128/8},
-	{"twofish", PGP_SYM_TWOFISH, "twofish-ecb", 256/8, 128/8},
+	{"3des", PGP_SYM_DES3, "3des-ecb", 192 / 8, 64 / 8},
+	{"cast5", PGP_SYM_CAST5, "cast5-ecb", 128 / 8, 64 / 8},
+	{"bf", PGP_SYM_BLOWFISH, "bf-ecb", 128 / 8, 64 / 8},
+	{"blowfish", PGP_SYM_BLOWFISH, "bf-ecb", 128 / 8, 64 / 8},
+	{"aes", PGP_SYM_AES_128, "aes-ecb", 128 / 8, 128 / 8},
+	{"aes128", PGP_SYM_AES_128, "aes-ecb", 128 / 8, 128 / 8},
+	{"aes192", PGP_SYM_AES_192, "aes-ecb", 192 / 8, 128 / 8},
+	{"aes256", PGP_SYM_AES_256, "aes-ecb", 256 / 8, 128 / 8},
+	{"twofish", PGP_SYM_TWOFISH, "twofish-ecb", 256 / 8, 128 / 8},
 	{NULL, 0, NULL}
 };
 
@@ -94,6 +94,7 @@ static const struct cipher_info *
 get_cipher_info(int code)
 {
 	const struct cipher_info *i;
+
 	for (i = cipher_list; i->name; i++)
 		if (i->code == code)
 			return i;
@@ -104,6 +105,7 @@ int
 pgp_get_digest_code(const char *name)
 {
 	const struct digest_info *i;
+
 	for (i = digest_list; i->name; i++)
 		if (pg_strcasecmp(i->name, name) == 0)
 			return i->code;
@@ -114,6 +116,7 @@ int
 pgp_get_cipher_code(const char *name)
 {
 	const struct cipher_info *i;
+
 	for (i = cipher_list; i->name; i++)
 		if (pg_strcasecmp(i->name, name) == 0)
 			return i->code;
@@ -124,6 +127,7 @@ const char *
 pgp_get_digest_name(int code)
 {
 	const struct digest_info *i;
+
 	for (i = digest_list; i->name; i++)
 		if (i->code == code)
 			return i->name;
@@ -134,6 +138,7 @@ const char *
 pgp_get_cipher_name(int code)
 {
 	const struct cipher_info *i = get_cipher_info(code);
+
 	if (i != NULL)
 		return i->name;
 	return NULL;
@@ -143,6 +148,7 @@ int
 pgp_get_cipher_key_size(int code)
 {
 	const struct cipher_info *i = get_cipher_info(code);
+
 	if (i != NULL)
 		return i->key_len;
 	return 0;
@@ -152,6 +158,7 @@ int
 pgp_get_cipher_block_size(int code)
 {
 	const struct cipher_info *i = get_cipher_info(code);
+
 	if (i != NULL)
 		return i->block_len;
 	return 0;
@@ -300,6 +307,7 @@ int
 pgp_set_cipher_algo(PGP_Context * ctx, const char *name)
 {
 	int			code = pgp_get_cipher_code(name);
+
 	if (code < 0)
 		return code;
 	ctx->cipher_algo = code;
@@ -310,6 +318,7 @@ int
 pgp_set_s2k_cipher_algo(PGP_Context * ctx, const char *name)
 {
 	int			code = pgp_get_cipher_code(name);
+
 	if (code < 0)
 		return code;
 	ctx->s2k_cipher_algo = code;
@@ -320,6 +329,7 @@ int
 pgp_set_s2k_digest_algo(PGP_Context * ctx, const char *name)
 {
 	int			code = pgp_get_digest_code(name);
+
 	if (code < 0)
 		return code;
 	ctx->s2k_digest_algo = code;
@@ -327,20 +337,20 @@ pgp_set_s2k_digest_algo(PGP_Context * ctx, const char *name)
 }
 
 int
-pgp_get_unicode_mode(PGP_Context *ctx)
+pgp_get_unicode_mode(PGP_Context * ctx)
 {
 	return ctx->unicode_mode;
 }
 
 int
-pgp_set_unicode_mode(PGP_Context *ctx, int mode)
+pgp_set_unicode_mode(PGP_Context * ctx, int mode)
 {
 	ctx->unicode_mode = mode ? 1 : 0;
 	return 0;
 }
 
 int
-pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int len)
+pgp_set_symkey(PGP_Context * ctx, const uint8 *key, int len)
 {
 	if (key == NULL || len < 1)
 		return PXE_ARGUMENT_ERROR;
@@ -348,4 +358,3 @@ pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int len)
 	ctx->sym_key_len = len;
 	return 0;
 }
-
diff --git a/contrib/pgcrypto/pgp.h b/contrib/pgcrypto/pgp.h
index 81934afbb2..3b5a9c1feb 100644
--- a/contrib/pgcrypto/pgp.h
+++ b/contrib/pgcrypto/pgp.h
@@ -55,7 +55,7 @@ enum
 	PGP_PKT_USER_ATTR = 17,
 	PGP_PKT_SYMENCRYPTED_DATA_MDC = 18,
 	PGP_PKT_MDC = 19,
-	PGP_PKT_PRIV_61 = 61  /* occurs in gpg secring */
+	PGP_PKT_PRIV_61 = 61		/* occurs in gpg secring */
 } PGP_PKT_TYPE;
 
 enum
@@ -93,11 +93,11 @@ enum
 enum
 {
 	PGP_DIGEST_MD5 = 1,			/* should, deprecated  */
-	PGP_DIGEST_SHA1 = 2,			/* must */
+	PGP_DIGEST_SHA1 = 2,		/* must */
 	PGP_DIGEST_RIPEMD160 = 3,
-	PGP_DIGEST_XSHA = 4,			/* obsolete */
+	PGP_DIGEST_XSHA = 4,		/* obsolete */
 	PGP_DIGEST_MD2 = 5,			/* obsolete */
-	PGP_DIGEST_TIGER192 = 6,		/* obsolete */
+	PGP_DIGEST_TIGER192 = 6,	/* obsolete */
 	PGP_DIGEST_HAVAL5_160 = 7,	/* obsolete */
 	PGP_DIGEST_SHA256 = 8,
 	PGP_DIGEST_SHA384 = 9,
@@ -114,14 +114,15 @@ typedef struct PGP_PubKey PGP_PubKey;
 typedef struct PGP_Context PGP_Context;
 typedef struct PGP_S2K PGP_S2K;
 
-struct PGP_S2K {
-	uint8 mode;
-	uint8 digest_algo;
-	uint8 salt[8];
-	uint8 iter;
+struct PGP_S2K
+{
+	uint8		mode;
+	uint8		digest_algo;
+	uint8		salt[8];
+	uint8		iter;
 	/* calculated: */
-	uint8 key[PGP_MAX_KEY];
-	uint8 key_len;
+	uint8		key[PGP_MAX_KEY];
+	uint8		key_len;
 };
 
 
@@ -151,9 +152,9 @@ struct PGP_Context
 	int			in_mdc_pkt;
 	int			use_mdcbuf_filter;
 	PX_MD	   *mdc_ctx;
-	
-	PGP_PubKey	*pub_key; /* ctx owns it*/
-	const uint8 *sym_key; /* ctx does not own it */
+
+	PGP_PubKey *pub_key;		/* ctx owns it */
+	const uint8 *sym_key;		/* ctx does not own it */
 	int			sym_key_len;
 
 	/*
@@ -163,54 +164,64 @@ struct PGP_Context
 	unsigned	sess_key_len;
 };
 
-struct PGP_MPI {
-	uint8 *data;
-	int bits;
-	int bytes;
+struct PGP_MPI
+{
+	uint8	   *data;
+	int			bits;
+	int			bytes;
 };
 
-struct PGP_PubKey {
-	uint8 ver;
-	uint8 time[4];
-	uint8 algo;
+struct PGP_PubKey
+{
+	uint8		ver;
+	uint8		time[4];
+	uint8		algo;
 
 	/* public part */
-	union {
-		struct {
-			PGP_MPI *p;
-			PGP_MPI *g;
-			PGP_MPI *y;
-		} elg;
-		struct {
-			PGP_MPI *n;
-			PGP_MPI *e;
-		} rsa;
-		struct {
-			PGP_MPI *p;
-			PGP_MPI *q;
-			PGP_MPI *g;
-			PGP_MPI *y;
-		} dsa;
-	} pub;
+	union
+	{
+		struct
+		{
+			PGP_MPI    *p;
+			PGP_MPI    *g;
+			PGP_MPI    *y;
+		}			elg;
+		struct
+		{
+			PGP_MPI    *n;
+			PGP_MPI    *e;
+		}			rsa;
+		struct
+		{
+			PGP_MPI    *p;
+			PGP_MPI    *q;
+			PGP_MPI    *g;
+			PGP_MPI    *y;
+		}			dsa;
+	}			pub;
 
 	/* secret part */
-	union {
-		struct {
-			PGP_MPI *x;
-		} elg;
-		struct {
-			PGP_MPI *d;
-			PGP_MPI *p;
-			PGP_MPI *q;
-			PGP_MPI *u;
-		} rsa;
-		struct {
-			PGP_MPI *x;
-		} dsa;
-	} sec;
-
-	uint8 key_id[8];
-	int can_encrypt;
+	union
+	{
+		struct
+		{
+			PGP_MPI    *x;
+		}			elg;
+		struct
+		{
+			PGP_MPI    *d;
+			PGP_MPI    *p;
+			PGP_MPI    *q;
+			PGP_MPI    *u;
+		}			rsa;
+		struct
+		{
+			PGP_MPI    *x;
+		}			dsa;
+	}			sec;
+
+	uint8		key_id[8];
+	int			can_encrypt;
 };
 
 int			pgp_init(PGP_Context ** ctx);
@@ -236,11 +247,11 @@ int			pgp_set_text_mode(PGP_Context * ctx, int mode);
 int			pgp_set_unicode_mode(PGP_Context * ctx, int mode);
 int			pgp_get_unicode_mode(PGP_Context * ctx);
 
-int			pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int klen);
-int			pgp_set_pubkey(PGP_Context *ctx, MBuf *keypkt,
-						const uint8 *key, int klen, int pubtype);
+int			pgp_set_symkey(PGP_Context * ctx, const uint8 *key, int klen);
+int pgp_set_pubkey(PGP_Context * ctx, MBuf * keypkt,
+			   const uint8 *key, int klen, int pubtype);
 
-int			pgp_get_keyid(MBuf *pgp_data, char *dst);
+int			pgp_get_keyid(MBuf * pgp_data, char *dst);
 
 /* internal functions */
 
@@ -249,55 +260,55 @@ int			pgp_load_cipher(int c, PX_Cipher ** res);
 int			pgp_get_cipher_key_size(int c);
 int			pgp_get_cipher_block_size(int c);
 
-int pgp_s2k_fill(PGP_S2K *s2k, int mode, int digest_algo);
-int pgp_s2k_read(PullFilter *src, PGP_S2K *s2k);
-int pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int klen);
+int			pgp_s2k_fill(PGP_S2K * s2k, int mode, int digest_algo);
+int			pgp_s2k_read(PullFilter * src, PGP_S2K * s2k);
+int			pgp_s2k_process(PGP_S2K * s2k, int cipher, const uint8 *key, int klen);
 
 typedef struct PGP_CFB PGP_CFB;
-int pgp_cfb_create(PGP_CFB **ctx_p, int algo,
-		const uint8 *key, int key_len, int recync, uint8 *iv);
-void pgp_cfb_free(PGP_CFB *ctx);
-int pgp_cfb_encrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
-int pgp_cfb_decrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
+int
+pgp_cfb_create(PGP_CFB ** ctx_p, int algo,
+			   const uint8 *key, int key_len, int recync, uint8 *iv);
+void		pgp_cfb_free(PGP_CFB * ctx);
+int			pgp_cfb_encrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
+int			pgp_cfb_decrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
 
 int			pgp_armor_encode(const uint8 *src, unsigned len, uint8 *dst);
 int			pgp_armor_decode(const uint8 *src, unsigned len, uint8 *dst);
 unsigned	pgp_armor_enc_len(unsigned len);
 unsigned	pgp_armor_dec_len(unsigned len);
 
-int pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst);
-int pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src);
+int			pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst);
+int			pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src);
 
-int pgp_key_alloc(PGP_PubKey **pk_p);
-void pgp_key_free(PGP_PubKey *pk);
-int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p);
+int			pgp_key_alloc(PGP_PubKey ** pk_p);
+void		pgp_key_free(PGP_PubKey * pk);
+int			_pgp_read_public_key(PullFilter * pkt, PGP_PubKey ** pk_p);
 
-int pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt);
-int pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
-		        int pkttype, PGP_Context *ctx);
+int			pgp_parse_pubenc_sesskey(PGP_Context * ctx, PullFilter * pkt);
+int pgp_create_pkt_reader(PullFilter ** pf_p, PullFilter * src, int len,
+					  int pkttype, PGP_Context * ctx);
 int pgp_parse_pkt_hdr(PullFilter * src, uint8 *tag, int *len_p,
-		        int allow_ctx);
+				  int allow_ctx);
 
-int pgp_skip_packet(PullFilter *pkt);
-int pgp_expect_packet_end(PullFilter *pkt);
+int			pgp_skip_packet(PullFilter * pkt);
+int			pgp_expect_packet_end(PullFilter * pkt);
 
-int pgp_write_pubenc_sesskey(PGP_Context *ctx, PushFilter *dst);
-int pgp_create_pkt_writer(PushFilter *dst, int tag, PushFilter **res_p);
+int			pgp_write_pubenc_sesskey(PGP_Context * ctx, PushFilter * dst);
+int			pgp_create_pkt_writer(PushFilter * dst, int tag, PushFilter ** res_p);
 
-int pgp_mpi_alloc(int bits, PGP_MPI **mpi);
-int pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi);
-int pgp_mpi_free(PGP_MPI *mpi);
-int pgp_mpi_read(PullFilter *src, PGP_MPI **mpi);
-int pgp_mpi_write(PushFilter *dst, PGP_MPI *n);
-int pgp_mpi_hash(PX_MD *md, PGP_MPI *n);
-unsigned pgp_mpi_cksum(unsigned cksum, PGP_MPI *n);
+int			pgp_mpi_alloc(int bits, PGP_MPI ** mpi);
+int			pgp_mpi_create(uint8 *data, int bits, PGP_MPI ** mpi);
+int			pgp_mpi_free(PGP_MPI * mpi);
+int			pgp_mpi_read(PullFilter * src, PGP_MPI ** mpi);
+int			pgp_mpi_write(PushFilter * dst, PGP_MPI * n);
+int			pgp_mpi_hash(PX_MD * md, PGP_MPI * n);
+unsigned	pgp_mpi_cksum(unsigned cksum, PGP_MPI * n);
 
-int pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *m,
-						PGP_MPI **c1, PGP_MPI **c2);
-int pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *c1, PGP_MPI *c2,
-						PGP_MPI **m);
-int pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *m, PGP_MPI **c);
-int pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *c, PGP_MPI **m);
+int pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * m,
+					PGP_MPI ** c1, PGP_MPI ** c2);
+int pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * c1, PGP_MPI * c2,
+					PGP_MPI ** m);
+int			pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * m, PGP_MPI ** c);
+int			pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * c, PGP_MPI ** m);
 
 extern struct PullFilterOps pgp_decrypt_filter;
-
diff --git a/contrib/pgcrypto/px-crypt.c b/contrib/pgcrypto/px-crypt.c
index 68bc6f105c..b3cb239bfa 100644
--- a/contrib/pgcrypto/px-crypt.c
+++ b/contrib/pgcrypto/px-crypt.c
@@ -77,9 +77,9 @@ struct px_crypt_algo
 };
 
 static const struct px_crypt_algo
-px_crypt_list[] = {
+			px_crypt_list[] = {
 	{"$2a$", 4, run_crypt_bf},
-	{"$2$", 3, NULL},							/* N/A */
+	{"$2$", 3, NULL},			/* N/A */
 	{"$1$", 3, run_crypt_md5},
 	{"_", 1, run_crypt_des},
 	{"", 0, run_crypt_des},
@@ -164,4 +164,3 @@ px_gen_salt(const char *salt_type, char *buf, int rounds)
 
 	return strlen(p);
 }
-
diff --git a/contrib/pgcrypto/px-crypt.h b/contrib/pgcrypto/px-crypt.h
index 4e3096b744..b8db4b4c01 100644
--- a/contrib/pgcrypto/px-crypt.h
+++ b/contrib/pgcrypto/px-crypt.h
@@ -65,13 +65,13 @@ extern char px_crypt_a64[];
 
 /* crypt-gensalt.c */
 char *_crypt_gensalt_traditional_rn(unsigned long count,
-			 const char *input, int size, char *output, int output_size);
+				 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);
+				 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);
+				 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);
+				 const char *input, int size, char *output, int output_size);
 
 /* disable 'extended DES crypt' */
 /* #define DISABLE_XDES */
diff --git a/contrib/pgcrypto/px.c b/contrib/pgcrypto/px.c
index f3a49c87b6..e866959daa 100644
--- a/contrib/pgcrypto/px.c
+++ b/contrib/pgcrypto/px.c
@@ -33,8 +33,9 @@
 
 #include "px.h"
 
-struct error_desc {
-	int err;
+struct error_desc
+{
+	int			err;
 	const char *desc;
 };
 
@@ -67,14 +68,14 @@ static const struct error_desc px_err_list[] = {
 	{PXE_PGP_UNEXPECTED_PKT, "Unexpected packet in key data"},
 	{PXE_PGP_NO_BIGNUM,
 		"public-key functions disabled - "
-		"pgcrypto needs OpenSSL for bignums"},
+	"pgcrypto needs OpenSSL for bignums"},
 	{PXE_PGP_MATH_FAILED, "Math operation failed"},
 	{PXE_PGP_SHORT_ELGAMAL_KEY, "Elgamal keys must be at least 1024 bits long"},
 	{PXE_PGP_RSA_UNSUPPORTED, "pgcrypto does not support RSA keys"},
 	{PXE_PGP_UNKNOWN_PUBALGO, "Unknown public-key encryption algorithm"},
 	{PXE_PGP_WRONG_KEY, "Wrong key"},
 	{PXE_PGP_MULTIPLE_KEYS,
-		"Several keys given - pgcrypto does not handle keyring"},
+	"Several keys given - pgcrypto does not handle keyring"},
 	{PXE_PGP_EXPECT_PUBLIC_KEY, "Refusing to encrypt with secret key"},
 	{PXE_PGP_EXPECT_SECRET_KEY, "Cannot decrypt with public key"},
 	{PXE_PGP_NOT_V4_KEYPKT, "Only V4 key packets are supported"},
@@ -87,13 +88,15 @@ static const struct error_desc px_err_list[] = {
 
 	/* fake this as PXE_PGP_CORRUPT_DATA */
 	{PXE_MBUF_SHORT_READ, "Corrupt data"},
-	
+
 	{0, NULL},
 };
 
-const char *px_strerror(int err)
+const char *
+px_strerror(int err)
 {
 	const struct error_desc *e;
+
 	for (e = px_err_list; e->desc; e++)
 		if (e->err == err)
 			return e->desc;
@@ -113,19 +116,24 @@ px_resolve_alias(const PX_Alias * list, const char *name)
 	return name;
 }
 
-static void (*debug_handler)(const char *) = NULL;
+static void (*debug_handler) (const char *) = NULL;
 
-void px_set_debug_handler(void (*handler)(const char *))
+void
+px_set_debug_handler(void (*handler) (const char *))
 {
 	debug_handler = handler;
 }
 
-void px_debug(const char *fmt, ...)
+void
+px_debug(const char *fmt,...)
 {
-	va_list ap;
+	va_list		ap;
+
 	va_start(ap, fmt);
-	if (debug_handler) {
-		char buf[512];
+	if (debug_handler)
+	{
+		char		buf[512];
+
 		vsnprintf(buf, sizeof(buf), fmt, ap);
 		debug_handler(buf);
 	}
diff --git a/contrib/pgcrypto/px.h b/contrib/pgcrypto/px.h
index 52947209c7..1ef3813ae3 100644
--- a/contrib/pgcrypto/px.h
+++ b/contrib/pgcrypto/px.h
@@ -90,12 +90,12 @@ void		px_free(void *p);
 
 #define PXE_PGP_CORRUPT_DATA		-100
 #define PXE_PGP_CORRUPT_ARMOR		-101
-#define PXE_PGP_UNSUPPORTED_COMPR   -102
-#define PXE_PGP_UNSUPPORTED_CIPHER  -103
-#define PXE_PGP_UNSUPPORTED_HASH    -104
-#define PXE_PGP_COMPRESSION_ERROR   -105
-#define PXE_PGP_NOT_TEXT            -106
-#define PXE_PGP_UNEXPECTED_PKT      -107
+#define PXE_PGP_UNSUPPORTED_COMPR	-102
+#define PXE_PGP_UNSUPPORTED_CIPHER	-103
+#define PXE_PGP_UNSUPPORTED_HASH	-104
+#define PXE_PGP_COMPRESSION_ERROR	-105
+#define PXE_PGP_NOT_TEXT			-106
+#define PXE_PGP_UNEXPECTED_PKT		-107
 #define PXE_PGP_NO_BIGNUM			-108
 #define PXE_PGP_MATH_FAILED			-109
 #define PXE_PGP_SHORT_ELGAMAL_KEY	-110
@@ -110,7 +110,7 @@ void		px_free(void *p);
 #define PXE_PGP_NO_USABLE_KEY		-119
 #define PXE_PGP_NEED_SECRET_PSW		-120
 #define PXE_PGP_BAD_S2K_MODE		-121
-#define PXE_PGP_UNSUPPORTED_PUBALGO	-122
+#define PXE_PGP_UNSUPPORTED_PUBALGO -122
 #define PXE_PGP_MULTIPLE_SUBKEYS	-123
 
 
@@ -132,7 +132,7 @@ struct px_digest
 	union
 	{
 		unsigned	code;
-		void *ptr;
+		void	   *ptr;
 	}			p;
 };
 
@@ -207,9 +207,10 @@ const char *px_strerror(int err);
 
 const char *px_resolve_alias(const PX_Alias * aliases, const char *name);
 
-void          px_set_debug_handler(void (*handler)(const char *));
+void		px_set_debug_handler(void (*handler) (const char *));
+
 #ifdef PX_DEBUG
-void          px_debug(const char *fmt, ...);
+void		px_debug(const char *fmt,...);
 #else
 #define px_debug(...)
 #endif
diff --git a/contrib/pgcrypto/random.c b/contrib/pgcrypto/random.c
index 6431845f4b..b9300bad06 100644
--- a/contrib/pgcrypto/random.c
+++ b/contrib/pgcrypto/random.c
@@ -95,7 +95,6 @@ try_dev_random(uint8 *dst)
 		dst += res;
 	return dst;
 }
-
 #endif
 
 /*
@@ -111,22 +110,23 @@ try_dev_random(uint8 *dst)
 
 /*
  * this function is from libtomcrypt
- * 
+ *
  * try to use Microsoft crypto API
  */
-static uint8 * try_win32_genrand(uint8 *dst)
+static uint8 *
+try_win32_genrand(uint8 *dst)
 {
-	int res;
-	HCRYPTPROV h = 0;
+	int			res;
+	HCRYPTPROV	h = 0;
 
 	res = CryptAcquireContext(&h, NULL, MS_DEF_PROV, PROV_RSA_FULL,
-				(CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET));
+							  (CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET));
 	if (!res)
 		res = CryptAcquireContext(&h, NULL, MS_DEF_PROV, PROV_RSA_FULL,
-				CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET | CRYPT_NEWKEYSET);
+			   CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET | CRYPT_NEWKEYSET);
 	if (!res)
 		return dst;
-	
+
 	res = CryptGenRandom(h, RND_BYTES, dst);
 	if (res == TRUE)
 		dst += RND_BYTES;
@@ -135,9 +135,10 @@ static uint8 * try_win32_genrand(uint8 *dst)
 	return dst;
 }
 
-static uint8 * try_win32_perfc(uint8 *dst)
+static uint8 *
+try_win32_perfc(uint8 *dst)
 {
-	int res;
+	int			res;
 	LARGE_INTEGER time;
 
 	res = QueryPerformanceCounter(&time);
@@ -147,8 +148,7 @@ static uint8 * try_win32_perfc(uint8 *dst)
 	memcpy(dst, &time, sizeof(time));
 	return dst + sizeof(time);
 }
-
-#endif /* WIN32 */
+#endif   /* WIN32 */
 
 
 /*
@@ -174,33 +174,34 @@ static uint8 * try_win32_perfc(uint8 *dst)
 static uint8 *
 try_unix_std(uint8 *dst)
 {
-	pid_t pid;
-	int x;
-	PX_MD *md;
+	pid_t		pid;
+	int			x;
+	PX_MD	   *md;
 	struct timeval tv;
-	int res;
+	int			res;
 
 	/* process id */
 	pid = getpid();
-	memcpy(dst, (uint8*)&pid, sizeof(pid));
+	memcpy(dst, (uint8 *) &pid, sizeof(pid));
 	dst += sizeof(pid);
 
 	/* time */
 	gettimeofday(&tv, NULL);
-	memcpy(dst, (uint8*)&tv, sizeof(tv));
+	memcpy(dst, (uint8 *) &tv, sizeof(tv));
 	dst += sizeof(tv);
 
 	/* pointless, but should not hurt */
 	x = random();
-	memcpy(dst, (uint8*)&x, sizeof(x));
+	memcpy(dst, (uint8 *) &x, sizeof(x));
 	dst += sizeof(x);
 
 	/* let's be desperate */
 	res = px_find_digest("sha1", &md);
-	if (res >= 0) {
-		uint8 *ptr;
-		uint8 stack[8192];
-		int alloc = 32*1024;
+	if (res >= 0)
+	{
+		uint8	   *ptr;
+		uint8		stack[8192];
+		int			alloc = 32 * 1024;
 
 		px_md_update(md, stack, sizeof(stack));
 		ptr = px_alloc(alloc);
@@ -215,7 +216,6 @@ try_unix_std(uint8 *dst)
 
 	return dst;
 }
-
 #endif
 
 /*
@@ -223,9 +223,11 @@ try_unix_std(uint8 *dst)
  *
  * dst should have room for 1024 bytes.
  */
-unsigned px_acquire_system_randomness(uint8 *dst)
+unsigned
+px_acquire_system_randomness(uint8 *dst)
 {
-	uint8 *p = dst;
+	uint8	   *p = dst;
+
 #ifdef TRY_DEV_RANDOM
 	p = try_dev_random(p);
 #endif
@@ -240,4 +242,3 @@ unsigned px_acquire_system_randomness(uint8 *dst)
 #endif
 	return p - dst;
 }
-
diff --git a/contrib/pgcrypto/rijndael.c b/contrib/pgcrypto/rijndael.c
index 18e0752cf4..cb65d55478 100644
--- a/contrib/pgcrypto/rijndael.c
+++ b/contrib/pgcrypto/rijndael.c
@@ -91,7 +91,6 @@ static void gen_tabs(void);
 
 #include "rijndael.tbl"
 #define tab_gen		1
-
 #else							/* !PRE_CALC_TABLES */
 
 static u1byte pow_tab[256];
@@ -143,7 +142,6 @@ static u4byte tab_gen = 0;
 			 il_tab[1][byte((bi)[((n) + 3) & 3],1)] ^	\
 			 il_tab[2][byte((bi)[((n) + 2) & 3],2)] ^	\
 			 il_tab[3][byte((bi)[((n) + 1) & 3],3)] ^ *((k) + (n))
-
 #else
 
 #define ls_box(x)							 \
diff --git a/contrib/pgcrypto/sha2.c b/contrib/pgcrypto/sha2.c
index 406a07f91f..776138c544 100644
--- a/contrib/pgcrypto/sha2.c
+++ b/contrib/pgcrypto/sha2.c
@@ -3,7 +3,7 @@
 /*
  * FILE:	sha2.c
  * AUTHOR:	Aaron D. Gifford <[email protected]>
- * 
+ *
  * Copyright (c) 2000-2001, Aaron D. Gifford
  * All rights reserved.
  *
@@ -11,18 +11,18 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the copyright holder nor the names of contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * 
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -48,11 +48,11 @@
  * loop version for the hash transform rounds (defined using macros
  * later in this file).  Either define on the command line, for example:
  *
- *   cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
+ *	 cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
  *
  * or define below:
  *
- *   #define SHA2_UNROLL_TRANSFORM
+ *	 #define SHA2_UNROLL_TRANSFORM
  *
  */
 
@@ -69,16 +69,16 @@
  * If your system does not define the above, then you can do so by
  * hand like this:
  *
- *   #define LITTLE_ENDIAN 1234
- *   #define BIG_ENDIAN    4321
+ *	 #define LITTLE_ENDIAN 1234
+ *	 #define BIG_ENDIAN    4321
  *
  * And for little-endian machines, add:
  *
- *   #define BYTE_ORDER LITTLE_ENDIAN 
+ *	 #define BYTE_ORDER LITTLE_ENDIAN
  *
  * Or for big-endian machines:
  *
- *   #define BYTE_ORDER BIG_ENDIAN
+ *	 #define BYTE_ORDER BIG_ENDIAN
  *
  * The FreeBSD machine this was written on defines BYTE_ORDER
  * appropriately by including <sys/types.h> (which in turn includes
@@ -108,11 +108,11 @@
 	uint64 tmp = (w); \
 	tmp = (tmp >> 32) | (tmp << 32); \
 	tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \
-	      ((tmp & 0x00ff00ff00ff00ffULL) << 8); \
+		  ((tmp & 0x00ff00ff00ff00ffULL) << 8); \
 	(x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \
-	      ((tmp & 0x0000ffff0000ffffULL) << 16); \
+		  ((tmp & 0x0000ffff0000ffffULL) << 16); \
 }
-#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+#endif   /* BYTE_ORDER == LITTLE_ENDIAN */
 
 /*
  * Macro for incrementally adding the unsigned 64-bit integer n to the
@@ -130,13 +130,13 @@
 /*
  * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
  *
- *   NOTE:  The naming of R and S appears backwards here (R is a SHIFT and
- *   S is a ROTATION) because the SHA-256/384/512 description document
- *   (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
- *   same "backwards" definition.
+ *	 NOTE:	The naming of R and S appears backwards here (R is a SHIFT and
+ *	 S is a ROTATION) because the SHA-256/384/512 description document
+ *	 (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
+ *	 same "backwards" definition.
  */
 /* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
-#define R(b,x) 		((x) >> (b))
+#define R(b,x)		((x) >> (b))
 /* 32-bit Rotate-right (used in SHA-256): */
 #define S32(b,x)	(((x) >> (b)) | ((x) << (32 - (b))))
 /* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
@@ -163,9 +163,9 @@
  * library -- they are intended for private internal visibility/use
  * only.
  */
-void SHA512_Last(SHA512_CTX *);
-void SHA256_Transform(SHA256_CTX *, const uint8 *);
-void SHA512_Transform(SHA512_CTX *, const uint8 *);
+void		SHA512_Last(SHA512_CTX *);
+void		SHA256_Transform(SHA256_CTX *, const uint8 *);
+void		SHA512_Transform(SHA512_CTX *, const uint8 *);
 
 
 /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
@@ -272,7 +272,7 @@ static const uint64 sha512_initial_hash_value[8] = {
 
 /*** SHA-256: *********************************************************/
 void
-SHA256_Init(SHA256_CTX *context)
+SHA256_Init(SHA256_CTX * context)
 {
 	if (context == NULL)
 		return;
@@ -285,36 +285,46 @@ SHA256_Init(SHA256_CTX *context)
 
 /* Unrolled SHA-256 round macros: */
 
-#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) do {				    \
-	W256[j] = (uint32)data[3] | ((uint32)data[2] << 8) |	    \
-	    ((uint32)data[1] << 16) | ((uint32)data[0] << 24);	    \
-	data += 4;							    \
+#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) do {					\
+	W256[j] = (uint32)data[3] | ((uint32)data[2] << 8) |		\
+		((uint32)data[1] << 16) | ((uint32)data[0] << 24);		\
+	data += 4;								\
 	T1 = (h) + Sigma1_256((e)) + Ch((e), (f), (g)) + K256[j] + W256[j]; \
-	(d) += T1;							    \
-	(h) = T1 + Sigma0_256((a)) + Maj((a), (b), (c));		    \
-	j++;								    \
+	(d) += T1;								\
+	(h) = T1 + Sigma0_256((a)) + Maj((a), (b), (c));			\
+	j++;									\
 } while(0)
 
-#define ROUND256(a,b,c,d,e,f,g,h) do {					    \
-	s0 = W256[(j+1)&0x0f];						    \
-	s0 = sigma0_256(s0);						    \
-	s1 = W256[(j+14)&0x0f];						    \
-	s1 = sigma1_256(s1);						    \
-	T1 = (h) + Sigma1_256((e)) + Ch((e), (f), (g)) + K256[j] +	    \
-	     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);		    \
-	(d) += T1;							    \
-	(h) = T1 + Sigma0_256((a)) + Maj((a), (b), (c));		    \
-	j++;								    \
+#define ROUND256(a,b,c,d,e,f,g,h) do {						\
+	s0 = W256[(j+1)&0x0f];							\
+	s0 = sigma0_256(s0);							\
+	s1 = W256[(j+14)&0x0f];							\
+	s1 = sigma1_256(s1);							\
+	T1 = (h) + Sigma1_256((e)) + Ch((e), (f), (g)) + K256[j] +		\
+		 (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);			\
+	(d) += T1;								\
+	(h) = T1 + Sigma0_256((a)) + Maj((a), (b), (c));			\
+	j++;									\
 } while(0)
 
 void
-SHA256_Transform(SHA256_CTX *context, const uint8 *data)
+SHA256_Transform(SHA256_CTX * context, const uint8 *data)
 {
-	uint32	a, b, c, d, e, f, g, h, s0, s1;
-	uint32	T1, *W256;
-	int		j;
-
-	W256 = (uint32 *)context->buffer;
+	uint32		a,
+				b,
+				c,
+				d,
+				e,
+				f,
+				g,
+				h,
+				s0,
+				s1;
+	uint32		T1,
+			   *W256;
+	int			j;
+
+	W256 = (uint32 *) context->buffer;
 
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
@@ -327,28 +337,30 @@ SHA256_Transform(SHA256_CTX *context, const uint8 *data)
 	h = context->state[7];
 
 	j = 0;
-	do {
+	do
+	{
 		/* Rounds 0 to 15 (unrolled): */
-		ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
-		ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
-		ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
-		ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
-		ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
-		ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
-		ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
-		ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
+		ROUND256_0_TO_15(a, b, c, d, e, f, g, h);
+		ROUND256_0_TO_15(h, a, b, c, d, e, f, g);
+		ROUND256_0_TO_15(g, h, a, b, c, d, e, f);
+		ROUND256_0_TO_15(f, g, h, a, b, c, d, e);
+		ROUND256_0_TO_15(e, f, g, h, a, b, c, d);
+		ROUND256_0_TO_15(d, e, f, g, h, a, b, c);
+		ROUND256_0_TO_15(c, d, e, f, g, h, a, b);
+		ROUND256_0_TO_15(b, c, d, e, f, g, h, a);
 	} while (j < 16);
 
 	/* Now for the remaining rounds to 64: */
-	do {
-		ROUND256(a,b,c,d,e,f,g,h);
-		ROUND256(h,a,b,c,d,e,f,g);
-		ROUND256(g,h,a,b,c,d,e,f);
-		ROUND256(f,g,h,a,b,c,d,e);
-		ROUND256(e,f,g,h,a,b,c,d);
-		ROUND256(d,e,f,g,h,a,b,c);
-		ROUND256(c,d,e,f,g,h,a,b);
-		ROUND256(b,c,d,e,f,g,h,a);
+	do
+	{
+		ROUND256(a, b, c, d, e, f, g, h);
+		ROUND256(h, a, b, c, d, e, f, g);
+		ROUND256(g, h, a, b, c, d, e, f);
+		ROUND256(f, g, h, a, b, c, d, e);
+		ROUND256(e, f, g, h, a, b, c, d);
+		ROUND256(d, e, f, g, h, a, b, c);
+		ROUND256(c, d, e, f, g, h, a, b);
+		ROUND256(b, c, d, e, f, g, h, a);
 	} while (j < 64);
 
 	/* Compute the current intermediate hash value */
@@ -364,17 +376,27 @@ SHA256_Transform(SHA256_CTX *context, const uint8 *data)
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = 0;
 }
-
-#else /* SHA2_UNROLL_TRANSFORM */
+#else							/* SHA2_UNROLL_TRANSFORM */
 
 void
-SHA256_Transform(SHA256_CTX *context, const uint8 *data)
+SHA256_Transform(SHA256_CTX * context, const uint8 *data)
 {
-	uint32	a, b, c, d, e, f, g, h, s0, s1;
-	uint32	T1, T2, *W256;
-	int		j;
-
-	W256 = (uint32 *)context->buffer;
+	uint32		a,
+				b,
+				c,
+				d,
+				e,
+				f,
+				g,
+				h,
+				s0,
+				s1;
+	uint32		T1,
+				T2,
+			   *W256;
+	int			j;
+
+	W256 = (uint32 *) context->buffer;
 
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
@@ -387,9 +409,10 @@ SHA256_Transform(SHA256_CTX *context, const uint8 *data)
 	h = context->state[7];
 
 	j = 0;
-	do {
-		W256[j] = (uint32)data[3] | ((uint32)data[2] << 8) |
-		    ((uint32)data[1] << 16) | ((uint32)data[0] << 24);
+	do
+	{
+		W256[j] = (uint32) data[3] | ((uint32) data[2] << 8) |
+			((uint32) data[1] << 16) | ((uint32) data[0] << 24);
 		data += 4;
 		/* Apply the SHA-256 compression function to update a..h */
 		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
@@ -406,16 +429,17 @@ SHA256_Transform(SHA256_CTX *context, const uint8 *data)
 		j++;
 	} while (j < 16);
 
-	do {
+	do
+	{
 		/* Part of the message block expansion: */
-		s0 = W256[(j+1)&0x0f];
+		s0 = W256[(j + 1) & 0x0f];
 		s0 = sigma0_256(s0);
-		s1 = W256[(j+14)&0x0f];	
+		s1 = W256[(j + 14) & 0x0f];
 		s1 = sigma1_256(s1);
 
 		/* Apply the SHA-256 compression function to update a..h */
-		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + 
-		     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
+		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
+			(W256[j & 0x0f] += s1 + W256[(j + 9) & 0x0f] + s0);
 		T2 = Sigma0_256(a) + Maj(a, b, c);
 		h = g;
 		g = f;
@@ -442,31 +466,35 @@ SHA256_Transform(SHA256_CTX *context, const uint8 *data)
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = T2 = 0;
 }
-
-#endif /* SHA2_UNROLL_TRANSFORM */
+#endif   /* SHA2_UNROLL_TRANSFORM */
 
 void
-SHA256_Update(SHA256_CTX *context, const uint8 *data, size_t len)
+SHA256_Update(SHA256_CTX * context, const uint8 *data, size_t len)
 {
-	size_t	freespace, usedspace;
+	size_t		freespace,
+				usedspace;
 
 	/* Calling with no data is valid (we do nothing) */
 	if (len == 0)
 		return;
 
 	usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
-	if (usedspace > 0) {
+	if (usedspace > 0)
+	{
 		/* Calculate how much free space is available in the buffer */
 		freespace = SHA256_BLOCK_LENGTH - usedspace;
 
-		if (len >= freespace) {
+		if (len >= freespace)
+		{
 			/* Fill the buffer completely and process it */
 			memcpy(&context->buffer[usedspace], data, freespace);
 			context->bitcount += freespace << 3;
 			len -= freespace;
 			data += freespace;
 			SHA256_Transform(context, context->buffer);
-		} else {
+		}
+		else
+		{
 			/* The buffer is not yet full */
 			memcpy(&context->buffer[usedspace], data, len);
 			context->bitcount += len << 3;
@@ -475,14 +503,16 @@ SHA256_Update(SHA256_CTX *context, const uint8 *data, size_t len)
 			return;
 		}
 	}
-	while (len >= SHA256_BLOCK_LENGTH) {
+	while (len >= SHA256_BLOCK_LENGTH)
+	{
 		/* Process as many complete blocks as we can */
 		SHA256_Transform(context, data);
 		context->bitcount += SHA256_BLOCK_LENGTH << 3;
 		len -= SHA256_BLOCK_LENGTH;
 		data += SHA256_BLOCK_LENGTH;
 	}
-	if (len > 0) {
+	if (len > 0)
+	{
 		/* There's left-overs, so save 'em */
 		memcpy(context->buffer, data, len);
 		context->bitcount += len << 3;
@@ -492,26 +522,32 @@ SHA256_Update(SHA256_CTX *context, const uint8 *data, size_t len)
 }
 
 void
-SHA256_Final(uint8 digest[], SHA256_CTX *context)
+SHA256_Final(uint8 digest[], SHA256_CTX * context)
 {
-	unsigned int	usedspace;
+	unsigned int usedspace;
 
 	/* If no digest buffer is passed, we don't bother doing this: */
-	if (digest != NULL) {
+	if (digest != NULL)
+	{
 		usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
 #if BYTE_ORDER == LITTLE_ENDIAN
 		/* Convert FROM host byte order */
-		REVERSE64(context->bitcount,context->bitcount);
+		REVERSE64(context->bitcount, context->bitcount);
 #endif
-		if (usedspace > 0) {
+		if (usedspace > 0)
+		{
 			/* Begin padding with a 1 bit: */
 			context->buffer[usedspace++] = 0x80;
 
-			if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
+			if (usedspace <= SHA256_SHORT_BLOCK_LENGTH)
+			{
 				/* Set-up for the last transform: */
 				memset(&context->buffer[usedspace], 0, SHA256_SHORT_BLOCK_LENGTH - usedspace);
-			} else {
-				if (usedspace < SHA256_BLOCK_LENGTH) {
+			}
+			else
+			{
+				if (usedspace < SHA256_BLOCK_LENGTH)
+				{
 					memset(&context->buffer[usedspace], 0, SHA256_BLOCK_LENGTH - usedspace);
 				}
 				/* Do second-to-last transform: */
@@ -520,7 +556,9 @@ SHA256_Final(uint8 digest[], SHA256_CTX *context)
 				/* And set-up for the last transform: */
 				memset(context->buffer, 0, SHA256_SHORT_BLOCK_LENGTH);
 			}
-		} else {
+		}
+		else
+		{
 			/* Set-up for the last transform: */
 			memset(context->buffer, 0, SHA256_SHORT_BLOCK_LENGTH);
 
@@ -528,7 +566,7 @@ SHA256_Final(uint8 digest[], SHA256_CTX *context)
 			*context->buffer = 0x80;
 		}
 		/* Set the bit count: */
-		*(uint64 *)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
+		*(uint64 *) &context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
 
 		/* Final transform: */
 		SHA256_Transform(context, context->buffer);
@@ -536,9 +574,11 @@ SHA256_Final(uint8 digest[], SHA256_CTX *context)
 #if BYTE_ORDER == LITTLE_ENDIAN
 		{
 			/* Convert TO host byte order */
-			int	j;
-			for (j = 0; j < 8; j++) {
-				REVERSE32(context->state[j],context->state[j]);
+			int			j;
+
+			for (j = 0; j < 8; j++)
+			{
+				REVERSE32(context->state[j], context->state[j]);
 			}
 		}
 #endif
@@ -553,50 +593,60 @@ SHA256_Final(uint8 digest[], SHA256_CTX *context)
 
 /*** SHA-512: *********************************************************/
 void
-SHA512_Init(SHA512_CTX *context)
+SHA512_Init(SHA512_CTX * context)
 {
 	if (context == NULL)
 		return;
 	memcpy(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
 	memset(context->buffer, 0, SHA512_BLOCK_LENGTH);
-	context->bitcount[0] = context->bitcount[1] =  0;
+	context->bitcount[0] = context->bitcount[1] = 0;
 }
 
 #ifdef SHA2_UNROLL_TRANSFORM
 
 /* Unrolled SHA-512 round macros: */
 
-#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) do {				    \
-	W512[j] = (uint64)data[7] | ((uint64)data[6] << 8) |	    \
-	    ((uint64)data[5] << 16) | ((uint64)data[4] << 24) |	    \
-	    ((uint64)data[3] << 32) | ((uint64)data[2] << 40) |	    \
-	    ((uint64)data[1] << 48) | ((uint64)data[0] << 56);	    \
-	data += 8;							    \
+#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) do {					\
+	W512[j] = (uint64)data[7] | ((uint64)data[6] << 8) |		\
+		((uint64)data[5] << 16) | ((uint64)data[4] << 24) |		\
+		((uint64)data[3] << 32) | ((uint64)data[2] << 40) |		\
+		((uint64)data[1] << 48) | ((uint64)data[0] << 56);		\
+	data += 8;								\
 	T1 = (h) + Sigma1_512((e)) + Ch((e), (f), (g)) + K512[j] + W512[j]; \
-	(d) += T1;							    \
-	(h) = T1 + Sigma0_512((a)) + Maj((a), (b), (c));		    \
-	j++;								    \
+	(d) += T1;								\
+	(h) = T1 + Sigma0_512((a)) + Maj((a), (b), (c));			\
+	j++;									\
 } while(0)
 
 
-#define ROUND512(a,b,c,d,e,f,g,h) do {					    \
-	s0 = W512[(j+1)&0x0f];						    \
-	s0 = sigma0_512(s0);						    \
-	s1 = W512[(j+14)&0x0f];						    \
-	s1 = sigma1_512(s1);						    \
-	T1 = (h) + Sigma1_512((e)) + Ch((e), (f), (g)) + K512[j] +	    \
-             (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);		    \
-	(d) += T1;							    \
-	(h) = T1 + Sigma0_512((a)) + Maj((a), (b), (c));		    \
-	j++;								    \
+#define ROUND512(a,b,c,d,e,f,g,h) do {						\
+	s0 = W512[(j+1)&0x0f];							\
+	s0 = sigma0_512(s0);							\
+	s1 = W512[(j+14)&0x0f];							\
+	s1 = sigma1_512(s1);							\
+	T1 = (h) + Sigma1_512((e)) + Ch((e), (f), (g)) + K512[j] +		\
+			 (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);			\
+	(d) += T1;								\
+	(h) = T1 + Sigma0_512((a)) + Maj((a), (b), (c));			\
+	j++;									\
 } while(0)
 
 void
-SHA512_Transform(SHA512_CTX *context, const uint8 *data)
+SHA512_Transform(SHA512_CTX * context, const uint8 *data)
 {
-	uint64	a, b, c, d, e, f, g, h, s0, s1;
-	uint64	T1, *W512 = (uint64 *)context->buffer;
-	int		j;
+	uint64		a,
+				b,
+				c,
+				d,
+				e,
+				f,
+				g,
+				h,
+				s0,
+				s1;
+	uint64		T1,
+			   *W512 = (uint64 *) context->buffer;
+	int			j;
 
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
@@ -609,27 +659,29 @@ SHA512_Transform(SHA512_CTX *context, const uint8 *data)
 	h = context->state[7];
 
 	j = 0;
-	do {
-		ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
-		ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
-		ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
-		ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
-		ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
-		ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
-		ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
-		ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
+	do
+	{
+		ROUND512_0_TO_15(a, b, c, d, e, f, g, h);
+		ROUND512_0_TO_15(h, a, b, c, d, e, f, g);
+		ROUND512_0_TO_15(g, h, a, b, c, d, e, f);
+		ROUND512_0_TO_15(f, g, h, a, b, c, d, e);
+		ROUND512_0_TO_15(e, f, g, h, a, b, c, d);
+		ROUND512_0_TO_15(d, e, f, g, h, a, b, c);
+		ROUND512_0_TO_15(c, d, e, f, g, h, a, b);
+		ROUND512_0_TO_15(b, c, d, e, f, g, h, a);
 	} while (j < 16);
 
 	/* Now for the remaining rounds up to 79: */
-	do {
-		ROUND512(a,b,c,d,e,f,g,h);
-		ROUND512(h,a,b,c,d,e,f,g);
-		ROUND512(g,h,a,b,c,d,e,f);
-		ROUND512(f,g,h,a,b,c,d,e);
-		ROUND512(e,f,g,h,a,b,c,d);
-		ROUND512(d,e,f,g,h,a,b,c);
-		ROUND512(c,d,e,f,g,h,a,b);
-		ROUND512(b,c,d,e,f,g,h,a);
+	do
+	{
+		ROUND512(a, b, c, d, e, f, g, h);
+		ROUND512(h, a, b, c, d, e, f, g);
+		ROUND512(g, h, a, b, c, d, e, f);
+		ROUND512(f, g, h, a, b, c, d, e);
+		ROUND512(e, f, g, h, a, b, c, d);
+		ROUND512(d, e, f, g, h, a, b, c);
+		ROUND512(c, d, e, f, g, h, a, b);
+		ROUND512(b, c, d, e, f, g, h, a);
 	} while (j < 80);
 
 	/* Compute the current intermediate hash value */
@@ -645,15 +697,25 @@ SHA512_Transform(SHA512_CTX *context, const uint8 *data)
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = 0;
 }
-
-#else /* SHA2_UNROLL_TRANSFORM */
+#else							/* SHA2_UNROLL_TRANSFORM */
 
 void
-SHA512_Transform(SHA512_CTX *context, const uint8 *data)
+SHA512_Transform(SHA512_CTX * context, const uint8 *data)
 {
-	uint64	a, b, c, d, e, f, g, h, s0, s1;
-	uint64	T1, T2, *W512 = (uint64 *)context->buffer;
-	int		j;
+	uint64		a,
+				b,
+				c,
+				d,
+				e,
+				f,
+				g,
+				h,
+				s0,
+				s1;
+	uint64		T1,
+				T2,
+			   *W512 = (uint64 *) context->buffer;
+	int			j;
 
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
@@ -666,11 +728,12 @@ SHA512_Transform(SHA512_CTX *context, const uint8 *data)
 	h = context->state[7];
 
 	j = 0;
-	do {
-		W512[j] = (uint64)data[7] | ((uint64)data[6] << 8) |
-		    ((uint64)data[5] << 16) | ((uint64)data[4] << 24) |
-		    ((uint64)data[3] << 32) | ((uint64)data[2] << 40) |
-		    ((uint64)data[1] << 48) | ((uint64)data[0] << 56);
+	do
+	{
+		W512[j] = (uint64) data[7] | ((uint64) data[6] << 8) |
+			((uint64) data[5] << 16) | ((uint64) data[4] << 24) |
+			((uint64) data[3] << 32) | ((uint64) data[2] << 40) |
+			((uint64) data[1] << 48) | ((uint64) data[0] << 56);
 		data += 8;
 		/* Apply the SHA-512 compression function to update a..h */
 		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
@@ -687,16 +750,17 @@ SHA512_Transform(SHA512_CTX *context, const uint8 *data)
 		j++;
 	} while (j < 16);
 
-	do {
+	do
+	{
 		/* Part of the message block expansion: */
-		s0 = W512[(j+1)&0x0f];
+		s0 = W512[(j + 1) & 0x0f];
 		s0 = sigma0_512(s0);
-		s1 = W512[(j+14)&0x0f];
-		s1 =  sigma1_512(s1);
+		s1 = W512[(j + 14) & 0x0f];
+		s1 = sigma1_512(s1);
 
 		/* Apply the SHA-512 compression function to update a..h */
 		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
-		     (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
+			(W512[j & 0x0f] += s1 + W512[(j + 9) & 0x0f] + s0);
 		T2 = Sigma0_512(a) + Maj(a, b, c);
 		h = g;
 		g = f;
@@ -723,31 +787,35 @@ SHA512_Transform(SHA512_CTX *context, const uint8 *data)
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = T2 = 0;
 }
-
-#endif /* SHA2_UNROLL_TRANSFORM */
+#endif   /* SHA2_UNROLL_TRANSFORM */
 
 void
-SHA512_Update(SHA512_CTX *context, const uint8 *data, size_t len)
+SHA512_Update(SHA512_CTX * context, const uint8 *data, size_t len)
 {
-	size_t	freespace, usedspace;
+	size_t		freespace,
+				usedspace;
 
 	/* Calling with no data is valid (we do nothing) */
 	if (len == 0)
 		return;
 
 	usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
-	if (usedspace > 0) {
+	if (usedspace > 0)
+	{
 		/* Calculate how much free space is available in the buffer */
 		freespace = SHA512_BLOCK_LENGTH - usedspace;
 
-		if (len >= freespace) {
+		if (len >= freespace)
+		{
 			/* Fill the buffer completely and process it */
 			memcpy(&context->buffer[usedspace], data, freespace);
 			ADDINC128(context->bitcount, freespace << 3);
 			len -= freespace;
 			data += freespace;
 			SHA512_Transform(context, context->buffer);
-		} else {
+		}
+		else
+		{
 			/* The buffer is not yet full */
 			memcpy(&context->buffer[usedspace], data, len);
 			ADDINC128(context->bitcount, len << 3);
@@ -756,14 +824,16 @@ SHA512_Update(SHA512_CTX *context, const uint8 *data, size_t len)
 			return;
 		}
 	}
-	while (len >= SHA512_BLOCK_LENGTH) {
+	while (len >= SHA512_BLOCK_LENGTH)
+	{
 		/* Process as many complete blocks as we can */
 		SHA512_Transform(context, data);
 		ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
 		len -= SHA512_BLOCK_LENGTH;
 		data += SHA512_BLOCK_LENGTH;
 	}
-	if (len > 0) {
+	if (len > 0)
+	{
 		/* There's left-overs, so save 'em */
 		memcpy(context->buffer, data, len);
 		ADDINC128(context->bitcount, len << 3);
@@ -773,25 +843,30 @@ SHA512_Update(SHA512_CTX *context, const uint8 *data, size_t len)
 }
 
 void
-SHA512_Last(SHA512_CTX *context)
+SHA512_Last(SHA512_CTX * context)
 {
-	unsigned int	usedspace;
+	unsigned int usedspace;
 
 	usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
 #if BYTE_ORDER == LITTLE_ENDIAN
 	/* Convert FROM host byte order */
-	REVERSE64(context->bitcount[0],context->bitcount[0]);
-	REVERSE64(context->bitcount[1],context->bitcount[1]);
+	REVERSE64(context->bitcount[0], context->bitcount[0]);
+	REVERSE64(context->bitcount[1], context->bitcount[1]);
 #endif
-	if (usedspace > 0) {
+	if (usedspace > 0)
+	{
 		/* Begin padding with a 1 bit: */
 		context->buffer[usedspace++] = 0x80;
 
-		if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
+		if (usedspace <= SHA512_SHORT_BLOCK_LENGTH)
+		{
 			/* Set-up for the last transform: */
 			memset(&context->buffer[usedspace], 0, SHA512_SHORT_BLOCK_LENGTH - usedspace);
-		} else {
-			if (usedspace < SHA512_BLOCK_LENGTH) {
+		}
+		else
+		{
+			if (usedspace < SHA512_BLOCK_LENGTH)
+			{
 				memset(&context->buffer[usedspace], 0, SHA512_BLOCK_LENGTH - usedspace);
 			}
 			/* Do second-to-last transform: */
@@ -800,7 +875,9 @@ SHA512_Last(SHA512_CTX *context)
 			/* And set-up for the last transform: */
 			memset(context->buffer, 0, SHA512_BLOCK_LENGTH - 2);
 		}
-	} else {
+	}
+	else
+	{
 		/* Prepare for final transform: */
 		memset(context->buffer, 0, SHA512_SHORT_BLOCK_LENGTH);
 
@@ -808,27 +885,30 @@ SHA512_Last(SHA512_CTX *context)
 		*context->buffer = 0x80;
 	}
 	/* Store the length of input data (in bits): */
-	*(uint64 *)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
-	*(uint64 *)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
+	*(uint64 *) &context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
+	*(uint64 *) &context->buffer[SHA512_SHORT_BLOCK_LENGTH + 8] = context->bitcount[0];
 
 	/* Final transform: */
 	SHA512_Transform(context, context->buffer);
 }
 
 void
-SHA512_Final(uint8 digest[], SHA512_CTX *context)
+SHA512_Final(uint8 digest[], SHA512_CTX * context)
 {
 	/* If no digest buffer is passed, we don't bother doing this: */
-	if (digest != NULL) {
+	if (digest != NULL)
+	{
 		SHA512_Last(context);
 
 		/* Save the hash data for output: */
 #if BYTE_ORDER == LITTLE_ENDIAN
 		{
 			/* Convert TO host byte order */
-			int	j;
-			for (j = 0; j < 8; j++) {
-				REVERSE64(context->state[j],context->state[j]);
+			int			j;
+
+			for (j = 0; j < 8; j++)
+			{
+				REVERSE64(context->state[j], context->state[j]);
 			}
 		}
 #endif
@@ -842,7 +922,7 @@ SHA512_Final(uint8 digest[], SHA512_CTX *context)
 
 /*** SHA-384: *********************************************************/
 void
-SHA384_Init(SHA384_CTX *context)
+SHA384_Init(SHA384_CTX * context)
 {
 	if (context == NULL)
 		return;
@@ -852,25 +932,28 @@ SHA384_Init(SHA384_CTX *context)
 }
 
 void
-SHA384_Update(SHA384_CTX *context, const uint8 *data, size_t len)
+SHA384_Update(SHA384_CTX * context, const uint8 *data, size_t len)
 {
-	SHA512_Update((SHA512_CTX *)context, data, len);
+	SHA512_Update((SHA512_CTX *) context, data, len);
 }
 
 void
-SHA384_Final(uint8 digest[], SHA384_CTX *context)
+SHA384_Final(uint8 digest[], SHA384_CTX * context)
 {
 	/* If no digest buffer is passed, we don't bother doing this: */
-	if (digest != NULL) {
-		SHA512_Last((SHA512_CTX *)context);
+	if (digest != NULL)
+	{
+		SHA512_Last((SHA512_CTX *) context);
 
 		/* Save the hash data for output: */
 #if BYTE_ORDER == LITTLE_ENDIAN
 		{
 			/* Convert TO host byte order */
-			int	j;
-			for (j = 0; j < 6; j++) {
-				REVERSE64(context->state[j],context->state[j]);
+			int			j;
+
+			for (j = 0; j < 6; j++)
+			{
+				REVERSE64(context->state[j], context->state[j]);
 			}
 		}
 #endif
diff --git a/contrib/pgcrypto/sha2.h b/contrib/pgcrypto/sha2.h
index 9bfe9628c8..6c5ba7f596 100644
--- a/contrib/pgcrypto/sha2.h
+++ b/contrib/pgcrypto/sha2.h
@@ -4,7 +4,7 @@
 /*
  * FILE:	sha2.h
  * AUTHOR:	Aaron D. Gifford <[email protected]>
- * 
+ *
  * Copyright (c) 2000-2001, Aaron D. Gifford
  * All rights reserved.
  *
@@ -12,18 +12,18 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the copyright holder nor the names of contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * 
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -42,39 +42,41 @@
 /*** SHA-256/384/512 Various Length Definitions ***********************/
 #define SHA256_BLOCK_LENGTH		64
 #define SHA256_DIGEST_LENGTH		32
-#define SHA256_DIGEST_STRING_LENGTH	(SHA256_DIGEST_LENGTH * 2 + 1)
+#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
 #define SHA384_BLOCK_LENGTH		128
 #define SHA384_DIGEST_LENGTH		48
-#define SHA384_DIGEST_STRING_LENGTH	(SHA384_DIGEST_LENGTH * 2 + 1)
+#define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1)
 #define SHA512_BLOCK_LENGTH		128
 #define SHA512_DIGEST_LENGTH		64
-#define SHA512_DIGEST_STRING_LENGTH	(SHA512_DIGEST_LENGTH * 2 + 1)
+#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
 
 
 /*** SHA-256/384/512 Context Structures *******************************/
-typedef struct _SHA256_CTX {
-	uint32	state[8];
-	uint64	bitcount;
-	uint8	buffer[SHA256_BLOCK_LENGTH];
-} SHA256_CTX;
-typedef struct _SHA512_CTX {
-	uint64	state[8];
-	uint64	bitcount[2];
-	uint8	buffer[SHA512_BLOCK_LENGTH];
-} SHA512_CTX;
+typedef struct _SHA256_CTX
+{
+	uint32		state[8];
+	uint64		bitcount;
+	uint8		buffer[SHA256_BLOCK_LENGTH];
+}	SHA256_CTX;
+typedef struct _SHA512_CTX
+{
+	uint64		state[8];
+	uint64		bitcount[2];
+	uint8		buffer[SHA512_BLOCK_LENGTH];
+}	SHA512_CTX;
 
 typedef SHA512_CTX SHA384_CTX;
 
-void SHA256_Init(SHA256_CTX *);
-void SHA256_Update(SHA256_CTX *, const uint8 *, size_t);
-void SHA256_Final(uint8[SHA256_DIGEST_LENGTH], SHA256_CTX *);
+void		SHA256_Init(SHA256_CTX *);
+void		SHA256_Update(SHA256_CTX *, const uint8 *, size_t);
+void		SHA256_Final(uint8[SHA256_DIGEST_LENGTH], SHA256_CTX *);
 
-void SHA384_Init(SHA384_CTX *);
-void SHA384_Update(SHA384_CTX *, const uint8 *, size_t);
-void SHA384_Final(uint8[SHA384_DIGEST_LENGTH], SHA384_CTX *);
+void		SHA384_Init(SHA384_CTX *);
+void		SHA384_Update(SHA384_CTX *, const uint8 *, size_t);
+void		SHA384_Final(uint8[SHA384_DIGEST_LENGTH], SHA384_CTX *);
 
-void SHA512_Init(SHA512_CTX *);
-void SHA512_Update(SHA512_CTX *, const uint8 *, size_t);
-void SHA512_Final(uint8[SHA512_DIGEST_LENGTH], SHA512_CTX *);
+void		SHA512_Init(SHA512_CTX *);
+void		SHA512_Update(SHA512_CTX *, const uint8 *, size_t);
+void		SHA512_Final(uint8[SHA512_DIGEST_LENGTH], SHA512_CTX *);
 
-#endif /* _SHA2_H */
+#endif   /* _SHA2_H */
diff --git a/contrib/pgstattuple/pgstattuple.c b/contrib/pgstattuple/pgstattuple.c
index 19254faab4..3787874bfd 100644
--- a/contrib/pgstattuple/pgstattuple.c
+++ b/contrib/pgstattuple/pgstattuple.c
@@ -123,8 +123,8 @@ pgstattuple_real(Relation rel, FunctionCallInfo fcinfo)
 	tupdesc = CreateTupleDescCopy(tupdesc);
 
 	/*
-	 * Generate attribute metadata needed later to produce tuples from raw
-	 * C strings
+	 * Generate attribute metadata needed later to produce tuples from raw C
+	 * strings
 	 */
 	attinmeta = TupleDescGetAttInMetadata(tupdesc);
 
@@ -197,9 +197,9 @@ pgstattuple_real(Relation rel, FunctionCallInfo fcinfo)
 	}
 
 	/*
-	 * Prepare a values array for constructing the tuple. This should be
-	 * an array of C strings which will be processed later by the
-	 * appropriate "in" functions.
+	 * Prepare a values array for constructing the tuple. This should be an
+	 * array of C strings which will be processed later by the appropriate
+	 * "in" functions.
 	 */
 	values = (char **) palloc(NCOLUMNS * sizeof(char *));
 	for (i = 0; i < NCOLUMNS; i++)
diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c
index 5bdad542e4..52f65b062c 100644
--- a/contrib/seg/seg.c
+++ b/contrib/seg/seg.c
@@ -124,8 +124,7 @@ seg_out(SEG * seg)
 	if (seg->lower == seg->upper && seg->l_ext == seg->u_ext)
 	{
 		/*
-		 * indicates that this interval was built by seg_in off a single
-		 * point
+		 * indicates that this interval was built by seg_in off a single point
 		 */
 		p += restore(p, seg->lower, seg->l_sigd);
 	}
@@ -349,8 +348,7 @@ gseg_picksplit(GistEntryVector *entryvec,
 			size_waste = size_union - size_inter;
 
 			/*
-			 * are these a more promising split that what we've already
-			 * seen?
+			 * are these a more promising split that what we've already seen?
 			 */
 			if (size_waste > waste || firsttime)
 			{
@@ -375,24 +373,24 @@ gseg_picksplit(GistEntryVector *entryvec,
 	rt_seg_size(datum_r, &size_r);
 
 	/*
-	 * Now split up the regions between the two seeds.	An important
-	 * property of this split algorithm is that the split vector v has the
-	 * indices of items to be split in order in its left and right
-	 * vectors.  We exploit this property by doing a merge in the code
-	 * that actually splits the page.
+	 * Now split up the regions between the two seeds.	An important property
+	 * of this split algorithm is that the split vector v has the indices of
+	 * items to be split in order in its left and right vectors.  We exploit
+	 * this property by doing a merge in the code that actually splits the
+	 * page.
 	 *
-	 * For efficiency, we also place the new index tuple in this loop. This
-	 * is handled at the very end, when we have placed all the existing
-	 * tuples and i == maxoff + 1.
+	 * For efficiency, we also place the new index tuple in this loop. This is
+	 * handled at the very end, when we have placed all the existing tuples
+	 * and i == maxoff + 1.
 	 */
 
 	maxoff = OffsetNumberNext(maxoff);
 	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
 	{
 		/*
-		 * If we've already decided where to place this item, just put it
-		 * on the right list.  Otherwise, we need to figure out which page
-		 * needs the least enlargement in order to store the item.
+		 * If we've already decided where to place this item, just put it on
+		 * the right list.	Otherwise, we need to figure out which page needs
+		 * the least enlargement in order to store the item.
 		 */
 
 		if (i == seed_1)
@@ -742,8 +740,8 @@ seg_cmp(SEG * a, SEG * b)
 	 * a->lower == b->lower, so consider type of boundary.
 	 *
 	 * A '-' lower bound is < any other kind (this could only be relevant if
-	 * -HUGE_VAL is used as a regular data value). A '<' lower bound is <
-	 * any other kind except '-'. A '>' lower bound is > any other kind.
+	 * -HUGE_VAL is used as a regular data value). A '<' lower bound is < any
+	 * other kind except '-'. A '>' lower bound is > any other kind.
 	 */
 	if (a->l_ext != b->l_ext)
 	{
@@ -764,8 +762,7 @@ seg_cmp(SEG * a, SEG * b)
 	/*
 	 * For other boundary types, consider # of significant digits first.
 	 */
-	if (a->l_sigd < b->l_sigd)	/* (a) is blurred and is likely to include
-								 * (b) */
+	if (a->l_sigd < b->l_sigd)	/* (a) is blurred and is likely to include (b) */
 		return -1;
 	if (a->l_sigd > b->l_sigd)	/* (a) is less blurred and is likely to be
 								 * included in (b) */
@@ -800,8 +797,8 @@ seg_cmp(SEG * a, SEG * b)
 	 * a->upper == b->upper, so consider type of boundary.
 	 *
 	 * A '-' upper bound is > any other kind (this could only be relevant if
-	 * HUGE_VAL is used as a regular data value). A '<' upper bound is <
-	 * any other kind. A '>' upper bound is > any other kind except '-'.
+	 * HUGE_VAL is used as a regular data value). A '<' upper bound is < any
+	 * other kind. A '>' upper bound is > any other kind except '-'.
 	 */
 	if (a->u_ext != b->u_ext)
 	{
@@ -820,11 +817,10 @@ seg_cmp(SEG * a, SEG * b)
 	}
 
 	/*
-	 * For other boundary types, consider # of significant digits first.
-	 * Note result here is converse of the lower-boundary case.
+	 * For other boundary types, consider # of significant digits first. Note
+	 * result here is converse of the lower-boundary case.
 	 */
-	if (a->u_sigd < b->u_sigd)	/* (a) is blurred and is likely to include
-								 * (b) */
+	if (a->u_sigd < b->u_sigd)	/* (a) is blurred and is likely to include (b) */
 		return 1;
 	if (a->u_sigd > b->u_sigd)	/* (a) is less blurred and is likely to be
 								 * included in (b) */
@@ -908,17 +904,17 @@ restore(char *result, float val, int n)
 				sign;
 
 	/*
-	 * put a cap on the number of siugnificant digits to avoid nonsense in
-	 * the output
+	 * put a cap on the number of siugnificant digits to avoid nonsense in the
+	 * output
 	 */
 	n = Min(n, FLT_DIG);
 
 	/* remember the sign */
 	sign = (val < 0 ? 1 : 0);
 
-	efmt[5] = '0' + (n - 1) % 10;		/* makes %-15.(n-1)e -- this
-										 * format guarantees that the
-										 * exponent is always present */
+	efmt[5] = '0' + (n - 1) % 10;		/* makes %-15.(n-1)e -- this format
+										 * guarantees that the exponent is
+										 * always present */
 
 	sprintf(result, efmt, val);
 
@@ -940,8 +936,8 @@ restore(char *result, float val, int n)
 		if (Abs(exp) <= 4)
 		{
 			/*
-			 * remove the decimal point from the mantyssa and write the
-			 * digits to the buf array
+			 * remove the decimal point from the mantyssa and write the digits
+			 * to the buf array
 			 */
 			for (p = result + sign, i = 10, dp = 0; *p != 'e'; p++, i++)
 			{
@@ -960,10 +956,9 @@ restore(char *result, float val, int n)
 				if (dp - 10 + exp >= n)
 				{
 					/*
-					 * the decimal point is behind the last significant
-					 * digit; the digits in between must be converted to
-					 * the exponent and the decimal point placed after the
-					 * first digit
+					 * the decimal point is behind the last significant digit;
+					 * the digits in between must be converted to the exponent
+					 * and the decimal point placed after the first digit
 					 */
 					exp = dp - 10 + exp - n;
 					buf[10 + n] = '\0';
@@ -978,8 +973,8 @@ restore(char *result, float val, int n)
 					}
 
 					/*
-					 * adjust the exponent by the number of digits after
-					 * the decimal point
+					 * adjust the exponent by the number of digits after the
+					 * decimal point
 					 */
 					if (n > 1)
 						sprintf(&buf[11 + n], "e%d", exp + n - 1);
diff --git a/contrib/spi/autoinc.c b/contrib/spi/autoinc.c
index b6e0c64331..bad7c52735 100644
--- a/contrib/spi/autoinc.c
+++ b/contrib/spi/autoinc.c
@@ -73,8 +73,8 @@ autoinc(PG_FUNCTION_ARGS)
 		if (SPI_gettypeid(tupdesc, attnum) != INT4OID)
 			ereport(ERROR,
 					(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
-				   errmsg("attribute \"%s\" of \"%s\" must be type INT4",
-						  args[i], relname)));
+					 errmsg("attribute \"%s\" of \"%s\" must be type INT4",
+							args[i], relname)));
 
 		val = DatumGetInt32(SPI_getbinval(rettuple, tupdesc, attnum, &isnull));
 
diff --git a/contrib/spi/insert_username.c b/contrib/spi/insert_username.c
index 237b14d25c..ce8c21f9be 100644
--- a/contrib/spi/insert_username.c
+++ b/contrib/spi/insert_username.c
@@ -65,7 +65,7 @@ insert_username(PG_FUNCTION_ARGS)
 	if (attnum < 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
-			errmsg("\"%s\" has no attribute \"%s\"", relname, args[0])));
+				 errmsg("\"%s\" has no attribute \"%s\"", relname, args[0])));
 
 	if (SPI_gettypeid(tupdesc, attnum) != TEXTOID)
 		ereport(ERROR,
@@ -75,7 +75,7 @@ insert_username(PG_FUNCTION_ARGS)
 
 	/* create fields containing name */
 	newval = DirectFunctionCall1(textin,
-						CStringGetDatum(GetUserNameFromId(GetUserId())));
+							CStringGetDatum(GetUserNameFromId(GetUserId())));
 
 	/* construct new tuple */
 	rettuple = SPI_modifytuple(rel, rettuple, 1, &attnum, &newval, NULL);
diff --git a/contrib/spi/moddatetime.c b/contrib/spi/moddatetime.c
index f3a97e1c81..14556a8514 100644
--- a/contrib/spi/moddatetime.c
+++ b/contrib/spi/moddatetime.c
@@ -76,9 +76,8 @@ moddatetime(PG_FUNCTION_ARGS)
 								Int32GetDatum(-1));
 
 	/*
-	 * This gets the position in the tuple of the field we want. args[0]
-	 * being the name of the field to update, as passed in from the
-	 * trigger.
+	 * This gets the position in the tuple of the field we want. args[0] being
+	 * the name of the field to update, as passed in from the trigger.
 	 */
 	attnum = SPI_fnumber(tupdesc, args[0]);
 
@@ -100,8 +99,8 @@ moddatetime(PG_FUNCTION_ARGS)
 	if (SPI_gettypeid(tupdesc, attnum) != TIMESTAMPOID)
 		ereport(ERROR,
 				(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
-			  errmsg("attribute \"%s\" of \"%s\" must be type TIMESTAMP",
-					 args[0], relname)));
+				 errmsg("attribute \"%s\" of \"%s\" must be type TIMESTAMP",
+						args[0], relname)));
 
 /* 1 is the number of items in the arrays attnum and newdt.
 	attnum is the positional number of the field to be updated.
diff --git a/contrib/spi/refint.c b/contrib/spi/refint.c
index bc358f6eb4..8163f8ebaf 100644
--- a/contrib/spi/refint.c
+++ b/contrib/spi/refint.c
@@ -114,8 +114,8 @@ check_primary_key(PG_FUNCTION_ARGS)
 	kvals = (Datum *) palloc(nkeys * sizeof(Datum));
 
 	/*
-	 * Construct ident string as TriggerName $ TriggeredRelationId and try
-	 * to find prepared execution plan.
+	 * Construct ident string as TriggerName $ TriggeredRelationId and try to
+	 * find prepared execution plan.
 	 */
 	snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
 	plan = find_plan(ident, &PPlans, &nPPlans);
@@ -134,16 +134,16 @@ check_primary_key(PG_FUNCTION_ARGS)
 		if (fnumber < 0)
 			ereport(ERROR,
 					(errcode(ERRCODE_UNDEFINED_COLUMN),
-				errmsg("there is no attribute \"%s\" in relation \"%s\"",
-					   args[i], SPI_getrelname(rel))));
+					 errmsg("there is no attribute \"%s\" in relation \"%s\"",
+							args[i], SPI_getrelname(rel))));
 
 		/* Well, get binary (in internal format) value of column */
 		kvals[i] = SPI_getbinval(tuple, tupdesc, fnumber, &isnull);
 
 		/*
-		 * If it's NULL then nothing to do! DON'T FORGET call SPI_finish
-		 * ()! DON'T FORGET return tuple! Executor inserts tuple you're
-		 * returning! If you return NULL then nothing will be inserted!
+		 * If it's NULL then nothing to do! DON'T FORGET call SPI_finish ()!
+		 * DON'T FORGET return tuple! Executor inserts tuple you're returning!
+		 * If you return NULL then nothing will be inserted!
 		 */
 		if (isnull)
 		{
@@ -164,14 +164,14 @@ check_primary_key(PG_FUNCTION_ARGS)
 		char		sql[8192];
 
 		/*
-		 * Construct query: SELECT 1 FROM _referenced_relation_ WHERE
-		 * Pkey1 = $1 [AND Pkey2 = $2 [...]]
+		 * Construct query: SELECT 1 FROM _referenced_relation_ WHERE Pkey1 =
+		 * $1 [AND Pkey2 = $2 [...]]
 		 */
 		snprintf(sql, sizeof(sql), "select 1 from %s where ", relname);
 		for (i = 0; i < nkeys; i++)
 		{
 			snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), "%s = $%d %s",
-			  args[i + nkeys + 1], i + 1, (i < nkeys - 1) ? "and " : "");
+				  args[i + nkeys + 1], i + 1, (i < nkeys - 1) ? "and " : "");
 		}
 
 		/* Prepare plan for query */
@@ -181,9 +181,8 @@ check_primary_key(PG_FUNCTION_ARGS)
 			elog(ERROR, "check_primary_key: SPI_prepare returned %d", SPI_result);
 
 		/*
-		 * Remember that SPI_prepare places plan in current memory context
-		 * - so, we have to save plan in Top memory context for latter
-		 * use.
+		 * Remember that SPI_prepare places plan in current memory context -
+		 * so, we have to save plan in Top memory context for latter use.
 		 */
 		pplan = SPI_saveplan(pplan);
 		if (pplan == NULL)
@@ -252,8 +251,7 @@ check_foreign_key(PG_FUNCTION_ARGS)
 	EPlan	   *plan;			/* prepared plan(s) */
 	Oid		   *argtypes = NULL;	/* key types to prepare execution plan */
 	bool		isnull;			/* to know is some column NULL or not */
-	bool		isequal = true; /* are keys in both tuples equal (in
-								 * UPDATE) */
+	bool		isequal = true; /* are keys in both tuples equal (in UPDATE) */
 	char		ident[2 * NAMEDATALEN]; /* to identify myself */
 	int			is_update = 0;
 	int			ret;
@@ -287,9 +285,8 @@ check_foreign_key(PG_FUNCTION_ARGS)
 	trigtuple = trigdata->tg_trigtuple;
 
 	/*
-	 * But if this is UPDATE then we have to return tg_newtuple. Also, if
-	 * key in tg_newtuple is the same as in tg_trigtuple then nothing to
-	 * do.
+	 * But if this is UPDATE then we have to return tg_newtuple. Also, if key
+	 * in tg_newtuple is the same as in tg_trigtuple then nothing to do.
 	 */
 	is_update = 0;
 	if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
@@ -337,8 +334,8 @@ check_foreign_key(PG_FUNCTION_ARGS)
 	kvals = (Datum *) palloc(nkeys * sizeof(Datum));
 
 	/*
-	 * Construct ident string as TriggerName $ TriggeredRelationId and try
-	 * to find prepared execution plan(s).
+	 * Construct ident string as TriggerName $ TriggeredRelationId and try to
+	 * find prepared execution plan(s).
 	 */
 	snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
 	plan = find_plan(ident, &FPlans, &nFPlans);
@@ -365,16 +362,16 @@ check_foreign_key(PG_FUNCTION_ARGS)
 		if (fnumber < 0)
 			ereport(ERROR,
 					(errcode(ERRCODE_UNDEFINED_COLUMN),
-				errmsg("there is no attribute \"%s\" in relation \"%s\"",
-					   args[i], SPI_getrelname(rel))));
+					 errmsg("there is no attribute \"%s\" in relation \"%s\"",
+							args[i], SPI_getrelname(rel))));
 
 		/* Well, get binary (in internal format) value of column */
 		kvals[i] = SPI_getbinval(trigtuple, tupdesc, fnumber, &isnull);
 
 		/*
-		 * If it's NULL then nothing to do! DON'T FORGET call SPI_finish
-		 * ()! DON'T FORGET return tuple! Executor inserts tuple you're
-		 * returning! If you return NULL then nothing will be inserted!
+		 * If it's NULL then nothing to do! DON'T FORGET call SPI_finish ()!
+		 * DON'T FORGET return tuple! Executor inserts tuple you're returning!
+		 * If you return NULL then nothing will be inserted!
 		 */
 		if (isnull)
 		{
@@ -383,9 +380,9 @@ check_foreign_key(PG_FUNCTION_ARGS)
 		}
 
 		/*
-		 * If UPDATE then get column value from new tuple being inserted
-		 * and compare is this the same as old one. For the moment we use
-		 * string presentation of values...
+		 * If UPDATE then get column value from new tuple being inserted and
+		 * compare is this the same as old one. For the moment we use string
+		 * presentation of values...
 		 */
 		if (newtuple != NULL)
 		{
@@ -473,7 +470,7 @@ check_foreign_key(PG_FUNCTION_ARGS)
 						type = SPI_gettype(tupdesc, fn);
 
 						if ((strcmp(type, "text") && strcmp(type, "varchar") &&
-						strcmp(type, "char") && strcmp(type, "bpchar") &&
+							 strcmp(type, "char") && strcmp(type, "bpchar") &&
 							 strcmp(type, "date") && strcmp(type, "timestamp")) == 0)
 							is_char_type = 1;
 #ifdef	DEBUG_QUERY
@@ -482,8 +479,7 @@ check_foreign_key(PG_FUNCTION_ARGS)
 #endif
 
 						/*
-						 * is_char_type =1 i set ' ' for define a new
-						 * value
+						 * is_char_type =1 i set ' ' for define a new value
 						 */
 						snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql),
 								 " %s = %s%s%s %s ",
@@ -503,8 +499,8 @@ check_foreign_key(PG_FUNCTION_ARGS)
 			/*
 			 * For 'S'etnull action we construct UPDATE query - UPDATE
 			 * _referencing_relation_ SET Fkey1 null [, Fkey2 null [...]]
-			 * WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]] - to set key
-			 * columns in all referencing tuples to NULL.
+			 * WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]] - to set key columns in
+			 * all referencing tuples to NULL.
 			 */
 			else if (action == 's')
 			{
@@ -532,9 +528,9 @@ check_foreign_key(PG_FUNCTION_ARGS)
 				elog(ERROR, "check_foreign_key: SPI_prepare returned %d", SPI_result);
 
 			/*
-			 * Remember that SPI_prepare places plan in current memory
-			 * context - so, we have to save plan in Top memory context
-			 * for latter use.
+			 * Remember that SPI_prepare places plan in current memory context
+			 * - so, we have to save plan in Top memory context for latter
+			 * use.
 			 */
 			pplan = SPI_saveplan(pplan);
 			if (pplan == NULL)
@@ -566,8 +562,8 @@ check_foreign_key(PG_FUNCTION_ARGS)
 	for (r = 0; r < nrefs; r++)
 	{
 		/*
-		 * For 'R'estrict we may to execute plan for one tuple only, for
-		 * other actions - for all tuples.
+		 * For 'R'estrict we may to execute plan for one tuple only, for other
+		 * actions - for all tuples.
 		 */
 		int			tcount = (action == 'r') ? 1 : 0;
 
diff --git a/contrib/spi/timetravel.c b/contrib/spi/timetravel.c
index 0eae24a576..84a1153854 100644
--- a/contrib/spi/timetravel.c
+++ b/contrib/spi/timetravel.c
@@ -245,8 +245,8 @@ timetravel(PG_FUNCTION_ARGS)
 		elog(ERROR, "timetravel (%s): %s must be NOT NULL", relname, args[a_time_off]);
 
 	/*
-	 * If DELETE/UPDATE of tuple with stop_date neq INFINITY then say
-	 * upper Executor to skip operation for this tuple
+	 * If DELETE/UPDATE of tuple with stop_date neq INFINITY then say upper
+	 * Executor to skip operation for this tuple
 	 */
 	if (newtuple != NULL)
 	{							/* UPDATE */
@@ -263,8 +263,7 @@ timetravel(PG_FUNCTION_ARGS)
 				 relname, args[a_time_on], args[a_time_off]);
 	}
 	if (oldtimeoff != NOEND_ABSTIME)
-	{							/* current record is a deleted/updated
-								 * record */
+	{							/* current record is a deleted/updated record */
 		pfree(relname);
 		return PointerGetDatum(NULL);
 	}
@@ -285,8 +284,7 @@ timetravel(PG_FUNCTION_ARGS)
 	}
 
 	/* change date column(s) */
-	cvals[attnum[a_time_off] - 1] = newtimeoff; /* stop_date eq current
-												 * date */
+	cvals[attnum[a_time_off] - 1] = newtimeoff; /* stop_date eq current date */
 	cnulls[attnum[a_time_off] - 1] = ' ';
 
 	if (!newtuple)
@@ -299,8 +297,8 @@ timetravel(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Construct ident string as TriggerName $ TriggeredRelationId and try
-	 * to find prepared execution plan.
+	 * Construct ident string as TriggerName $ TriggeredRelationId and try to
+	 * find prepared execution plan.
 	 */
 	snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
 	plan = find_plan(ident, &Plans, &nPlans);
@@ -339,9 +337,8 @@ timetravel(PG_FUNCTION_ARGS)
 			elog(ERROR, "timetravel (%s): SPI_prepare returned %d", relname, SPI_result);
 
 		/*
-		 * Remember that SPI_prepare places plan in current memory context
-		 * - so, we have to save plan in Top memory context for latter
-		 * use.
+		 * Remember that SPI_prepare places plan in current memory context -
+		 * so, we have to save plan in Top memory context for latter use.
 		 */
 		pplan = SPI_saveplan(pplan);
 		if (pplan == NULL)
@@ -398,8 +395,8 @@ timetravel(PG_FUNCTION_ARGS)
 		rettuple = SPI_modifytuple(rel, newtuple, chnattrs, chattrs, newvals, newnulls);
 
 		/*
-		 * SPI_copytuple allocates tmptuple in upper executor context -
-		 * have to free allocation using SPI_pfree
+		 * SPI_copytuple allocates tmptuple in upper executor context - have
+		 * to free allocation using SPI_pfree
 		 */
 		/* SPI_pfree(tmptuple); */
 	}
diff --git a/contrib/tablefunc/tablefunc.c b/contrib/tablefunc/tablefunc.c
index 97163c81a4..7f67f37b00 100644
--- a/contrib/tablefunc/tablefunc.c
+++ b/contrib/tablefunc/tablefunc.c
@@ -184,8 +184,7 @@ normal_rand(PG_FUNCTION_ARGS)
 		funcctx = SRF_FIRSTCALL_INIT();
 
 		/*
-		 * switch to memory context appropriate for multiple function
-		 * calls
+		 * switch to memory context appropriate for multiple function calls
 		 */
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -196,10 +195,10 @@ normal_rand(PG_FUNCTION_ARGS)
 		fctx = (normal_rand_fctx *) palloc(sizeof(normal_rand_fctx));
 
 		/*
-		 * Use fctx to keep track of upper and lower bounds from call to
-		 * call. It will also be used to carry over the spare value we get
-		 * from the Box-Muller algorithm so that we only actually
-		 * calculate a new value every other call.
+		 * Use fctx to keep track of upper and lower bounds from call to call.
+		 * It will also be used to carry over the spare value we get from the
+		 * Box-Muller algorithm so that we only actually calculate a new value
+		 * every other call.
 		 */
 		fctx->mean = PG_GETARG_FLOAT8(1);
 		fctx->stddev = PG_GETARG_FLOAT8(2);
@@ -254,7 +253,7 @@ normal_rand(PG_FUNCTION_ARGS)
 		SRF_RETURN_NEXT(funcctx, Float8GetDatum(result));
 	}
 	else
-	/* do when there is no more left */
+		/* do when there is no more left */
 		SRF_RETURN_DONE(funcctx);
 }
 
@@ -331,8 +330,8 @@ get_normal_pair(float8 *x1, float8 *x2)
  * 1. SQL result must be ordered by 1,2.
  * 2. The number of values columns depends on the tuple description
  *	  of the function's declared return type.  The return type's columns
- *    must match the datatypes of the SQL query's result.  The datatype
- *    of the category column can be anything, however.
+ *	  must match the datatypes of the SQL query's result.  The datatype
+ *	  of the category column can be anything, however.
  * 3. Missing values (i.e. not enough adjacent rows of same rowid to
  *	  fill the number of result values columns) are filled in with nulls.
  * 4. Extra values (i.e. too many adjacent rows of same rowid to fill
@@ -368,8 +367,7 @@ crosstab(PG_FUNCTION_ARGS)
 		funcctx = SRF_FIRSTCALL_INIT();
 
 		/*
-		 * switch to memory context appropriate for multiple function
-		 * calls
+		 * switch to memory context appropriate for multiple function calls
 		 */
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -394,7 +392,7 @@ crosstab(PG_FUNCTION_ARGS)
 			 * 1. rowname
 			 *	the label or identifier for each row in the final result
 			 * 2. category
-			 *  the label or identifier for each column in the final result
+			 *	the label or identifier for each column in the final result
 			 * 3. values
 			 *	the value for each column in the final result
 			 *----------
@@ -404,7 +402,7 @@ crosstab(PG_FUNCTION_ARGS)
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 						 errmsg("invalid source data SQL statement"),
 						 errdetail("The provided SQL must return 3 "
-							 "columns: rowid, category, and values.")));
+								   "columns: rowid, category, and values.")));
 		}
 		else
 		{
@@ -439,8 +437,8 @@ crosstab(PG_FUNCTION_ARGS)
 		tupdesc = CreateTupleDescCopy(tupdesc);
 
 		/*
-		 * Check that return tupdesc is compatible with the data we got
-		 * from SPI, at least based on number and type of attributes
+		 * Check that return tupdesc is compatible with the data we got from
+		 * SPI, at least based on number and type of attributes
 		 */
 		if (!compatCrosstabTupleDescs(tupdesc, spi_tupdesc))
 			ereport(ERROR,
@@ -449,8 +447,8 @@ crosstab(PG_FUNCTION_ARGS)
 							"incompatible")));
 
 		/*
-		 * Generate attribute metadata needed later to produce tuples from
-		 * raw C strings
+		 * Generate attribute metadata needed later to produce tuples from raw
+		 * C strings
 		 */
 		attinmeta = TupleDescGetAttInMetadata(tupdesc);
 		funcctx->attinmeta = attinmeta;
@@ -530,11 +528,10 @@ crosstab(PG_FUNCTION_ARGS)
 				rowid = SPI_getvalue(spi_tuple, spi_tupdesc, 1);
 
 				/*
-				 * If this is the first pass through the values for this
-				 * rowid set it, otherwise make sure it hasn't changed on
-				 * us. Also check to see if the rowid is the same as that
-				 * of the last tuple sent -- if so, skip this tuple
-				 * entirely
+				 * If this is the first pass through the values for this rowid
+				 * set it, otherwise make sure it hasn't changed on us. Also
+				 * check to see if the rowid is the same as that of the last
+				 * tuple sent -- if so, skip this tuple entirely
 				 */
 				if (i == 0)
 					values[0] = pstrdup(rowid);
@@ -550,16 +547,15 @@ crosstab(PG_FUNCTION_ARGS)
 					 * Get the next category item value, which is alway
 					 * attribute number three.
 					 *
-					 * Be careful to sssign the value to the array index
-					 * based on which category we are presently
-					 * processing.
+					 * Be careful to sssign the value to the array index based on
+					 * which category we are presently processing.
 					 */
 					values[1 + i] = SPI_getvalue(spi_tuple, spi_tupdesc, 3);
 
 					/*
-					 * increment the counter since we consume a row for
-					 * each category, but not for last pass because the
-					 * API will do that for us
+					 * increment the counter since we consume a row for each
+					 * category, but not for last pass because the API will do
+					 * that for us
 					 */
 					if (i < (num_categories - 1))
 						call_cntr = ++funcctx->call_cntr;
@@ -567,9 +563,9 @@ crosstab(PG_FUNCTION_ARGS)
 				else
 				{
 					/*
-					 * We'll fill in NULLs for the missing values, but we
-					 * need to decrement the counter since this sql result
-					 * row doesn't belong to the current output tuple.
+					 * We'll fill in NULLs for the missing values, but we need
+					 * to decrement the counter since this sql result row
+					 * doesn't belong to the current output tuple.
 					 */
 					call_cntr = --funcctx->call_cntr;
 					break;
@@ -584,8 +580,8 @@ crosstab(PG_FUNCTION_ARGS)
 			if (values[0] != NULL)
 			{
 				/*
-				 * switch to memory context appropriate for multiple
-				 * function calls
+				 * switch to memory context appropriate for multiple function
+				 * calls
 				 */
 				oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -612,8 +608,8 @@ crosstab(PG_FUNCTION_ARGS)
 			else
 			{
 				/*
-				 * Skipping this tuple entirely, but we need to advance
-				 * the counter like the API would if we had returned one.
+				 * Skipping this tuple entirely, but we need to advance the
+				 * counter like the API would if we had returned one.
 				 */
 				call_cntr = ++funcctx->call_cntr;
 
@@ -631,7 +627,7 @@ crosstab(PG_FUNCTION_ARGS)
 		}
 	}
 	else
-	/* do when there is no more left */
+		/* do when there is no more left */
 	{
 		/* release SPI related resources */
 		SPI_finish();
@@ -730,10 +726,10 @@ crosstab_hash(PG_FUNCTION_ARGS)
 
 	/*
 	 * SFRM_Materialize mode expects us to return a NULL Datum. The actual
-	 * tuples are in our tuplestore and passed back through
-	 * rsinfo->setResult. rsinfo->setDesc is set to the tuple description
-	 * that we actually used to build our tuples with, so the caller can
-	 * verify we did what it was expecting.
+	 * tuples are in our tuplestore and passed back through rsinfo->setResult.
+	 * rsinfo->setDesc is set to the tuple description that we actually used
+	 * to build our tuples with, so the caller can verify we did what it was
+	 * expecting.
 	 */
 	rsinfo->setDesc = tupdesc;
 	MemoryContextSwitchTo(oldcontext);
@@ -758,8 +754,8 @@ load_categories_hash(char *cats_sql, MemoryContext per_query_ctx)
 	ctl.entrysize = sizeof(crosstab_HashEnt);
 
 	/*
-	 * use INIT_CATS, defined above as a guess of how many hash table
-	 * entries to create, initially
+	 * use INIT_CATS, defined above as a guess of how many hash table entries
+	 * to create, initially
 	 */
 	crosstab_HashTable = hash_create("crosstab hash", INIT_CATS, &ctl, HASH_ELEM);
 
@@ -780,8 +776,8 @@ load_categories_hash(char *cats_sql, MemoryContext per_query_ctx)
 		int			i;
 
 		/*
-		 * The provided categories SQL query must always return one
-		 * column: category - the label or identifier for each column
+		 * The provided categories SQL query must always return one column:
+		 * category - the label or identifier for each column
 		 */
 		if (spi_tupdesc->natts != 1)
 			ereport(ERROR,
@@ -872,26 +868,24 @@ get_crosstab_tuplestore(char *sql,
 		}
 
 		/*
-		 * The provided SQL query must always return at least three
-		 * columns:
+		 * The provided SQL query must always return at least three columns:
 		 *
-		 * 1. rowname	the label for each row - column 1 in the final result
-		 * 2. category	the label for each value-column in the final
-		 * result 3. value	   the values used to populate the
-		 * value-columns
+		 * 1. rowname	the label for each row - column 1 in the final result 2.
+		 * category  the label for each value-column in the final result 3.
+		 * value	 the values used to populate the value-columns
 		 *
 		 * If there are more than three columns, the last two are taken as
-		 * "category" and "values". The first column is taken as
-		 * "rowname". Additional columns (2 thru N-2) are assumed the same
-		 * for the same "rowname", and are copied into the result tuple
-		 * from the first time we encounter a particular rowname.
+		 * "category" and "values". The first column is taken as "rowname".
+		 * Additional columns (2 thru N-2) are assumed the same for the same
+		 * "rowname", and are copied into the result tuple from the first time
+		 * we encounter a particular rowname.
 		 */
 		if (ncols < 3)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 					 errmsg("invalid source data SQL statement"),
 					 errdetail("The provided SQL must return 3 " \
-							 " columns; rowid, category, and values.")));
+							   " columns; rowid, category, and values.")));
 
 		result_ncols = (ncols - 2) + num_categories;
 
@@ -902,7 +896,7 @@ get_crosstab_tuplestore(char *sql,
 					 errmsg("invalid return type"),
 					 errdetail("query-specified return " \
 							   "tuple has %d columns but crosstab " \
-						   "returns %d", tupdesc->natts, result_ncols)));
+							   "returns %d", tupdesc->natts, result_ncols)));
 
 		/* allocate space */
 		values = (char **) palloc(result_ncols * sizeof(char *));
@@ -933,14 +927,13 @@ get_crosstab_tuplestore(char *sql,
 			if ((lastrowid == NULL) || (strcmp(rowid, lastrowid) != 0))
 			{
 				/*
-				 * a new row means we need to flush the old one first,
-				 * unless we're on the very first row
+				 * a new row means we need to flush the old one first, unless
+				 * we're on the very first row
 				 */
 				if (lastrowid != NULL)
 				{
 					/*
-					 * switch to appropriate context while storing the
-					 * tuple
+					 * switch to appropriate context while storing the tuple
 					 */
 					SPIcontext = MemoryContextSwitchTo(per_query_ctx);
 
@@ -1103,10 +1096,10 @@ connectby_text(PG_FUNCTION_ARGS)
 
 	/*
 	 * SFRM_Materialize mode expects us to return a NULL Datum. The actual
-	 * tuples are in our tuplestore and passed back through
-	 * rsinfo->setResult. rsinfo->setDesc is set to the tuple description
-	 * that we actually used to build our tuples with, so the caller can
-	 * verify we did what it was expecting.
+	 * tuples are in our tuplestore and passed back through rsinfo->setResult.
+	 * rsinfo->setDesc is set to the tuple description that we actually used
+	 * to build our tuples with, so the caller can verify we did what it was
+	 * expecting.
 	 */
 	return (Datum) 0;
 }
@@ -1182,10 +1175,10 @@ connectby_text_serial(PG_FUNCTION_ARGS)
 
 	/*
 	 * SFRM_Materialize mode expects us to return a NULL Datum. The actual
-	 * tuples are in our tuplestore and passed back through
-	 * rsinfo->setResult. rsinfo->setDesc is set to the tuple description
-	 * that we actually used to build our tuples with, so the caller can
-	 * verify we did what it was expecting.
+	 * tuples are in our tuplestore and passed back through rsinfo->setResult.
+	 * rsinfo->setDesc is set to the tuple description that we actually used
+	 * to build our tuples with, so the caller can verify we did what it was
+	 * expecting.
 	 */
 	return (Datum) 0;
 }
@@ -1382,16 +1375,16 @@ build_tuplestore_recursively(char *key_fld,
 		{
 			/*
 			 * Check that return tupdesc is compatible with the one we got
-			 * from the query, but only at level 0 -- no need to check
-			 * more than once
+			 * from the query, but only at level 0 -- no need to check more
+			 * than once
 			 */
 
 			if (!compatConnectbyTupleDescs(tupdesc, spi_tupdesc))
 				ereport(ERROR,
 						(errcode(ERRCODE_SYNTAX_ERROR),
 						 errmsg("invalid return type"),
-					 errdetail("Return and SQL tuple descriptions are " \
-							   "incompatible.")));
+						 errdetail("Return and SQL tuple descriptions are " \
+								   "incompatible.")));
 		}
 
 		for (i = 0; i < proc; i++)
@@ -1576,7 +1569,7 @@ compatConnectbyTupleDescs(TupleDesc ret_tupdesc, TupleDesc sql_tupdesc)
 				(errcode(ERRCODE_SYNTAX_ERROR),
 				 errmsg("invalid return type"),
 				 errdetail("SQL parent key field datatype does " \
-						"not match return parent key field datatype.")));
+						   "not match return parent key field datatype.")));
 
 	/* OK, the two tupdescs are compatible for our purposes */
 	return true;
@@ -1605,9 +1598,9 @@ compatCrosstabTupleDescs(TupleDesc ret_tupdesc, TupleDesc sql_tupdesc)
 						   "return rowid datatype.")));
 
 	/*
-	 * - attribute [1] of the sql tuple is the category; no need to check
-	 * it - attribute [2] of the sql tuple should match attributes [1] to
-	 * [natts] of the return tuple
+	 * - attribute [1] of the sql tuple is the category; no need to check it -
+	 * attribute [2] of the sql tuple should match attributes [1] to [natts]
+	 * of the return tuple
 	 */
 	sql_attr = sql_tupdesc->attrs[2];
 	for (i = 1; i < ret_tupdesc->natts; i++)
diff --git a/contrib/tsearch2/dict.c b/contrib/tsearch2/dict.c
index de81846e37..f221d174ef 100644
--- a/contrib/tsearch2/dict.c
+++ b/contrib/tsearch2/dict.c
@@ -91,9 +91,9 @@ reset_dict(void)
 static int
 comparedict(const void *a, const void *b)
 {
-	if ( ((DictInfo *) a)->dict_id == ((DictInfo *) b)->dict_id )
+	if (((DictInfo *) a)->dict_id == ((DictInfo *) b)->dict_id)
 		return 0;
-	return ( ((DictInfo *) a)->dict_id < ((DictInfo *) b)->dict_id ) ? -1 : 1;
+	return (((DictInfo *) a)->dict_id < ((DictInfo *) b)->dict_id) ? -1 : 1;
 }
 
 DictInfo *
@@ -184,8 +184,8 @@ lexize(PG_FUNCTION_ARGS)
 {
 	text	   *in = PG_GETARG_TEXT_P(1);
 	DictInfo   *dict;
-	TSLexeme	  *res,
-			  *ptr;
+	TSLexeme   *res,
+			   *ptr;
 	Datum	   *da;
 	ArrayType  *a;
 
@@ -193,11 +193,11 @@ lexize(PG_FUNCTION_ARGS)
 	dict = finddict(PG_GETARG_OID(0));
 
 	ptr = res = (TSLexeme *) DatumGetPointer(
-									  FunctionCall3(&(dict->lexize_info),
-									   PointerGetDatum(dict->dictionary),
-											PointerGetDatum(VARDATA(in)),
-									Int32GetDatum(VARSIZE(in) - VARHDRSZ)
-													)
+										  FunctionCall3(&(dict->lexize_info),
+										   PointerGetDatum(dict->dictionary),
+												PointerGetDatum(VARDATA(in)),
+										Int32GetDatum(VARSIZE(in) - VARHDRSZ)
+														)
 		);
 	PG_FREE_IF_COPY(in, 1);
 	if (!res)
diff --git a/contrib/tsearch2/dict.h b/contrib/tsearch2/dict.h
index a21086a49d..0227bb4845 100644
--- a/contrib/tsearch2/dict.h
+++ b/contrib/tsearch2/dict.h
@@ -39,26 +39,22 @@ typedef struct
 void		parse_cfgdict(text *in, Map ** m);
 
 /* return struct for any lexize function */
-typedef struct {
-	/* number of variant of split word , for example
-		Word 'fotballklubber' (norwegian) has two varian to split:
-		( fotball, klubb ) and ( fot, ball, klubb ). So, dictionary
-		should return:
-		nvariant	lexeme
-		1		fotball
-		1		klubb
-		2		fot
-		2		ball
-		2		klubb
-
-	*/
-	uint16	nvariant;
+typedef struct
+{
+	/*
+	 * number of variant of split word , for example Word 'fotballklubber'
+	 * (norwegian) has two varian to split: ( fotball, klubb ) and ( fot,
+	 * ball, klubb ). So, dictionary should return: nvariant	lexeme 1
+	 * fotball 1	   klubb 2		 fot 2		 ball 2		  klubb
+	 *
+	 */
+	uint16		nvariant;
 
 	/* currently unused */
-	uint16	flags;
+	uint16		flags;
 
 	/* C-string */
-	char	*lexeme;
-} TSLexeme;
+	char	   *lexeme;
+}	TSLexeme;
 
 #endif
diff --git a/contrib/tsearch2/dict_ex.c b/contrib/tsearch2/dict_ex.c
index cee2d1e976..8ec3950f9f 100644
--- a/contrib/tsearch2/dict_ex.c
+++ b/contrib/tsearch2/dict_ex.c
@@ -52,7 +52,7 @@ dex_lexize(PG_FUNCTION_ARGS)
 	char	   *txt = pnstrdup(in, PG_GETARG_INT32(2));
 	TSLexeme   *res = palloc(sizeof(TSLexeme) * 2);
 
-	memset(res,0,sizeof(TSLexeme) * 2);
+	memset(res, 0, sizeof(TSLexeme) * 2);
 
 	if (*txt == '\0' || searchstoplist(&(d->stoplist), txt))
 	{
diff --git a/contrib/tsearch2/dict_ispell.c b/contrib/tsearch2/dict_ispell.c
index 12d9205a4e..28ce70a285 100644
--- a/contrib/tsearch2/dict_ispell.c
+++ b/contrib/tsearch2/dict_ispell.c
@@ -66,8 +66,8 @@ spell_init(PG_FUNCTION_ARGS)
 			{
 				freeDictISpell(d);
 				ereport(ERROR,
-					  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					   errmsg("dictionary already loaded")));
+						(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						 errmsg("dictionary already loaded")));
 			}
 			if (NIImportDictionary(&(d->obj), pcfg->value))
 			{
@@ -85,8 +85,8 @@ spell_init(PG_FUNCTION_ARGS)
 			{
 				freeDictISpell(d);
 				ereport(ERROR,
-					  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					   errmsg("affixes already loaded")));
+						(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						 errmsg("affixes already loaded")));
 			}
 			if (NIImportAffixes(&(d->obj), pcfg->value))
 			{
@@ -106,8 +106,8 @@ spell_init(PG_FUNCTION_ARGS)
 			{
 				freeDictISpell(d);
 				ereport(ERROR,
-					  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-					   errmsg("stop words already loaded")));
+						(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+						 errmsg("stop words already loaded")));
 			}
 			readstoplist(tmp, &(d->stoplist));
 			sortstoplist(&(d->stoplist));
@@ -157,9 +157,9 @@ spell_lexize(PG_FUNCTION_ARGS)
 	DictISpell *d = (DictISpell *) PG_GETARG_POINTER(0);
 	char	   *in = (char *) PG_GETARG_POINTER(1);
 	char	   *txt;
-	TSLexeme	  *res;
-	TSLexeme	  *ptr,
-			  *cptr;
+	TSLexeme   *res;
+	TSLexeme   *ptr,
+			   *cptr;
 
 	if (!PG_GETARG_INT32(2))
 		PG_RETURN_POINTER(NULL);
diff --git a/contrib/tsearch2/dict_snowball.c b/contrib/tsearch2/dict_snowball.c
index 5a83fb45d3..0c08c293d3 100644
--- a/contrib/tsearch2/dict_snowball.c
+++ b/contrib/tsearch2/dict_snowball.c
@@ -102,7 +102,7 @@ snb_lexize(PG_FUNCTION_ARGS)
 	DictSnowball *d = (DictSnowball *) PG_GETARG_POINTER(0);
 	char	   *in = (char *) PG_GETARG_POINTER(1);
 	char	   *txt = pnstrdup(in, PG_GETARG_INT32(2));
-	TSLexeme	  *res = palloc(sizeof(TSLexeme) * 2);
+	TSLexeme   *res = palloc(sizeof(TSLexeme) * 2);
 
 	memset(res, 0, sizeof(TSLexeme) * 2);
 	if (*txt == '\0' || searchstoplist(&(d->stoplist), txt))
diff --git a/contrib/tsearch2/dict_syn.c b/contrib/tsearch2/dict_syn.c
index d3e884212b..f328152080 100644
--- a/contrib/tsearch2/dict_syn.c
+++ b/contrib/tsearch2/dict_syn.c
@@ -159,7 +159,7 @@ syn_lexize(PG_FUNCTION_ARGS)
 	char	   *in = (char *) PG_GETARG_POINTER(1);
 	Syn			key,
 			   *found;
-	TSLexeme	  *res = NULL;
+	TSLexeme   *res = NULL;
 
 	if (!PG_GETARG_INT32(2))
 		PG_RETURN_POINTER(NULL);
@@ -174,7 +174,7 @@ syn_lexize(PG_FUNCTION_ARGS)
 		PG_RETURN_POINTER(NULL);
 
 	res = palloc(sizeof(TSLexeme) * 2);
-	memset(res,0,sizeof(TSLexeme) * 2);
+	memset(res, 0, sizeof(TSLexeme) * 2);
 	res[0].lexeme = pstrdup(found->out);
 
 	PG_RETURN_POINTER(res);
diff --git a/contrib/tsearch2/gistidx.c b/contrib/tsearch2/gistidx.c
index 653a476536..c0d15de691 100644
--- a/contrib/tsearch2/gistidx.c
+++ b/contrib/tsearch2/gistidx.c
@@ -65,30 +65,32 @@ gtsvector_in(PG_FUNCTION_ARGS)
 	PG_RETURN_DATUM(0);
 }
 
-#define	SINGOUTSTR	"%d true bits, %d false bits"
-#define	ARROUTSTR	"%d unique words"
+#define SINGOUTSTR	"%d true bits, %d false bits"
+#define ARROUTSTR	"%d unique words"
 #define EXTRALEN	( 2*13 )
 
-static int outbuf_maxlen = 0;
+static int	outbuf_maxlen = 0;
 
 Datum
 gtsvector_out(PG_FUNCTION_ARGS)
 {
 	GISTTYPE   *key = (GISTTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_POINTER(0)));
-	char *outbuf;
+	char	   *outbuf;
 
-	if ( outbuf_maxlen==0 )
-		outbuf_maxlen = 2*EXTRALEN + Max( strlen(SINGOUTSTR), strlen(ARROUTSTR) ) + 1;
-	outbuf = palloc( outbuf_maxlen );
+	if (outbuf_maxlen == 0)
+		outbuf_maxlen = 2 * EXTRALEN + Max(strlen(SINGOUTSTR), strlen(ARROUTSTR)) + 1;
+	outbuf = palloc(outbuf_maxlen);
 
-	if ( ISARRKEY(key) ) 
-		sprintf( outbuf, ARROUTSTR, (int) ARRNELEM(key) );  
-	else {
-		int cnttrue = ( ISALLTRUE(key) ) ? SIGLENBIT : sizebitvec(GETSIGN(key));
-		sprintf( outbuf, SINGOUTSTR, cnttrue, (int) SIGLENBIT - cnttrue ); 
-	}	
+	if (ISARRKEY(key))
+		sprintf(outbuf, ARROUTSTR, (int) ARRNELEM(key));
+	else
+	{
+		int			cnttrue = (ISALLTRUE(key)) ? SIGLENBIT : sizebitvec(GETSIGN(key));
+
+		sprintf(outbuf, SINGOUTSTR, cnttrue, (int) SIGLENBIT - cnttrue);
+	}
 
-	PG_FREE_IF_COPY(key,0);
+	PG_FREE_IF_COPY(key, 0);
 	PG_RETURN_POINTER(outbuf);
 }
 
@@ -165,8 +167,8 @@ gtsvector_compress(PG_FUNCTION_ARGS)
 		if (len != val->size)
 		{
 			/*
-			 * there is a collision of hash-function; len is always less
-			 * than val->size
+			 * there is a collision of hash-function; len is always less than
+			 * val->size
 			 */
 			len = CALCGTSIZE(ARRKEY, len);
 			res = (GISTTYPE *) repalloc((void *) res, len);
@@ -280,7 +282,7 @@ gtsvector_consistent(PG_FUNCTION_ARGS)
 {
 	QUERYTYPE  *query = (QUERYTYPE *) PG_GETARG_POINTER(1);
 	GISTTYPE   *key = (GISTTYPE *) DatumGetPointer(
-								((GISTENTRY *) PG_GETARG_POINTER(0))->key
+									((GISTENTRY *) PG_GETARG_POINTER(0))->key
 	);
 
 	if (!query->size)
diff --git a/contrib/tsearch2/gistidx.h b/contrib/tsearch2/gistidx.h
index b4422a306a..7e243534fb 100644
--- a/contrib/tsearch2/gistidx.h
+++ b/contrib/tsearch2/gistidx.h
@@ -10,8 +10,8 @@
  */
 
 #define BITBYTE 8
-#define SIGLENINT  63			/* >121 => key will toast, so it will not
-								 * work !!! */
+#define SIGLENINT  63			/* >121 => key will toast, so it will not work
+								 * !!! */
 #define SIGLEN	( sizeof(int4) * SIGLENINT )
 #define SIGLENBIT (SIGLEN * BITBYTE)
 
@@ -55,7 +55,7 @@ typedef struct
 #define ISSIGNKEY(x)	( ((GISTTYPE*)(x))->flag & SIGNKEY )
 #define ISALLTRUE(x)	( ((GISTTYPE*)(x))->flag & ALLISTRUE )
 
-#define GTHDRSIZE	( sizeof(int4) * 2  )
+#define GTHDRSIZE	( sizeof(int4) * 2	)
 #define CALCGTSIZE(flag, len) ( GTHDRSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(int4)) : (((flag) & ALLISTRUE) ? 0 : SIGLEN) ) )
 
 #define GETSIGN(x)	( (BITVECP)( (char*)(x)+GTHDRSIZE ) )
diff --git a/contrib/tsearch2/ispell/spell.c b/contrib/tsearch2/ispell/spell.c
index 872e7f972b..9999983cc8 100644
--- a/contrib/tsearch2/ispell/spell.c
+++ b/contrib/tsearch2/ispell/spell.c
@@ -153,7 +153,7 @@ NIImportDictionary(IspellDict * Conf, const char *filename)
 		return (1);
 	while (fgets(str, sizeof(str), dict))
 	{
-		char *s;
+		char	   *s;
 		const char *flag;
 
 		flag = NULL;
@@ -266,7 +266,7 @@ NIAddAffix(IspellDict * Conf, int flag, char flagflags, const char *mask, const
 	{
 		Conf->Affix[Conf->naffixes].issimple = 0;
 		Conf->Affix[Conf->naffixes].isregis = 0;
-		Conf->Affix[Conf->naffixes].mask = (char*)malloc( strlen(mask) + 2 );
+		Conf->Affix[Conf->naffixes].mask = (char *) malloc(strlen(mask) + 2);
 		if (type == FF_SUFFIX)
 			sprintf(Conf->Affix[Conf->naffixes].mask, "%s$", mask);
 		else
@@ -489,8 +489,8 @@ mkSPNode(IspellDict * Conf, int low, int high, int level)
 				if (data->isword && data->affix != Conf->Spell[i].p.d.affix)
 				{
 					/*
-					 * fprintf(stderr,"Word already exists: %s (affixes:
-					 * '%s' and '%s')\n", Conf->Spell[i].word,
+					 * fprintf(stderr,"Word already exists: %s (affixes: '%s'
+					 * and '%s')\n", Conf->Spell[i].word,
 					 * Conf->AffixData[data->affix],
 					 * Conf->AffixData[Conf->Spell[i].p.d.affix] );
 					 */
@@ -806,7 +806,8 @@ CheckAffix(const char *word, size_t len, AFFIX * Affix, char flagflags, char *ne
 			pfree(mask);
 			if (err)
 			{
-				char regerrstr[ERRSTRSIZE];	
+				char		regerrstr[ERRSTRSIZE];
+
 				pg_regerror(err, &(Affix->reg.regex), regerrstr, ERRSTRSIZE);
 				elog(ERROR, "Regex error in '%s': %s", Affix->mask, regerrstr);
 			}
@@ -1037,8 +1038,7 @@ SplitToVariants(IspellDict * Conf, SPNode * snode, SplitVar * orig, char *word,
 		while (level > startpos && (lenaff = CheckCompoundAffixes(&caff, word + level, wordlen - level)) > 0)
 		{
 			/*
-			 * there is one of compound suffixes, so check word for
-			 * existings
+			 * there is one of compound suffixes, so check word for existings
 			 */
 			char		buf[MAXNORMLEN];
 			char	  **subres;
@@ -1128,20 +1128,24 @@ TSLexeme *
 NINormalizeWord(IspellDict * Conf, char *word)
 {
 	char	  **res = NormalizeSubWord(Conf, word, 0);
-	TSLexeme *lcur=NULL, *lres=NULL;
-	uint16	  NVariant=1;
-
-	if (res) {
-		char **ptr = res;
-		lcur = lres = (TSLexeme*)palloc( MAX_NORM * sizeof(TSLexeme) );
-		while(*ptr) {
-			lcur->lexeme=*ptr;
-			lcur->flags=0;
+	TSLexeme   *lcur = NULL,
+			   *lres = NULL;
+	uint16		NVariant = 1;
+
+	if (res)
+	{
+		char	  **ptr = res;
+
+		lcur = lres = (TSLexeme *) palloc(MAX_NORM * sizeof(TSLexeme));
+		while (*ptr)
+		{
+			lcur->lexeme = *ptr;
+			lcur->flags = 0;
 			lcur->nvariant = NVariant++;
 			lcur++;
 			ptr++;
 		}
-		lcur->lexeme=NULL;
+		lcur->lexeme = NULL;
 		pfree(res);
 	}
 
@@ -1162,29 +1166,31 @@ NINormalizeWord(IspellDict * Conf, char *word)
 				{
 					char	  **subptr = subres;
 
-					if ( !lcur )
-						lcur = lres = (TSLexeme*)palloc( MAX_NORM * sizeof(TSLexeme) );
-		
-					while(*subptr) {
-						for(i=0;i<var->nstem-1;i++) {
-							lcur->lexeme=(subptr==subres) ? var->stem[ i ] : pstrdup(var->stem[ i ]);
-							lcur->flags=0;
+					if (!lcur)
+						lcur = lres = (TSLexeme *) palloc(MAX_NORM * sizeof(TSLexeme));
+
+					while (*subptr)
+					{
+						for (i = 0; i < var->nstem - 1; i++)
+						{
+							lcur->lexeme = (subptr == subres) ? var->stem[i] : pstrdup(var->stem[i]);
+							lcur->flags = 0;
 							lcur->nvariant = NVariant;
 							lcur++;
 						}
 
-						lcur->lexeme=*subptr;
-						lcur->flags=0;
+						lcur->lexeme = *subptr;
+						lcur->flags = 0;
 						lcur->nvariant = NVariant;
 						lcur++;
 						subptr++;
 						NVariant++;
-					}	
+					}
 
-					lcur->lexeme=NULL;
+					lcur->lexeme = NULL;
 					pfree(subres);
 					var->stem[0] = NULL;
-					pfree( var->stem[ var->nstem-1 ] );	
+					pfree(var->stem[var->nstem - 1]);
 				}
 			}
 
diff --git a/contrib/tsearch2/ispell/spell.h b/contrib/tsearch2/ispell/spell.h
index a3695113a1..ee86eac985 100644
--- a/contrib/tsearch2/ispell/spell.h
+++ b/contrib/tsearch2/ispell/spell.h
@@ -7,7 +7,7 @@
 
 #include "regis.h"
 #include "dict.h"
- 
+
 struct SPNode;
 
 
@@ -55,9 +55,9 @@ typedef struct aff_struct
 				isregis:1,
 				unused:1,
 				replen:16;
-	char		*mask;
-	char		*find;
-	char		*repl;
+	char	   *mask;
+	char	   *find;
+	char	   *repl;
 	union
 	{
 		regex_t		regex;
@@ -117,7 +117,7 @@ typedef struct
 
 }	IspellDict;
 
-TSLexeme	  *NINormalizeWord(IspellDict * Conf, char *word);
+TSLexeme   *NINormalizeWord(IspellDict * Conf, char *word);
 int			NIImportAffixes(IspellDict * Conf, const char *filename);
 int			NIImportDictionary(IspellDict * Conf, const char *filename);
 
diff --git a/contrib/tsearch2/prs_dcfg.c b/contrib/tsearch2/prs_dcfg.c
index af83b6506d..240aaa4497 100644
--- a/contrib/tsearch2/prs_dcfg.c
+++ b/contrib/tsearch2/prs_dcfg.c
@@ -73,8 +73,8 @@ parse_cfgdict(text *in, Map ** m)
 				ereport(ERROR,
 						(errcode(ERRCODE_SYNTAX_ERROR),
 						 errmsg("syntax error"),
-					 errdetail("Syntax error in position %d near \"%c\"",
-							   (int) (ptr - VARDATA(in)), *ptr)));
+						 errdetail("Syntax error in position %d near \"%c\"",
+								   (int) (ptr - VARDATA(in)), *ptr)));
 		}
 		else if (state == CS_INKEY)
 		{
@@ -92,8 +92,8 @@ parse_cfgdict(text *in, Map ** m)
 				ereport(ERROR,
 						(errcode(ERRCODE_SYNTAX_ERROR),
 						 errmsg("syntax error"),
-					 errdetail("Syntax error in position %d near \"%c\"",
-							   (int) (ptr - VARDATA(in)), *ptr)));
+						 errdetail("Syntax error in position %d near \"%c\"",
+								   (int) (ptr - VARDATA(in)), *ptr)));
 		}
 		else if (state == CS_WAITEQ)
 		{
@@ -103,8 +103,8 @@ parse_cfgdict(text *in, Map ** m)
 				ereport(ERROR,
 						(errcode(ERRCODE_SYNTAX_ERROR),
 						 errmsg("syntax error"),
-					 errdetail("Syntax error in position %d near \"%c\"",
-							   (int) (ptr - VARDATA(in)), *ptr)));
+						 errdetail("Syntax error in position %d near \"%c\"",
+								   (int) (ptr - VARDATA(in)), *ptr)));
 		}
 		else if (state == CS_WAITVALUE)
 		{
@@ -149,8 +149,8 @@ parse_cfgdict(text *in, Map ** m)
 				ereport(ERROR,
 						(errcode(ERRCODE_SYNTAX_ERROR),
 						 errmsg("syntax error"),
-					 errdetail("Syntax error in position %d near \"%c\"",
-							   (int) (ptr - VARDATA(in)), *ptr)));
+						 errdetail("Syntax error in position %d near \"%c\"",
+								   (int) (ptr - VARDATA(in)), *ptr)));
 		}
 		else if (state == CS_INESC)
 			state = CS_INVALUE;
diff --git a/contrib/tsearch2/query.c b/contrib/tsearch2/query.c
index 9681272925..d8b8d4c80d 100644
--- a/contrib/tsearch2/query.c
+++ b/contrib/tsearch2/query.c
@@ -265,7 +265,11 @@ pushval_morph(QPRS_STATE * state, int typeval, char *strval, int lenval, int2 we
 {
 	int4		count = 0;
 	PRSTEXT		prs;
-	uint32		variant, pos, cntvar=0, cntpos=0, cnt=0;
+	uint32		variant,
+				pos,
+				cntvar = 0,
+				cntpos = 0,
+				cnt = 0;
 
 	prs.lenwords = 32;
 	prs.curwords = 0;
@@ -274,39 +278,44 @@ pushval_morph(QPRS_STATE * state, int typeval, char *strval, int lenval, int2 we
 
 	parsetext_v2(findcfg(state->cfg_id), &prs, strval, lenval);
 
-	if ( prs.curwords>0 ) {
+	if (prs.curwords > 0)
+	{
 
-		while (count < prs.curwords) {
+		while (count < prs.curwords)
+		{
 			pos = prs.words[count].pos.pos;
-			cntvar=0;
-			while(count < prs.curwords && pos==prs.words[count].pos.pos) {
+			cntvar = 0;
+			while (count < prs.curwords && pos == prs.words[count].pos.pos)
+			{
 				variant = prs.words[count].nvariant;
 
-				cnt=0;
-				while(count < prs.curwords && pos==prs.words[count].pos.pos && variant==prs.words[count].nvariant)	{
-					
+				cnt = 0;
+				while (count < prs.curwords && pos == prs.words[count].pos.pos && variant == prs.words[count].nvariant)
+				{
+
 					pushval_asis(state, VAL, prs.words[count].word, prs.words[count].len, weight);
 					pfree(prs.words[count].word);
-					if ( cnt ) 
+					if (cnt)
 						pushquery(state, OPR, (int4) '&', 0, 0, 0);
 					cnt++;
 					count++;
 				}
 
-				if ( cntvar ) 
+				if (cntvar)
 					pushquery(state, OPR, (int4) '|', 0, 0, 0);
 				cntvar++;
 			}
 
-			if (cntpos) 
+			if (cntpos)
 				pushquery(state, OPR, (int4) '&', 0, 0, 0);
-		
+
 			cntpos++;
 		}
 
 		pfree(prs.words);
 
-	} else
+	}
+	else
 		pushval_asis(state, VALSTOP, NULL, 0, 0);
 }
 
diff --git a/contrib/tsearch2/rank.c b/contrib/tsearch2/rank.c
index 046b062b97..081b084087 100644
--- a/contrib/tsearch2/rank.c
+++ b/contrib/tsearch2/rank.c
@@ -45,6 +45,7 @@ static float weights[] = {0.1, 0.2, 0.4, 1.0};
 
 static float calc_rank_or(float *w, tsvector * t, QUERYTYPE * q);
 static float calc_rank_and(float *w, tsvector * t, QUERYTYPE * q);
+
 /*
  * Returns a weight of a word collocation
  */
@@ -115,44 +116,52 @@ find_wordentry(tsvector * t, QUERYTYPE * q, ITEM * item)
 }
 
 
-static char * SortAndUniqOperand=NULL;
+static char *SortAndUniqOperand = NULL;
 
 static int
-compareITEM( const void * a, const void * b ) {
-	if (  (*(ITEM**)a)->length == (*(ITEM**)b)->length )
-		return strncmp( SortAndUniqOperand + (*(ITEM**)a)->distance,
-				SortAndUniqOperand + (*(ITEM**)b)->distance,
-				(*(ITEM**)b)->length );
+compareITEM(const void *a, const void *b)
+{
+	if ((*(ITEM **) a)->length == (*(ITEM **) b)->length)
+		return strncmp(SortAndUniqOperand + (*(ITEM **) a)->distance,
+					   SortAndUniqOperand + (*(ITEM **) b)->distance,
+					   (*(ITEM **) b)->length);
 
-	return ((*(ITEM**)a)->length > (*(ITEM**)b)->length) ? 1 : -1;
+	return ((*(ITEM **) a)->length > (*(ITEM **) b)->length) ? 1 : -1;
 }
-         
-static ITEM**
-SortAndUniqItems( char *operand, ITEM *item, int *size ) {
-	ITEM   **res, **ptr, **prevptr;
 
-	ptr = res = (ITEM**) palloc( sizeof(ITEM*) * *size );
+static ITEM **
+SortAndUniqItems(char *operand, ITEM * item, int *size)
+{
+	ITEM	  **res,
+			  **ptr,
+			  **prevptr;
+
+	ptr = res = (ITEM **) palloc(sizeof(ITEM *) * *size);
 
-	while( (*size)-- ) {
-		if ( item->type == VAL ) {
+	while ((*size)--)
+	{
+		if (item->type == VAL)
+		{
 			*ptr = item;
 			ptr++;
-		}   
+		}
 		item++;
 	}
 
-	*size = ptr-res;
-	if ( *size < 2 )
+	*size = ptr - res;
+	if (*size < 2)
 		return res;
 
-	SortAndUniqOperand=operand;
-	qsort( res, *size, sizeof(ITEM**), compareITEM );
+	SortAndUniqOperand = operand;
+	qsort(res, *size, sizeof(ITEM **), compareITEM);
 
 	ptr = res + 1;
 	prevptr = res;
 
-	while( ptr - res < *size ) {
-		if ( compareITEM( (void*) ptr, (void*) prevptr ) != 0 ) {
+	while (ptr - res < *size)
+	{
+		if (compareITEM((void *) ptr, (void *) prevptr) != 0)
+		{
 			prevptr++;
 			*prevptr = *ptr;
 		}
@@ -183,18 +192,19 @@ calc_rank_and(float *w, tsvector * t, QUERYTYPE * q)
 				lenct,
 				dist;
 	float		res = -1.0;
-	ITEM	   **item;
-	int size = q->size;
+	ITEM	  **item;
+	int			size = q->size;
 
-	item = SortAndUniqItems( GETOPERAND(q), GETQUERY(q), &size);
-	if ( size < 2 ) {
+	item = SortAndUniqItems(GETOPERAND(q), GETQUERY(q), &size);
+	if (size < 2)
+	{
 		pfree(item);
 		return calc_rank_or(w, t, q);
-	} 
+	}
 	pos = (uint16 **) palloc(sizeof(uint16 *) * q->size);
 	memset(pos, 0, sizeof(uint16 *) * q->size);
 	*(uint16 *) POSNULL = lengthof(POSNULL) - 1;
-	WEP_SETPOS(POSNULL[1], MAXENTRYPOS-1);
+	WEP_SETPOS(POSNULL[1], MAXENTRYPOS - 1);
 
 	for (i = 0; i < size; i++)
 	{
@@ -220,7 +230,7 @@ calc_rank_and(float *w, tsvector * t, QUERYTYPE * q)
 			{
 				for (p = 0; p < lenct; p++)
 				{
-					dist = Abs((int)WEP_GETPOS(post[l]) - (int)WEP_GETPOS(ct[p]));
+					dist = Abs((int) WEP_GETPOS(post[l]) - (int) WEP_GETPOS(ct[p]));
 					if (dist || (dist == 0 && (pos[i] == (uint16 *) POSNULL || pos[k] == (uint16 *) POSNULL)))
 					{
 						float		curw;
@@ -248,11 +258,11 @@ calc_rank_or(float *w, tsvector * t, QUERYTYPE * q)
 				j,
 				i;
 	float		res = -1.0;
-	ITEM	   **item;
-	int	size = q->size;
+	ITEM	  **item;
+	int			size = q->size;
 
 	*(uint16 *) POSNULL = lengthof(POSNULL) - 1;
-	item = SortAndUniqItems( GETOPERAND(q), GETQUERY(q), &size);
+	item = SortAndUniqItems(GETOPERAND(q), GETQUERY(q), &size);
 
 	for (i = 0; i < size; i++)
 	{
@@ -279,7 +289,7 @@ calc_rank_or(float *w, tsvector * t, QUERYTYPE * q)
 				res = 1.0 - (1.0 - res) * (1.0 - wpos(post[j]));
 		}
 	}
-	pfree( item );
+	pfree(item);
 	return res;
 }
 
@@ -288,7 +298,7 @@ calc_rank(float *w, tsvector * t, QUERYTYPE * q, int4 method)
 {
 	ITEM	   *item = GETQUERY(q);
 	float		res = 0.0;
-	int 	   len;
+	int			len;
 
 	if (!t->size || !q->size)
 		return 0.0;
@@ -304,11 +314,12 @@ calc_rank(float *w, tsvector * t, QUERYTYPE * q, int4 method)
 		case 0:
 			break;
 		case 1:
-			res /= log( (float)(cnt_length(t)+1) ) / log(2.0);
+			res /= log((float) (cnt_length(t) + 1)) / log(2.0);
 			break;
 		case 2:
 			len = cnt_length(t);
-			if ( len > 0 )  res /= (float)len; 
+			if (len > 0)
+				res /= (float) len;
 			break;
 		default:
 			/* internal error */
@@ -406,7 +417,7 @@ checkcondition_DR(void *checkval, ITEM * val)
 
 	while (ptr - ((ChkDocR *) checkval)->doc < ((ChkDocR *) checkval)->len)
 	{
-		if ( val == ptr->item || compareITEM( &val, &(ptr->item) ) == 0 )
+		if (val == ptr->item || compareITEM(&val, &(ptr->item)) == 0)
 			return true;
 		ptr++;
 	}
@@ -496,12 +507,11 @@ Cover(DocRepresentation * doc, int len, QUERYTYPE * query, int *pos, int *p, int
 		ch.doc = f;
 		ch.len = (doc + lastpos) - f + 1;
 		*pos = f - doc + 1;
-		SortAndUniqOperand = GETOPERAND(query); 
+		SortAndUniqOperand = GETOPERAND(query);
 		if (TS_execute(GETQUERY(query), &ch, false, checkcondition_DR))
 		{
 			/*
-			 * elog(NOTICE,"OP:%d NP:%d P:%d Q:%d", *pos, lastpos, *p,
-			 * *q);
+			 * elog(NOTICE,"OP:%d NP:%d P:%d Q:%d", *pos, lastpos, *p, *q);
 			 */
 			return true;
 		}
@@ -611,11 +621,12 @@ rank_cd(PG_FUNCTION_ARGS)
 		case 0:
 			break;
 		case 1:
-			res /= log( (float)(cnt_length(txt)+1) );
+			res /= log((float) (cnt_length(txt) + 1));
 			break;
 		case 2:
 			len = cnt_length(txt);
-			if ( len > 0 )  res /= (float)len; 
+			if (len > 0)
+				res /= (float) len;
 			break;
 		default:
 			/* internal error */
@@ -638,7 +649,7 @@ rank_cd_def(PG_FUNCTION_ARGS)
 										Int32GetDatum(-1),
 										PG_GETARG_DATUM(0),
 										PG_GETARG_DATUM(1),
-										(PG_NARGS() == 3) ? PG_GETARG_DATUM(2) : Int32GetDatum(DEF_NORM_METHOD)
+	  (PG_NARGS() == 3) ? PG_GETARG_DATUM(2) : Int32GetDatum(DEF_NORM_METHOD)
 										));
 }
 
diff --git a/contrib/tsearch2/snowball/api.c b/contrib/tsearch2/snowball/api.c
index 9dd5a3b8fa..78e4fe0eef 100644
--- a/contrib/tsearch2/snowball/api.c
+++ b/contrib/tsearch2/snowball/api.c
@@ -1,69 +1,85 @@
 
-#include <stdlib.h> /* for calloc, free */
+#include <stdlib.h>				/* for calloc, free */
 #include "header.h"
 
-extern struct SN_env * SN_create_env(int S_size, int I_size, int B_size)
+extern struct SN_env *
+SN_create_env(int S_size, int I_size, int B_size)
 {
-    struct SN_env * z = (struct SN_env *) calloc(1, sizeof(struct SN_env));
-    if (z == NULL) return NULL;
-    z->p = create_s();
-    if (z->p == NULL) goto error;
-    if (S_size)
-    {
-        int i;
-        z->S = (symbol * *) calloc(S_size, sizeof(symbol *));
-        if (z->S == NULL) goto error;
+	struct SN_env *z = (struct SN_env *) calloc(1, sizeof(struct SN_env));
 
-        for (i = 0; i < S_size; i++)
-        {
-            z->S[i] = create_s();
-            if (z->S[i] == NULL) goto error;
-        }
-        z->S_size = S_size;
-    }
+	if (z == NULL)
+		return NULL;
+	z->p = create_s();
+	if (z->p == NULL)
+		goto error;
+	if (S_size)
+	{
+		int			i;
 
-    if (I_size)
-    {
-        z->I = (int *) calloc(I_size, sizeof(int));
-        if (z->I == NULL) goto error;
-        z->I_size = I_size;
-    }
+		z->S = (symbol * *) calloc(S_size, sizeof(symbol *));
+		if (z->S == NULL)
+			goto error;
 
-    if (B_size)
-    {
-        z->B = (symbol *) calloc(B_size, sizeof(symbol));
-        if (z->B == NULL) goto error;
-        z->B_size = B_size;
-    }
+		for (i = 0; i < S_size; i++)
+		{
+			z->S[i] = create_s();
+			if (z->S[i] == NULL)
+				goto error;
+		}
+		z->S_size = S_size;
+	}
 
-    return z;
+	if (I_size)
+	{
+		z->I = (int *) calloc(I_size, sizeof(int));
+		if (z->I == NULL)
+			goto error;
+		z->I_size = I_size;
+	}
+
+	if (B_size)
+	{
+		z->B = (symbol *) calloc(B_size, sizeof(symbol));
+		if (z->B == NULL)
+			goto error;
+		z->B_size = B_size;
+	}
+
+	return z;
 error:
-    SN_close_env(z);
-    return NULL;
+	SN_close_env(z);
+	return NULL;
 }
 
-extern void SN_close_env(struct SN_env * z)
+extern void
+SN_close_env(struct SN_env * z)
 {
-    if (z == NULL) return;
-    if (z->S_size)
-    {
-        int i;
-        for (i = 0; i < z->S_size; i++)
-        {
-            lose_s(z->S[i]);
-        }
-        free(z->S);
-    }
-    if (z->I_size) free(z->I);
-    if (z->B_size) free(z->B);
-    if (z->p) lose_s(z->p);
-    free(z);
+	if (z == NULL)
+		return;
+	if (z->S_size)
+	{
+		int			i;
+
+		for (i = 0; i < z->S_size; i++)
+		{
+			lose_s(z->S[i]);
+		}
+		free(z->S);
+	}
+	if (z->I_size)
+		free(z->I);
+	if (z->B_size)
+		free(z->B);
+	if (z->p)
+		lose_s(z->p);
+	free(z);
 }
 
-extern int SN_set_current(struct SN_env * z, int size, const symbol * s)
+extern int
+SN_set_current(struct SN_env * z, int size, const symbol * s)
 {
-    int err = replace_s(z, 0, z->l, size, s, NULL);
-    z->c = 0;
-    return err;
-}
+	int			err = replace_s(z, 0, z->l, size, s, NULL);
 
+	z->c = 0;
+	return err;
+}
diff --git a/contrib/tsearch2/snowball/api.h b/contrib/tsearch2/snowball/api.h
index adc2282e32..fb0a69469c 100644
--- a/contrib/tsearch2/snowball/api.h
+++ b/contrib/tsearch2/snowball/api.h
@@ -11,17 +11,24 @@ typedef unsigned char symbol;
 
 */
 
-struct SN_env {
-    symbol * p;
-    int c; int a; int l; int lb; int bra; int ket;
-    int S_size; int I_size; int B_size;
-    symbol * * S;
-    int * I;
-    symbol * B;
+struct SN_env
+{
+	symbol	   *p;
+	int			c;
+	int			a;
+	int			l;
+	int			lb;
+	int			bra;
+	int			ket;
+	int			S_size;
+	int			I_size;
+	int			B_size;
+	symbol	   **S;
+	int		   *I;
+	symbol	   *B;
 };
 
-extern struct SN_env * SN_create_env(int S_size, int I_size, int B_size);
+extern struct SN_env *SN_create_env(int S_size, int I_size, int B_size);
 extern void SN_close_env(struct SN_env * z);
 
-extern int SN_set_current(struct SN_env * z, int size, const symbol * s);
-
+extern int	SN_set_current(struct SN_env * z, int size, const symbol * s);
diff --git a/contrib/tsearch2/snowball/english_stem.c b/contrib/tsearch2/snowball/english_stem.c
index 54eb25f86f..de4f99114f 100644
--- a/contrib/tsearch2/snowball/english_stem.c
+++ b/contrib/tsearch2/snowball/english_stem.c
@@ -3,1154 +3,1618 @@
 
 #include "header.h"
 
-extern int english_ISO_8859_1_stem(struct SN_env * z);
-static int r_exception2(struct SN_env * z);
-static int r_exception1(struct SN_env * z);
-static int r_Step_5(struct SN_env * z);
-static int r_Step_4(struct SN_env * z);
-static int r_Step_3(struct SN_env * z);
-static int r_Step_2(struct SN_env * z);
-static int r_Step_1c(struct SN_env * z);
-static int r_Step_1b(struct SN_env * z);
-static int r_Step_1a(struct SN_env * z);
-static int r_R2(struct SN_env * z);
-static int r_R1(struct SN_env * z);
-static int r_shortv(struct SN_env * z);
-static int r_mark_regions(struct SN_env * z);
-static int r_postlude(struct SN_env * z);
-static int r_prelude(struct SN_env * z);
-
-extern struct SN_env * english_ISO_8859_1_create_env(void);
+extern int	english_ISO_8859_1_stem(struct SN_env * z);
+static int	r_exception2(struct SN_env * z);
+static int	r_exception1(struct SN_env * z);
+static int	r_Step_5(struct SN_env * z);
+static int	r_Step_4(struct SN_env * z);
+static int	r_Step_3(struct SN_env * z);
+static int	r_Step_2(struct SN_env * z);
+static int	r_Step_1c(struct SN_env * z);
+static int	r_Step_1b(struct SN_env * z);
+static int	r_Step_1a(struct SN_env * z);
+static int	r_R2(struct SN_env * z);
+static int	r_R1(struct SN_env * z);
+static int	r_shortv(struct SN_env * z);
+static int	r_mark_regions(struct SN_env * z);
+static int	r_postlude(struct SN_env * z);
+static int	r_prelude(struct SN_env * z);
+
+extern struct SN_env *english_ISO_8859_1_create_env(void);
 extern void english_ISO_8859_1_close_env(struct SN_env * z);
 
-static symbol s_0_0[6] = { 'c', 'o', 'm', 'm', 'u', 'n' };
-static symbol s_0_1[5] = { 'g', 'e', 'n', 'e', 'r' };
+static symbol s_0_0[6] = {'c', 'o', 'm', 'm', 'u', 'n'};
+static symbol s_0_1[5] = {'g', 'e', 'n', 'e', 'r'};
 
 static struct among a_0[2] =
 {
-/*  0 */ { 6, s_0_0, -1, -1, 0},
-/*  1 */ { 5, s_0_1, -1, -1, 0}
+	 /*  0 */ {6, s_0_0, -1, -1, 0},
+	 /*  1 */ {5, s_0_1, -1, -1, 0}
 };
 
-static symbol s_1_0[1] = { '\'' };
-static symbol s_1_1[3] = { '\'', 's', '\'' };
-static symbol s_1_2[2] = { '\'', 's' };
+static symbol s_1_0[1] = {'\''};
+static symbol s_1_1[3] = {'\'', 's', '\''};
+static symbol s_1_2[2] = {'\'', 's'};
 
 static struct among a_1[3] =
 {
-/*  0 */ { 1, s_1_0, -1, 1, 0},
-/*  1 */ { 3, s_1_1, 0, 1, 0},
-/*  2 */ { 2, s_1_2, -1, 1, 0}
+	 /*  0 */ {1, s_1_0, -1, 1, 0},
+	 /*  1 */ {3, s_1_1, 0, 1, 0},
+	 /*  2 */ {2, s_1_2, -1, 1, 0}
 };
 
-static symbol s_2_0[3] = { 'i', 'e', 'd' };
-static symbol s_2_1[1] = { 's' };
-static symbol s_2_2[3] = { 'i', 'e', 's' };
-static symbol s_2_3[4] = { 's', 's', 'e', 's' };
-static symbol s_2_4[2] = { 's', 's' };
-static symbol s_2_5[2] = { 'u', 's' };
+static symbol s_2_0[3] = {'i', 'e', 'd'};
+static symbol s_2_1[1] = {'s'};
+static symbol s_2_2[3] = {'i', 'e', 's'};
+static symbol s_2_3[4] = {'s', 's', 'e', 's'};
+static symbol s_2_4[2] = {'s', 's'};
+static symbol s_2_5[2] = {'u', 's'};
 
 static struct among a_2[6] =
 {
-/*  0 */ { 3, s_2_0, -1, 2, 0},
-/*  1 */ { 1, s_2_1, -1, 3, 0},
-/*  2 */ { 3, s_2_2, 1, 2, 0},
-/*  3 */ { 4, s_2_3, 1, 1, 0},
-/*  4 */ { 2, s_2_4, 1, -1, 0},
-/*  5 */ { 2, s_2_5, 1, -1, 0}
+	 /*  0 */ {3, s_2_0, -1, 2, 0},
+	 /*  1 */ {1, s_2_1, -1, 3, 0},
+	 /*  2 */ {3, s_2_2, 1, 2, 0},
+	 /*  3 */ {4, s_2_3, 1, 1, 0},
+	 /*  4 */ {2, s_2_4, 1, -1, 0},
+	 /*  5 */ {2, s_2_5, 1, -1, 0}
 };
 
-static symbol s_3_1[2] = { 'b', 'b' };
-static symbol s_3_2[2] = { 'd', 'd' };
-static symbol s_3_3[2] = { 'f', 'f' };
-static symbol s_3_4[2] = { 'g', 'g' };
-static symbol s_3_5[2] = { 'b', 'l' };
-static symbol s_3_6[2] = { 'm', 'm' };
-static symbol s_3_7[2] = { 'n', 'n' };
-static symbol s_3_8[2] = { 'p', 'p' };
-static symbol s_3_9[2] = { 'r', 'r' };
-static symbol s_3_10[2] = { 'a', 't' };
-static symbol s_3_11[2] = { 't', 't' };
-static symbol s_3_12[2] = { 'i', 'z' };
+static symbol s_3_1[2] = {'b', 'b'};
+static symbol s_3_2[2] = {'d', 'd'};
+static symbol s_3_3[2] = {'f', 'f'};
+static symbol s_3_4[2] = {'g', 'g'};
+static symbol s_3_5[2] = {'b', 'l'};
+static symbol s_3_6[2] = {'m', 'm'};
+static symbol s_3_7[2] = {'n', 'n'};
+static symbol s_3_8[2] = {'p', 'p'};
+static symbol s_3_9[2] = {'r', 'r'};
+static symbol s_3_10[2] = {'a', 't'};
+static symbol s_3_11[2] = {'t', 't'};
+static symbol s_3_12[2] = {'i', 'z'};
 
 static struct among a_3[13] =
 {
-/*  0 */ { 0, 0, -1, 3, 0},
-/*  1 */ { 2, s_3_1, 0, 2, 0},
-/*  2 */ { 2, s_3_2, 0, 2, 0},
-/*  3 */ { 2, s_3_3, 0, 2, 0},
-/*  4 */ { 2, s_3_4, 0, 2, 0},
-/*  5 */ { 2, s_3_5, 0, 1, 0},
-/*  6 */ { 2, s_3_6, 0, 2, 0},
-/*  7 */ { 2, s_3_7, 0, 2, 0},
-/*  8 */ { 2, s_3_8, 0, 2, 0},
-/*  9 */ { 2, s_3_9, 0, 2, 0},
-/* 10 */ { 2, s_3_10, 0, 1, 0},
-/* 11 */ { 2, s_3_11, 0, 2, 0},
-/* 12 */ { 2, s_3_12, 0, 1, 0}
+	 /*  0 */ {0, 0, -1, 3, 0},
+	 /*  1 */ {2, s_3_1, 0, 2, 0},
+	 /*  2 */ {2, s_3_2, 0, 2, 0},
+	 /*  3 */ {2, s_3_3, 0, 2, 0},
+	 /*  4 */ {2, s_3_4, 0, 2, 0},
+	 /*  5 */ {2, s_3_5, 0, 1, 0},
+	 /*  6 */ {2, s_3_6, 0, 2, 0},
+	 /*  7 */ {2, s_3_7, 0, 2, 0},
+	 /*  8 */ {2, s_3_8, 0, 2, 0},
+	 /*  9 */ {2, s_3_9, 0, 2, 0},
+	 /* 10 */ {2, s_3_10, 0, 1, 0},
+	 /* 11 */ {2, s_3_11, 0, 2, 0},
+	 /* 12 */ {2, s_3_12, 0, 1, 0}
 };
 
-static symbol s_4_0[2] = { 'e', 'd' };
-static symbol s_4_1[3] = { 'e', 'e', 'd' };
-static symbol s_4_2[3] = { 'i', 'n', 'g' };
-static symbol s_4_3[4] = { 'e', 'd', 'l', 'y' };
-static symbol s_4_4[5] = { 'e', 'e', 'd', 'l', 'y' };
-static symbol s_4_5[5] = { 'i', 'n', 'g', 'l', 'y' };
+static symbol s_4_0[2] = {'e', 'd'};
+static symbol s_4_1[3] = {'e', 'e', 'd'};
+static symbol s_4_2[3] = {'i', 'n', 'g'};
+static symbol s_4_3[4] = {'e', 'd', 'l', 'y'};
+static symbol s_4_4[5] = {'e', 'e', 'd', 'l', 'y'};
+static symbol s_4_5[5] = {'i', 'n', 'g', 'l', 'y'};
 
 static struct among a_4[6] =
 {
-/*  0 */ { 2, s_4_0, -1, 2, 0},
-/*  1 */ { 3, s_4_1, 0, 1, 0},
-/*  2 */ { 3, s_4_2, -1, 2, 0},
-/*  3 */ { 4, s_4_3, -1, 2, 0},
-/*  4 */ { 5, s_4_4, 3, 1, 0},
-/*  5 */ { 5, s_4_5, -1, 2, 0}
+	 /*  0 */ {2, s_4_0, -1, 2, 0},
+	 /*  1 */ {3, s_4_1, 0, 1, 0},
+	 /*  2 */ {3, s_4_2, -1, 2, 0},
+	 /*  3 */ {4, s_4_3, -1, 2, 0},
+	 /*  4 */ {5, s_4_4, 3, 1, 0},
+	 /*  5 */ {5, s_4_5, -1, 2, 0}
 };
 
-static symbol s_5_0[4] = { 'a', 'n', 'c', 'i' };
-static symbol s_5_1[4] = { 'e', 'n', 'c', 'i' };
-static symbol s_5_2[3] = { 'o', 'g', 'i' };
-static symbol s_5_3[2] = { 'l', 'i' };
-static symbol s_5_4[3] = { 'b', 'l', 'i' };
-static symbol s_5_5[4] = { 'a', 'b', 'l', 'i' };
-static symbol s_5_6[4] = { 'a', 'l', 'l', 'i' };
-static symbol s_5_7[5] = { 'f', 'u', 'l', 'l', 'i' };
-static symbol s_5_8[6] = { 'l', 'e', 's', 's', 'l', 'i' };
-static symbol s_5_9[5] = { 'o', 'u', 's', 'l', 'i' };
-static symbol s_5_10[5] = { 'e', 'n', 't', 'l', 'i' };
-static symbol s_5_11[5] = { 'a', 'l', 'i', 't', 'i' };
-static symbol s_5_12[6] = { 'b', 'i', 'l', 'i', 't', 'i' };
-static symbol s_5_13[5] = { 'i', 'v', 'i', 't', 'i' };
-static symbol s_5_14[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_5_15[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_5_16[5] = { 'a', 'l', 'i', 's', 'm' };
-static symbol s_5_17[5] = { 'a', 't', 'i', 'o', 'n' };
-static symbol s_5_18[7] = { 'i', 'z', 'a', 't', 'i', 'o', 'n' };
-static symbol s_5_19[4] = { 'i', 'z', 'e', 'r' };
-static symbol s_5_20[4] = { 'a', 't', 'o', 'r' };
-static symbol s_5_21[7] = { 'i', 'v', 'e', 'n', 'e', 's', 's' };
-static symbol s_5_22[7] = { 'f', 'u', 'l', 'n', 'e', 's', 's' };
-static symbol s_5_23[7] = { 'o', 'u', 's', 'n', 'e', 's', 's' };
+static symbol s_5_0[4] = {'a', 'n', 'c', 'i'};
+static symbol s_5_1[4] = {'e', 'n', 'c', 'i'};
+static symbol s_5_2[3] = {'o', 'g', 'i'};
+static symbol s_5_3[2] = {'l', 'i'};
+static symbol s_5_4[3] = {'b', 'l', 'i'};
+static symbol s_5_5[4] = {'a', 'b', 'l', 'i'};
+static symbol s_5_6[4] = {'a', 'l', 'l', 'i'};
+static symbol s_5_7[5] = {'f', 'u', 'l', 'l', 'i'};
+static symbol s_5_8[6] = {'l', 'e', 's', 's', 'l', 'i'};
+static symbol s_5_9[5] = {'o', 'u', 's', 'l', 'i'};
+static symbol s_5_10[5] = {'e', 'n', 't', 'l', 'i'};
+static symbol s_5_11[5] = {'a', 'l', 'i', 't', 'i'};
+static symbol s_5_12[6] = {'b', 'i', 'l', 'i', 't', 'i'};
+static symbol s_5_13[5] = {'i', 'v', 'i', 't', 'i'};
+static symbol s_5_14[6] = {'t', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_5_15[7] = {'a', 't', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_5_16[5] = {'a', 'l', 'i', 's', 'm'};
+static symbol s_5_17[5] = {'a', 't', 'i', 'o', 'n'};
+static symbol s_5_18[7] = {'i', 'z', 'a', 't', 'i', 'o', 'n'};
+static symbol s_5_19[4] = {'i', 'z', 'e', 'r'};
+static symbol s_5_20[4] = {'a', 't', 'o', 'r'};
+static symbol s_5_21[7] = {'i', 'v', 'e', 'n', 'e', 's', 's'};
+static symbol s_5_22[7] = {'f', 'u', 'l', 'n', 'e', 's', 's'};
+static symbol s_5_23[7] = {'o', 'u', 's', 'n', 'e', 's', 's'};
 
 static struct among a_5[24] =
 {
-/*  0 */ { 4, s_5_0, -1, 3, 0},
-/*  1 */ { 4, s_5_1, -1, 2, 0},
-/*  2 */ { 3, s_5_2, -1, 13, 0},
-/*  3 */ { 2, s_5_3, -1, 16, 0},
-/*  4 */ { 3, s_5_4, 3, 12, 0},
-/*  5 */ { 4, s_5_5, 4, 4, 0},
-/*  6 */ { 4, s_5_6, 3, 8, 0},
-/*  7 */ { 5, s_5_7, 3, 14, 0},
-/*  8 */ { 6, s_5_8, 3, 15, 0},
-/*  9 */ { 5, s_5_9, 3, 10, 0},
-/* 10 */ { 5, s_5_10, 3, 5, 0},
-/* 11 */ { 5, s_5_11, -1, 8, 0},
-/* 12 */ { 6, s_5_12, -1, 12, 0},
-/* 13 */ { 5, s_5_13, -1, 11, 0},
-/* 14 */ { 6, s_5_14, -1, 1, 0},
-/* 15 */ { 7, s_5_15, 14, 7, 0},
-/* 16 */ { 5, s_5_16, -1, 8, 0},
-/* 17 */ { 5, s_5_17, -1, 7, 0},
-/* 18 */ { 7, s_5_18, 17, 6, 0},
-/* 19 */ { 4, s_5_19, -1, 6, 0},
-/* 20 */ { 4, s_5_20, -1, 7, 0},
-/* 21 */ { 7, s_5_21, -1, 11, 0},
-/* 22 */ { 7, s_5_22, -1, 9, 0},
-/* 23 */ { 7, s_5_23, -1, 10, 0}
+	 /*  0 */ {4, s_5_0, -1, 3, 0},
+	 /*  1 */ {4, s_5_1, -1, 2, 0},
+	 /*  2 */ {3, s_5_2, -1, 13, 0},
+	 /*  3 */ {2, s_5_3, -1, 16, 0},
+	 /*  4 */ {3, s_5_4, 3, 12, 0},
+	 /*  5 */ {4, s_5_5, 4, 4, 0},
+	 /*  6 */ {4, s_5_6, 3, 8, 0},
+	 /*  7 */ {5, s_5_7, 3, 14, 0},
+	 /*  8 */ {6, s_5_8, 3, 15, 0},
+	 /*  9 */ {5, s_5_9, 3, 10, 0},
+	 /* 10 */ {5, s_5_10, 3, 5, 0},
+	 /* 11 */ {5, s_5_11, -1, 8, 0},
+	 /* 12 */ {6, s_5_12, -1, 12, 0},
+	 /* 13 */ {5, s_5_13, -1, 11, 0},
+	 /* 14 */ {6, s_5_14, -1, 1, 0},
+	 /* 15 */ {7, s_5_15, 14, 7, 0},
+	 /* 16 */ {5, s_5_16, -1, 8, 0},
+	 /* 17 */ {5, s_5_17, -1, 7, 0},
+	 /* 18 */ {7, s_5_18, 17, 6, 0},
+	 /* 19 */ {4, s_5_19, -1, 6, 0},
+	 /* 20 */ {4, s_5_20, -1, 7, 0},
+	 /* 21 */ {7, s_5_21, -1, 11, 0},
+	 /* 22 */ {7, s_5_22, -1, 9, 0},
+	 /* 23 */ {7, s_5_23, -1, 10, 0}
 };
 
-static symbol s_6_0[5] = { 'i', 'c', 'a', 't', 'e' };
-static symbol s_6_1[5] = { 'a', 't', 'i', 'v', 'e' };
-static symbol s_6_2[5] = { 'a', 'l', 'i', 'z', 'e' };
-static symbol s_6_3[5] = { 'i', 'c', 'i', 't', 'i' };
-static symbol s_6_4[4] = { 'i', 'c', 'a', 'l' };
-static symbol s_6_5[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_6_6[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
-static symbol s_6_7[3] = { 'f', 'u', 'l' };
-static symbol s_6_8[4] = { 'n', 'e', 's', 's' };
+static symbol s_6_0[5] = {'i', 'c', 'a', 't', 'e'};
+static symbol s_6_1[5] = {'a', 't', 'i', 'v', 'e'};
+static symbol s_6_2[5] = {'a', 'l', 'i', 'z', 'e'};
+static symbol s_6_3[5] = {'i', 'c', 'i', 't', 'i'};
+static symbol s_6_4[4] = {'i', 'c', 'a', 'l'};
+static symbol s_6_5[6] = {'t', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_6_6[7] = {'a', 't', 'i', 'o', 'n', 'a', 'l'};
+static symbol s_6_7[3] = {'f', 'u', 'l'};
+static symbol s_6_8[4] = {'n', 'e', 's', 's'};
 
 static struct among a_6[9] =
 {
-/*  0 */ { 5, s_6_0, -1, 4, 0},
-/*  1 */ { 5, s_6_1, -1, 6, 0},
-/*  2 */ { 5, s_6_2, -1, 3, 0},
-/*  3 */ { 5, s_6_3, -1, 4, 0},
-/*  4 */ { 4, s_6_4, -1, 4, 0},
-/*  5 */ { 6, s_6_5, -1, 1, 0},
-/*  6 */ { 7, s_6_6, 5, 2, 0},
-/*  7 */ { 3, s_6_7, -1, 5, 0},
-/*  8 */ { 4, s_6_8, -1, 5, 0}
+	 /*  0 */ {5, s_6_0, -1, 4, 0},
+	 /*  1 */ {5, s_6_1, -1, 6, 0},
+	 /*  2 */ {5, s_6_2, -1, 3, 0},
+	 /*  3 */ {5, s_6_3, -1, 4, 0},
+	 /*  4 */ {4, s_6_4, -1, 4, 0},
+	 /*  5 */ {6, s_6_5, -1, 1, 0},
+	 /*  6 */ {7, s_6_6, 5, 2, 0},
+	 /*  7 */ {3, s_6_7, -1, 5, 0},
+	 /*  8 */ {4, s_6_8, -1, 5, 0}
 };
 
-static symbol s_7_0[2] = { 'i', 'c' };
-static symbol s_7_1[4] = { 'a', 'n', 'c', 'e' };
-static symbol s_7_2[4] = { 'e', 'n', 'c', 'e' };
-static symbol s_7_3[4] = { 'a', 'b', 'l', 'e' };
-static symbol s_7_4[4] = { 'i', 'b', 'l', 'e' };
-static symbol s_7_5[3] = { 'a', 't', 'e' };
-static symbol s_7_6[3] = { 'i', 'v', 'e' };
-static symbol s_7_7[3] = { 'i', 'z', 'e' };
-static symbol s_7_8[3] = { 'i', 't', 'i' };
-static symbol s_7_9[2] = { 'a', 'l' };
-static symbol s_7_10[3] = { 'i', 's', 'm' };
-static symbol s_7_11[3] = { 'i', 'o', 'n' };
-static symbol s_7_12[2] = { 'e', 'r' };
-static symbol s_7_13[3] = { 'o', 'u', 's' };
-static symbol s_7_14[3] = { 'a', 'n', 't' };
-static symbol s_7_15[3] = { 'e', 'n', 't' };
-static symbol s_7_16[4] = { 'm', 'e', 'n', 't' };
-static symbol s_7_17[5] = { 'e', 'm', 'e', 'n', 't' };
+static symbol s_7_0[2] = {'i', 'c'};
+static symbol s_7_1[4] = {'a', 'n', 'c', 'e'};
+static symbol s_7_2[4] = {'e', 'n', 'c', 'e'};
+static symbol s_7_3[4] = {'a', 'b', 'l', 'e'};
+static symbol s_7_4[4] = {'i', 'b', 'l', 'e'};
+static symbol s_7_5[3] = {'a', 't', 'e'};
+static symbol s_7_6[3] = {'i', 'v', 'e'};
+static symbol s_7_7[3] = {'i', 'z', 'e'};
+static symbol s_7_8[3] = {'i', 't', 'i'};
+static symbol s_7_9[2] = {'a', 'l'};
+static symbol s_7_10[3] = {'i', 's', 'm'};
+static symbol s_7_11[3] = {'i', 'o', 'n'};
+static symbol s_7_12[2] = {'e', 'r'};
+static symbol s_7_13[3] = {'o', 'u', 's'};
+static symbol s_7_14[3] = {'a', 'n', 't'};
+static symbol s_7_15[3] = {'e', 'n', 't'};
+static symbol s_7_16[4] = {'m', 'e', 'n', 't'};
+static symbol s_7_17[5] = {'e', 'm', 'e', 'n', 't'};
 
 static struct among a_7[18] =
 {
-/*  0 */ { 2, s_7_0, -1, 1, 0},
-/*  1 */ { 4, s_7_1, -1, 1, 0},
-/*  2 */ { 4, s_7_2, -1, 1, 0},
-/*  3 */ { 4, s_7_3, -1, 1, 0},
-/*  4 */ { 4, s_7_4, -1, 1, 0},
-/*  5 */ { 3, s_7_5, -1, 1, 0},
-/*  6 */ { 3, s_7_6, -1, 1, 0},
-/*  7 */ { 3, s_7_7, -1, 1, 0},
-/*  8 */ { 3, s_7_8, -1, 1, 0},
-/*  9 */ { 2, s_7_9, -1, 1, 0},
-/* 10 */ { 3, s_7_10, -1, 1, 0},
-/* 11 */ { 3, s_7_11, -1, 2, 0},
-/* 12 */ { 2, s_7_12, -1, 1, 0},
-/* 13 */ { 3, s_7_13, -1, 1, 0},
-/* 14 */ { 3, s_7_14, -1, 1, 0},
-/* 15 */ { 3, s_7_15, -1, 1, 0},
-/* 16 */ { 4, s_7_16, 15, 1, 0},
-/* 17 */ { 5, s_7_17, 16, 1, 0}
+	 /*  0 */ {2, s_7_0, -1, 1, 0},
+	 /*  1 */ {4, s_7_1, -1, 1, 0},
+	 /*  2 */ {4, s_7_2, -1, 1, 0},
+	 /*  3 */ {4, s_7_3, -1, 1, 0},
+	 /*  4 */ {4, s_7_4, -1, 1, 0},
+	 /*  5 */ {3, s_7_5, -1, 1, 0},
+	 /*  6 */ {3, s_7_6, -1, 1, 0},
+	 /*  7 */ {3, s_7_7, -1, 1, 0},
+	 /*  8 */ {3, s_7_8, -1, 1, 0},
+	 /*  9 */ {2, s_7_9, -1, 1, 0},
+	 /* 10 */ {3, s_7_10, -1, 1, 0},
+	 /* 11 */ {3, s_7_11, -1, 2, 0},
+	 /* 12 */ {2, s_7_12, -1, 1, 0},
+	 /* 13 */ {3, s_7_13, -1, 1, 0},
+	 /* 14 */ {3, s_7_14, -1, 1, 0},
+	 /* 15 */ {3, s_7_15, -1, 1, 0},
+	 /* 16 */ {4, s_7_16, 15, 1, 0},
+	 /* 17 */ {5, s_7_17, 16, 1, 0}
 };
 
-static symbol s_8_0[1] = { 'e' };
-static symbol s_8_1[1] = { 'l' };
+static symbol s_8_0[1] = {'e'};
+static symbol s_8_1[1] = {'l'};
 
 static struct among a_8[2] =
 {
-/*  0 */ { 1, s_8_0, -1, 1, 0},
-/*  1 */ { 1, s_8_1, -1, 2, 0}
+	 /*  0 */ {1, s_8_0, -1, 1, 0},
+	 /*  1 */ {1, s_8_1, -1, 2, 0}
 };
 
-static symbol s_9_0[7] = { 's', 'u', 'c', 'c', 'e', 'e', 'd' };
-static symbol s_9_1[7] = { 'p', 'r', 'o', 'c', 'e', 'e', 'd' };
-static symbol s_9_2[6] = { 'e', 'x', 'c', 'e', 'e', 'd' };
-static symbol s_9_3[7] = { 'c', 'a', 'n', 'n', 'i', 'n', 'g' };
-static symbol s_9_4[6] = { 'i', 'n', 'n', 'i', 'n', 'g' };
-static symbol s_9_5[7] = { 'e', 'a', 'r', 'r', 'i', 'n', 'g' };
-static symbol s_9_6[7] = { 'h', 'e', 'r', 'r', 'i', 'n', 'g' };
-static symbol s_9_7[6] = { 'o', 'u', 't', 'i', 'n', 'g' };
+static symbol s_9_0[7] = {'s', 'u', 'c', 'c', 'e', 'e', 'd'};
+static symbol s_9_1[7] = {'p', 'r', 'o', 'c', 'e', 'e', 'd'};
+static symbol s_9_2[6] = {'e', 'x', 'c', 'e', 'e', 'd'};
+static symbol s_9_3[7] = {'c', 'a', 'n', 'n', 'i', 'n', 'g'};
+static symbol s_9_4[6] = {'i', 'n', 'n', 'i', 'n', 'g'};
+static symbol s_9_5[7] = {'e', 'a', 'r', 'r', 'i', 'n', 'g'};
+static symbol s_9_6[7] = {'h', 'e', 'r', 'r', 'i', 'n', 'g'};
+static symbol s_9_7[6] = {'o', 'u', 't', 'i', 'n', 'g'};
 
 static struct among a_9[8] =
 {
-/*  0 */ { 7, s_9_0, -1, -1, 0},
-/*  1 */ { 7, s_9_1, -1, -1, 0},
-/*  2 */ { 6, s_9_2, -1, -1, 0},
-/*  3 */ { 7, s_9_3, -1, -1, 0},
-/*  4 */ { 6, s_9_4, -1, -1, 0},
-/*  5 */ { 7, s_9_5, -1, -1, 0},
-/*  6 */ { 7, s_9_6, -1, -1, 0},
-/*  7 */ { 6, s_9_7, -1, -1, 0}
+	 /*  0 */ {7, s_9_0, -1, -1, 0},
+	 /*  1 */ {7, s_9_1, -1, -1, 0},
+	 /*  2 */ {6, s_9_2, -1, -1, 0},
+	 /*  3 */ {7, s_9_3, -1, -1, 0},
+	 /*  4 */ {6, s_9_4, -1, -1, 0},
+	 /*  5 */ {7, s_9_5, -1, -1, 0},
+	 /*  6 */ {7, s_9_6, -1, -1, 0},
+	 /*  7 */ {6, s_9_7, -1, -1, 0}
 };
 
-static symbol s_10_0[5] = { 'a', 'n', 'd', 'e', 's' };
-static symbol s_10_1[5] = { 'a', 't', 'l', 'a', 's' };
-static symbol s_10_2[4] = { 'b', 'i', 'a', 's' };
-static symbol s_10_3[6] = { 'c', 'o', 's', 'm', 'o', 's' };
-static symbol s_10_4[5] = { 'd', 'y', 'i', 'n', 'g' };
-static symbol s_10_5[5] = { 'e', 'a', 'r', 'l', 'y' };
-static symbol s_10_6[6] = { 'g', 'e', 'n', 't', 'l', 'y' };
-static symbol s_10_7[4] = { 'h', 'o', 'w', 'e' };
-static symbol s_10_8[4] = { 'i', 'd', 'l', 'y' };
-static symbol s_10_9[5] = { 'l', 'y', 'i', 'n', 'g' };
-static symbol s_10_10[4] = { 'n', 'e', 'w', 's' };
-static symbol s_10_11[4] = { 'o', 'n', 'l', 'y' };
-static symbol s_10_12[6] = { 's', 'i', 'n', 'g', 'l', 'y' };
-static symbol s_10_13[5] = { 's', 'k', 'i', 'e', 's' };
-static symbol s_10_14[4] = { 's', 'k', 'i', 's' };
-static symbol s_10_15[3] = { 's', 'k', 'y' };
-static symbol s_10_16[5] = { 't', 'y', 'i', 'n', 'g' };
-static symbol s_10_17[4] = { 'u', 'g', 'l', 'y' };
+static symbol s_10_0[5] = {'a', 'n', 'd', 'e', 's'};
+static symbol s_10_1[5] = {'a', 't', 'l', 'a', 's'};
+static symbol s_10_2[4] = {'b', 'i', 'a', 's'};
+static symbol s_10_3[6] = {'c', 'o', 's', 'm', 'o', 's'};
+static symbol s_10_4[5] = {'d', 'y', 'i', 'n', 'g'};
+static symbol s_10_5[5] = {'e', 'a', 'r', 'l', 'y'};
+static symbol s_10_6[6] = {'g', 'e', 'n', 't', 'l', 'y'};
+static symbol s_10_7[4] = {'h', 'o', 'w', 'e'};
+static symbol s_10_8[4] = {'i', 'd', 'l', 'y'};
+static symbol s_10_9[5] = {'l', 'y', 'i', 'n', 'g'};
+static symbol s_10_10[4] = {'n', 'e', 'w', 's'};
+static symbol s_10_11[4] = {'o', 'n', 'l', 'y'};
+static symbol s_10_12[6] = {'s', 'i', 'n', 'g', 'l', 'y'};
+static symbol s_10_13[5] = {'s', 'k', 'i', 'e', 's'};
+static symbol s_10_14[4] = {'s', 'k', 'i', 's'};
+static symbol s_10_15[3] = {'s', 'k', 'y'};
+static symbol s_10_16[5] = {'t', 'y', 'i', 'n', 'g'};
+static symbol s_10_17[4] = {'u', 'g', 'l', 'y'};
 
 static struct among a_10[18] =
 {
-/*  0 */ { 5, s_10_0, -1, -1, 0},
-/*  1 */ { 5, s_10_1, -1, -1, 0},
-/*  2 */ { 4, s_10_2, -1, -1, 0},
-/*  3 */ { 6, s_10_3, -1, -1, 0},
-/*  4 */ { 5, s_10_4, -1, 3, 0},
-/*  5 */ { 5, s_10_5, -1, 9, 0},
-/*  6 */ { 6, s_10_6, -1, 7, 0},
-/*  7 */ { 4, s_10_7, -1, -1, 0},
-/*  8 */ { 4, s_10_8, -1, 6, 0},
-/*  9 */ { 5, s_10_9, -1, 4, 0},
-/* 10 */ { 4, s_10_10, -1, -1, 0},
-/* 11 */ { 4, s_10_11, -1, 10, 0},
-/* 12 */ { 6, s_10_12, -1, 11, 0},
-/* 13 */ { 5, s_10_13, -1, 2, 0},
-/* 14 */ { 4, s_10_14, -1, 1, 0},
-/* 15 */ { 3, s_10_15, -1, -1, 0},
-/* 16 */ { 5, s_10_16, -1, 5, 0},
-/* 17 */ { 4, s_10_17, -1, 8, 0}
+	 /*  0 */ {5, s_10_0, -1, -1, 0},
+	 /*  1 */ {5, s_10_1, -1, -1, 0},
+	 /*  2 */ {4, s_10_2, -1, -1, 0},
+	 /*  3 */ {6, s_10_3, -1, -1, 0},
+	 /*  4 */ {5, s_10_4, -1, 3, 0},
+	 /*  5 */ {5, s_10_5, -1, 9, 0},
+	 /*  6 */ {6, s_10_6, -1, 7, 0},
+	 /*  7 */ {4, s_10_7, -1, -1, 0},
+	 /*  8 */ {4, s_10_8, -1, 6, 0},
+	 /*  9 */ {5, s_10_9, -1, 4, 0},
+	 /* 10 */ {4, s_10_10, -1, -1, 0},
+	 /* 11 */ {4, s_10_11, -1, 10, 0},
+	 /* 12 */ {6, s_10_12, -1, 11, 0},
+	 /* 13 */ {5, s_10_13, -1, 2, 0},
+	 /* 14 */ {4, s_10_14, -1, 1, 0},
+	 /* 15 */ {3, s_10_15, -1, -1, 0},
+	 /* 16 */ {5, s_10_16, -1, 5, 0},
+	 /* 17 */ {4, s_10_17, -1, 8, 0}
 };
 
-static unsigned char g_v[] = { 17, 65, 16, 1 };
-
-static unsigned char g_v_WXY[] = { 1, 17, 65, 208, 1 };
-
-static unsigned char g_valid_LI[] = { 55, 141, 2 };
-
-static symbol s_0[] = { '\'' };
-static symbol s_1[] = { 'y' };
-static symbol s_2[] = { 'Y' };
-static symbol s_3[] = { 'y' };
-static symbol s_4[] = { 'Y' };
-static symbol s_5[] = { 's', 's' };
-static symbol s_6[] = { 'i', 'e' };
-static symbol s_7[] = { 'i' };
-static symbol s_8[] = { 'e', 'e' };
-static symbol s_9[] = { 'e' };
-static symbol s_10[] = { 'e' };
-static symbol s_11[] = { 'y' };
-static symbol s_12[] = { 'Y' };
-static symbol s_13[] = { 'i' };
-static symbol s_14[] = { 't', 'i', 'o', 'n' };
-static symbol s_15[] = { 'e', 'n', 'c', 'e' };
-static symbol s_16[] = { 'a', 'n', 'c', 'e' };
-static symbol s_17[] = { 'a', 'b', 'l', 'e' };
-static symbol s_18[] = { 'e', 'n', 't' };
-static symbol s_19[] = { 'i', 'z', 'e' };
-static symbol s_20[] = { 'a', 't', 'e' };
-static symbol s_21[] = { 'a', 'l' };
-static symbol s_22[] = { 'f', 'u', 'l' };
-static symbol s_23[] = { 'o', 'u', 's' };
-static symbol s_24[] = { 'i', 'v', 'e' };
-static symbol s_25[] = { 'b', 'l', 'e' };
-static symbol s_26[] = { 'l' };
-static symbol s_27[] = { 'o', 'g' };
-static symbol s_28[] = { 'f', 'u', 'l' };
-static symbol s_29[] = { 'l', 'e', 's', 's' };
-static symbol s_30[] = { 't', 'i', 'o', 'n' };
-static symbol s_31[] = { 'a', 't', 'e' };
-static symbol s_32[] = { 'a', 'l' };
-static symbol s_33[] = { 'i', 'c' };
-static symbol s_34[] = { 's' };
-static symbol s_35[] = { 't' };
-static symbol s_36[] = { 'l' };
-static symbol s_37[] = { 's', 'k', 'i' };
-static symbol s_38[] = { 's', 'k', 'y' };
-static symbol s_39[] = { 'd', 'i', 'e' };
-static symbol s_40[] = { 'l', 'i', 'e' };
-static symbol s_41[] = { 't', 'i', 'e' };
-static symbol s_42[] = { 'i', 'd', 'l' };
-static symbol s_43[] = { 'g', 'e', 'n', 't', 'l' };
-static symbol s_44[] = { 'u', 'g', 'l', 'i' };
-static symbol s_45[] = { 'e', 'a', 'r', 'l', 'i' };
-static symbol s_46[] = { 'o', 'n', 'l', 'i' };
-static symbol s_47[] = { 's', 'i', 'n', 'g', 'l' };
-static symbol s_48[] = { 'Y' };
-static symbol s_49[] = { 'y' };
-
-static int r_prelude(struct SN_env * z) {
-    z->B[0] = 0; /* unset Y_found, line 26 */
-    {   int c = z->c; /* do, line 27 */
-        z->bra = z->c; /* [, line 27 */
-        if (!(eq_s(z, 1, s_0))) goto lab0;
-        z->ket = z->c; /* ], line 27 */
-        {   int ret;
-            ret = slice_del(z); /* delete, line 27 */
-            if (ret < 0) return ret;
-        }
-    lab0:
-        z->c = c;
-    }
-    {   int c = z->c; /* do, line 28 */
-        z->bra = z->c; /* [, line 28 */
-        if (!(eq_s(z, 1, s_1))) goto lab1;
-        z->ket = z->c; /* ], line 28 */
-        if (!(in_grouping(z, g_v, 97, 121))) goto lab1;
-        {   int ret;
-            ret = slice_from_s(z, 1, s_2); /* <-, line 28 */
-            if (ret < 0) return ret;
-        }
-        z->B[0] = 1; /* set Y_found, line 28 */
-    lab1:
-        z->c = c;
-    }
-    {   int c = z->c; /* do, line 29 */
-        while(1) { /* repeat, line 29 */
-            int c = z->c;
-            while(1) { /* goto, line 29 */
-                int c = z->c;
-                if (!(in_grouping(z, g_v, 97, 121))) goto lab4;
-                z->bra = z->c; /* [, line 29 */
-                if (!(eq_s(z, 1, s_3))) goto lab4;
-                z->ket = z->c; /* ], line 29 */
-                z->c = c;
-                break;
-            lab4:
-                z->c = c;
-                if (z->c >= z->l) goto lab3;
-                z->c++; /* goto, line 29 */
-            }
-            {   int ret;
-                ret = slice_from_s(z, 1, s_4); /* <-, line 29 */
-                if (ret < 0) return ret;
-            }
-            z->B[0] = 1; /* set Y_found, line 29 */
-            continue;
-        lab3:
-            z->c = c;
-            break;
-        }
-        z->c = c;
-    }
-    return 1;
+static unsigned char g_v[] = {17, 65, 16, 1};
+
+static unsigned char g_v_WXY[] = {1, 17, 65, 208, 1};
+
+static unsigned char g_valid_LI[] = {55, 141, 2};
+
+static symbol s_0[] = {'\''};
+static symbol s_1[] = {'y'};
+static symbol s_2[] = {'Y'};
+static symbol s_3[] = {'y'};
+static symbol s_4[] = {'Y'};
+static symbol s_5[] = {'s', 's'};
+static symbol s_6[] = {'i', 'e'};
+static symbol s_7[] = {'i'};
+static symbol s_8[] = {'e', 'e'};
+static symbol s_9[] = {'e'};
+static symbol s_10[] = {'e'};
+static symbol s_11[] = {'y'};
+static symbol s_12[] = {'Y'};
+static symbol s_13[] = {'i'};
+static symbol s_14[] = {'t', 'i', 'o', 'n'};
+static symbol s_15[] = {'e', 'n', 'c', 'e'};
+static symbol s_16[] = {'a', 'n', 'c', 'e'};
+static symbol s_17[] = {'a', 'b', 'l', 'e'};
+static symbol s_18[] = {'e', 'n', 't'};
+static symbol s_19[] = {'i', 'z', 'e'};
+static symbol s_20[] = {'a', 't', 'e'};
+static symbol s_21[] = {'a', 'l'};
+static symbol s_22[] = {'f', 'u', 'l'};
+static symbol s_23[] = {'o', 'u', 's'};
+static symbol s_24[] = {'i', 'v', 'e'};
+static symbol s_25[] = {'b', 'l', 'e'};
+static symbol s_26[] = {'l'};
+static symbol s_27[] = {'o', 'g'};
+static symbol s_28[] = {'f', 'u', 'l'};
+static symbol s_29[] = {'l', 'e', 's', 's'};
+static symbol s_30[] = {'t', 'i', 'o', 'n'};
+static symbol s_31[] = {'a', 't', 'e'};
+static symbol s_32[] = {'a', 'l'};
+static symbol s_33[] = {'i', 'c'};
+static symbol s_34[] = {'s'};
+static symbol s_35[] = {'t'};
+static symbol s_36[] = {'l'};
+static symbol s_37[] = {'s', 'k', 'i'};
+static symbol s_38[] = {'s', 'k', 'y'};
+static symbol s_39[] = {'d', 'i', 'e'};
+static symbol s_40[] = {'l', 'i', 'e'};
+static symbol s_41[] = {'t', 'i', 'e'};
+static symbol s_42[] = {'i', 'd', 'l'};
+static symbol s_43[] = {'g', 'e', 'n', 't', 'l'};
+static symbol s_44[] = {'u', 'g', 'l', 'i'};
+static symbol s_45[] = {'e', 'a', 'r', 'l', 'i'};
+static symbol s_46[] = {'o', 'n', 'l', 'i'};
+static symbol s_47[] = {'s', 'i', 'n', 'g', 'l'};
+static symbol s_48[] = {'Y'};
+static symbol s_49[] = {'y'};
+
+static int
+r_prelude(struct SN_env * z)
+{
+	z->B[0] = 0;				/* unset Y_found, line 26 */
+	{
+		int			c = z->c;	/* do, line 27 */
+
+		z->bra = z->c;			/* [, line 27 */
+		if (!(eq_s(z, 1, s_0)))
+			goto lab0;
+		z->ket = z->c;			/* ], line 27 */
+		{
+			int			ret;
+
+			ret = slice_del(z); /* delete, line 27 */
+			if (ret < 0)
+				return ret;
+		}
+lab0:
+		z->c = c;
+	}
+	{
+		int			c = z->c;	/* do, line 28 */
+
+		z->bra = z->c;			/* [, line 28 */
+		if (!(eq_s(z, 1, s_1)))
+			goto lab1;
+		z->ket = z->c;			/* ], line 28 */
+		if (!(in_grouping(z, g_v, 97, 121)))
+			goto lab1;
+		{
+			int			ret;
+
+			ret = slice_from_s(z, 1, s_2);		/* <-, line 28 */
+			if (ret < 0)
+				return ret;
+		}
+		z->B[0] = 1;			/* set Y_found, line 28 */
+lab1:
+		z->c = c;
+	}
+	{
+		int			c = z->c;	/* do, line 29 */
+
+		while (1)
+		{						/* repeat, line 29 */
+			int			c = z->c;
+
+			while (1)
+			{					/* goto, line 29 */
+				int			c = z->c;
+
+				if (!(in_grouping(z, g_v, 97, 121)))
+					goto lab4;
+				z->bra = z->c;	/* [, line 29 */
+				if (!(eq_s(z, 1, s_3)))
+					goto lab4;
+				z->ket = z->c;	/* ], line 29 */
+				z->c = c;
+				break;
+		lab4:
+				z->c = c;
+				if (z->c >= z->l)
+					goto lab3;
+				z->c++;			/* goto, line 29 */
+			}
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 1, s_4);	/* <-, line 29 */
+				if (ret < 0)
+					return ret;
+			}
+			z->B[0] = 1;		/* set Y_found, line 29 */
+			continue;
+	lab3:
+			z->c = c;
+			break;
+		}
+		z->c = c;
+	}
+	return 1;
 }
 
-static int r_mark_regions(struct SN_env * z) {
-    z->I[0] = z->l;
-    z->I[1] = z->l;
-    {   int c = z->c; /* do, line 35 */
-        {   int c = z->c; /* or, line 40 */
-            if (!(find_among(z, a_0, 2))) goto lab2; /* among, line 36 */
-            goto lab1;
-        lab2:
-            z->c = c;
-            while(1) { /* gopast, line 40 */
-                if (!(in_grouping(z, g_v, 97, 121))) goto lab3;
-                break;
-            lab3:
-                if (z->c >= z->l) goto lab0;
-                z->c++; /* gopast, line 40 */
-            }
-            while(1) { /* gopast, line 40 */
-                if (!(out_grouping(z, g_v, 97, 121))) goto lab4;
-                break;
-            lab4:
-                if (z->c >= z->l) goto lab0;
-                z->c++; /* gopast, line 40 */
-            }
-        }
-    lab1:
-        z->I[0] = z->c; /* setmark p1, line 41 */
-        while(1) { /* gopast, line 42 */
-            if (!(in_grouping(z, g_v, 97, 121))) goto lab5;
-            break;
-        lab5:
-            if (z->c >= z->l) goto lab0;
-            z->c++; /* gopast, line 42 */
-        }
-        while(1) { /* gopast, line 42 */
-            if (!(out_grouping(z, g_v, 97, 121))) goto lab6;
-            break;
-        lab6:
-            if (z->c >= z->l) goto lab0;
-            z->c++; /* gopast, line 42 */
-        }
-        z->I[1] = z->c; /* setmark p2, line 42 */
-    lab0:
-        z->c = c;
-    }
-    return 1;
+static int
+r_mark_regions(struct SN_env * z)
+{
+	z->I[0] = z->l;
+	z->I[1] = z->l;
+	{
+		int			c = z->c;	/* do, line 35 */
+
+		{
+			int			c = z->c;		/* or, line 40 */
+
+			if (!(find_among(z, a_0, 2)))
+				goto lab2;		/* among, line 36 */
+			goto lab1;
+	lab2:
+			z->c = c;
+			while (1)
+			{					/* gopast, line 40 */
+				if (!(in_grouping(z, g_v, 97, 121)))
+					goto lab3;
+				break;
+		lab3:
+				if (z->c >= z->l)
+					goto lab0;
+				z->c++;			/* gopast, line 40 */
+			}
+			while (1)
+			{					/* gopast, line 40 */
+				if (!(out_grouping(z, g_v, 97, 121)))
+					goto lab4;
+				break;
+		lab4:
+				if (z->c >= z->l)
+					goto lab0;
+				z->c++;			/* gopast, line 40 */
+			}
+		}
+lab1:
+		z->I[0] = z->c;			/* setmark p1, line 41 */
+		while (1)
+		{						/* gopast, line 42 */
+			if (!(in_grouping(z, g_v, 97, 121)))
+				goto lab5;
+			break;
+	lab5:
+			if (z->c >= z->l)
+				goto lab0;
+			z->c++;				/* gopast, line 42 */
+		}
+		while (1)
+		{						/* gopast, line 42 */
+			if (!(out_grouping(z, g_v, 97, 121)))
+				goto lab6;
+			break;
+	lab6:
+			if (z->c >= z->l)
+				goto lab0;
+			z->c++;				/* gopast, line 42 */
+		}
+		z->I[1] = z->c;			/* setmark p2, line 42 */
+lab0:
+		z->c = c;
+	}
+	return 1;
 }
 
-static int r_shortv(struct SN_env * z) {
-    {   int m = z->l - z->c; (void) m; /* or, line 50 */
-        if (!(out_grouping_b(z, g_v_WXY, 89, 121))) goto lab1;
-        if (!(in_grouping_b(z, g_v, 97, 121))) goto lab1;
-        if (!(out_grouping_b(z, g_v, 97, 121))) goto lab1;
-        goto lab0;
-    lab1:
-        z->c = z->l - m;
-        if (!(out_grouping_b(z, g_v, 97, 121))) return 0;
-        if (!(in_grouping_b(z, g_v, 97, 121))) return 0;
-        if (z->c > z->lb) return 0; /* atlimit, line 51 */
-    }
+static int
+r_shortv(struct SN_env * z)
+{
+	{
+		int			m = z->l - z->c;
+
+		(void) m;				/* or, line 50 */
+		if (!(out_grouping_b(z, g_v_WXY, 89, 121)))
+			goto lab1;
+		if (!(in_grouping_b(z, g_v, 97, 121)))
+			goto lab1;
+		if (!(out_grouping_b(z, g_v, 97, 121)))
+			goto lab1;
+		goto lab0;
+lab1:
+		z->c = z->l - m;
+		if (!(out_grouping_b(z, g_v, 97, 121)))
+			return 0;
+		if (!(in_grouping_b(z, g_v, 97, 121)))
+			return 0;
+		if (z->c > z->lb)
+			return 0;			/* atlimit, line 51 */
+	}
 lab0:
-    return 1;
+	return 1;
 }
 
-static int r_R1(struct SN_env * z) {
-    if (!(z->I[0] <= z->c)) return 0;
-    return 1;
+static int
+r_R1(struct SN_env * z)
+{
+	if (!(z->I[0] <= z->c))
+		return 0;
+	return 1;
 }
 
-static int r_R2(struct SN_env * z) {
-    if (!(z->I[1] <= z->c)) return 0;
-    return 1;
+static int
+r_R2(struct SN_env * z)
+{
+	if (!(z->I[1] <= z->c))
+		return 0;
+	return 1;
 }
 
-static int r_Step_1a(struct SN_env * z) {
-    int among_var;
-    {   int m = z->l - z->c; (void) m; /* try, line 58 */
-        z->ket = z->c; /* [, line 59 */
-        among_var = find_among_b(z, a_1, 3); /* substring, line 59 */
-        if (!(among_var)) { z->c = z->l - m; goto lab0; }
-        z->bra = z->c; /* ], line 59 */
-        switch(among_var) {
-            case 0: { z->c = z->l - m; goto lab0; }
-            case 1:
-                {   int ret;
-                    ret = slice_del(z); /* delete, line 61 */
-                    if (ret < 0) return ret;
-                }
-                break;
-        }
-    lab0:
-        ;
-    }
-    z->ket = z->c; /* [, line 64 */
-    among_var = find_among_b(z, a_2, 6); /* substring, line 64 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 64 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_from_s(z, 2, s_5); /* <-, line 65 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int m = z->l - z->c; (void) m; /* or, line 67 */
-                if (z->c <= z->lb) goto lab2;
-                z->c--; /* next, line 67 */
-                if (z->c > z->lb) goto lab2; /* atlimit, line 67 */
-                {   int ret;
-                    ret = slice_from_s(z, 2, s_6); /* <-, line 67 */
-                    if (ret < 0) return ret;
-                }
-                goto lab1;
-            lab2:
-                z->c = z->l - m;
-                {   int ret;
-                    ret = slice_from_s(z, 1, s_7); /* <-, line 67 */
-                    if (ret < 0) return ret;
-                }
-            }
-        lab1:
-            break;
-        case 3:
-            if (z->c <= z->lb) return 0;
-            z->c--; /* next, line 68 */
-            while(1) { /* gopast, line 68 */
-                if (!(in_grouping_b(z, g_v, 97, 121))) goto lab3;
-                break;
-            lab3:
-                if (z->c <= z->lb) return 0;
-                z->c--; /* gopast, line 68 */
-            }
-            {   int ret;
-                ret = slice_del(z); /* delete, line 68 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_Step_1a(struct SN_env * z)
+{
+	int			among_var;
+
+	{
+		int			m = z->l - z->c;
+
+		(void) m;				/* try, line 58 */
+		z->ket = z->c;			/* [, line 59 */
+		among_var = find_among_b(z, a_1, 3);	/* substring, line 59 */
+		if (!(among_var))
+		{
+			z->c = z->l - m;
+			goto lab0;
+		}
+		z->bra = z->c;			/* ], line 59 */
+		switch (among_var)
+		{
+			case 0:
+				{
+					z->c = z->l - m;
+					goto lab0;
+				}
+			case 1:
+				{
+					int			ret;
+
+					ret = slice_del(z); /* delete, line 61 */
+					if (ret < 0)
+						return ret;
+				}
+				break;
+		}
+lab0:
+		;
+	}
+	z->ket = z->c;				/* [, line 64 */
+	among_var = find_among_b(z, a_2, 6);		/* substring, line 64 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 64 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 2, s_5);	/* <-, line 65 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* or, line 67 */
+				if (z->c <= z->lb)
+					goto lab2;
+				z->c--;			/* next, line 67 */
+				if (z->c > z->lb)
+					goto lab2;	/* atlimit, line 67 */
+				{
+					int			ret;
+
+					ret = slice_from_s(z, 2, s_6);		/* <-, line 67 */
+					if (ret < 0)
+						return ret;
+				}
+				goto lab1;
+		lab2:
+				z->c = z->l - m;
+				{
+					int			ret;
+
+					ret = slice_from_s(z, 1, s_7);		/* <-, line 67 */
+					if (ret < 0)
+						return ret;
+				}
+			}
+	lab1:
+			break;
+		case 3:
+			if (z->c <= z->lb)
+				return 0;
+			z->c--;				/* next, line 68 */
+			while (1)
+			{					/* gopast, line 68 */
+				if (!(in_grouping_b(z, g_v, 97, 121)))
+					goto lab3;
+				break;
+		lab3:
+				if (z->c <= z->lb)
+					return 0;
+				z->c--;			/* gopast, line 68 */
+			}
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 68 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_Step_1b(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 74 */
-    among_var = find_among_b(z, a_4, 6); /* substring, line 74 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 74 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret = r_R1(z);
-                if (ret == 0) return 0; /* call R1, line 76 */
-                if (ret < 0) return ret;
-            }
-            {   int ret;
-                ret = slice_from_s(z, 2, s_8); /* <-, line 76 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int m_test = z->l - z->c; /* test, line 79 */
-                while(1) { /* gopast, line 79 */
-                    if (!(in_grouping_b(z, g_v, 97, 121))) goto lab0;
-                    break;
-                lab0:
-                    if (z->c <= z->lb) return 0;
-                    z->c--; /* gopast, line 79 */
-                }
-                z->c = z->l - m_test;
-            }
-            {   int ret;
-                ret = slice_del(z); /* delete, line 79 */
-                if (ret < 0) return ret;
-            }
-            {   int m_test = z->l - z->c; /* test, line 80 */
-                among_var = find_among_b(z, a_3, 13); /* substring, line 80 */
-                if (!(among_var)) return 0;
-                z->c = z->l - m_test;
-            }
-            switch(among_var) {
-                case 0: return 0;
-                case 1:
-                    {   int ret;
-                        {   int c = z->c;
-                            ret = insert_s(z, z->c, z->c, 1, s_9); /* <+, line 82 */
-                            z->c = c;
-                        }
-                        if (ret < 0) return ret;
-                    }
-                    break;
-                case 2:
-                    z->ket = z->c; /* [, line 85 */
-                    if (z->c <= z->lb) return 0;
-                    z->c--; /* next, line 85 */
-                    z->bra = z->c; /* ], line 85 */
-                    {   int ret;
-                        ret = slice_del(z); /* delete, line 85 */
-                        if (ret < 0) return ret;
-                    }
-                    break;
-                case 3:
-                    if (z->c != z->I[0]) return 0; /* atmark, line 86 */
-                    {   int m_test = z->l - z->c; /* test, line 86 */
-                        {   int ret = r_shortv(z);
-                            if (ret == 0) return 0; /* call shortv, line 86 */
-                            if (ret < 0) return ret;
-                        }
-                        z->c = z->l - m_test;
-                    }
-                    {   int ret;
-                        {   int c = z->c;
-                            ret = insert_s(z, z->c, z->c, 1, s_10); /* <+, line 86 */
-                            z->c = c;
-                        }
-                        if (ret < 0) return ret;
-                    }
-                    break;
-            }
-            break;
-    }
-    return 1;
+static int
+r_Step_1b(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 74 */
+	among_var = find_among_b(z, a_4, 6);		/* substring, line 74 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 74 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret = r_R1(z);
+
+				if (ret == 0)
+					return 0;	/* call R1, line 76 */
+				if (ret < 0)
+					return ret;
+			}
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 2, s_8);	/* <-, line 76 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			m_test = z->l - z->c;		/* test, line 79 */
+
+				while (1)
+				{				/* gopast, line 79 */
+					if (!(in_grouping_b(z, g_v, 97, 121)))
+						goto lab0;
+					break;
+			lab0:
+					if (z->c <= z->lb)
+						return 0;
+					z->c--;		/* gopast, line 79 */
+				}
+				z->c = z->l - m_test;
+			}
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 79 */
+				if (ret < 0)
+					return ret;
+			}
+			{
+				int			m_test = z->l - z->c;		/* test, line 80 */
+
+				among_var = find_among_b(z, a_3, 13);	/* substring, line 80 */
+				if (!(among_var))
+					return 0;
+				z->c = z->l - m_test;
+			}
+			switch (among_var)
+			{
+				case 0:
+					return 0;
+				case 1:
+					{
+						int			ret;
+
+						{
+							int			c = z->c;
+
+							ret = insert_s(z, z->c, z->c, 1, s_9);		/* <+, line 82 */
+							z->c = c;
+						}
+						if (ret < 0)
+							return ret;
+					}
+					break;
+				case 2:
+					z->ket = z->c;		/* [, line 85 */
+					if (z->c <= z->lb)
+						return 0;
+					z->c--;		/* next, line 85 */
+					z->bra = z->c;		/* ], line 85 */
+					{
+						int			ret;
+
+						ret = slice_del(z);		/* delete, line 85 */
+						if (ret < 0)
+							return ret;
+					}
+					break;
+				case 3:
+					if (z->c != z->I[0])
+						return 0;		/* atmark, line 86 */
+					{
+						int			m_test = z->l - z->c;		/* test, line 86 */
+
+						{
+							int			ret = r_shortv(z);
+
+							if (ret == 0)
+								return 0;		/* call shortv, line 86 */
+							if (ret < 0)
+								return ret;
+						}
+						z->c = z->l - m_test;
+					}
+					{
+						int			ret;
+
+						{
+							int			c = z->c;
+
+							ret = insert_s(z, z->c, z->c, 1, s_10);		/* <+, line 86 */
+							z->c = c;
+						}
+						if (ret < 0)
+							return ret;
+					}
+					break;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_Step_1c(struct SN_env * z) {
-    z->ket = z->c; /* [, line 93 */
-    {   int m = z->l - z->c; (void) m; /* or, line 93 */
-        if (!(eq_s_b(z, 1, s_11))) goto lab1;
-        goto lab0;
-    lab1:
-        z->c = z->l - m;
-        if (!(eq_s_b(z, 1, s_12))) return 0;
-    }
+static int
+r_Step_1c(struct SN_env * z)
+{
+	z->ket = z->c;				/* [, line 93 */
+	{
+		int			m = z->l - z->c;
+
+		(void) m;				/* or, line 93 */
+		if (!(eq_s_b(z, 1, s_11)))
+			goto lab1;
+		goto lab0;
+lab1:
+		z->c = z->l - m;
+		if (!(eq_s_b(z, 1, s_12)))
+			return 0;
+	}
 lab0:
-    z->bra = z->c; /* ], line 93 */
-    if (!(out_grouping_b(z, g_v, 97, 121))) return 0;
-    {   int m = z->l - z->c; (void) m; /* not, line 94 */
-        if (z->c > z->lb) goto lab2; /* atlimit, line 94 */
-        return 0;
-    lab2:
-        z->c = z->l - m;
-    }
-    {   int ret;
-        ret = slice_from_s(z, 1, s_13); /* <-, line 95 */
-        if (ret < 0) return ret;
-    }
-    return 1;
-}
+	z->bra = z->c;				/* ], line 93 */
+	if (!(out_grouping_b(z, g_v, 97, 121)))
+		return 0;
+	{
+		int			m = z->l - z->c;
 
-static int r_Step_2(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 99 */
-    among_var = find_among_b(z, a_5, 24); /* substring, line 99 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 99 */
-    {   int ret = r_R1(z);
-        if (ret == 0) return 0; /* call R1, line 99 */
-        if (ret < 0) return ret;
-    }
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_14); /* <-, line 100 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_15); /* <-, line 101 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 3:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_16); /* <-, line 102 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 4:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_17); /* <-, line 103 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 5:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_18); /* <-, line 104 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 6:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_19); /* <-, line 106 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 7:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_20); /* <-, line 108 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 8:
-            {   int ret;
-                ret = slice_from_s(z, 2, s_21); /* <-, line 110 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 9:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_22); /* <-, line 111 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 10:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_23); /* <-, line 113 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 11:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_24); /* <-, line 115 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 12:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_25); /* <-, line 117 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 13:
-            if (!(eq_s_b(z, 1, s_26))) return 0;
-            {   int ret;
-                ret = slice_from_s(z, 2, s_27); /* <-, line 118 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 14:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_28); /* <-, line 119 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 15:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_29); /* <-, line 120 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 16:
-            if (!(in_grouping_b(z, g_valid_LI, 99, 116))) return 0;
-            {   int ret;
-                ret = slice_del(z); /* delete, line 121 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+		(void) m;				/* not, line 94 */
+		if (z->c > z->lb)
+			goto lab2;			/* atlimit, line 94 */
+		return 0;
+lab2:
+		z->c = z->l - m;
+	}
+	{
+		int			ret;
+
+		ret = slice_from_s(z, 1, s_13); /* <-, line 95 */
+		if (ret < 0)
+			return ret;
+	}
+	return 1;
 }
 
-static int r_Step_3(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 126 */
-    among_var = find_among_b(z, a_6, 9); /* substring, line 126 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 126 */
-    {   int ret = r_R1(z);
-        if (ret == 0) return 0; /* call R1, line 126 */
-        if (ret < 0) return ret;
-    }
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_30); /* <-, line 127 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_31); /* <-, line 128 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 3:
-            {   int ret;
-                ret = slice_from_s(z, 2, s_32); /* <-, line 129 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 4:
-            {   int ret;
-                ret = slice_from_s(z, 2, s_33); /* <-, line 131 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 5:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 133 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 6:
-            {   int ret = r_R2(z);
-                if (ret == 0) return 0; /* call R2, line 135 */
-                if (ret < 0) return ret;
-            }
-            {   int ret;
-                ret = slice_del(z); /* delete, line 135 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_Step_2(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 99 */
+	among_var = find_among_b(z, a_5, 24);		/* substring, line 99 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 99 */
+	{
+		int			ret = r_R1(z);
+
+		if (ret == 0)
+			return 0;			/* call R1, line 99 */
+		if (ret < 0)
+			return ret;
+	}
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_14); /* <-, line 100 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_15); /* <-, line 101 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 3:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_16); /* <-, line 102 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 4:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_17); /* <-, line 103 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 5:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_18); /* <-, line 104 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 6:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_19); /* <-, line 106 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 7:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_20); /* <-, line 108 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 8:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 2, s_21); /* <-, line 110 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 9:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_22); /* <-, line 111 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 10:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_23); /* <-, line 113 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 11:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_24); /* <-, line 115 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 12:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_25); /* <-, line 117 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 13:
+			if (!(eq_s_b(z, 1, s_26)))
+				return 0;
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 2, s_27); /* <-, line 118 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 14:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_28); /* <-, line 119 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 15:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_29); /* <-, line 120 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 16:
+			if (!(in_grouping_b(z, g_valid_LI, 99, 116)))
+				return 0;
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 121 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_Step_4(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 140 */
-    among_var = find_among_b(z, a_7, 18); /* substring, line 140 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 140 */
-    {   int ret = r_R2(z);
-        if (ret == 0) return 0; /* call R2, line 140 */
-        if (ret < 0) return ret;
-    }
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 143 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int m = z->l - z->c; (void) m; /* or, line 144 */
-                if (!(eq_s_b(z, 1, s_34))) goto lab1;
-                goto lab0;
-            lab1:
-                z->c = z->l - m;
-                if (!(eq_s_b(z, 1, s_35))) return 0;
-            }
-        lab0:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 144 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_Step_3(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 126 */
+	among_var = find_among_b(z, a_6, 9);		/* substring, line 126 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 126 */
+	{
+		int			ret = r_R1(z);
+
+		if (ret == 0)
+			return 0;			/* call R1, line 126 */
+		if (ret < 0)
+			return ret;
+	}
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_30); /* <-, line 127 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_31); /* <-, line 128 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 3:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 2, s_32); /* <-, line 129 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 4:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 2, s_33); /* <-, line 131 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 5:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 133 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 6:
+			{
+				int			ret = r_R2(z);
+
+				if (ret == 0)
+					return 0;	/* call R2, line 135 */
+				if (ret < 0)
+					return ret;
+			}
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 135 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_Step_5(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 149 */
-    among_var = find_among_b(z, a_8, 2); /* substring, line 149 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 149 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int m = z->l - z->c; (void) m; /* or, line 150 */
-                {   int ret = r_R2(z);
-                    if (ret == 0) goto lab1; /* call R2, line 150 */
-                    if (ret < 0) return ret;
-                }
-                goto lab0;
-            lab1:
-                z->c = z->l - m;
-                {   int ret = r_R1(z);
-                    if (ret == 0) return 0; /* call R1, line 150 */
-                    if (ret < 0) return ret;
-                }
-                {   int m = z->l - z->c; (void) m; /* not, line 150 */
-                    {   int ret = r_shortv(z);
-                        if (ret == 0) goto lab2; /* call shortv, line 150 */
-                        if (ret < 0) return ret;
-                    }
-                    return 0;
-                lab2:
-                    z->c = z->l - m;
-                }
-            }
-        lab0:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 150 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int ret = r_R2(z);
-                if (ret == 0) return 0; /* call R2, line 151 */
-                if (ret < 0) return ret;
-            }
-            if (!(eq_s_b(z, 1, s_36))) return 0;
-            {   int ret;
-                ret = slice_del(z); /* delete, line 151 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_Step_4(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 140 */
+	among_var = find_among_b(z, a_7, 18);		/* substring, line 140 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 140 */
+	{
+		int			ret = r_R2(z);
+
+		if (ret == 0)
+			return 0;			/* call R2, line 140 */
+		if (ret < 0)
+			return ret;
+	}
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 143 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* or, line 144 */
+				if (!(eq_s_b(z, 1, s_34)))
+					goto lab1;
+				goto lab0;
+		lab1:
+				z->c = z->l - m;
+				if (!(eq_s_b(z, 1, s_35)))
+					return 0;
+			}
+	lab0:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 144 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_exception2(struct SN_env * z) {
-    z->ket = z->c; /* [, line 157 */
-    if (!(find_among_b(z, a_9, 8))) return 0; /* substring, line 157 */
-    z->bra = z->c; /* ], line 157 */
-    if (z->c > z->lb) return 0; /* atlimit, line 157 */
-    return 1;
+static int
+r_Step_5(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 149 */
+	among_var = find_among_b(z, a_8, 2);		/* substring, line 149 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 149 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* or, line 150 */
+				{
+					int			ret = r_R2(z);
+
+					if (ret == 0)
+						goto lab1;		/* call R2, line 150 */
+					if (ret < 0)
+						return ret;
+				}
+				goto lab0;
+		lab1:
+				z->c = z->l - m;
+				{
+					int			ret = r_R1(z);
+
+					if (ret == 0)
+						return 0;		/* call R1, line 150 */
+					if (ret < 0)
+						return ret;
+				}
+				{
+					int			m = z->l - z->c;
+
+					(void) m;	/* not, line 150 */
+					{
+						int			ret = r_shortv(z);
+
+						if (ret == 0)
+							goto lab2;	/* call shortv, line 150 */
+						if (ret < 0)
+							return ret;
+					}
+					return 0;
+			lab2:
+					z->c = z->l - m;
+				}
+			}
+	lab0:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 150 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			ret = r_R2(z);
+
+				if (ret == 0)
+					return 0;	/* call R2, line 151 */
+				if (ret < 0)
+					return ret;
+			}
+			if (!(eq_s_b(z, 1, s_36)))
+				return 0;
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 151 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_exception1(struct SN_env * z) {
-    int among_var;
-    z->bra = z->c; /* [, line 169 */
-    among_var = find_among(z, a_10, 18); /* substring, line 169 */
-    if (!(among_var)) return 0;
-    z->ket = z->c; /* ], line 169 */
-    if (z->c < z->l) return 0; /* atlimit, line 169 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_37); /* <-, line 173 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_38); /* <-, line 174 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 3:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_39); /* <-, line 175 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 4:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_40); /* <-, line 176 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 5:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_41); /* <-, line 177 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 6:
-            {   int ret;
-                ret = slice_from_s(z, 3, s_42); /* <-, line 181 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 7:
-            {   int ret;
-                ret = slice_from_s(z, 5, s_43); /* <-, line 182 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 8:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_44); /* <-, line 183 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 9:
-            {   int ret;
-                ret = slice_from_s(z, 5, s_45); /* <-, line 184 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 10:
-            {   int ret;
-                ret = slice_from_s(z, 4, s_46); /* <-, line 185 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 11:
-            {   int ret;
-                ret = slice_from_s(z, 5, s_47); /* <-, line 186 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_exception2(struct SN_env * z)
+{
+	z->ket = z->c;				/* [, line 157 */
+	if (!(find_among_b(z, a_9, 8)))
+		return 0;				/* substring, line 157 */
+	z->bra = z->c;				/* ], line 157 */
+	if (z->c > z->lb)
+		return 0;				/* atlimit, line 157 */
+	return 1;
 }
 
-static int r_postlude(struct SN_env * z) {
-    if (!(z->B[0])) return 0; /* Boolean test Y_found, line 202 */
-    while(1) { /* repeat, line 202 */
-        int c = z->c;
-        while(1) { /* goto, line 202 */
-            int c = z->c;
-            z->bra = z->c; /* [, line 202 */
-            if (!(eq_s(z, 1, s_48))) goto lab1;
-            z->ket = z->c; /* ], line 202 */
-            z->c = c;
-            break;
-        lab1:
-            z->c = c;
-            if (z->c >= z->l) goto lab0;
-            z->c++; /* goto, line 202 */
-        }
-        {   int ret;
-            ret = slice_from_s(z, 1, s_49); /* <-, line 202 */
-            if (ret < 0) return ret;
-        }
-        continue;
-    lab0:
-        z->c = c;
-        break;
-    }
-    return 1;
+static int
+r_exception1(struct SN_env * z)
+{
+	int			among_var;
+
+	z->bra = z->c;				/* [, line 169 */
+	among_var = find_among(z, a_10, 18);		/* substring, line 169 */
+	if (!(among_var))
+		return 0;
+	z->ket = z->c;				/* ], line 169 */
+	if (z->c < z->l)
+		return 0;				/* atlimit, line 169 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_37); /* <-, line 173 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_38); /* <-, line 174 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 3:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_39); /* <-, line 175 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 4:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_40); /* <-, line 176 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 5:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_41); /* <-, line 177 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 6:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 3, s_42); /* <-, line 181 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 7:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 5, s_43); /* <-, line 182 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 8:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_44); /* <-, line 183 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 9:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 5, s_45); /* <-, line 184 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 10:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 4, s_46); /* <-, line 185 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 11:
+			{
+				int			ret;
+
+				ret = slice_from_s(z, 5, s_47); /* <-, line 186 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-extern int english_ISO_8859_1_stem(struct SN_env * z) {
-    {   int c = z->c; /* or, line 206 */
-        {   int ret = r_exception1(z);
-            if (ret == 0) goto lab1; /* call exception1, line 206 */
-            if (ret < 0) return ret;
-        }
-        goto lab0;
-    lab1:
-        z->c = c;
-        {   int c = z->c; /* not, line 207 */
-            {   int c = z->c + 3;
-                if (0 > c || c > z->l) goto lab3;
-                z->c = c; /* hop, line 207 */
-            }
-            goto lab2;
-        lab3:
-            z->c = c;
-        }
-        goto lab0;
-    lab2:
-        z->c = c;
-        {   int c = z->c; /* do, line 208 */
-            {   int ret = r_prelude(z);
-                if (ret == 0) goto lab4; /* call prelude, line 208 */
-                if (ret < 0) return ret;
-            }
-        lab4:
-            z->c = c;
-        }
-        {   int c = z->c; /* do, line 209 */
-            {   int ret = r_mark_regions(z);
-                if (ret == 0) goto lab5; /* call mark_regions, line 209 */
-                if (ret < 0) return ret;
-            }
-        lab5:
-            z->c = c;
-        }
-        z->lb = z->c; z->c = z->l; /* backwards, line 210 */
-
-        {   int m = z->l - z->c; (void) m; /* do, line 212 */
-            {   int ret = r_Step_1a(z);
-                if (ret == 0) goto lab6; /* call Step_1a, line 212 */
-                if (ret < 0) return ret;
-            }
-        lab6:
-            z->c = z->l - m;
-        }
-        {   int m = z->l - z->c; (void) m; /* or, line 214 */
-            {   int ret = r_exception2(z);
-                if (ret == 0) goto lab8; /* call exception2, line 214 */
-                if (ret < 0) return ret;
-            }
-            goto lab7;
-        lab8:
-            z->c = z->l - m;
-            {   int m = z->l - z->c; (void) m; /* do, line 216 */
-                {   int ret = r_Step_1b(z);
-                    if (ret == 0) goto lab9; /* call Step_1b, line 216 */
-                    if (ret < 0) return ret;
-                }
-            lab9:
-                z->c = z->l - m;
-            }
-            {   int m = z->l - z->c; (void) m; /* do, line 217 */
-                {   int ret = r_Step_1c(z);
-                    if (ret == 0) goto lab10; /* call Step_1c, line 217 */
-                    if (ret < 0) return ret;
-                }
-            lab10:
-                z->c = z->l - m;
-            }
-            {   int m = z->l - z->c; (void) m; /* do, line 219 */
-                {   int ret = r_Step_2(z);
-                    if (ret == 0) goto lab11; /* call Step_2, line 219 */
-                    if (ret < 0) return ret;
-                }
-            lab11:
-                z->c = z->l - m;
-            }
-            {   int m = z->l - z->c; (void) m; /* do, line 220 */
-                {   int ret = r_Step_3(z);
-                    if (ret == 0) goto lab12; /* call Step_3, line 220 */
-                    if (ret < 0) return ret;
-                }
-            lab12:
-                z->c = z->l - m;
-            }
-            {   int m = z->l - z->c; (void) m; /* do, line 221 */
-                {   int ret = r_Step_4(z);
-                    if (ret == 0) goto lab13; /* call Step_4, line 221 */
-                    if (ret < 0) return ret;
-                }
-            lab13:
-                z->c = z->l - m;
-            }
-            {   int m = z->l - z->c; (void) m; /* do, line 223 */
-                {   int ret = r_Step_5(z);
-                    if (ret == 0) goto lab14; /* call Step_5, line 223 */
-                    if (ret < 0) return ret;
-                }
-            lab14:
-                z->c = z->l - m;
-            }
-        }
-    lab7:
-        z->c = z->lb;
-        {   int c = z->c; /* do, line 226 */
-            {   int ret = r_postlude(z);
-                if (ret == 0) goto lab15; /* call postlude, line 226 */
-                if (ret < 0) return ret;
-            }
-        lab15:
-            z->c = c;
-        }
-    }
+static int
+r_postlude(struct SN_env * z)
+{
+	if (!(z->B[0]))
+		return 0;				/* Boolean test Y_found, line 202 */
+	while (1)
+	{							/* repeat, line 202 */
+		int			c = z->c;
+
+		while (1)
+		{						/* goto, line 202 */
+			int			c = z->c;
+
+			z->bra = z->c;		/* [, line 202 */
+			if (!(eq_s(z, 1, s_48)))
+				goto lab1;
+			z->ket = z->c;		/* ], line 202 */
+			z->c = c;
+			break;
+	lab1:
+			z->c = c;
+			if (z->c >= z->l)
+				goto lab0;
+			z->c++;				/* goto, line 202 */
+		}
+		{
+			int			ret;
+
+			ret = slice_from_s(z, 1, s_49);		/* <-, line 202 */
+			if (ret < 0)
+				return ret;
+		}
+		continue;
 lab0:
-    return 1;
+		z->c = c;
+		break;
+	}
+	return 1;
 }
 
-extern struct SN_env * english_ISO_8859_1_create_env(void) { return SN_create_env(0, 2, 1); }
+extern int
+english_ISO_8859_1_stem(struct SN_env * z)
+{
+	{
+		int			c = z->c;	/* or, line 206 */
+
+		{
+			int			ret = r_exception1(z);
+
+			if (ret == 0)
+				goto lab1;		/* call exception1, line 206 */
+			if (ret < 0)
+				return ret;
+		}
+		goto lab0;
+lab1:
+		z->c = c;
+		{
+			int			c = z->c;		/* not, line 207 */
+
+			{
+				int			c = z->c + 3;
+
+				if (0 > c || c > z->l)
+					goto lab3;
+				z->c = c;		/* hop, line 207 */
+			}
+			goto lab2;
+	lab3:
+			z->c = c;
+		}
+		goto lab0;
+lab2:
+		z->c = c;
+		{
+			int			c = z->c;		/* do, line 208 */
+
+			{
+				int			ret = r_prelude(z);
+
+				if (ret == 0)
+					goto lab4;	/* call prelude, line 208 */
+				if (ret < 0)
+					return ret;
+			}
+	lab4:
+			z->c = c;
+		}
+		{
+			int			c = z->c;		/* do, line 209 */
+
+			{
+				int			ret = r_mark_regions(z);
+
+				if (ret == 0)
+					goto lab5;	/* call mark_regions, line 209 */
+				if (ret < 0)
+					return ret;
+			}
+	lab5:
+			z->c = c;
+		}
+		z->lb = z->c;
+		z->c = z->l;			/* backwards, line 210 */
+
+		{
+			int			m = z->l - z->c;
+
+			(void) m;			/* do, line 212 */
+			{
+				int			ret = r_Step_1a(z);
+
+				if (ret == 0)
+					goto lab6;	/* call Step_1a, line 212 */
+				if (ret < 0)
+					return ret;
+			}
+	lab6:
+			z->c = z->l - m;
+		}
+		{
+			int			m = z->l - z->c;
+
+			(void) m;			/* or, line 214 */
+			{
+				int			ret = r_exception2(z);
+
+				if (ret == 0)
+					goto lab8;	/* call exception2, line 214 */
+				if (ret < 0)
+					return ret;
+			}
+			goto lab7;
+	lab8:
+			z->c = z->l - m;
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* do, line 216 */
+				{
+					int			ret = r_Step_1b(z);
+
+					if (ret == 0)
+						goto lab9;		/* call Step_1b, line 216 */
+					if (ret < 0)
+						return ret;
+				}
+		lab9:
+				z->c = z->l - m;
+			}
+			{
+				int			m = z->l - z->c;
 
-extern void english_ISO_8859_1_close_env(struct SN_env * z) { SN_close_env(z); }
+				(void) m;		/* do, line 217 */
+				{
+					int			ret = r_Step_1c(z);
 
+					if (ret == 0)
+						goto lab10;		/* call Step_1c, line 217 */
+					if (ret < 0)
+						return ret;
+				}
+		lab10:
+				z->c = z->l - m;
+			}
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* do, line 219 */
+				{
+					int			ret = r_Step_2(z);
+
+					if (ret == 0)
+						goto lab11;		/* call Step_2, line 219 */
+					if (ret < 0)
+						return ret;
+				}
+		lab11:
+				z->c = z->l - m;
+			}
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* do, line 220 */
+				{
+					int			ret = r_Step_3(z);
+
+					if (ret == 0)
+						goto lab12;		/* call Step_3, line 220 */
+					if (ret < 0)
+						return ret;
+				}
+		lab12:
+				z->c = z->l - m;
+			}
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* do, line 221 */
+				{
+					int			ret = r_Step_4(z);
+
+					if (ret == 0)
+						goto lab13;		/* call Step_4, line 221 */
+					if (ret < 0)
+						return ret;
+				}
+		lab13:
+				z->c = z->l - m;
+			}
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* do, line 223 */
+				{
+					int			ret = r_Step_5(z);
+
+					if (ret == 0)
+						goto lab14;		/* call Step_5, line 223 */
+					if (ret < 0)
+						return ret;
+				}
+		lab14:
+				z->c = z->l - m;
+			}
+		}
+lab7:
+		z->c = z->lb;
+		{
+			int			c = z->c;		/* do, line 226 */
+
+			{
+				int			ret = r_postlude(z);
+
+				if (ret == 0)
+					goto lab15; /* call postlude, line 226 */
+				if (ret < 0)
+					return ret;
+			}
+	lab15:
+			z->c = c;
+		}
+	}
+lab0:
+	return 1;
+}
+
+extern struct SN_env *english_ISO_8859_1_create_env(void)
+{
+	return SN_create_env(0, 2, 1);
+}
+
+extern void english_ISO_8859_1_close_env(struct SN_env * z)
+{
+	SN_close_env(z);
+}
diff --git a/contrib/tsearch2/snowball/english_stem.h b/contrib/tsearch2/snowball/english_stem.h
index e685dcf7ef..8a3c3816d6 100644
--- a/contrib/tsearch2/snowball/english_stem.h
+++ b/contrib/tsearch2/snowball/english_stem.h
@@ -2,15 +2,16 @@
 /* This file was generated automatically by the Snowball to ANSI C compiler */
 
 #ifdef __cplusplus
-extern "C" {
+extern		"C"
+{
 #endif
 
-extern struct SN_env * english_ISO_8859_1_create_env(void);
-extern void english_ISO_8859_1_close_env(struct SN_env * z);
+	extern struct SN_env *english_ISO_8859_1_create_env(void);
+	extern void english_ISO_8859_1_close_env(struct SN_env * z);
 
-extern int english_ISO_8859_1_stem(struct SN_env * z);
+	extern int	english_ISO_8859_1_stem(struct SN_env * z);
 
 #ifdef __cplusplus
 }
-#endif
 
+#endif
diff --git a/contrib/tsearch2/snowball/header.h b/contrib/tsearch2/snowball/header.h
index c0721d6fd3..ad07388154 100644
--- a/contrib/tsearch2/snowball/header.h
+++ b/contrib/tsearch2/snowball/header.h
@@ -8,51 +8,51 @@
 
 #define HEAD 2*sizeof(int)
 
-#define SIZE(p)        ((int *)(p))[-1]
+#define SIZE(p)		   ((int *)(p))[-1]
 #define SET_SIZE(p, n) ((int *)(p))[-1] = n
 #define CAPACITY(p)    ((int *)(p))[-2]
 
 struct among
-{   int s_size;     /* number of chars in string */
-    symbol * s;       /* search string */
-    int substring_i;/* index to longest matching substring */
-    int result;     /* result of the lookup */
-    int (* function)(struct SN_env *);
+{
+	int			s_size;			/* number of chars in string */
+	symbol	   *s;				/* search string */
+	int			substring_i;	/* index to longest matching substring */
+	int			result;			/* result of the lookup */
+	int			(*function) (struct SN_env *);
 };
 
-extern symbol * create_s(void);
+extern symbol *create_s(void);
 extern void lose_s(symbol * p);
 
-extern int skip_utf8(const symbol * p, int c, int lb, int l, int n);
+extern int	skip_utf8(const symbol * p, int c, int lb, int l, int n);
 
-extern int in_grouping_U(struct SN_env * z, unsigned char * s, int min, int max);
-extern int in_grouping_b_U(struct SN_env * z, unsigned char * s, int min, int max);
-extern int out_grouping_U(struct SN_env * z, unsigned char * s, int min, int max);
-extern int out_grouping_b_U(struct SN_env * z, unsigned char * s, int min, int max);
+extern int	in_grouping_U(struct SN_env * z, unsigned char *s, int min, int max);
+extern int	in_grouping_b_U(struct SN_env * z, unsigned char *s, int min, int max);
+extern int	out_grouping_U(struct SN_env * z, unsigned char *s, int min, int max);
+extern int	out_grouping_b_U(struct SN_env * z, unsigned char *s, int min, int max);
 
-extern int in_grouping(struct SN_env * z, unsigned char * s, int min, int max);
-extern int in_grouping_b(struct SN_env * z, unsigned char * s, int min, int max);
-extern int out_grouping(struct SN_env * z, unsigned char * s, int min, int max);
-extern int out_grouping_b(struct SN_env * z, unsigned char * s, int min, int max);
+extern int	in_grouping(struct SN_env * z, unsigned char *s, int min, int max);
+extern int	in_grouping_b(struct SN_env * z, unsigned char *s, int min, int max);
+extern int	out_grouping(struct SN_env * z, unsigned char *s, int min, int max);
+extern int	out_grouping_b(struct SN_env * z, unsigned char *s, int min, int max);
 
-extern int eq_s(struct SN_env * z, int s_size, symbol * s);
-extern int eq_s_b(struct SN_env * z, int s_size, symbol * s);
-extern int eq_v(struct SN_env * z, symbol * p);
-extern int eq_v_b(struct SN_env * z, symbol * p);
+extern int	eq_s(struct SN_env * z, int s_size, symbol * s);
+extern int	eq_s_b(struct SN_env * z, int s_size, symbol * s);
+extern int	eq_v(struct SN_env * z, symbol * p);
+extern int	eq_v_b(struct SN_env * z, symbol * p);
 
-extern int find_among(struct SN_env * z, struct among * v, int v_size);
-extern int find_among_b(struct SN_env * z, struct among * v, int v_size);
+extern int	find_among(struct SN_env * z, struct among * v, int v_size);
+extern int	find_among_b(struct SN_env * z, struct among * v, int v_size);
 
-extern int replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s, int * adjustment);
-extern int slice_from_s(struct SN_env * z, int s_size, symbol * s);
-extern int slice_from_v(struct SN_env * z, symbol * p);
-extern int slice_del(struct SN_env * z);
+extern int	replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s, int *adjustment);
+extern int	slice_from_s(struct SN_env * z, int s_size, symbol * s);
+extern int	slice_from_v(struct SN_env * z, symbol * p);
+extern int	slice_del(struct SN_env * z);
 
-extern int insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s);
-extern int insert_v(struct SN_env * z, int bra, int ket, symbol * p);
+extern int	insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s);
+extern int	insert_v(struct SN_env * z, int bra, int ket, symbol * p);
 
-extern symbol * slice_to(struct SN_env * z, symbol * p);
-extern symbol * assign_to(struct SN_env * z, symbol * p);
+extern symbol *slice_to(struct SN_env * z, symbol * p);
+extern symbol *assign_to(struct SN_env * z, symbol * p);
 
 extern void debug(struct SN_env * z, int number, int line_count);
-
diff --git a/contrib/tsearch2/snowball/russian_stem.c b/contrib/tsearch2/snowball/russian_stem.c
index b9b453da86..213e88f7b9 100644
--- a/contrib/tsearch2/snowball/russian_stem.c
+++ b/contrib/tsearch2/snowball/russian_stem.c
@@ -3,699 +3,924 @@
 
 #include "header.h"
 
-extern int russian_KOI8_R_stem(struct SN_env * z);
-static int r_tidy_up(struct SN_env * z);
-static int r_derivational(struct SN_env * z);
-static int r_noun(struct SN_env * z);
-static int r_verb(struct SN_env * z);
-static int r_reflexive(struct SN_env * z);
-static int r_adjectival(struct SN_env * z);
-static int r_adjective(struct SN_env * z);
-static int r_perfective_gerund(struct SN_env * z);
-static int r_R2(struct SN_env * z);
-static int r_mark_regions(struct SN_env * z);
-
-extern struct SN_env * russian_KOI8_R_create_env(void);
+extern int	russian_KOI8_R_stem(struct SN_env * z);
+static int	r_tidy_up(struct SN_env * z);
+static int	r_derivational(struct SN_env * z);
+static int	r_noun(struct SN_env * z);
+static int	r_verb(struct SN_env * z);
+static int	r_reflexive(struct SN_env * z);
+static int	r_adjectival(struct SN_env * z);
+static int	r_adjective(struct SN_env * z);
+static int	r_perfective_gerund(struct SN_env * z);
+static int	r_R2(struct SN_env * z);
+static int	r_mark_regions(struct SN_env * z);
+
+extern struct SN_env *russian_KOI8_R_create_env(void);
 extern void russian_KOI8_R_close_env(struct SN_env * z);
 
-static symbol s_0_0[3] = { 0xD7, 0xDB, 0xC9 };
-static symbol s_0_1[4] = { 0xC9, 0xD7, 0xDB, 0xC9 };
-static symbol s_0_2[4] = { 0xD9, 0xD7, 0xDB, 0xC9 };
-static symbol s_0_3[1] = { 0xD7 };
-static symbol s_0_4[2] = { 0xC9, 0xD7 };
-static symbol s_0_5[2] = { 0xD9, 0xD7 };
-static symbol s_0_6[5] = { 0xD7, 0xDB, 0xC9, 0xD3, 0xD8 };
-static symbol s_0_7[6] = { 0xC9, 0xD7, 0xDB, 0xC9, 0xD3, 0xD8 };
-static symbol s_0_8[6] = { 0xD9, 0xD7, 0xDB, 0xC9, 0xD3, 0xD8 };
+static symbol s_0_0[3] = {0xD7, 0xDB, 0xC9};
+static symbol s_0_1[4] = {0xC9, 0xD7, 0xDB, 0xC9};
+static symbol s_0_2[4] = {0xD9, 0xD7, 0xDB, 0xC9};
+static symbol s_0_3[1] = {0xD7};
+static symbol s_0_4[2] = {0xC9, 0xD7};
+static symbol s_0_5[2] = {0xD9, 0xD7};
+static symbol s_0_6[5] = {0xD7, 0xDB, 0xC9, 0xD3, 0xD8};
+static symbol s_0_7[6] = {0xC9, 0xD7, 0xDB, 0xC9, 0xD3, 0xD8};
+static symbol s_0_8[6] = {0xD9, 0xD7, 0xDB, 0xC9, 0xD3, 0xD8};
 
 static struct among a_0[9] =
 {
-/*  0 */ { 3, s_0_0, -1, 1, 0},
-/*  1 */ { 4, s_0_1, 0, 2, 0},
-/*  2 */ { 4, s_0_2, 0, 2, 0},
-/*  3 */ { 1, s_0_3, -1, 1, 0},
-/*  4 */ { 2, s_0_4, 3, 2, 0},
-/*  5 */ { 2, s_0_5, 3, 2, 0},
-/*  6 */ { 5, s_0_6, -1, 1, 0},
-/*  7 */ { 6, s_0_7, 6, 2, 0},
-/*  8 */ { 6, s_0_8, 6, 2, 0}
+	 /*  0 */ {3, s_0_0, -1, 1, 0},
+	 /*  1 */ {4, s_0_1, 0, 2, 0},
+	 /*  2 */ {4, s_0_2, 0, 2, 0},
+	 /*  3 */ {1, s_0_3, -1, 1, 0},
+	 /*  4 */ {2, s_0_4, 3, 2, 0},
+	 /*  5 */ {2, s_0_5, 3, 2, 0},
+	 /*  6 */ {5, s_0_6, -1, 1, 0},
+	 /*  7 */ {6, s_0_7, 6, 2, 0},
+	 /*  8 */ {6, s_0_8, 6, 2, 0}
 };
 
-static symbol s_1_0[2] = { 0xC0, 0xC0 };
-static symbol s_1_1[2] = { 0xC5, 0xC0 };
-static symbol s_1_2[2] = { 0xCF, 0xC0 };
-static symbol s_1_3[2] = { 0xD5, 0xC0 };
-static symbol s_1_4[2] = { 0xC5, 0xC5 };
-static symbol s_1_5[2] = { 0xC9, 0xC5 };
-static symbol s_1_6[2] = { 0xCF, 0xC5 };
-static symbol s_1_7[2] = { 0xD9, 0xC5 };
-static symbol s_1_8[2] = { 0xC9, 0xC8 };
-static symbol s_1_9[2] = { 0xD9, 0xC8 };
-static symbol s_1_10[3] = { 0xC9, 0xCD, 0xC9 };
-static symbol s_1_11[3] = { 0xD9, 0xCD, 0xC9 };
-static symbol s_1_12[2] = { 0xC5, 0xCA };
-static symbol s_1_13[2] = { 0xC9, 0xCA };
-static symbol s_1_14[2] = { 0xCF, 0xCA };
-static symbol s_1_15[2] = { 0xD9, 0xCA };
-static symbol s_1_16[2] = { 0xC5, 0xCD };
-static symbol s_1_17[2] = { 0xC9, 0xCD };
-static symbol s_1_18[2] = { 0xCF, 0xCD };
-static symbol s_1_19[2] = { 0xD9, 0xCD };
-static symbol s_1_20[3] = { 0xC5, 0xC7, 0xCF };
-static symbol s_1_21[3] = { 0xCF, 0xC7, 0xCF };
-static symbol s_1_22[2] = { 0xC1, 0xD1 };
-static symbol s_1_23[2] = { 0xD1, 0xD1 };
-static symbol s_1_24[3] = { 0xC5, 0xCD, 0xD5 };
-static symbol s_1_25[3] = { 0xCF, 0xCD, 0xD5 };
+static symbol s_1_0[2] = {0xC0, 0xC0};
+static symbol s_1_1[2] = {0xC5, 0xC0};
+static symbol s_1_2[2] = {0xCF, 0xC0};
+static symbol s_1_3[2] = {0xD5, 0xC0};
+static symbol s_1_4[2] = {0xC5, 0xC5};
+static symbol s_1_5[2] = {0xC9, 0xC5};
+static symbol s_1_6[2] = {0xCF, 0xC5};
+static symbol s_1_7[2] = {0xD9, 0xC5};
+static symbol s_1_8[2] = {0xC9, 0xC8};
+static symbol s_1_9[2] = {0xD9, 0xC8};
+static symbol s_1_10[3] = {0xC9, 0xCD, 0xC9};
+static symbol s_1_11[3] = {0xD9, 0xCD, 0xC9};
+static symbol s_1_12[2] = {0xC5, 0xCA};
+static symbol s_1_13[2] = {0xC9, 0xCA};
+static symbol s_1_14[2] = {0xCF, 0xCA};
+static symbol s_1_15[2] = {0xD9, 0xCA};
+static symbol s_1_16[2] = {0xC5, 0xCD};
+static symbol s_1_17[2] = {0xC9, 0xCD};
+static symbol s_1_18[2] = {0xCF, 0xCD};
+static symbol s_1_19[2] = {0xD9, 0xCD};
+static symbol s_1_20[3] = {0xC5, 0xC7, 0xCF};
+static symbol s_1_21[3] = {0xCF, 0xC7, 0xCF};
+static symbol s_1_22[2] = {0xC1, 0xD1};
+static symbol s_1_23[2] = {0xD1, 0xD1};
+static symbol s_1_24[3] = {0xC5, 0xCD, 0xD5};
+static symbol s_1_25[3] = {0xCF, 0xCD, 0xD5};
 
 static struct among a_1[26] =
 {
-/*  0 */ { 2, s_1_0, -1, 1, 0},
-/*  1 */ { 2, s_1_1, -1, 1, 0},
-/*  2 */ { 2, s_1_2, -1, 1, 0},
-/*  3 */ { 2, s_1_3, -1, 1, 0},
-/*  4 */ { 2, s_1_4, -1, 1, 0},
-/*  5 */ { 2, s_1_5, -1, 1, 0},
-/*  6 */ { 2, s_1_6, -1, 1, 0},
-/*  7 */ { 2, s_1_7, -1, 1, 0},
-/*  8 */ { 2, s_1_8, -1, 1, 0},
-/*  9 */ { 2, s_1_9, -1, 1, 0},
-/* 10 */ { 3, s_1_10, -1, 1, 0},
-/* 11 */ { 3, s_1_11, -1, 1, 0},
-/* 12 */ { 2, s_1_12, -1, 1, 0},
-/* 13 */ { 2, s_1_13, -1, 1, 0},
-/* 14 */ { 2, s_1_14, -1, 1, 0},
-/* 15 */ { 2, s_1_15, -1, 1, 0},
-/* 16 */ { 2, s_1_16, -1, 1, 0},
-/* 17 */ { 2, s_1_17, -1, 1, 0},
-/* 18 */ { 2, s_1_18, -1, 1, 0},
-/* 19 */ { 2, s_1_19, -1, 1, 0},
-/* 20 */ { 3, s_1_20, -1, 1, 0},
-/* 21 */ { 3, s_1_21, -1, 1, 0},
-/* 22 */ { 2, s_1_22, -1, 1, 0},
-/* 23 */ { 2, s_1_23, -1, 1, 0},
-/* 24 */ { 3, s_1_24, -1, 1, 0},
-/* 25 */ { 3, s_1_25, -1, 1, 0}
+	 /*  0 */ {2, s_1_0, -1, 1, 0},
+	 /*  1 */ {2, s_1_1, -1, 1, 0},
+	 /*  2 */ {2, s_1_2, -1, 1, 0},
+	 /*  3 */ {2, s_1_3, -1, 1, 0},
+	 /*  4 */ {2, s_1_4, -1, 1, 0},
+	 /*  5 */ {2, s_1_5, -1, 1, 0},
+	 /*  6 */ {2, s_1_6, -1, 1, 0},
+	 /*  7 */ {2, s_1_7, -1, 1, 0},
+	 /*  8 */ {2, s_1_8, -1, 1, 0},
+	 /*  9 */ {2, s_1_9, -1, 1, 0},
+	 /* 10 */ {3, s_1_10, -1, 1, 0},
+	 /* 11 */ {3, s_1_11, -1, 1, 0},
+	 /* 12 */ {2, s_1_12, -1, 1, 0},
+	 /* 13 */ {2, s_1_13, -1, 1, 0},
+	 /* 14 */ {2, s_1_14, -1, 1, 0},
+	 /* 15 */ {2, s_1_15, -1, 1, 0},
+	 /* 16 */ {2, s_1_16, -1, 1, 0},
+	 /* 17 */ {2, s_1_17, -1, 1, 0},
+	 /* 18 */ {2, s_1_18, -1, 1, 0},
+	 /* 19 */ {2, s_1_19, -1, 1, 0},
+	 /* 20 */ {3, s_1_20, -1, 1, 0},
+	 /* 21 */ {3, s_1_21, -1, 1, 0},
+	 /* 22 */ {2, s_1_22, -1, 1, 0},
+	 /* 23 */ {2, s_1_23, -1, 1, 0},
+	 /* 24 */ {3, s_1_24, -1, 1, 0},
+	 /* 25 */ {3, s_1_25, -1, 1, 0}
 };
 
-static symbol s_2_0[2] = { 0xC5, 0xCD };
-static symbol s_2_1[2] = { 0xCE, 0xCE };
-static symbol s_2_2[2] = { 0xD7, 0xDB };
-static symbol s_2_3[3] = { 0xC9, 0xD7, 0xDB };
-static symbol s_2_4[3] = { 0xD9, 0xD7, 0xDB };
-static symbol s_2_5[1] = { 0xDD };
-static symbol s_2_6[2] = { 0xC0, 0xDD };
-static symbol s_2_7[3] = { 0xD5, 0xC0, 0xDD };
+static symbol s_2_0[2] = {0xC5, 0xCD};
+static symbol s_2_1[2] = {0xCE, 0xCE};
+static symbol s_2_2[2] = {0xD7, 0xDB};
+static symbol s_2_3[3] = {0xC9, 0xD7, 0xDB};
+static symbol s_2_4[3] = {0xD9, 0xD7, 0xDB};
+static symbol s_2_5[1] = {0xDD};
+static symbol s_2_6[2] = {0xC0, 0xDD};
+static symbol s_2_7[3] = {0xD5, 0xC0, 0xDD};
 
 static struct among a_2[8] =
 {
-/*  0 */ { 2, s_2_0, -1, 1, 0},
-/*  1 */ { 2, s_2_1, -1, 1, 0},
-/*  2 */ { 2, s_2_2, -1, 1, 0},
-/*  3 */ { 3, s_2_3, 2, 2, 0},
-/*  4 */ { 3, s_2_4, 2, 2, 0},
-/*  5 */ { 1, s_2_5, -1, 1, 0},
-/*  6 */ { 2, s_2_6, 5, 1, 0},
-/*  7 */ { 3, s_2_7, 6, 2, 0}
+	 /*  0 */ {2, s_2_0, -1, 1, 0},
+	 /*  1 */ {2, s_2_1, -1, 1, 0},
+	 /*  2 */ {2, s_2_2, -1, 1, 0},
+	 /*  3 */ {3, s_2_3, 2, 2, 0},
+	 /*  4 */ {3, s_2_4, 2, 2, 0},
+	 /*  5 */ {1, s_2_5, -1, 1, 0},
+	 /*  6 */ {2, s_2_6, 5, 1, 0},
+	 /*  7 */ {3, s_2_7, 6, 2, 0}
 };
 
-static symbol s_3_0[2] = { 0xD3, 0xD1 };
-static symbol s_3_1[2] = { 0xD3, 0xD8 };
+static symbol s_3_0[2] = {0xD3, 0xD1};
+static symbol s_3_1[2] = {0xD3, 0xD8};
 
 static struct among a_3[2] =
 {
-/*  0 */ { 2, s_3_0, -1, 1, 0},
-/*  1 */ { 2, s_3_1, -1, 1, 0}
+	 /*  0 */ {2, s_3_0, -1, 1, 0},
+	 /*  1 */ {2, s_3_1, -1, 1, 0}
 };
 
-static symbol s_4_0[1] = { 0xC0 };
-static symbol s_4_1[2] = { 0xD5, 0xC0 };
-static symbol s_4_2[2] = { 0xCC, 0xC1 };
-static symbol s_4_3[3] = { 0xC9, 0xCC, 0xC1 };
-static symbol s_4_4[3] = { 0xD9, 0xCC, 0xC1 };
-static symbol s_4_5[2] = { 0xCE, 0xC1 };
-static symbol s_4_6[3] = { 0xC5, 0xCE, 0xC1 };
-static symbol s_4_7[3] = { 0xC5, 0xD4, 0xC5 };
-static symbol s_4_8[3] = { 0xC9, 0xD4, 0xC5 };
-static symbol s_4_9[3] = { 0xCA, 0xD4, 0xC5 };
-static symbol s_4_10[4] = { 0xC5, 0xCA, 0xD4, 0xC5 };
-static symbol s_4_11[4] = { 0xD5, 0xCA, 0xD4, 0xC5 };
-static symbol s_4_12[2] = { 0xCC, 0xC9 };
-static symbol s_4_13[3] = { 0xC9, 0xCC, 0xC9 };
-static symbol s_4_14[3] = { 0xD9, 0xCC, 0xC9 };
-static symbol s_4_15[1] = { 0xCA };
-static symbol s_4_16[2] = { 0xC5, 0xCA };
-static symbol s_4_17[2] = { 0xD5, 0xCA };
-static symbol s_4_18[1] = { 0xCC };
-static symbol s_4_19[2] = { 0xC9, 0xCC };
-static symbol s_4_20[2] = { 0xD9, 0xCC };
-static symbol s_4_21[2] = { 0xC5, 0xCD };
-static symbol s_4_22[2] = { 0xC9, 0xCD };
-static symbol s_4_23[2] = { 0xD9, 0xCD };
-static symbol s_4_24[1] = { 0xCE };
-static symbol s_4_25[2] = { 0xC5, 0xCE };
-static symbol s_4_26[2] = { 0xCC, 0xCF };
-static symbol s_4_27[3] = { 0xC9, 0xCC, 0xCF };
-static symbol s_4_28[3] = { 0xD9, 0xCC, 0xCF };
-static symbol s_4_29[2] = { 0xCE, 0xCF };
-static symbol s_4_30[3] = { 0xC5, 0xCE, 0xCF };
-static symbol s_4_31[3] = { 0xCE, 0xCE, 0xCF };
-static symbol s_4_32[2] = { 0xC0, 0xD4 };
-static symbol s_4_33[3] = { 0xD5, 0xC0, 0xD4 };
-static symbol s_4_34[2] = { 0xC5, 0xD4 };
-static symbol s_4_35[3] = { 0xD5, 0xC5, 0xD4 };
-static symbol s_4_36[2] = { 0xC9, 0xD4 };
-static symbol s_4_37[2] = { 0xD1, 0xD4 };
-static symbol s_4_38[2] = { 0xD9, 0xD4 };
-static symbol s_4_39[2] = { 0xD4, 0xD8 };
-static symbol s_4_40[3] = { 0xC9, 0xD4, 0xD8 };
-static symbol s_4_41[3] = { 0xD9, 0xD4, 0xD8 };
-static symbol s_4_42[3] = { 0xC5, 0xDB, 0xD8 };
-static symbol s_4_43[3] = { 0xC9, 0xDB, 0xD8 };
-static symbol s_4_44[2] = { 0xCE, 0xD9 };
-static symbol s_4_45[3] = { 0xC5, 0xCE, 0xD9 };
+static symbol s_4_0[1] = {0xC0};
+static symbol s_4_1[2] = {0xD5, 0xC0};
+static symbol s_4_2[2] = {0xCC, 0xC1};
+static symbol s_4_3[3] = {0xC9, 0xCC, 0xC1};
+static symbol s_4_4[3] = {0xD9, 0xCC, 0xC1};
+static symbol s_4_5[2] = {0xCE, 0xC1};
+static symbol s_4_6[3] = {0xC5, 0xCE, 0xC1};
+static symbol s_4_7[3] = {0xC5, 0xD4, 0xC5};
+static symbol s_4_8[3] = {0xC9, 0xD4, 0xC5};
+static symbol s_4_9[3] = {0xCA, 0xD4, 0xC5};
+static symbol s_4_10[4] = {0xC5, 0xCA, 0xD4, 0xC5};
+static symbol s_4_11[4] = {0xD5, 0xCA, 0xD4, 0xC5};
+static symbol s_4_12[2] = {0xCC, 0xC9};
+static symbol s_4_13[3] = {0xC9, 0xCC, 0xC9};
+static symbol s_4_14[3] = {0xD9, 0xCC, 0xC9};
+static symbol s_4_15[1] = {0xCA};
+static symbol s_4_16[2] = {0xC5, 0xCA};
+static symbol s_4_17[2] = {0xD5, 0xCA};
+static symbol s_4_18[1] = {0xCC};
+static symbol s_4_19[2] = {0xC9, 0xCC};
+static symbol s_4_20[2] = {0xD9, 0xCC};
+static symbol s_4_21[2] = {0xC5, 0xCD};
+static symbol s_4_22[2] = {0xC9, 0xCD};
+static symbol s_4_23[2] = {0xD9, 0xCD};
+static symbol s_4_24[1] = {0xCE};
+static symbol s_4_25[2] = {0xC5, 0xCE};
+static symbol s_4_26[2] = {0xCC, 0xCF};
+static symbol s_4_27[3] = {0xC9, 0xCC, 0xCF};
+static symbol s_4_28[3] = {0xD9, 0xCC, 0xCF};
+static symbol s_4_29[2] = {0xCE, 0xCF};
+static symbol s_4_30[3] = {0xC5, 0xCE, 0xCF};
+static symbol s_4_31[3] = {0xCE, 0xCE, 0xCF};
+static symbol s_4_32[2] = {0xC0, 0xD4};
+static symbol s_4_33[3] = {0xD5, 0xC0, 0xD4};
+static symbol s_4_34[2] = {0xC5, 0xD4};
+static symbol s_4_35[3] = {0xD5, 0xC5, 0xD4};
+static symbol s_4_36[2] = {0xC9, 0xD4};
+static symbol s_4_37[2] = {0xD1, 0xD4};
+static symbol s_4_38[2] = {0xD9, 0xD4};
+static symbol s_4_39[2] = {0xD4, 0xD8};
+static symbol s_4_40[3] = {0xC9, 0xD4, 0xD8};
+static symbol s_4_41[3] = {0xD9, 0xD4, 0xD8};
+static symbol s_4_42[3] = {0xC5, 0xDB, 0xD8};
+static symbol s_4_43[3] = {0xC9, 0xDB, 0xD8};
+static symbol s_4_44[2] = {0xCE, 0xD9};
+static symbol s_4_45[3] = {0xC5, 0xCE, 0xD9};
 
 static struct among a_4[46] =
 {
-/*  0 */ { 1, s_4_0, -1, 2, 0},
-/*  1 */ { 2, s_4_1, 0, 2, 0},
-/*  2 */ { 2, s_4_2, -1, 1, 0},
-/*  3 */ { 3, s_4_3, 2, 2, 0},
-/*  4 */ { 3, s_4_4, 2, 2, 0},
-/*  5 */ { 2, s_4_5, -1, 1, 0},
-/*  6 */ { 3, s_4_6, 5, 2, 0},
-/*  7 */ { 3, s_4_7, -1, 1, 0},
-/*  8 */ { 3, s_4_8, -1, 2, 0},
-/*  9 */ { 3, s_4_9, -1, 1, 0},
-/* 10 */ { 4, s_4_10, 9, 2, 0},
-/* 11 */ { 4, s_4_11, 9, 2, 0},
-/* 12 */ { 2, s_4_12, -1, 1, 0},
-/* 13 */ { 3, s_4_13, 12, 2, 0},
-/* 14 */ { 3, s_4_14, 12, 2, 0},
-/* 15 */ { 1, s_4_15, -1, 1, 0},
-/* 16 */ { 2, s_4_16, 15, 2, 0},
-/* 17 */ { 2, s_4_17, 15, 2, 0},
-/* 18 */ { 1, s_4_18, -1, 1, 0},
-/* 19 */ { 2, s_4_19, 18, 2, 0},
-/* 20 */ { 2, s_4_20, 18, 2, 0},
-/* 21 */ { 2, s_4_21, -1, 1, 0},
-/* 22 */ { 2, s_4_22, -1, 2, 0},
-/* 23 */ { 2, s_4_23, -1, 2, 0},
-/* 24 */ { 1, s_4_24, -1, 1, 0},
-/* 25 */ { 2, s_4_25, 24, 2, 0},
-/* 26 */ { 2, s_4_26, -1, 1, 0},
-/* 27 */ { 3, s_4_27, 26, 2, 0},
-/* 28 */ { 3, s_4_28, 26, 2, 0},
-/* 29 */ { 2, s_4_29, -1, 1, 0},
-/* 30 */ { 3, s_4_30, 29, 2, 0},
-/* 31 */ { 3, s_4_31, 29, 1, 0},
-/* 32 */ { 2, s_4_32, -1, 1, 0},
-/* 33 */ { 3, s_4_33, 32, 2, 0},
-/* 34 */ { 2, s_4_34, -1, 1, 0},
-/* 35 */ { 3, s_4_35, 34, 2, 0},
-/* 36 */ { 2, s_4_36, -1, 2, 0},
-/* 37 */ { 2, s_4_37, -1, 2, 0},
-/* 38 */ { 2, s_4_38, -1, 2, 0},
-/* 39 */ { 2, s_4_39, -1, 1, 0},
-/* 40 */ { 3, s_4_40, 39, 2, 0},
-/* 41 */ { 3, s_4_41, 39, 2, 0},
-/* 42 */ { 3, s_4_42, -1, 1, 0},
-/* 43 */ { 3, s_4_43, -1, 2, 0},
-/* 44 */ { 2, s_4_44, -1, 1, 0},
-/* 45 */ { 3, s_4_45, 44, 2, 0}
+	 /*  0 */ {1, s_4_0, -1, 2, 0},
+	 /*  1 */ {2, s_4_1, 0, 2, 0},
+	 /*  2 */ {2, s_4_2, -1, 1, 0},
+	 /*  3 */ {3, s_4_3, 2, 2, 0},
+	 /*  4 */ {3, s_4_4, 2, 2, 0},
+	 /*  5 */ {2, s_4_5, -1, 1, 0},
+	 /*  6 */ {3, s_4_6, 5, 2, 0},
+	 /*  7 */ {3, s_4_7, -1, 1, 0},
+	 /*  8 */ {3, s_4_8, -1, 2, 0},
+	 /*  9 */ {3, s_4_9, -1, 1, 0},
+	 /* 10 */ {4, s_4_10, 9, 2, 0},
+	 /* 11 */ {4, s_4_11, 9, 2, 0},
+	 /* 12 */ {2, s_4_12, -1, 1, 0},
+	 /* 13 */ {3, s_4_13, 12, 2, 0},
+	 /* 14 */ {3, s_4_14, 12, 2, 0},
+	 /* 15 */ {1, s_4_15, -1, 1, 0},
+	 /* 16 */ {2, s_4_16, 15, 2, 0},
+	 /* 17 */ {2, s_4_17, 15, 2, 0},
+	 /* 18 */ {1, s_4_18, -1, 1, 0},
+	 /* 19 */ {2, s_4_19, 18, 2, 0},
+	 /* 20 */ {2, s_4_20, 18, 2, 0},
+	 /* 21 */ {2, s_4_21, -1, 1, 0},
+	 /* 22 */ {2, s_4_22, -1, 2, 0},
+	 /* 23 */ {2, s_4_23, -1, 2, 0},
+	 /* 24 */ {1, s_4_24, -1, 1, 0},
+	 /* 25 */ {2, s_4_25, 24, 2, 0},
+	 /* 26 */ {2, s_4_26, -1, 1, 0},
+	 /* 27 */ {3, s_4_27, 26, 2, 0},
+	 /* 28 */ {3, s_4_28, 26, 2, 0},
+	 /* 29 */ {2, s_4_29, -1, 1, 0},
+	 /* 30 */ {3, s_4_30, 29, 2, 0},
+	 /* 31 */ {3, s_4_31, 29, 1, 0},
+	 /* 32 */ {2, s_4_32, -1, 1, 0},
+	 /* 33 */ {3, s_4_33, 32, 2, 0},
+	 /* 34 */ {2, s_4_34, -1, 1, 0},
+	 /* 35 */ {3, s_4_35, 34, 2, 0},
+	 /* 36 */ {2, s_4_36, -1, 2, 0},
+	 /* 37 */ {2, s_4_37, -1, 2, 0},
+	 /* 38 */ {2, s_4_38, -1, 2, 0},
+	 /* 39 */ {2, s_4_39, -1, 1, 0},
+	 /* 40 */ {3, s_4_40, 39, 2, 0},
+	 /* 41 */ {3, s_4_41, 39, 2, 0},
+	 /* 42 */ {3, s_4_42, -1, 1, 0},
+	 /* 43 */ {3, s_4_43, -1, 2, 0},
+	 /* 44 */ {2, s_4_44, -1, 1, 0},
+	 /* 45 */ {3, s_4_45, 44, 2, 0}
 };
 
-static symbol s_5_0[1] = { 0xC0 };
-static symbol s_5_1[2] = { 0xC9, 0xC0 };
-static symbol s_5_2[2] = { 0xD8, 0xC0 };
-static symbol s_5_3[1] = { 0xC1 };
-static symbol s_5_4[1] = { 0xC5 };
-static symbol s_5_5[2] = { 0xC9, 0xC5 };
-static symbol s_5_6[2] = { 0xD8, 0xC5 };
-static symbol s_5_7[2] = { 0xC1, 0xC8 };
-static symbol s_5_8[2] = { 0xD1, 0xC8 };
-static symbol s_5_9[3] = { 0xC9, 0xD1, 0xC8 };
-static symbol s_5_10[1] = { 0xC9 };
-static symbol s_5_11[2] = { 0xC5, 0xC9 };
-static symbol s_5_12[2] = { 0xC9, 0xC9 };
-static symbol s_5_13[3] = { 0xC1, 0xCD, 0xC9 };
-static symbol s_5_14[3] = { 0xD1, 0xCD, 0xC9 };
-static symbol s_5_15[4] = { 0xC9, 0xD1, 0xCD, 0xC9 };
-static symbol s_5_16[1] = { 0xCA };
-static symbol s_5_17[2] = { 0xC5, 0xCA };
-static symbol s_5_18[3] = { 0xC9, 0xC5, 0xCA };
-static symbol s_5_19[2] = { 0xC9, 0xCA };
-static symbol s_5_20[2] = { 0xCF, 0xCA };
-static symbol s_5_21[2] = { 0xC1, 0xCD };
-static symbol s_5_22[2] = { 0xC5, 0xCD };
-static symbol s_5_23[3] = { 0xC9, 0xC5, 0xCD };
-static symbol s_5_24[2] = { 0xCF, 0xCD };
-static symbol s_5_25[2] = { 0xD1, 0xCD };
-static symbol s_5_26[3] = { 0xC9, 0xD1, 0xCD };
-static symbol s_5_27[1] = { 0xCF };
-static symbol s_5_28[1] = { 0xD1 };
-static symbol s_5_29[2] = { 0xC9, 0xD1 };
-static symbol s_5_30[2] = { 0xD8, 0xD1 };
-static symbol s_5_31[1] = { 0xD5 };
-static symbol s_5_32[2] = { 0xC5, 0xD7 };
-static symbol s_5_33[2] = { 0xCF, 0xD7 };
-static symbol s_5_34[1] = { 0xD8 };
-static symbol s_5_35[1] = { 0xD9 };
+static symbol s_5_0[1] = {0xC0};
+static symbol s_5_1[2] = {0xC9, 0xC0};
+static symbol s_5_2[2] = {0xD8, 0xC0};
+static symbol s_5_3[1] = {0xC1};
+static symbol s_5_4[1] = {0xC5};
+static symbol s_5_5[2] = {0xC9, 0xC5};
+static symbol s_5_6[2] = {0xD8, 0xC5};
+static symbol s_5_7[2] = {0xC1, 0xC8};
+static symbol s_5_8[2] = {0xD1, 0xC8};
+static symbol s_5_9[3] = {0xC9, 0xD1, 0xC8};
+static symbol s_5_10[1] = {0xC9};
+static symbol s_5_11[2] = {0xC5, 0xC9};
+static symbol s_5_12[2] = {0xC9, 0xC9};
+static symbol s_5_13[3] = {0xC1, 0xCD, 0xC9};
+static symbol s_5_14[3] = {0xD1, 0xCD, 0xC9};
+static symbol s_5_15[4] = {0xC9, 0xD1, 0xCD, 0xC9};
+static symbol s_5_16[1] = {0xCA};
+static symbol s_5_17[2] = {0xC5, 0xCA};
+static symbol s_5_18[3] = {0xC9, 0xC5, 0xCA};
+static symbol s_5_19[2] = {0xC9, 0xCA};
+static symbol s_5_20[2] = {0xCF, 0xCA};
+static symbol s_5_21[2] = {0xC1, 0xCD};
+static symbol s_5_22[2] = {0xC5, 0xCD};
+static symbol s_5_23[3] = {0xC9, 0xC5, 0xCD};
+static symbol s_5_24[2] = {0xCF, 0xCD};
+static symbol s_5_25[2] = {0xD1, 0xCD};
+static symbol s_5_26[3] = {0xC9, 0xD1, 0xCD};
+static symbol s_5_27[1] = {0xCF};
+static symbol s_5_28[1] = {0xD1};
+static symbol s_5_29[2] = {0xC9, 0xD1};
+static symbol s_5_30[2] = {0xD8, 0xD1};
+static symbol s_5_31[1] = {0xD5};
+static symbol s_5_32[2] = {0xC5, 0xD7};
+static symbol s_5_33[2] = {0xCF, 0xD7};
+static symbol s_5_34[1] = {0xD8};
+static symbol s_5_35[1] = {0xD9};
 
 static struct among a_5[36] =
 {
-/*  0 */ { 1, s_5_0, -1, 1, 0},
-/*  1 */ { 2, s_5_1, 0, 1, 0},
-/*  2 */ { 2, s_5_2, 0, 1, 0},
-/*  3 */ { 1, s_5_3, -1, 1, 0},
-/*  4 */ { 1, s_5_4, -1, 1, 0},
-/*  5 */ { 2, s_5_5, 4, 1, 0},
-/*  6 */ { 2, s_5_6, 4, 1, 0},
-/*  7 */ { 2, s_5_7, -1, 1, 0},
-/*  8 */ { 2, s_5_8, -1, 1, 0},
-/*  9 */ { 3, s_5_9, 8, 1, 0},
-/* 10 */ { 1, s_5_10, -1, 1, 0},
-/* 11 */ { 2, s_5_11, 10, 1, 0},
-/* 12 */ { 2, s_5_12, 10, 1, 0},
-/* 13 */ { 3, s_5_13, 10, 1, 0},
-/* 14 */ { 3, s_5_14, 10, 1, 0},
-/* 15 */ { 4, s_5_15, 14, 1, 0},
-/* 16 */ { 1, s_5_16, -1, 1, 0},
-/* 17 */ { 2, s_5_17, 16, 1, 0},
-/* 18 */ { 3, s_5_18, 17, 1, 0},
-/* 19 */ { 2, s_5_19, 16, 1, 0},
-/* 20 */ { 2, s_5_20, 16, 1, 0},
-/* 21 */ { 2, s_5_21, -1, 1, 0},
-/* 22 */ { 2, s_5_22, -1, 1, 0},
-/* 23 */ { 3, s_5_23, 22, 1, 0},
-/* 24 */ { 2, s_5_24, -1, 1, 0},
-/* 25 */ { 2, s_5_25, -1, 1, 0},
-/* 26 */ { 3, s_5_26, 25, 1, 0},
-/* 27 */ { 1, s_5_27, -1, 1, 0},
-/* 28 */ { 1, s_5_28, -1, 1, 0},
-/* 29 */ { 2, s_5_29, 28, 1, 0},
-/* 30 */ { 2, s_5_30, 28, 1, 0},
-/* 31 */ { 1, s_5_31, -1, 1, 0},
-/* 32 */ { 2, s_5_32, -1, 1, 0},
-/* 33 */ { 2, s_5_33, -1, 1, 0},
-/* 34 */ { 1, s_5_34, -1, 1, 0},
-/* 35 */ { 1, s_5_35, -1, 1, 0}
+	 /*  0 */ {1, s_5_0, -1, 1, 0},
+	 /*  1 */ {2, s_5_1, 0, 1, 0},
+	 /*  2 */ {2, s_5_2, 0, 1, 0},
+	 /*  3 */ {1, s_5_3, -1, 1, 0},
+	 /*  4 */ {1, s_5_4, -1, 1, 0},
+	 /*  5 */ {2, s_5_5, 4, 1, 0},
+	 /*  6 */ {2, s_5_6, 4, 1, 0},
+	 /*  7 */ {2, s_5_7, -1, 1, 0},
+	 /*  8 */ {2, s_5_8, -1, 1, 0},
+	 /*  9 */ {3, s_5_9, 8, 1, 0},
+	 /* 10 */ {1, s_5_10, -1, 1, 0},
+	 /* 11 */ {2, s_5_11, 10, 1, 0},
+	 /* 12 */ {2, s_5_12, 10, 1, 0},
+	 /* 13 */ {3, s_5_13, 10, 1, 0},
+	 /* 14 */ {3, s_5_14, 10, 1, 0},
+	 /* 15 */ {4, s_5_15, 14, 1, 0},
+	 /* 16 */ {1, s_5_16, -1, 1, 0},
+	 /* 17 */ {2, s_5_17, 16, 1, 0},
+	 /* 18 */ {3, s_5_18, 17, 1, 0},
+	 /* 19 */ {2, s_5_19, 16, 1, 0},
+	 /* 20 */ {2, s_5_20, 16, 1, 0},
+	 /* 21 */ {2, s_5_21, -1, 1, 0},
+	 /* 22 */ {2, s_5_22, -1, 1, 0},
+	 /* 23 */ {3, s_5_23, 22, 1, 0},
+	 /* 24 */ {2, s_5_24, -1, 1, 0},
+	 /* 25 */ {2, s_5_25, -1, 1, 0},
+	 /* 26 */ {3, s_5_26, 25, 1, 0},
+	 /* 27 */ {1, s_5_27, -1, 1, 0},
+	 /* 28 */ {1, s_5_28, -1, 1, 0},
+	 /* 29 */ {2, s_5_29, 28, 1, 0},
+	 /* 30 */ {2, s_5_30, 28, 1, 0},
+	 /* 31 */ {1, s_5_31, -1, 1, 0},
+	 /* 32 */ {2, s_5_32, -1, 1, 0},
+	 /* 33 */ {2, s_5_33, -1, 1, 0},
+	 /* 34 */ {1, s_5_34, -1, 1, 0},
+	 /* 35 */ {1, s_5_35, -1, 1, 0}
 };
 
-static symbol s_6_0[3] = { 0xCF, 0xD3, 0xD4 };
-static symbol s_6_1[4] = { 0xCF, 0xD3, 0xD4, 0xD8 };
+static symbol s_6_0[3] = {0xCF, 0xD3, 0xD4};
+static symbol s_6_1[4] = {0xCF, 0xD3, 0xD4, 0xD8};
 
 static struct among a_6[2] =
 {
-/*  0 */ { 3, s_6_0, -1, 1, 0},
-/*  1 */ { 4, s_6_1, -1, 1, 0}
+	 /*  0 */ {3, s_6_0, -1, 1, 0},
+	 /*  1 */ {4, s_6_1, -1, 1, 0}
 };
 
-static symbol s_7_0[4] = { 0xC5, 0xCA, 0xDB, 0xC5 };
-static symbol s_7_1[1] = { 0xCE };
-static symbol s_7_2[1] = { 0xD8 };
-static symbol s_7_3[3] = { 0xC5, 0xCA, 0xDB };
+static symbol s_7_0[4] = {0xC5, 0xCA, 0xDB, 0xC5};
+static symbol s_7_1[1] = {0xCE};
+static symbol s_7_2[1] = {0xD8};
+static symbol s_7_3[3] = {0xC5, 0xCA, 0xDB};
 
 static struct among a_7[4] =
 {
-/*  0 */ { 4, s_7_0, -1, 1, 0},
-/*  1 */ { 1, s_7_1, -1, 2, 0},
-/*  2 */ { 1, s_7_2, -1, 3, 0},
-/*  3 */ { 3, s_7_3, -1, 1, 0}
+	 /*  0 */ {4, s_7_0, -1, 1, 0},
+	 /*  1 */ {1, s_7_1, -1, 2, 0},
+	 /*  2 */ {1, s_7_2, -1, 3, 0},
+	 /*  3 */ {3, s_7_3, -1, 1, 0}
 };
 
-static unsigned char g_v[] = { 35, 130, 34, 18 };
-
-static symbol s_0[] = { 0xC1 };
-static symbol s_1[] = { 0xD1 };
-static symbol s_2[] = { 0xC1 };
-static symbol s_3[] = { 0xD1 };
-static symbol s_4[] = { 0xC1 };
-static symbol s_5[] = { 0xD1 };
-static symbol s_6[] = { 0xCE };
-static symbol s_7[] = { 0xCE };
-static symbol s_8[] = { 0xCE };
-static symbol s_9[] = { 0xC9 };
-
-static int r_mark_regions(struct SN_env * z) {
-    z->I[0] = z->l;
-    z->I[1] = z->l;
-    {   int c = z->c; /* do, line 63 */
-        while(1) { /* gopast, line 64 */
-            if (!(in_grouping(z, g_v, 192, 220))) goto lab1;
-            break;
-        lab1:
-            if (z->c >= z->l) goto lab0;
-            z->c++; /* gopast, line 64 */
-        }
-        z->I[0] = z->c; /* setmark pV, line 64 */
-        while(1) { /* gopast, line 64 */
-            if (!(out_grouping(z, g_v, 192, 220))) goto lab2;
-            break;
-        lab2:
-            if (z->c >= z->l) goto lab0;
-            z->c++; /* gopast, line 64 */
-        }
-        while(1) { /* gopast, line 65 */
-            if (!(in_grouping(z, g_v, 192, 220))) goto lab3;
-            break;
-        lab3:
-            if (z->c >= z->l) goto lab0;
-            z->c++; /* gopast, line 65 */
-        }
-        while(1) { /* gopast, line 65 */
-            if (!(out_grouping(z, g_v, 192, 220))) goto lab4;
-            break;
-        lab4:
-            if (z->c >= z->l) goto lab0;
-            z->c++; /* gopast, line 65 */
-        }
-        z->I[1] = z->c; /* setmark p2, line 65 */
-    lab0:
-        z->c = c;
-    }
-    return 1;
+static unsigned char g_v[] = {35, 130, 34, 18};
+
+static symbol s_0[] = {0xC1};
+static symbol s_1[] = {0xD1};
+static symbol s_2[] = {0xC1};
+static symbol s_3[] = {0xD1};
+static symbol s_4[] = {0xC1};
+static symbol s_5[] = {0xD1};
+static symbol s_6[] = {0xCE};
+static symbol s_7[] = {0xCE};
+static symbol s_8[] = {0xCE};
+static symbol s_9[] = {0xC9};
+
+static int
+r_mark_regions(struct SN_env * z)
+{
+	z->I[0] = z->l;
+	z->I[1] = z->l;
+	{
+		int			c = z->c;	/* do, line 63 */
+
+		while (1)
+		{						/* gopast, line 64 */
+			if (!(in_grouping(z, g_v, 192, 220)))
+				goto lab1;
+			break;
+	lab1:
+			if (z->c >= z->l)
+				goto lab0;
+			z->c++;				/* gopast, line 64 */
+		}
+		z->I[0] = z->c;			/* setmark pV, line 64 */
+		while (1)
+		{						/* gopast, line 64 */
+			if (!(out_grouping(z, g_v, 192, 220)))
+				goto lab2;
+			break;
+	lab2:
+			if (z->c >= z->l)
+				goto lab0;
+			z->c++;				/* gopast, line 64 */
+		}
+		while (1)
+		{						/* gopast, line 65 */
+			if (!(in_grouping(z, g_v, 192, 220)))
+				goto lab3;
+			break;
+	lab3:
+			if (z->c >= z->l)
+				goto lab0;
+			z->c++;				/* gopast, line 65 */
+		}
+		while (1)
+		{						/* gopast, line 65 */
+			if (!(out_grouping(z, g_v, 192, 220)))
+				goto lab4;
+			break;
+	lab4:
+			if (z->c >= z->l)
+				goto lab0;
+			z->c++;				/* gopast, line 65 */
+		}
+		z->I[1] = z->c;			/* setmark p2, line 65 */
+lab0:
+		z->c = c;
+	}
+	return 1;
 }
 
-static int r_R2(struct SN_env * z) {
-    if (!(z->I[1] <= z->c)) return 0;
-    return 1;
+static int
+r_R2(struct SN_env * z)
+{
+	if (!(z->I[1] <= z->c))
+		return 0;
+	return 1;
 }
 
-static int r_perfective_gerund(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 74 */
-    among_var = find_among_b(z, a_0, 9); /* substring, line 74 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 74 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int m = z->l - z->c; (void) m; /* or, line 78 */
-                if (!(eq_s_b(z, 1, s_0))) goto lab1;
-                goto lab0;
-            lab1:
-                z->c = z->l - m;
-                if (!(eq_s_b(z, 1, s_1))) return 0;
-            }
-        lab0:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 78 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 85 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_perfective_gerund(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 74 */
+	among_var = find_among_b(z, a_0, 9);		/* substring, line 74 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 74 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* or, line 78 */
+				if (!(eq_s_b(z, 1, s_0)))
+					goto lab1;
+				goto lab0;
+		lab1:
+				z->c = z->l - m;
+				if (!(eq_s_b(z, 1, s_1)))
+					return 0;
+			}
+	lab0:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 78 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 85 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_adjective(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 90 */
-    among_var = find_among_b(z, a_1, 26); /* substring, line 90 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 90 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 99 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_adjective(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 90 */
+	among_var = find_among_b(z, a_1, 26);		/* substring, line 90 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 90 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 99 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_adjectival(struct SN_env * z) {
-    int among_var;
-    {   int ret = r_adjective(z);
-        if (ret == 0) return 0; /* call adjective, line 104 */
-        if (ret < 0) return ret;
-    }
-    {   int m = z->l - z->c; (void) m; /* try, line 111 */
-        z->ket = z->c; /* [, line 112 */
-        among_var = find_among_b(z, a_2, 8); /* substring, line 112 */
-        if (!(among_var)) { z->c = z->l - m; goto lab0; }
-        z->bra = z->c; /* ], line 112 */
-        switch(among_var) {
-            case 0: { z->c = z->l - m; goto lab0; }
-            case 1:
-                {   int m = z->l - z->c; (void) m; /* or, line 117 */
-                    if (!(eq_s_b(z, 1, s_2))) goto lab2;
-                    goto lab1;
-                lab2:
-                    z->c = z->l - m;
-                    if (!(eq_s_b(z, 1, s_3))) { z->c = z->l - m; goto lab0; }
-                }
-            lab1:
-                {   int ret;
-                    ret = slice_del(z); /* delete, line 117 */
-                    if (ret < 0) return ret;
-                }
-                break;
-            case 2:
-                {   int ret;
-                    ret = slice_del(z); /* delete, line 124 */
-                    if (ret < 0) return ret;
-                }
-                break;
-        }
-    lab0:
-        ;
-    }
-    return 1;
+static int
+r_adjectival(struct SN_env * z)
+{
+	int			among_var;
+
+	{
+		int			ret = r_adjective(z);
+
+		if (ret == 0)
+			return 0;			/* call adjective, line 104 */
+		if (ret < 0)
+			return ret;
+	}
+	{
+		int			m = z->l - z->c;
+
+		(void) m;				/* try, line 111 */
+		z->ket = z->c;			/* [, line 112 */
+		among_var = find_among_b(z, a_2, 8);	/* substring, line 112 */
+		if (!(among_var))
+		{
+			z->c = z->l - m;
+			goto lab0;
+		}
+		z->bra = z->c;			/* ], line 112 */
+		switch (among_var)
+		{
+			case 0:
+				{
+					z->c = z->l - m;
+					goto lab0;
+				}
+			case 1:
+				{
+					int			m = z->l - z->c;
+
+					(void) m;	/* or, line 117 */
+					if (!(eq_s_b(z, 1, s_2)))
+						goto lab2;
+					goto lab1;
+			lab2:
+					z->c = z->l - m;
+					if (!(eq_s_b(z, 1, s_3)))
+					{
+						z->c = z->l - m;
+						goto lab0;
+					}
+				}
+		lab1:
+				{
+					int			ret;
+
+					ret = slice_del(z); /* delete, line 117 */
+					if (ret < 0)
+						return ret;
+				}
+				break;
+			case 2:
+				{
+					int			ret;
+
+					ret = slice_del(z); /* delete, line 124 */
+					if (ret < 0)
+						return ret;
+				}
+				break;
+		}
+lab0:
+		;
+	}
+	return 1;
 }
 
-static int r_reflexive(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 131 */
-    among_var = find_among_b(z, a_3, 2); /* substring, line 131 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 131 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 134 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_reflexive(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 131 */
+	among_var = find_among_b(z, a_3, 2);		/* substring, line 131 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 131 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 134 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_verb(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 139 */
-    among_var = find_among_b(z, a_4, 46); /* substring, line 139 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 139 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int m = z->l - z->c; (void) m; /* or, line 145 */
-                if (!(eq_s_b(z, 1, s_4))) goto lab1;
-                goto lab0;
-            lab1:
-                z->c = z->l - m;
-                if (!(eq_s_b(z, 1, s_5))) return 0;
-            }
-        lab0:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 145 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 153 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_verb(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 139 */
+	among_var = find_among_b(z, a_4, 46);		/* substring, line 139 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 139 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* or, line 145 */
+				if (!(eq_s_b(z, 1, s_4)))
+					goto lab1;
+				goto lab0;
+		lab1:
+				z->c = z->l - m;
+				if (!(eq_s_b(z, 1, s_5)))
+					return 0;
+			}
+	lab0:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 145 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 153 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_noun(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 162 */
-    among_var = find_among_b(z, a_5, 36); /* substring, line 162 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 162 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 169 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_noun(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 162 */
+	among_var = find_among_b(z, a_5, 36);		/* substring, line 162 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 162 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 169 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_derivational(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 178 */
-    among_var = find_among_b(z, a_6, 2); /* substring, line 178 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 178 */
-    {   int ret = r_R2(z);
-        if (ret == 0) return 0; /* call R2, line 178 */
-        if (ret < 0) return ret;
-    }
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 181 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_derivational(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 178 */
+	among_var = find_among_b(z, a_6, 2);		/* substring, line 178 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 178 */
+	{
+		int			ret = r_R2(z);
+
+		if (ret == 0)
+			return 0;			/* call R2, line 178 */
+		if (ret < 0)
+			return ret;
+	}
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 181 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-static int r_tidy_up(struct SN_env * z) {
-    int among_var;
-    z->ket = z->c; /* [, line 186 */
-    among_var = find_among_b(z, a_7, 4); /* substring, line 186 */
-    if (!(among_var)) return 0;
-    z->bra = z->c; /* ], line 186 */
-    switch(among_var) {
-        case 0: return 0;
-        case 1:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 190 */
-                if (ret < 0) return ret;
-            }
-            z->ket = z->c; /* [, line 191 */
-            if (!(eq_s_b(z, 1, s_6))) return 0;
-            z->bra = z->c; /* ], line 191 */
-            if (!(eq_s_b(z, 1, s_7))) return 0;
-            {   int ret;
-                ret = slice_del(z); /* delete, line 191 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 2:
-            if (!(eq_s_b(z, 1, s_8))) return 0;
-            {   int ret;
-                ret = slice_del(z); /* delete, line 194 */
-                if (ret < 0) return ret;
-            }
-            break;
-        case 3:
-            {   int ret;
-                ret = slice_del(z); /* delete, line 196 */
-                if (ret < 0) return ret;
-            }
-            break;
-    }
-    return 1;
+static int
+r_tidy_up(struct SN_env * z)
+{
+	int			among_var;
+
+	z->ket = z->c;				/* [, line 186 */
+	among_var = find_among_b(z, a_7, 4);		/* substring, line 186 */
+	if (!(among_var))
+		return 0;
+	z->bra = z->c;				/* ], line 186 */
+	switch (among_var)
+	{
+		case 0:
+			return 0;
+		case 1:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 190 */
+				if (ret < 0)
+					return ret;
+			}
+			z->ket = z->c;		/* [, line 191 */
+			if (!(eq_s_b(z, 1, s_6)))
+				return 0;
+			z->bra = z->c;		/* ], line 191 */
+			if (!(eq_s_b(z, 1, s_7)))
+				return 0;
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 191 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 2:
+			if (!(eq_s_b(z, 1, s_8)))
+				return 0;
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 194 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+		case 3:
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 196 */
+				if (ret < 0)
+					return ret;
+			}
+			break;
+	}
+	return 1;
 }
 
-extern int russian_KOI8_R_stem(struct SN_env * z) {
-    {   int c = z->c; /* do, line 203 */
-        {   int ret = r_mark_regions(z);
-            if (ret == 0) goto lab0; /* call mark_regions, line 203 */
-            if (ret < 0) return ret;
-        }
-    lab0:
-        z->c = c;
-    }
-    z->lb = z->c; z->c = z->l; /* backwards, line 204 */
-
-    {   int m3; /* setlimit, line 204 */
-        int m = z->l - z->c; (void) m;
-        if (z->c < z->I[0]) return 0;
-        z->c = z->I[0]; /* tomark, line 204 */
-        m3 = z->lb; z->lb = z->c;
-        z->c = z->l - m;
-        {   int m = z->l - z->c; (void) m; /* do, line 205 */
-            {   int m = z->l - z->c; (void) m; /* or, line 206 */
-                {   int ret = r_perfective_gerund(z);
-                    if (ret == 0) goto lab3; /* call perfective_gerund, line 206 */
-                    if (ret < 0) return ret;
-                }
-                goto lab2;
-            lab3:
-                z->c = z->l - m;
-                {   int m = z->l - z->c; (void) m; /* try, line 207 */
-                    {   int ret = r_reflexive(z);
-                        if (ret == 0) { z->c = z->l - m; goto lab4; } /* call reflexive, line 207 */
-                        if (ret < 0) return ret;
-                    }
-                lab4:
-                    ;
-                }
-                {   int m = z->l - z->c; (void) m; /* or, line 208 */
-                    {   int ret = r_adjectival(z);
-                        if (ret == 0) goto lab6; /* call adjectival, line 208 */
-                        if (ret < 0) return ret;
-                    }
-                    goto lab5;
-                lab6:
-                    z->c = z->l - m;
-                    {   int ret = r_verb(z);
-                        if (ret == 0) goto lab7; /* call verb, line 208 */
-                        if (ret < 0) return ret;
-                    }
-                    goto lab5;
-                lab7:
-                    z->c = z->l - m;
-                    {   int ret = r_noun(z);
-                        if (ret == 0) goto lab1; /* call noun, line 208 */
-                        if (ret < 0) return ret;
-                    }
-                }
-            lab5:
-                ;
-            }
-        lab2:
-        lab1:
-            z->c = z->l - m;
-        }
-        {   int m = z->l - z->c; (void) m; /* try, line 211 */
-            z->ket = z->c; /* [, line 211 */
-            if (!(eq_s_b(z, 1, s_9))) { z->c = z->l - m; goto lab8; }
-            z->bra = z->c; /* ], line 211 */
-            {   int ret;
-                ret = slice_del(z); /* delete, line 211 */
-                if (ret < 0) return ret;
-            }
-        lab8:
-            ;
-        }
-        {   int m = z->l - z->c; (void) m; /* do, line 214 */
-            {   int ret = r_derivational(z);
-                if (ret == 0) goto lab9; /* call derivational, line 214 */
-                if (ret < 0) return ret;
-            }
-        lab9:
-            z->c = z->l - m;
-        }
-        {   int m = z->l - z->c; (void) m; /* do, line 215 */
-            {   int ret = r_tidy_up(z);
-                if (ret == 0) goto lab10; /* call tidy_up, line 215 */
-                if (ret < 0) return ret;
-            }
-        lab10:
-            z->c = z->l - m;
-        }
-        z->lb = m3;
-    }
-    z->c = z->lb;
-    return 1;
+extern int
+russian_KOI8_R_stem(struct SN_env * z)
+{
+	{
+		int			c = z->c;	/* do, line 203 */
+
+		{
+			int			ret = r_mark_regions(z);
+
+			if (ret == 0)
+				goto lab0;		/* call mark_regions, line 203 */
+			if (ret < 0)
+				return ret;
+		}
+lab0:
+		z->c = c;
+	}
+	z->lb = z->c;
+	z->c = z->l;				/* backwards, line 204 */
+
+	{
+		int			m3;			/* setlimit, line 204 */
+		int			m = z->l - z->c;
+
+		(void) m;
+		if (z->c < z->I[0])
+			return 0;
+		z->c = z->I[0];			/* tomark, line 204 */
+		m3 = z->lb;
+		z->lb = z->c;
+		z->c = z->l - m;
+		{
+			int			m = z->l - z->c;
+
+			(void) m;			/* do, line 205 */
+			{
+				int			m = z->l - z->c;
+
+				(void) m;		/* or, line 206 */
+				{
+					int			ret = r_perfective_gerund(z);
+
+					if (ret == 0)
+						goto lab3;		/* call perfective_gerund, line 206 */
+					if (ret < 0)
+						return ret;
+				}
+				goto lab2;
+		lab3:
+				z->c = z->l - m;
+				{
+					int			m = z->l - z->c;
+
+					(void) m;	/* try, line 207 */
+					{
+						int			ret = r_reflexive(z);
+
+						if (ret == 0)
+						{
+							z->c = z->l - m;
+							goto lab4;
+						}		/* call reflexive, line 207 */
+						if (ret < 0)
+							return ret;
+					}
+			lab4:
+					;
+				}
+				{
+					int			m = z->l - z->c;
+
+					(void) m;	/* or, line 208 */
+					{
+						int			ret = r_adjectival(z);
+
+						if (ret == 0)
+							goto lab6;	/* call adjectival, line 208 */
+						if (ret < 0)
+							return ret;
+					}
+					goto lab5;
+			lab6:
+					z->c = z->l - m;
+					{
+						int			ret = r_verb(z);
+
+						if (ret == 0)
+							goto lab7;	/* call verb, line 208 */
+						if (ret < 0)
+							return ret;
+					}
+					goto lab5;
+			lab7:
+					z->c = z->l - m;
+					{
+						int			ret = r_noun(z);
+
+						if (ret == 0)
+							goto lab1;	/* call noun, line 208 */
+						if (ret < 0)
+							return ret;
+					}
+				}
+		lab5:
+				;
+			}
+	lab2:
+	lab1:
+			z->c = z->l - m;
+		}
+		{
+			int			m = z->l - z->c;
+
+			(void) m;			/* try, line 211 */
+			z->ket = z->c;		/* [, line 211 */
+			if (!(eq_s_b(z, 1, s_9)))
+			{
+				z->c = z->l - m;
+				goto lab8;
+			}
+			z->bra = z->c;		/* ], line 211 */
+			{
+				int			ret;
+
+				ret = slice_del(z);		/* delete, line 211 */
+				if (ret < 0)
+					return ret;
+			}
+	lab8:
+			;
+		}
+		{
+			int			m = z->l - z->c;
+
+			(void) m;			/* do, line 214 */
+			{
+				int			ret = r_derivational(z);
+
+				if (ret == 0)
+					goto lab9;	/* call derivational, line 214 */
+				if (ret < 0)
+					return ret;
+			}
+	lab9:
+			z->c = z->l - m;
+		}
+		{
+			int			m = z->l - z->c;
+
+			(void) m;			/* do, line 215 */
+			{
+				int			ret = r_tidy_up(z);
+
+				if (ret == 0)
+					goto lab10; /* call tidy_up, line 215 */
+				if (ret < 0)
+					return ret;
+			}
+	lab10:
+			z->c = z->l - m;
+		}
+		z->lb = m3;
+	}
+	z->c = z->lb;
+	return 1;
 }
 
-extern struct SN_env * russian_KOI8_R_create_env(void) { return SN_create_env(0, 2, 0); }
-
-extern void russian_KOI8_R_close_env(struct SN_env * z) { SN_close_env(z); }
+extern struct SN_env *russian_KOI8_R_create_env(void)
+{
+	return SN_create_env(0, 2, 0);
+}
 
+extern void russian_KOI8_R_close_env(struct SN_env * z)
+{
+	SN_close_env(z);
+}
diff --git a/contrib/tsearch2/snowball/russian_stem.h b/contrib/tsearch2/snowball/russian_stem.h
index de2179d29f..84941b037f 100644
--- a/contrib/tsearch2/snowball/russian_stem.h
+++ b/contrib/tsearch2/snowball/russian_stem.h
@@ -2,15 +2,16 @@
 /* This file was generated automatically by the Snowball to ANSI C compiler */
 
 #ifdef __cplusplus
-extern "C" {
+extern		"C"
+{
 #endif
 
-extern struct SN_env * russian_KOI8_R_create_env(void);
-extern void russian_KOI8_R_close_env(struct SN_env * z);
+	extern struct SN_env *russian_KOI8_R_create_env(void);
+	extern void russian_KOI8_R_close_env(struct SN_env * z);
 
-extern int russian_KOI8_R_stem(struct SN_env * z);
+	extern int	russian_KOI8_R_stem(struct SN_env * z);
 
 #ifdef __cplusplus
 }
-#endif
 
+#endif
diff --git a/contrib/tsearch2/snowball/utilities.c b/contrib/tsearch2/snowball/utilities.c
index a6bfa5c76a..f06e5bb7a1 100644
--- a/contrib/tsearch2/snowball/utilities.c
+++ b/contrib/tsearch2/snowball/utilities.c
@@ -9,19 +9,26 @@
 
 #define CREATE_SIZE 1
 
-extern symbol * create_s(void) {
-    symbol * p;
-    void * mem = malloc(HEAD + (CREATE_SIZE + 1) * sizeof(symbol));
-    if (mem == NULL) return NULL;
-    p = (symbol *) (HEAD + (char *) mem);
-    CAPACITY(p) = CREATE_SIZE;
-    SET_SIZE(p, CREATE_SIZE);
-    return p;
+extern symbol *
+create_s(void)
+{
+	symbol	   *p;
+	void	   *mem = malloc(HEAD + (CREATE_SIZE + 1) * sizeof(symbol));
+
+	if (mem == NULL)
+		return NULL;
+	p = (symbol *) (HEAD + (char *) mem);
+	CAPACITY(p) = CREATE_SIZE;
+	SET_SIZE(p, CREATE_SIZE);
+	return p;
 }
 
-extern void lose_s(symbol * p) {
-    if (p == NULL) return;
-    free((char *) p - HEAD);
+extern void
+lose_s(symbol * p)
+{
+	if (p == NULL)
+		return;
+	free((char *) p - HEAD);
 }
 
 /*
@@ -32,280 +39,435 @@ extern void lose_s(symbol * p) {
    -- used to implement hop and next in the utf8 case.
 */
 
-extern int skip_utf8(const symbol * p, int c, int lb, int l, int n) {
-    int b;
-    if (n >= 0) {
-        for (; n > 0; n--) {
-            if (c >= l) return -1;
-            b = p[c++];
-            if (b >= 0xC0) {   /* 1100 0000 */
-                while (c < l) {
-                    b = p[c];
-                    if (b >= 0xC0 || b < 0x80) break;
-                    /* break unless b is 10------ */
-                    c++;
-                }
-            }
-        }
-    } else {
-        for (; n < 0; n++) {
-            if (c <= lb) return -1;
-            b = p[--c];
-            if (b >= 0x80) {   /* 1000 0000 */
-                while (c > lb) {
-                    b = p[c];
-                    if (b >= 0xC0) break; /* 1100 0000 */
-                    c--;
-                }
-            }
-        }
-    }
-    return c;
+extern int
+skip_utf8(const symbol * p, int c, int lb, int l, int n)
+{
+	int			b;
+
+	if (n >= 0)
+	{
+		for (; n > 0; n--)
+		{
+			if (c >= l)
+				return -1;
+			b = p[c++];
+			if (b >= 0xC0)
+			{					/* 1100 0000 */
+				while (c < l)
+				{
+					b = p[c];
+					if (b >= 0xC0 || b < 0x80)
+						break;
+					/* break unless b is 10------ */
+					c++;
+				}
+			}
+		}
+	}
+	else
+	{
+		for (; n < 0; n++)
+		{
+			if (c <= lb)
+				return -1;
+			b = p[--c];
+			if (b >= 0x80)
+			{					/* 1000 0000 */
+				while (c > lb)
+				{
+					b = p[c];
+					if (b >= 0xC0)
+						break;	/* 1100 0000 */
+					c--;
+				}
+			}
+		}
+	}
+	return c;
 }
 
 /* Code for character groupings: utf8 cases */
 
-static int get_utf8(const symbol * p, int c, int l, int * slot) {
-    int b0, b1;
-    if (c >= l) return 0;
-    b0 = p[c++];
-    if (b0 < 0xC0 || c == l) {   /* 1100 0000 */
-        * slot = b0; return 1;
-    }
-    b1 = p[c++];
-    if (b0 < 0xE0 || c == l) {   /* 1110 0000 */
-        * slot = (b0 & 0x1F) << 6 | (b1 & 0x3F); return 2;
-    }
-    * slot = (b0 & 0xF) << 12 | (b1 & 0x3F) << 6 | (*p & 0x3F); return 3;
+static int
+get_utf8(const symbol * p, int c, int l, int *slot)
+{
+	int			b0,
+				b1;
+
+	if (c >= l)
+		return 0;
+	b0 = p[c++];
+	if (b0 < 0xC0 || c == l)
+	{							/* 1100 0000 */
+		*slot = b0;
+		return 1;
+	}
+	b1 = p[c++];
+	if (b0 < 0xE0 || c == l)
+	{							/* 1110 0000 */
+		*slot = (b0 & 0x1F) << 6 | (b1 & 0x3F);
+		return 2;
+	}
+	*slot = (b0 & 0xF) << 12 | (b1 & 0x3F) << 6 | (*p & 0x3F);
+	return 3;
 }
 
-static int get_b_utf8(const symbol * p, int c, int lb, int * slot) {
-    int b0, b1;
-    if (c <= lb) return 0;
-    b0 = p[--c];
-    if (b0 < 0x80 || c == lb) {   /* 1000 0000 */
-        * slot = b0; return 1;
-    }
-    b1 = p[--c];
-    if (b1 >= 0xC0 || c == lb) {   /* 1100 0000 */
-        * slot = (b1 & 0x1F) << 6 | (b0 & 0x3F); return 2;
-    }
-    * slot = (*p & 0xF) << 12 | (b1 & 0x3F) << 6 | (b0 & 0x3F); return 3;
+static int
+get_b_utf8(const symbol * p, int c, int lb, int *slot)
+{
+	int			b0,
+				b1;
+
+	if (c <= lb)
+		return 0;
+	b0 = p[--c];
+	if (b0 < 0x80 || c == lb)
+	{							/* 1000 0000 */
+		*slot = b0;
+		return 1;
+	}
+	b1 = p[--c];
+	if (b1 >= 0xC0 || c == lb)
+	{							/* 1100 0000 */
+		*slot = (b1 & 0x1F) << 6 | (b0 & 0x3F);
+		return 2;
+	}
+	*slot = (*p & 0xF) << 12 | (b1 & 0x3F) << 6 | (b0 & 0x3F);
+	return 3;
 }
 
-extern int in_grouping_U(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    int w = get_utf8(z->p, z->c, z->l, & ch);
-    unless (w) return 0;
-    if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c += w; return 1;
+extern int
+in_grouping_U(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+	int			w = get_utf8(z->p, z->c, z->l, &ch);
+
+	unless(w) return 0;
+	if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+		return 0;
+	z->c += w;
+	return 1;
 }
 
-extern int in_grouping_b_U(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    int w = get_b_utf8(z->p, z->c, z->lb, & ch);
-    unless (w) return 0;
-    if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c -= w; return 1;
+extern int
+in_grouping_b_U(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+	int			w = get_b_utf8(z->p, z->c, z->lb, &ch);
+
+	unless(w) return 0;
+	if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+		return 0;
+	z->c -= w;
+	return 1;
 }
 
-extern int out_grouping_U(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    int w = get_utf8(z->p, z->c, z->l, & ch);
-    unless (w) return 0;
-    unless (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c += w; return 1;
+extern int
+out_grouping_U(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+	int			w = get_utf8(z->p, z->c, z->l, &ch);
+
+	unless(w) return 0;
+	unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
+	z->c += w;
+	return 1;
 }
 
-extern int out_grouping_b_U(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    int w = get_b_utf8(z->p, z->c, z->lb, & ch);
-    unless (w) return 0;
-    unless (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c -= w; return 1;
+extern int
+out_grouping_b_U(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+	int			w = get_b_utf8(z->p, z->c, z->lb, &ch);
+
+	unless(w) return 0;
+	unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
+	z->c -= w;
+	return 1;
 }
 
 /* Code for character groupings: non-utf8 cases */
 
-extern int in_grouping(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    if (z->c >= z->l) return 0;
-    ch = z->p[z->c];
-    if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c++; return 1;
+extern int
+in_grouping(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+
+	if (z->c >= z->l)
+		return 0;
+	ch = z->p[z->c];
+	if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+		return 0;
+	z->c++;
+	return 1;
 }
 
-extern int in_grouping_b(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    if (z->c <= z->lb) return 0;
-    ch = z->p[z->c - 1];
-    if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c--; return 1;
+extern int
+in_grouping_b(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+
+	if (z->c <= z->lb)
+		return 0;
+	ch = z->p[z->c - 1];
+	if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+		return 0;
+	z->c--;
+	return 1;
 }
 
-extern int out_grouping(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    if (z->c >= z->l) return 0;
-    ch = z->p[z->c];
-    unless (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c++; return 1;
+extern int
+out_grouping(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+
+	if (z->c >= z->l)
+		return 0;
+	ch = z->p[z->c];
+	unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
+	z->c++;
+	return 1;
 }
 
-extern int out_grouping_b(struct SN_env * z, unsigned char * s, int min, int max) {
-    int ch;
-    if (z->c <= z->lb) return 0;
-    ch = z->p[z->c - 1];
-    unless (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
-    z->c--; return 1;
+extern int
+out_grouping_b(struct SN_env * z, unsigned char *s, int min, int max)
+{
+	int			ch;
+
+	if (z->c <= z->lb)
+		return 0;
+	ch = z->p[z->c - 1];
+	unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 0;
+	z->c--;
+	return 1;
 }
 
-extern int eq_s(struct SN_env * z, int s_size, symbol * s) {
-    if (z->l - z->c < s_size || memcmp(z->p + z->c, s, s_size * sizeof(symbol)) != 0) return 0;
-    z->c += s_size; return 1;
+extern int
+eq_s(struct SN_env * z, int s_size, symbol * s)
+{
+	if (z->l - z->c < s_size || memcmp(z->p + z->c, s, s_size * sizeof(symbol)) != 0)
+		return 0;
+	z->c += s_size;
+	return 1;
 }
 
-extern int eq_s_b(struct SN_env * z, int s_size, symbol * s) {
-    if (z->c - z->lb < s_size || memcmp(z->p + z->c - s_size, s, s_size * sizeof(symbol)) != 0) return 0;
-    z->c -= s_size; return 1;
+extern int
+eq_s_b(struct SN_env * z, int s_size, symbol * s)
+{
+	if (z->c - z->lb < s_size || memcmp(z->p + z->c - s_size, s, s_size * sizeof(symbol)) != 0)
+		return 0;
+	z->c -= s_size;
+	return 1;
 }
 
-extern int eq_v(struct SN_env * z, symbol * p) {
-    return eq_s(z, SIZE(p), p);
+extern int
+eq_v(struct SN_env * z, symbol * p)
+{
+	return eq_s(z, SIZE(p), p);
 }
 
-extern int eq_v_b(struct SN_env * z, symbol * p) {
-    return eq_s_b(z, SIZE(p), p);
+extern int
+eq_v_b(struct SN_env * z, symbol * p)
+{
+	return eq_s_b(z, SIZE(p), p);
 }
 
-extern int find_among(struct SN_env * z, struct among * v, int v_size) {
-
-    int i = 0;
-    int j = v_size;
-
-    int c = z->c; int l = z->l;
-    symbol * q = z->p + c;
-
-    struct among * w;
-
-    int common_i = 0;
-    int common_j = 0;
-
-    int first_key_inspected = 0;
-
-    while(1) {
-        int k = i + ((j - i) >> 1);
-        int diff = 0;
-        int common = common_i < common_j ? common_i : common_j; /* smaller */
-        w = v + k;
-        {
-            int i; for (i = common; i < w->s_size; i++) {
-                if (c + common == l) { diff = -1; break; }
-                diff = q[common] - w->s[i];
-                if (diff != 0) break;
-                common++;
-            }
-        }
-        if (diff < 0) { j = k; common_j = common; }
-                 else { i = k; common_i = common; }
-        if (j - i <= 1) {
-            if (i > 0) break; /* v->s has been inspected */
-            if (j == i) break; /* only one item in v */
-
-            /* - but now we need to go round once more to get
-               v->s inspected. This looks messy, but is actually
-               the optimal approach.  */
-
-            if (first_key_inspected) break;
-            first_key_inspected = 1;
-        }
-    }
-    while(1) {
-        w = v + i;
-        if (common_i >= w->s_size) {
-            z->c = c + w->s_size;
-            if (w->function == 0) return w->result;
-            {
-                int res = w->function(z);
-                z->c = c + w->s_size;
-                if (res) return w->result;
-            }
-        }
-        i = w->substring_i;
-        if (i < 0) return 0;
-    }
+extern int
+find_among(struct SN_env * z, struct among * v, int v_size)
+{
+
+	int			i = 0;
+	int			j = v_size;
+
+	int			c = z->c;
+	int			l = z->l;
+	symbol	   *q = z->p + c;
+
+	struct among *w;
+
+	int			common_i = 0;
+	int			common_j = 0;
+
+	int			first_key_inspected = 0;
+
+	while (1)
+	{
+		int			k = i + ((j - i) >> 1);
+		int			diff = 0;
+		int			common = common_i < common_j ? common_i : common_j; /* smaller */
+
+		w = v + k;
+		{
+			int			i;
+
+			for (i = common; i < w->s_size; i++)
+			{
+				if (c + common == l)
+				{
+					diff = -1;
+					break;
+				}
+				diff = q[common] - w->s[i];
+				if (diff != 0)
+					break;
+				common++;
+			}
+		}
+		if (diff < 0)
+		{
+			j = k;
+			common_j = common;
+		}
+		else
+		{
+			i = k;
+			common_i = common;
+		}
+		if (j - i <= 1)
+		{
+			if (i > 0)
+				break;			/* v->s has been inspected */
+			if (j == i)
+				break;			/* only one item in v */
+
+			/*
+			 * - but now we need to go round once more to get v->s inspected.
+			 * This looks messy, but is actually the optimal approach.
+			 */
+
+			if (first_key_inspected)
+				break;
+			first_key_inspected = 1;
+		}
+	}
+	while (1)
+	{
+		w = v + i;
+		if (common_i >= w->s_size)
+		{
+			z->c = c + w->s_size;
+			if (w->function == 0)
+				return w->result;
+			{
+				int			res = w->function(z);
+
+				z->c = c + w->s_size;
+				if (res)
+					return w->result;
+			}
+		}
+		i = w->substring_i;
+		if (i < 0)
+			return 0;
+	}
 }
 
 /* find_among_b is for backwards processing. Same comments apply */
 
-extern int find_among_b(struct SN_env * z, struct among * v, int v_size) {
-
-    int i = 0;
-    int j = v_size;
-
-    int c = z->c; int lb = z->lb;
-    symbol * q = z->p + c - 1;
-
-    struct among * w;
-
-    int common_i = 0;
-    int common_j = 0;
-
-    int first_key_inspected = 0;
-
-    while(1) {
-        int k = i + ((j - i) >> 1);
-        int diff = 0;
-        int common = common_i < common_j ? common_i : common_j;
-        w = v + k;
-        {
-            int i; for (i = w->s_size - 1 - common; i >= 0; i--) {
-                if (c - common == lb) { diff = -1; break; }
-                diff = q[- common] - w->s[i];
-                if (diff != 0) break;
-                common++;
-            }
-        }
-        if (diff < 0) { j = k; common_j = common; }
-                 else { i = k; common_i = common; }
-        if (j - i <= 1) {
-            if (i > 0) break;
-            if (j == i) break;
-            if (first_key_inspected) break;
-            first_key_inspected = 1;
-        }
-    }
-    while(1) {
-        w = v + i;
-        if (common_i >= w->s_size) {
-            z->c = c - w->s_size;
-            if (w->function == 0) return w->result;
-            {
-                int res = w->function(z);
-                z->c = c - w->s_size;
-                if (res) return w->result;
-            }
-        }
-        i = w->substring_i;
-        if (i < 0) return 0;
-    }
+extern int
+find_among_b(struct SN_env * z, struct among * v, int v_size)
+{
+
+	int			i = 0;
+	int			j = v_size;
+
+	int			c = z->c;
+	int			lb = z->lb;
+	symbol	   *q = z->p + c - 1;
+
+	struct among *w;
+
+	int			common_i = 0;
+	int			common_j = 0;
+
+	int			first_key_inspected = 0;
+
+	while (1)
+	{
+		int			k = i + ((j - i) >> 1);
+		int			diff = 0;
+		int			common = common_i < common_j ? common_i : common_j;
+
+		w = v + k;
+		{
+			int			i;
+
+			for (i = w->s_size - 1 - common; i >= 0; i--)
+			{
+				if (c - common == lb)
+				{
+					diff = -1;
+					break;
+				}
+				diff = q[-common] - w->s[i];
+				if (diff != 0)
+					break;
+				common++;
+			}
+		}
+		if (diff < 0)
+		{
+			j = k;
+			common_j = common;
+		}
+		else
+		{
+			i = k;
+			common_i = common;
+		}
+		if (j - i <= 1)
+		{
+			if (i > 0)
+				break;
+			if (j == i)
+				break;
+			if (first_key_inspected)
+				break;
+			first_key_inspected = 1;
+		}
+	}
+	while (1)
+	{
+		w = v + i;
+		if (common_i >= w->s_size)
+		{
+			z->c = c - w->s_size;
+			if (w->function == 0)
+				return w->result;
+			{
+				int			res = w->function(z);
+
+				z->c = c - w->s_size;
+				if (res)
+					return w->result;
+			}
+		}
+		i = w->substring_i;
+		if (i < 0)
+			return 0;
+	}
 }
 
 
 /* Increase the size of the buffer pointed to by p to at least n symbols.
  * If insufficient memory, returns NULL and frees the old buffer.
  */
-static symbol * increase_size(symbol * p, int n) {
-    symbol * q;
-    int new_size = n + 20;
-    void * mem = realloc((char *) p - HEAD,
-                         HEAD + (new_size + 1) * sizeof(symbol));
-    if (mem == NULL) {
-        lose_s(p);
-        return NULL;
-    }
-    q = (symbol *) (HEAD + (char *)mem);
-    CAPACITY(q) = new_size;
-    return q;
+static symbol *
+increase_size(symbol * p, int n)
+{
+	symbol	   *q;
+	int			new_size = n + 20;
+	void	   *mem = realloc((char *) p - HEAD,
+							  HEAD + (new_size + 1) * sizeof(symbol));
+
+	if (mem == NULL)
+	{
+		lose_s(p);
+		return NULL;
+	}
+	q = (symbol *) (HEAD + (char *) mem);
+	CAPACITY(q) = new_size;
+	return q;
 }
 
 /* to replace symbols between c_bra and c_ket in z->p by the
@@ -313,134 +475,182 @@ static symbol * increase_size(symbol * p, int n) {
    Returns 0 on success, -1 on error.
    Also, frees z->p (and sets it to NULL) on error.
 */
-extern int replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s, int * adjptr)
+extern int
+replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s, int *adjptr)
 {
-    int adjustment;
-    int len;
-    if (z->p == NULL) {
-        z->p = create_s();
-        if (z->p == NULL) return -1;
-    }
-    adjustment = s_size - (c_ket - c_bra);
-    len = SIZE(z->p);
-    if (adjustment != 0) {
-        if (adjustment + len > CAPACITY(z->p)) {
-            z->p = increase_size(z->p, adjustment + len);
-            if (z->p == NULL) return -1;
-        }
-        memmove(z->p + c_ket + adjustment,
-                z->p + c_ket,
-                (len - c_ket) * sizeof(symbol));
-        SET_SIZE(z->p, adjustment + len);
-        z->l += adjustment;
-        if (z->c >= c_ket)
-            z->c += adjustment;
-        else
-            if (z->c > c_bra)
-                z->c = c_bra;
-    }
-    unless (s_size == 0) memmove(z->p + c_bra, s, s_size * sizeof(symbol));
-    if (adjptr != NULL)
-        *adjptr = adjustment;
-    return 0;
+	int			adjustment;
+	int			len;
+
+	if (z->p == NULL)
+	{
+		z->p = create_s();
+		if (z->p == NULL)
+			return -1;
+	}
+	adjustment = s_size - (c_ket - c_bra);
+	len = SIZE(z->p);
+	if (adjustment != 0)
+	{
+		if (adjustment + len > CAPACITY(z->p))
+		{
+			z->p = increase_size(z->p, adjustment + len);
+			if (z->p == NULL)
+				return -1;
+		}
+		memmove(z->p + c_ket + adjustment,
+				z->p + c_ket,
+				(len - c_ket) * sizeof(symbol));
+		SET_SIZE(z->p, adjustment + len);
+		z->l += adjustment;
+		if (z->c >= c_ket)
+			z->c += adjustment;
+		else if (z->c > c_bra)
+			z->c = c_bra;
+	}
+	unless(s_size == 0) memmove(z->p + c_bra, s, s_size * sizeof(symbol));
+	if (adjptr != NULL)
+		*adjptr = adjustment;
+	return 0;
 }
 
-static int slice_check(struct SN_env * z) {
+static int
+slice_check(struct SN_env * z)
+{
 
-    if (z->bra < 0 ||
-        z->bra > z->ket ||
-        z->ket > z->l ||
-        z->p == NULL ||
-        z->l > SIZE(z->p)) /* this line could be removed */
-    {
+	if (z->bra < 0 ||
+		z->bra > z->ket ||
+		z->ket > z->l ||
+		z->p == NULL ||
+		z->l > SIZE(z->p))		/* this line could be removed */
+	{
 #if 0
-        fprintf(stderr, "faulty slice operation:\n");
-        debug(z, -1, 0);
+		fprintf(stderr, "faulty slice operation:\n");
+		debug(z, -1, 0);
 #endif
-        return -1;
-    }
-    return 0;
+		return -1;
+	}
+	return 0;
 }
 
-extern int slice_from_s(struct SN_env * z, int s_size, symbol * s) {
-    if (slice_check(z)) return -1;
-    return replace_s(z, z->bra, z->ket, s_size, s, NULL);
+extern int
+slice_from_s(struct SN_env * z, int s_size, symbol * s)
+{
+	if (slice_check(z))
+		return -1;
+	return replace_s(z, z->bra, z->ket, s_size, s, NULL);
 }
 
-extern int slice_from_v(struct SN_env * z, symbol * p) {
-    return slice_from_s(z, SIZE(p), p);
+extern int
+slice_from_v(struct SN_env * z, symbol * p)
+{
+	return slice_from_s(z, SIZE(p), p);
 }
 
-extern int slice_del(struct SN_env * z) {
-    return slice_from_s(z, 0, 0);
+extern int
+slice_del(struct SN_env * z)
+{
+	return slice_from_s(z, 0, 0);
 }
 
-extern int insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s) {
-    int adjustment;
-    if (replace_s(z, bra, ket, s_size, s, &adjustment))
-        return -1;
-    if (bra <= z->bra) z->bra += adjustment;
-    if (bra <= z->ket) z->ket += adjustment;
-    return 0;
+extern int
+insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s)
+{
+	int			adjustment;
+
+	if (replace_s(z, bra, ket, s_size, s, &adjustment))
+		return -1;
+	if (bra <= z->bra)
+		z->bra += adjustment;
+	if (bra <= z->ket)
+		z->ket += adjustment;
+	return 0;
 }
 
-extern int insert_v(struct SN_env * z, int bra, int ket, symbol * p) {
-    int adjustment;
-    if (replace_s(z, bra, ket, SIZE(p), p, &adjustment))
-        return -1;
-    if (bra <= z->bra) z->bra += adjustment;
-    if (bra <= z->ket) z->ket += adjustment;
-    return 0;
+extern int
+insert_v(struct SN_env * z, int bra, int ket, symbol * p)
+{
+	int			adjustment;
+
+	if (replace_s(z, bra, ket, SIZE(p), p, &adjustment))
+		return -1;
+	if (bra <= z->bra)
+		z->bra += adjustment;
+	if (bra <= z->ket)
+		z->ket += adjustment;
+	return 0;
 }
 
-extern symbol * slice_to(struct SN_env * z, symbol * p) {
-    if (slice_check(z)) {
-        lose_s(p);
-        return NULL;
-    }
-    {
-        int len = z->ket - z->bra;
-        if (CAPACITY(p) < len) {
-            p = increase_size(p, len);
-            if (p == NULL)
-                return NULL;
-        }
-        memmove(p, z->p + z->bra, len * sizeof(symbol));
-        SET_SIZE(p, len);
-    }
-    return p;
+extern symbol *
+slice_to(struct SN_env * z, symbol * p)
+{
+	if (slice_check(z))
+	{
+		lose_s(p);
+		return NULL;
+	}
+	{
+		int			len = z->ket - z->bra;
+
+		if (CAPACITY(p) < len)
+		{
+			p = increase_size(p, len);
+			if (p == NULL)
+				return NULL;
+		}
+		memmove(p, z->p + z->bra, len * sizeof(symbol));
+		SET_SIZE(p, len);
+	}
+	return p;
 }
 
-extern symbol * assign_to(struct SN_env * z, symbol * p) {
-    int len = z->l;
-    if (CAPACITY(p) < len) {
-        p = increase_size(p, len);
-        if (p == NULL)
-            return NULL;
-    }
-    memmove(p, z->p, len * sizeof(symbol));
-    SET_SIZE(p, len);
-    return p;
+extern symbol *
+assign_to(struct SN_env * z, symbol * p)
+{
+	int			len = z->l;
+
+	if (CAPACITY(p) < len)
+	{
+		p = increase_size(p, len);
+		if (p == NULL)
+			return NULL;
+	}
+	memmove(p, z->p, len * sizeof(symbol));
+	SET_SIZE(p, len);
+	return p;
 }
 
 #if 0
-extern void debug(struct SN_env * z, int number, int line_count) {
-    int i;
-    int limit = SIZE(z->p);
-    /*if (number >= 0) printf("%3d (line %4d): '", number, line_count);*/
-    if (number >= 0) printf("%3d (line %4d): [%d]'", number, line_count,limit);
-    for (i = 0; i <= limit; i++) {
-        if (z->lb == i) printf("{");
-        if (z->bra == i) printf("[");
-        if (z->c == i) printf("|");
-        if (z->ket == i) printf("]");
-        if (z->l == i) printf("}");
-        if (i < limit)
-        {   int ch = z->p[i];
-            if (ch == 0) ch = '#';
-            printf("%c", ch);
-        }
-    }
-    printf("'\n");
+extern void
+debug(struct SN_env * z, int number, int line_count)
+{
+	int			i;
+	int			limit = SIZE(z->p);
+
+	/* if (number >= 0) printf("%3d (line %4d): '", number, line_count); */
+	if (number >= 0)
+		printf("%3d (line %4d): [%d]'", number, line_count, limit);
+	for (i = 0; i <= limit; i++)
+	{
+		if (z->lb == i)
+			printf("{");
+		if (z->bra == i)
+			printf("[");
+		if (z->c == i)
+			printf("|");
+		if (z->ket == i)
+			printf("]");
+		if (z->l == i)
+			printf("}");
+		if (i < limit)
+		{
+			int			ch = z->p[i];
+
+			if (ch == 0)
+				ch = '#';
+			printf("%c", ch);
+		}
+	}
+	printf("'\n");
 }
+
 #endif
diff --git a/contrib/tsearch2/stopword.c b/contrib/tsearch2/stopword.c
index 185d085de1..b8789f9e64 100644
--- a/contrib/tsearch2/stopword.c
+++ b/contrib/tsearch2/stopword.c
@@ -58,8 +58,8 @@ readstoplist(text *in, StopList * s)
 		/* if path is relative, take it as relative to share dir */
 		if (!is_absolute_path(filename))
 		{
-			char	sharepath[MAXPGPATH];
-			char   *absfn;
+			char		sharepath[MAXPGPATH];
+			char	   *absfn;
 
 			get_share_path(my_exec_path, sharepath);
 			absfn = palloc(strlen(sharepath) + strlen(filename) + 2);
diff --git a/contrib/tsearch2/ts_cfg.c b/contrib/tsearch2/ts_cfg.c
index c5916b0f0d..a1fcf0b4f2 100644
--- a/contrib/tsearch2/ts_cfg.c
+++ b/contrib/tsearch2/ts_cfg.c
@@ -185,9 +185,9 @@ reset_cfg(void)
 static int
 comparecfg(const void *a, const void *b)
 {
-	if ( ((TSCfgInfo *) a)->id == ((TSCfgInfo *) b)->id )
+	if (((TSCfgInfo *) a)->id == ((TSCfgInfo *) b)->id)
 		return 0;
-	return ( ((TSCfgInfo *) a)->id < ((TSCfgInfo *) b)->id ) ? -1 : 1;
+	return (((TSCfgInfo *) a)->id < ((TSCfgInfo *) b)->id) ? -1 : 1;
 }
 
 TSCfgInfo *
@@ -289,17 +289,17 @@ parsetext_v2(TSCfgInfo * cfg, PRSTEXT * prs, char *buf, int4 buflen)
 
 	prsobj->prs = (void *) DatumGetPointer(
 										   FunctionCall2(
-												   &(prsobj->start_info),
-													PointerGetDatum(buf),
-													Int32GetDatum(buflen)
+													   &(prsobj->start_info),
+														 PointerGetDatum(buf),
+														 Int32GetDatum(buflen)
 														 )
 		);
 
 	while ((type = DatumGetInt32(FunctionCall3(
 											   &(prsobj->getlexeme_info),
-											PointerGetDatum(prsobj->prs),
+											   PointerGetDatum(prsobj->prs),
 											   PointerGetDatum(&lemm),
-									   PointerGetDatum(&lenlemm)))) != 0)
+										   PointerGetDatum(&lenlemm)))) != 0)
 	{
 
 		if (lenlemm >= MAXSTRLEN)
@@ -322,16 +322,16 @@ parsetext_v2(TSCfgInfo * cfg, PRSTEXT * prs, char *buf, int4 buflen)
 		for (i = 0; i < cfg->map[type].len; i++)
 		{
 			DictInfo   *dict = finddict(DatumGetObjectId(cfg->map[type].dict_id[i]));
-			TSLexeme	  *norms,
-					  *ptr;
+			TSLexeme   *norms,
+					   *ptr;
 
 			norms = ptr = (TSLexeme *) DatumGetPointer(
-													FunctionCall3(
-													&(dict->lexize_info),
-									   PointerGetDatum(dict->dictionary),
-												   PointerGetDatum(lemm),
-												 PointerGetDatum(lenlemm)
-																  )
+													   FunctionCall3(
+														&(dict->lexize_info),
+										   PointerGetDatum(dict->dictionary),
+													   PointerGetDatum(lemm),
+													 PointerGetDatum(lenlemm)
+																	 )
 				);
 			if (!norms)			/* dictionary doesn't know this lexem */
 				continue;
@@ -355,8 +355,7 @@ parsetext_v2(TSCfgInfo * cfg, PRSTEXT * prs, char *buf, int4 buflen)
 				prs->curwords++;
 			}
 			pfree(norms);
-			break;				/* lexem already normalized or is stop
-								 * word */
+			break;				/* lexem already normalized or is stop word */
 		}
 	}
 
@@ -425,17 +424,17 @@ hlparsetext(TSCfgInfo * cfg, HLPRSTEXT * prs, QUERYTYPE * query, char *buf, int4
 
 	prsobj->prs = (void *) DatumGetPointer(
 										   FunctionCall2(
-												   &(prsobj->start_info),
-													PointerGetDatum(buf),
-													Int32GetDatum(buflen)
+													   &(prsobj->start_info),
+														 PointerGetDatum(buf),
+														 Int32GetDatum(buflen)
 														 )
 		);
 
 	while ((type = DatumGetInt32(FunctionCall3(
 											   &(prsobj->getlexeme_info),
-											PointerGetDatum(prsobj->prs),
+											   PointerGetDatum(prsobj->prs),
 											   PointerGetDatum(&lemm),
-									   PointerGetDatum(&lenlemm)))) != 0)
+										   PointerGetDatum(&lenlemm)))) != 0)
 	{
 
 		if (lenlemm >= MAXSTRLEN)
@@ -460,16 +459,16 @@ hlparsetext(TSCfgInfo * cfg, HLPRSTEXT * prs, QUERYTYPE * query, char *buf, int4
 		for (i = 0; i < cfg->map[type].len; i++)
 		{
 			DictInfo   *dict = finddict(DatumGetObjectId(cfg->map[type].dict_id[i]));
-			TSLexeme	  *norms,
-					  *ptr;
+			TSLexeme   *norms,
+					   *ptr;
 
 			norms = ptr = (TSLexeme *) DatumGetPointer(
-													FunctionCall3(
-													&(dict->lexize_info),
-									   PointerGetDatum(dict->dictionary),
-												   PointerGetDatum(lemm),
-												 PointerGetDatum(lenlemm)
-																  )
+													   FunctionCall3(
+														&(dict->lexize_info),
+										   PointerGetDatum(dict->dictionary),
+													   PointerGetDatum(lemm),
+													 PointerGetDatum(lenlemm)
+																	 )
 				);
 			if (!norms)			/* dictionary doesn't know this lexem */
 				continue;
@@ -481,8 +480,7 @@ hlparsetext(TSCfgInfo * cfg, HLPRSTEXT * prs, QUERYTYPE * query, char *buf, int4
 				ptr++;
 			}
 			pfree(norms);
-			break;				/* lexem already normalized or is stop
-								 * word */
+			break;				/* lexem already normalized or is stop word */
 		}
 	}
 
diff --git a/contrib/tsearch2/ts_stat.c b/contrib/tsearch2/ts_stat.c
index aaf43f8d74..2cde25df8e 100644
--- a/contrib/tsearch2/ts_stat.c
+++ b/contrib/tsearch2/ts_stat.c
@@ -505,10 +505,10 @@ ts_stat_sql(text *txt, text *ws)
 			if (!isnull)
 			{
 				newstat = (tsstat *) DatumGetPointer(DirectFunctionCall2(
-																ts_accum,
-												   PointerGetDatum(stat),
-																	 data
-																	  ));
+																	ts_accum,
+													   PointerGetDatum(stat),
+																		 data
+																		 ));
 				if (stat != newstat && stat)
 					pfree(stat);
 				stat = newstat;
diff --git a/contrib/tsearch2/tsvector.c b/contrib/tsearch2/tsvector.c
index 2630694e4e..cfed6e428a 100644
--- a/contrib/tsearch2/tsvector.c
+++ b/contrib/tsearch2/tsvector.c
@@ -52,7 +52,7 @@ comparePos(const void *a, const void *b)
 {
 	if (WEP_GETPOS(*(WordEntryPos *) a) == WEP_GETPOS(*(WordEntryPos *) b))
 		return 0;
-	return (WEP_GETPOS(*(WordEntryPos *) a)> WEP_GETPOS(*(WordEntryPos *) b)) ? 1 : -1;
+	return (WEP_GETPOS(*(WordEntryPos *) a) > WEP_GETPOS(*(WordEntryPos *) b)) ? 1 : -1;
 }
 
 static int
@@ -328,7 +328,7 @@ gettoken_tsvector(TI_IN_STATE * state)
 					ereport(ERROR,
 							(errcode(ERRCODE_SYNTAX_ERROR),
 							 errmsg("wrong position info")));
-				WEP_SETWEIGHT( state->pos[*(uint16 *) (state->pos)], 0 );
+				WEP_SETWEIGHT(state->pos[*(uint16 *) (state->pos)], 0);
 				state->state = WAITPOSDELIM;
 			}
 			else
@@ -342,35 +342,35 @@ gettoken_tsvector(TI_IN_STATE * state)
 				state->state = INPOSINFO;
 			else if (tolower(*(state->prsbuf)) == 'a' || *(state->prsbuf) == '*')
 			{
-				if ( WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]) )
+				if (WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]))
 					ereport(ERROR,
 							(errcode(ERRCODE_SYNTAX_ERROR),
 							 errmsg("syntax error")));
-				WEP_SETWEIGHT( state->pos[*(uint16 *) (state->pos)], 3 );
+				WEP_SETWEIGHT(state->pos[*(uint16 *) (state->pos)], 3);
 			}
 			else if (tolower(*(state->prsbuf)) == 'b')
 			{
-				if ( WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]) )
+				if (WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]))
 					ereport(ERROR,
 							(errcode(ERRCODE_SYNTAX_ERROR),
 							 errmsg("syntax error")));
-				WEP_SETWEIGHT( state->pos[*(uint16 *) (state->pos)], 2 );
+				WEP_SETWEIGHT(state->pos[*(uint16 *) (state->pos)], 2);
 			}
 			else if (tolower(*(state->prsbuf)) == 'c')
 			{
-				if ( WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]) )
+				if (WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]))
 					ereport(ERROR,
 							(errcode(ERRCODE_SYNTAX_ERROR),
 							 errmsg("syntax error")));
-				WEP_SETWEIGHT( state->pos[*(uint16 *) (state->pos)], 1 );
+				WEP_SETWEIGHT(state->pos[*(uint16 *) (state->pos)], 1);
 			}
 			else if (tolower(*(state->prsbuf)) == 'd')
 			{
-				if ( WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]) )
+				if (WEP_GETWEIGHT(state->pos[*(uint16 *) (state->pos)]))
 					ereport(ERROR,
 							(errcode(ERRCODE_SYNTAX_ERROR),
 							 errmsg("syntax error")));
-				WEP_SETWEIGHT( state->pos[*(uint16 *) (state->pos)], 0 );
+				WEP_SETWEIGHT(state->pos[*(uint16 *) (state->pos)], 0);
 			}
 			else if (isspace((unsigned char) *(state->prsbuf)) ||
 					 *(state->prsbuf) == '\0')
@@ -906,9 +906,9 @@ tsearch2(PG_FUNCTION_ARGS)
 		if (funcoid != InvalidOid)
 		{
 			text	   *txttmp = (text *) DatumGetPointer(OidFunctionCall1(
-																 funcoid,
-											 PointerGetDatum(txt_toasted)
-																	  ));
+																	 funcoid,
+												 PointerGetDatum(txt_toasted)
+																		   ));
 
 			txt = (text *) DatumGetPointer(PG_DETOAST_DATUM(PointerGetDatum(txttmp)));
 			if (txt == txttmp)
diff --git a/contrib/tsearch2/tsvector.h b/contrib/tsearch2/tsvector.h
index e2fd0b6fae..b30d3239f3 100644
--- a/contrib/tsearch2/tsvector.h
+++ b/contrib/tsearch2/tsvector.h
@@ -24,13 +24,13 @@ typedef struct
 #define MAXSTRPOS ( 1<<20 )
 
 /*
-Equivalent to 
+Equivalent to
 typedef struct
 {
-       uint16
-                                weight:2,
-                                pos:14;
-}       WordEntryPos;
+	   uint16
+								weight:2,
+								pos:14;
+}	WordEntryPos;
 
 */
 
@@ -39,8 +39,8 @@ typedef uint16 WordEntryPos;
 #define  WEP_GETWEIGHT(x)	( (x) >> 14 )
 #define  WEP_GETPOS(x)		( (x) & 0x3fff )
 
-#define  WEP_SETWEIGHT(x,v)  (x) = ( (v) << 14 ) | ( (x) & 0x3fff ) 
-#define  WEP_SETPOS(x,v)	(x) = ( (x) & 0xc000 ) | ( (v) & 0x3fff ) 
+#define  WEP_SETWEIGHT(x,v)  (x) = ( (v) << 14 ) | ( (x) & 0x3fff )
+#define  WEP_SETPOS(x,v)	(x) = ( (x) & 0xc000 ) | ( (v) & 0x3fff )
 
 
 #define MAXENTRYPOS (1<<14)
diff --git a/contrib/tsearch2/tsvector_op.c b/contrib/tsearch2/tsvector_op.c
index 7f1a33c943..b2562e8984 100644
--- a/contrib/tsearch2/tsvector_op.c
+++ b/contrib/tsearch2/tsvector_op.c
@@ -106,7 +106,7 @@ setweight(PG_FUNCTION_ARGS)
 			p = POSDATAPTR(out, entry);
 			while (j--)
 			{
-				WEP_SETWEIGHT(*p,w);
+				WEP_SETWEIGHT(*p, w);
 				p++;
 			}
 		}
diff --git a/contrib/tsearch2/wparser.c b/contrib/tsearch2/wparser.c
index 0f3ead832e..725020e23d 100644
--- a/contrib/tsearch2/wparser.c
+++ b/contrib/tsearch2/wparser.c
@@ -92,9 +92,9 @@ reset_prs(void)
 static int
 compareprs(const void *a, const void *b)
 {
-	if ( ((WParserInfo *) a)->prs_id == ((WParserInfo *) b)->prs_id )
+	if (((WParserInfo *) a)->prs_id == ((WParserInfo *) b)->prs_id)
 		return 0;
-	return ( ((WParserInfo *) a)->prs_id < ((WParserInfo *) b)->prs_id ) ? -1 : 1;
+	return (((WParserInfo *) a)->prs_id < ((WParserInfo *) b)->prs_id) ? -1 : 1;
 }
 
 WParserInfo *
@@ -194,7 +194,7 @@ setup_firstcall(FunctionCallInfo fcinfo, FuncCallContext *funcctx, Oid prsid)
 	st = (TypeStorage *) palloc(sizeof(TypeStorage));
 	st->cur = 0;
 	st->list = (LexDescr *) DatumGetPointer(
-				OidFunctionCall1(prs->lextype, PointerGetDatum(prs->prs))
+					OidFunctionCall1(prs->lextype, PointerGetDatum(prs->prs))
 		);
 	funcctx->user_fctx = (void *) st;
 	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
@@ -375,8 +375,8 @@ prs_setup_firstcall(FunctionCallInfo fcinfo, FuncCallContext *funcctx,
 	prs->prs = (void *) DatumGetPointer(
 										FunctionCall2(
 													  &(prs->start_info),
-										   PointerGetDatum(VARDATA(txt)),
-								   Int32GetDatum(VARSIZE(txt) - VARHDRSZ)
+											   PointerGetDatum(VARDATA(txt)),
+									   Int32GetDatum(VARSIZE(txt) - VARHDRSZ)
 													  )
 		);
 
@@ -384,7 +384,7 @@ prs_setup_firstcall(FunctionCallInfo fcinfo, FuncCallContext *funcctx,
 											   &(prs->getlexeme_info),
 											   PointerGetDatum(prs->prs),
 											   PointerGetDatum(&lex),
-										  PointerGetDatum(&llen)))) != 0)
+											   PointerGetDatum(&llen)))) != 0)
 	{
 
 		if (st->cur >= st->len)
@@ -588,7 +588,7 @@ headline_byname(PG_FUNCTION_ARGS)
 							  ObjectIdGetDatum(name2id_cfg(cfg)),
 							  PG_GETARG_DATUM(1),
 							  PG_GETARG_DATUM(2),
-			(PG_NARGS() > 3) ? PG_GETARG_DATUM(3) : PointerGetDatum(NULL)
+				(PG_NARGS() > 3) ? PG_GETARG_DATUM(3) : PointerGetDatum(NULL)
 		);
 
 	PG_FREE_IF_COPY(cfg, 0);
@@ -606,6 +606,6 @@ headline_current(PG_FUNCTION_ARGS)
 										ObjectIdGetDatum(get_currcfg()),
 										PG_GETARG_DATUM(0),
 										PG_GETARG_DATUM(1),
-			(PG_NARGS() > 2) ? PG_GETARG_DATUM(2) : PointerGetDatum(NULL)
+				(PG_NARGS() > 2) ? PG_GETARG_DATUM(2) : PointerGetDatum(NULL)
 										));
 }
diff --git a/contrib/tsearch2/wparser_def.c b/contrib/tsearch2/wparser_def.c
index a33bacf31b..6686257887 100644
--- a/contrib/tsearch2/wparser_def.c
+++ b/contrib/tsearch2/wparser_def.c
@@ -242,7 +242,7 @@ prsd_headline(PG_FUNCTION_ARGS)
 			if (min_words >= max_words)
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					   errmsg("MinWords should be less than MaxWords")));
+						 errmsg("MinWords should be less than MaxWords")));
 			if (min_words <= 0)
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
diff --git a/contrib/vacuumlo/vacuumlo.c b/contrib/vacuumlo/vacuumlo.c
index 93cfe13138..2de1ec3297 100644
--- a/contrib/vacuumlo/vacuumlo.c
+++ b/contrib/vacuumlo/vacuumlo.c
@@ -130,8 +130,8 @@ vacuumlo(char *database, struct _param * param)
 	PQclear(res);
 
 	/*
-	 * Vacuum the temp table so that planner will generate decent plans
-	 * for the DELETEs below.
+	 * Vacuum the temp table so that planner will generate decent plans for
+	 * the DELETEs below.
 	 */
 	buf[0] = '\0';
 	strcat(buf, "VACUUM ANALYZE vacuum_l");
@@ -193,8 +193,8 @@ vacuumlo(char *database, struct _param * param)
 
 		/*
 		 * The "IN" construct used here was horribly inefficient before
-		 * Postgres 7.4, but should be now competitive if not better than
-		 * the bogus join we used before.
+		 * Postgres 7.4, but should be now competitive if not better than the
+		 * bogus join we used before.
 		 */
 		snprintf(buf, BUFSIZE,
 				 "DELETE FROM vacuum_l "
@@ -216,10 +216,9 @@ vacuumlo(char *database, struct _param * param)
 	PQclear(res);
 
 	/*
-	 * Run the actual deletes in a single transaction.	Note that this
-	 * would be a bad idea in pre-7.1 Postgres releases (since rolling
-	 * back a table delete used to cause problems), but it should be safe
-	 * now.
+	 * Run the actual deletes in a single transaction.	Note that this would
+	 * be a bad idea in pre-7.1 Postgres releases (since rolling back a table
+	 * delete used to cause problems), but it should be safe now.
 	 */
 	res = PQexec(conn, "begin");
 	PQclear(res);
@@ -277,7 +276,7 @@ vacuumlo(char *database, struct _param * param)
 
 	if (param->verbose)
 		fprintf(stdout, "\r%s %d large objects from %s.\n",
-		(param->dry_run ? "Would remove" : "Removed"), deleted, database);
+		   (param->dry_run ? "Would remove" : "Removed"), deleted, database);
 
 	return 0;
 }
diff --git a/contrib/xml2/xpath.c b/contrib/xml2/xpath.c
index 98a5e3a0e2..b4b06a039d 100644
--- a/contrib/xml2/xpath.c
+++ b/contrib/xml2/xpath.c
@@ -194,10 +194,11 @@ PG_FUNCTION_INFO_V1(xml_encode_special_chars);
 Datum
 xml_encode_special_chars(PG_FUNCTION_ARGS)
 {
-	text *tin = PG_GETARG_TEXT_P(0);
-	text *tout;
-	int32 ressize;
-	xmlChar *ts, *tt;
+	text	   *tin = PG_GETARG_TEXT_P(0);
+	text	   *tout;
+	int32		ressize;
+	xmlChar    *ts,
+			   *tt;
 
 	ts = pgxml_texttoxmlchar(tin);
 
@@ -225,15 +226,15 @@ pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
 	/* Function translates a nodeset into a text representation */
 
 	/*
-	 * iterates over each node in the set and calls xmlNodeDump to write
-	 * it to an xmlBuffer -from which an xmlChar * string is returned.
+	 * iterates over each node in the set and calls xmlNodeDump to write it to
+	 * an xmlBuffer -from which an xmlChar * string is returned.
 	 */
 
 	/* each representation is surrounded by <tagname> ... </tagname> */
 
 	/*
-	 * plainsep is an ordinary (not tag) seperator - if used, then nodes
-	 * are cast to string as output method
+	 * plainsep is an ordinary (not tag) seperator - if used, then nodes are
+	 * cast to string as output method
 	 */
 
 
@@ -257,7 +258,7 @@ pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
 			if (plainsep != NULL)
 			{
 				xmlBufferWriteCHAR(buf,
-						  xmlXPathCastNodeToString(nodeset->nodeTab[i]));
+							  xmlXPathCastNodeToString(nodeset->nodeTab[i]));
 
 				/* If this isn't the last entry, write the plain sep. */
 				if (i < (nodeset->nodeNr) - 1)
@@ -412,8 +413,8 @@ xpath_string(PG_FUNCTION_ARGS)
 	pathsize = VARSIZE(xpathsupp) - VARHDRSZ;
 
 	/*
-	 * We encapsulate the supplied path with "string()" = 8 chars + 1 for
-	 * NUL at end
+	 * We encapsulate the supplied path with "string()" = 8 chars + 1 for NUL
+	 * at end
 	 */
 	/* We could try casting to string using the libxml function? */
 
@@ -663,8 +664,8 @@ xpath_table(PG_FUNCTION_ARGS)
 	int			proc;
 	int			i;
 	int			j;
-	int			rownr;			/* For issuing multiple rows from one
-								 * original document */
+	int			rownr;			/* For issuing multiple rows from one original
+								 * document */
 	int			had_values;		/* To determine end of nodeset results */
 
 	StringInfo	querysql;
@@ -686,17 +687,19 @@ xpath_table(PG_FUNCTION_ARGS)
 	if (!(rsinfo->allowedModes & SFRM_Materialize))
 		ereport(ERROR,
 				(errcode(ERRCODE_SYNTAX_ERROR),
-				 errmsg("xpath_table requires Materialize mode, but it is not "
-						"allowed in this context")));
+			   errmsg("xpath_table requires Materialize mode, but it is not "
+					  "allowed in this context")));
 
-	/* The tuplestore must exist in a higher context than
-	 * this function call (per_query_ctx is used)
+	/*
+	 * The tuplestore must exist in a higher context than this function call
+	 * (per_query_ctx is used)
 	 */
 
 	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
 	oldcontext = MemoryContextSwitchTo(per_query_ctx);
 
-	/* Create the tuplestore - work_mem is the max in-memory size before a
+	/*
+	 * Create the tuplestore - work_mem is the max in-memory size before a
 	 * file is created on disk to hold it.
 	 */
 	tupstore = tuplestore_begin_heap(true, false, work_mem);
@@ -707,11 +710,11 @@ xpath_table(PG_FUNCTION_ARGS)
 	ret_tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
 
 	/*
-	 * At the moment we assume that the returned attributes make sense for
-	 * the XPath specififed (i.e. we trust the caller). It's not fatal if
-	 * they get it wrong - the input function for the column type will
-	 * raise an error if the path result can't be converted into the
-	 * correct binary representation.
+	 * At the moment we assume that the returned attributes make sense for the
+	 * XPath specififed (i.e. we trust the caller). It's not fatal if they get
+	 * it wrong - the input function for the column type will raise an error
+	 * if the path result can't be converted into the correct binary
+	 * representation.
 	 */
 
 	attinmeta = TupleDescGetAttInMetadata(ret_tupdesc);
@@ -810,8 +813,8 @@ xpath_table(PG_FUNCTION_ARGS)
 
 
 		/*
-		 * Clear the values array, so that not-well-formed documents
-		 * return NULL in all columns.
+		 * Clear the values array, so that not-well-formed documents return
+		 * NULL in all columns.
 		 */
 
 		/* Note that this also means that spare columns will be NULL. */
@@ -825,8 +828,7 @@ xpath_table(PG_FUNCTION_ARGS)
 		doctree = xmlParseMemory(xmldoc, strlen(xmldoc));
 
 		if (doctree == NULL)
-		{						/* not well-formed, so output all-NULL
-								 * tuple */
+		{						/* not well-formed, so output all-NULL tuple */
 
 			ret_tuple = BuildTupleFromCStrings(attinmeta, values);
 			oldcontext = MemoryContextSwitchTo(per_query_ctx);
@@ -933,10 +935,10 @@ xpath_table(PG_FUNCTION_ARGS)
 
 	/*
 	 * SFRM_Materialize mode expects us to return a NULL Datum. The actual
-	 * tuples are in our tuplestore and passed back through
-	 * rsinfo->setResult. rsinfo->setDesc is set to the tuple description
-	 * that we actually used to build our tuples with, so the caller can
-	 * verify we did what it was expecting.
+	 * tuples are in our tuplestore and passed back through rsinfo->setResult.
+	 * rsinfo->setDesc is set to the tuple description that we actually used
+	 * to build our tuples with, so the caller can verify we did what it was
+	 * expecting.
 	 */
 	return (Datum) 0;
 
diff --git a/contrib/xml2/xslt_proc.c b/contrib/xml2/xslt_proc.c
index 7b044a9e8a..ff2ab8d045 100644
--- a/contrib/xml2/xslt_proc.c
+++ b/contrib/xml2/xslt_proc.c
@@ -65,7 +65,7 @@ xslt_process(PG_FUNCTION_ARGS)
 		parse_params(params, paramstr);
 	}
 	else
-	/* No parameters */
+		/* No parameters */
 		params[0] = NULL;
 
 	/* Setup parser */
diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
index 40687f531d..17811ccb98 100644
--- a/src/backend/access/common/heaptuple.c
+++ b/src/backend/access/common/heaptuple.c
@@ -6,7 +6,7 @@
  *
  * NOTE: there is massive duplication of code in this module to
  * support both the convention that a null is marked by a bool TRUE,
- * and the convention that a null is marked by a char 'n'.  The latter
+ * and the convention that a null is marked by a char 'n'.	The latter
  * convention is deprecated but it'll probably be a long time before
  * we can get rid of it entirely.
  *
@@ -452,8 +452,8 @@ nocachegetattr(HeapTuple tuple,
 			int			j;
 
 			/*
-			 * In for(), we test <= and not < because we want to see if we
-			 * can go past it in initializing offsets.
+			 * In for(), we test <= and not < because we want to see if we can
+			 * go past it in initializing offsets.
 			 */
 			for (j = 0; j <= attnum; j++)
 			{
@@ -467,10 +467,9 @@ nocachegetattr(HeapTuple tuple,
 	}
 
 	/*
-	 * If slow is false, and we got here, we know that we have a tuple
-	 * with no nulls or var-widths before the target attribute. If
-	 * possible, we also want to initialize the remainder of the attribute
-	 * cached offset values.
+	 * If slow is false, and we got here, we know that we have a tuple with no
+	 * nulls or var-widths before the target attribute. If possible, we also
+	 * want to initialize the remainder of the attribute cached offset values.
 	 */
 	if (!slow)
 	{
@@ -513,11 +512,11 @@ nocachegetattr(HeapTuple tuple,
 		/*
 		 * Now we know that we have to walk the tuple CAREFULLY.
 		 *
-		 * Note - This loop is a little tricky.  For each non-null attribute,
-		 * we have to first account for alignment padding before the attr,
-		 * then advance over the attr based on its length.  Nulls have no
-		 * storage and no alignment padding either.  We can use/set attcacheoff
-		 * until we pass either a null or a var-width attribute.
+		 * Note - This loop is a little tricky.  For each non-null attribute, we
+		 * have to first account for alignment padding before the attr, then
+		 * advance over the attr based on its length.  Nulls have no storage
+		 * and no alignment padding either.  We can use/set attcacheoff until
+		 * we pass either a null or a var-width attribute.
 		 */
 
 		for (i = 0; i < attnum; i++)
@@ -597,15 +596,13 @@ heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
 			break;
 
 			/*
-			 * If the attribute number is 0, then we are supposed to
-			 * return the entire tuple as a row-type Datum.  (Using zero
-			 * for this purpose is unclean since it risks confusion with
-			 * "invalid attr" result codes, but it's not worth changing
-			 * now.)
+			 * If the attribute number is 0, then we are supposed to return
+			 * the entire tuple as a row-type Datum.  (Using zero for this
+			 * purpose is unclean since it risks confusion with "invalid attr"
+			 * result codes, but it's not worth changing now.)
 			 *
-			 * We have to make a copy of the tuple so we can safely insert
-			 * the Datum overhead fields, which are not set in on-disk
-			 * tuples.
+			 * We have to make a copy of the tuple so we can safely insert the
+			 * Datum overhead fields, which are not set in on-disk tuples.
 			 */
 		case InvalidAttrNumber:
 			{
@@ -708,15 +705,15 @@ heap_form_tuple(TupleDesc tupleDescriptor,
 						numberOfAttributes, MaxTupleAttributeNumber)));
 
 	/*
-	 * Check for nulls and embedded tuples; expand any toasted attributes
-	 * in embedded tuples.	This preserves the invariant that toasting can
-	 * only go one level deep.
+	 * Check for nulls and embedded tuples; expand any toasted attributes in
+	 * embedded tuples.  This preserves the invariant that toasting can only
+	 * go one level deep.
 	 *
 	 * We can skip calling toast_flatten_tuple_attribute() if the attribute
 	 * couldn't possibly be of composite type.  All composite datums are
-	 * varlena and have alignment 'd'; furthermore they aren't arrays.
-	 * Also, if an attribute is already toasted, it must have been sent to
-	 * disk already and so cannot contain toasted attributes.
+	 * varlena and have alignment 'd'; furthermore they aren't arrays. Also,
+	 * if an attribute is already toasted, it must have been sent to disk
+	 * already and so cannot contain toasted attributes.
 	 */
 	for (i = 0; i < numberOfAttributes; i++)
 	{
@@ -757,8 +754,8 @@ heap_form_tuple(TupleDesc tupleDescriptor,
 	tuple->t_data = td = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
 
 	/*
-	 * And fill in the information.  Note we fill the Datum fields even
-	 * though this tuple may never become a Datum.
+	 * And fill in the information.  Note we fill the Datum fields even though
+	 * this tuple may never become a Datum.
 	 */
 	tuple->t_len = len;
 	ItemPointerSetInvalid(&(tuple->t_self));
@@ -816,15 +813,15 @@ heap_formtuple(TupleDesc tupleDescriptor,
 						numberOfAttributes, MaxTupleAttributeNumber)));
 
 	/*
-	 * Check for nulls and embedded tuples; expand any toasted attributes
-	 * in embedded tuples.	This preserves the invariant that toasting can
-	 * only go one level deep.
+	 * Check for nulls and embedded tuples; expand any toasted attributes in
+	 * embedded tuples.  This preserves the invariant that toasting can only
+	 * go one level deep.
 	 *
 	 * We can skip calling toast_flatten_tuple_attribute() if the attribute
 	 * couldn't possibly be of composite type.  All composite datums are
-	 * varlena and have alignment 'd'; furthermore they aren't arrays.
-	 * Also, if an attribute is already toasted, it must have been sent to
-	 * disk already and so cannot contain toasted attributes.
+	 * varlena and have alignment 'd'; furthermore they aren't arrays. Also,
+	 * if an attribute is already toasted, it must have been sent to disk
+	 * already and so cannot contain toasted attributes.
 	 */
 	for (i = 0; i < numberOfAttributes; i++)
 	{
@@ -865,8 +862,8 @@ heap_formtuple(TupleDesc tupleDescriptor,
 	tuple->t_data = td = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
 
 	/*
-	 * And fill in the information.  Note we fill the Datum fields even
-	 * though this tuple may never become a Datum.
+	 * And fill in the information.  Note we fill the Datum fields even though
+	 * this tuple may never become a Datum.
 	 */
 	tuple->t_len = len;
 	ItemPointerSetInvalid(&(tuple->t_self));
@@ -917,15 +914,15 @@ heap_modify_tuple(HeapTuple tuple,
 	HeapTuple	newTuple;
 
 	/*
-	 * allocate and fill values and isnull arrays from either the tuple or
-	 * the repl information, as appropriate.
+	 * allocate and fill values and isnull arrays from either the tuple or the
+	 * repl information, as appropriate.
 	 *
 	 * NOTE: it's debatable whether to use heap_deform_tuple() here or just
-	 * heap_getattr() only the non-replaced colums.  The latter could win
-	 * if there are many replaced columns and few non-replaced ones.
-	 * However, heap_deform_tuple costs only O(N) while the heap_getattr
-	 * way would cost O(N^2) if there are many non-replaced columns, so it
-	 * seems better to err on the side of linear cost.
+	 * heap_getattr() only the non-replaced colums.  The latter could win if
+	 * there are many replaced columns and few non-replaced ones. However,
+	 * heap_deform_tuple costs only O(N) while the heap_getattr way would cost
+	 * O(N^2) if there are many non-replaced columns, so it seems better to
+	 * err on the side of linear cost.
 	 */
 	values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
 	isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));
@@ -950,8 +947,8 @@ heap_modify_tuple(HeapTuple tuple,
 	pfree(isnull);
 
 	/*
-	 * copy the identification info of the old tuple: t_ctid, t_self, and
-	 * OID (if any)
+	 * copy the identification info of the old tuple: t_ctid, t_self, and OID
+	 * (if any)
 	 */
 	newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
 	newTuple->t_self = tuple->t_self;
@@ -986,15 +983,15 @@ heap_modifytuple(HeapTuple tuple,
 	HeapTuple	newTuple;
 
 	/*
-	 * allocate and fill values and nulls arrays from either the tuple or
-	 * the repl information, as appropriate.
+	 * allocate and fill values and nulls arrays from either the tuple or the
+	 * repl information, as appropriate.
 	 *
 	 * NOTE: it's debatable whether to use heap_deformtuple() here or just
-	 * heap_getattr() only the non-replaced colums.  The latter could win
-	 * if there are many replaced columns and few non-replaced ones.
-	 * However, heap_deformtuple costs only O(N) while the heap_getattr
-	 * way would cost O(N^2) if there are many non-replaced columns, so it
-	 * seems better to err on the side of linear cost.
+	 * heap_getattr() only the non-replaced colums.  The latter could win if
+	 * there are many replaced columns and few non-replaced ones. However,
+	 * heap_deformtuple costs only O(N) while the heap_getattr way would cost
+	 * O(N^2) if there are many non-replaced columns, so it seems better to
+	 * err on the side of linear cost.
 	 */
 	values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
 	nulls = (char *) palloc(numberOfAttributes * sizeof(char));
@@ -1022,8 +1019,8 @@ heap_modifytuple(HeapTuple tuple,
 	pfree(nulls);
 
 	/*
-	 * copy the identification info of the old tuple: t_ctid, t_self, and
-	 * OID (if any)
+	 * copy the identification info of the old tuple: t_ctid, t_self, and OID
+	 * (if any)
 	 */
 	newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
 	newTuple->t_self = tuple->t_self;
@@ -1068,9 +1065,9 @@ heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
 	natts = tup->t_natts;
 
 	/*
-	 * In inheritance situations, it is possible that the given tuple
-	 * actually has more fields than the caller is expecting.  Don't run
-	 * off the end of the caller's arrays.
+	 * In inheritance situations, it is possible that the given tuple actually
+	 * has more fields than the caller is expecting.  Don't run off the end of
+	 * the caller's arrays.
 	 */
 	natts = Min(natts, tdesc_natts);
 
@@ -1161,9 +1158,9 @@ heap_deformtuple(HeapTuple tuple,
 	natts = tup->t_natts;
 
 	/*
-	 * In inheritance situations, it is possible that the given tuple
-	 * actually has more fields than the caller is expecting.  Don't run
-	 * off the end of the caller's arrays.
+	 * In inheritance situations, it is possible that the given tuple actually
+	 * has more fields than the caller is expecting.  Don't run off the end of
+	 * the caller's arrays.
 	 */
 	natts = Min(natts, tdesc_natts);
 
@@ -1228,22 +1225,22 @@ heap_deformtuple(HeapTuple tuple,
 static void
 slot_deform_tuple(TupleTableSlot *slot, int natts)
 {
-	HeapTuple		tuple = slot->tts_tuple;
-	TupleDesc		tupleDesc = slot->tts_tupleDescriptor;
+	HeapTuple	tuple = slot->tts_tuple;
+	TupleDesc	tupleDesc = slot->tts_tupleDescriptor;
 	Datum	   *values = slot->tts_values;
 	bool	   *isnull = slot->tts_isnull;
-	HeapTupleHeader	tup = tuple->t_data;
+	HeapTupleHeader tup = tuple->t_data;
 	bool		hasnulls = HeapTupleHasNulls(tuple);
 	Form_pg_attribute *att = tupleDesc->attrs;
 	int			attnum;
-	char	   *tp;					/* ptr to tuple data */
-	long		off;				/* offset in tuple data */
-	bits8	   *bp = tup->t_bits;	/* ptr to null bitmap in tuple */
-	bool		slow;				/* can we use/set attcacheoff? */
+	char	   *tp;				/* ptr to tuple data */
+	long		off;			/* offset in tuple data */
+	bits8	   *bp = tup->t_bits;		/* ptr to null bitmap in tuple */
+	bool		slow;			/* can we use/set attcacheoff? */
 
 	/*
-	 * Check whether the first call for this tuple, and initialize or
-	 * restore loop state.
+	 * Check whether the first call for this tuple, and initialize or restore
+	 * loop state.
 	 */
 	attnum = slot->tts_nvalid;
 	if (attnum == 0)
@@ -1269,7 +1266,7 @@ slot_deform_tuple(TupleTableSlot *slot, int natts)
 		{
 			values[attnum] = (Datum) 0;
 			isnull[attnum] = true;
-			slow = true;        /* can't use attcacheoff anymore */
+			slow = true;		/* can't use attcacheoff anymore */
 			continue;
 		}
 
@@ -1290,7 +1287,7 @@ slot_deform_tuple(TupleTableSlot *slot, int natts)
 		off = att_addlength(off, thisatt->attlen, tp + off);
 
 		if (thisatt->attlen <= 0)
-			slow = true;        /* can't use attcacheoff anymore */
+			slow = true;		/* can't use attcacheoff anymore */
 	}
 
 	/*
@@ -1316,9 +1313,9 @@ slot_deform_tuple(TupleTableSlot *slot, int natts)
 Datum
 slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
 {
-	HeapTuple		tuple = slot->tts_tuple;
-	TupleDesc		tupleDesc = slot->tts_tupleDescriptor;
-	HeapTupleHeader	tup;
+	HeapTuple	tuple = slot->tts_tuple;
+	TupleDesc	tupleDesc = slot->tts_tupleDescriptor;
+	HeapTupleHeader tup;
 
 	/*
 	 * system attributes are handled by heap_getsysattr
@@ -1349,18 +1346,18 @@ slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
 	}
 
 	/*
-	 * otherwise we had better have a physical tuple (tts_nvalid should
-	 * equal natts in all virtual-tuple cases)
+	 * otherwise we had better have a physical tuple (tts_nvalid should equal
+	 * natts in all virtual-tuple cases)
 	 */
-	if (tuple == NULL)		/* internal error */
+	if (tuple == NULL)			/* internal error */
 		elog(ERROR, "cannot extract attribute from empty tuple slot");
 
 	/*
 	 * return NULL if attnum is out of range according to the tuple
 	 *
-	 * (We have to check this separately because of various inheritance
-	 * and table-alteration scenarios: the tuple could be either longer
-	 * or shorter than the tupdesc.)
+	 * (We have to check this separately because of various inheritance and
+	 * table-alteration scenarios: the tuple could be either longer or shorter
+	 * than the tupdesc.)
 	 */
 	tup = tuple->t_data;
 	if (attnum > tup->t_natts)
@@ -1379,10 +1376,9 @@ slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
 	}
 
 	/*
-	 * If the attribute's column has been dropped, we force a NULL
-	 * result. This case should not happen in normal use, but it could
-	 * happen if we are executing a plan cached before the column was
-	 * dropped.
+	 * If the attribute's column has been dropped, we force a NULL result.
+	 * This case should not happen in normal use, but it could happen if we
+	 * are executing a plan cached before the column was dropped.
 	 */
 	if (tupleDesc->attrs[attnum - 1]->attisdropped)
 	{
@@ -1420,11 +1416,11 @@ slot_getallattrs(TupleTableSlot *slot)
 		return;
 
 	/*
-	 * otherwise we had better have a physical tuple (tts_nvalid should
-	 * equal natts in all virtual-tuple cases)
+	 * otherwise we had better have a physical tuple (tts_nvalid should equal
+	 * natts in all virtual-tuple cases)
 	 */
 	tuple = slot->tts_tuple;
-	if (tuple == NULL)		/* internal error */
+	if (tuple == NULL)			/* internal error */
 		elog(ERROR, "cannot extract attribute from empty tuple slot");
 
 	/*
@@ -1467,11 +1463,11 @@ slot_getsomeattrs(TupleTableSlot *slot, int attnum)
 		elog(ERROR, "invalid attribute number %d", attnum);
 
 	/*
-	 * otherwise we had better have a physical tuple (tts_nvalid should
-	 * equal natts in all virtual-tuple cases)
+	 * otherwise we had better have a physical tuple (tts_nvalid should equal
+	 * natts in all virtual-tuple cases)
 	 */
 	tuple = slot->tts_tuple;
-	if (tuple == NULL)		/* internal error */
+	if (tuple == NULL)			/* internal error */
 		elog(ERROR, "cannot extract attribute from empty tuple slot");
 
 	/*
@@ -1502,8 +1498,8 @@ slot_getsomeattrs(TupleTableSlot *slot, int attnum)
 bool
 slot_attisnull(TupleTableSlot *slot, int attnum)
 {
-	HeapTuple		tuple = slot->tts_tuple;
-	TupleDesc		tupleDesc = slot->tts_tupleDescriptor;
+	HeapTuple	tuple = slot->tts_tuple;
+	TupleDesc	tupleDesc = slot->tts_tupleDescriptor;
 
 	/*
 	 * system attributes are handled by heap_attisnull
@@ -1528,10 +1524,10 @@ slot_attisnull(TupleTableSlot *slot, int attnum)
 		return true;
 
 	/*
-	 * otherwise we had better have a physical tuple (tts_nvalid should
-	 * equal natts in all virtual-tuple cases)
+	 * otherwise we had better have a physical tuple (tts_nvalid should equal
+	 * natts in all virtual-tuple cases)
 	 */
-	if (tuple == NULL)		/* internal error */
+	if (tuple == NULL)			/* internal error */
 		elog(ERROR, "cannot extract attribute from empty tuple slot");
 
 	/* and let the tuple tell it */
diff --git a/src/backend/access/common/indextuple.c b/src/backend/access/common/indextuple.c
index a7de488b42..5d19cab77a 100644
--- a/src/backend/access/common/indextuple.c
+++ b/src/backend/access/common/indextuple.c
@@ -70,20 +70,20 @@ index_form_tuple(TupleDesc tupleDescriptor,
 			continue;
 
 		/*
-		 * If value is stored EXTERNAL, must fetch it so we are not
-		 * depending on outside storage.  This should be improved someday.
+		 * If value is stored EXTERNAL, must fetch it so we are not depending
+		 * on outside storage.	This should be improved someday.
 		 */
 		if (VARATT_IS_EXTERNAL(values[i]))
 		{
 			untoasted_values[i] = PointerGetDatum(
-												 heap_tuple_fetch_attr(
-							   (varattrib *) DatumGetPointer(values[i])));
+												  heap_tuple_fetch_attr(
+								  (varattrib *) DatumGetPointer(values[i])));
 			untoasted_free[i] = true;
 		}
 
 		/*
-		 * If value is above size target, and is of a compressible
-		 * datatype, try to compress it in-line.
+		 * If value is above size target, and is of a compressible datatype,
+		 * try to compress it in-line.
 		 */
 		if (VARATT_SIZE(untoasted_values[i]) > TOAST_INDEX_TARGET &&
 			!VARATT_IS_EXTENDED(untoasted_values[i]) &&
@@ -149,23 +149,23 @@ index_form_tuple(TupleDesc tupleDescriptor,
 
 	/*
 	 * We do this because heap_fill_tuple wants to initialize a "tupmask"
-	 * which is used for HeapTuples, but we want an indextuple infomask.
-	 * The only relevant info is the "has variable attributes" field.
-	 * We have already set the hasnull bit above.
+	 * which is used for HeapTuples, but we want an indextuple infomask. The
+	 * only relevant info is the "has variable attributes" field. We have
+	 * already set the hasnull bit above.
 	 */
 	if (tupmask & HEAP_HASVARWIDTH)
 		infomask |= INDEX_VAR_MASK;
 
 	/*
-	 * Here we make sure that the size will fit in the field reserved for
-	 * it in t_info.
+	 * Here we make sure that the size will fit in the field reserved for it
+	 * in t_info.
 	 */
 	if ((size & INDEX_SIZE_MASK) != size)
 		ereport(ERROR,
 				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-			  errmsg("index row requires %lu bytes, maximum size is %lu",
-					 (unsigned long) size,
-					 (unsigned long) INDEX_SIZE_MASK)));
+				 errmsg("index row requires %lu bytes, maximum size is %lu",
+						(unsigned long) size,
+						(unsigned long) INDEX_SIZE_MASK)));
 
 	infomask |= size;
 
@@ -322,10 +322,9 @@ nocache_index_getattr(IndexTuple tup,
 	}
 
 	/*
-	 * If slow is false, and we got here, we know that we have a tuple
-	 * with no nulls or var-widths before the target attribute. If
-	 * possible, we also want to initialize the remainder of the attribute
-	 * cached offset values.
+	 * If slow is false, and we got here, we know that we have a tuple with no
+	 * nulls or var-widths before the target attribute. If possible, we also
+	 * want to initialize the remainder of the attribute cached offset values.
 	 */
 	if (!slow)
 	{
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 5bc9f6d0c1..03db48f044 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -78,9 +78,9 @@ printtup_create_DR(CommandDest dest, Portal portal)
 	else
 	{
 		/*
-		 * In protocol 2.0 the Bind message does not exist, so there is no
-		 * way for the columns to have different print formats; it's
-		 * sufficient to look at the first one.
+		 * In protocol 2.0 the Bind message does not exist, so there is no way
+		 * for the columns to have different print formats; it's sufficient to
+		 * look at the first one.
 		 */
 		if (portal->formats && portal->formats[0] != 0)
 			self->pub.receiveSlot = printtup_internal_20;
@@ -113,8 +113,7 @@ printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
 	if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
 	{
 		/*
-		 * Send portal name to frontend (obsolete cruft, gone in proto
-		 * 3.0)
+		 * Send portal name to frontend (obsolete cruft, gone in proto 3.0)
 		 *
 		 * If portal name not specified, use "blank" portal.
 		 */
@@ -127,8 +126,8 @@ printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
 	}
 
 	/*
-	 * If this is a retrieve, and we are supposed to emit row
-	 * descriptions, then we send back the tuple descriptor of the tuples.
+	 * If this is a retrieve, and we are supposed to emit row descriptions,
+	 * then we send back the tuple descriptor of the tuples.
 	 */
 	if (operation == CMD_SELECT && myState->sendDescrip)
 		SendRowDescriptionMessage(typeinfo,
@@ -280,7 +279,7 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
 static void
 printtup(TupleTableSlot *slot, DestReceiver *self)
 {
-	TupleDesc typeinfo = slot->tts_tupleDescriptor;
+	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
 	DR_printtup *myState = (DR_printtup *) self;
 	StringInfoData buf;
 	int			natts = typeinfo->natts;
@@ -363,7 +362,7 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
 static void
 printtup_20(TupleTableSlot *slot, DestReceiver *self)
 {
-	TupleDesc typeinfo = slot->tts_tupleDescriptor;
+	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
 	DR_printtup *myState = (DR_printtup *) self;
 	StringInfoData buf;
 	int			natts = typeinfo->natts;
@@ -566,7 +565,7 @@ debugtup(TupleTableSlot *slot, DestReceiver *self)
 static void
 printtup_internal_20(TupleTableSlot *slot, DestReceiver *self)
 {
-	TupleDesc typeinfo = slot->tts_tupleDescriptor;
+	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
 	DR_printtup *myState = (DR_printtup *) self;
 	StringInfoData buf;
 	int			natts = typeinfo->natts;
diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index ad5b5b1339..a9740948c1 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -49,10 +49,10 @@ CreateTemplateTupleDesc(int natts, bool hasoid)
 	 * Allocate enough memory for the tuple descriptor, including the
 	 * attribute rows, and set up the attribute row pointers.
 	 *
-	 * Note: we assume that sizeof(struct tupleDesc) is a multiple of
-	 * the struct pointer alignment requirement, and hence we don't need
-	 * to insert alignment padding between the struct and the array of
-	 * attribute row pointers.
+	 * Note: we assume that sizeof(struct tupleDesc) is a multiple of the struct
+	 * pointer alignment requirement, and hence we don't need to insert
+	 * alignment padding between the struct and the array of attribute row
+	 * pointers.
 	 */
 	attroffset = sizeof(struct tupleDesc) + natts * sizeof(Form_pg_attribute);
 	attroffset = MAXALIGN(attroffset);
@@ -273,16 +273,16 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
 		Form_pg_attribute attr2 = tupdesc2->attrs[i];
 
 		/*
-		 * We do not need to check every single field here: we can
-		 * disregard attrelid and attnum (which were used to place the row
-		 * in the attrs array in the first place).  It might look like we
-		 * could dispense with checking attlen/attbyval/attalign, since these
-		 * are derived from atttypid; but in the case of dropped columns
-		 * we must check them (since atttypid will be zero for all dropped
-		 * columns) and in general it seems safer to check them always.
+		 * We do not need to check every single field here: we can disregard
+		 * attrelid and attnum (which were used to place the row in the attrs
+		 * array in the first place).  It might look like we could dispense
+		 * with checking attlen/attbyval/attalign, since these are derived
+		 * from atttypid; but in the case of dropped columns we must check
+		 * them (since atttypid will be zero for all dropped columns) and in
+		 * general it seems safer to check them always.
 		 *
-		 * attcacheoff must NOT be checked since it's possibly not set
-		 * in both copies.
+		 * attcacheoff must NOT be checked since it's possibly not set in both
+		 * copies.
 		 */
 		if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
 			return false;
@@ -332,9 +332,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
 			AttrDefault *defval2 = constr2->defval;
 
 			/*
-			 * We can't assume that the items are always read from the
-			 * system catalogs in the same order; so use the adnum field
-			 * to identify the matching item to compare.
+			 * We can't assume that the items are always read from the system
+			 * catalogs in the same order; so use the adnum field to identify
+			 * the matching item to compare.
 			 */
 			for (j = 0; j < n; defval2++, j++)
 			{
@@ -355,9 +355,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
 			ConstrCheck *check2 = constr2->check;
 
 			/*
-			 * Similarly, don't assume that the checks are always read in
-			 * the same order; match them up by name and contents. (The
-			 * name *should* be unique, but...)
+			 * Similarly, don't assume that the checks are always read in the
+			 * same order; match them up by name and contents. (The name
+			 * *should* be unique, but...)
 			 */
 			for (j = 0; j < n; check2++, j++)
 			{
@@ -407,8 +407,8 @@ TupleDescInitEntry(TupleDesc desc,
 
 	/*
 	 * Note: attributeName can be NULL, because the planner doesn't always
-	 * fill in valid resname values in targetlists, particularly for
-	 * resjunk attributes.
+	 * fill in valid resname values in targetlists, particularly for resjunk
+	 * attributes.
 	 */
 	if (attributeName != NULL)
 		namestrcpy(&(att->attname), attributeName);
@@ -482,8 +482,8 @@ BuildDescForRelation(List *schema)
 		ColumnDef  *entry = lfirst(l);
 
 		/*
-		 * for each entry in the list, get the name and type information
-		 * from the list and have TupleDescInitEntry fill in the attribute
+		 * for each entry in the list, get the name and type information from
+		 * the list and have TupleDescInitEntry fill in the attribute
 		 * information we need.
 		 */
 		attnum++;
@@ -508,8 +508,8 @@ BuildDescForRelation(List *schema)
 		desc->attrs[attnum - 1]->attnotnull = entry->is_not_null;
 
 		/*
-		 * Note we copy only pre-cooked default expressions. Digestion of
-		 * raw ones is someone else's problem.
+		 * Note we copy only pre-cooked default expressions. Digestion of raw
+		 * ones is someone else's problem.
 		 */
 		if (entry->cooked_default != NULL)
 		{
diff --git a/src/backend/access/gist/gistproc.c b/src/backend/access/gist/gistproc.c
index 784ee261a6..bb77c80e6c 100644
--- a/src/backend/access/gist/gistproc.c
+++ b/src/backend/access/gist/gistproc.c
@@ -26,7 +26,7 @@ typedef struct
 {
 	BOX		   *key;
 	int			pos;
-}	KBsort;
+} KBsort;
 
 static int	compare_KB(const void *a, const void *b);
 static bool gist_box_leaf_consistent(BOX *key, BOX *query,
diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
index 4d73f8f9c0..5e36330617 100644
--- a/src/backend/access/hash/hash.c
+++ b/src/backend/access/hash/hash.c
@@ -55,8 +55,8 @@ hashbuild(PG_FUNCTION_ARGS)
 	HashBuildState buildstate;
 
 	/*
-	 * We expect to be called exactly once for any index relation. If
-	 * that's not the case, big trouble's what we have.
+	 * We expect to be called exactly once for any index relation. If that's
+	 * not the case, big trouble's what we have.
 	 */
 	if (RelationGetNumberOfBlocks(index) != 0)
 		elog(ERROR, "index \"%s\" already contains data",
@@ -70,7 +70,7 @@ hashbuild(PG_FUNCTION_ARGS)
 
 	/* do the heap scan */
 	reltuples = IndexBuildHeapScan(heap, index, indexInfo,
-								hashbuildCallback, (void *) &buildstate);
+								   hashbuildCallback, (void *) &buildstate);
 
 	/* since we just counted the # of tuples, may as well update stats */
 	IndexCloseAndUpdateStats(heap, reltuples, index, buildstate.indtuples);
@@ -141,12 +141,12 @@ hashinsert(PG_FUNCTION_ARGS)
 
 	/*
 	 * If the single index key is null, we don't insert it into the index.
-	 * Hash tables support scans on '='. Relational algebra says that A =
-	 * B returns null if either A or B is null.  This means that no
-	 * qualification used in an index scan could ever return true on a
-	 * null attribute.	It also means that indices can't be used by ISNULL
-	 * or NOTNULL scans, but that's an artifact of the strategy map
-	 * architecture chosen in 1986, not of the way nulls are handled here.
+	 * Hash tables support scans on '='. Relational algebra says that A = B
+	 * returns null if either A or B is null.  This means that no
+	 * qualification used in an index scan could ever return true on a null
+	 * attribute.  It also means that indices can't be used by ISNULL or
+	 * NOTNULL scans, but that's an artifact of the strategy map architecture
+	 * chosen in 1986, not of the way nulls are handled here.
 	 */
 	if (IndexTupleHasNulls(itup))
 	{
@@ -180,16 +180,16 @@ hashgettuple(PG_FUNCTION_ARGS)
 	bool		res;
 
 	/*
-	 * We hold pin but not lock on current buffer while outside the hash
-	 * AM. Reacquire the read lock here.
+	 * We hold pin but not lock on current buffer while outside the hash AM.
+	 * Reacquire the read lock here.
 	 */
 	if (BufferIsValid(so->hashso_curbuf))
 		_hash_chgbufaccess(rel, so->hashso_curbuf, HASH_NOLOCK, HASH_READ);
 
 	/*
-	 * If we've already initialized this scan, we can just advance it in
-	 * the appropriate direction.  If we haven't done so yet, we call a
-	 * routine to get the first item in the scan.
+	 * If we've already initialized this scan, we can just advance it in the
+	 * appropriate direction.  If we haven't done so yet, we call a routine to
+	 * get the first item in the scan.
 	 */
 	if (ItemPointerIsValid(&(scan->currentItemData)))
 	{
@@ -199,17 +199,16 @@ hashgettuple(PG_FUNCTION_ARGS)
 		if (scan->kill_prior_tuple)
 		{
 			/*
-			 * Yes, so mark it by setting the LP_DELETE bit in the item
-			 * flags.
+			 * Yes, so mark it by setting the LP_DELETE bit in the item flags.
 			 */
 			offnum = ItemPointerGetOffsetNumber(&(scan->currentItemData));
 			page = BufferGetPage(so->hashso_curbuf);
 			PageGetItemId(page, offnum)->lp_flags |= LP_DELETE;
 
 			/*
-			 * Since this can be redone later if needed, it's treated the
-			 * same as a commit-hint-bit status update for heap tuples: we
-			 * mark the buffer dirty but don't make a WAL log entry.
+			 * Since this can be redone later if needed, it's treated the same
+			 * as a commit-hint-bit status update for heap tuples: we mark the
+			 * buffer dirty but don't make a WAL log entry.
 			 */
 			SetBufferCommitInfoNeedsSave(so->hashso_curbuf);
 		}
@@ -256,7 +255,7 @@ Datum
 hashgetmulti(PG_FUNCTION_ARGS)
 {
 	IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
-	ItemPointer	tids = (ItemPointer) PG_GETARG_POINTER(1);
+	ItemPointer tids = (ItemPointer) PG_GETARG_POINTER(1);
 	int32		max_tids = PG_GETARG_INT32(2);
 	int32	   *returned_tids = (int32 *) PG_GETARG_POINTER(3);
 	HashScanOpaque so = (HashScanOpaque) scan->opaque;
@@ -265,8 +264,8 @@ hashgetmulti(PG_FUNCTION_ARGS)
 	int32		ntids = 0;
 
 	/*
-	 * We hold pin but not lock on current buffer while outside the hash
-	 * AM. Reacquire the read lock here.
+	 * We hold pin but not lock on current buffer while outside the hash AM.
+	 * Reacquire the read lock here.
 	 */
 	if (BufferIsValid(so->hashso_curbuf))
 		_hash_chgbufaccess(rel, so->hashso_curbuf, HASH_NOLOCK, HASH_READ);
@@ -280,6 +279,7 @@ hashgetmulti(PG_FUNCTION_ARGS)
 			res = _hash_next(scan, ForwardScanDirection);
 		else
 			res = _hash_first(scan, ForwardScanDirection);
+
 		/*
 		 * Skip killed tuples if asked to.
 		 */
@@ -505,12 +505,12 @@ hashbulkdelete(PG_FUNCTION_ARGS)
 	num_index_tuples = 0;
 
 	/*
-	 * Read the metapage to fetch original bucket and tuple counts.  Also,
-	 * we keep a copy of the last-seen metapage so that we can use its
-	 * hashm_spares[] values to compute bucket page addresses.	This is a
-	 * bit hokey but perfectly safe, since the interesting entries in the
-	 * spares array cannot change under us; and it beats rereading the
-	 * metapage for each bucket.
+	 * Read the metapage to fetch original bucket and tuple counts.  Also, we
+	 * keep a copy of the last-seen metapage so that we can use its
+	 * hashm_spares[] values to compute bucket page addresses.	This is a bit
+	 * hokey but perfectly safe, since the interesting entries in the spares
+	 * array cannot change under us; and it beats rereading the metapage for
+	 * each bucket.
 	 */
 	metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ);
 	metap = (HashMetaPage) BufferGetPage(metabuf);
@@ -569,7 +569,7 @@ loop_top:
 				ItemPointer htup;
 
 				hitem = (HashItem) PageGetItem(page,
-											 PageGetItemId(page, offno));
+											   PageGetItemId(page, offno));
 				htup = &(hitem->hash_itup.t_tid);
 				if (callback(htup, callback_state))
 				{
@@ -641,8 +641,7 @@ loop_top:
 	{
 		/*
 		 * Otherwise, our count is untrustworthy since we may have
-		 * double-scanned tuples in split buckets.	Proceed by
-		 * dead-reckoning.
+		 * double-scanned tuples in split buckets.	Proceed by dead-reckoning.
 		 */
 		if (metap->hashm_ntuples > tuples_removed)
 			metap->hashm_ntuples -= tuples_removed;
diff --git a/src/backend/access/hash/hashfunc.c b/src/backend/access/hash/hashfunc.c
index dfa8090f78..88876ee9ba 100644
--- a/src/backend/access/hash/hashfunc.c
+++ b/src/backend/access/hash/hashfunc.c
@@ -46,11 +46,11 @@ hashint8(PG_FUNCTION_ARGS)
 {
 	/*
 	 * The idea here is to produce a hash value compatible with the values
-	 * produced by hashint4 and hashint2 for logically equivalent inputs;
-	 * this is necessary if we ever hope to support cross-type hash joins
-	 * across these input types.  Since all three types are signed, we can
-	 * xor the high half of the int8 value if the sign is positive, or the
-	 * complement of the high half when the sign is negative.
+	 * produced by hashint4 and hashint2 for logically equivalent inputs; this
+	 * is necessary if we ever hope to support cross-type hash joins across
+	 * these input types.  Since all three types are signed, we can xor the
+	 * high half of the int8 value if the sign is positive, or the complement
+	 * of the high half when the sign is negative.
 	 */
 #ifndef INT64_IS_BUSTED
 	int64		val = PG_GETARG_INT64(0);
@@ -78,9 +78,9 @@ hashfloat4(PG_FUNCTION_ARGS)
 	float4		key = PG_GETARG_FLOAT4(0);
 
 	/*
-	 * On IEEE-float machines, minus zero and zero have different bit
-	 * patterns but should compare as equal.  We must ensure that they
-	 * have the same hash value, which is most easily done this way:
+	 * On IEEE-float machines, minus zero and zero have different bit patterns
+	 * but should compare as equal.  We must ensure that they have the same
+	 * hash value, which is most easily done this way:
 	 */
 	if (key == (float4) 0)
 		PG_RETURN_UINT32(0);
@@ -94,9 +94,9 @@ hashfloat8(PG_FUNCTION_ARGS)
 	float8		key = PG_GETARG_FLOAT8(0);
 
 	/*
-	 * On IEEE-float machines, minus zero and zero have different bit
-	 * patterns but should compare as equal.  We must ensure that they
-	 * have the same hash value, which is most easily done this way:
+	 * On IEEE-float machines, minus zero and zero have different bit patterns
+	 * but should compare as equal.  We must ensure that they have the same
+	 * hash value, which is most easily done this way:
 	 */
 	if (key == (float8) 0)
 		PG_RETURN_UINT32(0);
@@ -126,8 +126,7 @@ hashname(PG_FUNCTION_ARGS)
 	char	   *key = NameStr(*PG_GETARG_NAME(0));
 	int			keylen = strlen(key);
 
-	Assert(keylen < NAMEDATALEN);		/* else it's not truncated
-										 * correctly */
+	Assert(keylen < NAMEDATALEN);		/* else it's not truncated correctly */
 
 	return hash_any((unsigned char *) key, keylen);
 }
@@ -139,8 +138,8 @@ hashtext(PG_FUNCTION_ARGS)
 	Datum		result;
 
 	/*
-	 * Note: this is currently identical in behavior to hashvarlena, but
-	 * it seems likely that we may need to do something different in non-C
+	 * Note: this is currently identical in behavior to hashvarlena, but it
+	 * seems likely that we may need to do something different in non-C
 	 * locales.  (See also hashbpchar, if so.)
 	 */
 	result = hash_any((unsigned char *) VARDATA(key),
diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c
index 9ffda67558..ddc1851751 100644
--- a/src/backend/access/hash/hashinsert.c
+++ b/src/backend/access/hash/hashinsert.c
@@ -50,8 +50,8 @@ _hash_doinsert(Relation rel, HashItem hitem)
 	bool		isnull;
 
 	/*
-	 * Compute the hash key for the item.  We do this first so as not to
-	 * need to hold any locks while running the hash function.
+	 * Compute the hash key for the item.  We do this first so as not to need
+	 * to hold any locks while running the hash function.
 	 */
 	itup = &(hitem->hash_itup);
 	if (rel->rd_rel->relnatts != 1)
@@ -64,12 +64,12 @@ _hash_doinsert(Relation rel, HashItem hitem)
 	itemsz = IndexTupleDSize(hitem->hash_itup)
 		+ (sizeof(HashItemData) - sizeof(IndexTupleData));
 
-	itemsz = MAXALIGN(itemsz);	/* be safe, PageAddItem will do this but
-								 * we need to be consistent */
+	itemsz = MAXALIGN(itemsz);	/* be safe, PageAddItem will do this but we
+								 * need to be consistent */
 
 	/*
-	 * Acquire shared split lock so we can compute the target bucket
-	 * safely (see README).
+	 * Acquire shared split lock so we can compute the target bucket safely
+	 * (see README).
 	 */
 	_hash_getlock(rel, 0, HASH_SHARE);
 
@@ -79,9 +79,9 @@ _hash_doinsert(Relation rel, HashItem hitem)
 	_hash_checkpage(rel, (Page) metap, LH_META_PAGE);
 
 	/*
-	 * Check whether the item can fit on a hash page at all. (Eventually,
-	 * we ought to try to apply TOAST methods if not.)	Note that at this
-	 * point, itemsz doesn't include the ItemId.
+	 * Check whether the item can fit on a hash page at all. (Eventually, we
+	 * ought to try to apply TOAST methods if not.)  Note that at this point,
+	 * itemsz doesn't include the ItemId.
 	 */
 	if (itemsz > HashMaxItemSize((Page) metap))
 		ereport(ERROR,
@@ -89,7 +89,7 @@ _hash_doinsert(Relation rel, HashItem hitem)
 				 errmsg("index row size %lu exceeds hash maximum %lu",
 						(unsigned long) itemsz,
 						(unsigned long) HashMaxItemSize((Page) metap)),
-				 errhint("Values larger than a buffer page cannot be indexed.")));
+			errhint("Values larger than a buffer page cannot be indexed.")));
 
 	/*
 	 * Compute the target bucket number, and convert to block number.
@@ -105,8 +105,7 @@ _hash_doinsert(Relation rel, HashItem hitem)
 	_hash_chgbufaccess(rel, metabuf, HASH_READ, HASH_NOLOCK);
 
 	/*
-	 * Acquire share lock on target bucket; then we can release split
-	 * lock.
+	 * Acquire share lock on target bucket; then we can release split lock.
 	 */
 	_hash_getlock(rel, blkno, HASH_SHARE);
 
@@ -130,8 +129,8 @@ _hash_doinsert(Relation rel, HashItem hitem)
 		if (BlockNumberIsValid(nextblkno))
 		{
 			/*
-			 * ovfl page exists; go get it.  if it doesn't have room,
-			 * we'll find out next pass through the loop test above.
+			 * ovfl page exists; go get it.  if it doesn't have room, we'll
+			 * find out next pass through the loop test above.
 			 */
 			_hash_relbuf(rel, buf);
 			buf = _hash_getbuf(rel, nextblkno, HASH_WRITE);
diff --git a/src/backend/access/hash/hashovfl.c b/src/backend/access/hash/hashovfl.c
index 75ddb04b81..0eb8057bfb 100644
--- a/src/backend/access/hash/hashovfl.c
+++ b/src/backend/access/hash/hashovfl.c
@@ -44,8 +44,8 @@ bitno_to_blkno(HashMetaPage metap, uint32 ovflbitnum)
 		 /* loop */ ;
 
 	/*
-	 * Convert to absolute page number by adding the number of bucket
-	 * pages that exist before this split point.
+	 * Convert to absolute page number by adding the number of bucket pages
+	 * that exist before this split point.
 	 */
 	return (BlockNumber) ((1 << i) + ovflbitnum);
 }
@@ -252,10 +252,10 @@ _hash_getovflpage(Relation rel, Buffer metabuf)
 		/*
 		 * We create the new bitmap page with all pages marked "in use".
 		 * Actually two pages in the new bitmap's range will exist
-		 * immediately: the bitmap page itself, and the following page
-		 * which is the one we return to the caller.  Both of these are
-		 * correctly marked "in use".  Subsequent pages do not exist yet,
-		 * but it is convenient to pre-mark them as "in use" too.
+		 * immediately: the bitmap page itself, and the following page which
+		 * is the one we return to the caller.	Both of these are correctly
+		 * marked "in use".  Subsequent pages do not exist yet, but it is
+		 * convenient to pre-mark them as "in use" too.
 		 */
 		_hash_initbitmap(rel, metap, bitno_to_blkno(metap, bit));
 
@@ -265,8 +265,8 @@ _hash_getovflpage(Relation rel, Buffer metabuf)
 	else
 	{
 		/*
-		 * Nothing to do here; since the page was past the last used page,
-		 * we know its bitmap bit was preinitialized to "in use".
+		 * Nothing to do here; since the page was past the last used page, we
+		 * know its bitmap bit was preinitialized to "in use".
 		 */
 	}
 
@@ -275,8 +275,7 @@ _hash_getovflpage(Relation rel, Buffer metabuf)
 
 	/*
 	 * Adjust hashm_firstfree to avoid redundant searches.	But don't risk
-	 * changing it if someone moved it while we were searching bitmap
-	 * pages.
+	 * changing it if someone moved it while we were searching bitmap pages.
 	 */
 	if (metap->hashm_firstfree == orig_firstfree)
 		metap->hashm_firstfree = bit + 1;
@@ -305,8 +304,7 @@ found:
 
 	/*
 	 * Adjust hashm_firstfree to avoid redundant searches.	But don't risk
-	 * changing it if someone moved it while we were searching bitmap
-	 * pages.
+	 * changing it if someone moved it while we were searching bitmap pages.
 	 */
 	if (metap->hashm_firstfree == orig_firstfree)
 	{
@@ -394,10 +392,10 @@ _hash_freeovflpage(Relation rel, Buffer ovflbuf)
 	_hash_wrtbuf(rel, ovflbuf);
 
 	/*
-	 * Fix up the bucket chain.  this is a doubly-linked list, so we must
-	 * fix up the bucket chain members behind and ahead of the overflow
-	 * page being deleted.	No concurrency issues since we hold exclusive
-	 * lock on the entire bucket.
+	 * Fix up the bucket chain.  this is a doubly-linked list, so we must fix
+	 * up the bucket chain members behind and ahead of the overflow page being
+	 * deleted.  No concurrency issues since we hold exclusive lock on the
+	 * entire bucket.
 	 */
 	if (BlockNumberIsValid(prevblkno))
 	{
@@ -488,12 +486,11 @@ _hash_initbitmap(Relation rel, HashMetaPage metap, BlockNumber blkno)
 
 	/*
 	 * It is okay to write-lock the new bitmap page while holding metapage
-	 * write lock, because no one else could be contending for the new
-	 * page.
+	 * write lock, because no one else could be contending for the new page.
 	 *
-	 * There is some loss of concurrency in possibly doing I/O for the new
-	 * page while holding the metapage lock, but this path is taken so
-	 * seldom that it's not worth worrying about.
+	 * There is some loss of concurrency in possibly doing I/O for the new page
+	 * while holding the metapage lock, but this path is taken so seldom that
+	 * it's not worth worrying about.
 	 */
 	buf = _hash_getbuf(rel, blkno, HASH_WRITE);
 	pg = BufferGetPage(buf);
@@ -586,8 +583,8 @@ _hash_squeezebucket(Relation rel,
 	}
 
 	/*
-	 * find the last page in the bucket chain by starting at the base
-	 * bucket page and working forward.
+	 * find the last page in the bucket chain by starting at the base bucket
+	 * page and working forward.
 	 */
 	ropaque = wopaque;
 	do
@@ -655,22 +652,21 @@ _hash_squeezebucket(Relation rel,
 
 			/*
 			 * delete the tuple from the "read" page. PageIndexTupleDelete
-			 * repacks the ItemId array, so 'roffnum' will be "advanced"
-			 * to the "next" ItemId.
+			 * repacks the ItemId array, so 'roffnum' will be "advanced" to
+			 * the "next" ItemId.
 			 */
 			PageIndexTupleDelete(rpage, roffnum);
 		}
 
 		/*
-		 * if the "read" page is now empty because of the deletion (or
-		 * because it was empty when we got to it), free it.
+		 * if the "read" page is now empty because of the deletion (or because
+		 * it was empty when we got to it), free it.
 		 *
 		 * Tricky point here: if our read and write pages are adjacent in the
 		 * bucket chain, our write lock on wbuf will conflict with
 		 * _hash_freeovflpage's attempt to update the sibling links of the
-		 * removed page.  However, in that case we are done anyway, so we
-		 * can simply drop the write lock before calling
-		 * _hash_freeovflpage.
+		 * removed page.  However, in that case we are done anyway, so we can
+		 * simply drop the write lock before calling _hash_freeovflpage.
 		 */
 		if (PageIsEmpty(rpage))
 		{
diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index 24b7a67a4f..fc0279c528 100644
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -240,13 +240,13 @@ _hash_metapinit(Relation rel)
 			 RelationGetRelationName(rel));
 
 	/*
-	 * Determine the target fill factor (tuples per bucket) for this
-	 * index. The idea is to make the fill factor correspond to pages
-	 * about 3/4ths full.  We can compute it exactly if the index datatype
-	 * is fixed-width, but for var-width there's some guessing involved.
+	 * Determine the target fill factor (tuples per bucket) for this index.
+	 * The idea is to make the fill factor correspond to pages about 3/4ths
+	 * full.  We can compute it exactly if the index datatype is fixed-width,
+	 * but for var-width there's some guessing involved.
 	 */
 	data_width = get_typavgwidth(RelationGetDescr(rel)->attrs[0]->atttypid,
-							 RelationGetDescr(rel)->attrs[0]->atttypmod);
+								 RelationGetDescr(rel)->attrs[0]->atttypmod);
 	item_width = MAXALIGN(sizeof(HashItemData)) + MAXALIGN(data_width) +
 		sizeof(ItemIdData);		/* include the line pointer */
 	ffactor = (BLCKSZ * 3 / 4) / item_width;
@@ -289,9 +289,8 @@ _hash_metapinit(Relation rel)
 	metap->hashm_procid = index_getprocid(rel, 1, HASHPROC);
 
 	/*
-	 * We initialize the index with two buckets, 0 and 1, occupying
-	 * physical blocks 1 and 2.  The first freespace bitmap page is in
-	 * block 3.
+	 * We initialize the index with two buckets, 0 and 1, occupying physical
+	 * blocks 1 and 2.	The first freespace bitmap page is in block 3.
 	 */
 	metap->hashm_maxbucket = metap->hashm_lowmask = 1;	/* nbuckets - 1 */
 	metap->hashm_highmask = 3;	/* (nbuckets << 1) - 1 */
@@ -321,8 +320,8 @@ _hash_metapinit(Relation rel)
 	}
 
 	/*
-	 * Initialize first bitmap page.  Can't do this until we create the
-	 * first two buckets, else smgr will complain.
+	 * Initialize first bitmap page.  Can't do this until we create the first
+	 * two buckets, else smgr will complain.
 	 */
 	_hash_initbitmap(rel, metap, 3);
 
@@ -367,15 +366,14 @@ _hash_expandtable(Relation rel, Buffer metabuf)
 	 * Obtain the page-zero lock to assert the right to begin a split (see
 	 * README).
 	 *
-	 * Note: deadlock should be impossible here. Our own backend could only
-	 * be holding bucket sharelocks due to stopped indexscans; those will
-	 * not block other holders of the page-zero lock, who are only
-	 * interested in acquiring bucket sharelocks themselves.  Exclusive
-	 * bucket locks are only taken here and in hashbulkdelete, and neither
-	 * of these operations needs any additional locks to complete.	(If,
-	 * due to some flaw in this reasoning, we manage to deadlock anyway,
-	 * it's okay to error out; the index will be left in a consistent
-	 * state.)
+	 * Note: deadlock should be impossible here. Our own backend could only be
+	 * holding bucket sharelocks due to stopped indexscans; those will not
+	 * block other holders of the page-zero lock, who are only interested in
+	 * acquiring bucket sharelocks themselves.	Exclusive bucket locks are
+	 * only taken here and in hashbulkdelete, and neither of these operations
+	 * needs any additional locks to complete.	(If, due to some flaw in this
+	 * reasoning, we manage to deadlock anyway, it's okay to error out; the
+	 * index will be left in a consistent state.)
 	 */
 	_hash_getlock(rel, 0, HASH_EXCLUSIVE);
 
@@ -386,8 +384,8 @@ _hash_expandtable(Relation rel, Buffer metabuf)
 	_hash_checkpage(rel, (Page) metap, LH_META_PAGE);
 
 	/*
-	 * Check to see if split is still needed; someone else might have
-	 * already done one while we waited for the lock.
+	 * Check to see if split is still needed; someone else might have already
+	 * done one while we waited for the lock.
 	 *
 	 * Make sure this stays in sync with _hash_doinsert()
 	 */
@@ -402,11 +400,11 @@ _hash_expandtable(Relation rel, Buffer metabuf)
 	 * The lock protects us against other backends, but not against our own
 	 * backend.  Must check for active scans separately.
 	 *
-	 * Ideally we would lock the new bucket too before proceeding, but if we
-	 * are about to cross a splitpoint then the BUCKET_TO_BLKNO mapping
-	 * isn't correct yet.  For simplicity we update the metapage first and
-	 * then lock.  This should be okay because no one else should be
-	 * trying to lock the new bucket yet...
+	 * Ideally we would lock the new bucket too before proceeding, but if we are
+	 * about to cross a splitpoint then the BUCKET_TO_BLKNO mapping isn't
+	 * correct yet.  For simplicity we update the metapage first and then
+	 * lock.  This should be okay because no one else should be trying to lock
+	 * the new bucket yet...
 	 */
 	new_bucket = metap->hashm_maxbucket + 1;
 	old_bucket = (new_bucket & metap->hashm_lowmask);
@@ -420,14 +418,13 @@ _hash_expandtable(Relation rel, Buffer metabuf)
 		goto fail;
 
 	/*
-	 * Okay to proceed with split.	Update the metapage bucket mapping
-	 * info.
+	 * Okay to proceed with split.	Update the metapage bucket mapping info.
 	 *
-	 * Since we are scribbling on the metapage data right in the shared
-	 * buffer, any failure in this next little bit leaves us with a big
-	 * problem: the metapage is effectively corrupt but could get written
-	 * back to disk.  We don't really expect any failure, but just to be
-	 * sure, establish a critical section.
+	 * Since we are scribbling on the metapage data right in the shared buffer,
+	 * any failure in this next little bit leaves us with a big problem: the
+	 * metapage is effectively corrupt but could get written back to disk.	We
+	 * don't really expect any failure, but just to be sure, establish a
+	 * critical section.
 	 */
 	START_CRIT_SECTION();
 
@@ -443,8 +440,8 @@ _hash_expandtable(Relation rel, Buffer metabuf)
 	/*
 	 * If the split point is increasing (hashm_maxbucket's log base 2
 	 * increases), we need to adjust the hashm_spares[] array and
-	 * hashm_ovflpoint so that future overflow pages will be created
-	 * beyond this new batch of bucket pages.
+	 * hashm_ovflpoint so that future overflow pages will be created beyond
+	 * this new batch of bucket pages.
 	 *
 	 * XXX should initialize new bucket pages to prevent out-of-order page
 	 * creation?  Don't wanna do it right here though.
@@ -471,10 +468,9 @@ _hash_expandtable(Relation rel, Buffer metabuf)
 	/*
 	 * Copy bucket mapping info now; this saves re-accessing the meta page
 	 * inside _hash_splitbucket's inner loop.  Note that once we drop the
-	 * split lock, other splits could begin, so these values might be out
-	 * of date before _hash_splitbucket finishes.  That's okay, since all
-	 * it needs is to tell which of these two buckets to map hashkeys
-	 * into.
+	 * split lock, other splits could begin, so these values might be out of
+	 * date before _hash_splitbucket finishes.	That's okay, since all it
+	 * needs is to tell which of these two buckets to map hashkeys into.
 	 */
 	maxbucket = metap->hashm_maxbucket;
 	highmask = metap->hashm_highmask;
@@ -554,9 +550,9 @@ _hash_splitbucket(Relation rel,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 
 	/*
-	 * It should be okay to simultaneously write-lock pages from each
-	 * bucket, since no one else can be trying to acquire buffer lock on
-	 * pages of either bucket.
+	 * It should be okay to simultaneously write-lock pages from each bucket,
+	 * since no one else can be trying to acquire buffer lock on pages of
+	 * either bucket.
 	 */
 	oblkno = start_oblkno;
 	nblkno = start_nblkno;
@@ -578,17 +574,17 @@ _hash_splitbucket(Relation rel,
 	nopaque->hasho_filler = HASHO_FILL;
 
 	/*
-	 * Partition the tuples in the old bucket between the old bucket and
-	 * the new bucket, advancing along the old bucket's overflow bucket
-	 * chain and adding overflow pages to the new bucket as needed.
+	 * Partition the tuples in the old bucket between the old bucket and the
+	 * new bucket, advancing along the old bucket's overflow bucket chain and
+	 * adding overflow pages to the new bucket as needed.
 	 */
 	ooffnum = FirstOffsetNumber;
 	omaxoffnum = PageGetMaxOffsetNumber(opage);
 	for (;;)
 	{
 		/*
-		 * at each iteration through this loop, each of these variables
-		 * should be up-to-date: obuf opage oopaque ooffnum omaxoffnum
+		 * at each iteration through this loop, each of these variables should
+		 * be up-to-date: obuf opage oopaque ooffnum omaxoffnum
 		 */
 
 		/* check if we're at the end of the page */
@@ -600,8 +596,8 @@ _hash_splitbucket(Relation rel,
 				break;
 
 			/*
-			 * we ran out of tuples on this particular page, but we have
-			 * more overflow pages; advance to next page.
+			 * we ran out of tuples on this particular page, but we have more
+			 * overflow pages; advance to next page.
 			 */
 			_hash_wrtbuf(rel, obuf);
 
@@ -618,8 +614,7 @@ _hash_splitbucket(Relation rel,
 		 * Re-hash the tuple to determine which bucket it now belongs in.
 		 *
 		 * It is annoying to call the hash function while holding locks, but
-		 * releasing and relocking the page for each tuple is unappealing
-		 * too.
+		 * releasing and relocking the page for each tuple is unappealing too.
 		 */
 		hitem = (HashItem) PageGetItem(opage, PageGetItemId(opage, ooffnum));
 		itup = &(hitem->hash_itup);
@@ -632,9 +627,9 @@ _hash_splitbucket(Relation rel,
 		if (bucket == nbucket)
 		{
 			/*
-			 * insert the tuple into the new bucket.  if it doesn't fit on
-			 * the current page in the new bucket, we must allocate a new
-			 * overflow page and place the tuple on that page instead.
+			 * insert the tuple into the new bucket.  if it doesn't fit on the
+			 * current page in the new bucket, we must allocate a new overflow
+			 * page and place the tuple on that page instead.
 			 */
 			itemsz = IndexTupleDSize(hitem->hash_itup)
 				+ (sizeof(HashItemData) - sizeof(IndexTupleData));
@@ -659,13 +654,13 @@ _hash_splitbucket(Relation rel,
 					 RelationGetRelationName(rel));
 
 			/*
-			 * now delete the tuple from the old bucket.  after this
-			 * section of code, 'ooffnum' will actually point to the
-			 * ItemId to which we would point if we had advanced it before
-			 * the deletion (PageIndexTupleDelete repacks the ItemId
-			 * array).	this also means that 'omaxoffnum' is exactly one
-			 * less than it used to be, so we really can just decrement it
-			 * instead of calling PageGetMaxOffsetNumber.
+			 * now delete the tuple from the old bucket.  after this section
+			 * of code, 'ooffnum' will actually point to the ItemId to which
+			 * we would point if we had advanced it before the deletion
+			 * (PageIndexTupleDelete repacks the ItemId array).  this also
+			 * means that 'omaxoffnum' is exactly one less than it used to be,
+			 * so we really can just decrement it instead of calling
+			 * PageGetMaxOffsetNumber.
 			 */
 			PageIndexTupleDelete(opage, ooffnum);
 			omaxoffnum = OffsetNumberPrev(omaxoffnum);
@@ -673,9 +668,9 @@ _hash_splitbucket(Relation rel,
 		else
 		{
 			/*
-			 * the tuple stays on this page.  we didn't move anything, so
-			 * we didn't delete anything and therefore we don't have to
-			 * change 'omaxoffnum'.
+			 * the tuple stays on this page.  we didn't move anything, so we
+			 * didn't delete anything and therefore we don't have to change
+			 * 'omaxoffnum'.
 			 */
 			Assert(bucket == obucket);
 			ooffnum = OffsetNumberNext(ooffnum);
@@ -683,11 +678,10 @@ _hash_splitbucket(Relation rel,
 	}
 
 	/*
-	 * We're at the end of the old bucket chain, so we're done
-	 * partitioning the tuples.  Before quitting, call _hash_squeezebucket
-	 * to ensure the tuples remaining in the old bucket (including the
-	 * overflow pages) are packed as tightly as possible.  The new bucket
-	 * is already tight.
+	 * We're at the end of the old bucket chain, so we're done partitioning
+	 * the tuples.	Before quitting, call _hash_squeezebucket to ensure the
+	 * tuples remaining in the old bucket (including the overflow pages) are
+	 * packed as tightly as possible.  The new bucket is already tight.
 	 */
 	_hash_wrtbuf(rel, obuf);
 	_hash_wrtbuf(rel, nbuf);
diff --git a/src/backend/access/hash/hashscan.c b/src/backend/access/hash/hashscan.c
index f069ea9cf8..a288329f85 100644
--- a/src/backend/access/hash/hashscan.c
+++ b/src/backend/access/hash/hashscan.c
@@ -44,9 +44,9 @@ ReleaseResources_hash(void)
 	HashScanList next;
 
 	/*
-	 * Note: this should be a no-op during normal query shutdown. However,
-	 * in an abort situation ExecutorEnd is not called and so there may be
-	 * open index scans to clean up.
+	 * Note: this should be a no-op during normal query shutdown. However, in
+	 * an abort situation ExecutorEnd is not called and so there may be open
+	 * index scans to clean up.
 	 */
 	prev = NULL;
 
diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c
index 0bafea4873..77d16a7bf0 100644
--- a/src/backend/access/hash/hashsearch.c
+++ b/src/backend/access/hash/hashsearch.c
@@ -137,33 +137,32 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	ItemPointerSetInvalid(current);
 
 	/*
-	 * We do not support hash scans with no index qualification, because
-	 * we would have to read the whole index rather than just one bucket.
-	 * That creates a whole raft of problems, since we haven't got a
-	 * practical way to lock all the buckets against splits or
-	 * compactions.
+	 * We do not support hash scans with no index qualification, because we
+	 * would have to read the whole index rather than just one bucket. That
+	 * creates a whole raft of problems, since we haven't got a practical way
+	 * to lock all the buckets against splits or compactions.
 	 */
 	if (scan->numberOfKeys < 1)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-			   errmsg("hash indexes do not support whole-index scans")));
+				 errmsg("hash indexes do not support whole-index scans")));
 
 	/*
-	 * If the constant in the index qual is NULL, assume it cannot match
-	 * any items in the index.
+	 * If the constant in the index qual is NULL, assume it cannot match any
+	 * items in the index.
 	 */
 	if (scan->keyData[0].sk_flags & SK_ISNULL)
 		return false;
 
 	/*
-	 * Okay to compute the hash key.  We want to do this before acquiring
-	 * any locks, in case a user-defined hash function happens to be slow.
+	 * Okay to compute the hash key.  We want to do this before acquiring any
+	 * locks, in case a user-defined hash function happens to be slow.
 	 */
 	hashkey = _hash_datum2hashkey(rel, scan->keyData[0].sk_argument);
 
 	/*
-	 * Acquire shared split lock so we can compute the target bucket
-	 * safely (see README).
+	 * Acquire shared split lock so we can compute the target bucket safely
+	 * (see README).
 	 */
 	_hash_getlock(rel, 0, HASH_SHARE);
 
@@ -186,8 +185,7 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	_hash_relbuf(rel, metabuf);
 
 	/*
-	 * Acquire share lock on target bucket; then we can release split
-	 * lock.
+	 * Acquire share lock on target bucket; then we can release split lock.
 	 */
 	_hash_getlock(rel, blkno, HASH_SHARE);
 
@@ -263,9 +261,9 @@ _hash_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir)
 	bucket = opaque->hasho_bucket;
 
 	/*
-	 * If _hash_step is called from _hash_first, current will not be
-	 * valid, so we can't dereference it.  However, in that case, we
-	 * presumably want to start at the beginning/end of the page...
+	 * If _hash_step is called from _hash_first, current will not be valid, so
+	 * we can't dereference it.  However, in that case, we presumably want to
+	 * start at the beginning/end of the page...
 	 */
 	maxoff = PageGetMaxOffsetNumber(page);
 	if (ItemPointerIsValid(current))
@@ -276,8 +274,8 @@ _hash_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir)
 	/*
 	 * 'offnum' now points to the last tuple we have seen (if any).
 	 *
-	 * continue to step through tuples until: 1) we get to the end of the
-	 * bucket chain or 2) we find a valid tuple.
+	 * continue to step through tuples until: 1) we get to the end of the bucket
+	 * chain or 2) we find a valid tuple.
 	 */
 	do
 	{
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 5ac5ee17df..94ff5449db 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -54,7 +54,7 @@
 
 
 static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
-	   ItemPointerData from, Buffer newbuf, HeapTuple newtup, bool move);
+		   ItemPointerData from, Buffer newbuf, HeapTuple newtup, bool move);
 
 
 /* ----------------------------------------------------------------
@@ -272,8 +272,8 @@ heapgettup(Relation relation,
 	/* 'dir' is now non-zero */
 
 	/*
-	 * calculate line pointer and number of remaining items to check on
-	 * this page.
+	 * calculate line pointer and number of remaining items to check on this
+	 * page.
 	 */
 	lpp = PageGetItemId(dp, lineoff);
 	if (dir < 0)
@@ -282,8 +282,8 @@ heapgettup(Relation relation,
 		linesleft = lines - lineoff;
 
 	/*
-	 * advance the scan until we find a qualifying tuple or run out of
-	 * stuff to scan
+	 * advance the scan until we find a qualifying tuple or run out of stuff
+	 * to scan
 	 */
 	for (;;)
 	{
@@ -321,15 +321,14 @@ heapgettup(Relation relation,
 			}
 			else
 			{
-				++lpp;			/* move forward in this page's ItemId
-								 * array */
+				++lpp;			/* move forward in this page's ItemId array */
 				++lineoff;
 			}
 		}
 
 		/*
-		 * if we get here, it means we've exhausted the items on this page
-		 * and it's time to move to the next.
+		 * if we get here, it means we've exhausted the items on this page and
+		 * it's time to move to the next.
 		 */
 		LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
 
@@ -506,15 +505,15 @@ relation_openrv(const RangeVar *relation, LOCKMODE lockmode)
 
 	/*
 	 * Check for shared-cache-inval messages before trying to open the
-	 * relation.  This is needed to cover the case where the name
-	 * identifies a rel that has been dropped and recreated since the
-	 * start of our transaction: if we don't flush the old syscache entry
-	 * then we'll latch onto that entry and suffer an error when we do
-	 * LockRelation. Note that relation_open does not need to do this,
-	 * since a relation's OID never changes.
+	 * relation.  This is needed to cover the case where the name identifies a
+	 * rel that has been dropped and recreated since the start of our
+	 * transaction: if we don't flush the old syscache entry then we'll latch
+	 * onto that entry and suffer an error when we do LockRelation. Note that
+	 * relation_open does not need to do this, since a relation's OID never
+	 * changes.
 	 *
-	 * We skip this if asked for NoLock, on the assumption that the caller
-	 * has already ensured some appropriate lock is held.
+	 * We skip this if asked for NoLock, on the assumption that the caller has
+	 * already ensured some appropriate lock is held.
 	 */
 	if (lockmode != NoLock)
 		AcceptInvalidationMessages();
@@ -633,9 +632,9 @@ heap_beginscan(Relation relation, Snapshot snapshot,
 	/*
 	 * increment relation ref count while scanning relation
 	 *
-	 * This is just to make really sure the relcache entry won't go away
-	 * while the scan has a pointer to it.	Caller should be holding the
-	 * rel open anyway, so this is redundant in all normal scenarios...
+	 * This is just to make really sure the relcache entry won't go away while
+	 * the scan has a pointer to it.  Caller should be holding the rel open
+	 * anyway, so this is redundant in all normal scenarios...
 	 */
 	RelationIncrementReferenceCount(relation);
 
@@ -649,8 +648,8 @@ heap_beginscan(Relation relation, Snapshot snapshot,
 	scan->rs_nkeys = nkeys;
 
 	/*
-	 * we do this here instead of in initscan() because heap_rescan also
-	 * calls initscan() and we don't want to allocate memory again
+	 * we do this here instead of in initscan() because heap_rescan also calls
+	 * initscan() and we don't want to allocate memory again
 	 */
 	if (nkeys > 0)
 		scan->rs_key = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
@@ -763,8 +762,8 @@ heap_getnext(HeapScanDesc scan, ScanDirection direction)
 	}
 
 	/*
-	 * if we get here it means we have a new current scan tuple, so point
-	 * to the proper return buffer and return the tuple.
+	 * if we get here it means we have a new current scan tuple, so point to
+	 * the proper return buffer and return the tuple.
 	 */
 
 	HEAPDEBUG_3;				/* heap_getnext returning tuple */
@@ -859,8 +858,8 @@ heap_release_fetch(Relation relation,
 	dp = (PageHeader) BufferGetPage(buffer);
 
 	/*
-	 * We'd better check for out-of-range offnum in case of VACUUM since
-	 * the TID was obtained.
+	 * We'd better check for out-of-range offnum in case of VACUUM since the
+	 * TID was obtained.
 	 */
 	offnum = ItemPointerGetOffsetNumber(tid);
 	if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(dp))
@@ -952,7 +951,7 @@ heap_release_fetch(Relation relation,
  * possibly uncommitted version.
  *
  * *tid is both an input and an output parameter: it is updated to
- * show the latest version of the row.  Note that it will not be changed
+ * show the latest version of the row.	Note that it will not be changed
  * if no version of the row passes the snapshot test.
  */
 void
@@ -960,7 +959,7 @@ heap_get_latest_tid(Relation relation,
 					Snapshot snapshot,
 					ItemPointer tid)
 {
-	BlockNumber	blk;
+	BlockNumber blk;
 	ItemPointerData ctid;
 	TransactionId priorXmax;
 
@@ -969,10 +968,10 @@ heap_get_latest_tid(Relation relation,
 		return;
 
 	/*
-	 * Since this can be called with user-supplied TID, don't trust the
-	 * input too much.  (RelationGetNumberOfBlocks is an expensive check,
-	 * so we don't check t_ctid links again this way.  Note that it would
-	 * not do to call it just once and save the result, either.)
+	 * Since this can be called with user-supplied TID, don't trust the input
+	 * too much.  (RelationGetNumberOfBlocks is an expensive check, so we
+	 * don't check t_ctid links again this way.  Note that it would not do to
+	 * call it just once and save the result, either.)
 	 */
 	blk = ItemPointerGetBlockNumber(tid);
 	if (blk >= RelationGetNumberOfBlocks(relation))
@@ -980,9 +979,9 @@ heap_get_latest_tid(Relation relation,
 			 blk, RelationGetRelationName(relation));
 
 	/*
-	 * Loop to chase down t_ctid links.  At top of loop, ctid is the
-	 * tuple we need to examine, and *tid is the TID we will return if
-	 * ctid turns out to be bogus.
+	 * Loop to chase down t_ctid links.  At top of loop, ctid is the tuple we
+	 * need to examine, and *tid is the TID we will return if ctid turns out
+	 * to be bogus.
 	 *
 	 * Note that we will loop until we reach the end of the t_ctid chain.
 	 * Depending on the snapshot passed, there might be at most one visible
@@ -1008,8 +1007,8 @@ heap_get_latest_tid(Relation relation,
 
 		/*
 		 * Check for bogus item number.  This is not treated as an error
-		 * condition because it can happen while following a t_ctid link.
-		 * We just assume that the prior tid is OK and return it unchanged.
+		 * condition because it can happen while following a t_ctid link. We
+		 * just assume that the prior tid is OK and return it unchanged.
 		 */
 		offnum = ItemPointerGetOffsetNumber(&ctid);
 		if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(dp))
@@ -1037,7 +1036,7 @@ heap_get_latest_tid(Relation relation,
 		 * tuple.  Check for XMIN match.
 		 */
 		if (TransactionIdIsValid(priorXmax) &&
-			!TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
+		  !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
 		{
 			LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 			ReleaseBuffer(buffer);
@@ -1068,7 +1067,7 @@ heap_get_latest_tid(Relation relation,
 		priorXmax = HeapTupleHeaderGetXmax(tp.t_data);
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 		ReleaseBuffer(buffer);
-	}				/* end of loop */
+	}							/* end of loop */
 }
 
 /*
@@ -1102,13 +1101,12 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 #endif
 
 		/*
-		 * If the object id of this tuple has already been assigned, trust
-		 * the caller.	There are a couple of ways this can happen.  At
-		 * initial db creation, the backend program sets oids for tuples.
-		 * When we define an index, we set the oid.  Finally, in the
-		 * future, we may allow users to set their own object ids in order
-		 * to support a persistent object store (objects need to contain
-		 * pointers to one another).
+		 * If the object id of this tuple has already been assigned, trust the
+		 * caller.	There are a couple of ways this can happen.  At initial db
+		 * creation, the backend program sets oids for tuples. When we define
+		 * an index, we set the oid.  Finally, in the future, we may allow
+		 * users to set their own object ids in order to support a persistent
+		 * object store (objects need to contain pointers to one another).
 		 */
 		if (!OidIsValid(HeapTupleGetOid(tup)))
 			HeapTupleSetOid(tup, GetNewOid(relation));
@@ -1129,8 +1127,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 
 	/*
 	 * If the new tuple is too big for storage or contains already toasted
-	 * out-of-line attributes from some other relation, invoke the
-	 * toaster.
+	 * out-of-line attributes from some other relation, invoke the toaster.
 	 */
 	if (HeapTupleHasExternal(tup) ||
 		(MAXALIGN(tup->t_len) > TOAST_TUPLE_THRESHOLD))
@@ -1172,9 +1169,9 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 		xlhdr.t_hoff = tup->t_data->t_hoff;
 
 		/*
-		 * note we mark rdata[1] as belonging to buffer; if XLogInsert
-		 * decides to write the whole page to the xlog, we don't need to
-		 * store xl_heap_header in the xlog.
+		 * note we mark rdata[1] as belonging to buffer; if XLogInsert decides
+		 * to write the whole page to the xlog, we don't need to store
+		 * xl_heap_header in the xlog.
 		 */
 		rdata[1].data = (char *) &xlhdr;
 		rdata[1].len = SizeOfHeapHeader;
@@ -1190,9 +1187,9 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 		rdata[2].next = NULL;
 
 		/*
-		 * If this is the single and first tuple on page, we can reinit
-		 * the page instead of restoring the whole thing.  Set flag, and
-		 * hide buffer references from XLogInsert.
+		 * If this is the single and first tuple on page, we can reinit the
+		 * page instead of restoring the whole thing.  Set flag, and hide
+		 * buffer references from XLogInsert.
 		 */
 		if (ItemPointerGetOffsetNumber(&(tup->t_self)) == FirstOffsetNumber &&
 			PageGetMaxOffsetNumber(page) == FirstOffsetNumber)
@@ -1213,10 +1210,10 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 	WriteBuffer(buffer);
 
 	/*
-	 * If tuple is cachable, mark it for invalidation from the caches in
-	 * case we abort.  Note it is OK to do this after WriteBuffer releases
-	 * the buffer, because the "tup" data structure is all in local
-	 * memory, not in the shared buffer.
+	 * If tuple is cachable, mark it for invalidation from the caches in case
+	 * we abort.  Note it is OK to do this after WriteBuffer releases the
+	 * buffer, because the "tup" data structure is all in local memory, not in
+	 * the shared buffer.
 	 */
 	CacheInvalidateHeapTuple(relation, tup);
 
@@ -1268,7 +1265,7 @@ heap_delete(Relation relation, ItemPointer tid,
 			ItemPointer ctid, TransactionId *update_xmax,
 			CommandId cid, Snapshot crosscheck, bool wait)
 {
-	HTSU_Result	result;
+	HTSU_Result result;
 	TransactionId xid = GetCurrentTransactionId();
 	ItemId		lp;
 	HeapTupleData tp;
@@ -1301,7 +1298,7 @@ l1:
 	else if (result == HeapTupleBeingUpdated && wait)
 	{
 		TransactionId xwait;
-		uint16	infomask;
+		uint16		infomask;
 
 		/* must copy state data before unlocking buffer */
 		xwait = HeapTupleHeaderGetXmax(tp.t_data);
@@ -1310,13 +1307,13 @@ l1:
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
 		/*
-		 * Acquire tuple lock to establish our priority for the tuple
-		 * (see heap_lock_tuple).  LockTuple will release us when we are
+		 * Acquire tuple lock to establish our priority for the tuple (see
+		 * heap_lock_tuple).  LockTuple will release us when we are
 		 * next-in-line for the tuple.
 		 *
-		 * If we are forced to "start over" below, we keep the tuple lock;
-		 * this arranges that we stay at the head of the line while
-		 * rechecking tuple state.
+		 * If we are forced to "start over" below, we keep the tuple lock; this
+		 * arranges that we stay at the head of the line while rechecking
+		 * tuple state.
 		 */
 		if (!have_tuple_lock)
 		{
@@ -1347,12 +1344,12 @@ l1:
 				goto l1;
 
 			/*
-			 * You might think the multixact is necessarily done here, but
-			 * not so: it could have surviving members, namely our own xact
-			 * or other subxacts of this backend.  It is legal for us to
-			 * delete the tuple in either case, however (the latter case is
-			 * essentially a situation of upgrading our former shared lock
-			 * to exclusive).  We don't bother changing the on-disk hint bits
+			 * You might think the multixact is necessarily done here, but not
+			 * so: it could have surviving members, namely our own xact or
+			 * other subxacts of this backend.	It is legal for us to delete
+			 * the tuple in either case, however (the latter case is
+			 * essentially a situation of upgrading our former shared lock to
+			 * exclusive).	We don't bother changing the on-disk hint bits
 			 * since we are about to overwrite the xmax altogether.
 			 */
 		}
@@ -1385,8 +1382,8 @@ l1:
 		}
 
 		/*
-		 * We may overwrite if previous xmax aborted, or if it committed
-		 * but only locked the tuple without updating it.
+		 * We may overwrite if previous xmax aborted, or if it committed but
+		 * only locked the tuple without updating it.
 		 */
 		if (tp.t_data->t_infomask & (HEAP_XMAX_INVALID |
 									 HEAP_IS_LOCKED))
@@ -1467,18 +1464,18 @@ l1:
 
 	/*
 	 * If the tuple has toasted out-of-line attributes, we need to delete
-	 * those items too.  We have to do this before WriteBuffer because we
-	 * need to look at the contents of the tuple, but it's OK to release
-	 * the context lock on the buffer first.
+	 * those items too.  We have to do this before WriteBuffer because we need
+	 * to look at the contents of the tuple, but it's OK to release the
+	 * context lock on the buffer first.
 	 */
 	if (HeapTupleHasExternal(&tp))
 		heap_tuple_toast_attrs(relation, NULL, &tp);
 
 	/*
 	 * Mark tuple for invalidation from system caches at next command
-	 * boundary. We have to do this before WriteBuffer because we need to
-	 * look at the contents of the tuple, so we need to hold our refcount
-	 * on the buffer.
+	 * boundary. We have to do this before WriteBuffer because we need to look
+	 * at the contents of the tuple, so we need to hold our refcount on the
+	 * buffer.
 	 */
 	CacheInvalidateHeapTuple(relation, &tp);
 
@@ -1506,7 +1503,7 @@ l1:
 void
 simple_heap_delete(Relation relation, ItemPointer tid)
 {
-	HTSU_Result		result;
+	HTSU_Result result;
 	ItemPointerData update_ctid;
 	TransactionId update_xmax;
 
@@ -1569,7 +1566,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
 			ItemPointer ctid, TransactionId *update_xmax,
 			CommandId cid, Snapshot crosscheck, bool wait)
 {
-	HTSU_Result	result;
+	HTSU_Result result;
 	TransactionId xid = GetCurrentTransactionId();
 	ItemId		lp;
 	HeapTupleData oldtup;
@@ -1598,8 +1595,8 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
 	/*
 	 * Note: beyond this point, use oldtup not otid to refer to old tuple.
 	 * otid may very well point at newtup->t_self, which we will overwrite
-	 * with the new tuple's location, so there's great risk of confusion
-	 * if we use otid anymore.
+	 * with the new tuple's location, so there's great risk of confusion if we
+	 * use otid anymore.
 	 */
 
 l2:
@@ -1614,7 +1611,7 @@ l2:
 	else if (result == HeapTupleBeingUpdated && wait)
 	{
 		TransactionId xwait;
-		uint16	infomask;
+		uint16		infomask;
 
 		/* must copy state data before unlocking buffer */
 		xwait = HeapTupleHeaderGetXmax(oldtup.t_data);
@@ -1623,13 +1620,13 @@ l2:
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
 		/*
-		 * Acquire tuple lock to establish our priority for the tuple
-		 * (see heap_lock_tuple).  LockTuple will release us when we are
+		 * Acquire tuple lock to establish our priority for the tuple (see
+		 * heap_lock_tuple).  LockTuple will release us when we are
 		 * next-in-line for the tuple.
 		 *
-		 * If we are forced to "start over" below, we keep the tuple lock;
-		 * this arranges that we stay at the head of the line while
-		 * rechecking tuple state.
+		 * If we are forced to "start over" below, we keep the tuple lock; this
+		 * arranges that we stay at the head of the line while rechecking
+		 * tuple state.
 		 */
 		if (!have_tuple_lock)
 		{
@@ -1660,12 +1657,12 @@ l2:
 				goto l2;
 
 			/*
-			 * You might think the multixact is necessarily done here, but
-			 * not so: it could have surviving members, namely our own xact
-			 * or other subxacts of this backend.  It is legal for us to
-			 * update the tuple in either case, however (the latter case is
-			 * essentially a situation of upgrading our former shared lock
-			 * to exclusive).  We don't bother changing the on-disk hint bits
+			 * You might think the multixact is necessarily done here, but not
+			 * so: it could have surviving members, namely our own xact or
+			 * other subxacts of this backend.	It is legal for us to update
+			 * the tuple in either case, however (the latter case is
+			 * essentially a situation of upgrading our former shared lock to
+			 * exclusive).	We don't bother changing the on-disk hint bits
 			 * since we are about to overwrite the xmax altogether.
 			 */
 		}
@@ -1698,8 +1695,8 @@ l2:
 		}
 
 		/*
-		 * We may overwrite if previous xmax aborted, or if it committed
-		 * but only locked the tuple without updating it.
+		 * We may overwrite if previous xmax aborted, or if it committed but
+		 * only locked the tuple without updating it.
 		 */
 		if (oldtup.t_data->t_infomask & (HEAP_XMAX_INVALID |
 										 HEAP_IS_LOCKED))
@@ -1753,15 +1750,15 @@ l2:
 	HeapTupleHeaderSetCmax(newtup->t_data, 0);	/* for cleanliness */
 
 	/*
-	 * If the toaster needs to be activated, OR if the new tuple will not
-	 * fit on the same page as the old, then we need to release the
-	 * context lock (but not the pin!) on the old tuple's buffer while we
-	 * are off doing TOAST and/or table-file-extension work.  We must mark
-	 * the old tuple to show that it's already being updated, else other
-	 * processes may try to update it themselves.
+	 * If the toaster needs to be activated, OR if the new tuple will not fit
+	 * on the same page as the old, then we need to release the context lock
+	 * (but not the pin!) on the old tuple's buffer while we are off doing
+	 * TOAST and/or table-file-extension work.	We must mark the old tuple to
+	 * show that it's already being updated, else other processes may try to
+	 * update it themselves.
 	 *
-	 * We need to invoke the toaster if there are already any out-of-line
-	 * toasted values present, or if the new tuple is over-threshold.
+	 * We need to invoke the toaster if there are already any out-of-line toasted
+	 * values present, or if the new tuple is over-threshold.
 	 */
 	need_toast = (HeapTupleHasExternal(&oldtup) ||
 				  HeapTupleHasExternal(newtup) ||
@@ -1790,22 +1787,21 @@ l2:
 		}
 
 		/*
-		 * Now, do we need a new page for the tuple, or not?  This is a
-		 * bit tricky since someone else could have added tuples to the
-		 * page while we weren't looking.  We have to recheck the
-		 * available space after reacquiring the buffer lock.  But don't
-		 * bother to do that if the former amount of free space is still
-		 * not enough; it's unlikely there's more free now than before.
+		 * Now, do we need a new page for the tuple, or not?  This is a bit
+		 * tricky since someone else could have added tuples to the page while
+		 * we weren't looking.  We have to recheck the available space after
+		 * reacquiring the buffer lock.  But don't bother to do that if the
+		 * former amount of free space is still not enough; it's unlikely
+		 * there's more free now than before.
 		 *
 		 * What's more, if we need to get a new page, we will need to acquire
-		 * buffer locks on both old and new pages.	To avoid deadlock
-		 * against some other backend trying to get the same two locks in
-		 * the other order, we must be consistent about the order we get
-		 * the locks in. We use the rule "lock the lower-numbered page of
-		 * the relation first".  To implement this, we must do
-		 * RelationGetBufferForTuple while not holding the lock on the old
-		 * page, and we must rely on it to get the locks on both pages in
-		 * the correct order.
+		 * buffer locks on both old and new pages.	To avoid deadlock against
+		 * some other backend trying to get the same two locks in the other
+		 * order, we must be consistent about the order we get the locks in.
+		 * We use the rule "lock the lower-numbered page of the relation
+		 * first".  To implement this, we must do RelationGetBufferForTuple
+		 * while not holding the lock on the old page, and we must rely on it
+		 * to get the locks on both pages in the correct order.
 		 */
 		if (newtupsize > pagefree)
 		{
@@ -1823,8 +1819,8 @@ l2:
 			{
 				/*
 				 * Rats, it doesn't fit anymore.  We must now unlock and
-				 * relock to avoid deadlock.  Fortunately, this path
-				 * should seldom be taken.
+				 * relock to avoid deadlock.  Fortunately, this path should
+				 * seldom be taken.
 				 */
 				LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 				newbuf = RelationGetBufferForTuple(relation, newtup->t_len,
@@ -1845,9 +1841,9 @@ l2:
 	}
 
 	/*
-	 * At this point newbuf and buffer are both pinned and locked, and
-	 * newbuf has enough space for the new tuple.  If they are the same
-	 * buffer, only one pin is held.
+	 * At this point newbuf and buffer are both pinned and locked, and newbuf
+	 * has enough space for the new tuple.	If they are the same buffer, only
+	 * one pin is held.
 	 */
 
 	/* NO EREPORT(ERROR) from here till changes are logged */
@@ -1897,8 +1893,8 @@ l2:
 
 	/*
 	 * Mark old tuple for invalidation from system caches at next command
-	 * boundary. We have to do this before WriteBuffer because we need to
-	 * look at the contents of the tuple, so we need to hold our refcount.
+	 * boundary. We have to do this before WriteBuffer because we need to look
+	 * at the contents of the tuple, so we need to hold our refcount.
 	 */
 	CacheInvalidateHeapTuple(relation, &oldtup);
 
@@ -1907,10 +1903,10 @@ l2:
 	WriteBuffer(buffer);
 
 	/*
-	 * If new tuple is cachable, mark it for invalidation from the caches
-	 * in case we abort.  Note it is OK to do this after WriteBuffer
-	 * releases the buffer, because the "newtup" data structure is all in
-	 * local memory, not in the shared buffer.
+	 * If new tuple is cachable, mark it for invalidation from the caches in
+	 * case we abort.  Note it is OK to do this after WriteBuffer releases the
+	 * buffer, because the "newtup" data structure is all in local memory, not
+	 * in the shared buffer.
 	 */
 	CacheInvalidateHeapTuple(relation, newtup);
 
@@ -1936,7 +1932,7 @@ l2:
 void
 simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup)
 {
-	HTSU_Result		result;
+	HTSU_Result result;
 	ItemPointerData update_ctid;
 	TransactionId update_xmax;
 
@@ -2012,7 +2008,7 @@ simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup)
  * waiter gets the tuple, potentially leading to indefinite starvation of
  * some waiters.  The possibility of share-locking makes the problem much
  * worse --- a steady stream of share-lockers can easily block an exclusive
- * locker forever.  To provide more reliable semantics about who gets a
+ * locker forever.	To provide more reliable semantics about who gets a
  * tuple-level lock first, we use the standard lock manager.  The protocol
  * for waiting for a tuple-level lock is really
  *		LockTuple()
@@ -2020,7 +2016,7 @@ simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup)
  *		mark tuple as locked by me
  *		UnlockTuple()
  * When there are multiple waiters, arbitration of who is to get the lock next
- * is provided by LockTuple().  However, at most one tuple-level lock will
+ * is provided by LockTuple().	However, at most one tuple-level lock will
  * be held or awaited per backend at any time, so we don't risk overflow
  * of the lock table.  Note that incoming share-lockers are required to
  * do LockTuple as well, if there is any conflict, to ensure that they don't
@@ -2032,11 +2028,11 @@ heap_lock_tuple(Relation relation, HeapTuple tuple, Buffer *buffer,
 				ItemPointer ctid, TransactionId *update_xmax,
 				CommandId cid, LockTupleMode mode, bool nowait)
 {
-	HTSU_Result	result;
+	HTSU_Result result;
 	ItemPointer tid = &(tuple->t_self);
 	ItemId		lp;
 	PageHeader	dp;
-	TransactionId	xid;
+	TransactionId xid;
 	uint16		new_infomask;
 	LOCKMODE	tuple_lock_type;
 	bool		have_tuple_lock = false;
@@ -2067,7 +2063,7 @@ l3:
 	else if (result == HeapTupleBeingUpdated)
 	{
 		TransactionId xwait;
-		uint16	infomask;
+		uint16		infomask;
 
 		/* must copy state data before unlocking buffer */
 		xwait = HeapTupleHeaderGetXmax(tuple->t_data);
@@ -2077,12 +2073,12 @@ l3:
 
 		/*
 		 * Acquire tuple lock to establish our priority for the tuple.
-		 * LockTuple will release us when we are next-in-line for the
-		 * tuple.  We must do this even if we are share-locking.
+		 * LockTuple will release us when we are next-in-line for the tuple.
+		 * We must do this even if we are share-locking.
 		 *
-		 * If we are forced to "start over" below, we keep the tuple lock;
-		 * this arranges that we stay at the head of the line while
-		 * rechecking tuple state.
+		 * If we are forced to "start over" below, we keep the tuple lock; this
+		 * arranges that we stay at the head of the line while rechecking
+		 * tuple state.
 		 */
 		if (!have_tuple_lock)
 		{
@@ -2091,8 +2087,8 @@ l3:
 				if (!ConditionalLockTuple(relation, tid, tuple_lock_type))
 					ereport(ERROR,
 							(errcode(ERRCODE_LOCK_NOT_AVAILABLE),
-							 errmsg("could not obtain lock on row in relation \"%s\"",
-									RelationGetRelationName(relation))));
+					errmsg("could not obtain lock on row in relation \"%s\"",
+						   RelationGetRelationName(relation))));
 			}
 			else
 				LockTuple(relation, tid, tuple_lock_type);
@@ -2108,8 +2104,8 @@ l3:
 			LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
 			/*
-			 * Make sure it's still a shared lock, else start over.  (It's
-			 * OK if the ownership of the shared lock has changed, though.)
+			 * Make sure it's still a shared lock, else start over.  (It's OK
+			 * if the ownership of the shared lock has changed, though.)
 			 */
 			if (!(tuple->t_data->t_infomask & HEAP_XMAX_SHARED_LOCK))
 				goto l3;
@@ -2122,8 +2118,8 @@ l3:
 				if (!ConditionalMultiXactIdWait((MultiXactId) xwait))
 					ereport(ERROR,
 							(errcode(ERRCODE_LOCK_NOT_AVAILABLE),
-							 errmsg("could not obtain lock on row in relation \"%s\"",
-									RelationGetRelationName(relation))));
+					errmsg("could not obtain lock on row in relation \"%s\"",
+						   RelationGetRelationName(relation))));
 			}
 			else
 				MultiXactIdWait((MultiXactId) xwait);
@@ -2131,9 +2127,9 @@ l3:
 			LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
 			/*
-			 * If xwait had just locked the tuple then some other xact
-			 * could update this tuple before we get to this point.
-			 * Check for xmax change, and start over if so.
+			 * If xwait had just locked the tuple then some other xact could
+			 * update this tuple before we get to this point. Check for xmax
+			 * change, and start over if so.
 			 */
 			if (!(tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI) ||
 				!TransactionIdEquals(HeapTupleHeaderGetXmax(tuple->t_data),
@@ -2141,12 +2137,12 @@ l3:
 				goto l3;
 
 			/*
-			 * You might think the multixact is necessarily done here, but
-			 * not so: it could have surviving members, namely our own xact
-			 * or other subxacts of this backend.  It is legal for us to
-			 * lock the tuple in either case, however.  We don't bother
-			 * changing the on-disk hint bits since we are about to
-			 * overwrite the xmax altogether.
+			 * You might think the multixact is necessarily done here, but not
+			 * so: it could have surviving members, namely our own xact or
+			 * other subxacts of this backend.	It is legal for us to lock the
+			 * tuple in either case, however.  We don't bother changing the
+			 * on-disk hint bits since we are about to overwrite the xmax
+			 * altogether.
 			 */
 		}
 		else
@@ -2157,8 +2153,8 @@ l3:
 				if (!ConditionalXactLockTableWait(xwait))
 					ereport(ERROR,
 							(errcode(ERRCODE_LOCK_NOT_AVAILABLE),
-							 errmsg("could not obtain lock on row in relation \"%s\"",
-									RelationGetRelationName(relation))));
+					errmsg("could not obtain lock on row in relation \"%s\"",
+						   RelationGetRelationName(relation))));
 			}
 			else
 				XactLockTableWait(xwait);
@@ -2166,9 +2162,9 @@ l3:
 			LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
 			/*
-			 * xwait is done, but if xwait had just locked the tuple then
-			 * some other xact could update this tuple before we get to
-			 * this point.  Check for xmax change, and start over if so.
+			 * xwait is done, but if xwait had just locked the tuple then some
+			 * other xact could update this tuple before we get to this point.
+			 * Check for xmax change, and start over if so.
 			 */
 			if ((tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI) ||
 				!TransactionIdEquals(HeapTupleHeaderGetXmax(tuple->t_data),
@@ -2188,10 +2184,10 @@ l3:
 		}
 
 		/*
-		 * We may lock if previous xmax aborted, or if it committed
-		 * but only locked the tuple without updating it.  The case where
-		 * we didn't wait because we are joining an existing shared lock
-		 * is correctly handled, too.
+		 * We may lock if previous xmax aborted, or if it committed but only
+		 * locked the tuple without updating it.  The case where we didn't
+		 * wait because we are joining an existing shared lock is correctly
+		 * handled, too.
 		 */
 		if (tuple->t_data->t_infomask & (HEAP_XMAX_INVALID |
 										 HEAP_IS_LOCKED))
@@ -2213,9 +2209,9 @@ l3:
 	}
 
 	/*
-	 * Compute the new xmax and infomask to store into the tuple.  Note we
-	 * do not modify the tuple just yet, because that would leave it in the
-	 * wrong state if multixact.c elogs.
+	 * Compute the new xmax and infomask to store into the tuple.  Note we do
+	 * not modify the tuple just yet, because that would leave it in the wrong
+	 * state if multixact.c elogs.
 	 */
 	xid = GetCurrentTransactionId();
 
@@ -2229,17 +2225,16 @@ l3:
 
 	if (mode == LockTupleShared)
 	{
-		TransactionId	xmax = HeapTupleHeaderGetXmax(tuple->t_data);
+		TransactionId xmax = HeapTupleHeaderGetXmax(tuple->t_data);
 		uint16		old_infomask = tuple->t_data->t_infomask;
 
 		/*
 		 * If this is the first acquisition of a shared lock in the current
-		 * transaction, set my per-backend OldestMemberMXactId setting.
-		 * We can be certain that the transaction will never become a
-		 * member of any older MultiXactIds than that.  (We have to do this
-		 * even if we end up just using our own TransactionId below, since
-		 * some other backend could incorporate our XID into a MultiXact
-		 * immediately afterwards.)
+		 * transaction, set my per-backend OldestMemberMXactId setting. We can
+		 * be certain that the transaction will never become a member of any
+		 * older MultiXactIds than that.  (We have to do this even if we end
+		 * up just using our own TransactionId below, since some other backend
+		 * could incorporate our XID into a MultiXact immediately afterwards.)
 		 */
 		MultiXactIdSetOldestMember();
 
@@ -2249,14 +2244,14 @@ l3:
 		 * Check to see if we need a MultiXactId because there are multiple
 		 * lockers.
 		 *
-		 * HeapTupleSatisfiesUpdate will have set the HEAP_XMAX_INVALID
-		 * bit if the xmax was a MultiXactId but it was not running anymore.
-		 * There is a race condition, which is that the MultiXactId may have
-		 * finished since then, but that uncommon case is handled within
+		 * HeapTupleSatisfiesUpdate will have set the HEAP_XMAX_INVALID bit if
+		 * the xmax was a MultiXactId but it was not running anymore. There is
+		 * a race condition, which is that the MultiXactId may have finished
+		 * since then, but that uncommon case is handled within
 		 * MultiXactIdExpand.
 		 *
-		 * There is a similar race condition possible when the old xmax was
-		 * a regular TransactionId.  We test TransactionIdIsInProgress again
+		 * There is a similar race condition possible when the old xmax was a
+		 * regular TransactionId.  We test TransactionIdIsInProgress again
 		 * just to narrow the window, but it's still possible to end up
 		 * creating an unnecessary MultiXactId.  Fortunately this is harmless.
 		 */
@@ -2277,10 +2272,10 @@ l3:
 				{
 					/*
 					 * If the old locker is ourselves, we'll just mark the
-					 * tuple again with our own TransactionId.  However we
-					 * have to consider the possibility that we had
-					 * exclusive rather than shared lock before --- if so,
-					 * be careful to preserve the exclusivity of the lock.
+					 * tuple again with our own TransactionId.	However we
+					 * have to consider the possibility that we had exclusive
+					 * rather than shared lock before --- if so, be careful to
+					 * preserve the exclusivity of the lock.
 					 */
 					if (!(old_infomask & HEAP_XMAX_SHARED_LOCK))
 					{
@@ -2303,9 +2298,9 @@ l3:
 			else
 			{
 				/*
-				 * Can get here iff HeapTupleSatisfiesUpdate saw the old
-				 * xmax as running, but it finished before
-				 * TransactionIdIsInProgress() got to run.  Treat it like
+				 * Can get here iff HeapTupleSatisfiesUpdate saw the old xmax
+				 * as running, but it finished before
+				 * TransactionIdIsInProgress() got to run.	Treat it like
 				 * there's no locker in the tuple.
 				 */
 			}
@@ -2329,8 +2324,8 @@ l3:
 	/*
 	 * Store transaction information of xact locking the tuple.
 	 *
-	 * Note: our CID is meaningless if storing a MultiXactId, but no harm
-	 * in storing it anyway.
+	 * Note: our CID is meaningless if storing a MultiXactId, but no harm in
+	 * storing it anyway.
 	 */
 	tuple->t_data->t_infomask = new_infomask;
 	HeapTupleHeaderSetXmax(tuple->t_data, xid);
@@ -2339,8 +2334,8 @@ l3:
 	tuple->t_data->t_ctid = *tid;
 
 	/*
-	 * XLOG stuff.  You might think that we don't need an XLOG record because
-	 * there is no state change worth restoring after a crash.  You would be
+	 * XLOG stuff.	You might think that we don't need an XLOG record because
+	 * there is no state change worth restoring after a crash.	You would be
 	 * wrong however: we have just written either a TransactionId or a
 	 * MultiXactId that may never have been seen on disk before, and we need
 	 * to make sure that there are XLOG entries covering those ID numbers.
@@ -2473,8 +2468,8 @@ log_heap_clean(Relation reln, Buffer buffer, OffsetNumber *unused, int uncnt)
 
 	/*
 	 * The unused-offsets array is not actually in the buffer, but pretend
-	 * that it is.	When XLogInsert stores the whole buffer, the offsets
-	 * array need not be stored too.
+	 * that it is.	When XLogInsert stores the whole buffer, the offsets array
+	 * need not be stored too.
 	 */
 	if (uncnt > 0)
 	{
@@ -2500,11 +2495,10 @@ log_heap_update(Relation reln, Buffer oldbuf, ItemPointerData from,
 				Buffer newbuf, HeapTuple newtup, bool move)
 {
 	/*
-	 * Note: xlhdr is declared to have adequate size and correct alignment
-	 * for an xl_heap_header.  However the two tids, if present at all,
-	 * will be packed in with no wasted space after the xl_heap_header;
-	 * they aren't necessarily aligned as implied by this struct
-	 * declaration.
+	 * Note: xlhdr is declared to have adequate size and correct alignment for
+	 * an xl_heap_header.  However the two tids, if present at all, will be
+	 * packed in with no wasted space after the xl_heap_header; they aren't
+	 * necessarily aligned as implied by this struct declaration.
 	 */
 	struct
 	{
@@ -2555,8 +2549,8 @@ log_heap_update(Relation reln, Buffer oldbuf, ItemPointerData from,
 	}
 
 	/*
-	 * As with insert records, we need not store the rdata[2] segment if
-	 * we decide to store the whole buffer instead.
+	 * As with insert records, we need not store the rdata[2] segment if we
+	 * decide to store the whole buffer instead.
 	 */
 	rdata[2].data = (char *) &xlhdr;
 	rdata[2].len = hsize;
@@ -2655,8 +2649,8 @@ heap_xlog_newpage(XLogRecPtr lsn, XLogRecord *record)
 	Page		page;
 
 	/*
-	 * Note: the NEWPAGE log record is used for both heaps and indexes, so
-	 * do not do anything that assumes we are touching a heap.
+	 * Note: the NEWPAGE log record is used for both heaps and indexes, so do
+	 * not do anything that assumes we are touching a heap.
 	 */
 
 	if (record->xl_info & XLR_BKP_BLOCK_1)
@@ -2699,7 +2693,7 @@ heap_xlog_delete(XLogRecPtr lsn, XLogRecord *record)
 		return;
 
 	buffer = XLogReadBuffer(false, reln,
-						ItemPointerGetBlockNumber(&(xlrec->target.tid)));
+							ItemPointerGetBlockNumber(&(xlrec->target.tid)));
 	if (!BufferIsValid(buffer))
 		elog(PANIC, "heap_delete_redo: no block");
 
@@ -2707,7 +2701,7 @@ heap_xlog_delete(XLogRecPtr lsn, XLogRecord *record)
 	if (PageIsNew((PageHeader) page))
 		elog(PANIC, "heap_delete_redo: uninitialized page");
 
-	if (XLByteLE(lsn, PageGetLSN(page)))	/* changes are applied */
+	if (XLByteLE(lsn, PageGetLSN(page)))		/* changes are applied */
 	{
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 		ReleaseBuffer(buffer);
@@ -2749,7 +2743,7 @@ heap_xlog_insert(XLogRecPtr lsn, XLogRecord *record)
 	struct
 	{
 		HeapTupleHeaderData hdr;
-		char	data[MaxTupleSize];
+		char		data[MaxTupleSize];
 	}			tbuf;
 	HeapTupleHeader htup;
 	xl_heap_header xlhdr;
@@ -2764,7 +2758,7 @@ heap_xlog_insert(XLogRecPtr lsn, XLogRecord *record)
 		return;
 
 	buffer = XLogReadBuffer(true, reln,
-						ItemPointerGetBlockNumber(&(xlrec->target.tid)));
+							ItemPointerGetBlockNumber(&(xlrec->target.tid)));
 	if (!BufferIsValid(buffer))
 		return;
 
@@ -2776,7 +2770,7 @@ heap_xlog_insert(XLogRecPtr lsn, XLogRecord *record)
 	if (record->xl_info & XLOG_HEAP_INIT_PAGE)
 		PageInit(page, BufferGetPageSize(buffer), 0);
 
-	if (XLByteLE(lsn, PageGetLSN(page)))	/* changes are applied */
+	if (XLByteLE(lsn, PageGetLSN(page)))		/* changes are applied */
 	{
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 		ReleaseBuffer(buffer);
@@ -2835,7 +2829,7 @@ heap_xlog_update(XLogRecPtr lsn, XLogRecord *record, bool move)
 	struct
 	{
 		HeapTupleHeaderData hdr;
-		char	data[MaxTupleSize];
+		char		data[MaxTupleSize];
 	}			tbuf;
 	xl_heap_header xlhdr;
 	int			hsize;
@@ -2850,7 +2844,7 @@ heap_xlog_update(XLogRecPtr lsn, XLogRecord *record, bool move)
 	/* Deal with old tuple version */
 
 	buffer = XLogReadBuffer(false, reln,
-						ItemPointerGetBlockNumber(&(xlrec->target.tid)));
+							ItemPointerGetBlockNumber(&(xlrec->target.tid)));
 	if (!BufferIsValid(buffer))
 		elog(PANIC, "heap_update_redo: no block");
 
@@ -2858,7 +2852,7 @@ heap_xlog_update(XLogRecPtr lsn, XLogRecord *record, bool move)
 	if (PageIsNew((PageHeader) page))
 		elog(PANIC, "heap_update_redo: uninitialized old page");
 
-	if (XLByteLE(lsn, PageGetLSN(page)))	/* changes are applied */
+	if (XLByteLE(lsn, PageGetLSN(page)))		/* changes are applied */
 	{
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 		ReleaseBuffer(buffer);
@@ -2928,7 +2922,7 @@ newsame:;
 	if (record->xl_info & XLOG_HEAP_INIT_PAGE)
 		PageInit(page, BufferGetPageSize(buffer), 0);
 
-	if (XLByteLE(lsn, PageGetLSN(page)))	/* changes are applied */
+	if (XLByteLE(lsn, PageGetLSN(page)))		/* changes are applied */
 	{
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 		ReleaseBuffer(buffer);
@@ -2961,7 +2955,7 @@ newsame:;
 
 	if (move)
 	{
-		TransactionId xid[2];		/* xmax, xmin */
+		TransactionId xid[2];	/* xmax, xmin */
 
 		memcpy((char *) xid,
 			   (char *) xlrec + SizeOfHeapUpdate + SizeOfHeapHeader,
@@ -3008,7 +3002,7 @@ heap_xlog_lock(XLogRecPtr lsn, XLogRecord *record)
 		return;
 
 	buffer = XLogReadBuffer(false, reln,
-						ItemPointerGetBlockNumber(&(xlrec->target.tid)));
+							ItemPointerGetBlockNumber(&(xlrec->target.tid)));
 	if (!BufferIsValid(buffer))
 		elog(PANIC, "heap_lock_redo: no block");
 
@@ -3016,7 +3010,7 @@ heap_xlog_lock(XLogRecPtr lsn, XLogRecord *record)
 	if (PageIsNew((PageHeader) page))
 		elog(PANIC, "heap_lock_redo: uninitialized page");
 
-	if (XLByteLE(lsn, PageGetLSN(page)))	/* changes are applied */
+	if (XLByteLE(lsn, PageGetLSN(page)))		/* changes are applied */
 	{
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 		ReleaseBuffer(buffer);
@@ -3081,7 +3075,7 @@ static void
 out_target(char *buf, xl_heaptid *target)
 {
 	sprintf(buf + strlen(buf), "rel %u/%u/%u; tid %u/%u",
-		 target->node.spcNode, target->node.dbNode, target->node.relNode,
+			target->node.spcNode, target->node.dbNode, target->node.relNode,
 			ItemPointerGetBlockNumber(&(target->tid)),
 			ItemPointerGetOffsetNumber(&(target->tid)));
 }
diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c
index 5d7197b8bb..f14a4b57bb 100644
--- a/src/backend/access/heap/hio.c
+++ b/src/backend/access/heap/hio.c
@@ -80,7 +80,7 @@ RelationPutHeapTuple(Relation relation,
  *	enough there).	In that case, the page will be pinned and locked only once.
  *
  *	If use_fsm is true (the normal case), we use FSM to help us find free
- *	space.  If use_fsm is false, we always append a new empty page to the
+ *	space.	If use_fsm is false, we always append a new empty page to the
  *	end of the relation if the tuple won't fit on the current target page.
  *	This can save some cycles when we know the relation is new and doesn't
  *	contain useful amounts of free space.
@@ -122,22 +122,20 @@ RelationGetBufferForTuple(Relation relation, Size len,
 	if (otherBuffer != InvalidBuffer)
 		otherBlock = BufferGetBlockNumber(otherBuffer);
 	else
-		otherBlock = InvalidBlockNumber;		/* just to keep compiler
-												 * quiet */
+		otherBlock = InvalidBlockNumber;		/* just to keep compiler quiet */
 
 	/*
-	 * We first try to put the tuple on the same page we last inserted a
-	 * tuple on, as cached in the relcache entry.  If that doesn't work,
-	 * we ask the shared Free Space Map to locate a suitable page.	Since
-	 * the FSM's info might be out of date, we have to be prepared to loop
-	 * around and retry multiple times.  (To insure this isn't an infinite
-	 * loop, we must update the FSM with the correct amount of free space
-	 * on each page that proves not to be suitable.)  If the FSM has no
-	 * record of a page with enough free space, we give up and extend the
-	 * relation.
+	 * We first try to put the tuple on the same page we last inserted a tuple
+	 * on, as cached in the relcache entry.  If that doesn't work, we ask the
+	 * shared Free Space Map to locate a suitable page.  Since the FSM's info
+	 * might be out of date, we have to be prepared to loop around and retry
+	 * multiple times.	(To insure this isn't an infinite loop, we must update
+	 * the FSM with the correct amount of free space on each page that proves
+	 * not to be suitable.)  If the FSM has no record of a page with enough
+	 * free space, we give up and extend the relation.
 	 *
-	 * When use_fsm is false, we either put the tuple onto the existing
-	 * target page or extend the relation.
+	 * When use_fsm is false, we either put the tuple onto the existing target
+	 * page or extend the relation.
 	 */
 
 	targetBlock = relation->rd_targblock;
@@ -151,9 +149,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
 		targetBlock = GetPageWithFreeSpace(&relation->rd_node, len);
 
 		/*
-		 * If the FSM knows nothing of the rel, try the last page before
-		 * we give up and extend.  This avoids one-tuple-per-page syndrome
-		 * during bootstrapping or in a recently-started system.
+		 * If the FSM knows nothing of the rel, try the last page before we
+		 * give up and extend.	This avoids one-tuple-per-page syndrome during
+		 * bootstrapping or in a recently-started system.
 		 */
 		if (targetBlock == InvalidBlockNumber)
 		{
@@ -168,8 +166,8 @@ RelationGetBufferForTuple(Relation relation, Size len,
 	{
 		/*
 		 * Read and exclusive-lock the target block, as well as the other
-		 * block if one was given, taking suitable care with lock ordering
-		 * and the possibility they are the same block.
+		 * block if one was given, taking suitable care with lock ordering and
+		 * the possibility they are the same block.
 		 */
 		if (otherBuffer == InvalidBuffer)
 		{
@@ -199,8 +197,8 @@ RelationGetBufferForTuple(Relation relation, Size len,
 		}
 
 		/*
-		 * Now we can check to see if there's enough free space here. If
-		 * so, we're done.
+		 * Now we can check to see if there's enough free space here. If so,
+		 * we're done.
 		 */
 		pageHeader = (Page) BufferGetPage(buffer);
 		pageFreeSpace = PageGetFreeSpace(pageHeader);
@@ -213,9 +211,9 @@ RelationGetBufferForTuple(Relation relation, Size len,
 
 		/*
 		 * Not enough space, so we must give up our page locks and pin (if
-		 * any) and prepare to look elsewhere.	We don't care which order
-		 * we unlock the two buffers in, so this can be slightly simpler
-		 * than the code above.
+		 * any) and prepare to look elsewhere.	We don't care which order we
+		 * unlock the two buffers in, so this can be slightly simpler than the
+		 * code above.
 		 */
 		LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 		if (otherBuffer == InvalidBuffer)
@@ -231,8 +229,8 @@ RelationGetBufferForTuple(Relation relation, Size len,
 			break;
 
 		/*
-		 * Update FSM as to condition of this page, and ask for another
-		 * page to try.
+		 * Update FSM as to condition of this page, and ask for another page
+		 * to try.
 		 */
 		targetBlock = RecordAndGetPageWithFreeSpace(&relation->rd_node,
 													targetBlock,
@@ -243,10 +241,10 @@ RelationGetBufferForTuple(Relation relation, Size len,
 	/*
 	 * Have to extend the relation.
 	 *
-	 * We have to use a lock to ensure no one else is extending the rel at
-	 * the same time, else we will both try to initialize the same new
-	 * page.  We can skip locking for new or temp relations, however,
-	 * since no one else could be accessing them.
+	 * We have to use a lock to ensure no one else is extending the rel at the
+	 * same time, else we will both try to initialize the same new page.  We
+	 * can skip locking for new or temp relations, however, since no one else
+	 * could be accessing them.
 	 */
 	needLock = !RELATION_IS_LOCAL(relation);
 
@@ -254,17 +252,16 @@ RelationGetBufferForTuple(Relation relation, Size len,
 		LockRelationForExtension(relation, ExclusiveLock);
 
 	/*
-	 * XXX This does an lseek - rather expensive - but at the moment it is
-	 * the only way to accurately determine how many blocks are in a
-	 * relation.  Is it worth keeping an accurate file length in shared
-	 * memory someplace, rather than relying on the kernel to do it for
-	 * us?
+	 * XXX This does an lseek - rather expensive - but at the moment it is the
+	 * only way to accurately determine how many blocks are in a relation.	Is
+	 * it worth keeping an accurate file length in shared memory someplace,
+	 * rather than relying on the kernel to do it for us?
 	 */
 	buffer = ReadBuffer(relation, P_NEW);
 
 	/*
-	 * We can be certain that locking the otherBuffer first is OK, since
-	 * it must have a lower page number.
+	 * We can be certain that locking the otherBuffer first is OK, since it
+	 * must have a lower page number.
 	 */
 	if (otherBuffer != InvalidBuffer)
 		LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
@@ -275,10 +272,10 @@ RelationGetBufferForTuple(Relation relation, Size len,
 	LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
 	/*
-	 * Release the file-extension lock; it's now OK for someone else to
-	 * extend the relation some more.  Note that we cannot release this
-	 * lock before we have buffer lock on the new page, or we risk a
-	 * race condition against vacuumlazy.c --- see comments therein.
+	 * Release the file-extension lock; it's now OK for someone else to extend
+	 * the relation some more.	Note that we cannot release this lock before
+	 * we have buffer lock on the new page, or we risk a race condition
+	 * against vacuumlazy.c --- see comments therein.
 	 */
 	if (needLock)
 		UnlockRelationForExtension(relation, ExclusiveLock);
@@ -299,11 +296,11 @@ RelationGetBufferForTuple(Relation relation, Size len,
 	/*
 	 * Remember the new page as our target for future insertions.
 	 *
-	 * XXX should we enter the new page into the free space map immediately,
-	 * or just keep it for this backend's exclusive use in the short run
-	 * (until VACUUM sees it)?	Seems to depend on whether you expect the
-	 * current backend to make more insertions or not, which is probably a
-	 * good bet most of the time.  So for now, don't add it to FSM yet.
+	 * XXX should we enter the new page into the free space map immediately, or
+	 * just keep it for this backend's exclusive use in the short run (until
+	 * VACUUM sees it)?  Seems to depend on whether you expect the current
+	 * backend to make more insertions or not, which is probably a good bet
+	 * most of the time.  So for now, don't add it to FSM yet.
 	 */
 	relation->rd_targblock = BufferGetBlockNumber(buffer);
 
diff --git a/src/backend/access/heap/tuptoaster.c b/src/backend/access/heap/tuptoaster.c
index 7946df055c..c0c9e88078 100644
--- a/src/backend/access/heap/tuptoaster.c
+++ b/src/backend/access/heap/tuptoaster.c
@@ -90,8 +90,7 @@ heap_tuple_fetch_attr(varattrib *attr)
 	else
 	{
 		/*
-		 * This is a plain value inside of the main tuple - why am I
-		 * called?
+		 * This is a plain value inside of the main tuple - why am I called?
 		 */
 		result = attr;
 	}
@@ -154,8 +153,7 @@ heap_tuple_untoast_attr(varattrib *attr)
 	else
 
 		/*
-		 * This is a plain value inside of the main tuple - why am I
-		 * called?
+		 * This is a plain value inside of the main tuple - why am I called?
 		 */
 		return attr;
 
@@ -255,8 +253,8 @@ toast_raw_datum_size(Datum value)
 	else if (VARATT_IS_EXTERNAL(attr))
 	{
 		/*
-		 * an uncompressed external attribute has rawsize including the
-		 * header (not too consistent!)
+		 * an uncompressed external attribute has rawsize including the header
+		 * (not too consistent!)
 		 */
 		result = attr->va_content.va_external.va_rawsize;
 	}
@@ -274,26 +272,26 @@ toast_raw_datum_size(Datum value)
  *	Return the physical storage size (possibly compressed) of a varlena datum
  * ----------
  */
-Size 
+Size
 toast_datum_size(Datum value)
 {
-	varattrib	*attr = (varattrib *) DatumGetPointer(value);
+	varattrib  *attr = (varattrib *) DatumGetPointer(value);
 	Size		result;
 
 	if (VARATT_IS_EXTERNAL(attr))
 	{
 		/*
 		 * Attribute is stored externally - return the extsize whether
-		 * compressed or not.  We do not count the size of the toast
-		 * pointer ... should we?
+		 * compressed or not.  We do not count the size of the toast pointer
+		 * ... should we?
 		 */
 		result = attr->va_content.va_external.va_extsize;
 	}
 	else
 	{
 		/*
-		 * Attribute is stored inline either compressed or not, just
-		 * calculate the size of the datum in either case.
+		 * Attribute is stored inline either compressed or not, just calculate
+		 * the size of the datum in either case.
 		 */
 		result = VARSIZE(attr);
 	}
@@ -321,12 +319,12 @@ toast_delete(Relation rel, HeapTuple oldtup)
 	 * Get the tuple descriptor and break down the tuple into fields.
 	 *
 	 * NOTE: it's debatable whether to use heap_deformtuple() here or just
-	 * heap_getattr() only the varlena columns.  The latter could win if
-	 * there are few varlena columns and many non-varlena ones. However,
-	 * heap_deformtuple costs only O(N) while the heap_getattr way would
-	 * cost O(N^2) if there are many varlena columns, so it seems better
-	 * to err on the side of linear cost.  (We won't even be here unless
-	 * there's at least one varlena column, by the way.)
+	 * heap_getattr() only the varlena columns.  The latter could win if there
+	 * are few varlena columns and many non-varlena ones. However,
+	 * heap_deformtuple costs only O(N) while the heap_getattr way would cost
+	 * O(N^2) if there are many varlena columns, so it seems better to err on
+	 * the side of linear cost.  (We won't even be here unless there's at
+	 * least one varlena column, by the way.)
 	 */
 	tupleDesc = rel->rd_att;
 	att = tupleDesc->attrs;
@@ -336,8 +334,8 @@ toast_delete(Relation rel, HeapTuple oldtup)
 	heap_deform_tuple(oldtup, tupleDesc, toast_values, toast_isnull);
 
 	/*
-	 * Check for external stored attributes and delete them from the
-	 * secondary relation.
+	 * Check for external stored attributes and delete them from the secondary
+	 * relation.
 	 */
 	for (i = 0; i < numAttrs; i++)
 	{
@@ -447,9 +445,9 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
 				else
 				{
 					/*
-					 * This attribute isn't changed by this update so we
-					 * reuse the original reference to the old value in
-					 * the new tuple.
+					 * This attribute isn't changed by this update so we reuse
+					 * the original reference to the old value in the new
+					 * tuple.
 					 */
 					toast_action[i] = 'p';
 					toast_sizes[i] = VARATT_SIZE(toast_values[i]);
@@ -582,16 +580,15 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
 		else
 		{
 			/*
-			 * incompressible data, ignore on subsequent compression
-			 * passes
+			 * incompressible data, ignore on subsequent compression passes
 			 */
 			toast_action[i] = 'x';
 		}
 	}
 
 	/*
-	 * Second we look for attributes of attstorage 'x' or 'e' that are
-	 * still inline.
+	 * Second we look for attributes of attstorage 'x' or 'e' that are still
+	 * inline.
 	 */
 	while (MAXALIGN(heap_compute_data_size(tupleDesc,
 										   toast_values, toast_isnull)) >
@@ -696,8 +693,7 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
 		else
 		{
 			/*
-			 * incompressible data, ignore on subsequent compression
-			 * passes
+			 * incompressible data, ignore on subsequent compression passes
 			 */
 			toast_action[i] = 'x';
 		}
@@ -755,8 +751,8 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
 	}
 
 	/*
-	 * In the case we toasted any values, we need to build a new heap
-	 * tuple with the changed values.
+	 * In the case we toasted any values, we need to build a new heap tuple
+	 * with the changed values.
 	 */
 	if (need_change)
 	{
@@ -798,8 +794,8 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup)
 						has_nulls ? newtup->t_data->t_bits : NULL);
 
 		/*
-		 * In the case we modified a previously modified tuple again, free
-		 * the memory from the previous run
+		 * In the case we modified a previously modified tuple again, free the
+		 * memory from the previous run
 		 */
 		if ((char *) olddata != ((char *) newtup + HEAPTUPLESIZE))
 			pfree(olddata);
@@ -906,8 +902,8 @@ toast_flatten_tuple_attribute(Datum value,
 		return value;
 
 	/*
-	 * Calculate the new size of the tuple.  Header size should not
-	 * change, but data size might.
+	 * Calculate the new size of the tuple.  Header size should not change,
+	 * but data size might.
 	 */
 	new_len = offsetof(HeapTupleHeaderData, t_bits);
 	if (has_nulls)
@@ -1007,9 +1003,9 @@ toast_save_datum(Relation rel, Datum value)
 	int32		data_todo;
 
 	/*
-	 * Open the toast relation and its index.  We can use the index to
-	 * check uniqueness of the OID we assign to the toasted item, even
-	 * though it has additional columns besides OID.
+	 * Open the toast relation and its index.  We can use the index to check
+	 * uniqueness of the OID we assign to the toasted item, even though it has
+	 * additional columns besides OID.
 	 */
 	toastrel = heap_open(rel->rd_rel->reltoastrelid, RowExclusiveLock);
 	toasttupDesc = toastrel->rd_att;
@@ -1082,11 +1078,11 @@ toast_save_datum(Relation rel, Datum value)
 
 		/*
 		 * Create the index entry.	We cheat a little here by not using
-		 * FormIndexDatum: this relies on the knowledge that the index
-		 * columns are the same as the initial columns of the table.
+		 * FormIndexDatum: this relies on the knowledge that the index columns
+		 * are the same as the initial columns of the table.
 		 *
-		 * Note also that there had better not be any user-created index on
-		 * the TOAST table, since we don't bother to update anything else.
+		 * Note also that there had better not be any user-created index on the
+		 * TOAST table, since we don't bother to update anything else.
 		 */
 		index_insert(toastidx, t_values, t_isnull,
 					 &(toasttup->t_self),
@@ -1148,7 +1144,7 @@ toast_delete_datum(Relation rel, Datum value)
 	ScanKeyInit(&toastkey,
 				(AttrNumber) 1,
 				BTEqualStrategyNumber, F_OIDEQ,
-			  ObjectIdGetDatum(attr->va_content.va_external.va_valueid));
+				ObjectIdGetDatum(attr->va_content.va_external.va_valueid));
 
 	/*
 	 * Find the chunks by index
@@ -1219,14 +1215,14 @@ toast_fetch_datum(varattrib *attr)
 	ScanKeyInit(&toastkey,
 				(AttrNumber) 1,
 				BTEqualStrategyNumber, F_OIDEQ,
-			  ObjectIdGetDatum(attr->va_content.va_external.va_valueid));
+				ObjectIdGetDatum(attr->va_content.va_external.va_valueid));
 
 	/*
 	 * Read the chunks by index
 	 *
-	 * Note that because the index is actually on (valueid, chunkidx) we will
-	 * see the chunks in chunkidx order, even though we didn't explicitly
-	 * ask for it.
+	 * Note that because the index is actually on (valueid, chunkidx) we will see
+	 * the chunks in chunkidx order, even though we didn't explicitly ask for
+	 * it.
 	 */
 	nextidx = 0;
 
@@ -1367,13 +1363,13 @@ toast_fetch_datum_slice(varattrib *attr, int32 sliceoffset, int32 length)
 	toastidx = index_open(toastrel->rd_rel->reltoastidxid);
 
 	/*
-	 * Setup a scan key to fetch from the index. This is either two keys
-	 * or three depending on the number of chunks.
+	 * Setup a scan key to fetch from the index. This is either two keys or
+	 * three depending on the number of chunks.
 	 */
 	ScanKeyInit(&toastkey[0],
 				(AttrNumber) 1,
 				BTEqualStrategyNumber, F_OIDEQ,
-			  ObjectIdGetDatum(attr->va_content.va_external.va_valueid));
+				ObjectIdGetDatum(attr->va_content.va_external.va_valueid));
 
 	/*
 	 * Use equality condition for one chunk, a range condition otherwise:
diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c
index fc1c3dfb9e..de62901a67 100644
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -78,15 +78,15 @@ RelationGetIndexScan(Relation indexRelation,
 	scan->numberOfKeys = nkeys;
 
 	/*
-	 * We allocate the key space here, but the AM is responsible for
-	 * actually filling it from the passed key array.
+	 * We allocate the key space here, but the AM is responsible for actually
+	 * filling it from the passed key array.
 	 */
 	if (nkeys > 0)
 		scan->keyData = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
 	else
 		scan->keyData = NULL;
 
-	scan->is_multiscan = false;			/* caller may change this */
+	scan->is_multiscan = false; /* caller may change this */
 	scan->kill_prior_tuple = false;
 	scan->ignore_killed_tuples = true;	/* default setting */
 	scan->keys_are_unique = false;		/* may be set by index AM */
@@ -203,8 +203,8 @@ systable_beginscan(Relation heapRelation,
 		/*
 		 * Change attribute numbers to be index column numbers.
 		 *
-		 * This code could be generalized to search for the index key numbers
-		 * to substitute, but for now there's no need.
+		 * This code could be generalized to search for the index key numbers to
+		 * substitute, but for now there's no need.
 		 */
 		for (i = 0; i < nkeys; i++)
 		{
diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c
index 534b045cf1..3cc3554368 100644
--- a/src/backend/access/index/indexam.c
+++ b/src/backend/access/index/indexam.c
@@ -111,7 +111,7 @@ do { \
 } while(0)
 
 static IndexScanDesc index_beginscan_internal(Relation indexRelation,
-											  int nkeys, ScanKey key);
+						 int nkeys, ScanKey key);
 
 
 /* ----------------------------------------------------------------
@@ -122,14 +122,14 @@ static IndexScanDesc index_beginscan_internal(Relation indexRelation,
 /* ----------------
  *		index_open - open an index relation by relation OID
  *
- *		Note: we acquire no lock on the index.  A lock is not needed when
+ *		Note: we acquire no lock on the index.	A lock is not needed when
  *		simply examining the index reldesc; the index's schema information
  *		is considered to be protected by the lock that the caller had better
- *		be holding on the parent relation.  Some type of lock should be
+ *		be holding on the parent relation.	Some type of lock should be
  *		obtained on the index before physically accessing it, however.
  *		This is handled automatically for most uses by index_beginscan
  *		and index_endscan for scan cases, or by ExecOpenIndices and
- *		ExecCloseIndices for update cases.  Other callers will need to
+ *		ExecCloseIndices for update cases.	Other callers will need to
  *		obtain their own locks.
  *
  *		This is a convenience routine adapted for indexscan use.
@@ -241,8 +241,8 @@ index_beginscan(Relation heapRelation,
 	scan = index_beginscan_internal(indexRelation, nkeys, key);
 
 	/*
-	 * Save additional parameters into the scandesc.  Everything else was
-	 * set up by RelationGetIndexScan.
+	 * Save additional parameters into the scandesc.  Everything else was set
+	 * up by RelationGetIndexScan.
 	 */
 	scan->is_multiscan = false;
 	scan->heapRelation = heapRelation;
@@ -267,8 +267,8 @@ index_beginscan_multi(Relation indexRelation,
 	scan = index_beginscan_internal(indexRelation, nkeys, key);
 
 	/*
-	 * Save additional parameters into the scandesc.  Everything else was
-	 * set up by RelationGetIndexScan.
+	 * Save additional parameters into the scandesc.  Everything else was set
+	 * up by RelationGetIndexScan.
 	 */
 	scan->is_multiscan = true;
 	scan->xs_snapshot = snapshot;
@@ -294,14 +294,14 @@ index_beginscan_internal(Relation indexRelation,
 	 * Acquire AccessShareLock for the duration of the scan
 	 *
 	 * Note: we could get an SI inval message here and consequently have to
-	 * rebuild the relcache entry.	The refcount increment above ensures
-	 * that we will rebuild it and not just flush it...
+	 * rebuild the relcache entry.	The refcount increment above ensures that
+	 * we will rebuild it and not just flush it...
 	 */
 	LockRelation(indexRelation, AccessShareLock);
 
 	/*
-	 * LockRelation can clean rd_aminfo structure, so fill procedure
-	 * after LockRelation 
+	 * LockRelation can clean rd_aminfo structure, so fill procedure after
+	 * LockRelation
 	 */
 
 	GET_REL_PROCEDURE(ambeginscan);
@@ -425,8 +425,8 @@ index_restrpos(IndexScanDesc scan)
 
 	/*
 	 * We do not reset got_tuple; so if the scan is actually being
-	 * short-circuited by index_getnext, the effective position
-	 * restoration is done by restoring unique_tuple_pos.
+	 * short-circuited by index_getnext, the effective position restoration is
+	 * done by restoring unique_tuple_pos.
 	 */
 	scan->unique_tuple_pos = scan->unique_tuple_mark;
 
@@ -454,19 +454,19 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
 
 	/*
 	 * If we already got a tuple and it must be unique, there's no need to
-	 * make the index AM look through any additional tuples.  (This can
-	 * save a useful amount of work in scenarios where there are many dead
-	 * tuples due to heavy update activity.)
+	 * make the index AM look through any additional tuples.  (This can save a
+	 * useful amount of work in scenarios where there are many dead tuples due
+	 * to heavy update activity.)
 	 *
 	 * To do this we must keep track of the logical scan position
 	 * (before/on/after tuple).  Also, we have to be sure to release scan
-	 * resources before returning NULL; if we fail to do so then a
-	 * multi-index scan can easily run the system out of free buffers.	We
-	 * can release index-level resources fairly cheaply by calling
-	 * index_rescan.  This means there are two persistent states as far as
-	 * the index AM is concerned: on-tuple and rescanned.  If we are
-	 * actually asked to re-fetch the single tuple, we have to go through
-	 * a fresh indexscan startup, which penalizes that (infrequent) case.
+	 * resources before returning NULL; if we fail to do so then a multi-index
+	 * scan can easily run the system out of free buffers.	We can release
+	 * index-level resources fairly cheaply by calling index_rescan.  This
+	 * means there are two persistent states as far as the index AM is
+	 * concerned: on-tuple and rescanned.  If we are actually asked to
+	 * re-fetch the single tuple, we have to go through a fresh indexscan
+	 * startup, which penalizes that (infrequent) case.
 	 */
 	if (scan->keys_are_unique && scan->got_tuple)
 	{
@@ -485,19 +485,18 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
 		if (new_tuple_pos == 0)
 		{
 			/*
-			 * We are moving onto the unique tuple from having been off
-			 * it. We just fall through and let the index AM do the work.
-			 * Note we should get the right answer regardless of scan
-			 * direction.
+			 * We are moving onto the unique tuple from having been off it. We
+			 * just fall through and let the index AM do the work. Note we
+			 * should get the right answer regardless of scan direction.
 			 */
 			scan->unique_tuple_pos = 0; /* need to update position */
 		}
 		else
 		{
 			/*
-			 * Moving off the tuple; must do amrescan to release
-			 * index-level pins before we return NULL.	Since index_rescan
-			 * will reset my state, must save and restore...
+			 * Moving off the tuple; must do amrescan to release index-level
+			 * pins before we return NULL.	Since index_rescan will reset my
+			 * state, must save and restore...
 			 */
 			int			unique_tuple_mark = scan->unique_tuple_mark;
 
@@ -520,8 +519,7 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
 		bool		found;
 
 		/*
-		 * The AM's gettuple proc finds the next tuple matching the scan
-		 * keys.
+		 * The AM's gettuple proc finds the next tuple matching the scan keys.
 		 */
 		found = DatumGetBool(FunctionCall2(procedure,
 										   PointerGetDatum(scan),
@@ -556,9 +554,9 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
 			continue;
 
 		/*
-		 * If we can't see it, maybe no one else can either.  Check to see
-		 * if the tuple is dead to all transactions.  If so, signal the
-		 * index AM to not return it on future indexscans.
+		 * If we can't see it, maybe no one else can either.  Check to see if
+		 * the tuple is dead to all transactions.  If so, signal the index AM
+		 * to not return it on future indexscans.
 		 *
 		 * We told heap_release_fetch to keep a pin on the buffer, so we can
 		 * re-access the tuple here.  But we must re-lock the buffer first.
@@ -576,8 +574,8 @@ index_getnext(IndexScanDesc scan, ScanDirection direction)
 	scan->got_tuple = true;
 
 	/*
-	 * If we just fetched a known-unique tuple, then subsequent calls will
-	 * go through the short-circuit code above.  unique_tuple_pos has been
+	 * If we just fetched a known-unique tuple, then subsequent calls will go
+	 * through the short-circuit code above.  unique_tuple_pos has been
 	 * initialized to 0, which is the correct state ("on row").
 	 */
 
@@ -805,11 +803,10 @@ index_getprocinfo(Relation irel,
 		procId = loc[procindex];
 
 		/*
-		 * Complain if function was not found during
-		 * IndexSupportInitialize. This should not happen unless the
-		 * system tables contain bogus entries for the index opclass.  (If
-		 * an AM wants to allow a support function to be optional, it can
-		 * use index_getprocid.)
+		 * Complain if function was not found during IndexSupportInitialize.
+		 * This should not happen unless the system tables contain bogus
+		 * entries for the index opclass.  (If an AM wants to allow a support
+		 * function to be optional, it can use index_getprocid.)
 		 */
 		if (!RegProcedureIsValid(procId))
 			elog(ERROR, "missing support function %d for attribute %d of index \"%s\"",
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index b997447b89..78d06dbd4e 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -93,30 +93,29 @@ top:
 
 	/*
 	 * If the page was split between the time that we surrendered our read
-	 * lock and acquired our write lock, then this page may no longer be
-	 * the right place for the key we want to insert.  In this case, we
-	 * need to move right in the tree.	See Lehman and Yao for an
-	 * excruciatingly precise description.
+	 * lock and acquired our write lock, then this page may no longer be the
+	 * right place for the key we want to insert.  In this case, we need to
+	 * move right in the tree.	See Lehman and Yao for an excruciatingly
+	 * precise description.
 	 */
 	buf = _bt_moveright(rel, buf, natts, itup_scankey, false, BT_WRITE);
 
 	/*
-	 * If we're not allowing duplicates, make sure the key isn't already
-	 * in the index.
+	 * If we're not allowing duplicates, make sure the key isn't already in
+	 * the index.
 	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are
-	 * already in the index; so it cannot defend against concurrent
-	 * insertions of the same key.	We protect against that by means of
-	 * holding a write lock on the target page.  Any other would-be
-	 * inserter of the same key must acquire a write lock on the same
-	 * target page, so only one would-be inserter can be making the check
-	 * at one time.  Furthermore, once we are past the check we hold write
-	 * locks continuously until we have performed our insertion, so no
-	 * later inserter can fail to see our insertion.  (This requires some
-	 * care in _bt_insertonpg.)
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already in
+	 * the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the target page.  Any other would-be inserter of the same key must
+	 * acquire a write lock on the same target page, so only one would-be
+	 * inserter can be making the check at one time.  Furthermore, once we are
+	 * past the check we hold write locks continuously until we have performed
+	 * our insertion, so no later inserter can fail to see our insertion.
+	 * (This requires some care in _bt_insertonpg.)
 	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must start over completely.
+	 * If we must wait for another xact, we release the lock while waiting, and
+	 * then must start over completely.
 	 */
 	if (index_is_unique)
 	{
@@ -167,8 +166,8 @@ _bt_check_unique(Relation rel, BTItem btitem, Relation heapRel,
 	maxoff = PageGetMaxOffsetNumber(page);
 
 	/*
-	 * Find first item >= proposed new item.  Note we could also get a
-	 * pointer to end-of-page here.
+	 * Find first item >= proposed new item.  Note we could also get a pointer
+	 * to end-of-page here.
 	 */
 	offset = _bt_binsrch(rel, buf, natts, itup_scankey, false);
 
@@ -194,24 +193,24 @@ _bt_check_unique(Relation rel, BTItem btitem, Relation heapRel,
 			/*
 			 * We can skip items that are marked killed.
 			 *
-			 * Formerly, we applied _bt_isequal() before checking the kill
-			 * flag, so as to fall out of the item loop as soon as
-			 * possible. However, in the presence of heavy update activity
-			 * an index may contain many killed items with the same key;
-			 * running _bt_isequal() on each killed item gets expensive.
-			 * Furthermore it is likely that the non-killed version of
-			 * each key appears first, so that we didn't actually get to
-			 * exit any sooner anyway. So now we just advance over killed
-			 * items as quickly as we can. We only apply _bt_isequal()
-			 * when we get to a non-killed item or the end of the page.
+			 * Formerly, we applied _bt_isequal() before checking the kill flag,
+			 * so as to fall out of the item loop as soon as possible.
+			 * However, in the presence of heavy update activity an index may
+			 * contain many killed items with the same key; running
+			 * _bt_isequal() on each killed item gets expensive. Furthermore
+			 * it is likely that the non-killed version of each key appears
+			 * first, so that we didn't actually get to exit any sooner
+			 * anyway. So now we just advance over killed items as quickly as
+			 * we can. We only apply _bt_isequal() when we get to a non-killed
+			 * item or the end of the page.
 			 */
 			if (!ItemIdDeleted(curitemid))
 			{
 				/*
-				 * _bt_compare returns 0 for (1,NULL) and (1,NULL) -
-				 * this's how we handling NULLs - and so we must not use
-				 * _bt_compare in real comparison, but only for
-				 * ordering/finding items on pages. - vadim 03/24/97
+				 * _bt_compare returns 0 for (1,NULL) and (1,NULL) - this's
+				 * how we handling NULLs - and so we must not use _bt_compare
+				 * in real comparison, but only for ordering/finding items on
+				 * pages. - vadim 03/24/97
 				 */
 				if (!_bt_isequal(itupdesc, page, offset, natts, itup_scankey))
 					break;		/* we're past all the equal tuples */
@@ -246,15 +245,15 @@ _bt_check_unique(Relation rel, BTItem btitem, Relation heapRel,
 					 */
 					ereport(ERROR,
 							(errcode(ERRCODE_UNIQUE_VIOLATION),
-							 errmsg("duplicate key violates unique constraint \"%s\"",
-									RelationGetRelationName(rel))));
+					errmsg("duplicate key violates unique constraint \"%s\"",
+						   RelationGetRelationName(rel))));
 				}
 				else if (htup.t_data != NULL)
 				{
 					/*
-					 * Hmm, if we can't see the tuple, maybe it can be
-					 * marked killed.  This logic should match
-					 * index_getnext and btgettuple.
+					 * Hmm, if we can't see the tuple, maybe it can be marked
+					 * killed.	This logic should match index_getnext and
+					 * btgettuple.
 					 */
 					LockBuffer(hbuffer, BUFFER_LOCK_SHARE);
 					if (HeapTupleSatisfiesVacuum(htup.t_data, RecentGlobalXmin,
@@ -377,15 +376,15 @@ _bt_insertonpg(Relation rel,
 	itemsz = IndexTupleDSize(btitem->bti_itup)
 		+ (sizeof(BTItemData) - sizeof(IndexTupleData));
 
-	itemsz = MAXALIGN(itemsz);	/* be safe, PageAddItem will do this but
-								 * we need to be consistent */
+	itemsz = MAXALIGN(itemsz);	/* be safe, PageAddItem will do this but we
+								 * need to be consistent */
 
 	/*
-	 * Check whether the item can fit on a btree page at all. (Eventually,
-	 * we ought to try to apply TOAST methods if not.) We actually need to
-	 * be able to fit three items on every page, so restrict any one item
-	 * to 1/3 the per-page available space. Note that at this point,
-	 * itemsz doesn't include the ItemId.
+	 * Check whether the item can fit on a btree page at all. (Eventually, we
+	 * ought to try to apply TOAST methods if not.) We actually need to be
+	 * able to fit three items on every page, so restrict any one item to 1/3
+	 * the per-page available space. Note that at this point, itemsz doesn't
+	 * include the ItemId.
 	 */
 	if (itemsz > BTMaxItemSize(page))
 		ereport(ERROR,
@@ -393,9 +392,9 @@ _bt_insertonpg(Relation rel,
 				 errmsg("index row size %lu exceeds btree maximum, %lu",
 						(unsigned long) itemsz,
 						(unsigned long) BTMaxItemSize(page)),
-				 errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
-						 "Consider a function index of an MD5 hash of the value, "
-						 "or use full text indexing.")));
+		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
+				"Consider a function index of an MD5 hash of the value, "
+				"or use full text indexing.")));
 
 	/*
 	 * Determine exactly where new item will go.
@@ -432,11 +431,11 @@ _bt_insertonpg(Relation rel,
 			/*
 			 * step right to next non-dead page
 			 *
-			 * must write-lock that page before releasing write lock on
-			 * current page; else someone else's _bt_check_unique scan
-			 * could fail to see our insertion.  write locks on
-			 * intermediate dead pages won't do because we don't know when
-			 * they will get de-linked from the tree.
+			 * must write-lock that page before releasing write lock on current
+			 * page; else someone else's _bt_check_unique scan could fail to
+			 * see our insertion.  write locks on intermediate dead pages
+			 * won't do because we don't know when they will get de-linked
+			 * from the tree.
 			 */
 			Buffer		rbuf = InvalidBuffer;
 
@@ -459,9 +458,9 @@ _bt_insertonpg(Relation rel,
 		}
 
 		/*
-		 * Now we are on the right page, so find the insert position. If
-		 * we moved right at all, we know we should insert at the start of
-		 * the page, else must find the position by searching.
+		 * Now we are on the right page, so find the insert position. If we
+		 * moved right at all, we know we should insert at the start of the
+		 * page, else must find the position by searching.
 		 */
 		if (movedright)
 			newitemoff = P_FIRSTDATAKEY(lpageop);
@@ -472,9 +471,9 @@ _bt_insertonpg(Relation rel,
 	/*
 	 * Do we need to split the page to fit the item on it?
 	 *
-	 * Note: PageGetFreeSpace() subtracts sizeof(ItemIdData) from its result,
-	 * so this comparison is correct even though we appear to be
-	 * accounting only for the item and not for its line pointer.
+	 * Note: PageGetFreeSpace() subtracts sizeof(ItemIdData) from its result, so
+	 * this comparison is correct even though we appear to be accounting only
+	 * for the item and not for its line pointer.
 	 */
 	if (PageGetFreeSpace(page) < itemsz)
 	{
@@ -522,12 +521,11 @@ _bt_insertonpg(Relation rel,
 		itup_blkno = BufferGetBlockNumber(buf);
 
 		/*
-		 * If we are doing this insert because we split a page that was
-		 * the only one on its tree level, but was not the root, it may
-		 * have been the "fast root".  We need to ensure that the fast
-		 * root link points at or above the current page.  We can safely
-		 * acquire a lock on the metapage here --- see comments for
-		 * _bt_newroot().
+		 * If we are doing this insert because we split a page that was the
+		 * only one on its tree level, but was not the root, it may have been
+		 * the "fast root".  We need to ensure that the fast root link points
+		 * at or above the current page.  We can safely acquire a lock on the
+		 * metapage here --- see comments for _bt_newroot().
 		 */
 		if (split_only_page)
 		{
@@ -692,11 +690,11 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright,
 	lopaque->btpo.level = ropaque->btpo.level = oopaque->btpo.level;
 
 	/*
-	 * If the page we're splitting is not the rightmost page at its level
-	 * in the tree, then the first entry on the page is the high key for
-	 * the page.  We need to copy that to the right half.  Otherwise
-	 * (meaning the rightmost page case), all the items on the right half
-	 * will be user data.
+	 * If the page we're splitting is not the rightmost page at its level in
+	 * the tree, then the first entry on the page is the high key for the
+	 * page.  We need to copy that to the right half.  Otherwise (meaning the
+	 * rightmost page case), all the items on the right half will be user
+	 * data.
 	 */
 	rightoff = P_HIKEY;
 
@@ -712,9 +710,9 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright,
 	}
 
 	/*
-	 * The "high key" for the new left page will be the first key that's
-	 * going to go into the new right page.  This might be either the
-	 * existing data item at position firstright, or the incoming tuple.
+	 * The "high key" for the new left page will be the first key that's going
+	 * to go into the new right page.  This might be either the existing data
+	 * item at position firstright, or the incoming tuple.
 	 */
 	leftoff = P_HIKEY;
 	if (!newitemonleft && newitemoff == firstright)
@@ -806,8 +804,8 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright,
 	/*
 	 * We have to grab the right sibling (if any) and fix the prev pointer
 	 * there. We are guaranteed that this is deadlock-free since no other
-	 * writer will be holding a lock on that page and trying to move left,
-	 * and all readers release locks on a page before trying to fetch its
+	 * writer will be holding a lock on that page and trying to move left, and
+	 * all readers release locks on a page before trying to fetch its
 	 * neighbors.
 	 */
 
@@ -821,8 +819,8 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright,
 	}
 
 	/*
-	 * Right sibling is locked, new siblings are prepared, but original
-	 * page is not updated yet. Log changes before continuing.
+	 * Right sibling is locked, new siblings are prepared, but original page
+	 * is not updated yet. Log changes before continuing.
 	 *
 	 * NO EREPORT(ERROR) till right sibling is updated.
 	 */
@@ -850,10 +848,10 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright,
 		xlrec.level = lopaque->btpo.level;
 
 		/*
-		 * Direct access to page is not good but faster - we should
-		 * implement some new func in page API.  Note we only store the
-		 * tuples themselves, knowing that the item pointers are in the
-		 * same order and can be reconstructed by scanning the tuples.
+		 * Direct access to page is not good but faster - we should implement
+		 * some new func in page API.  Note we only store the tuples
+		 * themselves, knowing that the item pointers are in the same order
+		 * and can be reconstructed by scanning the tuples.
 		 */
 		xlrec.leftlen = ((PageHeader) leftpage)->pd_special -
 			((PageHeader) leftpage)->pd_upper;
@@ -903,13 +901,13 @@ _bt_split(Relation rel, Buffer buf, OffsetNumber firstright,
 	}
 
 	/*
-	 * By here, the original data page has been split into two new halves,
-	 * and these are correct.  The algorithm requires that the left page
-	 * never move during a split, so we copy the new left page back on top
-	 * of the original.  Note that this is not a waste of time, since we
-	 * also require (in the page management code) that the center of a
-	 * page always be clean, and the most efficient way to guarantee this
-	 * is just to compact the data by reinserting it into a new left page.
+	 * By here, the original data page has been split into two new halves, and
+	 * these are correct.  The algorithm requires that the left page never
+	 * move during a split, so we copy the new left page back on top of the
+	 * original.  Note that this is not a waste of time, since we also require
+	 * (in the page management code) that the center of a page always be
+	 * clean, and the most efficient way to guarantee this is just to compact
+	 * the data by reinserting it into a new left page.
 	 */
 
 	PageRestoreTempPage(leftpage, origpage);
@@ -984,13 +982,13 @@ _bt_findsplitloc(Relation rel,
 		MAXALIGN(sizeof(BTPageOpaqueData));
 
 	/*
-	 * Finding the best possible split would require checking all the
-	 * possible split points, because of the high-key and left-key special
-	 * cases. That's probably more work than it's worth; instead, stop as
-	 * soon as we find a "good-enough" split, where good-enough is defined
-	 * as an imbalance in free space of no more than pagesize/16
-	 * (arbitrary...) This should let us stop near the middle on most
-	 * pages, instead of plowing to the end.
+	 * Finding the best possible split would require checking all the possible
+	 * split points, because of the high-key and left-key special cases.
+	 * That's probably more work than it's worth; instead, stop as soon as we
+	 * find a "good-enough" split, where good-enough is defined as an
+	 * imbalance in free space of no more than pagesize/16 (arbitrary...) This
+	 * should let us stop near the middle on most pages, instead of plowing to
+	 * the end.
 	 */
 	goodenough = leftspace / 16;
 
@@ -1006,8 +1004,8 @@ _bt_findsplitloc(Relation rel,
 	dataitemtotal = rightspace - (int) PageGetFreeSpace(page);
 
 	/*
-	 * Scan through the data items and calculate space usage for a split
-	 * at each possible position.
+	 * Scan through the data items and calculate space usage for a split at
+	 * each possible position.
 	 */
 	dataitemstoleft = 0;
 	maxoff = PageGetMaxOffsetNumber(page);
@@ -1024,9 +1022,9 @@ _bt_findsplitloc(Relation rel,
 		itemsz = MAXALIGN(ItemIdGetLength(itemid)) + sizeof(ItemIdData);
 
 		/*
-		 * We have to allow for the current item becoming the high key of
-		 * the left page; therefore it counts against left space as well
-		 * as right space.
+		 * We have to allow for the current item becoming the high key of the
+		 * left page; therefore it counts against left space as well as right
+		 * space.
 		 */
 		leftfree = leftspace - dataitemstoleft - (int) itemsz;
 		rightfree = rightspace - (dataitemtotal - dataitemstoleft);
@@ -1058,8 +1056,8 @@ _bt_findsplitloc(Relation rel,
 	}
 
 	/*
-	 * I believe it is not possible to fail to find a feasible split, but
-	 * just in case ...
+	 * I believe it is not possible to fail to find a feasible split, but just
+	 * in case ...
 	 */
 	if (!state.have_split)
 		elog(ERROR, "could not find a feasible split point for \"%s\"",
@@ -1105,8 +1103,7 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright,
 		{
 			/*
 			 * On a rightmost page, try to equalize right free space with
-			 * twice the left free space.  See comments for
-			 * _bt_findsplitloc.
+			 * twice the left free space.  See comments for _bt_findsplitloc.
 			 */
 			delta = (2 * leftfree) - rightfree;
 		}
@@ -1153,19 +1150,18 @@ _bt_insert_parent(Relation rel,
 				  bool is_only)
 {
 	/*
-	 * Here we have to do something Lehman and Yao don't talk about: deal
-	 * with a root split and construction of a new root.  If our stack is
-	 * empty then we have just split a node on what had been the root
-	 * level when we descended the tree.  If it was still the root then we
-	 * perform a new-root construction.  If it *wasn't* the root anymore,
-	 * search to find the next higher level that someone constructed
-	 * meanwhile, and find the right place to insert as for the normal
-	 * case.
+	 * Here we have to do something Lehman and Yao don't talk about: deal with
+	 * a root split and construction of a new root.  If our stack is empty
+	 * then we have just split a node on what had been the root level when we
+	 * descended the tree.	If it was still the root then we perform a
+	 * new-root construction.  If it *wasn't* the root anymore, search to find
+	 * the next higher level that someone constructed meanwhile, and find the
+	 * right place to insert as for the normal case.
 	 *
-	 * If we have to search for the parent level, we do so by re-descending
-	 * from the root.  This is not super-efficient, but it's rare enough
-	 * not to matter.  (This path is also taken when called from WAL
-	 * recovery --- we have no stack in that case.)
+	 * If we have to search for the parent level, we do so by re-descending from
+	 * the root.  This is not super-efficient, but it's rare enough not to
+	 * matter.	(This path is also taken when called from WAL recovery --- we
+	 * have no stack in that case.)
 	 */
 	if (is_root)
 	{
@@ -1219,9 +1215,9 @@ _bt_insert_parent(Relation rel,
 		/*
 		 * Find the parent buffer and get the parent page.
 		 *
-		 * Oops - if we were moved right then we need to change stack item!
-		 * We want to find parent pointing to where we are, right ?    -
-		 * vadim 05/27/97
+		 * Oops - if we were moved right then we need to change stack item! We
+		 * want to find parent pointing to where we are, right ?	- vadim
+		 * 05/27/97
 		 */
 		ItemPointerSet(&(stack->bts_btitem.bti_itup.t_tid),
 					   bknum, P_HIKEY);
@@ -1291,9 +1287,9 @@ _bt_getstackbuf(Relation rel, BTStack stack, int access)
 			maxoff = PageGetMaxOffsetNumber(page);
 
 			/*
-			 * start = InvalidOffsetNumber means "search the whole page".
-			 * We need this test anyway due to possibility that page has a
-			 * high key now when it didn't before.
+			 * start = InvalidOffsetNumber means "search the whole page". We
+			 * need this test anyway due to possibility that page has a high
+			 * key now when it didn't before.
 			 */
 			if (start < minoff)
 				start = minoff;
@@ -1307,8 +1303,8 @@ _bt_getstackbuf(Relation rel, BTStack stack, int access)
 
 			/*
 			 * These loops will check every item on the page --- but in an
-			 * order that's attuned to the probability of where it
-			 * actually is.  Scan to the right first, then to the left.
+			 * order that's attuned to the probability of where it actually
+			 * is.	Scan to the right first, then to the left.
 			 */
 			for (offnum = start;
 				 offnum <= maxoff;
@@ -1424,9 +1420,9 @@ _bt_newroot(Relation rel, Buffer lbuf, Buffer rbuf)
 	metad->btm_fastlevel = rootopaque->btpo.level;
 
 	/*
-	 * Create downlink item for left page (old root).  Since this will be
-	 * the first item in a non-leaf page, it implicitly has minus-infinity
-	 * key value, so we need not store any actual key in it.
+	 * Create downlink item for left page (old root).  Since this will be the
+	 * first item in a non-leaf page, it implicitly has minus-infinity key
+	 * value, so we need not store any actual key in it.
 	 */
 	itemsz = sizeof(BTItemData);
 	new_item = (BTItem) palloc(itemsz);
@@ -1434,17 +1430,17 @@ _bt_newroot(Relation rel, Buffer lbuf, Buffer rbuf)
 	ItemPointerSet(&(new_item->bti_itup.t_tid), lbkno, P_HIKEY);
 
 	/*
-	 * Insert the left page pointer into the new root page.  The root page
-	 * is the rightmost page on its level so there is no "high key" in it;
-	 * the two items will go into positions P_HIKEY and P_FIRSTKEY.
+	 * Insert the left page pointer into the new root page.  The root page is
+	 * the rightmost page on its level so there is no "high key" in it; the
+	 * two items will go into positions P_HIKEY and P_FIRSTKEY.
 	 */
 	if (PageAddItem(rootpage, (Item) new_item, itemsz, P_HIKEY, LP_USED) == InvalidOffsetNumber)
 		elog(PANIC, "failed to add leftkey to new root page");
 	pfree(new_item);
 
 	/*
-	 * Create downlink item for right page.  The key for it is obtained
-	 * from the "high key" position in the left page.
+	 * Create downlink item for right page.  The key for it is obtained from
+	 * the "high key" position in the left page.
 	 */
 	itemid = PageGetItemId(lpage, P_HIKEY);
 	itemsz = ItemIdGetLength(itemid);
@@ -1476,8 +1472,8 @@ _bt_newroot(Relation rel, Buffer lbuf, Buffer rbuf)
 		rdata[0].next = &(rdata[1]);
 
 		/*
-		 * Direct access to page is not good but faster - we should
-		 * implement some new func in page API.
+		 * Direct access to page is not good but faster - we should implement
+		 * some new func in page API.
 		 */
 		rdata[1].data = (char *) rootpage + ((PageHeader) rootpage)->pd_upper;
 		rdata[1].len = ((PageHeader) rootpage)->pd_special -
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 718998b72a..915ecbc771 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -115,8 +115,8 @@ _bt_initmetapage(Page page, BlockNumber rootbknum, uint32 level)
 	metaopaque->btpo_flags = BTP_META;
 
 	/*
-	 * Set pd_lower just past the end of the metadata.  This is not
-	 * essential but it makes the page look compressible to xlog.c.
+	 * Set pd_lower just past the end of the metadata.	This is not essential
+	 * but it makes the page look compressible to xlog.c.
 	 */
 	((PageHeader) page)->pd_lower =
 		((char *) metad + sizeof(BTMetaPageData)) - (char *) page;
@@ -198,26 +198,26 @@ _bt_getroot(Relation rel, int access)
 		LockBuffer(metabuf, BT_WRITE);
 
 		/*
-		 * Race condition:	if someone else initialized the metadata
-		 * between the time we released the read lock and acquired the
-		 * write lock, we must avoid doing it again.
+		 * Race condition:	if someone else initialized the metadata between
+		 * the time we released the read lock and acquired the write lock, we
+		 * must avoid doing it again.
 		 */
 		if (metad->btm_root != P_NONE)
 		{
 			/*
-			 * Metadata initialized by someone else.  In order to
-			 * guarantee no deadlocks, we have to release the metadata
-			 * page and start all over again.  (Is that really true? But
-			 * it's hardly worth trying to optimize this case.)
+			 * Metadata initialized by someone else.  In order to guarantee no
+			 * deadlocks, we have to release the metadata page and start all
+			 * over again.	(Is that really true? But it's hardly worth trying
+			 * to optimize this case.)
 			 */
 			_bt_relbuf(rel, metabuf);
 			return _bt_getroot(rel, access);
 		}
 
 		/*
-		 * Get, initialize, write, and leave a lock of the appropriate
-		 * type on the new root page.  Since this is the first page in the
-		 * tree, it's a leaf as well as the root.
+		 * Get, initialize, write, and leave a lock of the appropriate type on
+		 * the new root page.  Since this is the first page in the tree, it's
+		 * a leaf as well as the root.
 		 */
 		rootbuf = _bt_getbuf(rel, P_NEW, BT_WRITE);
 		rootblkno = BufferGetBlockNumber(rootbuf);
@@ -266,9 +266,9 @@ _bt_getroot(Relation rel, int access)
 		_bt_wrtnorelbuf(rel, rootbuf);
 
 		/*
-		 * swap root write lock for read lock.	There is no danger of
-		 * anyone else accessing the new root page while it's unlocked,
-		 * since no one else knows where it is yet.
+		 * swap root write lock for read lock.	There is no danger of anyone
+		 * else accessing the new root page while it's unlocked, since no one
+		 * else knows where it is yet.
 		 */
 		LockBuffer(rootbuf, BUFFER_LOCK_UNLOCK);
 		LockBuffer(rootbuf, BT_READ);
@@ -312,8 +312,8 @@ _bt_getroot(Relation rel, int access)
 	}
 
 	/*
-	 * By here, we have a pin and read lock on the root page, and no lock
-	 * set on the metadata page.  Return the root page's buffer.
+	 * By here, we have a pin and read lock on the root page, and no lock set
+	 * on the metadata page.  Return the root page's buffer.
 	 */
 	return rootbuf;
 }
@@ -435,27 +435,26 @@ _bt_getbuf(Relation rel, BlockNumber blkno, int access)
 		/*
 		 * First see if the FSM knows of any free pages.
 		 *
-		 * We can't trust the FSM's report unreservedly; we have to check
-		 * that the page is still free.  (For example, an already-free
-		 * page could have been re-used between the time the last VACUUM
-		 * scanned it and the time the VACUUM made its FSM updates.)
+		 * We can't trust the FSM's report unreservedly; we have to check that
+		 * the page is still free.	(For example, an already-free page could
+		 * have been re-used between the time the last VACUUM scanned it and
+		 * the time the VACUUM made its FSM updates.)
 		 *
-		 * In fact, it's worse than that: we can't even assume that it's safe
-		 * to take a lock on the reported page.  If somebody else has a
-		 * lock on it, or even worse our own caller does, we could
-		 * deadlock.  (The own-caller scenario is actually not improbable.
-		 * Consider an index on a serial or timestamp column.  Nearly all
-		 * splits will be at the rightmost page, so it's entirely likely
-		 * that _bt_split will call us while holding a lock on the page
-		 * most recently acquired from FSM.  A VACUUM running concurrently
-		 * with the previous split could well have placed that page back
-		 * in FSM.)
+		 * In fact, it's worse than that: we can't even assume that it's safe to
+		 * take a lock on the reported page.  If somebody else has a lock on
+		 * it, or even worse our own caller does, we could deadlock.  (The
+		 * own-caller scenario is actually not improbable. Consider an index
+		 * on a serial or timestamp column.  Nearly all splits will be at the
+		 * rightmost page, so it's entirely likely that _bt_split will call us
+		 * while holding a lock on the page most recently acquired from FSM.
+		 * A VACUUM running concurrently with the previous split could well
+		 * have placed that page back in FSM.)
 		 *
-		 * To get around that, we ask for only a conditional lock on the
-		 * reported page.  If we fail, then someone else is using the
-		 * page, and we may reasonably assume it's not free.  (If we
-		 * happen to be wrong, the worst consequence is the page will be
-		 * lost to use till the next VACUUM, which is no big problem.)
+		 * To get around that, we ask for only a conditional lock on the reported
+		 * page.  If we fail, then someone else is using the page, and we may
+		 * reasonably assume it's not free.  (If we happen to be wrong, the
+		 * worst consequence is the page will be lost to use till the next
+		 * VACUUM, which is no big problem.)
 		 */
 		for (;;)
 		{
@@ -486,10 +485,10 @@ _bt_getbuf(Relation rel, BlockNumber blkno, int access)
 		/*
 		 * Extend the relation by one page.
 		 *
-		 * We have to use a lock to ensure no one else is extending the rel
-		 * at the same time, else we will both try to initialize the same
-		 * new page.  We can skip locking for new or temp relations,
-		 * however, since no one else could be accessing them.
+		 * We have to use a lock to ensure no one else is extending the rel at
+		 * the same time, else we will both try to initialize the same new
+		 * page.  We can skip locking for new or temp relations, however,
+		 * since no one else could be accessing them.
 		 */
 		needLock = !RELATION_IS_LOCAL(rel);
 
@@ -504,8 +503,8 @@ _bt_getbuf(Relation rel, BlockNumber blkno, int access)
 		/*
 		 * Release the file-extension lock; it's now OK for someone else to
 		 * extend the relation some more.  Note that we cannot release this
-		 * lock before we have buffer lock on the new page, or we risk a
-		 * race condition against btvacuumcleanup --- see comments therein.
+		 * lock before we have buffer lock on the new page, or we risk a race
+		 * condition against btvacuumcleanup --- see comments therein.
 		 */
 		if (needLock)
 			UnlockRelationForExtension(rel, ExclusiveLock);
@@ -614,10 +613,10 @@ _bt_page_recyclable(Page page)
 	BTPageOpaque opaque;
 
 	/*
-	 * It's possible to find an all-zeroes page in an index --- for
-	 * example, a backend might successfully extend the relation one page
-	 * and then crash before it is able to make a WAL entry for adding the
-	 * page. If we find a zeroed page then reclaim it.
+	 * It's possible to find an all-zeroes page in an index --- for example, a
+	 * backend might successfully extend the relation one page and then crash
+	 * before it is able to make a WAL entry for adding the page. If we find a
+	 * zeroed page then reclaim it.
 	 */
 	if (PageIsNew(page))
 		return true;
@@ -672,9 +671,9 @@ _bt_delitems(Relation rel, Buffer buf,
 		rdata[0].next = &(rdata[1]);
 
 		/*
-		 * The target-offsets array is not in the buffer, but pretend that
-		 * it is.  When XLogInsert stores the whole buffer, the offsets
-		 * array need not be stored too.
+		 * The target-offsets array is not in the buffer, but pretend that it
+		 * is.	When XLogInsert stores the whole buffer, the offsets array
+		 * need not be stored too.
 		 */
 		if (nitems > 0)
 		{
@@ -747,8 +746,8 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 	BTPageOpaque opaque;
 
 	/*
-	 * We can never delete rightmost pages nor root pages.	While at it,
-	 * check that page is not already deleted and is empty.
+	 * We can never delete rightmost pages nor root pages.	While at it, check
+	 * that page is not already deleted and is empty.
 	 */
 	page = BufferGetPage(buf);
 	opaque = (BTPageOpaque) PageGetSpecialPointer(page);
@@ -760,8 +759,8 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 	}
 
 	/*
-	 * Save info about page, including a copy of its high key (it must
-	 * have one, being non-rightmost).
+	 * Save info about page, including a copy of its high key (it must have
+	 * one, being non-rightmost).
 	 */
 	target = BufferGetBlockNumber(buf);
 	targetlevel = opaque->btpo.level;
@@ -770,11 +769,11 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 	targetkey = CopyBTItem((BTItem) PageGetItem(page, itemid));
 
 	/*
-	 * We need to get an approximate pointer to the page's parent page.
-	 * Use the standard search mechanism to search for the page's high
-	 * key; this will give us a link to either the current parent or
-	 * someplace to its left (if there are multiple equal high keys).  To
-	 * avoid deadlocks, we'd better drop the target page lock first.
+	 * We need to get an approximate pointer to the page's parent page. Use
+	 * the standard search mechanism to search for the page's high key; this
+	 * will give us a link to either the current parent or someplace to its
+	 * left (if there are multiple equal high keys).  To avoid deadlocks, we'd
+	 * better drop the target page lock first.
 	 */
 	_bt_relbuf(rel, buf);
 	/* we need a scan key to do our search, so build one */
@@ -786,9 +785,8 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 	_bt_relbuf(rel, lbuf);
 
 	/*
-	 * If we are trying to delete an interior page, _bt_search did more
-	 * than we needed.	Locate the stack item pointing to our parent
-	 * level.
+	 * If we are trying to delete an interior page, _bt_search did more than
+	 * we needed.  Locate the stack item pointing to our parent level.
 	 */
 	ilevel = 0;
 	for (;;)
@@ -803,16 +801,15 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 
 	/*
 	 * We have to lock the pages we need to modify in the standard order:
-	 * moving right, then up.  Else we will deadlock against other
-	 * writers.
+	 * moving right, then up.  Else we will deadlock against other writers.
 	 *
-	 * So, we need to find and write-lock the current left sibling of the
-	 * target page.  The sibling that was current a moment ago could have
-	 * split, so we may have to move right.  This search could fail if
-	 * either the sibling or the target page was deleted by someone else
-	 * meanwhile; if so, give up.  (Right now, that should never happen,
-	 * since page deletion is only done in VACUUM and there shouldn't be
-	 * multiple VACUUMs concurrently on the same table.)
+	 * So, we need to find and write-lock the current left sibling of the target
+	 * page.  The sibling that was current a moment ago could have split, so
+	 * we may have to move right.  This search could fail if either the
+	 * sibling or the target page was deleted by someone else meanwhile; if
+	 * so, give up.  (Right now, that should never happen, since page deletion
+	 * is only done in VACUUM and there shouldn't be multiple VACUUMs
+	 * concurrently on the same table.)
 	 */
 	if (leftsib != P_NONE)
 	{
@@ -839,19 +836,18 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 		lbuf = InvalidBuffer;
 
 	/*
-	 * Next write-lock the target page itself.	It should be okay to take
-	 * just a write lock not a superexclusive lock, since no scans would
-	 * stop on an empty page.
+	 * Next write-lock the target page itself.	It should be okay to take just
+	 * a write lock not a superexclusive lock, since no scans would stop on an
+	 * empty page.
 	 */
 	buf = _bt_getbuf(rel, target, BT_WRITE);
 	page = BufferGetPage(buf);
 	opaque = (BTPageOpaque) PageGetSpecialPointer(page);
 
 	/*
-	 * Check page is still empty etc, else abandon deletion.  The empty
-	 * check is necessary since someone else might have inserted into it
-	 * while we didn't have it locked; the others are just for paranoia's
-	 * sake.
+	 * Check page is still empty etc, else abandon deletion.  The empty check
+	 * is necessary since someone else might have inserted into it while we
+	 * didn't have it locked; the others are just for paranoia's sake.
 	 */
 	if (P_RIGHTMOST(opaque) || P_ISROOT(opaque) || P_ISDELETED(opaque) ||
 		P_FIRSTDATAKEY(opaque) <= PageGetMaxOffsetNumber(page))
@@ -872,9 +868,8 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 	rbuf = _bt_getbuf(rel, rightsib, BT_WRITE);
 
 	/*
-	 * Next find and write-lock the current parent of the target page.
-	 * This is essentially the same as the corresponding step of
-	 * splitting.
+	 * Next find and write-lock the current parent of the target page. This is
+	 * essentially the same as the corresponding step of splitting.
 	 */
 	ItemPointerSet(&(stack->bts_btitem.bti_itup.t_tid),
 				   target, P_HIKEY);
@@ -887,8 +882,8 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 
 	/*
 	 * If the target is the rightmost child of its parent, then we can't
-	 * delete, unless it's also the only child --- in which case the
-	 * parent changes to half-dead status.
+	 * delete, unless it's also the only child --- in which case the parent
+	 * changes to half-dead status.
 	 */
 	page = BufferGetPage(pbuf);
 	opaque = (BTPageOpaque) PageGetSpecialPointer(page);
@@ -917,11 +912,10 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 	}
 
 	/*
-	 * If we are deleting the next-to-last page on the target's level,
-	 * then the rightsib is a candidate to become the new fast root. (In
-	 * theory, it might be possible to push the fast root even further
-	 * down, but the odds of doing so are slim, and the locking
-	 * considerations daunting.)
+	 * If we are deleting the next-to-last page on the target's level, then
+	 * the rightsib is a candidate to become the new fast root. (In theory, it
+	 * might be possible to push the fast root even further down, but the odds
+	 * of doing so are slim, and the locking considerations daunting.)
 	 *
 	 * We can safely acquire a lock on the metapage here --- see comments for
 	 * _bt_newroot().
@@ -939,9 +933,9 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 			metad = BTPageGetMeta(metapg);
 
 			/*
-			 * The expected case here is btm_fastlevel == targetlevel+1;
-			 * if the fastlevel is <= targetlevel, something is wrong, and
-			 * we choose to overwrite it to fix it.
+			 * The expected case here is btm_fastlevel == targetlevel+1; if
+			 * the fastlevel is <= targetlevel, something is wrong, and we
+			 * choose to overwrite it to fix it.
 			 */
 			if (metad->btm_fastlevel > targetlevel + 1)
 			{
@@ -961,9 +955,9 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 
 	/*
 	 * Update parent.  The normal case is a tad tricky because we want to
-	 * delete the target's downlink and the *following* key.  Easiest way
-	 * is to copy the right sibling's downlink over the target downlink,
-	 * and then delete the following item.
+	 * delete the target's downlink and the *following* key.  Easiest way is
+	 * to copy the right sibling's downlink over the target downlink, and then
+	 * delete the following item.
 	 */
 	page = BufferGetPage(pbuf);
 	opaque = (BTPageOpaque) PageGetSpecialPointer(page);
@@ -992,8 +986,8 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 	}
 
 	/*
-	 * Update siblings' side-links.  Note the target page's side-links
-	 * will continue to point to the siblings.
+	 * Update siblings' side-links.  Note the target page's side-links will
+	 * continue to point to the siblings.
 	 */
 	if (BufferIsValid(lbuf))
 	{
@@ -1123,10 +1117,10 @@ _bt_pagedel(Relation rel, Buffer buf, bool vacuum_full)
 		_bt_wrtbuf(rel, lbuf);
 
 	/*
-	 * If parent became half dead, recurse to try to delete it. Otherwise,
-	 * if right sibling is empty and is now the last child of the parent,
-	 * recurse to try to delete it.  (These cases cannot apply at the same
-	 * time, though the second case might itself recurse to the first.)
+	 * If parent became half dead, recurse to try to delete it. Otherwise, if
+	 * right sibling is empty and is now the last child of the parent, recurse
+	 * to try to delete it.  (These cases cannot apply at the same time,
+	 * though the second case might itself recurse to the first.)
 	 */
 	if (parent_half_dead)
 	{
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index a6dd9d3e93..ccacf23851 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -39,9 +39,9 @@ typedef struct
 	BTSpool    *spool;
 
 	/*
-	 * spool2 is needed only when the index is an unique index. Dead
-	 * tuples are put into spool2 instead of spool in order to avoid
-	 * uniqueness check.
+	 * spool2 is needed only when the index is an unique index. Dead tuples
+	 * are put into spool2 instead of spool in order to avoid uniqueness
+	 * check.
 	 */
 	BTSpool    *spool2;
 	double		indtuples;
@@ -72,10 +72,10 @@ btbuild(PG_FUNCTION_ARGS)
 	BTBuildState buildstate;
 
 	/*
-	 * bootstrap processing does something strange, so don't use
-	 * sort/build for initial catalog indices.	at some point i need to
-	 * look harder at this.  (there is some kind of incremental processing
-	 * going on there.) -- pma 08/29/95
+	 * bootstrap processing does something strange, so don't use sort/build
+	 * for initial catalog indices.  at some point i need to look harder at
+	 * this.  (there is some kind of incremental processing going on there.)
+	 * -- pma 08/29/95
 	 */
 	buildstate.usefast = (FastBuild && IsNormalProcessingMode());
 	buildstate.isUnique = indexInfo->ii_Unique;
@@ -91,8 +91,8 @@ btbuild(PG_FUNCTION_ARGS)
 #endif   /* BTREE_BUILD_STATS */
 
 	/*
-	 * We expect to be called exactly once for any index relation. If
-	 * that's not the case, big trouble's what we have.
+	 * We expect to be called exactly once for any index relation. If that's
+	 * not the case, big trouble's what we have.
 	 */
 	if (RelationGetNumberOfBlocks(index) != 0)
 		elog(ERROR, "index \"%s\" already contains data",
@@ -103,8 +103,8 @@ btbuild(PG_FUNCTION_ARGS)
 		buildstate.spool = _bt_spoolinit(index, indexInfo->ii_Unique, false);
 
 		/*
-		 * If building a unique index, put dead tuples in a second spool
-		 * to keep them out of the uniqueness check.
+		 * If building a unique index, put dead tuples in a second spool to
+		 * keep them out of the uniqueness check.
 		 */
 		if (indexInfo->ii_Unique)
 			buildstate.spool2 = _bt_spoolinit(index, false, true);
@@ -129,8 +129,8 @@ btbuild(PG_FUNCTION_ARGS)
 
 	/*
 	 * if we are doing bottom-up btree build, finish the build by (1)
-	 * completing the sort of the spool file, (2) inserting the sorted
-	 * tuples into btree pages and (3) building the upper levels.
+	 * completing the sort of the spool file, (2) inserting the sorted tuples
+	 * into btree pages and (3) building the upper levels.
 	 */
 	if (buildstate.usefast)
 	{
@@ -176,9 +176,8 @@ btbuildCallback(Relation index,
 	btitem = _bt_formitem(itup);
 
 	/*
-	 * if we are doing bottom-up btree build, we insert the index into a
-	 * spool file for subsequent processing.  otherwise, we insert into
-	 * the btree.
+	 * if we are doing bottom-up btree build, we insert the index into a spool
+	 * file for subsequent processing.	otherwise, we insert into the btree.
 	 */
 	if (buildstate->usefast)
 	{
@@ -248,16 +247,16 @@ btgettuple(PG_FUNCTION_ARGS)
 	bool		res;
 
 	/*
-	 * If we've already initialized this scan, we can just advance it in
-	 * the appropriate direction.  If we haven't done so yet, we call a
-	 * routine to get the first item in the scan.
+	 * If we've already initialized this scan, we can just advance it in the
+	 * appropriate direction.  If we haven't done so yet, we call a routine to
+	 * get the first item in the scan.
 	 */
 	if (ItemPointerIsValid(&(scan->currentItemData)))
 	{
 		/*
-		 * Restore scan position using heap TID returned by previous call
-		 * to btgettuple(). _bt_restscan() re-grabs the read lock on the
-		 * buffer, too.
+		 * Restore scan position using heap TID returned by previous call to
+		 * btgettuple(). _bt_restscan() re-grabs the read lock on the buffer,
+		 * too.
 		 */
 		_bt_restscan(scan);
 
@@ -267,17 +266,16 @@ btgettuple(PG_FUNCTION_ARGS)
 		if (scan->kill_prior_tuple)
 		{
 			/*
-			 * Yes, so mark it by setting the LP_DELETE bit in the item
-			 * flags.
+			 * Yes, so mark it by setting the LP_DELETE bit in the item flags.
 			 */
 			offnum = ItemPointerGetOffsetNumber(&(scan->currentItemData));
 			page = BufferGetPage(so->btso_curbuf);
 			PageGetItemId(page, offnum)->lp_flags |= LP_DELETE;
 
 			/*
-			 * Since this can be redone later if needed, it's treated the
-			 * same as a commit-hint-bit status update for heap tuples: we
-			 * mark the buffer dirty but don't make a WAL log entry.
+			 * Since this can be redone later if needed, it's treated the same
+			 * as a commit-hint-bit status update for heap tuples: we mark the
+			 * buffer dirty but don't make a WAL log entry.
 			 */
 			SetBufferCommitInfoNeedsSave(so->btso_curbuf);
 		}
@@ -306,11 +304,11 @@ btgettuple(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Save heap TID to use it in _bt_restscan.  Then release the read
-	 * lock on the buffer so that we aren't blocking other backends.
+	 * Save heap TID to use it in _bt_restscan.  Then release the read lock on
+	 * the buffer so that we aren't blocking other backends.
 	 *
-	 * NOTE: we do keep the pin on the buffer!	This is essential to ensure
-	 * that someone else doesn't delete the index entry we are stopped on.
+	 * NOTE: we do keep the pin on the buffer!	This is essential to ensure that
+	 * someone else doesn't delete the index entry we are stopped on.
 	 */
 	if (res)
 	{
@@ -333,7 +331,7 @@ Datum
 btgetmulti(PG_FUNCTION_ARGS)
 {
 	IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
-	ItemPointer	tids = (ItemPointer) PG_GETARG_POINTER(1);
+	ItemPointer tids = (ItemPointer) PG_GETARG_POINTER(1);
 	int32		max_tids = PG_GETARG_INT32(2);
 	int32	   *returned_tids = (int32 *) PG_GETARG_POINTER(3);
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
@@ -355,6 +353,7 @@ btgetmulti(PG_FUNCTION_ARGS)
 			res = _bt_next(scan, ForwardScanDirection);
 		else
 			res = _bt_first(scan, ForwardScanDirection);
+
 		/*
 		 * Skip killed tuples if asked to.
 		 */
@@ -381,8 +380,8 @@ btgetmulti(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Save heap TID to use it in _bt_restscan.  Then release the read
-	 * lock on the buffer so that we aren't blocking other backends.
+	 * Save heap TID to use it in _bt_restscan.  Then release the read lock on
+	 * the buffer so that we aren't blocking other backends.
 	 */
 	if (res)
 	{
@@ -456,8 +455,8 @@ btrescan(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Reset the scan keys. Note that keys ordering stuff moved to
-	 * _bt_first.	   - vadim 05/05/97
+	 * Reset the scan keys. Note that keys ordering stuff moved to _bt_first.
+	 * - vadim 05/05/97
 	 */
 	if (scankey && scan->numberOfKeys > 0)
 		memmove(scan->keyData,
@@ -593,21 +592,20 @@ btbulkdelete(PG_FUNCTION_ARGS)
 	num_index_tuples = 0;
 
 	/*
-	 * The outer loop iterates over index leaf pages, the inner over items
-	 * on a leaf page.	We issue just one _bt_delitems() call per page, so
-	 * as to minimize WAL traffic.
+	 * The outer loop iterates over index leaf pages, the inner over items on
+	 * a leaf page.  We issue just one _bt_delitems() call per page, so as to
+	 * minimize WAL traffic.
 	 *
 	 * Note that we exclusive-lock every leaf page containing data items, in
-	 * sequence left to right.	It sounds attractive to only
-	 * exclusive-lock those containing items we need to delete, but
-	 * unfortunately that is not safe: we could then pass a stopped
-	 * indexscan, which could in rare cases lead to deleting the item it
-	 * needs to find when it resumes.  (See _bt_restscan --- this could
-	 * only happen if an indexscan stops on a deletable item and then a
-	 * page split moves that item into a page further to its right, which
-	 * the indexscan will have no pin on.)	We can skip obtaining
-	 * exclusive lock on empty pages though, since no indexscan could be
-	 * stopped on those.
+	 * sequence left to right.	It sounds attractive to only exclusive-lock
+	 * those containing items we need to delete, but unfortunately that is not
+	 * safe: we could then pass a stopped indexscan, which could in rare cases
+	 * lead to deleting the item it needs to find when it resumes.	(See
+	 * _bt_restscan --- this could only happen if an indexscan stops on a
+	 * deletable item and then a page split moves that item into a page
+	 * further to its right, which the indexscan will have no pin on.)	We can
+	 * skip obtaining exclusive lock on empty pages though, since no indexscan
+	 * could be stopped on those.
 	 */
 	buf = _bt_get_endpoint(rel, 0, false);
 	if (BufferIsValid(buf))		/* check for empty index */
@@ -632,15 +630,15 @@ btbulkdelete(PG_FUNCTION_ARGS)
 			if (minoff <= maxoff && !P_ISDELETED(opaque))
 			{
 				/*
-				 * Trade in the initial read lock for a super-exclusive
-				 * write lock on this page.
+				 * Trade in the initial read lock for a super-exclusive write
+				 * lock on this page.
 				 */
 				LockBuffer(buf, BUFFER_LOCK_UNLOCK);
 				LockBufferForCleanup(buf);
 
 				/*
-				 * Recompute minoff/maxoff, both of which could have
-				 * changed while we weren't holding the lock.
+				 * Recompute minoff/maxoff, both of which could have changed
+				 * while we weren't holding the lock.
 				 */
 				minoff = P_FIRSTDATAKEY(opaque);
 				maxoff = PageGetMaxOffsetNumber(page);
@@ -657,7 +655,7 @@ btbulkdelete(PG_FUNCTION_ARGS)
 					ItemPointer htup;
 
 					btitem = (BTItem) PageGetItem(page,
-											PageGetItemId(page, offnum));
+												PageGetItemId(page, offnum));
 					htup = &(btitem->bti_itup.t_tid);
 					if (callback(htup, callback_state))
 					{
@@ -670,8 +668,8 @@ btbulkdelete(PG_FUNCTION_ARGS)
 			}
 
 			/*
-			 * If we need to delete anything, do it and write the buffer;
-			 * else just release the buffer.
+			 * If we need to delete anything, do it and write the buffer; else
+			 * just release the buffer.
 			 */
 			nextpage = opaque->btpo_next;
 			if (ndeletable > 0)
@@ -725,19 +723,19 @@ btvacuumcleanup(PG_FUNCTION_ARGS)
 	Assert(stats != NULL);
 
 	/*
-	 * First find out the number of pages in the index.  We must acquire
-	 * the relation-extension lock while doing this to avoid a race
-	 * condition: if someone else is extending the relation, there is
-	 * a window where bufmgr/smgr have created a new all-zero page but
-	 * it hasn't yet been write-locked by _bt_getbuf().  If we manage to
-	 * scan such a page here, we'll improperly assume it can be recycled.
-	 * Taking the lock synchronizes things enough to prevent a problem:
-	 * either num_pages won't include the new page, or _bt_getbuf already
-	 * has write lock on the buffer and it will be fully initialized before
-	 * we can examine it.  (See also vacuumlazy.c, which has the same issue.)
+	 * First find out the number of pages in the index.  We must acquire the
+	 * relation-extension lock while doing this to avoid a race condition: if
+	 * someone else is extending the relation, there is a window where
+	 * bufmgr/smgr have created a new all-zero page but it hasn't yet been
+	 * write-locked by _bt_getbuf().  If we manage to scan such a page here,
+	 * we'll improperly assume it can be recycled. Taking the lock
+	 * synchronizes things enough to prevent a problem: either num_pages won't
+	 * include the new page, or _bt_getbuf already has write lock on the
+	 * buffer and it will be fully initialized before we can examine it.  (See
+	 * also vacuumlazy.c, which has the same issue.)
 	 *
-	 * We can skip locking for new or temp relations,
-	 * however, since no one else could be accessing them.
+	 * We can skip locking for new or temp relations, however, since no one else
+	 * could be accessing them.
 	 */
 	needLock = !RELATION_IS_LOCAL(rel);
 
@@ -807,12 +805,12 @@ btvacuumcleanup(PG_FUNCTION_ARGS)
 
 			/*
 			 * During VACUUM FULL it's okay to recycle deleted pages
-			 * immediately, since there can be no other transactions
-			 * scanning the index.	Note that we will only recycle the
-			 * current page and not any parent pages that _bt_pagedel
-			 * might have recursed to; this seems reasonable in the name
-			 * of simplicity.  (Trying to do otherwise would mean we'd
-			 * have to sort the list of recyclable pages we're building.)
+			 * immediately, since there can be no other transactions scanning
+			 * the index.  Note that we will only recycle the current page and
+			 * not any parent pages that _bt_pagedel might have recursed to;
+			 * this seems reasonable in the name of simplicity.  (Trying to do
+			 * otherwise would mean we'd have to sort the list of recyclable
+			 * pages we're building.)
 			 */
 			if (ndel && info->vacuum_full)
 			{
@@ -827,10 +825,10 @@ btvacuumcleanup(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * During VACUUM FULL, we truncate off any recyclable pages at the end
-	 * of the index.  In a normal vacuum it'd be unsafe to do this except
-	 * by acquiring exclusive lock on the index and then rechecking all
-	 * the pages; doesn't seem worth it.
+	 * During VACUUM FULL, we truncate off any recyclable pages at the end of
+	 * the index.  In a normal vacuum it'd be unsafe to do this except by
+	 * acquiring exclusive lock on the index and then rechecking all the
+	 * pages; doesn't seem worth it.
 	 */
 	if (info->vacuum_full && nFreePages > 0)
 	{
@@ -857,9 +855,9 @@ btvacuumcleanup(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Update the shared Free Space Map with the info we now have about
-	 * free pages in the index, discarding any old info the map may have.
-	 * We do not need to sort the page numbers; they're in order already.
+	 * Update the shared Free Space Map with the info we now have about free
+	 * pages in the index, discarding any old info the map may have. We do not
+	 * need to sort the page numbers; they're in order already.
 	 */
 	RecordIndexFreeSpace(&rel->rd_node, nFreePages, freePages);
 
@@ -915,15 +913,15 @@ _bt_restscan(IndexScanDesc scan)
 	opaque = (BTPageOpaque) PageGetSpecialPointer(page);
 
 	/*
-	 * We use this as flag when first index tuple on page is deleted but
-	 * we do not move left (this would slowdown vacuum) - so we set
+	 * We use this as flag when first index tuple on page is deleted but we do
+	 * not move left (this would slowdown vacuum) - so we set
 	 * current->ip_posid before first index tuple on the current page
 	 * (_bt_step will move it right)...  XXX still needed?
 	 */
 	if (!ItemPointerIsValid(target))
 	{
 		ItemPointerSetOffsetNumber(current,
-							   OffsetNumberPrev(P_FIRSTDATAKEY(opaque)));
+								   OffsetNumberPrev(P_FIRSTDATAKEY(opaque)));
 		return;
 	}
 
@@ -948,12 +946,12 @@ _bt_restscan(IndexScanDesc scan)
 		}
 
 		/*
-		 * The item we're looking for moved right at least one page, so
-		 * move right.	We are careful here to pin and read-lock the next
-		 * non-dead page before releasing the current one.	This ensures
-		 * that a concurrent btbulkdelete scan cannot pass our position
-		 * --- if it did, it might be able to reach and delete our target
-		 * item before we can find it again.
+		 * The item we're looking for moved right at least one page, so move
+		 * right.  We are careful here to pin and read-lock the next non-dead
+		 * page before releasing the current one.  This ensures that a
+		 * concurrent btbulkdelete scan cannot pass our position --- if it
+		 * did, it might be able to reach and delete our target item before we
+		 * can find it again.
 		 */
 		if (P_RIGHTMOST(opaque))
 			elog(ERROR, "failed to re-find previous key in \"%s\"",
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c80d54e5ac..a6c92a0c30 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -69,9 +69,9 @@ _bt_search(Relation rel, int keysz, ScanKey scankey, bool nextkey,
 		BTStack		new_stack;
 
 		/*
-		 * Race -- the page we just grabbed may have split since we read
-		 * its pointer in the parent (or metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
+		 * Race -- the page we just grabbed may have split since we read its
+		 * pointer in the parent (or metapage).  If it has, we may need to
+		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, *bufP, keysz, scankey, nextkey, BT_READ);
 
@@ -82,8 +82,8 @@ _bt_search(Relation rel, int keysz, ScanKey scankey, bool nextkey,
 			break;
 
 		/*
-		 * Find the appropriate item on the internal page, and get the
-		 * child page that it points to.
+		 * Find the appropriate item on the internal page, and get the child
+		 * page that it points to.
 		 */
 		offnum = _bt_binsrch(rel, *bufP, keysz, scankey, nextkey);
 		itemid = PageGetItemId(page, offnum);
@@ -94,13 +94,13 @@ _bt_search(Relation rel, int keysz, ScanKey scankey, bool nextkey,
 
 		/*
 		 * We need to save the location of the index entry we chose in the
-		 * parent page on a stack. In case we split the tree, we'll use
-		 * the stack to work back up to the parent page.  We also save the
-		 * actual downlink (TID) to uniquely identify the index entry, in
-		 * case it moves right while we're working lower in the tree.  See
-		 * the paper by Lehman and Yao for how this is detected and
-		 * handled. (We use the child link to disambiguate duplicate keys
-		 * in the index -- Lehman and Yao disallow duplicate keys.)
+		 * parent page on a stack. In case we split the tree, we'll use the
+		 * stack to work back up to the parent page.  We also save the actual
+		 * downlink (TID) to uniquely identify the index entry, in case it
+		 * moves right while we're working lower in the tree.  See the paper
+		 * by Lehman and Yao for how this is detected and handled. (We use the
+		 * child link to disambiguate duplicate keys in the index -- Lehman
+		 * and Yao disallow duplicate keys.)
 		 */
 		new_stack = (BTStack) palloc(sizeof(BTStackData));
 		new_stack->bts_blkno = par_blkno;
@@ -156,19 +156,18 @@ _bt_moveright(Relation rel,
 	opaque = (BTPageOpaque) PageGetSpecialPointer(page);
 
 	/*
-	 * When nextkey = false (normal case): if the scan key that brought us
-	 * to this page is > the high key stored on the page, then the page
-	 * has split and we need to move right.  (If the scan key is equal to
-	 * the high key, we might or might not need to move right; have to
-	 * scan the page first anyway.)
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (If the scan key is equal to the high key,
+	 * we might or might not need to move right; have to scan the page first
+	 * anyway.)
 	 *
 	 * When nextkey = true: move right if the scan key is >= page's high key.
 	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
+	 * The page could even have split more than once, so scan as far as needed.
 	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
+	 * We also have to move right if we followed a link that brought us to a dead
+	 * page.
 	 */
 	cmpval = nextkey ? 0 : 1;
 
@@ -242,24 +241,24 @@ _bt_binsrch(Relation rel,
 	high = PageGetMaxOffsetNumber(page);
 
 	/*
-	 * If there are no keys on the page, return the first available slot.
-	 * Note this covers two cases: the page is really empty (no keys), or
-	 * it contains only a high key.  The latter case is possible after
-	 * vacuuming.  This can never happen on an internal page, however,
-	 * since they are never empty (an internal page must have children).
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
 	 */
 	if (high < low)
 		return low;
 
 	/*
-	 * Binary search to find the first key on the page >= scan key, or
-	 * first key > scankey when nextkey is true.
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
 	 *
 	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
 	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
 	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before 'low'
+	 * are <= scan key, all slots at or after 'high' are > scan key.
 	 *
 	 * We can fall out when high == low.
 	 */
@@ -285,15 +284,15 @@ _bt_binsrch(Relation rel,
 	 * At this point we have high == low, but be careful: they could point
 	 * past the last slot on the page.
 	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
+	 * On a leaf page, we always return the first key >= scan key (resp. > scan
+	 * key), which could be the last slot + 1.
 	 */
 	if (P_ISLEAF(opaque))
 		return low;
 
 	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan
-	 * key). There must be one if _bt_compare() is playing by the rules.
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
 	 */
 	Assert(low > P_FIRSTDATAKEY(opaque));
 
@@ -337,8 +336,8 @@ _bt_compare(Relation rel,
 	int			i;
 
 	/*
-	 * Force result ">" if target item is first data item on an internal
-	 * page --- see NOTE above.
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
 	 */
 	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
 		return 1;
@@ -347,15 +346,15 @@ _bt_compare(Relation rel,
 	itup = &(btitem->bti_itup);
 
 	/*
-	 * The scan key is set up with the attribute number associated with
-	 * each term in the key.  It is important that, if the index is
-	 * multi-key, the scan contain the first k key attributes, and that
-	 * they be in order.  If you think about how multi-key ordering works,
-	 * you'll understand why this is.
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.	If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
 	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right
-	 * (see _bt_first).
+	 * We don't test for violation of this condition here, however.  The initial
+	 * setup for the index scan had better have gotten it right (see
+	 * _bt_first).
 	 */
 
 	for (i = 1; i <= keysz; i++)
@@ -381,15 +380,15 @@ _bt_compare(Relation rel,
 		else
 		{
 			/*
-			 * The sk_func needs to be passed the index value as left arg
-			 * and the sk_argument as right arg (they might be of
-			 * different types).  Since it is convenient for callers to
-			 * think of _bt_compare as comparing the scankey to the index
-			 * item, we have to flip the sign of the comparison result.
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).	Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.
 			 *
-			 * Note: curious-looking coding is to avoid overflow if
-			 * comparison function returns INT_MIN.  There is no risk of
-			 * overflow for positive results.
+			 * Note: curious-looking coding is to avoid overflow if comparison
+			 * function returns INT_MIN.  There is no risk of overflow for
+			 * positive results.
 			 */
 			result = DatumGetInt32(FunctionCall2(&scankey->sk_func,
 												 datum,
@@ -497,7 +496,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	bool		goback;
 	bool		continuescan;
 	ScanKey		startKeys[INDEX_MAX_KEYS];
-	ScanKeyData	scankeys[INDEX_MAX_KEYS];
+	ScanKeyData scankeys[INDEX_MAX_KEYS];
 	int			keysCount = 0;
 	int			i;
 	StrategyNumber strat_total;
@@ -505,8 +504,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	pgstat_count_index_scan(&scan->xs_pgstat_info);
 
 	/*
-	 * Examine the scan keys and eliminate any redundant keys; also
-	 * discover how many keys must be matched to continue the scan.
+	 * Examine the scan keys and eliminate any redundant keys; also discover
+	 * how many keys must be matched to continue the scan.
 	 */
 	_bt_preprocess_keys(scan);
 
@@ -556,9 +555,9 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 		ScanKey		cur;
 
 		/*
-		 * chosen is the so-far-chosen key for the current attribute, if
-		 * any. We don't cast the decision in stone until we reach keys
-		 * for the next attribute.
+		 * chosen is the so-far-chosen key for the current attribute, if any.
+		 * We don't cast the decision in stone until we reach keys for the
+		 * next attribute.
 		 */
 		curattr = 1;
 		chosen = NULL;
@@ -595,9 +594,9 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 				}
 
 				/*
-				 * Done if that was the last attribute, or if next key
-				 * is not in sequence (implying no boundary key is available
-				 * for the next attribute).
+				 * Done if that was the last attribute, or if next key is not
+				 * in sequence (implying no boundary key is available for the
+				 * next attribute).
 				 */
 				if (i >= so->numberOfKeys ||
 					cur->sk_attno != curattr + 1)
@@ -632,17 +631,17 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	}
 
 	/*
-	 * If we found no usable boundary keys, we have to start from one end
-	 * of the tree.  Walk down that edge to the first or last key, and
-	 * scan from there.
+	 * If we found no usable boundary keys, we have to start from one end of
+	 * the tree.  Walk down that edge to the first or last key, and scan from
+	 * there.
 	 */
 	if (keysCount == 0)
 		return _bt_endpoint(scan, dir);
 
 	/*
 	 * We want to start the scan somewhere within the index.  Set up a
-	 * 3-way-comparison scankey we can use to search for the boundary
-	 * point we identified above.
+	 * 3-way-comparison scankey we can use to search for the boundary point we
+	 * identified above.
 	 */
 	Assert(keysCount <= INDEX_MAX_KEYS);
 	for (i = 0; i < keysCount; i++)
@@ -650,16 +649,15 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 		ScanKey		cur = startKeys[i];
 
 		/*
-		 * _bt_preprocess_keys disallows it, but it's place to add some
-		 * code later
+		 * _bt_preprocess_keys disallows it, but it's place to add some code
+		 * later
 		 */
 		if (cur->sk_flags & SK_ISNULL)
 			elog(ERROR, "btree doesn't support is(not)null, yet");
 
 		/*
-		 * If scankey operator is of default subtype, we can use the
-		 * cached comparison procedure; otherwise gotta look it up in the
-		 * catalogs.
+		 * If scankey operator is of default subtype, we can use the cached
+		 * comparison procedure; otherwise gotta look it up in the catalogs.
 		 */
 		if (cur->sk_subtype == InvalidOid)
 		{
@@ -692,13 +690,13 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	}
 
 	/*
-	 * Examine the selected initial-positioning strategy to determine
-	 * exactly where we need to start the scan, and set flag variables to
-	 * control the code below.
+	 * Examine the selected initial-positioning strategy to determine exactly
+	 * where we need to start the scan, and set flag variables to control the
+	 * code below.
 	 *
-	 * If nextkey = false, _bt_search and _bt_binsrch will locate the first
-	 * item >= scan key.  If nextkey = true, they will locate the first
-	 * item > scan key.
+	 * If nextkey = false, _bt_search and _bt_binsrch will locate the first item
+	 * >= scan key.  If nextkey = true, they will locate the first item > scan
+	 * key.
 	 *
 	 * If goback = true, we will then step back one item, while if goback =
 	 * false, we will start the scan on the located item.
@@ -710,10 +708,10 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 		case BTLessStrategyNumber:
 
 			/*
-			 * Find first item >= scankey, then back up one to arrive at
-			 * last item < scankey.  (Note: this positioning strategy is
-			 * only used for a backward scan, so that is always the
-			 * correct starting position.)
+			 * Find first item >= scankey, then back up one to arrive at last
+			 * item < scankey.	(Note: this positioning strategy is only used
+			 * for a backward scan, so that is always the correct starting
+			 * position.)
 			 */
 			nextkey = false;
 			goback = true;
@@ -722,10 +720,10 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 		case BTLessEqualStrategyNumber:
 
 			/*
-			 * Find first item > scankey, then back up one to arrive at
-			 * last item <= scankey.  (Note: this positioning strategy is
-			 * only used for a backward scan, so that is always the
-			 * correct starting position.)
+			 * Find first item > scankey, then back up one to arrive at last
+			 * item <= scankey.  (Note: this positioning strategy is only used
+			 * for a backward scan, so that is always the correct starting
+			 * position.)
 			 */
 			nextkey = true;
 			goback = true;
@@ -734,14 +732,14 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 		case BTEqualStrategyNumber:
 
 			/*
-			 * If a backward scan was specified, need to start with last
-			 * equal item not first one.
+			 * If a backward scan was specified, need to start with last equal
+			 * item not first one.
 			 */
 			if (ScanDirectionIsBackward(dir))
 			{
 				/*
-				 * This is the same as the <= strategy.  We will check at
-				 * the end whether the found item is actually =.
+				 * This is the same as the <= strategy.  We will check at the
+				 * end whether the found item is actually =.
 				 */
 				nextkey = true;
 				goback = true;
@@ -749,8 +747,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 			else
 			{
 				/*
-				 * This is the same as the >= strategy.  We will check at
-				 * the end whether the found item is actually =.
+				 * This is the same as the >= strategy.  We will check at the
+				 * end whether the found item is actually =.
 				 */
 				nextkey = false;
 				goback = false;
@@ -813,24 +811,24 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	ItemPointerSet(current, blkno, offnum);
 
 	/*
-	 * If nextkey = false, we are positioned at the first item >= scan
-	 * key, or possibly at the end of a page on which all the existing
-	 * items are less than the scan key and we know that everything on
-	 * later pages is greater than or equal to scan key.
+	 * If nextkey = false, we are positioned at the first item >= scan key, or
+	 * possibly at the end of a page on which all the existing items are less
+	 * than the scan key and we know that everything on later pages is greater
+	 * than or equal to scan key.
 	 *
 	 * If nextkey = true, we are positioned at the first item > scan key, or
-	 * possibly at the end of a page on which all the existing items are
-	 * less than or equal to the scan key and we know that everything on
-	 * later pages is greater than scan key.
+	 * possibly at the end of a page on which all the existing items are less
+	 * than or equal to the scan key and we know that everything on later
+	 * pages is greater than scan key.
 	 *
-	 * The actually desired starting point is either this item or the prior
-	 * one, or in the end-of-page case it's the first item on the next
-	 * page or the last item on this page.	We apply _bt_step if needed to
-	 * get to the right place.
+	 * The actually desired starting point is either this item or the prior one,
+	 * or in the end-of-page case it's the first item on the next page or the
+	 * last item on this page.	We apply _bt_step if needed to get to the
+	 * right place.
 	 *
 	 * If _bt_step fails (meaning we fell off the end of the index in one
-	 * direction or the other), then there are no matches so we just
-	 * return false.
+	 * direction or the other), then there are no matches so we just return
+	 * false.
 	 */
 	if (goback)
 	{
@@ -902,8 +900,8 @@ _bt_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir)
 	BlockNumber blkno;
 
 	/*
-	 * Don't use ItemPointerGetOffsetNumber or you risk to get assertion
-	 * due to ability of ip_posid to be equal 0.
+	 * Don't use ItemPointerGetOffsetNumber or you risk to get assertion due
+	 * to ability of ip_posid to be equal 0.
 	 */
 	offnum = current->ip_posid;
 
@@ -954,9 +952,9 @@ _bt_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir)
 			/*
 			 * Walk left to the next page with data.  This is much more
 			 * complex than the walk-right case because of the possibility
-			 * that the page to our left splits while we are in flight to
-			 * it, plus the possibility that the page we were on gets
-			 * deleted after we leave it.  See nbtree/README for details.
+			 * that the page to our left splits while we are in flight to it,
+			 * plus the possibility that the page we were on gets deleted
+			 * after we leave it.  See nbtree/README for details.
 			 */
 			for (;;)
 			{
@@ -973,9 +971,9 @@ _bt_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir)
 				opaque = (BTPageOpaque) PageGetSpecialPointer(page);
 
 				/*
-				 * Okay, we managed to move left to a non-deleted page.
-				 * Done if it's not half-dead and not empty.  Else loop
-				 * back and do it all again.
+				 * Okay, we managed to move left to a non-deleted page. Done
+				 * if it's not half-dead and not empty.  Else loop back and do
+				 * it all again.
 				 */
 				if (!P_IGNORE(opaque))
 				{
@@ -1043,15 +1041,14 @@ _bt_walk_left(Relation rel, Buffer buf)
 
 		/*
 		 * If this isn't the page we want, walk right till we find what we
-		 * want --- but go no more than four hops (an arbitrary limit). If
-		 * we don't find the correct page by then, the most likely bet is
-		 * that the original page got deleted and isn't in the sibling
-		 * chain at all anymore, not that its left sibling got split more
-		 * than four times.
+		 * want --- but go no more than four hops (an arbitrary limit). If we
+		 * don't find the correct page by then, the most likely bet is that
+		 * the original page got deleted and isn't in the sibling chain at all
+		 * anymore, not that its left sibling got split more than four times.
 		 *
-		 * Note that it is correct to test P_ISDELETED not P_IGNORE here,
-		 * because half-dead pages are still in the sibling chain.	Caller
-		 * must reject half-dead pages if wanted.
+		 * Note that it is correct to test P_ISDELETED not P_IGNORE here, because
+		 * half-dead pages are still in the sibling chain.	Caller must reject
+		 * half-dead pages if wanted.
 		 */
 		tries = 0;
 		for (;;)
@@ -1077,9 +1074,9 @@ _bt_walk_left(Relation rel, Buffer buf)
 		{
 			/*
 			 * It was deleted.	Move right to first nondeleted page (there
-			 * must be one); that is the page that has acquired the
-			 * deleted one's keyspace, so stepping left from it will take
-			 * us where we want to be.
+			 * must be one); that is the page that has acquired the deleted
+			 * one's keyspace, so stepping left from it will take us where we
+			 * want to be.
 			 */
 			for (;;)
 			{
@@ -1095,16 +1092,16 @@ _bt_walk_left(Relation rel, Buffer buf)
 			}
 
 			/*
-			 * Now return to top of loop, resetting obknum to point to
-			 * this nondeleted page, and try again.
+			 * Now return to top of loop, resetting obknum to point to this
+			 * nondeleted page, and try again.
 			 */
 		}
 		else
 		{
 			/*
-			 * It wasn't deleted; the explanation had better be that the
-			 * page to the left got split or deleted. Without this check,
-			 * we'd go into an infinite loop if there's anything wrong.
+			 * It wasn't deleted; the explanation had better be that the page
+			 * to the left got split or deleted. Without this check, we'd go
+			 * into an infinite loop if there's anything wrong.
 			 */
 			if (opaque->btpo_prev == lblkno)
 				elog(ERROR, "could not find left sibling in \"%s\"",
@@ -1137,8 +1134,8 @@ _bt_get_endpoint(Relation rel, uint32 level, bool rightmost)
 
 	/*
 	 * If we are looking for a leaf page, okay to descend from fast root;
-	 * otherwise better descend from true root.  (There is no point in
-	 * being smarter about intermediate levels.)
+	 * otherwise better descend from true root.  (There is no point in being
+	 * smarter about intermediate levels.)
 	 */
 	if (level == 0)
 		buf = _bt_getroot(rel, BT_READ);
@@ -1159,8 +1156,8 @@ _bt_get_endpoint(Relation rel, uint32 level, bool rightmost)
 		/*
 		 * If we landed on a deleted page, step right to find a live page
 		 * (there must be one).  Also, if we want the rightmost page, step
-		 * right if needed to get to it (this could happen if the page
-		 * split since we obtained a pointer to it).
+		 * right if needed to get to it (this could happen if the page split
+		 * since we obtained a pointer to it).
 		 */
 		while (P_IGNORE(opaque) ||
 			   (rightmost && !P_RIGHTMOST(opaque)))
@@ -1228,9 +1225,9 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	so = (BTScanOpaque) scan->opaque;
 
 	/*
-	 * Scan down to the leftmost or rightmost leaf page.  This is a
-	 * simplified version of _bt_search().	We don't maintain a stack
-	 * since we know we won't need it.
+	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
+	 * version of _bt_search().  We don't maintain a stack since we know we
+	 * won't need it.
 	 */
 	buf = _bt_get_endpoint(rel, 0, ScanDirectionIsBackward(dir));
 
@@ -1261,8 +1258,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 		Assert(P_RIGHTMOST(opaque));
 
 		start = PageGetMaxOffsetNumber(page);
-		if (start < P_FIRSTDATAKEY(opaque))		/* watch out for empty
-												 * page */
+		if (start < P_FIRSTDATAKEY(opaque))		/* watch out for empty page */
 			start = P_FIRSTDATAKEY(opaque);
 	}
 	else
@@ -1276,8 +1272,8 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	so->btso_curbuf = buf;
 
 	/*
-	 * Left/rightmost page could be empty due to deletions, if so step
-	 * till we find a nonempty page.
+	 * Left/rightmost page could be empty due to deletions, if so step till we
+	 * find a nonempty page.
 	 */
 	if (start > maxoff)
 	{
@@ -1291,8 +1287,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	itup = &(btitem->bti_itup);
 
 	/*
-	 * Okay, we are on the first or last tuple.  Does it pass all the
-	 * quals?
+	 * Okay, we are on the first or last tuple.  Does it pass all the quals?
 	 */
 	if (_bt_checkkeys(scan, itup, dir, &continuescan))
 	{
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 742c180c35..d421c629ec 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -99,12 +99,10 @@ typedef struct BTPageState
 {
 	Page		btps_page;		/* workspace for page building */
 	BlockNumber btps_blkno;		/* block # to write this page at */
-	BTItem		btps_minkey;	/* copy of minimum key (first item) on
-								 * page */
+	BTItem		btps_minkey;	/* copy of minimum key (first item) on page */
 	OffsetNumber btps_lastoff;	/* last item offset loaded */
 	uint32		btps_level;		/* tree level (0 = leaf) */
-	Size		btps_full;		/* "full" if less than this much free
-								 * space */
+	Size		btps_full;		/* "full" if less than this much free space */
 	struct BTPageState *btps_next;		/* link to parent level, if any */
 } BTPageState;
 
@@ -157,21 +155,21 @@ _bt_spoolinit(Relation index, bool isunique, bool isdead)
 	btspool->isunique = isunique;
 
 	/*
-	 * We size the sort area as maintenance_work_mem rather than work_mem
-	 * to speed index creation.  This should be OK since a single backend
-	 * can't run multiple index creations in parallel.  Note that creation
-	 * of a unique index actually requires two BTSpool objects.  We expect
-	 * that the second one (for dead tuples) won't get very full, so we
-	 * give it only work_mem.
+	 * We size the sort area as maintenance_work_mem rather than work_mem to
+	 * speed index creation.  This should be OK since a single backend can't
+	 * run multiple index creations in parallel.  Note that creation of a
+	 * unique index actually requires two BTSpool objects.	We expect that the
+	 * second one (for dead tuples) won't get very full, so we give it only
+	 * work_mem.
 	 */
 	btKbytes = isdead ? work_mem : maintenance_work_mem;
 	btspool->sortstate = tuplesort_begin_index(index, isunique,
 											   btKbytes, false);
 
 	/*
-	 * Currently, tuplesort provides sort functions on IndexTuples. If we
-	 * kept anything in a BTItem other than a regular IndexTuple, we'd
-	 * need to modify tuplesort to understand BTItems as such.
+	 * Currently, tuplesort provides sort functions on IndexTuples. If we kept
+	 * anything in a BTItem other than a regular IndexTuple, we'd need to
+	 * modify tuplesort to understand BTItems as such.
 	 */
 	Assert(sizeof(BTItemData) == sizeof(IndexTupleData));
 
@@ -222,8 +220,8 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 	wstate.index = btspool->index;
 
 	/*
-	 * We need to log index creation in WAL iff WAL archiving is enabled
-	 * AND it's not a temp index.
+	 * We need to log index creation in WAL iff WAL archiving is enabled AND
+	 * it's not a temp index.
 	 */
 	wstate.btws_use_wal = XLogArchivingActive() && !wstate.index->rd_istemp;
 
@@ -313,9 +311,9 @@ _bt_blwritepage(BTWriteState *wstate, Page page, BlockNumber blkno)
 	/*
 	 * If we have to write pages nonsequentially, fill in the space with
 	 * zeroes until we come back and overwrite.  This is not logically
-	 * necessary on standard Unix filesystems (unwritten space will read
-	 * as zeroes anyway), but it should help to avoid fragmentation. The
-	 * dummy pages aren't WAL-logged though.
+	 * necessary on standard Unix filesystems (unwritten space will read as
+	 * zeroes anyway), but it should help to avoid fragmentation. The dummy
+	 * pages aren't WAL-logged though.
 	 */
 	while (blkno > wstate->btws_pages_written)
 	{
@@ -328,8 +326,8 @@ _bt_blwritepage(BTWriteState *wstate, Page page, BlockNumber blkno)
 
 	/*
 	 * Now write the page.	We say isTemp = true even if it's not a temp
-	 * index, because there's no need for smgr to schedule an fsync for
-	 * this write; we'll do it ourselves before ending the build.
+	 * index, because there's no need for smgr to schedule an fsync for this
+	 * write; we'll do it ourselves before ending the build.
 	 */
 	smgrwrite(wstate->index->rd_smgr, blkno, (char *) page, true);
 
@@ -483,15 +481,15 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, BTItem bti)
 	btisz = MAXALIGN(btisz);
 
 	/*
-	 * Check whether the item can fit on a btree page at all. (Eventually,
-	 * we ought to try to apply TOAST methods if not.) We actually need to
-	 * be able to fit three items on every page, so restrict any one item
-	 * to 1/3 the per-page available space. Note that at this point, btisz
-	 * doesn't include the ItemId.
+	 * Check whether the item can fit on a btree page at all. (Eventually, we
+	 * ought to try to apply TOAST methods if not.) We actually need to be
+	 * able to fit three items on every page, so restrict any one item to 1/3
+	 * the per-page available space. Note that at this point, btisz doesn't
+	 * include the ItemId.
 	 *
-	 * NOTE: similar code appears in _bt_insertonpg() to defend against
-	 * oversize items being inserted into an already-existing index. But
-	 * during creation of an index, we don't go through there.
+	 * NOTE: similar code appears in _bt_insertonpg() to defend against oversize
+	 * items being inserted into an already-existing index. But during
+	 * creation of an index, we don't go through there.
 	 */
 	if (btisz > BTMaxItemSize(npage))
 		ereport(ERROR,
@@ -499,9 +497,9 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, BTItem bti)
 				 errmsg("index row size %lu exceeds btree maximum, %lu",
 						(unsigned long) btisz,
 						(unsigned long) BTMaxItemSize(npage)),
-				 errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
-						 "Consider a function index of an MD5 hash of the value, "
-						 "or use full text indexing.")));
+		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
+				"Consider a function index of an MD5 hash of the value, "
+				"or use full text indexing.")));
 
 	if (pgspc < btisz || pgspc < state->btps_full)
 	{
@@ -523,11 +521,11 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, BTItem bti)
 
 		/*
 		 * We copy the last item on the page into the new page, and then
-		 * rearrange the old page so that the 'last item' becomes its high
-		 * key rather than a true data item.  There had better be at least
-		 * two items on the page already, else the page would be empty of
-		 * useful data.  (Hence, we must allow pages to be packed at least
-		 * 2/3rds full; the 70% figure used above is close to minimum.)
+		 * rearrange the old page so that the 'last item' becomes its high key
+		 * rather than a true data item.  There had better be at least two
+		 * items on the page already, else the page would be empty of useful
+		 * data.  (Hence, we must allow pages to be packed at least 2/3rds
+		 * full; the 70% figure used above is close to minimum.)
 		 */
 		Assert(last_off > P_FIRSTKEY);
 		ii = PageGetItemId(opage, last_off);
@@ -544,8 +542,8 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, BTItem bti)
 
 		/*
 		 * Link the old page into its parent, using its minimum key. If we
-		 * don't have a parent, we have to create one; this adds a new
-		 * btree level.
+		 * don't have a parent, we have to create one; this adds a new btree
+		 * level.
 		 */
 		if (state->btps_next == NULL)
 			state->btps_next = _bt_pagestate(wstate, state->btps_level + 1);
@@ -557,9 +555,9 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, BTItem bti)
 		pfree(state->btps_minkey);
 
 		/*
-		 * Save a copy of the minimum key for the new page.  We have to
-		 * copy it off the old page, not the new one, in case we are not
-		 * at leaf level.
+		 * Save a copy of the minimum key for the new page.  We have to copy
+		 * it off the old page, not the new one, in case we are not at leaf
+		 * level.
 		 */
 		state->btps_minkey = _bt_formitem(&(obti->bti_itup));
 
@@ -576,8 +574,8 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, BTItem bti)
 		}
 
 		/*
-		 * Write out the old page.	We never need to touch it again, so we
-		 * can free the opage workspace too.
+		 * Write out the old page.	We never need to touch it again, so we can
+		 * free the opage workspace too.
 		 */
 		_bt_blwritepage(wstate, opage, oblkno);
 
@@ -588,10 +586,10 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, BTItem bti)
 	}
 
 	/*
-	 * If the new item is the first for its page, stash a copy for later.
-	 * Note this will only happen for the first item on a level; on later
-	 * pages, the first item for a page is copied from the prior page in
-	 * the code above.
+	 * If the new item is the first for its page, stash a copy for later. Note
+	 * this will only happen for the first item on a level; on later pages,
+	 * the first item for a page is copied from the prior page in the code
+	 * above.
 	 */
 	if (last_off == P_HIKEY)
 	{
@@ -636,9 +634,9 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 		 * We have to link the last page on this level to somewhere.
 		 *
 		 * If we're at the top, it's the root, so attach it to the metapage.
-		 * Otherwise, add an entry for it to its parent using its minimum
-		 * key.  This may cause the last page of the parent level to
-		 * split, but that's not a problem -- we haven't gotten to it yet.
+		 * Otherwise, add an entry for it to its parent using its minimum key.
+		 * This may cause the last page of the parent level to split, but
+		 * that's not a problem -- we haven't gotten to it yet.
 		 */
 		if (s->btps_next == NULL)
 		{
@@ -657,8 +655,8 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 		}
 
 		/*
-		 * This is the rightmost page, so the ItemId array needs to be
-		 * slid back one slot.	Then we can dump out the page.
+		 * This is the rightmost page, so the ItemId array needs to be slid
+		 * back one slot.  Then we can dump out the page.
 		 */
 		_bt_slideleft(s->btps_page);
 		_bt_blwritepage(wstate, s->btps_page, s->btps_blkno);
@@ -667,9 +665,9 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 
 	/*
 	 * As the last step in the process, construct the metapage and make it
-	 * point to the new root (unless we had no data at all, in which case
-	 * it's set to point to "P_NONE").  This changes the index to the
-	 * "valid" state by filling in a valid magic number in the metapage.
+	 * point to the new root (unless we had no data at all, in which case it's
+	 * set to point to "P_NONE").  This changes the index to the "valid" state
+	 * by filling in a valid magic number in the metapage.
 	 */
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, rootblkno, rootlevel);
@@ -748,7 +746,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 
 						compare = DatumGetInt32(FunctionCall2(&entry->sk_func,
 															  attrDatum1,
-															attrDatum2));
+															  attrDatum2));
 						if (compare > 0)
 						{
 							load1 = false;
@@ -772,7 +770,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				if (should_free)
 					pfree(bti);
 				bti = (BTItem) tuplesort_getindextuple(btspool->sortstate,
-													 true, &should_free);
+													   true, &should_free);
 			}
 			else
 			{
@@ -780,7 +778,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				if (should_free2)
 					pfree(bti2);
 				bti2 = (BTItem) tuplesort_getindextuple(btspool2->sortstate,
-													true, &should_free2);
+														true, &should_free2);
 			}
 		}
 		_bt_freeskey(indexScanKey);
@@ -789,7 +787,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 	{
 		/* merge is unnecessary */
 		while ((bti = (BTItem) tuplesort_getindextuple(btspool->sortstate,
-											true, &should_free)) != NULL)
+												true, &should_free)) != NULL)
 		{
 			/* When we see first tuple, create first index page */
 			if (state == NULL)
@@ -805,19 +803,19 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 	_bt_uppershutdown(wstate, state);
 
 	/*
-	 * If the index isn't temp, we must fsync it down to disk before it's
-	 * safe to commit the transaction.	(For a temp index we don't care
-	 * since the index will be uninteresting after a crash anyway.)
+	 * If the index isn't temp, we must fsync it down to disk before it's safe
+	 * to commit the transaction.  (For a temp index we don't care since the
+	 * index will be uninteresting after a crash anyway.)
 	 *
 	 * It's obvious that we must do this when not WAL-logging the build. It's
 	 * less obvious that we have to do it even if we did WAL-log the index
-	 * pages.  The reason is that since we're building outside shared
-	 * buffers, a CHECKPOINT occurring during the build has no way to
-	 * flush the previously written data to disk (indeed it won't know the
-	 * index even exists).	A crash later on would replay WAL from the
-	 * checkpoint, therefore it wouldn't replay our earlier WAL entries.
-	 * If we do not fsync those pages here, they might still not be on
-	 * disk when the crash occurs.
+	 * pages.  The reason is that since we're building outside shared buffers,
+	 * a CHECKPOINT occurring during the build has no way to flush the
+	 * previously written data to disk (indeed it won't know the index even
+	 * exists).  A crash later on would replay WAL from the checkpoint,
+	 * therefore it wouldn't replay our earlier WAL entries. If we do not
+	 * fsync those pages here, they might still not be on disk when the crash
+	 * occurs.
 	 */
 	if (!wstate->index->rd_istemp)
 		smgrimmedsync(wstate->index->rd_smgr);
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 2975e372df..90606a8a98 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -48,8 +48,8 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		bool		null;
 
 		/*
-		 * We can use the cached (default) support procs since no
-		 * cross-type comparison can be needed.
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
 		 */
 		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
 		arg = index_getattr(itup, i + 1, itupdesc, &null);
@@ -93,8 +93,8 @@ _bt_mkscankey_nodata(Relation rel)
 		FmgrInfo   *procinfo;
 
 		/*
-		 * We can use the cached (default) support procs since no
-		 * cross-type comparison can be needed.
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
 		 */
 		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
 		ScanKeyEntryInitializeWithInfo(&skey[i],
@@ -257,9 +257,9 @@ _bt_preprocess_keys(IndexScanDesc scan)
 	if (numberOfKeys == 1)
 	{
 		/*
-		 * We don't use indices for 'A is null' and 'A is not null'
-		 * currently and 'A < = > <> NULL' will always fail - so qual is
-		 * not OK if comparison value is NULL.		- vadim 03/21/97
+		 * We don't use indices for 'A is null' and 'A is not null' currently
+		 * and 'A < = > <> NULL' will always fail - so qual is not OK if
+		 * comparison value is NULL.	  - vadim 03/21/97
 		 */
 		if (cur->sk_flags & SK_ISNULL)
 			so->qual_ok = false;
@@ -286,20 +286,20 @@ _bt_preprocess_keys(IndexScanDesc scan)
 	/*
 	 * Initialize for processing of keys for attr 1.
 	 *
-	 * xform[i] points to the currently best scan key of strategy type i+1,
-	 * if any is found with a default operator subtype; it is NULL if we
-	 * haven't yet found such a key for this attr.  Scan keys of
-	 * nondefault subtypes are transferred to the output with no
-	 * processing except for noting if they are of "=" type.
+	 * xform[i] points to the currently best scan key of strategy type i+1, if
+	 * any is found with a default operator subtype; it is NULL if we haven't
+	 * yet found such a key for this attr.	Scan keys of nondefault subtypes
+	 * are transferred to the output with no processing except for noting if
+	 * they are of "=" type.
 	 */
 	attno = 1;
 	memset(xform, 0, sizeof(xform));
 	hasOtherTypeEqual = false;
 
 	/*
-	 * Loop iterates from 0 to numberOfKeys inclusive; we use the last
-	 * pass to handle after-last-key processing.  Actual exit from the
-	 * loop is at the "break" statement below.
+	 * Loop iterates from 0 to numberOfKeys inclusive; we use the last pass to
+	 * handle after-last-key processing.  Actual exit from the loop is at the
+	 * "break" statement below.
 	 */
 	for (i = 0;; cur++, i++)
 	{
@@ -319,8 +319,8 @@ _bt_preprocess_keys(IndexScanDesc scan)
 		}
 
 		/*
-		 * If we are at the end of the keys for a particular attr, finish
-		 * up processing and emit the cleaned-up keys.
+		 * If we are at the end of the keys for a particular attr, finish up
+		 * processing and emit the cleaned-up keys.
 		 */
 		if (i == numberOfKeys || cur->sk_attno != attno)
 		{
@@ -331,9 +331,9 @@ _bt_preprocess_keys(IndexScanDesc scan)
 				elog(ERROR, "btree index keys must be ordered by attribute");
 
 			/*
-			 * If = has been specified, no other key will be used. In case
-			 * of key > 2 && key == 1 and so on we have to set qual_ok to
-			 * false before discarding the other keys.
+			 * If = has been specified, no other key will be used. In case of
+			 * key > 2 && key == 1 and so on we have to set qual_ok to false
+			 * before discarding the other keys.
 			 */
 			if (xform[BTEqualStrategyNumber - 1])
 			{
@@ -411,8 +411,8 @@ _bt_preprocess_keys(IndexScanDesc scan)
 			}
 
 			/*
-			 * If all attrs before this one had "=", include these keys
-			 * into the required-keys count.
+			 * If all attrs before this one had "=", include these keys into
+			 * the required-keys count.
 			 */
 			if (priorNumberOfEqualCols == attno - 1)
 				so->numberOfRequiredKeys = new_numberOfKeys;
@@ -526,11 +526,11 @@ _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
 		if (isNull)
 		{
 			/*
-			 * Since NULLs are sorted after non-NULLs, we know we have
-			 * reached the upper limit of the range of values for this
-			 * index attr.	On a forward scan, we can stop if this qual is
-			 * one of the "must match" subset.	On a backward scan,
-			 * however, we should keep going.
+			 * Since NULLs are sorted after non-NULLs, we know we have reached
+			 * the upper limit of the range of values for this index attr.	On
+			 * a forward scan, we can stop if this qual is one of the "must
+			 * match" subset.  On a backward scan, however, we should keep
+			 * going.
 			 */
 			if (ikey < so->numberOfRequiredKeys &&
 				ScanDirectionIsForward(dir))
@@ -547,24 +547,22 @@ _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
 		if (!DatumGetBool(test))
 		{
 			/*
-			 * Tuple fails this qual.  If it's a required qual, then we
-			 * may be able to conclude no further tuples will pass,
-			 * either. We have to look at the scan direction and the qual
-			 * type.
+			 * Tuple fails this qual.  If it's a required qual, then we may be
+			 * able to conclude no further tuples will pass, either. We have
+			 * to look at the scan direction and the qual type.
 			 *
-			 * Note: the only case in which we would keep going after failing
-			 * a required qual is if there are partially-redundant quals
-			 * that _bt_preprocess_keys() was unable to eliminate.	For
-			 * example, given "x > 4 AND x > 10" where both are cross-type
-			 * comparisons and so not removable, we might start the scan
-			 * at the x = 4 boundary point.  The "x > 10" condition will
-			 * fail until we pass x = 10, but we must not stop the scan on
-			 * its account.
+			 * Note: the only case in which we would keep going after failing a
+			 * required qual is if there are partially-redundant quals that
+			 * _bt_preprocess_keys() was unable to eliminate.  For example,
+			 * given "x > 4 AND x > 10" where both are cross-type comparisons
+			 * and so not removable, we might start the scan at the x = 4
+			 * boundary point.	The "x > 10" condition will fail until we pass
+			 * x = 10, but we must not stop the scan on its account.
 			 *
-			 * Note: because we stop the scan as soon as any required
-			 * equality qual fails, it is critical that equality quals be
-			 * used for the initial positioning in _bt_first() when they
-			 * are available. See comments in _bt_first().
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
 			 */
 			if (ikey < so->numberOfRequiredKeys)
 			{
diff --git a/src/backend/access/nbtree/nbtxlog.c b/src/backend/access/nbtree/nbtxlog.c
index 69c2d26e33..a6c7933363 100644
--- a/src/backend/access/nbtree/nbtxlog.c
+++ b/src/backend/access/nbtree/nbtxlog.c
@@ -101,7 +101,7 @@ _bt_restore_page(Page page, char *from, int len)
 			(sizeof(BTItemData) - sizeof(IndexTupleData));
 		itemsz = MAXALIGN(itemsz);
 		if (PageAddItem(page, (Item) from, itemsz,
-					  FirstOffsetNumber, LP_USED) == InvalidOffsetNumber)
+						FirstOffsetNumber, LP_USED) == InvalidOffsetNumber)
 			elog(PANIC, "_bt_restore_page: can't add item to page");
 		from += itemsz;
 	}
@@ -136,8 +136,8 @@ _bt_restore_meta(Relation reln, XLogRecPtr lsn,
 	pageop->btpo_flags = BTP_META;
 
 	/*
-	 * Set pd_lower just past the end of the metadata.  This is not
-	 * essential but it makes the page look compressible to xlog.c.
+	 * Set pd_lower just past the end of the metadata.	This is not essential
+	 * but it makes the page look compressible to xlog.c.
 	 */
 	((PageHeader) metapg)->pd_lower =
 		((char *) md + sizeof(BTMetaPageData)) - (char *) metapg;
@@ -181,7 +181,7 @@ btree_xlog_insert(bool isleaf, bool ismeta,
 	if (!(record->xl_info & XLR_BKP_BLOCK_1))
 	{
 		buffer = XLogReadBuffer(false, reln,
-						ItemPointerGetBlockNumber(&(xlrec->target.tid)));
+							ItemPointerGetBlockNumber(&(xlrec->target.tid)));
 		if (!BufferIsValid(buffer))
 			elog(PANIC, "btree_insert_redo: block unfound");
 		page = (Page) BufferGetPage(buffer);
@@ -217,8 +217,8 @@ btree_xlog_insert(bool isleaf, bool ismeta,
 	if (!isleaf && incomplete_splits != NIL)
 	{
 		forget_matching_split(reln, xlrec->target.node,
-						 ItemPointerGetBlockNumber(&(xlrec->target.tid)),
-						ItemPointerGetOffsetNumber(&(xlrec->target.tid)),
+							  ItemPointerGetBlockNumber(&(xlrec->target.tid)),
+							ItemPointerGetOffsetNumber(&(xlrec->target.tid)),
 							  false);
 	}
 }
@@ -325,8 +325,8 @@ btree_xlog_split(bool onleft, bool isroot,
 	if (xlrec->level > 0 && incomplete_splits != NIL)
 	{
 		forget_matching_split(reln, xlrec->target.node,
-						 ItemPointerGetBlockNumber(&(xlrec->target.tid)),
-						ItemPointerGetOffsetNumber(&(xlrec->target.tid)),
+							  ItemPointerGetBlockNumber(&(xlrec->target.tid)),
+							ItemPointerGetOffsetNumber(&(xlrec->target.tid)),
 							  false);
 	}
 
@@ -655,7 +655,7 @@ static void
 out_target(char *buf, xl_btreetid *target)
 {
 	sprintf(buf + strlen(buf), "rel %u/%u/%u; tid %u/%u",
-		 target->node.spcNode, target->node.dbNode, target->node.relNode,
+			target->node.spcNode, target->node.dbNode, target->node.relNode,
 			ItemPointerGetBlockNumber(&(target->tid)),
 			ItemPointerGetOffsetNumber(&(target->tid)));
 }
diff --git a/src/backend/access/rtree/rtget.c b/src/backend/access/rtree/rtget.c
index 5c0be884d1..d69486d9f7 100644
--- a/src/backend/access/rtree/rtget.c
+++ b/src/backend/access/rtree/rtget.c
@@ -32,12 +32,12 @@ rtgettuple(PG_FUNCTION_ARGS)
 	IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1);
 	RTreeScanOpaque so = (RTreeScanOpaque) s->opaque;
-	Page page;
+	Page		page;
 	OffsetNumber offnum;
 
 	/*
-	 * If we've already produced a tuple and the executor has informed
-	 * us that it should be marked "killed", do so now.
+	 * If we've already produced a tuple and the executor has informed us that
+	 * it should be marked "killed", do so now.
 	 */
 	if (s->kill_prior_tuple && ItemPointerIsValid(&(s->currentItemData)))
 	{
@@ -48,14 +48,13 @@ rtgettuple(PG_FUNCTION_ARGS)
 	}
 
 	/*
-	 * Get the next tuple that matches the search key; if asked to
-	 * skip killed tuples, find the first non-killed tuple that
-	 * matches. Return as soon as we've run out of matches or we've
-	 * found an acceptable match.
+	 * Get the next tuple that matches the search key; if asked to skip killed
+	 * tuples, find the first non-killed tuple that matches. Return as soon as
+	 * we've run out of matches or we've found an acceptable match.
 	 */
 	for (;;)
 	{
-		bool res = rtnext(s, dir);
+		bool		res = rtnext(s, dir);
 
 		if (res && s->ignore_killed_tuples)
 		{
@@ -73,7 +72,7 @@ Datum
 rtgetmulti(PG_FUNCTION_ARGS)
 {
 	IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0);
-	ItemPointer	tids = (ItemPointer) PG_GETARG_POINTER(1);
+	ItemPointer tids = (ItemPointer) PG_GETARG_POINTER(1);
 	int32		max_tids = PG_GETARG_INT32(2);
 	int32	   *returned_tids = (int32 *) PG_GETARG_POINTER(3);
 	RTreeScanOpaque so = (RTreeScanOpaque) s->opaque;
@@ -86,7 +85,7 @@ rtgetmulti(PG_FUNCTION_ARGS)
 		res = rtnext(s, ForwardScanDirection);
 		if (res && s->ignore_killed_tuples)
 		{
-			Page page;
+			Page		page;
 			OffsetNumber offnum;
 
 			offnum = ItemPointerGetOffsetNumber(&(s->currentItemData));
@@ -201,12 +200,11 @@ rtnext(IndexScanDesc s, ScanDirection dir)
 			blk = ItemPointerGetBlockNumber(&(it->t_tid));
 
 			/*
-			 * Note that we release the pin on the page as we descend
-			 * down the tree, even though there's a good chance we'll
-			 * eventually need to re-read the buffer later in this
-			 * scan. This may or may not be optimal, but it doesn't
-			 * seem likely to make a huge performance difference
-			 * either way.
+			 * Note that we release the pin on the page as we descend down the
+			 * tree, even though there's a good chance we'll eventually need
+			 * to re-read the buffer later in this scan. This may or may not
+			 * be optimal, but it doesn't seem likely to make a huge
+			 * performance difference either way.
 			 */
 			so->curbuf = ReleaseAndReadBuffer(so->curbuf, s->indexRelation, blk);
 			p = BufferGetPage(so->curbuf);
@@ -233,7 +231,7 @@ findnext(IndexScanDesc s, OffsetNumber n, ScanDirection dir)
 	IndexTuple	it;
 	RTreePageOpaque po;
 	RTreeScanOpaque so;
-	Page p;
+	Page		p;
 
 	so = (RTreeScanOpaque) s->opaque;
 	p = BufferGetPage(so->curbuf);
@@ -242,8 +240,8 @@ findnext(IndexScanDesc s, OffsetNumber n, ScanDirection dir)
 	po = (RTreePageOpaque) PageGetSpecialPointer(p);
 
 	/*
-	 * If we modified the index during the scan, we may have a pointer to
-	 * a ghost tuple, before the scan.	If this is the case, back up one.
+	 * If we modified the index during the scan, we may have a pointer to a
+	 * ghost tuple, before the scan.  If this is the case, back up one.
 	 */
 
 	if (so->s_flags & RTS_CURBEFORE)
@@ -277,7 +275,7 @@ findnext(IndexScanDesc s, OffsetNumber n, ScanDirection dir)
 	}
 
 	if (n >= FirstOffsetNumber && n <= maxoff)
-		return n;						/* found a match on this page */
+		return n;				/* found a match on this page */
 	else
 		return InvalidOffsetNumber;		/* no match, go to next page */
 }
diff --git a/src/backend/access/rtree/rtproc.c b/src/backend/access/rtree/rtproc.c
index a183a98835..a6dbd60274 100644
--- a/src/backend/access/rtree/rtproc.c
+++ b/src/backend/access/rtree/rtproc.c
@@ -146,8 +146,8 @@ rt_poly_size(PG_FUNCTION_ARGS)
 				ydim;
 
 	/*
-	 * Can't just use GETARG because of possibility that input is NULL;
-	 * since POLYGON is toastable, GETARG will try to inspect its value
+	 * Can't just use GETARG because of possibility that input is NULL; since
+	 * POLYGON is toastable, GETARG will try to inspect its value
 	 */
 	if (aptr == NULL)
 	{
diff --git a/src/backend/access/rtree/rtree.c b/src/backend/access/rtree/rtree.c
index e837334319..981e12f663 100644
--- a/src/backend/access/rtree/rtree.c
+++ b/src/backend/access/rtree/rtree.c
@@ -121,8 +121,8 @@ rtbuild(PG_FUNCTION_ARGS)
 	initRtstate(&buildstate.rtState, index);
 
 	/*
-	 * We expect to be called exactly once for any index relation. If
-	 * that's not the case, big trouble's what we have.
+	 * We expect to be called exactly once for any index relation. If that's
+	 * not the case, big trouble's what we have.
 	 */
 	if (RelationGetNumberOfBlocks(index) != 0)
 		elog(ERROR, "index \"%s\" already contains data",
@@ -175,10 +175,10 @@ rtbuildCallback(Relation index,
 
 	/*
 	 * Since we already have the index relation locked, we call rtdoinsert
-	 * directly.  Normal access method calls dispatch through rtinsert,
-	 * which locks the relation for write.	This is the right thing to do
-	 * if you're inserting single tups, but not when you're initializing
-	 * the whole index at once.
+	 * directly.  Normal access method calls dispatch through rtinsert, which
+	 * locks the relation for write.  This is the right thing to do if you're
+	 * inserting single tups, but not when you're initializing the whole index
+	 * at once.
 	 */
 	rtdoinsert(index, itup, &buildstate->rtState);
 
@@ -226,9 +226,8 @@ rtinsert(PG_FUNCTION_ARGS)
 	initRtstate(&rtState, r);
 
 	/*
-	 * Since rtree is not marked "amconcurrent" in pg_am, caller should
-	 * have acquired exclusive lock on index relation.	We need no locking
-	 * here.
+	 * Since rtree is not marked "amconcurrent" in pg_am, caller should have
+	 * acquired exclusive lock on index relation.  We need no locking here.
 	 */
 	rtdoinsert(r, itup, &rtState);
 
@@ -331,7 +330,7 @@ rttighten(Relation r,
 	p = BufferGetPage(b);
 
 	oldud = IndexTupleGetDatum(PageGetItem(p,
-									  PageGetItemId(p, stk->rts_child)));
+										   PageGetItemId(p, stk->rts_child)));
 
 	FunctionCall2(&rtstate->sizeFn, oldud,
 				  PointerGetDatum(&old_size));
@@ -342,8 +341,8 @@ rttighten(Relation r,
 				  PointerGetDatum(&newd_size));
 
 	/*
-	 * If newd_size == 0 we have degenerate rectangles, so we don't know
-	 * if there was any change, so we have to assume there was.
+	 * If newd_size == 0 we have degenerate rectangles, so we don't know if
+	 * there was any change, so we have to assume there was.
 	 */
 	if ((newd_size == 0) || (newd_size != old_size))
 	{
@@ -370,8 +369,8 @@ rttighten(Relation r,
 		/*
 		 * The user may be defining an index on variable-sized data (like
 		 * polygons).  If so, we need to get a constant-sized datum for
-		 * insertion on the internal page.	We do this by calling the
-		 * union proc, which is required to return a rectangle.
+		 * insertion on the internal page.	We do this by calling the union
+		 * proc, which is required to return a rectangle.
 		 */
 		tdatum = FunctionCall2(&rtstate->unionFn, datum, datum);
 
@@ -428,8 +427,8 @@ rtdosplit(Relation r,
 
 	/*
 	 * The root of the tree is the first block in the relation.  If we're
-	 * about to split the root, we need to do some hocus-pocus to enforce
-	 * this guarantee.
+	 * about to split the root, we need to do some hocus-pocus to enforce this
+	 * guarantee.
 	 */
 
 	if (BufferGetBlockNumber(buffer) == P_ROOT)
@@ -459,10 +458,9 @@ rtdosplit(Relation r,
 	newitemoff = OffsetNumberNext(maxoff);
 
 	/*
-	 * spl_left contains a list of the offset numbers of the tuples that
-	 * will go to the left page.  For each offset number, get the tuple
-	 * item, then add the item to the left page.  Similarly for the right
-	 * side.
+	 * spl_left contains a list of the offset numbers of the tuples that will
+	 * go to the left page.  For each offset number, get the tuple item, then
+	 * add the item to the left page.  Similarly for the right side.
 	 */
 
 	/* fill left node */
@@ -525,13 +523,13 @@ rtdosplit(Relation r,
 	 * introduced in its structure by splitting this page.
 	 *
 	 * 2)  "Tighten" the bounding box of the pointer to the left page in the
-	 * parent node in the tree, if any.  Since we moved a bunch of stuff
-	 * off the left page, we expect it to get smaller.	This happens in
-	 * the internal insertion routine.
+	 * parent node in the tree, if any.  Since we moved a bunch of stuff off
+	 * the left page, we expect it to get smaller.	This happens in the
+	 * internal insertion routine.
 	 *
-	 * 3)  Insert a pointer to the right page in the parent.  This may cause
-	 * the parent to split.  If it does, we need to repeat steps one and
-	 * two for each split node in the tree.
+	 * 3)  Insert a pointer to the right page in the parent.  This may cause the
+	 * parent to split.  If it does, we need to repeat steps one and two for
+	 * each split node in the tree.
 	 */
 
 	/* adjust active scans */
@@ -583,10 +581,10 @@ rtintinsert(Relation r,
 	old = (IndexTuple) PageGetItem(p, PageGetItemId(p, stk->rts_child));
 
 	/*
-	 * This is a hack.	Right now, we force rtree internal keys to be
-	 * constant size. To fix this, need delete the old key and add both
-	 * left and right for the two new pages.  The insertion of left may
-	 * force a split if the new left key is bigger than the old key.
+	 * This is a hack.	Right now, we force rtree internal keys to be constant
+	 * size. To fix this, need delete the old key and add both left and right
+	 * for the two new pages.  The insertion of left may force a split if the
+	 * new left key is bigger than the old key.
 	 */
 
 	if (IndexTupleSize(old) != IndexTupleSize(ltup))
@@ -603,8 +601,7 @@ rtintinsert(Relation r,
 		rttighten(r, stk->rts_parent, newdatum,
 				  IndexTupleAttSize(ltup), rtstate);
 		rtdosplit(r, b, stk->rts_parent, rtup, rtstate);
-		WriteBuffer(b);			/* don't forget to release buffer!  -
-								 * 01/31/94 */
+		WriteBuffer(b);			/* don't forget to release buffer!  - 01/31/94 */
 	}
 	else
 	{
@@ -716,16 +713,15 @@ rtpicksplit(Relation r,
 	int			total_num_tuples,
 				num_tuples_without_seeds,
 				max_after_split;	/* in Guttman's lingo, (M - m) */
-	float		diff;			/* diff between cost of putting tuple left
-								 * or right */
+	float		diff;			/* diff between cost of putting tuple left or
+								 * right */
 	SPLITCOST  *cost_vector;
 	int			n;
 
 	/*
-	 * First, make sure the new item is not so large that we can't
-	 * possibly fit it on a page, even by itself.  (It's sufficient to
-	 * make this test here, since any oversize tuple must lead to a page
-	 * split attempt.)
+	 * First, make sure the new item is not so large that we can't possibly
+	 * fit it on a page, even by itself.  (It's sufficient to make this test
+	 * here, since any oversize tuple must lead to a page split attempt.)
 	 */
 	newitemsz = IndexTupleTotalSize(itup);
 	if (newitemsz > RTPageAvailSpace)
@@ -734,11 +730,10 @@ rtpicksplit(Relation r,
 				 errmsg("index row size %lu exceeds rtree maximum, %lu",
 						(unsigned long) newitemsz,
 						(unsigned long) RTPageAvailSpace),
-				 errhint("Values larger than a buffer page cannot be indexed.")));
+			errhint("Values larger than a buffer page cannot be indexed.")));
 
 	maxoff = PageGetMaxOffsetNumber(page);
-	newitemoff = OffsetNumberNext(maxoff);		/* phony index for new
-												 * item */
+	newitemoff = OffsetNumberNext(maxoff);		/* phony index for new item */
 	total_num_tuples = newitemoff;
 	num_tuples_without_seeds = total_num_tuples - 2;
 	max_after_split = total_num_tuples / 2;		/* works for m = M/2 */
@@ -793,8 +788,7 @@ rtpicksplit(Relation r,
 				pfree(DatumGetPointer(inter_d));
 
 			/*
-			 * are these a more promising split that what we've already
-			 * seen?
+			 * are these a more promising split that what we've already seen?
 			 */
 			if (size_waste > waste || firsttime)
 			{
@@ -809,10 +803,10 @@ rtpicksplit(Relation r,
 	if (firsttime)
 	{
 		/*
-		 * There is no possible split except to put the new item on its
-		 * own page.  Since we still have to compute the union rectangles,
-		 * we play dumb and run through the split algorithm anyway,
-		 * setting seed_1 = first item on page and seed_2 = new item.
+		 * There is no possible split except to put the new item on its own
+		 * page.  Since we still have to compute the union rectangles, we play
+		 * dumb and run through the split algorithm anyway, setting seed_1 =
+		 * first item on page and seed_2 = new item.
 		 */
 		seed_1 = FirstOffsetNumber;
 		seed_2 = newitemoff;
@@ -840,25 +834,23 @@ rtpicksplit(Relation r,
 	/*
 	 * Now split up the regions between the two seeds.
 	 *
-	 * The cost_vector array will contain hints for determining where each
-	 * tuple should go.  Each record in the array will contain a boolean,
-	 * choose_left, that indicates which node the tuple prefers to be on,
-	 * and the absolute difference in cost between putting the tuple in
-	 * its favored node and in the other node.
+	 * The cost_vector array will contain hints for determining where each tuple
+	 * should go.  Each record in the array will contain a boolean,
+	 * choose_left, that indicates which node the tuple prefers to be on, and
+	 * the absolute difference in cost between putting the tuple in its
+	 * favored node and in the other node.
 	 *
 	 * Later, we will sort the cost_vector in descending order by cost
-	 * difference, and consider the tuples in that order for placement.
-	 * That way, the tuples that *really* want to be in one node or the
-	 * other get to choose first, and the tuples that don't really care
-	 * choose last.
+	 * difference, and consider the tuples in that order for placement. That
+	 * way, the tuples that *really* want to be in one node or the other get
+	 * to choose first, and the tuples that don't really care choose last.
 	 *
 	 * First, build the cost_vector array.	The new index tuple will also be
-	 * handled in this loop, and represented in the array, with
-	 * i==newitemoff.
+	 * handled in this loop, and represented in the array, with i==newitemoff.
 	 *
-	 * In the case of variable size tuples it is possible that we only have
-	 * the two seeds and no other tuples, in which case we don't do any of
-	 * this cost_vector stuff.
+	 * In the case of variable size tuples it is possible that we only have the
+	 * two seeds and no other tuples, in which case we don't do any of this
+	 * cost_vector stuff.
 	 */
 
 	/* to keep compiler quiet */
@@ -908,13 +900,13 @@ rtpicksplit(Relation r,
 	}
 
 	/*
-	 * Now make the final decisions about where each tuple will go, and
-	 * build the vectors to return in the SPLITVEC record.
+	 * Now make the final decisions about where each tuple will go, and build
+	 * the vectors to return in the SPLITVEC record.
 	 *
-	 * The cost_vector array contains (descriptions of) all the tuples, in
-	 * the order that we want to consider them, so we we just iterate
-	 * through it and place each tuple in left or right nodes, according
-	 * to the criteria described below.
+	 * The cost_vector array contains (descriptions of) all the tuples, in the
+	 * order that we want to consider them, so we we just iterate through it
+	 * and place each tuple in left or right nodes, according to the criteria
+	 * described below.
 	 */
 
 	left = v->spl_left;
@@ -923,8 +915,8 @@ rtpicksplit(Relation r,
 	v->spl_nright = 0;
 
 	/*
-	 * Place the seeds first. left avail space, left union, right avail
-	 * space, and right union have already been adjusted for the seeds.
+	 * Place the seeds first. left avail space, left union, right avail space,
+	 * and right union have already been adjusted for the seeds.
 	 */
 
 	*left++ = seed_1;
@@ -966,32 +958,30 @@ rtpicksplit(Relation r,
 					  PointerGetDatum(&size_beta));
 
 		/*
-		 * We prefer the page that shows smaller enlargement of its union
-		 * area (Guttman's algorithm), but we must take care that at least
-		 * one page will still have room for the new item after this one
-		 * is added.
+		 * We prefer the page that shows smaller enlargement of its union area
+		 * (Guttman's algorithm), but we must take care that at least one page
+		 * will still have room for the new item after this one is added.
 		 *
-		 * (We know that all the old items together can fit on one page, so
-		 * we need not worry about any other problem than failing to fit
-		 * the new item.)
+		 * (We know that all the old items together can fit on one page, so we
+		 * need not worry about any other problem than failing to fit the new
+		 * item.)
 		 *
-		 * Guttman's algorithm actually has two factors to consider (in
-		 * order):	1. if one node has so many tuples already assigned to
-		 * it that the other needs all the rest in order to satisfy the
-		 * condition that neither node has fewer than m tuples, then that
-		 * is decisive; 2. otherwise, choose the page that shows the
-		 * smaller enlargement of its union area.
+		 * Guttman's algorithm actually has two factors to consider (in order):
+		 * 1. if one node has so many tuples already assigned to it that the
+		 * other needs all the rest in order to satisfy the condition that
+		 * neither node has fewer than m tuples, then that is decisive; 2.
+		 * otherwise, choose the page that shows the smaller enlargement of
+		 * its union area.
 		 *
-		 * I have chosen m = M/2, where M is the maximum number of tuples on
-		 * a page.	(Actually, this is only strictly true for fixed size
-		 * tuples.	For variable size tuples, there still might have to be
-		 * only one tuple on a page, if it is really big.  But even with
-		 * variable size tuples we still try to get m as close as possible
-		 * to M/2.)
+		 * I have chosen m = M/2, where M is the maximum number of tuples on a
+		 * page.  (Actually, this is only strictly true for fixed size tuples.
+		 * For variable size tuples, there still might have to be only one
+		 * tuple on a page, if it is really big.  But even with variable size
+		 * tuples we still try to get m as close as possible to M/2.)
 		 *
-		 * The question of which page shows the smaller enlargement of its
-		 * union area has already been answered, and the answer stored in
-		 * the choose_left field of the SPLITCOST record.
+		 * The question of which page shows the smaller enlargement of its union
+		 * area has already been answered, and the answer stored in the
+		 * choose_left field of the SPLITCOST record.
 		 */
 		left_feasible = (left_avail_space >= item_1_sz &&
 						 ((left_avail_space - item_1_sz) >= newitemsz ||
@@ -1003,9 +993,8 @@ rtpicksplit(Relation r,
 		{
 			/*
 			 * Both feasible, use Guttman's algorithm. First check the m
-			 * condition described above, and if that doesn't apply,
-			 * choose the page with the smaller enlargement of its union
-			 * area.
+			 * condition described above, and if that doesn't apply, choose
+			 * the page with the smaller enlargement of its union area.
 			 */
 			if (v->spl_nleft > max_after_split)
 				choose_left = false;
@@ -1153,9 +1142,8 @@ rtbulkdelete(PG_FUNCTION_ARGS)
 	num_index_tuples = 0;
 
 	/*
-	 * Since rtree is not marked "amconcurrent" in pg_am, caller should
-	 * have acquired exclusive lock on index relation.	We need no locking
-	 * here.
+	 * Since rtree is not marked "amconcurrent" in pg_am, caller should have
+	 * acquired exclusive lock on index relation.  We need no locking here.
 	 */
 
 	/*
diff --git a/src/backend/access/rtree/rtscan.c b/src/backend/access/rtree/rtscan.c
index 79049b1330..26a6181116 100644
--- a/src/backend/access/rtree/rtscan.c
+++ b/src/backend/access/rtree/rtscan.c
@@ -123,11 +123,11 @@ rtrescan(PG_FUNCTION_ARGS)
 
 		/*
 		 * Scans on internal pages use different operators than they do on
-		 * leaf pages.	For example, if the user wants all boxes that
-		 * exactly match (x1,y1,x2,y2), then on internal pages we need to
-		 * find all boxes that contain (x1,y1,x2,y2).  rtstrat.c knows
-		 * how to pick the opclass member to use for internal pages.
-		 * In some cases we need to negate the result of the opclass member.
+		 * leaf pages.	For example, if the user wants all boxes that exactly
+		 * match (x1,y1,x2,y2), then on internal pages we need to find all
+		 * boxes that contain (x1,y1,x2,y2).  rtstrat.c knows how to pick the
+		 * opclass member to use for internal pages. In some cases we need to
+		 * negate the result of the opclass member.
 		 */
 		for (i = 0; i < s->numberOfKeys; i++)
 		{
@@ -333,9 +333,9 @@ ReleaseResources_rtree(void)
 	RTScanList	next;
 
 	/*
-	 * Note: this should be a no-op during normal query shutdown. However,
-	 * in an abort situation ExecutorEnd is not called and so there may be
-	 * open index scans to clean up.
+	 * Note: this should be a no-op during normal query shutdown. However, in
+	 * an abort situation ExecutorEnd is not called and so there may be open
+	 * index scans to clean up.
 	 */
 	prev = NULL;
 
@@ -440,8 +440,7 @@ adjustiptr(IndexScanDesc s,
 						else
 						{
 							/*
-							 * remember that we're before the current
-							 * tuple
+							 * remember that we're before the current tuple
 							 */
 							ItemPointerSet(iptr, blkno, FirstOffsetNumber);
 							if (iptr == &(s->currentItemData))
diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c
index 9dffed89ae..dcc1cd37aa 100644
--- a/src/backend/access/transam/clog.c
+++ b/src/backend/access/transam/clog.c
@@ -222,14 +222,14 @@ StartupCLOG(void)
 	/*
 	 * Zero out the remainder of the current clog page.  Under normal
 	 * circumstances it should be zeroes already, but it seems at least
-	 * theoretically possible that XLOG replay will have settled on a
-	 * nextXID value that is less than the last XID actually used and
-	 * marked by the previous database lifecycle (since subtransaction
-	 * commit writes clog but makes no WAL entry).  Let's just be safe.
-	 * (We need not worry about pages beyond the current one, since those
-	 * will be zeroed when first used.  For the same reason, there is no
-	 * need to do anything when nextXid is exactly at a page boundary; and
-	 * it's likely that the "current" page doesn't exist yet in that case.)
+	 * theoretically possible that XLOG replay will have settled on a nextXID
+	 * value that is less than the last XID actually used and marked by the
+	 * previous database lifecycle (since subtransaction commit writes clog
+	 * but makes no WAL entry).  Let's just be safe. (We need not worry about
+	 * pages beyond the current one, since those will be zeroed when first
+	 * used.  For the same reason, there is no need to do anything when
+	 * nextXid is exactly at a page boundary; and it's likely that the
+	 * "current" page doesn't exist yet in that case.)
 	 */
 	if (TransactionIdToPgIndex(xid) != 0)
 	{
@@ -325,8 +325,8 @@ TruncateCLOG(TransactionId oldestXact)
 	int			cutoffPage;
 
 	/*
-	 * The cutoff point is the start of the segment containing oldestXact.
-	 * We pass the *page* containing oldestXact to SimpleLruTruncate.
+	 * The cutoff point is the start of the segment containing oldestXact. We
+	 * pass the *page* containing oldestXact to SimpleLruTruncate.
 	 */
 	cutoffPage = TransactionIdToPage(oldestXact);
 
diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
index 3fd53a4eec..b4ae074b83 100644
--- a/src/backend/access/transam/multixact.c
+++ b/src/backend/access/transam/multixact.c
@@ -4,15 +4,15 @@
  *		PostgreSQL multi-transaction-log manager
  *
  * The pg_multixact manager is a pg_clog-like manager that stores an array
- * of TransactionIds for each MultiXactId.  It is a fundamental part of the
- * shared-row-lock implementation.  A share-locked tuple stores a
+ * of TransactionIds for each MultiXactId.	It is a fundamental part of the
+ * shared-row-lock implementation.	A share-locked tuple stores a
  * MultiXactId in its Xmax, and a transaction that needs to wait for the
  * tuple to be unlocked can sleep on the potentially-several TransactionIds
  * that compose the MultiXactId.
  *
  * We use two SLRU areas, one for storing the offsets at which the data
  * starts for each MultiXactId in the other one.  This trick allows us to
- * store variable length arrays of TransactionIds.  (We could alternatively
+ * store variable length arrays of TransactionIds.	(We could alternatively
  * use one area containing counts and TransactionIds, with valid MultiXactId
  * values pointing at slots containing counts; but that way seems less robust
  * since it would get completely confused if someone inquired about a bogus
@@ -32,7 +32,7 @@
  *
  * Like clog.c, and unlike subtrans.c, we have to preserve state across
  * crashes and ensure that MXID and offset numbering increases monotonically
- * across a crash.  We do this in the same way as it's done for transaction
+ * across a crash.	We do this in the same way as it's done for transaction
  * IDs: the WAL record is guaranteed to contain evidence of every MXID we
  * could need to worry about, and we just make sure that at the end of
  * replay, the next-MXID and next-offset counters are at least as large as
@@ -59,13 +59,13 @@
 
 
 /*
- * Defines for MultiXactOffset page sizes.  A page is the same BLCKSZ as is
+ * Defines for MultiXactOffset page sizes.	A page is the same BLCKSZ as is
  * used everywhere else in Postgres.
  *
  * Note: because both MultiXactOffsets and TransactionIds are 32 bits and
  * wrap around at 0xFFFFFFFF, MultiXact page numbering also wraps around at
  * 0xFFFFFFFF/MULTIXACT_*_PER_PAGE, and segment numbering at
- * 0xFFFFFFFF/MULTIXACT_*_PER_PAGE/SLRU_SEGMENTS_PER_PAGE.  We need take no
+ * 0xFFFFFFFF/MULTIXACT_*_PER_PAGE/SLRU_SEGMENTS_PER_PAGE.	We need take no
  * explicit notice of that fact in this module, except when comparing segment
  * and page numbers in TruncateMultiXact
  * (see MultiXact{Offset,Member}PagePrecedes).
@@ -92,11 +92,11 @@
 static SlruCtlData MultiXactOffsetCtlData;
 static SlruCtlData MultiXactMemberCtlData;
 
-#define MultiXactOffsetCtl  (&MultiXactOffsetCtlData)
-#define MultiXactMemberCtl  (&MultiXactMemberCtlData)
+#define MultiXactOffsetCtl	(&MultiXactOffsetCtlData)
+#define MultiXactMemberCtl	(&MultiXactMemberCtlData)
 
 /*
- * MultiXact state shared across all backends.  All this state is protected
+ * MultiXact state shared across all backends.	All this state is protected
  * by MultiXactGenLock.  (We also use MultiXactOffsetControlLock and
  * MultiXactMemberControlLock to guard accesses to the two sets of SLRU
  * buffers.  For concurrency's sake, we avoid holding more than one of these
@@ -105,50 +105,48 @@ static SlruCtlData MultiXactMemberCtlData;
 typedef struct MultiXactStateData
 {
 	/* next-to-be-assigned MultiXactId */
-	MultiXactId		nextMXact;
+	MultiXactId nextMXact;
 
 	/* next-to-be-assigned offset */
-	MultiXactOffset	nextOffset;
+	MultiXactOffset nextOffset;
 
 	/* the Offset SLRU area was last truncated at this MultiXactId */
-	MultiXactId		lastTruncationPoint;
+	MultiXactId lastTruncationPoint;
 
 	/*
-	 * Per-backend data starts here.  We have two arrays stored in
-	 * the area immediately following the MultiXactStateData struct.
-	 * Each is indexed by BackendId.  (Note: valid BackendIds run from 1 to
-	 * MaxBackends; element zero of each array is never used.)
+	 * Per-backend data starts here.  We have two arrays stored in the area
+	 * immediately following the MultiXactStateData struct. Each is indexed by
+	 * BackendId.  (Note: valid BackendIds run from 1 to MaxBackends; element
+	 * zero of each array is never used.)
 	 *
-	 * OldestMemberMXactId[k] is the oldest MultiXactId each backend's
-	 * current transaction(s) could possibly be a member of, or
-	 * InvalidMultiXactId when the backend has no live transaction that
-	 * could possibly be a member of a MultiXact.  Each backend sets its
-	 * entry to the current nextMXact counter just before first acquiring a
-	 * shared lock in a given transaction, and clears it at transaction end.
-	 * (This works because only during or after acquiring a shared lock
-	 * could an XID possibly become a member of a MultiXact, and that
-	 * MultiXact would have to be created during or after the lock
-	 * acquisition.)
+	 * OldestMemberMXactId[k] is the oldest MultiXactId each backend's current
+	 * transaction(s) could possibly be a member of, or InvalidMultiXactId
+	 * when the backend has no live transaction that could possibly be a
+	 * member of a MultiXact.  Each backend sets its entry to the current
+	 * nextMXact counter just before first acquiring a shared lock in a given
+	 * transaction, and clears it at transaction end. (This works because only
+	 * during or after acquiring a shared lock could an XID possibly become a
+	 * member of a MultiXact, and that MultiXact would have to be created
+	 * during or after the lock acquisition.)
 	 *
-	 * OldestVisibleMXactId[k] is the oldest MultiXactId each backend's
-	 * current transaction(s) think is potentially live, or InvalidMultiXactId
-	 * when not in a transaction or not in a transaction that's paid any
-	 * attention to MultiXacts yet.  This is computed when first needed in
-	 * a given transaction, and cleared at transaction end.  We can compute
-	 * it as the minimum of the valid OldestMemberMXactId[] entries at the
-	 * time we compute it (using nextMXact if none are valid).  Each backend
-	 * is required not to attempt to access any SLRU data for MultiXactIds
-	 * older than its own OldestVisibleMXactId[] setting; this is necessary
-	 * because the checkpointer could truncate away such data at any instant.
+	 * OldestVisibleMXactId[k] is the oldest MultiXactId each backend's current
+	 * transaction(s) think is potentially live, or InvalidMultiXactId when
+	 * not in a transaction or not in a transaction that's paid any attention
+	 * to MultiXacts yet.  This is computed when first needed in a given
+	 * transaction, and cleared at transaction end.  We can compute it as the
+	 * minimum of the valid OldestMemberMXactId[] entries at the time we
+	 * compute it (using nextMXact if none are valid).	Each backend is
+	 * required not to attempt to access any SLRU data for MultiXactIds older
+	 * than its own OldestVisibleMXactId[] setting; this is necessary because
+	 * the checkpointer could truncate away such data at any instant.
 	 *
-	 * The checkpointer can compute the safe truncation point as the oldest
-	 * valid value among all the OldestMemberMXactId[] and
-	 * OldestVisibleMXactId[] entries, or nextMXact if none are valid.
-	 * Clearly, it is not possible for any later-computed OldestVisibleMXactId
-	 * value to be older than this, and so there is no risk of truncating
-	 * data that is still needed.
+	 * The checkpointer can compute the safe truncation point as the oldest valid
+	 * value among all the OldestMemberMXactId[] and OldestVisibleMXactId[]
+	 * entries, or nextMXact if none are valid. Clearly, it is not possible
+	 * for any later-computed OldestVisibleMXactId value to be older than
+	 * this, and so there is no risk of truncating data that is still needed.
 	 */
-	MultiXactId	   perBackendXactIds[1];	/* VARIABLE LENGTH ARRAY */
+	MultiXactId perBackendXactIds[1];	/* VARIABLE LENGTH ARRAY */
 } MultiXactStateData;
 
 /* Pointers to the state data in shared memory */
@@ -176,13 +174,13 @@ static MultiXactId *OldestVisibleMXactId;
 typedef struct mXactCacheEnt
 {
 	struct mXactCacheEnt *next;
-	MultiXactId		multi;
-	int				nxids;
-	TransactionId	xids[1];	/* VARIABLE LENGTH ARRAY */
+	MultiXactId multi;
+	int			nxids;
+	TransactionId xids[1];		/* VARIABLE LENGTH ARRAY */
 } mXactCacheEnt;
 
-static mXactCacheEnt   *MXactCache = NULL;
-static MemoryContext	MXactContext = NULL;
+static mXactCacheEnt *MXactCache = NULL;
+static MemoryContext MXactContext = NULL;
 
 
 #ifdef MULTIXACT_DEBUG
@@ -201,14 +199,15 @@ static MemoryContext	MXactContext = NULL;
 static void MultiXactIdSetOldestVisible(void);
 static MultiXactId CreateMultiXactId(int nxids, TransactionId *xids);
 static void RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
-							   int nxids, TransactionId *xids);
+				   int nxids, TransactionId *xids);
 static MultiXactId GetNewMultiXactId(int nxids, MultiXactOffset *offset);
 
 /* MultiXact cache management */
 static MultiXactId mXactCacheGetBySet(int nxids, TransactionId *xids);
-static int mXactCacheGetById(MultiXactId multi, TransactionId **xids);
+static int	mXactCacheGetById(MultiXactId multi, TransactionId **xids);
 static void mXactCachePut(MultiXactId multi, int nxids, TransactionId *xids);
-static int xidComparator(const void *arg1, const void *arg2);
+static int	xidComparator(const void *arg1, const void *arg2);
+
 #ifdef MULTIXACT_DEBUG
 static char *mxid_to_string(MultiXactId multi, int nxids, TransactionId *xids);
 #endif
@@ -220,7 +219,7 @@ static bool MultiXactOffsetPagePrecedes(int page1, int page2);
 static bool MultiXactMemberPagePrecedes(int page1, int page2);
 static bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2);
 static bool MultiXactOffsetPrecedes(MultiXactOffset offset1,
-									MultiXactOffset offset2);
+						MultiXactOffset offset2);
 static void ExtendMultiXactOffset(MultiXactId multi);
 static void ExtendMultiXactMember(MultiXactOffset offset, int nmembers);
 static void TruncateMultiXact(void);
@@ -239,8 +238,8 @@ static void WriteMZeroPageXlogRec(int pageno, uint8 info);
 MultiXactId
 MultiXactIdCreate(TransactionId xid1, TransactionId xid2)
 {
-	MultiXactId		newMulti;
-	TransactionId	xids[2];
+	MultiXactId newMulti;
+	TransactionId xids[2];
 
 	AssertArg(TransactionIdIsValid(xid1));
 	AssertArg(TransactionIdIsValid(xid2));
@@ -248,9 +247,9 @@ MultiXactIdCreate(TransactionId xid1, TransactionId xid2)
 	Assert(!TransactionIdEquals(xid1, xid2));
 
 	/*
-	 * Note: unlike MultiXactIdExpand, we don't bother to check that both
-	 * XIDs are still running.  In typical usage, xid2 will be our own XID
-	 * and the caller just did a check on xid1, so it'd be wasted effort.
+	 * Note: unlike MultiXactIdExpand, we don't bother to check that both XIDs
+	 * are still running.  In typical usage, xid2 will be our own XID and the
+	 * caller just did a check on xid1, so it'd be wasted effort.
 	 */
 
 	xids[0] = xid1;
@@ -281,12 +280,12 @@ MultiXactIdCreate(TransactionId xid1, TransactionId xid2)
 MultiXactId
 MultiXactIdExpand(MultiXactId multi, TransactionId xid)
 {
-	MultiXactId		newMulti;
-	TransactionId  *members;
-	TransactionId  *newMembers;
-	int				nmembers;
-	int				i;
-	int				j;
+	MultiXactId newMulti;
+	TransactionId *members;
+	TransactionId *newMembers;
+	int			nmembers;
+	int			i;
+	int			j;
 
 	AssertArg(MultiXactIdIsValid(multi));
 	AssertArg(TransactionIdIsValid(xid));
@@ -313,8 +312,8 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid)
 	}
 
 	/*
-	 * If the TransactionId is already a member of the MultiXactId,
-	 * just return the existing MultiXactId.
+	 * If the TransactionId is already a member of the MultiXactId, just
+	 * return the existing MultiXactId.
 	 */
 	for (i = 0; i < nmembers; i++)
 	{
@@ -329,9 +328,9 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid)
 
 	/*
 	 * Determine which of the members of the MultiXactId are still running,
-	 * and use them to create a new one.  (Removing dead members is just
-	 * an optimization, but a useful one.  Note we have the same race
-	 * condition here as above: j could be 0 at the end of the loop.)
+	 * and use them to create a new one.  (Removing dead members is just an
+	 * optimization, but a useful one.	Note we have the same race condition
+	 * here as above: j could be 0 at the end of the loop.)
 	 */
 	newMembers = (TransactionId *)
 		palloc(sizeof(TransactionId) * (nmembers + 1));
@@ -355,7 +354,7 @@ MultiXactIdExpand(MultiXactId multi, TransactionId xid)
 
 /*
  * MultiXactIdIsRunning
- * 		Returns whether a MultiXactId is "running".
+ *		Returns whether a MultiXactId is "running".
  *
  * We return true if at least one member of the given MultiXactId is still
  * running.  Note that a "false" result is certain not to change,
@@ -365,9 +364,9 @@ bool
 MultiXactIdIsRunning(MultiXactId multi)
 {
 	TransactionId *members;
-	TransactionId  myXid;
-	int		nmembers;
-	int		i;
+	TransactionId myXid;
+	int			nmembers;
+	int			i;
 
 	debug_elog3(DEBUG2, "IsRunning %u?", multi);
 
@@ -394,7 +393,7 @@ MultiXactIdIsRunning(MultiXactId multi)
 
 	/*
 	 * This could be made faster by having another entry point in procarray.c,
-	 * walking the PGPROC array only once for all the members.  But in most
+	 * walking the PGPROC array only once for all the members.	But in most
 	 * cases nmembers should be small enough that it doesn't much matter.
 	 */
 	for (i = 0; i < nmembers; i++)
@@ -436,19 +435,19 @@ MultiXactIdSetOldestMember(void)
 
 		/*
 		 * You might think we don't need to acquire a lock here, since
-		 * fetching and storing of TransactionIds is probably atomic,
-		 * but in fact we do: suppose we pick up nextMXact and then
-		 * lose the CPU for a long time.  Someone else could advance
-		 * nextMXact, and then another someone else could compute an
-		 * OldestVisibleMXactId that would be after the value we are
-		 * going to store when we get control back.  Which would be wrong.
+		 * fetching and storing of TransactionIds is probably atomic, but in
+		 * fact we do: suppose we pick up nextMXact and then lose the CPU for
+		 * a long time.  Someone else could advance nextMXact, and then
+		 * another someone else could compute an OldestVisibleMXactId that
+		 * would be after the value we are going to store when we get control
+		 * back.  Which would be wrong.
 		 */
 		LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
 
 		/*
 		 * We have to beware of the possibility that nextMXact is in the
-		 * wrapped-around state.  We don't fix the counter itself here,
-		 * but we must be sure to store a valid value in our array entry.
+		 * wrapped-around state.  We don't fix the counter itself here, but we
+		 * must be sure to store a valid value in our array entry.
 		 */
 		nextMXact = MultiXactState->nextMXact;
 		if (nextMXact < FirstMultiXactId)
@@ -475,7 +474,7 @@ MultiXactIdSetOldestMember(void)
  * The value to set is the oldest of nextMXact and all the valid per-backend
  * OldestMemberMXactId[] entries.  Because of the locking we do, we can be
  * certain that no subsequent call to MultiXactIdSetOldestMember can set
- * an OldestMemberMXactId[] entry older than what we compute here.  Therefore
+ * an OldestMemberMXactId[] entry older than what we compute here.	Therefore
  * there is no live transaction, now or later, that can be a member of any
  * MultiXactId older than the OldestVisibleMXactId we compute here.
  */
@@ -485,14 +484,14 @@ MultiXactIdSetOldestVisible(void)
 	if (!MultiXactIdIsValid(OldestVisibleMXactId[MyBackendId]))
 	{
 		MultiXactId oldestMXact;
-		int		i;
+		int			i;
 
 		LWLockAcquire(MultiXactGenLock, LW_EXCLUSIVE);
 
 		/*
 		 * We have to beware of the possibility that nextMXact is in the
-		 * wrapped-around state.  We don't fix the counter itself here,
-		 * but we must be sure to store a valid value in our array entry.
+		 * wrapped-around state.  We don't fix the counter itself here, but we
+		 * must be sure to store a valid value in our array entry.
 		 */
 		oldestMXact = MultiXactState->nextMXact;
 		if (oldestMXact < FirstMultiXactId)
@@ -535,17 +534,17 @@ void
 MultiXactIdWait(MultiXactId multi)
 {
 	TransactionId *members;
-	int		nmembers;
+	int			nmembers;
 
 	nmembers = GetMultiXactIdMembers(multi, &members);
 
 	if (nmembers >= 0)
 	{
-		int		i;
+		int			i;
 
 		for (i = 0; i < nmembers; i++)
 		{
-			TransactionId	member = members[i];
+			TransactionId member = members[i];
 
 			debug_elog4(DEBUG2, "MultiXactIdWait: waiting for %d (%u)",
 						i, member);
@@ -564,19 +563,19 @@ MultiXactIdWait(MultiXactId multi)
 bool
 ConditionalMultiXactIdWait(MultiXactId multi)
 {
-	bool	result = true;
+	bool		result = true;
 	TransactionId *members;
-	int		nmembers;
+	int			nmembers;
 
 	nmembers = GetMultiXactIdMembers(multi, &members);
 
 	if (nmembers >= 0)
 	{
-		int		i;
+		int			i;
 
 		for (i = 0; i < nmembers; i++)
 		{
-			TransactionId	member = members[i];
+			TransactionId member = members[i];
 
 			debug_elog4(DEBUG2, "ConditionalMultiXactIdWait: trying %d (%u)",
 						i, member);
@@ -596,7 +595,7 @@ ConditionalMultiXactIdWait(MultiXactId multi)
 
 /*
  * CreateMultiXactId
- * 		Make a new MultiXactId
+ *		Make a new MultiXactId
  *
  * Make XLOG, SLRU and cache entries for a new MultiXactId, recording the
  * given TransactionIds as members.  Returns the newly created MultiXactId.
@@ -606,7 +605,7 @@ ConditionalMultiXactIdWait(MultiXactId multi)
 static MultiXactId
 CreateMultiXactId(int nxids, TransactionId *xids)
 {
-	MultiXactId	multi;
+	MultiXactId multi;
 	MultiXactOffset offset;
 	XLogRecData rdata[2];
 	xl_multixact_create xlrec;
@@ -641,15 +640,15 @@ CreateMultiXactId(int nxids, TransactionId *xids)
 	/*
 	 * Make an XLOG entry describing the new MXID.
 	 *
-	 * Note: we need not flush this XLOG entry to disk before proceeding.
-	 * The only way for the MXID to be referenced from any data page is
-	 * for heap_lock_tuple() to have put it there, and heap_lock_tuple()
-	 * generates an XLOG record that must follow ours.  The normal LSN
-	 * interlock between the data page and that XLOG record will ensure
-	 * that our XLOG record reaches disk first.  If the SLRU members/offsets
-	 * data reaches disk sooner than the XLOG record, we do not care because
-	 * we'll overwrite it with zeroes unless the XLOG record is there too;
-	 * see notes at top of this file.
+	 * Note: we need not flush this XLOG entry to disk before proceeding. The
+	 * only way for the MXID to be referenced from any data page is for
+	 * heap_lock_tuple() to have put it there, and heap_lock_tuple() generates
+	 * an XLOG record that must follow ours.  The normal LSN interlock between
+	 * the data page and that XLOG record will ensure that our XLOG record
+	 * reaches disk first.	If the SLRU members/offsets data reaches disk
+	 * sooner than the XLOG record, we do not care because we'll overwrite it
+	 * with zeroes unless the XLOG record is there too; see notes at top of
+	 * this file.
 	 */
 	xlrec.mid = multi;
 	xlrec.moff = offset;
@@ -702,9 +701,9 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
 	/*
 	 * Note: we pass the MultiXactId to SimpleLruReadPage as the "transaction"
 	 * to complain about if there's any I/O error.  This is kinda bogus, but
-	 * since the errors will always give the full pathname, it should be
-	 * clear enough that a MultiXactId is really involved.  Perhaps someday
-	 * we'll take the trouble to generalize the slru.c error reporting code.
+	 * since the errors will always give the full pathname, it should be clear
+	 * enough that a MultiXactId is really involved.  Perhaps someday we'll
+	 * take the trouble to generalize the slru.c error reporting code.
 	 */
 	slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, multi);
 	offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
@@ -750,7 +749,7 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
  * GetNewMultiXactId
  *		Get the next MultiXactId.
  *
- * Also, reserve the needed amount of space in the "members" area.  The
+ * Also, reserve the needed amount of space in the "members" area.	The
  * starting offset of the reserved space is returned in *offset.
  *
  * This may generate XLOG records for expansion of the offsets and/or members
@@ -761,7 +760,7 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
 static MultiXactId
 GetNewMultiXactId(int nxids, MultiXactOffset *offset)
 {
-	MultiXactId		result;
+	MultiXactId result;
 
 	debug_elog3(DEBUG2, "GetNew: for %d xids", nxids);
 
@@ -785,8 +784,8 @@ GetNewMultiXactId(int nxids, MultiXactOffset *offset)
 	 * Advance counter.  As in GetNewTransactionId(), this must not happen
 	 * until after ExtendMultiXactOffset has succeeded!
 	 *
-	 * We don't care about MultiXactId wraparound here; it will be handled by
-	 * the next iteration.  But note that nextMXact may be InvalidMultiXactId
+	 * We don't care about MultiXactId wraparound here; it will be handled by the
+	 * next iteration.	But note that nextMXact may be InvalidMultiXactId
 	 * after this routine exits, so anyone else looking at the variable must
 	 * be prepared to deal with that.
 	 */
@@ -809,7 +808,7 @@ GetNewMultiXactId(int nxids, MultiXactOffset *offset)
 
 /*
  * GetMultiXactIdMembers
- * 		Returns the set of TransactionIds that make up a MultiXactId
+ *		Returns the set of TransactionIds that make up a MultiXactId
  *
  * We return -1 if the MultiXactId is too old to possibly have any members
  * still running; in that case we have not actually looked them up, and
@@ -822,13 +821,13 @@ GetMultiXactIdMembers(MultiXactId multi, TransactionId **xids)
 	int			prev_pageno;
 	int			entryno;
 	int			slotno;
-	MultiXactOffset	   *offptr;
-	MultiXactOffset		offset;
+	MultiXactOffset *offptr;
+	MultiXactOffset offset;
 	int			length;
 	int			i;
-	MultiXactId	nextMXact;
-	MultiXactId	tmpMXact;
-	MultiXactOffset		nextOffset;
+	MultiXactId nextMXact;
+	MultiXactId tmpMXact;
+	MultiXactOffset nextOffset;
 	TransactionId *ptr;
 
 	debug_elog3(DEBUG2, "GetMembers: asked for %u", multi);
@@ -850,13 +849,13 @@ GetMultiXactIdMembers(MultiXactId multi, TransactionId **xids)
 	/*
 	 * We check known limits on MultiXact before resorting to the SLRU area.
 	 *
-	 * An ID older than our OldestVisibleMXactId[] entry can't possibly still
-	 * be running, and we'd run the risk of trying to read already-truncated
-	 * SLRU data if we did try to examine it.
+	 * An ID older than our OldestVisibleMXactId[] entry can't possibly still be
+	 * running, and we'd run the risk of trying to read already-truncated SLRU
+	 * data if we did try to examine it.
 	 *
-	 * Conversely, an ID >= nextMXact shouldn't ever be seen here; if it is
-	 * seen, it implies undetected ID wraparound has occurred.  We just
-	 * silently assume that such an ID is no longer running.
+	 * Conversely, an ID >= nextMXact shouldn't ever be seen here; if it is seen,
+	 * it implies undetected ID wraparound has occurred.  We just silently
+	 * assume that such an ID is no longer running.
 	 *
 	 * Shared lock is enough here since we aren't modifying any global state.
 	 * Also, we can examine our own OldestVisibleMXactId without the lock,
@@ -880,9 +879,9 @@ GetMultiXactIdMembers(MultiXactId multi, TransactionId **xids)
 	}
 
 	/*
-	 * Before releasing the lock, save the current counter values, because
-	 * the target MultiXactId may be just one less than nextMXact.  We will
-	 * need to use nextOffset as the endpoint if so.
+	 * Before releasing the lock, save the current counter values, because the
+	 * target MultiXactId may be just one less than nextMXact.	We will need
+	 * to use nextOffset as the endpoint if so.
 	 */
 	nextMXact = MultiXactState->nextMXact;
 	nextOffset = MultiXactState->nextOffset;
@@ -902,11 +901,11 @@ GetMultiXactIdMembers(MultiXactId multi, TransactionId **xids)
 
 	/*
 	 * How many members do we need to read?  If we are at the end of the
-	 * assigned MultiXactIds, use the offset just saved above.  Else we
-	 * need to check the MultiXactId following ours.
+	 * assigned MultiXactIds, use the offset just saved above.	Else we need
+	 * to check the MultiXactId following ours.
 	 *
-	 * Use the same increment rule as GetNewMultiXactId(), that is, don't
-	 * handle wraparound explicitly until needed.
+	 * Use the same increment rule as GetNewMultiXactId(), that is, don't handle
+	 * wraparound explicitly until needed.
 	 */
 	tmpMXact = multi + 1;
 
@@ -974,9 +973,9 @@ GetMultiXactIdMembers(MultiXactId multi, TransactionId **xids)
 
 /*
  * mXactCacheGetBySet
- * 		returns a MultiXactId from the cache based on the set of
- * 		TransactionIds that compose it, or InvalidMultiXactId if
- * 		none matches.
+ *		returns a MultiXactId from the cache based on the set of
+ *		TransactionIds that compose it, or InvalidMultiXactId if
+ *		none matches.
  *
  * This is helpful, for example, if two transactions want to lock a huge
  * table.  By using the cache, the second will use the same MultiXactId
@@ -988,7 +987,7 @@ GetMultiXactIdMembers(MultiXactId multi, TransactionId **xids)
 static MultiXactId
 mXactCacheGetBySet(int nxids, TransactionId *xids)
 {
-	mXactCacheEnt	*entry;
+	mXactCacheEnt *entry;
 
 	debug_elog3(DEBUG2, "CacheGet: looking for %s",
 				mxid_to_string(InvalidMultiXactId, nxids, xids));
@@ -1015,8 +1014,8 @@ mXactCacheGetBySet(int nxids, TransactionId *xids)
 
 /*
  * mXactCacheGetById
- * 		returns the composing TransactionId set from the cache for a
- * 		given MultiXactId, if present.
+ *		returns the composing TransactionId set from the cache for a
+ *		given MultiXactId, if present.
  *
  * If successful, *xids is set to the address of a palloc'd copy of the
  * TransactionId set.  Return value is number of members, or -1 on failure.
@@ -1024,7 +1023,7 @@ mXactCacheGetBySet(int nxids, TransactionId *xids)
 static int
 mXactCacheGetById(MultiXactId multi, TransactionId **xids)
 {
-	mXactCacheEnt	*entry;
+	mXactCacheEnt *entry;
 
 	debug_elog3(DEBUG2, "CacheGet: looking for %u", multi);
 
@@ -1032,7 +1031,7 @@ mXactCacheGetById(MultiXactId multi, TransactionId **xids)
 	{
 		if (entry->multi == multi)
 		{
-			TransactionId	*ptr;
+			TransactionId *ptr;
 			Size		size;
 
 			size = sizeof(TransactionId) * entry->nxids;
@@ -1042,7 +1041,7 @@ mXactCacheGetById(MultiXactId multi, TransactionId **xids)
 			memcpy(ptr, entry->xids, size);
 
 			debug_elog3(DEBUG2, "CacheGet: found %s",
-					mxid_to_string(multi, entry->nxids, entry->xids));
+						mxid_to_string(multi, entry->nxids, entry->xids));
 			return entry->nxids;
 		}
 	}
@@ -1053,12 +1052,12 @@ mXactCacheGetById(MultiXactId multi, TransactionId **xids)
 
 /*
  * mXactCachePut
- * 		Add a new MultiXactId and its composing set into the local cache.
+ *		Add a new MultiXactId and its composing set into the local cache.
  */
 static void
 mXactCachePut(MultiXactId multi, int nxids, TransactionId *xids)
 {
-	mXactCacheEnt  *entry;
+	mXactCacheEnt *entry;
 
 	debug_elog3(DEBUG2, "CachePut: storing %s",
 				mxid_to_string(multi, nxids, xids));
@@ -1092,7 +1091,7 @@ mXactCachePut(MultiXactId multi, int nxids, TransactionId *xids)
 
 /*
  * xidComparator
- * 		qsort comparison function for XIDs
+ *		qsort comparison function for XIDs
  *
  * We don't need to use wraparound comparison for XIDs, and indeed must
  * not do so since that does not respect the triangle inequality!  Any
@@ -1101,8 +1100,8 @@ mXactCachePut(MultiXactId multi, int nxids, TransactionId *xids)
 static int
 xidComparator(const void *arg1, const void *arg2)
 {
-	TransactionId xid1 = * (const TransactionId *) arg1;
-	TransactionId xid2 = * (const TransactionId *) arg2;
+	TransactionId xid1 = *(const TransactionId *) arg1;
+	TransactionId xid2 = *(const TransactionId *) arg2;
 
 	if (xid1 > xid2)
 		return 1;
@@ -1115,8 +1114,9 @@ xidComparator(const void *arg1, const void *arg2)
 static char *
 mxid_to_string(MultiXactId multi, int nxids, TransactionId *xids)
 {
-	char *str = palloc(15 * (nxids + 1) + 4);
-	int i;
+	char	   *str = palloc(15 * (nxids + 1) + 4);
+	int			i;
+
 	snprintf(str, 47, "%u %d[%u", multi, nxids, xids[0]);
 
 	for (i = 1; i < nxids; i++)
@@ -1137,18 +1137,18 @@ void
 AtEOXact_MultiXact(void)
 {
 	/*
-	 * Reset our OldestMemberMXactId and OldestVisibleMXactId values,
-	 * both of which should only be valid while within a transaction.
+	 * Reset our OldestMemberMXactId and OldestVisibleMXactId values, both of
+	 * which should only be valid while within a transaction.
 	 *
-	 * We assume that storing a MultiXactId is atomic and so we need
-	 * not take MultiXactGenLock to do this.
+	 * We assume that storing a MultiXactId is atomic and so we need not take
+	 * MultiXactGenLock to do this.
 	 */
 	OldestMemberMXactId[MyBackendId] = InvalidMultiXactId;
 	OldestVisibleMXactId[MyBackendId] = InvalidMultiXactId;
 
 	/*
-	 * Discard the local MultiXactId cache.  Since MXactContext was created
-	 * as a child of TopTransactionContext, we needn't delete it explicitly.
+	 * Discard the local MultiXactId cache.  Since MXactContext was created as
+	 * a child of TopTransactionContext, we needn't delete it explicitly.
 	 */
 	MXactContext = NULL;
 	MXactCache = NULL;
@@ -1156,7 +1156,7 @@ AtEOXact_MultiXact(void)
 
 /*
  * Initialization of shared memory for MultiXact.  We use two SLRU areas,
- * thus double memory.  Also, reserve space for the shared MultiXactState
+ * thus double memory.	Also, reserve space for the shared MultiXactState
  * struct and the per-backend MultiXactId arrays (two of those, too).
  */
 Size
@@ -1178,7 +1178,7 @@ MultiXactShmemSize(void)
 void
 MultiXactShmemInit(void)
 {
-	bool	found;
+	bool		found;
 
 	debug_elog2(DEBUG2, "Shared Memory Init for MultiXact");
 
@@ -1205,8 +1205,8 @@ MultiXactShmemInit(void)
 		Assert(found);
 
 	/*
-	 * Set up array pointers.  Note that perBackendXactIds[0] is wasted
-	 * space since we only use indexes 1..MaxBackends in each array.
+	 * Set up array pointers.  Note that perBackendXactIds[0] is wasted space
+	 * since we only use indexes 1..MaxBackends in each array.
 	 */
 	OldestMemberMXactId = MultiXactState->perBackendXactIds;
 	OldestVisibleMXactId = OldestMemberMXactId + MaxBackends;
@@ -1214,7 +1214,7 @@ MultiXactShmemInit(void)
 
 /*
  * This func must be called ONCE on system install.  It creates the initial
- * MultiXact segments.  (The MultiXacts directories are assumed to have been
+ * MultiXact segments.	(The MultiXacts directories are assumed to have been
  * created by initdb, and MultiXactShmemInit must have been called already.)
  */
 void
@@ -1287,7 +1287,7 @@ ZeroMultiXactMemberPage(int pageno, bool writeXlog)
  * This must be called ONCE during postmaster or standalone-backend startup.
  *
  * StartupXLOG has already established nextMXact/nextOffset by calling
- * MultiXactSetNextMXact and/or MultiXactAdvanceNextMXact.  Note that we
+ * MultiXactSetNextMXact and/or MultiXactAdvanceNextMXact.	Note that we
  * may already have replayed WAL data into the SLRU files.
  *
  * We don't need any locks here, really; the SLRU locks are taken
@@ -1311,14 +1311,14 @@ StartupMultiXact(void)
 	MultiXactOffsetCtl->shared->latest_page_number = pageno;
 
 	/*
-	 * Zero out the remainder of the current offsets page.  See notes
-	 * in StartupCLOG() for motivation.
+	 * Zero out the remainder of the current offsets page.	See notes in
+	 * StartupCLOG() for motivation.
 	 */
 	entryno = MultiXactIdToOffsetEntry(multi);
 	if (entryno != 0)
 	{
 		int			slotno;
-		MultiXactOffset	   *offptr;
+		MultiXactOffset *offptr;
 
 		slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, multi);
 		offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
@@ -1341,14 +1341,14 @@ StartupMultiXact(void)
 	MultiXactMemberCtl->shared->latest_page_number = pageno;
 
 	/*
-	 * Zero out the remainder of the current members page.  See notes
-	 * in StartupCLOG() for motivation.
+	 * Zero out the remainder of the current members page.	See notes in
+	 * StartupCLOG() for motivation.
 	 */
 	entryno = MXOffsetToMemberEntry(offset);
 	if (entryno != 0)
 	{
 		int			slotno;
-		TransactionId	   *xidptr;
+		TransactionId *xidptr;
 
 		slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, offset);
 		xidptr = (TransactionId *) MultiXactMemberCtl->shared->page_buffer[slotno];
@@ -1499,14 +1499,14 @@ static void
 ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
 {
 	/*
-	 * It's possible that the members span more than one page of the
-	 * members file, so we loop to ensure we consider each page.  The
-	 * coding is not optimal if the members span several pages, but
-	 * that seems unusual enough to not worry much about.
+	 * It's possible that the members span more than one page of the members
+	 * file, so we loop to ensure we consider each page.  The coding is not
+	 * optimal if the members span several pages, but that seems unusual
+	 * enough to not worry much about.
 	 */
 	while (nmembers > 0)
 	{
-		int		entryno;
+		int			entryno;
 
 		/*
 		 * Only zero when at first entry of a page.
@@ -1514,7 +1514,7 @@ ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
 		entryno = MXOffsetToMemberEntry(offset);
 		if (entryno == 0)
 		{
-			int		pageno;
+			int			pageno;
 
 			pageno = MXOffsetToMemberPage(offset);
 
@@ -1536,7 +1536,7 @@ ExtendMultiXactMember(MultiXactOffset offset, int nmembers)
  * Remove all MultiXactOffset and MultiXactMember segments before the oldest
  * ones still of interest.
  *
- * This is called only during checkpoints.  We assume no more than one
+ * This is called only during checkpoints.	We assume no more than one
  * backend does this at a time.
  *
  * XXX do we have any issues with needing to checkpoint here?
@@ -1545,23 +1545,23 @@ static void
 TruncateMultiXact(void)
 {
 	MultiXactId nextMXact;
-	MultiXactOffset		nextOffset;
+	MultiXactOffset nextOffset;
 	MultiXactId oldestMXact;
-	MultiXactOffset		oldestOffset;
+	MultiXactOffset oldestOffset;
 	int			cutoffPage;
 	int			i;
 
 	/*
-	 * First, compute where we can safely truncate.  Per notes above,
-	 * this is the oldest valid value among all the OldestMemberMXactId[] and
+	 * First, compute where we can safely truncate.  Per notes above, this is
+	 * the oldest valid value among all the OldestMemberMXactId[] and
 	 * OldestVisibleMXactId[] entries, or nextMXact if none are valid.
 	 */
 	LWLockAcquire(MultiXactGenLock, LW_SHARED);
 
 	/*
 	 * We have to beware of the possibility that nextMXact is in the
-	 * wrapped-around state.  We don't fix the counter itself here,
-	 * but we must be sure to use a valid value in our calculation.
+	 * wrapped-around state.  We don't fix the counter itself here, but we
+	 * must be sure to use a valid value in our calculation.
 	 */
 	nextMXact = MultiXactState->nextMXact;
 	if (nextMXact < FirstMultiXactId)
@@ -1597,9 +1597,9 @@ TruncateMultiXact(void)
 		return;
 
 	/*
-	 * We need to determine where to truncate MultiXactMember.  If we
-	 * found a valid oldest MultiXactId, read its starting offset;
-	 * otherwise we use the nextOffset value we saved above.
+	 * We need to determine where to truncate MultiXactMember.	If we found a
+	 * valid oldest MultiXactId, read its starting offset; otherwise we use
+	 * the nextOffset value we saved above.
 	 */
 	if (oldestMXact == nextMXact)
 		oldestOffset = nextOffset;
@@ -1608,7 +1608,7 @@ TruncateMultiXact(void)
 		int			pageno;
 		int			slotno;
 		int			entryno;
-		MultiXactOffset	   *offptr;
+		MultiXactOffset *offptr;
 
 		LWLockAcquire(MultiXactOffsetControlLock, LW_EXCLUSIVE);
 
@@ -1624,8 +1624,8 @@ TruncateMultiXact(void)
 	}
 
 	/*
-	 * The cutoff point is the start of the segment containing oldestMXact.
-	 * We pass the *page* containing oldestMXact to SimpleLruTruncate.
+	 * The cutoff point is the start of the segment containing oldestMXact. We
+	 * pass the *page* containing oldestMXact to SimpleLruTruncate.
 	 */
 	cutoffPage = MultiXactIdToOffsetPage(oldestMXact);
 
@@ -1677,8 +1677,8 @@ MultiXactOffsetPagePrecedes(int page1, int page2)
 static bool
 MultiXactMemberPagePrecedes(int page1, int page2)
 {
-	MultiXactOffset	offset1;
-	MultiXactOffset	offset2;
+	MultiXactOffset offset1;
+	MultiXactOffset offset2;
 
 	offset1 = ((MultiXactOffset) page1) * MULTIXACT_MEMBERS_PER_PAGE;
 	offset2 = ((MultiXactOffset) page2) * MULTIXACT_MEMBERS_PER_PAGE;
@@ -1695,7 +1695,7 @@ MultiXactMemberPagePrecedes(int page1, int page2)
 static bool
 MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
 {
-	int32 diff = (int32) (multi1 - multi2);
+	int32		diff = (int32) (multi1 - multi2);
 
 	return (diff < 0);
 }
@@ -1706,7 +1706,7 @@ MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
 static bool
 MultiXactOffsetPrecedes(MultiXactOffset offset1, MultiXactOffset offset2)
 {
-	int32 diff = (int32) (offset1 - offset2);
+	int32		diff = (int32) (offset1 - offset2);
 
 	return (diff < 0);
 }
@@ -1783,9 +1783,9 @@ multixact_redo(XLogRecPtr lsn, XLogRecord *record)
 		MultiXactAdvanceNextMXact(xlrec->mid + 1, xlrec->moff + xlrec->nxids);
 
 		/*
-		 * Make sure nextXid is beyond any XID mentioned in the record.
-		 * This should be unnecessary, since any XID found here ought to
-		 * have other evidence in the XLOG, but let's be safe.
+		 * Make sure nextXid is beyond any XID mentioned in the record. This
+		 * should be unnecessary, since any XID found here ought to have other
+		 * evidence in the XLOG, but let's be safe.
 		 */
 		max_xid = record->xl_xid;
 		for (i = 0; i < xlrec->nxids; i++)
diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
index 54d1badfd9..65d7212aec 100644
--- a/src/backend/access/transam/slru.c
+++ b/src/backend/access/transam/slru.c
@@ -186,8 +186,8 @@ SimpleLruInit(SlruCtl ctl, const char *name,
 		Assert(found);
 
 	/*
-	 * Initialize the unshared control struct, including directory path.
-	 * We assume caller set PagePrecedes.
+	 * Initialize the unshared control struct, including directory path. We
+	 * assume caller set PagePrecedes.
 	 */
 	ctl->shared = shared;
 	ctl->do_fsync = true;		/* default behavior */
@@ -351,11 +351,11 @@ SimpleLruWritePage(SlruCtl ctl, int slotno, SlruFlush fdata)
 	LWLockAcquire(shared->buffer_locks[slotno], LW_EXCLUSIVE);
 
 	/*
-	 * Check to see if someone else already did the write, or took the
-	 * buffer away from us.  If so, do nothing.  NOTE: we really should
-	 * never see WRITE_IN_PROGRESS here, since that state should only
-	 * occur while the writer is holding the buffer lock.  But accept it
-	 * so that we have a recovery path if a writer aborts.
+	 * Check to see if someone else already did the write, or took the buffer
+	 * away from us.  If so, do nothing.  NOTE: we really should never see
+	 * WRITE_IN_PROGRESS here, since that state should only occur while the
+	 * writer is holding the buffer lock.  But accept it so that we have a
+	 * recovery path if a writer aborts.
 	 */
 	if (shared->page_number[slotno] != pageno ||
 		(shared->page_status[slotno] != SLRU_PAGE_DIRTY &&
@@ -368,15 +368,14 @@ SimpleLruWritePage(SlruCtl ctl, int slotno, SlruFlush fdata)
 
 	/*
 	 * Mark the slot write-busy.  After this point, a transaction status
-	 * update on this page will mark it dirty again.  NB: we are assuming
-	 * that read/write of the page status field is atomic, since we change
-	 * the state while not holding control lock.  However, we cannot set
-	 * this state any sooner, or we'd possibly fool a previous writer into
-	 * thinking he's successfully dumped the page when he hasn't.
-	 * (Scenario: other writer starts, page is redirtied, we come along
-	 * and set WRITE_IN_PROGRESS again, other writer completes and sets
-	 * CLEAN because redirty info has been lost, then we think it's clean
-	 * too.)
+	 * update on this page will mark it dirty again.  NB: we are assuming that
+	 * read/write of the page status field is atomic, since we change the
+	 * state while not holding control lock.  However, we cannot set this
+	 * state any sooner, or we'd possibly fool a previous writer into thinking
+	 * he's successfully dumped the page when he hasn't. (Scenario: other
+	 * writer starts, page is redirtied, we come along and set
+	 * WRITE_IN_PROGRESS again, other writer completes and sets CLEAN because
+	 * redirty info has been lost, then we think it's clean too.)
 	 */
 	shared->page_status[slotno] = SLRU_PAGE_WRITE_IN_PROGRESS;
 
@@ -436,8 +435,8 @@ SlruPhysicalReadPage(SlruCtl ctl, int pageno, int slotno)
 	 * In a crash-and-restart situation, it's possible for us to receive
 	 * commands to set the commit status of transactions whose bits are in
 	 * already-truncated segments of the commit log (see notes in
-	 * SlruPhysicalWritePage).	Hence, if we are InRecovery, allow the
-	 * case where the file doesn't exist, and return zeroes instead.
+	 * SlruPhysicalWritePage).	Hence, if we are InRecovery, allow the case
+	 * where the file doesn't exist, and return zeroes instead.
 	 */
 	fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR);
 	if (fd < 0)
@@ -528,17 +527,16 @@ SlruPhysicalWritePage(SlruCtl ctl, int pageno, int slotno, SlruFlush fdata)
 	{
 		/*
 		 * If the file doesn't already exist, we should create it.  It is
-		 * possible for this to need to happen when writing a page that's
-		 * not first in its segment; we assume the OS can cope with that.
-		 * (Note: it might seem that it'd be okay to create files only
-		 * when SimpleLruZeroPage is called for the first page of a
-		 * segment. However, if after a crash and restart the REDO logic
-		 * elects to replay the log from a checkpoint before the latest
-		 * one, then it's possible that we will get commands to set
-		 * transaction status of transactions that have already been
-		 * truncated from the commit log. Easiest way to deal with that is
-		 * to accept references to nonexistent files here and in
-		 * SlruPhysicalReadPage.)
+		 * possible for this to need to happen when writing a page that's not
+		 * first in its segment; we assume the OS can cope with that. (Note:
+		 * it might seem that it'd be okay to create files only when
+		 * SimpleLruZeroPage is called for the first page of a segment.
+		 * However, if after a crash and restart the REDO logic elects to
+		 * replay the log from a checkpoint before the latest one, then it's
+		 * possible that we will get commands to set transaction status of
+		 * transactions that have already been truncated from the commit log.
+		 * Easiest way to deal with that is to accept references to
+		 * nonexistent files here and in SlruPhysicalReadPage.)
 		 */
 		SlruFileName(ctl, path, segno);
 		fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR);
@@ -635,49 +633,49 @@ SlruReportIOError(SlruCtl ctl, int pageno, TransactionId xid)
 		case SLRU_OPEN_FAILED:
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				errmsg("could not access status of transaction %u", xid),
+					 errmsg("could not access status of transaction %u", xid),
 					 errdetail("could not open file \"%s\": %m",
 							   path)));
 			break;
 		case SLRU_CREATE_FAILED:
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				errmsg("could not access status of transaction %u", xid),
+					 errmsg("could not access status of transaction %u", xid),
 					 errdetail("could not create file \"%s\": %m",
 							   path)));
 			break;
 		case SLRU_SEEK_FAILED:
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				errmsg("could not access status of transaction %u", xid),
-			  errdetail("could not seek in file \"%s\" to offset %u: %m",
-						path, offset)));
+					 errmsg("could not access status of transaction %u", xid),
+				  errdetail("could not seek in file \"%s\" to offset %u: %m",
+							path, offset)));
 			break;
 		case SLRU_READ_FAILED:
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				errmsg("could not access status of transaction %u", xid),
-			errdetail("could not read from file \"%s\" at offset %u: %m",
-					  path, offset)));
+					 errmsg("could not access status of transaction %u", xid),
+				errdetail("could not read from file \"%s\" at offset %u: %m",
+						  path, offset)));
 			break;
 		case SLRU_WRITE_FAILED:
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				errmsg("could not access status of transaction %u", xid),
-			 errdetail("could not write to file \"%s\" at offset %u: %m",
-					   path, offset)));
+					 errmsg("could not access status of transaction %u", xid),
+				 errdetail("could not write to file \"%s\" at offset %u: %m",
+						   path, offset)));
 			break;
 		case SLRU_FSYNC_FAILED:
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				errmsg("could not access status of transaction %u", xid),
+					 errmsg("could not access status of transaction %u", xid),
 					 errdetail("could not fsync file \"%s\": %m",
 							   path)));
 			break;
 		case SLRU_CLOSE_FAILED:
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				errmsg("could not access status of transaction %u", xid),
+					 errmsg("could not access status of transaction %u", xid),
 					 errdetail("could not close file \"%s\": %m",
 							   path)));
 			break;
@@ -723,8 +721,8 @@ SlruSelectLRUPage(SlruCtl ctl, int pageno)
 		}
 
 		/*
-		 * If we find any EMPTY slot, just select that one. Else locate
-		 * the least-recently-used slot that isn't the latest page.
+		 * If we find any EMPTY slot, just select that one. Else locate the
+		 * least-recently-used slot that isn't the latest page.
 		 */
 		for (slotno = 0; slotno < NUM_SLRU_BUFFERS; slotno++)
 		{
@@ -745,10 +743,10 @@ SlruSelectLRUPage(SlruCtl ctl, int pageno)
 			return bestslot;
 
 		/*
-		 * We need to do I/O.  Normal case is that we have to write it
-		 * out, but it's possible in the worst case to have selected a
-		 * read-busy page.	In that case we use SimpleLruReadPage to wait
-		 * for the read to complete.
+		 * We need to do I/O.  Normal case is that we have to write it out,
+		 * but it's possible in the worst case to have selected a read-busy
+		 * page.  In that case we use SimpleLruReadPage to wait for the read
+		 * to complete.
 		 */
 		if (shared->page_status[bestslot] == SLRU_PAGE_READ_IN_PROGRESS)
 			(void) SimpleLruReadPage(ctl, shared->page_number[bestslot],
@@ -757,9 +755,9 @@ SlruSelectLRUPage(SlruCtl ctl, int pageno)
 			SimpleLruWritePage(ctl, bestslot, NULL);
 
 		/*
-		 * Now loop back and try again.  This is the easiest way of
-		 * dealing with corner cases such as the victim page being
-		 * re-dirtied while we wrote it.
+		 * Now loop back and try again.  This is the easiest way of dealing
+		 * with corner cases such as the victim page being re-dirtied while we
+		 * wrote it.
 		 */
 	}
 }
@@ -789,9 +787,9 @@ SimpleLruFlush(SlruCtl ctl, bool checkpoint)
 		SimpleLruWritePage(ctl, slotno, &fdata);
 
 		/*
-		 * When called during a checkpoint, we cannot assert that the slot
-		 * is clean now, since another process might have re-dirtied it
-		 * already.  That's okay.
+		 * When called during a checkpoint, we cannot assert that the slot is
+		 * clean now, since another process might have re-dirtied it already.
+		 * That's okay.
 		 */
 		Assert(checkpoint ||
 			   shared->page_status[slotno] == SLRU_PAGE_EMPTY ||
@@ -841,10 +839,10 @@ SimpleLruTruncate(SlruCtl ctl, int cutoffPage)
 	cutoffPage -= cutoffPage % SLRU_PAGES_PER_SEGMENT;
 
 	/*
-	 * Scan shared memory and remove any pages preceding the cutoff page,
-	 * to ensure we won't rewrite them later.  (Since this is normally
-	 * called in or just after a checkpoint, any dirty pages should have
-	 * been flushed already ... we're just being extra careful here.)
+	 * Scan shared memory and remove any pages preceding the cutoff page, to
+	 * ensure we won't rewrite them later.  (Since this is normally called in
+	 * or just after a checkpoint, any dirty pages should have been flushed
+	 * already ... we're just being extra careful here.)
 	 */
 	LWLockAcquire(shared->ControlLock, LW_EXCLUSIVE);
 
@@ -852,16 +850,16 @@ restart:;
 
 	/*
 	 * While we are holding the lock, make an important safety check: the
-	 * planned cutoff point must be <= the current endpoint page.
-	 * Otherwise we have already wrapped around, and proceeding with the
-	 * truncation would risk removing the current segment.
+	 * planned cutoff point must be <= the current endpoint page. Otherwise we
+	 * have already wrapped around, and proceeding with the truncation would
+	 * risk removing the current segment.
 	 */
 	if (ctl->PagePrecedes(shared->latest_page_number, cutoffPage))
 	{
 		LWLockRelease(shared->ControlLock);
 		ereport(LOG,
-				(errmsg("could not truncate directory \"%s\": apparent wraparound",
-						ctl->Dir)));
+		  (errmsg("could not truncate directory \"%s\": apparent wraparound",
+				  ctl->Dir)));
 		return;
 	}
 
@@ -882,9 +880,9 @@ restart:;
 		}
 
 		/*
-		 * Hmm, we have (or may have) I/O operations acting on the page,
-		 * so we've got to wait for them to finish and then start again.
-		 * This is the same logic as in SlruSelectLRUPage.
+		 * Hmm, we have (or may have) I/O operations acting on the page, so
+		 * we've got to wait for them to finish and then start again. This is
+		 * the same logic as in SlruSelectLRUPage.
 		 */
 		if (shared->page_status[slotno] == SLRU_PAGE_READ_IN_PROGRESS)
 			(void) SimpleLruReadPage(ctl, shared->page_number[slotno],
diff --git a/src/backend/access/transam/subtrans.c b/src/backend/access/transam/subtrans.c
index ab40011e29..a9263c70fe 100644
--- a/src/backend/access/transam/subtrans.c
+++ b/src/backend/access/transam/subtrans.c
@@ -234,9 +234,8 @@ StartupSUBTRANS(TransactionId oldestActiveXID)
 	/*
 	 * Since we don't expect pg_subtrans to be valid across crashes, we
 	 * initialize the currently-active page(s) to zeroes during startup.
-	 * Whenever we advance into a new page, ExtendSUBTRANS will likewise
-	 * zero the new page without regard to whatever was previously on
-	 * disk.
+	 * Whenever we advance into a new page, ExtendSUBTRANS will likewise zero
+	 * the new page without regard to whatever was previously on disk.
 	 */
 	LWLockAcquire(SubtransControlLock, LW_EXCLUSIVE);
 
@@ -262,8 +261,8 @@ ShutdownSUBTRANS(void)
 	/*
 	 * Flush dirty SUBTRANS pages to disk
 	 *
-	 * This is not actually necessary from a correctness point of view. We do
-	 * it merely as a debugging aid.
+	 * This is not actually necessary from a correctness point of view. We do it
+	 * merely as a debugging aid.
 	 */
 	SimpleLruFlush(SubTransCtl, false);
 }
@@ -277,9 +276,9 @@ CheckPointSUBTRANS(void)
 	/*
 	 * Flush dirty SUBTRANS pages to disk
 	 *
-	 * This is not actually necessary from a correctness point of view. We do
-	 * it merely to improve the odds that writing of dirty pages is done
-	 * by the checkpoint process and not by backends.
+	 * This is not actually necessary from a correctness point of view. We do it
+	 * merely to improve the odds that writing of dirty pages is done by the
+	 * checkpoint process and not by backends.
 	 */
 	SimpleLruFlush(SubTransCtl, true);
 }
@@ -329,8 +328,8 @@ TruncateSUBTRANS(TransactionId oldestXact)
 	int			cutoffPage;
 
 	/*
-	 * The cutoff point is the start of the segment containing oldestXact.
-	 * We pass the *page* containing oldestXact to SimpleLruTruncate.
+	 * The cutoff point is the start of the segment containing oldestXact. We
+	 * pass the *page* containing oldestXact to SimpleLruTruncate.
 	 */
 	cutoffPage = TransactionIdToPage(oldestXact);
 
diff --git a/src/backend/access/transam/transam.c b/src/backend/access/transam/transam.c
index 35a31294bc..1b139118ab 100644
--- a/src/backend/access/transam/transam.c
+++ b/src/backend/access/transam/transam.c
@@ -54,8 +54,8 @@ TransactionLogFetch(TransactionId transactionId)
 	XidStatus	xidstatus;
 
 	/*
-	 * Before going to the commit log manager, check our single item cache
-	 * to see if we didn't just check the transaction status a moment ago.
+	 * Before going to the commit log manager, check our single item cache to
+	 * see if we didn't just check the transaction status a moment ago.
 	 */
 	if (TransactionIdEquals(transactionId, cachedFetchXid))
 		return cachedFetchXidStatus;
@@ -78,8 +78,8 @@ TransactionLogFetch(TransactionId transactionId)
 	xidstatus = TransactionIdGetStatus(transactionId);
 
 	/*
-	 * DO NOT cache status for unfinished or sub-committed transactions!
-	 * We only cache status that is guaranteed not to change.
+	 * DO NOT cache status for unfinished or sub-committed transactions! We
+	 * only cache status that is guaranteed not to change.
 	 */
 	if (xidstatus != TRANSACTION_STATUS_IN_PROGRESS &&
 		xidstatus != TRANSACTION_STATUS_SUB_COMMITTED)
@@ -169,18 +169,18 @@ TransactionIdDidCommit(TransactionId transactionId)
 		return true;
 
 	/*
-	 * If it's marked subcommitted, we have to check the parent
-	 * recursively. However, if it's older than TransactionXmin, we can't
-	 * look at pg_subtrans; instead assume that the parent crashed without
-	 * cleaning up its children.
+	 * If it's marked subcommitted, we have to check the parent recursively.
+	 * However, if it's older than TransactionXmin, we can't look at
+	 * pg_subtrans; instead assume that the parent crashed without cleaning up
+	 * its children.
 	 *
-	 * Originally we Assert'ed that the result of SubTransGetParent was
-	 * not zero.  However with the introduction of prepared transactions,
-	 * there can be a window just after database startup where we do not
-	 * have complete knowledge in pg_subtrans of the transactions after
-	 * TransactionXmin.  StartupSUBTRANS() has ensured that any missing
-	 * information will be zeroed.  Since this case should not happen under
-	 * normal conditions, it seems reasonable to emit a WARNING for it.
+	 * Originally we Assert'ed that the result of SubTransGetParent was not zero.
+	 * However with the introduction of prepared transactions, there can be a
+	 * window just after database startup where we do not have complete
+	 * knowledge in pg_subtrans of the transactions after TransactionXmin.
+	 * StartupSUBTRANS() has ensured that any missing information will be
+	 * zeroed.	Since this case should not happen under normal conditions, it
+	 * seems reasonable to emit a WARNING for it.
 	 */
 	if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
 	{
@@ -225,10 +225,10 @@ TransactionIdDidAbort(TransactionId transactionId)
 		return true;
 
 	/*
-	 * If it's marked subcommitted, we have to check the parent
-	 * recursively. However, if it's older than TransactionXmin, we can't
-	 * look at pg_subtrans; instead assume that the parent crashed without
-	 * cleaning up its children.
+	 * If it's marked subcommitted, we have to check the parent recursively.
+	 * However, if it's older than TransactionXmin, we can't look at
+	 * pg_subtrans; instead assume that the parent crashed without cleaning up
+	 * its children.
 	 */
 	if (xidstatus == TRANSACTION_STATUS_SUB_COMMITTED)
 	{
diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
index 6036f995d4..1e5c7814fa 100644
--- a/src/backend/access/transam/twophase.c
+++ b/src/backend/access/transam/twophase.c
@@ -64,7 +64,7 @@
 #define TWOPHASE_DIR "pg_twophase"
 
 /* GUC variable, can't be changed after startup */
-int max_prepared_xacts = 5;
+int			max_prepared_xacts = 5;
 
 /*
  * This struct describes one global transaction that is in prepared state
@@ -97,7 +97,7 @@ int max_prepared_xacts = 5;
  * entry will remain in prepXacts until recycled.  We can detect recyclable
  * entries by checking for valid = false and locking_xid no longer active.
  *
- * typedef struct GlobalTransactionData *GlobalTransaction appears in 
+ * typedef struct GlobalTransactionData *GlobalTransaction appears in
  * twophase.h
  */
 #define GIDSIZE 200
@@ -105,12 +105,12 @@ int max_prepared_xacts = 5;
 typedef struct GlobalTransactionData
 {
 	PGPROC		proc;			/* dummy proc */
-	TimestampTz	prepared_at;	/* time of preparation */
+	TimestampTz prepared_at;	/* time of preparation */
 	XLogRecPtr	prepare_lsn;	/* XLOG offset of prepare record */
 	Oid			owner;			/* ID of user that executed the xact */
 	TransactionId locking_xid;	/* top-level XID of backend working on xact */
 	bool		valid;			/* TRUE if fully prepared */
-	char gid[GIDSIZE];			/* The GID assigned to the prepared xact */
+	char		gid[GIDSIZE];	/* The GID assigned to the prepared xact */
 } GlobalTransactionData;
 
 /*
@@ -123,30 +123,30 @@ typedef struct TwoPhaseStateData
 	SHMEM_OFFSET freeGXacts;
 
 	/* Number of valid prepXacts entries. */
-	int		numPrepXacts;
+	int			numPrepXacts;
 
 	/*
 	 * There are max_prepared_xacts items in this array, but C wants a
 	 * fixed-size array.
 	 */
-	GlobalTransaction	prepXacts[1]; /* VARIABLE LENGTH ARRAY */
+	GlobalTransaction prepXacts[1];		/* VARIABLE LENGTH ARRAY */
 } TwoPhaseStateData;			/* VARIABLE LENGTH STRUCT */
 
 static TwoPhaseStateData *TwoPhaseState;
 
 
 static void RecordTransactionCommitPrepared(TransactionId xid,
-											int nchildren,
-											TransactionId *children,
-											int nrels,
-											RelFileNode *rels);
+								int nchildren,
+								TransactionId *children,
+								int nrels,
+								RelFileNode *rels);
 static void RecordTransactionAbortPrepared(TransactionId xid,
-											int nchildren,
-											TransactionId *children,
-											int nrels,
-											RelFileNode *rels);
+							   int nchildren,
+							   TransactionId *children,
+							   int nrels,
+							   RelFileNode *rels);
 static void ProcessRecords(char *bufptr, TransactionId xid,
-						   const TwoPhaseCallback callbacks[]);
+			   const TwoPhaseCallback callbacks[]);
 
 
 /*
@@ -171,7 +171,7 @@ TwoPhaseShmemSize(void)
 void
 TwoPhaseShmemInit(void)
 {
-	bool found;
+	bool		found;
 
 	TwoPhaseState = ShmemInitStruct("Prepared Transaction Table",
 									TwoPhaseShmemSize(),
@@ -190,7 +190,7 @@ TwoPhaseShmemInit(void)
 		 */
 		gxacts = (GlobalTransaction)
 			((char *) TwoPhaseState +
-			 MAXALIGN(offsetof(TwoPhaseStateData, prepXacts) + 
+			 MAXALIGN(offsetof(TwoPhaseStateData, prepXacts) +
 					  sizeof(GlobalTransaction) * max_prepared_xacts));
 		for (i = 0; i < max_prepared_xacts; i++)
 		{
@@ -205,7 +205,7 @@ TwoPhaseShmemInit(void)
 
 /*
  * MarkAsPreparing
- * 		Reserve the GID for the given transaction.
+ *		Reserve the GID for the given transaction.
  *
  * Internally, this creates a gxact struct and puts it into the active array.
  * NOTE: this is also used when reloading a gxact after a crash; so avoid
@@ -215,8 +215,8 @@ GlobalTransaction
 MarkAsPreparing(TransactionId xid, const char *gid,
 				TimestampTz prepared_at, Oid owner, Oid databaseid)
 {
-	GlobalTransaction	gxact;
-	int i;
+	GlobalTransaction gxact;
+	int			i;
 
 	if (strlen(gid) >= GIDSIZE)
 		ereport(ERROR,
@@ -227,10 +227,9 @@ MarkAsPreparing(TransactionId xid, const char *gid,
 	LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
 
 	/*
-	 * First, find and recycle any gxacts that failed during prepare.
-	 * We do this partly to ensure we don't mistakenly say their GIDs
-	 * are still reserved, and partly so we don't fail on out-of-slots
-	 * unnecessarily.
+	 * First, find and recycle any gxacts that failed during prepare. We do
+	 * this partly to ensure we don't mistakenly say their GIDs are still
+	 * reserved, and partly so we don't fail on out-of-slots unnecessarily.
 	 */
 	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
 	{
@@ -360,13 +359,13 @@ MarkAsPrepared(GlobalTransaction gxact)
 static GlobalTransaction
 LockGXact(const char *gid, Oid user)
 {
-	int i;
+	int			i;
 
 	LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
 
 	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
 	{
-		GlobalTransaction	gxact = TwoPhaseState->prepXacts[i];
+		GlobalTransaction gxact = TwoPhaseState->prepXacts[i];
 
 		/* Ignore not-yet-valid GIDs */
 		if (!gxact->valid)
@@ -380,15 +379,15 @@ LockGXact(const char *gid, Oid user)
 			if (TransactionIdIsActive(gxact->locking_xid))
 				ereport(ERROR,
 						(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-						 errmsg("prepared transaction with identifier \"%s\" is busy",
-								gid)));
+				errmsg("prepared transaction with identifier \"%s\" is busy",
+					   gid)));
 			gxact->locking_xid = InvalidTransactionId;
 		}
 
 		if (user != gxact->owner && !superuser_arg(user))
 			ereport(ERROR,
 					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-					 errmsg("permission denied to finish prepared transaction"),
+				  errmsg("permission denied to finish prepared transaction"),
 					 errhint("Must be superuser or the user that prepared the transaction.")));
 
 		/* OK for me to lock it */
@@ -403,8 +402,8 @@ LockGXact(const char *gid, Oid user)
 
 	ereport(ERROR,
 			(errcode(ERRCODE_UNDEFINED_OBJECT),
-			 errmsg("prepared transaction with identifier \"%s\" does not exist",
-					gid)));
+		 errmsg("prepared transaction with identifier \"%s\" does not exist",
+				gid)));
 
 	/* NOTREACHED */
 	return NULL;
@@ -419,7 +418,7 @@ LockGXact(const char *gid, Oid user)
 static void
 RemoveGXact(GlobalTransaction gxact)
 {
-	int i;
+	int			i;
 
 	LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
 
@@ -449,7 +448,7 @@ RemoveGXact(GlobalTransaction gxact)
 /*
  * TransactionIdIsPrepared
  *		True iff transaction associated with the identifier is prepared
- *      for two-phase commit
+ *		for two-phase commit
  *
  * Note: only gxacts marked "valid" are considered; but notice we do not
  * check the locking status.
@@ -459,14 +458,14 @@ RemoveGXact(GlobalTransaction gxact)
 static bool
 TransactionIdIsPrepared(TransactionId xid)
 {
-	bool result = false;
-	int i;
+	bool		result = false;
+	int			i;
 
 	LWLockAcquire(TwoPhaseStateLock, LW_SHARED);
 
 	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
 	{
-		GlobalTransaction	gxact = TwoPhaseState->prepXacts[i];
+		GlobalTransaction gxact = TwoPhaseState->prepXacts[i];
 
 		if (gxact->valid && gxact->proc.xid == xid)
 		{
@@ -496,8 +495,8 @@ static int
 GetPreparedTransactionList(GlobalTransaction *gxacts)
 {
 	GlobalTransaction array;
-	int		num;
-	int		i;
+	int			num;
+	int			i;
 
 	LWLockAcquire(TwoPhaseStateLock, LW_SHARED);
 
@@ -526,13 +525,13 @@ GetPreparedTransactionList(GlobalTransaction *gxacts)
 typedef struct
 {
 	GlobalTransaction array;
-	int		ngxacts;
-	int		currIdx;
+	int			ngxacts;
+	int			currIdx;
 } Working_State;
 
 /*
  * pg_prepared_xact
- * 		Produce a view with one row per prepared transaction.
+ *		Produce a view with one row per prepared transaction.
  *
  * This function is here so we don't have to export the
  * GlobalTransactionData struct definition.
@@ -552,8 +551,7 @@ pg_prepared_xact(PG_FUNCTION_ARGS)
 		funcctx = SRF_FIRSTCALL_INIT();
 
 		/*
-		 * Switch to memory context appropriate for multiple function
-		 * calls
+		 * Switch to memory context appropriate for multiple function calls
 		 */
 		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
@@ -574,8 +572,8 @@ pg_prepared_xact(PG_FUNCTION_ARGS)
 		funcctx->tuple_desc = BlessTupleDesc(tupdesc);
 
 		/*
-		 * Collect all the 2PC status information that we will format and
-		 * send out as a result set.
+		 * Collect all the 2PC status information that we will format and send
+		 * out as a result set.
 		 */
 		status = (Working_State *) palloc(sizeof(Working_State));
 		funcctx->user_fctx = (void *) status;
@@ -644,7 +642,7 @@ TwoPhaseGetDummyProc(TransactionId xid)
 
 	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
 	{
-		GlobalTransaction	gxact = TwoPhaseState->prepXacts[i];
+		GlobalTransaction gxact = TwoPhaseState->prepXacts[i];
 
 		if (gxact->proc.xid == xid)
 		{
@@ -665,7 +663,7 @@ TwoPhaseGetDummyProc(TransactionId xid)
 }
 
 /************************************************************************/
-/* State file support                                                   */
+/* State file support													*/
 /************************************************************************/
 
 #define TwoPhaseFilePath(path, xid) \
@@ -674,14 +672,14 @@ TwoPhaseGetDummyProc(TransactionId xid)
 /*
  * 2PC state file format:
  *
- *  1. TwoPhaseFileHeader
- *  2. TransactionId[] (subtransactions)
+ *	1. TwoPhaseFileHeader
+ *	2. TransactionId[] (subtransactions)
  *	3. RelFileNode[] (files to be deleted at commit)
  *	4. RelFileNode[] (files to be deleted at abort)
- *  5. TwoPhaseRecordOnDisk
- *  6. ...
- *  7. TwoPhaseRecordOnDisk (end sentinel, rmid == TWOPHASE_RM_END_ID)
- *  8. CRC32
+ *	5. TwoPhaseRecordOnDisk
+ *	6. ...
+ *	7. TwoPhaseRecordOnDisk (end sentinel, rmid == TWOPHASE_RM_END_ID)
+ *	8. CRC32
  *
  * Each segment except the final CRC32 is MAXALIGN'd.
  */
@@ -693,16 +691,16 @@ TwoPhaseGetDummyProc(TransactionId xid)
 
 typedef struct TwoPhaseFileHeader
 {
-	uint32			magic;				/* format identifier */
-	uint32			total_len;			/* actual file length */
-	TransactionId	xid;				/* original transaction XID */
-	Oid				database;			/* OID of database it was in */
-	TimestampTz		prepared_at;		/* time of preparation */
-	Oid				owner;				/* user running the transaction */
-	int32			nsubxacts;			/* number of following subxact XIDs */
-	int32			ncommitrels;		/* number of delete-on-commit rels */
-	int32			nabortrels;			/* number of delete-on-abort rels */
-	char			gid[GIDSIZE];		/* GID for transaction */
+	uint32		magic;			/* format identifier */
+	uint32		total_len;		/* actual file length */
+	TransactionId xid;			/* original transaction XID */
+	Oid			database;		/* OID of database it was in */
+	TimestampTz prepared_at;	/* time of preparation */
+	Oid			owner;			/* user running the transaction */
+	int32		nsubxacts;		/* number of following subxact XIDs */
+	int32		ncommitrels;	/* number of delete-on-commit rels */
+	int32		nabortrels;		/* number of delete-on-abort rels */
+	char		gid[GIDSIZE];	/* GID for transaction */
 } TwoPhaseFileHeader;
 
 /*
@@ -713,9 +711,9 @@ typedef struct TwoPhaseFileHeader
  */
 typedef struct TwoPhaseRecordOnDisk
 {
-	uint32			len;		/* length of rmgr data */
-	TwoPhaseRmgrId	rmid;		/* resource manager for this record */
-	uint16			info;		/* flag bits for use by rmgr */
+	uint32		len;			/* length of rmgr data */
+	TwoPhaseRmgrId rmid;		/* resource manager for this record */
+	uint16		info;			/* flag bits for use by rmgr */
 } TwoPhaseRecordOnDisk;
 
 /*
@@ -728,9 +726,9 @@ static struct xllist
 {
 	XLogRecData *head;			/* first data block in the chain */
 	XLogRecData *tail;			/* last block in chain */
-	uint32 bytes_free;			/* free bytes left in tail block */
-	uint32 total_len;			/* total data bytes in chain */
-} records;
+	uint32		bytes_free;		/* free bytes left in tail block */
+	uint32		total_len;		/* total data bytes in chain */
+}	records;
 
 
 /*
@@ -744,7 +742,7 @@ static struct xllist
 static void
 save_state_data(const void *data, uint32 len)
 {
-	uint32	padlen = MAXALIGN(len);
+	uint32		padlen = MAXALIGN(len);
 
 	if (padlen > records.bytes_free)
 	{
@@ -772,7 +770,7 @@ save_state_data(const void *data, uint32 len)
 void
 StartPrepare(GlobalTransaction gxact)
 {
-	TransactionId	xid = gxact->proc.xid;
+	TransactionId xid = gxact->proc.xid;
 	TwoPhaseFileHeader hdr;
 	TransactionId *children;
 	RelFileNode *commitrels;
@@ -833,13 +831,13 @@ StartPrepare(GlobalTransaction gxact)
 void
 EndPrepare(GlobalTransaction gxact)
 {
-	TransactionId	xid = gxact->proc.xid;
+	TransactionId xid = gxact->proc.xid;
 	TwoPhaseFileHeader *hdr;
-	char			path[MAXPGPATH];
-	XLogRecData	   *record;
-	pg_crc32		statefile_crc;
-	pg_crc32		bogus_crc;
-	int				fd;
+	char		path[MAXPGPATH];
+	XLogRecData *record;
+	pg_crc32	statefile_crc;
+	pg_crc32	bogus_crc;
+	int			fd;
 
 	/* Add the end sentinel to the list of 2PC records */
 	RegisterTwoPhaseRecord(TWOPHASE_RM_END_ID, 0,
@@ -853,10 +851,10 @@ EndPrepare(GlobalTransaction gxact)
 	/*
 	 * Create the 2PC state file.
 	 *
-	 * Note: because we use BasicOpenFile(), we are responsible for ensuring
-	 * the FD gets closed in any error exit path.  Once we get into the
-	 * critical section, though, it doesn't matter since any failure causes
-	 * PANIC anyway.
+	 * Note: because we use BasicOpenFile(), we are responsible for ensuring the
+	 * FD gets closed in any error exit path.  Once we get into the critical
+	 * section, though, it doesn't matter since any failure causes PANIC
+	 * anyway.
 	 */
 	TwoPhaseFilePath(path, xid);
 
@@ -887,11 +885,10 @@ EndPrepare(GlobalTransaction gxact)
 	FIN_CRC32(statefile_crc);
 
 	/*
-	 * Write a deliberately bogus CRC to the state file; this is just
-	 * paranoia to catch the case where four more bytes will run us out of
-	 * disk space.
+	 * Write a deliberately bogus CRC to the state file; this is just paranoia
+	 * to catch the case where four more bytes will run us out of disk space.
 	 */
-	bogus_crc = ~ statefile_crc;
+	bogus_crc = ~statefile_crc;
 
 	if ((write(fd, &bogus_crc, sizeof(pg_crc32))) != sizeof(pg_crc32))
 	{
@@ -914,11 +911,11 @@ EndPrepare(GlobalTransaction gxact)
 	 * The state file isn't valid yet, because we haven't written the correct
 	 * CRC yet.  Before we do that, insert entry in WAL and flush it to disk.
 	 *
-	 * Between the time we have written the WAL entry and the time we write
-	 * out the correct state file CRC, we have an inconsistency: the xact is
-	 * prepared according to WAL but not according to our on-disk state.
-	 * We use a critical section to force a PANIC if we are unable to complete
-	 * the write --- then, WAL replay should repair the inconsistency.  The
+	 * Between the time we have written the WAL entry and the time we write out
+	 * the correct state file CRC, we have an inconsistency: the xact is
+	 * prepared according to WAL but not according to our on-disk state. We
+	 * use a critical section to force a PANIC if we are unable to complete
+	 * the write --- then, WAL replay should repair the inconsistency.	The
 	 * odds of a PANIC actually occurring should be very tiny given that we
 	 * were able to write the bogus CRC above.
 	 *
@@ -956,16 +953,16 @@ EndPrepare(GlobalTransaction gxact)
 				 errmsg("could not close twophase state file: %m")));
 
 	/*
-	 * Mark the prepared transaction as valid.  As soon as xact.c marks
-	 * MyProc as not running our XID (which it will do immediately after
-	 * this function returns), others can commit/rollback the xact.
+	 * Mark the prepared transaction as valid.	As soon as xact.c marks MyProc
+	 * as not running our XID (which it will do immediately after this
+	 * function returns), others can commit/rollback the xact.
 	 *
 	 * NB: a side effect of this is to make a dummy ProcArray entry for the
 	 * prepared XID.  This must happen before we clear the XID from MyProc,
 	 * else there is a window where the XID is not running according to
-	 * TransactionIdInProgress, and onlookers would be entitled to assume
-	 * the xact crashed.  Instead we have a window where the same XID
-	 * appears twice in ProcArray, which is OK.
+	 * TransactionIdInProgress, and onlookers would be entitled to assume the
+	 * xact crashed.  Instead we have a window where the same XID appears
+	 * twice in ProcArray, which is OK.
 	 */
 	MarkAsPrepared(gxact);
 
@@ -1011,9 +1008,10 @@ ReadTwoPhaseFile(TransactionId xid)
 	char	   *buf;
 	TwoPhaseFileHeader *hdr;
 	int			fd;
-	struct stat	stat;
+	struct stat stat;
 	uint32		crc_offset;
-	pg_crc32	calc_crc, file_crc;
+	pg_crc32	calc_crc,
+				file_crc;
 
 	TwoPhaseFilePath(path, xid);
 
@@ -1028,9 +1026,8 @@ ReadTwoPhaseFile(TransactionId xid)
 	}
 
 	/*
-	 * Check file length.  We can determine a lower bound pretty easily.
-	 * We set an upper bound mainly to avoid palloc() failure on a corrupt
-	 * file.
+	 * Check file length.  We can determine a lower bound pretty easily. We
+	 * set an upper bound mainly to avoid palloc() failure on a corrupt file.
 	 */
 	if (fstat(fd, &stat))
 	{
@@ -1107,17 +1104,17 @@ FinishPreparedTransaction(const char *gid, bool isCommit)
 {
 	GlobalTransaction gxact;
 	TransactionId xid;
-	char *buf;
-	char *bufptr;
+	char	   *buf;
+	char	   *bufptr;
 	TwoPhaseFileHeader *hdr;
 	TransactionId *children;
 	RelFileNode *commitrels;
 	RelFileNode *abortrels;
-	int		i;
+	int			i;
 
 	/*
-	 * Validate the GID, and lock the GXACT to ensure that two backends
-	 * do not try to commit the same GID at once.
+	 * Validate the GID, and lock the GXACT to ensure that two backends do not
+	 * try to commit the same GID at once.
 	 */
 	gxact = LockGXact(gid, GetUserId());
 	xid = gxact->proc.xid;
@@ -1148,10 +1145,10 @@ FinishPreparedTransaction(const char *gid, bool isCommit)
 	/*
 	 * The order of operations here is critical: make the XLOG entry for
 	 * commit or abort, then mark the transaction committed or aborted in
-	 * pg_clog, then remove its PGPROC from the global ProcArray (which
-	 * means TransactionIdIsInProgress will stop saying the prepared xact
-	 * is in progress), then run the post-commit or post-abort callbacks.
-	 * The callbacks will release the locks the transaction held.
+	 * pg_clog, then remove its PGPROC from the global ProcArray (which means
+	 * TransactionIdIsInProgress will stop saying the prepared xact is in
+	 * progress), then run the post-commit or post-abort callbacks. The
+	 * callbacks will release the locks the transaction held.
 	 */
 	if (isCommit)
 		RecordTransactionCommitPrepared(xid,
@@ -1165,18 +1162,18 @@ FinishPreparedTransaction(const char *gid, bool isCommit)
 	ProcArrayRemove(&gxact->proc);
 
 	/*
-	 * In case we fail while running the callbacks, mark the gxact invalid
-	 * so no one else will try to commit/rollback, and so it can be recycled
-	 * properly later.  It is still locked by our XID so it won't go away yet.
+	 * In case we fail while running the callbacks, mark the gxact invalid so
+	 * no one else will try to commit/rollback, and so it can be recycled
+	 * properly later.	It is still locked by our XID so it won't go away yet.
 	 *
 	 * (We assume it's safe to do this without taking TwoPhaseStateLock.)
 	 */
 	gxact->valid = false;
 
 	/*
-	 * We have to remove any files that were supposed to be dropped.
-	 * For consistency with the regular xact.c code paths, must do this
-	 * before releasing locks, so do it before running the callbacks.
+	 * We have to remove any files that were supposed to be dropped. For
+	 * consistency with the regular xact.c code paths, must do this before
+	 * releasing locks, so do it before running the callbacks.
 	 *
 	 * NB: this code knows that we couldn't be dropping any temp rels ...
 	 */
@@ -1228,8 +1225,8 @@ ProcessRecords(char *bufptr, TransactionId xid,
 		bufptr += MAXALIGN(sizeof(TwoPhaseRecordOnDisk));
 
 		if (callbacks[record->rmid] != NULL)
-			callbacks[record->rmid](xid, record->info,
-									(void *) bufptr, record->len);
+			callbacks[record->rmid] (xid, record->info,
+									 (void *) bufptr, record->len);
 
 		bufptr += MAXALIGN(record->len);
 	}
@@ -1244,15 +1241,15 @@ ProcessRecords(char *bufptr, TransactionId xid,
 void
 RemoveTwoPhaseFile(TransactionId xid, bool giveWarning)
 {
-	char path[MAXPGPATH];
+	char		path[MAXPGPATH];
 
 	TwoPhaseFilePath(path, xid);
 	if (unlink(path))
 		if (errno != ENOENT || giveWarning)
 			ereport(WARNING,
 					(errcode_for_file_access(),
-					 errmsg("could not remove two-phase state file \"%s\": %m",
-							path)));
+				   errmsg("could not remove two-phase state file \"%s\": %m",
+						  path)));
 }
 
 /*
@@ -1300,8 +1297,8 @@ RecreateTwoPhaseFile(TransactionId xid, void *content, int len)
 	}
 
 	/*
-	 * We must fsync the file because the end-of-replay checkpoint will
-	 * not do so, there being no GXACT in shared memory yet to tell it to.
+	 * We must fsync the file because the end-of-replay checkpoint will not do
+	 * so, there being no GXACT in shared memory yet to tell it to.
 	 */
 	if (pg_fsync(fd) != 0)
 	{
@@ -1343,15 +1340,15 @@ CheckPointTwoPhase(XLogRecPtr redo_horizon)
 	int			i;
 
 	/*
-	 * We don't want to hold the TwoPhaseStateLock while doing I/O,
-	 * so we grab it just long enough to make a list of the XIDs that
-	 * require fsyncing, and then do the I/O afterwards.
+	 * We don't want to hold the TwoPhaseStateLock while doing I/O, so we grab
+	 * it just long enough to make a list of the XIDs that require fsyncing,
+	 * and then do the I/O afterwards.
 	 *
-	 * This approach creates a race condition: someone else could delete
-	 * a GXACT between the time we release TwoPhaseStateLock and the time
-	 * we try to open its state file.  We handle this by special-casing
-	 * ENOENT failures: if we see that, we verify that the GXACT is no
-	 * longer valid, and if so ignore the failure.
+	 * This approach creates a race condition: someone else could delete a GXACT
+	 * between the time we release TwoPhaseStateLock and the time we try to
+	 * open its state file.  We handle this by special-casing ENOENT failures:
+	 * if we see that, we verify that the GXACT is no longer valid, and if so
+	 * ignore the failure.
 	 */
 	if (max_prepared_xacts <= 0)
 		return;					/* nothing to do */
@@ -1362,9 +1359,9 @@ CheckPointTwoPhase(XLogRecPtr redo_horizon)
 
 	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
 	{
-		GlobalTransaction	gxact = TwoPhaseState->prepXacts[i];
+		GlobalTransaction gxact = TwoPhaseState->prepXacts[i];
 
-		if (gxact->valid && 
+		if (gxact->valid &&
 			XLByteLE(gxact->prepare_lsn, redo_horizon))
 			xids[nxids++] = gxact->proc.xid;
 	}
@@ -1374,7 +1371,7 @@ CheckPointTwoPhase(XLogRecPtr redo_horizon)
 	for (i = 0; i < nxids; i++)
 	{
 		TransactionId xid = xids[i];
-		int		fd;
+		int			fd;
 
 		TwoPhaseFilePath(path, xid);
 
@@ -1424,7 +1421,7 @@ CheckPointTwoPhase(XLogRecPtr redo_horizon)
  *
  * We throw away any prepared xacts with main XID beyond nextXid --- if any
  * are present, it suggests that the DBA has done a PITR recovery to an
- * earlier point in time without cleaning out pg_twophase.  We dare not
+ * earlier point in time without cleaning out pg_twophase.	We dare not
  * try to recover such prepared xacts since they likely depend on database
  * state that doesn't exist now.
  *
@@ -1442,7 +1439,7 @@ PrescanPreparedTransactions(void)
 {
 	TransactionId origNextXid = ShmemVariableCache->nextXid;
 	TransactionId result = origNextXid;
-	DIR		*cldir;
+	DIR		   *cldir;
 	struct dirent *clde;
 
 	cldir = AllocateDir(TWOPHASE_DIR);
@@ -1452,10 +1449,10 @@ PrescanPreparedTransactions(void)
 			strspn(clde->d_name, "0123456789ABCDEF") == 8)
 		{
 			TransactionId xid;
-			char *buf;
-			TwoPhaseFileHeader	*hdr;
+			char	   *buf;
+			TwoPhaseFileHeader *hdr;
 			TransactionId *subxids;
-			int i;
+			int			i;
 
 			xid = (TransactionId) strtoul(clde->d_name, NULL, 16);
 
@@ -1541,8 +1538,8 @@ PrescanPreparedTransactions(void)
 void
 RecoverPreparedTransactions(void)
 {
-	char	dir[MAXPGPATH];
-	DIR		*cldir;
+	char		dir[MAXPGPATH];
+	DIR		   *cldir;
 	struct dirent *clde;
 
 	snprintf(dir, MAXPGPATH, "%s", TWOPHASE_DIR);
@@ -1554,12 +1551,12 @@ RecoverPreparedTransactions(void)
 			strspn(clde->d_name, "0123456789ABCDEF") == 8)
 		{
 			TransactionId xid;
-			char *buf;
-			char *bufptr;
-			TwoPhaseFileHeader	*hdr;
+			char	   *buf;
+			char	   *bufptr;
+			TwoPhaseFileHeader *hdr;
 			TransactionId *subxids;
-			GlobalTransaction	gxact;
-			int i;
+			GlobalTransaction gxact;
+			int			i;
 
 			xid = (TransactionId) strtoul(clde->d_name, NULL, 16);
 
@@ -1598,8 +1595,8 @@ RecoverPreparedTransactions(void)
 
 			/*
 			 * Reconstruct subtrans state for the transaction --- needed
-			 * because pg_subtrans is not preserved over a restart.  Note
-			 * that we are linking all the subtransactions directly to the
+			 * because pg_subtrans is not preserved over a restart.  Note that
+			 * we are linking all the subtransactions directly to the
 			 * top-level XID; there may originally have been a more complex
 			 * hierarchy, but there's no need to restore that exactly.
 			 */
@@ -1609,12 +1606,12 @@ RecoverPreparedTransactions(void)
 			/*
 			 * Recreate its GXACT and dummy PGPROC
 			 *
-			 * Note: since we don't have the PREPARE record's WAL location
-			 * at hand, we leave prepare_lsn zeroes.  This means the GXACT
-			 * will be fsync'd on every future checkpoint.  We assume this
+			 * Note: since we don't have the PREPARE record's WAL location at
+			 * hand, we leave prepare_lsn zeroes.  This means the GXACT will
+			 * be fsync'd on every future checkpoint.  We assume this
 			 * situation is infrequent enough that the performance cost is
-			 * negligible (especially since we know the state file has
-			 * already been fsynced).
+			 * negligible (especially since we know the state file has already
+			 * been fsynced).
 			 */
 			gxact = MarkAsPreparing(xid, hdr->gid,
 									hdr->prepared_at,
@@ -1773,12 +1770,11 @@ RecordTransactionAbortPrepared(TransactionId xid,
 	XLogFlush(recptr);
 
 	/*
-	 * Mark the transaction aborted in clog.  This is not absolutely
-	 * necessary but we may as well do it while we are here.
+	 * Mark the transaction aborted in clog.  This is not absolutely necessary
+	 * but we may as well do it while we are here.
 	 */
 	TransactionIdAbort(xid);
 	TransactionIdAbortTree(nchildren, children);
 
 	END_CRIT_SECTION();
 }
-
diff --git a/src/backend/access/transam/twophase_rmgr.c b/src/backend/access/transam/twophase_rmgr.c
index 020dc32ec1..c358890e66 100644
--- a/src/backend/access/transam/twophase_rmgr.c
+++ b/src/backend/access/transam/twophase_rmgr.c
@@ -21,29 +21,29 @@
 #include "utils/inval.h"
 
 
-const TwoPhaseCallback twophase_recover_callbacks[TWOPHASE_RM_MAX_ID + 1] = 
+const TwoPhaseCallback twophase_recover_callbacks[TWOPHASE_RM_MAX_ID + 1] =
 {
-	NULL,							/* END ID */
-	lock_twophase_recover,			/* Lock */
-	NULL,							/* Inval */
-	NULL,							/* flat file update */
-	NULL							/* notify/listen */
+	NULL,						/* END ID */
+	lock_twophase_recover,		/* Lock */
+	NULL,						/* Inval */
+	NULL,						/* flat file update */
+	NULL						/* notify/listen */
 };
 
-const TwoPhaseCallback twophase_postcommit_callbacks[TWOPHASE_RM_MAX_ID + 1] = 
+const TwoPhaseCallback twophase_postcommit_callbacks[TWOPHASE_RM_MAX_ID + 1] =
 {
-	NULL,							/* END ID */
-	lock_twophase_postcommit,		/* Lock */
-	inval_twophase_postcommit,		/* Inval */
-	flatfile_twophase_postcommit,	/* flat file update */
-	notify_twophase_postcommit		/* notify/listen */
+	NULL,						/* END ID */
+	lock_twophase_postcommit,	/* Lock */
+	inval_twophase_postcommit,	/* Inval */
+	flatfile_twophase_postcommit,		/* flat file update */
+	notify_twophase_postcommit	/* notify/listen */
 };
 
-const TwoPhaseCallback twophase_postabort_callbacks[TWOPHASE_RM_MAX_ID + 1] = 
+const TwoPhaseCallback twophase_postabort_callbacks[TWOPHASE_RM_MAX_ID + 1] =
 {
-	NULL,							/* END ID */
-	lock_twophase_postabort,		/* Lock */
-	NULL,							/* Inval */
-	NULL,							/* flat file update */
-	NULL							/* notify/listen */
+	NULL,						/* END ID */
+	lock_twophase_postabort,	/* Lock */
+	NULL,						/* Inval */
+	NULL,						/* flat file update */
+	NULL						/* notify/listen */
 };
diff --git a/src/backend/access/transam/varsup.c b/src/backend/access/transam/varsup.c
index 6f9c6b8b7a..8881c6cc03 100644
--- a/src/backend/access/transam/varsup.c
+++ b/src/backend/access/transam/varsup.c
@@ -49,21 +49,21 @@ GetNewTransactionId(bool isSubXact)
 	xid = ShmemVariableCache->nextXid;
 
 	/*
-	 * Check to see if it's safe to assign another XID.  This protects
-	 * against catastrophic data loss due to XID wraparound.  The basic
-	 * rules are: warn if we're past xidWarnLimit, and refuse to execute
-	 * transactions if we're past xidStopLimit, unless we are running in
-	 * a standalone backend (which gives an escape hatch to the DBA who
-	 * ignored all those warnings).
+	 * Check to see if it's safe to assign another XID.  This protects against
+	 * catastrophic data loss due to XID wraparound.  The basic rules are:
+	 * warn if we're past xidWarnLimit, and refuse to execute transactions if
+	 * we're past xidStopLimit, unless we are running in a standalone backend
+	 * (which gives an escape hatch to the DBA who ignored all those
+	 * warnings).
 	 *
-	 * Test is coded to fall out as fast as possible during normal operation,
-	 * ie, when the warn limit is set and we haven't violated it.
+	 * Test is coded to fall out as fast as possible during normal operation, ie,
+	 * when the warn limit is set and we haven't violated it.
 	 */
 	if (TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidWarnLimit) &&
 		TransactionIdIsValid(ShmemVariableCache->xidWarnLimit))
 	{
 		if (IsUnderPostmaster &&
-			TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidStopLimit))
+		 TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidStopLimit))
 			ereport(ERROR,
 					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 					 errmsg("database is not accepting queries to avoid wraparound data loss in database \"%s\"",
@@ -72,20 +72,19 @@ GetNewTransactionId(bool isSubXact)
 							 NameStr(ShmemVariableCache->limit_datname))));
 		else
 			ereport(WARNING,
-					(errmsg("database \"%s\" must be vacuumed within %u transactions",
-							NameStr(ShmemVariableCache->limit_datname),
-							ShmemVariableCache->xidWrapLimit - xid),
-					 errhint("To avoid a database shutdown, execute a full-database VACUUM in \"%s\".",
-							 NameStr(ShmemVariableCache->limit_datname))));
+			(errmsg("database \"%s\" must be vacuumed within %u transactions",
+					NameStr(ShmemVariableCache->limit_datname),
+					ShmemVariableCache->xidWrapLimit - xid),
+			 errhint("To avoid a database shutdown, execute a full-database VACUUM in \"%s\".",
+					 NameStr(ShmemVariableCache->limit_datname))));
 	}
 
 	/*
 	 * If we are allocating the first XID of a new page of the commit log,
-	 * zero out that commit-log page before returning. We must do this
-	 * while holding XidGenLock, else another xact could acquire and
-	 * commit a later XID before we zero the page.	Fortunately, a page of
-	 * the commit log holds 32K or more transactions, so we don't have to
-	 * do this very often.
+	 * zero out that commit-log page before returning. We must do this while
+	 * holding XidGenLock, else another xact could acquire and commit a later
+	 * XID before we zero the page.  Fortunately, a page of the commit log
+	 * holds 32K or more transactions, so we don't have to do this very often.
 	 *
 	 * Extend pg_subtrans too.
 	 */
@@ -93,45 +92,43 @@ GetNewTransactionId(bool isSubXact)
 	ExtendSUBTRANS(xid);
 
 	/*
-	 * Now advance the nextXid counter.  This must not happen until after
-	 * we have successfully completed ExtendCLOG() --- if that routine
-	 * fails, we want the next incoming transaction to try it again.  We
-	 * cannot assign more XIDs until there is CLOG space for them.
+	 * Now advance the nextXid counter.  This must not happen until after we
+	 * have successfully completed ExtendCLOG() --- if that routine fails, we
+	 * want the next incoming transaction to try it again.	We cannot assign
+	 * more XIDs until there is CLOG space for them.
 	 */
 	TransactionIdAdvance(ShmemVariableCache->nextXid);
 
 	/*
-	 * We must store the new XID into the shared PGPROC array before
-	 * releasing XidGenLock.  This ensures that when GetSnapshotData calls
+	 * We must store the new XID into the shared PGPROC array before releasing
+	 * XidGenLock.	This ensures that when GetSnapshotData calls
 	 * ReadNewTransactionId, all active XIDs before the returned value of
-	 * nextXid are already present in PGPROC.  Else we have a race
-	 * condition.
+	 * nextXid are already present in PGPROC.  Else we have a race condition.
 	 *
 	 * XXX by storing xid into MyProc without acquiring ProcArrayLock, we are
 	 * relying on fetch/store of an xid to be atomic, else other backends
 	 * might see a partially-set xid here.	But holding both locks at once
-	 * would be a nasty concurrency hit (and in fact could cause a
-	 * deadlock against GetSnapshotData).  So for now, assume atomicity.
-	 * Note that readers of PGPROC xid field should be careful to fetch
-	 * the value only once, rather than assume they can read it multiple
-	 * times and get the same answer each time.
+	 * would be a nasty concurrency hit (and in fact could cause a deadlock
+	 * against GetSnapshotData).  So for now, assume atomicity. Note that
+	 * readers of PGPROC xid field should be careful to fetch the value only
+	 * once, rather than assume they can read it multiple times and get the
+	 * same answer each time.
 	 *
 	 * The same comments apply to the subxact xid count and overflow fields.
 	 *
-	 * A solution to the atomic-store problem would be to give each PGPROC
-	 * its own spinlock used only for fetching/storing that PGPROC's xid
-	 * and related fields.
+	 * A solution to the atomic-store problem would be to give each PGPROC its
+	 * own spinlock used only for fetching/storing that PGPROC's xid and
+	 * related fields.
 	 *
 	 * If there's no room to fit a subtransaction XID into PGPROC, set the
 	 * cache-overflowed flag instead.  This forces readers to look in
-	 * pg_subtrans to map subtransaction XIDs up to top-level XIDs. There
-	 * is a race-condition window, in that the new XID will not appear as
-	 * running until its parent link has been placed into pg_subtrans.
-	 * However, that will happen before anyone could possibly have a
-	 * reason to inquire about the status of the XID, so it seems OK.
-	 * (Snapshots taken during this window *will* include the parent XID,
-	 * so they will deliver the correct answer later on when someone does
-	 * have a reason to inquire.)
+	 * pg_subtrans to map subtransaction XIDs up to top-level XIDs. There is a
+	 * race-condition window, in that the new XID will not appear as running
+	 * until its parent link has been placed into pg_subtrans. However, that
+	 * will happen before anyone could possibly have a reason to inquire about
+	 * the status of the XID, so it seems OK. (Snapshots taken during this
+	 * window *will* include the parent XID, so they will deliver the correct
+	 * answer later on when someone does have a reason to inquire.)
 	 */
 	if (MyProc != NULL)
 	{
@@ -197,27 +194,26 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
 		xidWrapLimit += FirstNormalTransactionId;
 
 	/*
-	 * We'll refuse to continue assigning XIDs in interactive mode once
-	 * we get within 1M transactions of data loss.  This leaves lots
-	 * of room for the DBA to fool around fixing things in a standalone
-	 * backend, while not being significant compared to total XID space.
-	 * (Note that since vacuuming requires one transaction per table
-	 * cleaned, we had better be sure there's lots of XIDs left...)
+	 * We'll refuse to continue assigning XIDs in interactive mode once we get
+	 * within 1M transactions of data loss.  This leaves lots of room for the
+	 * DBA to fool around fixing things in a standalone backend, while not
+	 * being significant compared to total XID space. (Note that since
+	 * vacuuming requires one transaction per table cleaned, we had better be
+	 * sure there's lots of XIDs left...)
 	 */
 	xidStopLimit = xidWrapLimit - 1000000;
 	if (xidStopLimit < FirstNormalTransactionId)
 		xidStopLimit -= FirstNormalTransactionId;
 
 	/*
-	 * We'll start complaining loudly when we get within 10M transactions
-	 * of the stop point.  This is kind of arbitrary, but if you let your
-	 * gas gauge get down to 1% of full, would you be looking for the
-	 * next gas station?  We need to be fairly liberal about this number
-	 * because there are lots of scenarios where most transactions are
-	 * done by automatic clients that won't pay attention to warnings.
-	 * (No, we're not gonna make this configurable.  If you know enough to
-	 * configure it, you know enough to not get in this kind of trouble in
-	 * the first place.)
+	 * We'll start complaining loudly when we get within 10M transactions of
+	 * the stop point.	This is kind of arbitrary, but if you let your gas
+	 * gauge get down to 1% of full, would you be looking for the next gas
+	 * station?  We need to be fairly liberal about this number because there
+	 * are lots of scenarios where most transactions are done by automatic
+	 * clients that won't pay attention to warnings. (No, we're not gonna make
+	 * this configurable.  If you know enough to configure it, you know enough
+	 * to not get in this kind of trouble in the first place.)
 	 */
 	xidWarnLimit = xidStopLimit - 10000000;
 	if (xidWarnLimit < FirstNormalTransactionId)
@@ -234,16 +230,16 @@ SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
 
 	/* Log the info */
 	ereport(LOG,
-			(errmsg("transaction ID wrap limit is %u, limited by database \"%s\"",
-					xidWrapLimit, NameStr(*oldest_datname))));
+	   (errmsg("transaction ID wrap limit is %u, limited by database \"%s\"",
+			   xidWrapLimit, NameStr(*oldest_datname))));
 	/* Give an immediate warning if past the wrap warn point */
 	if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit))
 		ereport(WARNING,
-				(errmsg("database \"%s\" must be vacuumed within %u transactions",
-						NameStr(*oldest_datname),
-						xidWrapLimit - curXid),
-				 errhint("To avoid a database shutdown, execute a full-database VACUUM in \"%s\".",
-						 NameStr(*oldest_datname))));
+		   (errmsg("database \"%s\" must be vacuumed within %u transactions",
+				   NameStr(*oldest_datname),
+				   xidWrapLimit - curXid),
+			errhint("To avoid a database shutdown, execute a full-database VACUUM in \"%s\".",
+					NameStr(*oldest_datname))));
 }
 
 
@@ -272,11 +268,11 @@ GetNewObjectId(void)
 	 * right after a wrap occurs, so as to avoid a possibly large number of
 	 * iterations in GetNewOid.)  Note we are relying on unsigned comparison.
 	 *
-	 * During initdb, we start the OID generator at FirstBootstrapObjectId,
-	 * so we only enforce wrapping to that point when in bootstrap or
-	 * standalone mode.  The first time through this routine after normal
-	 * postmaster start, the counter will be forced up to FirstNormalObjectId.
-	 * This mechanism leaves the OIDs between FirstBootstrapObjectId and
+	 * During initdb, we start the OID generator at FirstBootstrapObjectId, so we
+	 * only enforce wrapping to that point when in bootstrap or standalone
+	 * mode.  The first time through this routine after normal postmaster
+	 * start, the counter will be forced up to FirstNormalObjectId. This
+	 * mechanism leaves the OIDs between FirstBootstrapObjectId and
 	 * FirstNormalObjectId available for automatic assignment during initdb,
 	 * while ensuring they will never conflict with user-assigned OIDs.
 	 */
diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
index 7b851713b2..305a599760 100644
--- a/src/backend/access/transam/xact.c
+++ b/src/backend/access/transam/xact.c
@@ -110,15 +110,14 @@ typedef enum TBlockState
  */
 typedef struct TransactionStateData
 {
-	TransactionId transactionId;		/* my XID, or Invalid if none */
+	TransactionId transactionId;	/* my XID, or Invalid if none */
 	SubTransactionId subTransactionId;	/* my subxact ID */
 	char	   *name;			/* savepoint name, if any */
 	int			savepointLevel; /* savepoint level */
 	TransState	state;			/* low-level state */
 	TBlockState blockState;		/* high-level state */
 	int			nestingLevel;	/* nest depth */
-	MemoryContext curTransactionContext;		/* my xact-lifetime
-												 * context */
+	MemoryContext curTransactionContext;		/* my xact-lifetime context */
 	ResourceOwner curTransactionOwner;	/* my query resources */
 	List	   *childXids;		/* subcommitted child XIDs */
 	Oid			currentUser;	/* subxact start current_user */
@@ -219,8 +218,8 @@ static void AtStart_Memory(void);
 static void AtStart_ResourceOwner(void);
 static void CallXactCallbacks(XactEvent event);
 static void CallSubXactCallbacks(SubXactEvent event,
-								 SubTransactionId mySubid,
-								 SubTransactionId parentSubid);
+					 SubTransactionId mySubid,
+					 SubTransactionId parentSubid);
 static void CleanupTransaction(void);
 static void CommitTransaction(void);
 static void RecordTransactionAbort(void);
@@ -349,18 +348,18 @@ AssignSubTransactionId(TransactionState s)
 	/*
 	 * Generate a new Xid and record it in PG_PROC and pg_subtrans.
 	 *
-	 * NB: we must make the subtrans entry BEFORE the Xid appears anywhere
-	 * in shared storage other than PG_PROC; because if there's no room for
-	 * it in PG_PROC, the subtrans entry is needed to ensure that other
-	 * backends see the Xid as "running".  See GetNewTransactionId.
+	 * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
+	 * shared storage other than PG_PROC; because if there's no room for it in
+	 * PG_PROC, the subtrans entry is needed to ensure that other backends see
+	 * the Xid as "running".  See GetNewTransactionId.
 	 */
 	s->transactionId = GetNewTransactionId(true);
 
 	SubTransSetParent(s->transactionId, s->parent->transactionId);
 
 	/*
-	 * Acquire lock on the transaction XID.  (We assume this cannot block.)
-	 * We have to be sure that the lock is assigned to the transaction's
+	 * Acquire lock on the transaction XID.  (We assume this cannot block.) We
+	 * have to be sure that the lock is assigned to the transaction's
 	 * ResourceOwner.
 	 */
 	currentOwner = CurrentResourceOwner;
@@ -453,22 +452,22 @@ TransactionIdIsCurrentTransactionId(TransactionId xid)
 
 	/*
 	 * We always say that BootstrapTransactionId is "not my transaction ID"
-	 * even when it is (ie, during bootstrap).  Along with the fact that
+	 * even when it is (ie, during bootstrap).	Along with the fact that
 	 * transam.c always treats BootstrapTransactionId as already committed,
-	 * this causes the tqual.c routines to see all tuples as committed,
-	 * which is what we need during bootstrap.  (Bootstrap mode only inserts
-	 * tuples, it never updates or deletes them, so all tuples can be presumed
-	 * good immediately.)
+	 * this causes the tqual.c routines to see all tuples as committed, which
+	 * is what we need during bootstrap.  (Bootstrap mode only inserts tuples,
+	 * it never updates or deletes them, so all tuples can be presumed good
+	 * immediately.)
 	 */
 	if (xid == BootstrapTransactionId)
 		return false;
 
 	/*
-	 * We will return true for the Xid of the current subtransaction, any
-	 * of its subcommitted children, any of its parents, or any of their
-	 * previously subcommitted children.  However, a transaction being
-	 * aborted is no longer "current", even though it may still have an
-	 * entry on the state stack.
+	 * We will return true for the Xid of the current subtransaction, any of
+	 * its subcommitted children, any of its parents, or any of their
+	 * previously subcommitted children.  However, a transaction being aborted
+	 * is no longer "current", even though it may still have an entry on the
+	 * state stack.
 	 */
 	for (s = CurrentTransactionState; s != NULL; s = s->parent)
 	{
@@ -498,12 +497,12 @@ void
 CommandCounterIncrement(void)
 {
 	currentCommandId += 1;
-	if (currentCommandId == FirstCommandId) /* check for overflow */
+	if (currentCommandId == FirstCommandId)		/* check for overflow */
 	{
 		currentCommandId -= 1;
 		ereport(ERROR,
 				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-				 errmsg("cannot have more than 2^32-1 commands in a transaction")));
+		  errmsg("cannot have more than 2^32-1 commands in a transaction")));
 	}
 
 	/* Propagate new command ID into static snapshots, if set */
@@ -607,16 +606,15 @@ AtSubStart_Memory(void)
 	Assert(CurTransactionContext != NULL);
 
 	/*
-	 * Create a CurTransactionContext, which will be used to hold data
-	 * that survives subtransaction commit but disappears on
-	 * subtransaction abort. We make it a child of the immediate parent's
-	 * CurTransactionContext.
+	 * Create a CurTransactionContext, which will be used to hold data that
+	 * survives subtransaction commit but disappears on subtransaction abort.
+	 * We make it a child of the immediate parent's CurTransactionContext.
 	 */
 	CurTransactionContext = AllocSetContextCreate(CurTransactionContext,
 												  "CurTransactionContext",
-												ALLOCSET_DEFAULT_MINSIZE,
-											   ALLOCSET_DEFAULT_INITSIZE,
-											   ALLOCSET_DEFAULT_MAXSIZE);
+												  ALLOCSET_DEFAULT_MINSIZE,
+												  ALLOCSET_DEFAULT_INITSIZE,
+												  ALLOCSET_DEFAULT_MAXSIZE);
 	s->curTransactionContext = CurTransactionContext;
 
 	/* Make the CurTransactionContext active. */
@@ -634,8 +632,8 @@ AtSubStart_ResourceOwner(void)
 	Assert(s->parent != NULL);
 
 	/*
-	 * Create a resource owner for the subtransaction.	We make it a child
-	 * of the immediate parent's resource owner.
+	 * Create a resource owner for the subtransaction.	We make it a child of
+	 * the immediate parent's resource owner.
 	 */
 	s->curTransactionOwner =
 		ResourceOwnerCreate(s->parent->curTransactionOwner,
@@ -666,11 +664,10 @@ RecordTransactionCommit(void)
 	nchildren = xactGetCommittedChildren(&children);
 
 	/*
-	 * If we made neither any XLOG entries nor any temp-rel updates, and
-	 * have no files to be deleted, we can omit recording the transaction
-	 * commit at all.  (This test includes the effects of subtransactions,
-	 * so the presence of committed subxacts need not alone force a
-	 * write.)
+	 * If we made neither any XLOG entries nor any temp-rel updates, and have
+	 * no files to be deleted, we can omit recording the transaction commit at
+	 * all.  (This test includes the effects of subtransactions, so the
+	 * presence of committed subxacts need not alone force a write.)
 	 */
 	if (MyXactMadeXLogEntry || MyXactMadeTempRelUpdate || nrels > 0)
 	{
@@ -684,18 +681,17 @@ RecordTransactionCommit(void)
 		START_CRIT_SECTION();
 
 		/*
-		 * If our transaction made any transaction-controlled XLOG
-		 * entries, we need to lock out checkpoint start between writing
-		 * our XLOG record and updating pg_clog.  Otherwise it is possible
-		 * for the checkpoint to set REDO after the XLOG record but fail
-		 * to flush the pg_clog update to disk, leading to loss of the
-		 * transaction commit if we crash a little later.  Slightly klugy
-		 * fix for problem discovered 2004-08-10.
+		 * If our transaction made any transaction-controlled XLOG entries, we
+		 * need to lock out checkpoint start between writing our XLOG record
+		 * and updating pg_clog.  Otherwise it is possible for the checkpoint
+		 * to set REDO after the XLOG record but fail to flush the pg_clog
+		 * update to disk, leading to loss of the transaction commit if we
+		 * crash a little later.  Slightly klugy fix for problem discovered
+		 * 2004-08-10.
 		 *
-		 * (If it made no transaction-controlled XLOG entries, its XID
-		 * appears nowhere in permanent storage, so no one else will ever
-		 * care if it committed; so it doesn't matter if we lose the
-		 * commit flag.)
+		 * (If it made no transaction-controlled XLOG entries, its XID appears
+		 * nowhere in permanent storage, so no one else will ever care if it
+		 * committed; so it doesn't matter if we lose the commit flag.)
 		 *
 		 * Note we only need a shared lock.
 		 */
@@ -704,8 +700,8 @@ RecordTransactionCommit(void)
 			LWLockAcquire(CheckpointStartLock, LW_SHARED);
 
 		/*
-		 * We only need to log the commit in XLOG if the transaction made
-		 * any transaction-controlled XLOG entries or will delete files.
+		 * We only need to log the commit in XLOG if the transaction made any
+		 * transaction-controlled XLOG entries or will delete files.
 		 */
 		if (madeTCentries || nrels > 0)
 		{
@@ -748,26 +744,26 @@ RecordTransactionCommit(void)
 		}
 
 		/*
-		 * We must flush our XLOG entries to disk if we made any XLOG
-		 * entries, whether in or out of transaction control.  For
-		 * example, if we reported a nextval() result to the client, this
-		 * ensures that any XLOG record generated by nextval will hit the
-		 * disk before we report the transaction committed.
+		 * We must flush our XLOG entries to disk if we made any XLOG entries,
+		 * whether in or out of transaction control.  For example, if we
+		 * reported a nextval() result to the client, this ensures that any
+		 * XLOG record generated by nextval will hit the disk before we report
+		 * the transaction committed.
 		 *
-		 * Note: if we generated a commit record above, MyXactMadeXLogEntry
-		 * will certainly be set now.
+		 * Note: if we generated a commit record above, MyXactMadeXLogEntry will
+		 * certainly be set now.
 		 */
 		if (MyXactMadeXLogEntry)
 		{
 			/*
 			 * Sleep before flush! So we can flush more than one commit
-			 * records per single fsync.  (The idea is some other backend
-			 * may do the XLogFlush while we're sleeping.  This needs work
-			 * still, because on most Unixen, the minimum select() delay
-			 * is 10msec or more, which is way too long.)
+			 * records per single fsync.  (The idea is some other backend may
+			 * do the XLogFlush while we're sleeping.  This needs work still,
+			 * because on most Unixen, the minimum select() delay is 10msec or
+			 * more, which is way too long.)
 			 *
-			 * We do not sleep if enableFsync is not turned on, nor if there
-			 * are fewer than CommitSiblings other backends with active
+			 * We do not sleep if enableFsync is not turned on, nor if there are
+			 * fewer than CommitSiblings other backends with active
 			 * transactions.
 			 */
 			if (CommitDelay > 0 && enableFsync &&
@@ -778,14 +774,13 @@ RecordTransactionCommit(void)
 		}
 
 		/*
-		 * We must mark the transaction committed in clog if its XID
-		 * appears either in permanent rels or in local temporary rels. We
-		 * test this by seeing if we made transaction-controlled entries
-		 * *OR* local-rel tuple updates.  Note that if we made only the
-		 * latter, we have not emitted an XLOG record for our commit, and
-		 * so in the event of a crash the clog update might be lost.  This
-		 * is okay because no one else will ever care whether we
-		 * committed.
+		 * We must mark the transaction committed in clog if its XID appears
+		 * either in permanent rels or in local temporary rels. We test this
+		 * by seeing if we made transaction-controlled entries *OR* local-rel
+		 * tuple updates.  Note that if we made only the latter, we have not
+		 * emitted an XLOG record for our commit, and so in the event of a
+		 * crash the clog update might be lost.  This is okay because no one
+		 * else will ever care whether we committed.
 		 */
 		if (madeTCentries || MyXactMadeTempRelUpdate)
 		{
@@ -833,9 +828,8 @@ static void
 AtCommit_Memory(void)
 {
 	/*
-	 * Now that we're "out" of a transaction, have the system allocate
-	 * things in the top memory context instead of per-transaction
-	 * contexts.
+	 * Now that we're "out" of a transaction, have the system allocate things
+	 * in the top memory context instead of per-transaction contexts.
 	 */
 	MemoryContextSwitchTo(TopMemoryContext);
 
@@ -870,9 +864,9 @@ AtSubCommit_Memory(void)
 
 	/*
 	 * Ordinarily we cannot throw away the child's CurTransactionContext,
-	 * since the data it contains will be needed at upper commit.  However,
-	 * if there isn't actually anything in it, we can throw it away.  This
-	 * avoids a small memory leak in the common case of "trivial" subxacts.
+	 * since the data it contains will be needed at upper commit.  However, if
+	 * there isn't actually anything in it, we can throw it away.  This avoids
+	 * a small memory leak in the common case of "trivial" subxacts.
 	 */
 	if (MemoryContextIsEmpty(s->curTransactionContext))
 	{
@@ -908,9 +902,10 @@ AtSubCommit_childXids(void)
 	{
 		s->parent->childXids = list_concat(s->parent->childXids,
 										   s->childXids);
+
 		/*
-		 * list_concat doesn't free the list header for the second list;
-		 * do so here to avoid memory leakage (kluge)
+		 * list_concat doesn't free the list header for the second list; do so
+		 * here to avoid memory leakage (kluge)
 		 */
 		pfree(s->childXids);
 		s->childXids = NIL;
@@ -929,14 +924,14 @@ RecordSubTransactionCommit(void)
 	 * We do not log the subcommit in XLOG; it doesn't matter until the
 	 * top-level transaction commits.
 	 *
-	 * We must mark the subtransaction subcommitted in clog if its XID
-	 * appears either in permanent rels or in local temporary rels. We
-	 * test this by seeing if we made transaction-controlled entries *OR*
-	 * local-rel tuple updates.  (The test here actually covers the entire
-	 * transaction tree so far, so it may mark subtransactions that don't
-	 * really need it, but it's probably not worth being tenser. Note that
-	 * if a prior subtransaction dirtied these variables, then
-	 * RecordTransactionCommit will have to do the full pushup anyway...)
+	 * We must mark the subtransaction subcommitted in clog if its XID appears
+	 * either in permanent rels or in local temporary rels. We test this by
+	 * seeing if we made transaction-controlled entries *OR* local-rel tuple
+	 * updates.  (The test here actually covers the entire transaction tree so
+	 * far, so it may mark subtransactions that don't really need it, but it's
+	 * probably not worth being tenser. Note that if a prior subtransaction
+	 * dirtied these variables, then RecordTransactionCommit will have to do
+	 * the full pushup anyway...)
 	 */
 	if (MyLastRecPtr.xrecoff != 0 || MyXactMadeTempRelUpdate)
 	{
@@ -974,9 +969,9 @@ RecordTransactionAbort(void)
 
 	/*
 	 * If we made neither any transaction-controlled XLOG entries nor any
-	 * temp-rel updates, and are not going to delete any files, we can
-	 * omit recording the transaction abort at all.  No one will ever care
-	 * that it aborted.  (These tests cover our whole transaction tree.)
+	 * temp-rel updates, and are not going to delete any files, we can omit
+	 * recording the transaction abort at all.	No one will ever care that it
+	 * aborted.  (These tests cover our whole transaction tree.)
 	 */
 	if (MyLastRecPtr.xrecoff != 0 || MyXactMadeTempRelUpdate || nrels > 0)
 	{
@@ -992,16 +987,16 @@ RecordTransactionAbort(void)
 		START_CRIT_SECTION();
 
 		/*
-		 * We only need to log the abort in XLOG if the transaction made
-		 * any transaction-controlled XLOG entries or will delete files.
-		 * (If it made no transaction-controlled XLOG entries, its XID
-		 * appears nowhere in permanent storage, so no one else will ever
-		 * care if it committed.)
+		 * We only need to log the abort in XLOG if the transaction made any
+		 * transaction-controlled XLOG entries or will delete files. (If it
+		 * made no transaction-controlled XLOG entries, its XID appears
+		 * nowhere in permanent storage, so no one else will ever care if it
+		 * committed.)
 		 *
-		 * We do not flush XLOG to disk unless deleting files, since the
-		 * default assumption after a crash would be that we aborted,
-		 * anyway. For the same reason, we don't need to worry about
-		 * interlocking against checkpoint start.
+		 * We do not flush XLOG to disk unless deleting files, since the default
+		 * assumption after a crash would be that we aborted, anyway. For the
+		 * same reason, we don't need to worry about interlocking against
+		 * checkpoint start.
 		 */
 		if (MyLastRecPtr.xrecoff != 0 || nrels > 0)
 		{
@@ -1047,8 +1042,8 @@ RecordTransactionAbort(void)
 		 * Mark the transaction aborted in clog.  This is not absolutely
 		 * necessary but we may as well do it while we are here.
 		 *
-		 * The ordering here isn't critical but it seems best to mark the
-		 * parent first.  This assures an atomic transition of all the
+		 * The ordering here isn't critical but it seems best to mark the parent
+		 * first.  This assures an atomic transition of all the
 		 * subtransactions to aborted state from the point of view of
 		 * concurrent TransactionIdDidAbort calls.
 		 */
@@ -1078,8 +1073,8 @@ AtAbort_Memory(void)
 {
 	/*
 	 * Make sure we are in a valid context (not a child of
-	 * TopTransactionContext...).  Note that it is possible for this code
-	 * to be called when we aren't in a transaction at all; go directly to
+	 * TopTransactionContext...).  Note that it is possible for this code to
+	 * be called when we aren't in a transaction at all; go directly to
 	 * TopMemoryContext in that case.
 	 */
 	if (TopTransactionContext != NULL)
@@ -1087,8 +1082,8 @@ AtAbort_Memory(void)
 		MemoryContextSwitchTo(TopTransactionContext);
 
 		/*
-		 * We do not want to destroy the transaction's global state yet,
-		 * so we can't free any memory here.
+		 * We do not want to destroy the transaction's global state yet, so we
+		 * can't free any memory here.
 		 */
 	}
 	else
@@ -1114,8 +1109,8 @@ static void
 AtAbort_ResourceOwner(void)
 {
 	/*
-	 * Make sure we have a valid ResourceOwner, if possible (else it
-	 * will be NULL, which is OK)
+	 * Make sure we have a valid ResourceOwner, if possible (else it will be
+	 * NULL, which is OK)
 	 */
 	CurrentResourceOwner = TopTransactionResourceOwner;
 }
@@ -1143,7 +1138,7 @@ AtSubAbort_childXids(void)
 
 	/*
 	 * We keep the child-XID lists in TopTransactionContext (see
-	 * AtSubCommit_childXids).  This means we'd better free the list
+	 * AtSubCommit_childXids).	This means we'd better free the list
 	 * explicitly at abort to avoid leakage.
 	 */
 	list_free(s->childXids);
@@ -1168,11 +1163,11 @@ RecordSubTransactionAbort(void)
 
 	/*
 	 * If we made neither any transaction-controlled XLOG entries nor any
-	 * temp-rel updates, and are not going to delete any files, we can
-	 * omit recording the transaction abort at all.  No one will ever care
-	 * that it aborted.  (These tests cover our whole transaction tree,
-	 * and therefore may mark subxacts that don't really need it, but it's
-	 * probably not worth being tenser.)
+	 * temp-rel updates, and are not going to delete any files, we can omit
+	 * recording the transaction abort at all.	No one will ever care that it
+	 * aborted.  (These tests cover our whole transaction tree, and therefore
+	 * may mark subxacts that don't really need it, but it's probably not
+	 * worth being tenser.)
 	 *
 	 * In this case we needn't worry about marking subcommitted children as
 	 * aborted, because they didn't mark themselves as subcommitted in the
@@ -1183,8 +1178,8 @@ RecordSubTransactionAbort(void)
 		START_CRIT_SECTION();
 
 		/*
-		 * We only need to log the abort in XLOG if the transaction made
-		 * any transaction-controlled XLOG entries or will delete files.
+		 * We only need to log the abort in XLOG if the transaction made any
+		 * transaction-controlled XLOG entries or will delete files.
 		 */
 		if (MyLastRecPtr.xrecoff != 0 || nrels > 0)
 		{
@@ -1238,11 +1233,10 @@ RecordSubTransactionAbort(void)
 	}
 
 	/*
-	 * We can immediately remove failed XIDs from PGPROC's cache of
-	 * running child XIDs. It's easiest to do it here while we have the
-	 * child XID array at hand, even though in the main-transaction case
-	 * the equivalent work happens just after return from
-	 * RecordTransactionAbort.
+	 * We can immediately remove failed XIDs from PGPROC's cache of running
+	 * child XIDs. It's easiest to do it here while we have the child XID
+	 * array at hand, even though in the main-transaction case the equivalent
+	 * work happens just after return from RecordTransactionAbort.
 	 */
 	XidCacheRemoveRunningXids(xid, nchildren, children);
 
@@ -1265,9 +1259,8 @@ static void
 AtCleanup_Memory(void)
 {
 	/*
-	 * Now that we're "out" of a transaction, have the system allocate
-	 * things in the top memory context instead of per-transaction
-	 * contexts.
+	 * Now that we're "out" of a transaction, have the system allocate things
+	 * in the top memory context instead of per-transaction contexts.
 	 */
 	MemoryContextSwitchTo(TopMemoryContext);
 
@@ -1304,9 +1297,9 @@ AtSubCleanup_Memory(void)
 	CurTransactionContext = s->parent->curTransactionContext;
 
 	/*
-	 * Delete the subxact local memory contexts. Its CurTransactionContext
-	 * can go too (note this also kills CurTransactionContexts from any
-	 * children of the subxact).
+	 * Delete the subxact local memory contexts. Its CurTransactionContext can
+	 * go too (note this also kills CurTransactionContexts from any children
+	 * of the subxact).
 	 */
 	if (s->curTransactionContext)
 		MemoryContextDelete(s->curTransactionContext);
@@ -1344,11 +1337,10 @@ StartTransaction(void)
 	 * start processing
 	 */
 	s->state = TRANS_START;
-	s->transactionId = InvalidTransactionId; /* until assigned */
+	s->transactionId = InvalidTransactionId;	/* until assigned */
 
 	/*
-	 * Make sure we've freed any old snapshot, and reset xact state
-	 * variables
+	 * Make sure we've freed any old snapshot, and reset xact state variables
 	 */
 	FreeXactSnapshot();
 	XactIsoLevel = DefaultXactIsoLevel;
@@ -1386,10 +1378,10 @@ StartTransaction(void)
 	s->childXids = NIL;
 
 	/*
-	 * You might expect to see "s->currentUser = GetUserId();" here, but
-	 * you won't because it doesn't work during startup; the userid isn't
-	 * set yet during a backend's first transaction start.  We only use
-	 * the currentUser field in sub-transaction state structs.
+	 * You might expect to see "s->currentUser = GetUserId();" here, but you
+	 * won't because it doesn't work during startup; the userid isn't set yet
+	 * during a backend's first transaction start.  We only use the
+	 * currentUser field in sub-transaction state structs.
 	 *
 	 * prevXactReadOnly is also valid only in sub-transactions.
 	 */
@@ -1432,13 +1424,12 @@ CommitTransaction(void)
 	Assert(s->parent == NULL);
 
 	/*
-	 * Do pre-commit processing (most of this stuff requires database
-	 * access, and in fact could still cause an error...)
+	 * Do pre-commit processing (most of this stuff requires database access,
+	 * and in fact could still cause an error...)
 	 *
-	 * It is possible for CommitHoldablePortals to invoke functions that
-	 * queue deferred triggers, and it's also possible that triggers create
-	 * holdable cursors.  So we have to loop until there's nothing left to
-	 * do.
+	 * It is possible for CommitHoldablePortals to invoke functions that queue
+	 * deferred triggers, and it's also possible that triggers create holdable
+	 * cursors.  So we have to loop until there's nothing left to do.
 	 */
 	for (;;)
 	{
@@ -1525,19 +1516,19 @@ CommitTransaction(void)
 	}
 
 	/*
-	 * This is all post-commit cleanup.  Note that if an error is raised
-	 * here, it's too late to abort the transaction.  This should be just
+	 * This is all post-commit cleanup.  Note that if an error is raised here,
+	 * it's too late to abort the transaction.  This should be just
 	 * noncritical resource releasing.
 	 *
-	 * The ordering of operations is not entirely random.  The idea is:
-	 * release resources visible to other backends (eg, files, buffer
-	 * pins); then release locks; then release backend-local resources. We
-	 * want to release locks at the point where any backend waiting for us
-	 * will see our transaction as being fully cleaned up.
+	 * The ordering of operations is not entirely random.  The idea is: release
+	 * resources visible to other backends (eg, files, buffer pins); then
+	 * release locks; then release backend-local resources. We want to release
+	 * locks at the point where any backend waiting for us will see our
+	 * transaction as being fully cleaned up.
 	 *
-	 * Resources that can be associated with individual queries are handled
-	 * by the ResourceOwner mechanism.	The other calls here are for
-	 * backend-wide state.
+	 * Resources that can be associated with individual queries are handled by
+	 * the ResourceOwner mechanism.  The other calls here are for backend-wide
+	 * state.
 	 */
 
 	CallXactCallbacks(XACT_EVENT_COMMIT);
@@ -1553,12 +1544,11 @@ CommitTransaction(void)
 	AtEOXact_RelationCache(true);
 
 	/*
-	 * Make catalog changes visible to all backends.  This has to happen
-	 * after relcache references are dropped (see comments for
-	 * AtEOXact_RelationCache), but before locks are released (if anyone
-	 * is waiting for lock on a relation we've modified, we want them to
-	 * know about the catalog change before they start using the
-	 * relation).
+	 * Make catalog changes visible to all backends.  This has to happen after
+	 * relcache references are dropped (see comments for
+	 * AtEOXact_RelationCache), but before locks are released (if anyone is
+	 * waiting for lock on a relation we've modified, we want them to know
+	 * about the catalog change before they start using the relation).
 	 */
 	AtEOXact_Inval(true);
 
@@ -1621,10 +1611,10 @@ CommitTransaction(void)
 static void
 PrepareTransaction(void)
 {
-	TransactionState	s = CurrentTransactionState;
-	TransactionId		xid = GetCurrentTransactionId();
-	GlobalTransaction	gxact;
-	TimestampTz			prepared_at;
+	TransactionState s = CurrentTransactionState;
+	TransactionId xid = GetCurrentTransactionId();
+	GlobalTransaction gxact;
+	TimestampTz prepared_at;
 
 	ShowTransactionState("PrepareTransaction");
 
@@ -1637,13 +1627,12 @@ PrepareTransaction(void)
 	Assert(s->parent == NULL);
 
 	/*
-	 * Do pre-commit processing (most of this stuff requires database
-	 * access, and in fact could still cause an error...)
+	 * Do pre-commit processing (most of this stuff requires database access,
+	 * and in fact could still cause an error...)
 	 *
-	 * It is possible for PrepareHoldablePortals to invoke functions that
-	 * queue deferred triggers, and it's also possible that triggers create
-	 * holdable cursors.  So we have to loop until there's nothing left to
-	 * do.
+	 * It is possible for PrepareHoldablePortals to invoke functions that queue
+	 * deferred triggers, and it's also possible that triggers create holdable
+	 * cursors.  So we have to loop until there's nothing left to do.
 	 */
 	for (;;)
 	{
@@ -1693,8 +1682,8 @@ PrepareTransaction(void)
 	BufmgrCommit();
 
 	/*
-	 * Reserve the GID for this transaction. This could fail if the
-	 * requested GID is invalid or already in use.
+	 * Reserve the GID for this transaction. This could fail if the requested
+	 * GID is invalid or already in use.
 	 */
 	gxact = MarkAsPreparing(xid, prepareGID, prepared_at,
 							GetUserId(), MyDatabaseId);
@@ -1707,14 +1696,14 @@ PrepareTransaction(void)
 	 * want transaction abort to be able to clean up.  (In particular, the
 	 * AtPrepare routines may error out if they find cases they cannot
 	 * handle.)  State cleanup should happen in the PostPrepare routines
-	 * below.  However, some modules can go ahead and clear state here
-	 * because they wouldn't do anything with it during abort anyway.
+	 * below.  However, some modules can go ahead and clear state here because
+	 * they wouldn't do anything with it during abort anyway.
 	 *
 	 * Note: because the 2PC state file records will be replayed in the same
-	 * order they are made, the order of these calls has to match the order
-	 * in which we want things to happen during COMMIT PREPARED or
-	 * ROLLBACK PREPARED; in particular, pay attention to whether things
-	 * should happen before or after releasing the transaction's locks.
+	 * order they are made, the order of these calls has to match the order in
+	 * which we want things to happen during COMMIT PREPARED or ROLLBACK
+	 * PREPARED; in particular, pay attention to whether things should happen
+	 * before or after releasing the transaction's locks.
 	 */
 	StartPrepare(gxact);
 
@@ -1726,15 +1715,14 @@ PrepareTransaction(void)
 	/*
 	 * Here is where we really truly prepare.
 	 *
-	 * We have to record transaction prepares even if we didn't
-	 * make any updates, because the transaction manager might
-	 * get confused if we lose a global transaction.
+	 * We have to record transaction prepares even if we didn't make any updates,
+	 * because the transaction manager might get confused if we lose a global
+	 * transaction.
 	 */
 	EndPrepare(gxact);
 
 	/*
-	 * Now we clean up backend-internal state and release internal
-	 * resources.
+	 * Now we clean up backend-internal state and release internal resources.
 	 */
 
 	/* Break the chain of back-links in the XLOG records I output */
@@ -1743,9 +1731,9 @@ PrepareTransaction(void)
 	MyXactMadeTempRelUpdate = false;
 
 	/*
-	 * Let others know about no transaction in progress by me.  This has
-	 * to be done *after* the prepared transaction has been marked valid,
-	 * else someone may think it is unlocked and recyclable.
+	 * Let others know about no transaction in progress by me.	This has to be
+	 * done *after* the prepared transaction has been marked valid, else
+	 * someone may think it is unlocked and recyclable.
 	 */
 
 	/* Lock ProcArrayLock because that's what GetSnapshotData uses. */
@@ -1762,7 +1750,7 @@ PrepareTransaction(void)
 	/*
 	 * This is all post-transaction cleanup.  Note that if an error is raised
 	 * here, it's too late to abort the transaction.  This should be just
-	 * noncritical resource releasing.  See notes in CommitTransaction.
+	 * noncritical resource releasing.	See notes in CommitTransaction.
 	 */
 
 	CallXactCallbacks(XACT_EVENT_PREPARE);
@@ -1819,8 +1807,8 @@ PrepareTransaction(void)
 	s->childXids = NIL;
 
 	/*
-	 * done with 1st phase commit processing, set current transaction
-	 * state back to default
+	 * done with 1st phase commit processing, set current transaction state
+	 * back to default
 	 */
 	s->state = TRANS_DEFAULT;
 
@@ -1842,8 +1830,8 @@ AbortTransaction(void)
 	/*
 	 * Release any LW locks we might be holding as quickly as possible.
 	 * (Regular locks, however, must be held till we finish aborting.)
-	 * Releasing LW locks is critical since we might try to grab them
-	 * again while cleaning up!
+	 * Releasing LW locks is critical since we might try to grab them again
+	 * while cleaning up!
 	 */
 	LWLockReleaseAll();
 
@@ -1852,8 +1840,8 @@ AbortTransaction(void)
 	UnlockBuffers();
 
 	/*
-	 * Also clean up any open wait for lock, since the lock manager will
-	 * choke if we try to wait for another lock before doing this.
+	 * Also clean up any open wait for lock, since the lock manager will choke
+	 * if we try to wait for another lock before doing this.
 	 */
 	LockWaitCancel();
 
@@ -1866,8 +1854,8 @@ AbortTransaction(void)
 	Assert(s->parent == NULL);
 
 	/*
-	 * set the current transaction state information appropriately during
-	 * the abort processing
+	 * set the current transaction state information appropriately during the
+	 * abort processing
 	 */
 	s->state = TRANS_ABORT;
 
@@ -1876,15 +1864,14 @@ AbortTransaction(void)
 	AtAbort_ResourceOwner();
 
 	/*
-	 * Reset user id which might have been changed transiently.  We cannot
-	 * use s->currentUser, since it may not be set yet; instead rely on
-	 * internal state of miscinit.c.
+	 * Reset user id which might have been changed transiently.  We cannot use
+	 * s->currentUser, since it may not be set yet; instead rely on internal
+	 * state of miscinit.c.
 	 *
-	 * (Note: it is not necessary to restore session authorization here
-	 * because that can only be changed via GUC, and GUC will take care of
-	 * rolling it back if need be.	However, an error within a SECURITY
-	 * DEFINER function could send control here with the wrong current
-	 * userid.)
+	 * (Note: it is not necessary to restore session authorization here because
+	 * that can only be changed via GUC, and GUC will take care of rolling it
+	 * back if need be.  However, an error within a SECURITY DEFINER function
+	 * could send control here with the wrong current userid.)
 	 */
 	AtAbort_UserId();
 
@@ -1898,15 +1885,15 @@ AbortTransaction(void)
 	AtEOXact_UpdateFlatFiles(false);
 
 	/*
-	 * Advertise the fact that we aborted in pg_clog (assuming that we
-	 * got as far as assigning an XID to advertise).
+	 * Advertise the fact that we aborted in pg_clog (assuming that we got as
+	 * far as assigning an XID to advertise).
 	 */
 	if (TransactionIdIsValid(s->transactionId))
 		RecordTransactionAbort();
 
 	/*
-	 * Let others know about no transaction in progress by me. Note that
-	 * this must be done _before_ releasing locks we hold and _after_
+	 * Let others know about no transaction in progress by me. Note that this
+	 * must be done _before_ releasing locks we hold and _after_
 	 * RecordTransactionAbort.
 	 */
 	if (MyProc != NULL)
@@ -2012,8 +1999,8 @@ StartTransactionCommand(void)
 	switch (s->blockState)
 	{
 			/*
-			 * if we aren't in a transaction block, we just do our usual
-			 * start transaction.
+			 * if we aren't in a transaction block, we just do our usual start
+			 * transaction.
 			 */
 		case TBLOCK_DEFAULT:
 			StartTransaction();
@@ -2021,23 +2008,23 @@ StartTransactionCommand(void)
 			break;
 
 			/*
-			 * We are somewhere in a transaction block or subtransaction
-			 * and about to start a new command.  For now we do nothing,
-			 * but someday we may do command-local resource initialization.
-			 * (Note that any needed CommandCounterIncrement was done by
-			 * the previous CommitTransactionCommand.)
+			 * We are somewhere in a transaction block or subtransaction and
+			 * about to start a new command.  For now we do nothing, but
+			 * someday we may do command-local resource initialization. (Note
+			 * that any needed CommandCounterIncrement was done by the
+			 * previous CommitTransactionCommand.)
 			 */
 		case TBLOCK_INPROGRESS:
 		case TBLOCK_SUBINPROGRESS:
 			break;
 
 			/*
-			 * Here we are in a failed transaction block (one of
-			 * the commands caused an abort) so we do nothing but remain in
-			 * the abort state.  Eventually we will get a ROLLBACK command
-			 * which will get us out of this state.  (It is up to other
-			 * code to ensure that no commands other than ROLLBACK will be
-			 * processed in these states.)
+			 * Here we are in a failed transaction block (one of the commands
+			 * caused an abort) so we do nothing but remain in the abort
+			 * state.  Eventually we will get a ROLLBACK command which will
+			 * get us out of this state.  (It is up to other code to ensure
+			 * that no commands other than ROLLBACK will be processed in these
+			 * states.)
 			 */
 		case TBLOCK_ABORT:
 		case TBLOCK_SUBABORT:
@@ -2099,10 +2086,10 @@ CommitTransactionCommand(void)
 			break;
 
 			/*
-			 * We are completing a "BEGIN TRANSACTION" command, so we
-			 * change to the "transaction block in progress" state and
-			 * return.  (We assume the BEGIN did nothing to the database,
-			 * so we need no CommandCounterIncrement.)
+			 * We are completing a "BEGIN TRANSACTION" command, so we change
+			 * to the "transaction block in progress" state and return.  (We
+			 * assume the BEGIN did nothing to the database, so we need no
+			 * CommandCounterIncrement.)
 			 */
 		case TBLOCK_BEGIN:
 			s->blockState = TBLOCK_INPROGRESS;
@@ -2110,8 +2097,8 @@ CommitTransactionCommand(void)
 
 			/*
 			 * This is the case when we have finished executing a command
-			 * someplace within a transaction block.  We increment the
-			 * command counter and return.
+			 * someplace within a transaction block.  We increment the command
+			 * counter and return.
 			 */
 		case TBLOCK_INPROGRESS:
 		case TBLOCK_SUBINPROGRESS:
@@ -2119,8 +2106,8 @@ CommitTransactionCommand(void)
 			break;
 
 			/*
-			 * We are completing a "COMMIT" command.  Do it and return to
-			 * the idle state.
+			 * We are completing a "COMMIT" command.  Do it and return to the
+			 * idle state.
 			 */
 		case TBLOCK_END:
 			CommitTransaction();
@@ -2128,17 +2115,17 @@ CommitTransactionCommand(void)
 			break;
 
 			/*
-			 * Here we are in the middle of a transaction block but one of
-			 * the commands caused an abort so we do nothing but remain in
-			 * the abort state.  Eventually we will get a ROLLBACK comand.
+			 * Here we are in the middle of a transaction block but one of the
+			 * commands caused an abort so we do nothing but remain in the
+			 * abort state.  Eventually we will get a ROLLBACK comand.
 			 */
 		case TBLOCK_ABORT:
 		case TBLOCK_SUBABORT:
 			break;
 
 			/*
-			 * Here we were in an aborted transaction block and we just
-			 * got the ROLLBACK command from the user, so clean up the
+			 * Here we were in an aborted transaction block and we just got
+			 * the ROLLBACK command from the user, so clean up the
 			 * already-aborted transaction and return to the idle state.
 			 */
 		case TBLOCK_ABORT_END:
@@ -2147,9 +2134,9 @@ CommitTransactionCommand(void)
 			break;
 
 			/*
-			 * Here we were in a perfectly good transaction block but the
-			 * user told us to ROLLBACK anyway.  We have to abort the
-			 * transaction and then clean up.
+			 * Here we were in a perfectly good transaction block but the user
+			 * told us to ROLLBACK anyway.	We have to abort the transaction
+			 * and then clean up.
 			 */
 		case TBLOCK_ABORT_PENDING:
 			AbortTransaction();
@@ -2169,8 +2156,8 @@ CommitTransactionCommand(void)
 			/*
 			 * We were just issued a SAVEPOINT inside a transaction block.
 			 * Start a subtransaction.	(DefineSavepoint already did
-			 * PushTransaction, so as to have someplace to put the
-			 * SUBBEGIN state.)
+			 * PushTransaction, so as to have someplace to put the SUBBEGIN
+			 * state.)
 			 */
 		case TBLOCK_SUBBEGIN:
 			StartSubTransaction();
@@ -2259,8 +2246,8 @@ CommitTransactionCommand(void)
 			break;
 
 			/*
-			 * Same as above, but the subtransaction had already failed,
-			 * so we don't need AbortSubTransaction.
+			 * Same as above, but the subtransaction had already failed, so we
+			 * don't need AbortSubTransaction.
 			 */
 		case TBLOCK_SUBABORT_RESTART:
 			{
@@ -2320,8 +2307,8 @@ AbortCurrentTransaction(void)
 			break;
 
 			/*
-			 * if we aren't in a transaction block, we just do the basic
-			 * abort & cleanup transaction.
+			 * if we aren't in a transaction block, we just do the basic abort
+			 * & cleanup transaction.
 			 */
 		case TBLOCK_STARTED:
 			AbortTransaction();
@@ -2330,11 +2317,11 @@ AbortCurrentTransaction(void)
 			break;
 
 			/*
-			 * If we are in TBLOCK_BEGIN it means something screwed up
-			 * right after reading "BEGIN TRANSACTION".  We assume that
-			 * the user will interpret the error as meaning the BEGIN
-			 * failed to get him into a transaction block, so we should
-			 * abort and return to idle state.
+			 * If we are in TBLOCK_BEGIN it means something screwed up right
+			 * after reading "BEGIN TRANSACTION".  We assume that the user
+			 * will interpret the error as meaning the BEGIN failed to get him
+			 * into a transaction block, so we should abort and return to idle
+			 * state.
 			 */
 		case TBLOCK_BEGIN:
 			AbortTransaction();
@@ -2354,9 +2341,9 @@ AbortCurrentTransaction(void)
 			break;
 
 			/*
-			 * Here, we failed while trying to COMMIT.  Clean up the
-			 * transaction and return to idle state (we do not want to
-			 * stay in the transaction).
+			 * Here, we failed while trying to COMMIT.	Clean up the
+			 * transaction and return to idle state (we do not want to stay in
+			 * the transaction).
 			 */
 		case TBLOCK_END:
 			AbortTransaction();
@@ -2365,9 +2352,9 @@ AbortCurrentTransaction(void)
 			break;
 
 			/*
-			 * Here, we are already in an aborted transaction state and
-			 * are waiting for a ROLLBACK, but for some reason we failed
-			 * again!  So we just remain in the abort state.
+			 * Here, we are already in an aborted transaction state and are
+			 * waiting for a ROLLBACK, but for some reason we failed again!
+			 * So we just remain in the abort state.
 			 */
 		case TBLOCK_ABORT:
 		case TBLOCK_SUBABORT:
@@ -2375,8 +2362,8 @@ AbortCurrentTransaction(void)
 
 			/*
 			 * We are in a failed transaction and we got the ROLLBACK command.
-			 * We have already aborted, we just need to cleanup and go to
-			 * idle state.
+			 * We have already aborted, we just need to cleanup and go to idle
+			 * state.
 			 */
 		case TBLOCK_ABORT_END:
 			CleanupTransaction();
@@ -2395,8 +2382,8 @@ AbortCurrentTransaction(void)
 
 			/*
 			 * Here, we failed while trying to PREPARE.  Clean up the
-			 * transaction and return to idle state (we do not want to
-			 * stay in the transaction).
+			 * transaction and return to idle state (we do not want to stay in
+			 * the transaction).
 			 */
 		case TBLOCK_PREPARE:
 			AbortTransaction();
@@ -2406,8 +2393,8 @@ AbortCurrentTransaction(void)
 
 			/*
 			 * We got an error inside a subtransaction.  Abort just the
-			 * subtransaction, and go to the persistent SUBABORT state
-			 * until we get ROLLBACK.
+			 * subtransaction, and go to the persistent SUBABORT state until
+			 * we get ROLLBACK.
 			 */
 		case TBLOCK_SUBINPROGRESS:
 			AbortSubTransaction();
@@ -2416,7 +2403,7 @@ AbortCurrentTransaction(void)
 
 			/*
 			 * If we failed while trying to create a subtransaction, clean up
-			 * the broken subtransaction and abort the parent.  The same
+			 * the broken subtransaction and abort the parent.	The same
 			 * applies if we get a failure while ending a subtransaction.
 			 */
 		case TBLOCK_SUBBEGIN:
@@ -2479,15 +2466,15 @@ PreventTransactionChain(void *stmtNode, const char *stmtType)
 						stmtType)));
 
 	/*
-	 * Are we inside a function call?  If the statement's parameter block
-	 * was allocated in QueryContext, assume it is an interactive command.
+	 * Are we inside a function call?  If the statement's parameter block was
+	 * allocated in QueryContext, assume it is an interactive command.
 	 * Otherwise assume it is coming from a function.
 	 */
 	if (!MemoryContextContains(QueryContext, stmtNode))
 		ereport(ERROR,
 				(errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
 		/* translator: %s represents an SQL statement name */
-			 errmsg("%s cannot be executed from a function", stmtType)));
+				 errmsg("%s cannot be executed from a function", stmtType)));
 
 	/* If we got past IsTransactionBlock test, should be in default state */
 	if (CurrentTransactionState->blockState != TBLOCK_DEFAULT &&
@@ -2529,8 +2516,8 @@ RequireTransactionChain(void *stmtNode, const char *stmtType)
 		return;
 
 	/*
-	 * Are we inside a function call?  If the statement's parameter block
-	 * was allocated in QueryContext, assume it is an interactive command.
+	 * Are we inside a function call?  If the statement's parameter block was
+	 * allocated in QueryContext, assume it is an interactive command.
 	 * Otherwise assume it is coming from a function.
 	 */
 	if (!MemoryContextContains(QueryContext, stmtNode))
@@ -2556,8 +2543,8 @@ bool
 IsInTransactionChain(void *stmtNode)
 {
 	/*
-	 * Return true on same conditions that would make
-	 * PreventTransactionChain error out
+	 * Return true on same conditions that would make PreventTransactionChain
+	 * error out
 	 */
 	if (IsTransactionBlock())
 		return true;
@@ -2705,8 +2692,7 @@ BeginTransactionBlock(void)
 	switch (s->blockState)
 	{
 			/*
-			 * We are not inside a transaction block, so allow one to
-			 * begin.
+			 * We are not inside a transaction block, so allow one to begin.
 			 */
 		case TBLOCK_STARTED:
 			s->blockState = TBLOCK_BEGIN;
@@ -2721,7 +2707,7 @@ BeginTransactionBlock(void)
 		case TBLOCK_SUBABORT:
 			ereport(WARNING,
 					(errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
-				  errmsg("there is already a transaction in progress")));
+					 errmsg("there is already a transaction in progress")));
 			break;
 
 			/* These cases are invalid. */
@@ -2759,7 +2745,7 @@ bool
 PrepareTransactionBlock(char *gid)
 {
 	TransactionState s;
-	bool result;
+	bool		result;
 
 	/* Set up to commit the current transaction */
 	result = EndTransactionBlock();
@@ -2832,8 +2818,8 @@ EndTransactionBlock(void)
 			break;
 
 			/*
-			 * We are in a live subtransaction block.  Set up to subcommit
-			 * all open subtransactions and then commit the main transaction.
+			 * We are in a live subtransaction block.  Set up to subcommit all
+			 * open subtransactions and then commit the main transaction.
 			 */
 		case TBLOCK_SUBINPROGRESS:
 			while (s->parent != NULL)
@@ -2854,9 +2840,9 @@ EndTransactionBlock(void)
 			break;
 
 			/*
-			 * Here we are inside an aborted subtransaction.  Treat the
-			 * COMMIT as ROLLBACK: set up to abort everything and exit
-			 * the main transaction.
+			 * Here we are inside an aborted subtransaction.  Treat the COMMIT
+			 * as ROLLBACK: set up to abort everything and exit the main
+			 * transaction.
 			 */
 		case TBLOCK_SUBABORT:
 			while (s->parent != NULL)
@@ -2927,9 +2913,9 @@ UserAbortTransactionBlock(void)
 	switch (s->blockState)
 	{
 			/*
-			 * We are inside a transaction block and we got a ROLLBACK
-			 * command from the user, so tell CommitTransactionCommand
-			 * to abort and exit the transaction block.
+			 * We are inside a transaction block and we got a ROLLBACK command
+			 * from the user, so tell CommitTransactionCommand to abort and
+			 * exit the transaction block.
 			 */
 		case TBLOCK_INPROGRESS:
 			s->blockState = TBLOCK_ABORT_PENDING;
@@ -2937,17 +2923,17 @@ UserAbortTransactionBlock(void)
 
 			/*
 			 * We are inside a failed transaction block and we got a ROLLBACK
-			 * command from the user.  Abort processing is already done,
-			 * so CommitTransactionCommand just has to cleanup and go back
-			 * to idle state.
+			 * command from the user.  Abort processing is already done, so
+			 * CommitTransactionCommand just has to cleanup and go back to
+			 * idle state.
 			 */
 		case TBLOCK_ABORT:
 			s->blockState = TBLOCK_ABORT_END;
 			break;
 
 			/*
-			 * We are inside a subtransaction.  Mark everything
-			 * up to top level as exitable.
+			 * We are inside a subtransaction.	Mark everything up to top
+			 * level as exitable.
 			 */
 		case TBLOCK_SUBINPROGRESS:
 		case TBLOCK_SUBABORT:
@@ -2972,8 +2958,8 @@ UserAbortTransactionBlock(void)
 			break;
 
 			/*
-			 * The user issued ABORT when not inside a transaction. Issue
-			 * a WARNING and go to abort state.  The upcoming call to
+			 * The user issued ABORT when not inside a transaction. Issue a
+			 * WARNING and go to abort state.  The upcoming call to
 			 * CommitTransactionCommand() will then put us back into the
 			 * default state.
 			 */
@@ -3021,8 +3007,8 @@ DefineSavepoint(char *name)
 			s = CurrentTransactionState;		/* changed by push */
 
 			/*
-			 * Savepoint names, like the TransactionState block itself,
-			 * live in TopTransactionContext.
+			 * Savepoint names, like the TransactionState block itself, live
+			 * in TopTransactionContext.
 			 */
 			if (name)
 				s->name = MemoryContextStrdup(TopTransactionContext, name);
@@ -3078,8 +3064,8 @@ ReleaseSavepoint(List *options)
 			break;
 
 			/*
-			 * We are in a non-aborted subtransaction.	This is the only
-			 * valid case.
+			 * We are in a non-aborted subtransaction.	This is the only valid
+			 * case.
 			 */
 		case TBLOCK_SUBINPROGRESS:
 			break;
@@ -3134,8 +3120,8 @@ ReleaseSavepoint(List *options)
 
 	/*
 	 * Mark "commit pending" all subtransactions up to the target
-	 * subtransaction.	The actual commits will happen when control gets
-	 * to CommitTransactionCommand.
+	 * subtransaction.	The actual commits will happen when control gets to
+	 * CommitTransactionCommand.
 	 */
 	xact = CurrentTransactionState;
 	for (;;)
@@ -3232,8 +3218,8 @@ RollbackToSavepoint(List *options)
 
 	/*
 	 * Mark "abort pending" all subtransactions up to the target
-	 * subtransaction.	The actual aborts will happen when control gets
-	 * to CommitTransactionCommand.
+	 * subtransaction.	The actual aborts will happen when control gets to
+	 * CommitTransactionCommand.
 	 */
 	xact = CurrentTransactionState;
 	for (;;)
@@ -3284,8 +3270,8 @@ BeginInternalSubTransaction(char *name)
 			s = CurrentTransactionState;		/* changed by push */
 
 			/*
-			 * Savepoint names, like the TransactionState block itself,
-			 * live in TopTransactionContext.
+			 * Savepoint names, like the TransactionState block itself, live
+			 * in TopTransactionContext.
 			 */
 			if (name)
 				s->name = MemoryContextStrdup(TopTransactionContext, name);
@@ -3333,7 +3319,7 @@ ReleaseCurrentSubTransaction(void)
 	Assert(s->state == TRANS_INPROGRESS);
 	MemoryContextSwitchTo(CurTransactionContext);
 	CommitSubTransaction();
-	s = CurrentTransactionState; /* changed by pop */
+	s = CurrentTransactionState;	/* changed by pop */
 	Assert(s->state == TRANS_INPROGRESS);
 }
 
@@ -3433,8 +3419,7 @@ AbortOutOfAnyTransaction(void)
 				break;
 
 				/*
-				 * In a subtransaction, so clean it up and abort parent
-				 * too
+				 * In a subtransaction, so clean it up and abort parent too
 				 */
 			case TBLOCK_SUBBEGIN:
 			case TBLOCK_SUBINPROGRESS:
@@ -3667,9 +3652,9 @@ CommitSubTransaction(void)
 					  s->parent->subTransactionId);
 
 	/*
-	 * We need to restore the upper transaction's read-only state, in case
-	 * the upper is read-write while the child is read-only; GUC will
-	 * incorrectly think it should leave the child state in place.
+	 * We need to restore the upper transaction's read-only state, in case the
+	 * upper is read-write while the child is read-only; GUC will incorrectly
+	 * think it should leave the child state in place.
 	 */
 	XactReadOnly = s->prevXactReadOnly;
 
@@ -3706,8 +3691,8 @@ AbortSubTransaction(void)
 	/*
 	 * Release any LW locks we might be holding as quickly as possible.
 	 * (Regular locks, however, must be held till we finish aborting.)
-	 * Releasing LW locks is critical since we might try to grab them
-	 * again while cleaning up!
+	 * Releasing LW locks is critical since we might try to grab them again
+	 * while cleaning up!
 	 *
 	 * FIXME This may be incorrect --- Are there some locks we should keep?
 	 * Buffer locks, for example?  I don't think so but I'm not sure.
@@ -3726,8 +3711,8 @@ AbortSubTransaction(void)
 	AtSubAbort_ResourceOwner();
 
 	/*
-	 * We can skip all this stuff if the subxact failed before creating
-	 * a ResourceOwner...
+	 * We can skip all this stuff if the subxact failed before creating a
+	 * ResourceOwner...
 	 */
 	if (s->curTransactionOwner)
 	{
@@ -3777,25 +3762,23 @@ AbortSubTransaction(void)
 	}
 
 	/*
-	 * Reset user id which might have been changed transiently.  Here we
-	 * want to restore to the userid that was current at subxact entry.
-	 * (As in AbortTransaction, we need not worry about the session
-	 * userid.)
+	 * Reset user id which might have been changed transiently.  Here we want
+	 * to restore to the userid that was current at subxact entry. (As in
+	 * AbortTransaction, we need not worry about the session userid.)
 	 *
-	 * Must do this after AtEOXact_GUC to handle the case where we entered
-	 * the subxact inside a SECURITY DEFINER function (hence current and
-	 * session userids were different) and then session auth was changed
-	 * inside the subxact.	GUC will reset both current and session
-	 * userids to the entry-time session userid.  This is right in every
-	 * other scenario so it seems simplest to let GUC do that and fix it
-	 * here.
+	 * Must do this after AtEOXact_GUC to handle the case where we entered the
+	 * subxact inside a SECURITY DEFINER function (hence current and session
+	 * userids were different) and then session auth was changed inside the
+	 * subxact.  GUC will reset both current and session userids to the
+	 * entry-time session userid.  This is right in every other scenario so it
+	 * seems simplest to let GUC do that and fix it here.
 	 */
 	SetUserId(s->currentUser);
 
 	/*
-	 * Restore the upper transaction's read-only state, too.  This should
-	 * be redundant with GUC's cleanup but we may as well do it for
-	 * consistency with the commit case.
+	 * Restore the upper transaction's read-only state, too.  This should be
+	 * redundant with GUC's cleanup but we may as well do it for consistency
+	 * with the commit case.
 	 */
 	XactReadOnly = s->prevXactReadOnly;
 
@@ -3846,11 +3829,11 @@ PushTransaction(void)
 {
 	TransactionState p = CurrentTransactionState;
 	TransactionState s;
-	Oid	currentUser;
+	Oid			currentUser;
 
 	/*
-	 * At present, GetUserId cannot fail, but let's not assume that.  Get
-	 * the ID before entering the critical code sequence.
+	 * At present, GetUserId cannot fail, but let's not assume that.  Get the
+	 * ID before entering the critical code sequence.
 	 */
 	currentUser = GetUserId();
 
@@ -3860,6 +3843,7 @@ PushTransaction(void)
 	s = (TransactionState)
 		MemoryContextAllocZero(TopTransactionContext,
 							   sizeof(TransactionStateData));
+
 	/*
 	 * Assign a subtransaction ID, watching out for counter wraparound.
 	 */
@@ -3872,11 +3856,12 @@ PushTransaction(void)
 				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 				 errmsg("cannot have more than 2^32-1 subtransactions in a transaction")));
 	}
+
 	/*
 	 * We can now stack a minimally valid subtransaction without fear of
 	 * failure.
 	 */
-	s->transactionId = InvalidTransactionId; /* until assigned */
+	s->transactionId = InvalidTransactionId;	/* until assigned */
 	s->subTransactionId = currentSubTransactionId;
 	s->parent = p;
 	s->nestingLevel = p->nestingLevel + 1;
@@ -3889,10 +3874,10 @@ PushTransaction(void)
 	CurrentTransactionState = s;
 
 	/*
-	 * AbortSubTransaction and CleanupSubTransaction have to be able to
-	 * cope with the subtransaction from here on out; in particular they
-	 * should not assume that it necessarily has a transaction context,
-	 * resource owner, or XID.
+	 * AbortSubTransaction and CleanupSubTransaction have to be able to cope
+	 * with the subtransaction from here on out; in particular they should not
+	 * assume that it necessarily has a transaction context, resource owner,
+	 * or XID.
 	 */
 }
 
@@ -3959,7 +3944,7 @@ ShowTransactionStateRec(TransactionState s)
 	/* use ereport to suppress computation if msg will not be printed */
 	ereport(DEBUG3,
 			(errmsg_internal("name: %s; blockState: %13s; state: %7s, xid/subid/cid: %u/%u/%u, nestlvl: %d, children: %s",
-						   PointerIsValid(s->name) ? s->name : "unnamed",
+							 PointerIsValid(s->name) ? s->name : "unnamed",
 							 BlockStateAsString(s->blockState),
 							 TransStateAsString(s->state),
 							 (unsigned int) s->transactionId,
@@ -4215,7 +4200,7 @@ xact_desc_commit(char *buf, xl_xact_commit *xlrec)
 	if (xlrec->nsubxacts > 0)
 	{
 		TransactionId *xacts = (TransactionId *)
-			&xlrec->xnodes[xlrec->nrels];
+		&xlrec->xnodes[xlrec->nrels];
 
 		sprintf(buf + strlen(buf), "; subxacts:");
 		for (i = 0; i < xlrec->nsubxacts; i++)
@@ -4246,7 +4231,7 @@ xact_desc_abort(char *buf, xl_xact_abort *xlrec)
 	if (xlrec->nsubxacts > 0)
 	{
 		TransactionId *xacts = (TransactionId *)
-			&xlrec->xnodes[xlrec->nrels];
+		&xlrec->xnodes[xlrec->nrels];
 
 		sprintf(buf + strlen(buf), "; subxacts:");
 		for (i = 0; i < xlrec->nsubxacts; i++)
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 561ab82733..de7b89c2ff 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -51,7 +51,7 @@
 /*
  *	Because O_DIRECT bypasses the kernel buffers, and because we never
  *	read those buffers except during crash recovery, it is a win to use
- *	it in all cases where we sync on each write().  We could allow O_DIRECT
+ *	it in all cases where we sync on each write().	We could allow O_DIRECT
  *	with fsync(), but because skipping the kernel buffer forces writes out
  *	quickly, it seems best just to use it for O_SYNC.  It is hard to imagine
  *	how fsync() could be a win for O_DIRECT compared to O_SYNC and O_DIRECT.
@@ -85,14 +85,14 @@
 #if O_DSYNC != BARE_OPEN_SYNC_FLAG
 #define OPEN_DATASYNC_FLAG		(O_DSYNC | PG_O_DIRECT)
 #endif
-#else /* !defined(OPEN_SYNC_FLAG) */
+#else							/* !defined(OPEN_SYNC_FLAG) */
 /* Win32 only has O_DSYNC */
 #define OPEN_DATASYNC_FLAG		(O_DSYNC | PG_O_DIRECT)
 #endif
 #endif
 
 #if defined(OPEN_DATASYNC_FLAG)
-#define DEFAULT_SYNC_METHOD_STR	"open_datasync"
+#define DEFAULT_SYNC_METHOD_STR "open_datasync"
 #define DEFAULT_SYNC_METHOD		SYNC_METHOD_OPEN
 #define DEFAULT_SYNC_FLAGBIT	OPEN_DATASYNC_FLAG
 #elif defined(HAVE_FDATASYNC)
@@ -154,7 +154,7 @@ bool		XLOG_DEBUG = false;
 
 
 /* these are derived from XLOG_sync_method by assign_xlog_sync_method */
-int	sync_method = DEFAULT_SYNC_METHOD;
+int			sync_method = DEFAULT_SYNC_METHOD;
 static int	open_sync_bit = DEFAULT_SYNC_FLAGBIT;
 
 #define XLOG_SYNC_BIT  (enableFsync ? open_sync_bit : 0)
@@ -368,10 +368,9 @@ typedef struct XLogCtlData
 	XLogCtlWrite Write;
 
 	/*
-	 * These values do not change after startup, although the pointed-to
-	 * pages and xlblocks values certainly do.	Permission to read/write
-	 * the pages and xlblocks values depends on WALInsertLock and
-	 * WALWriteLock.
+	 * These values do not change after startup, although the pointed-to pages
+	 * and xlblocks values certainly do.  Permission to read/write the pages
+	 * and xlblocks values depends on WALInsertLock and WALWriteLock.
 	 */
 	char	   *pages;			/* buffers for unwritten XLOG pages */
 	XLogRecPtr *xlblocks;		/* 1st byte ptr-s + BLCKSZ */
@@ -449,8 +448,8 @@ static char *readRecordBuf = NULL;
 static uint32 readRecordBufSize = 0;
 
 /* State information for XLOG reading */
-static XLogRecPtr ReadRecPtr;				/* start of last record read */
-static XLogRecPtr EndRecPtr;				/* end+1 of last record read */
+static XLogRecPtr ReadRecPtr;	/* start of last record read */
+static XLogRecPtr EndRecPtr;	/* end+1 of last record read */
 static XLogRecord *nextRecord = NULL;
 static TimeLineID lastPageTLI = 0;
 
@@ -467,7 +466,7 @@ static void exitArchiveRecovery(TimeLineID endTLI,
 static bool recoveryStopsHere(XLogRecord *record, bool *includeThis);
 
 static bool XLogCheckBuffer(XLogRecData *rdata,
-							XLogRecPtr *lsn, BkpBlock *bkpb);
+				XLogRecPtr *lsn, BkpBlock *bkpb);
 static bool AdvanceXLInsertBuffer(void);
 static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible);
 static int XLogFileInit(uint32 log, uint32 seg,
@@ -481,7 +480,7 @@ static bool RestoreArchivedFile(char *path, const char *xlogfname,
 					const char *recovername, off_t expectedSize);
 static int	PreallocXlogFiles(XLogRecPtr endptr);
 static void MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr,
-							int *nsegsremoved, int *nsegsrecycled);
+				int *nsegsremoved, int *nsegsrecycled);
 static void RemoveOldBackupHistory(void);
 static XLogRecord *ReadRecord(XLogRecPtr *RecPtr, int emode);
 static bool ValidXLOGHeader(XLogPageHeader hdr, int emode);
@@ -554,36 +553,34 @@ XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
 	}
 
 	/*
-	 * In bootstrap mode, we don't actually log anything but XLOG
-	 * resources; return a phony record pointer.
+	 * In bootstrap mode, we don't actually log anything but XLOG resources;
+	 * return a phony record pointer.
 	 */
 	if (IsBootstrapProcessingMode() && rmid != RM_XLOG_ID)
 	{
 		RecPtr.xlogid = 0;
-		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt
-												 * record */
+		RecPtr.xrecoff = SizeOfXLogLongPHD;		/* start of 1st chkpt record */
 		return (RecPtr);
 	}
 
 	/*
 	 * Here we scan the rdata chain, determine which buffers must be backed
 	 * up, and compute the CRC values for the data.  Note that the record
-	 * header isn't added into the CRC initially since we don't know the
-	 * final length or info bits quite yet.  Thus, the CRC will represent
-	 * the CRC of the whole record in the order "rdata, then backup blocks,
-	 * then record header".
+	 * header isn't added into the CRC initially since we don't know the final
+	 * length or info bits quite yet.  Thus, the CRC will represent the CRC of
+	 * the whole record in the order "rdata, then backup blocks, then record
+	 * header".
 	 *
-	 * We may have to loop back to here if a race condition is detected
-	 * below. We could prevent the race by doing all this work while
-	 * holding the insert lock, but it seems better to avoid doing CRC
-	 * calculations while holding the lock.  This means we have to be
-	 * careful about modifying the rdata chain until we know we aren't
-	 * going to loop back again.  The only change we allow ourselves to
-	 * make earlier is to set rdt->data = NULL in chain items we have
-	 * decided we will have to back up the whole buffer for.  This is OK
-	 * because we will certainly decide the same thing again for those
-	 * items if we do it over; doing it here saves an extra pass over the
-	 * chain later.
+	 * We may have to loop back to here if a race condition is detected below. We
+	 * could prevent the race by doing all this work while holding the insert
+	 * lock, but it seems better to avoid doing CRC calculations while holding
+	 * the lock.  This means we have to be careful about modifying the rdata
+	 * chain until we know we aren't going to loop back again.  The only
+	 * change we allow ourselves to make earlier is to set rdt->data = NULL in
+	 * chain items we have decided we will have to back up the whole buffer
+	 * for.  This is OK because we will certainly decide the same thing again
+	 * for those items if we do it over; doing it here saves an extra pass
+	 * over the chain later.
 	 */
 begin:;
 	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
@@ -680,12 +677,12 @@ begin:;
 	}
 
 	/*
-	 * NOTE: the test for len == 0 here is somewhat fishy, since in theory
-	 * all of the rmgr data might have been suppressed in favor of backup
-	 * blocks.	Currently, all callers of XLogInsert provide at least some
-	 * not-in-a-buffer data and so len == 0 should never happen, but that
-	 * may not be true forever.  If you need to remove the len == 0 check,
-	 * also remove the check for xl_len == 0 in ReadRecord, below.
+	 * NOTE: the test for len == 0 here is somewhat fishy, since in theory all
+	 * of the rmgr data might have been suppressed in favor of backup blocks.
+	 * Currently, all callers of XLogInsert provide at least some
+	 * not-in-a-buffer data and so len == 0 should never happen, but that may
+	 * not be true forever.  If you need to remove the len == 0 check, also
+	 * remove the check for xl_len == 0 in ReadRecord, below.
 	 */
 	if (len == 0)
 		elog(PANIC, "invalid xlog record length %u", len);
@@ -718,9 +715,9 @@ begin:;
 			 * Since the amount of data we write here is completely optional
 			 * anyway, tell XLogWrite it can be "flexible" and stop at a
 			 * convenient boundary.  This allows writes triggered by this
-			 * mechanism to synchronize with the cache boundaries, so that
-			 * in a long transaction we'll basically dump alternating halves
-			 * of the buffer array.
+			 * mechanism to synchronize with the cache boundaries, so that in
+			 * a long transaction we'll basically dump alternating halves of
+			 * the buffer array.
 			 */
 			LogwrtResult = XLogCtl->Write.LogwrtResult;
 			if (XLByteLT(LogwrtResult.Write, LogwrtRqst.Write))
@@ -733,10 +730,9 @@ begin:;
 	LWLockAcquire(WALInsertLock, LW_EXCLUSIVE);
 
 	/*
-	 * Check to see if my RedoRecPtr is out of date.  If so, may have to
-	 * go back and recompute everything.  This can only happen just after
-	 * a checkpoint, so it's better to be slow in this case and fast
-	 * otherwise.
+	 * Check to see if my RedoRecPtr is out of date.  If so, may have to go
+	 * back and recompute everything.  This can only happen just after a
+	 * checkpoint, so it's better to be slow in this case and fast otherwise.
 	 */
 	if (!XLByteEQ(RedoRecPtr, Insert->RedoRecPtr))
 	{
@@ -751,8 +747,8 @@ begin:;
 				XLByteLE(dtbuf_lsn[i], RedoRecPtr))
 			{
 				/*
-				 * Oops, this buffer now needs to be backed up, but we
-				 * didn't think so above.  Start over.
+				 * Oops, this buffer now needs to be backed up, but we didn't
+				 * think so above.	Start over.
 				 */
 				LWLockRelease(WALInsertLock);
 				END_CRIT_SECTION();
@@ -762,15 +758,14 @@ begin:;
 	}
 
 	/*
-	 * Make additional rdata chain entries for the backup blocks, so that
-	 * we don't need to special-case them in the write loop.  Note that we
-	 * have now irrevocably changed the input rdata chain.  At the exit of
-	 * this loop, write_len includes the backup block data.
+	 * Make additional rdata chain entries for the backup blocks, so that we
+	 * don't need to special-case them in the write loop.  Note that we have
+	 * now irrevocably changed the input rdata chain.  At the exit of this
+	 * loop, write_len includes the backup block data.
 	 *
-	 * Also set the appropriate info bits to show which buffers were backed
-	 * up.	The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th
-	 * distinct buffer value (ignoring InvalidBuffer) appearing in the
-	 * rdata chain.
+	 * Also set the appropriate info bits to show which buffers were backed up.
+	 * The i'th XLR_SET_BKP_BLOCK bit corresponds to the i'th distinct buffer
+	 * value (ignoring InvalidBuffer) appearing in the rdata chain.
 	 */
 	write_len = len;
 	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
@@ -822,8 +817,7 @@ begin:;
 
 	/*
 	 * If there isn't enough space on the current XLOG page for a record
-	 * header, advance to the next page (leaving the unused space as
-	 * zeroes).
+	 * header, advance to the next page (leaving the unused space as zeroes).
 	 */
 	updrqst = false;
 	freespace = INSERT_FREESPACE(Insert);
@@ -925,15 +919,15 @@ begin:;
 	freespace = INSERT_FREESPACE(Insert);
 
 	/*
-	 * The recptr I return is the beginning of the *next* record. This
-	 * will be stored as LSN for changed data pages...
+	 * The recptr I return is the beginning of the *next* record. This will be
+	 * stored as LSN for changed data pages...
 	 */
 	INSERT_RECPTR(RecPtr, Insert, curridx);
 
 	/* Need to update shared LogwrtRqst if some block was filled up */
 	if (freespace < SizeOfXLogRecord)
-		updrqst = true;			/* curridx is filled and available for
-								 * writing out */
+		updrqst = true;			/* curridx is filled and available for writing
+								 * out */
 	else
 		curridx = PrevBufIdx(curridx);
 	WriteRqst = XLogCtl->xlblocks[curridx];
@@ -975,9 +969,9 @@ XLogCheckBuffer(XLogRecData *rdata,
 	page = (PageHeader) BufferGetBlock(rdata->buffer);
 
 	/*
-	 * XXX We assume page LSN is first data on *every* page that can be
-	 * passed to XLogInsert, whether it otherwise has the standard page
-	 * layout or not.
+	 * XXX We assume page LSN is first data on *every* page that can be passed
+	 * to XLogInsert, whether it otherwise has the standard page layout or
+	 * not.
 	 */
 	*lsn = page->pd_lsn;
 
@@ -1163,9 +1157,9 @@ AdvanceXLInsertBuffer(void)
 		LogwrtResult = Insert->LogwrtResult;
 
 	/*
-	 * Get ending-offset of the buffer page we need to replace (this may
-	 * be zero if the buffer hasn't been used yet).  Fall through if it's
-	 * already written out.
+	 * Get ending-offset of the buffer page we need to replace (this may be
+	 * zero if the buffer hasn't been used yet).  Fall through if it's already
+	 * written out.
 	 */
 	OldPageRqstPtr = XLogCtl->xlblocks[nextidx];
 	if (!XLByteLE(OldPageRqstPtr, LogwrtResult.Write))
@@ -1208,9 +1202,8 @@ AdvanceXLInsertBuffer(void)
 			else
 			{
 				/*
-				 * Have to write buffers while holding insert lock. This
-				 * is not good, so only write as much as we absolutely
-				 * must.
+				 * Have to write buffers while holding insert lock. This is
+				 * not good, so only write as much as we absolutely must.
 				 */
 				WriteRqst.Write = OldPageRqstPtr;
 				WriteRqst.Flush.xlogid = 0;
@@ -1223,8 +1216,8 @@ AdvanceXLInsertBuffer(void)
 	}
 
 	/*
-	 * Now the next buffer slot is free and we can set it up to be the
-	 * next output page.
+	 * Now the next buffer slot is free and we can set it up to be the next
+	 * output page.
 	 */
 	NewPageEndPtr = XLogCtl->xlblocks[Insert->curridx];
 	if (NewPageEndPtr.xrecoff >= XLogFileSize)
@@ -1237,24 +1230,27 @@ AdvanceXLInsertBuffer(void)
 		NewPageEndPtr.xrecoff += BLCKSZ;
 	XLogCtl->xlblocks[nextidx] = NewPageEndPtr;
 	NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * (Size) BLCKSZ);
+
 	Insert->curridx = nextidx;
 	Insert->currpage = NewPage;
-	Insert->currpos = ((char *) NewPage) + SizeOfXLogShortPHD;
+
+	Insert->currpos = ((char *) NewPage) +SizeOfXLogShortPHD;
 
 	/*
-	 * Be sure to re-zero the buffer so that bytes beyond what we've
-	 * written will look like zeroes and not valid XLOG records...
+	 * Be sure to re-zero the buffer so that bytes beyond what we've written
+	 * will look like zeroes and not valid XLOG records...
 	 */
 	MemSet((char *) NewPage, 0, BLCKSZ);
 
 	/*
 	 * Fill the new page's header
 	 */
-	NewPage->xlp_magic = XLOG_PAGE_MAGIC;
+	NewPage   ->xlp_magic = XLOG_PAGE_MAGIC;
+
 	/* NewPage->xlp_info = 0; */	/* done by memset */
-	NewPage->xlp_tli = ThisTimeLineID;
-	NewPage->xlp_pageaddr.xlogid = NewPageEndPtr.xlogid;
-	NewPage->xlp_pageaddr.xrecoff = NewPageEndPtr.xrecoff - BLCKSZ;
+	NewPage   ->xlp_tli = ThisTimeLineID;
+	NewPage   ->xlp_pageaddr.xlogid = NewPageEndPtr.xlogid;
+	NewPage   ->xlp_pageaddr.xrecoff = NewPageEndPtr.xrecoff - BLCKSZ;
 
 	/*
 	 * If first page of an XLOG segment file, make it a long header.
@@ -1265,8 +1261,9 @@ AdvanceXLInsertBuffer(void)
 
 		NewLongPage->xlp_sysid = ControlFile->system_identifier;
 		NewLongPage->xlp_seg_size = XLogSegSize;
-		NewPage->xlp_info |= XLP_LONG_HEADER;
-		Insert->currpos = ((char *) NewPage) + SizeOfXLogLongPHD;
+		NewPage   ->xlp_info |= XLP_LONG_HEADER;
+
+		Insert->currpos = ((char *) NewPage) +SizeOfXLogLongPHD;
 	}
 
 	return update_needed;
@@ -1298,19 +1295,18 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 	Assert(CritSectionCount > 0);
 
 	/*
-	 * Update local LogwrtResult (caller probably did this already,
-	 * but...)
+	 * Update local LogwrtResult (caller probably did this already, but...)
 	 */
 	LogwrtResult = Write->LogwrtResult;
 
 	/*
 	 * Since successive pages in the xlog cache are consecutively allocated,
 	 * we can usually gather multiple pages together and issue just one
-	 * write() call.  npages is the number of pages we have determined can
-	 * be written together; startidx is the cache block index of the first
-	 * one, and startoffset is the file offset at which it should go.
-	 * The latter two variables are only valid when npages > 0, but we must
-	 * initialize all of them to keep the compiler quiet.
+	 * write() call.  npages is the number of pages we have determined can be
+	 * written together; startidx is the cache block index of the first one,
+	 * and startoffset is the file offset at which it should go. The latter
+	 * two variables are only valid when npages > 0, but we must initialize
+	 * all of them to keep the compiler quiet.
 	 */
 	npages = 0;
 	startidx = 0;
@@ -1320,18 +1316,17 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 	 * Within the loop, curridx is the cache block index of the page to
 	 * consider writing.  We advance Write->curridx only after successfully
 	 * writing pages.  (Right now, this refinement is useless since we are
-	 * going to PANIC if any error occurs anyway; but someday it may come
-	 * in useful.)
+	 * going to PANIC if any error occurs anyway; but someday it may come in
+	 * useful.)
 	 */
 	curridx = Write->curridx;
 
 	while (XLByteLT(LogwrtResult.Write, WriteRqst.Write))
 	{
 		/*
-		 * Make sure we're not ahead of the insert process.  This could
-		 * happen if we're passed a bogus WriteRqst.Write that is past the
-		 * end of the last page that's been initialized by
-		 * AdvanceXLInsertBuffer.
+		 * Make sure we're not ahead of the insert process.  This could happen
+		 * if we're passed a bogus WriteRqst.Write that is past the end of the
+		 * last page that's been initialized by AdvanceXLInsertBuffer.
 		 */
 		if (!XLByteLT(LogwrtResult.Write, XLogCtl->xlblocks[curridx]))
 			elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
@@ -1355,8 +1350,8 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 				if (close(openLogFile))
 					ereport(PANIC,
 							(errcode_for_file_access(),
-					errmsg("could not close log file %u, segment %u: %m",
-						   openLogId, openLogSeg)));
+						errmsg("could not close log file %u, segment %u: %m",
+							   openLogId, openLogSeg)));
 				openLogFile = -1;
 			}
 			XLByteToPrevSeg(LogwrtResult.Write, openLogId, openLogSeg);
@@ -1379,13 +1374,13 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 				UpdateControlFile();
 
 				/*
-				 * Signal bgwriter to start a checkpoint if it's been
-				 * too long since the last one.  (We look at local copy of
-				 * RedoRecPtr which might be a little out of date, but
-				 * should be close enough for this purpose.)
+				 * Signal bgwriter to start a checkpoint if it's been too long
+				 * since the last one.	(We look at local copy of RedoRecPtr
+				 * which might be a little out of date, but should be close
+				 * enough for this purpose.)
 				 *
-				 * A straight computation of segment number could overflow
-				 * 32 bits.  Rather than assuming we have working 64-bit
+				 * A straight computation of segment number could overflow 32
+				 * bits.  Rather than assuming we have working 64-bit
 				 * arithmetic, we compare the highest-order bits separately,
 				 * and force a checkpoint immediately when they change.
 				 */
@@ -1434,10 +1429,10 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 		npages++;
 
 		/*
-		 * Dump the set if this will be the last loop iteration, or if
-		 * we are at the last page of the cache area (since the next page
-		 * won't be contiguous in memory), or if we are at the end of the
-		 * logfile segment.
+		 * Dump the set if this will be the last loop iteration, or if we are
+		 * at the last page of the cache area (since the next page won't be
+		 * contiguous in memory), or if we are at the end of the logfile
+		 * segment.
 		 */
 		finishing_seg = !ispartialpage &&
 			(startoffset + npages * BLCKSZ) >= XLogSegSize;
@@ -1496,7 +1491,7 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 			if (finishing_seg)
 			{
 				issue_xlog_fsync();
-				LogwrtResult.Flush = LogwrtResult.Write;	/* end of page */
+				LogwrtResult.Flush = LogwrtResult.Write;		/* end of page */
 
 				if (XLogArchivingActive())
 					XLogArchiveNotifySeg(openLogId, openLogSeg);
@@ -1526,20 +1521,20 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 		XLByteLT(LogwrtResult.Flush, LogwrtResult.Write))
 	{
 		/*
-		 * Could get here without iterating above loop, in which case we
-		 * might have no open file or the wrong one.  However, we do not
-		 * need to fsync more than one file.
+		 * Could get here without iterating above loop, in which case we might
+		 * have no open file or the wrong one.	However, we do not need to
+		 * fsync more than one file.
 		 */
 		if (sync_method != SYNC_METHOD_OPEN)
 		{
 			if (openLogFile >= 0 &&
-			 !XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
+				!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg))
 			{
 				if (close(openLogFile))
 					ereport(PANIC,
 							(errcode_for_file_access(),
-					errmsg("could not close log file %u, segment %u: %m",
-						   openLogId, openLogSeg)));
+						errmsg("could not close log file %u, segment %u: %m",
+							   openLogId, openLogSeg)));
 				openLogFile = -1;
 			}
 			if (openLogFile < 0)
@@ -1557,8 +1552,8 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible)
 	 * Update shared-memory status
 	 *
 	 * We make sure that the shared 'request' values do not fall behind the
-	 * 'result' values.  This is not absolutely essential, but it saves
-	 * some code in a couple of places.
+	 * 'result' values.  This is not absolutely essential, but it saves some
+	 * code in a couple of places.
 	 */
 	{
 		/* use volatile pointer to prevent code rearrangement */
@@ -1608,11 +1603,10 @@ XLogFlush(XLogRecPtr record)
 
 	/*
 	 * Since fsync is usually a horribly expensive operation, we try to
-	 * piggyback as much data as we can on each fsync: if we see any more
-	 * data entered into the xlog buffer, we'll write and fsync that too,
-	 * so that the final value of LogwrtResult.Flush is as large as
-	 * possible. This gives us some chance of avoiding another fsync
-	 * immediately after.
+	 * piggyback as much data as we can on each fsync: if we see any more data
+	 * entered into the xlog buffer, we'll write and fsync that too, so that
+	 * the final value of LogwrtResult.Flush is as large as possible. This
+	 * gives us some chance of avoiding another fsync immediately after.
 	 */
 
 	/* initialize to given target; may increase below */
@@ -1669,31 +1663,29 @@ XLogFlush(XLogRecPtr record)
 
 	/*
 	 * If we still haven't flushed to the request point then we have a
-	 * problem; most likely, the requested flush point is past end of
-	 * XLOG. This has been seen to occur when a disk page has a corrupted
-	 * LSN.
+	 * problem; most likely, the requested flush point is past end of XLOG.
+	 * This has been seen to occur when a disk page has a corrupted LSN.
 	 *
-	 * Formerly we treated this as a PANIC condition, but that hurts the
-	 * system's robustness rather than helping it: we do not want to take
-	 * down the whole system due to corruption on one data page.  In
-	 * particular, if the bad page is encountered again during recovery
-	 * then we would be unable to restart the database at all!	(This
-	 * scenario has actually happened in the field several times with 7.1
-	 * releases. Note that we cannot get here while InRedo is true, but if
-	 * the bad page is brought in and marked dirty during recovery then
-	 * CreateCheckPoint will try to flush it at the end of recovery.)
+	 * Formerly we treated this as a PANIC condition, but that hurts the system's
+	 * robustness rather than helping it: we do not want to take down the
+	 * whole system due to corruption on one data page.  In particular, if the
+	 * bad page is encountered again during recovery then we would be unable
+	 * to restart the database at all!	(This scenario has actually happened
+	 * in the field several times with 7.1 releases. Note that we cannot get
+	 * here while InRedo is true, but if the bad page is brought in and marked
+	 * dirty during recovery then CreateCheckPoint will try to flush it at the
+	 * end of recovery.)
 	 *
-	 * The current approach is to ERROR under normal conditions, but only
-	 * WARNING during recovery, so that the system can be brought up even
-	 * if there's a corrupt LSN.  Note that for calls from xact.c, the
-	 * ERROR will be promoted to PANIC since xact.c calls this routine
-	 * inside a critical section.  However, calls from bufmgr.c are not
-	 * within critical sections and so we will not force a restart for a
-	 * bad LSN on a data page.
+	 * The current approach is to ERROR under normal conditions, but only WARNING
+	 * during recovery, so that the system can be brought up even if there's a
+	 * corrupt LSN.  Note that for calls from xact.c, the ERROR will be
+	 * promoted to PANIC since xact.c calls this routine inside a critical
+	 * section.  However, calls from bufmgr.c are not within critical sections
+	 * and so we will not force a restart for a bad LSN on a data page.
 	 */
 	if (XLByteLT(LogwrtResult.Flush, record))
 		elog(InRecovery ? WARNING : ERROR,
-			 "xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
+		"xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
 			 record.xlogid, record.xrecoff,
 			 LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff);
 }
@@ -1734,8 +1726,7 @@ XLogFileInit(uint32 log, uint32 seg,
 	XLogFilePath(path, ThisTimeLineID, log, seg);
 
 	/*
-	 * Try to use existent file (checkpoint maker may have created it
-	 * already)
+	 * Try to use existent file (checkpoint maker may have created it already)
 	 */
 	if (*use_existent)
 	{
@@ -1754,10 +1745,10 @@ XLogFileInit(uint32 log, uint32 seg,
 	}
 
 	/*
-	 * Initialize an empty (all zeroes) segment.  NOTE: it is possible
-	 * that another process is doing the same thing.  If so, we will end
-	 * up pre-creating an extra log segment.  That seems OK, and better
-	 * than holding the lock throughout this lengthy process.
+	 * Initialize an empty (all zeroes) segment.  NOTE: it is possible that
+	 * another process is doing the same thing.  If so, we will end up
+	 * pre-creating an extra log segment.  That seems OK, and better than
+	 * holding the lock throughout this lengthy process.
 	 */
 	snprintf(tmppath, MAXPGPATH, XLOGDIR "/xlogtemp.%d", (int) getpid());
 
@@ -1772,13 +1763,13 @@ XLogFileInit(uint32 log, uint32 seg,
 				 errmsg("could not create file \"%s\": %m", tmppath)));
 
 	/*
-	 * Zero-fill the file.	We have to do this the hard way to ensure that
-	 * all the file space has really been allocated --- on platforms that
-	 * allow "holes" in files, just seeking to the end doesn't allocate
-	 * intermediate space.	This way, we know that we have all the space
-	 * and (after the fsync below) that all the indirect blocks are down
-	 * on disk.  Therefore, fdatasync(2) or O_DSYNC will be sufficient to
-	 * sync future writes to the log file.
+	 * Zero-fill the file.	We have to do this the hard way to ensure that all
+	 * the file space has really been allocated --- on platforms that allow
+	 * "holes" in files, just seeking to the end doesn't allocate intermediate
+	 * space.  This way, we know that we have all the space and (after the
+	 * fsync below) that all the indirect blocks are down on disk.	Therefore,
+	 * fdatasync(2) or O_DSYNC will be sufficient to sync future writes to the
+	 * log file.
 	 */
 	MemSet(zbuffer, 0, sizeof(zbuffer));
 	for (nbytes = 0; nbytes < XLogSegSize; nbytes += sizeof(zbuffer))
@@ -1789,8 +1780,7 @@ XLogFileInit(uint32 log, uint32 seg,
 			int			save_errno = errno;
 
 			/*
-			 * If we fail to make the file, delete it to release disk
-			 * space
+			 * If we fail to make the file, delete it to release disk space
 			 */
 			unlink(tmppath);
 			/* if write didn't set errno, assume problem is no disk space */
@@ -1798,7 +1788,7 @@ XLogFileInit(uint32 log, uint32 seg,
 
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				 errmsg("could not write to file \"%s\": %m", tmppath)));
+					 errmsg("could not write to file \"%s\": %m", tmppath)));
 		}
 	}
 
@@ -1816,9 +1806,9 @@ XLogFileInit(uint32 log, uint32 seg,
 	 * Now move the segment into place with its final name.
 	 *
 	 * If caller didn't want to use a pre-existing file, get rid of any
-	 * pre-existing file.  Otherwise, cope with possibility that someone
-	 * else has created the file while we were filling ours: if so, use
-	 * ours to pre-create a future log segment.
+	 * pre-existing file.  Otherwise, cope with possibility that someone else
+	 * has created the file while we were filling ours: if so, use ours to
+	 * pre-create a future log segment.
 	 */
 	installed_log = log;
 	installed_seg = seg;
@@ -1840,8 +1830,8 @@ XLogFileInit(uint32 log, uint32 seg,
 	if (fd < 0)
 		ereport(ERROR,
 				(errcode_for_file_access(),
-		errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
-			   path, log, seg)));
+		   errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
+				  path, log, seg)));
 
 	return (fd);
 }
@@ -1908,7 +1898,7 @@ XLogFileCopy(uint32 log, uint32 seg,
 						 errmsg("could not read file \"%s\": %m", path)));
 			else
 				ereport(ERROR,
-					 (errmsg("not enough data in file \"%s\"", path)));
+						(errmsg("not enough data in file \"%s\"", path)));
 		}
 		errno = 0;
 		if ((int) write(fd, buffer, sizeof(buffer)) != (int) sizeof(buffer))
@@ -1916,8 +1906,7 @@ XLogFileCopy(uint32 log, uint32 seg,
 			int			save_errno = errno;
 
 			/*
-			 * If we fail to make the file, delete it to release disk
-			 * space
+			 * If we fail to make the file, delete it to release disk space
 			 */
 			unlink(tmppath);
 			/* if write didn't set errno, assume problem is no disk space */
@@ -1925,7 +1914,7 @@ XLogFileCopy(uint32 log, uint32 seg,
 
 			ereport(ERROR,
 					(errcode_for_file_access(),
-				 errmsg("could not write to file \"%s\": %m", tmppath)));
+					 errmsg("could not write to file \"%s\": %m", tmppath)));
 		}
 	}
 
@@ -2057,8 +2046,8 @@ XLogFileOpen(uint32 log, uint32 seg)
 	if (fd < 0)
 		ereport(PANIC,
 				(errcode_for_file_access(),
-		errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
-			   path, log, seg)));
+		   errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
+				  path, log, seg)));
 
 	return fd;
 }
@@ -2075,14 +2064,14 @@ XLogFileRead(uint32 log, uint32 seg, int emode)
 	int			fd;
 
 	/*
-	 * Loop looking for a suitable timeline ID: we might need to read any
-	 * of the timelines listed in expectedTLIs.
+	 * Loop looking for a suitable timeline ID: we might need to read any of
+	 * the timelines listed in expectedTLIs.
 	 *
 	 * We expect curFileTLI on entry to be the TLI of the preceding file in
-	 * sequence, or 0 if there was no predecessor.	We do not allow
-	 * curFileTLI to go backwards; this prevents us from picking up the
-	 * wrong file when a parent timeline extends to higher segment numbers
-	 * than the child we want to read.
+	 * sequence, or 0 if there was no predecessor.	We do not allow curFileTLI
+	 * to go backwards; this prevents us from picking up the wrong file when a
+	 * parent timeline extends to higher segment numbers than the child we
+	 * want to read.
 	 */
 	foreach(cell, expectedTLIs)
 	{
@@ -2111,8 +2100,8 @@ XLogFileRead(uint32 log, uint32 seg, int emode)
 		if (errno != ENOENT)	/* unexpected failure? */
 			ereport(PANIC,
 					(errcode_for_file_access(),
-					 errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
-							path, log, seg)));
+			errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
+				   path, log, seg)));
 	}
 
 	/* Couldn't find it.  For simplicity, complain about front timeline */
@@ -2120,8 +2109,8 @@ XLogFileRead(uint32 log, uint32 seg, int emode)
 	errno = ENOENT;
 	ereport(emode,
 			(errcode_for_file_access(),
-	   errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
-			  path, log, seg)));
+		   errmsg("could not open file \"%s\" (log file %u, segment %u): %m",
+				  path, log, seg)));
 	return -1;
 }
 
@@ -2152,29 +2141,27 @@ RestoreArchivedFile(char *path, const char *xlogfname,
 	struct stat stat_buf;
 
 	/*
-	 * When doing archive recovery, we always prefer an archived log file
-	 * even if a file of the same name exists in XLOGDIR.  The reason is
-	 * that the file in XLOGDIR could be an old, un-filled or
-	 * partly-filled version that was copied and restored as part of
-	 * backing up $PGDATA.
+	 * When doing archive recovery, we always prefer an archived log file even
+	 * if a file of the same name exists in XLOGDIR.  The reason is that the
+	 * file in XLOGDIR could be an old, un-filled or partly-filled version
+	 * that was copied and restored as part of backing up $PGDATA.
 	 *
 	 * We could try to optimize this slightly by checking the local copy
-	 * lastchange timestamp against the archived copy, but we have no API
-	 * to do this, nor can we guarantee that the lastchange timestamp was
-	 * preserved correctly when we copied to archive. Our aim is
-	 * robustness, so we elect not to do this.
+	 * lastchange timestamp against the archived copy, but we have no API to
+	 * do this, nor can we guarantee that the lastchange timestamp was
+	 * preserved correctly when we copied to archive. Our aim is robustness,
+	 * so we elect not to do this.
 	 *
-	 * If we cannot obtain the log file from the archive, however, we will
-	 * try to use the XLOGDIR file if it exists.  This is so that we can
-	 * make use of log segments that weren't yet transferred to the
-	 * archive.
+	 * If we cannot obtain the log file from the archive, however, we will try to
+	 * use the XLOGDIR file if it exists.  This is so that we can make use of
+	 * log segments that weren't yet transferred to the archive.
 	 *
-	 * Notice that we don't actually overwrite any files when we copy back
-	 * from archive because the recoveryRestoreCommand may inadvertently
-	 * restore inappropriate xlogs, or they may be corrupt, so we may wish
-	 * to fallback to the segments remaining in current XLOGDIR later. The
-	 * copy-from-archive filename is always the same, ensuring that we
-	 * don't run out of disk space on long recoveries.
+	 * Notice that we don't actually overwrite any files when we copy back from
+	 * archive because the recoveryRestoreCommand may inadvertently restore
+	 * inappropriate xlogs, or they may be corrupt, so we may wish to fallback
+	 * to the segments remaining in current XLOGDIR later. The
+	 * copy-from-archive filename is always the same, ensuring that we don't
+	 * run out of disk space on long recoveries.
 	 */
 	snprintf(xlogpath, MAXPGPATH, XLOGDIR "/%s", recovername);
 
@@ -2259,11 +2246,11 @@ RestoreArchivedFile(char *path, const char *xlogfname,
 		 * command apparently succeeded, but let's make sure the file is
 		 * really there now and has the correct size.
 		 *
-		 * XXX I made wrong-size a fatal error to ensure the DBA would notice
-		 * it, but is that too strong?	We could try to plow ahead with a
-		 * local copy of the file ... but the problem is that there
-		 * probably isn't one, and we'd incorrectly conclude we've reached
-		 * the end of WAL and we're done recovering ...
+		 * XXX I made wrong-size a fatal error to ensure the DBA would notice it,
+		 * but is that too strong?	We could try to plow ahead with a local
+		 * copy of the file ... but the problem is that there probably isn't
+		 * one, and we'd incorrectly conclude we've reached the end of WAL and
+		 * we're done recovering ...
 		 */
 		if (stat(xlogpath, &stat_buf) == 0)
 		{
@@ -2296,18 +2283,17 @@ RestoreArchivedFile(char *path, const char *xlogfname,
 	/*
 	 * remember, we rollforward UNTIL the restore fails so failure here is
 	 * just part of the process... that makes it difficult to determine
-	 * whether the restore failed because there isn't an archive to
-	 * restore, or because the administrator has specified the restore
-	 * program incorrectly.  We have to assume the former.
+	 * whether the restore failed because there isn't an archive to restore,
+	 * or because the administrator has specified the restore program
+	 * incorrectly.  We have to assume the former.
 	 */
 	ereport(DEBUG2,
-		 (errmsg("could not restore file \"%s\" from archive: return code %d",
-				 xlogfname, rc)));
+		(errmsg("could not restore file \"%s\" from archive: return code %d",
+				xlogfname, rc)));
 
 	/*
-	 * if an archived file is not available, there might still be a
-	 * version of this file in XLOGDIR, so return that as the filename to
-	 * open.
+	 * if an archived file is not available, there might still be a version of
+	 * this file in XLOGDIR, so return that as the filename to open.
 	 *
 	 * In many recovery scenarios we expect this to fail also, but if so that
 	 * just means we've reached the end of WAL.
@@ -2375,8 +2361,8 @@ MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr,
 	if (xldir == NULL)
 		ereport(ERROR,
 				(errcode_for_file_access(),
-			errmsg("could not open transaction log directory \"%s\": %m",
-				   XLOGDIR)));
+				 errmsg("could not open transaction log directory \"%s\": %m",
+						XLOGDIR)));
 
 	XLogFileName(lastoff, ThisTimeLineID, log, seg);
 
@@ -2384,14 +2370,14 @@ MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr,
 	{
 		/*
 		 * We ignore the timeline part of the XLOG segment identifiers in
-		 * deciding whether a segment is still needed.	This ensures that
-		 * we won't prematurely remove a segment from a parent timeline.
-		 * We could probably be a little more proactive about removing
-		 * segments of non-parent timelines, but that would be a whole lot
-		 * more complicated.
+		 * deciding whether a segment is still needed.	This ensures that we
+		 * won't prematurely remove a segment from a parent timeline. We could
+		 * probably be a little more proactive about removing segments of
+		 * non-parent timelines, but that would be a whole lot more
+		 * complicated.
 		 *
-		 * We use the alphanumeric sorting property of the filenames to
-		 * decide which ones are earlier than the lastoff segment.
+		 * We use the alphanumeric sorting property of the filenames to decide
+		 * which ones are earlier than the lastoff segment.
 		 */
 		if (strlen(xlde->d_name) == 24 &&
 			strspn(xlde->d_name, "0123456789ABCDEF") == 24 &&
@@ -2409,16 +2395,16 @@ MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr,
 				snprintf(path, MAXPGPATH, XLOGDIR "/%s", xlde->d_name);
 
 				/*
-				 * Before deleting the file, see if it can be recycled as
-				 * a future log segment.
+				 * Before deleting the file, see if it can be recycled as a
+				 * future log segment.
 				 */
 				if (InstallXLogFileSegment(&endlogId, &endlogSeg, path,
 										   true, &max_advance,
 										   true))
 				{
 					ereport(DEBUG2,
-						  (errmsg("recycled transaction log file \"%s\"",
-								  xlde->d_name)));
+							(errmsg("recycled transaction log file \"%s\"",
+									xlde->d_name)));
 					(*nsegsrecycled)++;
 					/* Needn't recheck that slot on future iterations */
 					if (max_advance > 0)
@@ -2431,8 +2417,8 @@ MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr,
 				{
 					/* No need for any more future segments... */
 					ereport(DEBUG2,
-						  (errmsg("removing transaction log file \"%s\"",
-								  xlde->d_name)));
+							(errmsg("removing transaction log file \"%s\"",
+									xlde->d_name)));
 					unlink(path);
 					(*nsegsremoved)++;
 				}
@@ -2459,8 +2445,8 @@ RemoveOldBackupHistory(void)
 	if (xldir == NULL)
 		ereport(ERROR,
 				(errcode_for_file_access(),
-			errmsg("could not open transaction log directory \"%s\": %m",
-				   XLOGDIR)));
+				 errmsg("could not open transaction log directory \"%s\": %m",
+						XLOGDIR)));
 
 	while ((xlde = ReadDir(xldir, XLOGDIR)) != NULL)
 	{
@@ -2473,8 +2459,8 @@ RemoveOldBackupHistory(void)
 			if (!XLogArchivingActive() || XLogArchiveIsDone(xlde->d_name))
 			{
 				ereport(DEBUG2,
-					  (errmsg("removing transaction log backup history file \"%s\"",
-							  xlde->d_name)));
+				(errmsg("removing transaction log backup history file \"%s\"",
+						xlde->d_name)));
 				snprintf(path, MAXPGPATH, XLOGDIR "/%s", xlde->d_name);
 				unlink(path);
 				XLogArchiveCleanup(xlde->d_name);
@@ -2576,7 +2562,7 @@ RecordIsValid(XLogRecord *record, XLogRecPtr recptr, int emode)
 	blk = (char *) XLogRecGetData(record) + len;
 	for (i = 0; i < XLR_MAX_BKP_BLOCKS; i++)
 	{
-		uint32	blen;
+		uint32		blen;
 
 		if (!(record->xl_info & XLR_SET_BKP_BLOCK(i)))
 			continue;
@@ -2611,8 +2597,8 @@ RecordIsValid(XLogRecord *record, XLogRecPtr recptr, int emode)
 	if (!EQ_CRC32(record->xl_crc, crc))
 	{
 		ereport(emode,
-				(errmsg("incorrect resource manager data checksum in record at %X/%X",
-						recptr.xlogid, recptr.xrecoff)));
+		(errmsg("incorrect resource manager data checksum in record at %X/%X",
+				recptr.xlogid, recptr.xrecoff)));
 		return false;
 	}
 
@@ -2647,12 +2633,11 @@ ReadRecord(XLogRecPtr *RecPtr, int emode)
 	if (readBuf == NULL)
 	{
 		/*
-		 * First time through, permanently allocate readBuf.  We do it
-		 * this way, rather than just making a static array, for two
-		 * reasons: (1) no need to waste the storage in most
-		 * instantiations of the backend; (2) a static char array isn't
-		 * guaranteed to have any particular alignment, whereas malloc()
-		 * will provide MAXALIGN'd storage.
+		 * First time through, permanently allocate readBuf.  We do it this
+		 * way, rather than just making a static array, for two reasons: (1)
+		 * no need to waste the storage in most instantiations of the backend;
+		 * (2) a static char array isn't guaranteed to have any particular
+		 * alignment, whereas malloc() will provide MAXALIGN'd storage.
 		 */
 		readBuf = (char *) malloc(BLCKSZ);
 		Assert(readBuf != NULL);
@@ -2685,11 +2670,11 @@ ReadRecord(XLogRecPtr *RecPtr, int emode)
 							RecPtr->xlogid, RecPtr->xrecoff)));
 
 		/*
-		 * Since we are going to a random position in WAL, forget any
-		 * prior state about what timeline we were in, and allow it to be
-		 * any timeline in expectedTLIs.  We also set a flag to allow
-		 * curFileTLI to go backwards (but we can't reset that variable
-		 * right here, since we might not change files at all).
+		 * Since we are going to a random position in WAL, forget any prior
+		 * state about what timeline we were in, and allow it to be any
+		 * timeline in expectedTLIs.  We also set a flag to allow curFileTLI
+		 * to go backwards (but we can't reset that variable right here, since
+		 * we might not change files at all).
 		 */
 		lastPageTLI = 0;		/* see comment in ValidXLOGHeader */
 		randAccess = true;		/* allow curFileTLI to go backwards too */
@@ -2741,9 +2726,9 @@ ReadRecord(XLogRecPtr *RecPtr, int emode)
 	if (targetRecOff == 0)
 	{
 		/*
-		 * Can only get here in the continuing-from-prev-page case,
-		 * because XRecOffIsValid eliminated the zero-page-offset case
-		 * otherwise. Need to skip over the new page's header.
+		 * Can only get here in the continuing-from-prev-page case, because
+		 * XRecOffIsValid eliminated the zero-page-offset case otherwise. Need
+		 * to skip over the new page's header.
 		 */
 		tmpRecPtr.xrecoff += pageHeaderSize;
 		targetRecOff = pageHeaderSize;
@@ -2791,14 +2776,14 @@ got_record:;
 	{
 		ereport(emode,
 				(errmsg("invalid resource manager ID %u at %X/%X",
-					 record->xl_rmid, RecPtr->xlogid, RecPtr->xrecoff)));
+						record->xl_rmid, RecPtr->xlogid, RecPtr->xrecoff)));
 		goto next_record_is_invalid;
 	}
 	if (randAccess)
 	{
 		/*
-		 * We can't exactly verify the prev-link, but surely it should be
-		 * less than the record's own address.
+		 * We can't exactly verify the prev-link, but surely it should be less
+		 * than the record's own address.
 		 */
 		if (!XLByteLT(record->xl_prev, *RecPtr))
 		{
@@ -2812,9 +2797,9 @@ got_record:;
 	else
 	{
 		/*
-		 * Record's prev-link should exactly match our previous location.
-		 * This check guards against torn WAL pages where a stale but
-		 * valid-looking WAL record starts on a sector boundary.
+		 * Record's prev-link should exactly match our previous location. This
+		 * check guards against torn WAL pages where a stale but valid-looking
+		 * WAL record starts on a sector boundary.
 		 */
 		if (!XLByteEQ(record->xl_prev, ReadRecPtr))
 		{
@@ -2827,11 +2812,10 @@ got_record:;
 	}
 
 	/*
-	 * Allocate or enlarge readRecordBuf as needed.  To avoid useless
-	 * small increases, round its size to a multiple of BLCKSZ, and make
-	 * sure it's at least 4*BLCKSZ to start with.  (That is enough for all
-	 * "normal" records, but very large commit or abort records might need
-	 *