GHC/ConsoleHandler.hs

{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE CPP #-}

-----------------------------------------------------------------------------
-- |
-- Module : GHC.ConsoleHandler
-- Copyright : (c) The University of Glasgow
-- License : see libraries/base/LICENSE
-- 
-- Maintainer : cvs-ghc@haskell.org
-- Stability : internal
-- Portability : non-portable (GHC extensions)
--
-- NB. the contents of this module are only available on Windows.
--
-- Installing Win32 console handlers.
-- 
-----------------------------------------------------------------------------

module GHC.ConsoleHandler
#if !defined(mingw32_HOST_OS) && !defined(__HADDOCK__)
 where

import GHC.Base () -- dummy dependency
#else /* whole file */
 ( Handler(..)
 , installHandler
 , ConsoleEvent(..)
 , flushConsole
 ) where

{-
#include "rts/Signals.h"

Note: this #include is inside a Haskell comment
 but it brings into scope some #defines
 that are used by CPP below (eg STG_SIG_DFL).
 Having it in a comment means that there's no
 danger that C-like crap will be misunderstood
 by GHC
-}

import GHC.Base
import Foreign
import Foreign.C
import GHC.IO.FD
import GHC.IO.Exception
import GHC.IO.Handle.Types
import GHC.IO.Handle.Internals
import GHC.Conc
import Control.Concurrent.MVar
import Data.Typeable

data Handler
 = Default
 | Ignore
 | Catch (ConsoleEvent -> IO ())

-- | Allows Windows console events to be caught and handled. To
-- handle a console event, call 'installHandler' passing the
-- appropriate 'Handler' value. When the event is received, if the
-- 'Handler' value is @Catch f@, then a new thread will be spawned by
-- the system to execute @f e@, where @e@ is the 'ConsoleEvent' that
-- was received.
--
-- Note that console events can only be received by an application
-- running in a Windows console. Certain environments that look like consoles
-- do not support console events, these include:
--
-- * Cygwin shells with @CYGWIN=tty@ set (if you don't set @CYGWIN=tty@,
-- then a Cygwin shell behaves like a Windows console).
-- * Cygwin xterm and rxvt windows
-- * MSYS rxvt windows
--
-- In order for your application to receive console events, avoid running
-- it in one of these environments.
--
installHandler :: Handler -> IO Handler
installHandler handler
 | threaded =
 modifyMVar win32ConsoleHandler $ \old_h -> do
 (new_h,rc) <-
 case handler of
 Default -> do
 r <- rts_installHandler STG_SIG_DFL nullPtr
 return (no_handler, r)
 Ignore -> do
 r <- rts_installHandler STG_SIG_IGN nullPtr
 return (no_handler, r)
 Catch h -> do
 r <- rts_installHandler STG_SIG_HAN nullPtr
 return (h, r)
 prev_handler <-
 case rc of
 STG_SIG_DFL -> return Default
 STG_SIG_IGN -> return Ignore
 STG_SIG_HAN -> return (Catch old_h)
 _ -> error "installHandler: Bad threaded rc value"
 return (new_h, prev_handler)

 | otherwise =
 alloca $ \ p_sp -> do
 rc <-
 case handler of
 Default -> rts_installHandler STG_SIG_DFL p_sp
 Ignore -> rts_installHandler STG_SIG_IGN p_sp
 Catch h -> do
 v <- newStablePtr (toHandler h)
 poke p_sp v
 rts_installHandler STG_SIG_HAN p_sp
 case rc of
 STG_SIG_DFL -> return Default
 STG_SIG_IGN -> return Ignore
 STG_SIG_HAN -> do
 osptr <- peek p_sp
 oldh <- deRefStablePtr osptr
 -- stable pointer is no longer in use, free it.
 freeStablePtr osptr
 return (Catch (\ ev -> oldh (fromConsoleEvent ev)))
 _ -> error "installHandler: Bad non-threaded rc value"
 where
 fromConsoleEvent ev =
 case ev of
 ControlC -> 0 {- CTRL_C_EVENT-}
 Break -> 1 {- CTRL_BREAK_EVENT-}
 Close -> 2 {- CTRL_CLOSE_EVENT-}
 Logoff -> 5 {- CTRL_LOGOFF_EVENT-}
 Shutdown -> 6 {- CTRL_SHUTDOWN_EVENT-}

 toHandler hdlr ev = do
 case toWin32ConsoleEvent ev of
 -- see rts/win32/ConsoleHandler.c for comments as to why
 -- rts_ConsoleHandlerDone is called here.
 Just x -> hdlr x >> rts_ConsoleHandlerDone ev
 Nothing -> return () -- silently ignore..

 no_handler = error "win32ConsoleHandler"

foreign import ccall "rtsSupportsBoundThreads" threaded :: Bool

foreign import ccall unsafe "RtsExternal.h rts_InstallConsoleEvent" 
 rts_installHandler :: CInt -> Ptr (StablePtr (CInt -> IO ())) -> IO CInt
foreign import ccall unsafe "RtsExternal.h rts_ConsoleHandlerDone"
 rts_ConsoleHandlerDone :: CInt -> IO ()


flushConsole :: Handle -> IO ()
flushConsole h =
 wantReadableHandle_ "flushConsole" h $ \ Handle__{haDevice=dev} ->
 case cast dev of
 Nothing -> ioException $
 IOError (Just h) IllegalOperation "flushConsole"
 "handle is not a file descriptor" Nothing Nothing
 Just fd -> do
 throwErrnoIfMinus1Retry_ "flushConsole" $
 flush_console_fd (fdFD fd)

foreign import ccall unsafe "consUtils.h flush_input_console__"
 flush_console_fd :: CInt -> IO CInt

#endif /* mingw32_HOST_OS */