+ %
+% (c) The University of Glasgow, 2006
%
-% (c) The University of Glasgow, 2000
+% Package manipulation
%
-\section{Package manipulation}
-
\begin{code}
module Packages (
module PackageConfig,
extendPackageConfigMap, dumpPackages,
-- * Reading the package config, and processing cmdline args
- PackageIdH(..), isHomePackage,
PackageState(..),
- mkPackageState,
initPackages,
getPackageDetails,
- checkForPackageConflicts,
lookupModuleInAllPackages,
- HomeModules, mkHomeModules, isHomeModule,
-
-- * Inspecting the set of packages in scope
getPackageIncludePath,
getPackageCIncludes,
getPackageExtraCcOpts,
getPackageFrameworkPath,
getPackageFrameworks,
- getExplicitPackagesAnd,
+ getPreloadPackagesAnd,
-- * Utils
isDllName
#include "HsVersions.h"
import PackageConfig
-import SysTools ( getTopDir, getPackageConfigPath )
import ParsePkgConf ( loadPackageConfig )
import DynFlags ( dopt, DynFlag(..), DynFlags(..), PackageFlag(..) )
import StaticFlags ( opt_Static )
import Name ( Name, nameModule_maybe )
import UniqFM
import Module
-import FiniteMap
-import UniqSet
import Util
import Maybes ( expectJust, MaybeErr(..) )
import Panic
import Outputable
-#if __GLASGOW_HASKELL__ >= 603
-import System.Directory ( getAppUserDataDirectory )
-#else
+#if __GLASGOW_HASKELL__ < 603
import Compat.Directory ( getAppUserDataDirectory )
#endif
import Distribution.InstalledPackageInfo
import Distribution.Package
import Distribution.Version
-import System.Directory ( doesFileExist, doesDirectoryExist,
- getDirectoryContents )
-import Control.Monad ( foldM )
-import Data.List ( nub, partition, sortBy, isSuffixOf )
import FastString
-import EXCEPTION ( throwDyn )
import ErrUtils ( debugTraceMsg, putMsg, Message )
+import System.Directory
+import Data.Maybe
+import Control.Monad
+import Data.List
+import Control.Exception ( throwDyn )
+
-- ---------------------------------------------------------------------------
-- The Package state
-- Let depExposedPackages be the transitive closure from exposedPackages of
-- their dependencies.
--
--- * It is an error for any two packages in depExposedPackages to provide the
--- same module.
---
--- * When searching for a module from an explicit import declaration,
+-- * When searching for a module from an preload import declaration,
-- only the exposed modules in exposedPackages are valid.
--
-- * When searching for a module from an implicit import, all modules
-- * When linking in a comp manager mode, we link in packages the
-- program depends on (the compiler knows this list by the
-- time it gets to the link step). Also, we link in all packages
--- which were mentioned with explicit -package flags on the command-line,
+-- which were mentioned with preload -package flags on the command-line,
-- or are a transitive dependency of same, or are "base"/"rts".
-- The reason for (b) is that we might need packages which don't
-- contain any Haskell modules, and therefore won't be discovered
-- by the normal mechanism of dependency tracking.
-
--- One important thing that the package state provides is a way to
--- tell, for a given module, whether it is part of the current package
--- or not. We need to know this for two reasons:
---
--- * generating cross-DLL calls is different from intra-DLL calls
--- (see below).
--- * we don't record version information in interface files for entities
--- in a different package.
---
-- Notes on DLLs
-- ~~~~~~~~~~~~~
-- When compiling module A, which imports module B, we need to
-- in a different DLL, by setting the DLL flag.
data PackageState = PackageState {
+ pkgIdMap :: PackageConfigMap, -- PackageId -> PackageConfig
+ -- The exposed flags are adjusted according to -package and
+ -- -hide-package flags, and -ignore-package removes packages.
- explicitPackages :: [PackageId],
+ preloadPackages :: [PackageId],
-- The packages we're going to link in eagerly. This list
-- should be in reverse dependency order; that is, a package
-- is always mentioned before the packages it depends on.
- origPkgIdMap :: PackageConfigMap, -- PackageId -> PackageConfig
- -- the full package database
-
- pkgIdMap :: PackageConfigMap, -- PackageId -> PackageConfig
- -- Derived from origPkgIdMap.
- -- The exposed flags are adjusted according to -package and
- -- -hide-package flags, and -ignore-package removes packages.
-
- moduleToPkgConfAll :: ModuleEnv [(PackageConfig,Bool)],
+ moduleToPkgConfAll :: UniqFM [(PackageConfig,Bool)] -- ModuleEnv mapping
-- Derived from pkgIdMap.
-- Maps Module to (pkgconf,exposed), where pkgconf is the
-- PackageConfig for the package containing the module, and
-- exposed is True if the package exposes that module.
-
- -- The PackageIds of some known packages
- basePackageId :: PackageIdH,
- rtsPackageId :: PackageIdH,
- haskell98PackageId :: PackageIdH,
- thPackageId :: PackageIdH
}
-data PackageIdH
- = HomePackage -- The "home" package is the package curently
- -- being compiled
- | ExtPackage PackageId -- An "external" package is any other package
-
-
-isHomePackage :: PackageIdH -> Bool
-isHomePackage HomePackage = True
-isHomePackage (ExtPackage _) = False
-
-- A PackageConfigMap maps a PackageId to a PackageConfig
type PackageConfigMap = UniqFM PackageConfig
-- ----------------------------------------------------------------------------
-- Loading the package config files and building up the package state
--- | Call this after parsing the DynFlags. It reads the package
+-- | Call this after 'DynFlags.parseDynFlags'. It reads the package
-- configuration files, and sets up various internal tables of package
-- information, according to the package-related flags on the
-- command-line (@-package@, @-hide-package@ etc.)
-initPackages :: DynFlags -> IO DynFlags
+--
+-- Returns a list of packages to link in if we're doing dynamic linking.
+-- This list contains the packages that the user explicitly mentioned with
+-- -package flags.
+--
+-- 'initPackages' can be called again subsequently after updating the
+-- 'packageFlags' field of the 'DynFlags', and it will update the
+-- 'packageState' in 'DynFlags' and return a list of packages to
+-- link in.
+initPackages :: DynFlags -> IO (DynFlags, [PackageId])
initPackages dflags = do
- pkg_map <- readPackageConfigs dflags;
- state <- mkPackageState dflags pkg_map
- return dflags{ pkgState = state }
+ pkg_db <- case pkgDatabase dflags of
+ Nothing -> readPackageConfigs dflags
+ Just db -> return db
+ (pkg_state, preload, this_pkg)
+ <- mkPackageState dflags pkg_db [] (thisPackage dflags)
+ return (dflags{ pkgDatabase = Just pkg_db,
+ pkgState = pkg_state,
+ thisPackage = this_pkg },
+ preload)
-- -----------------------------------------------------------------------------
-- Reading the package database(s)
getSystemPackageConfigs :: DynFlags -> IO [FilePath]
getSystemPackageConfigs dflags = do
-- System one always comes first
- system_pkgconf <- getPackageConfigPath
+ let system_pkgconf = systemPackageConfig dflags
-- allow package.conf.d to contain a bunch of .conf files
-- containing package specifications. This is an easier way
readPackageConfig dflags pkg_map conf_file = do
debugTraceMsg dflags 2 (text "Using package config file:" <+> text conf_file)
proto_pkg_configs <- loadPackageConfig conf_file
- top_dir <- getTopDir
- let pkg_configs1 = mungePackagePaths top_dir proto_pkg_configs
+ let top_dir = topDir dflags
+ pkg_configs1 = mungePackagePaths top_dir proto_pkg_configs
pkg_configs2 = maybeHidePackages dflags pkg_configs1
return (extendPackageConfigMap pkg_map pkg_configs2)
-- -----------------------------------------------------------------------------
--- When all the command-line options are in, we can process our package
--- settings and populate the package state.
-
-mkPackageState :: DynFlags -> PackageConfigMap -> IO PackageState
-mkPackageState dflags orig_pkg_db = do
- --
- -- Modify the package database according to the command-line flags
- -- (-package, -hide-package, -ignore-package, -hide-all-packages).
- --
- -- Also, here we build up a set of the packages mentioned in -package
- -- flags on the command line; these are called the "explicit" packages.
- -- we link these packages in eagerly. The explicit set should contain
- -- at least rts & base, which is why we pretend that the command line
- -- contains -package rts & -package base.
- --
- let
- flags = reverse (packageFlags dflags)
-
- procflags pkgs expl [] = return (pkgs,expl)
- procflags pkgs expl (ExposePackage str : flags) = do
- case pick str pkgs of
+-- Modify our copy of the package database based on a package flag
+-- (-package, -hide-package, -ignore-package).
+
+applyPackageFlag
+ :: [PackageConfig] -- Initial database
+ -> PackageFlag -- flag to apply
+ -> IO [PackageConfig] -- new database
+
+applyPackageFlag pkgs flag =
+ case flag of
+ ExposePackage str ->
+ case matchingPackages str pkgs of
Nothing -> missingPackageErr str
- Just (p,ps) -> procflags (p':ps') expl' flags
- where pkgid = packageConfigId p
- p' = p {exposed=True}
- ps' = hideAll (pkgName (package p)) ps
- expl' = addOneToUniqSet expl pkgid
- procflags pkgs expl (HidePackage str : flags) = do
- case partition (matches str) pkgs of
- ([],_) -> missingPackageErr str
- (ps,qs) -> procflags (map hide ps ++ qs) expl flags
+ Just (p:ps,qs) -> return (p':ps')
+ where p' = p {exposed=True}
+ ps' = hideAll (pkgName (package p)) (ps++qs)
+
+ HidePackage str ->
+ case matchingPackages str pkgs of
+ Nothing -> missingPackageErr str
+ Just (ps,qs) -> return (map hide ps ++ qs)
where hide p = p {exposed=False}
- procflags pkgs expl (IgnorePackage str : flags) = do
- case partition (matches str) pkgs of
- (ps,qs) -> procflags qs expl flags
+
+ IgnorePackage str ->
+ case matchingPackages str pkgs of
+ Nothing -> return pkgs
+ Just (ps,qs) -> return qs
-- missing package is not an error for -ignore-package,
-- because a common usage is to -ignore-package P as
-- a preventative measure just in case P exists.
+ where
+ -- When a package is requested to be exposed, we hide all other
+ -- packages with the same name.
+ hideAll name ps = map maybe_hide ps
+ where maybe_hide p | pkgName (package p) == name = p {exposed=False}
+ | otherwise = p
- pick str pkgs
- = case partition (matches str) pkgs of
- ([],_) -> Nothing
- (ps,rest) ->
- case sortBy (flip (comparing (pkgVersion.package))) ps of
- (p:ps) -> Just (p, ps ++ rest)
- _ -> panic "Packages.pick"
-
- comparing f a b = f a `compare` f b
- -- A package named on the command line can either include the
+matchingPackages :: String -> [PackageConfig]
+ -> Maybe ([PackageConfig], [PackageConfig])
+matchingPackages str pkgs
+ = case partition (matches str) pkgs of
+ ([],_) -> Nothing
+ (ps,rest) -> Just (sortByVersion ps, rest)
+ where
+ -- A package named on the command line can either include the
-- version, or just the name if it is unambiguous.
matches str p
= str == showPackageId (package p)
|| str == pkgName (package p)
- -- When a package is requested to be exposed, we hide all other
- -- packages with the same name.
- hideAll name ps = map maybe_hide ps
- where maybe_hide p | pkgName (package p) == name = p {exposed=False}
- | otherwise = p
- --
- (pkgs1,explicit) <- procflags (eltsUFM orig_pkg_db) emptyUniqSet flags
- --
- -- hide all packages for which there is also a later version
- -- that is already exposed. This just makes it non-fatal to have two
- -- versions of a package exposed, which can happen if you install a
- -- later version of a package in the user database, for example.
- --
- let maybe_hide p
+
+pickPackages pkgs strs =
+ [ p | p <- strs, Just (p:ps,_) <- [matchingPackages p pkgs] ]
+
+sortByVersion = sortBy (flip (comparing (pkgVersion.package)))
+comparing f a b = f a `compare` f b
+
+-- -----------------------------------------------------------------------------
+-- Hide old versions of packages
+
+--
+-- hide all packages for which there is also a later version
+-- that is already exposed. This just makes it non-fatal to have two
+-- versions of a package exposed, which can happen if you install a
+-- later version of a package in the user database, for example.
+--
+hideOldPackages :: DynFlags -> [PackageConfig] -> IO [PackageConfig]
+hideOldPackages dflags pkgs = mapM maybe_hide pkgs
+ where maybe_hide p
| not (exposed p) = return p
| (p' : _) <- later_versions = do
debugTraceMsg dflags 2 $
- (ptext SLIT("hiding package") <+> text (showPackageId (package p)) <+>
+ (ptext SLIT("hiding package") <+>
+ text (showPackageId (package p)) <+>
ptext SLIT("to avoid conflict with later version") <+>
text (showPackageId (package p')))
return (p {exposed=False})
| otherwise = return p
where myname = pkgName (package p)
myversion = pkgVersion (package p)
- later_versions = [ p | p <- pkgs1, exposed p,
+ later_versions = [ p | p <- pkgs, exposed p,
let pkg = package p,
pkgName pkg == myname,
pkgVersion pkg > myversion ]
- a_later_version_is_exposed
- = not (null later_versions)
- pkgs2 <- mapM maybe_hide pkgs1
- --
- -- Eliminate any packages which have dangling dependencies (perhaps
- -- because the package was removed by -ignore-package).
- --
- let
- elimDanglingDeps pkgs =
- case partition (not.null.snd) (map (getDanglingDeps pkgs) pkgs) of
- ([],ps) -> return (map fst ps)
- (ps,qs) -> do
- mapM_ reportElim ps
- elimDanglingDeps (map fst qs)
-
- reportElim (p, deps) =
- debugTraceMsg dflags 2 $
- (ptext SLIT("package") <+> pprPkg p <+>
- ptext SLIT("will be ignored due to missing dependencies:") $$
- nest 2 (hsep (map (text.showPackageId) deps)))
+-- -----------------------------------------------------------------------------
+-- Wired-in packages
- getDanglingDeps pkgs p = (p, filter dangling (depends p))
- where dangling pid = pid `notElem` all_pids
- all_pids = map package pkgs
- --
- pkgs <- elimDanglingDeps pkgs2
- let pkg_db = extendPackageConfigMap emptyPackageConfigMap pkgs
- --
- -- Find the transitive closure of dependencies of exposed
- --
- let exposed_pkgids = [ packageConfigId p | p <- pkgs, exposed p ]
- dep_exposed <- closeDeps pkg_db exposed_pkgids
+findWiredInPackages
+ :: DynFlags
+ -> [PackageConfig] -- database
+ -> [PackageIdentifier] -- preload packages
+ -> PackageId -- this package
+ -> IO ([PackageConfig],
+ [PackageIdentifier],
+ PackageId)
+
+findWiredInPackages dflags pkgs preload this_package = do
--
- -- Look up some known PackageIds
+ -- Now we must find our wired-in packages, and rename them to
+ -- their canonical names (eg. base-1.0 ==> base).
--
let
- lookupPackageByName :: FastString -> PackageIdH
- lookupPackageByName nm =
- case [ conf | p <- dep_exposed,
- Just conf <- [lookupPackage pkg_db p],
- nm == mkFastString (pkgName (package conf)) ] of
- [] -> HomePackage
- (p:ps) -> ExtPackage (mkPackageId (package p))
-
- -- Get the PackageIds for some known packages (we know the names,
- -- but we don't know the versions). Some of these packages might
- -- not exist in the database, so they are Maybes.
- basePackageId = lookupPackageByName basePackageName
- rtsPackageId = lookupPackageByName rtsPackageName
- haskell98PackageId = lookupPackageByName haskell98PackageName
- thPackageId = lookupPackageByName thPackageName
-
- -- add base & rts to the explicit packages
- basicLinkedPackages = [basePackageId,rtsPackageId]
- explicit' = addListToUniqSet explicit
- [ p | ExtPackage p <- basicLinkedPackages ]
- --
- -- Close the explicit packages with their dependencies
+ wired_in_pkgids = [ basePackageId,
+ rtsPackageId,
+ haskell98PackageId,
+ thPackageId ]
+
+ wired_in_names = map packageIdString wired_in_pkgids
+
+ -- find which package corresponds to each wired-in package
+ -- delete any other packages with the same name
+ -- update the package and any dependencies to point to the new
+ -- one.
+ --
+ -- When choosing which package to map to a wired-in package
+ -- name, we prefer exposed packages, and pick the latest
+ -- version. To override the default choice, -hide-package
+ -- could be used to hide newer versions.
+ --
+ findWiredInPackage :: [PackageConfig] -> String
+ -> IO (Maybe PackageIdentifier)
+ findWiredInPackage pkgs wired_pkg =
+ let all_ps = [ p | p <- pkgs, pkgName (package p) == wired_pkg ] in
+ case filter exposed all_ps of
+ [] -> case all_ps of
+ [] -> notfound
+ many -> pick (head (sortByVersion many))
+ many -> pick (head (sortByVersion many))
+ where
+ notfound = do
+ debugTraceMsg dflags 2 $
+ ptext SLIT("wired-in package ")
+ <> text wired_pkg
+ <> ptext SLIT(" not found.")
+ return Nothing
+ pick pkg = do
+ debugTraceMsg dflags 2 $
+ ptext SLIT("wired-in package ")
+ <> text wired_pkg
+ <> ptext SLIT(" mapped to ")
+ <> text (showPackageId (package pkg))
+ return (Just (package pkg))
+
+
+ mb_wired_in_ids <- mapM (findWiredInPackage pkgs) wired_in_names
+ let
+ wired_in_ids = catMaybes mb_wired_in_ids
+
+ deleteOtherWiredInPackages pkgs = filter ok pkgs
+ where ok p = pkgName (package p) `notElem` wired_in_names
+ || package p `elem` wired_in_ids
+
+ updateWiredInDependencies pkgs = map upd_pkg pkgs
+ where upd_pkg p = p{ package = upd_pid (package p),
+ depends = map upd_pid (depends p) }
+
+ upd_pid pid = case filter (== pid) wired_in_ids of
+ [] -> pid
+ (x:_) -> x{ pkgVersion = Version [] [] }
+
+ pkgs1 = deleteOtherWiredInPackages pkgs
+
+ pkgs2 = updateWiredInDependencies pkgs1
+
+ preload1 = map upd_pid preload
+
+ -- we must return an updated thisPackage, just in case we
+ -- are actually compiling one of the wired-in packages
+ Just old_this_pkg = unpackPackageId this_package
+ new_this_pkg = mkPackageId (upd_pid old_this_pkg)
+
+ return (pkgs2, preload1, new_this_pkg)
+
+-- -----------------------------------------------------------------------------
+--
+-- Eliminate any packages which have dangling dependencies (
+-- because the dependency was removed by -ignore-package).
+--
+elimDanglingDeps
+ :: DynFlags
+ -> [PackageConfig]
+ -> [PackageId] -- ignored packages
+ -> IO [PackageConfig]
+
+elimDanglingDeps dflags pkgs ignored =
+ case partition (not.null.snd) (map (getDanglingDeps pkgs ignored) pkgs) of
+ ([],ps) -> return (map fst ps)
+ (ps,qs) -> do
+ mapM_ reportElim ps
+ elimDanglingDeps dflags (map fst qs)
+ (ignored ++ map packageConfigId (map fst ps))
+ where
+ reportElim (p, deps) =
+ debugTraceMsg dflags 2 $
+ (ptext SLIT("package") <+> pprPkg p <+>
+ ptext SLIT("will be ignored due to missing dependencies:") $$
+ nest 2 (hsep (map (text.showPackageId) deps)))
+
+ getDanglingDeps pkgs ignored p = (p, filter dangling (depends p))
+ where dangling pid = mkPackageId pid `elem` ignored
+
+-- -----------------------------------------------------------------------------
+-- When all the command-line options are in, we can process our package
+-- settings and populate the package state.
+
+mkPackageState
+ :: DynFlags
+ -> PackageConfigMap -- initial database
+ -> [PackageId] -- preloaded packages
+ -> PackageId -- this package
+ -> IO (PackageState,
+ [PackageId], -- new packages to preload
+ PackageId) -- this package, might be modified if the current
+
+ -- package is a wired-in package.
+
+mkPackageState dflags orig_pkg_db preload0 this_package = do
--
- dep_explicit <- closeDeps pkg_db (uniqSetToList explicit')
+ -- Modify the package database according to the command-line flags
+ -- (-package, -hide-package, -ignore-package, -hide-all-packages).
--
- -- Build up a mapping from Module -> PackageConfig for all modules.
- -- Discover any conflicts at the same time, and factor in the new exposed
- -- status of each package.
+ let flags = reverse (packageFlags dflags)
+ let pkgs0 = eltsUFM orig_pkg_db
+ pkgs1 <- foldM applyPackageFlag pkgs0 flags
+
+ -- Here we build up a set of the packages mentioned in -package
+ -- flags on the command line; these are called the "preload"
+ -- packages. we link these packages in eagerly. The preload set
+ -- should contain at least rts & base, which is why we pretend that
+ -- the command line contains -package rts & -package base.
--
- let mod_map = mkModuleMap pkg_db dep_exposed
-
- return PackageState{ explicitPackages = dep_explicit,
- origPkgIdMap = orig_pkg_db,
- pkgIdMap = pkg_db,
- moduleToPkgConfAll = mod_map,
- basePackageId = basePackageId,
- rtsPackageId = rtsPackageId,
- haskell98PackageId = haskell98PackageId,
- thPackageId = thPackageId
- }
- -- done!
-
-basePackageName = FSLIT("base")
-rtsPackageName = FSLIT("rts")
-haskell98PackageName = FSLIT("haskell98")
-thPackageName = FSLIT("template-haskell")
- -- Template Haskell libraries in here
+ let new_preload_packages =
+ map package (pickPackages pkgs0 [ p | ExposePackage p <- flags ])
+
+ -- hide packages that are subsumed by later versions
+ pkgs2 <- hideOldPackages dflags pkgs1
+
+ -- sort out which packages are wired in
+ (pkgs3, preload1, new_this_pkg)
+ <- findWiredInPackages dflags pkgs2 new_preload_packages this_package
+
+ let ignored = map packageConfigId $
+ pickPackages pkgs0 [ p | IgnorePackage p <- flags ]
+ pkgs <- elimDanglingDeps dflags pkgs3 ignored
+
+ let pkg_db = extendPackageConfigMap emptyPackageConfigMap pkgs
+ pkgids = map packageConfigId pkgs
+
+ -- add base & rts to the preload packages
+ basicLinkedPackages = filter (flip elemUFM pkg_db)
+ [basePackageId,rtsPackageId]
+ preload2 = nub (basicLinkedPackages ++ map mkPackageId preload1)
+
+ -- Close the preload packages with their dependencies
+ dep_preload <- closeDeps pkg_db (zip preload2 (repeat Nothing))
+ let new_dep_preload = filter (`notElem` preload0) dep_preload
+
+ let pstate = PackageState{ preloadPackages = dep_preload,
+ pkgIdMap = pkg_db,
+ moduleToPkgConfAll = mkModuleMap pkg_db
+ }
+
+ return (pstate, new_dep_preload, new_this_pkg)
+
+
+-- -----------------------------------------------------------------------------
+-- Make the mapping from module to package info
mkModuleMap
:: PackageConfigMap
- -> [PackageId]
- -> ModuleEnv [(PackageConfig, Bool)]
-mkModuleMap pkg_db pkgs = foldr extend_modmap emptyUFM pkgs
+ -> UniqFM [(PackageConfig, Bool)]
+mkModuleMap pkg_db = foldr extend_modmap emptyUFM pkgids
where
- extend_modmap pkgname modmap =
+ pkgids = map packageConfigId (eltsUFM pkg_db)
+
+ extend_modmap pkgid modmap =
addListToUFM_C (++) modmap
[(m, [(pkg, m `elem` exposed_mods)]) | m <- all_mods]
where
- pkg = expectJust "mkModuleMap" (lookupPackage pkg_db pkgname)
- exposed_mods = map mkModule (exposedModules pkg)
- hidden_mods = map mkModule (hiddenModules pkg)
+ pkg = expectJust "mkModuleMap" (lookupPackage pkg_db pkgid)
+ exposed_mods = map mkModuleName (exposedModules pkg)
+ hidden_mods = map mkModuleName (hiddenModules pkg)
all_mods = exposed_mods ++ hidden_mods
--- -----------------------------------------------------------------------------
--- Check for conflicts in the program.
-
--- | A conflict arises if the program contains two modules with the same
--- name, which can arise if the program depends on multiple packages that
--- expose the same module, or if the program depends on a package that
--- contains a module also present in the program (the "home package").
---
-checkForPackageConflicts
- :: DynFlags
- -> [Module] -- modules in the home package
- -> [PackageId] -- packages on which the program depends
- -> MaybeErr Message ()
-
-checkForPackageConflicts dflags mods pkgs = do
- let
- state = pkgState dflags
- pkg_db = pkgIdMap state
- --
- dep_pkgs <- closeDepsErr pkg_db pkgs
-
- let
- extend_modmap pkgname modmap =
- addListToFM_C (++) modmap
- [(m, [(pkg, m `elem` exposed_mods)]) | m <- all_mods]
- where
- pkg = expectJust "checkForPackageConflicts"
- (lookupPackage pkg_db pkgname)
- exposed_mods = map mkModule (exposedModules pkg)
- hidden_mods = map mkModule (hiddenModules pkg)
- all_mods = exposed_mods ++ hidden_mods
-
- mod_map = foldr extend_modmap emptyFM pkgs
- mod_map_list :: [(Module,[(PackageConfig,Bool)])]
- mod_map_list = fmToList mod_map
-
- overlaps = [ (m, map fst ps) | (m,ps@(_:_:_)) <- mod_map_list ]
- --
- if not (null overlaps)
- then Failed (pkgOverlapError overlaps)
- else do
-
- let
- overlap_mods = [ (mod,pkg)
- | mod <- mods,
- Just ((pkg,_):_) <- [lookupFM mod_map mod] ]
- -- will be only one package here
- if not (null overlap_mods)
- then Failed (modOverlapError overlap_mods)
- else do
-
- return ()
-
-pkgOverlapError overlaps = vcat (map msg overlaps)
- where
- msg (mod,pkgs) =
- text "conflict: module" <+> quotes (ppr mod)
- <+> ptext SLIT("is present in multiple packages:")
- <+> hsep (punctuate comma (map pprPkg pkgs))
-
-modOverlapError overlaps = vcat (map msg overlaps)
- where
- msg (mod,pkg) = fsep [
- text "conflict: module",
- quotes (ppr mod),
- ptext SLIT("belongs to the current program/library"),
- ptext SLIT("and also to package"),
- pprPkg pkg ]
-
pprPkg :: PackageConfig -> SDoc
pprPkg p = text (showPackageId (package p))
-- i.e. those packages that were found to be depended on by the
-- current module/program. These can be auto or non-auto packages, it
-- doesn't really matter. The list is always combined with the list
--- of explicit (command-line) packages to determine which packages to
+-- of preload (command-line) packages to determine which packages to
-- use.
getPackageIncludePath :: DynFlags -> [PackageId] -> IO [String]
getPackageIncludePath dflags pkgs = do
- ps <- getExplicitPackagesAnd dflags pkgs
+ ps <- getPreloadPackagesAnd dflags pkgs
return (nub (filter notNull (concatMap includeDirs ps)))
-- includes are in reverse dependency order (i.e. rts first)
getPackageLibraryPath :: DynFlags -> [PackageId] -> IO [String]
getPackageLibraryPath dflags pkgs = do
- ps <- getExplicitPackagesAnd dflags pkgs
+ ps <- getPreloadPackagesAnd dflags pkgs
return (nub (filter notNull (concatMap libraryDirs ps)))
getPackageLinkOpts :: DynFlags -> [PackageId] -> IO [String]
getPackageLinkOpts dflags pkgs = do
- ps <- getExplicitPackagesAnd dflags pkgs
+ ps <- getPreloadPackagesAnd dflags pkgs
let tag = buildTag dflags
rts_tag = rtsBuildTag dflags
let
getPackageExtraCcOpts :: DynFlags -> [PackageId] -> IO [String]
getPackageExtraCcOpts dflags pkgs = do
- ps <- getExplicitPackagesAnd dflags pkgs
+ ps <- getPreloadPackagesAnd dflags pkgs
return (concatMap ccOptions ps)
getPackageFrameworkPath :: DynFlags -> [PackageId] -> IO [String]
getPackageFrameworkPath dflags pkgs = do
- ps <- getExplicitPackagesAnd dflags pkgs
+ ps <- getPreloadPackagesAnd dflags pkgs
return (nub (filter notNull (concatMap frameworkDirs ps)))
getPackageFrameworks :: DynFlags -> [PackageId] -> IO [String]
getPackageFrameworks dflags pkgs = do
- ps <- getExplicitPackagesAnd dflags pkgs
+ ps <- getPreloadPackagesAnd dflags pkgs
return (concatMap frameworks ps)
-- -----------------------------------------------------------------------------
-- | Takes a Module, and if the module is in a package returns
-- @(pkgconf,exposed)@ where pkgconf is the PackageConfig for that package,
-- and exposed is True if the package exposes the module.
-lookupModuleInAllPackages :: DynFlags -> Module -> [(PackageConfig,Bool)]
+lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(PackageConfig,Bool)]
lookupModuleInAllPackages dflags m =
- case lookupModuleEnv (moduleToPkgConfAll (pkgState dflags)) m of
+ case lookupUFM (moduleToPkgConfAll (pkgState dflags)) m of
Nothing -> []
Just ps -> ps
-getExplicitPackagesAnd :: DynFlags -> [PackageId] -> IO [PackageConfig]
-getExplicitPackagesAnd dflags pkgids =
+getPreloadPackagesAnd :: DynFlags -> [PackageId] -> IO [PackageConfig]
+getPreloadPackagesAnd dflags pkgids =
let
state = pkgState dflags
pkg_map = pkgIdMap state
- expl = explicitPackages state
+ preload = preloadPackages state
+ pairs = zip pkgids (repeat Nothing)
in do
- all_pkgs <- throwErr (foldM (add_package pkg_map) expl pkgids)
+ all_pkgs <- throwErr (foldM (add_package pkg_map) preload pairs)
return (map (getPackageDetails state) all_pkgs)
-- Takes a list of packages, and returns the list with dependencies included,
-- in reverse dependency order (a package appears before those it depends on).
-closeDeps :: PackageConfigMap -> [PackageId] -> IO [PackageId]
+closeDeps :: PackageConfigMap -> [(PackageId, Maybe PackageId)]
+ -> IO [PackageId]
closeDeps pkg_map ps = throwErr (closeDepsErr pkg_map ps)
throwErr :: MaybeErr Message a -> IO a
Failed e -> throwDyn (CmdLineError (showSDoc e))
Succeeded r -> return r
-closeDepsErr :: PackageConfigMap -> [PackageId]
+closeDepsErr :: PackageConfigMap -> [(PackageId,Maybe PackageId)]
-> MaybeErr Message [PackageId]
closeDepsErr pkg_map ps = foldM (add_package pkg_map) [] ps
-- internal helper
-add_package :: PackageConfigMap -> [PackageId] -> PackageId
+add_package :: PackageConfigMap -> [PackageId] -> (PackageId,Maybe PackageId)
-> MaybeErr Message [PackageId]
-add_package pkg_db ps p
+add_package pkg_db ps (p, mb_parent)
| p `elem` ps = return ps -- Check if we've already added this package
| otherwise =
case lookupPackage pkg_db p of
- Nothing -> Failed (missingPackageMsg (packageIdString p))
+ Nothing -> Failed (missingPackageMsg (packageIdString p) <>
+ missingDependencyMsg mb_parent)
Just pkg -> do
-- Add the package's dependents also
let deps = map mkPackageId (depends pkg)
- ps' <- foldM (add_package pkg_db) ps deps
+ ps' <- foldM (add_package pkg_db) ps (zip deps (repeat (Just p)))
return (p : ps')
missingPackageErr p = throwDyn (CmdLineError (showSDoc (missingPackageMsg p)))
missingPackageMsg p = ptext SLIT("unknown package:") <+> text p
--- -----------------------------------------------------------------------------
--- The home module set
-
-newtype HomeModules = HomeModules ModuleSet
+missingDependencyMsg Nothing = empty
+missingDependencyMsg (Just parent)
+ = space <> parens (ptext SLIT("dependency of") <+> ftext (packageIdFS parent))
-mkHomeModules :: [Module] -> HomeModules
-mkHomeModules = HomeModules . mkModuleSet
-
-isHomeModule :: HomeModules -> Module -> Bool
-isHomeModule (HomeModules set) mod = elemModuleSet mod set
-
--- Determining whether a Name refers to something in another package or not.
--- Cross-package references need to be handled differently when dynamically-
--- linked libraries are involved.
+-- -----------------------------------------------------------------------------
-isDllName :: HomeModules -> Name -> Bool
-isDllName pdeps name
+isDllName :: PackageId -> Name -> Bool
+isDllName this_pkg name
| opt_Static = False
- | Just mod <- nameModule_maybe name = not (isHomeModule pdeps mod)
+ | Just mod <- nameModule_maybe name = modulePackageId mod /= this_pkg
| otherwise = False -- no, it is not even an external name
-- -----------------------------------------------------------------------------