public LLDB.Process GetProcess()
{
var __ret = new LLDB.Process.Internal();
Internal.GetProcess_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment));
return LLDB.Process.__CreateInstance(__ret);
}
/// <summary>
/// <para>Attach to process with name.</para>
/// </summary>
/// <param name="listener">
/// <para>An optional listener that will receive all process events.</para>
/// <para>If</para>
/// <para>is valid then</para>
/// <para>will listen to all</para>
/// <para>process events. If not valid, then this target's debugger</para>
/// <para>(SBTarget::GetDebugger()) will listen to all process events.</para>
/// </param>
/// <param name="name">
/// <para>Basename of process to attach to.</para>
/// </param>
/// <param name="wait_for">
/// <para>If true wait for a new instance of 'name' to be launched.</para>
/// </param>
/// <param name="error">
/// <para>An error explaining what went wrong if attach fails.</para>
/// </param>
/// <returns>
/// <para>A process object for the attached process.</para>
/// </returns>
public LLDB.Process AttachToProcessWithName(LLDB.Listener listener, string name, bool wait_for, LLDB.Error error)
{
if (ReferenceEquals(listener, null))
throw new global::System.ArgumentNullException("listener", "Cannot be null because it is a C++ reference (&).");
var arg0 = listener.__Instance;
var arg1 = Marshal.StringToHGlobalAnsi(name);
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg3 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.AttachToProcessWithName_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1, wait_for, arg3);
Marshal.FreeHGlobal(arg1);
return LLDB.Process.__CreateInstance(__ret);
}
/// <summary>
/// <para>Connect to a remote debug server with url.</para>
/// </summary>
/// <param name="listener">
/// <para>An optional listener that will receive all process events.</para>
/// <para>If</para>
/// <para>is valid then</para>
/// <para>will listen to all</para>
/// <para>process events. If not valid, then this target's debugger</para>
/// <para>(SBTarget::GetDebugger()) will listen to all process events.</para>
/// </param>
/// <param name="url">
/// <para>The url to connect to, e.g., 'connect://localhost:12345'.</para>
/// </param>
/// <param name="plugin_name">
/// <para>The plugin name to be used; can be nullptr.</para>
/// </param>
/// <param name="error">
/// <para>An error explaining what went wrong if the connect fails.</para>
/// </param>
/// <returns>
/// <para>A process object for the connected process.</para>
/// </returns>
public LLDB.Process ConnectRemote(LLDB.Listener listener, string url, string plugin_name, LLDB.Error error)
{
if (ReferenceEquals(listener, null))
throw new global::System.ArgumentNullException("listener", "Cannot be null because it is a C++ reference (&).");
var arg0 = listener.__Instance;
var arg1 = Marshal.StringToHGlobalAnsi(url);
var arg2 = Marshal.StringToHGlobalAnsi(plugin_name);
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg3 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.ConnectRemote_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1, arg2, arg3);
Marshal.FreeHGlobal(arg1);
Marshal.FreeHGlobal(arg2);
return LLDB.Process.__CreateInstance(__ret);
}
public LLDB.Process Attach(LLDB.AttachInfo attach_info, LLDB.Error error)
{
if (ReferenceEquals(attach_info, null))
throw new global::System.ArgumentNullException("attach_info", "Cannot be null because it is a C++ reference (&).");
var arg0 = attach_info.__Instance;
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg1 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.Attach_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1);
return LLDB.Process.__CreateInstance(__ret);
}
public LLDB.Process AttachToProcessWithID(LLDB.Listener listener, int pid, LLDB.Error error)
{
if (ReferenceEquals(listener, null))
throw new global::System.ArgumentNullException("listener", "Cannot be null because it is a C++ reference (&).");
var arg0 = listener.__Instance;
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg2 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.AttachToProcessWithID_1(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, pid, arg2);
return LLDB.Process.__CreateInstance(__ret);
}
/// <summary>
/// <para>Launch a new process with sensible defaults.</para>
/// </summary>
/// <param name="argv">
/// <para>The argument array.</para>
/// </param>
/// <param name="envp">
/// <para>The environment array.</para>
/// </param>
/// <param name="working_directory">
/// <para>The working directory to have the child process run in</para>
/// <para>Default: listener</para>
/// <para>Set to the target's debugger (SBTarget::GetDebugger())</para>
/// <para>Default: launch_flags</para>
/// <para>Empty launch flags</para>
/// <para>Default: stdin_path</para>
/// <para>Default: stdout_path</para>
/// <para>Default: stderr_path</para>
/// <para>A pseudo terminal will be used.</para>
/// </param>
/// <returns>
/// <para>A process object for the newly created process.</para>
/// </returns>
public LLDB.Process LaunchSimple(sbyte** argv, sbyte** envp, string working_directory)
{
var arg0 = argv;
var arg1 = envp;
var arg2 = Marshal.StringToHGlobalAnsi(working_directory);
var __ret = new LLDB.Process.Internal();
Internal.LaunchSimple_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1, arg2);
Marshal.FreeHGlobal(arg2);
return LLDB.Process.__CreateInstance(__ret);
}
public LLDB.Process LoadCore(string core_file)
{
var arg0 = Marshal.StringToHGlobalAnsi(core_file);
var __ret = new LLDB.Process.Internal();
Internal.LoadCore_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0);
Marshal.FreeHGlobal(arg0);
return LLDB.Process.__CreateInstance(__ret);
}
/// <summary>
/// <para>Launch a new process.</para>
/// </summary>
/// <remarks>
/// <para>Launch a new process by spawning a new process using the</para>
/// <para>target object's executable module's file as the file to launch.</para>
/// <para>Arguments are given in </para>
/// <para>and the environment variables</para>
/// <para>are in </para>
/// <para>Standard input and output files can be</para>
/// <para>optionally re-directed to </para>
/// <para> </para>
/// <para>and</para>
/// </remarks>
/// <param name="listener">
/// <para>An optional listener that will receive all process events.</para>
/// <para>If</para>
/// <para>is valid then</para>
/// <para>will listen to all</para>
/// <para>process events. If not valid, then this target's debugger</para>
/// <para>(SBTarget::GetDebugger()) will listen to all process events.</para>
/// </param>
/// <param name="argv">
/// <para>The argument array.</para>
/// </param>
/// <param name="envp">
/// <para>The environment array.</para>
/// </param>
/// <param name="launch_flags">
/// <para>Flags to modify the launch (</para>
/// </param>
/// <param name="stdin_path">
/// <para>The path to use when re-directing the STDIN of the new</para>
/// <para>process. If all stdXX_path arguments are nullptr, a pseudo</para>
/// <para>terminal will be used.</para>
/// </param>
/// <param name="stdout_path">
/// <para>The path to use when re-directing the STDOUT of the new</para>
/// <para>process. If all stdXX_path arguments are nullptr, a pseudo</para>
/// <para>terminal will be used.</para>
/// </param>
/// <param name="stderr_path">
/// <para>The path to use when re-directing the STDERR of the new</para>
/// <para>process. If all stdXX_path arguments are nullptr, a pseudo</para>
/// <para>terminal will be used.</para>
/// </param>
/// <param name="working_directory">
/// <para>The working directory to have the child process run in</para>
/// </param>
/// <param name="launch_flags">
/// <para>Some launch options specified by logical OR'ing</para>
/// <para>lldb::LaunchFlags enumeration values together.</para>
/// </param>
/// <param name="stop_at_entry">
/// <para>If false do not stop the inferior at the entry point.</para>
/// </param>
/// <param name="error">
/// <para>An error object. Contains the reason if there is some failure.</para>
/// </param>
/// <returns>
/// <para>A process object for the newly created process.</para>
/// </returns>
public LLDB.Process Launch(LLDB.Listener listener, sbyte** argv, sbyte** envp, string stdin_path, string stdout_path, string stderr_path, string working_directory, uint launch_flags, bool stop_at_entry, out LLDB.Error error)
{
if (ReferenceEquals(listener, null))
throw new global::System.ArgumentNullException("listener", "Cannot be null because it is a C++ reference (&).");
var arg0 = listener.__Instance;
var arg1 = argv;
var arg2 = envp;
var arg3 = Marshal.StringToHGlobalAnsi(stdin_path);
var arg4 = Marshal.StringToHGlobalAnsi(stdout_path);
var arg5 = Marshal.StringToHGlobalAnsi(stderr_path);
var arg6 = Marshal.StringToHGlobalAnsi(working_directory);
error = new LLDB.Error();
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg9 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.Launch_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1, arg2, arg3, arg4, arg5, arg6, launch_flags, stop_at_entry, arg9);
LLDB.Error __result0;
if (arg9 == IntPtr.Zero) __result0 = null;
else if (LLDB.Error.NativeToManagedMap.ContainsKey(arg9))
__result0 = (LLDB.Error) LLDB.Error.NativeToManagedMap[arg9];
else __result0 = LLDB.Error.__CreateInstance(arg9);
error = __result0;
Marshal.FreeHGlobal(arg3);
Marshal.FreeHGlobal(arg4);
Marshal.FreeHGlobal(arg5);
Marshal.FreeHGlobal(arg6);
return LLDB.Process.__CreateInstance(__ret);
}
/// <summary>
/// <para>Connect to a remote debug server with url.</para>
/// </summary>
/// <param name="listener">
/// <para>An optional listener that will receive all process events.</para>
/// <para>If</para>
/// <para>is valid then</para>
/// <para>will listen to all</para>
/// <para>process events. If not valid, then this target's debugger</para>
/// <para>(SBTarget::GetDebugger()) will listen to all process events.</para>
/// </param>
/// <param name="url">
/// <para>The url to connect to, e.g., 'connect://localhost:12345'.</para>
/// </param>
/// <param name="plugin_name">
/// <para>The plugin name to be used; can be nullptr.</para>
/// </param>
/// <param name="error">
/// <para>An error explaining what went wrong if the connect fails.</para>
/// </param>
/// <returns>
/// <para>A process object for the connected process.</para>
/// </returns>
public LLDB.Process ConnectRemote(LLDB.Listener listener, string url, string plugin_name, out LLDB.Error error)
{
if (ReferenceEquals(listener, null))
throw new global::System.ArgumentNullException("listener", "Cannot be null because it is a C++ reference (&).");
var arg0 = listener.__Instance;
var arg1 = Marshal.StringToHGlobalAnsi(url);
var arg2 = Marshal.StringToHGlobalAnsi(plugin_name);
error = new LLDB.Error();
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg3 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.ConnectRemote_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), arg0, arg1, arg2, arg3);
LLDB.Error __result0;
if (arg3 == IntPtr.Zero) __result0 = null;
else if (LLDB.Error.NativeToManagedMap.ContainsKey(arg3))
__result0 = (LLDB.Error) LLDB.Error.NativeToManagedMap[arg3];
else __result0 = LLDB.Error.__CreateInstance(arg3);
error = __result0;
Marshal.FreeHGlobal(arg1);
Marshal.FreeHGlobal(arg2);
return LLDB.Process.__CreateInstance(__ret);
}
/// <summary>
/// <para>Attach to process with pid.</para>
/// </summary>
/// <param name="listener">
/// <para>An optional listener that will receive all process events.</para>
/// <para>If</para>
/// <para>is valid then</para>
/// <para>will listen to all</para>
/// <para>process events. If not valid, then this target's debugger</para>
/// <para>(SBTarget::GetDebugger()) will listen to all process events.</para>
/// </param>
/// <param name="pid">
/// <para>The process ID to attach to.</para>
/// </param>
/// <param name="error">
/// <para>An error explaining what went wrong if attach fails.</para>
/// </param>
/// <returns>
/// <para>A process object for the attached process.</para>
/// </returns>
public LLDB.Process AttachToProcessWithID(LLDB.Listener listener, ulong pid, out LLDB.Error error)
{
if (ReferenceEquals(listener, null))
throw new global::System.ArgumentNullException("listener", "Cannot be null because it is a C++ reference (&).");
var arg0 = listener.__Instance;
error = new LLDB.Error();
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg2 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.AttachToProcessWithID_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), arg0, pid, arg2);
LLDB.Error __result0;
if (arg2 == IntPtr.Zero) __result0 = null;
else if (LLDB.Error.NativeToManagedMap.ContainsKey(arg2))
__result0 = (LLDB.Error) LLDB.Error.NativeToManagedMap[arg2];
else __result0 = LLDB.Error.__CreateInstance(arg2);
error = __result0;
return LLDB.Process.__CreateInstance(__ret);
}
public LLDB.Process Launch(LLDB.LaunchInfo launch_info, out LLDB.Error error)
{
if (ReferenceEquals(launch_info, null))
throw new global::System.ArgumentNullException("launch_info", "Cannot be null because it is a C++ reference (&).");
var arg0 = launch_info.__Instance;
error = new LLDB.Error();
if (ReferenceEquals(error, null))
throw new global::System.ArgumentNullException("error", "Cannot be null because it is a C++ reference (&).");
var arg1 = error.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.Launch_1((__Instance + __PointerAdjustment), new IntPtr(&__ret), arg0, arg1);
LLDB.Error __result0;
if (arg1 == IntPtr.Zero) __result0 = null;
else if (LLDB.Error.NativeToManagedMap.ContainsKey(arg1))
__result0 = (LLDB.Error) LLDB.Error.NativeToManagedMap[arg1];
else __result0 = LLDB.Error.__CreateInstance(arg1);
error = __result0;
return LLDB.Process.__CreateInstance(__ret);
}
public static LLDB.Process GetProcessFromEvent(LLDB.Event @event)
{
if (ReferenceEquals(@event, null))
throw new global::System.ArgumentNullException("@event", "Cannot be null because it is a C++ reference (&).");
var arg0 = @event.__Instance;
var __ret = new LLDB.Process.Internal();
Internal.GetProcessFromEvent_0(new IntPtr(&__ret), arg0);
return LLDB.Process.__CreateInstance(__ret);
}
