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
44 , PackageName -- = FastString; instance of Outputable, Uniquable
45 , preludePackage -- :: PackageName
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 , mkVanillaModule -- :: ModuleName -> Module
60 , isVanillaModule -- :: Module -> Bool
61 , mkPrelModule -- :: UserString -> Module
62 , mkModule -- :: ModuleName -> PackageName -> Module
63 , mkHomeModule -- :: ModuleName -> Module
64 , isHomeModule -- :: Module -> Bool
65 , mkPackageModule -- :: ModuleName -> Module
67 , mkModuleName -- :: UserString -> ModuleName
68 , mkModuleNameFS -- :: UserFS -> ModuleName
69 , mkSysModuleNameFS -- :: EncodedFS -> ModuleName
73 -- Where to find a .hi file
77 , elemModuleEnv, extendModuleEnv, extendModuleEnvList, plusModuleEnv_C
78 , delModuleEnvList, delModuleEnv, plusModuleEnv, lookupModuleEnv
79 , lookupWithDefaultModuleEnv, mapModuleEnv, mkModuleEnv, emptyModuleEnv
80 , moduleEnvElts, unitModuleEnv, isEmptyModuleEnv, foldModuleEnv
81 , lookupModuleEnvByName, extendModuleEnv_C
83 , ModuleSet, emptyModuleSet, mkModuleSet, moduleSetElts, extendModuleSet, elemModuleSet
87 #include "HsVersions.h"
90 import CmdLineOpts ( opt_InPackage )
91 import FastString ( FastString )
92 import Unique ( Uniquable(..) )
99 %************************************************************************
101 \subsection{Interface file flavour}
103 %************************************************************************
105 A further twist to the tale is the support for dynamically linked
106 libraries under Win32. Here, dealing with the use of global variables
107 that's residing in a DLL requires special handling at the point of use
108 (there's an extra level of indirection, i.e., (**v) to get at v's
109 value, rather than just (*v) .) When slurping in an interface file we
110 then record whether it's coming from a .hi corresponding to a module
111 that's packaged up in a DLL or not, so that we later can emit the
114 The logic for how an interface file is marked as corresponding to a
115 module that's hiding in a DLL is explained elsewhere (ToDo: give
119 data Module = Module ModuleName !PackageInfo
121 instance Binary Module where
122 put_ bh (Module m p) = put_ bh m
123 get bh = do m <- get bh; return (Module m DunnoYet)
126 = ThisPackage -- A module from the same package
127 -- as the one being compiled
128 | AnotherPackage -- A module from a different package
130 | DunnoYet -- This is used when we don't yet know
131 -- Main case: we've come across Foo.x in an interface file
132 -- but we havn't yet opened Foo.hi. We need a Name for Foo.x
133 -- Later on (in RnEnv.newTopBinder) we'll update the cache
134 -- to have the right PackageName
136 type PackageName = FastString -- No encoding at all
138 preludePackage :: PackageName
139 preludePackage = FSLIT("std")
141 packageInfoPackage :: PackageInfo -> PackageName
142 packageInfoPackage ThisPackage = opt_InPackage
143 packageInfoPackage DunnoYet = FSLIT("<?>")
144 packageInfoPackage AnotherPackage = FSLIT("<pkg>")
146 instance Outputable PackageInfo where
147 -- Just used in debug prints of lex tokens and in debug modde
148 ppr pkg_info = ppr (packageInfoPackage pkg_info)
152 %************************************************************************
154 \subsection{Where from}
156 %************************************************************************
158 The @WhereFrom@ type controls where the renamer looks for an interface file
161 data WhereFrom = ImportByUser -- Ordinary user import: look for M.hi
162 | ImportByUserSource -- User {- SOURCE -}: look for M.hi-boot
163 | ImportBySystem -- Non user import. Look for M.hi if M is in
164 -- the module this module depends on, or is a system-ish module;
165 -- M.hi-boot otherwise
166 | ImportByCmdLine -- The user typed a qualified name at
167 -- the GHCi prompt, try to demand-load
170 instance Outputable WhereFrom where
171 ppr ImportByUser = empty
172 ppr ImportByUserSource = ptext SLIT("{- SOURCE -}")
173 ppr ImportBySystem = ptext SLIT("{- SYSTEM IMPORT -}")
177 %************************************************************************
179 \subsection{The name of a module}
181 %************************************************************************
184 newtype ModuleName = ModuleName EncodedFS
185 -- Haskell module names can include the quote character ',
186 -- so the module names have the z-encoding applied to them
188 instance Binary ModuleName where
189 put_ bh (ModuleName m) = put_ bh m
190 get bh = do m <- get bh; return (ModuleName m)
192 instance Uniquable ModuleName where
193 getUnique (ModuleName nm) = getUnique nm
195 instance Eq ModuleName where
196 nm1 == nm2 = getUnique nm1 == getUnique nm2
198 -- Warning: gives an ordering relation based on the uniques of the
199 -- FastStrings which are the (encoded) module names. This is _not_
200 -- a lexicographical ordering.
201 instance Ord ModuleName where
202 nm1 `compare` nm2 = getUnique nm1 `compare` getUnique nm2
204 instance Outputable ModuleName where
208 pprModuleName :: ModuleName -> SDoc
209 pprModuleName (ModuleName nm) = pprEncodedFS nm
211 moduleNameFS :: ModuleName -> EncodedFS
212 moduleNameFS (ModuleName mod) = mod
214 moduleNameString :: ModuleName -> EncodedString
215 moduleNameString (ModuleName mod) = _UNPK_ mod
217 moduleNameUserString :: ModuleName -> UserString
218 moduleNameUserString (ModuleName mod) = decode (_UNPK_ mod)
220 -- used to be called mkSrcModule
221 mkModuleName :: UserString -> ModuleName
222 mkModuleName s = ModuleName (_PK_ (encode s))
224 -- used to be called mkSrcModuleFS
225 mkModuleNameFS :: UserFS -> ModuleName
226 mkModuleNameFS s = ModuleName (encodeFS s)
228 -- used to be called mkSysModuleFS
229 mkSysModuleNameFS :: EncodedFS -> ModuleName
230 mkSysModuleNameFS s = ModuleName s
234 instance Outputable Module where
237 instance Uniquable Module where
238 getUnique (Module nm _) = getUnique nm
240 -- Same if they have the same name.
241 instance Eq Module where
242 m1 == m2 = getUnique m1 == getUnique m2
244 -- Warning: gives an ordering relation based on the uniques of the
245 -- FastStrings which are the (encoded) module names. This is _not_
246 -- a lexicographical ordering.
247 instance Ord Module where
248 m1 `compare` m2 = getUnique m1 `compare` getUnique m2
253 pprModule :: Module -> SDoc
254 pprModule (Module mod p) = getPprStyle $ \ sty ->
255 if debugStyle sty then
256 -- Print the package too
257 ppr p <> dot <> pprModuleName mod
264 mkModule :: ModuleName -- Name of the module
267 mkModule mod_nm pack_name
268 = Module mod_nm pack_info
270 pack_info | pack_name == opt_InPackage = ThisPackage
271 | otherwise = AnotherPackage
273 mkHomeModule :: ModuleName -> Module
274 mkHomeModule mod_nm = Module mod_nm ThisPackage
276 isHomeModule :: Module -> Bool
277 isHomeModule (Module nm ThisPackage) = True
278 isHomeModule _ = False
280 mkPackageModule :: ModuleName -> Module
281 mkPackageModule mod_nm = Module mod_nm AnotherPackage
283 -- Used temporarily when we first come across Foo.x in an interface
284 -- file, but before we've opened Foo.hi.
285 -- (Until we've opened Foo.hi we don't know what the Package is.)
286 mkVanillaModule :: ModuleName -> Module
287 mkVanillaModule name = Module name DunnoYet
289 isVanillaModule :: Module -> Bool
290 isVanillaModule (Module nm DunnoYet) = True
291 isVanillaModule _ = False
293 mkPrelModule :: ModuleName -> Module
294 mkPrelModule name = mkModule name preludePackage
296 moduleString :: Module -> EncodedString
297 moduleString (Module (ModuleName fs) _) = _UNPK_ fs
299 moduleName :: Module -> ModuleName
300 moduleName (Module mod pkg_info) = mod
302 moduleUserString :: Module -> UserString
303 moduleUserString (Module mod _) = moduleNameUserString mod
305 printModulePrefix :: Module -> Bool
306 -- When printing, say M.x
307 printModulePrefix (Module nm ThisPackage) = False
308 printModulePrefix _ = True
312 %************************************************************************
314 \subsection{@ModuleEnv@s}
316 %************************************************************************
319 type ModuleEnv elt = UniqFM elt
321 emptyModuleEnv :: ModuleEnv a
322 mkModuleEnv :: [(Module, a)] -> ModuleEnv a
323 unitModuleEnv :: Module -> a -> ModuleEnv a
324 extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
325 extendModuleEnv_C :: (a->a->a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
326 plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
327 extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
329 delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
330 delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
331 plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
332 mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
333 moduleEnvElts :: ModuleEnv a -> [a]
335 isEmptyModuleEnv :: ModuleEnv a -> Bool
336 lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
337 lookupModuleEnvByName:: ModuleEnv a -> ModuleName -> Maybe a
338 lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
339 elemModuleEnv :: Module -> ModuleEnv a -> Bool
340 foldModuleEnv :: (a -> b -> b) -> b -> ModuleEnv a -> b
342 elemModuleEnv = elemUFM
343 extendModuleEnv = addToUFM
344 extendModuleEnv_C = addToUFM_C
345 extendModuleEnvList = addListToUFM
346 plusModuleEnv_C = plusUFM_C
347 delModuleEnvList = delListFromUFM
348 delModuleEnv = delFromUFM
349 plusModuleEnv = plusUFM
350 lookupModuleEnv = lookupUFM
351 lookupModuleEnvByName = lookupUFM
352 lookupWithDefaultModuleEnv = lookupWithDefaultUFM
353 mapModuleEnv = mapUFM
354 mkModuleEnv = listToUFM
355 emptyModuleEnv = emptyUFM
356 moduleEnvElts = eltsUFM
357 unitModuleEnv = unitUFM
358 isEmptyModuleEnv = isNullUFM
359 foldModuleEnv = foldUFM
364 type ModuleSet = UniqSet Module
365 mkModuleSet :: [Module] -> ModuleSet
366 extendModuleSet :: ModuleSet -> Module -> ModuleSet
367 emptyModuleSet :: ModuleSet
368 moduleSetElts :: ModuleSet -> [Module]
369 elemModuleSet :: Module -> ModuleSet -> Bool
371 emptyModuleSet = emptyUniqSet
372 mkModuleSet = mkUniqSet
373 extendModuleSet = addOneToUniqSet
374 moduleSetElts = uniqSetToList
375 elemModuleSet = elementOfUniqSet