X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=Control%2FException.hs;h=cb4ba3e98f7ba384e24f49e051cf8a969bc69018;hb=819adca5f17b40ee129e4a30edf685f817febbf9;hp=dd6b6fdf9e8c7b8d2ce8b2b63800bbf50e46d8e9;hpb=e6593a2d027bf4beb737b6760a1a6e024bc74982;p=haskell-directory.git

diff --git a/Control/Exception.hs b/Control/Exception.hs
index dd6b6fd..cb4ba3e 100644
--- a/Control/Exception.hs
+++ b/Control/Exception.hs
@@ -117,7 +117,7 @@ import GHC.Base		( assert )
 import GHC.Exception 	as ExceptionBase hiding (catch)
 import GHC.Conc		( throwTo, ThreadId )
 import Data.IORef	( IORef, newIORef, readIORef, writeIORef )
-import Foreign.C.String ( CString, withCStringLen )
+import Foreign.C.String ( CString, withCString )
 import System.IO	( stdout, hFlush )
 #endif
 
@@ -130,13 +130,6 @@ import System.IO.Error	hiding ( catch, try )
 import System.IO.Unsafe (unsafePerformIO)
 import Data.Dynamic
 
-#include "Typeable.h"
-INSTANCE_TYPEABLE0(Exception,exceptionTc,"Exception")
-INSTANCE_TYPEABLE0(IOException,ioExceptionTc,"IOException")
-INSTANCE_TYPEABLE0(ArithException,arithExceptionTc,"ArithException")
-INSTANCE_TYPEABLE0(ArrayException,arrayExceptionTc,"ArrayException")
-INSTANCE_TYPEABLE0(AsyncException,asyncExceptionTc,"AsyncException")
-
 -----------------------------------------------------------------------------
 -- Catching exceptions
 
@@ -169,10 +162,9 @@ INSTANCE_TYPEABLE0(AsyncException,asyncExceptionTc,"AsyncException")
 -- might be a 'ThreadKilled', for example).  In this case it is usually better
 -- to use 'catchJust' and select the kinds of exceptions to catch.
 --
--- Also note that the "Prelude" also exports a
--- function called 'Prelude.catch' which has the same type as
--- 'Control.Exception.catch', the difference being that the
--- "Prelude" version only catches the IO and user
+-- Also note that the "Prelude" also exports a function called
+-- 'Prelude.catch' with a similar type to 'Control.Exception.catch',
+-- except that the "Prelude" version only catches the IO and user
 -- families of exceptions (as required by Haskell 98).  We recommend
 -- either hiding the "Prelude" version of
 -- 'Prelude.catch' when importing
@@ -244,6 +236,11 @@ mapException f v = unsafePerformIO (catch (evaluate v)
 -- to re-throw the exception after performing whatever cleanup is needed.
 -- Otherwise, 'tryJust' is generally considered to be better.
 --
+-- Also note that "System.IO.Error" also exports a function called
+-- 'System.IO.Error.try' with a similar type to 'Control.Exception.try',
+-- except that it catches only the IO and user families of exceptions
+-- (as required by the Haskell 98 @IO@ module).
+
 try :: IO a -> IO (Either Exception a)
 try a = catch (a >>= \ v -> return (Right v)) (\e -> return (Left e))
 
@@ -470,23 +467,6 @@ Similar arguments apply for other interruptible operations like
 'System.IO.openFile'.
 -}
 
--- -----------------------------------------------------------------------------
--- Assert
-
-#ifdef __HADDOCK__
--- | If the first argument evaluates to 'True', then the result is the
--- second argument.  Otherwise an 'AssertionFailed' exception is raised,
--- containing a 'String' with the source file and line number of the
--- call to assert.
---
--- Assertions can normally be turned on or off with a compiler flag
--- (for GHC, assertions are normally on unless the @-fignore-asserts@
--- option is give).  When assertions are turned off, the first
--- argument to 'assert' is ignored, and the second argument is
--- returned as the result.
-assert :: Bool -> a -> a
-#endif
-
 #ifndef __GLASGOW_HASKELL__
 assert :: Bool -> a -> a
 assert True x = x
@@ -506,10 +486,11 @@ uncaughtExceptionHandler = unsafePerformIO (newIORef defaultHandler)
                Deadlock    -> "no threads to run:  infinite loop or deadlock?"
                ErrorCall s -> s
                other       -> showsPrec 0 other "\n"
-         withCStringLen ("Fail: "++msg) $ \(cstr,len) -> writeErrString cstr len
-         
-foreign import ccall unsafe "writeErrString__"
-	writeErrString :: CString -> Int -> IO ()
+         withCString "%s" $ \cfmt ->
+          withCString msg $ \cmsg ->
+            errorBelch cfmt cmsg
+
+foreign import ccall unsafe errorBelch :: CString -> CString -> IO ()
 
 setUncaughtExceptionHandler :: (Exception -> IO ()) -> IO ()
 setUncaughtExceptionHandler = writeIORef uncaughtExceptionHandler