findObjectLinkableMaybe,
findObjectLinkable,
- cantFindError,
+ cannotFindModule,
+ cannotFindInterface,
) where
#include "HsVersions.h"
import UniqFM
import Maybes ( expectJust )
-import DATA_IOREF ( IORef, writeIORef, readIORef, modifyIORef )
-
+import Data.IORef ( IORef, writeIORef, readIORef, modifyIORef )
import Data.List
import System.Directory
import System.IO
import Control.Monad
-import Time ( ClockTime )
+import System.Time ( ClockTime )
type FileExt = String -- Filename extension
where is_ext mod _ | modulePackageId mod /= this_pkg = True
| otherwise = False
+addToFinderCache :: IORef FinderCache -> ModuleName -> FindResult -> IO ()
addToFinderCache ref key val = modifyIORef ref $ \c -> addToUFM c key val
+
+addToModLocationCache :: IORef ModLocationCache -> Module -> ModLocation -> IO ()
addToModLocationCache ref key val = modifyIORef ref $ \c -> addToFM c key val
+removeFromFinderCache :: IORef FinderCache -> ModuleName -> IO ()
removeFromFinderCache ref key = modifyIORef ref $ \c -> delFromUFM c key
+
+removeFromModLocationCache :: IORef ModLocationCache -> Module -> IO ()
removeFromModLocationCache ref key = modifyIORef ref $ \c -> delFromFM c key
+lookupFinderCache :: IORef FinderCache -> ModuleName -> IO (Maybe FindResult)
lookupFinderCache ref key = do
c <- readIORef ref
return $! lookupUFM c key
+lookupModLocationCache :: IORef ModLocationCache -> Module
+ -> IO (Maybe ModLocation)
lookupModLocationCache ref key = do
c <- readIORef ref
return $! lookupFM c key
-- -----------------------------------------------------------------------------
-- Helpers
+orIfNotFound :: IO FindResult -> IO FindResult -> IO FindResult
this `orIfNotFound` or_this = do
res <- this
case res of
- NotFound here -> do
+ NotFound here _ -> do
res2 <- or_this
case res2 of
- NotFound or_here -> return (NotFound (here ++ or_here))
+ NotFound or_here pkg -> return (NotFound (here ++ or_here) pkg)
_other -> return res2
_other -> return res
findExposedPackageModule :: HscEnv -> ModuleName -> IO FindResult
findExposedPackageModule hsc_env mod_name
-- not found in any package:
- | null found = return (NotFound [])
+ | null found = return (NotFound [] Nothing)
-- found in just one exposed package:
| [(pkg_conf, _)] <- found_exposed
= let pkgid = mkPackageId (package pkg_conf) in
exts | isOneShot (ghcMode dflags) = hi_exts
| otherwise = source_exts
in
+
+ -- special case for GHC.Prim; we won't find it in the filesystem.
+ -- This is important only when compiling the base package (where GHC.Prim
+ -- is a home module).
+ if mod == gHC_PRIM
+ then return (Found (error "GHC.Prim ModLocation") mod)
+ else
+
searchPathExts home_path mod exts
Nothing -> return (NoPackage pkg_id)
Just pkg_conf -> findPackageModule_ hsc_env mod pkg_conf
+findPackageModule_ :: HscEnv -> Module -> PackageConfig -> IO FindResult
findPackageModule_ hsc_env mod pkg_conf =
modLocationCache hsc_env mod $
file = base `joinFileExt` ext
]
- search [] = return (NotFound (map fst to_search))
+ search [] = return (NotFound (map fst to_search) (Just (modulePackageId mod)))
search ((file, mk_result) : rest) = do
b <- doesFileExist file
if b
:: DynFlags
-> ModuleName
-> ModLocation
- -> (FilePath,FilePath)
+ -> (FilePath,FilePath,FilePath)
mkStubPaths dflags mod location
= let
| otherwise = src_basename
stub_basename = stub_basename0 ++ "_stub"
+
+ -- this is the filename we're going to use when
+ -- #including the stub_h file from the .hc file.
+ -- Without -stubdir, we just #include the basename
+ -- (eg. for a module A.B, we #include "B_stub.h"),
+ -- relying on the fact that we add an implicit -I flag
+ -- for the directory in which the source file resides
+ -- (see DriverPipeline.hs). With -stubdir, we
+ -- #include "A/B.h", assuming that the user has added
+ -- -I<dir> along with -stubdir <dir>.
+ include_basename
+ | Just _ <- stubdir = mod_basename
+ | otherwise = filenameOf src_basename
in
(stub_basename `joinFileExt` "c",
- stub_basename `joinFileExt` "h")
+ stub_basename `joinFileExt` "h",
+ (include_basename ++ "_stub") `joinFileExt` "h")
-- the _stub.o filename is derived from the ml_obj_file.
-- -----------------------------------------------------------------------------
findObjectLinkable :: Module -> FilePath -> ClockTime -> IO Linkable
findObjectLinkable mod obj_fn obj_time = do
let stub_fn = case splitFilename3 obj_fn of
- (dir, base, ext) -> dir ++ "/" ++ base ++ "_stub.o"
+ (dir, base, _ext) -> dir ++ "/" ++ base ++ "_stub.o"
stub_exist <- doesFileExist stub_fn
if stub_exist
then return (LM obj_time mod [DotO obj_fn, DotO stub_fn])
-- -----------------------------------------------------------------------------
-- Utils
+dots_to_slashes :: String -> String
dots_to_slashes = map (\c -> if c == '.' then '/' else c)
-
-- -----------------------------------------------------------------------------
-- Error messages
-cantFindError :: DynFlags -> ModuleName -> FindResult -> SDoc
-cantFindError dflags mod_name (FoundMultiple pkgs)
- = hang (ptext SLIT("Cannot import") <+> quotes (ppr mod_name) <> colon) 2 (
+cannotFindModule :: DynFlags -> ModuleName -> FindResult -> SDoc
+cannotFindModule = cantFindErr SLIT("Could not find module")
+
+cannotFindInterface :: DynFlags -> ModuleName -> FindResult -> SDoc
+cannotFindInterface = cantFindErr SLIT("Failed to load interface for")
+
+cantFindErr :: LitString -> DynFlags -> ModuleName -> FindResult -> SDoc
+cantFindErr cannot_find _dflags mod_name (FoundMultiple pkgs)
+ = hang (ptext cannot_find <+> quotes (ppr mod_name) <> colon) 2 (
sep [ptext SLIT("it was found in multiple packages:"),
hsep (map (text.packageIdString) pkgs)]
)
-cantFindError dflags mod_name find_result
- = hang (ptext SLIT("Could not find module") <+> quotes (ppr mod_name) <> colon)
+cantFindErr cannot_find dflags mod_name find_result
+ = hang (ptext cannot_find <+> quotes (ppr mod_name) <> colon)
2 more_info
where
more_info
-> ptext SLIT("no package matching") <+> ppr pkg <+>
ptext SLIT("was found")
- NotFound files
+ NotFound files mb_pkg
| null files
-> ptext SLIT("it is not a module in the current program, or in any known package.")
- | verbosity dflags < 3
- -> ptext SLIT("use -v to see a list of the files searched for")
- | otherwise
- -> hang (ptext SLIT("locations searched:"))
- 2 (vcat (map text files))
+ | Just pkg <- mb_pkg, pkg /= thisPackage dflags, build_tag /= ""
+ -> let
+ build = if build_tag == "p" then "profiling"
+ else "\"" ++ build_tag ++ "\""
+ in
+ ptext SLIT("Perhaps you haven't installed the ") <> text build <>
+ ptext SLIT(" libraries for package ") <> ppr pkg <> char '?' $$
+ not_found files
+
+ | otherwise
+ -> not_found files
NotFoundInPackage pkg
-> ptext SLIT("it is not in package") <+> ppr pkg
_ -> panic "cantFindErr"
+
+ build_tag = buildTag dflags
+
+ not_found files
+ | verbosity dflags < 3
+ = ptext SLIT("Use -v to see a list of the files searched for.")
+ | otherwise
+ = hang (ptext SLIT("locations searched:")) 2 (vcat (map text files))
\end{code}
projects / ghc-hetmet.git / blobdiff