Class SBValue

GetChildAtIndex(SBValue self, uint32_t idx) -> SBValue
GetChildAtIndex(SBValue self, uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) -> SBValue

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.

GetIndexOfChildWithName(SBValue self, char const * name) -> uint32_t

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.

GetChildMemberWithName(SBValue self, char const * name) -> SBValue
GetChildMemberWithName(SBValue self, char const * name, lldb::DynamicValueType use_dynamic) -> SBValue

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.

GetValueForExpressionPath(SBValue self, char const * expr_path) -> SBValue

Expands nested expressions like .a->b[0].c[1]->d.

Watch(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint

Find and watch a variable. It returns an SBWatchpoint, which may be invalid.

WatchPointee(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint

Find and watch the location pointed to by a variable. It returns an SBWatchpoint, which may be invalid.

GetPointeeData(SBValue self, uint32_t item_idx=0, uint32_t item_count=1) -> SBData
GetPointeeData(SBValue self, uint32_t item_idx=0) -> SBData
GetPointeeData(SBValue self) -> SBData

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 SBData.

@param[in] 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[in] 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
    An SBData with the contents of the copied items, on success.
    An empty SBData otherwise.

GetData(SBValue self) -> SBData

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.

GetExpressionPath(SBValue self, SBStream description) -> bool GetExpressionPath(SBValue self, SBStream description, bool qualify_cxx_base_classes) -> bool

Returns an expression path for this value.

Generator adaptor to support iteration for SBValue as a linked list.

linked_list_iter() is a special purpose iterator to treat the SBValue as
the head of a list data structure, where you specify the child member
name which points to the next item on the list and you specify the
end-of-list test function which takes an SBValue for an item and returns
True if EOL is reached and False if not.

linked_list_iter() also detects infinite loop and bails out early.

The end_of_list_test arg, if omitted, defaults to the __eol_test
function above.

For example,

# Get Frame #0.
...

# Get variable 'task_head'.
task_head = frame0.FindVariable('task_head')
...

for t in task_head.linked_list_iter('next'):
    print t