Add Gdb::{break_insert,break_disable,break_delete}

Author: dzfranklin

src/breakpoint.rs

@@ -0,0 +1,77 @@
+use camino::Utf8PathBuf;
+
+use crate::{raw, Error};
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum LineSpec {
+    Line { file: Utf8PathBuf, num: u32 },
+    Function(String),
+    FunctionExplicitFile { file: Utf8PathBuf, name: String },
+}
+
+impl LineSpec {
+    pub fn line(file: impl Into<Utf8PathBuf>, num: u32) -> Self {
+        Self::Line {
+            file: file.into(),
+            num,
+        }
+    }
+
+    pub fn function(name: impl Into<String>) -> Self {
+        Self::Function(name.into())
+    }
+
+    pub fn function_with_explicit_file(
+        file: impl Into<Utf8PathBuf>,
+        name: impl Into<String>,
+    ) -> Self {
+        Self::FunctionExplicitFile {
+            file: file.into(),
+            name: name.into(),
+        }
+    }
+
+    pub fn serialize(self) -> String {
+        match self {
+            Self::Line { file, num } => format!("{}:{}", file, num),
+            Self::Function(name) => name,
+            Self::FunctionExplicitFile { file, name } => format!("{}:{}", file, name),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Breakpoint {
+    pub number: u32,
+    pub addr: u64,
+    pub file: Utf8PathBuf,
+    pub line: u32,
+    pub thread_groups: Vec<String>,
+    pub times: u32,
+}
+
+impl Breakpoint {
+    pub fn from_raw(mut raw: raw::Dict) -> Result<Self, Error> {
+        let number = raw.remove_expect("number")?.expect_number()?;
+        let addr = raw.remove_expect("addr")?.expect_hex()?;
+        let file = raw.remove_expect("fullname")?.expect_path()?;
+        let line = raw.remove_expect("line")?.expect_number()?;
+        let times = raw.remove_expect("times")?.expect_number()?;
+
+        let thread_groups = raw
+            .remove_expect("thread-groups")?
+            .expect_list()?
+            .into_iter()
+            .map(raw::Value::expect_string)
+            .collect::<Result<_, _>>()?;
+
+        Ok(Self {
+            number,
+            addr,
+            file,
+            line,
+            thread_groups,
+            times,
+        })
+    }
+}

src/inner.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, time::Duration};
 use crate::{
     parser::{self, parse_message},
     raw::{GeneralMessage, Response},
-    ResponseError, Token,
+    Error, Token,
 };
 
 use tokio::{
@@ -34,11 +34,7 @@ impl Inner {
         }
     }
 
-    pub(super) async fn execute(
-        &self,
-        msg: String,
-        timeout: Duration,
-    ) -> Result<Response, ResponseError> {
+    pub(super) async fn execute(&self, msg: String, timeout: Duration) -> Result<Response, Error> {
         let token = Token::generate();
         let (out_tx, mut out_rx) = mpsc::channel(1);
 
@@ -48,7 +44,7 @@ impl Inner {
 
         time::timeout(timeout, out_rx.recv())
             .await
-            .map_err(|_| ResponseError::Timeout)?
+            .map_err(|_| Error::Timeout)?
             .expect("out chan not closed")
     }
 
@@ -59,7 +55,7 @@ impl Inner {
     }
 }
 
-type Request = (Token, String, mpsc::Sender<Result<Response, ResponseError>>);
+type Request = (Token, String, mpsc::Sender<Result<Response, Error>>);
 
 async fn mainloop(
     mut cmd: process::Child,

src/lib.rs

@@ -1,10 +1,12 @@
 use std::{collections::HashMap, fmt, process::Stdio, time::Duration};
 
+use breakpoint::{Breakpoint, LineSpec};
 use camino::{Utf8Path, Utf8PathBuf};
 use rand::Rng;
 use tokio::{io, process};
 use tracing::{debug, error};
 
+pub mod breakpoint;
 mod inner;
 pub mod parser;
 pub mod raw;
@@ -19,7 +21,7 @@ use crate::symbol::Symbol;
 mod test_common;
 
 #[derive(Debug, Clone, thiserror::Error, Eq, PartialEq)]
-pub enum ResponseError {
+pub enum Error {
     #[error(transparent)]
     Gdb(#[from] GdbError),
 
@@ -33,9 +35,12 @@ pub enum ResponseError {
     #[error("Expected response to have a payload")]
     ExpectedPayload,
 
-    #[error("Failed to parse payload value as u32, got: {0}")]
+    #[error("Failed to parse payload value as u32")]
     ParseU32(#[from] std::num::ParseIntError),
 
+    #[error("Failed to parse payload value as hex")]
+    ParseHex(#[from] ParseHexError),
+
     #[error("Expected response to have message {expected}, got {actual}")]
     UnexpectedResponseMessage { expected: String, actual: String },
 
@@ -50,6 +55,14 @@ pub struct GdbError {
     msg: String,
 }
 
+#[derive(Debug, Clone, thiserror::Error, Eq, PartialEq)]
+pub enum ParseHexError {
+    #[error("Expected to start with 0x")]
+    InvalidPrefix,
+    #[error(transparent)]
+    ParseInt(#[from] std::num::ParseIntError),
+}
+
 pub struct Gdb {
     inner: Inner,
     timeout: Duration,
@@ -91,16 +104,56 @@ impl Gdb {
         Ok(Self { inner, timeout })
     }
 
-    pub async fn run(&self) -> Result<(), ResponseError> {
+    pub async fn run(&self) -> Result<(), Error> {
         self.execute_raw("-exec-run")
             .await?
             .expect_result()?
             .expect_msg_is("running")
     }
 
-    pub async fn symbol_info_functions(
-        &self,
-    ) -> Result<HashMap<Utf8PathBuf, Vec<Symbol>>, ResponseError> {
+    pub async fn break_insert(&self, at: LineSpec) -> Result<Breakpoint, Error> {
+        let raw = self
+            .execute_raw(format!("-break-insert {}", at.serialize()))
+            .await?
+            .expect_result()?
+            .expect_payload()?
+            .remove_expect("bkpt")?
+            .expect_dict()?;
+
+        Breakpoint::from_raw(raw)
+    }
+
+    pub async fn break_disable<'a, I>(&self, breakpoints: I) -> Result<(), Error>
+    where
+        I: IntoIterator<Item = &'a Breakpoint>,
+    {
+        let mut raw = String::new();
+        for bp in breakpoints {
+            raw.push_str(&format!("{} ", bp.number));
+        }
+
+        self.execute_raw(format!("-break-disable {}", raw))
+            .await?
+            .expect_result()?
+            .expect_msg_is("done")
+    }
+
+    pub async fn break_delete<'a, I>(&self, breakpoints: I) -> Result<(), Error>
+    where
+        I: IntoIterator<Item = &'a Breakpoint>,
+    {
+        let mut raw = String::new();
+        for bp in breakpoints {
+            raw.push_str(&format!("{} ", bp.number));
+        }
+
+        self.execute_raw(format!("-break-delete {}", raw))
+            .await?
+            .expect_result()?
+            .expect_msg_is("done")
+    }
+
+    pub async fn symbol_info_functions(&self) -> Result<HashMap<Utf8PathBuf, Vec<Symbol>>, Error> {
         let payload = self
             .execute_raw("-symbol-info-functions")
             .await?
@@ -112,17 +165,14 @@ impl Gdb {
     /// Execute a command for a response.
     ///
     /// Your command will be prefixed with a token and suffixed with a newline.
-    pub async fn execute_raw(
-        &self,
-        msg: impl Into<String>,
-    ) -> Result<raw::Response, ResponseError> {
+    pub async fn execute_raw(&self, msg: impl Into<String>) -> Result<raw::Response, Error> {
         self.inner.execute(msg.into(), self.timeout).await
     }
 
     /// Waits until gdb is responsive to commands.
     ///
     /// You do not need to call this before sending commands yourself.
-    pub async fn await_ready(&self) -> Result<(), ResponseError> {
+    pub async fn await_ready(&self) -> Result<(), Error> {
         self.execute_raw("-list-target-features").await?;
         Ok(())
     }
@@ -155,7 +205,7 @@ impl Token {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::BTreeMap;
+    use std::{collections::BTreeMap, iter};
 
     use super::*;
     use insta::assert_debug_snapshot;
@@ -167,6 +217,24 @@ mod tests {
         Ok(Gdb::spawn(bin, TIMEOUT)?)
     }
 
+    #[tokio::test]
+    async fn test_break() -> Result {
+        let subject = fixture()?;
+
+        let bp = subject
+            .break_insert(LineSpec::line("samples/hello_world/src/main.rs", 13))
+            .await?;
+        assert_eq!(1, bp.number);
+        assert!(bp.file.ends_with("samples/hello_world/src/main.rs"));
+        assert_eq!(13, bp.line);
+        assert_eq!(0, bp.times);
+
+        subject.break_disable(iter::once(&bp)).await?;
+        subject.break_delete(iter::once(&bp)).await?;
+
+        Ok(())
+    }
+
     #[tokio::test]
     async fn test_run() -> Result {
         let subject = fixture()?;
@@ -206,7 +274,7 @@ mod tests {
         let err = subject.execute_raw("-invalid-command").await.unwrap_err();
 
         assert_eq!(
-            ResponseError::Gdb(GdbError {
+            Error::Gdb(GdbError {
                 code: "undefined-command".into(),
                 msg: "Undefined MI command: invalid-command".into(),
             }),