-> Action ()

 runAr outputFilePath arPath flagArgs fileArgs buildOptions = do

     rspFile <- responseFilePath outputFilePath

     cmd [arPath] flagArgs ('@' : rspFile) buildOptions

 -- | Invoke @ar@ given a path to it and a list of arguments. Note that @ar@

     -- * File system operations

     copyFile, copyFileUntracked, createFileLink, fixFile,

     makeExecutable, moveFile, removeFile, createDirectory, copyDirectory,

     -- * Diagnostic info

     Colour (..), ANSIColour (..), putColoured, shouldUseColor,

 import Data.Maybe

 import Data.Typeable (TypeRep, typeOf)

 import Development.Shake hiding (Normal)

 import Development.Shake.Classes

 import Development.Shake.Command (CmdArgument (..), IsCmdArgument (toCmdArgument))

 import Development.Shake.FilePath

         then cmd argsPre argsResp argsPost

         else do

             rspFile <- responseFilePath outputFilePath

             cmd argsPre ['@' : rspFile] argsPost

 -- | Convert a command's output file path to a response file path to be used for that command.

     putProgressInfo =<< renderAction "Copy file (untracked)" source target

     liftIO $ IO.copyFile source target

 -- | Transform a given file by applying a function to its contents.

 fixFile :: FilePath -> (String -> String) -> Action ()

 fixFile file f = do

         let new = f old

         IO.evaluate $ rnf new

         return new

 -- | Make a given file executable by running the @chmod +x@ command.

 makeExecutable :: FilePath -> Action ()

         bindistContext = vanillaContext library_stage compiler

     bindistSettingsContent <- interpretInContext bindistContext $

         generateSettings bindistSettings False "package.conf.d"

     copyDirectory rtsIncludeDir         bindistFilesDir

     when windowsHost $ createGhcii (bindistFilesDir -/- "bin")

     need $ map (bindistFilesDir -/-)

               (["configure", "Makefile"] ++ bindistInstallFiles)

     copyFile ("hadrian" -/- "bindist" -/- "config.mk.in") (bindistFilesDir -/- "config.mk.in")

     copyFile ("hadrian" -/- "cfg" -/- "default.target.in") (bindistFilesDir -/- "default.target.in")

     copyFile ("hadrian" -/- "cfg" -/- "default.host.target.in") (bindistFilesDir -/- "default.host.target.in")

               versioned_wrapper = wrapper_name ++ "-" ++ suffix

               versioned_wrapper_path = bindistFilesDir -/- "wrappers" -/- versioned_wrapper

           -- Write the wrapper to the versioned path

           -- Create a symlink from the non-versioned to the versioned.

           liftIO $ do

             IO.removeFile unversioned_wrapper_path <|> return ()

         withVerbosity Diagnostic $

           buildWithCmdOptions [] $

             target (vanillaContext Stage2 pkg) (Cabal Install Stage2) [] []

     phony "build-cabal" $ need [root -/- "stage-cabal" -/- "bin" -/- ".stamp"]

                     ]

                   output_file = outputDir -/- wrapper_name

               wrapper_content <- wrapper Stage2 wrapper_name

               makeExecutable output_file

               pure ()

         syn  <- pkgSynopsis    (Context.package ctx)

         desc <- pkgDescription (Context.package ctx)

         let prologue = if null desc then syn else desc

     root -/- htmlRoot -/- "libraries/*/*.haddock" %> \file -> do

         context <- pkgDocContext =<< getPkgDocTarget root file

     outPath %> \_ -> do

         s <- readFile' inPath

         result <- runInterpolations interps s

         putSuccess ("| Successfully generated " ++ outPath ++ " from its template")

 templateRule :: FilePath -> Interpolations -> Rules ()

   -- Write the current time into the file so the file always changes if

   -- we restamp it because a dependency changes.

   time <- liftIO $ getCurrentTime

   ways <- interpretInContext ctx getLibraryWays

   let hasVanilla = elem vanilla ways

       hasDynamic = elem dynamic ways

   when ((hasVanilla && hasDynamic) &&

         support && way == vanilla) $ do

     stamp <- (pkgStampFile (ctx { way = dynamic }))

         unit $ cmd (Cwd "nofib") [makePath] ["clean"]

         unit $ cmd (Cwd "nofib") [makePath] (nofibArgs ++ ["boot"])

         (Exit e, Stdouterr log) <- cmd (Cwd "nofib") [makePath] nofibArgs

         if e == ExitSuccess

             then putVerbose $ "nofib log available at " ++ fp

             else error $ "nofib failed, full log available at " ++ fp

         top <- topDirectory

         need [ top -/- "configure" ]

         copyDirectory (top -/- "inplace" -/- "mingw") root

     -- Rules for programs that are actually built by hadrian.

     forM_ allStages $ \stage ->

         -- leads to errors in GHC).

         buildWithResources rs $

             target (Context stage compiler vanilla iplace) (GhcPkg Recache stage) [] []

     -- Special rule for registering system-cxx-std-lib

     root -/- relativePackageDbPath (PackageDbLoc stage iplace) -/- systemCxxStdLibConf %> \file -> do

     templateIn <- readFile' "rts/win32/libHSghc-internal.def.in"

     let dllName = takeFileName target -<.> "dll"

         templateOut = replace "@GhcInternalDll@" dllName templateIn

 buildGhcInternalImportLib :: Stage -> FilePath -> Action ()

 buildGhcInternalImportLib stg target = do

       need [mingw_tarballs_stamp]

     mingw_tarballs_stamp %> \stamp -> do

       build (target (vanillaContext Stage1 compiler) (Win32Tarballs DownloadTarballs) [] [])

 archiveSourceTree :: (FilePath -> Action ()) -> FilePath -> Action ()

             let script = unlines

                     [ "#!/bin/sh"

                     , "exec " ++ python ++ " $0.py \"$@\"" ]

             makeExecutable (root -/- timeoutPath)

 -- | Build extra programs and libraries required by testsuite

   -- Get the arguments for all the targets

   pargs <- mapM one_args tool_targets

   -- Build any other dependencies (such as generated files)

   where

     resp_file root p = root </> "multi" </> pkgName p

           normalisePackageIds (x:xs) = x : normalisePackageIds xs

           normalisePackageIds [] = []

                                                       ++  modules cd

                                                       ++ concatMap rexp (reexportModules cd)

                                                       ++ ["-outputdir", hidir,

     Just (_, (p, extra)) -> mkToolTarget extra p

     Nothing -> fail $ "No prefixes matched " ++ show fp ++ " IN\n " ++ show mm

 writeOutput args = do

 mkToolTarget :: [String] -> Package -> Action ()

 mkToolTarget es p = do

     need (gens ++ srcs ++ dep_confs)

     arg_list <- interpret fake_target getArgs

 -- This list is quite a lot like stage0packages but doesn't include

 -- critically the `exe:ghc` component as that depends on the GHC library

       cd <- readContextData c

       ids <- liftIO $ mapM canonicalizePath [pkgPath p </> i | i <- srcDirs cd]

       return $ map (,(p, modules cd ++ otherModules cd)) ids