Module _lldb'

[frames] | no frames]

Module _lldb'

Functions

[hide private]

SBAddress_Clear(...)
SBAddress_Clear(SBAddress self)

SBAddress_GetAddressClass(...)
SBAddress_GetAddressClass(SBAddress self) -> lldb::AddressClass

SBAddress_GetBlock(...)
SBAddress_GetBlock(SBAddress self) -> SBBlock

SBAddress_GetCompileUnit(...)
SBAddress_GetCompileUnit(SBAddress self) -> SBCompileUnit

SBAddress_GetDescription(...)
SBAddress_GetDescription(SBAddress self, SBStream description) -> bool

SBAddress_GetFileAddress(...)
SBAddress_GetFileAddress(SBAddress self) -> lldb::addr_t

SBAddress_GetFunction(...)
SBAddress_GetFunction(SBAddress self) -> SBFunction

SBAddress_GetLineEntry(...)
SBAddress_GetLineEntry(SBAddress self) -> SBLineEntry

SBAddress_GetLoadAddress(...)
SBAddress_GetLoadAddress(SBAddress self, SBTarget target) -> lldb::addr_t

SBAddress_GetModule(...)
SBAddress_GetModule(SBAddress self) -> SBModule

SBAddress_GetOffset(...)
SBAddress_GetOffset(SBAddress self) -> lldb::addr_t

SBAddress_GetSection(...)
SBAddress_GetSection(SBAddress self) -> SBSection

SBAddress_GetSymbol(...)
SBAddress_GetSymbol(SBAddress self) -> SBSymbol

SBAddress_GetSymbolContext(...)
SBAddress_GetSymbolContext(SBAddress self, uint32_t resolve_scope) -> SBSymbolContext

SBAddress_IsValid(...)
SBAddress_IsValid(SBAddress self) -> bool

SBAddress_OffsetAddress(...)
SBAddress_OffsetAddress(SBAddress self, lldb::addr_t offset) -> bool

SBAddress_SetAddress(...)
SBAddress_SetAddress(SBAddress self, SBSection section, lldb::addr_t offset)

SBAddress_SetLoadAddress(...)
SBAddress_SetLoadAddress(SBAddress self, lldb::addr_t load_addr, SBTarget target)

SBAddress___str__(...)
SBAddress___str__(SBAddress self) -> PyObject *

SBAddress_swigregister(...)

SBAttachInfo_EffectiveGroupIDIsValid(...)
SBAttachInfo_EffectiveGroupIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_EffectiveUserIDIsValid(...)
SBAttachInfo_EffectiveUserIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_GetEffectiveGroupID(...)
SBAttachInfo_GetEffectiveGroupID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetEffectiveUserID(...)
SBAttachInfo_GetEffectiveUserID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetGroupID(...)
SBAttachInfo_GetGroupID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetIgnoreExisting(...)
SBAttachInfo_GetIgnoreExisting(SBAttachInfo self) -> bool

SBAttachInfo_GetListener(...)
SBAttachInfo_GetListener(SBAttachInfo self) -> SBListener

SBAttachInfo_GetParentProcessID(...)
SBAttachInfo_GetParentProcessID(SBAttachInfo self) -> lldb::pid_t

SBAttachInfo_GetProcessID(...)
SBAttachInfo_GetProcessID(SBAttachInfo self) -> lldb::pid_t

SBAttachInfo_GetProcessPluginName(...)
SBAttachInfo_GetProcessPluginName(SBAttachInfo self) -> char const *

SBAttachInfo_GetResumeCount(...)
SBAttachInfo_GetResumeCount(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetUserID(...)
SBAttachInfo_GetUserID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetWaitForLaunch(...)
SBAttachInfo_GetWaitForLaunch(SBAttachInfo self) -> bool

SBAttachInfo_GroupIDIsValid(...)
SBAttachInfo_GroupIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_ParentProcessIDIsValid(...)
SBAttachInfo_ParentProcessIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_SetEffectiveGroupID(...)
SBAttachInfo_SetEffectiveGroupID(SBAttachInfo self, uint32_t gid)

SBAttachInfo_SetEffectiveUserID(...)
SBAttachInfo_SetEffectiveUserID(SBAttachInfo self, uint32_t uid)

SBAttachInfo_SetExecutable(...)
SetExecutable(char const * path) SBAttachInfo_SetExecutable(SBAttachInfo self, SBFileSpec exe_file)

SBAttachInfo_SetGroupID(...)
SBAttachInfo_SetGroupID(SBAttachInfo self, uint32_t gid)

SBAttachInfo_SetIgnoreExisting(...)
SBAttachInfo_SetIgnoreExisting(SBAttachInfo self, bool b)

SBAttachInfo_SetListener(...)
SBAttachInfo_SetListener(SBAttachInfo self, SBListener listener)

SBAttachInfo_SetParentProcessID(...)
SBAttachInfo_SetParentProcessID(SBAttachInfo self, lldb::pid_t pid)

SBAttachInfo_SetProcessID(...)
SBAttachInfo_SetProcessID(SBAttachInfo self, lldb::pid_t pid)

SBAttachInfo_SetProcessPluginName(...)
SBAttachInfo_SetProcessPluginName(SBAttachInfo self, char const * plugin_name)

SBAttachInfo_SetResumeCount(...)
SBAttachInfo_SetResumeCount(SBAttachInfo self, uint32_t c)

SBAttachInfo_SetUserID(...)
SBAttachInfo_SetUserID(SBAttachInfo self, uint32_t uid)

SBAttachInfo_SetWaitForLaunch(...)
SetWaitForLaunch(bool b) SBAttachInfo_SetWaitForLaunch(SBAttachInfo self, bool b, bool async)

SBAttachInfo_UserIDIsValid(...)
SBAttachInfo_UserIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_swigregister(...)

SBBlock_GetContainingInlinedBlock(...)
SBBlock_GetContainingInlinedBlock(SBBlock self) -> SBBlock

SBBlock_GetDescription(...)
SBBlock_GetDescription(SBBlock self, SBStream description) -> bool

SBBlock_GetFirstChild(...)
SBBlock_GetFirstChild(SBBlock self) -> SBBlock

SBBlock_GetInlinedCallSiteColumn(...)
SBBlock_GetInlinedCallSiteColumn(SBBlock self) -> uint32_t

SBBlock_GetInlinedCallSiteFile(...)
SBBlock_GetInlinedCallSiteFile(SBBlock self) -> SBFileSpec

SBBlock_GetInlinedCallSiteLine(...)
SBBlock_GetInlinedCallSiteLine(SBBlock self) -> uint32_t

SBBlock_GetInlinedName(...)
SBBlock_GetInlinedName(SBBlock self) -> char const *

SBBlock_GetNumRanges(...)
SBBlock_GetNumRanges(SBBlock self) -> uint32_t

SBBlock_GetParent(...)
SBBlock_GetParent(SBBlock self) -> SBBlock

SBBlock_GetRangeEndAddress(...)
SBBlock_GetRangeEndAddress(SBBlock self, uint32_t idx) -> SBAddress

SBBlock_GetRangeIndexForBlockAddress(...)
SBBlock_GetRangeIndexForBlockAddress(SBBlock self, SBAddress block_addr) -> uint32_t

SBBlock_GetRangeStartAddress(...)
SBBlock_GetRangeStartAddress(SBBlock self, uint32_t idx) -> SBAddress

SBBlock_GetSibling(...)
SBBlock_GetSibling(SBBlock self) -> SBBlock

SBBlock_GetVariables(...)
GetVariables(SBFrame frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) -> SBValueList SBBlock_GetVariables(SBBlock self, SBTarget target, bool arguments, bool locals, bool statics) -> SBValueList

SBBlock_IsInlined(...)
SBBlock_IsInlined(SBBlock self) -> bool

SBBlock_IsValid(...)
SBBlock_IsValid(SBBlock self) -> bool

SBBlock___str__(...)
SBBlock___str__(SBBlock self) -> PyObject *

SBBlock_swigregister(...)

SBBreakpointList_Append(...)
SBBreakpointList_Append(SBBreakpointList self, SBBreakpoint sb_bkpt)

SBBreakpointList_AppendByID(...)
SBBreakpointList_AppendByID(SBBreakpointList self, lldb::break_id_t id)

SBBreakpointList_AppendIfUnique(...)
SBBreakpointList_AppendIfUnique(SBBreakpointList self, SBBreakpoint sb_bkpt) -> bool

SBBreakpointList_Clear(...)
SBBreakpointList_Clear(SBBreakpointList self)

SBBreakpointList_FindBreakpointByID(...)
SBBreakpointList_FindBreakpointByID(SBBreakpointList self, lldb::break_id_t arg2) -> SBBreakpoint

SBBreakpointList_GetBreakpointAtIndex(...)
SBBreakpointList_GetBreakpointAtIndex(SBBreakpointList self, size_t idx) -> SBBreakpoint

SBBreakpointList_GetSize(...)
SBBreakpointList_GetSize(SBBreakpointList self) -> size_t

SBBreakpointList_swigregister(...)

SBBreakpointLocation_GetAddress(...)
SBBreakpointLocation_GetAddress(SBBreakpointLocation self) -> SBAddress

SBBreakpointLocation_GetBreakpoint(...)
SBBreakpointLocation_GetBreakpoint(SBBreakpointLocation self) -> SBBreakpoint

SBBreakpointLocation_GetCondition(...)
SBBreakpointLocation_GetCondition(SBBreakpointLocation self) -> char const *

SBBreakpointLocation_GetDescription(...)
SBBreakpointLocation_GetDescription(SBBreakpointLocation self, SBStream description, lldb::DescriptionLevel level) -> bool

SBBreakpointLocation_GetID(...)
SBBreakpointLocation_GetID(SBBreakpointLocation self) -> lldb::break_id_t

SBBreakpointLocation_GetIgnoreCount(...)
SBBreakpointLocation_GetIgnoreCount(SBBreakpointLocation self) -> uint32_t

SBBreakpointLocation_GetLoadAddress(...)
SBBreakpointLocation_GetLoadAddress(SBBreakpointLocation self) -> lldb::addr_t

SBBreakpointLocation_GetQueueName(...)
SBBreakpointLocation_GetQueueName(SBBreakpointLocation self) -> char const *

SBBreakpointLocation_GetThreadID(...)
SBBreakpointLocation_GetThreadID(SBBreakpointLocation self) -> lldb::tid_t

SBBreakpointLocation_GetThreadIndex(...)
SBBreakpointLocation_GetThreadIndex(SBBreakpointLocation self) -> uint32_t

SBBreakpointLocation_GetThreadName(...)
SBBreakpointLocation_GetThreadName(SBBreakpointLocation self) -> char const *

SBBreakpointLocation_IsEnabled(...)
SBBreakpointLocation_IsEnabled(SBBreakpointLocation self) -> bool

SBBreakpointLocation_IsResolved(...)
SBBreakpointLocation_IsResolved(SBBreakpointLocation self) -> bool

SBBreakpointLocation_IsValid(...)
SBBreakpointLocation_IsValid(SBBreakpointLocation self) -> bool

SBBreakpointLocation_SetCondition(...)
SBBreakpointLocation_SetCondition(SBBreakpointLocation self, char const * condition)

SBBreakpointLocation_SetEnabled(...)
SBBreakpointLocation_SetEnabled(SBBreakpointLocation self, bool enabled)

SBBreakpointLocation_SetIgnoreCount(...)
SBBreakpointLocation_SetIgnoreCount(SBBreakpointLocation self, uint32_t n)

SBBreakpointLocation_SetQueueName(...)
SBBreakpointLocation_SetQueueName(SBBreakpointLocation self, char const * queue_name)

SBBreakpointLocation_SetScriptCallbackBody(...)
SBBreakpointLocation_SetScriptCallbackBody(SBBreakpointLocation self, char const * script_body_text) -> SBError

SBBreakpointLocation_SetScriptCallbackFunction(...)
SBBreakpointLocation_SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name)

SBBreakpointLocation_SetThreadID(...)
SBBreakpointLocation_SetThreadID(SBBreakpointLocation self, lldb::tid_t sb_thread_id)

SBBreakpointLocation_SetThreadIndex(...)
SBBreakpointLocation_SetThreadIndex(SBBreakpointLocation self, uint32_t index)

SBBreakpointLocation_SetThreadName(...)
SBBreakpointLocation_SetThreadName(SBBreakpointLocation self, char const * thread_name)

SBBreakpointLocation___str__(...)
SBBreakpointLocation___str__(SBBreakpointLocation self) -> PyObject *

SBBreakpointLocation_swigregister(...)

SBBreakpoint_AddName(...)
SBBreakpoint_AddName(SBBreakpoint self, char const * new_name) -> bool

SBBreakpoint_ClearAllBreakpointSites(...)
SBBreakpoint_ClearAllBreakpointSites(SBBreakpoint self)

SBBreakpoint_EventIsBreakpointEvent(...)
SBBreakpoint_EventIsBreakpointEvent(SBEvent event) -> bool

SBBreakpoint_FindLocationByAddress(...)
SBBreakpoint_FindLocationByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> SBBreakpointLocation

SBBreakpoint_FindLocationByID(...)
SBBreakpoint_FindLocationByID(SBBreakpoint self, lldb::break_id_t bp_loc_id) -> SBBreakpointLocation

SBBreakpoint_FindLocationIDByAddress(...)
SBBreakpoint_FindLocationIDByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> lldb::break_id_t

SBBreakpoint_GetBreakpointEventTypeFromEvent(...)
SBBreakpoint_GetBreakpointEventTypeFromEvent(SBEvent event) -> lldb::BreakpointEventType

SBBreakpoint_GetBreakpointFromEvent(...)
SBBreakpoint_GetBreakpointFromEvent(SBEvent event) -> SBBreakpoint

SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(...)
SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(SBEvent event, uint32_t loc_idx) -> SBBreakpointLocation

SBBreakpoint_GetCommandLineCommands(...)
SBBreakpoint_GetCommandLineCommands(SBBreakpoint self, SBStringList commands) -> bool

SBBreakpoint_GetCondition(...)
SBBreakpoint_GetCondition(SBBreakpoint self) -> char const *

SBBreakpoint_GetDescription(...)
GetDescription(SBStream description) -> bool SBBreakpoint_GetDescription(SBBreakpoint self, SBStream description, bool include_locations) -> bool

SBBreakpoint_GetHitCount(...)
SBBreakpoint_GetHitCount(SBBreakpoint self) -> uint32_t

SBBreakpoint_GetID(...)
SBBreakpoint_GetID(SBBreakpoint self) -> lldb::break_id_t

SBBreakpoint_GetIgnoreCount(...)
SBBreakpoint_GetIgnoreCount(SBBreakpoint self) -> uint32_t

SBBreakpoint_GetLocationAtIndex(...)
SBBreakpoint_GetLocationAtIndex(SBBreakpoint self, uint32_t index) -> SBBreakpointLocation

SBBreakpoint_GetNames(...)
SBBreakpoint_GetNames(SBBreakpoint self, SBStringList names)

SBBreakpoint_GetNumBreakpointLocationsFromEvent(...)
SBBreakpoint_GetNumBreakpointLocationsFromEvent(SBEvent event_sp) -> uint32_t

SBBreakpoint_GetNumLocations(...)
SBBreakpoint_GetNumLocations(SBBreakpoint self) -> size_t

SBBreakpoint_GetNumResolvedLocations(...)
SBBreakpoint_GetNumResolvedLocations(SBBreakpoint self) -> size_t

SBBreakpoint_GetQueueName(...)
SBBreakpoint_GetQueueName(SBBreakpoint self) -> char const *

SBBreakpoint_GetThreadID(...)
SBBreakpoint_GetThreadID(SBBreakpoint self) -> lldb::tid_t

SBBreakpoint_GetThreadIndex(...)
SBBreakpoint_GetThreadIndex(SBBreakpoint self) -> uint32_t

SBBreakpoint_GetThreadName(...)
SBBreakpoint_GetThreadName(SBBreakpoint self) -> char const *

SBBreakpoint_IsEnabled(...)
SBBreakpoint_IsEnabled(SBBreakpoint self) -> bool

SBBreakpoint_IsInternal(...)
SBBreakpoint_IsInternal(SBBreakpoint self) -> bool

SBBreakpoint_IsOneShot(...)
SBBreakpoint_IsOneShot(SBBreakpoint self) -> bool

SBBreakpoint_IsValid(...)
SBBreakpoint_IsValid(SBBreakpoint self) -> bool

SBBreakpoint_MatchesName(...)
SBBreakpoint_MatchesName(SBBreakpoint self, char const * name) -> bool

SBBreakpoint_RemoveName(...)
SBBreakpoint_RemoveName(SBBreakpoint self, char const * name_to_remove)

SBBreakpoint_SetCommandLineCommands(...)
SBBreakpoint_SetCommandLineCommands(SBBreakpoint self, SBStringList commands)

SBBreakpoint_SetCondition(...)
SBBreakpoint_SetCondition(SBBreakpoint self, char const * condition)

SBBreakpoint_SetEnabled(...)
SBBreakpoint_SetEnabled(SBBreakpoint self, bool enable)

SBBreakpoint_SetIgnoreCount(...)
SBBreakpoint_SetIgnoreCount(SBBreakpoint self, uint32_t count)

SBBreakpoint_SetOneShot(...)
SBBreakpoint_SetOneShot(SBBreakpoint self, bool one_shot)

SBBreakpoint_SetQueueName(...)
SBBreakpoint_SetQueueName(SBBreakpoint self, char const * queue_name)

SBBreakpoint_SetScriptCallbackBody(...)
SBBreakpoint_SetScriptCallbackBody(SBBreakpoint self, char const * script_body_text) -> SBError

SBBreakpoint_SetScriptCallbackFunction(...)
SBBreakpoint_SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name)

SBBreakpoint_SetThreadID(...)
SBBreakpoint_SetThreadID(SBBreakpoint self, lldb::tid_t sb_thread_id)

SBBreakpoint_SetThreadIndex(...)
SBBreakpoint_SetThreadIndex(SBBreakpoint self, uint32_t index)

SBBreakpoint_SetThreadName(...)
SBBreakpoint_SetThreadName(SBBreakpoint self, char const * thread_name)

SBBreakpoint___eq__(...)
SBBreakpoint___eq__(SBBreakpoint self, SBBreakpoint rhs) -> bool

SBBreakpoint___ne__(...)
SBBreakpoint___ne__(SBBreakpoint self, SBBreakpoint rhs) -> bool

SBBreakpoint___str__(...)
SBBreakpoint___str__(SBBreakpoint self) -> PyObject *

SBBreakpoint_swigregister(...)

SBBroadcaster_AddInitialEventsToListener(...)
SBBroadcaster_AddInitialEventsToListener(SBBroadcaster self, SBListener listener, uint32_t requested_events)

SBBroadcaster_AddListener(...)
SBBroadcaster_AddListener(SBBroadcaster self, SBListener listener, uint32_t event_mask) -> uint32_t

SBBroadcaster_BroadcastEvent(...)
BroadcastEvent(SBEvent event, bool unique=False) SBBroadcaster_BroadcastEvent(SBBroadcaster self, SBEvent event)

SBBroadcaster_BroadcastEventByType(...)
BroadcastEventByType(uint32_t event_type, bool unique=False) SBBroadcaster_BroadcastEventByType(SBBroadcaster self, uint32_t event_type)

SBBroadcaster_Clear(...)
SBBroadcaster_Clear(SBBroadcaster self)

SBBroadcaster_EventTypeHasListeners(...)
SBBroadcaster_EventTypeHasListeners(SBBroadcaster self, uint32_t event_type) -> bool

SBBroadcaster_GetName(...)
SBBroadcaster_GetName(SBBroadcaster self) -> char const *

SBBroadcaster_IsValid(...)
SBBroadcaster_IsValid(SBBroadcaster self) -> bool

SBBroadcaster_RemoveListener(...)
RemoveListener(SBListener listener, uint32_t event_mask=4294967295U) -> bool SBBroadcaster_RemoveListener(SBBroadcaster self, SBListener listener) -> bool

SBBroadcaster___eq__(...)
SBBroadcaster___eq__(SBBroadcaster self, SBBroadcaster rhs) -> bool

SBBroadcaster___ne__(...)
SBBroadcaster___ne__(SBBroadcaster self, SBBroadcaster rhs) -> bool

SBBroadcaster_swigregister(...)

SBCommandInterpreterRunOptions_GetAddToHistory(...)
SBCommandInterpreterRunOptions_GetAddToHistory(SBCommandInterpreterRunOptions self) -> bool

SBCommandInterpreterRunOptions_GetEchoCommands(...)
SBCommandInterpreterRunOptions_GetEchoCommands(SBCommandInterpreterRunOptions self) -> bool

SBCommandInterpreterRunOptions_GetPrintResults(...)
SBCommandInterpreterRunOptions_GetPrintResults(SBCommandInterpreterRunOptions self) -> bool

SBCommandInterpreterRunOptions_GetStopOnContinue(...)
SBCommandInterpreterRunOptions_GetStopOnContinue(SBCommandInterpreterRunOptions self) -> bool

SBCommandInterpreterRunOptions_GetStopOnCrash(...)
SBCommandInterpreterRunOptions_GetStopOnCrash(SBCommandInterpreterRunOptions self) -> bool

SBCommandInterpreterRunOptions_GetStopOnError(...)
SBCommandInterpreterRunOptions_GetStopOnError(SBCommandInterpreterRunOptions self) -> bool

SBCommandInterpreterRunOptions_SetAddToHistory(...)
SBCommandInterpreterRunOptions_SetAddToHistory(SBCommandInterpreterRunOptions self, bool arg2)

SBCommandInterpreterRunOptions_SetEchoCommands(...)
SBCommandInterpreterRunOptions_SetEchoCommands(SBCommandInterpreterRunOptions self, bool arg2)

SBCommandInterpreterRunOptions_SetPrintResults(...)
SBCommandInterpreterRunOptions_SetPrintResults(SBCommandInterpreterRunOptions self, bool arg2)

SBCommandInterpreterRunOptions_SetStopOnContinue(...)
SBCommandInterpreterRunOptions_SetStopOnContinue(SBCommandInterpreterRunOptions self, bool arg2)

SBCommandInterpreterRunOptions_SetStopOnCrash(...)
SBCommandInterpreterRunOptions_SetStopOnCrash(SBCommandInterpreterRunOptions self, bool arg2)

SBCommandInterpreterRunOptions_SetStopOnError(...)
SBCommandInterpreterRunOptions_SetStopOnError(SBCommandInterpreterRunOptions self, bool arg2)

SBCommandInterpreterRunOptions_swigregister(...)

SBCommandInterpreter_AliasExists(...)
SBCommandInterpreter_AliasExists(SBCommandInterpreter self, char const * cmd) -> bool

SBCommandInterpreter_CommandExists(...)
SBCommandInterpreter_CommandExists(SBCommandInterpreter self, char const * cmd) -> bool

SBCommandInterpreter_EventIsCommandInterpreterEvent(...)
SBCommandInterpreter_EventIsCommandInterpreterEvent(SBEvent event) -> bool

SBCommandInterpreter_GetArgumentDescriptionAsCString(...)
SBCommandInterpreter_GetArgumentDescriptionAsCString(lldb::CommandArgumentType const arg_type) -> char const *

SBCommandInterpreter_GetArgumentTypeAsCString(...)
SBCommandInterpreter_GetArgumentTypeAsCString(lldb::CommandArgumentType const arg_type) -> char const *

SBCommandInterpreter_GetBroadcaster(...)
SBCommandInterpreter_GetBroadcaster(SBCommandInterpreter self) -> SBBroadcaster

char const *

SBCommandInterpreter_GetBroadcasterClass()

SBCommandInterpreter_GetDebugger(...)
SBCommandInterpreter_GetDebugger(SBCommandInterpreter self) -> SBDebugger

SBCommandInterpreter_GetIOHandlerControlSequence(...)
SBCommandInterpreter_GetIOHandlerControlSequence(SBCommandInterpreter self, char ch) -> char const *

SBCommandInterpreter_GetProcess(...)
SBCommandInterpreter_GetProcess(SBCommandInterpreter self) -> SBProcess

SBCommandInterpreter_GetPromptOnQuit(...)
SBCommandInterpreter_GetPromptOnQuit(SBCommandInterpreter self) -> bool

SBCommandInterpreter_HandleCommand(...)
HandleCommand(char const * command_line, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus...

SBCommandInterpreter_HandleCommandsFromFile(...)
SBCommandInterpreter_HandleCommandsFromFile(SBCommandInterpreter self, SBFileSpec file, SBExecutionContext override_context, ...

SBCommandInterpreter_HandleCompletion(...)
SBCommandInterpreter_HandleCompletion(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, ...

SBCommandInterpreter_HasAliasOptions(...)
SBCommandInterpreter_HasAliasOptions(SBCommandInterpreter self) -> bool

SBCommandInterpreter_HasAliases(...)
SBCommandInterpreter_HasAliases(SBCommandInterpreter self) -> bool

SBCommandInterpreter_HasCommands(...)
SBCommandInterpreter_HasCommands(SBCommandInterpreter self) -> bool

SBCommandInterpreter_IsActive(...)
SBCommandInterpreter_IsActive(SBCommandInterpreter self) -> bool

SBCommandInterpreter_IsValid(...)
SBCommandInterpreter_IsValid(SBCommandInterpreter self) -> bool

SBCommandInterpreter_ResolveCommand(...)
SBCommandInterpreter_ResolveCommand(SBCommandInterpreter self, char const * command_line, SBCommandReturnObject result)

SBCommandInterpreter_SetPromptOnQuit(...)
SBCommandInterpreter_SetPromptOnQuit(SBCommandInterpreter self, bool b)

SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(...)
SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(SBCommandInterpreter self, SBCommandReturnObject result)

SBCommandInterpreter_SourceInitFileInHomeDirectory(...)
SBCommandInterpreter_SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result)

SBCommandInterpreter_swigregister(...)

SBCommandReturnObject_AppendMessage(...)
SBCommandReturnObject_AppendMessage(SBCommandReturnObject self, char const * message)

SBCommandReturnObject_AppendWarning(...)
SBCommandReturnObject_AppendWarning(SBCommandReturnObject self, char const * message)

SBCommandReturnObject_Clear(...)
SBCommandReturnObject_Clear(SBCommandReturnObject self)

SBCommandReturnObject_GetDescription(...)
SBCommandReturnObject_GetDescription(SBCommandReturnObject self, SBStream description) -> bool

char const

SBCommandReturnObject_GetError()
SBCommandReturnObject_GetError(SBCommandReturnObject self, bool if_no_immediate) -> char const *

SBCommandReturnObject_GetErrorSize(...)
SBCommandReturnObject_GetErrorSize(SBCommandReturnObject self) -> size_t

char const

SBCommandReturnObject_GetOutput()
SBCommandReturnObject_GetOutput(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *

SBCommandReturnObject_GetOutputSize(...)
SBCommandReturnObject_GetOutputSize(SBCommandReturnObject self) -> size_t

SBCommandReturnObject_GetStatus(...)
SBCommandReturnObject_GetStatus(SBCommandReturnObject self) -> lldb::ReturnStatus

SBCommandReturnObject_HasResult(...)
SBCommandReturnObject_HasResult(SBCommandReturnObject self) -> bool

SBCommandReturnObject_IsValid(...)
SBCommandReturnObject_IsValid(SBCommandReturnObject self) -> bool

SBCommandReturnObject_Print(...)
SBCommandReturnObject_Print(SBCommandReturnObject self, char const * str)

SBCommandReturnObject_PutCString(...)
SBCommandReturnObject_PutCString(SBCommandReturnObject self, char const * string)

SBCommandReturnObject_PutError(...)
SBCommandReturnObject_PutError(SBCommandReturnObject self, FILE * fh) -> size_t

SBCommandReturnObject_PutOutput(...)
SBCommandReturnObject_PutOutput(SBCommandReturnObject self, FILE * fh) -> size_t

SBCommandReturnObject_SetError(...)
SetError(SBError error, char const * fallback_error_cstr=None) SetError(SBError error) SBCommandReturnObject_SetError(SBCommandReturnObject self, char const * error_cstr)

SBCommandReturnObject_SetImmediateErrorFile(...)
SBCommandReturnObject_SetImmediateErrorFile(SBCommandReturnObject self, FILE * fh)

SBCommandReturnObject_SetImmediateOutputFile(...)
SBCommandReturnObject_SetImmediateOutputFile(SBCommandReturnObject self, FILE * fh)

SBCommandReturnObject_SetStatus(...)
SBCommandReturnObject_SetStatus(SBCommandReturnObject self, lldb::ReturnStatus status)

SBCommandReturnObject_Succeeded(...)
SBCommandReturnObject_Succeeded(SBCommandReturnObject self) -> bool

SBCommandReturnObject___str__(...)
SBCommandReturnObject___str__(SBCommandReturnObject self) -> PyObject *

SBCommandReturnObject_flush(...)
SBCommandReturnObject_flush(SBCommandReturnObject self)

SBCommandReturnObject_swigregister(...)

SBCommandReturnObject_write(...)
SBCommandReturnObject_write(SBCommandReturnObject self, char const * str)

SBCommunication_AdoptFileDesriptor(...)
SBCommunication_AdoptFileDesriptor(SBCommunication self, int fd, bool owns_fd) -> lldb::ConnectionStatus

SBCommunication_Connect(...)
SBCommunication_Connect(SBCommunication self, char const * url) -> lldb::ConnectionStatus

SBCommunication_Disconnect(...)
SBCommunication_Disconnect(SBCommunication self) -> lldb::ConnectionStatus

SBCommunication_GetBroadcaster(...)
SBCommunication_GetBroadcaster(SBCommunication self) -> SBBroadcaster

char const *

SBCommunication_GetBroadcasterClass()

SBCommunication_GetCloseOnEOF(...)
SBCommunication_GetCloseOnEOF(SBCommunication self) -> bool

SBCommunication_IsConnected(...)
SBCommunication_IsConnected(SBCommunication self) -> bool

SBCommunication_IsValid(...)
SBCommunication_IsValid(SBCommunication self) -> bool

SBCommunication_Read(...)
SBCommunication_Read(SBCommunication self, void * dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus & status) -> size_t

SBCommunication_ReadThreadIsRunning(...)
SBCommunication_ReadThreadIsRunning(SBCommunication self) -> bool

SBCommunication_ReadThreadStart(...)
SBCommunication_ReadThreadStart(SBCommunication self) -> bool

SBCommunication_ReadThreadStop(...)
SBCommunication_ReadThreadStop(SBCommunication self) -> bool

SBCommunication_SetCloseOnEOF(...)
SBCommunication_SetCloseOnEOF(SBCommunication self, bool b)

SBCommunication_SetReadThreadBytesReceivedCallback(...)
SBCommunication_SetReadThreadBytesReceivedCallback(SBCommunication self, lldb::SBCommunication::ReadThreadBytesReceived callback, void * callback_baton) -> bool

SBCommunication_Write(...)
SBCommunication_Write(SBCommunication self, void const * src, size_t src_len, lldb::ConnectionStatus & status) -> size_t

SBCommunication_swigregister(...)

SBCompileUnit_FindLineEntryIndex(...)
FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec) -> uint32_t...

SBCompileUnit_FindSupportFileIndex(...)
SBCompileUnit_FindSupportFileIndex(SBCompileUnit self, uint32_t start_idx, SBFileSpec sb_file, bool full) -> uint32_t

SBCompileUnit_GetDescription(...)
SBCompileUnit_GetDescription(SBCompileUnit self, SBStream description) -> bool

SBCompileUnit_GetFileSpec(...)
SBCompileUnit_GetFileSpec(SBCompileUnit self) -> SBFileSpec

SBCompileUnit_GetLanguage(...)
SBCompileUnit_GetLanguage(SBCompileUnit self) -> lldb::LanguageType

SBCompileUnit_GetLineEntryAtIndex(...)
SBCompileUnit_GetLineEntryAtIndex(SBCompileUnit self, uint32_t idx) -> SBLineEntry

SBCompileUnit_GetNumLineEntries(...)
SBCompileUnit_GetNumLineEntries(SBCompileUnit self) -> uint32_t

SBCompileUnit_GetNumSupportFiles(...)
SBCompileUnit_GetNumSupportFiles(SBCompileUnit self) -> uint32_t

SBCompileUnit_GetSupportFileAtIndex(...)
SBCompileUnit_GetSupportFileAtIndex(SBCompileUnit self, uint32_t idx) -> SBFileSpec

SBCompileUnit_GetTypes(...)
GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBCompileUnit_GetTypes(SBCompileUnit self) -> SBTypeList

SBCompileUnit_IsValid(...)
SBCompileUnit_IsValid(SBCompileUnit self) -> bool

SBCompileUnit___eq__(...)
SBCompileUnit___eq__(SBCompileUnit self, SBCompileUnit rhs) -> bool

SBCompileUnit___ne__(...)
SBCompileUnit___ne__(SBCompileUnit self, SBCompileUnit rhs) -> bool

SBCompileUnit___str__(...)
SBCompileUnit___str__(SBCompileUnit self) -> PyObject *

SBCompileUnit_swigregister(...)

SBData_Append(...)
SBData_Append(SBData self, SBData rhs) -> bool

SBData_Clear(...)
SBData_Clear(SBData self)

SBData_CreateDataFromCString(...)
SBData_CreateDataFromCString(lldb::ByteOrder endian, uint32_t addr_byte_size, char const * data) -> SBData

SBData_CreateDataFromDoubleArray(...)
SBData_CreateDataFromDoubleArray(lldb::ByteOrder endian, uint32_t addr_byte_size, double * array) -> SBData

SBData_CreateDataFromSInt32Array(...)
SBData_CreateDataFromSInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t * array) -> SBData

SBData_CreateDataFromSInt64Array(...)
SBData_CreateDataFromSInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t * array) -> SBData

