[skip ci] rts: Detabify sm/Sanity.c

Signed-off-by: Austin Seipp <austin@well-typed.com>

1 files changed, 165 insertions, 165 deletions

diff --git a/rts/sm/Sanity.c b/rts/sm/Sanity.c
index c653331164..dd50ded063 100644
--- a/rts/sm/Sanity.c
+++ b/rts/sm/Sanity.c
@@ -9,7 +9,7 @@
  *    - All things that are supposed to be pointers look like pointers.
  *
  *    - Objects in text space are marked as static closures, those
- *	in the heap are dynamic.
+ *      in the heap are dynamic.
  *
  * ---------------------------------------------------------------------------*/
 
@@ -48,9 +48,9 @@ checkSmallBitmap( StgPtr payload, StgWord bitmap, nat size )
     nat i;
 
     for(i = 0; i < size; i++, bitmap >>= 1 ) {
-	if ((bitmap & 1) == 0) {
-	    checkClosureShallow((StgClosure *)payload[i]);
-	}
+        if ((bitmap & 1) == 0) {
+            checkClosureShallow((StgClosure *)payload[i]);
+        }
     }
 }
 
@@ -62,13 +62,13 @@ checkLargeBitmap( StgPtr payload, StgLargeBitmap* large_bitmap, nat size )
 
     i = 0;
     for (bmp=0; i < size; bmp++) {
-	StgWord bitmap = large_bitmap->bitmap[bmp];
-	j = 0;
-	for(; i < size && j < BITS_IN(W_); j++, i++, bitmap >>= 1 ) {
-	    if ((bitmap & 1) == 0) {
-		checkClosureShallow((StgClosure *)payload[i]);
-	    }
-	}
+        StgWord bitmap = large_bitmap->bitmap[bmp];
+        j = 0;
+        for(; i < size && j < BITS_IN(W_); j++, i++, bitmap >>= 1 ) {
+            if ((bitmap & 1) == 0) {
+                checkClosureShallow((StgClosure *)payload[i]);
+            }
+        }
     }
 }
 
@@ -77,8 +77,8 @@ checkLargeBitmap( StgPtr payload, StgLargeBitmap* large_bitmap, nat size )
  * used to avoid recursion between checking PAPs and checking stack
  * chunks.
  */
- 
-static void 
+
+static void
 checkClosureShallow( StgClosure* p )
 {
     StgClosure *q;
@@ -88,14 +88,14 @@ checkClosureShallow( StgClosure* p )
 
     /* Is it a static closure? */
     if (!HEAP_ALLOCED(q)) {
-	ASSERT(closure_STATIC(q));
+        ASSERT(closure_STATIC(q));
     } else {
-	ASSERT(!closure_STATIC(q));
+        ASSERT(!closure_STATIC(q));
     }
 }
 
 // check an individual stack object
