pgindent run.

contrib/btree_gist/btree_gist.c

@@ -299,6 +299,7 @@ gts_compress(PG_FUNCTION_ARGS)
 	if (entry->leafkey)
 	{
 		TSKEY	   *r = (TSKEY *) palloc(sizeof(TSKEY));
+
 		retval = palloc(sizeof(GISTENTRY));
 		r->lower = r->upper = *(Timestamp *) (entry->key);
 		gistentryinit(*retval, PointerGetDatum(r),

contrib/cube/cube.c

@@ -73,11 +73,11 @@ bool		cube_right(NDBOX * a, NDBOX * b);
 bool		cube_lt(NDBOX * a, NDBOX * b);
 bool		cube_gt(NDBOX * a, NDBOX * b);
 double	   *cube_distance(NDBOX * a, NDBOX * b);
-int	cube_dim(NDBOX *a);
+int			cube_dim(NDBOX * a);
 double	   *cube_ll_coord(NDBOX * a, int n);
 double	   *cube_ur_coord(NDBOX * a, int n);
 bool		cube_is_point(NDBOX * a);
-NDBOX	   *cube_enlarge(NDBOX * a, double * r, int n);
+NDBOX	   *cube_enlarge(NDBOX * a, double *r, int n);
 
 
 /*
@@ -115,7 +115,7 @@ cube(text *str)
 }
 
 char *
-cube_out(NDBOX *cube)
+cube_out(NDBOX * cube)
 {
 	StringInfoData buf;
 	bool		equal = true;
@@ -792,6 +792,7 @@ cube_lt(NDBOX * a, NDBOX * b)
 			if (max(a->x[i], a->x[a->dim + i]) < 0)
 				return (TRUE);
 		}
+
 		/*
 		 * if all common dimensions are equal, the cube with more
 		 * dimensions wins
@@ -814,6 +815,7 @@ cube_lt(NDBOX * a, NDBOX * b)
 			if (max(b->x[i], b->x[b->dim + i]) < 0)
 				return (FALSE);
 		}
+
 		/*
 		 * if all common dimensions are equal, the cube with more
 		 * dimensions wins
@@ -874,6 +876,7 @@ cube_gt(NDBOX * a, NDBOX * b)
 			if (max(a->x[i], a->x[a->dim + i]) > 0)
 				return (TRUE);
 		}
+
 		/*
 		 * if all common dimensions are equal, the cube with more
 		 * dimensions wins
@@ -896,6 +899,7 @@ cube_gt(NDBOX * a, NDBOX * b)
 			if (max(b->x[i], b->x[b->dim + i]) > 0)
 				return (FALSE);
 		}
+
 		/*
 		 * if all common dimensions are equal, the cube with more
 		 * dimensions wins
@@ -937,9 +941,9 @@ cube_same(NDBOX * a, NDBOX * b)
 
 	/*
 	 * all dimensions of (b) are compared to those of (a); instead of
-	 * those in (a) absent in (b), compare (a) to zero
-         * Since both LL and UR coordinates are compared to zero, we can
-         * just check them all without worrying about which is which.
+	 * those in (a) absent in (b), compare (a) to zero Since both LL and
+	 * UR coordinates are compared to zero, we can just check them all
+	 * without worrying about which is which.
 	 */
 	for (i = b->dim; i < a->dim; i++)
 	{
@@ -974,9 +978,9 @@ cube_contains(NDBOX * a, NDBOX * b)
 	{
 		/*
 		 * 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.
+		 * 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++)
 		{
@@ -1124,9 +1128,11 @@ cube_is_point(NDBOX * a)
 {
 	int			i,
 				j;
+
 	for (i = 0, j = a->dim; i < a->dim; i++, j++)
 	{
-                if (a->x[i] != a->x[j]) return FALSE;
+		if (a->x[i] != a->x[j])
+			return FALSE;
 	}
 
 	return TRUE;
@@ -1145,10 +1151,11 @@ double *
 cube_ll_coord(NDBOX * a, int n)
 {
 	double	   *result;
+
 	result = (double *) palloc(sizeof(double));
 	*result = 0;
 	if (a->dim >= n && n > 0)
-               *result = min(a->x[n-1], a->x[a->dim + n-1]);
+		*result = min(a->x[n - 1], a->x[a->dim + n - 1]);
 	return result;
 }
 
@@ -1157,24 +1164,28 @@ double *
 cube_ur_coord(NDBOX * a, int n)
 {
 	double	   *result;
+
 	result = (double *) palloc(sizeof(double));
 	*result = 0;
 	if (a->dim >= n && n > 0)
-                *result = max(a->x[n-1], a->x[a->dim + n-1]);
+		*result = max(a->x[n - 1], a->x[a->dim + n - 1]);
 	return result;
 }
 
 /* Increase or decrease box size by a radius in at least n dimensions. */
 NDBOX *
-cube_enlarge(NDBOX * a, double * r, int n)
+cube_enlarge(NDBOX * a, double *r, int n)
 {
 	NDBOX	   *result;
 	int			dim = 0;
 	int			size;
 	int			i,
 				j;
-        if (*r > 0 && n > 0) dim = n;
-        if (a->dim > dim) dim = a->dim;
+
+	if (*r > 0 && n > 0)
+		dim = n;
+	if (a->dim > dim)
+		dim = a->dim;
 	size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2;
 	result = (NDBOX *) palloc(size);
 	memset(result, 0, size);

contrib/intagg/int_aggregate.c

@@ -49,7 +49,7 @@ typedef struct
 	int			items;
 	int			lower;
 	int4		array[1];
-}PGARRAY;
+}	PGARRAY;
 
 /* This is used to keep track of our position during enumeration */
 typedef struct callContext
@@ -57,14 +57,14 @@ typedef struct callContext
 	PGARRAY    *p;
 	int			num;
 	int			flags;
-}CTX;
+}	CTX;
 
 #define TOASTED		1
 #define START_NUM	8
 #define PGARRAY_SIZE(n) (sizeof(PGARRAY) + ((n-1)*sizeof(int4)))
 
-static PGARRAY * GetPGArray(int4 state, int fAdd);
-static PGARRAY *ShrinkPGArray(PGARRAY *p);
+static PGARRAY *GetPGArray(int4 state, int fAdd);
+static PGARRAY *ShrinkPGArray(PGARRAY * p);
 
 Datum		int_agg_state(PG_FUNCTION_ARGS);
 Datum		int_agg_final_count(PG_FUNCTION_ARGS);
@@ -80,20 +80,21 @@ PG_FUNCTION_INFO_V1(int_enum);
  * Manage the aggregation state of the array
  * You need to specify the correct memory context, or it will vanish!
  */
-static PGARRAY * GetPGArray(int4 state, int fAdd)
+static PGARRAY *
+GetPGArray(int4 state, int fAdd)
 {
 	PGARRAY    *p = (PGARRAY *) state;
 
-	if(!state)
+	if (!state)
 	{
 		/* New array */
 		int			cb = PGARRAY_SIZE(START_NUM);
 
 		p = (PGARRAY *) MemoryContextAlloc(TopTransactionContext, cb);
 
-		if(!p)
+		if (!p)
 		{
-			elog(ERROR,"Integer aggregator, cant allocate TopTransactionContext memory");
+			elog(ERROR, "Integer aggregator, cant allocate TopTransactionContext memory");
 			return 0;
 		}
 
@@ -104,11 +105,11 @@ static PGARRAY * GetPGArray(int4 state, int fAdd)
 		p->a.elemtype = INT4OID;
 #endif
 		p->items = 0;
-		p->lower= START_NUM;
+		p->lower = START_NUM;
 	}
-	else if(fAdd)
+	else if (fAdd)
 	{							/* Ensure array has space */
-		if(p->items >= p->lower)
+		if (p->items >= p->lower)
 		{
 			PGARRAY    *pn;
 			int			n = p->lower + p->lower;
@@ -116,10 +117,10 @@ static PGARRAY * GetPGArray(int4 state, int fAdd)
 
 			pn = (PGARRAY *) repalloc(p, cbNew);
 
-			if(!pn)
+			if (!pn)
 			{					/* Realloc failed! Reallocate new block. */
 				pn = (PGARRAY *) MemoryContextAlloc(TopTransactionContext, cbNew);
-				if(!pn)
+				if (!pn)
 				{
 					elog(ERROR, "Integer aggregator, REALLY REALLY can't alloc memory");
 					return (PGARRAY *) NULL;
@@ -137,10 +138,12 @@ static PGARRAY * GetPGArray(int4 state, int fAdd)
 
 /* Shrinks the array to its actual size and moves it into the standard
  * memory allocation context, frees working memory	*/
-static PGARRAY *ShrinkPGArray(PGARRAY *p)
+static PGARRAY *
+ShrinkPGArray(PGARRAY * p)
 {
-	PGARRAY *pnew=NULL;
-	if(p)
+	PGARRAY    *pnew = NULL;
+
+	if (p)
 	{
 		/* get target size */
 		int			cb = PGARRAY_SIZE(p->items);
@@ -148,12 +151,15 @@ static PGARRAY *ShrinkPGArray(PGARRAY *p)
 		/* use current transaction context */
 		pnew = palloc(cb);
 
-		if(pnew)
+		if (pnew)
 		{
-			/* Fix up the fields in the new structure, so Postgres understands */
+			/*
+			 * Fix up the fields in the new structure, so Postgres
+			 * understands
+			 */
 			memcpy(pnew, p, cb);
 			pnew->a.size = cb;
-			pnew->a.ndim=1;
+			pnew->a.ndim = 1;
 			pnew->a.flags = 0;
 #ifndef PG_7_2
 			pnew->a.elemtype = INT4OID;
@@ -161,79 +167,72 @@ static PGARRAY *ShrinkPGArray(PGARRAY *p)
 			pnew->lower = 0;
 		}
 		else
-		{
 			elog(ERROR, "Integer aggregator, can't allocate memory");
-		}
 		pfree(p);
 	}
 	return pnew;
 }
 
 /* Called for each iteration during an aggregate function */
-Datum int_agg_state(PG_FUNCTION_ARGS)
+Datum
+int_agg_state(PG_FUNCTION_ARGS)
 {
 	int4		state = PG_GETARG_INT32(0);
 	int4		value = PG_GETARG_INT32(1);
 
 	PGARRAY    *p = GetPGArray(state, 1);
-	if(!p)
-	{
-		elog(ERROR,"No aggregate storage");
-	}
-	else if(p->items >= p->lower)
-	{
-		elog(ERROR,"aggregate storage too small");
-	}
+
+	if (!p)
+		elog(ERROR, "No aggregate storage");
+	else if (p->items >= p->lower)
+		elog(ERROR, "aggregate storage too small");
 	else
-	{
-		p->array[p->items++]= value;
-	}
+		p->array[p->items++] = value;
 	PG_RETURN_INT32(p);
 }
 
 /* This is the final function used for the integer aggregator. It returns all the integers
  * collected as a one dimentional integer array */
-Datum int_agg_final_array(PG_FUNCTION_ARGS)
+Datum
+int_agg_final_array(PG_FUNCTION_ARGS)
 {
-	PGARRAY *pnew = ShrinkPGArray(GetPGArray(PG_GETARG_INT32(0),0));
-	if(pnew)
-	{
+	PGARRAY    *pnew = ShrinkPGArray(GetPGArray(PG_GETARG_INT32(0), 0));
+
+	if (pnew)
 		PG_RETURN_POINTER(pnew);
-	}
 	else
-	{
 		PG_RETURN_NULL();
-	}
 }
 
 /* This function accepts an array, and returns one item for each entry in the array */
-Datum int_enum(PG_FUNCTION_ARGS)
+Datum
+int_enum(PG_FUNCTION_ARGS)
 {
 	PGARRAY    *p = (PGARRAY *) PG_GETARG_POINTER(0);
 	CTX		   *pc;
-	ReturnSetInfo *rsi = (ReturnSetInfo *)fcinfo->resultinfo;
+	ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 
 	if (!rsi || !IsA(rsi, ReturnSetInfo))
 		elog(ERROR, "No ReturnSetInfo sent! function must be declared returning a 'setof' integer");
 
-	if(!p)
+	if (!p)
 	{
 		elog(WARNING, "No data sent");
 		PG_RETURN_NULL();
 	}
 
-	if(!fcinfo->context)
+	if (!fcinfo->context)
 	{
 		/* Allocate a working context */
 		pc = (CTX *) palloc(sizeof(CTX));
 
 		/* Don't copy atribute if you don't need too */
-		if(VARATT_IS_EXTENDED(p) )
+		if (VARATT_IS_EXTENDED(p))
 		{
 			/* Toasted!!! */
 			pc->p = (PGARRAY *) PG_DETOAST_DATUM_COPY(p);
 			pc->flags = TOASTED;
-			if(!pc->p)
+			if (!pc->p)
 			{
 				elog(ERROR, "Error in toaster!!! no detoasting");
 				PG_RETURN_NULL();
@@ -246,25 +245,26 @@ Datum int_enum(PG_FUNCTION_ARGS)
 			pc->flags = 0;
 		}
 		fcinfo->context = (Node *) pc;
-		pc->num=0;
+		pc->num = 0;
 	}
-	else /* use an existing one */
-	{
+	else
+/* use an existing one */
 		pc = (CTX *) fcinfo->context;
-	}
 	/* Are we done yet? */
-	if(pc->num >= pc->p->items)
+	if (pc->num >= pc->p->items)
 	{
 		/* We are done */
-		if(pc->flags & TOASTED)
+		if (pc->flags & TOASTED)
 			pfree(pc->p);
 		pfree(fcinfo->context);
 		fcinfo->context = NULL;
-		rsi->isDone = ExprEndResult ;
+		rsi->isDone = ExprEndResult;
 	}
-	else	/* nope, return the next value */
+	else
+/* nope, return the next value */
 	{
 		int			val = pc->p->array[pc->num++];
+
 		rsi->isDone = ExprMultipleResult;
 		PG_RETURN_INT32(val);
 	}

contrib/ltree/_ltree_op.c

@@ -31,24 +31,28 @@ Datum _ltxtq_extract_exec(PG_FUNCTION_ARGS);
 PG_FUNCTION_INFO_V1(_lca);
 Datum		_lca(PG_FUNCTION_ARGS);
 
-typedef Datum (*PGCALL2)(PG_FUNCTION_ARGS);
+typedef Datum (*PGCALL2) (PG_FUNCTION_ARGS);
+
 #define NEXTVAL(x) ( (ltree*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
 
 static bool
-array_iterator( ArrayType *la, PGCALL2 callback, void* param, ltree ** found) {
-	int num=ArrayGetNItems( ARR_NDIM(la), ARR_DIMS(la));
-	ltree	*item = (ltree*)ARR_DATA_PTR(la);
-
-	if ( ARR_NDIM(la) !=1 )
-		elog(ERROR,"Dimension of array != 1");
-
-	if ( found )
-		*found=NULL;
-	while( num>0 ) {
-		if ( DatumGetBool( DirectFunctionCall2( callback, 
-			PointerGetDatum(item), PointerGetDatum(param) ) ) ) {
-
-			if ( found )
+array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree ** found)
+{
+	int			num = ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la));
+	ltree	   *item = (ltree *) ARR_DATA_PTR(la);
+
+	if (ARR_NDIM(la) != 1)
+		elog(ERROR, "Dimension of array != 1");
+
+	if (found)
+		*found = NULL;
+	while (num > 0)
+	{
+		if (DatumGetBool(DirectFunctionCall2(callback,
+						 PointerGetDatum(item), PointerGetDatum(param))))
+		{
+
+			if (found)
 				*found = item;
 			return true;
 		}
@@ -60,179 +64,205 @@ array_iterator( ArrayType *la, PGCALL2 callback, void* param, ltree ** found) {
 }
 
 Datum
-_ltree_isparent(PG_FUNCTION_ARGS) {
+_ltree_isparent(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	ltree	   *query = PG_GETARG_LTREE(1);
-	bool res = array_iterator( la, ltree_isparent, (void*)query, NULL );
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	bool		res = array_iterator(la, ltree_isparent, (void *) query, NULL);
+
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_BOOL(res);
 }
 
 Datum
-_ltree_r_isparent(PG_FUNCTION_ARGS) {
-	PG_RETURN_DATUM( DirectFunctionCall2( _ltree_isparent,
+_ltree_r_isparent(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_DATUM(DirectFunctionCall2(_ltree_isparent,
 										PG_GETARG_DATUM(1),
 										PG_GETARG_DATUM(0)
-	) );
+										));
 }
 
 Datum
-_ltree_risparent(PG_FUNCTION_ARGS) {
+_ltree_risparent(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	ltree	   *query = PG_GETARG_LTREE(1);
-	bool res = array_iterator( la, ltree_risparent, (void*)query, NULL );
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	bool		res = array_iterator(la, ltree_risparent, (void *) query, NULL);
+
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_BOOL(res);
 }
 
 Datum
-_ltree_r_risparent(PG_FUNCTION_ARGS) {
-	PG_RETURN_DATUM( DirectFunctionCall2( _ltree_risparent,
+_ltree_r_risparent(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_DATUM(DirectFunctionCall2(_ltree_risparent,
 										PG_GETARG_DATUM(1),
 										PG_GETARG_DATUM(0)
-	) );
+										));
 }
 
 Datum
-_ltq_regex(PG_FUNCTION_ARGS) {
+_ltq_regex(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	lquery	   *query = PG_GETARG_LQUERY(1);
-	bool res = array_iterator( la, ltq_regex, (void*)query, NULL );
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	bool		res = array_iterator(la, ltq_regex, (void *) query, NULL);
+
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_BOOL(res);
 }
 
 Datum
-_ltq_rregex(PG_FUNCTION_ARGS) {
-	PG_RETURN_DATUM( DirectFunctionCall2( _ltq_regex,
+_ltq_rregex(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_DATUM(DirectFunctionCall2(_ltq_regex,
 										PG_GETARG_DATUM(1),
 										PG_GETARG_DATUM(0)
-	) );
+										));
 }
 
 Datum
-_ltxtq_exec(PG_FUNCTION_ARGS) {
+_ltxtq_exec(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	ltxtquery  *query = PG_GETARG_LTXTQUERY(1);
-	bool res = array_iterator( la, ltxtq_exec, (void*)query, NULL );
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	bool		res = array_iterator(la, ltxtq_exec, (void *) query, NULL);
+
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_BOOL(res);
 }
 
 Datum
-_ltxtq_rexec(PG_FUNCTION_ARGS) {
-	PG_RETURN_DATUM( DirectFunctionCall2( _ltxtq_exec,
+_ltxtq_rexec(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_DATUM(DirectFunctionCall2(_ltxtq_exec,
 										PG_GETARG_DATUM(1),
 										PG_GETARG_DATUM(0)
-	) );
+										));
 }
 
 
 Datum
-_ltree_extract_isparent(PG_FUNCTION_ARGS) {
+_ltree_extract_isparent(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	ltree	   *query = PG_GETARG_LTREE(1);
-	ltree		*found,*item;
+	ltree	   *found,
+			   *item;
 
-	if ( !array_iterator( la, ltree_isparent, (void*)query, &found )  ) {
-		PG_FREE_IF_COPY(la,0);
-		PG_FREE_IF_COPY(query,1);
+	if (!array_iterator(la, ltree_isparent, (void *) query, &found))
+	{
+		PG_FREE_IF_COPY(la, 0);
+		PG_FREE_IF_COPY(query, 1);
 		PG_RETURN_NULL();
 	}
 
-	item = (ltree*)palloc( found->len );
-	memcpy( item, found, found->len );	
+	item = (ltree *) palloc(found->len);
+	memcpy(item, found, found->len);
 
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_POINTER(item);
 }
 
 Datum
-_ltree_extract_risparent(PG_FUNCTION_ARGS) {
+_ltree_extract_risparent(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	ltree	   *query = PG_GETARG_LTREE(1);
-	ltree		*found,*item;
+	ltree	   *found,
+			   *item;
 
-	if ( !array_iterator( la, ltree_risparent, (void*)query, &found )  ) {
-		PG_FREE_IF_COPY(la,0);
-		PG_FREE_IF_COPY(query,1);
+	if (!array_iterator(la, ltree_risparent, (void *) query, &found))
+	{
+		PG_FREE_IF_COPY(la, 0);
+		PG_FREE_IF_COPY(query, 1);
 		PG_RETURN_NULL();
 	}
 
-	item = (ltree*)palloc( found->len );
-	memcpy( item, found, found->len );	
+	item = (ltree *) palloc(found->len);
+	memcpy(item, found, found->len);
 
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_POINTER(item);
 }
 
 Datum
-_ltq_extract_regex(PG_FUNCTION_ARGS) {
+_ltq_extract_regex(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	lquery	   *query = PG_GETARG_LQUERY(1);
-	ltree		*found,*item;
+	ltree	   *found,
+			   *item;
 
-	if ( !array_iterator( la, ltq_regex, (void*)query, &found )  ) {
-		PG_FREE_IF_COPY(la,0);
-		PG_FREE_IF_COPY(query,1);
+	if (!array_iterator(la, ltq_regex, (void *) query, &found))
+	{
+		PG_FREE_IF_COPY(la, 0);
+		PG_FREE_IF_COPY(query, 1);
 		PG_RETURN_NULL();
 	}
 
-	item = (ltree*)palloc( found->len );
-	memcpy( item, found, found->len );	
+	item = (ltree *) palloc(found->len);
+	memcpy(item, found, found->len);
 
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_POINTER(item);
 }
 
 Datum
-_ltxtq_extract_exec(PG_FUNCTION_ARGS) {
+_ltxtq_extract_exec(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
 	ltxtquery  *query = PG_GETARG_LTXTQUERY(1);
-	ltree		*found,*item;
+	ltree	   *found,
+			   *item;
 
-	if ( !array_iterator( la, ltxtq_exec, (void*)query, &found )  ) {
-		PG_FREE_IF_COPY(la,0);
-		PG_FREE_IF_COPY(query,1);
+	if (!array_iterator(la, ltxtq_exec, (void *) query, &found))
+	{
+		PG_FREE_IF_COPY(la, 0);
+		PG_FREE_IF_COPY(query, 1);
 		PG_RETURN_NULL();
 	}
 
-	item = (ltree*)palloc( found->len );
-	memcpy( item, found, found->len );	
+	item = (ltree *) palloc(found->len);
+	memcpy(item, found, found->len);
 
-	PG_FREE_IF_COPY(la,0);
-	PG_FREE_IF_COPY(query,1);
+	PG_FREE_IF_COPY(la, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_POINTER(item);
 }
 
 Datum
-_lca(PG_FUNCTION_ARGS) {
+_lca(PG_FUNCTION_ARGS)
+{
 	ArrayType  *la = PG_GETARG_ARRAYTYPE_P(0);
-	int num=ArrayGetNItems( ARR_NDIM(la), ARR_DIMS(la));
-	ltree	*item = (ltree*)ARR_DATA_PTR(la);
-        ltree **a,*res;
-
-        a=(ltree**)palloc( sizeof(ltree*) * num );
-	while( num>0 ) {
+	int			num = ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la));
+	ltree	   *item = (ltree *) ARR_DATA_PTR(la);
+	ltree	  **a,
+			   *res;
+
+	a = (ltree **) palloc(sizeof(ltree *) * num);
+	while (num > 0)
+	{
 		num--;
 		a[num] = item;
 		item = NEXTVAL(item);
 	}
-        res = lca_inner(a, ArrayGetNItems( ARR_NDIM(la), ARR_DIMS(la)));
+	res = lca_inner(a, ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la)));
 	pfree(a);
 
-	PG_FREE_IF_COPY(la,0);
+	PG_FREE_IF_COPY(la, 0);
 
-        if ( res )
+	if (res)
 		PG_RETURN_POINTER(res);
 	else
 		PG_RETURN_NULL();
 }
-

contrib/ltree/crc32.c

@@ -105,6 +105,6 @@ ltree_crc32_sz(char *buf, int size)
 	len = 0;
 	nr = size;
 	for (len += nr, p = buf; nr--; ++p)
-		_CRC32_(crc, TOLOWER((unsigned int)*p));
+		_CRC32_(crc, TOLOWER((unsigned int) *p));
 	return ~crc;
 }

contrib/ltree/lquery_op.c

@@ -9,7 +9,8 @@
 PG_FUNCTION_INFO_V1(ltq_regex);
 PG_FUNCTION_INFO_V1(ltq_rregex);
 
-typedef struct {
+typedef struct
+{
 	lquery_level *q;
 	int			nq;
 	ltree_level *t;
@@ -19,17 +20,18 @@ typedef struct {
 }	FieldNot;
 
 static char *
-getlexem(char *start, char *end, int *len) {
+getlexem(char *start, char *end, int *len)
+{
 	char	   *ptr;
 
-	while( start<end && *start == '_' )
+	while (start < end && *start == '_')
 		start++;
 
 	ptr = start;
-	if ( ptr == end )
+	if (ptr == end)
 		return NULL;
 
-	while( ptr < end && *ptr != '_') 
+	while (ptr < end && *ptr != '_')
 		ptr++;
 
 	*len = ptr - start;
@@ -37,23 +39,28 @@ getlexem(char *start, char *end, int *len) {
 }
 
 bool
-compare_subnode( ltree_level *t, char *qn, int len, int (*cmpptr)(const char *,const char *,size_t), bool anyend ) {
+			compare_subnode(ltree_level * t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend)
+{
 	char	   *endt = t->name + t->len;
 	char	   *endq = qn + len;
 	char	   *tn;
-	int lent,lenq;
+	int			lent,
+				lenq;
 	bool		isok;
 
-	while( (qn=getlexem(qn,endq,&lenq)) != NULL ) {
-		tn=t->name;
+	while ((qn = getlexem(qn, endq, &lenq)) != NULL)
+	{
+		tn = t->name;
 		isok = false;
-		while( (tn=getlexem(tn,endt,&lent)) != NULL ) {
+		while ((tn = getlexem(tn, endt, &lent)) != NULL)
+		{
 			if (
 				(
 				 lent == lenq ||
-					( lent > lenq && anyend )
+				 (lent > lenq && anyend)
 				 ) &&
-				(*cmpptr)(qn,tn,lenq) == 0 ) {
+				(*cmpptr) (qn, tn, lenq) == 0)
+			{
 
 				isok = true;
 				break;
@@ -61,7 +68,7 @@ compare_subnode( ltree_level *t, char *qn, int len, int (*cmpptr)(const char *,c
 			tn += lent;
 		}
 
-		if ( !isok )
+		if (!isok)
 			return false;
 		qn += lenq;
 	}
@@ -70,23 +77,28 @@ compare_subnode( ltree_level *t, char *qn, int len, int (*cmpptr)(const char *,c
 }
 
 static bool
-checkLevel( lquery_level *curq, ltree_level *curt ) {
-	int (*cmpptr)(const char *,const char *,size_t);
+checkLevel(lquery_level * curq, ltree_level * curt)
+{
+	int			(*cmpptr) (const char *, const char *, size_t);
 	lquery_variant *curvar = LQL_FIRST(curq);
 	int			i;
 
-	for(i=0;i<curq->numvar;i++) {
-		cmpptr = ( curvar->flag & LVAR_INCASE ) ? strncasecmp : strncmp;
+	for (i = 0; i < curq->numvar; i++)
+	{
+		cmpptr = (curvar->flag & LVAR_INCASE) ? strncasecmp : strncmp;
 
-		if ( curvar->flag & LVAR_SUBLEXEM ) {
-			if ( compare_subnode(curt, curvar->name, curvar->len, cmpptr, (curvar->flag & LVAR_ANYEND) ) )
+		if (curvar->flag & LVAR_SUBLEXEM)
+		{
+			if (compare_subnode(curt, curvar->name, curvar->len, cmpptr, (curvar->flag & LVAR_ANYEND)))
 				return true;
-		} else if ( 
+		}
+		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 ) {
+				 (*cmpptr) (curvar->name, curt->name, curvar->len) == 0)
+		{
 
 			return true;
 		}
@@ -106,74 +118,93 @@ printFieldNot(FieldNot *fn ) {
 */
 
 static bool
-checkCond( lquery_level *curq, int query_numlevel, ltree_level *curt, int tree_numlevel, FieldNot *ptr ) {
-	uint32 low_pos=0,high_pos=0,cur_tpos=0;
-	int tlen = tree_numlevel, qlen = query_numlevel;
+checkCond(lquery_level * curq, int query_numlevel, ltree_level * curt, int tree_numlevel, FieldNot * ptr)
+{
+	uint32		low_pos = 0,
+				high_pos = 0,
+				cur_tpos = 0;
+	int			tlen = tree_numlevel,
+				qlen = query_numlevel;
 	int			isok;
-	lquery_level *prevq=NULL;
-	ltree_level  *prevt=NULL;
+	lquery_level *prevq = NULL;
+	ltree_level *prevt = NULL;
 
-	while( tlen >0 && qlen>0 ) {
-		if ( curq->numvar ) {
+	while (tlen > 0 && qlen > 0)
+	{
+		if (curq->numvar)
+		{
 			prevt = curt;
-			while ( cur_tpos < low_pos ) {
+			while (cur_tpos < low_pos)
+			{
 				curt = LEVEL_NEXT(curt);
 				tlen--;
 				cur_tpos++;
-				if ( tlen==0 )
+				if (tlen == 0)
 					return false;
-				if ( ptr && ptr->q )
+				if (ptr && ptr->q)
 					ptr->nt++;
 			}
 
-			if ( ptr && curq->flag & LQL_NOT ) {
-				if ( !(prevq && prevq->numvar == 0) )
+			if (ptr && curq->flag & LQL_NOT)
+			{
+				if (!(prevq && prevq->numvar == 0))
 					prevq = curq;
-				if ( ptr->q == NULL ) {
+				if (ptr->q == NULL)
+				{
 					ptr->t = prevt;
 					ptr->q = prevq;
-					ptr->nt=1;
-					ptr->nq=1 + ( (prevq==curq) ? 0 : 1 );
-					ptr->posq = query_numlevel - qlen - ( (prevq==curq) ? 0 : 1 ); 
+					ptr->nt = 1;
+					ptr->nq = 1 + ((prevq == curq) ? 0 : 1);
+					ptr->posq = query_numlevel - qlen - ((prevq == curq) ? 0 : 1);
 					ptr->post = cur_tpos;
-				} else {
+				}
+				else
+				{
 					ptr->nt++;
 					ptr->nq++;
 				}
 
-				if ( qlen == 1 && ptr->q->numvar==0 )
+				if (qlen == 1 && ptr->q->numvar == 0)
 					ptr->nt = tree_numlevel - ptr->post;
 				curt = LEVEL_NEXT(curt);
 				tlen--;
 				cur_tpos++;
-				if ( high_pos < cur_tpos )
+				if (high_pos < cur_tpos)
 					high_pos++;
-			} else { 
+			}
+			else
+			{
 				isok = false;
-				while( cur_tpos <= high_pos && tlen > 0 && !isok) {
+				while (cur_tpos <= high_pos && tlen > 0 && !isok)
+				{
 					isok = checkLevel(curq, curt);
 					curt = LEVEL_NEXT(curt);
 					tlen--;
 					cur_tpos++;
-					if ( !isok && ptr )
+					if (!isok && ptr)
 						ptr->nt++;
 				}
-				if ( !isok )
+				if (!isok)
 					return false;
 
-				if (ptr && ptr->q) {
-					if ( checkCond(ptr->q,ptr->nq,ptr->t,ptr->nt,NULL) )
+				if (ptr && ptr->q)
+				{
+					if (checkCond(ptr->q, ptr->nq, ptr->t, ptr->nt, NULL))
 						return false;
 					ptr->q = NULL;
 				}
-				low_pos=cur_tpos; high_pos=cur_tpos;
+				low_pos = cur_tpos;
+				high_pos = cur_tpos;
 			}
-		} else {
+		}
+		else
+		{
 			low_pos = cur_tpos + curq->low;
 			high_pos = cur_tpos + curq->high;
-			if ( ptr && ptr->q ) {
+			if (ptr && ptr->q)
+			{
 				ptr->nq++;
-				if ( qlen==1 )
+				if (qlen == 1)
 					ptr->nt = tree_numlevel - ptr->post;
 			}
 		}
@@ -183,14 +214,18 @@ checkCond( lquery_level *curq, int query_numlevel, ltree_level *curt, int tree_n
 		qlen--;
 	}
 
-	if ( low_pos > tree_numlevel || tree_numlevel > high_pos )
+	if (low_pos > tree_numlevel || tree_numlevel > high_pos)
 		return false;
 
-	while( qlen>0 ) {
-		if ( curq->numvar ) {
-			if ( ! (curq->flag & LQL_NOT) )
+	while (qlen > 0)
+	{
+		if (curq->numvar)
+		{
+			if (!(curq->flag & LQL_NOT))
 				return false;
-		} else {
+		}
+		else
+		{
 			low_pos = cur_tpos + curq->low;
 			high_pos = cur_tpos + curq->high;
 		}
@@ -199,42 +234,47 @@ checkCond( lquery_level *curq, int query_numlevel, ltree_level *curt, int tree_n
 		qlen--;
 	}
 
-	if ( low_pos > tree_numlevel || tree_numlevel > high_pos )
+	if (low_pos > tree_numlevel || tree_numlevel > high_pos)
 		return false;
 
-	if ( ptr && ptr->q && checkCond(ptr->q,ptr->nq,ptr->t,ptr->nt,NULL) )
+	if (ptr && ptr->q && checkCond(ptr->q, ptr->nq, ptr->t, ptr->nt, NULL))
 		return false;
 
 	return true;
 }
 
 Datum
-ltq_regex(PG_FUNCTION_ARGS) {
+ltq_regex(PG_FUNCTION_ARGS)
+{
 	ltree	   *tree = PG_GETARG_LTREE(0);
 	lquery	   *query = PG_GETARG_LQUERY(1);
-	bool res= false;
+	bool		res = false;
 
-	if ( query->flag & LQUERY_HASNOT ) {
+	if (query->flag & LQUERY_HASNOT)
+	{
 		FieldNot	fn;
 
-		fn.q=NULL;
+		fn.q = NULL;
 
-		res = checkCond( LQUERY_FIRST(query), query->numlevel, 
-			LTREE_FIRST(tree), tree->numlevel, &fn );
-	} else {
-		res = checkCond( LQUERY_FIRST(query), query->numlevel, 
-			LTREE_FIRST(tree), tree->numlevel, NULL ); 
+		res = checkCond(LQUERY_FIRST(query), query->numlevel,
+						LTREE_FIRST(tree), tree->numlevel, &fn);
+	}
+	else
+	{
+		res = checkCond(LQUERY_FIRST(query), query->numlevel,
+						LTREE_FIRST(tree), tree->numlevel, NULL);
 	}
 
-        PG_FREE_IF_COPY(tree,0);
-        PG_FREE_IF_COPY(query,1);
+	PG_FREE_IF_COPY(tree, 0);
+	PG_FREE_IF_COPY(query, 1);
 	PG_RETURN_BOOL(res);
 }
 
 Datum
-ltq_rregex(PG_FUNCTION_ARGS) {
-	PG_RETURN_DATUM( DirectFunctionCall2( ltq_regex,
+ltq_rregex(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_DATUM(DirectFunctionCall2(ltq_regex,
 										PG_GETARG_DATUM(1),
 										PG_GETARG_DATUM(0)
-	) );
+										));
 }

contrib/ltree/ltree.h

@@ -6,7 +6,8 @@
 #include "utils/palloc.h"
 #include "utils/builtins.h"
 
-typedef struct {
+typedef struct
+{
 	uint8		len;
 	char		name[1];
 }	ltree_level;
@@ -14,7 +15,8 @@ typedef struct {
 #define LEVEL_HDRSIZE	(sizeof(uint8))
 #define LEVEL_NEXT(x)	( (ltree_level*)( ((char*)(x)) + MAXALIGN(((ltree_level*)(x))->len + LEVEL_HDRSIZE) ) )
 
-typedef struct {
+typedef struct
+{
 	int32		len;
 	uint16		numlevel;
 	char		data[1];
@@ -26,7 +28,8 @@ typedef struct {
 
 /* lquery */
 
-typedef struct {
+typedef struct
+{
 	int4		val;
 	uint8		len;
 	uint8		flag;
@@ -40,7 +43,8 @@ typedef struct {
 #define LVAR_INCASE 0x02
 #define LVAR_SUBLEXEM	0x04
 
-typedef struct {
+typedef struct
+{
 	uint16		totallen;
 	uint16		flag;
 	uint16		numvar;
@@ -61,7 +65,8 @@ typedef struct {
 #endif
 #define LQL_CANLOOKSIGN(x) FLG_CANLOOKSIGN( ((lquery_level*)(x))->flag )
 
-typedef struct {
+typedef struct
+{
 	int32		len;
 	uint16		numlevel;
 	uint16		firstgood;
@@ -155,11 +160,11 @@ Datum ltree_in(PG_FUNCTION_ARGS);
 bool ltree_execute(ITEM * curitem, void *checkval,
 			  bool calcnot, bool (*chkcond) (void *checkval, ITEM * val));
 
-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 );
-ltree* lca_inner(ltree** a, int len);
+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);
+ltree	   *lca_inner(ltree ** a, int len);
 
 #define PG_GETARG_LTREE(x)	((ltree*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
 #define PG_GETARG_LQUERY(x) ((lquery*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
@@ -203,7 +208,8 @@ typedef unsigned char *BITVECP;
  *
  */
 
-typedef struct {
+typedef struct
+{
 	int4		len;
 	uint32		flag;
 	char		data[1];
@@ -249,4 +255,3 @@ typedef unsigned char ABITVEC[ASIGLEN];
 /* type of key is the same to ltree_gist */
 
 #endif
-

contrib/ltree/ltxtquery_io.c

@@ -9,6 +9,7 @@
 
 PG_FUNCTION_INFO_V1(ltxtq_in);
 Datum		ltxtq_in(PG_FUNCTION_ARGS);
+
 PG_FUNCTION_INFO_V1(ltxtq_out);
 Datum		ltxtq_out(PG_FUNCTION_ARGS);
 
@@ -22,7 +23,8 @@ Datum	   ltxtq_out(PG_FUNCTION_ARGS);
  * node of query tree, also used
  * for storing polish notation in parser
  */
-typedef struct NODE {
+typedef struct NODE
+{
 	int4		type;
 	int4		val;
 	int2		distance;
@@ -31,7 +33,8 @@ typedef struct NODE {
 	struct NODE *next;
 }	NODE;
 
-typedef struct {
+typedef struct
+{
 	char	   *buf;
 	int4		state;
 	int4		count;
@@ -70,27 +73,31 @@ gettoken_query(QPRS_STATE * state, int4 *val, int4 *lenval, char **strval, uint1
 					(state->buf)++;
 					return OPEN;
 				}
-				else if ( ISALNUM(*(state->buf)) )
+				else if (ISALNUM(*(state->buf)))
 				{
 					state->state = INOPERAND;
 					*strval = state->buf;
 					*lenval = 1;
 					*flag = 0;
-				} else if ( !isspace((unsigned int)*(state->buf)) )
-					elog(ERROR,"Operand syntax error");
+				}
+				else if (!isspace((unsigned int) *(state->buf)))
+					elog(ERROR, "Operand syntax error");
 				break;
 			case INOPERAND:
-				if ( ISALNUM(*(state->buf)) ) {
-					if ( *flag )
-						elog(ERROR,"Modificators syntax error");
+				if (ISALNUM(*(state->buf)))
+				{
+					if (*flag)
+						elog(ERROR, "Modificators syntax error");
 					(*lenval)++;
-				} else if ( *(state->buf) == '%' ) {
+				}
+				else if (*(state->buf) == '%')
 					*flag |= LVAR_SUBLEXEM;
-				} else if ( *(state->buf) == '@' ) {
+				else if (*(state->buf) == '@')
 					*flag |= LVAR_INCASE;
-				} else if ( *(state->buf) == '*' ) {
+				else if (*(state->buf) == '*')
 					*flag |= LVAR_ANYEND;
-				} else {
+				else
+				{
 					state->state = WAITOPERATOR;
 					return VAL;
 				}
@@ -188,11 +195,12 @@ makepol(QPRS_STATE * state)
 	int4		lenstack = 0;
 	uint16		flag;
 
-	while ((type = gettoken_query(state, &val, &lenval, &strval,&flag)) != END) {
+	while ((type = gettoken_query(state, &val, &lenval, &strval, &flag)) != END)
+	{
 		switch (type)
 		{
 			case VAL:
-				pushval_asis(state, VAL, strval, lenval,flag);
+				pushval_asis(state, VAL, strval, lenval, flag);
 				while (lenstack && (stack[lenstack - 1] == (int4) '&' ||
 									stack[lenstack - 1] == (int4) '!'))
 				{
@@ -236,7 +244,8 @@ makepol(QPRS_STATE * state)
 
 		}
 	}
-	while (lenstack) {
+	while (lenstack)
+	{
 		lenstack--;
 		pushquery(state, OPR, stack[lenstack], 0, 0, 0);
 	};
@@ -379,20 +388,24 @@ infix(INFIX * in, bool first)
 		char	   *op = in->op + in->curpol->distance;
 
 		RESIZEBUF(in, in->curpol->length * 2 + 5);
-		while (*op) {
+		while (*op)
+		{
 			*(in->cur) = *op;
 			op++;
 			in->cur++;
 		}
-		if ( in->curpol->flag & LVAR_SUBLEXEM ) {
+		if (in->curpol->flag & LVAR_SUBLEXEM)
+		{
 			*(in->cur) = '%';
 			in->cur++;
 		}
-		if ( in->curpol->flag & LVAR_INCASE ) {
+		if (in->curpol->flag & LVAR_INCASE)
+		{
 			*(in->cur) = '@';
 			in->cur++;
 		}
-		if ( in->curpol->flag & LVAR_ANYEND ) {
+		if (in->curpol->flag & LVAR_ANYEND)
+		{
 			*(in->cur) = '*';
 			in->cur++;
 		}
@@ -481,4 +494,3 @@ ltxtq_out(PG_FUNCTION_ARGS)
 	PG_FREE_IF_COPY(query, 0);
 	PG_RETURN_POINTER(nrm.buf);
 }
-

contrib/pg_dumplo/lo_export.c

 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.9 2002/08/15 02:58:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.10 2002/09/04 20:31:06 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------

contrib/pg_dumplo/lo_import.c

 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.7 2002/08/15 02:58:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.8 2002/09/04 20:31:06 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------

contrib/pg_dumplo/main.c

 /* -------------------------------------------------------------------------
  * pg_dumplo
  *
- * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.10 2001/11/12 17:44:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.11 2002/09/04 20:31:07 momjian Exp $
  *
  *					Karel Zak 1999-2000
  * -------------------------------------------------------------------------

contrib/tsearch/deflex.h

@@ -31,4 +31,3 @@
 extern const char *descr[];
 
 #endif
-

contrib/tsearch/morph.c

@@ -114,7 +114,7 @@ initmorph(void)
 		needinit[i] = false;
 
 	PGLC_current(&lc);
-	if ( lc.lc_ctype )
+	if (lc.lc_ctype)
 		for (i = 1; i < lengthof(dicts); i++)
 			if (strcmp(dicts[i].localename, lc.lc_ctype) == 0)
 			{

contrib/tsearch/txtidx.c

@@ -402,7 +402,7 @@ compareWORD(const void *a, const void *b)
 }
 
 static int
-uniqueWORD(WORD *a, int4 l)
+uniqueWORD(WORD * a, int4 l)
 {
 	WORD	   *ptr,
 			   *res;

src/backend/access/gist/gistget.c

@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.34 2002/06/20 20:29:24 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.35 2002/09/04 20:31:09 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */