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

tests pass.

1 files changed, 382 insertions, 338 deletions

diff --git a/contrib/btree_gist/btree_gist.c b/contrib/btree_gist/btree_gist.c
index 999d199ff20..4235c0a5d9b 100644
--- a/contrib/btree_gist/btree_gist.c
+++ b/contrib/btree_gist/btree_gist.c
@@ -8,43 +8,46 @@
 #include "utils/geo_decls.h"
 #include "utils/elog.h"
 
-typedef int (*CMPFUNC)(const void *a, const void *b);
-typedef void (*BINARY_UNION)(Datum*, char*);
+typedef int (*CMPFUNC) (const void *a, const void *b);
+typedef void (*BINARY_UNION) (Datum *, char *);
 
-typedef struct intkey {
-	int4	lower;
-	int4	upper;
-} INT4KEY; 
+typedef struct intkey
+{
+	int4		lower;
+	int4		upper;
+}			INT4KEY;
 
-typedef struct tskey {
-        Timestamp       lower;
-        Timestamp       upper;
-} TSKEY;
+typedef struct tskey
+{
+	Timestamp	lower;
+	Timestamp	upper;
+}			TSKEY;
 
 /* used for sorting */
-typedef struct rix {
-    int index;
-    char *r;
-} RIX;
+typedef struct rix
+{
+	int			index;
+	char	   *r;
+}			RIX;
 
 /*
 ** int4key in/out
 */
 PG_FUNCTION_INFO_V1(int4key_in);
 PG_FUNCTION_INFO_V1(int4key_out);
-Datum	int4key_in(PG_FUNCTION_ARGS);
-Datum	int4key_out(PG_FUNCTION_ARGS);
+Datum		int4key_in(PG_FUNCTION_ARGS);
+Datum		int4key_out(PG_FUNCTION_ARGS);
 
 /*
 ** tskey in/out
 */
 PG_FUNCTION_INFO_V1(tskey_in);
 PG_FUNCTION_INFO_V1(tskey_out);
-Datum	tskey_in(PG_FUNCTION_ARGS);
-Datum	tskey_out(PG_FUNCTION_ARGS);
+Datum		tskey_in(PG_FUNCTION_ARGS);
+Datum		tskey_out(PG_FUNCTION_ARGS);
 
 /*
-** int4 ops 
+** int4 ops
 */
 PG_FUNCTION_INFO_V1(gint4_compress);
 PG_FUNCTION_INFO_V1(gint4_union);
@@ -53,15 +56,15 @@ PG_FUNCTION_INFO_V1(gint4_consistent);
 PG_FUNCTION_INFO_V1(gint4_penalty);
 PG_FUNCTION_INFO_V1(gint4_same);
 
-Datum	gint4_compress(PG_FUNCTION_ARGS);
-Datum	gint4_union(PG_FUNCTION_ARGS);
-Datum	gint4_picksplit(PG_FUNCTION_ARGS);
-Datum	gint4_consistent(PG_FUNCTION_ARGS);
-Datum	gint4_penalty(PG_FUNCTION_ARGS);
-Datum	gint4_same(PG_FUNCTION_ARGS);
+Datum		gint4_compress(PG_FUNCTION_ARGS);
+Datum		gint4_union(PG_FUNCTION_ARGS);
+Datum		gint4_picksplit(PG_FUNCTION_ARGS);
+Datum		gint4_consistent(PG_FUNCTION_ARGS);
+Datum		gint4_penalty(PG_FUNCTION_ARGS);
+Datum		gint4_same(PG_FUNCTION_ARGS);
 
 static void gint4_binary_union(Datum *r1, char *r2);