-StgOffset 
+StgOffset
 checkStackFrame( StgPtr c )
 {
     nat size;
@@ -116,99 +116,99 @@ checkStackFrame( StgPtr c )
     case UNDERFLOW_FRAME:
     case STOP_FRAME:
     case RET_SMALL:
-	size = BITMAP_SIZE(info->i.layout.bitmap);
-	checkSmallBitmap((StgPtr)c + 1, 
-			 BITMAP_BITS(info->i.layout.bitmap), size);
-	return 1 + size;
+        size = BITMAP_SIZE(info->i.layout.bitmap);
+        checkSmallBitmap((StgPtr)c + 1,
+                         BITMAP_BITS(info->i.layout.bitmap), size);
+        return 1 + size;
 
     case RET_BCO: {
-	StgBCO *bco;
-	nat size;
-	bco = (StgBCO *)*(c+1);
-	size = BCO_BITMAP_SIZE(bco);
-	checkLargeBitmap((StgPtr)c + 2, BCO_BITMAP(bco), size);
-	return 2 + size;
+        StgBCO *bco;
+        nat size;
+        bco = (StgBCO *)*(c+1);
+        size = BCO_BITMAP_SIZE(bco);
+        checkLargeBitmap((StgPtr)c + 2, BCO_BITMAP(bco), size);
+        return 2 + size;
     }
 
     case RET_BIG: // large bitmap (> 32 entries)
-	size = GET_LARGE_BITMAP(&info->i)->size;
-	checkLargeBitmap((StgPtr)c + 1, GET_LARGE_BITMAP(&info->i), size);
-	return 1 + size;
+        size = GET_LARGE_BITMAP(&info->i)->size;
+        checkLargeBitmap((StgPtr)c + 1, GET_LARGE_BITMAP(&info->i), size);
+        return 1 + size;
 
     case RET_FUN:
     {
-	StgFunInfoTable *fun_info;
-	StgRetFun *ret_fun;
-
-	ret_fun = (StgRetFun *)c;
-	fun_info = get_fun_itbl(UNTAG_CLOSURE(ret_fun->fun));
-	size = ret_fun->size;
-	switch (fun_info->f.fun_type) {
-	case ARG_GEN:
-	    checkSmallBitmap((StgPtr)ret_fun->payload, 
-			     BITMAP_BITS(fun_info->f.b.bitmap), size);
-	    break;
-	case ARG_GEN_BIG:
-	    checkLargeBitmap((StgPtr)ret_fun->payload,
-			     GET_FUN_LARGE_BITMAP(fun_info), size);
-	    break;
-	default:
-	    checkSmallBitmap((StgPtr)ret_fun->payload,
-			     BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]),
-			     size);
-	    break;
-	}
-	return sizeofW(StgRetFun) + size;
+        StgFunInfoTable *fun_info;
+        StgRetFun *ret_fun;
+
+        ret_fun = (StgRetFun *)c;
+        fun_info = get_fun_itbl(UNTAG_CLOSURE(ret_fun->fun));
+        size = ret_fun->size;
+        switch (fun_info->f.fun_type) {
+        case ARG_GEN:
+            checkSmallBitmap((StgPtr)ret_fun->payload,
+                             BITMAP_BITS(fun_info->f.b.bitmap), size);
+            break;
+        case ARG_GEN_BIG:
+            checkLargeBitmap((StgPtr)ret_fun->payload,
+                             GET_FUN_LARGE_BITMAP(fun_info), size);
+            break;
+        default:
+            checkSmallBitmap((StgPtr)ret_fun->payload,
+                             BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]),
+                             size);
+            break;
+        }
+        return sizeofW(StgRetFun) + size;
     }
 
     default:
-	barf("checkStackFrame: weird activation record found on stack (%p %d).",c,info->i.type);
+        barf("checkStackFrame: weird activation record found on stack (%p %d).",c,info->i.type);
     }
 }
 
 // check sections of stack between update frames
-void 
+void
 checkStackChunk( StgPtr sp, StgPtr stack_end )
 {
     StgPtr p;
 
     p = sp;
     while (p < stack_end) {
-	p += checkStackFrame( p );
+        p += checkStackFrame( p );
     }
     // ASSERT( p == stack_end ); -- HWL
 }
 
 static void
 checkPAP (StgClosure *tagged_fun, StgClosure** payload, StgWord n_args)
-{ 
+{
     StgClosure *fun;
     StgFunInfoTable *fun_info;
-    
+
     fun = UNTAG_CLOSURE(tagged_fun);
     ASSERT(LOOKS_LIKE_CLOSURE_PTR(fun));
     fun_info = get_fun_itbl(fun);
-    
+
     switch (fun_info->f.fun_type) {
     case ARG_GEN:
-	checkSmallBitmap( (StgPtr)payload, 
-			  BITMAP_BITS(fun_info->f.b.bitmap), n_args );
-	break;
+        checkSmallBitmap( (StgPtr)payload,
+                          BITMAP_BITS(fun_info->f.b.bitmap), n_args );
+        break;
     case ARG_GEN_BIG:
-	checkLargeBitmap( (StgPtr)payload, 
-			  GET_FUN_LARGE_BITMAP(fun_info), 
-			  n_args );
-	break;
+        checkLargeBitmap( (StgPtr)payload,
+                          GET_FUN_LARGE_BITMAP(fun_info),
+                          n_args );
+        break;
     case ARG_BCO:
-	checkLargeBitmap( (StgPtr)payload, 
-			  BCO_BITMAP(fun), 
-			  n_args );
-	break;
+        checkLargeBitmap( (StgPtr)payload,
+                          BCO_BITMAP(fun),
+                          n_args );
+        break;
     default:
-	checkSmallBitmap( (StgPtr)payload, 
-			  BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]),
-			  n_args );
-	break;
+        checkSmallBitmap( (StgPtr)payload,
+                          BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]),
+                          n_args );
+        break;
     }
 
     ASSERT(fun_info->f.arity > TAG_MASK ? GET_CLOSURE_TAG(tagged_fun) == 0
@@ -216,7 +216,7 @@ checkPAP (StgClosure *tagged_fun, StgClosure** payload, StgWord n_args)
 }
 
 
