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); }