X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fghci%2FInteractiveUI.hs;h=f8ee7bf1b8d5a4ec7fb65566e983fc37fd4ab2a1;hb=e68a5b608d7ac55f133481d9e428119850668e7a;hp=0bf37dc4005e408893fc4663c9dc5d34b22a9528;hpb=8d180b0dd5b3796c96b162464b93ab1cacc3b789;p=ghc-hetmet.git

diff --git a/ghc/compiler/ghci/InteractiveUI.hs b/ghc/compiler/ghci/InteractiveUI.hs
index 0bf37dc..f8ee7bf 100644
--- a/ghc/compiler/ghci/InteractiveUI.hs
+++ b/ghc/compiler/ghci/InteractiveUI.hs
@@ -16,19 +16,23 @@ module InteractiveUI (
 -- The GHC interface
 import qualified GHC
 import GHC		( Session, verbosity, dopt, DynFlag(..), Target(..),
-			  TargetId(..),
-			  mkModule, pprModule, Type, Module, SuccessFlag(..),
+			  TargetId(..), DynFlags(..),
+			  pprModule, Type, Module, SuccessFlag(..),
 			  TyThing(..), Name, LoadHowMuch(..), Phase,
 			  GhcException(..), showGhcException,
 			  CheckedModule(..), SrcLoc )
+import DynFlags         ( allFlags )
+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 )
@@ -74,6 +78,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) )
@@ -91,30 +96,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, 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,	False, completeFilename),
+  ("browse",    keepGoing browseCmd,		False, completeModule),
+  ("cd",    	keepGoing changeDirectory, 	False, completeFilename),
+  ("def",	keepGoing defineMacro,		False, completeIdentifier),
+  ("help",	keepGoing help,			False, completeNone),
+  ("?",		keepGoing help,			False, completeNone),
+  ("info",      keepGoing info,			False, completeIdentifier),
+  ("load",	keepGoingPaths loadModule_,	False, completeHomeModuleOrFile),
+  ("module",	keepGoing setContext,		False, completeModule),
+  ("main",	keepGoing runMain,		False, completeIdentifier),
+  ("reload",	keepGoing reloadModule,		False, completeNone),
+  ("check",	keepGoing checkModule,		False, completeHomeModule),
+  ("set",	keepGoing setCmd,		True,  completeSetOptions),
+  ("show",	keepGoing showCmd,		False, completeNone),
+  ("etags",	keepGoing createETagsFileCmd,	False, completeFilename),
+  ("ctags",	keepGoing createCTagsFileCmd, 	False, completeFilename),
+  ("type",	keepGoing typeOfExpr,		False, completeIdentifier),
+  ("kind",	keepGoing kindOfType,		False, completeIdentifier),
+  ("unset",	keepGoing unsetOptions,		True,  completeSetOptions),
+  ("undef",     keepGoing undefineMacro,	False, completeMacro),
+  ("quit",	quit,				False, completeNone)
   ]
 
 keepGoing :: (String -> GHCi ()) -> (String -> GHCi Bool)
@@ -138,6 +147,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" ++
@@ -195,6 +205,16 @@ interactiveUI session srcs maybe_expr = do
 
 #ifdef USE_READLINE
    Readline.initialize
+   Readline.setAttemptedCompletionFunction (Just completeWord)
+   --Readline.parseAndBind "set show-all-if-ambiguous 1"
+
+   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)
@@ -282,15 +302,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
@@ -373,10 +396,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  ->
@@ -483,15 +508,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
@@ -576,6 +607,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.
@@ -606,7 +643,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
@@ -621,7 +658,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), False, completeNone)]))
 
 runMacro :: GHC.HValue{-String -> IO String-} -> String -> GHCi ()
 runMacro fun s = do
@@ -631,15 +668,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
@@ -674,7 +711,7 @@ 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)
   case result of
@@ -699,7 +736,7 @@ 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
@@ -813,7 +850,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 
@@ -903,7 +940,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"))
@@ -962,13 +999,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
@@ -1146,6 +1183,122 @@ cleanType ty = do
 	then return ty
 	else return $! GHC.dropForAlls ty
 
+-- -----------------------------------------------------------------------------
+-- Completion
+
+completeNone :: String -> IO [String]
+completeNone w = return []
+
+#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
+           let (n,w') = selectWord (words' 0 line)
+	   case maybe_cmd of
+	     Nothing -> return Nothing
+	     Just (_,_,False,complete) -> wrapCompleter complete w
+	     Just (_,_,True,complete) -> let complete' w = do rets <- complete w
+                                                              return (map (drop n) rets)
+                                         in wrapCompleter complete' w'
+	| otherwise     -> do
+		--printf "complete %s, start = %d, end = %d\n" w start end
+		wrapCompleter completeIdentifier w
+    where words' _ [] = []
+          words' n str = let (w,r) = break isSpace str
+                             (s,r') = span isSpace r
+                         in (n,w):words' (n+length w+length s) r'
+          -- In a Haskell expression we want to parse 'a-b' as three words
+          -- where a compiler flag (ie. -fno-monomorphism-restriction) should
+          -- only be a single word.
+          selectWord [] = (0,w)
+          selectWord ((offset,x):xs)
+              | offset+length x >= start = (start-offset,take (end-offset) x)
+              | otherwise = selectWord xs
+
+is_cmd line 
+ | ((':':w) : _) <- words (dropWhile isSpace line) = Just w
+ | otherwise = Nothing
+
+completeCmd w = do
+  cmds <- readIORef commands
+  return (filter (w `isPrefixOf`) (map (':':) (map cmdName cmds)))
+
+completeMacro w = do
+  cmds <- readIORef commands
+  let cmds' = [ cmd | cmd <- map cmdName cmds, cmd `elem` map cmdName builtin_commands ]
+  return (filter (w `isPrefixOf`) 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))
+
+completeSetOptions w = do
+  return (filter (w `isPrefixOf`) options)
+    where options = "args":"prog":allFlags
+
+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)
+#else
+completeCmd        = completeNone
+completeMacro      = completeNone
+completeIdentifier = completeNone
+completeModule     = completeNone
+completeHomeModule = completeNone
+completeSetOptions = completeNone
+completeFilename   = completeNone
+completeHomeModuleOrFile=completeNone
+#endif
+
 -----------------------------------------------------------------------------
 -- GHCi monad
 
@@ -1182,6 +1335,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)