import GHC.Types.SrcLoc

 import GHC.Types.Name.Occurrence

 import Control.DeepSeq

 import Data.IntMap.Strict (IntMap)

 import qualified Data.IntMap.Strict as IM

 getBreakDecls :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [String]

 getBreakDecls = getBreakXXX modBreaks_decls

 getBreakCCS = getBreakXXX modBreaks_ccs

 -- | Internal utility to access a ModBreaks field at a particular breakpoint index

         symbol

           | null unit = ztmp

           | otherwise = zEncodeString unit ++ "_" ++ ztmp

       Nothing -> pprPanic "loadExternalPlugins"

                   (vcat [ text "Symbol not found"

                         , text "  Library path: " <> text path

 import GHC.Prelude

 import Data.Array

 import GHC.HsToCore.Ticks (Tick (..))

 import GHC.Data.SizedSeq

 import GHC.Types.Tickish (BreakTickIndex, BreakpointId(..))

 import GHC.Unit.Module (Module)

 import GHC.Utils.Binary

 import GHC.Utils.Outputable

 import Data.List (intersperse)

 import Data.Coerce

    , modBreaks_decls  :: !(Array BreakTickIndex [String])

         -- ^ An array giving the names of the declarations enclosing each breakpoint.

         -- See Note [Field modBreaks_decls]

         -- ^ Array pointing to cost centre info for each breakpoint;

         -- actual 'CostCentre' allocation is done at link-time.

    , modBreaks_module :: !Module

           | interpreterProfiled =

               listArray

                 (0, count - 1)

                   )

                 | t <- entries

                 ]

             ccs <- {- one ccs ptr per tick index -}

               mkCostCentres

                 interp

                 (elems modBreaks_ccs)

             return $ M.fromList $

               zipWith (\el ix -> (BreakpointId modBreaks_module ix, el)) ccs [0..]

 import Control.Monad.Catch as MC (mask)

 import Data.Binary

 import Data.ByteString (ByteString)

 import Foreign hiding (void)

 import qualified GHC.Exts.Heap as Heap

 import GHC.Stack.CCS (CostCentre,CostCentreStack)

 mallocData :: Interp -> ByteString -> IO (RemotePtr ())

 mallocData interp bs = interpCmd interp (MallocData bs)

 -- | Create a set of BCOs that may be mutually recursive.

 createBCOs :: Interp -> [ResolvedBCO] -> IO [HValueRef]

 evalBreakpointToId eval_break =

   let

     mkUnitId u = fsToUnit $ mkFastStringShortByteString u

   in

     InternalBreakpointId

       { ibi_info_mod   = toModule (eb_info_mod_unit eval_break) (eb_info_mod eval_break)

 lookupSymbol interp str = withSymbolCache interp str $

   case interpInstance interp of

 #if defined(HAVE_INTERNAL_INTERPRETER)

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

       ExtJS {} -> pprPanic "lookupSymbol not supported by the JS interpreter" (ppr str)

       ExtWasm i -> withWasmInterp i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

 lookupSymbolInDLL :: Interp -> RemotePtr LoadedDLL -> InterpSymbol s -> IO (Maybe (Ptr ()))

 lookupSymbolInDLL interp dll str = withSymbolCache interp str $

   case interpInstance interp of

 #if defined(HAVE_INTERNAL_INTERPRETER)

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

       ExtJS {} -> pprPanic "lookupSymbol not supported by the JS interpreter" (ppr str)

       -- wasm dyld doesn't track which symbol comes from which .so

       ExtWasm {} -> lookupSymbol interp str

 lookupClosure :: Interp -> InterpSymbol s -> IO (Maybe HValueRef)

 lookupClosure interp str =

 -- | 'withSymbolCache' tries to find a symbol in the 'interpLookupSymbolCache'

 -- which maps symbols to the address where they are loaded.

   PatSigErrCtxt sig_ty res_ty ->

     vcat [ hang (text "When checking that the pattern signature:")

               4 (ppr sig_ty)

   PatCtxt pat ->

     hang (text "In the pattern:") 2 (ppr pat)

       full_herald = pprExpectedFunTyHerald herald

                 <+> speakNOf n_vis_args_in_call (text "visible argument")

                  -- What are "visible" arguments? See Note [Visibility and arity] in GHC.Types.Basic

     | -- Check for too few args

       --  fun_tau = a -> b, res_tau = Int

       n_fun > n_env

     -> empty

       -- text "Debug" <+> vcat [ppr fun, ppr n_val_args, ppr res_fun, ppr res_env, ppr n_fun, ppr n_env]

     where

       not_fun ty   -- ty is definitely not an arrow type,

                    -- and cannot conceivably become one

         = case tcSplitTyConApp_maybe ty of

 import GHC.Driver.DynFlags

 import GHC.Utils.Misc

 import GHC.Utils.Outputable as Outputable

 import GHC.Data.Maybe

 *                                                                      *

 ********************************************************************* -}

               -> TcType -> ExpRhoType

               -> TcM a -> TcM a

 -- When we have a mis-match in the return type of a function

 -- But not in generated code, where we don't want

 -- to mention internal (rebindable syntax) function names

 addFunResCtxt fun args fun_res_ty env_ty thing_inside

       -- NB: use a landmark error context, so that an empty context

       -- doesn't suppress some more useful context

 {-

 Note [Splitting nested sigma types in mismatched function types]

   -- | In the instance type signature of a class method.

   | MethSigCtxt !Name !TcType !TcType

   -- | In a pattern type signature.

   | PatSigErrCtxt !TcType !ExpType

   -- | In a pattern.

   | PatCtxt !(Pat GhcRn)

   -- | In a pattern synonym declaration.

   -- | In a function call.

   | FunTysCtxt !ExpectedFunTyCtxt !Type !Int !Int

   -- | In the result of a function call.

   -- | In the declaration of a type constructor.

   | TyConDeclCtxt !Name !(TyConFlavour TyCon)

   -- | In a type or data family instance (or default instance).

 isHsCtxtLandmark (FunResCtxt{}) = True

 isHsCtxtLandmark (VDQWarningCtxt{}) = True

 isHsCtxtLandmark _ = False

   ExpType(..), ExpKind, InferResult(..), InferInstFlag(..), InferFRRFlag(..),

   ExpTypeFRR, ExpSigmaType, ExpSigmaTypeFRR,

   ExpRhoType, ExpRhoTypeFRR,

   checkingExpType_maybe, checkingExpType,

   ExpPatType(..), mkCheckExpFunPatTy, mkInvisExpPatType,

   | IIF_ShallowRho  -- Trying to infer a shallow RhoType (no foralls or => at the top)

                     -- Top-instantiate (only, regardless of DeepSubsumption) before filling the hole

   | IIF_DeepRho     -- Trying to infer a possibly-deep RhoType (depending on DeepSubsumption)

                     -- If DeepSubsumption is off, same as IIF_ShallowRho

                     -- If DeepSubsumption is on, instantiate deeply before filling the hole

 type ExpSigmaType = ExpType

 type ExpRhoType   = ExpType

 mkCheckExpType :: TcType -> ExpType

 mkCheckExpType = Check

 -- | Returns the expected type when in checking mode.

 checkingExpType_maybe :: ExpType -> Maybe TcType

 checkingExpType_maybe (Check ty) = Just ty

 zonkTidyHsCtxt env (FunTysCtxt ctxt ty i1 i2) = do

   (env', ty') <- zonkTidyTcType env ty

   return $ (env', FunTysCtxt ctxt ty' i1 i2)

 zonkTidyHsCtxt env (PatSigErrCtxt sig_ty res_ty) = do

   (env', sig_ty') <- zonkTidyTcType env sig_ty

 zonkTidyHsCtxt env p = return (env, p)

   * Hide implementation details when throwing exceptions in throw and throwSTM. ([CLC proposal #387](https://github.com/haskell/core-libraries-committee/issues/387))

   * Change `hIsReadable` and `hIsWritable` such that they always throw a respective exception when encountering a closed or semi-closed handle, not just in the case of a file handle. ([CLC proposal #371](github.com/haskell/core-libraries-committee/issues/371))

   * Annotate `onException` continuation with `WhileHandling`. ([CLC Proposal #397](https://github.com/haskell/core-libraries-committee/issues/397))

 ## 4.22.0.0 *TBA*

   * Shipped with GHC 9.14.1

     pred (maxBound::Char) = '\1114110'

     pred (minBound::Char) = error "Prelude.Enum.Char.pred: bad argument"

     (map (toEnum::Int->Char) [123,ord (minBound::Char), ord(maxBound::Char)]) = "{\NUL\1114111"

     (map fromEnum ['X',minBound,maxBound]) = [88,0,1114111]

     (take 7 ['\NUL' .. ]) = "\NUL\SOH\STX\ETX\EOT\ENQ\ACK"

     (take 7 ['\250' .. ]) = "\250\251\252\253\254\255\256"

     pred (maxBound::Char) = '\1114110'

     pred (minBound::Char) = error "Prelude.Enum.Char.pred: bad argument"

     (map (toEnum::Int->Char) [123,ord (minBound::Char), ord(maxBound::Char)]) = "{\NUL\1114111"

     (map fromEnum ['X',minBound,maxBound]) = [88,0,1114111]

     (take 7 ['\NUL' .. ]) = "\NUL\SOH\STX\ETX\EOT\ENQ\ACK"

     (take 7 ['\250' .. ]) = "\250\251\252\253\254\255\256"

     pred (maxBound::Char) = '\1114110'

     pred (minBound::Char) = error "Prelude.Enum.Char.pred: bad argument"

     (map (toEnum::Int->Char) [123,ord (minBound::Char), ord(maxBound::Char)]) = "{\NUL\1114111"

     (map fromEnum ['X',minBound,maxBound]) = [88,0,1114111]

     (take 7 ['\NUL' .. ]) = "\NUL\SOH\STX\ETX\EOT\ENQ\ACK"

     (take 7 ['\250' .. ]) = "\250\251\252\253\254\255\256"

 import GHC.Internal.Classes (eqChar, neChar)

 import GHC.Internal.Base (otherwise, (++))

 import GHC.Internal.Show

 import GHC.Internal.Prim (chr#, int2Word#, leWord#, Int#, Char#)

 import GHC.Internal.Types (Char(..), Int(..), isTrue#)

 {-# NOINLINE chr_error #-}

 chr_error :: Int# -> Char#

   -- These all invoke the corresponding functions in the RTS Linker API.

   InitLinker :: Message ()

   LoadDLLs :: [String] -> Message (Either String [RemotePtr LoadedDLL])

   LoadArchive :: String -> Message () -- error?

   LoadObj :: String -> Message () -- error?

   -- | Create a set of CostCentres with the same module name

   MkCostCentres

    -> Message [RemotePtr CostCentre]

   -- | Show a 'CostCentreStack' as a @[String]@

 instance Binary a => Binary (EvalStatus_ a b)

 data EvalBreakpoint = EvalBreakpoint

   , eb_info_mod_unit :: BS.ShortByteString -- ^ Breakpoint tick module unit id

   , eb_info_index    :: Int    -- ^ Breakpoint info index

   }

 import GHCi.Message (LoadedDLL)

 import Control.Exception (throwIO, ErrorCall(..))

 import Control.Monad    ( when )

 import Data.Foldable

 import Foreign.C

 import Foreign.Marshal.Alloc ( alloca, free )

 purgeObj :: String -> IO ()

 purgeObj f = throwIO $ ErrorCall $ "purgeObj: unsupported on wasm for " <> f

   evaluate $ if r == nullPtr then Nothing else Just r

 lookupSymbolInDLL _ _ = pure Nothing

 resolveObjs :: IO Bool

 initObjLinker RetainCAFs = c_initLinker_ 1

 initObjLinker _ = c_initLinker_ 0

 lookupSymbol str_in = do

    let str = prefixUnderscore str_in

      addr <- c_lookupSymbol c_str

      if addr == nullPtr

         then return Nothing

         else return (Just addr)

 lookupSymbolInDLL dll str_in = do

    let str = prefixUnderscore str_in

      addr <- c_lookupSymbolInNativeObj dll c_str

      if addr == nullPtr

        then return Nothing

        else return (Just addr)

 prefixUnderscore

  | otherwise          = id

 -- | loadDLL loads a dynamic library using the OS's native linker

 #endif

 lookupClosure str = do

   m <- lookupSymbol str

   case m of

 import Control.Exception

 import Control.Monad

 import Data.ByteString (ByteString)

 import qualified Data.ByteString.Unsafe as B

 import GHC.Exts

 import qualified GHC.Exts.Heap as Heap

 foreign import javascript "((ptr,off) => globalThis.h$lookupClosure(h$decodeUtf8z(ptr,off)))" lookupJSClosure# :: CString -> State# RealWorld -> (# State# RealWorld, Int# #)

   case lookupJSClosure# cstr s of

     (# s', r #) -> (# s', I# r #))

 lookupJSClosure str = lookupJSClosure' str >>= \case

   0 -> pure Nothing

   r -> pure (Just (RemoteRef (RemotePtr (fromIntegral r))))

        if is_exception

        then pure Nothing

        else do

          info_mod_uid <- BS.packCString (Ptr info_mod_uid#)

          pure (Just (EvalBreakpoint info_mod info_mod_uid (I# infox#)))

      putMVar statusMVar $ EvalBreak apStack_r breakpoint resume_r ccs

   pokeElemOff (ptr :: Ptr CChar) len 0

   return (castRemotePtr (toRemotePtr ptr))

 #if defined(PROFILING)

 mkCostCentres mod ccs = do

   mapM (mk_one c_module) ccs

  where

   mk_one c_module (decl_path,srcspan) = do

     toRemotePtr <$> c_mkCostCentre c_name c_module c_srcspan

 foreign import ccall unsafe "mkCostCentre"

   c_mkCostCentre :: Ptr CChar -> Ptr CChar -> Ptr CChar -> IO (Ptr CostCentre)

 #else

 {-# LANGUAGE RecordWildCards #-}

 module Main (main) where

 import Control.Exception

 import Control.Monad

 import Foreign

 rotateSO

   :: (FunPtr (IO (StablePtr a)) -> (IO (StablePtr a)))

   -> (Maybe FilePath, FilePath)

   -> IO a

 rotateSO dynamicCall symName (old, newDLL) = do

 import GHCi.ObjLink

 lookupClosure "blah"

 module Main (main) where

 import Foreign

     }

     return 0;

   }

 }

 // The main entry point of dyld that may be run on node/browser, and