{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE UnliftedFFITypes #-}
{-# OPTIONS_HADDOCK not-home #-}
module GHC.TopHandler (
runMainIO, runIO, runIOFastExit, runNonIO,
topHandler, topHandlerFastExit,
reportStackOverflow, reportError,
flushStdHandles
) where
#include "HsBaseConfig.h"
import Control.Exception
import Data.Maybe
import Foreign
import Foreign.C
import GHC.Base
import GHC.Conc hiding (throwTo)
import GHC.Real
import GHC.IO
import GHC.IO.Handle
import GHC.IO.StdHandles
import GHC.IO.Exception
import GHC.Weak
#if defined(mingw32_HOST_OS)
import GHC.ConsoleHandler
#else
import Data.Dynamic (toDyn)
#endif
foreign import ccall unsafe "rts_setMainThread"
setMainThread :: Weak# ThreadId -> IO ()
runMainIO :: IO a -> IO a
runMainIO :: forall a. IO a -> IO a
runMainIO IO a
main =
do
ThreadId
main_thread_id <- IO ThreadId
myThreadId
Weak ThreadId
weak_tid <- ThreadId -> IO (Weak ThreadId)
mkWeakThreadId ThreadId
main_thread_id
case Weak ThreadId
weak_tid of (Weak Weak# ThreadId
w) -> Weak# ThreadId -> IO ()
setMainThread Weak# ThreadId
w
IO () -> IO ()
install_interrupt_handler forall a b. (a -> b) -> a -> b
$ do
Maybe ThreadId
m <- forall v. Weak v -> IO (Maybe v)
deRefWeak Weak ThreadId
weak_tid
case Maybe ThreadId
m of
Maybe ThreadId
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
Just ThreadId
tid -> forall e. Exception e => ThreadId -> e -> IO ()
throwTo ThreadId
tid (forall e. Exception e => e -> SomeException
toException AsyncException
UserInterrupt)
IO a
main
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
`catch`
forall a. SomeException -> IO a
topHandler
install_interrupt_handler :: IO () -> IO ()
#if defined(mingw32_HOST_OS)
install_interrupt_handler handler = do
_ <- GHC.ConsoleHandler.installHandler $
Catch $ \event ->
case event of
ControlC -> handler
Break -> handler
Close -> handler
_ -> return ()
return ()
#else
#include "rts/Signals.h"
install_interrupt_handler :: IO () -> IO ()
install_interrupt_handler IO ()
handler = do
let sig :: CInt
sig = CONST_SIGINT :: CInt
Maybe (HandlerFun, Dynamic)
_ <- CInt
-> Maybe (HandlerFun, Dynamic) -> IO (Maybe (HandlerFun, Dynamic))
setHandler CInt
sig (forall a. a -> Maybe a
Just (forall a b. a -> b -> a
const IO ()
handler, forall a. Typeable a => a -> Dynamic
toDyn IO ()
handler))
CInt
_ <- CInt -> CInt -> Ptr () -> IO CInt
stg_sig_install CInt
sig STG_SIG_RST nullPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall unsafe
stg_sig_install
:: CInt
-> CInt
-> Ptr ()
-> IO CInt
#endif
runIO :: IO a -> IO a
runIO :: forall a. IO a -> IO a
runIO IO a
main = forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catch IO a
main forall a. SomeException -> IO a
topHandler
runIOFastExit :: IO a -> IO a
runIOFastExit :: forall a. IO a -> IO a
runIOFastExit IO a
main = forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catch IO a
main forall a. SomeException -> IO a
topHandlerFastExit
runNonIO :: a -> IO a
runNonIO :: forall a. a -> IO a
runNonIO a
a = forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catch (a
a seq :: forall a b. a -> b -> b
`seq` forall (m :: * -> *) a. Monad m => a -> m a
return a
a) forall a. SomeException -> IO a
topHandler
topHandler :: SomeException -> IO a
topHandler :: forall a. SomeException -> IO a
topHandler SomeException
err = forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catch (forall a. (Int -> IO a) -> SomeException -> IO a
real_handler forall a. Int -> IO a
safeExit SomeException
err) forall a. SomeException -> IO a
topHandler
topHandlerFastExit :: SomeException -> IO a
topHandlerFastExit :: forall a. SomeException -> IO a
topHandlerFastExit SomeException
err =
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catchException (forall a. (Int -> IO a) -> SomeException -> IO a
real_handler forall a. Int -> IO a
fastExit SomeException
err) forall a. SomeException -> IO a
topHandlerFastExit
real_handler :: (Int -> IO a) -> SomeException -> IO a
real_handler :: forall a. (Int -> IO a) -> SomeException -> IO a
real_handler Int -> IO a
exit SomeException
se = do
IO ()
flushStdHandles
case forall e. Exception e => SomeException -> Maybe e
fromException SomeException
se of
Just AsyncException
StackOverflow -> do
IO ()
reportStackOverflow
Int -> IO a
exit Int
2
Just AsyncException
UserInterrupt -> forall a. IO a
exitInterrupted
Just AsyncException
HeapOverflow -> do
IO ()
reportHeapOverflow
Int -> IO a
exit Int
251
Maybe AsyncException
_ -> case forall e. Exception e => SomeException -> Maybe e
fromException SomeException
se of
Just ExitCode
ExitSuccess -> Int -> IO a
exit Int
0
Just (ExitFailure Int
n) -> Int -> IO a
exit Int
n
Maybe ExitCode
_ -> forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catch (case forall e. Exception e => SomeException -> Maybe e
fromException SomeException
se of
Just IOError{ ioe_type :: IOError -> IOErrorType
ioe_type = IOErrorType
ResourceVanished,
ioe_errno :: IOError -> Maybe CInt
ioe_errno = Just CInt
ioe,
ioe_handle :: IOError -> Maybe Handle
ioe_handle = Just Handle
hdl }
| CInt -> Errno
Errno CInt
ioe forall a. Eq a => a -> a -> Bool
== Errno
ePIPE, Handle
hdl forall a. Eq a => a -> a -> Bool
== Handle
stdout -> Int -> IO a
exit Int
0
Maybe IOError
_ -> do SomeException -> IO ()
reportError SomeException
se
Int -> IO a
exit Int
1
) (forall a. (Int -> IO a) -> IOError -> IO a
disasterHandler Int -> IO a
exit)
foreign import ccall unsafe "HsBase.h errorBelch2"
errorBelch :: CString -> CString -> IO ()
disasterHandler :: (Int -> IO a) -> IOError -> IO a
disasterHandler :: forall a. (Int -> IO a) -> IOError -> IO a
disasterHandler Int -> IO a
exit IOError
_ =
forall a. String -> (CString -> IO a) -> IO a
withCAString String
"%s" forall a b. (a -> b) -> a -> b
$ \CString
fmt ->
forall a. String -> (CString -> IO a) -> IO a
withCAString String
msgStr forall a b. (a -> b) -> a -> b
$ \CString
msg ->
CString -> CString -> IO ()
errorBelch CString
fmt CString
msg forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> IO a
exit Int
1
where
msgStr :: String
msgStr =
String
"encountered an exception while trying to report an exception.\n" forall a. [a] -> [a] -> [a]
++
String
"One possible reason for this is that we failed while trying to " forall a. [a] -> [a] -> [a]
++
String
"encode an error message. Check that your locale is configured " forall a. [a] -> [a] -> [a]
++
String
"properly."
flushStdHandles :: IO ()
flushStdHandles :: IO ()
flushStdHandles = do
Handle -> IO ()
hFlush Handle
stdout forall a. IO a -> (forall e. Exception e => e -> IO a) -> IO a
`catchAny` \e
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
Handle -> IO ()
hFlush Handle
stderr forall a. IO a -> (forall e. Exception e => e -> IO a) -> IO a
`catchAny` \e
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
safeExit, fastExit :: Int -> IO a
safeExit :: forall a. Int -> IO a
safeExit = forall a. CInt -> Int -> IO a
exitHelper CInt
useSafeExit
fastExit :: forall a. Int -> IO a
fastExit = forall a. CInt -> Int -> IO a
exitHelper CInt
useFastExit
unreachable :: IO a
unreachable :: forall a. IO a
unreachable = forall a. String -> IO a
failIO String
"If you can read this, shutdownHaskellAndExit did not exit."
exitHelper :: CInt -> Int -> IO a
#if defined(mingw32_HOST_OS)
exitHelper exitKind r =
shutdownHaskellAndExit (fromIntegral r) exitKind >> unreachable
#else
exitHelper :: forall a. CInt -> Int -> IO a
exitHelper CInt
exitKind Int
r
| Int
r forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
r forall a. Ord a => a -> a -> Bool
<= Int
255
= CInt -> CInt -> IO ()
shutdownHaskellAndExit (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
r) CInt
exitKind forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall a. IO a
unreachable
| Int
r forall a. Ord a => a -> a -> Bool
>= -Int
127 Bool -> Bool -> Bool
&& Int
r forall a. Ord a => a -> a -> Bool
<= -Int
1
= CInt -> CInt -> IO ()
shutdownHaskellAndSignal (forall a b. (Integral a, Num b) => a -> b
fromIntegral (-Int
r)) CInt
exitKind forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall a. IO a
unreachable
| Bool
otherwise
= CInt -> CInt -> IO ()
shutdownHaskellAndExit CInt
0xff CInt
exitKind forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall a. IO a
unreachable
foreign import ccall "shutdownHaskellAndSignal"
shutdownHaskellAndSignal :: CInt -> CInt -> IO ()
#endif
exitInterrupted :: IO a
exitInterrupted :: forall a. IO a
exitInterrupted =
#if defined(mingw32_HOST_OS)
safeExit 252
#else
forall a. Int -> IO a
safeExit (-CONST_SIGINT)
#endif
foreign import ccall "Rts.h shutdownHaskellAndExit"
shutdownHaskellAndExit :: CInt -> CInt -> IO ()
useFastExit, useSafeExit :: CInt
useFastExit :: CInt
useFastExit = CInt
1
useSafeExit :: CInt
useSafeExit = CInt
0