-- -fno-cse is needed for GLOBAL_VAR's to behave properly
{-# OPTIONS -#include "Linker.h" #-}
+{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-----------------------------------------------------------------------------
--
-- GHC Interactive User Interface
import Maybes ( orElse, expectJust )
import FastString
import Encoding
+import Foreign.C
#ifndef mingw32_HOST_OS
import System.Posix hiding (getEnv)
import Text.Printf
import Foreign
import GHC.Exts ( unsafeCoerce# )
+
+#if __GLASGOW_HASKELL__ >= 611
+import GHC.IO.Exception ( IOErrorType(InvalidArgument) )
+import GHC.IO.Handle ( hFlushAll )
+#else
import GHC.IOBase ( IOErrorType(InvalidArgument) )
+#endif
+
import GHC.TopHandler
import Data.IORef ( IORef, readIORef, writeIORef )
return ""
#endif
+foreign import ccall unsafe "rts_isProfiled" isProfiled :: IO CInt
+
interactiveUI :: [(FilePath, Maybe Phase)] -> Maybe [String]
-> Ghc ()
interactiveUI srcs maybe_exprs = do
+ -- although GHCi compiles with -prof, it is not usable: the byte-code
+ -- compiler and interpreter don't work with profiling. So we check for
+ -- this up front and emit a helpful error message (#2197)
+ i <- liftIO $ isProfiled
+ when (i /= 0) $
+ ghcError (InstallationError "GHCi cannot be used when compiled with -prof")
+
-- HACK! If we happen to get into an infinite loop (eg the user
-- types 'let x=x in x' at the prompt), then the thread will block
-- on a blackhole, and become unreachable during GC. The GC will
Nothing ->
do
-- enter the interactive loop
- runGHCiInput $ runCommands $ haskelineLoop show_prompt
+ runGHCiInput $ runCommands $ nextInputLine show_prompt is_tty
Just exprs -> do
-- just evaluate the expression we were given
enqueueCommands exprs
setLogAction
f
--- TODO really bad name
-haskelineLoop :: Bool -> InputT GHCi (Maybe String)
-haskelineLoop show_prompt = do
+nextInputLine :: Bool -> Bool -> InputT GHCi (Maybe String)
+nextInputLine show_prompt is_tty
+ | is_tty = do
prompt <- if show_prompt then lift mkPrompt else return ""
- l <- getInputLine prompt
- return l
-
+ getInputLine prompt
+ | otherwise = do
+ when show_prompt $ lift mkPrompt >>= liftIO . putStr
+ fileLoop stdin
-- NOTE: We only read .ghci files if they are owned by the current user,
-- and aren't world writable. Otherwise, we could be accidentally
fileLoop :: MonadIO m => Handle -> InputT m (Maybe String)
fileLoop hdl = do
- l <- liftIO $ IO.try (BS.hGetLine hdl)
+ l <- liftIO $ IO.try $ hGetLine hdl
case l of
Left e | isEOFError e -> return Nothing
| InvalidArgument <- etype -> return Nothing
-- this can happen if the user closed stdin, or
-- perhaps did getContents which closes stdin at
-- EOF.
- Right l -> fmap Just (Encoding.decode l)
+ Right l -> return (Just l)
mkPrompt :: GHCi String
mkPrompt = do
| null (filter (not.isSpace) stmt) = return False
| ["import", mod] <- words stmt = keepGoing' setContext ('+':mod)
| otherwise
- = do result <- GhciMonad.runStmt stmt step
+ = do
+#if __GLASGOW_HASKELL__ >= 611
+ -- In the new IO library, read handles buffer data even if the Handle
+ -- is set to NoBuffering. This causes problems for GHCi where there
+ -- are really two stdin Handles. So we flush any bufferred data in
+ -- GHCi's stdin Handle here (only relevant if stdin is attached to
+ -- a file, otherwise the read buffer can't be flushed).
+ liftIO $ IO.try $ hFlushAll stdin
+#endif
+ result <- GhciMonad.runStmt stmt step
afterRunStmt (const True) result
--afterRunStmt :: GHC.RunResult -> GHCi Bool