import GHC.Data.Maybe

 import GHC.Data.StringBuffer

 import GHC.Data.FastString

 import qualified GHC.Data.EnumSet as EnumSet

 import qualified GHC.Data.ShortText as ST

         Nothing  -> panic "addUnit: called too early"

         Just dbs ->

          let newdb = UnitDatabase

                , unitDatabaseUnits = [u]

                }

          in return (dbs ++ [newdb]) -- added at the end because ordering matters

 import GHC.Data.Bool

 import GHC.Data.EnumSet (EnumSet)

 import GHC.Data.Maybe

 import GHC.Builtin.Names ( mAIN_NAME )

 import GHC.Driver.Backend

 import GHC.Driver.Flags

 data PkgDbRef

   = GlobalPkgDb

   | UserPkgDb

   deriving Eq

 -- | Used to differentiate the scope an include needs to apply to.

         types_var <- newIORef (md_types details)

         let kv = knotVarsFromModuleEnv (mkModuleEnv [(this_mod, types_var)])

         let hsc_env' = hscUpdateHPT act hsc_env { hsc_type_env_vars = kv }

         -- The bytecode generation itself is lazy because otherwise even when doing

         -- recompilation checking the bytecode will be generated (which slows things down a lot)

         -- the laziness is OK because generateByteCode just depends on things already loaded

 import GHC.Types.SafeHaskell

 import GHC.Types.Basic ( treatZeroAsInf )

 import GHC.Data.FastString

 import GHC.Utils.TmpFs

 import GHC.Utils.Fingerprint

 import GHC.Utils.Outputable

 package_flags_deps = [

         ------- Packages ----------------------------------------------------

     make_ord_flag defFlag "package-db"

   , make_ord_flag defFlag "clear-package-db"      (NoArg clearPkgDb)

   , make_ord_flag defFlag "no-global-package-db"  (NoArg removeGlobalPkgDb)

   , make_ord_flag defFlag "no-user-package-db"    (NoArg removeUserPkgDb)

       (NoArg (addPkgDbRef UserPkgDb))

     -- backwards compat with GHC<=7.4 :

   , make_dep_flag defFlag "package-conf"

   , make_dep_flag defFlag "no-user-package-conf"

       (NoArg removeUserPkgDb)              "Use -no-user-package-db instead"

   , make_ord_flag defGhcFlag "package-name"       (HasArg $ \name ->

 parseEnvFile envfile = mapM_ parseEntry . lines

   where

     parseEntry str = case words str of

         -- relative package dbs are interpreted relative to the env file

         where envdir = takeDirectory envfile

               db     = drop 11 str

 import Control.Monad.Trans.Except (ExceptT, runExceptT, throwE)

 import qualified Data.Set as Set

 import System.FilePath

 import System.Directory

 import System.Environment ( getEnv )

 import GHC.Data.FastString

 import qualified GHC.Data.ShortText as ST

 import GHC.Utils.Logger

 import GHC.Utils.Error

 import GHC.Utils.Exception

 import Control.Monad

 import Data.Graph (stronglyConnComp, SCC(..))

 import Data.Char ( toUpper )

 import Data.Set (Set)

 import Data.Monoid (First(..))

 import qualified Data.Semigroup as Semigroup

   where

     offsetPackageDb :: Maybe FilePath -> PackageDBFlag -> PackageDBFlag

     offsetPackageDb _ p = p

 -- | Unit database

 data UnitDatabase unit = UnitDatabase

    , unitDatabaseUnits :: [GenUnitInfo unit]

    }

 instance Outputable u => Outputable (UnitDatabase u) where

 type UnitInfoMap = UniqMap UnitId UnitInfo

         Left _ -> system_conf_refs

         Right path

          | Just (xs, x) <- snocView path, isSearchPathSeparator x

          | otherwise

   -- Apply the package DB-related flags from the command line to get the

   -- final list of package DBs.

 -- NB: This logic is reimplemented in Cabal, so if you change it,

 -- make sure you update Cabal. (Or, better yet, dump it in the

 -- compiler info so Cabal can use the info.)

 resolveUnitDatabase cfg UserPkgDb = runMaybeT $ do

   dir <- versionedAppDir (unitConfigProgramName cfg) (unitConfigPlatformArchOS cfg)

   let pkgconf = dir </> unitConfigDBName cfg

   exist <- tryMaybeT $ doesDirectoryExist pkgconf

 resolveUnitDatabase _ (PkgDbPath name) = return $ Just name

 readUnitDatabase logger cfg conf_file = do

   proto_pkg_configs <-

     if isdir

        then readDirStyleUnitInfo conf_file

        else do

             if isfile

                then do

                  mpkgs <- tryReadOldFileStyleUnitInfo

                    Just pkgs -> return pkgs

                    Nothing   -> throwGhcExceptionIO $ InstallationError $

                       "ghc no longer supports single-file style package " ++

                       ") use 'ghc-pkg init' to create the database with " ++

                       "the correct format."

                else throwGhcExceptionIO $ InstallationError $

   let

       -- Fix #16360: remove trailing slash from conf_file before calculating pkgroot

       pkg_configs1 = map (mungeUnitInfo top_dir pkgroot . mapUnitInfo (\(UnitKey x) -> UnitId x) . mkUnitKeyInfo)

                          proto_pkg_configs

   --

   return $ UnitDatabase conf_file' pkg_configs1

   where

     readDirStyleUnitInfo conf_dir = do

       if cache_exists

         then do

         else do

           -- If there is no package.cache file, we check if the database is not

           -- empty by inspecting if the directory contains any .conf file. If it

           -- does, something is wrong and we fail. Otherwise we assume that the

           -- database is empty.

           debugTraceMsg logger 2 $ text "There is no package.cache in"

                        <> text ", checking if the database is empty"

           if db_empty

             then do

               debugTraceMsg logger 3 $ text "There are no .conf files in"

                           <+> text "package database as empty"

               return []

             else

               throwGhcExceptionIO $ InstallationError $

                 " even though package database is not empty"

     -- assumes it's a file and tries to overwrite with 'writeFile'.

     -- ghc-pkg also cooperates with this workaround.

     tryReadOldFileStyleUnitInfo = do

       if take 2 content == "[]"

         then do

           if direxists

                      liftM Just (readDirStyleUnitInfo conf_dir)

              else return (Just []) -- ghc-pkg will create it when it's updated

         else return Nothing

   where

     distrust pkg = pkg{ unitIsTrusted = False }

                    -> UnitInfo -> UnitInfo

 mungeUnitInfo top_dir pkgroot =

     mungeDynLibFields

 mungeDynLibFields :: UnitInfo -> UnitInfo

 mungeDynLibFields pkg =

   where

     merge (pkg_map, prec_map) (i, UnitDatabase db_path db) = do

       debugTraceMsg logger 2 $

       forM_ (Set.toList override_set) $ \pkg ->

           debugTraceMsg logger 2 $

               text "package" <+> ppr pkg <+>

                    containers >= 0.6.2.1 && < 0.8,

                    array      >= 0.1 && < 0.6,

                    filepath   >= 1   && < 1.6,

                    template-haskell == 2.22.*,

                    hpc        >= 0.6 && < 0.8,

                    transformers >= 0.5 && < 0.7,

         GHC.Data.List.SetOps

         GHC.Data.Maybe

         GHC.Data.OrdList

         GHC.Data.Pair

         GHC.Data.SmallArray

         GHC.Data.Stream