X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fghci%2FInteractiveUI.hs;h=c4b5f973072b3fcb22572dba1e603f7be9b0447f;hb=315a1f6c671b9800909752c702bda347198dd60a;hp=7cd720cd39540aef4fff84552d36f88240b6a902;hpb=b4ab2c414dcc719a2dc0c38b29c65624165ad1c7;p=ghc-hetmet.git

diff --git a/ghc/compiler/ghci/InteractiveUI.hs b/ghc/compiler/ghci/InteractiveUI.hs
index 7cd720c..c4b5f97 100644
--- a/ghc/compiler/ghci/InteractiveUI.hs
+++ b/ghc/compiler/ghci/InteractiveUI.hs
@@ -15,21 +15,26 @@ module InteractiveUI (
 
 -- The GHC interface
 import qualified GHC
-import GHC		( Session, verbosity, dopt, DynFlag(..),
-			  mkModule, pprModule, Type, Module, SuccessFlag(..),
+import GHC		( Session, verbosity, dopt, DynFlag(..), Target(..),
+			  TargetId(..), DynFlags(..),
+			  pprModule, Type, Module, SuccessFlag(..),
 			  TyThing(..), Name, LoadHowMuch(..), Phase,
 			  GhcException(..), showGhcException,
 			  CheckedModule(..), SrcLoc )
+import Packages		( PackageState(..) )
+import PackageConfig	( InstalledPackageInfo(..) )
+import UniqFM		( eltsUFM )
 import PprTyThing
 import Outputable
 
 -- for createtags (should these come via GHC?)
-import Module( moduleUserString )
-import Name( nameSrcLoc, nameModule, nameOccName )
-import OccName( pprOccName )
-import SrcLoc( isGoodSrcLoc, srcLocFile, srcLocLine, srcLocCol )
+import Module		( moduleString )
+import Name		( nameSrcLoc, nameModule, nameOccName )
+import OccName		( pprOccName )
+import SrcLoc		( isGoodSrcLoc, srcLocFile, srcLocLine, srcLocCol )
 
 -- Other random utilities
+import Digraph		( flattenSCCs )
 import BasicTypes	( failed, successIf )
 import Panic 		( panic, installSignalHandlers )
 import Config
@@ -37,7 +42,6 @@ import StaticFlags	( opt_IgnoreDotGhci )
 import Linker		( showLinkerState )
 import Util		( removeSpaces, handle, global, toArgs,
 			  looksLikeModuleName, prefixMatch, sortLe )
-import ErrUtils		( printErrorsAndWarnings )
 
 #ifndef mingw32_HOST_OS
 import System.Posix
@@ -73,6 +77,7 @@ import System.IO.Error as IO
 import Data.Char
 import Control.Monad as Monad
 import Foreign.StablePtr	( newStablePtr )
+import Text.Printf
 
 import GHC.Exts		( unsafeCoerce# )
 import GHC.IOBase	( IOErrorType(InvalidArgument) )
@@ -90,30 +95,34 @@ ghciWelcomeMsg =
  "/ /_\\\\/ __  / /___| |      http://www.haskell.org/ghc/\n"++
  "\\____/\\/ /_/\\____/|_|      Type :? for help.\n"
 
-GLOBAL_VAR(commands, builtin_commands, [(String, String -> GHCi Bool)])
+type Command = (String, String -> GHCi Bool, String -> IO [String])
+cmdName (n,_,_) = n
 
-builtin_commands :: [(String, String -> GHCi Bool)]
+GLOBAL_VAR(commands, builtin_commands, [Command])
+
+builtin_commands :: [Command]
 builtin_commands = [
-  ("add",	keepGoingPaths addModule),
-  ("browse",    keepGoing browseCmd),
-  ("cd",    	keepGoing changeDirectory),
-  ("def",	keepGoing defineMacro),
-  ("help",	keepGoing help),
-  ("?",		keepGoing help),
-  ("info",      keepGoing info),
-  ("load",	keepGoingPaths loadModule_),
-  ("module",	keepGoing setContext),
-  ("reload",	keepGoing reloadModule),
-  ("check",	keepGoing checkModule),
-  ("set",	keepGoing setCmd),
-  ("show",	keepGoing showCmd),
-  ("etags",	keepGoing createETagsFileCmd),
-  ("ctags",	keepGoing createCTagsFileCmd),
-  ("type",	keepGoing typeOfExpr),
-  ("kind",	keepGoing kindOfType),
-  ("unset",	keepGoing unsetOptions),
-  ("undef",     keepGoing undefineMacro),
-  ("quit",	quit)
+  ("add",	keepGoingPaths addModule,	completeFilename),
+  ("browse",    keepGoing browseCmd,		completeModule),
+  ("cd",    	keepGoing changeDirectory, 	completeFilename),
+  ("def",	keepGoing defineMacro,		completeIdentifier),
+  ("help",	keepGoing help,			completeNone),
+  ("?",		keepGoing help,			completeNone),
+  ("info",      keepGoing info,			completeIdentifier),
+  ("load",	keepGoingPaths loadModule_,	completeHomeModuleOrFile),
+  ("module",	keepGoing setContext,		completeModule),
+  ("main",	keepGoing runMain,		completeIdentifier),
+  ("reload",	keepGoing reloadModule,		completeNone),
+  ("check",	keepGoing checkModule,		completeHomeModule),
+  ("set",	keepGoing setCmd,		completeNone), -- ToDo
+  ("show",	keepGoing showCmd,		completeNone),
+  ("etags",	keepGoing createETagsFileCmd,	completeFilename),
+  ("ctags",	keepGoing createCTagsFileCmd, 	completeFilename),
+  ("type",	keepGoing typeOfExpr,		completeIdentifier),
+  ("kind",	keepGoing kindOfType,		completeIdentifier),
+  ("unset",	keepGoing unsetOptions,		completeNone), -- ToDo
+  ("undef",     keepGoing undefineMacro,	completeNone), -- ToDo
+  ("quit",	quit,				completeNone)
   ]
 
 keepGoing :: (String -> GHCi ()) -> (String -> GHCi Bool)
@@ -137,6 +146,7 @@ helpText =
  "   :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\n" ++
+ "   :main [<arguments> ...]     run the main function with the given arguments\n" ++
  "   :reload                     reload the current module set\n" ++
  "\n" ++
  "   :set <option> ...           set options\n" ++
@@ -194,19 +204,18 @@ interactiveUI session srcs maybe_expr = do
 
 #ifdef USE_READLINE
    Readline.initialize
-#endif
+   Readline.setAttemptedCompletionFunction (Just completeWord)
+   --Readline.parseAndBind "set show-all-if-ambiguous 1"
 
-#if defined(mingw32_HOST_OS)
-    -- The win32 Console API mutates the first character of 
-    -- type-ahead when reading from it in a non-buffered manner. Work
-    -- around this by flushing the input buffer of type-ahead characters,
-    -- but only if stdin is available.
-   flushed <- IO.try (GHC.ConsoleHandler.flushConsole stdin)
-   case flushed of 
-   	Left err | isDoesNotExistError err -> return ()
-   		 | otherwise -> ioError err
-   	Right () -> return ()
+   let symbols = "!#$%&*+/<=>?@\\^|-~"
+       specials = "(),;[]`{}"
+       spaces = " \t\n"
+       word_break_chars = spaces ++ specials ++ symbols
+
+   Readline.setBasicWordBreakCharacters word_break_chars
+   Readline.setCompleterWordBreakCharacters word_break_chars
 #endif
+
    startGHCi (runGHCi srcs maybe_expr)
 	GHCiState{ progname = "<interactive>",
 		   args = [],
@@ -269,6 +278,18 @@ runGHCi paths maybe_expr = do
 
   case maybe_expr of
 	Nothing -> 
+#if defined(mingw32_HOST_OS)
+          do
+            -- The win32 Console API mutates the first character of 
+            -- type-ahead when reading from it in a non-buffered manner. Work
+            -- around this by flushing the input buffer of type-ahead characters,
+            -- but only if stdin is available.
+            flushed <- io (IO.try (GHC.ConsoleHandler.flushConsole stdin))
+            case flushed of 
+   	     Left err | isDoesNotExistError err -> return ()
+   		      | otherwise -> io (ioError err)
+   	     Right () -> return ()
+#endif
 	    -- enter the interactive loop
 	    interactiveLoop is_tty show_prompt
 	Just expr -> do
@@ -280,15 +301,18 @@ runGHCi paths maybe_expr = do
   io $ do when (verbosity dflags > 0) $ putStrLn "Leaving GHCi."
 
 
-interactiveLoop is_tty show_prompt = do
+interactiveLoop is_tty show_prompt =
   -- Ignore ^C exceptions caught here
   ghciHandleDyn (\e -> case e of 
-			Interrupted -> ghciUnblock (
+			Interrupted -> do
 #if defined(mingw32_HOST_OS)
-						io (putStrLn "") >> 
+				io (putStrLn "")
 #endif
-						interactiveLoop is_tty show_prompt)
-			_other      -> return ()) $ do
+				interactiveLoop is_tty show_prompt
+			_other      -> return ()) $ 
+
+  ghciUnblock $ do -- unblock necessary if we recursed from the 
+		   -- exception handler above.
 
   -- read commands from stdin
 #ifdef USE_READLINE
@@ -371,10 +395,12 @@ readlineLoop = do
    session <- getSession
    (mod,imports) <- io (GHC.getContext session)
    io yield
+   saveSession -- for use by completion
    l <- io (readline (mkPrompt mod imports)
 	  	`finally` setNonBlockingFD 0)
 		-- readline sometimes puts stdin into blocking mode,
 		-- so we need to put it back for the IO library
+   splatSavedSession
    case l of
 	Nothing -> return ()
 	Just l  ->
@@ -481,15 +507,21 @@ specialCommand :: String -> GHCi Bool
 specialCommand ('!':str) = shellEscape (dropWhile isSpace str)
 specialCommand str = do
   let (cmd,rest) = break isSpace str
-  cmds <- io (readIORef commands)
-  case [ (s,f) | (s,f) <- cmds, prefixMatch cmd s ] of
-     []      -> io (hPutStr stdout ("unknown command ':" ++ cmd ++ "'\n" 
+  maybe_cmd <- io (lookupCommand cmd)
+  case maybe_cmd of
+    Nothing -> io (hPutStr stdout ("unknown command ':" ++ cmd ++ "'\n" 
 		                    ++ shortHelpText) >> return False)
-     [(_,f)] -> f (dropWhile isSpace rest)
-     cs      -> io (hPutStrLn stdout ("prefix " ++ cmd ++ 
-			    	      " matches multiple commands (" ++ 
-	         	     	       foldr1 (\a b -> a ++ ',':b) (map fst cs)
-					 ++ ")") >> return False)
+    Just (_,f,_) -> f (dropWhile isSpace rest)
+
+lookupCommand :: String -> IO (Maybe Command)
+lookupCommand str = do
+  cmds <- readIORef commands
+  -- look for exact match first, then the first prefix match
+  case [ c | c <- cmds, str == cmdName c ] of
+     c:_ -> return (Just c)
+     [] -> case [ c | c@(s,_,_) <- cmds, prefixMatch str s ] of
+     		[] -> return Nothing
+     		c:_ -> return (Just c)
 
 -----------------------------------------------------------------------------
 -- To flush buffers for the *interpreted* computation we need
@@ -574,6 +606,12 @@ pprInfo exts (thing, fixity, insts)
 -----------------------------------------------------------------------------
 -- Commands
 
+runMain :: String -> GHCi ()
+runMain args = do
+  let ss = concat $ intersperse "," (map (\ s -> ('"':s)++"\"") (toArgs args))
+  runCommand $ '[': ss ++ "] `System.Environment.withArgs` main"
+  return ()
+
 addModule :: [FilePath] -> GHCi ()
 addModule files = do
   io (revertCAFs)			-- always revert CAFs on load/add.
@@ -592,7 +630,7 @@ changeDirectory dir = do
 	io $ putStr "Warning: changing directory causes all loaded modules to be unloaded,\nbecause the search path has changed.\n"
   io (GHC.setTargets session [])
   io (GHC.load session LoadAllTargets)
-  setContextAfterLoad []
+  setContextAfterLoad session []
   io (GHC.workingDirectoryChanged session)
   dir <- expandPath dir
   io (setCurrentDirectory dir)
@@ -604,7 +642,7 @@ defineMacro s = do
   if (null macro_name) 
 	then throwDyn (CmdLineError "invalid macro name") 
 	else do
-  if (macro_name `elem` map fst cmds) 
+  if (macro_name `elem` map cmdName cmds)
 	then throwDyn (CmdLineError 
 		("command '" ++ macro_name ++ "' is already defined"))
 	else do
@@ -619,7 +657,7 @@ defineMacro s = do
   case maybe_hv of
      Nothing -> return ()
      Just hv -> io (writeIORef commands --
-		    ((macro_name, keepGoing (runMacro hv)) : cmds))
+		    (cmds ++ [(macro_name, keepGoing (runMacro hv), completeNone)]))
 
 runMacro :: GHC.HValue{-String -> IO String-} -> String -> GHCi ()
 runMacro fun s = do
@@ -629,15 +667,15 @@ runMacro fun s = do
 undefineMacro :: String -> GHCi ()
 undefineMacro macro_name = do
   cmds <- io (readIORef commands)
-  if (macro_name `elem` map fst builtin_commands) 
+  if (macro_name `elem` map cmdName builtin_commands) 
 	then throwDyn (CmdLineError
 		("command '" ++ macro_name ++ "' cannot be undefined"))
 	else do
-  if (macro_name `notElem` map fst cmds) 
+  if (macro_name `notElem` map cmdName cmds) 
 	then throwDyn (CmdLineError 
 		("command '" ++ macro_name ++ "' not defined"))
 	else do
-  io (writeIORef commands (filter ((/= macro_name) . fst) cmds))
+  io (writeIORef commands (filter ((/= macro_name) . cmdName) cmds))
 
 
 loadModule :: [(FilePath, Maybe Phase)] -> GHCi SuccessFlag
@@ -672,9 +710,9 @@ loadModule' files = do
 
 checkModule :: String -> GHCi ()
 checkModule m = do
-  let modl = mkModule m
+  let modl = GHC.mkModule m
   session <- getSession
-  result <- io (GHC.checkModule session modl printErrorsAndWarnings)
+  result <- io (GHC.checkModule session modl)
   case result of
     Nothing -> io $ putStrLn "Nothing"
     Just r  -> io $ putStrLn (showSDoc (
@@ -697,25 +735,45 @@ reloadModule "" = do
 reloadModule m = do
   io (revertCAFs)		-- always revert CAFs on reload.
   session <- getSession
-  ok <- io (GHC.load session (LoadUpTo (mkModule m)))
+  ok <- io (GHC.load session (LoadUpTo (GHC.mkModule m)))
   afterLoad ok session
 
 afterLoad ok session = do
   io (revertCAFs)  -- always revert CAFs on load.
   graph <- io (GHC.getModuleGraph session)
-  let mods = map GHC.ms_mod graph
-  mods' <- filterM (io . GHC.isLoaded session) mods
-  setContextAfterLoad mods'
-  modulesLoadedMsg ok mods'
+  graph' <- filterM (io . GHC.isLoaded session . GHC.ms_mod) graph
+  setContextAfterLoad session graph'
+  modulesLoadedMsg ok (map GHC.ms_mod graph')
 
-setContextAfterLoad [] = do
-  session <- getSession
+setContextAfterLoad session [] = do
   io (GHC.setContext session [] [prelude_mod])
-setContextAfterLoad (m:_) = do
-  session <- getSession
-  b <- io (GHC.moduleIsInterpreted session m)
-  if b then io (GHC.setContext session [m] []) 
-       else io (GHC.setContext session []  [prelude_mod,m])
+setContextAfterLoad session ms = do
+  -- load a target if one is available, otherwise load the topmost module.
+  targets <- io (GHC.getTargets session)
+  case [ m | Just m <- map (findTarget ms) targets ] of
+	[]    -> 
+	  let graph' = flattenSCCs (GHC.topSortModuleGraph True ms Nothing) in
+	  load_this (last graph')	  
+	(m:_) -> 
+	  load_this m
+ where
+   findTarget ms t
+    = case filter (`matches` t) ms of
+	[]    -> Nothing
+	(m:_) -> Just m
+
+   summary `matches` Target (TargetModule m) _
+	= GHC.ms_mod summary == m
+   summary `matches` Target (TargetFile f _) _ 
+	| Just f' <- GHC.ml_hs_file (GHC.ms_location summary)	= f == f'
+   summary `matches` target
+	= False
+
+   load_this summary | m <- GHC.ms_mod summary = do
+	b <- io (GHC.moduleIsInterpreted session m)
+	if b then io (GHC.setContext session [m] []) 
+       	     else io (GHC.setContext session []  [prelude_mod,m])
+
 
 modulesLoadedMsg :: SuccessFlag -> [Module] -> GHCi ()
 modulesLoadedMsg ok mods = do
@@ -791,7 +849,7 @@ createTagsFile session tagskind tagFile = do
         is_interpreted <- GHC.moduleIsInterpreted session m
         -- should we just skip these?
         when (not is_interpreted) $
-          throwDyn (CmdLineError ("module '" ++ moduleUserString m ++ "' is not interpreted"))
+          throwDyn (CmdLineError ("module '" ++ moduleString m ++ "' is not interpreted"))
 
         mbModInfo <- GHC.getModuleInfo session m
         let unqual 
@@ -881,7 +939,7 @@ browseCmd m =
 browseModule m exports_only = do
   s <- getSession
 
-  let modl = mkModule m
+  let modl = GHC.mkModule m
   is_interpreted <- io (GHC.moduleIsInterpreted s modl)
   when (not is_interpreted && not exports_only) $
 	throwDyn (CmdLineError ("module '" ++ m ++ "' is not interpreted"))
@@ -940,13 +998,13 @@ separate :: Session -> [String] -> [Module] -> [Module]
   -> GHCi ([Module],[Module])
 separate session []           as bs = return (as,bs)
 separate session (('*':m):ms) as bs = do
-   let modl = mkModule m
+   let modl = GHC.mkModule m
    b <- io (GHC.moduleIsInterpreted session modl)
    if b then separate session ms (modl:as) bs
    	else throwDyn (CmdLineError ("module '" ++ m ++ "' is not interpreted"))
-separate session (m:ms)       as bs = separate session ms as (mkModule m:bs)
+separate session (m:ms)       as bs = separate session ms as (GHC.mkModule m:bs)
 
-prelude_mod = mkModule "Prelude"
+prelude_mod = GHC.mkModule "Prelude"
 
 
 addToContext mods = do
@@ -1124,6 +1182,88 @@ cleanType ty = do
 	then return ty
 	else return $! GHC.dropForAlls ty
 
+-- -----------------------------------------------------------------------------
+-- Completion
+
+#ifdef USE_READLINE
+completeWord :: String -> Int -> Int -> IO (Maybe (String, [String]))
+completeWord w start end = do
+  line <- Readline.getLineBuffer
+  case w of 
+     ':':_ | all isSpace (take (start-1) line) -> wrapCompleter completeCmd w
+     _other
+	| Just c <- is_cmd line -> do
+	   maybe_cmd <- lookupCommand c
+	   case maybe_cmd of
+	     Nothing -> return Nothing
+	     Just (_,_,complete) -> wrapCompleter complete w
+	| otherwise     -> do
+		--printf "complete %s, start = %d, end = %d\n" w start end
+		wrapCompleter completeIdentifier w
+
+is_cmd line 
+ | ((':':w) : _) <- words (dropWhile isSpace line) = Just w
+ | otherwise = Nothing
+
+completeNone w = return []
+
+completeCmd w = do
+  cmds <- readIORef commands
+  return (filter (w `isPrefixOf`) (map (':':) (map cmdName cmds)))
+
+completeIdentifier w = do
+  s <- restoreSession
+  rdrs <- GHC.getRdrNamesInScope s
+  return (filter (w `isPrefixOf`) (map (showSDoc.ppr) rdrs))
+
+completeModule w = do
+  s <- restoreSession
+  dflags <- GHC.getSessionDynFlags s
+  let pkg_mods = allExposedModules dflags
+  return (filter (w `isPrefixOf`) (map (showSDoc.ppr) pkg_mods))
+
+completeHomeModule w = do
+  s <- restoreSession
+  g <- GHC.getModuleGraph s
+  let home_mods = map GHC.ms_mod g
+  return (filter (w `isPrefixOf`) (map (showSDoc.ppr) home_mods))
+
+completeFilename = Readline.filenameCompletionFunction
+
+completeHomeModuleOrFile = unionComplete completeHomeModule completeFilename
+
+unionComplete :: (String -> IO [String]) -> (String -> IO [String]) -> String -> IO [String]
+unionComplete f1 f2 w = do
+  s1 <- f1 w
+  s2 <- f2 w
+  return (s1 ++ s2)
+
+wrapCompleter :: (String -> IO [String]) -> String -> IO (Maybe (String,[String]))
+wrapCompleter fun w =  do
+  strs <- fun w
+  case strs of
+    []  -> return Nothing
+    [x] -> return (Just (x,[]))
+    xs  -> case getCommonPrefix xs of
+		""   -> return (Just ("",xs))
+		pref -> return (Just (pref,xs))
+
+getCommonPrefix :: [String] -> String
+getCommonPrefix [] = ""
+getCommonPrefix (s:ss) = foldl common s ss
+  where common s "" = s
+	common "" s = ""
+	common (c:cs) (d:ds)
+	   | c == d = c : common cs ds
+	   | otherwise = ""
+
+allExposedModules :: DynFlags -> [Module]
+allExposedModules dflags 
+ = map GHC.mkModule (concat (map exposedModules (filter exposed (eltsUFM pkg_db))))
+ where
+  pkg_db = pkgIdMap (pkgState dflags)
+#endif
+
 -----------------------------------------------------------------------------
 -- GHCi monad
 
@@ -1160,6 +1300,12 @@ setGHCiState s = GHCi $ \r -> writeIORef r s
 -- for convenience...
 getSession = getGHCiState >>= return . session
 
+GLOBAL_VAR(saved_sess, no_saved_sess, Session)
+no_saved_sess = error "no saved_ses"
+saveSession = getSession >>= io . writeIORef saved_sess
+splatSavedSession = io (writeIORef saved_sess no_saved_sess)
+restoreSession = readIORef saved_sess
+
 getDynFlags = do
   s <- getSession
   io (GHC.getSessionDynFlags s)