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(..) )
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 | DunnoYet -- This is used when we don't yet know
126 -- Main case: we've come across Foo.x in an interface file
127 -- but we havn't yet opened Foo.hi. We need a Name for Foo.x
128 -- Later on (in RnEnv.newTopBinder) we'll update the cache
129 -- to have the right PackageName
131 type PackageName = FastString -- No encoding at all
133 preludePackage :: PackageName
134 preludePackage = SLIT("std")
136 packageInfoPackage :: PackageInfo -> PackageName
137 packageInfoPackage ThisPackage = opt_InPackage
138 packageInfoPackage DunnoYet = SLIT("<?>")
139 packageInfoPackage AnotherPackage = SLIT("<pkg>")
141 instance Outputable PackageInfo where
142 -- Just used in debug prints of lex tokens and in debug modde
143 ppr pkg_info = ppr (packageInfoPackage pkg_info)
147 %************************************************************************
149 \subsection{Where from}
151 %************************************************************************
153 The @WhereFrom@ type controls where the renamer looks for an interface file
156 data WhereFrom = ImportByUser -- Ordinary user import: look for M.hi
157 | ImportByUserSource -- User {- SOURCE -}: look for M.hi-boot
158 | ImportBySystem -- Non user import. Look for M.hi if M is in
159 -- the module this module depends on, or is a system-ish module;
160 -- M.hi-boot otherwise
161 | ImportByCmdLine -- The user typed a qualified name at
162 -- the GHCi prompt, try to demand-load
165 instance Outputable WhereFrom where
166 ppr ImportByUser = empty
167 ppr ImportByUserSource = ptext SLIT("{- SOURCE -}")
168 ppr ImportBySystem = ptext SLIT("{- SYSTEM IMPORT -}")
172 %************************************************************************
174 \subsection{The name of a module}
176 %************************************************************************
179 newtype ModuleName = ModuleName EncodedFS
180 -- Haskell module names can include the quote character ',
181 -- so the module names have the z-encoding applied to them
183 instance Uniquable ModuleName where
184 getUnique (ModuleName nm) = getUnique nm
186 instance Eq ModuleName where
187 nm1 == nm2 = getUnique nm1 == getUnique nm2
189 -- Warning: gives an ordering relation based on the uniques of the
190 -- FastStrings which are the (encoded) module names. This is _not_
191 -- a lexicographical ordering.
192 instance Ord ModuleName where
193 nm1 `compare` nm2 = getUnique nm1 `compare` getUnique nm2
195 instance Outputable ModuleName where
199 pprModuleName :: ModuleName -> SDoc
200 pprModuleName (ModuleName nm) = pprEncodedFS nm
202 moduleNameFS :: ModuleName -> EncodedFS
203 moduleNameFS (ModuleName mod) = mod
205 moduleNameString :: ModuleName -> EncodedString
206 moduleNameString (ModuleName mod) = _UNPK_ mod
208 moduleNameUserString :: ModuleName -> UserString
209 moduleNameUserString (ModuleName mod) = decode (_UNPK_ mod)
211 -- used to be called mkSrcModule
212 mkModuleName :: UserString -> ModuleName
213 mkModuleName s = ModuleName (_PK_ (encode s))
215 -- used to be called mkSrcModuleFS
216 mkModuleNameFS :: UserFS -> ModuleName
217 mkModuleNameFS s = ModuleName (encodeFS s)
219 -- used to be called mkSysModuleFS
220 mkSysModuleNameFS :: EncodedFS -> ModuleName
221 mkSysModuleNameFS s = ModuleName s
225 instance Outputable Module where
228 instance Uniquable Module where
229 getUnique (Module nm _) = getUnique nm
231 -- Same if they have the same name.
232 instance Eq Module where
233 m1 == m2 = getUnique m1 == getUnique m2
235 -- Warning: gives an ordering relation based on the uniques of the
236 -- FastStrings which are the (encoded) module names. This is _not_
237 -- a lexicographical ordering.
238 instance Ord Module where
239 m1 `compare` m2 = getUnique m1 `compare` getUnique m2
244 pprModule :: Module -> SDoc
245 pprModule (Module mod p) = getPprStyle $ \ sty ->
246 if debugStyle sty then
247 -- Print the package too
248 ppr p <> dot <> pprModuleName mod
255 mkModule :: ModuleName -- Name of the module
258 mkModule mod_nm pack_name
259 = Module mod_nm pack_info
261 pack_info | pack_name == opt_InPackage = ThisPackage
262 | otherwise = AnotherPackage
264 mkHomeModule :: ModuleName -> Module
265 mkHomeModule mod_nm = Module mod_nm ThisPackage
267 isHomeModule :: Module -> Bool
268 isHomeModule (Module nm ThisPackage) = True
269 isHomeModule _ = False
271 mkPackageModule :: ModuleName -> Module
272 mkPackageModule mod_nm = Module mod_nm AnotherPackage
274 -- Used temporarily when we first come across Foo.x in an interface
275 -- file, but before we've opened Foo.hi.
276 -- (Until we've opened Foo.hi we don't know what the Package is.)
277 mkVanillaModule :: ModuleName -> Module
278 mkVanillaModule name = Module name DunnoYet
280 isVanillaModule :: Module -> Bool
281 isVanillaModule (Module nm DunnoYet) = True
282 isVanillaModule _ = False
284 mkPrelModule :: ModuleName -> Module
285 mkPrelModule name = mkModule name preludePackage
287 moduleString :: Module -> EncodedString
288 moduleString (Module (ModuleName fs) _) = _UNPK_ fs
290 moduleName :: Module -> ModuleName
291 moduleName (Module mod pkg_info) = mod
293 moduleUserString :: Module -> UserString
294 moduleUserString (Module mod _) = moduleNameUserString mod
296 printModulePrefix :: Module -> Bool
297 -- When printing, say M.x
298 printModulePrefix (Module nm ThisPackage) = False
299 printModulePrefix _ = True
303 %************************************************************************
305 \subsection{@ModuleEnv@s}
307 %************************************************************************
310 type ModuleEnv elt = UniqFM elt
312 emptyModuleEnv :: ModuleEnv a
313 mkModuleEnv :: [(Module, a)] -> ModuleEnv a
314 unitModuleEnv :: Module -> a -> ModuleEnv a
315 extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
316 extendModuleEnv_C :: (a->a->a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
317 plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
318 extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
320 delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
321 delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
322 plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
323 mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
324 moduleEnvElts :: ModuleEnv a -> [a]
326 isEmptyModuleEnv :: ModuleEnv a -> Bool
327 lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
328 lookupModuleEnvByName:: ModuleEnv a -> ModuleName -> Maybe a
329 lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
330 elemModuleEnv :: Module -> ModuleEnv a -> Bool
331 foldModuleEnv :: (a -> b -> b) -> b -> ModuleEnv a -> b
333 elemModuleEnv = elemUFM
334 extendModuleEnv = addToUFM
335 extendModuleEnv_C = addToUFM_C
336 extendModuleEnvList = addListToUFM
337 plusModuleEnv_C = plusUFM_C
338 delModuleEnvList = delListFromUFM
339 delModuleEnv = delFromUFM
340 plusModuleEnv = plusUFM
341 lookupModuleEnv = lookupUFM
342 lookupModuleEnvByName = lookupUFM
343 lookupWithDefaultModuleEnv = lookupWithDefaultUFM
344 mapModuleEnv = mapUFM
345 mkModuleEnv = listToUFM
346 emptyModuleEnv = emptyUFM
347 moduleEnvElts = eltsUFM
348 unitModuleEnv = unitUFM
349 isEmptyModuleEnv = isNullUFM
350 foldModuleEnv = foldUFM
355 type ModuleSet = UniqSet Module
356 mkModuleSet :: [Module] -> ModuleSet
357 extendModuleSet :: ModuleSet -> Module -> ModuleSet
358 emptyModuleSet :: ModuleSet
359 moduleSetElts :: ModuleSet -> [Module]
360 elemModuleSet :: Module -> ModuleSet -> Bool
362 emptyModuleSet = emptyUniqSet
363 mkModuleSet = mkUniqSet
364 extendModuleSet = addOneToUniqSet
365 moduleSetElts = uniqSetToList
366 elemModuleSet = elementOfUniqSet