findHomeModule,
mkHomeModLocation,
mkHomeModLocation2,
+ mkHiOnlyModLocation,
addHomeModuleToFinder,
uncacheModule,
mkStubPaths,
cannotFindModule,
cannotFindInterface,
- ) where
-#include "HsVersions.h"
+ ) where
import Module
import HscTypes
import DynFlags ( DynFlags(..), isOneShot, GhcMode(..) )
import Outputable
import FiniteMap
-import UniqFM
+import LazyUniqFM
import Maybes ( expectJust )
import Data.IORef ( IORef, writeIORef, readIORef, modifyIORef )
import Data.List
import System.Directory
+import System.FilePath
import System.IO
import Control.Monad
import System.Time ( ClockTime )
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
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 $
return result
where
- basename = dots_to_slashes (moduleNameString (moduleName mod))
+ basename = moduleNameSlashes (moduleName mod)
to_search :: [(FilePath, IO ModLocation)]
to_search = [ (file, fn path basename)
| path <- paths,
(ext,fn) <- exts,
let base | path == "." = basename
- | otherwise = path `joinFileName` basename
- file = base `joinFileExt` ext
+ | otherwise = path </> basename
+ file = base <.> ext
]
search [] = return (NotFound (map fst to_search) (Just (modulePackageId mod)))
mkHomeModLocationSearched :: DynFlags -> ModuleName -> FileExt
-> FilePath -> BaseName -> IO ModLocation
mkHomeModLocationSearched dflags mod suff path basename = do
- mkHomeModLocation2 dflags mod (path `joinFileName` basename) suff
+ mkHomeModLocation2 dflags mod (path </> basename) suff
-- -----------------------------------------------------------------------------
-- Constructing a home module location
-- (b) and (c): "."
--
-- src_basename
--- (a): dots_to_slashes (moduleNameUserString mod)
+-- (a): (moduleNameSlashes mod)
-- (b) and (c): The filename of the source file, minus its extension
--
-- ext
mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation
mkHomeModLocation dflags mod src_filename = do
- let (basename,extension) = splitFilename src_filename
+ let (basename,extension) = splitExtension src_filename
mkHomeModLocation2 dflags mod basename extension
mkHomeModLocation2 :: DynFlags
-> String -- Suffix
-> IO ModLocation
mkHomeModLocation2 dflags mod src_basename ext = do
- let mod_basename = dots_to_slashes (moduleNameString mod)
+ let mod_basename = moduleNameSlashes mod
obj_fn <- mkObjPath dflags src_basename mod_basename
hi_fn <- mkHiPath dflags src_basename mod_basename
- return (ModLocation{ ml_hs_file = Just (src_basename `joinFileExt` ext),
+ return (ModLocation{ ml_hs_file = Just (src_basename <.> ext),
ml_hi_file = hi_fn,
ml_obj_file = obj_fn })
mkHiOnlyModLocation :: DynFlags -> Suffix -> FilePath -> String
-> IO ModLocation
mkHiOnlyModLocation dflags hisuf path basename
- = do let full_basename = path `joinFileName` basename
+ = do let full_basename = path </> basename
obj_fn <- mkObjPath dflags full_basename basename
return ModLocation{ ml_hs_file = Nothing,
- ml_hi_file = full_basename `joinFileExt` hisuf,
+ ml_hi_file = full_basename <.> hisuf,
-- Remove the .hi-boot suffix from
-- hi_file, if it had one. We always
-- want the name of the real .hi file
odir = objectDir dflags
osuf = objectSuf dflags
- obj_basename | Just dir <- odir = dir `joinFileName` mod_basename
+ obj_basename | Just dir <- odir = dir </> mod_basename
| otherwise = basename
- return (obj_basename `joinFileExt` osuf)
+ return (obj_basename <.> osuf)
-- | Constructs the filename of a .hi file for a given source file.
-- Does /not/ check whether the .hi file exists
hidir = hiDir dflags
hisuf = hiSuf dflags
- hi_basename | Just dir <- hidir = dir `joinFileName` mod_basename
+ hi_basename | Just dir <- hidir = dir </> mod_basename
| otherwise = basename
- return (hi_basename `joinFileExt` hisuf)
+ return (hi_basename <.> hisuf)
-- -----------------------------------------------------------------------------
:: DynFlags
-> ModuleName
-> ModLocation
- -> (FilePath,FilePath)
+ -> (FilePath,FilePath,FilePath)
mkStubPaths dflags mod location
= let
- stubdir = stubDir dflags
-
- mod_basename = dots_to_slashes (moduleNameString mod)
- src_basename = basenameOf (expectJust "mkStubPaths"
- (ml_hs_file location))
-
- stub_basename0
- | Just dir <- stubdir = dir `joinFileName` mod_basename
- | otherwise = src_basename
-
- stub_basename = stub_basename0 ++ "_stub"
+ stubdir = stubDir dflags
+
+ mod_basename = moduleNameSlashes mod
+ src_basename = dropExtension $ expectJust "mkStubPaths"
+ (ml_hs_file location)
+
+ stub_basename0
+ | Just dir <- stubdir = dir </> mod_basename
+ | 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 = takeFileName src_basename
in
- (stub_basename `joinFileExt` "c",
- stub_basename `joinFileExt` "h")
- -- the _stub.o filename is derived from the ml_obj_file.
+ (stub_basename <.> "c",
+ stub_basename <.> "h",
+ (include_basename ++ "_stub") <.> "h")
+ -- the _stub.o filename is derived from the ml_obj_file.
-- -----------------------------------------------------------------------------
-- findLinkable isn't related to the other stuff in here,
-- its modification time.
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"
+ let stub_fn = (dropExtension obj_fn ++ "_stub") <.> "o"
stub_exist <- doesFileExist stub_fn
if stub_exist
then return (LM obj_time mod [DotO obj_fn, DotO stub_fn])
else return (LM obj_time mod [DotO obj_fn])
-- -----------------------------------------------------------------------------
--- Utils
-
-dots_to_slashes = map (\c -> if c == '.' then '/' else c)
-
-
--- -----------------------------------------------------------------------------
-- Error messages
cannotFindModule :: DynFlags -> ModuleName -> FindResult -> SDoc
-cannotFindModule = cantFindErr SLIT("Could not find module")
+cannotFindModule = cantFindErr (sLit "Could not find module")
cannotFindInterface :: DynFlags -> ModuleName -> FindResult -> SDoc
-cannotFindInterface = cantFindErr SLIT("Failed to load interface for")
+cannotFindInterface = cantFindErr (sLit "Failed to load interface for")
-cantFindErr cannot_find dflags mod_name (FoundMultiple pkgs)
+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:"),
+ sep [ptext (sLit "it was found in multiple packages:"),
hsep (map (text.packageIdString) pkgs)]
)
cantFindErr cannot_find dflags mod_name find_result
more_info
= case find_result of
PackageHidden pkg
- -> ptext SLIT("it is a member of package") <+> ppr pkg <> comma
- <+> ptext SLIT("which is hidden")
+ -> ptext (sLit "it is a member of package") <+> ppr pkg <> comma
+ <+> ptext (sLit "which is hidden")
ModuleHidden pkg
- -> ptext SLIT("it is hidden") <+> parens (ptext SLIT("in package")
+ -> ptext (sLit "it is hidden") <+> parens (ptext (sLit "in package")
<+> ppr pkg)
NoPackage pkg
- -> ptext SLIT("no package matching") <+> ppr pkg <+>
- ptext SLIT("was found")
+ -> ptext (sLit "no package matching") <+> ppr pkg <+>
+ ptext (sLit "was found")
NotFound files mb_pkg
| null files
- -> ptext SLIT("it is not a module in the current program, or in any known package.")
+ -> ptext (sLit "it is not a module in the current program, or in any known package.")
| 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 '?' $$
+ 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
+ -> ptext (sLit "it is not in package") <+> ppr pkg
_ -> panic "cantFindErr"
not_found files
| verbosity dflags < 3
- = ptext SLIT("Use -v to see a list of the files searched for.")
+ = ptext (sLit "Use -v to see a list of the files searched for.")
| otherwise
- = hang (ptext SLIT("locations searched:")) 2 (vcat (map text files))
+ = hang (ptext (sLit "locations searched:")) 2 (vcat (map text files))
\end{code}