ghc/compiler/basicTypes/Module.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[Module]{The @Module@ module.}
   5
   6 Representing modules and their flavours.
   7
   8
   9 Notes on DLLs
  10 ~~~~~~~~~~~~~
  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.
  17
  18
  19
  20
  21 \begin{code}
  22 module Module
  23     (
  24       Module,                   -- Abstract, instance of Eq, Ord, Outputable
  25
  26     , PackageName               -- = FastString; instance of Outputable, Uniquable
  27     , modulePackage             -- :: Module -> PackageName
  28     , preludePackage            -- :: PackageName       name of Standard Prelude package
  29
  30     , ModuleName
  31     , pprModuleName             -- :: ModuleName -> SDoc
  32     , printModulePrefix
  33
  34     , moduleName                -- :: Module -> ModuleName
  35     , moduleNameString          -- :: ModuleName -> EncodedString
  36     , moduleNameUserString      -- :: ModuleName -> UserString
  37     , moduleNameFS              -- :: ModuleName -> EncodedFS
  38
  39     , moduleString              -- :: Module -> EncodedString
  40     , moduleUserString          -- :: Module -> UserString
  41
  42     , mkVanillaModule           -- :: ModuleName -> Module
  43     , isVanillaModule           -- :: Module -> Bool
  44     , mkPrelModule              -- :: UserString -> Module
  45     , isPrelModule              -- :: Module -> Bool
  46     , mkModule                  -- :: ModuleName -> PackageName -> Module
  47     , mkHomeModule              -- :: ModuleName -> Module
  48     , isHomeModule              -- :: Module -> Bool
  49
  50     , mkModuleName              -- :: UserString -> ModuleName
  51     , mkModuleNameFS            -- :: UserFS    -> ModuleName
  52     , mkSysModuleNameFS         -- :: EncodedFS -> ModuleName
  53
  54     , pprModule,
  55
  56         -- Where to find a .hi file
  57     , WhereFrom(..)
  58
  59     , ModuleEnv,
  60     , elemModuleEnv, extendModuleEnv, extendModuleEnvList, plusModuleEnv_C
  61     , delModuleEnvList, delModuleEnv, plusModuleEnv, lookupModuleEnv
  62     , lookupWithDefaultModuleEnv, mapModuleEnv, mkModuleEnv, emptyModuleEnv
  63     , moduleEnvElts, unitModuleEnv, isEmptyModuleEnv, foldModuleEnv
  64     , lookupModuleEnvByName, extendModuleEnv_C
  65
  66     , ModuleSet, emptyModuleSet, mkModuleSet, moduleSetElts, extendModuleSet, elemModuleSet
  67
  68     ) where
  69
  70 #include "HsVersions.h"
  71 import OccName
  72 import Outputable
  73 import CmdLineOpts      ( opt_InPackage )
  74 import FastString       ( FastString )
  75 import Unique           ( Uniquable(..) )
  76 import UniqFM
  77 import UniqSet
  78 \end{code}
  79
  80
  81 %************************************************************************
  82 %*                                                                      *
  83 \subsection{Interface file flavour}
  84 %*                                                                      *
  85 %************************************************************************
  86
  87 A further twist to the tale is the support for dynamically linked
  88 libraries under Win32. Here, dealing with the use of global variables
  89 that's residing in a DLL requires special handling at the point of use
  90 (there's an extra level of indirection, i.e., (**v) to get at v's
  91 value, rather than just (*v) .) When slurping in an interface file we
  92 then record whether it's coming from a .hi corresponding to a module
  93 that's packaged up in a DLL or not, so that we later can emit the
  94 appropriate code.
  95
  96 The logic for how an interface file is marked as corresponding to a
  97 module that's hiding in a DLL is explained elsewhere (ToDo: give
  98 renamer href here.)
  99
 100 \begin{code}
 101 data Module = Module ModuleName PackageInfo
 102
 103 data PackageInfo
 104   = ThisPackage                         -- A module from the same package
 105                                         -- as the one being compiled
 106   | AnotherPackage PackageName          -- A module from a different package
 107
 108   | DunnoYet    -- This is used when we don't yet know
 109                 -- Main case: we've come across Foo.x in an interface file
 110                 -- but we havn't yet opened Foo.hi.  We need a Name for Foo.x
 111                 -- Later on (in RnEnv.newTopBinder) we'll update the cache
 112                 -- to have the right PackageName
 113
 114 type PackageName = FastString           -- No encoding at all
 115
 116 preludePackage :: PackageName
 117 preludePackage = SLIT("std")
 118
 119 packageInfoPackage :: PackageInfo -> PackageName
 120 packageInfoPackage ThisPackage        = SLIT("<THIS>")
 121 packageInfoPackage DunnoYet           = SLIT("<?>")
 122 packageInfoPackage (AnotherPackage p) = p
 123
 124 instance Outputable PackageInfo where
 125         -- Just used in debug prints of lex tokens and in debug modde
 126    ppr pkg_info = ppr (packageInfoPackage pkg_info)
 127 \end{code}
 128
 129
 130 %************************************************************************
 131 %*                                                                      *
 132 \subsection{Where from}
 133 %*                                                                      *
 134 %************************************************************************
 135
 136 The @WhereFrom@ type controls where the renamer looks for an interface file
 137
 138 \begin{code}
 139 data WhereFrom = ImportByUser           -- Ordinary user import: look for M.hi
 140                | ImportByUserSource     -- User {- SOURCE -}: look for M.hi-boot
 141                | ImportBySystem         -- Non user import.  Look for M.hi if M is in
 142                                         -- the module this module depends on, or is a system-ish module;
 143                                         -- M.hi-boot otherwise
 144                | ImportByCmdLine        -- The user typed a qualified name at
 145                                         -- the GHCi prompt, try to demand-load
 146                                         -- the interface.
 147
 148 instance Outputable WhereFrom where
 149   ppr ImportByUser       = empty
 150   ppr ImportByUserSource = ptext SLIT("{- SOURCE -}")
 151   ppr ImportBySystem     = ptext SLIT("{- SYSTEM IMPORT -}")
 152 \end{code}
 153
 154
 155 %************************************************************************
 156 %*                                                                      *
 157 \subsection{The name of a module}
 158 %*                                                                      *
 159 %************************************************************************
 160
 161 \begin{code}
 162 newtype ModuleName = ModuleName EncodedFS
 163         -- Haskell module names can include the quote character ',
 164         -- so the module names have the z-encoding applied to them
 165
 166 instance Uniquable ModuleName where
 167   getUnique (ModuleName nm) = getUnique nm
 168
 169 instance Eq ModuleName where
 170   nm1 == nm2 = getUnique nm1 == getUnique nm2
 171
 172 -- Warning: gives an ordering relation based on the uniques of the
 173 -- FastStrings which are the (encoded) module names.  This is _not_
 174 -- a lexicographical ordering.
 175 instance Ord ModuleName where
 176   nm1 `compare` nm2 = getUnique nm1 `compare` getUnique nm2
 177
 178 instance Outputable ModuleName where
 179   ppr = pprModuleName
 180
 181
 182 pprModuleName :: ModuleName -> SDoc
 183 pprModuleName (ModuleName nm) = pprEncodedFS nm
 184
 185 moduleNameFS :: ModuleName -> EncodedFS
 186 moduleNameFS (ModuleName mod) = mod
 187
 188 moduleNameString :: ModuleName -> EncodedString
 189 moduleNameString (ModuleName mod) = _UNPK_ mod
 190
 191 moduleNameUserString :: ModuleName -> UserString
 192 moduleNameUserString (ModuleName mod) = decode (_UNPK_ mod)
 193
 194 -- used to be called mkSrcModule
 195 mkModuleName :: UserString -> ModuleName
 196 mkModuleName s = ModuleName (_PK_ (encode s))
 197
 198 -- used to be called mkSrcModuleFS
 199 mkModuleNameFS :: UserFS -> ModuleName
 200 mkModuleNameFS s = ModuleName (encodeFS s)
 201
 202 -- used to be called mkSysModuleFS
 203 mkSysModuleNameFS :: EncodedFS -> ModuleName
 204 mkSysModuleNameFS s = ModuleName s
 205 \end{code}
 206
 207 \begin{code}
 208 instance Outputable Module where
 209   ppr = pprModule
 210
 211 instance Uniquable Module where
 212   getUnique (Module nm _) = getUnique nm
 213
 214 -- Same if they have the same name.
 215 instance Eq Module where
 216   m1 == m2 = getUnique m1 == getUnique m2
 217
 218 -- Warning: gives an ordering relation based on the uniques of the
 219 -- FastStrings which are the (encoded) module names.  This is _not_
 220 -- a lexicographical ordering.
 221 instance Ord Module where
 222   m1 `compare` m2 = getUnique m1 `compare` getUnique m2
 223 \end{code}
 224
 225
 226 \begin{code}
 227 pprModule :: Module -> SDoc
 228 pprModule (Module mod p) = getPprStyle $ \ sty ->
 229                            if debugStyle sty then
 230                                 -- Print the package too
 231                                 ppr p <> dot <> pprModuleName mod
 232                            else
 233                                 pprModuleName mod
 234 \end{code}
 235
 236
 237 \begin{code}
 238 mkModule :: ModuleName  -- Name of the module
 239          -> PackageName
 240          -> Module
 241 mkModule mod_nm pack_name
 242   = Module mod_nm pack_info
 243   where
 244     pack_info | pack_name == opt_InPackage = ThisPackage
 245               | otherwise                  = AnotherPackage pack_name
 246
 247 mkHomeModule :: ModuleName -> Module
 248 mkHomeModule mod_nm = Module mod_nm ThisPackage
 249
 250 isHomeModule :: Module -> Bool
 251 isHomeModule (Module nm ThisPackage) = True
 252 isHomeModule _                       = False
 253
 254 -- Used temporarily when we first come across Foo.x in an interface
 255 -- file, but before we've opened Foo.hi.
 256 -- (Until we've opened Foo.hi we don't know what the Package is.)
 257 mkVanillaModule :: ModuleName -> Module
 258 mkVanillaModule name = Module name DunnoYet
 259
 260 isVanillaModule :: Module -> Bool
 261 isVanillaModule (Module nm DunnoYet) = True
 262 isVanillaModule _                       = False
 263
 264 mkPrelModule :: ModuleName -> Module
 265 mkPrelModule name = mkModule name preludePackage
 266
 267 isPrelModule :: Module -> Bool
 268 isPrelModule (Module nm (AnotherPackage p)) | p == preludePackage = True
 269 isPrelModule _                       = False
 270
 271 moduleString :: Module -> EncodedString
 272 moduleString (Module (ModuleName fs) _) = _UNPK_ fs
 273
 274 moduleName :: Module -> ModuleName
 275 moduleName (Module mod pkg_info) = mod
 276
 277 modulePackage :: Module -> PackageName
 278 modulePackage (Module mod pkg_info) = packageInfoPackage pkg_info
 279
 280 moduleUserString :: Module -> UserString
 281 moduleUserString (Module mod _) = moduleNameUserString mod
 282
 283 printModulePrefix :: Module -> Bool
 284   -- When printing, say M.x
 285 printModulePrefix (Module nm ThisPackage) = False
 286 printModulePrefix _                       = True
 287 \end{code}
 288
 289
 290 %************************************************************************
 291 %*                                                                      *
 292 \subsection{@ModuleEnv@s}
 293 %*                                                                      *
 294 %************************************************************************
 295
 296 \begin{code}
 297 type ModuleEnv elt = UniqFM elt
 298
 299 emptyModuleEnv       :: ModuleEnv a
 300 mkModuleEnv          :: [(Module, a)] -> ModuleEnv a
 301 unitModuleEnv        :: Module -> a -> ModuleEnv a
 302 extendModuleEnv      :: ModuleEnv a -> Module -> a -> ModuleEnv a
 303 extendModuleEnv_C    :: (a->a->a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
 304 plusModuleEnv        :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
 305 extendModuleEnvList  :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
 306
 307 delModuleEnvList     :: ModuleEnv a -> [Module] -> ModuleEnv a
 308 delModuleEnv         :: ModuleEnv a -> Module -> ModuleEnv a
 309 plusModuleEnv_C      :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
 310 mapModuleEnv         :: (a -> b) -> ModuleEnv a -> ModuleEnv b
 311 moduleEnvElts        :: ModuleEnv a -> [a]
 312
 313 isEmptyModuleEnv     :: ModuleEnv a -> Bool
 314 lookupModuleEnv      :: ModuleEnv a -> Module     -> Maybe a
 315 lookupModuleEnvByName:: ModuleEnv a -> ModuleName -> Maybe a
 316 lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
 317 elemModuleEnv        :: Module -> ModuleEnv a -> Bool
 318 foldModuleEnv        :: (a -> b -> b) -> b -> ModuleEnv a -> b
 319
 320 elemModuleEnv       = elemUFM
 321 extendModuleEnv     = addToUFM
 322 extendModuleEnv_C   = addToUFM_C
 323 extendModuleEnvList = addListToUFM
 324 plusModuleEnv_C     = plusUFM_C
 325 delModuleEnvList    = delListFromUFM
 326 delModuleEnv        = delFromUFM
 327 plusModuleEnv       = plusUFM
 328 lookupModuleEnv     = lookupUFM
 329 lookupModuleEnvByName = lookupUFM
 330 lookupWithDefaultModuleEnv = lookupWithDefaultUFM
 331 mapModuleEnv        = mapUFM
 332 mkModuleEnv         = listToUFM
 333 emptyModuleEnv      = emptyUFM
 334 moduleEnvElts       = eltsUFM
 335 unitModuleEnv       = unitUFM
 336 isEmptyModuleEnv    = isNullUFM
 337 foldModuleEnv       = foldUFM
 338 \end{code}
 339
 340 \begin{code}
 341
 342 type ModuleSet = UniqSet Module
 343 mkModuleSet     :: [Module] -> ModuleSet
 344 extendModuleSet :: ModuleSet -> Module -> ModuleSet
 345 emptyModuleSet  :: ModuleSet
 346 moduleSetElts   :: ModuleSet -> [Module]
 347 elemModuleSet   :: Module -> ModuleSet -> Bool
 348
 349 emptyModuleSet  = emptyUniqSet
 350 mkModuleSet     = mkUniqSet
 351 extendModuleSet = addOneToUniqSet
 352 moduleSetElts   = uniqSetToList
 353 elemModuleSet   = elementOfUniqSet
 354 \end{code}