189 lines
7 KiB
OpenEdge ABL
189 lines
7 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;
|