GhciMonad.hs 13.5 KB
Newer Older
1
{-# OPTIONS_GHC -fno-cse -fno-warn-orphans #-}
2
3
-- -fno-cse is needed for GLOBAL_VAR's to behave properly

mnislaih's avatar
mnislaih committed
4
5
6
7
8
9
10
11
-----------------------------------------------------------------------------
--
-- Monadery code used in InteractiveUI
--
-- (c) The GHC Team 2005-2006
--
-----------------------------------------------------------------------------

12
13
14
15
16
17
18
module GhciMonad (
        GHCi(..), startGHCi,
        GHCiState(..), setGHCiState, getGHCiState, modifyGHCiState,
        GHCiOption(..), isOptionSet, setOption, unsetOption,
        Command,
        BreakLocation(..),
        TickArray,
19
        getDynFlags,
20
21
22
23

        runStmt, runDecls, resume, timeIt, recordBreak, revertCAFs,

        printForUser, printForUserPartWay, prettyLocations,
dterei's avatar
dterei committed
24
        initInterpBuffering, turnOffBuffering, flushInterpBuffers,
25
    ) where
26
27
28
29

#include "HsVersions.h"

import qualified GHC
30
import GhcMonad         hiding (liftIO)
31
import Outputable       hiding (printForUser, printForUserPartWay)
32
import qualified Outputable
33
import Util
Simon Marlow's avatar
Simon Marlow committed
34
import DynFlags
35
import HscTypes
36
import SrcLoc
37
import Module
38
import ObjLink
39
import Linker
40
import StaticFlags
41
import qualified MonadUtils
42

43
import Exception
44
import Numeric
45
import Data.Array
46
47
48
import Data.Int         ( Int64 )
import Data.IORef
import System.CPUTime
mnislaih's avatar
mnislaih committed
49
import System.Environment
50
51
52
53
import System.IO
import Control.Monad as Monad
import GHC.Exts

54
55
import System.Console.Haskeline (CompletionFunc, InputT)
import qualified System.Console.Haskeline as Haskeline
56
57
import Control.Monad.Trans.Class as Trans
import Control.Monad.IO.Class as Trans
58

59
60
61
-----------------------------------------------------------------------------
-- GHCi monad

62
type Command = (String, String -> InputT GHCi Bool, CompletionFunc GHCi)
63

64
data GHCiState = GHCiState
dterei's avatar
dterei committed
65
66
67
     {
        progname       :: String,
        args           :: [String],
68
        prompt         :: String,
dterei's avatar
dterei committed
69
        editor         :: String,
Simon Marlow's avatar
Simon Marlow committed
70
        stop           :: String,
dterei's avatar
dterei committed
71
        options        :: [GHCiOption],
vivian's avatar
vivian committed
72
        line_number    :: !Int,         -- input line
73
74
        break_ctr      :: !Int,
        breaks         :: ![(Int, BreakLocation)],
75
        tickarrays     :: ModuleEnv TickArray,
76
77
78
                -- tickarrays caches the TickArray for loaded modules,
                -- so that we don't rebuild it each time the user sets
                -- a breakpoint.
79
80
81
        -- ":" at the GHCi prompt repeats the last command, so we
        -- remember is here:
        last_command   :: Maybe Command,
Simon Marlow's avatar
Simon Marlow committed
82
        cmdqueue       :: [String],
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

        remembered_ctx :: [InteractiveImport],
             -- the imports that the user has asked for, via import
             -- declarations and :module commands.  This list is
             -- persistent over :reloads (but any imports for modules
             -- that are not loaded are temporarily ignored).  After a
             -- :load, all the home-package imports are stripped from
             -- this list.

             -- See bugs #2049, #1873, #1360

        transient_ctx  :: [InteractiveImport],
             -- An import added automatically after a :load, usually of
             -- the most recently compiled module.  May be empty if
             -- there are no modules loaded.  This list is replaced by
             -- :load, :reload, and :add.  In between it may be modified
             -- by :module.

101
        ghc_e :: Bool -- True if this is 'ghc -e' (or runghc)
102
103
     }

104
105
type TickArray = Array Int [(BreakIndex,SrcSpan)]

dterei's avatar
dterei committed
106
107
108
109
data GHCiOption
        = ShowTiming            -- show time/allocs after evaluation
        | ShowType              -- show the type of expressions
        | RevertCAFs            -- revert CAFs after every evaluation
vivian's avatar
vivian committed
110
        | Multiline             -- use multiline commands
dterei's avatar
dterei committed
111
        deriving Eq
112

113
114
115
116
117
data BreakLocation
   = BreakLocation
   { breakModule :: !GHC.Module
   , breakLoc    :: !SrcSpan
   , breakTick   :: {-# UNPACK #-} !Int
118
   , onBreakCmd  :: String
dterei's avatar
dterei committed
119
   }
120
121
122
123

instance Eq BreakLocation where
  loc1 == loc2 = breakModule loc1 == breakModule loc2 &&
                 breakTick loc1   == breakTick loc2
124
125

prettyLocations :: [(Int, BreakLocation)] -> SDoc
dterei's avatar
dterei committed
126
prettyLocations []   = text "No active breakpoints."
127
128
129
prettyLocations locs = vcat $ map (\(i, loc) -> brackets (int i) <+> ppr loc) $ reverse $ locs

instance Outputable BreakLocation where
130
131
132
133
   ppr loc = (ppr $ breakModule loc) <+> ppr (breakLoc loc) <+>
                if null (onBreakCmd loc)
                   then empty
                   else doubleQuotes (text (onBreakCmd loc))
134
135
136
137

recordBreak :: BreakLocation -> GHCi (Bool{- was already present -}, Int)
recordBreak brkLoc = do
   st <- getGHCiState
dterei's avatar
dterei committed
138
   let oldActiveBreaks = breaks st
139
   -- don't store the same break point twice
140
   case [ nm | (nm, loc) <- oldActiveBreaks, loc == brkLoc ] of
141
142
     (nm:_) -> return (True, nm)
     [] -> do
143
      let oldCounter = break_ctr st
144
          newCounter = oldCounter + 1
145
146
147
      setGHCiState $ st { break_ctr = newCounter,
                          breaks = (oldCounter, brkLoc) : oldActiveBreaks
                        }
148
149
      return (False, oldCounter)

150
newtype GHCi a = GHCi { unGHCi :: IORef GHCiState -> Ghc a }
151

152
153
154
155
156
157
158
159
160
161
162
163
164
reflectGHCi :: (Session, IORef GHCiState) -> GHCi a -> IO a
reflectGHCi (s, gs) m = unGhc (unGHCi m gs) s

reifyGHCi :: ((Session, IORef GHCiState) -> IO a) -> GHCi a
reifyGHCi f = GHCi f'
  where
    -- f' :: IORef GHCiState -> Ghc a
    f' gs = reifyGhc (f'' gs)
    -- f'' :: IORef GHCiState -> Session -> IO a
    f'' gs s = f (s, gs)

startGHCi :: GHCi a -> GHCiState -> Ghc a
startGHCi g state = do ref <- liftIO $ newIORef state; unGHCi g ref
165
166
167

instance Monad GHCi where
  (GHCi m) >>= k  =  GHCi $ \s -> m s >>= \a -> unGHCi (k a) s
Ian Lynagh's avatar
Ian Lynagh committed
168
  return a  = GHCi $ \_ -> return a
169

mnislaih's avatar
mnislaih committed
170
171
172
instance Functor GHCi where
    fmap f m = m >>= return . f

Ian Lynagh's avatar
Ian Lynagh committed
173
getGHCiState :: GHCi GHCiState
174
getGHCiState   = GHCi $ \r -> liftIO $ readIORef r
Ian Lynagh's avatar
Ian Lynagh committed
175
setGHCiState :: GHCiState -> GHCi ()
176
setGHCiState s = GHCi $ \r -> liftIO $ writeIORef r s
177
178
modifyGHCiState :: (GHCiState -> GHCiState) -> GHCi ()
modifyGHCiState f = GHCi $ \r -> liftIO $ readIORef r >>= writeIORef r . f
179
180
181
182

liftGhc :: Ghc a -> GHCi a
liftGhc m = GHCi $ \_ -> m

183
184
185
186
187
instance MonadUtils.MonadIO GHCi where
  liftIO = liftGhc . MonadUtils.liftIO

instance Trans.MonadIO Ghc where
  liftIO = MonadUtils.liftIO
188

189
190
191
instance HasDynFlags GHCi where
  getDynFlags = getSessionDynFlags

192
193
194
195
instance GhcMonad GHCi where
  setSession s' = liftGhc $ setSession s'
  getSession    = liftGhc $ getSession

196
197
198
instance HasDynFlags (InputT GHCi) where
  getDynFlags = lift getDynFlags

199
200
201
202
203
204
205
instance GhcMonad (InputT GHCi) where
  setSession = lift . setSession
  getSession = lift getSession

instance MonadUtils.MonadIO (InputT GHCi) where
  liftIO = Trans.liftIO

206
207
instance ExceptionMonad GHCi where
  gcatch m h = GHCi $ \r -> unGHCi m r `gcatch` (\e -> unGHCi (h e) r)
208
209
  gblock (GHCi m)   = GHCi $ \r -> gblock (m r)
  gunblock (GHCi m) = GHCi $ \r -> gunblock (m r)
210
211
212
213
214
215
  gmask f =
      GHCi $ \s -> gmask $ \io_restore ->
                             let
                                g_restore (GHCi m) = GHCi $ \s' -> io_restore (m s')
                             in
                                unGHCi (f g_restore) s
216

217
instance MonadIO GHCi where
Ian Lynagh's avatar
Ian Lynagh committed
218
  liftIO = MonadUtils.liftIO
Ian Lynagh's avatar
Ian Lynagh committed
219

220
221
222
223
224
instance Haskeline.MonadException Ghc where
  controlIO f = Ghc $ \s -> Haskeline.controlIO $ \(Haskeline.RunIO run) -> let
                    run' = Haskeline.RunIO (fmap (Ghc . const) . run . flip unGhc s)
                    in fmap (flip unGhc s) $ f run'

225
instance Haskeline.MonadException GHCi where
226
227
228
  controlIO f = GHCi $ \s -> Haskeline.controlIO $ \(Haskeline.RunIO run) -> let
                    run' = Haskeline.RunIO (fmap (GHCi . const) . run . flip unGHCi s)
                    in fmap (flip unGHCi s) $ f run'
Ian Lynagh's avatar
Ian Lynagh committed
229

230
instance ExceptionMonad (InputT GHCi) where
231
  gcatch = Haskeline.catch
232
233
234
235
  gmask f = Haskeline.liftIOOp gmask (f . Haskeline.liftIOOp_)

  gblock = Haskeline.liftIOOp_ gblock
  gunblock = Haskeline.liftIOOp_ gunblock
236

237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
isOptionSet :: GHCiOption -> GHCi Bool
isOptionSet opt
 = do st <- getGHCiState
      return (opt `elem` options st)

setOption :: GHCiOption -> GHCi ()
setOption opt
 = do st <- getGHCiState
      setGHCiState (st{ options = opt : filter (/= opt) (options st) })

unsetOption :: GHCiOption -> GHCi ()
unsetOption opt
 = do st <- getGHCiState
      setGHCiState (st{ options = filter (/= opt) (options st) })

252
printForUser :: GhcMonad m => SDoc -> m ()
253
printForUser doc = do
254
  unqual <- GHC.getPrintUnqual
Ian Lynagh's avatar
Ian Lynagh committed
255
256
  dflags <- getDynFlags
  MonadUtils.liftIO $ Outputable.printForUser dflags stdout unqual doc
257

258
259
printForUserPartWay :: SDoc -> GHCi ()
printForUserPartWay doc = do
260
  unqual <- GHC.getPrintUnqual
Ian Lynagh's avatar
Ian Lynagh committed
261
262
  dflags <- getDynFlags
  liftIO $ Outputable.printForUserPartWay dflags stdout opt_PprUserLength unqual doc
263

264
-- | Run a single Haskell expression
265
runStmt :: String -> GHC.SingleStep -> GHCi (Maybe GHC.RunResult)
266
runStmt expr step = do
267
268
269
270
271
  st <- getGHCiState
  reifyGHCi $ \x ->
    withProgName (progname st) $
    withArgs (args st) $
      reflectGHCi x $ do
dterei's avatar
dterei committed
272
        GHC.handleSourceError (\e -> do GHC.printException e;
273
274
275
276
277
278
279
280
281
282
283
284
285
                                        return Nothing) $ do
          r <- GHC.runStmtWithLocation (progname st) (line_number st) expr step
          return (Just r)

runDecls :: String -> GHCi [GHC.Name]
runDecls decls = do
  st <- getGHCiState
  reifyGHCi $ \x ->
    withProgName (progname st) $
    withArgs (args st) $
      reflectGHCi x $ do
        GHC.handleSourceError (\e -> do GHC.printException e; return []) $ do
          GHC.runDeclsWithLocation (progname st) (line_number st) decls
mnislaih's avatar
mnislaih committed
286

287
resume :: (SrcSpan -> Bool) -> GHC.SingleStep -> GHCi GHC.RunResult
288
289
290
291
292
293
294
resume canLogSpan step = do
  st <- getGHCiState
  reifyGHCi $ \x ->
    withProgName (progname st) $
    withArgs (args st) $
      reflectGHCi x $ do
        GHC.resume canLogSpan step
mnislaih's avatar
mnislaih committed
295

mnislaih's avatar
mnislaih committed
296
-- --------------------------------------------------------------------------
297
298
-- timing & statistics

299
timeIt :: InputT GHCi a -> InputT GHCi a
300
timeIt action
301
  = do b <- lift $ isOptionSet ShowTiming
dterei's avatar
dterei committed
302
303
304
305
306
307
308
309
310
311
       if not b
          then action
          else do allocs1 <- liftIO $ getAllocations
                  time1   <- liftIO $ getCPUTime
                  a <- action
                  allocs2 <- liftIO $ getAllocations
                  time2   <- liftIO $ getCPUTime
                  liftIO $ printTimes (fromIntegral (allocs2 - allocs1))
                                  (time2 - time1)
                  return a
312
313

foreign import ccall unsafe "getAllocations" getAllocations :: IO Int64
dterei's avatar
dterei committed
314
        -- defined in ghc/rts/Stats.c
315
316
317

printTimes :: Integer -> Integer -> IO ()
printTimes allocs psecs
318
   = do let secs = (fromIntegral psecs / (10^(12::Integer))) :: Float
dterei's avatar
dterei committed
319
320
321
322
            secs_str = showFFloat (Just 2) secs
        putStrLn (showSDoc (
                 parens (text (secs_str "") <+> text "secs" <> comma <+>
                         text (show allocs) <+> text "bytes")))
323
324
325

-----------------------------------------------------------------------------
-- reverting CAFs
dterei's avatar
dterei committed
326

327
revertCAFs :: GHCi ()
328
revertCAFs = do
Ian Lynagh's avatar
Ian Lynagh committed
329
  liftIO rts_revertCAFs
330
  s <- getGHCiState
Ian Lynagh's avatar
Ian Lynagh committed
331
  when (not (ghc_e s)) $ liftIO turnOffBuffering
dterei's avatar
dterei committed
332
333
        -- Have to turn off buffering again, because we just
        -- reverted stdout, stderr & stdin to their defaults.
334

dterei's avatar
dterei committed
335
336
foreign import ccall "revertCAFs" rts_revertCAFs  :: IO ()
        -- Make it "safe", just in case
337
338
339
340
341

-----------------------------------------------------------------------------
-- To flush buffers for the *interpreted* computation we need
-- to refer to *its* stdout/stderr handles

342
343
344
GLOBAL_VAR(stdin_ptr,  error "no stdin_ptr",  Ptr ())
GLOBAL_VAR(stdout_ptr, error "no stdout_ptr", Ptr ())
GLOBAL_VAR(stderr_ptr, error "no stderr_ptr", Ptr ())
345

346
347
348
349
350
351
352
353
354
355
356
357
358
-- After various attempts, I believe this is the least bad way to do
-- what we want.  We know look up the address of the static stdin,
-- stdout, and stderr closures in the loaded base package, and each
-- time we need to refer to them we cast the pointer to a Handle.
-- This avoids any problems with the CAF having been reverted, because
-- we'll always get the current value.
--
-- The previous attempt that didn't work was to compile an expression
-- like "hSetBuffering stdout NoBuffering" into an expression of type
-- IO () and run this expression each time we needed it, but the
-- problem is that evaluating the expression might cache the contents
-- of the Handle rather than referring to it from its static address
-- each time.  There's no safe workaround for this.
359

360
361
362
363
initInterpBuffering :: Ghc ()
initInterpBuffering = do -- make sure these are linked
    dflags <- GHC.getSessionDynFlags
    liftIO $ do
364
      initDynLinker dflags
365
366
367
368

        -- 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.
369
370
371
      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"
372
373

      let f ref (Just ptr) = writeIORef ref ptr
Ian Lynagh's avatar
Ian Lynagh committed
374
          f _   Nothing    = panic "interactiveUI:setBuffering2"
375
376
      zipWithM_ f [stdin_ptr,stdout_ptr,stderr_ptr]
                  [mb_stdin_ptr,mb_stdout_ptr,mb_stderr_ptr]
377
378
379

flushInterpBuffers :: GHCi ()
flushInterpBuffers
Ian Lynagh's avatar
Ian Lynagh committed
380
381
 = liftIO $ do getHandle stdout_ptr >>= hFlush
               getHandle stderr_ptr >>= hFlush
382
383
384

turnOffBuffering :: IO ()
turnOffBuffering
385
386
387
388
389
390
 = do hdls <- mapM getHandle [stdin_ptr,stdout_ptr,stderr_ptr]
      mapM_ (\h -> hSetBuffering h NoBuffering) hdls

getHandle :: IORef (Ptr ()) -> IO Handle
getHandle ref = do
  (Ptr addr) <- readIORef ref
391
  case addrToAny# addr of (# hval #) -> return (unsafeCoerce# hval)
dterei's avatar
dterei committed
392