import qualified GHC
import Outputable hiding (printForUser, printForUserPartWay)
-import qualified Pretty
import qualified Outputable
import Panic hiding (showException)
import Util
import Linker
import StaticFlags
import qualified MonadUtils
-import qualified ErrUtils
import Exception
-import Data.Maybe
+-- import Data.Maybe
import Numeric
import Data.Array
-import Data.Char
+-- import Data.Char
import Data.Int ( Int64 )
import Data.IORef
-import Data.List
+-- import Data.List
import System.CPUTime
import System.Environment
import System.IO
import System.Console.Haskeline (CompletionFunc, InputT)
import qualified System.Console.Haskeline as Haskeline
-import System.Console.Haskeline.Encoding
import Control.Monad.Trans as Trans
-import qualified Data.ByteString as B
-----------------------------------------------------------------------------
-- GHCi monad
-- remember is here:
last_command :: Maybe Command,
cmdqueue :: [String],
- remembered_ctx :: [(CtxtCmd, [String], [String])],
+ remembered_ctx :: [CtxtCmd],
-- we remember the :module commands between :loads, so that
-- on a :reload we can replay them. See bugs #2049,
-- \#1873, #1360. Previously we tried to remember modules that
}
data CtxtCmd
- = SetContext
- | AddModules
- | RemModules
+ = SetContext [String] [String]
+ | AddModules [String] [String]
+ | RemModules [String] [String]
+ | Import String
type TickArray = Array Int [(BreakIndex,SrcSpan)]
gcatch m h = GHCi $ \r -> unGHCi m r `gcatch` (\e -> unGHCi (h e) r)
gblock (GHCi m) = GHCi $ \r -> gblock (m r)
gunblock (GHCi m) = GHCi $ \r -> gunblock (m r)
+ gmask f =
+ GHCi $ \s -> gmask $ \io_restore ->
+ let
+ g_restore (GHCi m) = GHCi $ \s' -> io_restore (m s')
+ in
+ unGHCi (f g_restore) s
instance WarnLogMonad GHCi where
setWarnings warns = liftGhc $ setWarnings warns
catch = gcatch
block = gblock
unblock = gunblock
+ -- XXX when Haskeline's MonadException changes, we can drop our
+ -- deprecated block/unblock methods
instance ExceptionMonad (InputT GHCi) where
- gcatch = Haskeline.catch
- gblock = Haskeline.block
- gunblock = Haskeline.unblock
+ gcatch = Haskeline.catch
+ gmask f = Haskeline.block (f Haskeline.unblock) -- slightly wrong
+ gblock = Haskeline.block
+ gunblock = Haskeline.unblock
-- for convenience...
getPrelude :: GHCi Module
io :: IO a -> GHCi a
io = MonadUtils.liftIO
-printForUser :: SDoc -> GHCi ()
+printForUser :: GhcMonad m => SDoc -> m ()
printForUser doc = do
unqual <- GHC.getPrintUnqual
- io $ Outputable.printForUser stdout unqual doc
-
-printForUser' :: SDoc -> InputT GHCi ()
-printForUser' doc = do
- unqual <- GHC.getPrintUnqual
- Haskeline.outputStrLn $ showSDocForUser unqual doc
+ MonadUtils.liftIO $ Outputable.printForUser stdout unqual doc
printForUserPartWay :: SDoc -> GHCi ()
printForUserPartWay doc = do
unqual <- GHC.getPrintUnqual
io $ Outputable.printForUserPartWay stdout opt_PprUserLength unqual doc
--- We set log_action to write encoded output.
--- This fails whenever GHC tries to mention an (already encoded) filename,
--- but I don't know how to work around that.
-setLogAction :: InputT GHCi ()
-setLogAction = do
- encoder <- getEncoder
- dflags <- GHC.getSessionDynFlags
- GHC.setSessionDynFlags dflags {log_action = logAction encoder}
- return ()
- where
- logAction encoder severity srcSpan style msg = case severity of
- GHC.SevInfo -> printEncErrs encoder (msg style)
- GHC.SevFatal -> printEncErrs encoder (msg style)
- _ -> do
- hPutChar stderr '\n'
- printEncErrs encoder (ErrUtils.mkLocMessage srcSpan msg style)
- printEncErrs encoder doc = do
- str <- encoder (Pretty.showDocWith Pretty.PageMode doc)
- B.hPutStrLn stderr str
- hFlush stderr
-
runStmt :: String -> GHC.SingleStep -> GHCi GHC.RunResult
runStmt expr step = do
st <- getGHCiState
GHC.runStmt expr step
resume :: (SrcSpan -> Bool) -> GHC.SingleStep -> GHCi GHC.RunResult
-resume canLogSpan step = GHC.resume canLogSpan step
+resume canLogSpan step = do
+ st <- getGHCiState
+ reifyGHCi $ \x ->
+ withProgName (progname st) $
+ withArgs (args st) $
+ reflectGHCi x $ do
+ GHC.resume canLogSpan step
-- --------------------------------------------------------------------------
-- timing & statistics
-- ToDo: we should really look up these names properly, but
-- it's a fiddle and not all the bits are exposed via the GHC
-- interface.
- mb_stdin_ptr <- ObjLink.lookupSymbol "base_GHCziHandle_stdin_closure"
- mb_stdout_ptr <- ObjLink.lookupSymbol "base_GHCziHandle_stdout_closure"
- mb_stderr_ptr <- ObjLink.lookupSymbol "base_GHCziHandle_stderr_closure"
+ mb_stdin_ptr <- ObjLink.lookupSymbol "base_GHCziIOziHandleziFD_stdin_closure"
+ mb_stdout_ptr <- ObjLink.lookupSymbol "base_GHCziIOziHandleziFD_stdout_closure"
+ mb_stderr_ptr <- ObjLink.lookupSymbol "base_GHCziIOziHandleziFD_stderr_closure"
let f ref (Just ptr) = writeIORef ref ptr
f _ Nothing = panic "interactiveUI:setBuffering2"
- zipWithM f [stdin_ptr,stdout_ptr,stderr_ptr]
- [mb_stdin_ptr,mb_stdout_ptr,mb_stderr_ptr]
- return ()
+ zipWithM_ f [stdin_ptr,stdout_ptr,stderr_ptr]
+ [mb_stdin_ptr,mb_stdout_ptr,mb_stderr_ptr]
flushInterpBuffers :: GHCi ()
flushInterpBuffers