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