{-# LANGUAGE GADTs #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

module Haskell.Debug.Adapter.State.GHCiRun where

import Control.Monad.IO.Class
import qualified System.Log.Logger as L

import qualified Haskell.DAP as DAP
import Haskell.Debug.Adapter.Constant
import Haskell.Debug.Adapter.Type
import Haskell.Debug.Adapter.State.GHCiRun.ConfigurationDone()
import qualified Haskell.Debug.Adapter.State.Utility as SU
import qualified Haskell.Debug.Adapter.Utility as U

instance AppStateIF GHCiRunStateData where
  -- |
  --
  entryAction :: AppState GHCiRunStateData -> AppContext ()
entryAction AppState GHCiRunStateData
GHCiRunState = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP String
"GHCiRunState entryAction called."
    () -> AppContext ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

  -- |
  --
  exitAction :: AppState GHCiRunStateData -> AppContext ()
exitAction AppState GHCiRunStateData
GHCiRunState = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP String
"GHCiRunState exitAction called."
    () -> AppContext ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()


  -- |
  --
  doActivity :: AppState GHCiRunStateData
-> WrapRequest -> AppContext (Maybe StateTransit)
doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@InitializeRequest{})              = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@LaunchRequest{})                  = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@DisconnectRequest{})              = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@PauseRequest{})                   = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@TerminateRequest{})               = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@SetBreakpointsRequest{})          = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@SetFunctionBreakpointsRequest{})  = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@SetExceptionBreakpointsRequest{}) = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@ConfigurationDoneRequest{})       = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@ThreadsRequest{})                 = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@StackTraceRequest{})              = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@ScopesRequest{})                  = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@VariablesRequest{})               = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@ContinueRequest{})                = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@NextRequest{})                    = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@StepInRequest{})                  = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@EvaluateRequest{})                = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@CompletionsRequest{})             = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@InternalTransitRequest{})         = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@InternalTerminateRequest{})       = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r
  doActivity AppState GHCiRunStateData
s (WrapRequest r :: Request a
r@InternalLoadRequest{})            = AppState GHCiRunStateData
-> Request a -> AppContext (Maybe StateTransit)
forall s r.
StateActivityIF s r =>
AppState s -> Request r -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
s Request a
r

-- |
--   default nop.
--
instance StateActivityIF GHCiRunStateData DAP.InitializeRequest

-- |
--   default nop.
--
instance StateActivityIF GHCiRunStateData DAP.LaunchRequest

-- |
--   default nop.
--
instance StateActivityIF GHCiRunStateData DAP.DisconnectRequest

-- |
--   default nop.
--
instance StateActivityIF GHCiRunStateData DAP.PauseRequest

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.TerminateRequest where
  action :: AppState GHCiRunStateData
