Pgindent run for 8.0.

3 files changed, 348 insertions, 262 deletions

diff --git a/contrib/pg_trgm/trgm.h b/contrib/pg_trgm/trgm.h
index a56edca1297..73c4cb6aa6f 100644
--- a/contrib/pg_trgm/trgm.h
+++ b/contrib/pg_trgm/trgm.h
@@ -11,53 +11,54 @@
 #include "storage/bufpage.h"
 
 /* options */
-#define LPADDING        2
-#define RPADDING        1
+#define LPADDING		2
+#define RPADDING		1
 #define KEEPONLYALNUM
-#define IGNORECASE  
+#define IGNORECASE
 #define DIVUNION
 
 
 typedef char trgm[3];
 
 #define CMPCHAR(a,b) ( ((a)==(b)) ? 0 : ( ((a)<(b)) ? -1 : 1 ) )
-#define CMPPCHAR(a,b,i)  CMPCHAR( *(((char*)(a))+i), *(((char*)(b))+i) ) 
+#define CMPPCHAR(a,b,i)  CMPCHAR( *(((char*)(a))+i), *(((char*)(b))+i) )
 #define CMPTRGM(a,b) ( CMPPCHAR(a,b,0) ? CMPPCHAR(a,b,0) : ( CMPPCHAR(a,b,1) ? CMPPCHAR(a,b,1) : CMPPCHAR(a,b,2) ) )
 
-#define CPTRGM(a,b) do {		      	\
+#define CPTRGM(a,b) do {				\
 	*(((char*)(a))+0) = *(((char*)(b))+0);	\
 	*(((char*)(a))+1) = *(((char*)(b))+1);	\
 	*(((char*)(a))+2) = *(((char*)(b))+2);	\
 } while(0);
 
 
-typedef struct {
-	int4	len;
-	uint8	flag;
-	char	data[1];
-} TRGM;
+typedef struct
+{
+	int4		len;
+	uint8		flag;
+	char		data[1];
+}	TRGM;
 
-#define TRGMHRDSIZE       (sizeof(int4)+sizeof(uint8))
+#define TRGMHRDSIZE		  (sizeof(int4)+sizeof(uint8))
 
 /* gist */
 #define BITBYTE 8
-#define SIGLENINT  3               /* >122 => key will toast, so very slow!!! */
-#define SIGLEN  ( sizeof(int)*SIGLENINT )
+#define SIGLENINT  3			/* >122 => key will toast, so very slow!!! */
+#define SIGLEN	( sizeof(int)*SIGLENINT )
 
-#define SIGLENBIT (SIGLEN*BITBYTE - 1) /* see makesign */ 
+#define SIGLENBIT (SIGLEN*BITBYTE - 1)	/* see makesign */
 
 typedef char BITVEC[SIGLEN];
 typedef char *BITVECP;
 
 #define LOOPBYTE(a) \
-                for(i=0;i<SIGLEN;i++) {\
-                                a;\
-                }
+				for(i=0;i<SIGLEN;i++) {\
+								a;\
+				}
 
 #define LOOPBIT(a) \
-                for(i=0;i<SIGLENBIT;i++) {\
-                                a;\
-                }
+				for(i=0;i<SIGLENBIT;i++) {\
+								a;\
+				}
 
 #define GETBYTE(x,i) ( *( (BITVECP)(x) + (int)( (i) / BITBYTE ) ) )
 #define GETBITBYTE(x,i) ( ((char)(x)) >> i & 0x01 )
@@ -68,21 +69,21 @@ typedef char *BITVECP;
 #define HASHVAL(val) (((unsigned int)(val)) % SIGLENBIT)
 #define HASH(sign, val) SETBIT((sign), HASHVAL(val))
 
-#define ARRKEY          0x01
-#define SIGNKEY         0x02
-#define ALLISTRUE       0x04
-   
+#define ARRKEY			0x01
+#define SIGNKEY			0x02
+#define ALLISTRUE		0x04
+
 #define ISARRKEY(x) ( ((TRGM*)x)->flag & ARRKEY )
-#define ISSIGNKEY(x)    ( ((TRGM*)x)->flag & SIGNKEY )
-#define ISALLTRUE(x)    ( ((TRGM*)x)->flag & ALLISTRUE )
+#define ISSIGNKEY(x)	( ((TRGM*)x)->flag & SIGNKEY )
+#define ISALLTRUE(x)	( ((TRGM*)x)->flag & ALLISTRUE )
 
 #define CALCGTSIZE(flag, len) ( TRGMHRDSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(trgm)) : (((flag) & ALLISTRUE) ? 0 : SIGLEN) ) )
-#define GETSIGN(x)      ( (BITVECP)( (char*)x+TRGMHRDSIZE ) )
-#define GETARR(x)       ( (trgm*)( (char*)x+TRGMHRDSIZE ) )
+#define GETSIGN(x)		( (BITVECP)( (char*)x+TRGMHRDSIZE ) )
+#define GETARR(x)		( (trgm*)( (char*)x+TRGMHRDSIZE ) )
 #define ARRNELEM(x) ( ( ((TRGM*)x)->len - TRGMHRDSIZE )/sizeof(trgm) )
 
 extern float4 trgm_limit;