-StgOffset 
+StgOffset
 checkClosure( StgClosure* p )
 {
     const StgInfoTable *info;
@@ -226,9 +226,9 @@ checkClosure( StgClosure* p )
     p = UNTAG_CLOSURE(p);
     /* Is it a static closure (i.e. in the data segment)? */
     if (!HEAP_ALLOCED(p)) {
-	ASSERT(closure_STATIC(p));
+        ASSERT(closure_STATIC(p));
     } else {
-	ASSERT(!closure_STATIC(p));
+        ASSERT(!closure_STATIC(p));
     }
 
     info = p->header.info;
@@ -242,12 +242,12 @@ checkClosure( StgClosure* p )
 
     case MVAR_CLEAN:
     case MVAR_DIRTY:
-      { 
-	StgMVar *mvar = (StgMVar *)p;
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(mvar->head));
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(mvar->tail));
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(mvar->value));
-	return sizeofW(StgMVar);
+      {
+        StgMVar *mvar = (StgMVar *)p;
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(mvar->head));
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(mvar->tail));
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(mvar->value));
+        return sizeofW(StgMVar);
       }
 
     case THUNK:
@@ -257,11 +257,11 @@ checkClosure( StgClosure* p )
     case THUNK_0_2:
     case THUNK_2_0:
       {
-	nat i;
-	for (i = 0; i < info->layout.payload.ptrs; i++) {
-	  ASSERT(LOOKS_LIKE_CLOSURE_PTR(((StgThunk *)p)->payload[i]));
-	}
-	return thunk_sizeW_fromITBL(info);
+        nat i;
+        for (i = 0; i < info->layout.payload.ptrs; i++) {
+          ASSERT(LOOKS_LIKE_CLOSURE_PTR(((StgThunk *)p)->payload[i]));
+        }
+        return thunk_sizeW_fromITBL(info);
       }
 
     case FUN:
@@ -287,13 +287,13 @@ checkClosure( StgClosure* p )
     case CONSTR_NOCAF_STATIC:
     case THUNK_STATIC:
     case FUN_STATIC:
-	{
-	    nat i;
-	    for (i = 0; i < info->layout.payload.ptrs; i++) {
-		ASSERT(LOOKS_LIKE_CLOSURE_PTR(p->payload[i]));
-	    }
-	    return sizeW_fromITBL(info);
-	}
+        {
+            nat i;
+            for (i = 0; i < info->layout.payload.ptrs; i++) {
+                ASSERT(LOOKS_LIKE_CLOSURE_PTR(p->payload[i]));
+            }
+            return sizeW_fromITBL(info);
+        }
 
     case BLOCKING_QUEUE:
     {
@@ -304,9 +304,9 @@ checkClosure( StgClosure* p )
         ASSERT(LOOKS_LIKE_CLOSURE_PTR(bq->bh));
 
         ASSERT(get_itbl((StgClosure *)(bq->owner))->type == TSO);
-        ASSERT(bq->queue == (MessageBlackHole*)END_TSO_QUEUE 
+        ASSERT(bq->queue == (MessageBlackHole*)END_TSO_QUEUE
                || bq->queue->header.info == &stg_MSG_BLACKHOLE_info);
-        ASSERT(bq->link == (StgBlockingQueue*)END_TSO_QUEUE || 
+        ASSERT(bq->link == (StgBlockingQueue*)END_TSO_QUEUE ||
                get_itbl((StgClosure *)(bq->link))->type == IND ||
                get_itbl((StgClosure *)(bq->link))->type == BLOCKING_QUEUE);
 
@@ -314,11 +314,11 @@ checkClosure( StgClosure* p )
     }
 
     case BCO: {
-	StgBCO *bco = (StgBCO *)p;
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(bco->instrs));
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(bco->literals));
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(bco->ptrs));
-	return bco_sizeW(bco);
+        StgBCO *bco = (StgBCO *)p;
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(bco->instrs));
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(bco->literals));
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(bco->ptrs));
+        return bco_sizeW(bco);
     }
 
     case IND_STATIC: /* (1, 0) closure */