-static int int4key_cmp(const void *a, const void *b);
+static int	int4key_cmp(const void *a, const void *b);
 
 /*
 ** timestamp ops
@@ -73,51 +76,51 @@ PG_FUNCTION_INFO_V1(gts_consistent);
 PG_FUNCTION_INFO_V1(gts_penalty);
 PG_FUNCTION_INFO_V1(gts_same);
 
-Datum   gts_compress(PG_FUNCTION_ARGS);
-Datum   gts_union(PG_FUNCTION_ARGS);
-Datum   gts_picksplit(PG_FUNCTION_ARGS);
-Datum   gts_consistent(PG_FUNCTION_ARGS);
-Datum   gts_penalty(PG_FUNCTION_ARGS);
-Datum   gts_same(PG_FUNCTION_ARGS);
+Datum		gts_compress(PG_FUNCTION_ARGS);
+Datum		gts_union(PG_FUNCTION_ARGS);
+Datum		gts_picksplit(PG_FUNCTION_ARGS);
+Datum		gts_consistent(PG_FUNCTION_ARGS);
+Datum		gts_penalty(PG_FUNCTION_ARGS);
+Datum		gts_same(PG_FUNCTION_ARGS);
 
 static void gts_binary_union(Datum *r1, char *r2);
-static int tskey_cmp(const void *a, const void *b);
+static int	tskey_cmp(const void *a, const void *b);
 
 /* define for comparison */
 #define TSGE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_ge, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_ge, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSGT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_gt, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_gt, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSEQ( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_eq, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_eq, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSLT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_lt, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_lt, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 #define TSLE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \
-        timestamp_le, \
-        PointerGetDatum( ts1 ), \
-        PointerGetDatum( ts2 ) \
+		timestamp_le, \
+		PointerGetDatum( ts1 ), \
+		PointerGetDatum( ts2 ) \
 )))
 
 /*
 ** Common btree-function (for all ops)
 */
-static GIST_SPLITVEC * btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, 
-	BINARY_UNION bu, CMPFUNC cmp);
+static GIST_SPLITVEC *btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
+				BINARY_UNION bu, CMPFUNC cmp);
 
 PG_FUNCTION_INFO_V1(btree_decompress);
