delve: github.com/go-delve/delve/service/rpc2 Index | Files

package rpc2

import "github.com/go-delve/delve/service/rpc2"

Index

Package Files

client.go server.go

type AmendBreakpointIn Uses

type AmendBreakpointIn struct {
    Breakpoint api.Breakpoint
}

type AmendBreakpointOut Uses

type AmendBreakpointOut struct {
}

type AncestorsIn Uses

type AncestorsIn struct {
    GoroutineID  int
    NumAncestors int
    Depth        int
}

type AncestorsOut Uses

type AncestorsOut struct {
    Ancestors []api.Ancestor
}

type AttachedToExistingProcessIn Uses

type AttachedToExistingProcessIn struct {
}

type AttachedToExistingProcessOut Uses

type AttachedToExistingProcessOut struct {
    Answer bool
}

type CancelNextIn Uses

type CancelNextIn struct {
}

type CancelNextOut Uses

type CancelNextOut struct {
}

type CheckpointIn Uses

type CheckpointIn struct {
    Where string
}

type CheckpointOut Uses

type CheckpointOut struct {
    ID int
}

type ClearBreakpointIn Uses

type ClearBreakpointIn struct {
    Id   int
    Name string
}

type ClearBreakpointOut Uses

type ClearBreakpointOut struct {
    Breakpoint *api.Breakpoint
}

type ClearCheckpointIn Uses

type ClearCheckpointIn struct {
    ID int
}

type ClearCheckpointOut Uses

type ClearCheckpointOut struct {
}

type CommandOut Uses

type CommandOut struct {
    State api.DebuggerState
}

type CreateBreakpointIn Uses

type CreateBreakpointIn struct {
    Breakpoint api.Breakpoint
}

type CreateBreakpointOut Uses

type CreateBreakpointOut struct {
    Breakpoint api.Breakpoint
}

type DetachIn Uses

type DetachIn struct {
    Kill bool
}

type DetachOut Uses

type DetachOut struct {
}

type DisassembleIn Uses

type DisassembleIn struct {
    Scope          api.EvalScope
    StartPC, EndPC uint64
    Flavour        api.AssemblyFlavour
}

type DisassembleOut Uses

type DisassembleOut struct {
    Disassemble api.AsmInstructions
}

type EvalIn Uses

type EvalIn struct {
    Scope api.EvalScope
    Expr  string
    Cfg   *api.LoadConfig
}

type EvalOut Uses

type EvalOut struct {
    Variable *api.Variable
}

type FindLocationIn Uses

type FindLocationIn struct {
    Scope                     api.EvalScope
    Loc                       string
    IncludeNonExecutableLines bool
}

type FindLocationOut Uses

type FindLocationOut struct {
    Locations []api.Location
}

type FunctionReturnLocationsIn Uses

type FunctionReturnLocationsIn struct {
    // FnName is the name of the function for which all
    // return locations should be given.
    FnName string
}

FunctionReturnLocationsIn holds arguments for the FunctionReturnLocationsRPC call. It holds the name of the function for which all return locations should be given.

type FunctionReturnLocationsOut Uses

type FunctionReturnLocationsOut struct {
    // Addrs is the list of all locations where the given function returns.
    Addrs []uint64
}

FunctionReturnLocationsOut holds the result of the FunctionReturnLocations RPC call. It provides the list of addresses that the given function returns, for example with a `RET` instruction or `CALL runtime.deferreturn`.

type GetBreakpointIn Uses

type GetBreakpointIn struct {
    Id   int
    Name string
}

type GetBreakpointOut Uses

type GetBreakpointOut struct {
    Breakpoint api.Breakpoint
}

type GetThreadIn Uses

type GetThreadIn struct {
    Id int
}

type GetThreadOut Uses

type GetThreadOut struct {
    Thread *api.Thread
}

type IsMulticlientIn Uses

type IsMulticlientIn struct {
}

type IsMulticlientOut Uses

type IsMulticlientOut struct {
    // IsMulticlient returns true if the headless instance was started with --accept-multiclient
    IsMulticlient bool
}

type LastModifiedIn Uses

type LastModifiedIn struct {
}

type LastModifiedOut Uses

type LastModifiedOut struct {
    Time time.Time
}

type ListBreakpointsIn Uses

type ListBreakpointsIn struct {
}

type ListBreakpointsOut Uses

