662548c826
Instead of maintaining separate swig interface files, we can use the API headers directly. They implement the exact same C++ APIs and we can conditionally include the python extensions as needed. To remove the swig extensions from the API headers when building the LLDB framework, we can use the unifdef tool when it is available. Otherwise we just copy them as-is. Differential Revision: https://reviews.llvm.org/D142926
190 lines
7.0 KiB
OpenEdge ABL
190 lines
7.0 KiB
OpenEdge ABL
%feature("docstring",
|
|
"Represents the value of a variable, a register, or an expression.
|
|
|
|
SBValue supports iteration through its child, which in turn is represented
|
|
as an SBValue. For example, we can get the general purpose registers of a
|
|
frame as an SBValue, and iterate through all the registers,::
|
|
|
|
registerSet = frame.registers # Returns an SBValueList.
|
|
for regs in registerSet:
|
|
if 'general purpose registers' in regs.name.lower():
|
|
GPRs = regs
|
|
break
|
|
|
|
print('%s (number of children = %d):' % (GPRs.name, GPRs.num_children))
|
|
for reg in GPRs:
|
|
print('Name: ', reg.name, ' Value: ', reg.value)
|
|
|
|
produces the output: ::
|
|
|
|
General Purpose Registers (number of children = 21):
|
|
Name: rax Value: 0x0000000100000c5c
|
|
Name: rbx Value: 0x0000000000000000
|
|
Name: rcx Value: 0x00007fff5fbffec0
|
|
Name: rdx Value: 0x00007fff5fbffeb8
|
|
Name: rdi Value: 0x0000000000000001
|
|
Name: rsi Value: 0x00007fff5fbffea8
|
|
Name: rbp Value: 0x00007fff5fbffe80
|
|
Name: rsp Value: 0x00007fff5fbffe60
|
|
Name: r8 Value: 0x0000000008668682
|
|
Name: r9 Value: 0x0000000000000000
|
|
Name: r10 Value: 0x0000000000001200
|
|
Name: r11 Value: 0x0000000000000206
|
|
Name: r12 Value: 0x0000000000000000
|
|
Name: r13 Value: 0x0000000000000000
|
|
Name: r14 Value: 0x0000000000000000
|
|
Name: r15 Value: 0x0000000000000000
|
|
Name: rip Value: 0x0000000100000dae
|
|
Name: rflags Value: 0x0000000000000206
|
|
Name: cs Value: 0x0000000000000027
|
|
Name: fs Value: 0x0000000000000010
|
|
Name: gs Value: 0x0000000000000048
|
|
|
|
See also linked_list_iter() for another perspective on how to iterate through an
|
|
SBValue instance which interprets the value object as representing the head of a
|
|
linked list."
|
|
) lldb::SBValue;
|
|
|
|
%feature("docstring", "
|
|
Get a child value by index from a value.
|
|
|
|
Structs, unions, classes, arrays and pointers have child
|
|
values that can be access by index.
|
|
|
|
Structs and unions access child members using a zero based index
|
|
for each child member. For
|
|
|
|
Classes reserve the first indexes for base classes that have
|
|
members (empty base classes are omitted), and all members of the
|
|
current class will then follow the base classes.
|
|
|
|
Pointers differ depending on what they point to. If the pointer
|
|
points to a simple type, the child at index zero
|
|
is the only child value available, unless synthetic_allowed
|
|
is true, in which case the pointer will be used as an array
|
|
and can create 'synthetic' child values using positive or
|
|
negative indexes. If the pointer points to an aggregate type
|
|
(an array, class, union, struct), then the pointee is
|
|
transparently skipped and any children are going to be the indexes
|
|
of the child values within the aggregate type. For example if
|
|
we have a 'Point' type and we have a SBValue that contains a
|
|
pointer to a 'Point' type, then the child at index zero will be
|
|
the 'x' member, and the child at index 1 will be the 'y' member
|
|
(the child at index zero won't be a 'Point' instance).
|
|
|
|
If you actually need an SBValue that represents the type pointed
|
|
to by a SBValue for which GetType().IsPointeeType() returns true,
|
|
regardless of the pointee type, you can do that with the SBValue.Dereference
|
|
method (or the equivalent deref property).
|
|
|
|
Arrays have a preset number of children that can be accessed by
|
|
index and will returns invalid child values for indexes that are
|
|
out of bounds unless the synthetic_allowed is true. In this
|
|
case the array can create 'synthetic' child values for indexes
|
|
that aren't in the array bounds using positive or negative
|
|
indexes.
|
|
|
|
@param[in] idx
|
|
The index of the child value to get
|
|
|
|
@param[in] use_dynamic
|
|
An enumeration that specifies whether to get dynamic values,
|
|
and also if the target can be run to figure out the dynamic
|
|
type of the child value.
|
|
|
|
@param[in] synthetic_allowed
|
|
If true, then allow child values to be created by index
|
|
for pointers and arrays for indexes that normally wouldn't
|
|
be allowed.
|
|
|
|
@return
|
|
A new SBValue object that represents the child member value."
|
|
) lldb::SBValue::GetChildAtIndex;
|
|
|
|
%feature("docstring", "
|
|
Returns the child member index.
|
|
|
|
Matches children of this object only and will match base classes and
|
|
member names if this is a clang typed object.
|
|
|
|
@param[in] name
|
|
The name of the child value to get
|
|
|
|
@return
|
|
An index to the child member value."
|
|
) lldb::SBValue::GetIndexOfChildWithName;
|
|
|
|
%feature("docstring", "
|
|
Returns the child member value.
|
|
|
|
Matches child members of this object and child members of any base
|
|
classes.
|
|
|
|
@param[in] name
|
|
The name of the child value to get
|
|
|
|
@param[in] use_dynamic
|
|
An enumeration that specifies whether to get dynamic values,
|
|
and also if the target can be run to figure out the dynamic
|
|
type of the child value.
|
|
|
|
@return
|
|
A new SBValue object that represents the child member value."
|
|
) lldb::SBValue::GetChildMemberWithName;
|
|
|
|
%feature("docstring", "Expands nested expressions like .a->b[0].c[1]->d."
|
|
) lldb::SBValue::GetValueForExpressionPath;
|
|
|
|
%feature("doctstring", "
|
|
Returns the number for children.
|
|
|
|
@param[in] max
|
|
If max is less the lldb.UINT32_MAX, then the returned value is
|
|
capped to max.
|
|
|
|
@return
|
|
An integer value capped to the argument max."
|
|
) lldb::SBValue::GetNumChildren;
|
|
|
|
%feature("docstring", "
|
|
Find and watch a variable.
|
|
It returns an SBWatchpoint, which may be invalid."
|
|
) lldb::SBValue::Watch;
|
|
|
|
%feature("docstring", "
|
|
Find and watch the location pointed to by a variable.
|
|
It returns an SBWatchpoint, which may be invalid."
|
|
) lldb::SBValue::WatchPointee;
|
|
|
|
%feature("docstring", "
|
|
Get an SBData wrapping what this SBValue points to.
|
|
|
|
This method will dereference the current SBValue, if its
|
|
data type is a ``T\*`` or ``T[]``, and extract ``item_count`` elements
|
|
of type ``T`` from it, copying their contents in an :py:class:`SBData`.
|
|
|
|
:param item_idx: The index of the first item to retrieve. For an array
|
|
this is equivalent to array[item_idx], for a pointer
|
|
to ``\*(pointer + item_idx)``. In either case, the measurement
|
|
unit for item_idx is the ``sizeof(T)`` rather than the byte
|
|
:param item_count: How many items should be copied into the output. By default
|
|
only one item is copied, but more can be asked for.
|
|
:return: The contents of the copied items on success. An empty :py:class:`SBData` otherwise.
|
|
:rtype: SBData
|
|
"
|
|
) lldb::SBValue::GetPointeeData;
|
|
|
|
%feature("docstring", "
|
|
Get an SBData wrapping the contents of this SBValue.
|
|
|
|
This method will read the contents of this object in memory
|
|
and copy them into an SBData for future use.
|
|
|
|
@return
|
|
An SBData with the contents of this SBValue, on success.
|
|
An empty SBData otherwise."
|
|
) lldb::SBValue::GetData;
|
|
|
|
%feature("docstring", "Returns an expression path for this value."
|
|
) lldb::SBValue::GetExpressionPath;
|