-Datum btree_decompress(PG_FUNCTION_ARGS);
+Datum		btree_decompress(PG_FUNCTION_ARGS);
 
 /**************************************************
  * int4 ops
@@ -126,334 +129,364 @@ Datum btree_decompress(PG_FUNCTION_ARGS);
 Datum
 gint4_compress(PG_FUNCTION_ARGS)
 {
-	GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
-	GISTENTRY *retval;
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	GISTENTRY  *retval;
+
+	if (entry->leafkey)
+	{
+		INT4KEY    *r = palloc(sizeof(INT4KEY));
 
-	if ( entry->leafkey) {
-		INT4KEY *r = palloc(sizeof(INT4KEY));
 		retval = palloc(sizeof(GISTENTRY));
 		r->lower = r->upper = (entry->key);
-		
+
 		gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
-			entry->offset, sizeof(INT4KEY),FALSE);
+					  entry->offset, sizeof(INT4KEY), FALSE);
 
-	} else {
-		retval = entry;
 	}
-	PG_RETURN_POINTER( retval );
+	else
+		retval = entry;
+	PG_RETURN_POINTER(retval);
 }
 
-Datum 
+Datum
 gint4_consistent(PG_FUNCTION_ARGS)
 {
-    GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
-    int4 query       = PG_GETARG_INT32(1);
-    INT4KEY *kkk= (INT4KEY *)DatumGetPointer(entry->key);
-    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
-    bool retval;
-
-    switch(strategy) {
-	case BTLessEqualStrategyNumber:
-		retval = ( query >= kkk->lower );
-		break;
-	case BTLessStrategyNumber:
-		if (GIST_LEAF(entry)) 
-			retval = ( query >  kkk->lower  );
-		else 
-			retval = ( query >= kkk->lower ); 
-		break;
-	case BTEqualStrategyNumber:
-    		/* in leaf page kkk->lower always = kkk->upper */
-		if (GIST_LEAF(entry)) 
-			retval = ( query == kkk->lower );
-		else 
-			retval = ( kkk->lower <= query && query <= kkk->upper ); 
-		break;
-	case BTGreaterStrategyNumber:
-		if (GIST_LEAF(entry)) 
-			retval = ( query <  kkk->upper  );
-		else 
-			retval = ( query <= kkk->upper ); 
-		break;
-	case BTGreaterEqualStrategyNumber:
-		retval = ( query <= kkk->upper );
-		break;
-	default:
-		retval = FALSE;
-    }
-    PG_RETURN_BOOL(retval);
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	int4		query = PG_GETARG_INT32(1);
+	INT4KEY    *kkk = (INT4KEY *) DatumGetPointer(entry->key);
+	StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+	bool		retval;
+
+	switch (strategy)
+	{
+		case BTLessEqualStrategyNumber:
+			retval = (query >= kkk->lower);
+			break;
+		case BTLessStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = (query > kkk->lower);
+			else
+				retval = (query >= kkk->lower);
+			break;
+		case BTEqualStrategyNumber:
+			/* in leaf page kkk->lower always = kkk->upper */
+			if (GIST_LEAF(entry))
+				retval = (query == kkk->lower);
+			else
+				retval = (kkk->lower <= query && query <= kkk->upper);
+			break;
+		case BTGreaterStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = (query < kkk->upper);
+			else
+				retval = (query <= kkk->upper);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			retval = (query <= kkk->upper);
+			break;
+		default:
+			retval = FALSE;
+	}
+	PG_RETURN_BOOL(retval);
 }
 
 Datum
 gint4_union(PG_FUNCTION_ARGS)
 {
-    bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
-    int i, numranges;
-    INT4KEY *cur, *out=palloc(sizeof(INT4KEY));
-
-    numranges  = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); 
-    *(int*) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
-
-    cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) );
-    out->lower = cur->lower;
-    out->upper = cur->upper;
-
-    for (i = 1; i < numranges; i++) {
-	cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
-	if ( out->lower > cur->lower ) out->lower = cur->lower;	
-	if ( out->upper < cur->upper ) out->upper = cur->upper;	
-    }
+	bytea	   *entryvec = (bytea *) PG_GETARG_POINTER(0);
+	int			i,
+				numranges;
+	INT4KEY    *cur,
+			   *out = palloc(sizeof(INT4KEY));
+
+	numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+	*(int *) PG_GETARG_POINTER(1) = sizeof(INT4KEY);
+
+	cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
+	out->lower = cur->lower;
+	out->upper = cur->upper;
+
+	for (i = 1; i < numranges; i++)
+	{
+		cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
+		if (out->lower > cur->lower)
+			out->lower = cur->lower;
+		if (out->upper < cur->upper)
+			out->upper = cur->upper;
+	}
 
