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, mod_name, mod_kind
  25                             -- abstract, instance of Eq, Ord, Outputable
  26     , ModuleName
  27     , ModuleKind(..)
  28     , isPackageKind
  29
  30     , moduleNameString          -- :: ModuleName -> EncodedString
  31     , moduleNameUserString      -- :: ModuleName -> UserString
  32
  33     , moduleString          -- :: Module -> EncodedString
  34     , moduleUserString      -- :: Module -> UserString
  35     , moduleName            -- :: Module -> ModuleName
  36
  37 --    , mkVanillaModule     -- :: ModuleName -> Module
  38 --    , mkThisModule        -- :: ModuleName -> Module
  39 --    , mkPrelModule          -- :: UserString -> Module
  40     , mkModule              -- :: ModuleName -> ModuleKind -> Module
  41
  42 --    , isLocalModule       -- :: Module -> Bool
  43
  44 --    , mkSrcModule
  45
  46     , mkModuleName              -- :: UserString -> ModuleName
  47     , mkModuleNameFS            -- :: UserFS    -> ModuleName
  48     , mkSysModuleNameFS         -- :: EncodedFS -> ModuleName
  49
  50     , pprModule,
  51
  52     , PackageName
  53
  54         -- Where to find a .hi file
  55     , WhereFrom(..)
  56
  57     ) where
  58
  59 #include "HsVersions.h"
  60 import OccName
  61 import Outputable
  62 import CmdLineOpts      ( opt_InPackage )
  63 import FastString       ( FastString, uniqueOfFS )
  64 import Unique           ( Uniquable(..), mkUniqueGrimily )
  65 \end{code}
  66
  67
  68 %************************************************************************
  69 %*                                                                      *
  70 \subsection{Interface file flavour}
  71 %*                                                                      *
  72 %************************************************************************
  73
  74 A further twist to the tale is the support for dynamically linked libraries under
  75 Win32. Here, dealing with the use of global variables that's residing in a DLL
  76 requires special handling at the point of use (there's an extra level of indirection,
  77 i.e., (**v) to get at v's value, rather than just (*v) .) When slurping in an
  78 interface file we then record whether it's coming from a .hi corresponding to a
  79 module that's packaged up in a DLL or not, so that we later can emit the
  80 appropriate code.
  81
  82 The logic for how an interface file is marked as corresponding to a module that's
  83 hiding in a DLL is explained elsewhere (ToDo: give renamer href here.)
  84
  85 @SourceOnly@ and @ObjectCode@ indicate a module from the same package
  86 as the one being compiled, i.e. a home module.  @InPackage@ means one
  87 from a different package.
  88
  89 \begin{code}
  90 data ModuleKind
  91    = SourceOnly FilePath            -- .hs
  92    | ObjectCode FilePath FilePath   -- .o, .hi
  93    | InPackage  PackageName
  94
  95 isPackageKind (InPackage _) = True
  96 isPackageKind _             = False
  97
  98 type PackageName = FastString           -- No encoding at all
  99
 100 preludePackage :: PackageName
 101 preludePackage = SLIT("std")
 102
 103 instance Outputable ModuleKind where
 104    ppr (SourceOnly path_hs)
 105       = text "SourceOnly" <+> text (show path_hs)
 106    ppr (ObjectCode path_o path_hi)
 107       = text "ObjectCode" <+> text (show path_o) <+> text (show path_hi)
 108    ppr (InPackage pkgname)
 109       = text "InPackage" <+> text (show pkgname)
 110 \end{code}
 111
 112
 113 %************************************************************************
 114 %*                                                                      *
 115 \subsection{Where from}
 116 %*                                                                      *
 117 %************************************************************************
 118
 119 The @WhereFrom@ type controls where the renamer looks for an interface file
 120
 121 \begin{code}
 122 data WhereFrom = ImportByUser           -- Ordinary user import: look for M.hi
 123                | ImportByUserSource     -- User {- SOURCE -}: look for M.hi-boot
 124                | ImportBySystem         -- Non user import.  Look for M.hi if M is in
 125                                         -- the module this module depends on, or is a system-ish module;
 126                                         -- M.hi-boot otherwise
 127
 128 instance Outputable WhereFrom where
 129   ppr ImportByUser       = empty
 130   ppr ImportByUserSource = ptext SLIT("{- SOURCE -}")
 131   ppr ImportBySystem     = ptext SLIT("{- SYSTEM IMPORT -}")
 132 \end{code}
 133
 134
 135 %************************************************************************
 136 %*                                                                      *
 137 \subsection{The name of a module}
 138 %*                                                                      *
 139 %************************************************************************
 140
 141 \begin{code}
 142 newtype ModuleName = ModuleName EncodedFS
 143         -- Haskell module names can include the quote character ',
 144         -- so the module names have the z-encoding applied to them
 145
 146 instance Uniquable ModuleName where
 147   getUnique (ModuleName nm) = mkUniqueGrimily (uniqueOfFS nm)
 148
 149 instance Eq ModuleName where
 150   nm1 == nm2 = getUnique nm1 == getUnique nm2
 151
 152 -- Warning: gives an ordering relation based on the uniques of the
 153 -- FastStrings which are the (encoded) module names.  This is _not_
 154 -- a lexicographical ordering.
 155 instance Ord ModuleName where
 156   nm1 `compare` nm2 = getUnique nm1 `compare` getUnique nm2
 157
 158 instance Outputable ModuleName where
 159   ppr = pprModuleName
 160
 161
 162 pprModuleName :: ModuleName -> SDoc
 163 pprModuleName (ModuleName nm) = pprEncodedFS nm
 164
 165 moduleNameString :: ModuleName -> EncodedString
 166 moduleNameString (ModuleName mod) = _UNPK_ mod
 167
 168 moduleNameUserString :: ModuleName -> UserString
 169 moduleNameUserString (ModuleName mod) = decode (_UNPK_ mod)
 170
 171 -- used to be called mkSrcModule
 172 mkModuleName :: UserString -> ModuleName
 173 mkModuleName s = ModuleName (_PK_ (encode s))
 174
 175 -- used to be called mkSrcModuleFS
 176 mkModuleNameFS :: UserFS -> ModuleName
 177 mkModuleNameFS s = ModuleName (encodeFS s)
 178
 179 -- used to be called mkSysModuleFS
 180 mkSysModuleNameFS :: EncodedFS -> ModuleName
 181 mkSysModuleNameFS s = ModuleName s
 182 \end{code}
 183
 184 \begin{code}
 185 data Module = Module ModuleName ModuleKind
 186
 187 mod_name (Module nm kind) = nm
 188 mod_kind (Module nm kind) = kind
 189 \end{code}
 190
 191 \begin{code}
 192 instance Outputable Module where
 193   ppr = pprModule
 194
 195 instance Uniquable Module where
 196   getUnique (Module nm _) = getUnique nm
 197
 198 -- Same if they have the same name.
 199 instance Eq Module where
 200   m1 == m2 = getUnique m1 == getUnique m2
 201
 202 -- Warning: gives an ordering relation based on the uniques of the
 203 -- FastStrings which are the (encoded) module names.  This is _not_
 204 -- a lexicographical ordering.
 205 instance Ord Module where
 206   m1 `compare` m2 = getUnique m1 `compare` getUnique m2
 207 \end{code}
 208
 209
 210 \begin{code}
 211 pprModule :: Module -> SDoc
 212 pprModule (Module mod p) = getPprStyle $ \ sty ->
 213                            if debugStyle sty then
 214                                 -- Print the package too
 215                                 ppr p <> dot <> pprModuleName mod
 216                            else
 217                                 pprModuleName mod
 218 \end{code}
 219
 220
 221 \begin{code}
 222 mkModule :: ModuleName -> ModuleKind -> Module
 223 mkModule = Module
 224 -- I don't think anybody except the Finder should ever try to create a
 225 -- Module now, so this lot commented out pro tem (JRS)
 226 --mkModule :: ModuleName        -- Name of the module
 227 --       -> PackageName
 228 --       -> Module
 229 --mkModule mod_nm pack_name
 230 --  = Module mod_nm pack_info
 231 --  where
 232 --    pack_info | pack_name == opt_InPackage = ThisPackage
 233 --            | otherwise                  = AnotherPackage pack_name
 234
 235
 236 --mkVanillaModule :: ModuleName -> Module
 237 --mkVanillaModule name = Module name ThisPackage
 238         -- Used temporarily when we first come across Foo.x in an interface
 239         -- file, but before we've opened Foo.hi.
 240         -- (Until we've opened Foo.hi we don't know what the PackageInfo is.)
 241
 242 --mkThisModule :: ModuleName -> Module  -- The module being compiled
 243 --mkThisModule name = Module name ThisPackage
 244
 245 --mkPrelModule :: ModuleName -> Module
 246 --mkPrelModule name = mkModule name preludePackage
 247
 248 moduleString :: Module -> EncodedString
 249 moduleString (Module (ModuleName fs) _) = _UNPK_ fs
 250
 251 moduleName :: Module -> ModuleName
 252 moduleName (Module mod _) = mod
 253
 254 moduleUserString :: Module -> UserString
 255 moduleUserString (Module mod _) = moduleNameUserString mod
 256 \end{code}
 257
 258 \begin{code}
 259 --isLocalModule :: Module -> Bool
 260 --isLocalModule (Module _ ThisPackage) = True
 261 --isLocalModule _                            = False
 262 \end{code}