2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[Module]{The @Module@ module.}
6 Representing modules and their flavours.
11 When compiling module A, which imports module B, we need to
12 know whether B will be in the same DLL as A.
13 If it's in the same DLL, we refer to B_f_closure
14 If it isn't, we refer to _imp__B_f_closure
15 When compiling A, we record in B's Module value whether it's
16 in a different DLL, by setting the DLL flag.
24 Module, moduleName, packageOfModule,
25 -- abstract, instance of Eq, Ord, Outputable
29 , moduleNameString -- :: ModuleName -> EncodedString
30 , moduleNameUserString -- :: ModuleName -> UserString
31 , moduleNameFS -- :: ModuleName -> EncodedFS
33 , moduleString -- :: Module -> EncodedString
34 , moduleUserString -- :: Module -> UserString
36 , mkVanillaModule -- :: ModuleName -> Module
37 , mkPrelModule -- :: UserString -> Module
38 , mkModule -- :: ModuleName -> PackageName -> Module
39 , mkHomeModule -- :: ModuleName -> Module
40 , isHomeModule -- :: Module -> Bool
42 , mkModuleName -- :: UserString -> ModuleName
43 , mkModuleNameFS -- :: UserFS -> ModuleName
44 , mkSysModuleNameFS -- :: EncodedFS -> ModuleName
50 -- Where to find a .hi file
54 , elemModuleEnv, extendModuleEnv, extendModuleEnvList, plusModuleEnv_C
55 , delModuleEnvList, delModuleEnv, plusModuleEnv, lookupModuleEnv
56 , lookupWithDefaultModuleEnv, mapModuleEnv, mkModuleEnv, emptyModuleEnv
57 , moduleEnvElts, unitModuleEnv, isEmptyModuleEnv, foldModuleEnv
58 , lookupModuleEnvByName, extendModuleEnv_C
60 , ModuleSet, emptyModuleSet, mkModuleSet, moduleSetElts, extendModuleSet, elemModuleSet
64 #include "HsVersions.h"
67 import CmdLineOpts ( opt_InPackage )
68 import FastString ( FastString, uniqueOfFS )
69 import Unique ( Uniquable(..), mkUniqueGrimily )
75 %************************************************************************
77 \subsection{Interface file flavour}
79 %************************************************************************
81 A further twist to the tale is the support for dynamically linked
82 libraries under Win32. Here, dealing with the use of global variables
83 that's residing in a DLL requires special handling at the point of use
84 (there's an extra level of indirection, i.e., (**v) to get at v's
85 value, rather than just (*v) .) When slurping in an interface file we
86 then record whether it's coming from a .hi corresponding to a module
87 that's packaged up in a DLL or not, so that we later can emit the
90 The logic for how an interface file is marked as corresponding to a
91 module that's hiding in a DLL is explained elsewhere (ToDo: give
95 data Module = Module ModuleName PackageInfo
98 = ThisPackage -- A module from the same package
99 -- as the one being compiled
100 | AnotherPackage PackageName -- A module from a different package
102 | DunnoYet -- This is used when we don't yet know
103 -- Main case: we've come across Foo.x in an interface file
104 -- but we havn't yet opened Foo.hi. We need a Name for Foo.x
105 -- Later on (in RnEnv.newTopBinder) we'll update the cache
106 -- to have the right PackageInfo
108 type PackageName = FastString -- No encoding at all
110 preludePackage :: PackageName
111 preludePackage = SLIT("std")
113 instance Outputable PackageInfo where
114 -- Just used in debug prints of lex tokens and in debug modde
115 ppr ThisPackage = ptext SLIT("<THIS>")
116 ppr DunnoYet = ptext SLIT("<?>")
117 ppr (AnotherPackage p) = ptext p
121 %************************************************************************
123 \subsection{Where from}
125 %************************************************************************
127 The @WhereFrom@ type controls where the renamer looks for an interface file
130 data WhereFrom = ImportByUser -- Ordinary user import: look for M.hi
131 | ImportByUserSource -- User {- SOURCE -}: look for M.hi-boot
132 | ImportBySystem -- Non user import. Look for M.hi if M is in
133 -- the module this module depends on, or is a system-ish module;
134 -- M.hi-boot otherwise
136 instance Outputable WhereFrom where
137 ppr ImportByUser = empty
138 ppr ImportByUserSource = ptext SLIT("{- SOURCE -}")
139 ppr ImportBySystem = ptext SLIT("{- SYSTEM IMPORT -}")
143 %************************************************************************
145 \subsection{The name of a module}
147 %************************************************************************
150 newtype ModuleName = ModuleName EncodedFS
151 -- Haskell module names can include the quote character ',
152 -- so the module names have the z-encoding applied to them
154 instance Uniquable ModuleName where
155 getUnique (ModuleName nm) = mkUniqueGrimily (uniqueOfFS nm)
157 instance Eq ModuleName where
158 nm1 == nm2 = getUnique nm1 == getUnique nm2
160 -- Warning: gives an ordering relation based on the uniques of the
161 -- FastStrings which are the (encoded) module names. This is _not_
162 -- a lexicographical ordering.
163 instance Ord ModuleName where
164 nm1 `compare` nm2 = getUnique nm1 `compare` getUnique nm2
166 instance Outputable ModuleName where
170 pprModuleName :: ModuleName -> SDoc
171 pprModuleName (ModuleName nm) = pprEncodedFS nm
173 moduleNameFS :: ModuleName -> EncodedFS
174 moduleNameFS (ModuleName mod) = mod
176 moduleNameString :: ModuleName -> EncodedString
177 moduleNameString (ModuleName mod) = _UNPK_ mod
179 moduleNameUserString :: ModuleName -> UserString
180 moduleNameUserString (ModuleName mod) = decode (_UNPK_ mod)
182 -- used to be called mkSrcModule
183 mkModuleName :: UserString -> ModuleName
184 mkModuleName s = ModuleName (_PK_ (encode s))
186 -- used to be called mkSrcModuleFS
187 mkModuleNameFS :: UserFS -> ModuleName
188 mkModuleNameFS s = ModuleName (encodeFS s)
190 -- used to be called mkSysModuleFS
191 mkSysModuleNameFS :: EncodedFS -> ModuleName
192 mkSysModuleNameFS s = ModuleName s
196 instance Outputable Module where
199 instance Uniquable Module where
200 getUnique (Module nm _) = getUnique nm
202 -- Same if they have the same name.
203 instance Eq Module where
204 m1 == m2 = getUnique m1 == getUnique m2
206 -- Warning: gives an ordering relation based on the uniques of the
207 -- FastStrings which are the (encoded) module names. This is _not_
208 -- a lexicographical ordering.
209 instance Ord Module where
210 m1 `compare` m2 = getUnique m1 `compare` getUnique m2
215 pprModule :: Module -> SDoc
216 pprModule (Module mod p) = getPprStyle $ \ sty ->
217 if debugStyle sty then
218 -- Print the package too
219 ppr p <> dot <> pprModuleName mod
226 mkModule :: ModuleName -- Name of the module
229 mkModule mod_nm pack_name
230 = Module mod_nm pack_info
232 pack_info | pack_name == opt_InPackage = ThisPackage
233 | otherwise = AnotherPackage pack_name
235 mkHomeModule :: ModuleName -> Module
236 mkHomeModule mod_nm = Module mod_nm ThisPackage
238 isHomeModule :: Module -> Bool
239 isHomeModule (Module nm ThisPackage) = True
240 isHomeModule _ = False
242 -- Used temporarily when we first come across Foo.x in an interface
243 -- file, but before we've opened Foo.hi.
244 -- (Until we've opened Foo.hi we don't know what the PackageInfo is.)
245 mkVanillaModule :: ModuleName -> Module
246 mkVanillaModule name = Module name DunnoYet
248 mkPrelModule :: ModuleName -> Module
249 mkPrelModule name = mkModule name preludePackage
251 moduleString :: Module -> EncodedString
252 moduleString (Module (ModuleName fs) _) = _UNPK_ fs
254 moduleName :: Module -> ModuleName
255 moduleName (Module mod pkg_info) = mod
257 moduleUserString :: Module -> UserString
258 moduleUserString (Module mod _) = moduleNameUserString mod
260 packageOfModule :: Module -> Maybe PackageName
261 packageOfModule (Module nm (AnotherPackage pn)) = Just pn
262 packageOfModule _ = Nothing
264 printModulePrefix :: Module -> Bool
265 -- When printing, say M.x
266 printModulePrefix (Module nm ThisPackage) = False
267 printModulePrefix _ = True
271 %************************************************************************
273 \subsection{@ModuleEnv@s}
275 %************************************************************************
278 type ModuleEnv elt = UniqFM elt
280 emptyModuleEnv :: ModuleEnv a
281 mkModuleEnv :: [(Module, a)] -> ModuleEnv a
282 unitModuleEnv :: Module -> a -> ModuleEnv a
283 extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
284 extendModuleEnv_C :: (a->a->a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
285 plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
286 extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
288 delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
289 delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
290 plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
291 mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
292 moduleEnvElts :: ModuleEnv a -> [a]
294 isEmptyModuleEnv :: ModuleEnv a -> Bool
295 lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
296 lookupModuleEnvByName:: ModuleEnv a -> ModuleName -> Maybe a
297 lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
298 elemModuleEnv :: Module -> ModuleEnv a -> Bool
299 foldModuleEnv :: (a -> b -> b) -> b -> ModuleEnv a -> b
301 elemModuleEnv = elemUFM
302 extendModuleEnv = addToUFM
303 extendModuleEnv_C = addToUFM_C
304 extendModuleEnvList = addListToUFM
305 plusModuleEnv_C = plusUFM_C
306 delModuleEnvList = delListFromUFM
307 delModuleEnv = delFromUFM
308 plusModuleEnv = plusUFM
309 lookupModuleEnv = lookupUFM
310 lookupModuleEnvByName = lookupUFM
311 lookupWithDefaultModuleEnv = lookupWithDefaultUFM
312 mapModuleEnv = mapUFM
313 mkModuleEnv = listToUFM
314 emptyModuleEnv = emptyUFM
315 moduleEnvElts = eltsUFM
316 unitModuleEnv = unitUFM
317 isEmptyModuleEnv = isNullUFM
318 foldModuleEnv = foldUFM
323 type ModuleSet = UniqSet Module
324 mkModuleSet :: [Module] -> ModuleSet
325 extendModuleSet :: ModuleSet -> Module -> ModuleSet
326 emptyModuleSet :: ModuleSet
327 moduleSetElts :: ModuleSet -> [Module]
328 elemModuleSet :: Module -> ModuleSet -> Bool
330 emptyModuleSet = emptyUniqSet
331 mkModuleSet = mkUniqSet
332 extendModuleSet = addOneToUniqSet
333 moduleSetElts = uniqSetToList
334 elemModuleSet = elementOfUniqSet