-> Request TerminateRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (TerminateRequest TerminateRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState TerminateRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ TerminateRequest -> String
forall a. Show a => a -> String
show TerminateRequest
req

    TerminateRequest -> AppContext ()
SU.terminateRequest TerminateRequest
req

    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
GHCiRun_Shutdown

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.SetBreakpointsRequest where
  action :: AppState GHCiRunStateData
-> Request SetBreakpointsRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (SetBreakpointsRequest SetBreakpointsRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState SetBreakpointsRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ SetBreakpointsRequest -> String
forall a. Show a => a -> String
show SetBreakpointsRequest
req
    SetBreakpointsRequest -> AppContext (Maybe StateTransit)
SU.setBreakpointsRequest SetBreakpointsRequest
req

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.SetExceptionBreakpointsRequest where
  action :: AppState GHCiRunStateData
-> Request SetExceptionBreakpointsRequest
-> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (SetExceptionBreakpointsRequest SetExceptionBreakpointsRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState SetExceptionBreakpointsRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ SetExceptionBreakpointsRequest -> String
forall a. Show a => a -> String
show SetExceptionBreakpointsRequest
req
    SetExceptionBreakpointsRequest -> AppContext (Maybe StateTransit)
SU.setExceptionBreakpointsRequest SetExceptionBreakpointsRequest
req

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.SetFunctionBreakpointsRequest where
  action :: AppState GHCiRunStateData
-> Request SetFunctionBreakpointsRequest
-> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (SetFunctionBreakpointsRequest SetFunctionBreakpointsRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState SetFunctionBreakpointsRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ SetFunctionBreakpointsRequest -> String
forall a. Show a => a -> String
show SetFunctionBreakpointsRequest
req
    SetFunctionBreakpointsRequest -> AppContext (Maybe StateTransit)
SU.setFunctionBreakpointsRequest SetFunctionBreakpointsRequest
req

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.ThreadsRequest where
  action :: AppState GHCiRunStateData
-> Request ThreadsRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (ThreadsRequest ThreadsRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState ThreadsRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ ThreadsRequest -> String
forall a. Show a => a -> String
show ThreadsRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: ThreadsResponse
res = ThreadsResponse
DAP.defaultThreadsResponse {
              seqThreadsResponse :: Int
DAP.seqThreadsResponse = Int
resSeq
            , request_seqThreadsResponse :: Int
DAP.request_seqThreadsResponse = ThreadsRequest -> Int
DAP.seqThreadsRequest ThreadsRequest
req
            , successThreadsResponse :: Bool
DAP.successThreadsResponse = Bool
False
            , messageThreadsResponse :: String
DAP.messageThreadsResponse = String
"GHCiRun State. debugging not started."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ThreadsResponse -> Response
ThreadsResponse ThreadsResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.StackTraceRequest where
  action :: AppState GHCiRunStateData
-> Request StackTraceRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (StackTraceRequest StackTraceRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState StackTraceRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ StackTraceRequest -> String
forall a. Show a => a -> String
show StackTraceRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: StackTraceResponse
res = StackTraceResponse
DAP.defaultStackTraceResponse {
              seqStackTraceResponse :: Int
DAP.seqStackTraceResponse = Int
resSeq
            , request_seqStackTraceResponse :: Int
DAP.request_seqStackTraceResponse = StackTraceRequest -> Int
DAP.seqStackTraceRequest StackTraceRequest
req
            , successStackTraceResponse :: Bool
DAP.successStackTraceResponse = Bool
False
            , messageStackTraceResponse :: String
DAP.messageStackTraceResponse = String
"GHCiRun State. debugging not started."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ StackTraceResponse -> Response
StackTraceResponse StackTraceResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.ScopesRequest where
  action :: AppState GHCiRunStateData
-> Request ScopesRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (ScopesRequest ScopesRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState ScopesRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ ScopesRequest -> String
forall a. Show a => a -> String
show ScopesRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: ScopesResponse
res = ScopesResponse
DAP.defaultScopesResponse {
              seqScopesResponse :: Int
DAP.seqScopesResponse = Int
resSeq
            , request_seqScopesResponse :: Int
DAP.request_seqScopesResponse = ScopesRequest -> Int
DAP.seqScopesRequest ScopesRequest
req
            , successScopesResponse :: Bool
DAP.successScopesResponse = Bool
False
            , messageScopesResponse :: String
DAP.messageScopesResponse = String
"GHCiRun State. debugging not started."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ScopesResponse -> Response
ScopesResponse ScopesResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.VariablesRequest where
  action :: AppState GHCiRunStateData
-> Request VariablesRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (VariablesRequest VariablesRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState VariablesRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ VariablesRequest -> String
forall a. Show a => a -> String
show VariablesRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: VariablesResponse
res = VariablesResponse
DAP.defaultVariablesResponse {
              seqVariablesResponse :: Int
DAP.seqVariablesResponse = Int
resSeq
            , request_seqVariablesResponse :: Int
DAP.request_seqVariablesResponse = VariablesRequest -> Int
DAP.seqVariablesRequest VariablesRequest
req
            , successVariablesResponse :: Bool
DAP.successVariablesResponse = Bool
False
            , messageVariablesResponse :: String
DAP.messageVariablesResponse = String
"GHCiRun State. debugging not started."
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ VariablesResponse -> Response
VariablesResponse VariablesResponse
res
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StateTransit
forall a. Maybe a
Nothing


-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.ContinueRequest where
  action :: AppState GHCiRunStateData
-> Request ContinueRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (ContinueRequest ContinueRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState ContinueRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ ContinueRequest -> String
forall a. Show a => a -> String
show ContinueRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: ContinueResponse
res = ContinueResponse
DAP.defaultContinueResponse {
              seqContinueResponse :: Int
DAP.seqContinueResponse = Int
resSeq
            , request_seqContinueResponse :: Int
DAP.request_seqContinueResponse = ContinueRequest -> Int
DAP.seqContinueRequest ContinueRequest
req
            , successContinueResponse :: Bool
DAP.successContinueResponse = Bool
True
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ ContinueResponse -> Response
ContinueResponse ContinueResponse
res

    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
GHCiRun_DebugRun


-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.NextRequest where
  action :: AppState GHCiRunStateData
-> Request NextRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (NextRequest NextRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState NextRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ NextRequest -> String
forall a. Show a => a -> String
show NextRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: NextResponse
res = NextResponse
DAP.defaultNextResponse {
              seqNextResponse :: Int
DAP.seqNextResponse = Int
resSeq
            , request_seqNextResponse :: Int
DAP.request_seqNextResponse = NextRequest -> Int
DAP.seqNextRequest NextRequest
req
            , successNextResponse :: Bool
DAP.successNextResponse = Bool
True
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ NextResponse -> Response
NextResponse NextResponse
res

    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
GHCiRun_DebugRun


-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.StepInRequest where
  action :: AppState GHCiRunStateData
-> Request StepInRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (StepInRequest StepInRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState StepInRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ StepInRequest -> String
forall a. Show a => a -> String
show StepInRequest
req
    Int
resSeq <- AppContext Int
U.getIncreasedResponseSequence
    let res :: StepInResponse
res = StepInResponse
DAP.defaultStepInResponse {
              seqStepInResponse :: Int
DAP.seqStepInResponse = Int
resSeq
            , request_seqStepInResponse :: Int
DAP.request_seqStepInResponse = StepInRequest -> Int
DAP.seqStepInRequest StepInRequest
req
            , successStepInResponse :: Bool
DAP.successStepInResponse = Bool
True
            }

    Response -> AppContext ()
U.addResponse (Response -> AppContext ()) -> Response -> AppContext ()
forall a b. (a -> b) -> a -> b
$ StepInResponse -> Response
StepInResponse StepInResponse
res

    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
GHCiRun_DebugRun


-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.EvaluateRequest where
  action :: AppState GHCiRunStateData
-> Request EvaluateRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (EvaluateRequest EvaluateRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState EvaluateRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ EvaluateRequest -> String
forall a. Show a => a -> String
show EvaluateRequest
req
    EvaluateRequest -> AppContext (Maybe StateTransit)
SU.evaluateRequest EvaluateRequest
req

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData DAP.CompletionsRequest where
  action :: AppState GHCiRunStateData
-> Request CompletionsRequest -> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (CompletionsRequest CompletionsRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState CompletionsRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompletionsRequest -> String
forall a. Show a => a -> String
show CompletionsRequest
req
    CompletionsRequest -> AppContext (Maybe StateTransit)
SU.completionsRequest CompletionsRequest
req

-- |
--   default nop.
--
instance StateActivityIF GHCiRunStateData HdaInternalTransitRequest

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData HdaInternalTerminateRequest where
  action :: AppState GHCiRunStateData
-> Request HdaInternalTerminateRequest
-> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (InternalTerminateRequest HdaInternalTerminateRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState InternalTerminateRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ HdaInternalTerminateRequest -> String
forall a. Show a => a -> String
show HdaInternalTerminateRequest
req
    AppContext ()
SU.internalTerminateRequest
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
GHCiRun_Shutdown

-- |
--  Any errors should be sent back as False result Response
--
instance StateActivityIF GHCiRunStateData HdaInternalLoadRequest where
  action :: AppState GHCiRunStateData
-> Request HdaInternalLoadRequest
-> AppContext (Maybe StateTransit)
action AppState GHCiRunStateData
_ (InternalLoadRequest HdaInternalLoadRequest
req) = do
    IO () -> AppContext ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> AppContext ()) -> IO () -> AppContext ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
L.debugM String
_LOG_APP (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"GHCiRunState InternalTerminateRequest called. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ HdaInternalLoadRequest -> String
forall a. Show a => a -> String
show HdaInternalLoadRequest
req
    AppContext ()
SU.internalTerminateRequest
    Maybe StateTransit -> AppContext (Maybe StateTransit)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StateTransit -> AppContext (Maybe StateTransit))
-> Maybe StateTransit -> AppContext (Maybe StateTransit)
forall a b. (a -> b) -> a -> b
$ StateTransit -> Maybe StateTransit
forall a. a -> Maybe a
Just StateTransit
GHCiRun_Shutdown