Enum Command 

pub enum Command {
    Start {
        program: PathBuf,
        args: Vec<String>,
        adapter: Option<String>,
        stop_on_entry: bool,
        initial_breakpoints: Vec<String>,
    },
    Attach {
        pid: u32,
        adapter: Option<String>,
    },
    Detach,
    Stop,
    Restart,
    Status,
    BreakpointAdd {
        location: BreakpointLocation,
        condition: Option<String>,
        hit_count: Option<u32>,
    },
    BreakpointRemove {
        id: Option<u32>,
        all: bool,
    },
    BreakpointList,
    BreakpointEnable {
        id: u32,
    },
    BreakpointDisable {
        id: u32,
    },
    Continue,
    Next,
    StepIn,
    StepOut,
    Pause,
    StackTrace {
        thread_id: Option<i64>,
        limit: usize,
    },
    Locals {
        frame_id: Option<i64>,
    },
    Evaluate {
        expression: String,
        frame_id: Option<i64>,
        context: EvaluateContext,
    },
    Scopes {
        frame_id: i64,
    },
    Variables {
        reference: i64,
    },
    Threads,
    ThreadSelect {
        id: i64,
    },
    FrameSelect {
        number: usize,
    },
    FrameUp,
    FrameDown,
    Context {
        lines: usize,
    },
    Await {
        timeout_secs: u64,
    },
    GetOutput {
        tail: Option<usize>,
        clear: bool,
    },
    SubscribeOutput,
    Shutdown,
}

Commands that can be sent from CLI to daemon

Variants

Start

Start debugging a program

Fields

program: PathBuf

args: Vec<String>

adapter: Option<String>

stop_on_entry: bool

initial_breakpoints: Vec<String>

Initial breakpoints to set before program starts (file:line or function name)

Attach

Attach to a running process

Fields

pid: u32

adapter: Option<String>

Detach

Detach from process (keeps it running)

Stop

Stop debugging (terminates debuggee)

Restart

Restart program with same arguments

Status

Get session status

BreakpointAdd

Add a breakpoint

Fields

location: BreakpointLocation

condition: Option<String>

hit_count: Option<u32>

BreakpointRemove

Remove a breakpoint

Fields

id: Option<u32>

all: bool

BreakpointList

List all breakpoints

BreakpointEnable

Enable a breakpoint

Fields

id: u32

BreakpointDisable

Disable a breakpoint

Fields

id: u32

Continue

Continue execution

Next

Step over (next line, skip function calls)

StepIn

Step into (next line, enter function calls)

StepOut

Step out (run until function returns)

Pause

Pause execution

StackTrace

Get stack trace

Fields

thread_id: Option<i64>

limit: usize

Locals

Get local variables

Fields

frame_id: Option<i64>

Evaluate

Evaluate expression

Fields

expression: String

frame_id: Option<i64>

context: EvaluateContext

Scopes

Get scopes for a frame

Fields

frame_id: i64

Variables

Get variables in a scope

Fields

reference: i64

Threads

List all threads

ThreadSelect

Switch to thread

Fields

id: i64

FrameSelect

Select stack frame

Fields

number: usize

FrameUp

Move up the stack (to caller)

FrameDown

Move down the stack (toward current frame)

Context

Get current position with source context

Fields

lines: usize

Await

Wait for next stop event

Fields

timeout_secs: u64

GetOutput

Get buffered output

Fields

tail: Option<usize>

clear: bool

SubscribeOutput

Subscribe to output events (for –follow)

Shutdown

Shutdown the daemon

Trait Implementations

impl Debug for Command

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Command

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Command

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.