[submodule "libraries/file-io"]

 	path = libraries/file-io

 	url = https://gitlab.haskell.org/ghc/packages/file-io.git

 .. code-block:: none

     True

 Furthermore, GHCi will print the result of the I/O action if (and only

     ghci> putStrLn "hello"

     hello

     hello

     "yes"

 .. code-block:: none

     ghci> print x

     42

     ghci>

 ``IO`` monad, and bind the result to ``x``\ ”. We can then use ``x`` in

 future statements, for example to print it as we did above.

     .. code-block:: none

         ghci> :def date date

         ghci> :date

         2017-04-10 12:34:56.93213581 UTC

     .. code-block:: none

         ghci> :def mycd mycd

         ghci> :mycd ..

     in the current directory:

     .. code-block:: none

     We can define a command that reads GHCi input from a file. This

     might be useful for creating a set of bindings that we want to

     a double colon (eg ``::load``).

     It's not possible to redefine the commands ``:{``, ``:}`` and ``:!``.

 .. ghci-cmd:: :delete; * | ⟨num⟩ ...

     Delete one or more breakpoints by number (use :ghci-cmd:`:show breaks` to

     .. code-block:: none

         *ghci> :set stop 0 :cond (x < 3)

     To ignore breakpoints for a specified number of iterations use

     ghcToolchain, ghcToolchainBin, haddockApi, haddockLibrary, haddock, haskeline,

     hsc2hs, hp2ps, hpc, hpcBin, integerGmp, iserv, iservProxy,

     libffi, mtl, osString, parsec, pretty, primitive, process, remoteIserv, rts,

     transformers, unlit, unix, win32, xhtml,

     lintersCommon, lintNotes, lintCodes, lintCommitMsg, lintSubmoduleRefs, lintWhitespace,

     ghcPackages, isGhcPackage,

     , ghcCompact, ghcConfig, ghcExperimental, ghcHeap, ghcInternal, ghci, ghciWrapper, ghcPkg, ghcPrim

     , ghcToolchain, ghcToolchainBin, haddockApi, haddockLibrary, haddock, haskeline, hsc2hs

     , hp2ps, hpc, hpcBin, integerGmp, iserv, libffi, mtl, osString

     , terminfo, text, time, transformers, unlit, unix, win32, xhtml, fileio

     , timeout

     , lintersCommon

   ghcCompact, ghcConfig, ghcExperimental, ghcHeap, ghci, ghcInternal, ghciWrapper, ghcPkg, ghcPrim,

   ghcToolchain, ghcToolchainBin, haddockLibrary, haddockApi, haddock, haskeline, hsc2hs,

   hp2ps, hpc, hpcBin, integerGmp, iserv, iservProxy, remoteIserv, libffi, mtl,

   terminfo, text, time, transformers, unlit, unix, win32, xhtml,

   timeout,

   lintersCommon, lintNotes, lintCodes, lintCommitMsg, lintSubmoduleRefs, lintWhitespace

 semaphoreCompat     = lib  "semaphore-compat"

 stm                 = lib  "stm"

 templateHaskell     = lib  "template-haskell"

 terminfo            = lib  "terminfo"

 text                = lib  "text"

 time                = lib  "time"

              , runGhc

              , semaphoreCompat -- depends on

              , time -- depends on win32

              , unlit

              , if windowsHost then win32 else unix

              -- We must use the in-tree `Win32` as the version

 -- | This module gives the definition of the 'Lift' class.

 --

 -- This is an internal module.

 module GHC.Internal.TH.Lift

   ( Lift(..)

 -- >   deriving Lift

 --

 -- Representation-polymorphic since /template-haskell-2.16.0.0/.

 class Lift (t :: TYPE r) where

   -- | Turn a value into a Template Haskell expression, suitable for use in

   -- a splice.

 -- @QuasiQuoter@ that is only intended to be used in certain splice

 -- contexts, the unused fields should just 'fail'. This is most easily

 -- accomplished using 'namedefaultQuasiQuoter' or 'defaultQuasiQuoter'.

 data QuasiQuoter = QuasiQuoter {

     -- | Quasi-quoter for expressions, invoked by quotes like @lhs = $[q|...]@

     quoteExp  :: String -> Q Exp,

 ])

 if test ! -f compiler/GHC/Parser/Lexer.hs || test ! -f compiler/GHC/Cmm/Lexer.hs

 then

     FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[3.2.6],

     FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-ge],[4.0.0],

 fi

 AlexVersion=$fptools_cv_alex_version;

 AC_SUBST(AlexVersion)

 AC_SUBST(HappyCmd,$HAPPY)

 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,

 changequote(, )dnl

    fptools_cv_happy_version=`"$HappyCmd" -v |

               grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'` ;

 else

 ])

 if test ! -f compiler/GHC/Parser.hs || test ! -f compiler/GHC/Cmm/Parser.hs

 then

     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.20.0],

       [AC_MSG_ERROR([$failure_msg])])[]

     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-ge],[1.21.0],

         [AC_MSG_ERROR([$failure_msg])])[])[]

     FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-ge],[2.2.0],

       [AC_MSG_ERROR([$failure_msg])])[]

 fi

 HappyVersion=$fptools_cv_happy_version;

 AC_SUBST(HappyVersion)

 {

   uint32_t g, n;

   bdescr *bd;

   int i = 0;

   searched = 0;

   // just before a block is used.

   for (n = 0; n < getNumCapabilities(); n++) {

       bd = nurseries[i].blocks;

   }

 #endif

   for (g = 0; g < RtsFlags.GcFlags.generations; g++) {

       bd = generations[g].blocks;

       bd = generations[g].large_objects;

       for (n = 0; n < getNumCapabilities(); n++) {

           i = findPtrBlocks(p, gc_threads[n]->gens[g].part_list,

           i = findPtrBlocks(p, gc_threads[n]->gens[g].todo_bd,

       }

   }

   if (follow && i == 1) {

       debugBelch("-->\n");

     }

 #endif

     void *bad_allocs[MAX_ATTEMPTS];

     size_t bad_alloc_lens[MAX_ATTEMPTS];

     memset(bad_allocs, 0, sizeof(void*) * MAX_ATTEMPTS);

     # These aren't comprehensive; they are only CPU features that we care about

     # x86:

     'avx', 'avx2', 'avx512f',

     'fma',

     'popcnt', 'bmi1', 'bmi2'

 {-# LANGUAGE BangPatterns #-}

 import Control.Monad.ST

 import Data.Array.ST

      [collect_runtime_residency(2),

       collect_stats('bytes allocated', 5),

       only_ways(['normal']),

       ],

      compile_and_run,

      ['-O'])