section: packaging

 description:

 -- about enumerating them.  Just one set of error messages has been

 -- ported to have an open-world assumption: these are the error

 -- messages associated with type checking of foreign imports and

 -- assumption, use functions `backendValidityOfCImport` and

 -- `backendValidityOfCExport` as models, and have a look at how the

 -- 'expected back ends' are used in modules "GHC.Tc.Gen.Foreign" and

   | otherwise                               = False

 -- The set of back ends cannot be extended except by modifying the

 -- definition of @Backend@ in this module.

 --

 -- not exported.  It's crucial that they not be exported, because a

 -- value of type @Backend@ carries only the back end's /name/, not its

 -- behavior or properties.  If @Backend@ were not abstract, then code

     pure $ L l_mod $

       mod { hsmodExports = hsmodExports'

           , hsmodDecls = hsmodDecls'

 lexHsDocString :: HsDocString -> HsDoc GhcPs

 lexHsDocString = lexHsDoc parseIdentifier

 -- for

 --   (a) this binder only (it maybe a top-level or a nested declaration)

 --   (b) that do not have an enclosing breakpoint

 findBreakForBind str_name modbreaks = filter (not . enclosed) ticks

   where

     ticks = [ (index, span)

 -- source breakpoint, it means all *ocurrences* of that breakpoint across

 -- modules should be stopped at -- hence we keep a trie from BreakpointId to

 -- the list of internal break ids using it.

 type BreakpointOccurrences = ModuleEnv (IntMap.IntMap [InternalBreakpointId])

 -- | Lookup all InternalBreakpointIds matching the given BreakpointId

 -- and the SrcSpan of a breakpoint we hit, return @True@ if we should stop at

 -- this breakpoint.

 --

 -- @'RunAndLogSteps'@. We'd need further information e.g. about the user

 -- breakpoints to determine whether to break in those modes.

 breakHere :: Bool       -- ^ Was this breakpoint explicitly active (in the @BreakArray@s)?

     return $ repPrim (tyConAppTyCon ty) words

 ppr_termM1 Suspension{ty=ty, bound_to=Nothing, infoprov=mipe} =

   return $ hcat $

         space <>

         dcolon <>

         pprSigmaType ty

         space <>

         char '<' <>

         text (ipSrcFile ipe) <>

         char ':' <>

         text (ipSrcSpan ipe) <>

         char '>'

     , not $ null $ ipSrcFile ipe

 ppr_termM1 Suspension{ty=ty, bound_to=Just n}

   | otherwise = return$ parens$ ppr n <> dcolon <> pprSigmaType ty

 ppr_termM1 Term{}        = panic "ppr_termM1 - Term"

 -- | The default 'LogAction' parametrized over the standard output and standard error handles.

 -- Allows clients to replicate the log message formatting of GHC with custom handles.

 defaultLogActionWithHandles out err logflags msg_class srcSpan msg

   | log_dopt Opt_D_dump_json logflags = jsonLogActionWithHandle out logflags msg_class srcSpan msg

   | otherwise = case msg_class of

 ``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.

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

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

     let buildBinDist compressor = do

           win_target <- isWinTarget

       _                    -> False

 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool

 startsConSym c = c == ':'                -- Infix data constructors

 startsVarId c  = c == '_' || case generalCategory c of  -- Ordinary Ids

   LowercaseLetter -> True