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     , ModLocation(..),
  45     , showModMsg
  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     , mkHomeModule              -- :: ModuleName -> Module
  63     , isHomeModule              -- :: Module -> Bool
  64     , mkPackageModule           -- :: ModuleName -> Module
  65
  66     , mkModuleName              -- :: UserString -> ModuleName
  67     , mkModuleNameFS            -- :: UserFS    -> ModuleName
  68     , mkSysModuleNameFS         -- :: EncodedFS -> ModuleName
  69
  70     , pprModule,
  71
  72     , ModuleEnv,
  73     , elemModuleEnv, extendModuleEnv, extendModuleEnvList, plusModuleEnv_C
  74     , delModuleEnvList, delModuleEnv, plusModuleEnv, lookupModuleEnv
  75     , lookupWithDefaultModuleEnv, mapModuleEnv, mkModuleEnv, emptyModuleEnv
  76     , moduleEnvElts, unitModuleEnv, isEmptyModuleEnv, foldModuleEnv
  77     , extendModuleEnv_C
  78     , lookupModuleEnvByName, extendModuleEnvByName, unitModuleEnvByName
  79
  80     , ModuleSet, emptyModuleSet, mkModuleSet, moduleSetElts, extendModuleSet, elemModuleSet
  81
  82     ) where
  83
  84 #include "HsVersions.h"
  85 import OccName
  86 import Outputable
  87 import Packages         ( PackageName, preludePackage )
  88 import CmdLineOpts      ( opt_InPackage )
  89 import FastString       ( FastString )
  90 import Unique           ( Uniquable(..) )
  91 import Maybes           ( expectJust )
  92 import UniqFM
  93 import UniqSet
  94 import Binary
  95 import FastString
  96 \end{code}
  97
  98
  99 %************************************************************************
 100 %*                                                                      *
 101 \subsection{Interface file flavour}
 102 %*                                                                      *
 103 %************************************************************************
 104
 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
 112 appropriate code.
 113
 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
 116 renamer href here.)
 117
 118 \begin{code}
 119 data Module = Module ModuleName !PackageInfo
 120
 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)
 124
 125 data PackageInfo
 126   = ThisPackage                         -- A module from the same package
 127                                         -- as the one being compiled
 128   | AnotherPackage                      -- A module from a different package
 129
 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
 135
 136 packageInfoPackage :: PackageInfo -> PackageName
 137 packageInfoPackage ThisPackage        = opt_InPackage
 138 packageInfoPackage DunnoYet           = FSLIT("<?>")
 139 packageInfoPackage AnotherPackage     = FSLIT("<pkg>")
 140
 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)
 144 \end{code}
 145
 146
 147 %************************************************************************
 148 %*                                                                      *
 149 \subsection{Module locations}
 150 %*                                                                      *
 151 %************************************************************************
 152
 153 \begin{code}
 154 data ModLocation
 155    = ModLocation {
 156         ml_hs_file   :: Maybe FilePath,
 157         ml_hspp_file :: Maybe FilePath,  -- path of preprocessed source
 158         ml_hi_file   :: FilePath,
 159         ml_obj_file  :: Maybe FilePath
 160      }
 161      deriving Show
 162
 163 instance Outputable ModLocation where
 164    ppr = text . show
 165
 166 -- Rather a gruesome function to have in Module
 167
 168 showModMsg :: Bool -> Module -> ModLocation -> String
 169 showModMsg use_object mod location =
 170     mod_str ++ replicate (max 0 (16 - length mod_str)) ' '
 171     ++" ( " ++ expectJust "showModMsg" (ml_hs_file location) ++ ", "
 172     ++ (if use_object
 173           then expectJust "showModMsg" (ml_obj_file location)
 174           else "interpreted")
 175     ++ " )"
 176  where mod_str = moduleUserString mod
 177 \end{code}
 178
 179 For a module in another package, the hs_file and obj_file
 180 components of ModLocation are undefined.
 181
 182 The locations specified by a ModLocation may or may not
 183 correspond to actual files yet: for example, even if the object
 184 file doesn't exist, the ModLocation still contains the path to
 185 where the object file will reside if/when it is created.
 186
 187
 188 %************************************************************************
 189 %*                                                                      *
 190 \subsection{The name of a module}
 191 %*                                                                      *
 192 %************************************************************************
 193
 194 \begin{code}
 195 newtype ModuleName = ModuleName EncodedFS
 196         -- Haskell module names can include the quote character ',
 197         -- so the module names have the z-encoding applied to them
 198
 199 instance Binary ModuleName where
 200    put_ bh (ModuleName m) = put_ bh m
 201    get bh = do m <- get bh; return (ModuleName m)
 202
 203 instance Uniquable ModuleName where
 204   getUnique (ModuleName nm) = getUnique nm
 205
 206 instance Eq ModuleName where
 207   nm1 == nm2 = getUnique nm1 == getUnique nm2
 208
 209 -- Warning: gives an ordering relation based on the uniques of the
 210 -- FastStrings which are the (encoded) module names.  This is _not_
 211 -- a lexicographical ordering.
 212 instance Ord ModuleName where
 213   nm1 `compare` nm2 = getUnique nm1 `compare` getUnique nm2
 214
 215 instance Outputable ModuleName where
 216   ppr = pprModuleName
 217
 218
 219 pprModuleName :: ModuleName -> SDoc
 220 pprModuleName (ModuleName nm) = pprEncodedFS nm
 221
 222 moduleNameFS :: ModuleName -> EncodedFS
 223 moduleNameFS (ModuleName mod) = mod
 224
 225 moduleNameString :: ModuleName -> EncodedString
 226 moduleNameString (ModuleName mod) = unpackFS mod
 227
 228 moduleNameUserString :: ModuleName -> UserString
 229 moduleNameUserString (ModuleName mod) = decode (unpackFS mod)
 230
 231 -- used to be called mkSrcModule
 232 mkModuleName :: UserString -> ModuleName
 233 mkModuleName s = ModuleName (mkFastString (encode s))
 234
 235 -- used to be called mkSrcModuleFS
 236 mkModuleNameFS :: UserFS -> ModuleName
 237 mkModuleNameFS s = ModuleName (encodeFS s)
 238
 239 -- used to be called mkSysModuleFS
 240 mkSysModuleNameFS :: EncodedFS -> ModuleName
 241 mkSysModuleNameFS s = ModuleName s
 242 \end{code}
 243
 244 \begin{code}
 245 instance Outputable Module where
 246   ppr = pprModule
 247
 248 instance Uniquable Module where
 249   getUnique (Module nm _) = getUnique nm
 250
 251 -- Same if they have the same name.
 252 instance Eq Module where
 253   m1 == m2 = getUnique m1 == getUnique m2
 254
 255 -- Warning: gives an ordering relation based on the uniques of the
 256 -- FastStrings which are the (encoded) module names.  This is _not_
 257 -- a lexicographical ordering.
 258 instance Ord Module where
 259   m1 `compare` m2 = getUnique m1 `compare` getUnique m2
 260 \end{code}
 261
 262
 263 \begin{code}
 264 pprModule :: Module -> SDoc
 265 pprModule (Module mod p) = getPprStyle $ \ sty ->
 266                            if debugStyle sty then
 267                                 -- Print the package too
 268                                 -- Don't use '.' because it gets confused
 269                                 --      with module names
 270                                 brackets (ppr p) <> pprModuleName mod
 271                            else
 272                                 pprModuleName mod
 273 \end{code}
 274
 275
 276 \begin{code}
 277 mkPrelModule :: ModuleName -> Module
 278 mkPrelModule mod_nm
 279   = Module mod_nm pack_info
 280   where
 281     pack_info
 282       | opt_InPackage == preludePackage = ThisPackage
 283       | otherwise                       = AnotherPackage
 284
 285 mkHomeModule :: ModuleName -> Module
 286 mkHomeModule mod_nm = Module mod_nm ThisPackage
 287
 288 isHomeModule :: Module -> Bool
 289 isHomeModule (Module nm ThisPackage) = True
 290 isHomeModule _                       = False
 291
 292 mkPackageModule :: ModuleName -> Module
 293 mkPackageModule mod_nm = Module mod_nm AnotherPackage
 294
 295 -- Used temporarily when we first come across Foo.x in an interface
 296 -- file, but before we've opened Foo.hi.
 297 -- (Until we've opened Foo.hi we don't know what the Package is.)
 298 mkVanillaModule :: ModuleName -> Module
 299 mkVanillaModule name = Module name DunnoYet
 300
 301 isVanillaModule :: Module -> Bool
 302 isVanillaModule (Module nm DunnoYet) = True
 303 isVanillaModule _                       = False
 304
 305 moduleString :: Module -> EncodedString
 306 moduleString (Module (ModuleName fs) _) = unpackFS fs
 307
 308 moduleName :: Module -> ModuleName
 309 moduleName (Module mod pkg_info) = mod
 310
 311 moduleUserString :: Module -> UserString
 312 moduleUserString (Module mod _) = moduleNameUserString mod
 313
 314 printModulePrefix :: Module -> Bool
 315   -- When printing, say M.x
 316 printModulePrefix (Module nm ThisPackage) = False
 317 printModulePrefix _                       = True
 318 \end{code}
 319
 320
 321 %************************************************************************
 322 %*                                                                      *
 323 \subsection{@ModuleEnv@s}
 324 %*                                                                      *
 325 %************************************************************************
 326
 327 \begin{code}
 328 type ModuleEnv elt = UniqFM elt
 329 -- A ModuleName and Module have the same Unique,
 330 -- so both will work as keys.
 331 -- The 'ByName' variants work on ModuleNames
 332
 333 emptyModuleEnv       :: ModuleEnv a
 334 mkModuleEnv          :: [(Module, a)] -> ModuleEnv a
 335 unitModuleEnv        :: Module -> a -> ModuleEnv a
 336 extendModuleEnv      :: ModuleEnv a -> Module -> a -> ModuleEnv a
 337 extendModuleEnv_C    :: (a->a->a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
 338 plusModuleEnv        :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
 339 extendModuleEnvList  :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
 340
 341 delModuleEnvList     :: ModuleEnv a -> [Module] -> ModuleEnv a
 342 delModuleEnv         :: ModuleEnv a -> Module -> ModuleEnv a
 343 plusModuleEnv_C      :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
 344 mapModuleEnv         :: (a -> b) -> ModuleEnv a -> ModuleEnv b
 345 moduleEnvElts        :: ModuleEnv a -> [a]
 346
 347 isEmptyModuleEnv     :: ModuleEnv a -> Bool
 348 lookupModuleEnv      :: ModuleEnv a -> Module     -> Maybe a
 349 lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
 350 elemModuleEnv        :: Module -> ModuleEnv a -> Bool
 351 foldModuleEnv        :: (a -> b -> b) -> b -> ModuleEnv a -> b
 352
 353 -- The ByName variants
 354 lookupModuleEnvByName :: ModuleEnv a -> ModuleName -> Maybe a
 355 unitModuleEnvByName   :: ModuleName -> a -> ModuleEnv a
 356 extendModuleEnvByName :: ModuleEnv a -> ModuleName -> a -> ModuleEnv a
 357
 358 elemModuleEnv       = elemUFM
 359 extendModuleEnv     = addToUFM
 360 extendModuleEnvByName = addToUFM
 361 extendModuleEnv_C   = addToUFM_C
 362 extendModuleEnvList = addListToUFM
 363 plusModuleEnv_C     = plusUFM_C
 364 delModuleEnvList    = delListFromUFM
 365 delModuleEnv        = delFromUFM
 366 plusModuleEnv       = plusUFM
 367 lookupModuleEnv     = lookupUFM
 368 lookupModuleEnvByName = lookupUFM
 369 lookupWithDefaultModuleEnv = lookupWithDefaultUFM
 370 mapModuleEnv        = mapUFM
 371 mkModuleEnv         = listToUFM
 372 emptyModuleEnv      = emptyUFM
 373 moduleEnvElts       = eltsUFM
 374 unitModuleEnv       = unitUFM
 375 unitModuleEnvByName = unitUFM
 376 isEmptyModuleEnv    = isNullUFM
 377 foldModuleEnv       = foldUFM
 378 \end{code}
 379
 380 \begin{code}
 381
 382 type ModuleSet = UniqSet Module
 383 mkModuleSet     :: [Module] -> ModuleSet
 384 extendModuleSet :: ModuleSet -> Module -> ModuleSet
 385 emptyModuleSet  :: ModuleSet
 386 moduleSetElts   :: ModuleSet -> [Module]
 387 elemModuleSet   :: Module -> ModuleSet -> Bool
 388
 389 emptyModuleSet  = emptyUniqSet
 390 mkModuleSet     = mkUniqSet
 391 extendModuleSet = addOneToUniqSet
 392 moduleSetElts   = uniqSetToList
 393 elemModuleSet   = elementOfUniqSet
 394 \end{code}