[project @ 2004-11-06 10:45:46 by panne]

[ghc-base.git] / Control / Exception.hs

diff --git a/Control/Exception.hs b/Control/Exception.hs
index a8e9dd6..aed144b 100644 (file)
--- a/Control/Exception.hs
+++ b/Control/Exception.hs
@@ -107,8 +107,8 @@ module Control.Exception (
        finally,        -- :: IO a -> IO b -> IO a
        
 #ifdef __GLASGOW_HASKELL__
-       setUncatchedExceptionHandler,      -- :: (Exception -> IO ()) -> IO ()
-       getUncatchedExceptionHandler       -- :: IO (Exception -> IO ())
+       setUncaughtExceptionHandler,      -- :: (Exception -> IO ()) -> IO ()
+       getUncaughtExceptionHandler       -- :: IO (Exception -> IO ())
 #endif
   ) where
 
@@ -116,16 +116,15 @@ module Control.Exception (
 import GHC.Base                ( assert )
 import GHC.Exception   as ExceptionBase hiding (catch)
 import GHC.Conc                ( throwTo, ThreadId )
-import GHC.IOBase      ( IO(..), IORef(..), newIORef, readIORef, writeIORef )
-import GHC.Handle       ( stdout, hFlush )
+import Data.IORef      ( IORef, newIORef, readIORef, writeIORef )
+import Foreign.C.String ( CString, withCStringLen )
+import System.IO       ( stdout, hFlush )
 #endif
 
 #ifdef __HUGS__
 import Hugs.Exception  as ExceptionBase
 #endif
 
-import Foreign.C.String ( CString, withCStringLen )
-
 import Prelude                 hiding ( catch )
 import System.IO.Error hiding ( catch, try )
 import System.IO.Unsafe (unsafePerformIO)
@@ -221,25 +220,6 @@ handleJust :: (Exception -> Maybe b) -> (b -> IO a) -> IO a -> IO a
 handleJust p =  flip (catchJust p)
 
 -----------------------------------------------------------------------------
--- evaluate
-
--- | Forces its argument to be evaluated, and returns the result in
--- the 'IO' monad.  It can be used to order evaluation with respect to
--- other 'IO' operations; its semantics are given by
---
--- >   evaluate undefined `seq` return ()  ==> return ()
--- >   catch (evaluate undefined) (\e -> return ())  ==> return ()
---
--- NOTE: @(evaluate a)@ is /not/ the same as @(a \`seq\` return a)@.
-#ifdef __GLASGOW_HASKELL__
-evaluate :: a -> IO a
-evaluate a = IO $ \s -> case a `seq` () of () -> (# s, a #)
-       -- NB. can't write  
-       --      a `seq` (# s, a #)
-       -- because we can't have an unboxed tuple as a function argument
-#endif
-
------------------------------------------------------------------------------
 -- 'mapException'
 
 -- | This function maps one exception into another as proposed in the
@@ -515,9 +495,9 @@ assert False _ = throw (AssertionFailed "")
 
 
 #ifdef __GLASGOW_HASKELL__
-{-# NOINLINE uncatchedExceptionHandler #-}
-uncatchedExceptionHandler :: IORef (Exception -> IO ())
-uncatchedExceptionHandler = unsafePerformIO (newIORef defaultHandler)
+{-# NOINLINE uncaughtExceptionHandler #-}
+uncaughtExceptionHandler :: IORef (Exception -> IO ())
+uncaughtExceptionHandler = unsafePerformIO (newIORef defaultHandler)
    where
       defaultHandler :: Exception -> IO ()
       defaultHandler ex = do
@@ -531,9 +511,9 @@ uncatchedExceptionHandler = unsafePerformIO (newIORef defaultHandler)
 foreign import ccall unsafe "writeErrString__"
        writeErrString :: CString -> Int -> IO ()
 
-setUncatchedExceptionHandler :: (Exception -> IO ()) -> IO ()
-setUncatchedExceptionHandler = writeIORef uncatchedExceptionHandler
+setUncaughtExceptionHandler :: (Exception -> IO ()) -> IO ()
+setUncaughtExceptionHandler = writeIORef uncaughtExceptionHandler
 
-getUncatchedExceptionHandler :: IO (Exception -> IO ())
-getUncatchedExceptionHandler = readIORef uncatchedExceptionHandler
-#endif
\ No newline at end of file
+getUncaughtExceptionHandler :: IO (Exception -> IO ())
+getUncaughtExceptionHandler = readIORef uncaughtExceptionHandler
+#endif