ghc/compiler/basicTypes/Module.lhs

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