pgindent run before PG 9.1 beta 1.

6 files changed, 110 insertions, 101 deletions

diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c
index 9529413e80e..fae3464600a 100644
--- a/src/backend/access/gist/gist.c
+++ b/src/backend/access/gist/gist.c
@@ -34,8 +34,8 @@ typedef struct
 /* A List of these is used represent a split-in-progress. */
 typedef struct
 {
-	Buffer		buf;		/* the split page "half" */
-	IndexTuple	downlink;	/* downlink for this half. */
+	Buffer		buf;			/* the split page "half" */
+	IndexTuple	downlink;		/* downlink for this half. */
 } GISTPageSplitInfo;
 
 /* non-export function prototypes */
@@ -306,13 +306,13 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 	bool		is_split;
 
 	/*
-	 * Refuse to modify a page that's incompletely split. This should
-	 * not happen because we finish any incomplete splits while we walk
-	 * down the tree. However, it's remotely possible that another
-	 * concurrent inserter splits a parent page, and errors out before
-	 * completing the split. We will just throw an error in that case,
-	 * and leave any split we had in progress unfinished too. The next
-	 * insert that comes along will clean up the mess.
+	 * Refuse to modify a page that's incompletely split. This should not
+	 * happen because we finish any incomplete splits while we walk down the
+	 * tree. However, it's remotely possible that another concurrent inserter
+	 * splits a parent page, and errors out before completing the split. We
+	 * will just throw an error in that case, and leave any split we had in
+	 * progress unfinished too. The next insert that comes along will clean up
+	 * the mess.
 	 */
 	if (GistFollowRight(page))
 		elog(ERROR, "concurrent GiST page split was incomplete");
@@ -338,7 +338,7 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 		SplitedPageLayout *dist = NULL,
 				   *ptr;
 		BlockNumber oldrlink = InvalidBlockNumber;
-		GistNSN		oldnsn = { 0, 0 };
+		GistNSN		oldnsn = {0, 0};
 		SplitedPageLayout rootpg;
 		BlockNumber blkno = BufferGetBlockNumber(buffer);
 		bool		is_rootsplit;