@@ -330,28 +330,28 @@ checkClosure( StgClosure* p )
        * representative of the actual layout.
        */
       { StgWeak *w = (StgWeak *)p;
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->key));
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->value));
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->finalizer));
-	if (w->link) {
-	  ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->link));
-	}
-	return sizeW_fromITBL(info);
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->key));
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->value));
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->finalizer));
+        if (w->link) {
+          ASSERT(LOOKS_LIKE_CLOSURE_PTR(w->link));
+        }
+        return sizeW_fromITBL(info);
       }
 
     case THUNK_SELECTOR:
-	    ASSERT(LOOKS_LIKE_CLOSURE_PTR(((StgSelector *)p)->selectee));
-	    return THUNK_SELECTOR_sizeW();
+            ASSERT(LOOKS_LIKE_CLOSURE_PTR(((StgSelector *)p)->selectee));
+            return THUNK_SELECTOR_sizeW();
 
     case IND:
-	{ 
-  	    /* we don't expect to see any of these after GC
-	     * but they might appear during execution
-	     */
-	    StgInd *ind = (StgInd *)p;
-	    ASSERT(LOOKS_LIKE_CLOSURE_PTR(ind->indirectee));
-	    return sizeofW(StgInd);
-	}
+        {
+            /* we don't expect to see any of these after GC
+             * but they might appear during execution
+             */
+            StgInd *ind = (StgInd *)p;
+            ASSERT(LOOKS_LIKE_CLOSURE_PTR(ind->indirectee));
+            return sizeofW(StgInd);
+        }
 
     case RET_BCO:
     case RET_SMALL:
@@ -363,45 +363,45 @@ checkClosure( StgClosure* p )
     case ATOMICALLY_FRAME:
     case CATCH_RETRY_FRAME:
     case CATCH_STM_FRAME:
-	    barf("checkClosure: stack frame");
+            barf("checkClosure: stack frame");
 
     case AP:
     {
-	StgAP* ap = (StgAP *)p;
-	checkPAP (ap->fun, ap->payload, ap->n_args);
-	return ap_sizeW(ap);
+        StgAP* ap = (StgAP *)p;
+        checkPAP (ap->fun, ap->payload, ap->n_args);
+        return ap_sizeW(ap);
     }
 
     case PAP:
     {
-	StgPAP* pap = (StgPAP *)p;
-	checkPAP (pap->fun, pap->payload, pap->n_args);
-	return pap_sizeW(pap);
+        StgPAP* pap = (StgPAP *)p;
+        checkPAP (pap->fun, pap->payload, pap->n_args);
+        return pap_sizeW(pap);
     }
 
     case AP_STACK:
-    { 
-	StgAP_STACK *ap = (StgAP_STACK *)p;
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(ap->fun));
-	checkStackChunk((StgPtr)ap->payload, (StgPtr)ap->payload + ap->size);
-	return ap_stack_sizeW(ap);
+    {
+        StgAP_STACK *ap = (StgAP_STACK *)p;
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(ap->fun));
+        checkStackChunk((StgPtr)ap->payload, (StgPtr)ap->payload + ap->size);
+        return ap_stack_sizeW(ap);
     }
 
     case ARR_WORDS:
