import qualified Data.Map as Map

 import qualified Data.Set as Set

 import GHC.Types.Error (mkUnknownDiagnostic)

 -- | Entry point to compile a Backpack file.

 doBackpack :: [FilePath] -> Ghc ()

         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 System.Environment (lookupEnv)

 import System.FilePath (normalise, (</>))

 import System.Directory

 import GHC.Foreign (withCString, peekCString)

 import qualified Data.Set as Set

 data PkgDbRef

   = GlobalPkgDb

   | UserPkgDb

   deriving Eq

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

 import qualified Data.Set as Set

 import Data.Word

 import System.FilePath

 import Text.ParserCombinators.ReadP hiding (char)

 import Text.ParserCombinators.ReadP as R

 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 System.Directory

 import System.FilePath as FilePath

 import Control.Monad

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

 import Data.Char ( toUpper )

   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.

   let pkgconf = dir </> unitConfigDBName cfg

   exist <- tryMaybeT $ doesDirectoryExist pkgconf

   if exist then return pkgconf else mzero

 readUnitDatabase :: Logger -> UnitConfig -> FilePath -> IO (UnitDatabase UnitId)

 readUnitDatabase logger cfg conf_file = do

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

                          proto_pkg_configs

   --

   where

     readDirStyleUnitInfo conf_dir = do

       let filename = conf_dir </> "package.cache"

   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 <+>