bugstalker 0.4.5

BugStalker is a modern and lightweight debugger for rust applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::debugger::BreakpointView;
use crate::debugger::Debugger;
use crate::debugger::Error;
use crate::debugger::address::Address;

#[derive(Debug, Clone, PartialEq)]
pub enum BreakpointIdentity {
    Address(usize),
    Line(String, u64),
    Function(String),
    Number(u32),
}

#[derive(Debug, Clone, PartialEq)]
pub enum Command {
    Add(BreakpointIdentity),
    Remove(BreakpointIdentity),
    Info,
    AddDeferred(BreakpointIdentity),
}

impl Command {
    /// Return underline breakpoint identity (if command not an `info`).
    pub fn identity(&self) -> Option<BreakpointIdentity> {
        match self {
            Command::Add(b) => Some(b.clone()),
            Command::Remove(b) => Some(b.clone()),
            Command::Info => None,
            Command::AddDeferred(b) => Some(b.clone()),
        }
    }
}

pub struct Handler<'a> {
    dbg: &'a mut Debugger,
}

pub enum ExecutionResult<'a> {
    New(Vec<BreakpointView<'a>>),
    Removed(Vec<BreakpointView<'a>>),
    Dump(Vec<BreakpointView<'a>>),
    AddDeferred,
}

impl<'a> Handler<'a> {
    pub fn new(debugger: &'a mut Debugger) -> Self {
        Self { dbg: debugger }
    }

    pub fn handle(&mut self, cmd: &Command) -> Result<ExecutionResult<'_>, Error> {
        let result = match cmd {
            Command::Add(brkpt) => {
                let res = match brkpt {
                    BreakpointIdentity::Address(addr) => {
                        vec![self.dbg.set_breakpoint_at_addr((*addr).into())?]
                    }
                    BreakpointIdentity::Line(file, line) => {
                        self.dbg.set_breakpoint_at_line(file, *line)?
                    }
                    BreakpointIdentity::Function(func_name) => {
                        self.dbg.set_breakpoint_at_fn(func_name)?
                    }
                    BreakpointIdentity::Number(_) => {
                        unreachable!()
                    }
                };
                ExecutionResult::New(res)
            }
            Command::Remove(brkpt) => {
                let res = match brkpt {
                    BreakpointIdentity::Address(addr) => self
                        .dbg
                        .remove_breakpoint(Address::Relocated((*addr).into()))?
                        .map(|brkpt| vec![brkpt])
                        .unwrap_or_default(),
                    BreakpointIdentity::Line(file, line) => {
                        self.dbg.remove_breakpoint_at_line(file, *line)?
                    }
                    BreakpointIdentity::Function(func_name) => {
                        self.dbg.remove_breakpoint_at_fn(func_name)?
                    }
                    BreakpointIdentity::Number(number) => self
                        .dbg
                        .remove_breakpoint_by_number(*number)?
                        .map(|brkpt| vec![brkpt])
                        .unwrap_or_default(),
                };
                ExecutionResult::Removed(res)
            }
            Command::Info => ExecutionResult::Dump(self.dbg.breakpoints_snapshot()),
            Command::AddDeferred(brkpt) => {
                match brkpt {
                    BreakpointIdentity::Address(addr) => {
                        self.dbg.add_deferred_at_addr((*addr).into())
                    }
                    BreakpointIdentity::Line(file, line) => {
                        self.dbg.add_deferred_at_line(file, *line)
                    }
                    BreakpointIdentity::Function(function) => {
                        self.dbg.add_deferred_at_function(function)
                    }
                    BreakpointIdentity::Number(_) => {
                        unreachable!()
                    }
                };
                ExecutionResult::AddDeferred
            }
        };
        Ok(result)
    }
}