-TRGM* generate_trgm(char *str, int slen);
-float4 cnt_sml(TRGM *trg1, TRGM *trg2);
+TRGM	   *generate_trgm(char *str, int slen);
+float4		cnt_sml(TRGM * trg1, TRGM * trg2);
 
 #endif
diff --git a/contrib/pg_trgm/trgm_gist.c b/contrib/pg_trgm/trgm_gist.c
index 6f30a442448..3ae8f4b3aa2 100644
--- a/contrib/pg_trgm/trgm_gist.c
+++ b/contrib/pg_trgm/trgm_gist.c
@@ -71,12 +71,13 @@ makesign(BITVECP sign, TRGM * a)
 	int4		k,
 				len = ARRNELEM(a);
 	trgm	   *ptr = GETARR(a);
-	int4 tmp=0;
+	int4		tmp = 0;
 
 	MemSet((void *) sign, 0, sizeof(BITVEC));
-	SETBIT(sign, SIGLENBIT); /*set last unused bit*/
-	for (k = 0; k < len; k++) {
-		CPTRGM( ((char*)&tmp), ptr+k );
+	SETBIT(sign, SIGLENBIT);	/* set last unused bit */
+	for (k = 0; k < len; k++)
+	{
+		CPTRGM(((char *) &tmp), ptr + k);
 		HASH(sign, tmp);
 	}
 }