SBData_CreateDataFromUInt32Array(...)
SBData_CreateDataFromUInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t * array) -> SBData

SBData_CreateDataFromUInt64Array(...)
SBData_CreateDataFromUInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t * array) -> SBData

SBData_GetAddress(...)
SBData_GetAddress(SBData self, SBError error, lldb::offset_t offset) -> lldb::addr_t

SBData_GetAddressByteSize(...)
SBData_GetAddressByteSize(SBData self) -> uint8_t

SBData_GetByteOrder(...)
SBData_GetByteOrder(SBData self) -> lldb::ByteOrder

SBData_GetByteSize(...)
SBData_GetByteSize(SBData self) -> size_t

SBData_GetDescription(...)
SBData_GetDescription(SBData self, SBStream description, lldb::addr_t base_addr) -> bool

SBData_GetDouble(...)
SBData_GetDouble(SBData self, SBError error, lldb::offset_t offset) -> double

SBData_GetFloat(...)
SBData_GetFloat(SBData self, SBError error, lldb::offset_t offset) -> float

SBData_GetLongDouble(...)
SBData_GetLongDouble(SBData self, SBError error, lldb::offset_t offset) -> long double

SBData_GetSignedInt16(...)
SBData_GetSignedInt16(SBData self, SBError error, lldb::offset_t offset) -> int16_t

SBData_GetSignedInt32(...)
SBData_GetSignedInt32(SBData self, SBError error, lldb::offset_t offset) -> int32_t

SBData_GetSignedInt64(...)
SBData_GetSignedInt64(SBData self, SBError error, lldb::offset_t offset) -> int64_t

SBData_GetSignedInt8(...)
SBData_GetSignedInt8(SBData self, SBError error, lldb::offset_t offset) -> int8_t

SBData_GetString(...)
SBData_GetString(SBData self, SBError error, lldb::offset_t offset) -> char const *

SBData_GetUnsignedInt16(...)
SBData_GetUnsignedInt16(SBData self, SBError error, lldb::offset_t offset) -> uint16_t

SBData_GetUnsignedInt32(...)
SBData_GetUnsignedInt32(SBData self, SBError error, lldb::offset_t offset) -> uint32_t

SBData_GetUnsignedInt64(...)
SBData_GetUnsignedInt64(SBData self, SBError error, lldb::offset_t offset) -> uint64_t

SBData_GetUnsignedInt8(...)
SBData_GetUnsignedInt8(SBData self, SBError error, lldb::offset_t offset) -> uint8_t

SBData_IsValid(...)
SBData_IsValid(SBData self) -> bool

SBData_ReadRawData(...)
SBData_ReadRawData(SBData self, SBError error, lldb::offset_t offset, void * buf) -> size_t

SBData_SetAddressByteSize(...)
SBData_SetAddressByteSize(SBData self, uint8_t addr_byte_size)

SBData_SetByteOrder(...)
SBData_SetByteOrder(SBData self, lldb::ByteOrder endian)

SBData_SetData(...)
SBData_SetData(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)

SBData_SetDataFromCString(...)
SBData_SetDataFromCString(SBData self, char const * data) -> bool

SBData_SetDataFromDoubleArray(...)
SBData_SetDataFromDoubleArray(SBData self, double * array) -> bool

SBData_SetDataFromSInt32Array(...)
SBData_SetDataFromSInt32Array(SBData self, int32_t * array) -> bool

SBData_SetDataFromSInt64Array(...)
SBData_SetDataFromSInt64Array(SBData self, int64_t * array) -> bool

SBData_SetDataFromUInt32Array(...)
SBData_SetDataFromUInt32Array(SBData self, uint32_t * array) -> bool

SBData_SetDataFromUInt64Array(...)
SBData_SetDataFromUInt64Array(SBData self, uint64_t * array) -> bool

SBData___str__(...)
SBData___str__(SBData self) -> PyObject *

SBData_swigregister(...)

SBDebugger_Clear(...)
SBDebugger_Clear(SBDebugger self)

SBDebugger

SBDebugger_Create()
Create(bool source_init_files) -> SBDebugger SBDebugger_Create(bool source_init_files, lldb::LogOutputCallback log_callback) -> SBDebugger

SBDebugger_CreateCategory(...)
SBDebugger_CreateCategory(SBDebugger self, char const * category_name) -> SBTypeCategory

SBDebugger_CreateTarget(...)
CreateTarget(char const * filename, char const * target_triple, char const * platform_name, bool add_dependent_modules, ...

SBDebugger_CreateTargetWithFileAndArch(...)
SBDebugger_CreateTargetWithFileAndArch(SBDebugger self, char const * filename, char const * archname) -> SBTarget

SBDebugger_CreateTargetWithFileAndTargetTriple(...)
SBDebugger_CreateTargetWithFileAndTargetTriple(SBDebugger self, char const * filename, char const * target_triple) -> SBTarget

SBDebugger_DeleteCategory(...)
SBDebugger_DeleteCategory(SBDebugger self, char const * category_name) -> bool

SBDebugger_DeleteTarget(...)
SBDebugger_DeleteTarget(SBDebugger self, SBTarget target) -> bool

SBDebugger_Destroy(...)
SBDebugger_Destroy(SBDebugger debugger)

SBDebugger_DispatchInput(...)
SBDebugger_DispatchInput(SBDebugger self, void const * data)

SBDebugger_DispatchInputEndOfFile(...)
SBDebugger_DispatchInputEndOfFile(SBDebugger self)

SBDebugger_DispatchInputInterrupt(...)
SBDebugger_DispatchInputInterrupt(SBDebugger self)

SBDebugger_EnableLog(...)
SBDebugger_EnableLog(SBDebugger self, char const * channel, char const ** types) -> bool

SBDebugger_FindDebuggerWithID(...)
SBDebugger_FindDebuggerWithID(int id) -> SBDebugger

SBDebugger_FindTargetWithFileAndArch(...)
SBDebugger_FindTargetWithFileAndArch(SBDebugger self, char const * filename, char const * arch) -> SBTarget

SBDebugger_FindTargetWithProcessID(...)
SBDebugger_FindTargetWithProcessID(SBDebugger self, lldb::pid_t pid) -> SBTarget

SBDebugger_GetAsync(...)
SBDebugger_GetAsync(SBDebugger self) -> bool

SBDebugger_GetCategory(...)
GetCategory(char const * category_name) -> SBTypeCategory SBDebugger_GetCategory(SBDebugger self, lldb::LanguageType lang_type) -> SBTypeCategory

SBDebugger_GetCategoryAtIndex(...)
SBDebugger_GetCategoryAtIndex(SBDebugger self, uint32_t arg2) -> SBTypeCategory

SBDebugger_GetCloseInputOnEOF(...)
SBDebugger_GetCloseInputOnEOF(SBDebugger self) -> bool

SBDebugger_GetCommandInterpreter(...)
SBDebugger_GetCommandInterpreter(SBDebugger self) -> SBCommandInterpreter

SBDebugger_GetDefaultArchitecture(...)
SBDebugger_GetDefaultArchitecture(char * arch_name, size_t arch_name_len) -> bool

SBDebugger_GetDefaultCategory(...)
SBDebugger_GetDefaultCategory(SBDebugger self) -> SBTypeCategory

SBDebugger_GetDescription(...)
SBDebugger_GetDescription(SBDebugger self, SBStream description) -> bool

SBDebugger_GetErrorFileHandle(...)
SBDebugger_GetErrorFileHandle(SBDebugger self) -> FILE *

SBDebugger_GetFilterForType(...)
SBDebugger_GetFilterForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeFilter

SBDebugger_GetFormatForType(...)
SBDebugger_GetFormatForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeFormat

SBDebugger_GetID(...)
SBDebugger_GetID(SBDebugger self) -> lldb::user_id_t

SBDebugger_GetIndexOfTarget(...)
SBDebugger_GetIndexOfTarget(SBDebugger self, SBTarget target) -> uint32_t

SBDebugger_GetInputFileHandle(...)
SBDebugger_GetInputFileHandle(SBDebugger self) -> FILE *

SBDebugger_GetInstanceName(...)
SBDebugger_GetInstanceName(SBDebugger self) -> char const *

SBDebugger_GetInternalVariableValue(...)
SBDebugger_GetInternalVariableValue(char const * var_name, char const * debugger_instance_name) -> SBStringList

SBDebugger_GetListener(...)
SBDebugger_GetListener(SBDebugger self) -> SBListener

SBDebugger_GetNumCategories(...)
SBDebugger_GetNumCategories(SBDebugger self) -> uint32_t

SBDebugger_GetNumTargets(...)
SBDebugger_GetNumTargets(SBDebugger self) -> uint32_t

SBDebugger_GetOutputFileHandle(...)
SBDebugger_GetOutputFileHandle(SBDebugger self) -> FILE *

SBDebugger_GetPrompt(...)
SBDebugger_GetPrompt(SBDebugger self) -> char const *

SBDebugger_GetScriptLanguage(...)
SBDebugger_GetScriptLanguage(SBDebugger self) -> lldb::ScriptLanguage

SBDebugger_GetScriptingLanguage(...)
SBDebugger_GetScriptingLanguage(SBDebugger self, char const * script_language_name) -> lldb::ScriptLanguage

SBDebugger_GetSelectedPlatform(...)
SBDebugger_GetSelectedPlatform(SBDebugger self) -> SBPlatform

SBDebugger_GetSelectedTarget(...)
SBDebugger_GetSelectedTarget(SBDebugger self) -> SBTarget

SBDebugger_GetSourceManager(...)
SBDebugger_GetSourceManager(SBDebugger self) -> SBSourceManager

SBDebugger_GetSummaryForType(...)
SBDebugger_GetSummaryForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeSummary

SBDebugger_GetSyntheticForType(...)
SBDebugger_GetSyntheticForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic

SBDebugger_GetTargetAtIndex(...)
SBDebugger_GetTargetAtIndex(SBDebugger self, uint32_t idx) -> SBTarget

SBDebugger_GetTerminalWidth(...)
SBDebugger_GetTerminalWidth(SBDebugger self) -> uint32_t

SBDebugger_GetUseColor(...)
SBDebugger_GetUseColor(SBDebugger self) -> bool

SBDebugger_GetUseExternalEditor(...)
SBDebugger_GetUseExternalEditor(SBDebugger self) -> bool

char const *

SBDebugger_GetVersionString()

SBDebugger_HandleCommand(...)
SBDebugger_HandleCommand(SBDebugger self, char const * command)

SBDebugger_HandleProcessEvent(...)
SBDebugger_HandleProcessEvent(SBDebugger self, SBProcess process, SBEvent event, FILE * out, FILE * err)

SBDebugger_Initialize()

SBDebugger_IsValid(...)
SBDebugger_IsValid(SBDebugger self) -> bool

SBDebugger_MemoryPressureDetected()

SBDebugger_RunCommandInterpreter(...)
SBDebugger_RunCommandInterpreter(SBDebugger self, bool auto_handle_events, bool spawn_thread, SBCommandInterpreterRunOptions options, ...

SBDebugger_RunREPL(...)
SBDebugger_RunREPL(SBDebugger self, lldb::LanguageType language, char const * repl_options) -> SBError

SBDebugger_SetAsync(...)
SBDebugger_SetAsync(SBDebugger self, bool b)

SBDebugger_SetCloseInputOnEOF(...)
SBDebugger_SetCloseInputOnEOF(SBDebugger self, bool b)

SBDebugger_SetCurrentPlatform(...)
SBDebugger_SetCurrentPlatform(SBDebugger self, char const * platform_name) -> SBError

SBDebugger_SetCurrentPlatformSDKRoot(...)
SBDebugger_SetCurrentPlatformSDKRoot(SBDebugger self, char const * sysroot) -> bool

SBDebugger_SetDefaultArchitecture(...)
SBDebugger_SetDefaultArchitecture(char const * arch_name) -> bool

SBDebugger_SetErrorFileHandle(...)
SBDebugger_SetErrorFileHandle(SBDebugger self, FILE * f, bool transfer_ownership)

SBDebugger_SetInputFileHandle(...)
SBDebugger_SetInputFileHandle(SBDebugger self, FILE * f, bool transfer_ownership)

SBDebugger_SetInternalVariable(...)
SBDebugger_SetInternalVariable(char const * var_name, char const * value, char const * debugger_instance_name) -> SBError

SBDebugger_SetLoggingCallback(...)
SBDebugger_SetLoggingCallback(SBDebugger self, lldb::LogOutputCallback log_callback)

SBDebugger_SetOutputFileHandle(...)
SBDebugger_SetOutputFileHandle(SBDebugger self, FILE * f, bool transfer_ownership)

SBDebugger_SetPrompt(...)
SBDebugger_SetPrompt(SBDebugger self, char const * prompt)

SBDebugger_SetScriptLanguage(...)
SBDebugger_SetScriptLanguage(SBDebugger self, lldb::ScriptLanguage script_lang)

SBDebugger_SetSelectedPlatform(...)
SBDebugger_SetSelectedPlatform(SBDebugger self, SBPlatform platform)

SBDebugger_SetSelectedTarget(...)
SBDebugger_SetSelectedTarget(SBDebugger self, SBTarget target)

SBDebugger_SetTerminalWidth(...)
SBDebugger_SetTerminalWidth(SBDebugger self, uint32_t term_width)

SBDebugger_SetUseColor(...)
SBDebugger_SetUseColor(SBDebugger self, bool use_color) -> bool

SBDebugger_SetUseExternalEditor(...)
SBDebugger_SetUseExternalEditor(SBDebugger self, bool input) -> bool

SBDebugger_SkipLLDBInitFiles(...)
SBDebugger_SkipLLDBInitFiles(SBDebugger self, bool b)

SBDebugger_StateAsCString(...)
SBDebugger_StateAsCString(lldb::StateType state) -> char const *

SBDebugger_StateIsRunningState(...)
SBDebugger_StateIsRunningState(lldb::StateType state) -> bool

SBDebugger_StateIsStoppedState(...)
SBDebugger_StateIsStoppedState(lldb::StateType state) -> bool

SBDebugger_Terminate()

SBDebugger___str__(...)
SBDebugger___str__(SBDebugger self) -> PyObject *

SBDebugger_swigregister(...)

SBDeclaration_GetColumn(...)
SBDeclaration_GetColumn(SBDeclaration self) -> uint32_t

SBDeclaration_GetDescription(...)
SBDeclaration_GetDescription(SBDeclaration self, SBStream description) -> bool

SBDeclaration_GetFileSpec(...)
SBDeclaration_GetFileSpec(SBDeclaration self) -> SBFileSpec

SBDeclaration_GetLine(...)
SBDeclaration_GetLine(SBDeclaration self) -> uint32_t

SBDeclaration_IsValid(...)
SBDeclaration_IsValid(SBDeclaration self) -> bool

SBDeclaration_SetColumn(...)
SBDeclaration_SetColumn(SBDeclaration self, uint32_t column)

SBDeclaration_SetFileSpec(...)
SBDeclaration_SetFileSpec(SBDeclaration self, SBFileSpec filespec)

SBDeclaration_SetLine(...)
SBDeclaration_SetLine(SBDeclaration self, uint32_t line)

SBDeclaration___eq__(...)
SBDeclaration___eq__(SBDeclaration self, SBDeclaration rhs) -> bool

SBDeclaration___ne__(...)
SBDeclaration___ne__(SBDeclaration self, SBDeclaration rhs) -> bool

SBDeclaration___str__(...)
SBDeclaration___str__(SBDeclaration self) -> PyObject *

SBDeclaration_swigregister(...)

SBError_Clear(...)
SBError_Clear(SBError self)

SBError_Fail(...)
SBError_Fail(SBError self) -> bool

SBError_GetCString(...)
SBError_GetCString(SBError self) -> char const *

SBError_GetDescription(...)
SBError_GetDescription(SBError self, SBStream description) -> bool

SBError_GetError(...)
SBError_GetError(SBError self) -> uint32_t

SBError_GetType(...)
SBError_GetType(SBError self) -> lldb::ErrorType

SBError_IsValid(...)
SBError_IsValid(SBError self) -> bool

SBError_SetError(...)
SBError_SetError(SBError self, uint32_t err, lldb::ErrorType type)

SBError_SetErrorString(...)
SBError_SetErrorString(SBError self, char const * err_str)

SBError_SetErrorStringWithFormat(...)
SetErrorStringWithFormat(char const * format, char * str1=None, char * str2=None, char * str3=None) -> int SetErrorStringWithFormat(char const * format, char * str1=None, char * str2=None) -> int SetErrorStringWithFormat(char const * format, char * str1=None) -> int SBError_SetErrorStringWithFormat(SBError self, char const * format) -> int

SBError_SetErrorToErrno(...)
SBError_SetErrorToErrno(SBError self)

SBError_SetErrorToGenericError(...)
SBError_SetErrorToGenericError(SBError self)

SBError_Success(...)
SBError_Success(SBError self) -> bool

SBError___str__(...)
SBError___str__(SBError self) -> PyObject *

SBError_swigregister(...)

SBEvent_BroadcasterMatchesRef(...)
SBEvent_BroadcasterMatchesRef(SBEvent self, SBBroadcaster broadcaster) -> bool

SBEvent_Clear(...)
SBEvent_Clear(SBEvent self)

SBEvent_GetBroadcaster(...)
SBEvent_GetBroadcaster(SBEvent self) -> SBBroadcaster

SBEvent_GetBroadcasterClass(...)
SBEvent_GetBroadcasterClass(SBEvent self) -> char const *

SBEvent_GetCStringFromEvent(...)
SBEvent_GetCStringFromEvent(SBEvent event) -> char const *

SBEvent_GetDataFlavor(...)
SBEvent_GetDataFlavor(SBEvent self) -> char const *

SBEvent_GetDescription(...)
SBEvent_GetDescription(SBEvent self, SBStream description) -> bool

SBEvent_GetType(...)
SBEvent_GetType(SBEvent self) -> uint32_t

SBEvent_IsValid(...)
SBEvent_IsValid(SBEvent self) -> bool

SBEvent_swigregister(...)

SBExecutionContext_GetFrame(...)
SBExecutionContext_GetFrame(SBExecutionContext self) -> SBFrame

SBExecutionContext_GetProcess(...)
SBExecutionContext_GetProcess(SBExecutionContext self) -> SBProcess

SBExecutionContext_GetTarget(...)
SBExecutionContext_GetTarget(SBExecutionContext self) -> SBTarget

SBExecutionContext_GetThread(...)
SBExecutionContext_GetThread(SBExecutionContext self) -> SBThread

SBExecutionContext_swigregister(...)

SBExpressionOptions_GetAutoApplyFixIts(...)
SBExpressionOptions_GetAutoApplyFixIts(SBExpressionOptions self) -> bool

SBExpressionOptions_GetCoerceResultToId(...)
SBExpressionOptions_GetCoerceResultToId(SBExpressionOptions self) -> bool

SBExpressionOptions_GetFetchDynamicValue(...)
SBExpressionOptions_GetFetchDynamicValue(SBExpressionOptions self) -> lldb::DynamicValueType

SBExpressionOptions_GetGenerateDebugInfo(...)
SBExpressionOptions_GetGenerateDebugInfo(SBExpressionOptions self) -> bool

SBExpressionOptions_GetIgnoreBreakpoints(...)
SBExpressionOptions_GetIgnoreBreakpoints(SBExpressionOptions self) -> bool

SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(...)
SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t

SBExpressionOptions_GetPrefix(...)
SBExpressionOptions_GetPrefix(SBExpressionOptions self) -> char const *

SBExpressionOptions_GetStopOthers(...)
SBExpressionOptions_GetStopOthers(SBExpressionOptions self) -> bool

SBExpressionOptions_GetSuppressPersistentResult(...)
SBExpressionOptions_GetSuppressPersistentResult(SBExpressionOptions self) -> bool

SBExpressionOptions_GetTimeoutInMicroSeconds(...)
SBExpressionOptions_GetTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t

SBExpressionOptions_GetTopLevel(...)
SBExpressionOptions_GetTopLevel(SBExpressionOptions self) -> bool

SBExpressionOptions_GetTrapExceptions(...)
SBExpressionOptions_GetTrapExceptions(SBExpressionOptions self) -> bool

SBExpressionOptions_GetTryAllThreads(...)
SBExpressionOptions_GetTryAllThreads(SBExpressionOptions self) -> bool

SBExpressionOptions_GetUnwindOnError(...)
SBExpressionOptions_GetUnwindOnError(SBExpressionOptions self) -> bool

SBExpressionOptions_SetAutoApplyFixIts(...)
SetAutoApplyFixIts(bool b=True) SBExpressionOptions_SetAutoApplyFixIts(SBExpressionOptions self)

SBExpressionOptions_SetCoerceResultToId(...)
SetCoerceResultToId(bool coerce=True) SBExpressionOptions_SetCoerceResultToId(SBExpressionOptions self)

SBExpressionOptions_SetFetchDynamicValue(...)
SetFetchDynamicValue(lldb::DynamicValueType dynamic=eDynamicCanRunTarget) SBExpressionOptions_SetFetchDynamicValue(SBExpressionOptions self)

SBExpressionOptions_SetGenerateDebugInfo(...)
SetGenerateDebugInfo(bool b=True) SBExpressionOptions_SetGenerateDebugInfo(SBExpressionOptions self)

SBExpressionOptions_SetIgnoreBreakpoints(...)
SetIgnoreBreakpoints(bool ignore=True) SBExpressionOptions_SetIgnoreBreakpoints(SBExpressionOptions self)

SBExpressionOptions_SetLanguage(...)
SBExpressionOptions_SetLanguage(SBExpressionOptions self, lldb::LanguageType language)

SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds(...)
SetOneThreadTimeoutInMicroSeconds(uint32_t timeout=0) SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self)

SBExpressionOptions_SetPrefix(...)
SBExpressionOptions_SetPrefix(SBExpressionOptions self, char const * prefix)

SBExpressionOptions_SetStopOthers(...)
SetStopOthers(bool stop_others=True) SBExpressionOptions_SetStopOthers(SBExpressionOptions self)

SBExpressionOptions_SetSuppressPersistentResult(...)
SetSuppressPersistentResult(bool b=False) SBExpressionOptions_SetSuppressPersistentResult(SBExpressionOptions self)

SBExpressionOptions_SetTimeoutInMicroSeconds(...)
SetTimeoutInMicroSeconds(uint32_t timeout=0) SBExpressionOptions_SetTimeoutInMicroSeconds(SBExpressionOptions self)

SBExpressionOptions_SetTopLevel(...)
SetTopLevel(bool b=True) SBExpressionOptions_SetTopLevel(SBExpressionOptions self)

SBExpressionOptions_SetTrapExceptions(...)
SetTrapExceptions(bool trap_exceptions=True) SBExpressionOptions_SetTrapExceptions(SBExpressionOptions self)

SBExpressionOptions_SetTryAllThreads(...)
SetTryAllThreads(bool run_others=True) SBExpressionOptions_SetTryAllThreads(SBExpressionOptions self)

SBExpressionOptions_SetUnwindOnError(...)
SetUnwindOnError(bool unwind=True) SBExpressionOptions_SetUnwindOnError(SBExpressionOptions self)

SBExpressionOptions_swigregister(...)

SBFileSpecList_Append(...)
SBFileSpecList_Append(SBFileSpecList self, SBFileSpec sb_file)

SBFileSpecList_AppendIfUnique(...)
SBFileSpecList_AppendIfUnique(SBFileSpecList self, SBFileSpec sb_file) -> bool

SBFileSpecList_Clear(...)
SBFileSpecList_Clear(SBFileSpecList self)

SBFileSpecList_FindFileIndex(...)
SBFileSpecList_FindFileIndex(SBFileSpecList self, uint32_t idx, SBFileSpec sb_file, bool full) -> uint32_t

SBFileSpecList_GetDescription(...)
SBFileSpecList_GetDescription(SBFileSpecList self, SBStream description) -> bool

SBFileSpecList_GetFileSpecAtIndex(...)
SBFileSpecList_GetFileSpecAtIndex(SBFileSpecList self, uint32_t idx) -> SBFileSpec

SBFileSpecList_GetSize(...)
SBFileSpecList_GetSize(SBFileSpecList self) -> uint32_t

SBFileSpecList_swigregister(...)

SBFileSpec_AppendPathComponent(...)
SBFileSpec_AppendPathComponent(SBFileSpec self, char const * file_or_directory)

SBFileSpec_Exists(...)
SBFileSpec_Exists(SBFileSpec self) -> bool

SBFileSpec_GetDescription(...)
SBFileSpec_GetDescription(SBFileSpec self, SBStream description) -> bool

SBFileSpec_GetDirectory(...)
SBFileSpec_GetDirectory(SBFileSpec self) -> char const *

SBFileSpec_GetFilename(...)
SBFileSpec_GetFilename(SBFileSpec self) -> char const *

SBFileSpec_GetPath(...)
SBFileSpec_GetPath(SBFileSpec self, char * dst_path, size_t dst_len) -> uint32_t

SBFileSpec_IsValid(...)
SBFileSpec_IsValid(SBFileSpec self) -> bool

SBFileSpec_ResolveExecutableLocation(...)
SBFileSpec_ResolveExecutableLocation(SBFileSpec self) -> bool

SBFileSpec_ResolvePath(...)
SBFileSpec_ResolvePath(char const * src_path, char * dst_path, size_t dst_len) -> int

SBFileSpec_SetDirectory(...)
SBFileSpec_SetDirectory(SBFileSpec self, char const * directory)

SBFileSpec_SetFilename(...)
SBFileSpec_SetFilename(SBFileSpec self, char const * filename)

SBFileSpec___str__(...)
SBFileSpec___str__(SBFileSpec self) -> PyObject *

SBFileSpec_swigregister(...)

SBFrame_Clear(...)
SBFrame_Clear(SBFrame self)

SBFrame_Disassemble(...)
SBFrame_Disassemble(SBFrame self) -> char const *

SBFrame_EvaluateExpression(...)
EvaluateExpression(char const * expr) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) -> SBValue SBFrame_EvaluateExpression(SBFrame self, char const * expr, SBExpressionOptions options) -> SBValue

SBFrame_FindRegister(...)
SBFrame_FindRegister(SBFrame self, char const * name) -> SBValue

SBFrame_FindValue(...)
FindValue(char const * name, lldb::ValueType value_type) -> SBValue SBFrame_FindValue(SBFrame self, char const * name, lldb::ValueType value_type, lldb::DynamicValueType use_dynamic) -> SBValue

SBFrame_FindVariable(...)
FindVariable(char const * var_name) -> SBValue SBFrame_FindVariable(SBFrame self, char const * var_name, lldb::DynamicValueType use_dynamic) -> SBValue

SBFrame_GetBlock(...)
SBFrame_GetBlock(SBFrame self) -> SBBlock

SBFrame_GetCFA(...)
SBFrame_GetCFA(SBFrame self) -> lldb::addr_t

SBFrame_GetCompileUnit(...)
SBFrame_GetCompileUnit(SBFrame self) -> SBCompileUnit

SBFrame_GetDescription(...)
SBFrame_GetDescription(SBFrame self, SBStream description) -> bool

SBFrame_GetDisplayFunctionName(...)
SBFrame_GetDisplayFunctionName(SBFrame self) -> char const *

SBFrame_GetFP(...)
SBFrame_GetFP(SBFrame self) -> lldb::addr_t

SBFrame_GetFrameBlock(...)
SBFrame_GetFrameBlock(SBFrame self) -> SBBlock

SBFrame_GetFrameID(...)
SBFrame_GetFrameID(SBFrame self) -> uint32_t

SBFrame_GetFunction(...)
SBFrame_GetFunction(SBFrame self) -> SBFunction

char const

SBFrame_GetFunctionName()
SBFrame_GetFunctionName(SBFrame self) -> char const *

SBFrame_GetLineEntry(...)
SBFrame_GetLineEntry(SBFrame self) -> SBLineEntry

SBFrame_GetModule(...)
SBFrame_GetModule(SBFrame self) -> SBModule

SBFrame_GetPC(...)
SBFrame_GetPC(SBFrame self) -> lldb::addr_t

SBFrame_GetPCAddress(...)
SBFrame_GetPCAddress(SBFrame self) -> SBAddress

SBFrame_GetRegisters(...)
SBFrame_GetRegisters(SBFrame self) -> SBValueList

SBFrame_GetSP(...)
SBFrame_GetSP(SBFrame self) -> lldb::addr_t

SBFrame_GetSymbol(...)
SBFrame_GetSymbol(SBFrame self) -> SBSymbol

SBFrame_GetSymbolContext(...)
SBFrame_GetSymbolContext(SBFrame self, uint32_t resolve_scope) -> SBSymbolContext

SBFrame_GetThread(...)
SBFrame_GetThread(SBFrame self) -> SBThread

SBFrame_GetValueForVariablePath(...)
GetValueForVariablePath(char const * var_path) -> SBValue SBFrame_GetValueForVariablePath(SBFrame self, char const * var_path, lldb::DynamicValueType use_dynamic) -> SBValue

SBFrame_GetVariables(...)
GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only) -> SBValueList GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) -> SBValueList SBFrame_GetVariables(SBFrame self, SBVariablesOptions options) -> SBValueList

SBFrame_IsEqual(...)
SBFrame_IsEqual(SBFrame self, SBFrame rhs) -> bool

bool

SBFrame_IsInlined()
SBFrame_IsInlined(SBFrame self) -> bool

SBFrame_IsValid(...)
SBFrame_IsValid(SBFrame self) -> bool

SBFrame_SetPC(...)
SBFrame_SetPC(SBFrame self, lldb::addr_t new_pc) -> bool

SBFrame___str__(...)
SBFrame___str__(SBFrame self) -> PyObject *

SBFrame_swigregister(...)

SBFunction_GetArgumentName(...)
SBFunction_GetArgumentName(SBFunction self, uint32_t arg_idx) -> char const *

SBFunction_GetBlock(...)
SBFunction_GetBlock(SBFunction self) -> SBBlock

SBFunction_GetDescription(...)
SBFunction_GetDescription(SBFunction self, SBStream description) -> bool

SBFunction_GetDisplayName(...)
SBFunction_GetDisplayName(SBFunction self) -> char const *

SBFunction_GetEndAddress(...)
SBFunction_GetEndAddress(SBFunction self) -> SBAddress

SBFunction_GetInstructions(...)
GetInstructions(SBTarget target) -> SBInstructionList SBFunction_GetInstructions(SBFunction self, SBTarget target, char const * flavor) -> SBInstructionList

SBFunction_GetIsOptimized(...)
SBFunction_GetIsOptimized(SBFunction self) -> bool

SBFunction_GetLanguage(...)
SBFunction_GetLanguage(SBFunction self) -> lldb::LanguageType

SBFunction_GetMangledName(...)
SBFunction_GetMangledName(SBFunction self) -> char const *

SBFunction_GetName(...)
SBFunction_GetName(SBFunction self) -> char const *

