section: packaging

 description:

 ``ghc -c -O1 Foo.hs -O2 Bar.hs`` to apply different optimisation levels

 to the files ``Foo.hs`` and ``Bar.hs``.

 .. note::

     .. index::

         ``-fspecialise`` will not be enabled, since the ``-fno-specialise``

         overrides the ``-fspecialise`` implied by ``-O1``.

 .. _source-file-options:

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 .. index::

             case builder of

                 Ar Pack stg -> do

                     useTempFile <- arSupportsAtFile stg

                                    else runArWithoutTempFile path buildArgs buildInputs buildOptions

                 Ar Unpack _ -> cmd' [Cwd output] [path] buildArgs buildOptions

                     Exit _ <- cmd' [path] (buildArgs ++ [input]) buildOptions

                     return ()

                 Ghc _ _ ->

                   -- Use a response file for ghc invocations to avoid issues with command line

                   -- NB: we can't put the buildArgs in a response file, because some flags require

                   -- empty arguments (such as the -dep-suffix flag), but that isn't supported

                   -- yet due to #26560.

                     buildInputs

                 HsCpp    -> captureStdout

 -- | Invoke @haddock@ given a path to it and a list of arguments. On Windows,

 -- the input file arguments are passed as a response file.

       -> [String]

       -> [FilePath]  -- ^ input file paths

       -> Action ()

   fileInputs

 -- TODO: Some builders are required only on certain platforms. For example,

 -- 'Objdump' is only required on OpenBSD and AIX. Add support for platform

     lookupBignum,

     cmdBignum, cmdProgressInfo, cmdCompleteSetting,

     cmdDocsArgs, cmdUnitIdHash, lookupBuildRoot, TestArgs(..), TestSpeed(..), defaultTestArgs,

     ) where

 import Data.Either

 import Data.List.Extra

 import Development.Shake hiding (Normal)

 import Flavour (DocTargets, DocTarget(..))

 import Settings.Parser

 import System.Console.GetOpt

 import System.Environment

     , testArgs       :: TestArgs

     , docsArgs       :: DocArgs

     , docTargets     :: DocTargets

     , prefix           :: Maybe FilePath

     , changelogVersion :: Maybe String

     , completeStg      :: Maybe String }

     , testArgs       = defaultTestArgs

     , docsArgs       = defaultDocArgs

     , docTargets     = Set.fromList [minBound..maxBound]

     , prefix           = Nothing

     , changelogVersion = Nothing

     , completeStg      = Nothing }

 readFreeze2 = Right $ \flags -> flags { freeze1 = True, freeze2 = True }

 readSkipDepends = Right $ \flags -> flags { skipDepends = True }

 readUnitIdHash :: Either String (CommandLineArgs -> CommandLineArgs)

 readUnitIdHash = Right $ \flags ->

   trace "--hash-unit-ids is deprecated. It is enabled by release flavour or +hash_unit_ids flavour transformer" $

       "Progress info style (None, Brief, Normal or Unicorn)."

     , Option [] ["docs"] (ReqArg readDocsArg "TARGET")

       "Strip down docs targets (none, no-haddocks, no-sphinx[-{html, pdfs, man}]."

     , Option ['k'] ["keep-test-files"] (NoArg readTestKeepFiles)

       "Keep all the files generated when running the testsuite."

     , Option [] ["test-compiler"] (ReqArg readTestCompiler "TEST_COMPILER")

     return $ insertExtra (progressInfo               args) -- Accessed by Hadrian.Utilities

            $ insertExtra (buildRoot                  args) -- Accessed by Hadrian.Utilities

            $ insertExtra (testArgs                   args) -- Accessed by Settings.Builders.RunTest

            $ insertExtra (docsArgs                   args) -- Accessed by Rules.Documentation

            $ insertExtra allSettings                       -- Accessed by Settings

 cmdBignum :: Action (Maybe String)

 cmdBignum = bignum <$> cmdLineArgs

 cmdProgressInfo :: Action ProgressInfo

 cmdProgressInfo = progressInfo <$> cmdLineArgs

 -- to be archived is passed via a temporary response file. Passing arguments

 -- via a response file is not supported by some versions of @ar@, in which

 -- case you should use 'runArWithoutTempFile' instead.

       -> [String]    -- ^ other arguments

       -> [FilePath]  -- ^ input file paths

       -> [CmdOption] -- ^ Additional options

       -> Action ()

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

 -- will be called multiple times if the list of files to be archived is too

 {-# LANGUAGE TypeFamilies #-}

 module Hadrian.Utilities (

     -- * List manipulation

     fromSingleton, replaceEq, minusOrd, intersectOrd, lookupAll, chunksOfSize,

     -- * Paths

     BuildRoot (..), buildRoot, buildRootRules, isGeneratedSource,

     -- * File system operations

     copyFile, copyFileUntracked, createFileLink, fixFile,

 import Data.Typeable (TypeRep, typeOf)

 import Development.Shake hiding (Normal)

 import Development.Shake.Classes

 import Development.Shake.FilePath

 import GHC.ResponseFile (escapeArgs)

 import System.Environment (lookupEnv)

 import System.IO.Error (isPermissionError)

 import qualified Data.ByteString        as BS

 -- library, they can reach 2MB! Some operating systems do not support command

 -- lines of such length, and this function can be used to obtain a reasonable

 -- approximation of the limit. On Windows, it is theoretically 32768 characters

 -- the builder path & name, auxiliary flags, and other overheads. On Mac OS X,

 -- ARG_MAX is 262144, yet when using @xargs@ on OSX this is reduced by over

 -- 20000. Hence, 200000 seems like a sensible limit. On other operating systems

 -- we currently use the 4194304 setting.

 cmdLineLengthLimit :: Int

                    | IO.isMac     = 200000

                    | otherwise    = 4194304

 isGeneratedSource :: FilePath -> Action Bool

 isGeneratedSource file = buildRoot <&> (`isPrefixOf` file)

 -- | Link a file tracking the link target. Create the target directory if

 -- missing.