type ListBreakpointsOut struct {
    Breakpoints []*api.Breakpoint
}

type ListCheckpointsIn Uses

type ListCheckpointsIn struct {
}

type ListCheckpointsOut Uses

type ListCheckpointsOut struct {
    Checkpoints []api.Checkpoint
}

type ListDynamicLibrariesIn Uses

type ListDynamicLibrariesIn struct {
}

ListDynamicLibrariesIn holds the arguments of ListDynamicLibraries

type ListDynamicLibrariesOut Uses

type ListDynamicLibrariesOut struct {
    List []api.Image
}

ListDynamicLibrariesOut holds the return values of ListDynamicLibraries

type ListFunctionArgsIn Uses

type ListFunctionArgsIn struct {
    Scope api.EvalScope
    Cfg   api.LoadConfig
}

type ListFunctionArgsOut Uses

type ListFunctionArgsOut struct {
    Args []api.Variable
}

type ListFunctionsIn Uses

type ListFunctionsIn struct {
    Filter string
}

type ListFunctionsOut Uses

type ListFunctionsOut struct {
    Funcs []string
}

type ListGoroutinesIn Uses

type ListGoroutinesIn struct {
    Start int
    Count int
}

type ListGoroutinesOut Uses

type ListGoroutinesOut struct {
    Goroutines []*api.Goroutine
    Nextg      int
}

type ListLocalVarsIn Uses

type ListLocalVarsIn struct {
    Scope api.EvalScope
    Cfg   api.LoadConfig
}

type ListLocalVarsOut Uses

type ListLocalVarsOut struct {
    Variables []api.Variable
}

type ListPackageVarsIn Uses

type ListPackageVarsIn struct {
    Filter string
    Cfg    api.LoadConfig
}

type ListPackageVarsOut Uses

type ListPackageVarsOut struct {
    Variables []api.Variable
}

type ListRegistersIn Uses

type ListRegistersIn struct {
    ThreadID  int
    IncludeFp bool
}

type ListRegistersOut Uses

type ListRegistersOut struct {
    Registers string
    Regs      api.Registers
}

type ListSourcesIn Uses

type ListSourcesIn struct {
    Filter string
}

type ListSourcesOut Uses

type ListSourcesOut struct {
    Sources []string
}

type ListThreadsIn Uses

type ListThreadsIn struct {
}

type ListThreadsOut Uses

type ListThreadsOut struct {
    Threads []*api.Thread
}

type ListTypesIn Uses

type ListTypesIn struct {
    Filter string
}

type ListTypesOut Uses

type ListTypesOut struct {
    Types []string
}

type ProcessPidIn Uses

type ProcessPidIn struct {
}

type ProcessPidOut Uses

type ProcessPidOut struct {
    Pid int
}

type RPCClient Uses

type RPCClient struct {
    // contains filtered or unexported fields
}

Client is a RPC service.Client.

func NewClient Uses

func NewClient(addr string) *RPCClient

NewClient creates a new RPCClient.

func NewClientFromConn Uses

func NewClientFromConn(conn net.Conn) *RPCClient

NewClientFromConn creates a new RPCClient from the given connection.

func (*RPCClient) AmendBreakpoint Uses

func (c *RPCClient) AmendBreakpoint(bp *api.Breakpoint) error

func (*RPCClient) Ancestors Uses

func (c *RPCClient) Ancestors(goroutineID int, numAncestors int, depth int) ([]api.Ancestor, error)

func (*RPCClient) AttachedToExistingProcess Uses

func (c *RPCClient) AttachedToExistingProcess() bool

func (*RPCClient) Call Uses

func (c *RPCClient) Call(goroutineID int, expr string, unsafe bool) (*api.DebuggerState, error)

func (*RPCClient) CallAPI Uses

func (c *RPCClient) CallAPI(method string, args, reply interface{}) error

func (*RPCClient) CancelNext Uses

func (c *RPCClient) CancelNext() error

func (*RPCClient) Checkpoint Uses

func (c *RPCClient) Checkpoint(where string) (checkpointID int, err error)

Checkpoint sets a checkpoint at the current position.

func (*RPCClient) ClearBreakpoint Uses

func (c *RPCClient) ClearBreakpoint(id int) (*api.Breakpoint, error)

func (*RPCClient) ClearBreakpointByName Uses

func (c *RPCClient) ClearBreakpointByName(name string) (*api.Breakpoint, error)

