[commit: ghc] master: [skip ci] rts: Detabify Exception.cmm (68c45b6)

[git at git.haskell.org]

Repository : ssh://git@git.haskell.org/ghc

On branch  : master
Link       : http://ghc.haskell.org/trac/ghc/changeset/68c45b6563c375cf50d9da187747c57353cfcd0d/ghc

>---------------------------------------------------------------

commit 68c45b6563c375cf50d9da187747c57353cfcd0d
Author: Austin Seipp <austin at well-typed.com>
Date:   Tue Oct 21 16:39:15 2014 -0500

    [skip ci] rts: Detabify Exception.cmm
    
    Signed-off-by: Austin Seipp <austin at well-typed.com>


>---------------------------------------------------------------

68c45b6563c375cf50d9da187747c57353cfcd0d
 rts/Exception.cmm | 54 +++++++++++++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/rts/Exception.cmm b/rts/Exception.cmm
index bc55911..e03d53e 100644
--- a/rts/Exception.cmm
+++ b/rts/Exception.cmm
@@ -21,7 +21,7 @@ import ghczmprim_GHCziTypes_True_closure;
    A thread can request that asynchronous exceptions not be delivered
    ("masked") for the duration of an I/O computation.  The primitives
 
-	maskAsyncExceptions# :: IO a -> IO a
+        maskAsyncExceptions# :: IO a -> IO a
 
    and
 
@@ -30,7 +30,7 @@ import ghczmprim_GHCziTypes_True_closure;
    are used for this purpose.  During a masked section, asynchronous
    exceptions may be unmasked again temporarily:
 
-	unmaskAsyncExceptions# :: IO a -> IO a
+        unmaskAsyncExceptions# :: IO a -> IO a
 
    Furthermore, asynchronous exceptions are masked automatically during
    the execution of an exception handler.  All three of these primitives
@@ -111,7 +111,7 @@ INFO_TABLE_RET(stg_maskAsyncExceptionszh_ret, RET_SMALL, W_ info_ptr)
 {
     StgTSO_flags(CurrentTSO) =
        %lobits32(
-	 TO_W_(StgTSO_flags(CurrentTSO))
+         TO_W_(StgTSO_flags(CurrentTSO))
           | TSO_BLOCKEX | TSO_INTERRUPTIBLE
       );
 
@@ -123,7 +123,7 @@ INFO_TABLE_RET(stg_maskUninterruptiblezh_ret, RET_SMALL, W_ info_ptr)
 {
     StgTSO_flags(CurrentTSO) =
        %lobits32(
-	(TO_W_(StgTSO_flags(CurrentTSO))
+        (TO_W_(StgTSO_flags(CurrentTSO))
           | TSO_BLOCKEX)
           & ~TSO_INTERRUPTIBLE
        );
@@ -204,19 +204,19 @@ stg_unmaskAsyncExceptionszh /* explicit stack */
     /* If exceptions are already unmasked, there's nothing to do */
     if ((TO_W_(StgTSO_flags(CurrentTSO)) & TSO_BLOCKEX) != 0) {
 
-	/* avoid growing the stack unnecessarily */
-	if (Sp(0) == stg_unmaskAsyncExceptionszh_ret_info) {
-	    Sp_adj(1);
-	} else {
-	    Sp_adj(-1);
+        /* avoid growing the stack unnecessarily */
+        if (Sp(0) == stg_unmaskAsyncExceptionszh_ret_info) {
+            Sp_adj(1);
+        } else {
+            Sp_adj(-1);
             if ((TO_W_(StgTSO_flags(CurrentTSO)) & TSO_INTERRUPTIBLE) != 0) {
                 Sp(0) = stg_maskAsyncExceptionszh_ret_info;
             } else {
                 Sp(0) = stg_maskUninterruptiblezh_ret_info;
             }
-	}
+        }
 
-	StgTSO_flags(CurrentTSO) = %lobits32(
+        StgTSO_flags(CurrentTSO) = %lobits32(
             TO_W_(StgTSO_flags(CurrentTSO)) & ~(TSO_BLOCKEX|TSO_INTERRUPTIBLE));
 
         /* Eagerly raise a masked exception, if there is one */
@@ -244,12 +244,12 @@ stg_unmaskAsyncExceptionszh /* explicit stack */
             if (r != 0::CInt) {
                 if (StgTSO_what_next(CurrentTSO) == ThreadKilled::I16) {
                     jump stg_threadFinished [];
-	        } else {
-	            LOAD_THREAD_STATE();
-	            ASSERT(StgTSO_what_next(CurrentTSO) == ThreadRunGHC::I16);
+                } else {
+                    LOAD_THREAD_STATE();
+                    ASSERT(StgTSO_what_next(CurrentTSO) == ThreadRunGHC::I16);
                     R1 = io;
                     jump %ENTRY_CODE(Sp(0)) [R1];
-	        }
+                }
             } else {
                 /* we'll just call R1 directly, below */
                 Sp_adj(3);
@@ -306,7 +306,7 @@ stg_killThreadzh (P_ target, P_ exception)
     } else {
         W_ msg;
 
-	(msg) = ccall throwTo(MyCapability() "ptr",
+        (msg) = ccall throwTo(MyCapability() "ptr",
                                     CurrentTSO "ptr",
                                     target "ptr",
                                     exception "ptr");
@@ -316,9 +316,9 @@ stg_killThreadzh (P_ target, P_ exception)
         } else {
             StgTSO_why_blocked(CurrentTSO) = BlockedOnMsgThrowTo;
             StgTSO_block_info(CurrentTSO) = msg;
-	    // we must block, and unlock the message before returning
+            // we must block, and unlock the message before returning
             jump stg_block_throwto (target, exception);
-	}
+        }
     }
 }
 
@@ -535,19 +535,19 @@ retry_pop_stack:
     }
 
     if (frame_type == STOP_FRAME) {
-	/*
-	 * We've stripped the entire stack, the thread is now dead.
-	 * We will leave the stack in a GC'able state, see the stg_stop_thread
-	 * entry code in StgStartup.cmm.
-	 */
+        /*
+         * We've stripped the entire stack, the thread is now dead.
+         * We will leave the stack in a GC'able state, see the stg_stop_thread
+         * entry code in StgStartup.cmm.
+         */
         W_ stack;
         stack = StgTSO_stackobj(CurrentTSO);
         Sp = stack + OFFSET_StgStack_stack
                 + WDS(TO_W_(StgStack_stack_size(stack))) - WDS(2);
-	Sp(1) = exception;	/* save the exception */
-	Sp(0) = stg_enter_info; /* so that GC can traverse this stack */
-	StgTSO_what_next(CurrentTSO) = ThreadKilled::I16;
-	SAVE_THREAD_STATE();	/* inline! */
+        Sp(1) = exception;      /* save the exception */
+        Sp(0) = stg_enter_info; /* so that GC can traverse this stack */
+        StgTSO_what_next(CurrentTSO) = ThreadKilled::I16;
+        SAVE_THREAD_STATE();    /* inline! */
 
         jump stg_threadFinished [];
     }