-- by default we just care about breakpoints hit in this eval thread

   }

 execStmt

   :: GhcMonad m

   => String             -- ^ a statement (bind or expression)

   -> ExecOptions

 execStmt input exec_opts@ExecOptions{..} = do

     hsc_env <- getSession

     case mb_stmt of

       -- empty statement / comment

       Just stmt -> execStmt' stmt input exec_opts

 -- | Like `execStmt`, but takes a parsed statement as argument. Useful when

 -- doing preprocessing on the AST before execution, e.g. in GHCi (see

 -- GHCi.UI.runStmt).

 execStmt' stmt stmt_text ExecOptions{..} = do

     hsc_env <- getSession

     let interp = hscInterp hsc_env

     case r of

       Nothing ->

         -- empty statement / comment

       Just (ids, hval, fix_env) -> do

         updateFixityEnv fix_env

         let eval_opts = initEvalOpts idflags' (enableGhcStepMode execSingleStep)

                           (enableIsolateThreadBreaks execIsolateMode)

         let ic = hsc_IC hsc_env

             bindings = (ic_tythings ic, ic_gre_cache ic)

             size = ghciHistSize idflags'

 runDecls :: GhcMonad m => String -> m [TyThing]

 runDecls = runDeclsWithLocation "<interactive>" 1

       return (ExecComplete (Left (fromSerializableException e)) alloc)

     -- Nothing case: we stopped when an exception was raised, not at a breakpoint.

       let span = mkGeneralSrcSpan (fsLit "<unknown>")

       (hsc_env1, break_ids) <- liftIO $

         bindLocalsAtBreakpoint hsc_env apStack_fhv span Nothing

       let

         resume = Resume

           { resumeStmt = expr

           , resumeBindings = bindings

           , resumeFinalIds = final_ids

           , resumeApStack = apStack_fhv

     -- The interpreter yields on a breakpoint if:

     --  - the breakpoint was explicitly enabled (in @BreakArray@)

     --  - or one of the stepping options in @EvalOpts@ caused us to stop at one

       let ibi = evalBreakpointToId eval_break

       let hug = hsc_HUG hsc_env

       info_brks  <- liftIO $ readIModBreaks hug ibi

         breakArray <- getBreakArray interp ibi info_brks

         breakpointStatus interp breakArray (ibi_info_index ibi)

       -- This breakpoint is enabled or we mean to break here;

       -- we want to stop instead of just logging it.

         let

           resume = Resume

             { resumeStmt = expr

             , resumeBindings = bindings

             , resumeFinalIds = final_ids

             , resumeApStack = apStack_fhv

         return (ExecBreak break_ids (Just ibi) resume)

       else do

         -- resume with the same step type

         history <- if not tracing then pure history0 else do

           history1 <- liftIO $ mkHistory hug apStack_fhv ibi

           let !history' = history1 `consBL` history0

            -> ThreadBreaksIsolationMode

            -> Maybe Int

            -> Resume

 resumeExec step isolateMode mbCnt r = do

   hsc_env <- getSession

   let ic = hsc_IC hsc_env

   case r of

     Resume { resumeStmt = expr

            , resumeBindings = bindings

            , resumeFinalIds = final_ids

            , resumeApStack = apStack

           let eval_opts = initEvalOpts dflags (enableGhcStepMode step)

                             (enableIsolateThreadBreaks isolateMode)

 setupBreakpoint :: GhcMonad m => Interp -> InternalBreakpointId -> Int -> m ()   -- #19157

 setupBreakpoint interp ibi cnt = do

   updateFixityEnv fix_env

   let eval_opts = initEvalOpts dflags EvalStepNone True

   case status of

     EvalComplete _ (EvalSuccess [hval]) -> return hval

     EvalComplete _ (EvalException e) ->

   , evalStmt, EvalStatus_(..), EvalStatus, EvalResult(..), EvalExpr(..)

   , resumeStmt

   , abandonStmt

   , evalIO

   , evalString

   , evalStringToIOString

   :: Interp

   -> EvalOpts

   -> EvalExpr ForeignHValue

 evalStmt interp opts foreign_expr = do

     interpCmd interp (EvalStmt opts expr)

  where

   withExpr :: EvalExpr ForeignHValue -> (EvalExpr HValueRef -> IO a) -> IO a

   withExpr (EvalThis fhv) cont =

   :: Interp

   -> EvalOpts

   -> ForeignRef ThreadId

 resumeStmt interp opts resume_tid = do

     interpCmd interp (ResumeStmt opts rhv)

 abandonStmt :: Interp -> ForeignRef ThreadId -> IO ()

 abandonStmt interp resume_tid =

   withForeignRef resume_tid $ \rhv ->

     interpCmd interp (AbandonStmt rhv)

 handleEvalStatus

   :: Interp

   -> EvalStatus [HValueRef]

 seqHValue :: Interp -> UnitEnv -> Logger -> ForeignHValue -> IO (EvalResult ())

 seqHValue interp unit_env logger ref =

   withForeignRef ref $ \hval -> do

 evalBreakpointToId :: EvalBreakpoint -> InternalBreakpointId

 evalBreakpointToId eval_break =

             Just modbreaks -> put =<< getBreakLoc (readIModModBreaks hug) ibi modbreaks

       -- resume the seq (:force) processing in the iserv process

     (EvalComplete _ r) -> return r

                                           []

                                           (iservConfOpts    conf)

   interpPipe <- mkPipeFromHandles rh wh

   let process = InterpProcess

                   { interpHandle = ph

                   , interpPipe

                   }

   pending_frees <- newMVar []

 fromEvalResult :: EvalResult a -> IO a

 fromEvalResult (EvalException e) = throwIO (fromSerializableException e)

 fromEvalResult (EvalSuccess a) = return a

   std_in <- readIORef interp_in

   interpPipe <- mkPipeFromHandles rh wh

   let proc = InterpProcess

               { interpHandle = hdl

               , interpPipe

               }

   pure (std_in, proc)

   --   Haskell server.

   server_started <- jsServerStarted <$> readMVar (instJSState (instExtra inst))

   if server_started

     else jsLoadFile            inst all_js

   ----------------------------------------------------------------

   (

   -- * Message API

     Message(..)

   , sendMessage

   )

 where

 import Data.Binary

 import System.Exit

 import System.Process

 -- -----------------------------------------------------------------------------

 -- Top-level Message API

 sendMessage :: Binary a => ExtInterpInstance d -> Message a -> IO a

 -- | Send a 'Message' and receive the response from the interpreter process

 callInterpProcess :: Binary a => InterpProcess -> Message a -> IO a

   remoteCall (interpPipe i) msg

     `catchException` \(e :: SomeException) -> handleInterpProcessFailure i e

 handleInterpProcessFailure :: InterpProcess -> SomeException -> IO a

 handleInterpProcessFailure i e = do

   let hdl = interpHandle i

 data InterpProcess = InterpProcess

   { interpPipe   :: !Pipe           -- ^ Pipe to communicate with the server

   , interpHandle :: !ProcessHandle  -- ^ Process handle of the server

   }

 -- | Status of an external interpreter

   hSetBuffering rh NoBuffering

   interpPipe <- mkPipeFromHandles rh wh

   pending_frees <- newMVar []

   pure

     $ ExtInterpInstance

       { instProcess =

           InterpProcess

             { interpHandle = ph,

             },

         instPendingFrees = pending_frees,

         instExtra = ()

 module GHCi.Message

   ( Message(..), Msg(..)

   , ConInfoTable(..)

   , QResult(..)

   , EvalStatus_(..,EvalBreak), EvalStatus, EvalResult(..), EvalOpts(..), EvalExpr(..)

   , EvalBreak(..), EvalBreakpoint (..)

   , toSerializableException, fromSerializableException

   , THResult(..), THResultType(..)

   , QState(..)

   , Pipe, mkPipeFromHandles, mkPipeFromContinuations, remoteCall, remoteTHCall, readPipe, writePipe

   , BreakModule

   , BreakUnitId

 import Data.Typeable (TypeRep)

 import Data.IORef

 import Data.Map (Map)

 import Foreign

 import GHC.Generics

 import GHC.Stack.CCS

 import System.Exit

 import System.IO

 import System.IO.Error

 -- -----------------------------------------------------------------------------

 -- The RPC protocol between GHC and the interactive server

   EvalStmt

     :: EvalOpts

     -> EvalExpr HValueRef {- IO [a] -}

   -- | Resume evaluation of a statement after a breakpoint

   ResumeStmt

    :: EvalOpts

    -> RemoteRef ThreadId

   -- | Abandon evaluation of a statement after a breakpoint

   AbandonStmt

   -- | Evaluate something. This is used to support :force in GHCi.

   Seq

     :: HValueRef

   -- | Resume forcing a free variable in a breakpoint (#2950)

   ResumeSeq

     :: RemoteRef ThreadId

   -- | User-defined request encoded as a tag/payload pair.  This is left

   -- uninterpreted by GHC and is meant for GHC API applications to be able to supply

 deriving instance Show (THMessage a)

 putTHMessage :: THMessage a -> Put

 putTHMessage m = case m of

 -- -----------------------------------------------------------------------------

 -- Reading/writing messages

 -- | An opaque pipe for bidirectional binary data transmission.

 data Pipe = Pipe

   }

 -- | Make a 'Pipe' from a 'Handle' to read and a 'Handle' to write.

       putAll b = do

         B.hPutBuilder pipeWrite b

         hFlush pipeWrite

 -- | Make a 'Pipe' from a reader function and a writer function.

 mkPipeFromContinuations :: IO ByteString -> (B.Builder -> IO ()) -> IO Pipe

 mkPipeFromContinuations getSome putAll = do

 remoteCall pipe msg = do

 remoteTHCall :: Binary a => Pipe -> THMessage a -> IO a

 remoteTHCall pipe msg = do

   writePipe pipe (putTHMessage msg)

   readPipe pipe get

 readPipe :: Pipe -> Get a -> IO a

   leftovers <- readIORef pipeLeftovers

   m <- getBin getSome get leftovers

   case m of

         else go Nothing (fun (Just b))

    go _lft (Fail _rest _off str) =

      throwIO (ErrorCall ("getBin: " ++ str))

   Seq ref -> doSeq ref

   ResumeSeq ref -> resumeSeq ref

   Shutdown            -> unexpectedMessage m

   RunTH {}            -> unexpectedMessage m

   RunModFinalizers {} -> unexpectedMessage m

 --------------------------------------------------------------------------------

 evalStmt opts expr = do

   io <- mkIO expr

   sandboxIO opts $ do

 -- The UI process has more and therefore also can show more

 -- information about the breakpoint than the current iserv

 -- process.

     sandboxIO evalOptsSeq $ do

       _ <- (void $ evaluate =<< localRef ref)

       return []

 -- | Process a ResumeSeq message. Continue the :force processing     #2950

 -- after a breakpoint.