func (*RPCClient) ClearCheckpoint Uses

func (c *RPCClient) ClearCheckpoint(id int) error

ClearCheckpoint removes a checkpoint

func (*RPCClient) Continue Uses

func (c *RPCClient) Continue() <-chan *api.DebuggerState

func (*RPCClient) CreateBreakpoint Uses

func (c *RPCClient) CreateBreakpoint(breakPoint *api.Breakpoint) (*api.Breakpoint, error)

func (*RPCClient) Detach Uses

func (c *RPCClient) Detach(kill bool) error

func (*RPCClient) DisassemblePC Uses

func (c *RPCClient) DisassemblePC(scope api.EvalScope, pc uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error)

Disassemble function containing pc

func (*RPCClient) DisassembleRange Uses

func (c *RPCClient) DisassembleRange(scope api.EvalScope, startPC, endPC uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error)

Disassemble code between startPC and endPC

func (*RPCClient) Disconnect Uses

func (c *RPCClient) Disconnect(cont bool) error

func (*RPCClient) EvalVariable Uses

func (c *RPCClient) EvalVariable(scope api.EvalScope, expr string, cfg api.LoadConfig) (*api.Variable, error)

func (*RPCClient) FindLocation Uses

func (c *RPCClient) FindLocation(scope api.EvalScope, loc string, findInstructions bool) ([]api.Location, error)

func (*RPCClient) FunctionReturnLocations Uses

func (c *RPCClient) FunctionReturnLocations(fnName string) ([]uint64, error)

func (*RPCClient) GetBreakpoint Uses

func (c *RPCClient) GetBreakpoint(id int) (*api.Breakpoint, error)

func (*RPCClient) GetBreakpointByName Uses

func (c *RPCClient) GetBreakpointByName(name string) (*api.Breakpoint, error)

func (*RPCClient) GetState Uses

func (c *RPCClient) GetState() (*api.DebuggerState, error)

func (*RPCClient) GetStateNonBlocking Uses

func (c *RPCClient) GetStateNonBlocking() (*api.DebuggerState, error)

func (*RPCClient) GetThread Uses

func (c *RPCClient) GetThread(id int) (*api.Thread, error)

func (*RPCClient) Halt Uses

func (c *RPCClient) Halt() (*api.DebuggerState, error)

func (*RPCClient) IsMulticlient Uses

func (c *RPCClient) IsMulticlient() bool

func (*RPCClient) LastModified Uses

func (c *RPCClient) LastModified() time.Time

func (*RPCClient) ListBreakpoints Uses

func (c *RPCClient) ListBreakpoints() ([]*api.Breakpoint, error)

func (*RPCClient) ListCheckpoints Uses

func (c *RPCClient) ListCheckpoints() ([]api.Checkpoint, error)

ListCheckpoints gets all checkpoints.

func (*RPCClient) ListDynamicLibraries Uses

func (c *RPCClient) ListDynamicLibraries() ([]api.Image, error)

func (*RPCClient) ListFunctionArgs Uses

func (c *RPCClient) ListFunctionArgs(scope api.EvalScope, cfg api.LoadConfig) ([]api.Variable, error)

func (*RPCClient) ListFunctions Uses

func (c *RPCClient) ListFunctions(filter string) ([]string, error)

func (*RPCClient) ListGoroutines Uses

func (c *RPCClient) ListGoroutines(start, count int) ([]*api.Goroutine, int, error)

func (*RPCClient) ListLocalVariables Uses

func (c *RPCClient) ListLocalVariables(scope api.EvalScope, cfg api.LoadConfig) ([]api.Variable, error)

func (*RPCClient) ListPackageVariables Uses

func (c *RPCClient) ListPackageVariables(filter string, cfg api.LoadConfig) ([]api.Variable, error)

func (*RPCClient) ListRegisters Uses

func (c *RPCClient) ListRegisters(threadID int, includeFp bool) (api.Registers, error)

func (*RPCClient) ListSources Uses

func (c *RPCClient) ListSources(filter string) ([]string, error)

func (*RPCClient) ListThreads Uses

func (c *RPCClient) ListThreads() ([]*api.Thread, error)

func (*RPCClient) ListTypes Uses

func (c *RPCClient) ListTypes(filter string) ([]string, error)

func (*RPCClient) Next Uses