-	    return arr_words_sizeW((StgArrWords *)p);
+            return arr_words_sizeW((StgArrWords *)p);
 
     case MUT_ARR_PTRS_CLEAN:
     case MUT_ARR_PTRS_DIRTY:
     case MUT_ARR_PTRS_FROZEN:
     case MUT_ARR_PTRS_FROZEN0:
-	{
-	    StgMutArrPtrs* a = (StgMutArrPtrs *)p;
-	    nat i;
-	    for (i = 0; i < a->ptrs; i++) {
-		ASSERT(LOOKS_LIKE_CLOSURE_PTR(a->payload[i]));
-	    }
-	    return mut_arr_ptrs_sizeW(a);
-	}
+        {
+            StgMutArrPtrs* a = (StgMutArrPtrs *)p;
+            nat i;
+            for (i = 0; i < a->ptrs; i++) {
+                ASSERT(LOOKS_LIKE_CLOSURE_PTR(a->payload[i]));
+            }
+            return mut_arr_ptrs_sizeW(a);
+        }
 
     case TSO:
         checkTSO((StgTSO *)p);
@@ -423,9 +423,9 @@ checkClosure( StgClosure* p )
         }
         return sizeofW(StgTRecChunk);
       }
-      
+
     default:
-	    barf("checkClosure (closure type %d)", info->type);
+            barf("checkClosure (closure type %d)", info->type);
     }
 }
 
@@ -451,12 +451,12 @@ void checkHeapChain (bdescr *bd)
                 /* This is the smallest size of closure that can live in the heap */
                 ASSERT( size >= MIN_PAYLOAD_SIZE + sizeofW(StgHeader) );
                 p += size;
-	    
+
                 /* skip over slop */
                 while (p < bd->free &&
                        (*p < 0x1000 || !LOOKS_LIKE_INFO_PTR(*p))) { p++; }
             }
-	}
+        }
     }
 }
 
@@ -505,7 +505,7 @@ checkTSO(StgTSO *tso)
 
     if (tso->what_next == ThreadKilled) {
       /* The garbage collector doesn't bother following any pointers
-       * from dead threads, so don't check sanity here.  
+       * from dead threads, so don't check sanity here.
        */
       return;
     }
@@ -520,10 +520,10 @@ checkTSO(StgTSO *tso)
 
     if (   tso->why_blocked == BlockedOnMVar
         || tso->why_blocked == BlockedOnMVarRead
-	|| tso->why_blocked == BlockedOnBlackHole
-	|| tso->why_blocked == BlockedOnMsgThrowTo
+        || tso->why_blocked == BlockedOnBlackHole
+        || tso->why_blocked == BlockedOnMsgThrowTo
         || tso->why_blocked == NotBlocked
-	) {
+        ) {
         ASSERT(LOOKS_LIKE_CLOSURE_PTR(tso->block_info.closure));
     }
 
@@ -546,7 +546,7 @@ checkGlobalTSOList (rtsBool checkTSOs)
   nat g;
 
   for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