@@ -89,7 +90,7 @@ gtrgm_compress(PG_FUNCTION_ARGS)
 
 	if (entry->leafkey)
 	{							/* trgm */
-		TRGM   *res;
+		TRGM	   *res;
 		text	   *toastedval = (text *) DatumGetPointer(entry->key);
 		text	   *val = (text *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
 
@@ -107,7 +108,7 @@ gtrgm_compress(PG_FUNCTION_ARGS)
 	{
 		int4		i,
 					len;
-		TRGM   *res;
+		TRGM	   *res;
 		BITVECP		sign = GETSIGN(DatumGetPointer(entry->key));
 
 		LOOPBYTE(
@@ -137,37 +138,45 @@ gtrgm_decompress(PG_FUNCTION_ARGS)
 Datum
 gtrgm_consistent(PG_FUNCTION_ARGS)
 {
-	text  *query = (text *) PG_GETARG_TEXT_P(1);
-	TRGM   *key = (TRGM *) DatumGetPointer( ((GISTENTRY *) PG_GETARG_POINTER(0))->key );
-	TRGM   *qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ);
-	int res=false;
-
-	if ( GIST_LEAF( (GISTENTRY *) PG_GETARG_POINTER(0) ) ) { /* all leafs contains orig trgm */
-		float4 tmpsml = cnt_sml(key,qtrg);
-			/* strange bug at freebsd 5.2.1 and gcc 3.3.3 */
-		res = ( *(int*)&tmpsml==*(int*)&trgm_limit || tmpsml > trgm_limit ) ? true : false;
-	} else if ( ISALLTRUE(key) ) { /* non-leaf contains signature */
+	text	   *query = (text *) PG_GETARG_TEXT_P(1);
+	TRGM	   *key = (TRGM *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
+	TRGM	   *qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ);
+	int			res = false;
+
+	if (GIST_LEAF((GISTENTRY *) PG_GETARG_POINTER(0)))
+	{							/* all leafs contains orig trgm */
+		float4		tmpsml = cnt_sml(key, qtrg);
+
+		/* strange bug at freebsd 5.2.1 and gcc 3.3.3 */
+		res = (*(int *) &tmpsml == *(int *) &trgm_limit || tmpsml > trgm_limit) ? true : false;
+	}
+	else if (ISALLTRUE(key))
+	{							/* non-leaf contains signature */
 		res = true;
-	} else { /* non-leaf contains signature */
-		int4 count=0;
-		int4	k, len = ARRNELEM(qtrg);
+	}
+	else
+	{							/* non-leaf contains signature */
+		int4		count = 0;
+		int4		k,
+					len = ARRNELEM(qtrg);
 		trgm	   *ptr = GETARR(qtrg);
-		BITVECP	   sign = GETSIGN(key);
-		int4 tmp=0;
+		BITVECP		sign = GETSIGN(key);
+		int4		tmp = 0;
 
-		for (k = 0; k < len; k++) {
-			CPTRGM( ((char*)&tmp), ptr+k );
+		for (k = 0; k < len; k++)
+		{
+			CPTRGM(((char *) &tmp), ptr + k);
 			count += GETBIT(sign, HASHVAL(tmp));
 		}
 #ifdef DIVUNION
-		res = ( len==count ) ? true : ( ( ( ( ((float4)count) / ((float4)(len-count)) ) ) >= trgm_limit ) ? true : false );
+		res = (len == count) ? true : ((((((float4) count) / ((float4) (len - count)))) >= trgm_limit) ? true : false);
 #else
-		res = (len==0) ? false : ( ( ( ( ((float4)count) / ((float4)len) ) ) >= trgm_limit ) ? true : false );
+		res = (len == 0) ? false : ((((((float4) count) / ((float4) len))) >= trgm_limit) ? true : false);
 #endif
 	}
 
-	PG_FREE_IF_COPY(query,1);
-	pfree(qtrg); 
+	PG_FREE_IF_COPY(query, 1);
+	pfree(qtrg);
 
 	PG_RETURN_BOOL(res);
 }
@@ -191,10 +200,11 @@ unionkey(BITVECP sbase, TRGM * add)
 	else
 	{
 		trgm	   *ptr = GETARR(add);
-		int4 tmp=0;
+		int4		tmp = 0;
 
-		for (i = 0; i < ARRNELEM(add); i++) {
-			CPTRGM( ((char*)&tmp), ptr+i );
+		for (i = 0; i < ARRNELEM(add); i++)
+		{
+			CPTRGM(((char *) &tmp), ptr + i);
 			HASH(sbase, tmp);
 		}
 	}
@@ -205,13 +215,13 @@ unionkey(BITVECP sbase, TRGM * add)
 Datum
 gtrgm_union(PG_FUNCTION_ARGS)
 {
-        GistEntryVector      *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
-        int4        len = entryvec->n;
+	GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
+	int4		len = entryvec->n;
 	int		   *size = (int *) PG_GETARG_POINTER(1);
 	BITVEC		base;
 	int4		i;
 	int4		flag = 0;
-	TRGM   *result;
+	TRGM	   *result;
 
 	MemSet((void *) base, 0, sizeof(BITVEC));
 	for (i = 0; i < len; i++)
@@ -237,8 +247,8 @@ gtrgm_union(PG_FUNCTION_ARGS)
 Datum
 gtrgm_same(PG_FUNCTION_ARGS)
 {
-	TRGM   *a = (TRGM *) PG_GETARG_POINTER(0);
-	TRGM   *b = (TRGM *) PG_GETARG_POINTER(1);
+	TRGM	   *a = (TRGM *) PG_GETARG_POINTER(0);
+	TRGM	   *b = (TRGM *) PG_GETARG_POINTER(1);
 	bool	   *result = (bool *) PG_GETARG_POINTER(2);
 
 	if (ISSIGNKEY(a))
@@ -280,7 +290,7 @@ gtrgm_same(PG_FUNCTION_ARGS)
 
 			*result = true;
 			for (i = 0; i < lena; i++)
-				if (CMPTRGM(ptra+i, ptrb+i))
+				if (CMPTRGM(ptra + i, ptrb + i))
 				{
 					*result = false;
 					break;
@@ -298,34 +308,39 @@ sizebitvec(BITVECP sign)
 				i;
 
 	LOOPBYTE(
-		size += SUMBIT(*(char *) sign);
-		sign = (BITVECP) (((char *) sign) + 1);
+			 size += SUMBIT(*(char *) sign);
+	sign = (BITVECP) (((char *) sign) + 1);
 	);
 	return size;
 }
 
 static int
-hemdistsign(BITVECP  a, BITVECP b) {
-	int i,dist=0;
+hemdistsign(BITVECP a, BITVECP b)
+{
+	int			i,
+				dist = 0;
 
 	LOOPBIT(
-		if ( GETBIT(a,i) != GETBIT(b,i) )
+			if (GETBIT(a, i) != GETBIT(b, i))
 			dist++;
 	);
 	return dist;
 }
 
 static int
-hemdist(TRGM   *a, TRGM   *b) {
-	if ( ISALLTRUE(a) ) {
+hemdist(TRGM * a, TRGM * b)
+{
+	if (ISALLTRUE(a))
+	{
 		if (ISALLTRUE(b))
 			return 0;
 		else
-			return SIGLENBIT-sizebitvec(GETSIGN(b));
-	} else if (ISALLTRUE(b))
-		return SIGLENBIT-sizebitvec(GETSIGN(a));
+			return SIGLENBIT - sizebitvec(GETSIGN(b));
+	}
+	else if (ISALLTRUE(b))
+		return SIGLENBIT - sizebitvec(GETSIGN(a));
 
-	return hemdistsign( GETSIGN(a), GETSIGN(b) );
+	return hemdistsign(GETSIGN(a), GETSIGN(b));
 }
 
 Datum
@@ -334,23 +349,25 @@ gtrgm_penalty(PG_FUNCTION_ARGS)
 	GISTENTRY  *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
 	GISTENTRY  *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
 	float	   *penalty = (float *) PG_GETARG_POINTER(2);
-	TRGM   *origval = (TRGM *) DatumGetPointer(origentry->key);
-	TRGM   *newval = (TRGM *) DatumGetPointer(newentry->key);
+	TRGM	   *origval = (TRGM *) DatumGetPointer(origentry->key);
+	TRGM	   *newval = (TRGM *) DatumGetPointer(newentry->key);
 	BITVECP		orig = GETSIGN(origval);
 
 	*penalty = 0.0;
 
-	if (ISARRKEY(newval)) {
-		BITVEC sign;
+	if (ISARRKEY(newval))
+	{
+		BITVEC		sign;
+
 		makesign(sign, newval);
 
-		if ( ISALLTRUE(origval) ) 
-			*penalty=((float)(SIGLENBIT-sizebitvec(sign)))/(float)(SIGLENBIT+1);
-		else 
-			*penalty=hemdistsign(sign,orig);
-	} else {
-		*penalty=hemdist(origval,newval);
+		if (ISALLTRUE(origval))
+			*penalty = ((float) (SIGLENBIT - sizebitvec(sign))) / (float) (SIGLENBIT + 1);
+		else
+			*penalty = hemdistsign(sign, orig);
 	}
+	else
+		*penalty = hemdist(origval, newval);
 	PG_RETURN_POINTER(penalty);
 }
 
@@ -390,27 +407,30 @@ comparecost(const void *a, const void *b)
 
 
 static int
-hemdistcache(CACHESIGN   *a, CACHESIGN   *b) {
-	if ( a->allistrue ) {
+hemdistcache(CACHESIGN * a, CACHESIGN * b)
+{
+	if (a->allistrue)
+	{
 		if (b->allistrue)
 			return 0;
 		else
-			return SIGLENBIT-sizebitvec(b->sign);
-	} else if (b->allistrue)
-		return SIGLENBIT-sizebitvec(a->sign);
+			return SIGLENBIT - sizebitvec(b->sign);
+	}
+	else if (b->allistrue)
+		return SIGLENBIT - sizebitvec(a->sign);
 
-	return hemdistsign( a->sign, b->sign );
+	return hemdistsign(a->sign, b->sign);
 }
 
 Datum
 gtrgm_picksplit(PG_FUNCTION_ARGS)
 {
-        GistEntryVector      *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
-        OffsetNumber maxoff = entryvec->n - 2;
+	GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
+	OffsetNumber maxoff = entryvec->n - 2;
 	GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
 	OffsetNumber k,
 				j;
-	TRGM   *datum_l,
+	TRGM	   *datum_l,
 			   *datum_r;
 	BITVECP		union_l,
 				union_r;
@@ -435,13 +455,16 @@ gtrgm_picksplit(PG_FUNCTION_ARGS)
 	cache = (CACHESIGN *) palloc(sizeof(CACHESIGN) * (maxoff + 2));
 	fillcache(&cache[FirstOffsetNumber], GETENTRY(entryvec, FirstOffsetNumber));
 
-	for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) {
-		for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) {
+	for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
+	{
+		for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
+		{
 			if (k == FirstOffsetNumber)
 				fillcache(&cache[j], GETENTRY(entryvec, j));
 
-			size_waste=hemdistcache(&(cache[j]),&(cache[k]));
-			if (size_waste > waste) {
+			size_waste = hemdistcache(&(cache[j]), &(cache[k]));
+			if (size_waste > waste)
+			{
 				waste = size_waste;
 				seed_1 = k;
 				seed_2 = j;
@@ -454,101 +477,124 @@ gtrgm_picksplit(PG_FUNCTION_ARGS)
 	right = v->spl_right;
 	v->spl_nright = 0;
 
-	if (seed_1 == 0 || seed_2 == 0) {
+	if (seed_1 == 0 || seed_2 == 0)
+	{
 		seed_1 = 1;
 		seed_2 = 2;
 	}
 
 	/* form initial .. */
-	if (cache[seed_1].allistrue) {
+	if (cache[seed_1].allistrue)
+	{
 		datum_l = (TRGM *) palloc(CALCGTSIZE(SIGNKEY | ALLISTRUE, 0));
 		datum_l->len = CALCGTSIZE(SIGNKEY | ALLISTRUE, 0);
 		datum_l->flag = SIGNKEY | ALLISTRUE;
-	} else {
+	}
+	else
+	{
 		datum_l = (TRGM *) palloc(CALCGTSIZE(SIGNKEY, 0));
 		datum_l->len = CALCGTSIZE(SIGNKEY, 0);
 		datum_l->flag = SIGNKEY;
 		memcpy((void *) GETSIGN(datum_l), (void *) cache[seed_1].sign, sizeof(BITVEC));
 	}
-	if (cache[seed_2].allistrue) {
+	if (cache[seed_2].allistrue)
+	{
 		datum_r = (TRGM *) palloc(CALCGTSIZE(SIGNKEY | ALLISTRUE, 0));
 		datum_r->len = CALCGTSIZE(SIGNKEY | ALLISTRUE, 0);
 		datum_r->flag = SIGNKEY | ALLISTRUE;
-	} else {
+	}
+	else
+	{
 		datum_r = (TRGM *) palloc(CALCGTSIZE(SIGNKEY, 0));
 		datum_r->len = CALCGTSIZE(SIGNKEY, 0);
 		datum_r->flag = SIGNKEY;
 		memcpy((void *) GETSIGN(datum_r), (void *) cache[seed_2].sign, sizeof(BITVEC));
 	}
 
-	union_l=GETSIGN(datum_l);
-	union_r=GETSIGN(datum_r);
+	union_l = GETSIGN(datum_l);
+	union_r = GETSIGN(datum_r);
 	maxoff = OffsetNumberNext(maxoff);
 	fillcache(&cache[maxoff], GETENTRY(entryvec, maxoff));
 	/* sort before ... */
 	costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
-	for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j)) {
+	for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
+	{
 		costvector[j - 1].pos = j;
 		size_alpha = hemdistcache(&(cache[seed_1]), &(cache[j]));
-		size_beta  = hemdistcache(&(cache[seed_2]), &(cache[j]));
+		size_beta = hemdistcache(&(cache[seed_2]), &(cache[j]));
 		costvector[j - 1].cost = abs(size_alpha - size_beta);
 	}
 	qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
 
-	for (k = 0; k < maxoff; k++) {
+	for (k = 0; k < maxoff; k++)
+	{
 		j = costvector[k].pos;
-		if (j == seed_1) {
+		if (j == seed_1)
+		{
 			*left++ = j;
 			v->spl_nleft++;
 			continue;
-		} else if (j == seed_2) {
+		}
+		else if (j == seed_2)
+		{
 			*right++ = j;
 			v->spl_nright++;
 			continue;
 		}
 
-		if (ISALLTRUE(datum_l) || cache[j].allistrue) {
-			if ( ISALLTRUE(datum_l) && cache[j].allistrue )
-				size_alpha=0;
+		if (ISALLTRUE(datum_l) || cache[j].allistrue)
+		{
+			if (ISALLTRUE(datum_l) && cache[j].allistrue)
+				size_alpha = 0;
 			else
-				size_alpha = SIGLENBIT-sizebitvec(  
-					( cache[j].allistrue ) ? GETSIGN(datum_l) : GETSIGN(cache[j].sign)  
-				);
-		} else {
-			size_alpha=hemdistsign(cache[j].sign,GETSIGN(datum_l));
+				size_alpha = SIGLENBIT - sizebitvec(
+													(cache[j].allistrue) ? GETSIGN(datum_l) : GETSIGN(cache[j].sign)
+					);
 		}
+		else
+			size_alpha = hemdistsign(cache[j].sign, GETSIGN(datum_l));
 
-		if (ISALLTRUE(datum_r) || cache[j].allistrue) {
-			if ( ISALLTRUE(datum_r) && cache[j].allistrue )
-				size_beta=0;
+		if (ISALLTRUE(datum_r) || cache[j].allistrue)
+		{
+			if (ISALLTRUE(datum_r) && cache[j].allistrue)
+				size_beta = 0;
 			else
-				size_beta = SIGLENBIT-sizebitvec(  
-					( cache[j].allistrue ) ? GETSIGN(datum_r) : GETSIGN(cache[j].sign)  
-				);
-		} else {
-			size_beta=hemdistsign(cache[j].sign,GETSIGN(datum_r));
+				size_beta = SIGLENBIT - sizebitvec(
+												   (cache[j].allistrue) ? GETSIGN(datum_r) : GETSIGN(cache[j].sign)
+					);
 		}
+		else
+			size_beta = hemdistsign(cache[j].sign, GETSIGN(datum_r));
 
-		if (size_alpha  < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1)) {
-			if (ISALLTRUE(datum_l) || cache[j].allistrue) {
-				if (! ISALLTRUE(datum_l) )
+		if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1))
+		{
+			if (ISALLTRUE(datum_l) || cache[j].allistrue)
+			{
+				if (!ISALLTRUE(datum_l))
 					MemSet((void *) GETSIGN(datum_l), 0xff, sizeof(BITVEC));
-			} else {
-				ptr=cache[j].sign;
+			}
+			else
+			{
+				ptr = cache[j].sign;
 				LOOPBYTE(
-					union_l[i] |= ptr[i];
+						 union_l[i] |= ptr[i];
 				);
 			}
 			*left++ = j;
 			v->spl_nleft++;
-		} else {
-			if (ISALLTRUE(datum_r) || cache[j].allistrue) {
-				if (! ISALLTRUE(datum_r) )
+		}
+		else
+		{
+			if (ISALLTRUE(datum_r) || cache[j].allistrue)
+			{
+				if (!ISALLTRUE(datum_r))
 					MemSet((void *) GETSIGN(datum_r), 0xff, sizeof(BITVEC));
-			} else {
-				ptr=cache[j].sign;
+			}
+			else
+			{
+				ptr = cache[j].sign;
 				LOOPBYTE(
-					union_r[i] |= ptr[i];
+						 union_r[i] |= ptr[i];
 				);
 			}
 			*right++ = j;
diff --git a/contrib/pg_trgm/trgm_op.c b/contrib/pg_trgm/trgm_op.c
index 01ece90cdf5..57fb944a569 100644
--- a/contrib/pg_trgm/trgm_op.c
+++ b/contrib/pg_trgm/trgm_op.c
@@ -3,136 +3,162 @@
 #include "utils/array.h"
 #include "catalog/pg_type.h"
 
-float4 trgm_limit = 0.3;
+float4		trgm_limit = 0.3;
 
 PG_FUNCTION_INFO_V1(set_limit);
-Datum set_limit(PG_FUNCTION_ARGS);
+Datum		set_limit(PG_FUNCTION_ARGS);
 Datum
-set_limit(PG_FUNCTION_ARGS) {
-	float4 nlimit = PG_GETARG_FLOAT4(0);
-	if ( nlimit < 0 || nlimit > 1.0 ) 
-		elog(ERROR,"Wrong limit, should be between 0 and 1");
+set_limit(PG_FUNCTION_ARGS)
+{
+	float4		nlimit = PG_GETARG_FLOAT4(0);
+
+	if (nlimit < 0 || nlimit > 1.0)
+		elog(ERROR, "Wrong limit, should be between 0 and 1");
 	trgm_limit = nlimit;
 	PG_RETURN_FLOAT4(trgm_limit);
 }
 
 PG_FUNCTION_INFO_V1(show_limit);
-Datum show_limit(PG_FUNCTION_ARGS);
+Datum		show_limit(PG_FUNCTION_ARGS);
 Datum
-show_limit(PG_FUNCTION_ARGS) {
+show_limit(PG_FUNCTION_ARGS)
+{
 	PG_RETURN_FLOAT4(trgm_limit);
 }
 
-#define WORDWAIT        0
-#define INWORD          1
+#define WORDWAIT		0
+#define INWORD			1
 
 static int
-comp_trgm(const void *a, const void *b) {
-	return CMPTRGM(a,b);
+comp_trgm(const void *a, const void *b)
+{
+	return CMPTRGM(a, b);
 }
 
 static int
-unique_array (trgm *a, int len) {
-	trgm *curend, *tmp;
+unique_array(trgm * a, int len)
+{
+	trgm	   *curend,
+			   *tmp;
 
 	curend = tmp = a;
 	while (tmp - a < len)
-		if ( CMPTRGM(tmp, curend) ) {
+		if (CMPTRGM(tmp, curend))
+		{
 			curend++;
-			CPTRGM(curend,tmp);
+			CPTRGM(curend, tmp);
 			tmp++;
-		} else
+		}
+		else
 			tmp++;
- 
+
 	return curend + 1 - a;
 }
 
 
-TRGM*
-generate_trgm(char *str, int slen) {
-	TRGM*	trg;
-	char	*buf,*sptr,*bufptr;
-	trgm	*tptr;
-	int     state=WORDWAIT;
-	int wl,len;
+TRGM *
+generate_trgm(char *str, int slen)
+{
+	TRGM	   *trg;
+	char	   *buf,
+			   *sptr,
+			   *bufptr;
+	trgm	   *tptr;
+	int			state = WORDWAIT;
+	int			wl,
+				len;
 
-	trg = (TRGM*) palloc(TRGMHRDSIZE+sizeof(trgm) * (slen/2 + 1) * 3);
+	trg = (TRGM *) palloc(TRGMHRDSIZE + sizeof(trgm) * (slen / 2 + 1) * 3);
 	trg->flag = ARRKEY;
 	trg->len = TRGMHRDSIZE;
 
-	if ( slen+LPADDING+RPADDING<3 || slen == 0 )
+	if (slen + LPADDING + RPADDING < 3 || slen == 0)
 		return trg;
 
 	tptr = GETARR(trg);
 
-	buf = palloc(sizeof(char) * (slen+4));
+	buf = palloc(sizeof(char) * (slen + 4));
 	sptr = str;
 
-	if ( LPADDING > 0 ) {
+	if (LPADDING > 0)
+	{
 		*buf = ' ';
-		if ( LPADDING > 1 )
-			*(buf+1) = ' ';
+		if (LPADDING > 1)
+			*(buf + 1) = ' ';
 	}
 
-	bufptr = buf+LPADDING;
-	while( sptr-str < slen ) {
-		if ( state == WORDWAIT ) {
-			if ( 
+	bufptr = buf + LPADDING;
+	while (sptr - str < slen)
+	{
+		if (state == WORDWAIT)
+		{
+			if (
 #ifdef	KEEPONLYALNUM
-	 			isalnum((unsigned char)*sptr)
+				isalnum((unsigned char) *sptr)
 #else
-				!isspace( (unsigned char)*sptr )
+				!isspace((unsigned char) *sptr)
 #endif
-				) {
-				*bufptr = *sptr; /* start put word in buffer */
+				)
+			{
+				*bufptr = *sptr;	/* start put word in buffer */
 				bufptr++;
 				state = INWORD;
-				if ( sptr-str == slen-1 /* last char */ )
+				if (sptr - str == slen - 1 /* last char */ )
 					goto gettrg;
 			}
-		} else {
+		}
+		else
+		{
 			if (
 #ifdef	KEEPONLYALNUM
-	 			!isalnum((unsigned char)*sptr)
+				!isalnum((unsigned char) *sptr)
 #else
-				isspace( (unsigned char)*sptr )			
+				isspace((unsigned char) *sptr)
 #endif
-				) {
-gettrg:
+				)
+			{
+		gettrg:
 				/* word in buffer, so count trigrams */
 				*bufptr = ' ';
-				*(bufptr+1) = ' ';
-				wl = bufptr - (buf+LPADDING) - 2 + LPADDING + RPADDING;
-				if ( wl<=0 ) {
-					bufptr = buf+LPADDING;
+				*(bufptr + 1) = ' ';
+				wl = bufptr - (buf + LPADDING) - 2 + LPADDING + RPADDING;
+				if (wl <= 0)
+				{
+					bufptr = buf + LPADDING;
 					state = WORDWAIT;
 					sptr++;
 					continue;
 				}
 
 #ifdef IGNORECASE
-				do { /* lower word */
-					int wwl = bufptr-buf;
-					bufptr = buf+LPADDING;
-					while( bufptr-buf < wwl ) {
-						*bufptr = tolower( (unsigned char) *bufptr );
+				do
+				{				/* lower word */
+					int			wwl = bufptr - buf;
+
+					bufptr = buf + LPADDING;
+					while (bufptr - buf < wwl)
+					{
+						*bufptr = tolower((unsigned char) *bufptr);
 						bufptr++;
 					}
-				} while(0);
+				} while (0);
 #endif
 				bufptr = buf;
 				/* set trigrams */
-				while( bufptr-buf < wl ) {
+				while (bufptr - buf < wl)
+				{
 					CPTRGM(tptr, bufptr);
 					bufptr++;
 					tptr++;
 				}
-				bufptr = buf+LPADDING;
+				bufptr = buf + LPADDING;
 				state = WORDWAIT;
-			} else {
-				*bufptr = *sptr; /* put in buffer */
+			}
+			else
+			{
+				*bufptr = *sptr;	/* put in buffer */
 				bufptr++;
-				if ( sptr-str == slen-1 )
+				if (sptr - str == slen - 1)
 					goto gettrg;
 			}
 		}
@@ -141,13 +167,14 @@ gettrg:
 
 	pfree(buf);
 
-	if ( (len=tptr-GETARR(trg)) == 0 ) 
+	if ((len = tptr - GETARR(trg)) == 0)
 		return trg;
 
-	if ( len>0 ) {
-		qsort( (void*)GETARR(trg), len, sizeof(trgm), comp_trgm );
-		len = unique_array( GETARR(trg), len );
-	} 
+	if (len > 0)
+	{
+		qsort((void *) GETARR(trg), len, sizeof(trgm), comp_trgm);
+		len = unique_array(GETARR(trg), len);
+	}
 
 	trg->len = CALCGTSIZE(ARRKEY, len);
 
@@ -156,68 +183,78 @@ gettrg:
 
 
 PG_FUNCTION_INFO_V1(show_trgm);
-Datum show_trgm(PG_FUNCTION_ARGS);
+Datum		show_trgm(PG_FUNCTION_ARGS);
 Datum
-show_trgm(PG_FUNCTION_ARGS) {
-	text       *in = PG_GETARG_TEXT_P(0);
-	TRGM	*trg;
-	Datum *d;
-	ArrayType *a;
-	trgm *ptr;
+show_trgm(PG_FUNCTION_ARGS)
+{
+	text	   *in = PG_GETARG_TEXT_P(0);
+	TRGM	   *trg;
+	Datum	   *d;
+	ArrayType  *a;
+	trgm	   *ptr;
 
 	trg = generate_trgm(VARDATA(in), VARSIZE(in) - VARHDRSZ);
-	d = (Datum*)palloc( sizeof(Datum)*(1+ARRNELEM(trg)) );
+	d = (Datum *) palloc(sizeof(Datum) * (1 + ARRNELEM(trg)));
 
 	ptr = GETARR(trg);
-	while( ptr-GETARR(trg) < ARRNELEM(trg) ) {
-		text *item=(text*)palloc(VARHDRSZ + 3);
-		VARATT_SIZEP(item) = VARHDRSZ+3;
+	while (ptr - GETARR(trg) < ARRNELEM(trg))
+	{
+		text	   *item = (text *) palloc(VARHDRSZ + 3);
+
+		VARATT_SIZEP(item) = VARHDRSZ + 3;
 		CPTRGM(VARDATA(item), ptr);
-		d[ ptr-GETARR(trg) ] = PointerGetDatum(item);
+		d[ptr - GETARR(trg)] = PointerGetDatum(item);
 		ptr++;
 	}
 
 	a = construct_array(
-		d,
-		ARRNELEM(trg),
-		TEXTOID,
-		-1,
-		false,
-		'i'
-	);
+						d,
+						ARRNELEM(trg),
+						TEXTOID,
+						-1,
+						false,
+						'i'
+		);
 
 	ptr = GETARR(trg);
-	while( ptr-GETARR(trg) < ARRNELEM(trg) ) {
-		pfree(DatumGetPointer(d[ ptr-GETARR(trg) ]));
+	while (ptr - GETARR(trg) < ARRNELEM(trg))
+	{
+		pfree(DatumGetPointer(d[ptr - GETARR(trg)]));
 		ptr++;
 	}
-	
+
 	pfree(d);
 	pfree(trg);
-	PG_FREE_IF_COPY(in,0);
+	PG_FREE_IF_COPY(in, 0);
 
 	PG_RETURN_POINTER(a);
 }
 
 float4
-cnt_sml(TRGM *trg1, TRGM *trg2) {
-	trgm	*ptr1, *ptr2;
-	int count=0;
-	int len1, len2;
-	
+cnt_sml(TRGM * trg1, TRGM * trg2)
+{
+	trgm	   *ptr1,
+			   *ptr2;
+	int			count = 0;
+	int			len1,
+				len2;
+
 	ptr1 = GETARR(trg1);
 	ptr2 = GETARR(trg2);
-	
+
 	len1 = ARRNELEM(trg1);
 	len2 = ARRNELEM(trg2);
 
-	while( ptr1 - GETARR(trg1) < len1 && ptr2 - GETARR(trg2) < len2 ) {
-		int res = CMPTRGM(ptr1,ptr2);
-		if ( res < 0 ) {
+	while (ptr1 - GETARR(trg1) < len1 && ptr2 - GETARR(trg2) < len2)
+	{
+		int			res = CMPTRGM(ptr1, ptr2);
+
+		if (res < 0)
 			ptr1++;
-		} else if ( res > 0 ) {
+		else if (res > 0)
 			ptr2++;
-		} else {
+		else
+		{
 			ptr1++;
 			ptr2++;
 			count++;
@@ -225,45 +262,47 @@ cnt_sml(TRGM *trg1, TRGM *trg2) {
 	}
 
 #ifdef DIVUNION
-	return ( ( ((float4)count) / ((float4)(len1+len2-count)) ) );
+	return ((((float4) count) / ((float4) (len1 + len2 - count))));
 #else
-	return ( ((float)count) / ((float)( (len1>len2) ? len1 : len2 )) );
+	return (((float) count) / ((float) ((len1 > len2) ? len1 : len2)));
 #endif
 
 }
 
 PG_FUNCTION_INFO_V1(similarity);
-Datum similarity(PG_FUNCTION_ARGS);
+Datum		similarity(PG_FUNCTION_ARGS);
 Datum
-similarity(PG_FUNCTION_ARGS) {
-	text       *in1 = PG_GETARG_TEXT_P(0);
-	text       *in2 = PG_GETARG_TEXT_P(1);
-	TRGM    *trg1, *trg2;
-	float4 res;
+similarity(PG_FUNCTION_ARGS)
+{
+	text	   *in1 = PG_GETARG_TEXT_P(0);
+	text	   *in2 = PG_GETARG_TEXT_P(1);
+	TRGM	   *trg1,
+			   *trg2;
+	float4		res;
 
 	trg1 = generate_trgm(VARDATA(in1), VARSIZE(in1) - VARHDRSZ);
 	trg2 = generate_trgm(VARDATA(in2), VARSIZE(in2) - VARHDRSZ);
 
-	res = cnt_sml(trg1,trg2);
-	
+	res = cnt_sml(trg1, trg2);
+
 	pfree(trg1);
 	pfree(trg2);
-	PG_FREE_IF_COPY(in1,0);
-	PG_FREE_IF_COPY(in2,1);
-	
+	PG_FREE_IF_COPY(in1, 0);
+	PG_FREE_IF_COPY(in2, 1);
+
 	PG_RETURN_FLOAT4(res);
 }
 
 PG_FUNCTION_INFO_V1(similarity_op);
-Datum similarity_op(PG_FUNCTION_ARGS);
+Datum		similarity_op(PG_FUNCTION_ARGS);
 Datum
-similarity_op(PG_FUNCTION_ARGS) {
-	float4 res=DatumGetFloat4( DirectFunctionCall2(
-		similarity,
-		PG_GETARG_DATUM(0),
-		PG_GETARG_DATUM(1)
-	) );
-	PG_RETURN_BOOL( res >= trgm_limit );
+similarity_op(PG_FUNCTION_ARGS)
+{
+	float4		res = DatumGetFloat4(DirectFunctionCall2(
+														 similarity,
+													  PG_GETARG_DATUM(0),
+													   PG_GETARG_DATUM(1)
+														 ));
+
+	PG_RETURN_BOOL(res >= trgm_limit);
 }
-
-