func (c *RPCClient) Next() (*api.DebuggerState, error)

func (*RPCClient) ProcessPid Uses

func (c *RPCClient) ProcessPid() int

func (*RPCClient) Recorded Uses

func (c *RPCClient) Recorded() bool

Recorded returns true if the debugger target is a recording.

func (*RPCClient) Restart Uses

func (c *RPCClient) Restart() ([]api.DiscardedBreakpoint, error)

func (*RPCClient) RestartFrom Uses

func (c *RPCClient) RestartFrom(rerecord bool, pos string, resetArgs bool, newArgs []string) ([]api.DiscardedBreakpoint, error)

func (*RPCClient) ReverseStepInstruction Uses

func (c *RPCClient) ReverseStepInstruction() (*api.DebuggerState, error)

func (*RPCClient) Rewind Uses

func (c *RPCClient) Rewind() <-chan *api.DebuggerState

func (*RPCClient) SetReturnValuesLoadConfig Uses

func (c *RPCClient) SetReturnValuesLoadConfig(cfg *api.LoadConfig)

func (*RPCClient) SetVariable Uses

func (c *RPCClient) SetVariable(scope api.EvalScope, symbol, value string) error

func (*RPCClient) Stacktrace Uses

func (c *RPCClient) Stacktrace(goroutineId, depth int, opts api.StacktraceOptions, cfg *api.LoadConfig) ([]api.Stackframe, error)

func (*RPCClient) Step Uses

func (c *RPCClient) Step() (*api.DebuggerState, error)

func (*RPCClient) StepInstruction Uses

func (c *RPCClient) StepInstruction() (*api.DebuggerState, error)

func (*RPCClient) StepOut Uses

func (c *RPCClient) StepOut() (*api.DebuggerState, error)

func (*RPCClient) SwitchGoroutine Uses

func (c *RPCClient) SwitchGoroutine(goroutineID int) (*api.DebuggerState, error)

func (*RPCClient) SwitchThread Uses

func (c *RPCClient) SwitchThread(threadID int) (*api.DebuggerState, error)

func (*RPCClient) TraceDirectory Uses

func (c *RPCClient) TraceDirectory() (string, error)

TraceDirectory returns the path to the trace directory for a recording.

type RPCServer Uses

type RPCServer struct {
    // contains filtered or unexported fields
}

func NewServer Uses

func NewServer(config *service.Config, debugger *debugger.Debugger) *RPCServer

func (*RPCServer) AmendBreakpoint Uses

func (s *RPCServer) AmendBreakpoint(arg AmendBreakpointIn, out *AmendBreakpointOut) error

AmendBreakpoint allows user to update an existing breakpoint for example to change the information retrieved when the breakpoint is hit or to change, add or remove the break condition.

arg.Breakpoint.ID must be a valid breakpoint ID

func (*RPCServer) Ancestors Uses

func (s *RPCServer) Ancestors(arg AncestorsIn, out *AncestorsOut) error

Ancestors returns the stacktraces for the ancestors of a goroutine.

func (*RPCServer) AttachedToExistingProcess Uses

func (c *RPCServer) AttachedToExistingProcess(arg AttachedToExistingProcessIn, out *AttachedToExistingProcessOut) error

AttachedToExistingProcess returns whether we attached to a running process or not

func (*RPCServer) CancelNext Uses

func (s *RPCServer) CancelNext(arg CancelNextIn, out *CancelNextOut) error

func (*RPCServer) Checkpoint Uses

func (s *RPCServer) Checkpoint(arg CheckpointIn, out *CheckpointOut) error

func (*RPCServer) ClearBreakpoint Uses

func (s *RPCServer) ClearBreakpoint(arg ClearBreakpointIn, out *ClearBreakpointOut) error

ClearBreakpoint deletes a breakpoint by Name (if Name is not an empty string) or by ID.

func (*RPCServer) ClearCheckpoint Uses

func (s *RPCServer) ClearCheckpoint(arg ClearCheckpointIn, out *ClearCheckpointOut) error

func (*RPCServer) Command Uses

func (s *RPCServer) Command(command api.DebuggerCommand, cb service.RPCCallback)

Command interrupts, continues and steps through the program.

func (*RPCServer) CreateBreakpoint Uses

func (s *RPCServer) CreateBreakpoint(arg CreateBreakpointIn, out *CreateBreakpointOut) error