-    PG_RETURN_POINTER( out );
+	PG_RETURN_POINTER(out);
 }
 
 Datum
 gint4_penalty(PG_FUNCTION_ARGS)
 {
-    INT4KEY *origentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); 
-    INT4KEY *newentry  = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key );
-    float *result = (float*) PG_GETARG_POINTER(2);
- 
-    *result = Max( newentry->upper - origentry->upper, 0 ) + 
-	      Max( origentry->lower - newentry->lower, 0 );
-
-    PG_RETURN_POINTER( result );
+	INT4KEY    *origentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
+	INT4KEY    *newentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
+
+	*result = Max(newentry->upper - origentry->upper, 0) +
+		Max(origentry->lower - newentry->lower, 0);
+
+	PG_RETURN_POINTER(result);
 }
 
 Datum
 gint4_picksplit(PG_FUNCTION_ARGS)
 {
-    PG_RETURN_POINTER( btree_picksplit(
-	(bytea*)PG_GETARG_POINTER(0),
-	(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
-	gint4_binary_union,
-	int4key_cmp
-    ) );
+	PG_RETURN_POINTER(btree_picksplit(
+									  (bytea *) PG_GETARG_POINTER(0),
+								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									  gint4_binary_union,
+									  int4key_cmp
+									  ));
 }
 
 Datum
 gint4_same(PG_FUNCTION_ARGS)
 {
-  INT4KEY *b1 = (INT4KEY*) PG_GETARG_POINTER(0);
-  INT4KEY *b2 = (INT4KEY*) PG_GETARG_POINTER(1);
-  bool *result = (bool*) PG_GETARG_POINTER(2);
+	INT4KEY    *b1 = (INT4KEY *) PG_GETARG_POINTER(0);
+	INT4KEY    *b2 = (INT4KEY *) PG_GETARG_POINTER(1);
+	bool	   *result = (bool *) PG_GETARG_POINTER(2);
 
-  *result = ( b1->lower == b2->lower && b1->upper == b2->upper ) ? TRUE : FALSE;
-  PG_RETURN_POINTER(result);
+	*result = (b1->lower == b2->lower && b1->upper == b2->upper) ? TRUE : FALSE;
+	PG_RETURN_POINTER(result);
 }
 
-static void 
+static void
 gint4_binary_union(Datum *r1, char *r2)
 {
-    INT4KEY *b1;
-    INT4KEY *b2 = (INT4KEY*) r2;
-    if ( ! DatumGetPointer( *r1 ) ) {
-	*r1 = PointerGetDatum( palloc( sizeof(INT4KEY) ) );
-	b1 = (INT4KEY*)DatumGetPointer( *r1 ); 
-	b1->upper = b2->upper;
-	b1->lower = b2->lower;
-    } else { 
-	b1 = (INT4KEY*)DatumGetPointer( *r1 ); 
-
-	b1->lower = ( b1->lower > b2->lower ) ?
-		b2->lower : b1->lower;
-	b1->upper = ( b1->upper > b2->upper ) ?
-		b1->upper : b2->upper;
-    }
+	INT4KEY    *b1;
+	INT4KEY    *b2 = (INT4KEY *) r2;
+
+	if (!DatumGetPointer(*r1))
+	{
+		*r1 = PointerGetDatum(palloc(sizeof(INT4KEY)));
+		b1 = (INT4KEY *) DatumGetPointer(*r1);
+		b1->upper = b2->upper;
+		b1->lower = b2->lower;
+	}
+	else
+	{
+		b1 = (INT4KEY *) DatumGetPointer(*r1);
+
+		b1->lower = (b1->lower > b2->lower) ?
+			b2->lower : b1->lower;
+		b1->upper = (b1->upper > b2->upper) ?
+			b1->upper : b2->upper;
+	}
 }
 
 
-static int 
-int4key_cmp(const void *a, const void *b) {
-	return ( ((INT4KEY*)(((RIX*)a)->r))->lower - ((INT4KEY*)(((RIX*)b)->r))->lower );
+static int
+int4key_cmp(const void *a, const void *b)
+{
+	return (((INT4KEY *) (((RIX *) a)->r))->lower - ((INT4KEY *) (((RIX *) b)->r))->lower);
 }
 
 /**************************************************
  * timestamp ops
- **************************************************/  
+ **************************************************/
 
 Datum
 gts_compress(PG_FUNCTION_ARGS)
 {
-	GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
-	GISTENTRY *retval;
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	GISTENTRY  *retval;
+
+	if (entry->leafkey)
+	{
+		TSKEY	   *r = (TSKEY *) palloc(sizeof(TSKEY));
 
-	if ( entry->leafkey) {
-		TSKEY *r = (TSKEY *)palloc( sizeof(TSKEY) );
 		retval = palloc(sizeof(GISTENTRY));
-		if ( entry->key ) {
-			r->lower = r->upper = *(Timestamp*)(entry->key);
+		if (entry->key)
+		{
+			r->lower = r->upper = *(Timestamp *) (entry->key);
 
 			gistentryinit(*retval, PointerGetDatum(r),
 						  entry->rel, entry->page,
 						  entry->offset, sizeof(TSKEY), FALSE);
 
-		} else {
+		}
+		else
+		{
 			gistentryinit(*retval, PointerGetDatum(NULL),
 						  entry->rel, entry->page,
 						  entry->offset, 0, FALSE);
-		} 
-	} else {
-		retval = entry;
+		}
 	}
-	PG_RETURN_POINTER( retval );
+	else
+		retval = entry;
+	PG_RETURN_POINTER(retval);
 }
 
-Datum 
+Datum
 gts_consistent(PG_FUNCTION_ARGS)
 {
-    GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
-    Timestamp *query       = (Timestamp *)PG_GETARG_POINTER(1);
-    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
-    bool retval;
-    TSKEY *key;
-    /*
-    ** if entry is not leaf, use gbox_internal_consistent,
-    ** else use gbox_leaf_consistent
-    */
-    if ( ! entry->key )
-	return FALSE;
-    key = (TSKEY*) DatumGetPointer(entry->key);
-
-    switch(strategy) {
-	case BTLessEqualStrategyNumber:
-		retval = TSGE( query, &(key->lower) );
-		break;
-	case BTLessStrategyNumber:
-		if (GIST_LEAF(entry))
-			retval = TSGT( query, &(key->lower) );
-		else 
-			retval = TSGE( query, &(key->lower) );
-		break;
-	case BTEqualStrategyNumber:
-    		/* in leaf page key->lower always = key->upper */
-		if (GIST_LEAF(entry)) 
-			retval = TSEQ( query, &(key->lower));
-		else 
-			retval = ( TSLE( &(key->lower), query ) && TSLE( query, &(key->upper) ) ); 
-		break;
-	case BTGreaterStrategyNumber:
-		if (GIST_LEAF(entry))
-			retval = TSLT( query, &(key->upper) );
-		else 
-			retval = TSLE( query, &(key->upper) );
-		break;
-	case BTGreaterEqualStrategyNumber:
-		retval = TSLE( query, &(key->upper) );
-		break;
-	default:
-		retval = FALSE;
-    }
-    PG_RETURN_BOOL(retval);
+	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
+	Timestamp  *query = (Timestamp *) PG_GETARG_POINTER(1);
+	StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+	bool		retval;
+	TSKEY	   *key;
+
+	/*
+	 * * if entry is not leaf, use gbox_internal_consistent, * else use
+	 * gbox_leaf_consistent
+	 */
+	if (!entry->key)
+		return FALSE;
+	key = (TSKEY *) DatumGetPointer(entry->key);
+
+	switch (strategy)
+	{
+		case BTLessEqualStrategyNumber:
+			retval = TSGE(query, &(key->lower));
+			break;
+		case BTLessStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = TSGT(query, &(key->lower));
+			else
+				retval = TSGE(query, &(key->lower));
+			break;
+		case BTEqualStrategyNumber:
+			/* in leaf page key->lower always = key->upper */
+			if (GIST_LEAF(entry))
+				retval = TSEQ(query, &(key->lower));
+			else
+				retval = (TSLE(&(key->lower), query) && TSLE(query, &(key->upper)));
+			break;
+		case BTGreaterStrategyNumber:
+			if (GIST_LEAF(entry))
+				retval = TSLT(query, &(key->upper));
+			else
+				retval = TSLE(query, &(key->upper));
+			break;
+		case BTGreaterEqualStrategyNumber:
+			retval = TSLE(query, &(key->upper));
+			break;
+		default:
+			retval = FALSE;
+	}
+	PG_RETURN_BOOL(retval);
 }
 
 Datum
 gts_union(PG_FUNCTION_ARGS)
 {
-    bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
-    int i, numranges;
-    TSKEY *cur, *out=palloc(sizeof(TSKEY));
-
-    numranges  = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); 
-    *(int*) PG_GETARG_POINTER(1) = sizeof(TSKEY);
-
-    cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) );
-    out->lower = cur->lower;
-    out->upper = cur->upper;
-
-    for (i = 1; i < numranges; i++) {
-	cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
-	if ( TSGT( &out->lower, &cur->lower ) ) out->lower = cur->lower;	
-	if ( TSLT( &out->upper, &cur->upper ) ) out->upper = cur->upper;	
-    }
+	bytea	   *entryvec = (bytea *) PG_GETARG_POINTER(0);
+	int			i,
+				numranges;
+	TSKEY	   *cur,
+			   *out = palloc(sizeof(TSKEY));
+
+	numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+	*(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
+
+	cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
+	out->lower = cur->lower;
+	out->upper = cur->upper;
+
+	for (i = 1; i < numranges; i++)
+	{
+		cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
+		if (TSGT(&out->lower, &cur->lower))
+			out->lower = cur->lower;
+		if (TSLT(&out->upper, &cur->upper))
+			out->upper = cur->upper;
+	}
 
-    PG_RETURN_POINTER( out );
+	PG_RETURN_POINTER(out);
 }
 
 Datum
 gts_penalty(PG_FUNCTION_ARGS)
 {
-    TSKEY *origentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); 
-    TSKEY *newentry  = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key );
-    float *result = (float*) PG_GETARG_POINTER(2);
-    Interval *intr;
+	TSKEY	   *origentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
+	TSKEY	   *newentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+	float	   *result = (float *) PG_GETARG_POINTER(2);
+	Interval   *intr;
 