-      for (tso=generations[g].threads; tso != END_TSO_QUEUE; 
+      for (tso=generations[g].threads; tso != END_TSO_QUEUE;
            tso = tso->global_link) {
           ASSERT(LOOKS_LIKE_CLOSURE_PTR(tso));
           ASSERT(get_itbl((StgClosure *)tso)->type == TSO);
@@ -593,8 +593,8 @@ checkMutableList( bdescr *mut_bd, nat gen )
     StgClosure *p;
 
     for (bd = mut_bd; bd != NULL; bd = bd->link) {
-	for (q = bd->start; q < bd->free; q++) {
-	    p = (StgClosure *)*q;
+        for (q = bd->start; q < bd->free; q++) {
+            p = (StgClosure *)*q;
             ASSERT(!HEAP_ALLOCED(p) || Bdescr((P_)p)->gen_no == gen);
             checkClosure(p);
 
@@ -642,13 +642,13 @@ checkStaticObjects ( StgClosure* static_objects )
     info = get_itbl(p);
     switch (info->type) {
     case IND_STATIC:
-      { 
+      {
         StgClosure *indirectee = UNTAG_CLOSURE(((StgIndStatic *)p)->indirectee);
 
-	ASSERT(LOOKS_LIKE_CLOSURE_PTR(indirectee));
-	ASSERT(LOOKS_LIKE_INFO_PTR((StgWord)indirectee->header.info));
-	p = *IND_STATIC_LINK((StgClosure *)p);
-	break;
+        ASSERT(LOOKS_LIKE_CLOSURE_PTR(indirectee));
+        ASSERT(LOOKS_LIKE_INFO_PTR((StgWord)indirectee->header.info));
+        p = *IND_STATIC_LINK((StgClosure *)p);
+        break;
       }
 
     case THUNK_STATIC:
@@ -664,8 +664,8 @@ checkStaticObjects ( StgClosure* static_objects )
       break;
 
     default:
-      barf("checkStaticObjetcs: strange closure %p (%s)", 
-	   p, info_type(p));
+      barf("checkStaticObjetcs: strange closure %p (%s)",
+           p, info_type(p));
     }
   }
 }
@@ -681,14 +681,14 @@ checkNurserySanity (nursery *nursery)
     for (bd = nursery->blocks; bd != NULL; bd = bd->link) {
         ASSERT(bd->gen == g0);
         ASSERT(bd->u.back == prev);
-	prev = bd;
-	blocks += bd->blocks;
+        prev = bd;
+        blocks += bd->blocks;
     }
 
     ASSERT(blocks == nursery->n_blocks);
 }
 
-static void checkGeneration (generation *gen, 
+static void checkGeneration (generation *gen,
                              rtsBool after_major_gc USED_IF_THREADS)
 {
     nat n;
@@ -792,7 +792,7 @@ checkRunQueue(Capability *cap)
 {
     StgTSO *prev, *tso;
     prev = END_TSO_QUEUE;
-    for (tso = cap->run_queue_hd; tso != END_TSO_QUEUE; 
+    for (tso = cap->run_queue_hd; tso != END_TSO_QUEUE;
          prev = tso, tso = tso->_link) {
         ASSERT(prev == END_TSO_QUEUE || prev->_link == tso);
         ASSERT(tso->block_info.prev == prev);
@@ -828,8 +828,8 @@ genBlocks (generation *gen)
 {
     ASSERT(countBlocks(gen->blocks) == gen->n_blocks);
     ASSERT(countBlocks(gen->large_objects) == gen->n_large_blocks);
-    return gen->n_blocks + gen->n_old_blocks + 
-	    countAllocdBlocks(gen->large_objects);
+    return gen->n_blocks + gen->n_old_blocks +
+            countAllocdBlocks(gen->large_objects);
 }
 
 void
@@ -885,7 +885,7 @@ memInventory (rtsBool show)
   for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
       live_blocks += gen_blocks[g];
   }
-  live_blocks += nursery_blocks + 
+  live_blocks += nursery_blocks +
                + retainer_blocks + arena_blocks + exec_blocks;
 
 #define MB(n) (((double)(n) * BLOCK_SIZE_W) / ((1024*1024)/sizeof(W_)))
@@ -894,7 +894,7 @@ memInventory (rtsBool show)
 
   if (show || leak)
   {
-      if (leak) { 
+      if (leak) {
           debugBelch("Memory leak detected:\n");
       } else {
           debugBelch("Memory inventory:\n");
@@ -916,7 +916,7 @@ memInventory (rtsBool show)
       debugBelch("  total        : %5" FMT_Word " blocks (%6.1lf MB)\n",
                  live_blocks + free_blocks, MB(live_blocks+free_blocks));
       if (leak) {
-          debugBelch("\n  in system    : %5" FMT_Word " blocks (%" FMT_Word " MB)\n", 
+          debugBelch("\n  in system    : %5" FMT_Word " blocks (%" FMT_Word " MB)\n",
                      (W_)(mblocks_allocated * BLOCKS_PER_MBLOCK), mblocks_allocated);
       }
   }