import IO ( isPermissionError )
import System.Posix.Internals
+#if __GLASGOW_HASKELL__ >= 611
+import GHC.IO.Handle.FD (fdToHandle)
+#else
import GHC.Handle (fdToHandle)
+#endif
#if defined(GLOB)
import System.Process(runInteractiveCommand)
(cli,_,[]) | FlagVersion `elem` cli ->
bye ourCopyright
(cli,nonopts,[]) ->
- runit cli nonopts
+ case getVerbosity Normal cli of
+ Right v -> runit v cli nonopts
+ Left err -> die err
(_,_,errors) -> do
prog <- getProgramName
die (concat errors ++ usageInfo (usageHeader prog) flags)
| FlagNamesOnly
| FlagIgnoreCase
| FlagNoUserDb
+ | FlagVerbosity (Maybe String)
deriving Eq
flags :: [OptDescr Flag]
Option [] ["names-only"] (NoArg FlagNamesOnly)
"only print package names, not versions; can only be used with list --simple-output",
Option [] ["ignore-case"] (NoArg FlagIgnoreCase)
- "ignore case for substring matching"
+ "ignore case for substring matching",
+ Option ['v'] ["verbose"] (OptArg FlagVerbosity "Verbosity")
+ "verbosity level (0-2, default 1)"
]
+data Verbosity = Silent | Normal | Verbose
+ deriving (Show, Eq, Ord)
+
+getVerbosity :: Verbosity -> [Flag] -> Either String Verbosity
+getVerbosity v [] = Right v
+getVerbosity _ (FlagVerbosity Nothing : fs) = getVerbosity Verbose fs
+getVerbosity _ (FlagVerbosity (Just "0") : fs) = getVerbosity Silent fs
+getVerbosity _ (FlagVerbosity (Just "1") : fs) = getVerbosity Normal fs
+getVerbosity _ (FlagVerbosity (Just "2") : fs) = getVerbosity Verbose fs
+getVerbosity _ (FlagVerbosity v : _) = Left ("Bad verbosity: " ++ show v)
+getVerbosity v (_ : fs) = getVerbosity v fs
+
deprecFlags :: [OptDescr Flag]
deprecFlags = [
-- put deprecated flags here
data PackageArg = Id PackageIdentifier | Substring String (String->Bool)
-runit :: [Flag] -> [String] -> IO ()
-runit cli nonopts = do
+runit :: Verbosity -> [Flag] -> [String] -> IO ()
+runit verbosity cli nonopts = do
installSignalHandlers -- catch ^C and clean up
prog <- getProgramName
let
glob filename >>= print
#endif
["register", filename] ->
- registerPackage filename cli auto_ghci_libs False force
+ registerPackage filename verbosity cli auto_ghci_libs False force
["update", filename] ->
- registerPackage filename cli auto_ghci_libs True force
+ registerPackage filename verbosity cli auto_ghci_libs True force
["unregister", pkgid_str] -> do
pkgid <- readGlobPkgId pkgid_str
- unregisterPackage pkgid cli force
+ unregisterPackage pkgid verbosity cli force
["expose", pkgid_str] -> do
pkgid <- readGlobPkgId pkgid_str
- exposePackage pkgid cli force
+ exposePackage pkgid verbosity cli force
["hide", pkgid_str] -> do
pkgid <- readGlobPkgId pkgid_str
- hidePackage pkgid cli force
+ hidePackage pkgid verbosity cli force
["list"] -> do
listPackages cli Nothing Nothing
["list", pkgid_str] ->
let err_msg = "missing --global-conf option, location of global package.conf unknown\n"
global_conf <-
case [ f | FlagGlobalConfig f <- my_flags ] of
- [] -> do mb_dir <- getExecDir "/bin/ghc-pkg.exe"
+ [] -> do mb_dir <- getLibDir
case mb_dir of
Nothing -> die err_msg
Just dir ->
- do let path1 = dir </> "package.conf"
- path2 = dir </> ".." </> ".." </> ".."
- </> "inplace-datadir"
- </> "package.conf"
- exists1 <- doesFileExist path1
- exists2 <- doesFileExist path2
- if exists1 then return path1
- else if exists2 then return path2
- else die "Can't find package.conf"
+ do let path = dir </> "package.conf"
+ exists <- doesFileExist path
+ unless exists $ die "Can't find package.conf"
+ return path
fs -> return (last fs)
let global_conf_dir = global_conf ++ ".d"
-- Registering
registerPackage :: FilePath
+ -> Verbosity
-> [Flag]
-> Bool -- auto_ghci_libs
-> Bool -- update
-> Force
-> IO ()
-registerPackage input my_flags auto_ghci_libs update force = do
+registerPackage input verbosity my_flags auto_ghci_libs update force = do
(db_stack, Just to_modify) <- getPkgDatabases True my_flags
let
db_to_operate_on = my_head "register" $
s <-
case input of
"-" -> do
- putStr "Reading package info from stdin ... "
+ when (verbosity >= Normal) $
+ putStr "Reading package info from stdin ... "
getContents
f -> do
- putStr ("Reading package info from " ++ show f ++ " ... ")
+ when (verbosity >= Normal) $
+ putStr ("Reading package info from " ++ show f ++ " ... ")
readFile f
expanded <- expandEnvVars s force
pkg <- parsePackageInfo expanded
- putStrLn "done."
+ when (verbosity >= Normal) $
+ putStrLn "done."
let unversioned_deps = filter (not . realVersion) (depends pkg)
unless (null unversioned_deps) $
validatePackageConfig pkg truncated_stack auto_ghci_libs update force
let new_details = filter not_this (snd db_to_operate_on) ++ [pkg]
not_this p = package p /= package pkg
- writeNewConfig to_modify new_details
+ writeNewConfig verbosity to_modify new_details
parsePackageInfo
:: String
-- -----------------------------------------------------------------------------
-- Exposing, Hiding, Unregistering are all similar
-exposePackage :: PackageIdentifier -> [Flag] -> Force -> IO ()
+exposePackage :: PackageIdentifier -> Verbosity -> [Flag] -> Force -> IO ()
exposePackage = modifyPackage (\p -> [p{exposed=True}])
-hidePackage :: PackageIdentifier -> [Flag] -> Force -> IO ()
+hidePackage :: PackageIdentifier -> Verbosity -> [Flag] -> Force -> IO ()
hidePackage = modifyPackage (\p -> [p{exposed=False}])
-unregisterPackage :: PackageIdentifier -> [Flag] -> Force -> IO ()
+unregisterPackage :: PackageIdentifier -> Verbosity -> [Flag] -> Force -> IO ()
unregisterPackage = modifyPackage (\_ -> [])
modifyPackage
:: (InstalledPackageInfo -> [InstalledPackageInfo])
-> PackageIdentifier
+ -> Verbosity
-> [Flag]
-> Force
-> IO ()
-modifyPackage fn pkgid my_flags force = do
+modifyPackage fn pkgid verbosity my_flags force = do
(db_stack, Just _to_modify) <- getPkgDatabases True{-modify-} my_flags
((db_name, pkgs), ps) <- fmap head $ findPackagesByDB db_stack (Id pkgid)
-- let ((db_name, pkgs) : rest_of_stack) = db_stack
" would break the following packages: "
++ unwords (map display newly_broken))
- writeNewConfig db_name new_config
+ writeNewConfig verbosity db_name new_config
-- -----------------------------------------------------------------------------
-- Listing packages
hiddenModules = map convert h }
where convert = fromJust . simpleParse
-writeNewConfig :: FilePath -> [InstalledPackageInfo] -> IO ()
-writeNewConfig filename packages = do
- hPutStr stdout "Writing new package config file... "
+writeNewConfig :: Verbosity -> FilePath -> [InstalledPackageInfo] -> IO ()
+writeNewConfig verbosity filename packages = do
+ when (verbosity >= Normal) $
+ hPutStr stdout "Writing new package config file... "
createDirectoryIfMissing True $ takeDirectory filename
let shown = concat $ intersperse ",\n "
$ map (show . convertPackageInfoOut) packages
if isPermissionError e
then die (filename ++ ": you don't have permission to modify this file")
else ioError e
- hPutStrLn stdout "done."
+ when (verbosity >= Normal) $
+ hPutStrLn stdout "done."
-----------------------------------------------------------------------------
-- Sanity-check a new package config, and automatically build GHCi libs
| auto_build = autoBuildGHCiLib batch_lib_dir batch_lib_file ghci_lib_file
| otherwise = do
m <- doesFileExistOnPath ghci_lib_file dirs
- when (isNothing m) $
+ when (isNothing m && ghci_lib_file /= "HSrts.o") $
hPutStrLn stderr ("warning: can't find GHCi lib " ++ ghci_lib_file)
where
ghci_lib_file = lib <.> "o"
#if defined(darwin_HOST_OS)
r <- rawSystem "ld" ["-r","-x","-o",ghci_lib_file,"-all_load",batch_lib_file]
#elif defined(mingw32_HOST_OS)
- execDir <- getExecDir "/bin/ghc-pkg.exe"
+ execDir <- getLibDir
r <- rawSystem (maybe "" (++"/gcc-lib/") execDir++"ld") ["-r","-x","-o",ghci_lib_file,"--whole-archive",batch_lib_file]
#else
r <- rawSystem "ld" ["-r","-x","-o",ghci_lib_file,"--whole-archive",batch_lib_file]
unDosifyPath :: FilePath -> FilePath
unDosifyPath xs = subst '\\' '/' xs
-getExecDir :: String -> IO (Maybe String)
+getLibDir :: IO (Maybe String)
+getLibDir = fmap (fmap (</> "lib")) $ getExecDir "/bin/ghc-pkg.exe"
+
-- (getExecDir cmd) returns the directory in which the current
-- executable, which should be called 'cmd', is running
-- So if the full path is /a/b/c/d/e, and you pass "d/e" as cmd,
-- you'll get "/a/b/c" back as the result
-getExecDir cmd
- = allocaArray len $ \buf -> do
- ret <- getModuleFileName nullPtr buf len
- if ret == 0 then return Nothing
- else do s <- peekCString buf
- return (Just (reverse (drop (length cmd)
- (reverse (unDosifyPath s)))))
- where
- len = 2048::Int -- Plenty, PATH_MAX is 512 under Win32.
+getExecDir :: String -> IO (Maybe String)
+getExecDir cmd =
+ getExecPath >>= maybe (return Nothing) removeCmdSuffix
+ where initN n = reverse . drop n . reverse
+ removeCmdSuffix = return . Just . initN (length cmd) . unDosifyPath
+
+getExecPath :: IO (Maybe String)
+getExecPath =
+ allocaArray len $ \buf -> do
+ ret <- getModuleFileName nullPtr buf len
+ if ret == 0 then return Nothing
+ else liftM Just $ peekCString buf
+ where len = 2048 -- Plenty, PATH_MAX is 512 under Win32.
+
+foreign import stdcall unsafe "GetModuleFileNameA"
+ getModuleFileName :: Ptr () -> CString -> Int -> IO Int32
-foreign import stdcall unsafe "GetModuleFileNameA"
- getModuleFileName :: Ptr () -> CString -> Int -> IO Int32
#else
-getExecDir :: String -> IO (Maybe String)
-getExecDir _ = return Nothing
+getLibDir :: IO (Maybe String)
+getLibDir = return Nothing
#endif
-----------------------------------------
oflags = rw_flags .|. o_EXCL
+#if __GLASGOW_HASKELL__ < 611
+ withFilePath = withCString
+#endif
+
findTempName x = do
- fd <- withCString filepath $ \ f ->
+ fd <- withFilePath filepath $ \ f ->
c_open f oflags 0o666
if fd < 0
then do