import Control.Concurrent

 import Control.Monad

 import Control.Monad.IO.Class

 import Data.Binary

 import Data.ByteString (ByteString)

 import qualified Data.ByteString.Short as SBS

 #if defined(HAVE_INTERNAL_INTERPRETER)

   InternalInterp     -> run msg -- Just run it directly

 #endif

     sendMessage inst msg

   ExtJS    i -> withJSInterp i action

   ExtWasm  i -> withWasmInterp i action

   ExtIServ i -> withIServ    i action

 withExtInterpStatus :: ExtInterp -> (forall d. ExtInterpStatusVar d -> m a) -> m a

 withExtInterpStatus ext action = case ext of

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> do

           sendMessage inst (LookupSymbol (fastStringToShortByteString (interpSymbolToCLabel str)))

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

       ExtWasm i -> withWasmInterp i $ \inst -> do

           sendMessage inst (LookupSymbol (fastStringToShortByteString (interpSymbolToCLabel str)))

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

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> do

           sendMessage inst (LookupSymbolInDLL dll (fastStringToShortByteString (interpSymbolToCLabel str)))

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

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

                else sendMessage i Shutdown

             -- We asked the server to shutdown, so we will also shutdown any communication.

             closePipe (interpPipe (instProcess i))

             pure InterpPending

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

 import GHC.Runtime.Interpreter.Types

 import GHCi.Message

 import GHC.Utils.Panic

 import GHC.Utils.Exception as Ex

 import Data.Binary

 import Control.Concurrent

 import Data.IORef

 import Control.Concurrent.STM

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

 sendMessage i msg =

   remoteCall (interpPipe proc) msg

   where

     proc = instProcess i

                       else loop

        in loop

 data CancelTHHandler = CancelTHHandler deriving Show

 instance Exception CancelTHHandler where

   fromException = asyncExceptionFromException

       runQinTcM $ sequence_ qs

 #endif

       tcg <- getGblEnv

       th_state <- readTcRef (tcg_th_remote_state tcg)

       case th_state of

       return r

 #endif

       -- Run it on the server.  For an overview of how TH works with

       -- Remote GHCi, see Note [Remote Template Haskell] in

       -- libraries/ghci/GHCi/TH.hs.

   , Pipe(..), mkPipeFromHandles, mkPipeFromContinuations, closePipe

   , remoteCall, remoteTHCall

   , handleRemoteCall, handleRemoteTHCall, writeReply

   , InboxId(..)

   , newMailbox

 import qualified GHC.Boot.TH.Syntax        as TH

 import qualified GHC.Boot.TH.Monad         as TH

 import GHCi.Message.Async

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

 -- The RPC protocol between GHC and the interactive server

   (

     -- * Pipes

     Pipe(..), mkPipeFromHandles, mkPipeFromContinuations

     -- * Interface for async bidirectional RPC

   , remoteAsyncReq, handleAsyncReq

       unless writeAlreadyClosed

         (throwTo (asyncFillTid pipeAsyncMngr) PipeWriteClosedException)

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

 -- ** Pipe thread-safe read/write

 {-

 Note [Exceptions during serialization]

 For efficiency reasons, any `IddMsg` to be sent is forced only when already

 writing onto the Pipe, so we cannot discern whether any raised exception

 import System.IO

 import Control.Concurrent

 import GHCi.Message.Async (runWriteReply, (%>>=))

 import GHCi.Server.Threads