@@ -364,8 +364,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 
 		/*
 		 * Set up pages to work with. Allocate new buffers for all but the
-		 * leftmost page. The original page becomes the new leftmost page,
-		 * and is just replaced with the new contents.
+		 * leftmost page. The original page becomes the new leftmost page, and
+		 * is just replaced with the new contents.
 		 *
 		 * For a root-split, allocate new buffers for all child pages, the
 		 * original page is overwritten with new root page containing
@@ -414,8 +414,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 		if (is_rootsplit)
 		{
 			IndexTuple *downlinks;
-			int ndownlinks = 0;
-			int i;
+			int			ndownlinks = 0;
+			int			i;
 
 			rootpg.buffer = buffer;
 			rootpg.page = PageGetTempPageCopySpecial(BufferGetPage(rootpg.buffer));
@@ -443,6 +443,7 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 			for (ptr = dist; ptr; ptr = ptr->next)
 			{
 				GISTPageSplitInfo *si = palloc(sizeof(GISTPageSplitInfo));
+
 				si->buf = ptr->buffer;
 				si->downlink = ptr->itup;
 				*splitinfo = lappend(*splitinfo, si);
@@ -455,7 +456,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 		 */
 		for (ptr = dist; ptr; ptr = ptr->next)
 		{
-			char *data = (char *) (ptr->list);
+			char	   *data = (char *) (ptr->list);
+
 			for (i = 0; i < ptr->block.num; i++)
 			{
 				if (PageAddItem(ptr->page, (Item) data, IndexTupleSize((IndexTuple) data), i + FirstOffsetNumber, false, false) == InvalidOffsetNumber)
@@ -495,8 +497,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 			MarkBufferDirty(leftchildbuf);
 
 		/*
-		 * The first page in the chain was a temporary working copy meant
-		 * to replace the old page. Copy it over the old page.
+		 * The first page in the chain was a temporary working copy meant to
+		 * replace the old page. Copy it over the old page.
 		 */
 		PageRestoreTempPage(dist->page, BufferGetPage(dist->buffer));
 		dist->page = BufferGetPage(dist->buffer);
@@ -518,8 +520,8 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 		 * Return the new child buffers to the caller.
 		 *
 		 * If this was a root split, we've already inserted the downlink
-		 * pointers, in the form of a new root page. Therefore we can
-		 * release all the new buffers, and keep just the root page locked.
+		 * pointers, in the form of a new root page. Therefore we can release
+		 * all the new buffers, and keep just the root page locked.
 		 */
 		if (is_rootsplit)
 		{
@@ -572,20 +574,20 @@ gistplacetopage(GISTInsertState *state, GISTSTATE *giststate,
 
 	/*
 	 * If we inserted the downlink for a child page, set NSN and clear
-	 * F_FOLLOW_RIGHT flag on the left child, so that concurrent scans know
-	 * to follow the rightlink if and only if they looked at the parent page
+	 * F_FOLLOW_RIGHT flag on the left child, so that concurrent scans know to
+	 * follow the rightlink if and only if they looked at the parent page
 	 * before we inserted the downlink.
 	 *
 	 * Note that we do this *after* writing the WAL record. That means that
-	 * the possible full page image in the WAL record does not include
-	 * these changes, and they must be replayed even if the page is restored
-	 * from the full page image. There's a chicken-and-egg problem: if we
-	 * updated the child pages first, we wouldn't know the recptr of the WAL
-	 * record we're about to write.
+	 * the possible full page image in the WAL record does not include these
+	 * changes, and they must be replayed even if the page is restored from
+	 * the full page image. There's a chicken-and-egg problem: if we updated
+	 * the child pages first, we wouldn't know the recptr of the WAL record
+	 * we're about to write.
 	 */
 	if (BufferIsValid(leftchildbuf))
 	{
-		Page leftpg = BufferGetPage(leftchildbuf);
+		Page		leftpg = BufferGetPage(leftchildbuf);
 
 		GistPageGetOpaque(leftpg)->nsn = recptr;
 		GistClearFollowRight(leftpg);
@@ -636,8 +638,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 			stack->buffer = ReadBuffer(state.r, stack->blkno);
 
 		/*
-		 * Be optimistic and grab shared lock first. Swap it for an
-		 * exclusive lock later if we need to update the page.
+		 * Be optimistic and grab shared lock first. Swap it for an exclusive
+		 * lock later if we need to update the page.
 		 */
 		if (!xlocked)
 		{
@@ -650,9 +652,9 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 		Assert(!RelationNeedsWAL(state.r) || !XLogRecPtrIsInvalid(stack->lsn));
 
 		/*
-		 * If this page was split but the downlink was never inserted to
-		 * the parent because the inserting backend crashed before doing
-		 * that, fix that now.
+		 * If this page was split but the downlink was never inserted to the
+		 * parent because the inserting backend crashed before doing that, fix
+		 * that now.
 		 */
 		if (GistFollowRight(stack->page))
 		{
@@ -680,8 +682,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 			/*
 			 * Concurrent split detected. There's no guarantee that the
 			 * downlink for this page is consistent with the tuple we're
-			 * inserting anymore, so go back to parent and rechoose the
-			 * best child.
+			 * inserting anymore, so go back to parent and rechoose the best
+			 * child.
 			 */
 			UnlockReleaseBuffer(stack->buffer);
 			xlocked = false;
@@ -696,7 +698,7 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 			 * Find the child node that has the minimum insertion penalty.
 			 */
 			BlockNumber childblkno;
-			IndexTuple newtup;
+			IndexTuple	newtup;
 			GISTInsertStack *item;
 
 			stack->childoffnum = gistchoose(state.r, stack->page, itup, giststate);
@@ -722,8 +724,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 			if (newtup)
 			{
 				/*
-				 * Swap shared lock for an exclusive one. Beware, the page
-				 * may change while we unlock/lock the page...
+				 * Swap shared lock for an exclusive one. Beware, the page may
+				 * change while we unlock/lock the page...
 				 */
 				if (!xlocked)
 				{
@@ -738,6 +740,7 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 						continue;
 					}
 				}
+
 				/*
 				 * Update the tuple.
 				 *
@@ -752,8 +755,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 									 stack->childoffnum, InvalidBuffer))
 				{
 					/*
-					 * If this was a root split, the root page continues to
-					 * be the parent and the updated tuple went to one of the
+					 * If this was a root split, the root page continues to be
+					 * the parent and the updated tuple went to one of the
 					 * child pages, so we just need to retry from the root
 					 * page.
 					 */
@@ -779,13 +782,13 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 		{
 			/*
 			 * Leaf page. Insert the new key. We've already updated all the
-			 * parents on the way down, but we might have to split the page
-			 * if it doesn't fit. gistinserthere() will take care of that.
+			 * parents on the way down, but we might have to split the page if
+			 * it doesn't fit. gistinserthere() will take care of that.
 			 */
 
 			/*
-			 * Swap shared lock for an exclusive one. Be careful, the page
-			 * may change while we unlock/lock the page...
+			 * Swap shared lock for an exclusive one. Be careful, the page may
+			 * change while we unlock/lock the page...
 			 */
 			if (!xlocked)
 			{
@@ -798,8 +801,8 @@ gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate)
 				if (stack->blkno == GIST_ROOT_BLKNO)
 				{
 					/*
-					 * the only page that can become inner instead of leaf
-					 * is the root page, so for root we should recheck it
+					 * the only page that can become inner instead of leaf is
+					 * the root page, so for root we should recheck it
 					 */
 					if (!GistPageIsLeaf(stack->page))
 					{
@@ -1059,21 +1062,23 @@ static IndexTuple
 gistformdownlink(Relation rel, Buffer buf, GISTSTATE *giststate,
 				 GISTInsertStack *stack)
 {
-	Page page = BufferGetPage(buf);
+	Page		page = BufferGetPage(buf);
 	OffsetNumber maxoff;
 	OffsetNumber offset;
-	IndexTuple downlink = NULL;
+	IndexTuple	downlink = NULL;
 
 	maxoff = PageGetMaxOffsetNumber(page);
 	for (offset = FirstOffsetNumber; offset <= maxoff; offset = OffsetNumberNext(offset))
 	{
 		IndexTuple	ituple = (IndexTuple)
-			PageGetItem(page, PageGetItemId(page, offset));
+		PageGetItem(page, PageGetItemId(page, offset));
+
 		if (downlink == NULL)
 			downlink = CopyIndexTuple(ituple);
 		else
 		{
-			IndexTuple newdownlink;
+			IndexTuple	newdownlink;
+
 			newdownlink = gistgetadjusted(rel, downlink, ituple,
 										  giststate);
 			if (newdownlink)
@@ -1082,19 +1087,18 @@ gistformdownlink(Relation rel, Buffer buf, GISTSTATE *giststate,
 	}
 
 	/*
-	 * If the page is completely empty, we can't form a meaningful
-	 * downlink for it. But we have to insert a downlink for the page.
-	 * Any key will do, as long as its consistent with the downlink of
-	 * parent page, so that we can legally insert it to the parent.
-	 * A minimal one that matches as few scans as possible would be best,
-	 * to keep scans from doing useless work, but we don't know how to
-	 * construct that. So we just use the downlink of the original page
-	 * that was split - that's as far from optimal as it can get but will
-	 * do..
+	 * If the page is completely empty, we can't form a meaningful downlink
+	 * for it. But we have to insert a downlink for the page. Any key will do,
+	 * as long as its consistent with the downlink of parent page, so that we
+	 * can legally insert it to the parent. A minimal one that matches as few
+	 * scans as possible would be best, to keep scans from doing useless work,
+	 * but we don't know how to construct that. So we just use the downlink of
+	 * the original page that was split - that's as far from optimal as it can
+	 * get but will do..
 	 */
 	if (!downlink)
 	{
-		ItemId iid;
+		ItemId		iid;
 
 		LockBuffer(stack->parent->buffer, GIST_EXCLUSIVE);
 		gistFindCorrectParent(rel, stack);
@@ -1131,13 +1135,13 @@ gistfixsplit(GISTInsertState *state, GISTSTATE *giststate)
 	buf = stack->buffer;
 
 	/*
-	 * Read the chain of split pages, following the rightlinks. Construct
-	 * a downlink tuple for each page.
+	 * Read the chain of split pages, following the rightlinks. Construct a
+	 * downlink tuple for each page.
 	 */
 	for (;;)
 	{
 		GISTPageSplitInfo *si = palloc(sizeof(GISTPageSplitInfo));
-		IndexTuple downlink;
+		IndexTuple	downlink;
 
 		page = BufferGetPage(buf);
 
@@ -1182,8 +1186,8 @@ gistinserttuples(GISTInsertState *state, GISTInsertStack *stack,
 				 IndexTuple *tuples, int ntup, OffsetNumber oldoffnum,
 				 Buffer leftchild)
 {
-	List *splitinfo;
-	bool is_split;
+	List	   *splitinfo;
+	bool		is_split;
 
 	is_split = gistplacetopage(state, giststate, stack->buffer,
 							   tuples, ntup, oldoffnum,
@@ -1204,21 +1208,21 @@ static void
 gistfinishsplit(GISTInsertState *state, GISTInsertStack *stack,
 				GISTSTATE *giststate, List *splitinfo)
 {
-	ListCell *lc;
-	List *reversed;
+	ListCell   *lc;
+	List	   *reversed;
 	GISTPageSplitInfo *right;
 	GISTPageSplitInfo *left;
-	IndexTuple tuples[2];
+	IndexTuple	tuples[2];
 
 	/* A split always contains at least two halves */
 	Assert(list_length(splitinfo) >= 2);
 
 	/*
-	 * We need to insert downlinks for each new page, and update the
-	 * downlink for the original (leftmost) page in the split. Begin at
-	 * the rightmost page, inserting one downlink at a time until there's
-	 * only two pages left. Finally insert the downlink for the last new
-	 * page and update the downlink for the original page as one operation.
+	 * We need to insert downlinks for each new page, and update the downlink
+	 * for the original (leftmost) page in the split. Begin at the rightmost
+	 * page, inserting one downlink at a time until there's only two pages
+	 * left. Finally insert the downlink for the last new page and update the
+	 * downlink for the original page as one operation.
 	 */
 
 	/* for convenience, create a copy of the list in reverse order */
@@ -1231,7 +1235,7 @@ gistfinishsplit(GISTInsertState *state, GISTInsertStack *stack,
 	LockBuffer(stack->parent->buffer, GIST_EXCLUSIVE);
 	gistFindCorrectParent(state->r, stack);
 
-	while(list_length(reversed) > 2)
+	while (list_length(reversed) > 2)
 	{
 		right = (GISTPageSplitInfo *) linitial(reversed);
 		left = (GISTPageSplitInfo *) lsecond(reversed);
@@ -1386,7 +1390,7 @@ initGISTstate(GISTSTATE *giststate, Relation index)
 		/* opclasses are not required to provide a Distance method */
 		if (OidIsValid(index_getprocid(index, i + 1, GIST_DISTANCE_PROC)))
 			fmgr_info_copy(&(giststate->distanceFn[i]),
-						   index_getprocinfo(index, i + 1, GIST_DISTANCE_PROC),
+						 index_getprocinfo(index, i + 1, GIST_DISTANCE_PROC),
 						   CurrentMemoryContext);
 		else
 			giststate->distanceFn[i].fn_oid = InvalidOid;
diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c
index 8355081553d..e4488a925de 100644
--- a/src/backend/access/gist/gistget.c
+++ b/src/backend/access/gist/gistget.c
@@ -32,7 +32,7 @@
  *
  * On success return for a heap tuple, *recheck_p is set to indicate
  * whether recheck is needed.  We recheck if any of the consistent() functions
- * request it.  recheck is not interesting when examining a non-leaf entry,
+ * request it.	recheck is not interesting when examining a non-leaf entry,
  * since we must visit the lower index page if there's any doubt.
  *
  * If we are doing an ordered scan, so->distances[] is filled with distance
@@ -62,15 +62,15 @@ gistindex_keytest(IndexScanDesc scan,
 	*recheck_p = false;
 
 	/*
-	 * If it's a leftover invalid tuple from pre-9.1, treat it as a match
-	 * with minimum possible distances.  This means we'll always follow it
-	 * to the referenced page.
+	 * If it's a leftover invalid tuple from pre-9.1, treat it as a match with
+	 * minimum possible distances.	This means we'll always follow it to the
+	 * referenced page.
 	 */
 	if (GistTupleIsInvalid(tuple))
 	{
-		int		i;
+		int			i;
 
-		if (GistPageIsLeaf(page))			/* shouldn't happen */
+		if (GistPageIsLeaf(page))		/* shouldn't happen */
 			elog(ERROR, "invalid GIST tuple found on leaf page");
 		for (i = 0; i < scan->numberOfOrderBys; i++)
 			so->distances[i] = -get_float8_infinity();
@@ -191,8 +191,8 @@ gistindex_keytest(IndexScanDesc scan,
 			 * always be zero, but might as well pass it for possible future
 			 * use.)
 			 *
-			 * Note that Distance functions don't get a recheck argument.
-			 * We can't tolerate lossy distance calculations on leaf tuples;
+			 * Note that Distance functions don't get a recheck argument. We
+			 * can't tolerate lossy distance calculations on leaf tuples;
 			 * there is no opportunity to re-sort the tuples afterwards.
 			 */
 			dist = FunctionCall4(&key->sk_func,
@@ -223,7 +223,7 @@ gistindex_keytest(IndexScanDesc scan,
  * ntids: if not NULL, gistgetbitmap's output tuple counter
  *
  * If tbm/ntids aren't NULL, we are doing an amgetbitmap scan, and heap
- * tuples should be reported directly into the bitmap.  If they are NULL,
+ * tuples should be reported directly into the bitmap.	If they are NULL,
  * we're doing a plain or ordered indexscan.  For a plain indexscan, heap
  * tuple TIDs are returned into so->pageData[].  For an ordered indexscan,
  * heap tuple TIDs are pushed into individual search queue items.
@@ -525,8 +525,8 @@ gistgettuple(PG_FUNCTION_ARGS)
 				/*
 				 * While scanning a leaf page, ItemPointers of matching heap
 				 * tuples are stored in so->pageData.  If there are any on
-				 * this page, we fall out of the inner "do" and loop around
-				 * to return them.
+				 * this page, we fall out of the inner "do" and loop around to
+				 * return them.
 				 */
 				gistScanPage(scan, item, so->curTreeItem->distances, NULL, NULL);
 
diff --git a/src/backend/access/gist/gistproc.c b/src/backend/access/gist/gistproc.c
index 86a5d90f955..43c4b1251b1 100644
--- a/src/backend/access/gist/gistproc.c
+++ b/src/backend/access/gist/gistproc.c
@@ -904,7 +904,7 @@ gist_point_compress(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(entry);
 }
 
-#define	point_point_distance(p1,p2)	\
+#define point_point_distance(p1,p2) \
 	DatumGetFloat8(DirectFunctionCall2(point_distance, \
 									   PointPGetDatum(p1), PointPGetDatum(p2)))
 
@@ -949,8 +949,8 @@ computeDistance(bool isLeaf, BOX *box, Point *point)
 	else
 	{
 		/* closest point will be a vertex */
-		Point	p;
-		double	subresult;
+		Point		p;
+		double		subresult;
 
 		result = point_point_distance(point, &box->low);
 
diff --git a/src/backend/access/gist/gistscan.c b/src/backend/access/gist/gistscan.c
index 0a125e772d0..67308ed37e5 100644
--- a/src/backend/access/gist/gistscan.c
+++ b/src/backend/access/gist/gistscan.c
@@ -57,9 +57,9 @@ GISTSearchTreeItemCombiner(RBNode *existing, const RBNode *newrb, void *arg)
 
 	/*
 	 * If new item is heap tuple, it goes to front of chain; otherwise insert
-	 * it before the first index-page item, so that index pages are visited
-	 * in LIFO order, ensuring depth-first search of index pages.  See
-	 * comments in gist_private.h.
+	 * it before the first index-page item, so that index pages are visited in
+	 * LIFO order, ensuring depth-first search of index pages.	See comments
+	 * in gist_private.h.
 	 */
 	if (GISTSearchItemIsHeap(*newitem))
 	{
@@ -136,6 +136,7 @@ gistrescan(PG_FUNCTION_ARGS)
 	IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
 	ScanKey		key = (ScanKey) PG_GETARG_POINTER(1);
 	ScanKey		orderbys = (ScanKey) PG_GETARG_POINTER(3);
+
 	/* nkeys and norderbys arguments are ignored */
 	GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
 	int			i;
@@ -164,8 +165,8 @@ gistrescan(PG_FUNCTION_ARGS)
 				scan->numberOfKeys * sizeof(ScanKeyData));
 
 		/*
-		 * Modify the scan key so that the Consistent method is called for
-		 * all comparisons. The original operator is passed to the Consistent
+		 * Modify the scan key so that the Consistent method is called for all
+		 * comparisons. The original operator is passed to the Consistent
 		 * function in the form of its strategy number, which is available
 		 * from the sk_strategy field, and its subtype from the sk_subtype
 		 * field.  Also, preserve sk_func.fn_collation which is the input
diff --git a/src/backend/access/gist/gistutil.c b/src/backend/access/gist/gistutil.c
index 6736fd166c3..e8bbd564c71 100644
--- a/src/backend/access/gist/gistutil.c
+++ b/src/backend/access/gist/gistutil.c
@@ -503,11 +503,12 @@ gistFormTuple(GISTSTATE *giststate, Relation r,
 	}
 
 	res = index_form_tuple(giststate->tupdesc, compatt, isnull);
+
 	/*
 	 * The offset number on tuples on internal pages is unused. For historical
 	 * reasons, it is set 0xffff.
 	 */
-	ItemPointerSetOffsetNumber( &(res->t_tid), 0xffff);
+	ItemPointerSetOffsetNumber(&(res->t_tid), 0xffff);
 	return res;
 }
 
diff --git a/src/backend/access/gist/gistxlog.c b/src/backend/access/gist/gistxlog.c
index 0f406e16c4e..51354c1c185 100644
--- a/src/backend/access/gist/gistxlog.c
+++ b/src/backend/access/gist/gistxlog.c
@@ -41,12 +41,12 @@ static void
 gistRedoClearFollowRight(RelFileNode node, XLogRecPtr lsn,
 						 BlockNumber leftblkno)
 {
-	Buffer buffer;
+	Buffer		buffer;
 
 	buffer = XLogReadBuffer(node, leftblkno, false);
 	if (BufferIsValid(buffer))
 	{
-		Page page = (Page) BufferGetPage(buffer);
+		Page		page = (Page) BufferGetPage(buffer);
 
 		/*
 		 * Note that we still update the page even if page LSN is equal to the
@@ -103,6 +103,7 @@ gistRedoPageUpdateRecord(XLogRecPtr lsn, XLogRecord *record)
 	{
 		int			i;
 		OffsetNumber *todelete = (OffsetNumber *) data;
+
 		data += sizeof(OffsetNumber) * xldata->ntodelete;
 
 		for (i = 0; i < xldata->ntodelete; i++)
@@ -115,12 +116,14 @@ gistRedoPageUpdateRecord(XLogRecPtr lsn, XLogRecord *record)
 	if (data - begin < record->xl_len)
 	{
 		OffsetNumber off = (PageIsEmpty(page)) ? FirstOffsetNumber :
-			OffsetNumberNext(PageGetMaxOffsetNumber(page));
+		OffsetNumberNext(PageGetMaxOffsetNumber(page));
+
 		while (data - begin < record->xl_len)
 		{
-			IndexTuple itup = (IndexTuple) data;
+			IndexTuple	itup = (IndexTuple) data;
 			Size		sz = IndexTupleSize(itup);
 			OffsetNumber l;
+
 			data += sz;
 
 			l = PageAddItem(page, (Item) itup, sz, off, false, false);
@@ -418,7 +421,7 @@ gistXLogSplit(RelFileNode node, BlockNumber blkno, bool page_is_leaf,
 	SplitedPageLayout *ptr;
 	int			npage = 0,
 				cur;
-	XLogRecPtr recptr;
+	XLogRecPtr	recptr;
 
 	for (ptr = dist; ptr; ptr = ptr->next)
 		npage++;
@@ -540,8 +543,8 @@ gistXLogUpdate(RelFileNode node, Buffer buffer,
 	}
 
 	/*
-	 * Include a full page image of the child buf. (only necessary if
-	 * a checkpoint happened since the child page was split)
+	 * Include a full page image of the child buf. (only necessary if a
+	 * checkpoint happened since the child page was split)
 	 */
 	if (BufferIsValid(leftchildbuf))
 	{