SBFunction_GetPrologueByteSize(...)
SBFunction_GetPrologueByteSize(SBFunction self) -> uint32_t

SBFunction_GetStartAddress(...)
SBFunction_GetStartAddress(SBFunction self) -> SBAddress

SBFunction_GetType(...)
SBFunction_GetType(SBFunction self) -> SBType

SBFunction_IsValid(...)
SBFunction_IsValid(SBFunction self) -> bool

SBFunction___eq__(...)
SBFunction___eq__(SBFunction self, SBFunction rhs) -> bool

SBFunction___ne__(...)
SBFunction___ne__(SBFunction self, SBFunction rhs) -> bool

SBFunction___str__(...)
SBFunction___str__(SBFunction self) -> PyObject *

SBFunction_swigregister(...)

SBHostOS_GetLLDBPath(...)
SBHostOS_GetLLDBPath(lldb::PathType path_type) -> SBFileSpec

SBFileSpec

SBHostOS_GetLLDBPythonPath()

SBFileSpec

SBHostOS_GetProgramFileSpec()

SBFileSpec

SBHostOS_GetUserHomeDirectory()

SBHostOS_ThreadCancel(...)
SBHostOS_ThreadCancel(lldb::thread_t thread, SBError err) -> bool

SBHostOS_ThreadCreate(...)
SBHostOS_ThreadCreate(char const * name, lldb::thread_func_t arg2, void * thread_arg, SBError err) -> lldb::thread_t

SBHostOS_ThreadCreated(...)
SBHostOS_ThreadCreated(char const * name)

SBHostOS_ThreadDetach(...)
SBHostOS_ThreadDetach(lldb::thread_t thread, SBError err) -> bool

SBHostOS_ThreadJoin(...)
SBHostOS_ThreadJoin(lldb::thread_t thread, lldb::thread_result_t * result, SBError err) -> bool

SBHostOS_swigregister(...)

SBInstructionList_AppendInstruction(...)
SBInstructionList_AppendInstruction(SBInstructionList self, SBInstruction inst)

SBInstructionList_Clear(...)
SBInstructionList_Clear(SBInstructionList self)

SBInstructionList_DumpEmulationForAllInstructions(...)
SBInstructionList_DumpEmulationForAllInstructions(SBInstructionList self, char const * triple) -> bool

SBInstructionList_GetDescription(...)
SBInstructionList_GetDescription(SBInstructionList self, SBStream description) -> bool

SBInstructionList_GetInstructionAtIndex(...)
SBInstructionList_GetInstructionAtIndex(SBInstructionList self, uint32_t idx) -> SBInstruction

SBInstructionList_GetSize(...)
SBInstructionList_GetSize(SBInstructionList self) -> size_t

SBInstructionList_IsValid(...)
SBInstructionList_IsValid(SBInstructionList self) -> bool

SBInstructionList_Print(...)
SBInstructionList_Print(SBInstructionList self, FILE * out)

SBInstructionList___str__(...)
SBInstructionList___str__(SBInstructionList self) -> PyObject *

SBInstructionList_swigregister(...)

SBInstruction_DoesBranch(...)
SBInstruction_DoesBranch(SBInstruction self) -> bool

SBInstruction_DumpEmulation(...)
SBInstruction_DumpEmulation(SBInstruction self, char const * triple) -> bool

SBInstruction_EmulateWithFrame(...)
SBInstruction_EmulateWithFrame(SBInstruction self, SBFrame frame, uint32_t evaluate_options) -> bool

SBInstruction_GetAddress(...)
SBInstruction_GetAddress(SBInstruction self) -> SBAddress

SBInstruction_GetAddressClass(...)
SBInstruction_GetAddressClass(SBInstruction self) -> lldb::AddressClass

SBInstruction_GetByteSize(...)
SBInstruction_GetByteSize(SBInstruction self) -> size_t

SBInstruction_GetComment(...)
SBInstruction_GetComment(SBInstruction self, SBTarget target) -> char const *

SBInstruction_GetData(...)
SBInstruction_GetData(SBInstruction self, SBTarget target) -> SBData

SBInstruction_GetDescription(...)
SBInstruction_GetDescription(SBInstruction self, SBStream description) -> bool

SBInstruction_GetMnemonic(...)
SBInstruction_GetMnemonic(SBInstruction self, SBTarget target) -> char const *

SBInstruction_GetOperands(...)
SBInstruction_GetOperands(SBInstruction self, SBTarget target) -> char const *

SBInstruction_HasDelaySlot(...)
SBInstruction_HasDelaySlot(SBInstruction self) -> bool

SBInstruction_IsValid(...)
SBInstruction_IsValid(SBInstruction self) -> bool

SBInstruction_Print(...)
SBInstruction_Print(SBInstruction self, FILE * out)

SBInstruction_TestEmulation(...)
SBInstruction_TestEmulation(SBInstruction self, SBStream output_stream, char const * test_file) -> bool

SBInstruction___str__(...)
SBInstruction___str__(SBInstruction self) -> PyObject *

SBInstruction_swigregister(...)

SBLanguageRuntime_GetLanguageTypeFromString(...)
SBLanguageRuntime_GetLanguageTypeFromString(char const * string) -> lldb::LanguageType

SBLanguageRuntime_GetNameForLanguageType(...)
SBLanguageRuntime_GetNameForLanguageType(lldb::LanguageType language) -> char const *

SBLanguageRuntime_swigregister(...)

SBLaunchInfo_AddCloseFileAction(...)
SBLaunchInfo_AddCloseFileAction(SBLaunchInfo self, int fd) -> bool

SBLaunchInfo_AddDuplicateFileAction(...)
SBLaunchInfo_AddDuplicateFileAction(SBLaunchInfo self, int fd, int dup_fd) -> bool

SBLaunchInfo_AddOpenFileAction(...)
SBLaunchInfo_AddOpenFileAction(SBLaunchInfo self, int fd, char const * path, bool read, bool write) -> bool

SBLaunchInfo_AddSuppressFileAction(...)
SBLaunchInfo_AddSuppressFileAction(SBLaunchInfo self, int fd, bool read, bool write) -> bool

SBLaunchInfo_Clear(...)
SBLaunchInfo_Clear(SBLaunchInfo self)

SBLaunchInfo_GetArgumentAtIndex(...)
SBLaunchInfo_GetArgumentAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *

SBLaunchInfo_GetDetachOnError(...)
SBLaunchInfo_GetDetachOnError(SBLaunchInfo self) -> bool

SBLaunchInfo_GetEnvironmentEntryAtIndex(...)
SBLaunchInfo_GetEnvironmentEntryAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *

SBLaunchInfo_GetExecutableFile(...)
SBLaunchInfo_GetExecutableFile(SBLaunchInfo self) -> SBFileSpec