CreateBreakpoint creates a new breakpoint.

- If arg.Breakpoint.File is not an empty string the breakpoint will be created on the specified file:line location

- If arg.Breakpoint.FunctionName is not an empty string the breakpoint will be created on the specified function:line location.

- If arg.Breakpoint.Addrs is filled it will create a logical breakpoint corresponding to all specified addresses.

- Otherwise the value specified by arg.Breakpoint.Addr will be used.

func (*RPCServer) Detach Uses

func (s *RPCServer) Detach(arg DetachIn, out *DetachOut) error

Detach detaches the debugger, optionally killing the process.

func (*RPCServer) Disassemble Uses

func (c *RPCServer) Disassemble(arg DisassembleIn, out *DisassembleOut) error

Disassemble code.

If both StartPC and EndPC are non-zero the specified range will be disassembled, otherwise the function containing StartPC will be disassembled.

Scope is used to mark the instruction the specified goroutine is stopped at.

Disassemble will also try to calculate the destination address of an absolute indirect CALL if it happens to be the instruction the selected goroutine is stopped at.

func (*RPCServer) Eval Uses

func (s *RPCServer) Eval(arg EvalIn, out *EvalOut) error

EvalVariable returns a variable in the specified context.

See https://github.com/go-delve/delve/wiki/Expressions for a description of acceptable values of arg.Expr.

func (*RPCServer) FindLocation Uses

func (c *RPCServer) FindLocation(arg FindLocationIn, out *FindLocationOut) error

FindLocation returns concrete location information described by a location expression.

loc ::= <filename>:<line> | <function>[:<line>] | /<regex>/ | (+|-)<offset> | <line> | *<address>
* <filename> can be the full path of a file or just a suffix
* <function> ::= <package>.<receiver type>.<name> | <package>.(*<receiver type>).<name> | <receiver type>.<name> | <package>.<name> | (*<receiver type>).<name> | <name>
* <function> must be unambiguous
* /<regex>/ will return a location for each function matched by regex
* +<offset> returns a location for the line that is <offset> lines after the current line
* -<offset> returns a location for the line that is <offset> lines before the current line
* <line> returns a location for a line in the current file
* *<address> returns the location corresponding to the specified address

NOTE: this function does not actually set breakpoints.

func (*RPCServer) FunctionReturnLocations Uses

func (s *RPCServer) FunctionReturnLocations(in FunctionReturnLocationsIn, out *FunctionReturnLocationsOut) error

FunctionReturnLocations is the implements the client call of the same name. Look at client documentation for more information.

func (*RPCServer) GetBreakpoint Uses

func (s *RPCServer) GetBreakpoint(arg GetBreakpointIn, out *GetBreakpointOut) error

GetBreakpoint gets a breakpoint by Name (if Name is not an empty string) or by ID.

func (*RPCServer) GetThread Uses

func (s *RPCServer) GetThread(arg GetThreadIn, out *GetThreadOut) error

GetThread gets a thread by its ID.

func (*RPCServer) IsMulticlient Uses

func (s *RPCServer) IsMulticlient(arg IsMulticlientIn, out *IsMulticlientOut) error

func (*RPCServer) LastModified Uses

func (s *RPCServer) LastModified(arg LastModifiedIn, out *LastModifiedOut) error

func (*RPCServer) ListBreakpoints Uses

func (s *RPCServer) ListBreakpoints(arg ListBreakpointsIn, out *ListBreakpointsOut) error

ListBreakpoints gets all breakpoints.

func (*RPCServer) ListCheckpoints Uses

func (s *RPCServer) ListCheckpoints(arg ListCheckpointsIn, out *ListCheckpointsOut) error

func (*RPCServer) ListDynamicLibraries Uses

func (s *RPCServer) ListDynamicLibraries(in ListDynamicLibrariesIn, out *ListDynamicLibrariesOut) error

func (*RPCServer) ListFunctionArgs Uses

func (s *RPCServer) ListFunctionArgs(arg ListFunctionArgsIn, out *ListFunctionArgsOut) error

ListFunctionArgs lists all arguments to the current function

func (*RPCServer) ListFunctions Uses

func (s *RPCServer) ListFunctions(arg ListFunctionsIn, out *ListFunctionsOut) error

ListFunctions lists all functions in the process matching filter.

func (*RPCServer) ListGoroutines Uses

