public LLDB.Value Persist()
{
var __ret = new LLDB.Value.Internal();
Internal.Persist_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment));
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value FindValueObjectByUID(ulong uid)
{
var __ret = new LLDB.Value.Internal();
Internal.FindValueObjectByUID_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), uid);
return LLDB.Value.__CreateInstance(__ret);
}
/// <summary>
/// <para>The version that doesn't supply a 'use_dynamic' value will use the</para>
/// <para>target's default.</para>
/// </summary>
public LLDB.Value GetValueForVariablePath(string var_path)
{
var arg0 = Marshal.StringToHGlobalAnsi(var_path);
var __ret = new LLDB.Value.Internal();
Internal.GetValueForVariablePath_1(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value Dereference()
{
var __ret = new LLDB.Value.Internal();
Internal.Dereference_0((__Instance + __PointerAdjustment), new IntPtr(&__ret));
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value EvaluateExpression(string expr, LLDB.ExpressionOptions options)
{
var arg0 = Marshal.StringToHGlobalAnsi(expr);
if (ReferenceEquals(options, null))
throw new global::System.ArgumentNullException("options", "Cannot be null because it is a C++ reference (&).");
var arg1 = options.__Instance;
var __ret = new LLDB.Value.Internal();
Internal.EvaluateExpression_3(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value FindVariable(string var_name, LLDB.DynamicValueType use_dynamic)
{
var arg0 = Marshal.StringToHGlobalAnsi(var_name);
var arg1 = use_dynamic;
var __ret = new LLDB.Value.Internal();
Internal.FindVariable_1(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value CreateChildAtOffset(string name, uint offset, LLDB.Type type)
{
var arg0 = Marshal.StringToHGlobalAnsi(name);
var arg2 = ReferenceEquals(type, null) ? new LLDB.Type.Internal() : *(LLDB.Type.Internal*) (type.__Instance);
var __ret = new LLDB.Value.Internal();
Internal.CreateChildAtOffset_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, offset, arg2);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
/// <summary>
/// <para>The version that doesn't supply a 'use_dynamic' value will use the</para>
/// <para>target's default.</para>
/// </summary>
public LLDB.Value EvaluateExpression(string expr)
{
var arg0 = Marshal.StringToHGlobalAnsi(expr);
var __ret = new LLDB.Value.Internal();
Internal.EvaluateExpression_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value AddressOf()
{
var __ret = new LLDB.Value.Internal();
Internal.AddressOf_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment));
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value Cast(LLDB.Type type)
{
var arg0 = ReferenceEquals(type, null) ? new LLDB.Type.Internal() : *(LLDB.Type.Internal*) (type.__Instance);
var __ret = new LLDB.Value.Internal();
Internal.Cast_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0);
return LLDB.Value.__CreateInstance(__ret);
}
/// <summary>
/// <para>Find the first global (or static) variable by name.</para>
/// </summary>
/// <param name="name">
/// <para>The name of the global or static variable we are looking</para>
/// <para>for.</para>
/// </param>
/// <returns>
/// <para>An SBValue that gets filled in with the found variable (if any).</para>
/// </returns>
public LLDB.Value FindFirstGlobalVariable(string name)
{
var arg0 = Marshal.StringToHGlobalAnsi(name);
var __ret = new LLDB.Value.Internal();
Internal.FindFirstGlobalVariable_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetValueForExpressionPath(string expr_path)
{
var arg0 = Marshal.StringToHGlobalAnsi(expr_path);
var __ret = new LLDB.Value.Internal();
Internal.GetValueForExpressionPath_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), arg0);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetNonSyntheticValue()
{
var __ret = new LLDB.Value.Internal();
Internal.GetNonSyntheticValue_0((__Instance + __PointerAdjustment), new IntPtr(&__ret));
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetFirstValueByName(string name)
{
var arg0 = Marshal.StringToHGlobalAnsi(name);
var __ret = new LLDB.Value.Internal();
Internal.GetFirstValueByName_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), arg0);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value CreateValueFromData(string name, LLDB.Data data, LLDB.Type type)
{
var arg0 = Marshal.StringToHGlobalAnsi(name);
var arg1 = ReferenceEquals(data, null) ? new LLDB.Data.Internal() : *(LLDB.Data.Internal*) (data.__Instance);
var arg2 = ReferenceEquals(type, null) ? new LLDB.Type.Internal() : *(LLDB.Type.Internal*) (type.__Instance);
var __ret = new LLDB.Value.Internal();
Internal.CreateValueFromData_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1, arg2);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetValueAtIndex(uint idx)
{
var __ret = new LLDB.Value.Internal();
Internal.GetValueAtIndex_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), idx);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value CreateValueFromExpression(string name, string expression)
{
var arg0 = Marshal.StringToHGlobalAnsi(name);
var arg1 = Marshal.StringToHGlobalAnsi(expression);
var __ret = new LLDB.Value.Internal();
Internal.CreateValueFromExpression_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1);
Marshal.FreeHGlobal(arg0);
Marshal.FreeHGlobal(arg1);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value EvaluateExpression(string expr, LLDB.DynamicValueType use_dynamic, bool unwind_on_error)
{
var arg0 = Marshal.StringToHGlobalAnsi(expr);
var arg1 = use_dynamic;
var __ret = new LLDB.Value.Internal();
Internal.EvaluateExpression_2(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1, unwind_on_error);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
/// <summary>
/// <para>Get a child value by index from a value.</para>
/// </summary>
/// <remarks>
/// <para>Structs, unions, classes, arrays and pointers have child</para>
/// <para>values that can be access by index. </para>
/// <para>Structs and unions access child members using a zero based index</para>
/// <para>for each child member. For</para>
/// <para>Classes reserve the first indexes for base classes that have </para>
/// <para>members (empty base classes are omitted), and all members of the</para>
/// <para>current class will then follow the base classes. </para>
/// <para>Pointers differ depending on what they point to. If the pointer</para>
/// <para>points to a simple type, the child at index zero</para>
/// <para>is the only child value available, unless </para>
/// <para> </para>
/// <para>is </para>
/// <para>in which case the pointer will be used as an array</para>
/// <para>and can create 'synthetic' child values using positive or </para>
/// <para>negative indexes. If the pointer points to an aggregate type </para>
/// <para>(an array, class, union, struct), then the pointee is </para>
/// <para>transparently skipped and any children are going to be the indexes</para>
/// <para>of the child values within the aggregate type. For example if</para>
/// <para>we have a 'Point' type and we have a SBValue that contains a</para>
/// <para>pointer to a 'Point' type, then the child at index zero will be</para>
/// <para>the 'x' member, and the child at index 1 will be the 'y' member</para>
/// <para>(the child at index zero won't be a 'Point' instance).</para>
/// <para>If you actually need an SBValue that represents the type pointed</para>
/// <para>to by a SBValue for which GetType().IsPointeeType() returns true,</para>
/// <para>regardless of the pointee type, you can do that with SBValue::Dereference.</para>
/// <para>Arrays have a preset number of children that can be accessed by</para>
/// <para>index and will returns invalid child values for indexes that are</para>
/// <para>out of bounds unless the </para>
/// <para>is </para>
/// <para>In this</para>
/// <para>case the array can create 'synthetic' child values for indexes </para>
/// <para>that aren't in the array bounds using positive or negative </para>
/// <para>indexes.</para>
/// </remarks>
/// <param name="idx">
/// <para>The index of the child value to get</para>
/// </param>
/// <param name="use_dynamic">
/// <para>An enumeration that specifies whether to get dynamic values,</para>
/// <para>and also if the target can be run to figure out the dynamic</para>
/// <para>type of the child value.</para>
/// </param>
/// <param name="can_create_synthetic">
/// <para>If</para>
/// <para>then allow child values to be created by index</para>
/// <para>for pointers and arrays for indexes that normally wouldn't</para>
/// <para>be allowed.</para>
/// </param>
/// <returns>
/// <para>A new SBValue object that represents the child member value.</para>
/// </returns>
public LLDB.Value GetChildAtIndex(uint idx, LLDB.DynamicValueType use_dynamic, bool can_create_synthetic)
{
var arg1 = use_dynamic;
var __ret = new LLDB.Value.Internal();
Internal.GetChildAtIndex_1(new IntPtr(&__ret), (__Instance + __PointerAdjustment), idx, arg1, can_create_synthetic);
return LLDB.Value.__CreateInstance(__ret);
}
/// <summary>
/// <para>Find variables, register sets, registers, or persistent variables using</para>
/// <para>the frame as the scope.</para>
/// </summary>
/// <remarks>
/// <para>NB. This function does not look up ivars in the function object pointer.</para>
/// <para>To do that use GetValueForVariablePath.</para>
/// <para>The version that doesn't supply a 'use_dynamic' value will use the</para>
/// <para>target's default.</para>
/// </remarks>
public LLDB.Value FindValue(string name, LLDB.ValueType value_type)
{
var arg0 = Marshal.StringToHGlobalAnsi(name);
var arg1 = value_type;
var __ret = new LLDB.Value.Internal();
Internal.FindValue_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetChildMemberWithName(string name, LLDB.DynamicValueType use_dynamic)
{
var arg0 = Marshal.StringToHGlobalAnsi(name);
var arg1 = use_dynamic;
var __ret = new LLDB.Value.Internal();
Internal.GetChildMemberWithName_1(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetValueForVariablePath(string var_expr_cstr, LLDB.DynamicValueType use_dynamic)
{
var arg0 = Marshal.StringToHGlobalAnsi(var_expr_cstr);
var arg1 = use_dynamic;
var __ret = new LLDB.Value.Internal();
Internal.GetValueForVariablePath_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0, arg1);
Marshal.FreeHGlobal(arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetDynamicValue(LLDB.DynamicValueType use_dynamic)
{
var arg0 = use_dynamic;
var __ret = new LLDB.Value.Internal();
Internal.GetDynamicValue_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), arg0);
return LLDB.Value.__CreateInstance(__ret);
}
public LLDB.Value GetStopReturnValue()
{
var __ret = new LLDB.Value.Internal();
Internal.GetStopReturnValue_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment));
return LLDB.Value.__CreateInstance(__ret);
}
/// <summary>
/// <para>Find the first global (or static) variable by name.</para>
/// </summary>
/// <param name="target">
/// <para>A valid SBTarget instance representing the debuggee.</para>
/// </param>
/// <param name="name">
/// <para>The name of the global or static variable we are looking</para>
/// <para>for.</para>
/// </param>
/// <returns>
/// <para>An SBValue that gets filled in with the found variable (if any).</para>
/// </returns>
public LLDB.Value FindFirstGlobalVariable(LLDB.Target target, string name)
{
if (ReferenceEquals(target, null))
throw new global::System.ArgumentNullException("target", "Cannot be null because it is a C++ reference (&).");
var arg0 = target.__Instance;
var arg1 = Marshal.StringToHGlobalAnsi(name);
var __ret = new LLDB.Value.Internal();
Internal.FindFirstGlobalVariable_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), arg0, arg1);
Marshal.FreeHGlobal(arg1);
return LLDB.Value.__CreateInstance(__ret);
}