X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fmain%2FFinder.lhs;h=4c6ae292985e7350d8a98446e3cf610367565406;hb=5892af0e08fdb890b5a0b9a64346d9f7773a6ed8;hp=206d118d6e92aabf31f98cc32abe09e1d5d6ad0b;hpb=98c68a1c5b63aadf9c7917274519d95bbe9394d4;p=ghc-hetmet.git diff --git a/compiler/main/Finder.lhs b/compiler/main/Finder.lhs index 206d118..4c6ae29 100644 --- a/compiler/main/Finder.lhs +++ b/compiler/main/Finder.lhs @@ -25,8 +25,6 @@ module Finder ( ) where -#include "HsVersions.h" - import Module import HscTypes import Packages @@ -36,12 +34,14 @@ import PrelNames ( gHC_PRIM ) import DynFlags ( DynFlags(..), isOneShot, GhcMode(..) ) import Outputable import FiniteMap -import UniqFM +import LazyUniqFM import Maybes ( expectJust ) +import Distribution.Package hiding (PackageId) 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 ) @@ -114,27 +114,20 @@ lookupModLocationCache ref key = do -- packages to find the module, if a package is specified then only -- that package is searched for the module. -findImportedModule :: HscEnv -> ModuleName -> Maybe PackageId -> IO FindResult -findImportedModule hsc_env mod_name mb_pkgid = - case mb_pkgid of - Nothing -> unqual_import - Just pkg | pkg == this_pkg -> home_import - | otherwise -> pkg_import pkg +findImportedModule :: HscEnv -> ModuleName -> Maybe FastString -> IO FindResult +findImportedModule hsc_env mod_name mb_pkg = + case mb_pkg of + Nothing -> unqual_import + Just pkg | pkg == fsLit "this" -> home_import -- "this" is special + | otherwise -> pkg_import where - dflags = hsc_dflags hsc_env - this_pkg = thisPackage dflags - - home_import = findHomeModule hsc_env mod_name + home_import = findHomeModule hsc_env mod_name - pkg_import pkg = findPackageModule hsc_env (mkModule pkg mod_name) - -- ToDo: this isn't quite right, the module we want - -- might actually be in another package, but re-exposed - -- ToDo: should return NotFoundInPackage if - -- the module isn't exposed by the package. + pkg_import = findExposedPackageModule hsc_env mod_name mb_pkg - unqual_import = home_import + unqual_import = home_import `orIfNotFound` - findExposedPackageModule hsc_env mod_name + findExposedPackageModule hsc_env mod_name Nothing -- | Locate a specific 'Module'. The purpose of this function is to -- create a 'ModLocation' for a given 'Module', that is to find out @@ -177,8 +170,9 @@ homeSearchCache hsc_env mod_name do_this = do _other -> return () return result -findExposedPackageModule :: HscEnv -> ModuleName -> IO FindResult -findExposedPackageModule hsc_env mod_name +findExposedPackageModule :: HscEnv -> ModuleName -> Maybe FastString + -> IO FindResult +findExposedPackageModule hsc_env mod_name mb_pkg -- not found in any package: | null found = return (NotFound [] Nothing) -- found in just one exposed package: @@ -196,9 +190,19 @@ findExposedPackageModule hsc_env mod_name where dflags = hsc_dflags hsc_env found = lookupModuleInAllPackages dflags mod_name - found_exposed = filter is_exposed found + + found_exposed = [ (pkg_conf,exposed_mod) + | x@(pkg_conf,exposed_mod) <- found, + is_exposed x, + pkg_conf `matches` mb_pkg ] + is_exposed (pkg_conf,exposed_mod) = exposed pkg_conf && exposed_mod + _pkg_conf `matches` Nothing = True + pkg_conf `matches` Just pkg = + case packageName pkg_conf of + PackageName n -> pkg == mkFastString n + modLocationCache :: HscEnv -> Module -> IO FindResult -> IO FindResult modLocationCache hsc_env mod do_this = do @@ -346,8 +350,8 @@ searchPathExts paths mod exts | 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))) @@ -360,7 +364,7 @@ searchPathExts paths mod exts 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 @@ -397,7 +401,7 @@ mkHomeModLocationSearched dflags mod suff path basename = do 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 @@ -411,17 +415,17 @@ mkHomeModLocation2 dflags mod src_basename ext = do 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 @@ -441,10 +445,10 @@ mkObjPath dflags basename mod_basename 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 @@ -458,10 +462,10 @@ mkHiPath dflags basename mod_basename 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) -- ----------------------------------------------------------------------------- @@ -478,35 +482,35 @@ mkStubPaths mkStubPaths dflags mod location = let - stubdir = stubDir dflags - - mod_basename = moduleNameSlashes 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" - - -- 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 along with -stubdir . - include_basename - | Just _ <- stubdir = mod_basename - | otherwise = filenameOf src_basename + 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 along with -stubdir . + include_basename + | Just _ <- stubdir = mod_basename + | otherwise = takeFileName src_basename in - (stub_basename `joinFileExt` "c", - stub_basename `joinFileExt` "h", - (include_basename ++ "_stub") `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, @@ -524,8 +528,7 @@ findObjectLinkableMaybe mod locn -- 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]) @@ -535,15 +538,15 @@ findObjectLinkable mod obj_fn obj_time = do -- 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 :: 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 @@ -553,34 +556,34 @@ 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" @@ -588,7 +591,7 @@ cantFindErr cannot_find dflags mod_name find_result 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}