Struct SBLaunchInfo 

pub struct SBLaunchInfo {
    pub raw: SBLaunchInfoRef,
}

Configuration for launching a process.

See SBTarget::launch().

Fields

raw: SBLaunchInfoRef

The underlying raw SBLaunchInfoRef.

Implementations

impl SBLaunchInfo

pub fn new() -> SBLaunchInfo

Construct a new SBLaunchInfo.

Examples found in repository

examples/basic_synchronous.rs (line 13)

fn main() {
    SBDebugger::initialize();

    let debugger = SBDebugger::create(false);
    debugger.set_asynchronous(false);
    println!("{debugger:?}");

    if let Some(target) = debugger.create_target_simple("/usr/local/bin/servo") {
        println!("{target:?}");

        let launchinfo = SBLaunchInfo::new();
        launchinfo.set_launch_flags(LaunchFlags::STOP_AT_ENTRY);
        match target.launch(launchinfo) {
            Ok(process) => {
                println!("{process:?}");
                let _ = process.continue_execution();
                println!("{process:?}");
            }
            Err(e) => println!("Uhoh: {e:?}"),
        }
    }
    SBDebugger::terminate();
}

pub fn process_id(&self) -> lldb_pid_t

pub fn user_id(&self) -> Option<u32>

pub fn set_user_id(&self, user_id: u32)

pub fn group_id(&self) -> Option<u32>

pub fn set_group_id(&self, group_id: u32)

pub fn executable_file(&self) -> Option<SBFileSpec>

pub fn set_executable_file(&self, filespec: &SBFileSpec, add_as_first_arg: bool)

Set the executable file that will be used to launch the process and optionally set it as the first argument in the argument vector.

This only needs to be specified if clients wish to carefully control the exact path will be used to launch a binary. If you create a target with a symlink, that symlink will get resolved in the target and the resolved path will get used to launch the process. Calling this function can help you still launch your process using the path of your choice.

If this function is not called prior to launching with SBTarget::launch(...), the target will use the resolved executable path that was used to create the target.

exe_file is the override path to use when launching the executable.

If add_as_first_arg is true, then the path will be inserted into the argument vector prior to launching. Otherwise the argument vector will be left alone.

pub fn listener(&self) -> Option<SBListener>

Get the listener that will be used to receive process events.

If no listener has been set via a call to SBLaunchInfo::set_listener(), then None will be returned. If a listener has been set, then the listener object will be returned.

pub fn set_listener(&self, listener: &SBListener)

Set the listener that will be used to receive process events.

By default the SBDebugger, which has a listener, that the SBTarget belongs to will listen for the process events. Calling this function allows a different listener to be used to listen for process events.

pub fn launch_flags(&self) -> LaunchFlags

pub fn set_launch_flags(&self, launch_flags: LaunchFlags)

Examples found in repository

examples/basic_synchronous.rs (line 14)

fn main() {
    SBDebugger::initialize();

    let debugger = SBDebugger::create(false);
    debugger.set_asynchronous(false);
    println!("{debugger:?}");

    if let Some(target) = debugger.create_target_simple("/usr/local/bin/servo") {
        println!("{target:?}");

        let launchinfo = SBLaunchInfo::new();
        launchinfo.set_launch_flags(LaunchFlags::STOP_AT_ENTRY);
        match target.launch(launchinfo) {
            Ok(process) => {
                println!("{process:?}");
                let _ = process.continue_execution();
                println!("{process:?}");
            }
            Err(e) => println!("Uhoh: {e:?}"),
        }
    }
    SBDebugger::terminate();
}

pub fn set_arguments<'a>( &self, args: impl IntoIterator<Item = &'a str>, append: bool, )

Specify the command line arguments.

pub fn arguments(&self) -> impl Iterator<Item = &str>

Returns an iterator over the command line arguments.

pub fn process_plugin_name(&self) -> Option<&str>

pub fn set_process_plugin_name(&self, plugin: &str)

pub fn shell(&self) -> Option<&str>

pub fn set_shell(&self, shell: &str)

pub fn shell_expand_arguments(&self) -> bool

pub fn set_shell_expand_arguments(&self, expand: bool)

pub fn resume_count(&self) -> u32

pub fn set_resume_count(&self, resume_count: u32)

pub fn add_close_file_action(&self, fd: i32) -> bool

pub fn add_duplicate_file_action(&self, fd: i32, dup_fd: i32) -> bool

pub fn add_open_file_action( &self, fd: i32, path: &str, read: bool, write: bool, ) -> bool

pub fn add_suppress_file_action(&self, fd: i32, read: bool, write: bool) -> bool

pub fn launch_event_data(&self) -> Option<&str>

pub fn set_launch_event_data(&self, data: &str)

pub fn detach_on_error(&self) -> bool

pub fn set_detach_on_error(&self, detach: bool)

Trait Implementations

impl Clone for SBLaunchInfo

fn clone(&self) -> SBLaunchInfo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SBLaunchInfo

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

Formats the value using the given formatter.

impl Default for SBLaunchInfo

fn default() -> SBLaunchInfo

Returns the “default value” for a type.

impl Drop for SBLaunchInfo

fn drop(&mut self)

Executes the destructor for this type.

impl Send for SBLaunchInfo

impl Sync for SBLaunchInfo