func (s *RPCServer) ListGoroutines(arg ListGoroutinesIn, out *ListGoroutinesOut) error

ListGoroutines lists all goroutines. If Count is specified ListGoroutines will return at the first Count goroutines and an index in Nextg, that can be passed as the Start parameter, to get more goroutines from ListGoroutines. Passing a value of Start that wasn't returned by ListGoroutines will skip an undefined number of goroutines.

func (*RPCServer) ListLocalVars Uses

func (s *RPCServer) ListLocalVars(arg ListLocalVarsIn, out *ListLocalVarsOut) error

ListLocalVars lists all local variables in scope.

func (*RPCServer) ListPackageVars Uses

func (s *RPCServer) ListPackageVars(arg ListPackageVarsIn, out *ListPackageVarsOut) error

ListPackageVars lists all package variables in the context of the current thread.

func (*RPCServer) ListRegisters Uses

func (s *RPCServer) ListRegisters(arg ListRegistersIn, out *ListRegistersOut) error

ListRegisters lists registers and their values.

func (*RPCServer) ListSources Uses

func (s *RPCServer) ListSources(arg ListSourcesIn, out *ListSourcesOut) error

ListSources lists all source files in the process matching filter.

func (*RPCServer) ListThreads Uses

func (s *RPCServer) ListThreads(arg ListThreadsIn, out *ListThreadsOut) (err error)

ListThreads lists all threads.

func (*RPCServer) ListTypes Uses

func (s *RPCServer) ListTypes(arg ListTypesIn, out *ListTypesOut) error

ListTypes lists all types in the process matching filter.

func (*RPCServer) ProcessPid Uses

func (s *RPCServer) ProcessPid(arg ProcessPidIn, out *ProcessPidOut) error

ProcessPid returns the pid of the process we are debugging.

func (*RPCServer) Recorded Uses

func (s *RPCServer) Recorded(arg RecordedIn, out *RecordedOut) error

func (*RPCServer) Restart Uses

func (s *RPCServer) Restart(arg RestartIn, out *RestartOut) error

Restart restarts program.

func (*RPCServer) Set Uses

func (s *RPCServer) Set(arg SetIn, out *SetOut) error

Set sets the value of a variable. Only numerical types and pointers are currently supported.

func (*RPCServer) Stacktrace Uses

func (s *RPCServer) Stacktrace(arg StacktraceIn, out *StacktraceOut) error

Stacktrace returns stacktrace of goroutine Id up to the specified Depth.

If Full is set it will also the variable of all local variables and function arguments of all stack frames.

func (*RPCServer) State Uses

func (s *RPCServer) State(arg StateIn, out *StateOut) error

State returns the current debugger state.

type RecordedIn Uses

type RecordedIn struct {
}

type RecordedOut Uses

type RecordedOut struct {
    Recorded       bool
    TraceDirectory string
}

type RestartIn Uses

type RestartIn struct {
    // Position to restart from, if it starts with 'c' it's a checkpoint ID,
    // otherwise it's an event number. Only valid for recorded targets.
    Position string

    // ResetArgs tell whether NewArgs should take effect.
    ResetArgs bool
    // NewArgs are arguments to launch a new process.  They replace only the
    // argv[1] and later. Argv[0] cannot be changed.
    NewArgs []string

    // When Rerecord is set the target will be rerecorded
    Rerecord bool
}

type RestartOut Uses

type RestartOut struct {
    DiscardedBreakpoints []api.DiscardedBreakpoint
}

type SetIn Uses

type SetIn struct {
    Scope  api.EvalScope
    Symbol string
    Value  string
}

type SetOut Uses

type SetOut struct {
}

type StacktraceIn Uses

type StacktraceIn struct {
    Id     int
    Depth  int
    Full   bool
    Defers bool // read deferred functions (equivalent to passing StacktraceReadDefers in Opts)
    Opts   api.StacktraceOptions
    Cfg    *api.LoadConfig
}

type StacktraceOut Uses

type StacktraceOut struct {
    Locations []api.Stackframe
}

type StateIn Uses

type StateIn struct {
    // If NonBlocking is true State will return immediately even if the target process is running.
    NonBlocking bool
}

type StateOut Uses

type StateOut struct {
    State *api.DebuggerState
}

Package rpc2 imports 10 packages (graph) and is imported by 9 packages. Updated 2019-11-04. Refresh now. Tools for package owners.