cmUnload, -- :: CmState -> DynFlags -> IO CmState
- cmSetContext, -- :: CmState -> String -> IO CmState
+#ifdef GHCI
+ cmModuleIsInterpreted, -- :: CmState -> String -> IO Bool
- cmGetContext, -- :: CmState -> IO String
+ cmSetContext, -- :: CmState -> DynFlags -> [String] -> [String] -> IO CmState
+ cmGetContext, -- :: CmState -> IO ([String],[String])
-#ifdef GHCI
- cmInfoThing, -- :: CmState -> DynFlags -> String -> IO (Maybe TyThing)
+ cmInfoThing, -- :: CmState -> DynFlags -> String
+ -- -> IO (CmState, [(TyThing,Fixity)])
CmRunResult(..),
cmRunStmt, -- :: CmState -> DynFlags -> String
cmTypeOfName, -- :: CmState -> Name -> IO (Maybe String)
+ HValue,
cmCompileExpr, -- :: CmState -> DynFlags -> String
- -- -> IO (CmState, Maybe HValue)#endif
+ -- -> IO (CmState, Maybe HValue)
+
+ cmGetModuleGraph, -- :: CmState -> ModuleGraph
+ cmGetLinkables, -- :: CmState -> [Linkable]
+
+ cmGetBindings, -- :: CmState -> [TyThing]
+ cmGetPrintUnqual, -- :: CmState -> PrintUnqualified
#endif
+
+ -- utils
+ showModMsg, --
)
where
#include "HsVersions.h"
+import MkIface --tmp
+import HsSyn -- tmp
+
import CmLink
import CmTypes
import DriverPipeline
-import DriverFlags ( getDynFlags )
import DriverState ( v_Output_file )
import DriverPhases
import DriverUtil
#endif
import HscTypes
import Name ( Name, NamedThing(..), nameRdrName, nameModule,
- isHomePackageName )
-import RdrName ( lookupRdrEnv, emptyRdrEnv )
+ isHomePackageName, isGlobalName )
+import Rename ( mkGlobalContext )
+import RdrName ( emptyRdrEnv )
import Module
import GetImports
import UniqFM
import Util
import Outputable
import Panic
-import CmdLineOpts ( DynFlags(..) )
+import CmdLineOpts ( DynFlags(..), getDynFlags )
import IOExts
#ifdef GHCI
+import RdrName ( lookupRdrEnv )
import Id ( idType, idName )
import NameEnv
import Type ( tidyType )
import VarEnv ( emptyTidyEnv )
-import RnEnv ( unQualInScope, mkIfaceGlobalRdrEnv )
import BasicTypes ( Fixity, defaultFixity )
import Interpreter ( HValue )
import HscMain ( hscStmt )
pls :: PersistentLinkerState -- link's persistent state
}
-emptyCmState :: GhciMode -> Module -> IO CmState
-emptyCmState gmode mod
+emptyCmState :: GhciMode -> IO CmState
+emptyCmState gmode
= do pcs <- initPersistentCompilerState
pls <- emptyPLS
return (CmState { hst = emptySymbolTable,
ui = emptyUI,
mg = emptyMG,
gmode = gmode,
- ic = emptyInteractiveContext mod,
+ ic = emptyInteractiveContext,
pcs = pcs,
pls = pls })
-emptyInteractiveContext mod
- = InteractiveContext { ic_module = mod,
- ic_rn_env = emptyRdrEnv,
+emptyInteractiveContext
+ = InteractiveContext { ic_toplev_scope = [],
+ ic_exports = [],
+ ic_rn_gbl_env = emptyRdrEnv,
+ ic_print_unqual = alwaysQualify,
+ ic_rn_local_env = emptyRdrEnv,
ic_type_env = emptyTypeEnv }
-defaultCurrentModuleName = mkModuleName "Prelude"
-GLOBAL_VAR(defaultCurrentModule, error "no defaultCurrentModule", Module)
-
-- CM internal types
type UnlinkedImage = [Linkable] -- the unlinked images (should be a set, really)
emptyUI :: UnlinkedImage
-- Produce an initial CmState.
cmInit :: GhciMode -> IO CmState
-cmInit mode = do
- prel <- moduleNameToModule defaultCurrentModuleName
- writeIORef defaultCurrentModule prel
- emptyCmState mode prel
+cmInit mode = emptyCmState mode
+
+-----------------------------------------------------------------------------
+-- Grab information from the CmState
+
+cmGetModuleGraph = mg
+cmGetLinkables = ui
+
+cmGetBindings cmstate = nameEnvElts (ic_type_env (ic cmstate))
+cmGetPrintUnqual cmstate = ic_print_unqual (ic cmstate)
-----------------------------------------------------------------------------
-- Setting the context doesn't throw away any bindings; the bindings
-- we've built up in the InteractiveContext simply move to the new
-- module. They always shadow anything in scope in the current context.
-cmSetContext :: CmState -> String -> IO CmState
-cmSetContext cmstate str
- = do let mn = mkModuleName str
- modules_loaded = [ (name_of_summary s, ms_mod s) | s <- mg cmstate ]
-
- m <- case lookup mn modules_loaded of
- Just m -> return m
- Nothing -> do
- mod <- moduleNameToModule mn
- if isHomeModule mod
- then throwDyn (CmdLineError (showSDoc
- (quotes (ppr (moduleName mod))
- <+> text "is not currently loaded")))
- else return mod
-
- return cmstate{ ic = (ic cmstate){ic_module=m} }
-
-cmGetContext :: CmState -> IO String
-cmGetContext cmstate = return (moduleUserString (ic_module (ic cmstate)))
-
-moduleNameToModule :: ModuleName -> IO Module
-moduleNameToModule mn
- = do maybe_stuff <- findModule mn
- case maybe_stuff of
- Nothing -> throwDyn (CmdLineError ("can't find module `"
+cmSetContext
+ :: CmState -> DynFlags
+ -> [String] -- take the top-level scopes of these modules
+ -> [String] -- and the just the exports from these
+ -> IO CmState
+cmSetContext cmstate dflags toplevs exports = do
+ let CmState{ hit=hit, hst=hst, pcs=pcs, ic=old_ic } = cmstate
+
+ toplev_mods <- mapM (getTopLevModule hit) (map mkModuleName toplevs)
+ export_mods <- mapM (moduleNameToModule hit) (map mkModuleName exports)
+
+ (new_pcs, print_unqual, maybe_env)
+ <- mkGlobalContext dflags hit hst pcs toplev_mods export_mods
+
+ case maybe_env of
+ Nothing -> return cmstate
+ Just env -> return cmstate{ pcs = new_pcs,
+ ic = old_ic{ ic_toplev_scope = toplev_mods,
+ ic_exports = export_mods,
+ ic_rn_gbl_env = env,
+ ic_print_unqual = print_unqual } }
+
+getTopLevModule hit mn =
+ case lookupModuleEnvByName hit mn of
+ Just iface
+ | Just _ <- mi_globals iface -> return (mi_module iface)
+ _other -> throwDyn (CmdLineError (
+ "cannot enter the top-level scope of a compiled module (module `" ++
+ moduleNameUserString mn ++ "')"))
+
+moduleNameToModule :: HomeIfaceTable -> ModuleName -> IO Module
+moduleNameToModule hit mn = do
+ case lookupModuleEnvByName hit mn of
+ Just iface -> return (mi_module iface)
+ _not_a_home_module -> do
+ maybe_stuff <- findModule mn
+ case maybe_stuff of
+ Nothing -> throwDyn (CmdLineError ("can't find module `"
++ moduleNameUserString mn ++ "'"))
- Just (m,_) -> return m
+ Just (m,_) -> return m
+
+cmGetContext :: CmState -> IO ([String],[String])
+cmGetContext CmState{ic=ic} =
+ return (map moduleUserString (ic_toplev_scope ic),
+ map moduleUserString (ic_exports ic))
+
+cmModuleIsInterpreted :: CmState -> String -> IO Bool
+cmModuleIsInterpreted cmstate str
+ = case lookupModuleEnvByName (hit cmstate) (mkModuleName str) of
+ Just iface -> return (not (isNothing (mi_globals iface)))
+ _not_a_home_module -> return False
-----------------------------------------------------------------------------
-- cmInfoThing: convert a String to a TyThing
-- and type constructor), so we return a list of all the possible TyThings.
#ifdef GHCI
-cmInfoThing :: CmState -> DynFlags -> String
- -> IO (CmState, PrintUnqualified, [(TyThing,Fixity)])
+cmInfoThing :: CmState -> DynFlags -> String -> IO (CmState, [(TyThing,Fixity)])
cmInfoThing cmstate dflags id
= do (new_pcs, things) <- hscThing dflags hst hit pcs icontext id
let pairs = map (\x -> (x, getFixity new_pcs (getName x))) things
- return (cmstate{ pcs=new_pcs }, unqual, pairs)
- where
+ return (cmstate{ pcs=new_pcs }, pairs)
+ where
CmState{ hst=hst, hit=hit, pcs=pcs, pls=pls, ic=icontext } = cmstate
- unqual = getUnqual pcs hit icontext
getFixity :: PersistentCompilerState -> Name -> Fixity
getFixity pcs name
- | Just iface <- lookupModuleEnv iface_table (nameModule name),
+ | isGlobalName name,
+ Just iface <- lookupModuleEnv iface_table (nameModule name),
Just fixity <- lookupNameEnv (mi_fixities iface) name
= fixity
| otherwise
data CmRunResult
= CmRunOk [Name] -- names bound by this evaluation
| CmRunFailed
- | CmRunDeadlocked -- statement deadlocked
| CmRunException Exception -- statement raised an exception
cmRunStmt :: CmState -> DynFlags -> String -> IO (CmState, CmRunResult)
dflags expr
= do
let InteractiveContext {
- ic_rn_env = rn_env,
- ic_type_env = type_env } = icontext
+ ic_rn_local_env = rn_env,
+ ic_type_env = type_env } = icontext
(new_pcs, maybe_stuff)
<- hscStmt dflags hst hit pcs icontext expr False{-stmt-}
new_type_env = extendNameEnvList filtered_type_env
[ (getName id, AnId id) | id <- ids]
- new_ic = icontext { ic_rn_env = new_rn_env,
- ic_type_env = new_type_env }
+ new_ic = icontext { ic_rn_local_env = new_rn_env,
+ ic_type_env = new_type_env }
-- link it
hval <- linkExpr pls bcos
either_hvals <- sandboxIO thing_to_run
case either_hvals of
Left err
- | err == dEADLOCKED
- -> return ( cmstate{ pcs=new_pcs, ic=new_ic },
- CmRunDeadlocked )
- | otherwise
-> do hPutStrLn stderr ("unknown failure, code " ++ show err)
return ( cmstate{ pcs=new_pcs, ic=new_ic }, CmRunFailed )
return (cmstate{ pcs=new_pcs, pls=new_pls, ic=new_ic },
CmRunOk names)
--- We run the statement in a "sandbox", which amounts to calling into
--- the RTS to request a new main thread. The main benefit is that we
--- get to detect a deadlock this way, but also there's no danger that
--- exceptions raised by the expression can affect the interpreter.
+
+-- We run the statement in a "sandbox" to protect the rest of the
+-- system from anything the expression might do. For now, this
+-- consists of just wrapping it in an exception handler, but see below
+-- for another version.
+
+sandboxIO :: IO a -> IO (Either Int (Either Exception a))
+sandboxIO thing = do
+ r <- Exception.try thing
+ return (Right r)
+
+{-
+-- This version of sandboxIO runs the expression in a completely new
+-- RTS main thread. It is disabled for now because ^C exceptions
+-- won't be delivered to the new thread, instead they'll be delivered
+-- to the (blocked) GHCi main thread.
sandboxIO :: IO a -> IO (Either Int (Either Exception a))
sandboxIO thing = do
else do
return (Left (fromIntegral stat))
--- ToDo: slurp this in from ghc/includes/RtsAPI.h somehow
-dEADLOCKED = 4 :: Int
-
foreign import "rts_evalStableIO" {- safe -}
rts_evalStableIO :: StablePtr (IO a) -> Ptr (StablePtr a) -> IO CInt
-- more informative than the C type!
+-}
#endif
-----------------------------------------------------------------------------
Just (_, ty, _) -> return (new_cmstate, Just str)
where
str = showSDocForUser unqual (ppr tidy_ty)
- unqual = getUnqual pcs hit ic
+ unqual = ic_print_unqual ic
tidy_ty = tidyType emptyTidyEnv ty
where
CmState{ hst=hst, hit=hit, pcs=pcs, ic=ic } = cmstate
-
-getUnqual pcs hit ic
- = case lookupIfaceByModName hit pit modname of
- Nothing -> alwaysQualify
- Just iface ->
- case mi_globals iface of
- Just env -> unQualInScope env
- Nothing -> unQualInScope (mkIfaceGlobalRdrEnv (mi_exports iface))
- where
- pit = pcs_PIT pcs
- modname = moduleName (ic_module ic)
#endif
-----------------------------------------------------------------------------
Nothing -> return Nothing
Just (AnId id) -> return (Just str)
where
- unqual = getUnqual pcs hit ic
+ unqual = ic_print_unqual ic
ty = tidyType emptyTidyEnv (idType id)
str = showSDocForUser unqual (ppr ty)
cmCompileExpr cmstate dflags expr
= do
let InteractiveContext {
- ic_rn_env = rn_env,
- ic_type_env = type_env,
- ic_module = this_mod } = icontext
+ ic_rn_local_env = rn_env,
+ ic_type_env = type_env } = icontext
(new_pcs, maybe_stuff)
<- hscStmt dflags hst hit pcs icontext
-- Empty the interactive context and set the module context to the topmost
-- newly loaded module, or the Prelude if none were loaded.
cmLoadFinish ok (LinkOK pls) hst hit ui mods ghci_mode pcs
- = do def_mod <- readIORef defaultCurrentModule
- let current_mod = case mods of
- [] -> def_mod
- (x:_) -> ms_mod x
-
- new_ic = emptyInteractiveContext current_mod
-
- new_cmstate = CmState{ hst=hst, hit=hit, ui=ui, mg=mods,
+ = do let new_cmstate = CmState{ hst=hst, hit=hit, ui=ui, mg=mods,
gmode=ghci_mode, pcs=pcs, pls=pls,
- ic = new_ic }
+ ic = emptyInteractiveContext }
mods_loaded = map (moduleNameUserString.name_of_summary) mods
return (new_cmstate, ok, mods_loaded)
projects / ghc-hetmet.git / blobdiff