UnixSignals

Author: vadimcn

adapter/codelldb/src/debug_session.rs

@@ -1147,7 +1147,7 @@ impl DebugSession {
                     if terminate {
                         process.kill()?;
                     } else {
-                        process.detach()?;
+                        process.detach(false)?;
                     }
                 }
             }

adapter/lldb/src/lib.rs

@@ -13,11 +13,13 @@ pub type ThreadID = u64;
 pub type BreakpointID = u32;
 pub type WatchpointID = u32;
 pub type UserID = u64;
+pub type SignalNumber = i32;
 
-pub const INVALID_ADDRESS: Address = Address::max_value();
+pub const INVALID_ADDRESS: Address = Address::MAX;
 pub const INVALID_THREAD_ID: ThreadID = 0;
 pub const INVALID_PROCESS_ID: ProcessID = 0;
 pub const INVALID_BREAK_ID: BreakpointID = 0;
+pub const INVALID_SIGNAL_NUMBER: i32 = SignalNumber::MAX;
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -156,6 +158,7 @@ mod sb {
     pub mod sbtarget;
     pub mod sbthread;
     pub mod sbtype;
+    pub mod sbunixsignals;
     pub mod sbvalue;
     pub mod sbvaluelist;
     pub mod sbwatchpoint;
@@ -198,6 +201,7 @@ pub use sb::sbsymbolcontextlist::*;
 pub use sb::sbtarget::*;
 pub use sb::sbthread::*;
 pub use sb::sbtype::*;
+pub use sb::sbunixsignals::*;
 pub use sb::sbvalue::*;
 pub use sb::sbvaluelist::*;
 pub use sb::sbwatchpoint::*;

adapter/lldb/src/sb/sbprocess.rs

@@ -79,9 +79,9 @@ impl SBProcess {
         })
         .into_result()
     }
-    pub fn detach(&self) -> Result<(), SBError> {
-        cpp!(unsafe [self as "SBProcess*"] -> SBError as "SBError" {
-            return self->Detach();
+    pub fn detach(&self, keep_stopped: bool) -> Result<(), SBError> {
+        cpp!(unsafe [self as "SBProcess*", keep_stopped as "bool"] -> SBError as "SBError" {
+            return self->Detach(keep_stopped);
         })
         .into_result()
     }
@@ -157,6 +157,17 @@ impl SBProcess {
             Err(error)
         }
     }
+    pub fn unix_signals(&self) -> SBUnixSignals {
+        cpp!(unsafe [self as "SBProcess*"] -> SBUnixSignals as "SBUnixSignals" {
+            return self->GetUnixSignals();
+        })
+    }
+    pub fn signal(&self, signo: SignalNumber) -> Result<(), SBError> {
+        cpp!(unsafe [self as "SBProcess*", signo as "int"] -> SBError as "SBError" {
+            return self->Signal(signo);
+        })
+        .into_result()
+    }
 }
 
 impl IsValid for SBProcess {

adapter/lldb/src/sb/sbunixsignals.rs

@@ -0,0 +1,83 @@
+use super::*;
+
+cpp_class!(pub unsafe struct SBUnixSignals as "SBUnixSignals");
+
+unsafe impl Send for SBUnixSignals {}
+
+impl SBUnixSignals {
+    pub fn clear(&mut self) {
+        cpp!(unsafe [self as "SBUnixSignals*"] {
+            self->Clear();
+        })
+    }
+    pub fn num_signals(&self) -> u32 {
+        cpp!(unsafe [self as "SBUnixSignals*"] -> u32 as "uint32_t" {
+            return self->GetNumSignals();
+        })
+    }
+    pub fn signal_at_index(&self, index: u32) -> SignalNumber {
+        cpp!(unsafe [self as "SBUnixSignals*", index as "uint32_t"] -> SignalNumber as "int" {
+            return self->GetSignalAtIndex(index);
+        })
+    }
+    pub fn signal_number_from_name(&self, name: &str) -> Option<SignalNumber> {
+        let signo = with_cstr(name, |name| {
+            cpp!(unsafe [self as "SBUnixSignals*", name as "const char*"] -> i32 as "int" {
+                return self->GetSignalNumberFromName(name);
+            })
+        });
+        if signo == INVALID_SIGNAL_NUMBER {
+            None
+        } else {
+            Some(signo)
+        }
+    }
+    pub fn signal_name(&self, signo: SignalNumber) -> Option<&CStr> {
+        let ptr = cpp!(unsafe [self as "SBUnixSignals*", signo as "int"] -> *const c_char as "const char*" {
+            return self->GetSignalAsCString(signo);
+        });
+        if ptr.is_null() {
+            None
+        } else {
+            unsafe { Some(CStr::from_ptr(ptr)) }
+        }
+    }
+    pub fn should_stop(&self, signo: SignalNumber) -> bool {
+        cpp!(unsafe [self as "SBUnixSignals*", signo as "int"] -> bool as "bool" {
+            return self->GetShouldStop(signo);
+        })
+    }
+    pub fn set_should_stop(&self, signo: SignalNumber, value: bool) -> bool {
+        cpp!(unsafe [self as "SBUnixSignals*", signo as "int", value as "bool"] -> bool as "bool" {
+            return self->SetShouldStop(signo, value);
+        })
+    }
+    pub fn should_suppress(&self, signo: SignalNumber) -> bool {
+        cpp!(unsafe [self as "SBUnixSignals*", signo as "int"] -> bool as "bool" {
+            return self->GetShouldSuppress(signo);
+        })
+    }
+    pub fn set_should_suppress(&self, signo: SignalNumber, value: bool) -> bool {
+        cpp!(unsafe [self as "SBUnixSignals*", signo as "int", value as "bool"] -> bool as "bool" {
+            return self->SetShouldSuppress(signo, value);
+        })
+    }
+    pub fn should_notify(&self, signo: SignalNumber) -> bool {
+        cpp!(unsafe [self as "SBUnixSignals*", signo as "int"] -> bool as "bool" {
+            return self->GetShouldNotify(signo);
+        })
+    }
+    pub fn set_should_notify(&self, signo: SignalNumber, value: bool) -> bool {
+        cpp!(unsafe [self as "SBUnixSignals*", signo as "int", value as "bool"] -> bool as "bool" {
+            return self->SetShouldNotify(signo, value);
+        })
+    }
+}
+
+impl IsValid for SBUnixSignals {
+    fn is_valid(&self) -> bool {
+        cpp!(unsafe [self as "SBUnixSignals*"] -> bool as "bool" {
+            return self->IsValid();
+        })
+    }
+}