pgindent run for 8.3.

src/backend/access/nbtree/nbtpage.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/access/nbtree/nbtpage.c,v 1.103 2007/09/12 22:10:26 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/access/nbtree/nbtpage.c,v 1.104 2007/11/15 21:14:32 momjian Exp $
  *
  *	NOTES
  *	   Postgres btree pages look like ordinary relation pages.	The opaque
@@ -751,8 +751,8 @@ _bt_parent_deletion_safe(Relation rel, BlockNumber target, BTStack stack)
 
 	/*
 	 * In recovery mode, assume the deletion being replayed is valid.  We
-	 * can't always check it because we won't have a full search stack,
-	 * and we should complain if there's a problem, anyway.
+	 * can't always check it because we won't have a full search stack, and we
+	 * should complain if there's a problem, anyway.
 	 */
 	if (InRecovery)
 		return true;
@@ -781,8 +781,8 @@ _bt_parent_deletion_safe(Relation rel, BlockNumber target, BTStack stack)
 		{
 			/*
 			 * It's only child, so safe if parent would itself be removable.
-			 * We have to check the parent itself, and then recurse to
-			 * test the conditions at the parent's parent.
+			 * We have to check the parent itself, and then recurse to test
+			 * the conditions at the parent's parent.
 			 */
 			if (P_RIGHTMOST(opaque) || P_ISROOT(opaque))
 			{
@@ -887,18 +887,18 @@ _bt_pagedel(Relation rel, Buffer buf, BTStack stack, bool vacuum_full)
 	targetkey = CopyIndexTuple((IndexTuple) PageGetItem(page, itemid));
 
 	/*
-	 * To avoid deadlocks, we'd better drop the target page lock before
-	 * going further.
+	 * To avoid deadlocks, we'd better drop the target page lock before going
+	 * further.
 	 */
 	_bt_relbuf(rel, buf);
 
 	/*
-	 * We need an approximate pointer to the page's parent page.  We use
-	 * the standard search mechanism to search for the page's high key; this
-	 * will give us a link to either the current parent or someplace to its
-	 * left (if there are multiple equal high keys).  In recursion cases,
-	 * the caller already generated a search stack and we can just re-use
-	 * that work.
+	 * We need an approximate pointer to the page's parent page.  We use the
+	 * standard search mechanism to search for the page's high key; this will
+	 * give us a link to either the current parent or someplace to its left
+	 * (if there are multiple equal high keys).  In recursion cases, the
+	 * caller already generated a search stack and we can just re-use that
+	 * work.
 	 */
 	if (stack == NULL)
 	{
@@ -933,11 +933,11 @@ _bt_pagedel(Relation rel, Buffer buf, BTStack stack, bool vacuum_full)
 			/*
 			 * During WAL recovery, we can't use _bt_search (for one reason,
 			 * it might invoke user-defined comparison functions that expect
-			 * facilities not available in recovery mode).  Instead, just
-			 * set up a dummy stack pointing to the left end of the parent
-			 * tree level, from which _bt_getstackbuf will walk right to the
-			 * parent page.  Painful, but we don't care too much about
-			 * performance in this scenario.
+			 * facilities not available in recovery mode).	Instead, just set
+			 * up a dummy stack pointing to the left end of the parent tree
+			 * level, from which _bt_getstackbuf will walk right to the parent
+			 * page.  Painful, but we don't care too much about performance in
+			 * this scenario.
 			 */
 			pbuf = _bt_get_endpoint(rel, targetlevel + 1, false);
 			stack = (BTStack) palloc(sizeof(BTStackData));
@@ -951,10 +951,10 @@ _bt_pagedel(Relation rel, Buffer buf, BTStack stack, bool vacuum_full)
 
 	/*
 	 * We cannot delete a page that is the rightmost child of its immediate
-	 * parent, unless it is the only child --- in which case the parent has
-	 * to be deleted too, and the same condition applies recursively to it.
-	 * We have to check this condition all the way up before trying to delete.
-	 * We don't need to re-test when deleting a non-leaf page, though.
+	 * parent, unless it is the only child --- in which case the parent has to
+	 * be deleted too, and the same condition applies recursively to it. We
+	 * have to check this condition all the way up before trying to delete. We
+	 * don't need to re-test when deleting a non-leaf page, though.
 	 */
 	if (targetlevel == 0 &&
 		!_bt_parent_deletion_safe(rel, target, stack))
@@ -1072,8 +1072,8 @@ _bt_pagedel(Relation rel, Buffer buf, BTStack stack, bool vacuum_full)
 	 * might be possible to push the fast root even further down, but the odds
 	 * of doing so are slim, and the locking considerations daunting.)
 	 *
-	 * We don't support handling this in the case where the parent is
-	 * becoming half-dead, even though it theoretically could occur.
+	 * We don't support handling this in the case where the parent is becoming
+	 * half-dead, even though it theoretically could occur.
 	 *
 	 * We can safely acquire a lock on the metapage here --- see comments for
 	 * _bt_newroot().
@@ -1287,10 +1287,10 @@ _bt_pagedel(Relation rel, Buffer buf, BTStack stack, bool vacuum_full)
 		_bt_relbuf(rel, lbuf);
 
 	/*
-	 * If parent became half dead, recurse to delete it. Otherwise, if
-	 * right sibling is empty and is now the last child of the parent, recurse
-	 * to try to delete it.  (These cases cannot apply at the same time,
-	 * though the second case might itself recurse to the first.)
+	 * If parent became half dead, recurse to delete it. Otherwise, if right
+	 * sibling is empty and is now the last child of the parent, recurse to
+	 * try to delete it.  (These cases cannot apply at the same time, though
+	 * the second case might itself recurse to the first.)
 	 *
 	 * When recursing to parent, we hold the lock on the target page until
 	 * done.  This delays any insertions into the keyspace that was just