-    intr = DatumGetIntervalP( DirectFunctionCall2(
-			timestamp_mi,
-                        TimestampGetDatum( newentry->upper ),
-                        TimestampGetDatum( origentry->upper )) );
+	intr = DatumGetIntervalP(DirectFunctionCall2(
+												 timestamp_mi,
+									  TimestampGetDatum(newentry->upper),
+								   TimestampGetDatum(origentry->upper)));
 
 	/* see interval_larger */
-    *result = Max( intr->time+intr->month * (30.0 * 86400),0 ); 
-    pfree( intr );
- 
-    intr = DatumGetIntervalP( DirectFunctionCall2(
-			timestamp_mi,
-                        TimestampGetDatum( origentry->lower ),
-                        TimestampGetDatum( newentry->lower )) );
+	*result = Max(intr->time + intr->month * (30.0 * 86400), 0);
+	pfree(intr);
+
+	intr = DatumGetIntervalP(DirectFunctionCall2(
+												 timestamp_mi,
+									 TimestampGetDatum(origentry->lower),
+									TimestampGetDatum(newentry->lower)));
 
 	/* see interval_larger */
-    *result += Max( intr->time+intr->month * (30.0 * 86400),0 ); 
-    pfree( intr ); 
- 
-    PG_RETURN_POINTER( result );
+	*result += Max(intr->time + intr->month * (30.0 * 86400), 0);
+	pfree(intr);
+
+	PG_RETURN_POINTER(result);
 }
 
 Datum
 gts_picksplit(PG_FUNCTION_ARGS)
 {
-    PG_RETURN_POINTER( btree_picksplit(
-	(bytea*)PG_GETARG_POINTER(0),
-	(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
-	gts_binary_union,
-	tskey_cmp
-    ) );
+	PG_RETURN_POINTER(btree_picksplit(
+									  (bytea *) PG_GETARG_POINTER(0),
+								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
+									  gts_binary_union,
+									  tskey_cmp
+									  ));
 }
 
 Datum
 gts_same(PG_FUNCTION_ARGS)
 {
-  TSKEY *b1 = (TSKEY*) PG_GETARG_POINTER(0);
-  TSKEY *b2 = (TSKEY*) PG_GETARG_POINTER(1);
-
-  bool *result = (bool*) PG_GETARG_POINTER(2);
-  if ( b1 && b2 )
-	*result = ( TSEQ( &(b1->lower), &(b2->lower) )  && TSEQ( &(b1->upper), &(b2->upper) ) ) ? TRUE : FALSE;
-  else
-	*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE; 
-  PG_RETURN_POINTER(result);
+	TSKEY	   *b1 = (TSKEY *) PG_GETARG_POINTER(0);
+	TSKEY	   *b2 = (TSKEY *) PG_GETARG_POINTER(1);
+
+	bool	   *result = (bool *) PG_GETARG_POINTER(2);
+
+	if (b1 && b2)
+		*result = (TSEQ(&(b1->lower), &(b2->lower)) && TSEQ(&(b1->upper), &(b2->upper))) ? TRUE : FALSE;
+	else
+		*result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE;
+	PG_RETURN_POINTER(result);
 }
 
-static void 
+static void
 gts_binary_union(Datum *r1, char *r2)
 {
-    TSKEY *b1;
-    TSKEY *b2 = (TSKEY*) r2;
-
-    if ( ! DatumGetPointer( *r1 ) ) {
-	*r1 = PointerGetDatum( palloc( sizeof(TSKEY) ) );
-	b1 = (TSKEY*)DatumGetPointer( *r1 ); 
-	b1->upper = b2->upper;
-	b1->lower = b2->lower;
-    } else { 
-	b1 = (TSKEY*)DatumGetPointer( *r1 ); 
-
-	b1->lower = ( TSGT( &b1->lower, &b2->lower) ) ?
-		b2->lower : b1->lower;
-	b1->upper = ( TSGT( &b1->upper, &b2->upper) ) ?
-		b1->upper : b2->upper;
-    }
+	TSKEY	   *b1;
+	TSKEY	   *b2 = (TSKEY *) r2;
+
+	if (!DatumGetPointer(*r1))
+	{
+		*r1 = PointerGetDatum(palloc(sizeof(TSKEY)));
+		b1 = (TSKEY *) DatumGetPointer(*r1);
+		b1->upper = b2->upper;
+		b1->lower = b2->lower;
+	}
+	else
+	{
+		b1 = (TSKEY *) DatumGetPointer(*r1);
+
+		b1->lower = (TSGT(&b1->lower, &b2->lower)) ?
+			b2->lower : b1->lower;
+		b1->upper = (TSGT(&b1->upper, &b2->upper)) ?
+			b1->upper : b2->upper;
+	}
 }
 
-static int 
-tskey_cmp(const void *a, const void *b) {
-    return DatumGetInt32(
-	DirectFunctionCall2(
-            timestamp_cmp,
-            TimestampGetDatum( ((TSKEY*)(((RIX*)a)->r))->lower ),
-            TimestampGetDatum( ((TSKEY*)(((RIX*)b)->r))->lower )
-        )
-   );
+static int
+tskey_cmp(const void *a, const void *b)
+{
+	return DatumGetInt32(
+						 DirectFunctionCall2(
+											 timestamp_cmp,
+				  TimestampGetDatum(((TSKEY *) (((RIX *) a)->r))->lower),
+				   TimestampGetDatum(((TSKEY *) (((RIX *) b)->r))->lower)
+											 )
+	);
 }
 
 /**************************************************
@@ -466,43 +499,48 @@ tskey_cmp(const void *a, const void *b) {
 static GIST_SPLITVEC *
 btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
 {
-    OffsetNumber i;
-    RIX *array;
-    OffsetNumber maxoff;
-    int nbytes;
-
-    maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1;
-    nbytes =  (maxoff + 2) * sizeof(OffsetNumber);
-    v->spl_left = (OffsetNumber *) palloc(nbytes);
-    v->spl_right = (OffsetNumber *) palloc(nbytes);
-    v->spl_nleft = 0;
-    v->spl_nright = 0;
-    v->spl_ldatum = PointerGetDatum( 0 );
-    v->spl_rdatum = PointerGetDatum( 0 );
-    array = (RIX*)palloc( sizeof(RIX) * (maxoff+1) );
-  
-    /* copy the data into RIXes, and sort the RIXes */
-    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
-	array[i].index = i;
-	array[i].r=(char *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) );
-    }
-    qsort((void*)&array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
-	 sizeof(RIX), cmp);
-  
-    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
-        if (i <= (maxoff - FirstOffsetNumber + 1)/2) {
-            v->spl_left[ v->spl_nleft ] = array[i].index;
-            v->spl_nleft++;
-	    (*bu)( &v->spl_ldatum, array[i].r );
-        } else {
-            v->spl_right[ v->spl_nright ] = array[i].index;
-            v->spl_nright++;
-	    (*bu)( &v->spl_rdatum, array[i].r );
-        }
-    }
-    pfree(array);
-
-    return( v );
+	OffsetNumber i;
+	RIX		   *array;
+	OffsetNumber maxoff;
+	int			nbytes;
+
+	maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
+	nbytes = (maxoff + 2) * sizeof(OffsetNumber);
+	v->spl_left = (OffsetNumber *) palloc(nbytes);
+	v->spl_right = (OffsetNumber *) palloc(nbytes);
+	v->spl_nleft = 0;
+	v->spl_nright = 0;
+	v->spl_ldatum = PointerGetDatum(0);
+	v->spl_rdatum = PointerGetDatum(0);
+	array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
+
+	/* copy the data into RIXes, and sort the RIXes */
+	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+	{
+		array[i].index = i;
+		array[i].r = (char *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
+	}
+	qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
+		  sizeof(RIX), cmp);
+
+	for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
+	{
+		if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
+		{
+			v->spl_left[v->spl_nleft] = array[i].index;
+			v->spl_nleft++;
+			(*bu) (&v->spl_ldatum, array[i].r);
+		}
+		else
+		{
+			v->spl_right[v->spl_nright] = array[i].index;
+			v->spl_nright++;
+			(*bu) (&v->spl_rdatum, array[i].r);
+		}
+	}
+	pfree(array);
+
+	return (v);
 }
 
 /*
@@ -512,38 +550,44 @@ btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
 Datum
 btree_decompress(PG_FUNCTION_ARGS)
 {
-    PG_RETURN_POINTER(PG_GETARG_POINTER(0));
+	PG_RETURN_POINTER(PG_GETARG_POINTER(0));
 }
 
 
 /**************************************************
  * In/Out for keys, not really needed
  **************************************************/
