X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fghci%2FInteractiveUI.hs;h=bb842292ca1720f9c51a70a7105eeb2ac3786b15;hb=4db852d22cffb9ae4b99f935c659100c27de53e8;hp=f75c6726eb1c369f66933f26d49562450e6e01b0;hpb=dd6f34b632c29306e56b6bdf232316af26800a4f;p=ghc-hetmet.git

diff --git a/ghc/compiler/ghci/InteractiveUI.hs b/ghc/compiler/ghci/InteractiveUI.hs
index f75c672..bb84229 100644
--- a/ghc/compiler/ghci/InteractiveUI.hs
+++ b/ghc/compiler/ghci/InteractiveUI.hs
@@ -1,38 +1,48 @@
+{-# OPTIONS -#include "Linker.h" -#include "SchedAPI.h" #-}
 -----------------------------------------------------------------------------
--- $Id: InteractiveUI.hs,v 1.86 2001/08/15 14:40:24 simonmar Exp $
+-- $Id: InteractiveUI.hs,v 1.111 2002/01/28 12:01:12 simonmar Exp $
 --
 -- GHC Interactive User Interface
 --
 -- (c) The GHC Team 2000
 --
 -----------------------------------------------------------------------------
-
-{-# OPTIONS -#include "Linker.h" #-}
-{-# OPTIONS -#include "SchedAPI.h" #-}
 module InteractiveUI ( interactiveUI, ghciWelcomeMsg ) where
 
 #include "../includes/config.h"
 #include "HsVersions.h"
 
 import Packages
+
 import CompManager
-import HscTypes		( GhciMode(..), TyThing(..) )
-import MkIface          ( ifaceTyCls )
-import ByteCodeLink
+import CmTypes		( Linkable, isObjectLinkable, ModSummary(..) )
+import CmLink		( findModuleLinkable_maybe )
+
+import HscTypes		( TyThing(..), showModMsg, InteractiveContext(..) )
+import HsSyn		( TyClDecl(..), ConDecl(..), Sig(..) )
+import MkIface		( ifaceTyThing )
 import DriverFlags
 import DriverState
-import DriverUtil
+import DriverUtil	( handle, remove_spaces )
 import Linker
 import Finder		( flushPackageCache )
 import Util
-import Id		( isDataConWrapId, idName )
+import Id		( isRecordSelector, recordSelectorFieldLabel, 
+			  isDataConWrapId, isDataConId, idName )
 import Class		( className )
-import TyCon		( tyConName )
+import TyCon		( tyConName, tyConClass_maybe, isPrimTyCon )
+import FieldLabel	( fieldLabelTyCon )
 import SrcLoc		( isGoodSrcLoc )
-import Name		( Name, isHomePackageName, nameSrcLoc )
+import Module		( moduleName )
+import NameEnv		( nameEnvElts )
+import Name		( Name, isHomePackageName, nameSrcLoc, nameOccName,
+			  NamedThing(..) )
+import OccName		( isSymOcc )
+import BasicTypes	( defaultFixity )
 import Outputable
-import CmdLineOpts	( DynFlag(..), getDynFlags, saveDynFlags, restoreDynFlags, dopt_unset )
-import Panic		( GhcException(..) )
+import CmdLineOpts	( DynFlag(..), DynFlags(..), getDynFlags, saveDynFlags,
+			  restoreDynFlags, dopt_unset )
+import Panic		( GhcException(..), showGhcException )
 import Config
 
 #ifndef mingw32_TARGET_OS
@@ -44,7 +54,9 @@ import Dynamic
 #if HAVE_READLINE_HEADERS && HAVE_READLINE_LIBS
 import Readline 
 #endif
+import Concurrent
 import IOExts
+import SystemExts
 
 import Numeric
 import List
@@ -53,7 +65,7 @@ import CPUTime
 import Directory
 import IO
 import Char
-import Monad 		( when )
+import Monad
 
 import PrelGHC 		( unsafeCoerce# )
 import Foreign		( nullPtr )
@@ -73,6 +85,7 @@ GLOBAL_VAR(commands, builtin_commands, [(String, String -> GHCi Bool)])
 builtin_commands :: [(String, String -> GHCi Bool)]
 builtin_commands = [
   ("add",	keepGoing addModule),
+  ("browse",    keepGoing browseCmd),
   ("cd",    	keepGoing changeDirectory),
   ("def",	keepGoing defineMacro),
   ("help",	keepGoing help),
@@ -81,7 +94,8 @@ builtin_commands = [
   ("load",	keepGoing loadModule),
   ("module",	keepGoing setContext),
   ("reload",	keepGoing reloadModule),
-  ("set",	keepGoing setOptions),
+  ("set",	keepGoing setCmd),
+  ("show",	keepGoing showCmd),
   ("type",	keepGoing typeOfExpr),
   ("unset",	keepGoing unsetOptions),
   ("undef",     keepGoing undefineMacro),
@@ -98,17 +112,24 @@ helpText = "\
 \\
 \   <stmt>		   evaluate/run <stmt>\n\ 
 \   :add <filename> ...    add module(s) to the current target set\n\ 
+\   :browse [*]<module>	   display the names defined by <module>\n\ 
 \   :cd <dir>		   change directory to <dir>\n\ 
 \   :def <cmd> <expr>      define a command :<cmd>\n\ 
 \   :help, :?		   display this list of commands\n\ 
-\   :info [<name> ...]     display information about the given names, or\n\ 
-\                          about currently loaded files if no names given\n\ 
+\   :info [<name> ...]     display information about the given names\n\ 
 \   :load <filename> ...   load module(s) and their dependents\n\ 
 \   :module <mod>	   set the context for expression evaluation to <mod>\n\ 
 \   :reload		   reload the current module set\n\ 
+\\n\ 
 \   :set <option> ...	   set options\n\ 
-\   :undef <cmd> 	   undefine user-defined command :<cmd>\n\ 
+\   :set args <arg> ...	   set the arguments returned by System.getArgs\n\ 
+\   :set prog <progname>   set the value returned by System.getProgName\n\ 
+\\n\ 
+\   :show modules	   show the currently loaded modules\n\ 
+\   :show bindings	   show the current bindings made at the prompt\n\ 
+\\n\ 
 \   :type <expr>	   show the type of <expr>\n\ 
+\   :undef <cmd> 	   undefine user-defined command :<cmd>\n\ 
 \   :unset <option> ...	   unset options\n\ 
 \   :quit		   exit GHCi\n\ 
 \   :!<command>		   run the shell command <command>\n\ 
@@ -127,23 +148,20 @@ interactiveUI cmstate paths cmdline_libs = do
    hFlush stdout
    hSetBuffering stdout NoBuffering
 
+   dflags <- getDynFlags
+
    -- link in the available packages
    pkgs <- getPackageInfo
    initLinker
-   linkPackages cmdline_libs pkgs
-
-   (cmstate, ok, mods) <-
-   	case paths of
-	     [] -> return (cmstate, True, [])
-	     _  -> cmLoadModule cmstate paths
-
-#if HAVE_READLINE_HEADERS && HAVE_READLINE_LIBS
-   Readline.initialize
-#endif
-
-   dflags <- getDynFlags
+   linkPackages dflags cmdline_libs pkgs
 
    (cmstate, maybe_hval) 
+	<- cmCompileExpr cmstate dflags "IO.hSetBuffering IO.stdout IO.NoBuffering Prelude.>> IO.hSetBuffering IO.stderr IO.NoBuffering"
+   case maybe_hval of
+	Just hval -> unsafeCoerce# hval :: IO ()
+	_ -> panic "interactiveUI:buffering"
+
+   (cmstate, maybe_hval)
 	<- cmCompileExpr cmstate dflags "IO.hFlush PrelHandle.stderr"
    case maybe_hval of
 	Just hval -> writeIORef flush_stderr (unsafeCoerce# hval :: IO ())
@@ -155,9 +173,19 @@ interactiveUI cmstate paths cmdline_libs = do
 	Just hval -> writeIORef flush_stdout (unsafeCoerce# hval :: IO ())
 	_ -> panic "interactiveUI:stdout"
 
-   startGHCi runGHCi GHCiState{ targets = paths,
-			        cmstate = cmstate,
-			        options = [] }
+	-- initial context is just the Prelude
+   cmstate <- cmSetContext cmstate dflags [] ["Prelude"]
+
+#if HAVE_READLINE_HEADERS && HAVE_READLINE_LIBS
+   Readline.initialize
+#endif
+
+   startGHCi (runGHCi paths dflags) 
+	GHCiState{ progname = "<interactive>",
+		   args = [],
+		   targets = paths,
+		   cmstate = cmstate,
+		   options = [] }
 
 #if HAVE_READLINE_HEADERS && HAVE_READLINE_LIBS
    Readline.resetTerminal Nothing
@@ -166,8 +194,8 @@ interactiveUI cmstate paths cmdline_libs = do
    return ()
 
 
-runGHCi :: GHCi ()
-runGHCi = do
+runGHCi :: [FilePath] -> DynFlags -> GHCi ()
+runGHCi paths dflags = do
   read_dot_files <- io (readIORef v_Read_DotGHCi)
 
   when (read_dot_files) $ do
@@ -199,16 +227,34 @@ runGHCi = do
   		  Left e    -> return ()
   		  Right hdl -> fileLoop hdl False
 
+  -- perform a :load for files given on the GHCi command line
+  when (not (null paths)) $
+     ghciHandle showException $
+	loadModule (unwords paths)
+
+  -- enter the interactive loop
+  is_tty <- io (hIsTerminalDevice stdin)
+  interactiveLoop is_tty
+
+  -- and finally, exit
+  io $ do when (verbosity dflags > 0) $ putStrLn "Leaving GHCi."
+
+
+interactiveLoop is_tty = do
+  -- ignore ^C exceptions caught here
+  ghciHandleDyn (\e -> case e of 
+			Interrupted -> ghciUnblock (interactiveLoop is_tty)
+			_other      -> return ()) $ do
+
   -- read commands from stdin
 #if HAVE_READLINE_HEADERS && HAVE_READLINE_LIBS
-  readlineLoop
+  if (is_tty) 
+	then readlineLoop
+	else fileLoop stdin False  -- turn off prompt for non-TTY input
 #else
   fileLoop stdin True
 #endif
 
-  -- and finally, exit
-  io $ do putStrLn "Leaving GHCi." 
-
 
 -- NOTE: We only read .ghci files if they are owned by the current user,
 -- and aren't world writable.  Otherwise, we could be accidentally 
@@ -243,9 +289,9 @@ checkPerms name =
 
 fileLoop :: Handle -> Bool -> GHCi ()
 fileLoop hdl prompt = do
-   st <- getGHCiState
-   mod <- io (cmGetContext (cmstate st))
-   when prompt (io (putStr (mod ++ "> ")))
+   cmstate <- getCmState
+   (mod,imports) <- io (cmGetContext cmstate)
+   when prompt (io (putStr (mkPrompt mod imports)))
    l <- io (IO.try (hGetLine hdl))
    case l of
 	Left e | isEOFError e -> return ()
@@ -259,18 +305,21 @@ fileLoop hdl prompt = do
 stringLoop :: [String] -> GHCi ()
 stringLoop [] = return ()
 stringLoop (s:ss) = do
-   st <- getGHCiState
    case remove_spaces s of
 	"" -> stringLoop ss
 	l  -> do quit <- runCommand l
                  if quit then return () else stringLoop ss
 
+mkPrompt toplevs exports
+   = concat (intersperse " " (toplevs ++ map ('*':) exports)) ++ "> "
+
 #if HAVE_READLINE_HEADERS && HAVE_READLINE_LIBS
 readlineLoop :: GHCi ()
 readlineLoop = do
-   st <- getGHCiState
-   mod <- io (cmGetContext (cmstate st))
-   l <- io (readline (mod ++ "> "))
+   cmstate <- getCmState
+   (mod,imports) <- io (cmGetContext cmstate)
+   io yield
+   l <- io (readline (mkPrompt mod imports))
    case l of
 	Nothing -> return ()
 	Just l  ->
@@ -295,45 +344,41 @@ runCommand c =
 
 showException (DynException dyn) =
   case fromDynamic dyn of
-    Nothing -> 
-	io (putStrLn ("*** Exception: (unknown)"))
-    Just (PhaseFailed phase code) ->
-	io (putStrLn ("Phase " ++ phase ++ " failed (code "
-		       ++ show code ++ ")"))
-    Just Interrupted ->
-	io (putStrLn "Interrupted.")
-    Just (CmdLineError s) -> 
-	io (putStrLn s)	 -- omit the location for CmdLineError
-    Just other_ghc_ex ->
-	io (putStrLn (show other_ghc_ex))
+    Nothing               -> io (putStrLn ("*** Exception: (unknown)"))
+    Just Interrupted      -> io (putStrLn "Interrupted.")
+    Just (CmdLineError s) -> io (putStrLn s)	 -- omit the location for CmdLineError
+    Just ph@PhaseFailed{} -> io (putStrLn (showGhcException ph "")) -- ditto
+    Just other_ghc_ex     -> io (print other_ghc_ex)
+
 showException other_exception
   = io (putStrLn ("*** Exception: " ++ show other_exception))
 
 doCommand (':' : command) = specialCommand command
 doCommand stmt
-   = do timeIt (do stuff <- runStmt stmt; finishEvalExpr stuff)
+   = do timeIt (do nms <- runStmt stmt; finishEvalExpr nms)
         return False
 
--- Returns True if the expr was successfully parsed, renamed and
--- typechecked.
-runStmt :: String -> GHCi (Maybe [Name])
+runStmt :: String -> GHCi [Name]
 runStmt stmt
- | null (filter (not.isSpace) stmt)
- = return Nothing
+ | null (filter (not.isSpace) stmt) = return []
  | otherwise
  = do st <- getGHCiState
       dflags <- io getDynFlags
       let dflags' = dopt_unset dflags Opt_WarnUnusedBinds
-      (new_cmstate, names) <- io (cmRunStmt (cmstate st) dflags' stmt)
+      (new_cmstate, result) <- 
+	io $ withProgName (progname st) $ withArgs (args st) $
+	cmRunStmt (cmstate st) dflags' stmt
       setGHCiState st{cmstate = new_cmstate}
-      return (Just names)
+      case result of
+	CmRunFailed      -> return []
+	CmRunException e -> showException e >> return []
+	CmRunOk names    -> return names
 
 -- possibly print the type and revert CAFs after evaluating an expression
-finishEvalExpr Nothing = return False
-finishEvalExpr (Just names)
+finishEvalExpr names
  = do b <- isOptionSet ShowType
-      st <- getGHCiState
-      when b (mapM_ (showTypeOfName (cmstate st)) names)
+      cmstate <- getCmState
+      when b (mapM_ (showTypeOfName cmstate) names)
 
       b <- isOptionSet RevertCAFs
       io (when b revertCAFs)
@@ -349,10 +394,8 @@ showTypeOfName cmstate n
 
 flushEverything :: GHCi ()
 flushEverything
-   = io $ do flush_so <- readIORef flush_stdout
-     	     flush_so
-     	     flush_se <- readIORef flush_stdout
-     	     flush_se
+   = io $ do Monad.join (readIORef flush_stdout)
+     	     Monad.join (readIORef flush_stderr)
              return ()
 
 specialCommand :: String -> GHCi Bool
@@ -381,29 +424,49 @@ info :: String -> GHCi ()
 info "" = throwDyn (CmdLineError "syntax: `:i <thing-you-want-info-about>'")
 info s = do
   let names = words s
-  state <- getGHCiState
+  init_cms <- getCmState
   dflags <- io getDynFlags
   let 
     infoThings cms [] = return cms
     infoThings cms (name:names) = do
-      (cms, unqual, ty_things) <- io (cmInfoThing cms dflags name)
+      (cms, stuff) <- io (cmInfoThing cms dflags name)
       io (putStrLn (showSDocForUser unqual (
-	    vcat (intersperse (text "") (map showThing ty_things))))
+	    vcat (intersperse (text "") (map showThing stuff))))
          )
       infoThings cms names
 
-    showThing ty_thing = vcat [ text "-- " <> showTyThing ty_thing, 
-			        ppr (ifaceTyCls ty_thing) ]
+    unqual = cmGetPrintUnqual init_cms
+
+    showThing (ty_thing, fixity) 
+	= vcat [ text "-- " <> showTyThing ty_thing, 
+		 showFixity fixity (getName ty_thing),
+	         ppr (ifaceTyThing ty_thing) ]
 
-    showTyThing (AClass cl) 
+    showFixity fix name
+	| fix == defaultFixity = empty
+	| otherwise            = ppr fix <+> 
+				 (if isSymOcc (nameOccName name)
+					then ppr name
+					else char '`' <> ppr name <> char '`')
+
+    showTyThing (AClass cl)
        = hcat [ppr cl, text " is a class", showSrcLoc (className cl)]
     showTyThing (ATyCon ty)
+       | isPrimTyCon ty
+       = hcat [ppr ty, text " is a primitive type constructor"]
+       | otherwise
        = hcat [ppr ty, text " is a type constructor", showSrcLoc (tyConName ty)]
     showTyThing (AnId   id)
-       | isDataConWrapId id 
-       = hcat [ppr id, text " is a data constructor", showSrcLoc (idName id)]
-       | otherwise
-       = hcat [ppr id, text " is a variable", showSrcLoc (idName id)]
+       = hcat [ppr id, text " is a ", idDescr id, showSrcLoc (idName id)]
+
+    idDescr id
+       | isRecordSelector id = 
+		case tyConClass_maybe (fieldLabelTyCon (
+				recordSelectorFieldLabel id)) of
+			Nothing -> text "record selector"
+			Just c  -> text "method in class " <> ppr c
+       | isDataConWrapId id  = text "data constructor"
+       | otherwise           = text "variable"
 
 	-- also print out the source location for home things
     showSrcLoc name
@@ -413,11 +476,10 @@ info s = do
 	= empty
 	where loc = nameSrcLoc name
 
-  cms <- infoThings (cmstate state) names
-  setGHCiState state{ cmstate = cms }
+  cms <- infoThings init_cms names
+  setCmState cms
   return ()
 
-
 addModule :: String -> GHCi ()
 addModule str = do
   let files = words str
@@ -425,21 +487,11 @@ addModule str = do
   dflags <- io (getDynFlags)
   io (revertCAFs)			-- always revert CAFs on load/add.
   let new_targets = files ++ targets state 
-  (cmstate1, ok, mods) <- io (cmLoadModule (cmstate state) new_targets)
+  graph <- io (cmDepAnal (cmstate state) dflags new_targets)
+  (cmstate1, ok, mods) <- io (cmLoadModules (cmstate state) dflags graph)
   setGHCiState state{ cmstate = cmstate1, targets = new_targets }
-  modulesLoadedMsg ok mods
-
-setContext :: String -> GHCi ()
-setContext ""
-  = throwDyn (CmdLineError "syntax: `:m <module>'")
-setContext m | not (isUpper (head m)) || not (all isAlphaNumEx (tail m))
-  = throwDyn (CmdLineError ("strange looking module name: `" ++ m ++ "'"))
-    where
-       isAlphaNumEx c = isAlphaNum c || c == '_'
-setContext str
-  = do st <- getGHCiState
-       new_cmstate <- io (cmSetContext (cmstate st) str)
-       setGHCiState st{cmstate=new_cmstate}
+  setContextAfterLoad mods
+  modulesLoadedMsg ok mods dflags
 
 changeDirectory :: String -> GHCi ()
 changeDirectory ('~':d) = do
@@ -464,10 +516,10 @@ defineMacro s = do
   let new_expr = '(' : definition ++ ") :: String -> IO String"
 
   -- compile the expression
-  st <- getGHCiState
+  cms <- getCmState
   dflags <- io getDynFlags
-  (new_cmstate, maybe_hv) <- io (cmCompileExpr (cmstate st) dflags new_expr)
-  setGHCiState st{cmstate = new_cmstate}
+  (new_cmstate, maybe_hv) <- io (cmCompileExpr cms dflags new_expr)
+  setCmState new_cmstate
   case maybe_hv of
      Nothing -> return ()
      Just hv -> io (writeIORef commands --
@@ -491,6 +543,7 @@ undefineMacro macro_name = do
 	else do
   io (writeIORef commands (filter ((/= macro_name) . fst) cmds))
 
+
 loadModule :: String -> GHCi ()
 loadModule str = timeIt (loadModule' str)
 
@@ -498,33 +551,56 @@ loadModule' str = do
   let files = words str
   state <- getGHCiState
   dflags <- io getDynFlags
+
+  -- do the dependency anal first, so that if it fails we don't throw
+  -- away the current set of modules.
+  graph <- io (cmDepAnal (cmstate state) dflags files)
+
+  -- Dependency anal ok, now unload everything
   cmstate1 <- io (cmUnload (cmstate state) dflags)
   setGHCiState state{ cmstate = cmstate1, targets = [] }
-  io (revertCAFs)			-- always revert CAFs on load.
-  (cmstate2, ok, mods) <- io (cmLoadModule cmstate1 files)
+
+  io (revertCAFs)  -- always revert CAFs on load.
+  (cmstate2, ok, mods) <- io (cmLoadModules cmstate1 dflags graph)
   setGHCiState state{ cmstate = cmstate2, targets = files }
-  modulesLoadedMsg ok mods
+
+  setContextAfterLoad mods
+  modulesLoadedMsg ok mods dflags
+
 
 reloadModule :: String -> GHCi ()
 reloadModule "" = do
   state <- getGHCiState
+  dflags <- io getDynFlags
   case targets state of
    [] -> io (putStr "no current target\n")
-   paths
-      -> do io (revertCAFs)		-- always revert CAFs on reload.
-	    (new_cmstate, ok, mods) <- io (cmLoadModule (cmstate state) paths)
-            setGHCiState state{ cmstate=new_cmstate }
-	    modulesLoadedMsg ok mods
+   paths -> do
+	-- do the dependency anal first, so that if it fails we don't throw
+	-- away the current set of modules.
+	graph <- io (cmDepAnal (cmstate state) dflags paths)
+
+	io (revertCAFs)		-- always revert CAFs on reload.
+	(cmstate1, ok, mods) 
+		<- io (cmLoadModules (cmstate state) dflags graph)
+        setGHCiState state{ cmstate=cmstate1 }
+	setContextAfterLoad mods
+	modulesLoadedMsg ok mods dflags
 
 reloadModule _ = noArgs ":reload"
 
+setContextAfterLoad [] = setContext prel
+setContextAfterLoad (m:_) = do
+  cmstate <- getCmState
+  b <- io (cmModuleIsInterpreted cmstate m)
+  if b then setContext m else setContext ('*':m)
 
-modulesLoadedMsg ok mods = do
-  let mod_commas 
+modulesLoadedMsg ok mods dflags =
+  when (verbosity dflags > 0) $ do
+   let mod_commas 
 	| null mods = text "none."
 	| otherwise = hsep (
 	    punctuate comma (map text mods)) <> text "."
-  case ok of
+   case ok of
     False -> 
        io (putStrLn (showSDoc (text "Failed, modules loaded: " <> mod_commas)))
     True  -> 
@@ -533,10 +609,10 @@ modulesLoadedMsg ok mods = do
 
 typeOfExpr :: String -> GHCi ()
 typeOfExpr str 
-  = do st <- getGHCiState
+  = do cms <- getCmState
        dflags <- io getDynFlags
-       (new_cmstate, maybe_tystr) <- io (cmTypeOfExpr (cmstate st) dflags str)
-       setGHCiState st{cmstate = new_cmstate}
+       (new_cmstate, maybe_tystr) <- io (cmTypeOfExpr cms dflags str)
+       setCmState new_cmstate
        case maybe_tystr of
 	  Nothing    -> return ()
 	  Just tystr -> io (putStrLn tystr)
@@ -547,6 +623,131 @@ quit _ = return True
 shellEscape :: String -> GHCi Bool
 shellEscape str = io (system str >> return False)
 
+-----------------------------------------------------------------------------
+-- Browing a module's contents
+
+browseCmd :: String -> GHCi ()
+browseCmd m = 
+  case words m of
+    ['*':m] | looksLikeModuleName m -> browseModule m True
+    [m]     | looksLikeModuleName m -> browseModule m False
+    _ -> throwDyn (CmdLineError "syntax:  :browse <module>")
+
+browseModule m exports_only = do
+  cms <- getCmState
+  dflags <- io getDynFlags
+
+  is_interpreted <- io (cmModuleIsInterpreted cms m)
+  when (not is_interpreted && not exports_only) $
+	throwDyn (CmdLineError ("module `" ++ m ++ "' is not interpreted"))
+
+  -- temporarily set the context to the module we're interested in,
+  -- just so we can get an appropriate PrintUnqualified
+  (as,bs) <- io (cmGetContext cms)
+  cms1 <- io (if exports_only then cmSetContext cms dflags [] [prel,m]
+			      else cmSetContext cms dflags [m] [])
+  cms2 <- io (cmSetContext cms1 dflags as bs)
+
+  (cms3, things) <- io (cmBrowseModule cms2 dflags m exports_only)
+
+  setCmState cms3
+
+  let unqual = cmGetPrintUnqual cms1 -- NOTE: cms1 with the new context
+
+      things' = filter wantToSee things
+
+      wantToSee (AnId id) = not (isDataConId id || isDataConWrapId id)
+      wantToSee _ = True
+
+      thing_names = map getName things
+
+      thingDecl thing@(AnId id)  = ifaceTyThing thing
+
+      thingDecl thing@(AClass c) =
+        let rn_decl = ifaceTyThing thing in
+	case rn_decl of
+	  ClassDecl { tcdSigs = cons } -> 
+		rn_decl{ tcdSigs = filter methodIsVisible cons }
+	  other -> other
+        where
+           methodIsVisible (ClassOpSig n _ _ _) = n `elem` thing_names
+
+      thingDecl thing@(ATyCon t) =
+        let rn_decl = ifaceTyThing thing in
+	case rn_decl of
+	  TyData { tcdCons = cons } -> 
+		rn_decl{ tcdCons = filter conIsVisible cons }
+	  other -> other
+        where
+	  conIsVisible (ConDecl n _ _ _ _ _) = n `elem` thing_names
+
+  io (putStrLn (showSDocForUser unqual (
+   	 vcat (map (ppr . thingDecl) things')))
+   )
+
+  where
+
+-----------------------------------------------------------------------------
+-- Setting the module context
+
+setContext str
+  | all sensible mods = fn mods
+  | otherwise = throwDyn (CmdLineError "syntax:  :module [+/-] [*]M1 ... [*]Mn")
+  where
+    (fn, mods) = case str of 
+			'+':stuff -> (addToContext,      words stuff)
+			'-':stuff -> (removeFromContext, words stuff)
+			stuff     -> (newContext,        words stuff) 
+
+    sensible ('*':m) = looksLikeModuleName m
+    sensible m       = looksLikeModuleName m
+
+newContext mods = do
+  cms <- getCmState
+  dflags <- io getDynFlags
+  (as,bs) <- separate cms mods [] []
+  let bs' = if null as && prel `notElem` bs then prel:bs else bs
+  cms' <- io (cmSetContext cms dflags as bs')
+  setCmState cms'
+
+separate cmstate []           as bs = return (as,bs)
+separate cmstate (('*':m):ms) as bs = separate cmstate ms as (m:bs)
+separate cmstate (m:ms)       as bs = do 
+   b <- io (cmModuleIsInterpreted cmstate m)
+   if b then separate cmstate ms (m:as) bs
+   	else throwDyn (CmdLineError ("module `" ++ m ++ "' is not interpreted"))
+	
+prel = "Prelude"
+
+
+addToContext mods = do
+  cms <- getCmState
+  dflags <- io getDynFlags
+  (as,bs) <- io (cmGetContext cms)
+
+  (as',bs') <- separate cms mods [] []
+
+  let as_to_add = as' \\ (as ++ bs)
+      bs_to_add = bs' \\ (as ++ bs)
+
+  cms' <- io (cmSetContext cms dflags 
+			(as ++ as_to_add) (bs ++ bs_to_add))
+  setCmState cms'
+
+
+removeFromContext mods = do
+  cms <- getCmState
+  dflags <- io getDynFlags
+  (as,bs) <- io (cmGetContext cms)
+
+  (as_to_remove,bs_to_remove) <- separate cms mods [] []
+
+  let as' = as \\ (as_to_remove ++ bs_to_remove)
+      bs' = bs \\ (as_to_remove ++ bs_to_remove)
+
+  cms' <- io (cmSetContext cms dflags as' bs')
+  setCmState cms'
+
 ----------------------------------------------------------------------------
 -- Code for `:set'
 
@@ -557,8 +758,8 @@ shellEscape str = io (system str >> return False)
 -- This is pretty fragile: most options won't work as expected.  ToDo:
 -- figure out which ones & disallow them.
 
-setOptions :: String -> GHCi ()
-setOptions ""
+setCmd :: String -> GHCi ()
+setCmd ""
   = do st <- getGHCiState
        let opts = options st
        io $ putStrLn (showSDoc (
@@ -567,9 +768,25 @@ setOptions ""
    		   then text "none."
    		   else hsep (map (\o -> char '+' <> text (optToStr o)) opts)
    	   ))
-setOptions str
-  = do -- first, deal with the GHCi opts (+s, +t, etc.)
-      let (plus_opts, minus_opts)  = partition isPlus (words str)
+setCmd str
+  = case words str of
+	("args":args) -> setArgs args
+	("prog":prog) -> setProg prog
+	wds -> setOptions wds
+
+setArgs args = do
+  st <- getGHCiState
+  setGHCiState st{ args = args }
+
+setProg [prog] = do
+  st <- getGHCiState
+  setGHCiState st{ progname = prog }
+setProg _ = do
+  io (hPutStrLn stderr "syntax: :set prog <progname>")
+
+setOptions wds =
+   do -- first, deal with the GHCi opts (+s, +t, etc.)
+      let (plus_opts, minus_opts)  = partition isPlus wds
       mapM setOpt plus_opts
 
       -- now, the GHC flags
@@ -649,13 +866,47 @@ newPackages new_pkgs = do
     flushPackageCache pkgs
    
     new_pkg_info <- getPackageDetails new_pkgs
-    mapM_ (linkPackage False) (reverse new_pkg_info)
+    mapM_ (linkPackage dflags) (reverse new_pkg_info)
+
+-----------------------------------------------------------------------------
+-- code for `:show'
+
+showCmd str =
+  case words str of
+	["modules" ] -> showModules
+	["bindings"] -> showBindings
+	_ -> throwDyn (CmdLineError "syntax:  :show [modules|bindings]")
+
+showModules = do
+  cms <- getCmState
+  let mg = cmGetModuleGraph cms
+      ls = cmGetLinkables   cms
+      maybe_linkables = map (findModuleLinkable_maybe ls) 
+				(map (moduleName.ms_mod) mg)
+  zipWithM showModule mg maybe_linkables
+  return ()
+
+showModule :: ModSummary -> Maybe Linkable -> GHCi ()
+showModule m (Just l) = do
+  io (putStrLn (showModMsg (isObjectLinkable l) (ms_mod m) (ms_location m)))
+showModule _ Nothing = panic "missing linkable"
+
+showBindings = do
+  cms <- getCmState
+  let
+	unqual = cmGetPrintUnqual cms
+	showBinding b = putStrLn (showSDocForUser unqual (ppr (ifaceTyThing b)))
+
+  io (mapM showBinding (cmGetBindings cms))
+  return ()
 
 -----------------------------------------------------------------------------
 -- GHCi monad
 
 data GHCiState = GHCiState
      { 
+	progname       :: String,
+	args	       :: [String],
 	targets        :: [FilePath],
 	cmstate        :: CmState,
 	options        :: [GHCiOption]
@@ -679,9 +930,17 @@ instance Monad GHCi where
   (GHCi m) >>= k  =  GHCi $ \s -> m s >>= \a -> unGHCi (k a) s
   return a  = GHCi $ \s -> return a
 
+ghciHandleDyn :: Typeable t => (t -> GHCi a) -> GHCi a -> GHCi a
+ghciHandleDyn h (GHCi m) = GHCi $ \s -> 
+   Exception.catchDyn (m s) (\e -> unGHCi (h e) s)
+
 getGHCiState   = GHCi $ \r -> readIORef r
 setGHCiState s = GHCi $ \r -> writeIORef r s
 
+-- for convenience...
+getCmState = getGHCiState >>= return . cmstate
+setCmState cms = do s <- getGHCiState; setGHCiState s{cmstate=cms}
+
 isOptionSet :: GHCiOption -> GHCi Bool
 isOptionSet opt
  = do st <- getGHCiState
@@ -734,47 +993,44 @@ type LibrarySpec
 showLS (Left nm)  = "(static) " ++ nm
 showLS (Right nm) = "(dynamic) " ++ nm
 
-linkPackages :: [LibrarySpec] -> [PackageConfig] -> IO ()
-linkPackages cmdline_lib_specs pkgs
-   = do sequence_ [ linkPackage (name p `elem` loaded) p | p <- reverse pkgs ]
+linkPackages :: DynFlags -> [LibrarySpec] -> [PackageConfig] -> IO ()
+linkPackages dflags cmdline_lib_specs pkgs
+   = do mapM_ (linkPackage dflags) (reverse pkgs)
         lib_paths <- readIORef v_Library_paths
-        mapM_ (preloadLib lib_paths) cmdline_lib_specs
+        mapM_ (preloadLib dflags lib_paths) cmdline_lib_specs
 	if (null cmdline_lib_specs)
 	   then return ()
-	   else do putStr "final link ... "
+	   else do maybePutStr dflags "final link ... "
 		   ok <- resolveObjs
-		   if ok then putStrLn "done."
-	      		 else throwDyn (InstallationError "linking extra libraries/objects failed")
+		   if ok then maybePutStrLn dflags "done."
+	      		 else throwDyn (InstallationError 
+                                          "linking extra libraries/objects failed")
      where
-	-- Packages that are already linked into GHCi.  For mingw32, we only
-	-- skip gmp and rts, since std and after need to load the msvcrt.dll
-	-- library which std depends on.
-	loaded 
-#          ifndef mingw32_TARGET_OS
-           = [ "gmp", "rts", "std", "concurrent", "posix", "text", "util" ]
-#          else
-           = [ "gmp", "rts" ]
-#          endif
-
-        preloadLib :: [String] -> LibrarySpec -> IO ()
-        preloadLib lib_paths lib_spec
-           = do putStr ("Loading object " ++ showLS lib_spec ++ " ... ")
+        preloadLib :: DynFlags -> [String] -> LibrarySpec -> IO ()
+        preloadLib dflags lib_paths lib_spec
+           = do maybePutStr dflags ("Loading object " ++ showLS lib_spec ++ " ... ")
                 case lib_spec of
                    Left static_ish
                       -> do b <- preload_static lib_paths static_ish
-                            putStrLn (if b then "done." else "not found")
+                            maybePutStrLn dflags (if b  then "done." 
+							else "not found")
                    Right dll_unadorned
                       -> -- We add "" to the set of paths to try, so that
                          -- if none of the real paths match, we force addDLL
                          -- to look in the default dynamic-link search paths.
-                         do b <- preload_dynamic (lib_paths++[""]) dll_unadorned
-                            when (not b) (cantFind lib_paths lib_spec)
-                            putStrLn "done"
-
-        cantFind :: [String] -> LibrarySpec -> IO ()
-        cantFind paths spec
-           = do putStr ("failed.\nCan't find " ++ showLS spec
-                        ++ " in directories:\n"
+                         do maybe_errstr <- preload_dynamic (lib_paths++[""]) 
+                                                            dll_unadorned
+                            case maybe_errstr of
+                               Nothing -> return ()
+                               Just mm -> preloadFailed mm lib_paths lib_spec
+                            maybePutStrLn dflags "done"
+
+        preloadFailed :: String -> [String] -> LibrarySpec -> IO ()
+        preloadFailed sys_errmsg paths spec
+           = do maybePutStr dflags
+		       ("failed.\nDynamic linker error message was:\n   " 
+                        ++ sys_errmsg  ++ "\nWhilst trying to load:  " 
+                        ++ showLS spec ++ "\nDirectories to search are:\n"
                         ++ unlines (map ("   "++) paths) )
                 give_up
 
@@ -784,26 +1040,40 @@ linkPackages cmdline_lib_specs pkgs
                 if not b then return False
                          else loadObj name >> return True
 
+        -- return Nothing == success, else Just error message from addDLL
         preload_dynamic [] name
-           = return False
+           = return Nothing
         preload_dynamic (path:paths) rootname
-           = do maybe_errmsg <- addDLL path rootname
-                if    maybe_errmsg /= nullPtr
+           = do -- addDLL returns NULL on success
+                maybe_errmsg <- addDLL path rootname
+                if    maybe_errmsg == nullPtr
                  then preload_dynamic paths rootname
-                 else return True
+                 else do str <- peekCString maybe_errmsg
+                         return (Just str)
 
         give_up 
            = (throwDyn . CmdLineError)
                 "user specified .o/.so/.DLL could not be loaded."
 
+-- Packages that don't need loading, because the compiler shares them with
+-- the interpreted program.
+dont_load_these = [ "gmp", "rts" ]
+
+-- Packages that are already linked into GHCi.  For mingw32, we only
+-- skip gmp and rts, since std and after need to load the msvcrt.dll
+-- library which std depends on.
+loaded_in_ghci
+#          ifndef mingw32_TARGET_OS
+           = [ "std", "concurrent", "posix", "text", "util" ]
+#          else
+	   = [ ]
+#          endif
 
-linkPackage :: Bool -> PackageConfig -> IO ()
--- ignore rts and gmp for now (ToDo; better?)
-linkPackage loaded_in_ghci pkg
-   | name pkg `elem` ["rts", "gmp"] 
-   = return ()
+linkPackage :: DynFlags -> PackageConfig -> IO ()
+linkPackage dflags pkg
+   | name pkg `elem` dont_load_these = return ()
    | otherwise
-   = do putStr ("Loading package " ++ name pkg ++ " ... ")
+   = do 
         -- For each obj, try obj.o and if that fails, obj.so.
         -- Complication: all the .so's must be loaded before any of the .o's.  
         let dirs      =  library_dirs pkg
@@ -813,13 +1083,14 @@ linkPackage loaded_in_ghci pkg
 	-- Don't load the .so libs if this is a package GHCi is already
 	-- linked against, because we'll already have the .so linked in.
 	let (so_libs, obj_libs) = partition isRight classifieds
-        let sos_first | loaded_in_ghci = obj_libs
-		      | otherwise      = so_libs ++ obj_libs
+        let sos_first | name pkg `elem` loaded_in_ghci = obj_libs
+		      | otherwise      		       = so_libs ++ obj_libs
 
+	maybePutStr dflags ("Loading package " ++ name pkg ++ " ... ")
         mapM loadClassified sos_first
-        putStr "linking ... "
+        maybePutStr dflags "linking ... "
         ok <- resolveObjs
-	if ok then putStrLn "done."
+	if ok then maybePutStrLn dflags "done."
 	      else panic ("can't load package `" ++ name pkg ++ "'")
      where
         isRight (Right _) = True
@@ -871,6 +1142,20 @@ printTimes allocs psecs
 			 int allocs <+> text "bytes")))
 
 -----------------------------------------------------------------------------
+-- utils
+
+looksLikeModuleName [] = False
+looksLikeModuleName (c:cs) = isUpper c && all isAlphaNumEx cs
+
+isAlphaNumEx c = isAlphaNum c || c == '_'
+
+maybePutStr dflags s | verbosity dflags > 0 = putStr s
+		     | otherwise	    = return ()
+
+maybePutStrLn dflags s | verbosity dflags > 0 = putStrLn s
+		       | otherwise	      = return ()
+
+-----------------------------------------------------------------------------
 -- reverting CAFs
 	
 foreign import revertCAFs :: IO ()	-- make it "safe", just in case