SBLaunchInfo_GetGroupID(...)
SBLaunchInfo_GetGroupID(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetLaunchEventData(...)
SBLaunchInfo_GetLaunchEventData(SBLaunchInfo self) -> char const *

SBLaunchInfo_GetLaunchFlags(...)
SBLaunchInfo_GetLaunchFlags(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetListener(...)
SBLaunchInfo_GetListener(SBLaunchInfo self) -> SBListener

SBLaunchInfo_GetNumArguments(...)
SBLaunchInfo_GetNumArguments(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetNumEnvironmentEntries(...)
SBLaunchInfo_GetNumEnvironmentEntries(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetProcessID(...)
SBLaunchInfo_GetProcessID(SBLaunchInfo self) -> lldb::pid_t

SBLaunchInfo_GetProcessPluginName(...)
SBLaunchInfo_GetProcessPluginName(SBLaunchInfo self) -> char const *

SBLaunchInfo_GetResumeCount(...)
SBLaunchInfo_GetResumeCount(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetShell(...)
SBLaunchInfo_GetShell(SBLaunchInfo self) -> char const *

SBLaunchInfo_GetShellExpandArguments(...)
SBLaunchInfo_GetShellExpandArguments(SBLaunchInfo self) -> bool

SBLaunchInfo_GetUserID(...)
SBLaunchInfo_GetUserID(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetWorkingDirectory(...)
SBLaunchInfo_GetWorkingDirectory(SBLaunchInfo self) -> char const *

SBLaunchInfo_GroupIDIsValid(...)
SBLaunchInfo_GroupIDIsValid(SBLaunchInfo self) -> bool

SBLaunchInfo_SetArguments(...)
SBLaunchInfo_SetArguments(SBLaunchInfo self, char const ** argv, bool append)

SBLaunchInfo_SetDetachOnError(...)
SBLaunchInfo_SetDetachOnError(SBLaunchInfo self, bool enable)

SBLaunchInfo_SetEnvironmentEntries(...)
SBLaunchInfo_SetEnvironmentEntries(SBLaunchInfo self, char const ** envp, bool append)

SBLaunchInfo_SetExecutableFile(...)
SBLaunchInfo_SetExecutableFile(SBLaunchInfo self, SBFileSpec exe_file, bool add_as_first_arg)

SBLaunchInfo_SetGroupID(...)
SBLaunchInfo_SetGroupID(SBLaunchInfo self, uint32_t gid)

SBLaunchInfo_SetLaunchEventData(...)
SBLaunchInfo_SetLaunchEventData(SBLaunchInfo self, char const * data)

SBLaunchInfo_SetLaunchFlags(...)
SBLaunchInfo_SetLaunchFlags(SBLaunchInfo self, uint32_t flags)

SBLaunchInfo_SetListener(...)
SBLaunchInfo_SetListener(SBLaunchInfo self, SBListener listener)

SBLaunchInfo_SetProcessPluginName(...)
SBLaunchInfo_SetProcessPluginName(SBLaunchInfo self, char const * plugin_name)

SBLaunchInfo_SetResumeCount(...)
SBLaunchInfo_SetResumeCount(SBLaunchInfo self, uint32_t c)

SBLaunchInfo_SetShell(...)
SBLaunchInfo_SetShell(SBLaunchInfo self, char const * path)

SBLaunchInfo_SetShellExpandArguments(...)
SBLaunchInfo_SetShellExpandArguments(SBLaunchInfo self, bool expand)

SBLaunchInfo_SetUserID(...)
SBLaunchInfo_SetUserID(SBLaunchInfo self, uint32_t uid)

SBLaunchInfo_SetWorkingDirectory(...)
SBLaunchInfo_SetWorkingDirectory(SBLaunchInfo self, char const * working_dir)

SBLaunchInfo_UserIDIsValid(...)
SBLaunchInfo_UserIDIsValid(SBLaunchInfo self) -> bool

SBLaunchInfo_swigregister(...)

SBLineEntry_GetColumn(...)
SBLineEntry_GetColumn(SBLineEntry self) -> uint32_t

SBLineEntry_GetDescription(...)
SBLineEntry_GetDescription(SBLineEntry self, SBStream description) -> bool

SBLineEntry_GetEndAddress(...)
SBLineEntry_GetEndAddress(SBLineEntry self) -> SBAddress

SBLineEntry_GetFileSpec(...)
SBLineEntry_GetFileSpec(SBLineEntry self) -> SBFileSpec

SBLineEntry_GetLine(...)
SBLineEntry_GetLine(SBLineEntry self) -> uint32_t

SBLineEntry_GetStartAddress(...)
SBLineEntry_GetStartAddress(SBLineEntry self) -> SBAddress

SBLineEntry_IsValid(...)
SBLineEntry_IsValid(SBLineEntry self) -> bool

SBLineEntry_SetColumn(...)
SBLineEntry_SetColumn(SBLineEntry self, uint32_t column)

SBLineEntry_SetFileSpec(...)
SBLineEntry_SetFileSpec(SBLineEntry self, SBFileSpec filespec)

SBLineEntry_SetLine(...)
SBLineEntry_SetLine(SBLineEntry self, uint32_t line)

SBLineEntry___eq__(...)
SBLineEntry___eq__(SBLineEntry self, SBLineEntry rhs) -> bool

SBLineEntry___ne__(...)
SBLineEntry___ne__(SBLineEntry self, SBLineEntry rhs) -> bool

SBLineEntry___str__(...)
SBLineEntry___str__(SBLineEntry self) -> PyObject *

SBLineEntry_swigregister(...)

SBListener_AddEvent(...)
SBListener_AddEvent(SBListener self, SBEvent event)

SBListener_Clear(...)
SBListener_Clear(SBListener self)

SBListener_GetNextEvent(...)
SBListener_GetNextEvent(SBListener self, SBEvent sb_event) -> bool

SBListener_GetNextEventForBroadcaster(...)
SBListener_GetNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool

SBListener_GetNextEventForBroadcasterWithType(...)
SBListener_GetNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool

SBListener_HandleBroadcastEvent(...)
SBListener_HandleBroadcastEvent(SBListener self, SBEvent event) -> bool

SBListener_IsValid(...)
SBListener_IsValid(SBListener self) -> bool

SBListener_PeekAtNextEvent(...)
SBListener_PeekAtNextEvent(SBListener self, SBEvent sb_event) -> bool

SBListener_PeekAtNextEventForBroadcaster(...)
SBListener_PeekAtNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool

SBListener_PeekAtNextEventForBroadcasterWithType(...)
SBListener_PeekAtNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool

SBListener_StartListeningForEventClass(...)
SBListener_StartListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> uint32_t

SBListener_StartListeningForEvents(...)
SBListener_StartListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> uint32_t

SBListener_StopListeningForEventClass(...)
SBListener_StopListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> uint32_t

SBListener_StopListeningForEvents(...)
SBListener_StopListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> bool

SBListener_WaitForEvent(...)
SBListener_WaitForEvent(SBListener self, uint32_t num_seconds, SBEvent event) -> bool

SBListener_WaitForEventForBroadcaster(...)
SBListener_WaitForEventForBroadcaster(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, SBEvent sb_event) -> bool

SBListener_WaitForEventForBroadcasterWithType(...)
SBListener_WaitForEventForBroadcasterWithType(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, uint32_t event_type_mask, ...

SBListener_swigregister(...)

SBMemoryRegionInfoList_Append(...)
Append(SBMemoryRegionInfo region) SBMemoryRegionInfoList_Append(SBMemoryRegionInfoList self, SBMemoryRegionInfoList region_list)

SBMemoryRegionInfoList_Clear(...)
SBMemoryRegionInfoList_Clear(SBMemoryRegionInfoList self)

SBMemoryRegionInfoList_GetMemoryRegionAtIndex(...)
SBMemoryRegionInfoList_GetMemoryRegionAtIndex(SBMemoryRegionInfoList self, uint32_t idx, SBMemoryRegionInfo region_info) -> bool

SBMemoryRegionInfoList_GetSize(...)
SBMemoryRegionInfoList_GetSize(SBMemoryRegionInfoList self) -> uint32_t

SBMemoryRegionInfoList_swigregister(...)

SBMemoryRegionInfo_Clear(...)
SBMemoryRegionInfo_Clear(SBMemoryRegionInfo self)

SBMemoryRegionInfo_GetDescription(...)
SBMemoryRegionInfo_GetDescription(SBMemoryRegionInfo self, SBStream description) -> bool

SBMemoryRegionInfo_GetRegionBase(...)
SBMemoryRegionInfo_GetRegionBase(SBMemoryRegionInfo self) -> lldb::addr_t

SBMemoryRegionInfo_GetRegionEnd(...)
SBMemoryRegionInfo_GetRegionEnd(SBMemoryRegionInfo self) -> lldb::addr_t

SBMemoryRegionInfo_IsExecutable(...)
SBMemoryRegionInfo_IsExecutable(SBMemoryRegionInfo self) -> bool

SBMemoryRegionInfo_IsMapped(...)
SBMemoryRegionInfo_IsMapped(SBMemoryRegionInfo self) -> bool

SBMemoryRegionInfo_IsReadable(...)
SBMemoryRegionInfo_IsReadable(SBMemoryRegionInfo self) -> bool

SBMemoryRegionInfo_IsWritable(...)
SBMemoryRegionInfo_IsWritable(SBMemoryRegionInfo self) -> bool

SBMemoryRegionInfo___eq__(...)
SBMemoryRegionInfo___eq__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool

SBMemoryRegionInfo___ne__(...)
SBMemoryRegionInfo___ne__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool

SBMemoryRegionInfo___str__(...)
SBMemoryRegionInfo___str__(SBMemoryRegionInfo self) -> PyObject *

SBMemoryRegionInfo_swigregister(...)

SBModuleSpecList_Append(...)
Append(SBModuleSpec spec) SBModuleSpecList_Append(SBModuleSpecList self, SBModuleSpecList spec_list)

SBModuleSpecList_FindFirstMatchingSpec(...)
SBModuleSpecList_FindFirstMatchingSpec(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpec

SBModuleSpecList_FindMatchingSpecs(...)
SBModuleSpecList_FindMatchingSpecs(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpecList

SBModuleSpecList_GetDescription(...)
SBModuleSpecList_GetDescription(SBModuleSpecList self, SBStream description) -> bool

SBModuleSpecList_GetModuleSpecifications(...)
SBModuleSpecList_GetModuleSpecifications(char const * path) -> SBModuleSpecList

SBModuleSpecList_GetSize(...)
SBModuleSpecList_GetSize(SBModuleSpecList self) -> size_t

SBModuleSpecList_GetSpecAtIndex(...)
SBModuleSpecList_GetSpecAtIndex(SBModuleSpecList self, size_t i) -> SBModuleSpec

SBModuleSpecList___str__(...)
SBModuleSpecList___str__(SBModuleSpecList self) -> PyObject *

SBModuleSpecList_swigregister(...)

SBModuleSpec_Clear(...)
SBModuleSpec_Clear(SBModuleSpec self)

SBModuleSpec_GetDescription(...)
SBModuleSpec_GetDescription(SBModuleSpec self, SBStream description) -> bool

SBModuleSpec_GetFileSpec(...)
SBModuleSpec_GetFileSpec(SBModuleSpec self) -> SBFileSpec

SBModuleSpec_GetObjectName(...)
SBModuleSpec_GetObjectName(SBModuleSpec self) -> char const *

SBModuleSpec_GetPlatformFileSpec(...)
SBModuleSpec_GetPlatformFileSpec(SBModuleSpec self) -> SBFileSpec

SBModuleSpec_GetSymbolFileSpec(...)
SBModuleSpec_GetSymbolFileSpec(SBModuleSpec self) -> SBFileSpec

SBModuleSpec_GetTriple(...)
SBModuleSpec_GetTriple(SBModuleSpec self) -> char const *

SBModuleSpec_GetUUIDBytes(...)
SBModuleSpec_GetUUIDBytes(SBModuleSpec self) -> uint8_t const *

SBModuleSpec_GetUUIDLength(...)
SBModuleSpec_GetUUIDLength(SBModuleSpec self) -> size_t

SBModuleSpec_IsValid(...)
SBModuleSpec_IsValid(SBModuleSpec self) -> bool

SBModuleSpec_SetFileSpec(...)
SBModuleSpec_SetFileSpec(SBModuleSpec self, SBFileSpec fspec)

SBModuleSpec_SetObjectName(...)
SBModuleSpec_SetObjectName(SBModuleSpec self, char const * name)

SBModuleSpec_SetPlatformFileSpec(...)
SBModuleSpec_SetPlatformFileSpec(SBModuleSpec self, SBFileSpec fspec)

SBModuleSpec_SetSymbolFileSpec(...)
SBModuleSpec_SetSymbolFileSpec(SBModuleSpec self, SBFileSpec fspec)

SBModuleSpec_SetTriple(...)
SBModuleSpec_SetTriple(SBModuleSpec self, char const * triple)

SBModuleSpec_SetUUIDBytes(...)
SBModuleSpec_SetUUIDBytes(SBModuleSpec self, uint8_t const * uuid, size_t uuid_len) -> bool

SBModuleSpec___str__(...)
SBModuleSpec___str__(SBModuleSpec self) -> PyObject *

SBModuleSpec_swigregister(...)

SBModule_Clear(...)
SBModule_Clear(SBModule self)

SBModule_FindFirstGlobalVariable(...)
SBModule_FindFirstGlobalVariable(SBModule self, SBTarget target, char const * name) -> SBValue

SBModule_FindFirstType(...)
SBModule_FindFirstType(SBModule self, char const * name) -> SBType

SBModule_FindFunctions(...)
FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBModule_FindFunctions(SBModule self, char const * name) -> SBSymbolContextList

SBModule_FindGlobalVariables(...)
SBModule_FindGlobalVariables(SBModule self, SBTarget target, char const * name, uint32_t max_matches) -> SBValueList

SBModule_FindSection(...)
SBModule_FindSection(SBModule self, char const * sect_name) -> SBSection

SBModule_FindSymbol(...)
FindSymbol(char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbol SBModule_FindSymbol(SBModule self, char const * name) -> SBSymbol

SBModule_FindSymbols(...)
FindSymbols(char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList SBModule_FindSymbols(SBModule self, char const * name) -> SBSymbolContextList

SBModule_FindTypes(...)
SBModule_FindTypes(SBModule self, char const * type) -> SBTypeList

SBModule_GetAddressByteSize(...)
SBModule_GetAddressByteSize(SBModule self) -> uint32_t

SBModule_GetBasicType(...)
SBModule_GetBasicType(SBModule self, lldb::BasicType type) -> SBType

SBModule_GetByteOrder(...)
SBModule_GetByteOrder(SBModule self) -> lldb::ByteOrder

SBModule_GetCompileUnitAtIndex(...)
SBModule_GetCompileUnitAtIndex(SBModule self, uint32_t arg2) -> SBCompileUnit

SBModule_GetDescription(...)
SBModule_GetDescription(SBModule self, SBStream description) -> bool

SBModule_GetFileSpec(...)
SBModule_GetFileSpec(SBModule self) -> SBFileSpec

SBModule_GetNumCompileUnits(...)
SBModule_GetNumCompileUnits(SBModule self) -> uint32_t

SBModule_GetNumSections(...)
SBModule_GetNumSections(SBModule self) -> size_t

SBModule_GetNumSymbols(...)
SBModule_GetNumSymbols(SBModule self) -> size_t

SBModule_GetObjectFileHeaderAddress(...)
SBModule_GetObjectFileHeaderAddress(SBModule self) -> SBAddress

SBModule_GetPlatformFileSpec(...)
SBModule_GetPlatformFileSpec(SBModule self) -> SBFileSpec

SBModule_GetRemoteInstallFileSpec(...)
SBModule_GetRemoteInstallFileSpec(SBModule self) -> SBFileSpec

SBModule_GetSectionAtIndex(...)
SBModule_GetSectionAtIndex(SBModule self, size_t idx) -> SBSection

SBModule_GetSymbolAtIndex(...)
SBModule_GetSymbolAtIndex(SBModule self, size_t idx) -> SBSymbol

SBModule_GetSymbolFileSpec(...)
SBModule_GetSymbolFileSpec(SBModule self) -> SBFileSpec

SBModule_GetTriple(...)
SBModule_GetTriple(SBModule self) -> char const *

SBModule_GetTypeByID(...)
SBModule_GetTypeByID(SBModule self, lldb::user_id_t uid) -> SBType

SBModule_GetTypes(...)
GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBModule_GetTypes(SBModule self) -> SBTypeList

SBModule_GetUUIDString(...)
SBModule_GetUUIDString(SBModule self) -> char const *

SBModule_GetVersion(...)
SBModule_GetVersion(SBModule self) -> uint32_t

SBModule_IsValid(...)
SBModule_IsValid(SBModule self) -> bool

SBModule_ResolveFileAddress(...)
SBModule_ResolveFileAddress(SBModule self, lldb::addr_t vm_addr) -> SBAddress

SBModule_ResolveSymbolContextForAddress(...)
SBModule_ResolveSymbolContextForAddress(SBModule self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext

SBModule_SetPlatformFileSpec(...)
SBModule_SetPlatformFileSpec(SBModule self, SBFileSpec platform_file) -> bool

SBModule_SetRemoteInstallFileSpec(...)
SBModule_SetRemoteInstallFileSpec(SBModule self, SBFileSpec file) -> bool

SBModule___eq__(...)
SBModule___eq__(SBModule self, SBModule rhs) -> bool

SBModule___ne__(...)
SBModule___ne__(SBModule self, SBModule rhs) -> bool

SBModule___str__(...)
SBModule___str__(SBModule self) -> PyObject *

SBModule_swigregister(...)

SBPlatformConnectOptions_DisableRsync(...)
SBPlatformConnectOptions_DisableRsync(SBPlatformConnectOptions self)

SBPlatformConnectOptions_EnableRsync(...)
SBPlatformConnectOptions_EnableRsync(SBPlatformConnectOptions self, char const * options, char const * remote_path_prefix, ...

SBPlatformConnectOptions_GetLocalCacheDirectory(...)
SBPlatformConnectOptions_GetLocalCacheDirectory(SBPlatformConnectOptions self) -> char const *

SBPlatformConnectOptions_GetRsyncEnabled(...)
SBPlatformConnectOptions_GetRsyncEnabled(SBPlatformConnectOptions self) -> bool

SBPlatformConnectOptions_GetURL(...)
SBPlatformConnectOptions_GetURL(SBPlatformConnectOptions self) -> char const *

SBPlatformConnectOptions_SetLocalCacheDirectory(...)
SBPlatformConnectOptions_SetLocalCacheDirectory(SBPlatformConnectOptions self, char const * path)

SBPlatformConnectOptions_SetURL(...)
SBPlatformConnectOptions_SetURL(SBPlatformConnectOptions self, char const * url)

SBPlatformConnectOptions_swigregister(...)

SBPlatformShellCommand_Clear(...)
SBPlatformShellCommand_Clear(SBPlatformShellCommand self)

SBPlatformShellCommand_GetCommand(...)
SBPlatformShellCommand_GetCommand(SBPlatformShellCommand self) -> char const *

SBPlatformShellCommand_GetOutput(...)
SBPlatformShellCommand_GetOutput(SBPlatformShellCommand self) -> char const *

SBPlatformShellCommand_GetSignal(...)
SBPlatformShellCommand_GetSignal(SBPlatformShellCommand self) -> int

SBPlatformShellCommand_GetStatus(...)
SBPlatformShellCommand_GetStatus(SBPlatformShellCommand self) -> int

SBPlatformShellCommand_GetTimeoutSeconds(...)
SBPlatformShellCommand_GetTimeoutSeconds(SBPlatformShellCommand self) -> uint32_t

SBPlatformShellCommand_GetWorkingDirectory(...)
SBPlatformShellCommand_GetWorkingDirectory(SBPlatformShellCommand self) -> char const *

SBPlatformShellCommand_SetCommand(...)
SBPlatformShellCommand_SetCommand(SBPlatformShellCommand self, char const * shell_command)

SBPlatformShellCommand_SetTimeoutSeconds(...)
SBPlatformShellCommand_SetTimeoutSeconds(SBPlatformShellCommand self, uint32_t sec)

SBPlatformShellCommand_SetWorkingDirectory(...)
SBPlatformShellCommand_SetWorkingDirectory(SBPlatformShellCommand self, char const * path)

SBPlatformShellCommand_swigregister(...)

SBPlatform_Clear(...)
SBPlatform_Clear(SBPlatform self)

SBPlatform_ConnectRemote(...)
SBPlatform_ConnectRemote(SBPlatform self, SBPlatformConnectOptions connect_options) -> SBError

SBPlatform_DisconnectRemote(...)
SBPlatform_DisconnectRemote(SBPlatform self)

SBPlatform_Get(...)
SBPlatform_Get(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError

SBPlatform_GetFilePermissions(...)
SBPlatform_GetFilePermissions(SBPlatform self, char const * path) -> uint32_t

SBPlatform_GetHostname(...)
SBPlatform_GetHostname(SBPlatform self) -> char const *

SBPlatform_GetName(...)
SBPlatform_GetName(SBPlatform self) -> char const *

SBPlatform_GetOSBuild(...)
SBPlatform_GetOSBuild(SBPlatform self) -> char const *

SBPlatform_GetOSDescription(...)
SBPlatform_GetOSDescription(SBPlatform self) -> char const *

SBPlatform_GetOSMajorVersion(...)
SBPlatform_GetOSMajorVersion(SBPlatform self) -> uint32_t

SBPlatform_GetOSMinorVersion(...)
SBPlatform_GetOSMinorVersion(SBPlatform self) -> uint32_t

SBPlatform_GetOSUpdateVersion(...)
SBPlatform_GetOSUpdateVersion(SBPlatform self) -> uint32_t

SBPlatform_GetTriple(...)
SBPlatform_GetTriple(SBPlatform self) -> char const *

SBPlatform_GetUnixSignals(...)
SBPlatform_GetUnixSignals(SBPlatform self) -> SBUnixSignals

SBPlatform_GetWorkingDirectory(...)
SBPlatform_GetWorkingDirectory(SBPlatform self) -> char const *

SBPlatform_Install(...)
SBPlatform_Install(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError

SBPlatform_IsConnected(...)
SBPlatform_IsConnected(SBPlatform self) -> bool

SBPlatform_IsValid(...)
SBPlatform_IsValid(SBPlatform self) -> bool

SBPlatform_Kill(...)
SBPlatform_Kill(SBPlatform self, lldb::pid_t const pid) -> SBError

SBPlatform_Launch(...)
SBPlatform_Launch(SBPlatform self, SBLaunchInfo launch_info) -> SBError

SBPlatform_MakeDirectory(...)
MakeDirectory(char const * path, uint32_t file_permissions=eFilePermissionsDirectoryDefault) -> SBError SBPlatform_MakeDirectory(SBPlatform self, char const * path) -> SBError

SBPlatform_Put(...)
SBPlatform_Put(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError

SBPlatform_Run(...)
SBPlatform_Run(SBPlatform self, SBPlatformShellCommand shell_command) -> SBError

SBPlatform_SetFilePermissions(...)
SBPlatform_SetFilePermissions(SBPlatform self, char const * path, uint32_t file_permissions) -> SBError

SBPlatform_SetWorkingDirectory(...)
SBPlatform_SetWorkingDirectory(SBPlatform self, char const * arg2) -> bool

SBPlatform_swigregister(...)

SBProcess_AppendEventStateReport(...)
SBProcess_AppendEventStateReport(SBProcess self, SBEvent event, SBCommandReturnObject result)

SBProcess_Clear(...)
SBProcess_Clear(SBProcess self)

SBProcess_Continue(...)
SBProcess_Continue(SBProcess self) -> SBError

SBProcess_CreateOSPluginThread(...)
Lazily create a thread on demand through the current OperatingSystem plug-in, if the current OperatingSystem plug-in supports it.

SBProcess_Destroy(...)
SBProcess_Destroy(SBProcess self) -> SBError

SBProcess_Detach(...)
SBProcess_Detach(SBProcess self) -> SBError

SBProcess_EventIsProcessEvent(...)
SBProcess_EventIsProcessEvent(SBEvent event) -> bool

SBProcess_EventIsStructuredDataEvent(...)
SBProcess_EventIsStructuredDataEvent(SBEvent event) -> bool

SBProcess_GetAddressByteSize(...)
SBProcess_GetAddressByteSize(SBProcess self) -> uint32_t

SBProcess_GetAsyncProfileData(...)
SBProcess_GetAsyncProfileData(SBProcess self, char * dst) -> size_t

SBProcess_GetBroadcaster(...)
SBProcess_GetBroadcaster(SBProcess self) -> SBBroadcaster

char const *

SBProcess_GetBroadcasterClassName()

SBProcess_GetByteOrder(...)
SBProcess_GetByteOrder(SBProcess self) -> lldb::ByteOrder

SBProcess_GetDescription(...)
SBProcess_GetDescription(SBProcess self, SBStream description) -> bool

SBProcess_GetExitDescription(...)
SBProcess_GetExitDescription(SBProcess self) -> char const *

SBProcess_GetExitStatus(...)
SBProcess_GetExitStatus(SBProcess self) -> int

SBProcess_GetExtendedBacktraceTypeAtIndex(...)
Takes an index argument, returns the name of one of the thread-origin extended backtrace methods as a str.

SBProcess_GetHistoryThreads(...)
SBProcess_GetHistoryThreads(SBProcess self, lldb::addr_t addr) -> SBThreadCollection

SBProcess_GetInterruptedFromEvent(...)
SBProcess_GetInterruptedFromEvent(SBEvent event) -> bool

SBProcess_GetMemoryRegionInfo(...)
SBProcess_GetMemoryRegionInfo(SBProcess self, lldb::addr_t load_addr, SBMemoryRegionInfo region_info) -> SBError

SBProcess_GetMemoryRegions(...)
SBProcess_GetMemoryRegions(SBProcess self) -> SBMemoryRegionInfoList

SBProcess_GetNumExtendedBacktraceTypes(...)
Return the number of different thread-origin extended backtraces this process can support as a uint32_t.

SBProcess_GetNumQueues(...)
SBProcess_GetNumQueues(SBProcess self) -> uint32_t

SBProcess_GetNumRestartedReasonsFromEvent(...)
SBProcess_GetNumRestartedReasonsFromEvent(SBEvent event) -> size_t

SBProcess_GetNumSupportedHardwareWatchpoints(...)
SBProcess_GetNumSupportedHardwareWatchpoints(SBProcess self, SBError error) -> uint32_t

SBProcess_GetNumThreads(...)
SBProcess_GetNumThreads(SBProcess self) -> uint32_t

SBProcess_GetPluginName(...)
SBProcess_GetPluginName(SBProcess self) -> char const *

SBProcess_GetProcessFromEvent(...)
SBProcess_GetProcessFromEvent(SBEvent event) -> SBProcess

SBProcess_GetProcessID(...)
Returns the process ID of the process.

SBProcess_GetQueueAtIndex(...)
SBProcess_GetQueueAtIndex(SBProcess self, uint32_t index) -> SBQueue

SBProcess_GetRestartedFromEvent(...)
SBProcess_GetRestartedFromEvent(SBEvent event) -> bool

SBProcess_GetRestartedReasonAtIndexFromEvent(...)
SBProcess_GetRestartedReasonAtIndexFromEvent(SBEvent event, size_t idx) -> char const *

SBProcess_GetSTDERR(...)
Reads data from the current process's stderr stream.

SBProcess_GetSTDOUT(...)
Reads data from the current process's stdout stream.

SBProcess_GetSelectedThread(...)
Returns the currently selected thread.

SBProcess_GetShortPluginName(...)
SBProcess_GetShortPluginName(SBProcess self) -> char const *

SBProcess_GetState(...)
SBProcess_GetState(SBProcess self) -> lldb::StateType

SBProcess_GetStateFromEvent(...)
SBProcess_GetStateFromEvent(SBEvent event) -> lldb::StateType

SBProcess_GetStopID(...)
GetStopID(bool include_expression_stops=False) -> uint32_t SBProcess_GetStopID(SBProcess self) -> uint32_t

SBProcess_GetStructuredDataFromEvent(...)
SBProcess_GetStructuredDataFromEvent(SBEvent event) -> SBStructuredData

SBProcess_GetTarget(...)
SBProcess_GetTarget(SBProcess self) -> SBTarget

SBProcess_GetThreadAtIndex(...)
Returns the INDEX'th thread from the list of current threads.

SBProcess_GetThreadByID(...)
Returns the thread with the given thread ID.

SBProcess_GetThreadByIndexID(...)
Returns the thread with the given thread IndexID.

SBProcess_GetUniqueID(...)
Returns an integer ID that is guaranteed to be unique across all process instances.

SBProcess_GetUnixSignals(...)
SBProcess_GetUnixSignals(SBProcess self) -> SBUnixSignals

SBProcess_IsInstrumentationRuntimePresent(...)
SBProcess_IsInstrumentationRuntimePresent(SBProcess self, lldb::InstrumentationRuntimeType type) -> bool

SBProcess_IsValid(...)
SBProcess_IsValid(SBProcess self) -> bool

SBProcess_Kill(...)
SBProcess_Kill(SBProcess self) -> SBError

SBProcess_LoadImage(...)
SBProcess_LoadImage(SBProcess self, SBFileSpec image_spec, SBError error) -> uint32_t

SBProcess_PutSTDIN(...)
Writes data into the current process's stdin.

SBProcess_ReadCStringFromMemory(...)
Reads a NULL terminated C string from the current process's address space.

SBProcess_ReadMemory(...)
Reads memory from the current process's address space and removes any traps that may have been inserted into the memory.

SBProcess_ReadPointerFromMemory(...)
Reads a pointer from memory from an address and returns the value.

SBProcess_ReadUnsignedFromMemory(...)
Reads an unsigned integer from memory given a byte size and an address.

SBProcess_RemoteAttachToProcessWithID(...)
SBProcess_RemoteAttachToProcessWithID(SBProcess self, lldb::pid_t pid, SBError error) -> bool

SBProcess_RemoteLaunch(...)
SBProcess_RemoteLaunch(SBProcess self, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> bool

SBProcess_ReportEventState(...)
SBProcess_ReportEventState(SBProcess self, SBEvent event, FILE * out)

SBProcess_SaveCore(...)
SBProcess_SaveCore(SBProcess self, char const * file_name) -> SBError

SBProcess_SendAsyncInterrupt(...)
SBProcess_SendAsyncInterrupt(SBProcess self)

SBProcess_SendEventData(...)
SBProcess_SendEventData(SBProcess self, char const * event_data) -> SBError

SBProcess_SetSelectedThread(...)
SBProcess_SetSelectedThread(SBProcess self, SBThread thread) -> bool

SBProcess_SetSelectedThreadByID(...)
SBProcess_SetSelectedThreadByID(SBProcess self, lldb::tid_t tid) -> bool

SBProcess_SetSelectedThreadByIndexID(...)
SBProcess_SetSelectedThreadByIndexID(SBProcess self, uint32_t index_id) -> bool

SBProcess_Signal(...)
SBProcess_Signal(SBProcess self, int signal) -> SBError

SBProcess_Stop(...)
SBProcess_Stop(SBProcess self) -> SBError

SBProcess_UnloadImage(...)
SBProcess_UnloadImage(SBProcess self, uint32_t image_token) -> SBError

SBProcess_WriteMemory(...)
Writes memory to the current process's address space and maintains any traps that might be present due to software breakpoints.

SBProcess___str__(...)
SBProcess___str__(SBProcess self) -> PyObject *

SBProcess_swigregister(...)

SBQueueItem_Clear(...)
SBQueueItem_Clear(SBQueueItem self)

SBQueueItem_GetAddress(...)
SBQueueItem_GetAddress(SBQueueItem self) -> SBAddress

SBQueueItem_GetExtendedBacktraceThread(...)
SBQueueItem_GetExtendedBacktraceThread(SBQueueItem self, char const * type) -> SBThread

SBQueueItem_GetKind(...)
SBQueueItem_GetKind(SBQueueItem self) -> lldb::QueueItemKind

SBQueueItem_IsValid(...)
SBQueueItem_IsValid(SBQueueItem self) -> bool

SBQueueItem_SetAddress(...)
SBQueueItem_SetAddress(SBQueueItem self, SBAddress addr)

SBQueueItem_SetKind(...)
SBQueueItem_SetKind(SBQueueItem self, lldb::QueueItemKind kind)

SBQueueItem_SetQueueItem(...)
SBQueueItem_SetQueueItem(SBQueueItem self, lldb::QueueItemSP const & queue_item_sp)

SBQueueItem_swigregister(...)

SBQueue_Clear(...)
SBQueue_Clear(SBQueue self)

SBQueue_GetIndexID(...)
SBQueue_GetIndexID(SBQueue self) -> uint32_t

SBQueue_GetKind(...)
Returns an lldb::QueueKind enumerated value (e.g.

SBQueue_GetName(...)
SBQueue_GetName(SBQueue self) -> char const *

SBQueue_GetNumPendingItems(...)
SBQueue_GetNumPendingItems(SBQueue self) -> uint32_t

SBQueue_GetNumRunningItems(...)
SBQueue_GetNumRunningItems(SBQueue self) -> uint32_t

SBQueue_GetNumThreads(...)
SBQueue_GetNumThreads(SBQueue self) -> uint32_t

SBQueue_GetPendingItemAtIndex(...)
SBQueue_GetPendingItemAtIndex(SBQueue self, uint32_t arg2) -> SBQueueItem

SBQueue_GetProcess(...)
SBQueue_GetProcess(SBQueue self) -> SBProcess

SBQueue_GetQueueID(...)
Returns an lldb::queue_id_t type unique identifier number for this queue that will not be used by any other queue during this process' execution.

SBQueue_GetThreadAtIndex(...)
SBQueue_GetThreadAtIndex(SBQueue self, uint32_t arg2) -> SBThread

SBQueue_IsValid(...)
SBQueue_IsValid(SBQueue self) -> bool

SBQueue_swigregister(...)

SBSection_FindSubSection(...)
SBSection_FindSubSection(SBSection self, char const * sect_name) -> SBSection

SBSection_GetByteSize(...)
SBSection_GetByteSize(SBSection self) -> lldb::addr_t

SBSection_GetDescription(...)
SBSection_GetDescription(SBSection self, SBStream description) -> bool

SBSection_GetFileAddress(...)
SBSection_GetFileAddress(SBSection self) -> lldb::addr_t

SBSection_GetFileByteSize(...)
SBSection_GetFileByteSize(SBSection self) -> uint64_t

SBSection_GetFileOffset(...)
SBSection_GetFileOffset(SBSection self) -> uint64_t

SBSection_GetLoadAddress(...)
SBSection_GetLoadAddress(SBSection self, SBTarget target) -> lldb::addr_t

SBSection_GetName(...)
SBSection_GetName(SBSection self) -> char const *

SBSection_GetNumSubSections(...)
SBSection_GetNumSubSections(SBSection self) -> size_t

SBSection_GetParent(...)
SBSection_GetParent(SBSection self) -> SBSection

SBSection_GetPermissions(...)
SBSection_GetPermissions(SBSection self) -> uint32_t

SBData

SBSection_GetSectionData()
SBSection_GetSectionData(SBSection self, uint64_t offset, uint64_t size) -> SBData

SBSection_GetSectionType(...)
SBSection_GetSectionType(SBSection self) -> lldb::SectionType

SBSection_GetSubSectionAtIndex(...)
SBSection_GetSubSectionAtIndex(SBSection self, size_t idx) -> SBSection

SBSection_GetTargetByteSize(...)
SBSection_GetTargetByteSize(SBSection self) -> uint32_t

SBSection_IsValid(...)
SBSection_IsValid(SBSection self) -> bool

SBSection___eq__(...)
SBSection___eq__(SBSection self, SBSection rhs) -> bool

SBSection___ne__(...)
SBSection___ne__(SBSection self, SBSection rhs) -> bool

SBSection___str__(...)
SBSection___str__(SBSection self) -> PyObject *

SBSection_swigregister(...)

SBSourceManager_DisplaySourceLinesWithLineNumbers(...)
SBSourceManager_DisplaySourceLinesWithLineNumbers(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t context_before, uint32_t context_after, ...

SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(...)
SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t column, uint32_t context_before, ...

SBSourceManager_swigregister(...)

SBStream_Clear(...)
SBStream_Clear(SBStream self)

SBStream_GetData(...)
SBStream_GetData(SBStream self) -> char const *

SBStream_GetSize(...)
SBStream_GetSize(SBStream self) -> size_t

SBStream_IsValid(...)
SBStream_IsValid(SBStream self) -> bool

SBStream_Print(...)
SBStream_Print(SBStream self, char const * str)

SBStream_RedirectToFile(...)
SBStream_RedirectToFile(SBStream self, char const * path, bool append)

SBStream_RedirectToFileDescriptor(...)
SBStream_RedirectToFileDescriptor(SBStream self, int fd, bool transfer_fh_ownership)

SBStream_RedirectToFileHandle(...)
SBStream_RedirectToFileHandle(SBStream self, FILE * fh, bool transfer_fh_ownership)

SBStream_flush(...)
SBStream_flush(SBStream self)

SBStream_swigregister(...)

SBStream_write(...)
SBStream_write(SBStream self, char const * str)

SBStringList_AppendList(...)
AppendList(char const ** strv, int strc) SBStringList_AppendList(SBStringList self, SBStringList strings)

SBStringList_AppendString(...)
SBStringList_AppendString(SBStringList self, char const * str)

SBStringList_Clear(...)
SBStringList_Clear(SBStringList self)

SBStringList_GetSize(...)
SBStringList_GetSize(SBStringList self) -> uint32_t

SBStringList_GetStringAtIndex(...)
SBStringList_GetStringAtIndex(SBStringList self, size_t idx) -> char const *

SBStringList_IsValid(...)
SBStringList_IsValid(SBStringList self) -> bool

SBStringList_swigregister(...)

SBStructuredData_Clear(...)
SBStructuredData_Clear(SBStructuredData self)

SBStructuredData_GetAsJSON(...)
SBStructuredData_GetAsJSON(SBStructuredData self, SBStream stream) -> SBError

SBStructuredData_GetDescription(...)
SBStructuredData_GetDescription(SBStructuredData self, SBStream stream) -> SBError

SBStructuredData_IsValid(...)
SBStructuredData_IsValid(SBStructuredData self) -> bool

SBStructuredData_swigregister(...)

SBSymbolContextList_Append(...)
Append(SBSymbolContext sc) SBSymbolContextList_Append(SBSymbolContextList self, SBSymbolContextList sc_list)

SBSymbolContextList_Clear(...)
SBSymbolContextList_Clear(SBSymbolContextList self)

SBSymbolContextList_GetContextAtIndex(...)
SBSymbolContextList_GetContextAtIndex(SBSymbolContextList self, uint32_t idx) -> SBSymbolContext

SBSymbolContextList_GetDescription(...)
SBSymbolContextList_GetDescription(SBSymbolContextList self, SBStream description) -> bool

SBSymbolContextList_GetSize(...)
SBSymbolContextList_GetSize(SBSymbolContextList self) -> uint32_t

SBSymbolContextList_IsValid(...)
SBSymbolContextList_IsValid(SBSymbolContextList self) -> bool

SBSymbolContextList___str__(...)
SBSymbolContextList___str__(SBSymbolContextList self) -> PyObject *

SBSymbolContextList_swigregister(...)

SBSymbolContext_GetBlock(...)
SBSymbolContext_GetBlock(SBSymbolContext self) -> SBBlock

SBSymbolContext_GetCompileUnit(...)
SBSymbolContext_GetCompileUnit(SBSymbolContext self) -> SBCompileUnit

SBSymbolContext_GetDescription(...)
SBSymbolContext_GetDescription(SBSymbolContext self, SBStream description) -> bool

SBSymbolContext_GetFunction(...)
SBSymbolContext_GetFunction(SBSymbolContext self) -> SBFunction

SBSymbolContext_GetLineEntry(...)
SBSymbolContext_GetLineEntry(SBSymbolContext self) -> SBLineEntry

SBSymbolContext_GetModule(...)
SBSymbolContext_GetModule(SBSymbolContext self) -> SBModule

SBSymbolContext_GetParentOfInlinedScope(...)
SBSymbolContext_GetParentOfInlinedScope(SBSymbolContext self, SBAddress curr_frame_pc, SBAddress parent_frame_addr) -> SBSymbolContext

SBSymbolContext_GetSymbol(...)
SBSymbolContext_GetSymbol(SBSymbolContext self) -> SBSymbol

SBSymbolContext_IsValid(...)
SBSymbolContext_IsValid(SBSymbolContext self) -> bool

SBSymbolContext_SetBlock(...)
SBSymbolContext_SetBlock(SBSymbolContext self, SBBlock block)

SBSymbolContext_SetCompileUnit(...)
SBSymbolContext_SetCompileUnit(SBSymbolContext self, SBCompileUnit compile_unit)

SBSymbolContext_SetFunction(...)
SBSymbolContext_SetFunction(SBSymbolContext self, SBFunction function)

SBSymbolContext_SetLineEntry(...)
SBSymbolContext_SetLineEntry(SBSymbolContext self, SBLineEntry line_entry)

SBSymbolContext_SetModule(...)
SBSymbolContext_SetModule(SBSymbolContext self, SBModule module)

SBSymbolContext_SetSymbol(...)
SBSymbolContext_SetSymbol(SBSymbolContext self, SBSymbol symbol)

SBSymbolContext___str__(...)
SBSymbolContext___str__(SBSymbolContext self) -> PyObject *

SBSymbolContext_swigregister(...)

SBSymbol_GetDescription(...)
SBSymbol_GetDescription(SBSymbol self, SBStream description) -> bool

SBSymbol_GetDisplayName(...)
SBSymbol_GetDisplayName(SBSymbol self) -> char const *

SBSymbol_GetEndAddress(...)
SBSymbol_GetEndAddress(SBSymbol self) -> SBAddress

SBSymbol_GetInstructions(...)
GetInstructions(SBTarget target) -> SBInstructionList SBSymbol_GetInstructions(SBSymbol self, SBTarget target, char const * flavor_string) -> SBInstructionList

SBSymbol_GetMangledName(...)
SBSymbol_GetMangledName(SBSymbol self) -> char const *

SBSymbol_GetName(...)
SBSymbol_GetName(SBSymbol self) -> char const *

SBSymbol_GetPrologueByteSize(...)
SBSymbol_GetPrologueByteSize(SBSymbol self) -> uint32_t

SBSymbol_GetStartAddress(...)
SBSymbol_GetStartAddress(SBSymbol self) -> SBAddress

SBSymbol_GetType(...)
SBSymbol_GetType(SBSymbol self) -> lldb::SymbolType

SBSymbol_IsExternal(...)
SBSymbol_IsExternal(SBSymbol self) -> bool

SBSymbol_IsSynthetic(...)
SBSymbol_IsSynthetic(SBSymbol self) -> bool

SBSymbol_IsValid(...)
SBSymbol_IsValid(SBSymbol self) -> bool

SBSymbol___eq__(...)
SBSymbol___eq__(SBSymbol self, SBSymbol rhs) -> bool

SBSymbol___ne__(...)
SBSymbol___ne__(SBSymbol self, SBSymbol rhs) -> bool

SBSymbol___str__(...)
SBSymbol___str__(SBSymbol self) -> PyObject *

SBSymbol_swigregister(...)

SBTarget_AddModule(...)
AddModule(SBModule module) -> bool AddModule(char const * path, char const * triple, char const * uuid) -> SBModule AddModule(char const * path, char const * triple, char const * uuid_cstr, char const * symfile) -> SBModule SBTarget_AddModule(SBTarget self, SBModuleSpec module_spec) -> SBModule

SBTarget_Attach(...)
SBTarget_Attach(SBTarget self, SBAttachInfo attach_info, SBError error) -> SBProcess

SBTarget_AttachToProcessWithID(...)
SBTarget_AttachToProcessWithID(SBTarget self, SBListener listener, lldb::pid_t pid, SBError error) -> SBProcess

SBTarget_AttachToProcessWithName(...)
SBTarget_AttachToProcessWithName(SBTarget self, SBListener listener, char const * name, bool wait_for, SBError error) -> SBProcess

SBTarget_BreakpointCreateByAddress(...)
SBTarget_BreakpointCreateByAddress(SBTarget self, lldb::addr_t address) -> SBBreakpoint

SBTarget_BreakpointCreateByLocation(...)
BreakpointCreateByLocation(char const * file, uint32_t line) -> SBBreakpoint BreakpointCreateByLocation(SBFileSpec file_spec, uint32_t line) -> SBBreakpoint BreakpointCreateByLocation(SBFileSpec file_spec, uint32_t line, lldb::addr_t offset) -> SBBreakpoint SBTarget_BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint

SBTarget_BreakpointCreateByName(...)
BreakpointCreateByName(char const * symbol_name, char const * module_name=None) -> SBBreakpoint...

SBTarget_BreakpointCreateByNames(...)
BreakpointCreateByNames(char const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint...

SBTarget_BreakpointCreateByRegex(...)
BreakpointCreateByRegex(char const * symbol_name_regex, char const * module_name=None) -> SBBreakpoint...

SBTarget_BreakpointCreateBySBAddress(...)
SBTarget_BreakpointCreateBySBAddress(SBTarget self, SBAddress sb_address) -> SBBreakpoint

SBTarget_BreakpointCreateBySourceRegex(...)
BreakpointCreateBySourceRegex(char const * source_regex, SBFileSpec source_file, char const * module_name=None) -> SBBreakpoint...

SBTarget_BreakpointCreateForException(...)
SBTarget_BreakpointCreateForException(SBTarget self, lldb::LanguageType language, bool catch_bp, bool throw_bp) -> SBBreakpoint

SBTarget_BreakpointDelete(...)
SBTarget_BreakpointDelete(SBTarget self, lldb::break_id_t break_id) -> bool

SBTarget_BreakpointsCreateFromFile(...)
BreakpointsCreateFromFile(SBFileSpec source_file, SBBreakpointList bkpt_list) -> SBError SBTarget_BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBStringList matching_names, SBBreakpointList new_bps) -> SBError

SBTarget_BreakpointsWriteToFile(...)
BreakpointsWriteToFile(SBFileSpec dest_file) -> SBError BreakpointsWriteToFile(SBFileSpec dest_file, SBBreakpointList bkpt_list, bool append=False) -> SBError SBTarget_BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file, SBBreakpointList bkpt_list) -> SBError

SBTarget_Clear(...)
SBTarget_Clear(SBTarget self)

SBTarget_ClearModuleLoadAddress(...)
SBTarget_ClearModuleLoadAddress(SBTarget self, SBModule module) -> SBError

SBTarget_ClearSectionLoadAddress(...)
SBTarget_ClearSectionLoadAddress(SBTarget self, SBSection section) -> SBError

SBTarget_ConnectRemote(...)
SBTarget_ConnectRemote(SBTarget self, SBListener listener, char const * url, char const * plugin_name, SBError error) -> SBProcess

SBTarget_CreateValueFromAddress(...)
SBTarget_CreateValueFromAddress(SBTarget self, char const * name, SBAddress addr, SBType type) -> SBValue

SBTarget_CreateValueFromData(...)
SBTarget_CreateValueFromData(SBTarget self, char const * name, SBData data, SBType type) -> SBValue

SBTarget_CreateValueFromExpression(...)
SBTarget_CreateValueFromExpression(SBTarget self, char const * name, char const * expr) -> SBValue

SBTarget_DeleteAllBreakpoints(...)
SBTarget_DeleteAllBreakpoints(SBTarget self) -> bool

SBTarget_DeleteAllWatchpoints(...)
SBTarget_DeleteAllWatchpoints(SBTarget self) -> bool

SBTarget_DeleteWatchpoint(...)
SBTarget_DeleteWatchpoint(SBTarget self, lldb::watch_id_t watch_id) -> bool

SBTarget_DisableAllBreakpoints(...)
SBTarget_DisableAllBreakpoints(SBTarget self) -> bool

SBTarget_DisableAllWatchpoints(...)
SBTarget_DisableAllWatchpoints(SBTarget self) -> bool

SBTarget_EnableAllBreakpoints(...)
SBTarget_EnableAllBreakpoints(SBTarget self) -> bool

SBTarget_EnableAllWatchpoints(...)
SBTarget_EnableAllWatchpoints(SBTarget self) -> bool

SBTarget_EvaluateExpression(...)
EvaluateExpression(char const * expr) -> SBValue SBTarget_EvaluateExpression(SBTarget self, char const * expr, SBExpressionOptions options) -> SBValue

SBTarget_EventIsTargetEvent(...)
SBTarget_EventIsTargetEvent(SBEvent event) -> bool

SBTarget_FindBreakpointByID(...)
SBTarget_FindBreakpointByID(SBTarget self, lldb::break_id_t break_id) -> SBBreakpoint

SBTarget_FindBreakpointsByName(...)
SBTarget_FindBreakpointsByName(SBTarget self, char const * name, SBBreakpointList bkpt_list) -> bool

SBTarget_FindFirstGlobalVariable(...)
SBTarget_FindFirstGlobalVariable(SBTarget self, char const * name) -> SBValue

SBTarget_FindFirstType(...)
SBTarget_FindFirstType(SBTarget self, char const * type) -> SBType

SBTarget_FindFunctions(...)
FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBTarget_FindFunctions(SBTarget self, char const * name) -> SBSymbolContextList

SBTarget_FindGlobalFunctions(...)
SBTarget_FindGlobalFunctions(SBTarget self, char const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBSymbolContextList

SBTarget_FindGlobalVariables(...)
FindGlobalVariables(char const * name, uint32_t max_matches) -> SBValueList SBTarget_FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBValueList

SBTarget_FindModule(...)
SBTarget_FindModule(SBTarget self, SBFileSpec file_spec) -> SBModule

SBTarget_FindSymbols(...)
FindSymbols(char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList SBTarget_FindSymbols(SBTarget self, char const * name) -> SBSymbolContextList

SBTarget_FindTypes(...)
SBTarget_FindTypes(SBTarget self, char const * type) -> SBTypeList

SBTarget_FindWatchpointByID(...)
SBTarget_FindWatchpointByID(SBTarget self, lldb::watch_id_t watch_id) -> SBWatchpoint

SBTarget_GetAddressByteSize(...)
SBTarget_GetAddressByteSize(SBTarget self) -> uint32_t

SBTarget_GetBasicType(...)
SBTarget_GetBasicType(SBTarget self, lldb::BasicType type) -> SBType

SBTarget_GetBreakpointAtIndex(...)
SBTarget_GetBreakpointAtIndex(SBTarget self, uint32_t idx) -> SBBreakpoint

SBTarget_GetBroadcaster(...)
SBTarget_GetBroadcaster(SBTarget self) -> SBBroadcaster

char const *

SBTarget_GetBroadcasterClassName()

SBTarget_GetByteOrder(...)
SBTarget_GetByteOrder(SBTarget self) -> lldb::ByteOrder

SBTarget_GetCodeByteSize(...)
SBTarget_GetCodeByteSize(SBTarget self) -> uint32_t

SBTarget_GetDataByteSize(...)
SBTarget_GetDataByteSize(SBTarget self) -> uint32_t

SBTarget_GetDebugger(...)
SBTarget_GetDebugger(SBTarget self) -> SBDebugger

SBTarget_GetDescription(...)
SBTarget_GetDescription(SBTarget self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTarget_GetExecutable(...)
SBTarget_GetExecutable(SBTarget self) -> SBFileSpec

SBTarget_GetInstructions(...)
SBTarget_GetInstructions(SBTarget self, SBAddress base_addr, void const * buf) -> SBInstructionList

SBTarget_GetInstructionsWithFlavor(...)
SBTarget_GetInstructionsWithFlavor(SBTarget self, SBAddress base_addr, char const * flavor_string, void const * buf) -> SBInstructionList

SBTarget_GetLaunchInfo(...)
SBTarget_GetLaunchInfo(SBTarget self) -> SBLaunchInfo

SBTarget_GetModuleAtIndex(...)
SBTarget_GetModuleAtIndex(SBTarget self, uint32_t idx) -> SBModule

SBTarget_GetModuleAtIndexFromEvent(...)
SBTarget_GetModuleAtIndexFromEvent(uint32_t const idx, SBEvent event) -> SBModule

SBTarget_GetNumBreakpoints(...)
SBTarget_GetNumBreakpoints(SBTarget self) -> uint32_t

SBTarget_GetNumModules(...)
SBTarget_GetNumModules(SBTarget self) -> uint32_t

SBTarget_GetNumModulesFromEvent(...)
SBTarget_GetNumModulesFromEvent(SBEvent event) -> uint32_t

SBTarget_GetNumWatchpoints(...)
SBTarget_GetNumWatchpoints(SBTarget self) -> uint32_t

SBTarget_GetPlatform(...)
SBTarget_GetPlatform(SBTarget self) -> SBPlatform

SBTarget_GetProcess(...)
SBTarget_GetProcess(SBTarget self) -> SBProcess

SBTarget_GetSourceManager(...)
SBTarget_GetSourceManager(SBTarget self) -> SBSourceManager

SBTarget_GetStackRedZoneSize(...)
SBTarget_GetStackRedZoneSize(SBTarget self) -> lldb::addr_t

SBTarget_GetTargetFromEvent(...)
SBTarget_GetTargetFromEvent(SBEvent event) -> SBTarget

SBTarget_GetTriple(...)
SBTarget_GetTriple(SBTarget self) -> char const *

SBTarget_GetWatchpointAtIndex(...)
SBTarget_GetWatchpointAtIndex(SBTarget self, uint32_t idx) -> SBWatchpoint

SBTarget_Install(...)
SBTarget_Install(SBTarget self) -> SBError

SBTarget_IsValid(...)
SBTarget_IsValid(SBTarget self) -> bool

SBTarget_Launch(...)
Launch(SBListener listener, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess SBTarget_Launch(SBTarget self, SBLaunchInfo launch_info, SBError error) -> SBProcess

SBTarget_LaunchSimple(...)
SBTarget_LaunchSimple(SBTarget self, char const ** argv, char const ** envp, char const * working_directory) -> SBProcess

SBTarget_LoadCore(...)
SBTarget_LoadCore(SBTarget self, char const * core_file) -> SBProcess

SBTarget_ReadInstructions(...)
ReadInstructions(SBAddress base_addr, uint32_t count) -> SBInstructionList SBTarget_ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, char const * flavor_string) -> SBInstructionList

SBTarget_ReadMemory(...)
SBTarget_ReadMemory(SBTarget self, SBAddress addr, void * buf, SBError error) -> size_t

SBTarget_RemoveModule(...)
SBTarget_RemoveModule(SBTarget self, SBModule module) -> bool

SBTarget_ResolveFileAddress(...)
SBTarget_ResolveFileAddress(SBTarget self, lldb::addr_t file_addr) -> SBAddress

SBTarget_ResolveLoadAddress(...)
SBTarget_ResolveLoadAddress(SBTarget self, lldb::addr_t vm_addr) -> SBAddress

SBTarget_ResolvePastLoadAddress(...)
SBTarget_ResolvePastLoadAddress(SBTarget self, uint32_t stop_id, lldb::addr_t vm_addr) -> SBAddress

SBTarget_ResolveSymbolContextForAddress(...)
SBTarget_ResolveSymbolContextForAddress(SBTarget self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext

SBTarget_SetLaunchInfo(...)
SBTarget_SetLaunchInfo(SBTarget self, SBLaunchInfo launch_info)

SBTarget_SetModuleLoadAddress(...)
SBTarget_SetModuleLoadAddress(SBTarget self, SBModule module, int64_t sections_offset) -> SBError

SBTarget_SetSectionLoadAddress(...)
SBTarget_SetSectionLoadAddress(SBTarget self, SBSection section, lldb::addr_t section_base_addr) -> SBError

SBTarget_WatchAddress(...)
SBTarget_WatchAddress(SBTarget self, lldb::addr_t addr, size_t size, bool read, bool write, SBError error) -> SBWatchpoint

SBTarget___eq__(...)
SBTarget___eq__(SBTarget self, SBTarget rhs) -> bool

SBTarget___ne__(...)
SBTarget___ne__(SBTarget self, SBTarget rhs) -> bool

SBTarget___str__(...)
SBTarget___str__(SBTarget self) -> PyObject *

SBTarget_swigregister(...)

SBThreadCollection_GetSize(...)
SBThreadCollection_GetSize(SBThreadCollection self) -> size_t

SBThreadCollection_GetThreadAtIndex(...)
SBThreadCollection_GetThreadAtIndex(SBThreadCollection self, size_t idx) -> SBThread

SBThreadCollection_IsValid(...)
SBThreadCollection_IsValid(SBThreadCollection self) -> bool

SBThreadCollection_swigregister(...)

SBThreadPlan_Clear(...)
SBThreadPlan_Clear(SBThreadPlan self)

SBThreadPlan_GetDescription(...)
SBThreadPlan_GetDescription(SBThreadPlan self, SBStream description) -> bool

SBThreadPlan_GetStopReason(...)
SBThreadPlan_GetStopReason(SBThreadPlan self) -> lldb::StopReason

SBThreadPlan_GetStopReasonDataAtIndex(...)
SBThreadPlan_GetStopReasonDataAtIndex(SBThreadPlan self, uint32_t idx) -> uint64_t

SBThreadPlan_GetStopReasonDataCount(...)
SBThreadPlan_GetStopReasonDataCount(SBThreadPlan self) -> size_t

SBThreadPlan_GetThread(...)
SBThreadPlan_GetThread(SBThreadPlan self) -> SBThread

SBThreadPlan_IsPlanComplete(...)
SBThreadPlan_IsPlanComplete(SBThreadPlan self) -> bool

SBThreadPlan_IsPlanStale(...)
SBThreadPlan_IsPlanStale(SBThreadPlan self) -> bool

bool

SBThreadPlan_IsValid()
SBThreadPlan_IsValid(SBThreadPlan self) -> bool

SBThreadPlan_QueueThreadPlanForRunToAddress(...)
SBThreadPlan_QueueThreadPlanForRunToAddress(SBThreadPlan self, SBAddress address) -> SBThreadPlan

SBThreadPlan_QueueThreadPlanForStepInRange(...)
SBThreadPlan_QueueThreadPlanForStepInRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan

SBThreadPlan_QueueThreadPlanForStepOut(...)
QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to, bool first_insn=False) -> SBThreadPlan SBThreadPlan_QueueThreadPlanForStepOut(SBThreadPlan self, uint32_t frame_idx_to_step_to) -> SBThreadPlan

SBThreadPlan_QueueThreadPlanForStepOverRange(...)
SBThreadPlan_QueueThreadPlanForStepOverRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan

SBThreadPlan_SetPlanComplete(...)
SBThreadPlan_SetPlanComplete(SBThreadPlan self, bool success)

SBThreadPlan_swigregister(...)

SBThread_Clear(...)
SBThread_Clear(SBThread self)

SBThread_EventIsThreadEvent(...)
SBThread_EventIsThreadEvent(SBEvent event) -> bool

char const *

SBThread_GetBroadcasterClassName()

SBThread_GetDescription(...)
SBThread_GetDescription(SBThread self, SBStream description) -> bool

SBThread_GetExtendedBacktraceOriginatingIndexID(...)
Takes no arguments, returns a uint32_t.

SBThread_GetExtendedBacktraceThread(...)
Given an argument of str to specify the type of thread-origin extended backtrace to retrieve, query whether the origin of this thread is available.

SBThread_GetFrameAtIndex(...)
SBThread_GetFrameAtIndex(SBThread self, uint32_t idx) -> SBFrame

SBThread_GetIndexID(...)
Return the index number for this SBThread.

SBThread_GetInfoItemByPathAsString(...)
Takes a path string and a SBStream reference as parameters, returns a bool.

SBThread_GetName(...)
SBThread_GetName(SBThread self) -> char const *

SBThread_GetNumFrames(...)
SBThread_GetNumFrames(SBThread self) -> uint32_t

SBThread_GetProcess(...)
SBThread_GetProcess(SBThread self) -> SBProcess

SBThread_GetQueue(...)
Return the SBQueue for this thread.

SBThread_GetQueueID(...)
Return the dispatch_queue_id for this thread, if any, as a lldb::queue_id_t.

SBThread_GetQueueName(...)
Return the queue name associated with this thread, if any, as a str.

SBThread_GetSelectedFrame(...)
SBThread_GetSelectedFrame(SBThread self) -> SBFrame

SBThread_GetStackFrameFromEvent(...)
SBThread_GetStackFrameFromEvent(SBEvent event) -> SBFrame

SBThread_GetStatus(...)
SBThread_GetStatus(SBThread self, SBStream status) -> bool

SBThread_GetStopDescription(...)
Pass only an (int)length and expect to get a Python string describing the stop reason.

SBThread_GetStopReason(...)
SBThread_GetStopReason(SBThread self) -> lldb::StopReason

SBThread_GetStopReasonDataAtIndex(...)
SBThread_GetStopReasonDataAtIndex(SBThread self, uint32_t idx) -> uint64_t

SBThread_GetStopReasonDataCount(...)
SBThread_GetStopReasonDataCount(SBThread self) -> size_t

SBThread_GetStopReasonExtendedBacktraces(...)
Returns a collection of historical stack traces that are significant to the current stop reason.

SBThread_GetStopReasonExtendedInfoAsJSON(...)
Collects a thread's stop reason extended information dictionary and prints it into the SBStream in a JSON format.

SBThread_GetStopReturnValue(...)
SBThread_GetStopReturnValue(SBThread self) -> SBValue

SBThread_GetThreadFromEvent(...)
SBThread_GetThreadFromEvent(SBEvent event) -> SBThread

SBThread_GetThreadID(...)
Returns a unique thread identifier (type lldb::tid_t, typically a 64-bit type) for the current SBThread that will remain constant throughout the thread's lifetime in this process and will not be reused by another thread during this process lifetime.

SBThread_IsStopped(...)
SBThread_IsStopped(SBThread self) -> bool

SBThread_IsSuspended(...)
SBThread_IsSuspended(SBThread self) -> bool

SBThread_IsValid(...)
SBThread_IsValid(SBThread self) -> bool

SBThread_JumpToLine(...)
SBThread_JumpToLine(SBThread self, SBFileSpec file_spec, uint32_t line) -> SBError

SBThread_Resume(...)
SBThread_Resume(SBThread self) -> bool

SBThread_ReturnFromFrame(...)
Force a return from the frame passed in (and any frames younger than it) without executing any more code in those frames.

SBThread_RunToAddress(...)
SBThread_RunToAddress(SBThread self, lldb::addr_t addr)

SBThread_SafeToCallFunctions(...)
Takes no arguments, returns a bool.

SBThread_SetSelectedFrame(...)
SBThread_SetSelectedFrame(SBThread self, uint32_t frame_idx) -> SBFrame

SBThread_StepInstruction(...)
SBThread_StepInstruction(SBThread self, bool step_over)

SBThread_StepInto(...)
StepInto(lldb::RunMode stop_other_threads=eOnlyDuringStepping) StepInto() StepInto(char const * target_name, lldb::RunMode stop_other_threads=eOnlyDuringStepping) StepInto(char const * target_name)

SBThread_StepOut(...)
SBThread_StepOut(SBThread self)

SBThread_StepOutOfFrame(...)
SBThread_StepOutOfFrame(SBThread self, SBFrame frame)

SBThread_StepOver(...)
StepOver(lldb::RunMode stop_other_threads=eOnlyDuringStepping) SBThread_StepOver(SBThread self)

SBThread_StepOverUntil(...)
SBThread_StepOverUntil(SBThread self, SBFrame frame, SBFileSpec file_spec, uint32_t line) -> SBError

SBThread_StepUsingScriptedThreadPlan(...)
StepUsingScriptedThreadPlan(char const * script_class_name) -> SBError SBThread_StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name, bool resume_immediately) -> SBError

SBThread_Suspend(...)
SBThread_Suspend(SBThread self) -> bool

SBThread_UnwindInnermostExpression(...)
Unwind the stack frames from the innermost expression evaluation.

SBThread___eq__(...)
SBThread___eq__(SBThread self, SBThread rhs) -> bool

SBThread___ne__(...)
SBThread___ne__(SBThread self, SBThread rhs) -> bool

SBThread___str__(...)
SBThread___str__(SBThread self) -> PyObject *

SBThread_swigregister(...)

SBTypeCategory_AddLanguage(...)
SBTypeCategory_AddLanguage(SBTypeCategory self, lldb::LanguageType language)

SBTypeCategory_AddTypeFilter(...)
SBTypeCategory_AddTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFilter arg3) -> bool

SBTypeCategory_AddTypeFormat(...)
SBTypeCategory_AddTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFormat arg3) -> bool

SBTypeCategory_AddTypeSummary(...)
SBTypeCategory_AddTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSummary arg3) -> bool

SBTypeCategory_AddTypeSynthetic(...)
SBTypeCategory_AddTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSynthetic arg3) -> bool

SBTypeCategory_DeleteTypeFilter(...)
SBTypeCategory_DeleteTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_DeleteTypeFormat(...)
SBTypeCategory_DeleteTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_DeleteTypeSummary(...)
SBTypeCategory_DeleteTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_DeleteTypeSynthetic(...)
SBTypeCategory_DeleteTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_GetDescription(...)
SBTypeCategory_GetDescription(SBTypeCategory self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeCategory_GetEnabled(...)
SBTypeCategory_GetEnabled(SBTypeCategory self) -> bool

SBTypeCategory_GetFilterAtIndex(...)
SBTypeCategory_GetFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFilter

SBTypeCategory_GetFilterForType(...)
SBTypeCategory_GetFilterForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFilter

SBTypeCategory_GetFormatAtIndex(...)
SBTypeCategory_GetFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFormat

SBTypeCategory_GetFormatForType(...)
SBTypeCategory_GetFormatForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFormat

SBTypeCategory_GetLanguageAtIndex(...)
SBTypeCategory_GetLanguageAtIndex(SBTypeCategory self, uint32_t idx) -> lldb::LanguageType

SBTypeCategory_GetName(...)
SBTypeCategory_GetName(SBTypeCategory self) -> char const *

SBTypeCategory_GetNumFilters(...)
SBTypeCategory_GetNumFilters(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetNumFormats(...)
SBTypeCategory_GetNumFormats(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetNumLanguages(...)
SBTypeCategory_GetNumLanguages(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetNumSummaries(...)
SBTypeCategory_GetNumSummaries(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetNumSynthetics(...)
SBTypeCategory_GetNumSynthetics(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetSummaryAtIndex(...)
SBTypeCategory_GetSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSummary

SBTypeCategory_GetSummaryForType(...)
SBTypeCategory_GetSummaryForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSummary

SBTypeCategory_GetSyntheticAtIndex(...)
SBTypeCategory_GetSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSynthetic

SBTypeCategory_GetSyntheticForType(...)
SBTypeCategory_GetSyntheticForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic

SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_IsValid(...)
SBTypeCategory_IsValid(SBTypeCategory self) -> bool

SBTypeCategory_SetEnabled(...)
SBTypeCategory_SetEnabled(SBTypeCategory self, bool arg2)

SBTypeCategory___str__(...)
SBTypeCategory___str__(SBTypeCategory self) -> PyObject *

SBTypeCategory_swigregister(...)

SBTypeEnumMemberList_Append(...)
SBTypeEnumMemberList_Append(SBTypeEnumMemberList self, SBTypeEnumMember entry)

SBTypeEnumMemberList_GetSize(...)
SBTypeEnumMemberList_GetSize(SBTypeEnumMemberList self) -> uint32_t

SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(...)
SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(SBTypeEnumMemberList self, uint32_t index) -> SBTypeEnumMember

SBTypeEnumMemberList_IsValid(...)
SBTypeEnumMemberList_IsValid(SBTypeEnumMemberList self) -> bool

SBTypeEnumMemberList_swigregister(...)

SBTypeEnumMember_GetDescription(...)
SBTypeEnumMember_GetDescription(SBTypeEnumMember self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeEnumMember_GetName(...)
SBTypeEnumMember_GetName(SBTypeEnumMember self) -> char const *

SBTypeEnumMember_GetType(...)
SBTypeEnumMember_GetType(SBTypeEnumMember self) -> SBType

SBTypeEnumMember_GetValueAsSigned(...)
SBTypeEnumMember_GetValueAsSigned(SBTypeEnumMember self) -> int64_t

SBTypeEnumMember_GetValueAsUnsigned(...)
SBTypeEnumMember_GetValueAsUnsigned(SBTypeEnumMember self) -> uint64_t

SBTypeEnumMember_IsValid(...)
SBTypeEnumMember_IsValid(SBTypeEnumMember self) -> bool

SBTypeEnumMember___str__(...)
SBTypeEnumMember___str__(SBTypeEnumMember self) -> PyObject *

SBTypeEnumMember_swigregister(...)

SBTypeFilter_AppendExpressionPath(...)
SBTypeFilter_AppendExpressionPath(SBTypeFilter self, char const * item)

SBTypeFilter_Clear(...)
SBTypeFilter_Clear(SBTypeFilter self)

SBTypeFilter_GetDescription(...)
SBTypeFilter_GetDescription(SBTypeFilter self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeFilter_GetExpressionPathAtIndex(...)
SBTypeFilter_GetExpressionPathAtIndex(SBTypeFilter self, uint32_t i) -> char const *

SBTypeFilter_GetNumberOfExpressionPaths(...)
SBTypeFilter_GetNumberOfExpressionPaths(SBTypeFilter self) -> uint32_t

SBTypeFilter_GetOptions(...)
SBTypeFilter_GetOptions(SBTypeFilter self) -> uint32_t

SBTypeFilter_IsEqualTo(...)
SBTypeFilter_IsEqualTo(SBTypeFilter self, SBTypeFilter rhs) -> bool

SBTypeFilter_IsValid(...)
SBTypeFilter_IsValid(SBTypeFilter self) -> bool

SBTypeFilter_ReplaceExpressionPathAtIndex(...)
SBTypeFilter_ReplaceExpressionPathAtIndex(SBTypeFilter self, uint32_t i, char const * item) -> bool

SBTypeFilter_SetOptions(...)
SBTypeFilter_SetOptions(SBTypeFilter self, uint32_t arg2)

SBTypeFilter___eq__(...)
SBTypeFilter___eq__(SBTypeFilter self, SBTypeFilter rhs) -> bool

SBTypeFilter___ne__(...)
SBTypeFilter___ne__(SBTypeFilter self, SBTypeFilter rhs) -> bool

SBTypeFilter___str__(...)
SBTypeFilter___str__(SBTypeFilter self) -> PyObject *

SBTypeFilter_swigregister(...)

SBTypeFormat_GetDescription(...)
SBTypeFormat_GetDescription(SBTypeFormat self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeFormat_GetFormat(...)
SBTypeFormat_GetFormat(SBTypeFormat self) -> lldb::Format

SBTypeFormat_GetOptions(...)
SBTypeFormat_GetOptions(SBTypeFormat self) -> uint32_t

SBTypeFormat_GetTypeName(...)
SBTypeFormat_GetTypeName(SBTypeFormat self) -> char const *

SBTypeFormat_IsEqualTo(...)
SBTypeFormat_IsEqualTo(SBTypeFormat self, SBTypeFormat rhs) -> bool

SBTypeFormat_IsValid(...)
SBTypeFormat_IsValid(SBTypeFormat self) -> bool

SBTypeFormat_SetFormat(...)
SBTypeFormat_SetFormat(SBTypeFormat self, lldb::Format arg2)

SBTypeFormat_SetOptions(...)
SBTypeFormat_SetOptions(SBTypeFormat self, uint32_t arg2)

SBTypeFormat_SetTypeName(...)
SBTypeFormat_SetTypeName(SBTypeFormat self, char const * arg2)

SBTypeFormat___eq__(...)
SBTypeFormat___eq__(SBTypeFormat self, SBTypeFormat rhs) -> bool

SBTypeFormat___ne__(...)
SBTypeFormat___ne__(SBTypeFormat self, SBTypeFormat rhs) -> bool

SBTypeFormat___str__(...)
SBTypeFormat___str__(SBTypeFormat self) -> PyObject *

SBTypeFormat_swigregister(...)

SBTypeList_Append(...)
SBTypeList_Append(SBTypeList self, SBType type)

SBTypeList_GetSize(...)
SBTypeList_GetSize(SBTypeList self) -> uint32_t

SBTypeList_GetTypeAtIndex(...)
SBTypeList_GetTypeAtIndex(SBTypeList self, uint32_t index) -> SBType

SBTypeList_IsValid(...)
SBTypeList_IsValid(SBTypeList self) -> bool

SBTypeList_swigregister(...)

SBTypeMemberFunction_GetArgumentTypeAtIndex(...)
SBTypeMemberFunction_GetArgumentTypeAtIndex(SBTypeMemberFunction self, uint32_t arg2) -> SBType

SBTypeMemberFunction_GetDemangledName(...)
SBTypeMemberFunction_GetDemangledName(SBTypeMemberFunction self) -> char const *

SBTypeMemberFunction_GetDescription(...)
SBTypeMemberFunction_GetDescription(SBTypeMemberFunction self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeMemberFunction_GetKind(...)
SBTypeMemberFunction_GetKind(SBTypeMemberFunction self) -> lldb::MemberFunctionKind

SBTypeMemberFunction_GetMangledName(...)
SBTypeMemberFunction_GetMangledName(SBTypeMemberFunction self) -> char const *

SBTypeMemberFunction_GetName(...)
SBTypeMemberFunction_GetName(SBTypeMemberFunction self) -> char const *

SBTypeMemberFunction_GetNumberOfArguments(...)
SBTypeMemberFunction_GetNumberOfArguments(SBTypeMemberFunction self) -> uint32_t

SBTypeMemberFunction_GetReturnType(...)
SBTypeMemberFunction_GetReturnType(SBTypeMemberFunction self) -> SBType

SBTypeMemberFunction_GetType(...)
SBTypeMemberFunction_GetType(SBTypeMemberFunction self) -> SBType

SBTypeMemberFunction_IsValid(...)
SBTypeMemberFunction_IsValid(SBTypeMemberFunction self) -> bool

SBTypeMemberFunction___str__(...)
SBTypeMemberFunction___str__(SBTypeMemberFunction self) -> PyObject *

SBTypeMemberFunction_swigregister(...)

SBTypeMember_GetBitfieldSizeInBits(...)
SBTypeMember_GetBitfieldSizeInBits(SBTypeMember self) -> uint32_t

SBTypeMember_GetName(...)
SBTypeMember_GetName(SBTypeMember self) -> char const *

SBTypeMember_GetOffsetInBits(...)
SBTypeMember_GetOffsetInBits(SBTypeMember self) -> uint64_t

SBTypeMember_GetOffsetInBytes(...)
SBTypeMember_GetOffsetInBytes(SBTypeMember self) -> uint64_t

SBTypeMember_GetType(...)
SBTypeMember_GetType(SBTypeMember self) -> SBType

SBTypeMember_IsBitfield(...)
SBTypeMember_IsBitfield(SBTypeMember self) -> bool

SBTypeMember_IsValid(...)
SBTypeMember_IsValid(SBTypeMember self) -> bool

SBTypeMember___str__(...)
SBTypeMember___str__(SBTypeMember self) -> PyObject *

SBTypeMember_swigregister(...)

SBTypeNameSpecifier_GetDescription(...)
SBTypeNameSpecifier_GetDescription(SBTypeNameSpecifier self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeNameSpecifier_GetName(...)
SBTypeNameSpecifier_GetName(SBTypeNameSpecifier self) -> char const *

SBTypeNameSpecifier_GetType(...)
SBTypeNameSpecifier_GetType(SBTypeNameSpecifier self) -> SBType

SBTypeNameSpecifier_IsEqualTo(...)
SBTypeNameSpecifier_IsEqualTo(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool

SBTypeNameSpecifier_IsRegex(...)
SBTypeNameSpecifier_IsRegex(SBTypeNameSpecifier self) -> bool

SBTypeNameSpecifier_IsValid(...)
SBTypeNameSpecifier_IsValid(SBTypeNameSpecifier self) -> bool

SBTypeNameSpecifier___eq__(...)
SBTypeNameSpecifier___eq__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool

SBTypeNameSpecifier___ne__(...)
SBTypeNameSpecifier___ne__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool

SBTypeNameSpecifier___str__(...)
SBTypeNameSpecifier___str__(SBTypeNameSpecifier self) -> PyObject *

SBTypeNameSpecifier_swigregister(...)

SBTypeSummaryOptions_GetCapping(...)
SBTypeSummaryOptions_GetCapping(SBTypeSummaryOptions self) -> lldb::TypeSummaryCapping

SBTypeSummaryOptions_GetLanguage(...)
SBTypeSummaryOptions_GetLanguage(SBTypeSummaryOptions self) -> lldb::LanguageType

SBTypeSummaryOptions_IsValid(...)
SBTypeSummaryOptions_IsValid(SBTypeSummaryOptions self) -> bool

SBTypeSummaryOptions_SetCapping(...)
SBTypeSummaryOptions_SetCapping(SBTypeSummaryOptions self, lldb::TypeSummaryCapping arg2)

SBTypeSummaryOptions_SetLanguage(...)
SBTypeSummaryOptions_SetLanguage(SBTypeSummaryOptions self, lldb::LanguageType arg2)

SBTypeSummaryOptions_swigregister(...)

SBTypeSummary_CreateWithFunctionName(...)
CreateWithFunctionName(char const * data, uint32_t options=0) -> SBTypeSummary SBTypeSummary_CreateWithFunctionName(char const * data) -> SBTypeSummary

SBTypeSummary_CreateWithScriptCode(...)
CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSummary SBTypeSummary_CreateWithScriptCode(char const * data) -> SBTypeSummary

SBTypeSummary_CreateWithSummaryString(...)
CreateWithSummaryString(char const * data, uint32_t options=0) -> SBTypeSummary SBTypeSummary_CreateWithSummaryString(char const * data) -> SBTypeSummary

SBTypeSummary_GetData(...)
SBTypeSummary_GetData(SBTypeSummary self) -> char const *

SBTypeSummary_GetDescription(...)
SBTypeSummary_GetDescription(SBTypeSummary self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeSummary_GetOptions(...)
SBTypeSummary_GetOptions(SBTypeSummary self) -> uint32_t

SBTypeSummary_IsEqualTo(...)
SBTypeSummary_IsEqualTo(SBTypeSummary self, SBTypeSummary rhs) -> bool

SBTypeSummary_IsFunctionCode(...)
SBTypeSummary_IsFunctionCode(SBTypeSummary self) -> bool

SBTypeSummary_IsFunctionName(...)
SBTypeSummary_IsFunctionName(SBTypeSummary self) -> bool

SBTypeSummary_IsSummaryString(...)
SBTypeSummary_IsSummaryString(SBTypeSummary self) -> bool

SBTypeSummary_IsValid(...)
SBTypeSummary_IsValid(SBTypeSummary self) -> bool

SBTypeSummary_SetFunctionCode(...)
SBTypeSummary_SetFunctionCode(SBTypeSummary self, char const * data)

SBTypeSummary_SetFunctionName(...)
SBTypeSummary_SetFunctionName(SBTypeSummary self, char const * data)

SBTypeSummary_SetOptions(...)
SBTypeSummary_SetOptions(SBTypeSummary self, uint32_t arg2)

SBTypeSummary_SetSummaryString(...)
SBTypeSummary_SetSummaryString(SBTypeSummary self, char const * data)

SBTypeSummary___eq__(...)
SBTypeSummary___eq__(SBTypeSummary self, SBTypeSummary rhs) -> bool

SBTypeSummary___ne__(...)
SBTypeSummary___ne__(SBTypeSummary self, SBTypeSummary rhs) -> bool

SBTypeSummary___str__(...)
SBTypeSummary___str__(SBTypeSummary self) -> PyObject *

SBTypeSummary_swigregister(...)

SBTypeSynthetic_CreateWithClassName(...)
CreateWithClassName(char const * data, uint32_t options=0) -> SBTypeSynthetic SBTypeSynthetic_CreateWithClassName(char const * data) -> SBTypeSynthetic

SBTypeSynthetic_CreateWithScriptCode(...)
CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSynthetic SBTypeSynthetic_CreateWithScriptCode(char const * data) -> SBTypeSynthetic

SBTypeSynthetic_GetData(...)
SBTypeSynthetic_GetData(SBTypeSynthetic self) -> char const *

SBTypeSynthetic_GetDescription(...)
SBTypeSynthetic_GetDescription(SBTypeSynthetic self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeSynthetic_GetOptions(...)
SBTypeSynthetic_GetOptions(SBTypeSynthetic self) -> uint32_t

SBTypeSynthetic_IsClassCode(...)
SBTypeSynthetic_IsClassCode(SBTypeSynthetic self) -> bool

SBTypeSynthetic_IsEqualTo(...)
SBTypeSynthetic_IsEqualTo(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool

SBTypeSynthetic_IsValid(...)
SBTypeSynthetic_IsValid(SBTypeSynthetic self) -> bool

SBTypeSynthetic_SetClassCode(...)
SBTypeSynthetic_SetClassCode(SBTypeSynthetic self, char const * data)

SBTypeSynthetic_SetClassName(...)
SBTypeSynthetic_SetClassName(SBTypeSynthetic self, char const * data)

SBTypeSynthetic_SetOptions(...)
SBTypeSynthetic_SetOptions(SBTypeSynthetic self, uint32_t arg2)

SBTypeSynthetic___eq__(...)
SBTypeSynthetic___eq__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool

SBTypeSynthetic___ne__(...)
SBTypeSynthetic___ne__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool

SBTypeSynthetic___str__(...)
SBTypeSynthetic___str__(SBTypeSynthetic self) -> PyObject *

SBTypeSynthetic_swigregister(...)

SBType_GetArrayElementType(...)
SBType_GetArrayElementType(SBType self) -> SBType

SBType_GetArrayType(...)
SBType_GetArrayType(SBType self, uint64_t size) -> SBType

lldb::BasicType

SBType_GetBasicType()
SBType_GetBasicType(SBType self, lldb::BasicType type) -> SBType

SBType_GetByteSize(...)
SBType_GetByteSize(SBType self) -> uint64_t

SBType_GetCanonicalType(...)
SBType_GetCanonicalType(SBType self) -> SBType

SBType_GetDereferencedType(...)
SBType_GetDereferencedType(SBType self) -> SBType

SBType_GetDirectBaseClassAtIndex(...)
SBType_GetDirectBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember

SBType_GetDisplayTypeName(...)
SBType_GetDisplayTypeName(SBType self) -> char const *

SBType_GetEnumMembers(...)
SBType_GetEnumMembers(SBType self) -> SBTypeEnumMemberList

SBType_GetFieldAtIndex(...)
SBType_GetFieldAtIndex(SBType self, uint32_t idx) -> SBTypeMember

SBType_GetFunctionArgumentTypes(...)
SBType_GetFunctionArgumentTypes(SBType self) -> SBTypeList

SBType_GetFunctionReturnType(...)
SBType_GetFunctionReturnType(SBType self) -> SBType

SBType_GetMemberFunctionAtIndex(...)
SBType_GetMemberFunctionAtIndex(SBType self, uint32_t idx) -> SBTypeMemberFunction

SBType_GetName(...)
SBType_GetName(SBType self) -> char const *

SBType_GetNumberOfDirectBaseClasses(...)
SBType_GetNumberOfDirectBaseClasses(SBType self) -> uint32_t

SBType_GetNumberOfFields(...)
SBType_GetNumberOfFields(SBType self) -> uint32_t

SBType_GetNumberOfMemberFunctions(...)
SBType_GetNumberOfMemberFunctions(SBType self) -> uint32_t

SBType_GetNumberOfTemplateArguments(...)
SBType_GetNumberOfTemplateArguments(SBType self) -> uint32_t

SBType_GetNumberOfVirtualBaseClasses(...)
SBType_GetNumberOfVirtualBaseClasses(SBType self) -> uint32_t

SBType_GetPointeeType(...)
SBType_GetPointeeType(SBType self) -> SBType

SBType_GetPointerType(...)
SBType_GetPointerType(SBType self) -> SBType

SBType_GetReferenceType(...)
SBType_GetReferenceType(SBType self) -> SBType

SBType_GetTemplateArgumentKind(...)
SBType_GetTemplateArgumentKind(SBType self, uint32_t idx) -> lldb::TemplateArgumentKind

SBType_GetTemplateArgumentType(...)
SBType_GetTemplateArgumentType(SBType self, uint32_t idx) -> SBType

SBType_GetTypeClass(...)
SBType_GetTypeClass(SBType self) -> lldb::TypeClass

SBType_GetTypeFlags(...)
SBType_GetTypeFlags(SBType self) -> uint32_t

SBType_GetTypedefedType(...)
SBType_GetTypedefedType(SBType self) -> SBType

SBType_GetUnqualifiedType(...)
SBType_GetUnqualifiedType(SBType self) -> SBType

SBType_GetVectorElementType(...)
SBType_GetVectorElementType(SBType self) -> SBType

SBType_GetVirtualBaseClassAtIndex(...)
SBType_GetVirtualBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember

SBType_IsAnonymousType(...)
SBType_IsAnonymousType(SBType self) -> bool

SBType_IsArrayType(...)
SBType_IsArrayType(SBType self) -> bool

SBType_IsFunctionType(...)
SBType_IsFunctionType(SBType self) -> bool

SBType_IsPointerType(...)
SBType_IsPointerType(SBType self) -> bool

SBType_IsPolymorphicClass(...)
SBType_IsPolymorphicClass(SBType self) -> bool

SBType_IsReferenceType(...)
SBType_IsReferenceType(SBType self) -> bool

SBType_IsTypeComplete(...)
SBType_IsTypeComplete(SBType self) -> bool

SBType_IsTypedefType(...)
SBType_IsTypedefType(SBType self) -> bool

SBType_IsValid(...)
SBType_IsValid(SBType self) -> bool

SBType_IsVectorType(...)
SBType_IsVectorType(SBType self) -> bool

SBType___str__(...)
SBType___str__(SBType self) -> PyObject *

SBType_swigregister(...)

SBUnixSignals_Clear(...)
SBUnixSignals_Clear(SBUnixSignals self)

SBUnixSignals_GetNumSignals(...)
SBUnixSignals_GetNumSignals(SBUnixSignals self) -> int32_t

SBUnixSignals_GetShouldNotify(...)
SBUnixSignals_GetShouldNotify(SBUnixSignals self, int32_t signo) -> bool

SBUnixSignals_GetShouldStop(...)
SBUnixSignals_GetShouldStop(SBUnixSignals self, int32_t signo) -> bool

SBUnixSignals_GetShouldSuppress(...)
SBUnixSignals_GetShouldSuppress(SBUnixSignals self, int32_t signo) -> bool

SBUnixSignals_GetSignalAsCString(...)
SBUnixSignals_GetSignalAsCString(SBUnixSignals self, int32_t signo) -> char const *

SBUnixSignals_GetSignalAtIndex(...)
SBUnixSignals_GetSignalAtIndex(SBUnixSignals self, int32_t index) -> int32_t

SBUnixSignals_GetSignalNumberFromName(...)
SBUnixSignals_GetSignalNumberFromName(SBUnixSignals self, char const * name) -> int32_t

SBUnixSignals_IsValid(...)
SBUnixSignals_IsValid(SBUnixSignals self) -> bool

SBUnixSignals_SetShouldNotify(...)
SBUnixSignals_SetShouldNotify(SBUnixSignals self, int32_t signo, bool value) -> bool

SBUnixSignals_SetShouldStop(...)
SBUnixSignals_SetShouldStop(SBUnixSignals self, int32_t signo, bool value) -> bool

SBUnixSignals_SetShouldSuppress(...)
SBUnixSignals_SetShouldSuppress(SBUnixSignals self, int32_t signo, bool value) -> bool

SBUnixSignals_swigregister(...)

SBValueList_Append(...)
Append(SBValue val_obj) SBValueList_Append(SBValueList self, SBValueList value_list)

SBValueList_Clear(...)
SBValueList_Clear(SBValueList self)

SBValueList_FindValueObjectByUID(...)
SBValueList_FindValueObjectByUID(SBValueList self, lldb::user_id_t uid) -> SBValue

SBValueList_GetFirstValueByName(...)
SBValueList_GetFirstValueByName(SBValueList self, char const * name) -> SBValue

SBValueList_GetSize(...)
SBValueList_GetSize(SBValueList self) -> uint32_t

SBValueList_GetValueAtIndex(...)
SBValueList_GetValueAtIndex(SBValueList self, uint32_t idx) -> SBValue

SBValueList_IsValid(...)
SBValueList_IsValid(SBValueList self) -> bool

SBValueList___str__(...)
SBValueList___str__(SBValueList self) -> PyObject *

SBValueList_swigregister(...)

SBValue_AddressOf(...)
SBValue_AddressOf(SBValue self) -> SBValue

SBValue_Cast(...)
SBValue_Cast(SBValue self, SBType type) -> SBValue

SBValue_Clear(...)
SBValue_Clear(SBValue self)

SBValue_CreateChildAtOffset(...)
SBValue_CreateChildAtOffset(SBValue self, char const * name, uint32_t offset, SBType type) -> SBValue

SBValue_CreateValueFromAddress(...)
SBValue_CreateValueFromAddress(SBValue self, char const * name, lldb::addr_t address, SBType type) -> SBValue

SBValue_CreateValueFromData(...)
SBValue_CreateValueFromData(SBValue self, char const * name, SBData data, SBType type) -> SBValue

SBValue_CreateValueFromExpression(...)
CreateValueFromExpression(char const * name, char const * expression) -> SBValue SBValue_CreateValueFromExpression(SBValue self, char const * name, char const * expression, SBExpressionOptions options) -> SBValue

SBValue_Dereference(...)
SBValue_Dereference(SBValue self) -> SBValue

SBValue_GetAddress(...)
SBValue_GetAddress(SBValue self) -> SBAddress

SBValue_GetByteSize(...)
SBValue_GetByteSize(SBValue self) -> size_t

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

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

SBValue_GetData(...)
SBValue_GetData(SBValue self) -> SBData

SBValue_GetDeclaration(...)
SBValue_GetDeclaration(SBValue self) -> SBDeclaration

SBValue_GetDescription(...)
SBValue_GetDescription(SBValue self, SBStream description) -> bool

SBValue_GetDisplayTypeName(...)
SBValue_GetDisplayTypeName(SBValue self) -> char const *

SBValue_GetDynamicValue(...)
SBValue_GetDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic) -> SBValue

SBValue_GetError(...)
SBValue_GetError(SBValue self) -> SBError

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

SBValue_GetFormat(...)
SBValue_GetFormat(SBValue self) -> lldb::Format

SBValue_GetFrame(...)
SBValue_GetFrame(SBValue self) -> SBFrame

SBValue_GetID(...)
SBValue_GetID(SBValue self) -> lldb::user_id_t

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

SBValue_GetLoadAddress(...)
SBValue_GetLoadAddress(SBValue self) -> lldb::addr_t

SBValue_GetLocation(...)
SBValue_GetLocation(SBValue self) -> char const *

SBValue_GetName(...)
SBValue_GetName(SBValue self) -> char const *

SBValue_GetNonSyntheticValue(...)
SBValue_GetNonSyntheticValue(SBValue self) -> SBValue

uint32_t

SBValue_GetNumChildren()
SBValue_GetNumChildren(SBValue self, uint32_t max) -> uint32_t

SBValue_GetObjectDescription(...)
SBValue_GetObjectDescription(SBValue self) -> char const *

SBValue_GetOpaqueType(...)
SBValue_GetOpaqueType(SBValue self) -> void *

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

SBValue_GetPreferDynamicValue(...)
SBValue_GetPreferDynamicValue(SBValue self) -> lldb::DynamicValueType

SBValue_GetPreferSyntheticValue(...)
SBValue_GetPreferSyntheticValue(SBValue self) -> bool

SBValue_GetProcess(...)
SBValue_GetProcess(SBValue self) -> SBProcess

SBValue_GetStaticValue(...)
SBValue_GetStaticValue(SBValue self) -> SBValue

char const

SBValue_GetSummary()
SBValue_GetSummary(SBValue self, SBStream stream, SBTypeSummaryOptions options) -> char const *

SBValue_GetTarget(...)
SBValue_GetTarget(SBValue self) -> SBTarget

SBValue_GetThread(...)
SBValue_GetThread(SBValue self) -> SBThread

SBValue_GetType(...)
SBValue_GetType(SBValue self) -> SBType

SBValue_GetTypeFilter(...)
SBValue_GetTypeFilter(SBValue self) -> SBTypeFilter

SBValue_GetTypeFormat(...)
SBValue_GetTypeFormat(SBValue self) -> SBTypeFormat

SBValue_GetTypeName(...)
SBValue_GetTypeName(SBValue self) -> char const *

SBValue_GetTypeSummary(...)
SBValue_GetTypeSummary(SBValue self) -> SBTypeSummary

SBValue_GetTypeSynthetic(...)
SBValue_GetTypeSynthetic(SBValue self) -> SBTypeSynthetic

SBValue_GetTypeValidatorResult(...)
SBValue_GetTypeValidatorResult(SBValue self) -> char const *

SBValue_GetValue(...)
SBValue_GetValue(SBValue self) -> char const *

SBValue_GetValueAsSigned(...)
GetValueAsSigned(SBError error, int64_t fail_value=0) -> int64_t GetValueAsSigned(SBError error) -> int64_t GetValueAsSigned(int64_t fail_value=0) -> int64_t SBValue_GetValueAsSigned(SBValue self) -> int64_t

SBValue_GetValueAsUnsigned(...)
GetValueAsUnsigned(SBError error, uint64_t fail_value=0) -> uint64_t GetValueAsUnsigned(SBError error) -> uint64_t GetValueAsUnsigned(uint64_t fail_value=0) -> uint64_t SBValue_GetValueAsUnsigned(SBValue self) -> uint64_t

SBValue_GetValueDidChange(...)
SBValue_GetValueDidChange(SBValue self) -> bool

SBValue_GetValueForExpressionPath(...)
SBValue_GetValueForExpressionPath(SBValue self, char const * expr_path) -> SBValue

SBValue_GetValueType(...)
SBValue_GetValueType(SBValue self) -> lldb::ValueType

SBValue_IsDynamic(...)
SBValue_IsDynamic(SBValue self) -> bool

SBValue_IsInScope(...)
SBValue_IsInScope(SBValue self) -> bool

SBValue_IsRuntimeSupportValue(...)
SBValue_IsRuntimeSupportValue(SBValue self) -> bool

SBValue_IsSynthetic(...)
SBValue_IsSynthetic(SBValue self) -> bool

SBValue_IsSyntheticChildrenGenerated(...)
SBValue_IsSyntheticChildrenGenerated(SBValue self) -> bool

SBValue_IsValid(...)
SBValue_IsValid(SBValue self) -> bool

SBValue_MightHaveChildren(...)
SBValue_MightHaveChildren(SBValue self) -> bool

SBValue_Persist(...)
SBValue_Persist(SBValue self) -> SBValue

SBValue_SetData(...)
SBValue_SetData(SBValue self, SBData data, SBError error) -> bool

SBValue_SetFormat(...)
SBValue_SetFormat(SBValue self, lldb::Format format)

SBValue_SetPreferDynamicValue(...)
SBValue_SetPreferDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic)

SBValue_SetPreferSyntheticValue(...)
SBValue_SetPreferSyntheticValue(SBValue self, bool use_synthetic)

SBValue_SetSyntheticChildrenGenerated(...)
SBValue_SetSyntheticChildrenGenerated(SBValue self, bool arg2)

SBValue_SetValueFromCString(...)
SetValueFromCString(char const * value_str) -> bool SBValue_SetValueFromCString(SBValue self, char const * value_str, SBError error) -> bool

SBValue_TypeIsPointerType(...)
SBValue_TypeIsPointerType(SBValue self) -> bool

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

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

SBValue___str__(...)
SBValue___str__(SBValue self) -> PyObject *

SBValue_swigregister(...)

SBVariablesOptions_GetInScopeOnly(...)
SBVariablesOptions_GetInScopeOnly(SBVariablesOptions self) -> bool

SBVariablesOptions_GetIncludeArguments(...)
SBVariablesOptions_GetIncludeArguments(SBVariablesOptions self) -> bool

SBVariablesOptions_GetIncludeLocals(...)
SBVariablesOptions_GetIncludeLocals(SBVariablesOptions self) -> bool

SBVariablesOptions_GetIncludeRuntimeSupportValues(...)
SBVariablesOptions_GetIncludeRuntimeSupportValues(SBVariablesOptions self) -> bool

SBVariablesOptions_GetIncludeStatics(...)
SBVariablesOptions_GetIncludeStatics(SBVariablesOptions self) -> bool

SBVariablesOptions_GetUseDynamic(...)
SBVariablesOptions_GetUseDynamic(SBVariablesOptions self) -> lldb::DynamicValueType

SBVariablesOptions_IsValid(...)
SBVariablesOptions_IsValid(SBVariablesOptions self) -> bool

SBVariablesOptions_SetInScopeOnly(...)
SBVariablesOptions_SetInScopeOnly(SBVariablesOptions self, bool arg2)

SBVariablesOptions_SetIncludeArguments(...)
SBVariablesOptions_SetIncludeArguments(SBVariablesOptions self, bool arg2)

SBVariablesOptions_SetIncludeLocals(...)
SBVariablesOptions_SetIncludeLocals(SBVariablesOptions self, bool arg2)

SBVariablesOptions_SetIncludeRuntimeSupportValues(...)
SBVariablesOptions_SetIncludeRuntimeSupportValues(SBVariablesOptions self, bool arg2)

SBVariablesOptions_SetIncludeStatics(...)
SBVariablesOptions_SetIncludeStatics(SBVariablesOptions self, bool arg2)

SBVariablesOptions_SetUseDynamic(...)
SBVariablesOptions_SetUseDynamic(SBVariablesOptions self, lldb::DynamicValueType arg2)

SBVariablesOptions_swigregister(...)

SBWatchpoint_EventIsWatchpointEvent(...)
SBWatchpoint_EventIsWatchpointEvent(SBEvent event) -> bool

SBWatchpoint_GetCondition(...)
SBWatchpoint_GetCondition(SBWatchpoint self) -> char const *

SBWatchpoint_GetDescription(...)
SBWatchpoint_GetDescription(SBWatchpoint self, SBStream description, lldb::DescriptionLevel level) -> bool

SBWatchpoint_GetError(...)
SBWatchpoint_GetError(SBWatchpoint self) -> SBError

SBWatchpoint_GetHardwareIndex(...)
SBWatchpoint_GetHardwareIndex(SBWatchpoint self) -> int32_t

SBWatchpoint_GetHitCount(...)
SBWatchpoint_GetHitCount(SBWatchpoint self) -> uint32_t

SBWatchpoint_GetID(...)
SBWatchpoint_GetID(SBWatchpoint self) -> lldb::watch_id_t

SBWatchpoint_GetIgnoreCount(...)
SBWatchpoint_GetIgnoreCount(SBWatchpoint self) -> uint32_t

SBWatchpoint_GetWatchAddress(...)
SBWatchpoint_GetWatchAddress(SBWatchpoint self) -> lldb::addr_t

SBWatchpoint_GetWatchSize(...)
SBWatchpoint_GetWatchSize(SBWatchpoint self) -> size_t

SBWatchpoint_GetWatchpointEventTypeFromEvent(...)
SBWatchpoint_GetWatchpointEventTypeFromEvent(SBEvent event) -> lldb::WatchpointEventType

SBWatchpoint_GetWatchpointFromEvent(...)
SBWatchpoint_GetWatchpointFromEvent(SBEvent event) -> SBWatchpoint

SBWatchpoint_IsEnabled(...)
SBWatchpoint_IsEnabled(SBWatchpoint self) -> bool

SBWatchpoint_IsValid(...)
SBWatchpoint_IsValid(SBWatchpoint self) -> bool

SBWatchpoint_SetCondition(...)
SBWatchpoint_SetCondition(SBWatchpoint self, char const * condition)

SBWatchpoint_SetEnabled(...)
SBWatchpoint_SetEnabled(SBWatchpoint self, bool enabled)

SBWatchpoint_SetIgnoreCount(...)
SBWatchpoint_SetIgnoreCount(SBWatchpoint self, uint32_t n)

SBWatchpoint___str__(...)
SBWatchpoint___str__(SBWatchpoint self) -> PyObject *

SBWatchpoint_swigregister(...)

SWIG_PyInstanceMethod_New(...)

delete_SBAddress(...)
delete_SBAddress(SBAddress self)

delete_SBAttachInfo(...)
delete_SBAttachInfo(SBAttachInfo self)

delete_SBBlock(...)
delete_SBBlock(SBBlock self)

delete_SBBreakpoint(...)
delete_SBBreakpoint(SBBreakpoint self)

delete_SBBreakpointList(...)
delete_SBBreakpointList(SBBreakpointList self)

delete_SBBreakpointLocation(...)
delete_SBBreakpointLocation(SBBreakpointLocation self)

delete_SBBroadcaster(...)
delete_SBBroadcaster(SBBroadcaster self)

delete_SBCommandInterpreter(...)
delete_SBCommandInterpreter(SBCommandInterpreter self)

delete_SBCommandInterpreterRunOptions(...)
delete_SBCommandInterpreterRunOptions(SBCommandInterpreterRunOptions self)

delete_SBCommandReturnObject(...)
delete_SBCommandReturnObject(SBCommandReturnObject self)

delete_SBCommunication(...)
delete_SBCommunication(SBCommunication self)

delete_SBCompileUnit(...)
delete_SBCompileUnit(SBCompileUnit self)

delete_SBData(...)
delete_SBData(SBData self)

delete_SBDebugger(...)
delete_SBDebugger(SBDebugger self)

delete_SBDeclaration(...)
delete_SBDeclaration(SBDeclaration self)

delete_SBError(...)
delete_SBError(SBError self)

delete_SBEvent(...)
delete_SBEvent(SBEvent self)

delete_SBExecutionContext(...)
delete_SBExecutionContext(SBExecutionContext self)

delete_SBExpressionOptions(...)
delete_SBExpressionOptions(SBExpressionOptions self)

delete_SBFileSpec(...)
delete_SBFileSpec(SBFileSpec self)

delete_SBFileSpecList(...)
delete_SBFileSpecList(SBFileSpecList self)

delete_SBFrame(...)
delete_SBFrame(SBFrame self)

delete_SBFunction(...)
delete_SBFunction(SBFunction self)

delete_SBHostOS(...)
delete_SBHostOS(SBHostOS self)

delete_SBInstruction(...)
delete_SBInstruction(SBInstruction self)

delete_SBInstructionList(...)
delete_SBInstructionList(SBInstructionList self)

delete_SBLanguageRuntime(...)
delete_SBLanguageRuntime(SBLanguageRuntime self)

delete_SBLaunchInfo(...)
delete_SBLaunchInfo(SBLaunchInfo self)

delete_SBLineEntry(...)
delete_SBLineEntry(SBLineEntry self)

delete_SBListener(...)
delete_SBListener(SBListener self)

delete_SBMemoryRegionInfo(...)
delete_SBMemoryRegionInfo(SBMemoryRegionInfo self)

delete_SBMemoryRegionInfoList(...)
delete_SBMemoryRegionInfoList(SBMemoryRegionInfoList self)

delete_SBModule(...)
delete_SBModule(SBModule self)

delete_SBModuleSpec(...)
delete_SBModuleSpec(SBModuleSpec self)

delete_SBModuleSpecList(...)
delete_SBModuleSpecList(SBModuleSpecList self)

delete_SBPlatform(...)
delete_SBPlatform(SBPlatform self)

delete_SBPlatformConnectOptions(...)
delete_SBPlatformConnectOptions(SBPlatformConnectOptions self)

delete_SBPlatformShellCommand(...)
delete_SBPlatformShellCommand(SBPlatformShellCommand self)

delete_SBProcess(...)
delete_SBProcess(SBProcess self)

delete_SBQueue(...)
delete_SBQueue(SBQueue self)

delete_SBQueueItem(...)
delete_SBQueueItem(SBQueueItem self)

delete_SBSection(...)
delete_SBSection(SBSection self)

delete_SBSourceManager(...)
delete_SBSourceManager(SBSourceManager self)

delete_SBStream(...)
delete_SBStream(SBStream self)

delete_SBStringList(...)
delete_SBStringList(SBStringList self)

delete_SBStructuredData(...)
delete_SBStructuredData(SBStructuredData self)

delete_SBSymbol(...)
delete_SBSymbol(SBSymbol self)

delete_SBSymbolContext(...)
delete_SBSymbolContext(SBSymbolContext self)

delete_SBSymbolContextList(...)
delete_SBSymbolContextList(SBSymbolContextList self)

delete_SBTarget(...)
delete_SBTarget(SBTarget self)

delete_SBThread(...)
delete_SBThread(SBThread self)

delete_SBThreadCollection(...)
delete_SBThreadCollection(SBThreadCollection self)

delete_SBThreadPlan(...)
delete_SBThreadPlan(SBThreadPlan self)

delete_SBType(...)
delete_SBType(SBType self)

delete_SBTypeCategory(...)
delete_SBTypeCategory(SBTypeCategory self)

delete_SBTypeEnumMember(...)
delete_SBTypeEnumMember(SBTypeEnumMember self)

delete_SBTypeEnumMemberList(...)
delete_SBTypeEnumMemberList(SBTypeEnumMemberList self)

delete_SBTypeFilter(...)
delete_SBTypeFilter(SBTypeFilter self)

delete_SBTypeFormat(...)
delete_SBTypeFormat(SBTypeFormat self)

delete_SBTypeList(...)
delete_SBTypeList(SBTypeList self)

delete_SBTypeMember(...)
delete_SBTypeMember(SBTypeMember self)

delete_SBTypeMemberFunction(...)
delete_SBTypeMemberFunction(SBTypeMemberFunction self)

delete_SBTypeNameSpecifier(...)
delete_SBTypeNameSpecifier(SBTypeNameSpecifier self)

delete_SBTypeSummary(...)
delete_SBTypeSummary(SBTypeSummary self)

delete_SBTypeSummaryOptions(...)
delete_SBTypeSummaryOptions(SBTypeSummaryOptions self)

delete_SBTypeSynthetic(...)
delete_SBTypeSynthetic(SBTypeSynthetic self)

delete_SBUnixSignals(...)
delete_SBUnixSignals(SBUnixSignals self)

delete_SBValue(...)
delete_SBValue(SBValue self)

delete_SBValueList(...)
delete_SBValueList(SBValueList self)

delete_SBVariablesOptions(...)
delete_SBVariablesOptions(SBVariablesOptions self)

delete_SBWatchpoint(...)
delete_SBWatchpoint(SBWatchpoint self)

new_SBAddress()
SBAddress(SBAddress rhs) SBAddress(SBSection section, lldb::addr_t offset) new_SBAddress(lldb::addr_t load_addr, SBTarget target) -> SBAddress

new_SBAttachInfo()
SBAttachInfo(lldb::pid_t pid) SBAttachInfo(char const * path, bool wait_for) SBAttachInfo(char const * path, bool wait_for, bool async) new_SBAttachInfo(SBAttachInfo rhs) -> SBAttachInfo

new_SBBlock()
new_SBBlock(SBBlock rhs) -> SBBlock

new_SBBreakpoint()
new_SBBreakpoint(SBBreakpoint rhs) -> SBBreakpoint

new_SBBreakpointList(...)
new_SBBreakpointList(SBTarget target) -> SBBreakpointList

new_SBBreakpointLocation()
new_SBBreakpointLocation(SBBreakpointLocation rhs) -> SBBreakpointLocation

new_SBBroadcaster()
SBBroadcaster(char const * name) new_SBBroadcaster(SBBroadcaster rhs) -> SBBroadcaster

new_SBCommandInterpreter(...)
new_SBCommandInterpreter(SBCommandInterpreter rhs) -> SBCommandInterpreter

SBCommandInterpreterRunOptions

new_SBCommandInterpreterRunOptions()

new_SBCommandReturnObject()
new_SBCommandReturnObject(SBCommandReturnObject rhs) -> SBCommandReturnObject

new_SBCommunication()
new_SBCommunication(char const * broadcaster_name) -> SBCommunication

new_SBCompileUnit()
new_SBCompileUnit(SBCompileUnit rhs) -> SBCompileUnit

new_SBData()
new_SBData(SBData rhs) -> SBData

new_SBDebugger()
new_SBDebugger(SBDebugger rhs) -> SBDebugger

new_SBDeclaration()
new_SBDeclaration(SBDeclaration rhs) -> SBDeclaration

new_SBError()
new_SBError(SBError rhs) -> SBError

new_SBEvent()
SBEvent(SBEvent rhs) __init__(self, int type, str data) -> SBEvent (make an event that contains a C string)

new_SBExecutionContext()
SBExecutionContext(SBExecutionContext rhs) SBExecutionContext(SBTarget target) SBExecutionContext(SBProcess process) SBExecutionContext(SBThread thread) new_SBExecutionContext(SBFrame frame) -> SBExecutionContext

new_SBExpressionOptions()
new_SBExpressionOptions(SBExpressionOptions rhs) -> SBExpressionOptions

new_SBFileSpec()
SBFileSpec(SBFileSpec rhs) SBFileSpec(char const * path) new_SBFileSpec(char const * path, bool resolve) -> SBFileSpec

new_SBFileSpecList()
new_SBFileSpecList(SBFileSpecList rhs) -> SBFileSpecList

new_SBFrame()
new_SBFrame(SBFrame rhs) -> SBFrame

new_SBFunction()
new_SBFunction(SBFunction rhs) -> SBFunction

SBHostOS

new_SBHostOS()

new_SBInstruction()
new_SBInstruction(SBInstruction rhs) -> SBInstruction

new_SBInstructionList()
new_SBInstructionList(SBInstructionList rhs) -> SBInstructionList

SBLanguageRuntime

new_SBLanguageRuntime()

new_SBLaunchInfo(...)
new_SBLaunchInfo(char const ** argv) -> SBLaunchInfo

new_SBLineEntry()
new_SBLineEntry(SBLineEntry rhs) -> SBLineEntry

new_SBListener()
SBListener(char const * name) new_SBListener(SBListener rhs) -> SBListener

new_SBMemoryRegionInfo()
new_SBMemoryRegionInfo(SBMemoryRegionInfo rhs) -> SBMemoryRegionInfo

new_SBMemoryRegionInfoList()
new_SBMemoryRegionInfoList(SBMemoryRegionInfoList rhs) -> SBMemoryRegionInfoList

new_SBModule()
SBModule(SBModule rhs) SBModule(SBModuleSpec module_spec) new_SBModule(SBProcess process, lldb::addr_t header_addr) -> SBModule

new_SBModuleSpec()
new_SBModuleSpec(SBModuleSpec rhs) -> SBModuleSpec

new_SBModuleSpecList()
new_SBModuleSpecList(SBModuleSpecList rhs) -> SBModuleSpecList

new_SBPlatform()
new_SBPlatform(char const * arg1) -> SBPlatform

new_SBPlatformConnectOptions(...)
SBPlatformConnectOptions(char const * url) new_SBPlatformConnectOptions(SBPlatformConnectOptions rhs) -> SBPlatformConnectOptions

new_SBPlatformShellCommand(...)
SBPlatformShellCommand(char const * shell_command) new_SBPlatformShellCommand(SBPlatformShellCommand rhs) -> SBPlatformShellCommand

new_SBProcess()
new_SBProcess(SBProcess rhs) -> SBProcess

new_SBQueue()
new_SBQueue(lldb::QueueSP const & queue_sp) -> SBQueue

new_SBQueueItem()
new_SBQueueItem(lldb::QueueItemSP const & queue_item_sp) -> SBQueueItem

new_SBSection()
new_SBSection(SBSection rhs) -> SBSection

new_SBSourceManager(...)
new_SBSourceManager(SBSourceManager rhs) -> SBSourceManager

SBStream

new_SBStream()

new_SBStringList()
new_SBStringList(SBStringList rhs) -> SBStringList

new_SBStructuredData()
SBStructuredData(SBStructuredData rhs) new_SBStructuredData(lldb::EventSP const & event_sp) -> SBStructuredData

new_SBSymbol()
new_SBSymbol(SBSymbol rhs) -> SBSymbol

new_SBSymbolContext()
new_SBSymbolContext(SBSymbolContext rhs) -> SBSymbolContext

new_SBSymbolContextList()
new_SBSymbolContextList(SBSymbolContextList rhs) -> SBSymbolContextList

new_SBTarget()
new_SBTarget(SBTarget rhs) -> SBTarget

new_SBThread()
new_SBThread(SBThread thread) -> SBThread

new_SBThreadCollection()
new_SBThreadCollection(SBThreadCollection rhs) -> SBThreadCollection

new_SBThreadPlan()
SBThreadPlan(SBThreadPlan threadPlan) SBThreadPlan(lldb::ThreadPlanSP const & lldb_object_sp) new_SBThreadPlan(SBThread thread, char const * class_name) -> SBThreadPlan

new_SBType()
new_SBType(SBType rhs) -> SBType

new_SBTypeCategory()
new_SBTypeCategory(SBTypeCategory rhs) -> SBTypeCategory

new_SBTypeEnumMember()
new_SBTypeEnumMember(SBTypeEnumMember rhs) -> SBTypeEnumMember

new_SBTypeEnumMemberList()
new_SBTypeEnumMemberList(SBTypeEnumMemberList rhs) -> SBTypeEnumMemberList

new_SBTypeFilter()
SBTypeFilter(uint32_t options) new_SBTypeFilter(SBTypeFilter rhs) -> SBTypeFilter

new_SBTypeFormat()
SBTypeFormat(lldb::Format format, uint32_t options=0) SBTypeFormat(lldb::Format format) SBTypeFormat(char const * type, uint32_t options=0) SBTypeFormat(char const * type) new_SBTypeFormat(SBTypeFormat rhs) -> SBTypeFormat

SBTypeList

new_SBTypeList()

new_SBTypeMember()
new_SBTypeMember(SBTypeMember rhs) -> SBTypeMember

new_SBTypeMemberFunction()
new_SBTypeMemberFunction(SBTypeMemberFunction rhs) -> SBTypeMemberFunction

new_SBTypeNameSpecifier()
SBTypeNameSpecifier(char const * name, bool is_regex=False) SBTypeNameSpecifier(char const * name) SBTypeNameSpecifier(SBType type) new_SBTypeNameSpecifier(SBTypeNameSpecifier rhs) -> SBTypeNameSpecifier

new_SBTypeSummary()
new_SBTypeSummary(SBTypeSummary rhs) -> SBTypeSummary

new_SBTypeSummaryOptions()
new_SBTypeSummaryOptions(SBTypeSummaryOptions rhs) -> SBTypeSummaryOptions

new_SBTypeSynthetic()
new_SBTypeSynthetic(SBTypeSynthetic rhs) -> SBTypeSynthetic

new_SBUnixSignals()
new_SBUnixSignals(SBUnixSignals rhs) -> SBUnixSignals

new_SBValue()
new_SBValue(SBValue rhs) -> SBValue

new_SBValueList()
new_SBValueList(SBValueList rhs) -> SBValueList

new_SBVariablesOptions()
new_SBVariablesOptions(SBVariablesOptions options) -> SBVariablesOptions

new_SBWatchpoint()
new_SBWatchpoint(SBWatchpoint rhs) -> SBWatchpoint

Variables

[hide private]

INT32_MAX = 2147483647

LLDB_ARCH_DEFAULT = 'systemArch'

LLDB_ARCH_DEFAULT_32BIT = 'systemArch32'

LLDB_ARCH_DEFAULT_64BIT = 'systemArch64'

LLDB_DEFAULT_BREAK_SIZE = 0

LLDB_GENERIC_ERROR = 4294967295

LLDB_INVALID_ADDRESS = 18446744073709551615

LLDB_INVALID_BREAK_ID = 0

LLDB_INVALID_CPUTYPE = 4294967294

LLDB_INVALID_FRAME_ID = 4294967295

LLDB_INVALID_IMAGE_TOKEN = 4294967295

LLDB_INVALID_INDEX32 = 4294967295

LLDB_INVALID_IVAR_OFFSET = 4294967295

LLDB_INVALID_LINE_NUMBER = 4294967295

LLDB_INVALID_MODULE_VERSION = 4294967295

LLDB_INVALID_OFFSET = 18446744073709551615

LLDB_INVALID_PROCESS_ID = 0

LLDB_INVALID_QUEUE_ID = 0

LLDB_INVALID_REGNUM = 4294967295

LLDB_INVALID_SIGNAL_NUMBER = 2147483647

LLDB_INVALID_THREAD_ID = 0

LLDB_INVALID_UID = 18446744073709551615

LLDB_INVALID_WATCH_ID = 0

LLDB_MAX_NUM_OPTION_SETS = 32

LLDB_OPT_SET_1 = 1

LLDB_OPT_SET_10 = 512

LLDB_OPT_SET_2 = 2

LLDB_OPT_SET_3 = 4

LLDB_OPT_SET_4 = 8

LLDB_OPT_SET_5 = 16

LLDB_OPT_SET_6 = 32

LLDB_OPT_SET_7 = 64

LLDB_OPT_SET_8 = 128

LLDB_OPT_SET_9 = 256

LLDB_OPT_SET_ALL = 4294967295

LLDB_REGNUM_GENERIC_ARG1 = 5

LLDB_REGNUM_GENERIC_ARG2 = 6

LLDB_REGNUM_GENERIC_ARG3 = 7

LLDB_REGNUM_GENERIC_ARG4 = 8

LLDB_REGNUM_GENERIC_ARG5 = 9

LLDB_REGNUM_GENERIC_ARG6 = 10

LLDB_REGNUM_GENERIC_ARG7 = 11

LLDB_REGNUM_GENERIC_ARG8 = 12

LLDB_REGNUM_GENERIC_FLAGS = 4

LLDB_REGNUM_GENERIC_FP = 2

LLDB_REGNUM_GENERIC_PC = 0

LLDB_REGNUM_GENERIC_RA = 3

LLDB_REGNUM_GENERIC_SP = 1

LLDB_WATCH_TYPE_READ = 1

LLDB_WATCH_TYPE_WRITE = 2

SBCommandInterpreter_eBroadcastBitAsynchronousErrorData = 16

SBCommandInterpreter_eBroadcastBitAsynchronousOutputData = 8

SBCommandInterpreter_eBroadcastBitQuitCommandReceived = 4

SBCommandInterpreter_eBroadcastBitResetPrompt = 2

SBCommandInterpreter_eBroadcastBitThreadShouldExit = 1

SBCommunication_eAllEventBits = -1

SBCommunication_eBroadcastBitDisconnected = 1

SBCommunication_eBroadcastBitPacketAvailable = 16

SBCommunication_eBroadcastBitReadThreadDidExit = 4

SBCommunication_eBroadcastBitReadThreadGotBytes = 2

SBCommunication_eBroadcastBitReadThreadShouldExit = 8

SBProcess_eBroadcastBitInterrupt = 2

SBProcess_eBroadcastBitProfileData = 16

SBProcess_eBroadcastBitSTDERR = 8

SBProcess_eBroadcastBitSTDOUT = 4

SBProcess_eBroadcastBitStateChanged = 1

SBProcess_eBroadcastBitStructuredData = 32

SBTarget_eBroadcastBitBreakpointChanged = 1

SBTarget_eBroadcastBitModulesLoaded = 2

SBTarget_eBroadcastBitModulesUnloaded = 4

SBTarget_eBroadcastBitSymbolsLoaded = 16

SBTarget_eBroadcastBitWatchpointChanged = 8

SBThread_eBroadcastBitSelectedFrameChanged = 8

SBThread_eBroadcastBitStackChanged = 1

SBThread_eBroadcastBitThreadResumed = 4

SBThread_eBroadcastBitThreadSelected = 16

SBThread_eBroadcastBitThreadSuspended = 2

UINT32_MAX = 4294967295

UINT64_MAX = 18446744073709551615

__package__ = None

eAccessNone = 0

eAccessPackage = 4

eAccessPrivate = 2

eAccessProtected = 3

eAccessPublic = 1

eAddressClassCode = 2

eAddressClassCodeAlternateISA = 3

eAddressClassData = 4

eAddressClassDebug = 5

eAddressClassInvalid = 0

eAddressClassRuntime = 6

eAddressClassUnknown = 1

eAllThreads = 1

eArgRawInput = 83

eArgTypeAddress = 0

eArgTypeAddressOrExpression = 1

eArgTypeAliasName = 2

eArgTypeAliasOptions = 3

eArgTypeArchitecture = 4

eArgTypeBoolean = 5

eArgTypeBreakpointID = 6

eArgTypeBreakpointIDRange = 7

eArgTypeBreakpointName = 8

eArgTypeByteSize = 9

eArgTypeClassName = 10

eArgTypeCommandName = 11

eArgTypeCount = 12

eArgTypeDescriptionVerbosity = 13

eArgTypeDirectoryName = 14

eArgTypeDisassemblyFlavor = 15

eArgTypeEndAddress = 16

eArgTypeExprFormat = 19

eArgTypeExpression = 17

eArgTypeExpressionPath = 18

eArgTypeFilename = 20

eArgTypeFormat = 21

eArgTypeFrameIndex = 22

eArgTypeFullName = 23

eArgTypeFunctionName = 24

eArgTypeFunctionOrSymbol = 25

eArgTypeGDBFormat = 26

eArgTypeHelpText = 27

eArgTypeIndex = 28

eArgTypeLanguage = 29

eArgTypeLastArg = 84

eArgTypeLineNum = 30

eArgTypeLogCategory = 31

eArgTypeLogChannel = 32

eArgTypeMethod = 33

eArgTypeName = 34

eArgTypeNewPathPrefix = 35

eArgTypeNone = 78

eArgTypeNumLines = 36

eArgTypeNumberPerLine = 37

eArgTypeOffset = 38

eArgTypeOldPathPrefix = 39

eArgTypeOneLiner = 40

eArgTypePath = 41

eArgTypePermissionsNumber = 42

eArgTypePermissionsString = 43

eArgTypePid = 44

eArgTypePlatform = 79

eArgTypePlugin = 45

eArgTypeProcessName = 46

eArgTypePythonClass = 47

eArgTypePythonFunction = 48

eArgTypePythonScript = 49

eArgTypeQueueName = 50

eArgTypeRegisterName = 51

eArgTypeRegularExpression = 52

eArgTypeRunArgs = 53

eArgTypeRunMode = 54

eArgTypeScriptLang = 56

eArgTypeScriptedCommandSynchronicity = 55

eArgTypeSearchWord = 57

eArgTypeSelector = 58

eArgTypeSettingIndex = 59

eArgTypeSettingKey = 60

eArgTypeSettingPrefix = 61

eArgTypeSettingVariableName = 62

eArgTypeShlibName = 63

eArgTypeSortOrder = 65

eArgTypeSourceFile = 64

eArgTypeStartAddress = 66

eArgTypeSummaryString = 67

eArgTypeSymbol = 68

eArgTypeThreadID = 69

eArgTypeThreadIndex = 70

eArgTypeThreadName = 71

eArgTypeTypeName = 72

eArgTypeUnixSignal = 74

eArgTypeUnsignedInteger = 73

eArgTypeValue = 76

eArgTypeVarName = 75

eArgTypeWatchType = 82

eArgTypeWatchpointID = 80

eArgTypeWatchpointIDRange = 81

eArgTypeWidth = 77

eBasicTypeBool = 20

eBasicTypeChar = 2

eBasicTypeChar16 = 8

eBasicTypeChar32 = 9

eBasicTypeDouble = 23

eBasicTypeDoubleComplex = 26

eBasicTypeFloat = 22

eBasicTypeFloatComplex = 25

eBasicTypeHalf = 21

eBasicTypeInt = 12

eBasicTypeInt128 = 18

eBasicTypeInvalid = 0

eBasicTypeLong = 14

eBasicTypeLongDouble = 24

eBasicTypeLongDoubleComplex = 27

eBasicTypeLongLong = 16

eBasicTypeNullPtr = 31

eBasicTypeObjCClass = 29

eBasicTypeObjCID = 28

eBasicTypeObjCSel = 30

eBasicTypeOther = 32

eBasicTypeShort = 10

eBasicTypeSignedChar = 3

eBasicTypeSignedWChar = 6

eBasicTypeUnsignedChar = 4

eBasicTypeUnsignedInt = 13

eBasicTypeUnsignedInt128 = 19

eBasicTypeUnsignedLong = 15

eBasicTypeUnsignedLongLong = 17

eBasicTypeUnsignedShort = 11

eBasicTypeUnsignedWChar = 7

eBasicTypeVoid = 1

eBasicTypeWChar = 5

eBreakpointEventTypeAdded = 2

eBreakpointEventTypeCommandChanged = 256

eBreakpointEventTypeConditionChanged = 512

eBreakpointEventTypeDisabled = 128

eBreakpointEventTypeEnabled = 64

eBreakpointEventTypeIgnoreChanged = 1024

eBreakpointEventTypeInvalidType = 1

eBreakpointEventTypeLocationsAdded = 8

eBreakpointEventTypeLocationsRemoved = 16

eBreakpointEventTypeLocationsResolved = 32

eBreakpointEventTypeRemoved = 4

eBreakpointEventTypeThreadChanged = 2048

eByteOrderBig = 1

eByteOrderInvalid = 0

eByteOrderLittle = 4

eByteOrderPDP = 2

eCommandProcessMustBeLaunched = 64

eCommandProcessMustBePaused = 128

eCommandRequiresFrame = 8

eCommandRequiresProcess = 2

eCommandRequiresRegContext = 16

eCommandRequiresTarget = 1

eCommandRequiresThread = 4

eCommandTryTargetAPILock = 32

eConnectionStatusEndOfFile = 1

eConnectionStatusError = 2

eConnectionStatusInterrupted = 6

eConnectionStatusLostConnection = 5

eConnectionStatusNoConnection = 4

eConnectionStatusSuccess = 0

eConnectionStatusTimedOut = 3

eDescriptionLevelBrief = 0

eDescriptionLevelFull = 1

eDescriptionLevelInitial = 3

eDescriptionLevelVerbose = 2

eDynamicCanRunTarget = 1

eDynamicDontRunTarget = 2

eEmulateInstructionOptionAutoAdvancePC = 1

eEmulateInstructionOptionIgnoreConditions = 2

eEmulateInstructionOptionNone = 0

eEncodingIEEE754 = 3

eEncodingInvalid = 0

eEncodingSint = 2

eEncodingUint = 1

eEncodingVector = 4

eErrorTypeExpression = 4

eErrorTypeGeneric = 1

eErrorTypeInvalid = 0

eErrorTypeMachKernel = 2

eErrorTypePOSIX = 3

eErrorTypeWin32 = 5

eExpressionCompleted = 0

eExpressionDiscarded = 3

eExpressionEvaluationComplete = 3

eExpressionEvaluationExecution = 2

eExpressionEvaluationIRGen = 1

eExpressionEvaluationParse = 0

eExpressionHitBreakpoint = 5

eExpressionInterrupted = 4

eExpressionParseError = 2

eExpressionResultUnavailable = 7

eExpressionSetupError = 1

eExpressionStoppedForDebug = 8

eExpressionTimedOut = 6

eFileFilePermissionsUserRX = 320

eFilePermissionsDirectoryDefault = 448

eFilePermissionsEveryoneR = 292

eFilePermissionsEveryoneRW = 438

eFilePermissionsEveryoneRWX = 511

eFilePermissionsEveryoneRX = 365

eFilePermissionsEveryoneW = 146

eFilePermissionsEveryoneX = 73

eFilePermissionsFileDefault = 384

eFilePermissionsGroupExecute = 8

eFilePermissionsGroupRW = 48

eFilePermissionsGroupRWX = 56

eFilePermissionsGroupRX = 40

eFilePermissionsGroupRead = 32

eFilePermissionsGroupWrite = 16

eFilePermissionsUserExecute = 64

eFilePermissionsUserRW = 384

eFilePermissionsUserRWX = 448

eFilePermissionsUserRead = 256

eFilePermissionsUserWrite = 128

eFilePermissionsWorldExecute = 1

eFilePermissionsWorldRW = 6

eFilePermissionsWorldRWX = 7

eFilePermissionsWorldRX = 5

eFilePermissionsWorldRead = 4

eFilePermissionsWorldWrite = 2

eFormatAddressInfo = 35

eFormatBinary = 2

eFormatBoolean = 1

eFormatBytes = 3

eFormatBytesWithASCII = 4

eFormatCString = 8

eFormatChar = 5

eFormatCharArray = 34

eFormatCharPrintable = 6

eFormatComplex = 7

eFormatComplexFloat = 7

eFormatComplexInteger = 33

eFormatDecimal = 9

eFormatDefault = 0

eFormatEnum = 10

eFormatFloat = 13

eFormatHex = 11

eFormatHexFloat = 36

eFormatHexUppercase = 12

eFormatInstruction = 37

eFormatInvalid = 0

eFormatOSType = 15

eFormatOctal = 14

eFormatPointer = 19

eFormatUnicode16 = 16

eFormatUnicode32 = 17

eFormatUnsigned = 18

eFormatVectorOfChar = 20

eFormatVectorOfFloat16 = 29

eFormatVectorOfFloat32 = 30

eFormatVectorOfFloat64 = 31

eFormatVectorOfSInt16 = 23

eFormatVectorOfSInt32 = 25

eFormatVectorOfSInt64 = 27

eFormatVectorOfSInt8 = 21

eFormatVectorOfUInt128 = 32

eFormatVectorOfUInt16 = 24

eFormatVectorOfUInt32 = 26

eFormatVectorOfUInt64 = 28

eFormatVectorOfUInt8 = 22

eFormatVoid = 38

eFrameCompareEqual = 2

eFrameCompareInvalid = 0

eFrameCompareOlder = 5

eFrameCompareSameParent = 3

eFrameCompareUnknown = 1

eFrameCompareYounger = 4

eFunctionNameTypeAny = 2

eFunctionNameTypeAuto = 2

eFunctionNameTypeBase = 8

eFunctionNameTypeFull = 4

eFunctionNameTypeMethod = 16

eFunctionNameTypeNone = 0

eFunctionNameTypeSelector = 32

eGdbSignalArithmetic = 147

eGdbSignalBadAccess = 145

eGdbSignalBadInstruction = 146

eGdbSignalBreakpoint = 150

eGdbSignalEmulation = 148

eGdbSignalSoftware = 149

eInputReaderActivate = 0

eInputReaderAsynchronousOutputWritten = 1

eInputReaderDeactivate = 3

eInputReaderDone = 7

eInputReaderEndOfFile = 6

eInputReaderGotToken = 4

eInputReaderGranularityAll = 4

eInputReaderGranularityByte = 1

eInputReaderGranularityInvalid = 0

eInputReaderGranularityLine = 3

eInputReaderGranularityWord = 2

eInputReaderInterrupt = 5

eInputReaderReactivate = 2

eInstrumentationRuntimeTypeAddressSanitizer = 0

eInstrumentationRuntimeTypeThreadSanitizer = 1

eLanguageTypeAda83 = 3

eLanguageTypeAda95 = 13

eLanguageTypeC = 2

eLanguageTypeC11 = 29

eLanguageTypeC89 = 1

eLanguageTypeC99 = 12

eLanguageTypeC_plus_plus = 4

eLanguageTypeC_plus_plus_03 = 25

eLanguageTypeC_plus_plus_11 = 26

eLanguageTypeC_plus_plus_14 = 33

eLanguageTypeCobol74 = 5

eLanguageTypeCobol85 = 6

eLanguageTypeD = 19

eLanguageTypeDylan = 32

eLanguageTypeExtRenderScript = 37

eLanguageTypeFortran03 = 34

eLanguageTypeFortran08 = 35

eLanguageTypeFortran77 = 7

eLanguageTypeFortran90 = 8

eLanguageTypeFortran95 = 14

eLanguageTypeGo = 22

eLanguageTypeHaskell = 24

eLanguageTypeJava = 11

eLanguageTypeJulia = 31

eLanguageTypeMipsAssembler = 36

eLanguageTypeModula2 = 10

eLanguageTypeModula3 = 23

eLanguageTypeOCaml = 27

eLanguageTypeObjC = 16

eLanguageTypeObjC_plus_plus = 17

eLanguageTypeOpenCL = 21

eLanguageTypePLI = 15

eLanguageTypePascal83 = 9

eLanguageTypePython = 20

eLanguageTypeRust = 28

eLanguageTypeSwift = 30

eLanguageTypeUPC = 18

eLanguageTypeUnknown = 0

eLaunchFlagCloseTTYOnExit = 2048

eLaunchFlagDebug = 2

eLaunchFlagDetachOnError = 512

eLaunchFlagDisableASLR = 8

eLaunchFlagDisableSTDIO = 16

eLaunchFlagDontSetExitStatus = 256

eLaunchFlagExec = 1

eLaunchFlagLaunchInSeparateProcessGroup = 128

eLaunchFlagLaunchInShell = 64

eLaunchFlagLaunchInTTY = 32

eLaunchFlagNone = 0

eLaunchFlagShellExpandArguments = 1024

eLaunchFlagStopAtEntry = 4

eMatchTypeNormal = 0

eMatchTypeRegex = 1

eMatchTypeStartsWith = 2

eMemberFunctionKindConstructor = 1

eMemberFunctionKindDestructor = 2

eMemberFunctionKindInstanceMethod = 3

eMemberFunctionKindStaticMethod = 4

eMemberFunctionKindUnknown = 0

eNoDynamicValues = 0

eNumInstrumentationRuntimeTypes = 2

eNumLanguageTypes = 38

eOnlyDuringStepping = 2

eOnlyThisThread = 0

ePathTypeClangDir = 8

ePathTypeGlobalLLDBTempSystemDir = 7

ePathTypeHeaderDir = 2

ePathTypeLLDBShlibDir = 0

ePathTypeLLDBSystemPlugins = 4

ePathTypeLLDBTempSystemDir = 6

ePathTypeLLDBUserPlugins = 5

ePathTypePythonDir = 3

ePathTypeSupportExecutableDir = 1

ePermissionsExecutable = 4

ePermissionsReadable = 2

ePermissionsWritable = 1

eQueueItemKindBlock = 2

eQueueItemKindFunction = 1

eQueueItemKindUnknown = 0

eQueueKindConcurrent = 2

eQueueKindSerial = 1

eQueueKindUnknown = 0

eRegisterKindDWARF = 1

eRegisterKindEHFrame = 0

eRegisterKindGeneric = 2

eRegisterKindLLDB = 4

eRegisterKindProcessPlugin = 3

eReturnStatusFailed = 6

eReturnStatusInvalid = 0

eReturnStatusQuit = 7

eReturnStatusStarted = 5

eReturnStatusSuccessContinuingNoResult = 3

eReturnStatusSuccessContinuingResult = 4

eReturnStatusSuccessFinishNoResult = 1

eReturnStatusSuccessFinishResult = 2

eScriptLanguageDefault = 1

eScriptLanguageNone = 0

eScriptLanguagePython = 1

eScriptLanguageUnknown = 2

eSectionTypeARMexidx = 38

eSectionTypeARMextab = 39

eSectionTypeAbsoluteAddress = 42

eSectionTypeCode = 1

eSectionTypeCompactUnwind = 40

eSectionTypeContainer = 2

eSectionTypeDWARFAppleNames = 29

eSectionTypeDWARFAppleNamespaces = 31

eSectionTypeDWARFAppleObjC = 32

eSectionTypeDWARFAppleTypes = 30

eSectionTypeDWARFDebugAbbrev = 15

eSectionTypeDWARFDebugAddr = 16

eSectionTypeDWARFDebugAranges = 17

eSectionTypeDWARFDebugFrame = 18

eSectionTypeDWARFDebugInfo = 19

eSectionTypeDWARFDebugLine = 20

eSectionTypeDWARFDebugLoc = 21

eSectionTypeDWARFDebugMacInfo = 22

eSectionTypeDWARFDebugMacro = 23

eSectionTypeDWARFDebugPubNames = 24

eSectionTypeDWARFDebugPubTypes = 25

eSectionTypeDWARFDebugRanges = 26

eSectionTypeDWARFDebugStr = 27

eSectionTypeDWARFDebugStrOffsets = 28

eSectionTypeData = 3

eSectionTypeData16 = 9

eSectionTypeData4 = 7

eSectionTypeData8 = 8

eSectionTypeDataCString = 4

eSectionTypeDataCStringPointers = 5

eSectionTypeDataObjCCFStrings = 14

eSectionTypeDataObjCMessageRefs = 13

eSectionTypeDataPointers = 10

eSectionTypeDataSymbolAddress = 6

eSectionTypeDebug = 11

eSectionTypeEHFrame = 37

eSectionTypeELFDynamicLinkInfo = 36

eSectionTypeELFDynamicSymbols = 34

eSectionTypeELFRelocationEntries = 35

eSectionTypeELFSymbolTable = 33

eSectionTypeGoSymtab = 41

eSectionTypeInvalid = 0

eSectionTypeOther = 43

eSectionTypeZeroFill = 12

eStateAttaching = 3

eStateConnected = 2

eStateCrashed = 8

eStateDetached = 9

eStateExited = 10

eStateInvalid = 0

eStateLaunching = 4

eStateRunning = 6

eStateStepping = 7

eStateStopped = 5

eStateSuspended = 11

eStateUnloaded = 1

eStopReasonBreakpoint = 3

eStopReasonException = 6

eStopReasonExec = 7

eStopReasonInstrumentation = 10

eStopReasonInvalid = 0

eStopReasonNone = 1

eStopReasonPlanComplete = 8

eStopReasonSignal = 5

eStopReasonThreadExiting = 9

eStopReasonTrace = 2

eStopReasonWatchpoint = 4

eStopShowColumnAnsi = 1

eStopShowColumnAnsiOrCaret = 0

eStopShowColumnCaret = 2

eStopShowColumnNone = 3

eSymbolContextBlock = 16

eSymbolContextCompUnit = 4

eSymbolContextEverything = 127

eSymbolContextFunction = 8

eSymbolContextLineEntry = 32

eSymbolContextModule = 2

eSymbolContextSymbol = 64

eSymbolContextTarget = 1

eSymbolContextVariable = 128

eSymbolTypeAbsolute = 1

eSymbolTypeAdditional = 21

eSymbolTypeAny = 0

eSymbolTypeBlock = 12

eSymbolTypeCode = 2

eSymbolTypeCommonBlock = 11

eSymbolTypeCompiler = 22

eSymbolTypeData = 4

eSymbolTypeException = 7

eSymbolTypeHeaderFile = 9

eSymbolTypeInstrumentation = 23

eSymbolTypeInvalid = 0

eSymbolTypeLineEntry = 17

eSymbolTypeLineHeader = 18

eSymbolTypeLocal = 13

eSymbolTypeObjCClass = 25

eSymbolTypeObjCIVar = 27

eSymbolTypeObjCMetaClass = 26

eSymbolTypeObjectFile = 10

eSymbolTypeParam = 14

eSymbolTypeReExported = 28

eSymbolTypeResolver = 3

eSymbolTypeRuntime = 6

eSymbolTypeScopeBegin = 19

eSymbolTypeScopeEnd = 20

eSymbolTypeSourceFile = 8

eSymbolTypeTrampoline = 5

eSymbolTypeUndefined = 24

eSymbolTypeVariable = 15

eSymbolTypeVariableType = 16

eTemplateArgumentKindDeclaration = 2

eTemplateArgumentKindExpression = 6

eTemplateArgumentKindIntegral = 3

eTemplateArgumentKindNull = 0

eTemplateArgumentKindPack = 7

eTemplateArgumentKindTemplate = 4

eTemplateArgumentKindTemplateExpansion = 5

eTemplateArgumentKindType = 1

eTypeClassAny = -1

eTypeClassArray = 1

eTypeClassBlockPointer = 2

eTypeClassBuiltin = 4

eTypeClassClass = 8

eTypeClassComplexFloat = 16

eTypeClassComplexInteger = 32

eTypeClassEnumeration = 64

eTypeClassFunction = 128

eTypeClassInvalid = 0

eTypeClassMemberPointer = 256

eTypeClassObjCInterface = 1024

eTypeClassObjCObject = 512

eTypeClassObjCObjectPointer = 2048

eTypeClassOther = -2147483648

eTypeClassPointer = 4096

eTypeClassReference = 8192

eTypeClassStruct = 16384

eTypeClassTypedef = 32768

eTypeClassUnion = 65536

eTypeClassVector = 131072

eTypeHasChildren = 1

eTypeHasValue = 2

eTypeInstanceIsPointer = 4194304

eTypeIsArray = 4

eTypeIsBlock = 8

eTypeIsBuiltIn = 16

eTypeIsCPlusPlus = 64

eTypeIsClass = 32

eTypeIsComplex = 1048576

eTypeIsEnumeration = 128

eTypeIsFloat = 524288

eTypeIsFuncPrototype = 256

eTypeIsInteger = 262144

eTypeIsMember = 512

eTypeIsObjC = 1024

eTypeIsPointer = 2048

eTypeIsReference = 4096

eTypeIsScalar = 131072

eTypeIsSigned = 2097152

eTypeIsStructUnion = 8192

eTypeIsTemplate = 16384

eTypeIsTypedef = 32768

eTypeIsVector = 65536

eTypeOptionCascade = 1

eTypeOptionHideChildren = 8

eTypeOptionHideEmptyAggregates = 256

eTypeOptionHideNames = 64

eTypeOptionHideValue = 16

eTypeOptionNonCacheable = 128

eTypeOptionNone = 0

eTypeOptionShowOneLiner = 32

eTypeOptionSkipPointers = 2

eTypeOptionSkipReferences = 4

eTypeSummaryCapped = True

eTypeSummaryUncapped = False

eValueTypeConstResult = 7

eValueTypeInvalid = 0

eValueTypeRegister = 5

eValueTypeRegisterSet = 6

eValueTypeVariableArgument = 3

eValueTypeVariableGlobal = 1

eValueTypeVariableLocal = 4

eValueTypeVariableStatic = 2

eValueTypeVariableThreadLocal = 8

eWatchpointEventTypeAdded = 2

eWatchpointEventTypeCommandChanged = 256

eWatchpointEventTypeConditionChanged = 512

eWatchpointEventTypeDisabled = 128

eWatchpointEventTypeEnabled = 64

eWatchpointEventTypeIgnoreChanged = 1024

eWatchpointEventTypeInvalidType = 1

eWatchpointEventTypeRemoved = 4

eWatchpointEventTypeThreadChanged = 2048

eWatchpointEventTypeTypeChanged = 4096

eWatchpointKindRead = 1

eWatchpointKindWrite = 2

kNumDescriptionLevels = 4

kNumFormats = 39

kNumRegisterKinds = 5

Function Details

[hide private]

SBAddress_GetModule(...)

SBAddress_GetModule(SBAddress self) -> SBModule

//------------------------------------------------------------------ /// GetModule() and the following grab individual objects for a given address and /// are less efficient if you want more than one symbol related objects. /// Use one of the following when you want multiple debug symbol related /// objects for an address: /// lldb::SBSymbolContext SBAddress::GetSymbolContext (uint32_t resolve_scope); /// lldb::SBSymbolContext SBTarget::ResolveSymbolContextForAddress (const SBAddress &addr, uint32_t resolve_scope); /// One or more bits from the SymbolContextItem enumerations can be logically /// OR'ed together to more efficiently retrieve multiple symbol objects. //------------------------------------------------------------------

SBAddress_GetSymbolContext(...)

SBAddress_GetSymbolContext(SBAddress self, uint32_t resolve_scope) -> SBSymbolContext

//------------------------------------------------------------------ /// GetSymbolContext() and the following can lookup symbol information for a given address. /// An address might refer to code or data from an existing module, or it /// might refer to something on the stack or heap. The following functions /// will only return valid values if the address has been resolved to a code /// or data address using 'void SBAddress::SetLoadAddress(...)' or /// 'lldb::SBAddress SBTarget::ResolveLoadAddress (...)'. //------------------------------------------------------------------

SBBlock_GetContainingInlinedBlock(...)

SBBlock_GetContainingInlinedBlock(SBBlock self) -> SBBlock

Get the inlined block that is or contains this block.

SBBlock_GetFirstChild(...)

SBBlock_GetFirstChild(SBBlock self) -> SBBlock

Get the first child block.

SBBlock_GetInlinedCallSiteColumn(...)

SBBlock_GetInlinedCallSiteColumn(SBBlock self) -> uint32_t

Get the call site column if this block represents an inlined function; otherwise, return 0.

SBBlock_GetInlinedCallSiteFile(...)

SBBlock_GetInlinedCallSiteFile(SBBlock self) -> SBFileSpec

Get the call site file if this block represents an inlined function; otherwise, return an invalid file spec.

SBBlock_GetInlinedCallSiteLine(...)

SBBlock_GetInlinedCallSiteLine(SBBlock self) -> uint32_t

Get the call site line if this block represents an inlined function; otherwise, return 0.

SBBlock_GetInlinedName(...)

SBBlock_GetInlinedName(SBBlock self) -> char const *

Get the function name if this block represents an inlined function; otherwise, return None.

SBBlock_GetParent(...)

SBBlock_GetParent(SBBlock self) -> SBBlock

Get the parent block.

SBBlock_GetSibling(...)

SBBlock_GetSibling(SBBlock self) -> SBBlock

Get the sibling block for this block.

SBBlock_IsInlined(...)

SBBlock_IsInlined(SBBlock self) -> bool

Does this block represent an inlined function?

SBBreakpointLocation_GetCondition(...)

SBBreakpointLocation_GetCondition(SBBreakpointLocation self) -> char const *

//------------------------------------------------------------------ /// Get the condition expression for the breakpoint location. //------------------------------------------------------------------

SBBreakpointLocation_SetCondition(...)

SBBreakpointLocation_SetCondition(SBBreakpointLocation self, char const * condition)

//-------------------------------------------------------------------------- /// The breakpoint location stops only if the condition expression evaluates /// to true. //--------------------------------------------------------------------------

SBBreakpointLocation_SetScriptCallbackBody(...)

SBBreakpointLocation_SetScriptCallbackBody(SBBreakpointLocation self, char const * script_body_text) -> SBError

//------------------------------------------------------------------ /// Provide the body for the script function to be called when the breakpoint location is hit. /// The body will be wrapped in a function, which be passed two arguments: /// 'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint /// 'bpno' - which is the SBBreakpointLocation to which the callback was attached. /// /// The error parameter is currently ignored, but will at some point hold the Python /// compilation diagnostics. /// Returns true if the body compiles successfully, false if not. //------------------------------------------------------------------

SBBreakpointLocation_SetScriptCallbackFunction(...)

SBBreakpointLocation_SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name)

//------------------------------------------------------------------ /// Set the callback to the given Python function name. //------------------------------------------------------------------

SBBreakpoint_GetCondition(...)

SBBreakpoint_GetCondition(SBBreakpoint self) -> char const *

//------------------------------------------------------------------ /// Get the condition expression for the breakpoint. //------------------------------------------------------------------

SBBreakpoint_SetCondition(...)

SBBreakpoint_SetCondition(SBBreakpoint self, char const * condition)

//-------------------------------------------------------------------------- /// The breakpoint stops only if the condition expression evaluates to true. //--------------------------------------------------------------------------

SBBreakpoint_SetScriptCallbackBody(...)

SBBreakpoint_SetScriptCallbackBody(SBBreakpoint self, char const * script_body_text) -> SBError

//------------------------------------------------------------------ /// Provide the body for the script function to be called when the breakpoint is hit. /// The body will be wrapped in a function, which be passed two arguments: /// 'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint /// 'bpno' - which is the SBBreakpointLocation to which the callback was attached. /// /// The error parameter is currently ignored, but will at some point hold the Python /// compilation diagnostics. /// Returns true if the body compiles successfully, false if not. //------------------------------------------------------------------

SBBreakpoint_SetScriptCallbackFunction(...)

SBBreakpoint_SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name)

//------------------------------------------------------------------ /// Set the name of the script function to be called when the breakpoint is hit. //------------------------------------------------------------------

SBCommandInterpreter_HandleCommand(...)


HandleCommand(char const * command_line, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus
HandleCommand(char const * command_line, SBCommandReturnObject result) -> lldb::ReturnStatus
HandleCommand(char const * command_line, SBExecutionContext exe_ctx, SBCommandReturnObject result, 
    bool add_to_history=False) -> lldb::ReturnStatus
SBCommandInterpreter_HandleCommand(SBCommandInterpreter self, char const * command_line, SBExecutionContext exe_ctx, 
    SBCommandReturnObject result) -> lldb::ReturnStatus

SBCommandInterpreter_HandleCommandsFromFile(...)


SBCommandInterpreter_HandleCommandsFromFile(SBCommandInterpreter self, SBFileSpec file, SBExecutionContext override_context, 
    SBCommandInterpreterRunOptions options, SBCommandReturnObject result)

SBCommandInterpreter_HandleCompletion(...)


SBCommandInterpreter_HandleCompletion(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, 
    int max_return_elements, SBStringList matches) -> int

SBCompileUnit_FindLineEntryIndex(...)


FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec) -> uint32_t
SBCompileUnit_FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec, 
    bool exact) -> uint32_t

SBCompileUnit_GetTypes(...)

GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBCompileUnit_GetTypes(SBCompileUnit self) -> SBTypeList

//------------------------------------------------------------------ /// Get all types matching type_mask from debug info in this /// compile unit. /// /// @param[in] type_mask /// A bitfield that consists of one or more bits logically OR'ed /// together from the lldb::TypeClass enumeration. This allows /// you to request only structure types, or only class, struct /// and union types. Passing in lldb::eTypeClassAny will return /// all types found in the debug information for this compile /// unit. /// /// @return /// A list of types in this compile unit that match type_mask //------------------------------------------------------------------

SBDebugger_CreateTarget(...)


CreateTarget(char const * filename, char const * target_triple, char const * platform_name, bool add_dependent_modules, 
    SBError sb_error) -> SBTarget
SBDebugger_CreateTarget(SBDebugger self, char const * filename) -> SBTarget

SBDebugger_DeleteTarget(...)

SBDebugger_DeleteTarget(SBDebugger self, SBTarget target) -> bool

Return true if target is deleted from the target list of the debugger.

SBDebugger_RunCommandInterpreter(...)


SBDebugger_RunCommandInterpreter(SBDebugger self, bool auto_handle_events, bool spawn_thread, SBCommandInterpreterRunOptions options, 
    int & num_errors, bool & quit_requested, bool & stopped_for_crash)

SBExpressionOptions_GetAutoApplyFixIts(...)

SBExpressionOptions_GetAutoApplyFixIts(SBExpressionOptions self) -> bool

Gets whether to auto-apply fix-it hints to an expression.

SBExpressionOptions_GetPrefix(...)

SBExpressionOptions_GetPrefix(SBExpressionOptions self) -> char const *

Gets the prefix to use for this expression.

SBExpressionOptions_SetAutoApplyFixIts(...)

SetAutoApplyFixIts(bool b=True) SBExpressionOptions_SetAutoApplyFixIts(SBExpressionOptions self)

Sets whether to auto-apply fix-it hints to the expression being evaluated.

SBExpressionOptions_SetCoerceResultToId(...)

SetCoerceResultToId(bool coerce=True) SBExpressionOptions_SetCoerceResultToId(SBExpressionOptions self)

Sets whether to coerce the expression result to ObjC id type after evaluation.

SBExpressionOptions_SetFetchDynamicValue(...)

SetFetchDynamicValue(lldb::DynamicValueType dynamic=eDynamicCanRunTarget) SBExpressionOptions_SetFetchDynamicValue(SBExpressionOptions self)

Sets whether to cast the expression result to its dynamic type.

SBExpressionOptions_SetGenerateDebugInfo(...)

SetGenerateDebugInfo(bool b=True) SBExpressionOptions_SetGenerateDebugInfo(SBExpressionOptions self)

Sets whether to generate debug information for the expression and also controls if a SBModule is generated.

SBExpressionOptions_SetLanguage(...)

SBExpressionOptions_SetLanguage(SBExpressionOptions self, lldb::LanguageType language)

Sets the language that LLDB should assume the expression is written in

SBExpressionOptions_SetPrefix(...)

SBExpressionOptions_SetPrefix(SBExpressionOptions self, char const * prefix)

Sets the prefix to use for this expression. This prefix gets inserted after the 'target.expr-prefix' prefix contents, but before the wrapped expression function body.

SBExpressionOptions_SetSuppressPersistentResult(...)

SetSuppressPersistentResult(bool b=False) SBExpressionOptions_SetSuppressPersistentResult(SBExpressionOptions self)

Sets whether to produce a persistent result that can be used in future expressions.

SBExpressionOptions_SetTimeoutInMicroSeconds(...)

SetTimeoutInMicroSeconds(uint32_t timeout=0) SBExpressionOptions_SetTimeoutInMicroSeconds(SBExpressionOptions self)

Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expresson will finish.

SBExpressionOptions_SetTryAllThreads(...)

SetTryAllThreads(bool run_others=True) SBExpressionOptions_SetTryAllThreads(SBExpressionOptions self)

Sets whether to run all threads if the expression does not complete on one thread.

SBExpressionOptions_SetUnwindOnError(...)

SetUnwindOnError(bool unwind=True) SBExpressionOptions_SetUnwindOnError(SBExpressionOptions self)

Sets whether to unwind the expression stack on error.

SBFrame_EvaluateExpression(...)

EvaluateExpression(char const * expr) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) -> SBValue SBFrame_EvaluateExpression(SBFrame self, char const * expr, SBExpressionOptions options) -> SBValue

/// The version that doesn't supply a 'use_dynamic' value will use the /// target's default.

SBFrame_FindValue(...)

FindValue(char const * name, lldb::ValueType value_type) -> SBValue SBFrame_FindValue(SBFrame self, char const * name, lldb::ValueType value_type, lldb::DynamicValueType use_dynamic) -> SBValue

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

SBFrame_FindVariable(...)

FindVariable(char const * var_name) -> SBValue SBFrame_FindVariable(SBFrame self, char const * var_name, lldb::DynamicValueType use_dynamic) -> SBValue

/// The version that doesn't supply a 'use_dynamic' value will use the /// target's default.

SBFrame_GetBlock(...)

SBFrame_GetBlock(SBFrame self) -> SBBlock

/// Gets the deepest block that contains the frame PC. /// /// See also GetFrameBlock().

SBFrame_GetCFA(...)

SBFrame_GetCFA(SBFrame self) -> lldb::addr_t

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.

SBFrame_GetFrameBlock(...)

SBFrame_GetFrameBlock(SBFrame self) -> SBBlock

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

SBFrame_GetFunctionName()

SBFrame_GetFunctionName(SBFrame self) -> char const *

/// 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().

Returns: char const

SBFrame_GetValueForVariablePath(...)

GetValueForVariablePath(char const * var_path) -> SBValue SBFrame_GetValueForVariablePath(SBFrame self, char const * var_path, lldb::DynamicValueType use_dynamic) -> SBValue

/// 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 lldb.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.

SBFrame_GetVariables(...)

GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only) -> SBValueList GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) -> SBValueList SBFrame_GetVariables(SBFrame self, SBVariablesOptions options) -> SBValueList

/// The version that doesn't supply a 'use_dynamic' value will use the /// target's default.

SBFrame_IsInlined()

SBFrame_IsInlined(SBFrame self) -> bool

/// Return true if this frame represents an inlined function. /// /// See also GetFunctionName().

Returns: bool

SBFunction_GetIsOptimized(...)

SBFunction_GetIsOptimized(SBFunction self) -> bool

Returns true if the function was compiled with optimization. Optimization, in this case, is meant to indicate that the debugger experience may be confusing for the user -- variables optimized away, stepping jumping between source lines -- and the driver may want to provide some guidance to the user about this. Returns false if unoptimized, or unknown.

SBListener_WaitForEventForBroadcasterWithType(...)


SBListener_WaitForEventForBroadcasterWithType(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, uint32_t event_type_mask, 
    SBEvent sb_event) -> bool

SBModule_FindFirstGlobalVariable(...)

SBModule_FindFirstGlobalVariable(SBModule self, SBTarget target, char const * name) -> SBValue

//------------------------------------------------------------------ /// Find the first global (or static) variable by name. /// /// @param[in] target /// A valid SBTarget instance representing the debuggee. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @return /// An SBValue that gets filled in with the found variable (if any). //------------------------------------------------------------------

SBModule_FindFunctions(...)

FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBModule_FindFunctions(SBModule self, char const * name) -> SBSymbolContextList

//------------------------------------------------------------------ /// Find functions by name. /// /// @param[in] name /// The name of the function we are looking for. /// /// @param[in] name_type_mask /// A logical OR of one or more FunctionNameType enum bits that /// indicate what kind of names should be used when doing the /// lookup. Bits include fully qualified names, base names, /// C++ methods, or ObjC selectors. /// See FunctionNameType for more details. /// /// @return /// A symbol context list that gets filled in with all of the /// matches. //------------------------------------------------------------------

SBModule_FindGlobalVariables(...)

SBModule_FindGlobalVariables(SBModule self, SBTarget target, char const * name, uint32_t max_matches) -> SBValueList

//------------------------------------------------------------------ /// Find global and static variables by name. /// /// @param[in] target /// A valid SBTarget instance representing the debuggee. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @param[in] max_matches /// Allow the number of matches to be limited to max_matches. /// /// @return /// A list of matched variables in an SBValueList. //------------------------------------------------------------------

SBModule_GetFileSpec(...)

SBModule_GetFileSpec(SBModule self) -> SBFileSpec

//------------------------------------------------------------------ /// Get const accessor for the module file specification. /// /// This function returns the file for the module on the host system /// that is running LLDB. This can differ from the path on the /// platform since we might be doing remote debugging. /// /// @return /// A const reference to the file specification object. //------------------------------------------------------------------

SBModule_GetPlatformFileSpec(...)

SBModule_GetPlatformFileSpec(SBModule self) -> SBFileSpec

//------------------------------------------------------------------ /// Get accessor for the module platform file specification. /// /// Platform file refers to the path of the module as it is known on /// the remote system on which it is being debugged. For local /// debugging this is always the same as Module::GetFileSpec(). But /// remote debugging might mention a file '/usr/lib/liba.dylib' /// which might be locally downloaded and cached. In this case the /// platform file could be something like: /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib' /// The file could also be cached in a local developer kit directory. /// /// @return /// A const reference to the file specification object. //------------------------------------------------------------------

SBModule_GetTypes(...)

GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBModule_GetTypes(SBModule self) -> SBTypeList

//------------------------------------------------------------------ /// Get all types matching type_mask from debug info in this /// module. /// /// @param[in] type_mask /// A bitfield that consists of one or more bits logically OR'ed /// together from the lldb::TypeClass enumeration. This allows /// you to request only structure types, or only class, struct /// and union types. Passing in lldb::eTypeClassAny will return /// all types found in the debug information for this module. /// /// @return /// A list of types in this module that match type_mask //------------------------------------------------------------------

SBModule_GetUUIDString(...)

SBModule_GetUUIDString(SBModule self) -> char const *

Returns the UUID of the module as a Python string.

SBPlatformConnectOptions_EnableRsync(...)


SBPlatformConnectOptions_EnableRsync(SBPlatformConnectOptions self, char const * options, char const * remote_path_prefix, 
    bool omit_remote_hostname)

SBProcess_Destroy(...)

SBProcess_Destroy(SBProcess self) -> SBError

Kills the process and shuts down all threads that were spawned to track and monitor process.

SBProcess_GetNumExtendedBacktraceTypes(...)

Return the number of different thread-origin extended backtraces this process can support as a uint32_t. When the process is stopped and you have an SBThread, lldb may be able to show a backtrace of when that thread was originally created, or the work item was enqueued to it (in the case of a libdispatch queue).

SBProcess_GetSTDERR(...)

Reads data from the current process's stderr stream. API client specifies the size of the buffer to read data into. It returns the byte buffer in a Python string.

SBProcess_GetSTDOUT(...)

Reads data from the current process's stdout stream. API client specifies the size of the buffer to read data into. It returns the byte buffer in a Python string.

SBProcess_GetStopID(...)

GetStopID(bool include_expression_stops=False) -> uint32_t SBProcess_GetStopID(SBProcess self) -> uint32_t

Returns a stop id that will increase every time the process executes. If include_expression_stops is true, then stops caused by expression evaluation will cause the returned value to increase, otherwise the counter returned will only increase when execution is continued explicitly by the user. Note, the value will always increase, but may increase by more than one per stop.

SBProcess_GetThreadAtIndex(...)

Returns the INDEX'th thread from the list of current threads. The index of a thread is only valid for the current stop. For a persistent thread identifier use either the thread ID or the IndexID. See help on SBThread for more details.

SBProcess_GetUniqueID(...)

Returns an integer ID that is guaranteed to be unique across all process instances. This is not the process ID, just a unique integer for comparison and caching purposes.

SBProcess_PutSTDIN(...)

Writes data into the current process's stdin. API client specifies a Python string as the only argument.

SBProcess_ReadCStringFromMemory(...)


Reads a NULL terminated C string from the current process's address space.
It returns a python string of the exact length, or truncates the string if
the maximum character limit is reached. Example:

# Read a C string of at most 256 bytes from address '0x1000' 
error = lldb.SBError()
cstring = process.ReadCStringFromMemory(0x1000, 256, error)
if error.Success():
    print('cstring: ', cstring)
else
    print('error: ', error)

SBProcess_ReadMemory(...)

Reads memory from the current process's address space and removes any traps that may have been inserted into the memory. It returns the byte buffer in a Python string. Example:

# Read 4 bytes from address 'addr' and assume error.Success() is True. content = process.ReadMemory(addr, 4, error) new_bytes = bytearray(content)

SBProcess_ReadPointerFromMemory(...)


Reads a pointer from memory from an address and returns the value. Example:

# Read a pointer from address 0x1000
error = lldb.SBError()
ptr = ReadPointerFromMemory(0x1000, error)
if error.Success():
    print('pointer: 0x%x' % ptr)
else
    print('error: ', error)

SBProcess_ReadUnsignedFromMemory(...)


Reads an unsigned integer from memory given a byte size and an address. 
Returns the unsigned integer that was read. Example:

# Read a 4 byte unsigned integer from address 0x1000
error = lldb.SBError()
uint = ReadUnsignedFromMemory(0x1000, 4, error)
if error.Success():
    print('integer: %u' % uint)
else
    print('error: ', error)

SBProcess_RemoteAttachToProcessWithID(...)

SBProcess_RemoteAttachToProcessWithID(SBProcess self, lldb::pid_t pid, SBError error) -> bool

//------------------------------------------------------------------ /// Remote connection related functions. These will fail if the /// process is not in eStateConnected. They are intended for use /// when connecting to an externally managed debugserver instance. //------------------------------------------------------------------

SBProcess_RemoteLaunch(...)


SBProcess_RemoteLaunch(SBProcess self, char const ** argv, char const ** envp, char const * stdin_path, 
    char const * stdout_path, char const * stderr_path, char const * working_directory, 
    uint32_t launch_flags, bool stop_at_entry, SBError error) -> bool

See SBTarget.Launch for argument description and usage.

SBProcess_Signal(...)

SBProcess_Signal(SBProcess self, int signal) -> SBError

Sends the process a unix signal.

SBProcess_WriteMemory(...)


Writes memory to the current process's address space and maintains any
traps that might be present due to software breakpoints. Example:

# Create a Python string from the byte array.
new_value = str(bytes)
result = process.WriteMemory(addr, new_value, error)
if not error.Success() or result != len(bytes):
    print('SBProcess.WriteMemory() failed!')

SBQueue_GetKind(...)

Returns an lldb::QueueKind enumerated value (e.g. eQueueKindUnknown, eQueueKindSerial, eQueueKindConcurrent) describing the type of this queue.

SBQueue_GetQueueID(...)

Returns an lldb::queue_id_t type unique identifier number for this queue that will not be used by any other queue during this process' execution. These ID numbers often start at 1 with the first system-created queues and increment from there.

SBSection_GetTargetByteSize(...)

SBSection_GetTargetByteSize(SBSection self) -> uint32_t

//------------------------------------------------------------------ /// Return the size of a target's byte represented by this section /// in numbers of host bytes. Note that certain architectures have /// varying minimum addressable unit (i.e. byte) size for their /// CODE or DATA buses. /// /// @return /// The number of host (8-bit) bytes needed to hold a target byte //------------------------------------------------------------------

SBSourceManager_DisplaySourceLinesWithLineNumbers(...)


SBSourceManager_DisplaySourceLinesWithLineNumbers(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t context_before, uint32_t context_after, 
    char const * current_line_cstr, SBStream s) -> size_t

SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(...)


SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t column, uint32_t context_before, 
    uint32_t context_after, char const * current_line_cstr, SBStream s) -> size_t

SBStream_Clear(...)

SBStream_Clear(SBStream self)

//-------------------------------------------------------------------------- /// If the stream is redirected to a file, forget about the file and if /// ownership of the file was transferred to this object, close the file. /// If the stream is backed by a local cache, clear this cache. //--------------------------------------------------------------------------

SBStream_GetData(...)

SBStream_GetData(SBStream self) -> char const *

//-------------------------------------------------------------------------- /// If this stream is not redirected to a file, it will maintain a local /// cache for the stream data which can be accessed using this accessor. //--------------------------------------------------------------------------

SBStream_GetSize(...)

SBStream_GetSize(SBStream self) -> size_t

//-------------------------------------------------------------------------- /// If this stream is not redirected to a file, it will maintain a local /// cache for the stream output whose length can be accessed using this /// accessor. //--------------------------------------------------------------------------

SBTarget_AttachToProcessWithID(...)

SBTarget_AttachToProcessWithID(SBTarget self, SBListener listener, lldb::pid_t pid, SBError error) -> SBProcess

//------------------------------------------------------------------ /// Attach to process with pid. /// /// @param[in] listener /// An optional listener that will receive all process events. /// If listener is valid then listener will listen to all /// process events. If not valid, then this target's debugger /// (SBTarget::GetDebugger()) will listen to all process events. /// /// @param[in] pid /// The process ID to attach to. /// /// @param[out] /// An error explaining what went wrong if attach fails. /// /// @return /// A process object for the attached process. //------------------------------------------------------------------

SBTarget_AttachToProcessWithName(...)

SBTarget_AttachToProcessWithName(SBTarget self, SBListener listener, char const * name, bool wait_for, SBError error) -> SBProcess

//------------------------------------------------------------------ /// Attach to process with name. /// /// @param[in] listener /// An optional listener that will receive all process events. /// If listener is valid then listener will listen to all /// process events. If not valid, then this target's debugger /// (SBTarget::GetDebugger()) will listen to all process events. /// /// @param[in] name /// Basename of process to attach to. /// /// @param[in] wait_for /// If true wait for a new instance of 'name' to be launched. /// /// @param[out] /// An error explaining what went wrong if attach fails. /// /// @return /// A process object for the attached process. //------------------------------------------------------------------

SBTarget_BreakpointCreateByName(...)


BreakpointCreateByName(char const * symbol_name, char const * module_name=None) -> SBBreakpoint
BreakpointCreateByName(char const * symbol_name) -> SBBreakpoint
BreakpointCreateByName(char const * symbol_name, uint32_t func_name_type, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
SBTarget_BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t func_name_type, lldb::LanguageType symbol_language, 
    SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint

SBTarget_BreakpointCreateByNames(...)


BreakpointCreateByNames(char const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
BreakpointCreateByNames(char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, 
    SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
SBTarget_BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, 
    lldb::addr_t offset, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint

SBTarget_BreakpointCreateByRegex(...)


BreakpointCreateByRegex(char const * symbol_name_regex, char const * module_name=None) -> SBBreakpoint
BreakpointCreateByRegex(char const * symbol_name_regex) -> SBBreakpoint
SBTarget_BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, lldb::LanguageType symbol_language, 
    SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint

SBTarget_BreakpointCreateBySourceRegex(...)


BreakpointCreateBySourceRegex(char const * source_regex, SBFileSpec source_file, char const * module_name=None) -> SBBreakpoint
BreakpointCreateBySourceRegex(char const * source_regex, SBFileSpec source_file) -> SBBreakpoint
BreakpointCreateBySourceRegex(char const * source_regex, SBFileSpecList module_list, SBFileSpecList file_list) -> SBBreakpoint
SBTarget_BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file, 
    SBStringList func_names) -> SBBreakpoint

SBTarget_BreakpointsCreateFromFile(...)

BreakpointsCreateFromFile(SBFileSpec source_file, SBBreakpointList bkpt_list) -> SBError SBTarget_BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBStringList matching_names, SBBreakpointList new_bps) -> SBError

//------------------------------------------------------------------ /// Read breakpoints from source_file and return the newly created /// breakpoints in bkpt_list. /// /// @param[in] source_file /// The file from which to read the breakpoints /// /// @param[out] bkpt_list /// A list of the newly created breakpoints. /// /// @return /// An SBError detailing any errors in reading in the breakpoints. //------------------------------------------------------------------

SBTarget_ConnectRemote(...)

SBTarget_ConnectRemote(SBTarget self, SBListener listener, char const * url, char const * plugin_name, SBError error) -> SBProcess

//------------------------------------------------------------------ /// Connect to a remote debug server with url. /// /// @param[in] listener /// An optional listener that will receive all process events. /// If listener is valid then listener will listen to all /// process events. If not valid, then this target's debugger /// (SBTarget::GetDebugger()) will listen to all process events. /// /// @param[in] url /// The url to connect to, e.g., 'connect://localhost:12345'. /// /// @param[in] plugin_name /// The plugin name to be used; can be NULL. /// /// @param[out] /// An error explaining what went wrong if the connect fails. /// /// @return /// A process object for the connected process. //------------------------------------------------------------------

SBTarget_CreateValueFromAddress(...)

SBTarget_CreateValueFromAddress(SBTarget self, char const * name, SBAddress addr, SBType type) -> SBValue

//------------------------------------------------------------------ /// Create an SBValue with the given name by treating the memory starting at addr as an entity of type. /// /// @param[in] name /// The name of the resultant SBValue /// /// @param[in] addr /// The address of the start of the memory region to be used. /// /// @param[in] type /// The type to use to interpret the memory starting at addr. /// /// @return /// An SBValue of the given type, may be invalid if there was an error reading /// the underlying memory. //------------------------------------------------------------------

SBTarget_FindFirstGlobalVariable(...)

SBTarget_FindFirstGlobalVariable(SBTarget self, char const * name) -> SBValue

//------------------------------------------------------------------ /// Find the first global (or static) variable by name. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @return /// An SBValue that gets filled in with the found variable (if any). //------------------------------------------------------------------

SBTarget_FindFunctions(...)

FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBTarget_FindFunctions(SBTarget self, char const * name) -> SBSymbolContextList

//------------------------------------------------------------------ /// Find functions by name. /// /// @param[in] name /// The name of the function we are looking for. /// /// @param[in] name_type_mask /// A logical OR of one or more FunctionNameType enum bits that /// indicate what kind of names should be used when doing the /// lookup. Bits include fully qualified names, base names, /// C++ methods, or ObjC selectors. /// See FunctionNameType for more details. /// /// @return /// A lldb::SBSymbolContextList that gets filled in with all of /// the symbol contexts for all the matches. //------------------------------------------------------------------

SBTarget_FindGlobalVariables(...)

FindGlobalVariables(char const * name, uint32_t max_matches) -> SBValueList SBTarget_FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBValueList

//------------------------------------------------------------------ /// Find global and static variables by name. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @param[in] max_matches /// Allow the number of matches to be limited to max_matches. /// /// @return /// A list of matched variables in an SBValueList. //------------------------------------------------------------------

SBTarget_GetCodeByteSize(...)

SBTarget_GetCodeByteSize(SBTarget self) -> uint32_t

//------------------------------------------------------------------ /// Architecture code byte width accessor /// /// @return /// The size in 8-bit (host) bytes of a minimum addressable /// unit from the Architecture's code bus //------------------------------------------------------------------

SBTarget_GetDataByteSize(...)

SBTarget_GetDataByteSize(SBTarget self) -> uint32_t

//------------------------------------------------------------------ /// Architecture data byte width accessor /// /// @return /// The size in 8-bit (host) bytes of a minimum addressable /// unit from the Architecture's data bus //------------------------------------------------------------------

SBTarget_GetInstructions(...)


SBTarget_GetInstructions(SBTarget self, SBAddress base_addr, void const * buf) -> SBInstructionList

Disassemble the bytes in a buffer and return them in an SBInstructionList.
Parameters:
   base_addr -- used for symbolicating the offsets in the byte stream when disassembling
   buf       -- bytes to be disassembled
   size      -- (C++) size of the buffer
Returns an SBInstructionList.

SBTarget_GetInstructionsWithFlavor(...)


SBTarget_GetInstructionsWithFlavor(SBTarget self, SBAddress base_addr, char const * flavor_string, void const * buf) -> SBInstructionList

Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
Parameters:
   base_addr -- used for symbolicating the offsets in the byte stream when disassembling
   flavor    -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
   buf       -- bytes to be disassembled
   size      -- (C++) size of the buffer
Returns an SBInstructionList.

SBTarget_GetPlatform(...)

SBTarget_GetPlatform(SBTarget self) -> SBPlatform

//------------------------------------------------------------------ /// Return the platform object associated with the target. /// /// After return, the platform object should be checked for /// validity. /// /// @return /// A platform object. //------------------------------------------------------------------

SBTarget_Install(...)

SBTarget_Install(SBTarget self) -> SBError

//------------------------------------------------------------------ /// Install any binaries that need to be installed. /// /// This function does nothing when debugging on the host system. /// When connected to remote platforms, the target's main executable /// and any modules that have their install path set will be /// installed on the remote platform. If the main executable doesn't /// have an install location set, it will be installed in the remote /// platform's working directory. /// /// @return /// An error describing anything that went wrong during /// installation. //------------------------------------------------------------------

SBTarget_Launch(...)


Launch(SBListener listener, char const ** argv, char const ** envp, char const * stdin_path, 
    char const * stdout_path, char const * stderr_path, char const * working_directory, 
    uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess
SBTarget_Launch(SBTarget self, SBLaunchInfo launch_info, SBError error) -> SBProcess

//------------------------------------------------------------------
/// Launch a new process.
///
/// Launch a new process by spawning a new process using the
/// target object's executable module's file as the file to launch.
/// Arguments are given in  argv, and the environment variables
/// are in  envp. Standard input and output files can be
/// optionally re-directed to  stdin_path,  stdout_path, and
///  stderr_path.
///
/// @param[in] listener
///     An optional listener that will receive all process events.
///     If  listener is valid then  listener will listen to all
///     process events. If not valid, then this target's debugger
///     (SBTarget::GetDebugger()) will listen to all process events. 
///
/// @param[in] argv
///     The argument array.
///
/// @param[in] envp
///     The environment array.
///
/// @param[in] launch_flags
///     Flags to modify the launch (@see lldb::LaunchFlags)
///
/// @param[in] stdin_path
///     The path to use when re-directing the STDIN of the new
///     process. If all stdXX_path arguments are NULL, a pseudo
///     terminal will be used.
///
/// @param[in] stdout_path
///     The path to use when re-directing the STDOUT of the new
///     process. If all stdXX_path arguments are NULL, a pseudo
///     terminal will be used.
///
/// @param[in] stderr_path
///     The path to use when re-directing the STDERR of the new
///     process. If all stdXX_path arguments are NULL, a pseudo
///     terminal will be used.
///
/// @param[in] working_directory
///     The working directory to have the child process run in
///
/// @param[in] launch_flags
///     Some launch options specified by logical OR'ing 
///     lldb::LaunchFlags enumeration values together.
///
/// @param[in] stop_at_entry
///     If false do not stop the inferior at the entry point.
///
/// @param[out]
///     An error object. Contains the reason if there is some failure.
///
/// @return
///      A process object for the newly created process.
//------------------------------------------------------------------

For example,

    process = target.Launch(self.dbg.GetListener(), None, None,
                            None, '/tmp/stdout.txt', None,
                            None, 0, False, error)

launches a new process by passing nothing for both the args and the envs
and redirect the standard output of the inferior to the /tmp/stdout.txt
file. It does not specify a working directory so that the debug server
will use its idea of what the current working directory is for the
inferior. Also, we ask the debugger not to stop the inferior at the
entry point. If no breakpoint is specified for the inferior, it should
run to completion if no user interaction is required.

SBTarget_LaunchSimple(...)


SBTarget_LaunchSimple(SBTarget self, char const ** argv, char const ** envp, char const * working_directory) -> SBProcess

//------------------------------------------------------------------
/// Launch a new process with sensible defaults.
///
/// @param[in] argv
///     The argument array.
///
/// @param[in] envp
///     The environment array.
///
/// @param[in] working_directory
///     The working directory to have the child process run in
///
/// Default: listener
///     Set to the target's debugger (SBTarget::GetDebugger())
///
/// Default: launch_flags
///     Empty launch flags
///
/// Default: stdin_path
/// Default: stdout_path
/// Default: stderr_path
///     A pseudo terminal will be used.
///
/// @return
///      A process object for the newly created process.
//------------------------------------------------------------------

For example,

    process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())

launches a new process by passing 'X', 'Y', 'Z' as the args to the
executable.

SBTarget_LoadCore(...)


SBTarget_LoadCore(SBTarget self, char const * core_file) -> SBProcess

//------------------------------------------------------------------
/// Load a core file
///
/// @param[in] core_file
///     File path of the core dump.
///
/// @return
///      A process object for the newly created core file.
//------------------------------------------------------------------

For example,

    process = target.LoadCore('./a.out.core')

loads a new core file and returns the process object.

SBTarget_ReadInstructions(...)


ReadInstructions(SBAddress base_addr, uint32_t count) -> SBInstructionList
SBTarget_ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, char const * flavor_string) -> SBInstructionList

Disassemble a specified number of instructions starting at an address.
Parameters:
   base_addr       -- the address to start disassembly from
   count           -- the number of instructions to disassemble
   flavor_string   -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
Returns an SBInstructionList.

SBTarget_ReadMemory(...)

SBTarget_ReadMemory(SBTarget self, SBAddress addr, void * buf, SBError error) -> size_t

//------------------------------------------------------------------ /// Read target memory. If a target process is running then memory /// is read from here. Otherwise the memory is read from the object /// files. For a target whose bytes are sized as a multiple of host /// bytes, the data read back will preserve the target's byte order. /// /// @param[in] addr /// A target address to read from. /// /// @param[out] buf /// The buffer to read memory into. /// /// @param[in] size /// The maximum number of host bytes to read in the buffer passed /// into this call /// /// @param[out] error /// Error information is written here if the memory read fails. /// /// @return /// The amount of data read in host bytes. //------------------------------------------------------------------

SBTarget_ResolveFileAddress(...)

SBTarget_ResolveFileAddress(SBTarget self, lldb::addr_t file_addr) -> SBAddress

//------------------------------------------------------------------ /// Resolve a current file address into a section offset address. /// /// @param[in] file_addr /// /// @return /// An SBAddress which will be valid if... //------------------------------------------------------------------

SBThread_GetExtendedBacktraceOriginatingIndexID(...)

Takes no arguments, returns a uint32_t. If this SBThread is an ExtendedBacktrace thread, get the IndexID of the original thread that this ExtendedBacktrace thread represents, if available. The thread that was running this backtrace in the past may not have been registered with lldb's thread index (if it was created, did its work, and was destroyed without lldb ever stopping execution). In that case, this ExtendedBacktrace thread's IndexID will be returned.

SBThread_GetExtendedBacktraceThread(...)

Given an argument of str to specify the type of thread-origin extended backtrace to retrieve, query whether the origin of this thread is available. An SBThread is retured; SBThread.IsValid will return true if an extended backtrace was available. The returned SBThread is not a part of the SBProcess' thread list and it cannot be manipulated like normal threads -- you cannot step or resume it, for instance -- it is intended to used primarily for generating a backtrace. You may request the returned thread's own thread origin in turn.

SBThread_GetIndexID(...)

Return the index number for this SBThread. The index number is the same thing that a user gives as an argument to 'thread select' in the command line lldb. These numbers start at 1 (for the first thread lldb sees in a debug session) and increments up throughout the process lifetime. An index number will not be reused for a different thread later in a process - thread 1 will always be associated with the same thread. See related GetThreadID. This method returns a uint32_t index number, takes no arguments.

SBThread_GetInfoItemByPathAsString(...)

Takes a path string and a SBStream reference as parameters, returns a bool. Collects the thread's 'info' dictionary from the remote system, uses the path argument to descend into the dictionary to an item of interest, and prints it into the SBStream in a natural format. Return bool is to indicate if anything was printed into the stream (true) or not (false).

SBThread_GetQueue(...)

Return the SBQueue for this thread. If this thread is not currently associated with a libdispatch queue, the SBQueue object's IsValid() method will return false. If this SBThread is actually a HistoryThread, we may be able to provide QueueID and QueueName, but not provide an SBQueue. Those individual attributes may have been saved for the HistoryThread without enough information to reconstitute the entire SBQueue at that time. This method takes no arguments, returns an SBQueue.

SBThread_GetQueueID(...)

Return the dispatch_queue_id for this thread, if any, as a lldb::queue_id_t. For example, with a libdispatch (aka Grand Central Dispatch) queue.

SBThread_GetQueueName(...)

Return the queue name associated with this thread, if any, as a str. For example, with a libdispatch (aka Grand Central Dispatch) queue.

SBThread_GetStopReasonDataAtIndex(...)

SBThread_GetStopReasonDataAtIndex(SBThread self, uint32_t idx) -> uint64_t

//-------------------------------------------------------------------------- /// Get information associated with a stop reason. /// /// Breakpoint stop reasons will have data that consists of pairs of /// breakpoint IDs followed by the breakpoint location IDs (they always come /// in pairs). /// /// Stop Reason Count Data Type /// ======================== ===== ========================================= /// eStopReasonNone 0 /// eStopReasonTrace 0 /// eStopReasonBreakpoint N duple: {breakpoint id, location id} /// eStopReasonWatchpoint 1 watchpoint id /// eStopReasonSignal 1 unix signal number /// eStopReasonException N exception data /// eStopReasonExec 0 /// eStopReasonPlanComplete 0 //--------------------------------------------------------------------------

SBThread_GetStopReasonDataCount(...)

SBThread_GetStopReasonDataCount(SBThread self) -> size_t

/// Get the number of words associated with the stop reason. /// See also GetStopReasonDataAtIndex().

SBThread_GetStopReasonExtendedBacktraces(...)

Returns a collection of historical stack traces that are significant to the current stop reason. Used by ThreadSanitizer, where we provide various stack traces that were involved in a data race or other type of detected issue.

SBThread_GetStopReasonExtendedInfoAsJSON(...)

Collects a thread's stop reason extended information dictionary and prints it into the SBStream in a JSON format. The format of this JSON dictionary depends on the stop reason and is currently used only for instrumentation plugins.

SBThread_GetThreadID(...)

Returns a unique thread identifier (type lldb::tid_t, typically a 64-bit type) for the current SBThread that will remain constant throughout the thread's lifetime in this process and will not be reused by another thread during this process lifetime. On Mac OS X systems, this is a system-wide unique thread identifier; this identifier is also used by other tools like sample which helps to associate data from those tools with lldb. See related GetIndexID.

SBThread_ReturnFromFrame(...)

Force a return from the frame passed in (and any frames younger than it) without executing any more code in those frames. If return_value contains a valid SBValue, that will be set as the return value from frame. Note, at present only scalar return values are supported.

SBThread_SafeToCallFunctions(...)

Takes no arguments, returns a bool. lldb may be able to detect that function calls should not be executed on a given thread at a particular point in time. It is recommended that this is checked before performing an inferior function call on a given thread.

SBThread_StepInto(...)


StepInto(lldb::RunMode stop_other_threads=eOnlyDuringStepping)
StepInto()
StepInto(char const * target_name, lldb::RunMode stop_other_threads=eOnlyDuringStepping)
StepInto(char const * target_name)

    Step  the current thread from the current source line to the line given by end_line, stopping if
    the thread steps into the function given by target_name.  If target_name is None, then stepping will stop
    in any of the places we would normally stop.
    

    Step  the current thread from the current source line to the line given by end_line, stopping if
    the thread steps into the function given by target_name.  If target_name is None, then stepping will stop
    in any of the places we would normally stop.

SBThread_Suspend(...)

SBThread_Suspend(SBThread self) -> bool

//-------------------------------------------------------------------------- /// LLDB currently supports process centric debugging which means when any /// thread in a process stops, all other threads are stopped. The Suspend() /// call here tells our process to suspend a thread and not let it run when /// the other threads in a process are allowed to run. So when /// SBProcess::Continue() is called, any threads that aren't suspended will /// be allowed to run. If any of the SBThread functions for stepping are /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the /// thread will now be allowed to run and these functions will simply return. /// /// Eventually we plan to add support for thread centric debugging where /// each thread is controlled individually and each thread would broadcast /// its state, but we haven't implemented this yet. /// /// Likewise the SBThread::Resume() call will again allow the thread to run /// when the process is continued. /// /// Suspend() and Resume() functions are not currently reference counted, if /// anyone has the need for them to be reference counted, please let us /// know. //--------------------------------------------------------------------------

SBThread_UnwindInnermostExpression(...)

Unwind the stack frames from the innermost expression evaluation. This API is equivalent to 'thread return -x'.

SBValue_GetData(...)


SBValue_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.
   //------------------------------------------------------------------

SBValue_GetIndexOfChildWithName(...)

SBValue_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. //------------------------------------------------------------------

SBValue_GetPointeeData(...)


GetPointeeData(uint32_t item_idx=0, uint32_t item_count=1) -> SBData
GetPointeeData(uint32_t item_idx=0) -> SBData
SBValue_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.
   //------------------------------------------------------------------

SBValue_GetValueForExpressionPath(...)

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

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

SBValue_Watch(...)

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

SBValue_WatchPointee(...)

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

SBWatchpoint_GetCondition(...)

SBWatchpoint_GetCondition(SBWatchpoint self) -> char const *

//------------------------------------------------------------------ /// Get the condition expression for the watchpoint. //------------------------------------------------------------------

SBWatchpoint_GetHardwareIndex(...)

SBWatchpoint_GetHardwareIndex(SBWatchpoint self) -> int32_t

//------------------------------------------------------------------ /// With -1 representing an invalid hardware index. //------------------------------------------------------------------

SBWatchpoint_SetCondition(...)

SBWatchpoint_SetCondition(SBWatchpoint self, char const * condition)

//-------------------------------------------------------------------------- /// The watchpoint stops only if the condition expression evaluates to true. //--------------------------------------------------------------------------