mark System.IO.openTempFile as non-portable in haddocks

[haskell-directory.git] / GHC / TopHandler.lhs

diff --git a/GHC/TopHandler.lhs b/GHC/TopHandler.lhs
index 4785f61..44ac461 100644 (file)
--- a/GHC/TopHandler.lhs
+++ b/GHC/TopHandler.lhs
@@ -68,27 +68,31 @@ runNonIO :: a -> IO a
 runNonIO a = catchException (a `seq` return a) topHandler
 
 topHandler :: Exception -> IO a
-topHandler err = catchException (real_handler err) topHandler
+topHandler err = catchException (real_handler safeExit err) topHandler
+
+topHandlerFastExit :: Exception -> IO a
+topHandlerFastExit err = 
+  catchException (real_handler fastExit err) topHandlerFastExit
 
 -- Make sure we handle errors while reporting the error!
 -- (e.g. evaluating the string passed to 'error' might generate
 --  another error, etc.)
 --
-real_handler :: Exception -> IO a
-real_handler ex =
+real_handler :: (Int -> IO a) -> Exception -> IO a
+real_handler exit exn =
   cleanUp >>
-  case ex of
+  case exn of
        AsyncException StackOverflow -> do
           reportStackOverflow
-          safeExit 2
+          exit 2
 
        -- only the main thread gets ExitException exceptions
-       ExitException ExitSuccess     -> safeExit 0
-       ExitException (ExitFailure n) -> safeExit n
+       ExitException ExitSuccess     -> exit 0
+       ExitException (ExitFailure n) -> exit n
 
        other -> do
           reportError other
-          safeExit 1
+          exit 1
           
 
 reportStackOverflow :: IO a
@@ -119,10 +123,16 @@ cleanUpAndExit r = do cleanUp; safeExit r
 -- we have to use unsafeCoerce# to get the 'IO a' result type, since the
 -- compiler doesn't let us declare that as the result type of a foreign export.
 safeExit :: Int -> IO a
-safeExit r = unsafeCoerce# (shutdownHaskellAndExit r)
+safeExit r = unsafeCoerce# (shutdownHaskellAndExit $ fromIntegral r)
 
 -- NOTE: shutdownHaskellAndExit must be called "safe", because it *can*
 -- re-enter Haskell land through finalizers.
-foreign import ccall "shutdownHaskellAndExit" 
-  shutdownHaskellAndExit :: Int -> IO ()
+foreign import ccall "Rts.h shutdownHaskellAndExit"
+  shutdownHaskellAndExit :: CInt -> IO ()
+
+fastExit :: Int -> IO a
+fastExit r = unsafeCoerce# (stg_exit (fromIntegral r))
+
+foreign import ccall "Rts.h stg_exit"
+  stg_exit :: CInt -> IO ()
 \end{code}