2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-2002
7 Simply the name of a module, represented as a Z-encoded FastString.
8 These are Uniquable, hence we can build FiniteMaps with ModuleNames as
14 A ModuleName with some additional information, namely whether the
15 module resides in the Home package or in a different package. We need
16 to know this for two reasons:
18 * generating cross-DLL calls is different from intra-DLL calls
20 * we don't record version information in interface files for entities
21 in a different package.
23 The unique of a Module is identical to the unique of a ModuleName, so
24 it is safe to look up in a Module map using a ModuleName and vice
29 When compiling module A, which imports module B, we need to
30 know whether B will be in the same DLL as A.
31 If it's in the same DLL, we refer to B_f_closure
32 If it isn't, we refer to _imp__B_f_closure
33 When compiling A, we record in B's Module value whether it's
34 in a different DLL, by setting the DLL flag.
42 Module, -- Abstract, instance of Eq, Ord, Outputable
48 , pprModuleName -- :: ModuleName -> SDoc
51 , moduleName -- :: Module -> ModuleName
52 , moduleNameString -- :: ModuleName -> EncodedString
53 , moduleNameUserString -- :: ModuleName -> UserString
54 , moduleNameFS -- :: ModuleName -> EncodedFS
56 , moduleString -- :: Module -> EncodedString
57 , moduleUserString -- :: Module -> UserString
59 , mkBasePkgModule -- :: UserString -> Module
60 , mkThPkgModule -- :: UserString -> Module
61 , mkHomeModule -- :: ModuleName -> Module
62 , isHomeModule -- :: Module -> Bool
63 , mkPackageModule -- :: ModuleName -> Module
65 , mkModuleName -- :: UserString -> ModuleName
66 , mkModuleNameFS -- :: UserFS -> ModuleName
67 , mkSysModuleNameFS -- :: EncodedFS -> ModuleName
72 , elemModuleEnv, extendModuleEnv, extendModuleEnvList, plusModuleEnv_C
73 , delModuleEnvList, delModuleEnv, plusModuleEnv, lookupModuleEnv
74 , lookupWithDefaultModuleEnv, mapModuleEnv, mkModuleEnv, emptyModuleEnv
75 , moduleEnvElts, unitModuleEnv, isEmptyModuleEnv, foldModuleEnv
77 , lookupModuleEnvByName, extendModuleEnvByName, unitModuleEnvByName
79 , ModuleSet, emptyModuleSet, mkModuleSet, moduleSetElts, extendModuleSet, elemModuleSet
83 #include "HsVersions.h"
86 import Packages ( PackageName, basePackage, thPackage )
87 import CmdLineOpts ( opt_InPackage )
88 import FastString ( FastString )
89 import Unique ( Uniquable(..) )
90 import Maybes ( expectJust )
98 %************************************************************************
100 \subsection{Interface file flavour}
102 %************************************************************************
104 A further twist to the tale is the support for dynamically linked
105 libraries under Win32. Here, dealing with the use of global variables
106 that's residing in a DLL requires special handling at the point of use
107 (there's an extra level of indirection, i.e., (**v) to get at v's
108 value, rather than just (*v) .) When slurping in an interface file we
109 then record whether it's coming from a .hi corresponding to a module
110 that's packaged up in a DLL or not, so that we later can emit the
113 The logic for how an interface file is marked as corresponding to a
114 module that's hiding in a DLL is explained elsewhere (ToDo: give
118 data Module = Module ModuleName !PackageInfo
121 = ThisPackage -- A module from the same package
122 -- as the one being compiled
123 | AnotherPackage -- A module from a different package
125 packageInfoPackage :: PackageInfo -> PackageName
126 packageInfoPackage ThisPackage = opt_InPackage
127 packageInfoPackage AnotherPackage = FSLIT("<pkg>")
129 instance Outputable PackageInfo where
130 -- Just used in debug prints of lex tokens and in debug modde
131 ppr pkg_info = ppr (packageInfoPackage pkg_info)
135 %************************************************************************
137 \subsection{Module locations}
139 %************************************************************************
144 ml_hs_file :: Maybe FilePath,
146 ml_hspp_file :: Maybe FilePath, -- Path of preprocessed source
148 ml_hi_file :: FilePath, -- Where the .hi file is, whether or not it exists
149 -- Always of form foo.hi, even if there is an hi-boot
150 -- file (we add the -boot suffix later)
152 ml_obj_file :: FilePath -- Where the .o file is, whether or not it exists
153 -- (might not exist either because the module
154 -- hasn't been compiled yet, or because
155 -- it is part of a package with a .a file)
159 instance Outputable ModLocation where
162 -- Rather a gruesome function to have in Module
164 showModMsg :: Bool -> Module -> ModLocation -> String
165 showModMsg use_object mod location =
166 mod_str ++ replicate (max 0 (16 - length mod_str)) ' '
167 ++" ( " ++ expectJust "showModMsg" (ml_hs_file location) ++ ", "
169 then ml_obj_file location
172 where mod_str = moduleUserString mod
175 For a module in another package, the hs_file and obj_file
176 components of ModLocation are undefined.
178 The locations specified by a ModLocation may or may not
179 correspond to actual files yet: for example, even if the object
180 file doesn't exist, the ModLocation still contains the path to
181 where the object file will reside if/when it is created.
184 %************************************************************************
186 \subsection{The name of a module}
188 %************************************************************************
191 newtype ModuleName = ModuleName EncodedFS
192 -- Haskell module names can include the quote character ',
193 -- so the module names have the z-encoding applied to them
195 instance Binary ModuleName where
196 put_ bh (ModuleName m) = put_ bh m
197 get bh = do m <- get bh; return (ModuleName m)
199 instance Uniquable ModuleName where
200 getUnique (ModuleName nm) = getUnique nm
202 instance Eq ModuleName where
203 nm1 == nm2 = getUnique nm1 == getUnique nm2
205 -- Warning: gives an ordering relation based on the uniques of the
206 -- FastStrings which are the (encoded) module names. This is _not_
207 -- a lexicographical ordering.
208 instance Ord ModuleName where
209 nm1 `compare` nm2 = getUnique nm1 `compare` getUnique nm2
211 instance Outputable ModuleName where
215 pprModuleName :: ModuleName -> SDoc
216 pprModuleName (ModuleName nm) = pprEncodedFS nm
218 moduleNameFS :: ModuleName -> EncodedFS
219 moduleNameFS (ModuleName mod) = mod
221 moduleNameString :: ModuleName -> EncodedString
222 moduleNameString (ModuleName mod) = unpackFS mod
224 moduleNameUserString :: ModuleName -> UserString
225 moduleNameUserString (ModuleName mod) = decode (unpackFS mod)
227 -- used to be called mkSrcModule
228 mkModuleName :: UserString -> ModuleName
229 mkModuleName s = ModuleName (mkFastString (encode s))
231 -- used to be called mkSrcModuleFS
232 mkModuleNameFS :: UserFS -> ModuleName
233 mkModuleNameFS s = ModuleName (encodeFS s)
235 -- used to be called mkSysModuleFS
236 mkSysModuleNameFS :: EncodedFS -> ModuleName
237 mkSysModuleNameFS s = ModuleName s
241 instance Outputable Module where
244 instance Uniquable Module where
245 getUnique (Module nm _) = getUnique nm
247 -- Same if they have the same name.
248 instance Eq Module where
249 m1 == m2 = getUnique m1 == getUnique m2
251 -- Warning: gives an ordering relation based on the uniques of the
252 -- FastStrings which are the (encoded) module names. This is _not_
253 -- a lexicographical ordering.
254 instance Ord Module where
255 m1 `compare` m2 = getUnique m1 `compare` getUnique m2
260 pprModule :: Module -> SDoc
261 pprModule (Module mod p) = getPprStyle $ \ sty ->
262 if debugStyle sty then
263 -- Print the package too
264 -- Don't use '.' because it gets confused
266 brackets (ppr p) <> pprModuleName mod
273 mkBasePkgModule :: ModuleName -> Module
274 mkBasePkgModule mod_nm
275 = Module mod_nm pack_info
278 | opt_InPackage == basePackage = ThisPackage
279 | otherwise = AnotherPackage
281 mkThPkgModule :: ModuleName -> Module
283 = Module mod_nm pack_info
286 | opt_InPackage == thPackage = ThisPackage
287 | otherwise = AnotherPackage
289 mkHomeModule :: ModuleName -> Module
290 mkHomeModule mod_nm = Module mod_nm ThisPackage
292 isHomeModule :: Module -> Bool
293 isHomeModule (Module nm ThisPackage) = True
294 isHomeModule _ = False
296 mkPackageModule :: ModuleName -> Module
297 mkPackageModule mod_nm = Module mod_nm AnotherPackage
299 moduleString :: Module -> EncodedString
300 moduleString (Module (ModuleName fs) _) = unpackFS fs
302 moduleName :: Module -> ModuleName
303 moduleName (Module mod pkg_info) = mod
305 moduleUserString :: Module -> UserString
306 moduleUserString (Module mod _) = moduleNameUserString mod
308 printModulePrefix :: Module -> Bool
309 -- When printing, say M.x
310 printModulePrefix (Module nm ThisPackage) = False
311 printModulePrefix _ = True
315 %************************************************************************
317 \subsection{@ModuleEnv@s}
319 %************************************************************************
322 type ModuleEnv elt = UniqFM elt
323 -- A ModuleName and Module have the same Unique,
324 -- so both will work as keys.
325 -- The 'ByName' variants work on ModuleNames
327 emptyModuleEnv :: ModuleEnv a
328 mkModuleEnv :: [(Module, a)] -> ModuleEnv a
329 unitModuleEnv :: Module -> a -> ModuleEnv a
330 extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
331 extendModuleEnv_C :: (a->a->a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
332 plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
333 extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
335 delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
336 delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
337 plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
338 mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
339 moduleEnvElts :: ModuleEnv a -> [a]
341 isEmptyModuleEnv :: ModuleEnv a -> Bool
342 lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
343 lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
344 elemModuleEnv :: Module -> ModuleEnv a -> Bool
345 foldModuleEnv :: (a -> b -> b) -> b -> ModuleEnv a -> b
347 -- The ByName variants
348 lookupModuleEnvByName :: ModuleEnv a -> ModuleName -> Maybe a
349 unitModuleEnvByName :: ModuleName -> a -> ModuleEnv a
350 extendModuleEnvByName :: ModuleEnv a -> ModuleName -> a -> ModuleEnv a
352 elemModuleEnv = elemUFM
353 extendModuleEnv = addToUFM
354 extendModuleEnvByName = addToUFM
355 extendModuleEnv_C = addToUFM_C
356 extendModuleEnvList = addListToUFM
357 plusModuleEnv_C = plusUFM_C
358 delModuleEnvList = delListFromUFM
359 delModuleEnv = delFromUFM
360 plusModuleEnv = plusUFM
361 lookupModuleEnv = lookupUFM
362 lookupModuleEnvByName = lookupUFM
363 lookupWithDefaultModuleEnv = lookupWithDefaultUFM
364 mapModuleEnv = mapUFM
365 mkModuleEnv = listToUFM
366 emptyModuleEnv = emptyUFM
367 moduleEnvElts = eltsUFM
368 unitModuleEnv = unitUFM
369 unitModuleEnvByName = unitUFM
370 isEmptyModuleEnv = isNullUFM
371 foldModuleEnv = foldUFM
376 type ModuleSet = UniqSet Module
377 mkModuleSet :: [Module] -> ModuleSet
378 extendModuleSet :: ModuleSet -> Module -> ModuleSet
379 emptyModuleSet :: ModuleSet
380 moduleSetElts :: ModuleSet -> [Module]
381 elemModuleSet :: Module -> ModuleSet -> Bool
383 emptyModuleSet = emptyUniqSet
384 mkModuleSet = mkUniqSet
385 extendModuleSet = addOneToUniqSet
386 moduleSetElts = uniqSetToList
387 elemModuleSet = elementOfUniqSet