bindings/interface/SBFrameDocstrings.i

%feature("docstring",
"Represents one of the stack frames associated with a thread.

SBThread contains SBFrame(s). For example (from test/lldbutil.py), ::

    def print_stacktrace(thread, string_buffer = False):
        '''Prints a simple stack trace of this thread.'''

        ...

        for i in range(depth):
            frame = thread.GetFrameAtIndex(i)
            function = frame.GetFunction()

            load_addr = addrs[i].GetLoadAddress(target)
            if not function:
                file_addr = addrs[i].GetFileAddress()
                start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress()
                symbol_offset = file_addr - start_addr
                print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
                    num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset)
            else:
                print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
                    num=i, addr=load_addr, mod=mods[i],
                    func='%s [inlined]' % funcs[i] if frame.IsInlined() else funcs[i],
                    file=files[i], line=lines[i],
                    args=get_args_as_string(frame, showFuncName=False) if not frame.IsInlined() else '()')

        ...

And, ::

    for frame in thread:
        print frame

See also SBThread."
) lldb::SBFrame;

%feature("docstring", "
    Get the Canonical Frame Address for this stack frame.
    This is the DWARF standard's definition of a CFA, a stack address
    that remains constant throughout the lifetime of the function.
    Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if
    the CFA cannot be determined."
) lldb::SBFrame::GetCFA;

%feature("docstring", "
    Gets the deepest block that contains the frame PC.

    See also GetFrameBlock()."
) lldb::SBFrame::GetBlock;

    %feature("docstring", "
    Get the appropriate function name for this frame. Inlined functions in
    LLDB are represented by Blocks that have inlined function information, so
    just looking at the SBFunction or SBSymbol for a frame isn't enough.
    This function will return the appropriate function, symbol or inlined
    function name for the frame.

    This function returns:
    - the name of the inlined function (if there is one)
    - the name of the concrete function (if there is one)
    - the name of the symbol (if there is one)
    - NULL

    See also IsInlined()."
) lldb::SBFrame::GetFunctionName;

%feature("docstring", "
    Returns the language of the frame's SBFunction, or if there.
    is no SBFunction, guess the language from the mangled name.
    ."
) lldb::SBFrame::GuessLanguage;

%feature("docstring", "
    Return true if this frame represents an inlined function.

    See also GetFunctionName()."
) lldb::SBFrame::IsInlined;

%feature("docstring", "
    Return true if this frame is artificial (e.g a frame synthesized to
    capture a tail call). Local variables may not be available in an artificial
    frame."
) lldb::SBFrame::IsArtificial;

%feature("docstring", "
    The version that doesn't supply a 'use_dynamic' value will use the
    target's default."
) lldb::SBFrame::EvaluateExpression;

%feature("docstring", "
    Gets the lexical block that defines the stack frame. Another way to think
    of this is it will return the block that contains all of the variables
    for a stack frame. Inlined functions are represented as SBBlock objects
    that have inlined function information: the name of the inlined function,
    where it was called from. The block that is returned will be the first
    block at or above the block for the PC (SBFrame::GetBlock()) that defines
    the scope of the frame. When a function contains no inlined functions,
    this will be the top most lexical block that defines the function.
    When a function has inlined functions and the PC is currently
    in one of those inlined functions, this method will return the inlined
    block that defines this frame. If the PC isn't currently in an inlined
    function, the lexical block that defines the function is returned."
) lldb::SBFrame::GetFrameBlock;

%feature("docstring", "
    The version that doesn't supply a 'use_dynamic' value will use the
    target's default."
) lldb::SBFrame::GetVariables;

%feature("docstring", "
    The version that doesn't supply a 'use_dynamic' value will use the
    target's default."
) lldb::SBFrame::FindVariable;

%feature("docstring", "
    Get a lldb.SBValue for a variable path.

    Variable paths can include access to pointer or instance members: ::

        rect_ptr->origin.y
        pt.x

    Pointer dereferences: ::

        *this->foo_ptr
        **argv

    Address of: ::

        &pt
        &my_array[3].x

    Array accesses and treating pointers as arrays: ::

        int_array[1]
        pt_ptr[22].x

    Unlike `EvaluateExpression()` which returns :py:class:`SBValue` objects
    with constant copies of the values at the time of evaluation,
    the result of this function is a value that will continue to
    track the current value of the value as execution progresses
    in the current frame."
) lldb::SBFrame::GetValueForVariablePath;

%feature("docstring", "
    Find variables, register sets, registers, or persistent variables using
    the frame as the scope.

    The version that doesn't supply a ``use_dynamic`` value will use the
    target's default."
) lldb::SBFrame::FindValue;