-Datum	
-int4key_in(PG_FUNCTION_ARGS) {
-	INT4KEY *key = palloc(sizeof(INT4KEY));
+Datum
+int4key_in(PG_FUNCTION_ARGS)
+{
+	INT4KEY    *key = palloc(sizeof(INT4KEY));
 
-	if ( sscanf( PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2 ) 
+	if (sscanf(PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2)
 		elog(ERROR, "Error in input format");
- 
-	PG_RETURN_POINTER( key );
+
+	PG_RETURN_POINTER(key);
 }
 
-Datum	int4key_out(PG_FUNCTION_ARGS) {
-	INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0);
-	char *str=palloc(sizeof(char)*22);
-	sprintf(str,"%d|%d", key->lower, key->upper);
-	PG_RETURN_POINTER( str ); 
+Datum
+int4key_out(PG_FUNCTION_ARGS)
+{
+	INT4KEY    *key = (INT4KEY *) PG_GETARG_POINTER(0);
+	char	   *str = palloc(sizeof(char) * 22);
+
+	sprintf(str, "%d|%d", key->lower, key->upper);
+	PG_RETURN_POINTER(str);
 }
 
 Datum
-tskey_in(PG_FUNCTION_ARGS) {
+tskey_in(PG_FUNCTION_ARGS)
+{
 	elog(ERROR, "Not implemented");
-	PG_RETURN_POINTER( NULL );
+	PG_RETURN_POINTER(NULL);
 }
 
 Datum
-tskey_out(PG_FUNCTION_ARGS) {
+tskey_out(PG_FUNCTION_ARGS)
+{
 	elog(ERROR, "Not implemented");
-	PG_RETURN_POINTER( NULL );
+	PG_RETURN_POINTER(NULL);
 }