Example #1
0
 public LLDB.Value Persist()
 {
     var __ret = new LLDB.Value.Internal();
     Internal.Persist_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment));
     return LLDB.Value.__CreateInstance(__ret);
 }
Example #2
0
 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);
 }
Example #3
0
 /// <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);
 }
Example #4
0
 public LLDB.Value Dereference()
 {
     var __ret = new LLDB.Value.Internal();
     Internal.Dereference_0((__Instance + __PointerAdjustment), new IntPtr(&__ret));
     return LLDB.Value.__CreateInstance(__ret);
 }
Example #5
0
 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);
 }
Example #6
0
 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);
 }
Example #7
0
 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);
 }
Example #8
0
 /// <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);
 }
Example #9
0
 public LLDB.Value AddressOf()
 {
     var __ret = new LLDB.Value.Internal();
     Internal.AddressOf_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment));
     return LLDB.Value.__CreateInstance(__ret);
 }
Example #10
0
 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);
 }
Example #11
0
 /// <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);
 }
Example #12
0
 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);
 }
Example #13
0
 public LLDB.Value GetNonSyntheticValue()
 {
     var __ret = new LLDB.Value.Internal();
     Internal.GetNonSyntheticValue_0((__Instance + __PointerAdjustment), new IntPtr(&__ret));
     return LLDB.Value.__CreateInstance(__ret);
 }
Example #14
0
 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);
 }
Example #15
0
 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);
 }
Example #16
0
 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);
 }
Example #17
0
 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);
 }
Example #18
0
 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);
 }
Example #19
0
 /// <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);
 }
Example #20
0
 /// <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);
 }
Example #21
0
 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);
 }
Example #22
0
 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);
 }
Example #23
0
 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);
 }
Example #24
0
 public LLDB.Value GetStopReturnValue()
 {
     var __ret = new LLDB.Value.Internal();
     Internal.GetStopReturnValue_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment));
     return LLDB.Value.__CreateInstance(__ret);
 }
Example #25
0
 /// <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);
 }