import Stage

 import Oracles.Flag

 import Expression

 data BindistConfig = BindistConfig { library_stage :: Stage -- ^ The stage compiler which builds the libraries

                                    , executable_stage :: Stage -- ^ The stage compiler which builds the executables

   -- libraries built for the host, but the distributed compiler would produce files for

   -- the target.

   cross <- flag CrossCompiling

 -- | Are we building things in this stage for the final target?

 buildingForTarget ::  Stage -> Action Bool

 data Relocatable = Relocatable | NotRelocatable

     root <- buildRoot

     version        <- setting ProjectVersion

     targetPlatform <- setting TargetPlatformFull

         bindistFilesDir  = root -/- "bindist" -/- ghcVersionPretty

     runBuilder (Configure bindistFilesDir) ["--prefix="++prefix] [] []

     let env = case relocatable of

     runBuilderWithCmdOptions env (Make bindistFilesDir) ["install"] [] []

     verbosity <- getVerbosity

     -- We 'need' all binaries and libraries

     distDir        <- Context.distDir (vanillaContext library_stage rts)

     let ghcBuildDir      = root -/- stageString library_stage

         ghcVersionPretty = "ghc-" ++ version ++ "-" ++ targetPlatform

         rtsIncludeDir    = distDir -/- "include"

     let bindistSettings = bindistFilesDir -/- "lib" -/- "settings"

         bindistContext = vanillaContext library_stage compiler

     bindistSettingsContent <- interpretInContext bindistContext $

     writeFile' bindistSettings bindistSettingsContent

     copyDirectory rtsIncludeDir         bindistFilesDir

     --

     -- N.B. the ghc-pkg executable may be prefixed with a target triple

     -- (c.f. #20267).

     need ["docs"]

 bindistRules :: Rules ()

 bindistRules = do

     root <- buildRootRules

         cwd <- liftIO IO.getCurrentDirectory

         version        <- setting ProjectVersion

         targetPlatform <- setting TargetPlatformFull

         let prefixErr = "You must specify a path with --prefix when using the"

         installPrefix <- fromMaybe (error prefixErr) <$> cmdPrefix

     phony "binary-dist-dir" $ do

       cfg <- implicitBindistConfig

     let buildBinDist compressor = do

           win_host <- isWinHost

           win_target <- isWinTarget Stage2

           when (win_target && win_host) (error "normal binary-dist does not work for windows targets, use `reloc-binary-dist-*` target instead.")

             need [target]

             version        <- setting ProjectVersion

             targetPlatform <- setting TargetPlatformFull

             -- Finally, we create the archive <root>/bindist/ghc-X.Y.Z-platform.tar.xz

             tarPath <- builderPath (Tar Create)

       phony (name <> "-dist-bzip2") $ mk_bindist Bzip2

       phony (name <> "-dist-xz") $ mk_bindist Xz

     -- Prepare binary distribution configure script

     -- (generated under <ghc root>/distrib/configure by 'autoreconf')

         ghcRoot <- topDirectory

         copyFile (ghcRoot -/- "aclocal.m4") (ghcRoot -/- "distrib" -/- "aclocal.m4")

         copyDirectory (ghcRoot -/- "m4") (ghcRoot -/- "distrib")

         buildWithCmdOptions env $

             target (vanillaContext Stage1 ghc) (Autoreconf $ ghcRoot -/- "distrib") [] []

         removeFile (ghcRoot -/- "distrib" -/- "aclocal.m4")

         removeDirectory (ghcRoot -/- "distrib" -/- "m4")

         moveFile (ghcRoot -/- "distrib" -/- "configure") configurePath

 data Compressor = Gzip | Bzip2 | Xz

                 deriving (Eq, Ord, Show)

         -- These are the packages which we want to expose to the user and hence

         -- there are wrappers installed in the bindist.

       | pkg `elem` [hpcBin, haddock, hp2ps, hsc2hs, ghc, ghcPkg]

       | otherwise     -> pure []

 wrapper :: Stage -> FilePath -> Action String

         let cabal_package_db = cwd -/- root -/- "stage-cabal" -/- "dist-newstyle" -/- "packagedb" -/- "ghc-" ++ version

         forM_ bin_targets $ \(bin_pkg,_bin_path) -> do

             let pgmName pkg

                   | pkg == ghc    = "ghc"

                   | pkg == hpcBin = "hpc"

                   | otherwise     = pkgName pkg

             let cabal_bin_out = work_dir -/- "cabal-bin" -/- (pgmName bin_pkg)

             forM_ needed_wrappers $ \wrapper_name -> do

               let wrapper_prefix = unlines

                     ["#!/usr/bin/env sh"

                     ,"export GHC_PACKAGE_PATH="++show cabal_package_db++":"

                     ]

                   output_file = outputDir -/- wrapper_name

               writeFile' output_file (wrapper_prefix ++ wrapper_content)

               makeExecutable output_file

               pure ()

                       then root -/- stageString stage' -/- "lib"

                       else prefix

                 relPkgDb = makeRelativeNoSysLink libTopDir pkgDb

         (prefix -/- "targets" -/- "default.target") %> \out -> go (show <$> expr (targetStage (succStage stage))) out

   where

 templateRule outPath =

   templateRuleFrom (outPath <.> "in") outPath

 templateRules :: Rules ()

 templateRules = do

   templateRule "compiler/ghc.cabal" $ projectVersion

     , interpolateVar "TargetOS_CPP" $ cppify <$> getTarget queryOS

     , interpolateVar "LLVMTarget" $ getTarget tgtLlvmTarget

     ]

     [ interpolateSetting "ConfiguredEmsdkVersion" EmsdkVersion

     , interpolateVar "CrossCompilePrefix" $ do

     , interpolateVar "LeadingUnderscore" $ yesNo <$> getTarget tgtSymbolsHaveLeadingUnderscore

     , interpolateSetting "LlvmMaxVersion" LlvmMaxVersion

     , interpolateSetting "LlvmMinVersion" LlvmMinVersion

     , interpolateVar "TablesNextToCode" $ yesNo <$> getTarget tgtTablesNextToCode

     , interpolateVar "TargetHasLibm" $ yesNo <$> interp (staged (buildFlag TargetHasLibm))

     , interpolateVar "TargetPlatform" $ getTarget targetPlatformTriple

     , interpolateVar "TargetWordBigEndian" $ getTarget isBigEndian

     , interpolateVar "TargetWordSize" $ getTarget wordSize

     , interpolateVar "Unregisterised" $ yesNo <$> getTarget tgtUnregisterised

     , interpolateVar "BaseUnitId" $ pkgUnitId Stage1 base

     , interpolateVar "GhcWithSMP" $ yesNo <$> targetSupportsSMP Stage2

     , interpolateVar "TargetPlatformFull" (setting TargetPlatformFull)

     ]

   where

     interp = interpretInContext (semiEmptyTarget Stage2)

 -- "package.conf.d"). Callers supply the correct relative path. For bindists

 -- the layout is known statically; for in-tree builds callers compute it. For

 -- bindists, we omit @LibDir@ so it defaults to @topDir@ at runtime.

     ctx <- getContext

     stage <- getStage

     -- For cross compilers, LibDir points to the succeeding stage's lib dir

     -- (which contains the target architecture's libraries). For non-cross,

     -- it points to the preceding stage's lib dir as usual.

     isCrossLibDir <- expr $ crossStage compilerStage

     let stage_dir_stage = if isCrossLibDir then stage else compilerStage