# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

"""
The lldb module contains the public APIs for Python binding.

Some of the important classes are described here:

* :py:class:`SBTarget`: Represents the target program running under the debugger.
* :py:class:`SBProcess`: Represents the process associated with the target program.
* :py:class:`SBThread`: Represents a thread of execution. :py:class:`SBProcess` contains SBThreads.
* :py:class:`SBFrame`: Represents one of the stack frames associated with a thread. :py:class:`SBThread`
  contains SBFrame(s).
* :py:class:`SBSymbolContext`: A container that stores various debugger related info.
* :py:class:`SBValue`: Represents the value of a variable, a register, or an expression.
* :py:class:`SBModule`: Represents an executable image and its associated object and symbol
  files.  :py:class:`SBTarget` contains SBModule.
* :py:class:`SBBreakpoint`: Represents a logical breakpoint and its associated settings.
  :py:class:`SBTarget` contains SBBreakpoints.
* :py:class:`SBSymbol`: Represents the symbol possibly associated with a stack frame.
* :py:class:`SBCompileUnit`: Represents a compilation unit, or compiled source file.
* :py:class:`SBFunction`: Represents a generic function, which can be inlined or not.
* :py:class:`SBBlock`: Represents a lexical block. :py:class:`SBFunction` contains SBBlocks.
* :py:class:`SBLineEntry`: Specifies an association with a contiguous range of instructions
  and a source file location. :py:class:`SBCompileUnit` contains SBLineEntry.

The different enums in the `lldb` module are described in :doc:`python_api_enums`.


"""

from sys import version_info as _swig_python_version_info
try:
    # Try an absolute import first.  If we're being loaded from lldb,
    # _lldb should be a built-in module.
    import _lldb
except ImportError:
    # Relative import should work if we are being loaded by Python.
    from . import _lldb

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



import uuid
import re
import os


#SWIG_VERSION is written as a single hex number, but the components of it are
#meant to be interpreted in decimal. So, 0x030012 is swig 3.0.12, and not
#3.0.18.
def _to_int(hex):
    return hex // 0x10 % 0x10 * 10 + hex % 0x10
swig_version = (_to_int(0x040401 // 0x10000), _to_int(0x040401 // 0x100), _to_int(0x040401))
del _to_int


# ===================================
# Iterator for lldb container objects
# ===================================
def lldb_iter(obj, getsize, getelem):
    """A generator adaptor to support iteration for lldb container objects."""
    size = getattr(obj, getsize)
    elem = getattr(obj, getelem)
    for i in range(size()):
        yield elem(i)

INT32_MAX = _lldb.INT32_MAX

UINT32_MAX = _lldb.UINT32_MAX

UINT64_MAX = _lldb.UINT64_MAX

LLDB_GENERIC_ERROR = _lldb.LLDB_GENERIC_ERROR

LLDB_INVALID_BREAK_ID = _lldb.LLDB_INVALID_BREAK_ID

LLDB_DEFAULT_BREAK_SIZE = _lldb.LLDB_DEFAULT_BREAK_SIZE

LLDB_INVALID_WATCH_ID = _lldb.LLDB_INVALID_WATCH_ID

LLDB_WATCH_TYPE_READ = _lldb.LLDB_WATCH_TYPE_READ

LLDB_WATCH_TYPE_WRITE = _lldb.LLDB_WATCH_TYPE_WRITE

LLDB_WATCH_TYPE_MODIFY = _lldb.LLDB_WATCH_TYPE_MODIFY

LLDB_INVALID_SITE_ID = _lldb.LLDB_INVALID_SITE_ID

LLDB_REGNUM_GENERIC_PC = _lldb.LLDB_REGNUM_GENERIC_PC

LLDB_REGNUM_GENERIC_SP = _lldb.LLDB_REGNUM_GENERIC_SP

LLDB_REGNUM_GENERIC_FP = _lldb.LLDB_REGNUM_GENERIC_FP

LLDB_REGNUM_GENERIC_RA = _lldb.LLDB_REGNUM_GENERIC_RA

LLDB_REGNUM_GENERIC_FLAGS = _lldb.LLDB_REGNUM_GENERIC_FLAGS

LLDB_REGNUM_GENERIC_ARG1 = _lldb.LLDB_REGNUM_GENERIC_ARG1

LLDB_REGNUM_GENERIC_ARG2 = _lldb.LLDB_REGNUM_GENERIC_ARG2

LLDB_REGNUM_GENERIC_ARG3 = _lldb.LLDB_REGNUM_GENERIC_ARG3

LLDB_REGNUM_GENERIC_ARG4 = _lldb.LLDB_REGNUM_GENERIC_ARG4

LLDB_REGNUM_GENERIC_ARG5 = _lldb.LLDB_REGNUM_GENERIC_ARG5

LLDB_REGNUM_GENERIC_ARG6 = _lldb.LLDB_REGNUM_GENERIC_ARG6

LLDB_REGNUM_GENERIC_ARG7 = _lldb.LLDB_REGNUM_GENERIC_ARG7

LLDB_REGNUM_GENERIC_ARG8 = _lldb.LLDB_REGNUM_GENERIC_ARG8

LLDB_REGNUM_GENERIC_TP = _lldb.LLDB_REGNUM_GENERIC_TP

LLDB_INVALID_STOP_ID = _lldb.LLDB_INVALID_STOP_ID
r"""Invalid value definitions"""
LLDB_INVALID_ADDRESS = _lldb.LLDB_INVALID_ADDRESS

LLDB_INVALID_INDEX32 = _lldb.LLDB_INVALID_INDEX32

LLDB_INVALID_IVAR_OFFSET = _lldb.LLDB_INVALID_IVAR_OFFSET

LLDB_INVALID_IMAGE_TOKEN = _lldb.LLDB_INVALID_IMAGE_TOKEN

LLDB_INVALID_MODULE_VERSION = _lldb.LLDB_INVALID_MODULE_VERSION

LLDB_INVALID_REGNUM = _lldb.LLDB_INVALID_REGNUM

LLDB_INVALID_UID = _lldb.LLDB_INVALID_UID

LLDB_INVALID_PROCESS_ID = _lldb.LLDB_INVALID_PROCESS_ID

LLDB_INVALID_THREAD_ID = _lldb.LLDB_INVALID_THREAD_ID

LLDB_INVALID_FRAME_ID = _lldb.LLDB_INVALID_FRAME_ID

LLDB_INVALID_SIGNAL_NUMBER = _lldb.LLDB_INVALID_SIGNAL_NUMBER

LLDB_INVALID_OFFSET = _lldb.LLDB_INVALID_OFFSET

LLDB_INVALID_LINE_NUMBER = _lldb.LLDB_INVALID_LINE_NUMBER

LLDB_INVALID_COLUMN_NUMBER = _lldb.LLDB_INVALID_COLUMN_NUMBER

LLDB_INVALID_QUEUE_ID = _lldb.LLDB_INVALID_QUEUE_ID

LLDB_INVALID_CPU_ID = _lldb.LLDB_INVALID_CPU_ID

LLDB_INVALID_WATCHPOINT_RESOURCE_ID = _lldb.LLDB_INVALID_WATCHPOINT_RESOURCE_ID

LLDB_ARCH_DEFAULT = _lldb.LLDB_ARCH_DEFAULT
r"""CPU Type definitions"""
LLDB_ARCH_DEFAULT_32BIT = _lldb.LLDB_ARCH_DEFAULT_32BIT

LLDB_ARCH_DEFAULT_64BIT = _lldb.LLDB_ARCH_DEFAULT_64BIT

LLDB_INVALID_CPUTYPE = _lldb.LLDB_INVALID_CPUTYPE

LLDB_MAX_NUM_OPTION_SETS = _lldb.LLDB_MAX_NUM_OPTION_SETS
r"""Option Set definitions"""
LLDB_OPT_SET_ALL = _lldb.LLDB_OPT_SET_ALL

LLDB_OPT_SET_1 = _lldb.LLDB_OPT_SET_1

LLDB_OPT_SET_2 = _lldb.LLDB_OPT_SET_2

LLDB_OPT_SET_3 = _lldb.LLDB_OPT_SET_3

LLDB_OPT_SET_4 = _lldb.LLDB_OPT_SET_4

LLDB_OPT_SET_5 = _lldb.LLDB_OPT_SET_5

LLDB_OPT_SET_6 = _lldb.LLDB_OPT_SET_6

LLDB_OPT_SET_7 = _lldb.LLDB_OPT_SET_7

LLDB_OPT_SET_8 = _lldb.LLDB_OPT_SET_8

LLDB_OPT_SET_9 = _lldb.LLDB_OPT_SET_9

LLDB_OPT_SET_10 = _lldb.LLDB_OPT_SET_10

LLDB_OPT_SET_11 = _lldb.LLDB_OPT_SET_11

LLDB_OPT_SET_12 = _lldb.LLDB_OPT_SET_12

LLDB_INVALID_ADDRESS_MASK = _lldb.LLDB_INVALID_ADDRESS_MASK
r"""
    Address Mask
    Bits not used for addressing are set to 1 in the mask;
    all mask bits set is an invalid value.
    """
eStateInvalid = _lldb.eStateInvalid

eStateUnloaded = _lldb.eStateUnloaded
r"""Process is object is valid, but not currently loaded"""
eStateConnected = _lldb.eStateConnected
r"""Process is connected to remote debug services, but not"""
eStateAttaching = _lldb.eStateAttaching
r"""launched or attached to anything yet Process is currently trying to attach"""
eStateLaunching = _lldb.eStateLaunching
r"""Process is in the process of launching"""
eStateStopped = _lldb.eStateStopped
r"""Process or thread is stopped and can be examined."""
eStateRunning = _lldb.eStateRunning
r"""Process or thread is running and can't be examined."""
eStateStepping = _lldb.eStateStepping
r"""Process or thread is in the process of stepping and can"""
eStateCrashed = _lldb.eStateCrashed
r"""not be examined. Process or thread has crashed and can be examined."""
eStateDetached = _lldb.eStateDetached
r"""Process has been detached and can't be examined."""
eStateExited = _lldb.eStateExited
r"""Process has exited and can't be examined."""
eStateSuspended = _lldb.eStateSuspended
r"""
    Process or thread is in a suspended state as far
    as the debugger is concerned while other processes
    or threads get the chance to run.
    """
kLastStateType = _lldb.kLastStateType

eLaunchFlagNone = _lldb.eLaunchFlagNone

eLaunchFlagExec = _lldb.eLaunchFlagExec
r"""Exec when launching and turn the calling"""
eLaunchFlagDebug = _lldb.eLaunchFlagDebug
r"""process into a new process Stop as soon as the process launches to"""
eLaunchFlagStopAtEntry = _lldb.eLaunchFlagStopAtEntry
r"""allow the process to be debugged Stop at the program entry point"""
eLaunchFlagDisableASLR = _lldb.eLaunchFlagDisableASLR
r"""
    instead of auto-continuing when
    launching or attaching at entry point Disable Address Space Layout Randomization
    """
eLaunchFlagDisableSTDIO = _lldb.eLaunchFlagDisableSTDIO
r"""Disable stdio for inferior process (e.g. for a GUI app)"""
eLaunchFlagLaunchInTTY = _lldb.eLaunchFlagLaunchInTTY
r"""Launch the process in a new TTY if supported by the host"""
eLaunchFlagLaunchInShell = _lldb.eLaunchFlagLaunchInShell
r"""Launch the process inside a shell to get shell expansion"""
eLaunchFlagLaunchInSeparateProcessGroup = _lldb.eLaunchFlagLaunchInSeparateProcessGroup
r"""
    Launch the process in a separate process group
    If you are going to hand the process off (e.g. to
    debugserver)
    """
eLaunchFlagDontSetExitStatus = _lldb.eLaunchFlagDontSetExitStatus
r"""set this flag so lldb & the handee don't race to set its exit status."""
eLaunchFlagDetachOnError = _lldb.eLaunchFlagDetachOnError
r"""
    If set, then the client stub
    should detach rather than killing
    the debugee
    if it loses connection with lldb.
    """
eLaunchFlagShellExpandArguments = _lldb.eLaunchFlagShellExpandArguments
r"""Perform shell-style argument expansion"""
eLaunchFlagCloseTTYOnExit = _lldb.eLaunchFlagCloseTTYOnExit
r"""Close the open TTY on exit"""
eLaunchFlagInheritTCCFromParent = _lldb.eLaunchFlagInheritTCCFromParent
r"""
    Don't make the inferior responsible for its own TCC
    permissions but instead inherit them from its parent.
    """
eOnlyThisThread = _lldb.eOnlyThisThread

eAllThreads = _lldb.eAllThreads

eOnlyDuringStepping = _lldb.eOnlyDuringStepping

eRunForward = _lldb.eRunForward

eRunReverse = _lldb.eRunReverse

eByteOrderInvalid = _lldb.eByteOrderInvalid

eByteOrderBig = _lldb.eByteOrderBig

eByteOrderPDP = _lldb.eByteOrderPDP

eByteOrderLittle = _lldb.eByteOrderLittle

eEncodingInvalid = _lldb.eEncodingInvalid

eEncodingUint = _lldb.eEncodingUint
r"""unsigned integer"""
eEncodingSint = _lldb.eEncodingSint
r"""signed integer"""
eEncodingIEEE754 = _lldb.eEncodingIEEE754
r"""float"""
eEncodingVector = _lldb.eEncodingVector
r"""vector registers"""
eFormatDefault = _lldb.eFormatDefault

eFormatInvalid = _lldb.eFormatInvalid

eFormatBoolean = _lldb.eFormatBoolean

eFormatBinary = _lldb.eFormatBinary

eFormatBytes = _lldb.eFormatBytes

eFormatBytesWithASCII = _lldb.eFormatBytesWithASCII

eFormatChar = _lldb.eFormatChar

eFormatCharPrintable = _lldb.eFormatCharPrintable
r"""Only printable characters, '.' if not printable"""
eFormatComplex = _lldb.eFormatComplex
r"""Floating point complex type"""
eFormatComplexFloat = _lldb.eFormatComplexFloat

eFormatCString = _lldb.eFormatCString
r"""NULL terminated C strings"""
eFormatDecimal = _lldb.eFormatDecimal

eFormatEnum = _lldb.eFormatEnum

eFormatHex = _lldb.eFormatHex

eFormatHexUppercase = _lldb.eFormatHexUppercase

eFormatFloat = _lldb.eFormatFloat

eFormatOctal = _lldb.eFormatOctal

eFormatOSType = _lldb.eFormatOSType
r"""
    OS character codes encoded into an integer 'PICT' 'text'
    etc...
    """
eFormatUnicode16 = _lldb.eFormatUnicode16

eFormatUnicode32 = _lldb.eFormatUnicode32

eFormatUnsigned = _lldb.eFormatUnsigned

eFormatPointer = _lldb.eFormatPointer

eFormatVectorOfChar = _lldb.eFormatVectorOfChar

eFormatVectorOfSInt8 = _lldb.eFormatVectorOfSInt8

eFormatVectorOfUInt8 = _lldb.eFormatVectorOfUInt8

eFormatVectorOfSInt16 = _lldb.eFormatVectorOfSInt16

eFormatVectorOfUInt16 = _lldb.eFormatVectorOfUInt16

eFormatVectorOfSInt32 = _lldb.eFormatVectorOfSInt32

eFormatVectorOfUInt32 = _lldb.eFormatVectorOfUInt32

eFormatVectorOfSInt64 = _lldb.eFormatVectorOfSInt64

eFormatVectorOfUInt64 = _lldb.eFormatVectorOfUInt64

eFormatVectorOfFloat16 = _lldb.eFormatVectorOfFloat16

eFormatVectorOfFloat32 = _lldb.eFormatVectorOfFloat32

eFormatVectorOfFloat64 = _lldb.eFormatVectorOfFloat64

eFormatVectorOfUInt128 = _lldb.eFormatVectorOfUInt128

eFormatComplexInteger = _lldb.eFormatComplexInteger
r"""Integer complex type"""
eFormatCharArray = _lldb.eFormatCharArray
r"""
    Print characters with no single quotes, used for
    character arrays that can contain non printable
    characters
    """
eFormatAddressInfo = _lldb.eFormatAddressInfo
r"""
    Describe what an address points to (func + offset
    with file/line, symbol + offset, data, etc)
    """
eFormatHexFloat = _lldb.eFormatHexFloat
r"""ISO C99 hex float string"""
eFormatInstruction = _lldb.eFormatInstruction
r"""Disassemble an opcode"""
eFormatVoid = _lldb.eFormatVoid
r"""Do not print this"""
eFormatUnicode8 = _lldb.eFormatUnicode8

kNumFormats = _lldb.kNumFormats

eDescriptionLevelBrief = _lldb.eDescriptionLevelBrief

eDescriptionLevelFull = _lldb.eDescriptionLevelFull

eDescriptionLevelVerbose = _lldb.eDescriptionLevelVerbose

eDescriptionLevelInitial = _lldb.eDescriptionLevelInitial

kNumDescriptionLevels = _lldb.kNumDescriptionLevels

eScriptLanguageNone = _lldb.eScriptLanguageNone

eScriptLanguagePython = _lldb.eScriptLanguagePython

eScriptLanguageLua = _lldb.eScriptLanguageLua

eScriptLanguageUnknown = _lldb.eScriptLanguageUnknown

eScriptLanguageDefault = _lldb.eScriptLanguageDefault

eRegisterKindEHFrame = _lldb.eRegisterKindEHFrame
r"""the register numbers seen in eh_frame"""
eRegisterKindDWARF = _lldb.eRegisterKindDWARF
r"""the register numbers seen DWARF"""
eRegisterKindGeneric = _lldb.eRegisterKindGeneric
r"""
    insn ptr reg, stack ptr reg, etc not specific to
    any particular target
    """
eRegisterKindProcessPlugin = _lldb.eRegisterKindProcessPlugin
r"""
    num used by the process plugin - e.g. by the
    remote gdb-protocol stub program
    """
eRegisterKindLLDB = _lldb.eRegisterKindLLDB
r"""lldb's internal register numbers"""
kNumRegisterKinds = _lldb.kNumRegisterKinds

eStopReasonInvalid = _lldb.eStopReasonInvalid

eStopReasonNone = _lldb.eStopReasonNone

eStopReasonTrace = _lldb.eStopReasonTrace

eStopReasonBreakpoint = _lldb.eStopReasonBreakpoint

eStopReasonWatchpoint = _lldb.eStopReasonWatchpoint

eStopReasonSignal = _lldb.eStopReasonSignal

eStopReasonException = _lldb.eStopReasonException

eStopReasonExec = _lldb.eStopReasonExec
r"""Program was re-exec'ed"""
eStopReasonPlanComplete = _lldb.eStopReasonPlanComplete

eStopReasonThreadExiting = _lldb.eStopReasonThreadExiting

eStopReasonInstrumentation = _lldb.eStopReasonInstrumentation

eStopReasonProcessorTrace = _lldb.eStopReasonProcessorTrace

eStopReasonFork = _lldb.eStopReasonFork

eStopReasonVFork = _lldb.eStopReasonVFork

eStopReasonVForkDone = _lldb.eStopReasonVForkDone

eStopReasonInterrupt = _lldb.eStopReasonInterrupt
r"""Thread requested interrupt"""
eStopReasonHistoryBoundary = _lldb.eStopReasonHistoryBoundary

eReturnStatusInvalid = _lldb.eReturnStatusInvalid

eReturnStatusSuccessFinishNoResult = _lldb.eReturnStatusSuccessFinishNoResult

eReturnStatusSuccessFinishResult = _lldb.eReturnStatusSuccessFinishResult

eReturnStatusSuccessContinuingNoResult = _lldb.eReturnStatusSuccessContinuingNoResult

eReturnStatusSuccessContinuingResult = _lldb.eReturnStatusSuccessContinuingResult

eReturnStatusStarted = _lldb.eReturnStatusStarted

eReturnStatusFailed = _lldb.eReturnStatusFailed

eReturnStatusQuit = _lldb.eReturnStatusQuit

eExpressionCompleted = _lldb.eExpressionCompleted

eExpressionSetupError = _lldb.eExpressionSetupError

eExpressionParseError = _lldb.eExpressionParseError

eExpressionDiscarded = _lldb.eExpressionDiscarded

eExpressionInterrupted = _lldb.eExpressionInterrupted

eExpressionHitBreakpoint = _lldb.eExpressionHitBreakpoint

eExpressionTimedOut = _lldb.eExpressionTimedOut

eExpressionResultUnavailable = _lldb.eExpressionResultUnavailable

eExpressionStoppedForDebug = _lldb.eExpressionStoppedForDebug

eExpressionThreadVanished = _lldb.eExpressionThreadVanished

eSearchDepthInvalid = _lldb.eSearchDepthInvalid

eSearchDepthTarget = _lldb.eSearchDepthTarget

eSearchDepthModule = _lldb.eSearchDepthModule

eSearchDepthCompUnit = _lldb.eSearchDepthCompUnit

eSearchDepthFunction = _lldb.eSearchDepthFunction

eSearchDepthBlock = _lldb.eSearchDepthBlock

eSearchDepthAddress = _lldb.eSearchDepthAddress

kLastSearchDepthKind = _lldb.kLastSearchDepthKind

eConnectionStatusSuccess = _lldb.eConnectionStatusSuccess
r"""Success"""
eConnectionStatusEndOfFile = _lldb.eConnectionStatusEndOfFile
r"""End-of-file encountered"""
eConnectionStatusError = _lldb.eConnectionStatusError
r"""Check GetError() for details"""
eConnectionStatusTimedOut = _lldb.eConnectionStatusTimedOut
r"""Request timed out"""
eConnectionStatusNoConnection = _lldb.eConnectionStatusNoConnection
r"""No connection"""
eConnectionStatusLostConnection = _lldb.eConnectionStatusLostConnection
r"""
    Lost connection while connected to a
    valid connection
    """
eConnectionStatusInterrupted = _lldb.eConnectionStatusInterrupted
r"""Interrupted read"""
eErrorTypeInvalid = _lldb.eErrorTypeInvalid

eErrorTypeGeneric = _lldb.eErrorTypeGeneric
r"""Generic errors that can be any value."""
eErrorTypeMachKernel = _lldb.eErrorTypeMachKernel
r"""Mach kernel error codes."""
eErrorTypePOSIX = _lldb.eErrorTypePOSIX
r"""POSIX error codes."""
eErrorTypeExpression = _lldb.eErrorTypeExpression
r"""These are from the ExpressionResults enum."""
eErrorTypeWin32 = _lldb.eErrorTypeWin32
r"""Standard Win32 error codes."""
eValueTypeInvalid = _lldb.eValueTypeInvalid

eValueTypeVariableGlobal = _lldb.eValueTypeVariableGlobal
r"""globals variable"""
eValueTypeVariableStatic = _lldb.eValueTypeVariableStatic
r"""static variable"""
eValueTypeVariableArgument = _lldb.eValueTypeVariableArgument
r"""function argument variables"""
eValueTypeVariableLocal = _lldb.eValueTypeVariableLocal
r"""function local variables"""
eValueTypeRegister = _lldb.eValueTypeRegister
r"""stack frame register value"""
eValueTypeRegisterSet = _lldb.eValueTypeRegisterSet
r"""A collection of stack frame register values"""
eValueTypeConstResult = _lldb.eValueTypeConstResult
r"""constant result variables"""
eValueTypeVariableThreadLocal = _lldb.eValueTypeVariableThreadLocal
r"""thread local storage variable"""
eValueTypeVTable = _lldb.eValueTypeVTable
r"""virtual function table"""
eValueTypeVTableEntry = _lldb.eValueTypeVTableEntry
r"""function pointer in virtual function table"""
eInputReaderGranularityInvalid = _lldb.eInputReaderGranularityInvalid

eInputReaderGranularityByte = _lldb.eInputReaderGranularityByte

eInputReaderGranularityWord = _lldb.eInputReaderGranularityWord

eInputReaderGranularityLine = _lldb.eInputReaderGranularityLine

eInputReaderGranularityAll = _lldb.eInputReaderGranularityAll

eSymbolContextTarget = _lldb.eSymbolContextTarget
r"""
    Set when *target* is requested from a query, or was located
    in query results
    """
eSymbolContextModule = _lldb.eSymbolContextModule
r"""
    Set when *module* is requested from a query, or was located
    in query results
    """
eSymbolContextCompUnit = _lldb.eSymbolContextCompUnit
r"""
    Set when *comp_unit* is requested from a query, or was
    located in query results
    """
eSymbolContextFunction = _lldb.eSymbolContextFunction
r"""
    Set when *function* is requested from a query, or was located
    in query results
    """
eSymbolContextBlock = _lldb.eSymbolContextBlock
r"""
    Set when the deepest *block* is requested from a query, or
    was located in query results
    """
eSymbolContextLineEntry = _lldb.eSymbolContextLineEntry
r"""
    Set when *line_entry* is requested from a query, or was
    located in query results
    """
eSymbolContextSymbol = _lldb.eSymbolContextSymbol
r"""
    Set when *symbol* is requested from a query, or was located
    in query results
    """
eSymbolContextEverything = _lldb.eSymbolContextEverything
r"""
    Indicates to try and lookup everything up during a routine
    symbol context query.
    """
eSymbolContextVariable = _lldb.eSymbolContextVariable
r"""
    Set when *global* or static variable is requested from a
    query, or was located in query results.
    eSymbolContextVariable is potentially expensive to lookup so
    it isn't included in eSymbolContextEverything which stops it
    from being used during frame PC lookups and many other
    potential address to symbol context lookups.
    """
eSymbolContextLastItem = _lldb.eSymbolContextLastItem

ePermissionsWritable = _lldb.ePermissionsWritable

ePermissionsReadable = _lldb.ePermissionsReadable

ePermissionsExecutable = _lldb.ePermissionsExecutable

eInputReaderActivate = _lldb.eInputReaderActivate
r"""reader is newly pushed onto the reader stack"""
eInputReaderAsynchronousOutputWritten = _lldb.eInputReaderAsynchronousOutputWritten
r"""
    an async output event occurred;
    the reader may want to do
    something
    """
eInputReaderReactivate = _lldb.eInputReaderReactivate
r"""
    reader is on top of the stack again after another
    reader was popped off
    """
eInputReaderDeactivate = _lldb.eInputReaderDeactivate
r"""another reader was pushed on the stack"""
eInputReaderGotToken = _lldb.eInputReaderGotToken
r"""reader got one of its tokens (granularity)"""
eInputReaderInterrupt = _lldb.eInputReaderInterrupt
r"""
    reader received an interrupt signal (probably from
    a control-c)
    """
eInputReaderEndOfFile = _lldb.eInputReaderEndOfFile
r"""
    reader received an EOF char (probably from a
    control-d)
    """
eInputReaderDone = _lldb.eInputReaderDone
r"""reader was just popped off the stack and is done"""
eBreakpointEventTypeInvalidType = _lldb.eBreakpointEventTypeInvalidType

eBreakpointEventTypeAdded = _lldb.eBreakpointEventTypeAdded

eBreakpointEventTypeRemoved = _lldb.eBreakpointEventTypeRemoved

eBreakpointEventTypeLocationsAdded = _lldb.eBreakpointEventTypeLocationsAdded
r"""
    Locations added doesn't
    get sent when the
    breakpoint is created
    """
eBreakpointEventTypeLocationsRemoved = _lldb.eBreakpointEventTypeLocationsRemoved

eBreakpointEventTypeLocationsResolved = _lldb.eBreakpointEventTypeLocationsResolved

eBreakpointEventTypeEnabled = _lldb.eBreakpointEventTypeEnabled

eBreakpointEventTypeDisabled = _lldb.eBreakpointEventTypeDisabled

eBreakpointEventTypeCommandChanged = _lldb.eBreakpointEventTypeCommandChanged

eBreakpointEventTypeConditionChanged = _lldb.eBreakpointEventTypeConditionChanged

eBreakpointEventTypeIgnoreChanged = _lldb.eBreakpointEventTypeIgnoreChanged

eBreakpointEventTypeThreadChanged = _lldb.eBreakpointEventTypeThreadChanged

eBreakpointEventTypeAutoContinueChanged = _lldb.eBreakpointEventTypeAutoContinueChanged

eWatchpointEventTypeInvalidType = _lldb.eWatchpointEventTypeInvalidType

eWatchpointEventTypeAdded = _lldb.eWatchpointEventTypeAdded

eWatchpointEventTypeRemoved = _lldb.eWatchpointEventTypeRemoved

eWatchpointEventTypeEnabled = _lldb.eWatchpointEventTypeEnabled

eWatchpointEventTypeDisabled = _lldb.eWatchpointEventTypeDisabled

eWatchpointEventTypeCommandChanged = _lldb.eWatchpointEventTypeCommandChanged

eWatchpointEventTypeConditionChanged = _lldb.eWatchpointEventTypeConditionChanged

eWatchpointEventTypeIgnoreChanged = _lldb.eWatchpointEventTypeIgnoreChanged

eWatchpointEventTypeThreadChanged = _lldb.eWatchpointEventTypeThreadChanged

eWatchpointEventTypeTypeChanged = _lldb.eWatchpointEventTypeTypeChanged

eWatchpointWriteTypeDisabled = _lldb.eWatchpointWriteTypeDisabled
r"""Don't stop when the watched memory region is written to."""
eWatchpointWriteTypeAlways = _lldb.eWatchpointWriteTypeAlways
r"""
    Stop on any write access to the memory region, even if
    the value doesn't change.  On some architectures, a write
    near the memory region may be falsely reported as a match,
    and notify this spurious stop as a watchpoint trap.
    """
eWatchpointWriteTypeOnModify = _lldb.eWatchpointWriteTypeOnModify
r"""
    Stop on a write to the memory region that changes its value.
    This is most likely the behavior a user expects, and is the
    behavior in gdb.  lldb can silently ignore writes near the
    watched memory region that are reported as accesses to lldb.
    """
eLanguageTypeUnknown = _lldb.eLanguageTypeUnknown
r"""Unknown or invalid language value."""
eLanguageTypeC89 = _lldb.eLanguageTypeC89
r"""ISO C:1989."""
eLanguageTypeC = _lldb.eLanguageTypeC
r"""Non-standardized C, such as K&R."""
eLanguageTypeAda83 = _lldb.eLanguageTypeAda83
r"""ISO Ada:1983."""
eLanguageTypeC_plus_plus = _lldb.eLanguageTypeC_plus_plus
r"""ISO C++:1998."""
eLanguageTypeCobol74 = _lldb.eLanguageTypeCobol74
r"""ISO Cobol:1974."""
eLanguageTypeCobol85 = _lldb.eLanguageTypeCobol85
r"""ISO Cobol:1985."""
eLanguageTypeFortran77 = _lldb.eLanguageTypeFortran77
r"""ISO Fortran 77."""
eLanguageTypeFortran90 = _lldb.eLanguageTypeFortran90
r"""ISO Fortran 90."""
eLanguageTypePascal83 = _lldb.eLanguageTypePascal83
r"""ISO Pascal:1983."""
eLanguageTypeModula2 = _lldb.eLanguageTypeModula2
r"""ISO Modula-2:1996."""
eLanguageTypeJava = _lldb.eLanguageTypeJava
r"""Java."""
eLanguageTypeC99 = _lldb.eLanguageTypeC99
r"""ISO C:1999."""
eLanguageTypeAda95 = _lldb.eLanguageTypeAda95
r"""ISO Ada:1995."""
eLanguageTypeFortran95 = _lldb.eLanguageTypeFortran95
r"""ISO Fortran 95."""
eLanguageTypePLI = _lldb.eLanguageTypePLI
r"""ANSI PL/I:1976."""
eLanguageTypeObjC = _lldb.eLanguageTypeObjC
r"""Objective-C."""
eLanguageTypeObjC_plus_plus = _lldb.eLanguageTypeObjC_plus_plus
r"""Objective-C++."""
eLanguageTypeUPC = _lldb.eLanguageTypeUPC
r"""Unified Parallel C."""
eLanguageTypeD = _lldb.eLanguageTypeD
r"""D."""
eLanguageTypePython = _lldb.eLanguageTypePython
r"""Python."""
eLanguageTypeOpenCL = _lldb.eLanguageTypeOpenCL
r"""OpenCL."""
eLanguageTypeGo = _lldb.eLanguageTypeGo
r"""Go."""
eLanguageTypeModula3 = _lldb.eLanguageTypeModula3
r"""Modula 3."""
eLanguageTypeHaskell = _lldb.eLanguageTypeHaskell
r"""Haskell."""
eLanguageTypeC_plus_plus_03 = _lldb.eLanguageTypeC_plus_plus_03
r"""ISO C++:2003."""
eLanguageTypeC_plus_plus_11 = _lldb.eLanguageTypeC_plus_plus_11
r"""ISO C++:2011."""
eLanguageTypeOCaml = _lldb.eLanguageTypeOCaml
r"""OCaml."""
eLanguageTypeRust = _lldb.eLanguageTypeRust
r"""Rust."""
eLanguageTypeC11 = _lldb.eLanguageTypeC11
r"""ISO C:2011."""
eLanguageTypeSwift = _lldb.eLanguageTypeSwift
r"""Swift."""
eLanguageTypeJulia = _lldb.eLanguageTypeJulia
r"""Julia."""
eLanguageTypeDylan = _lldb.eLanguageTypeDylan
r"""Dylan."""
eLanguageTypeC_plus_plus_14 = _lldb.eLanguageTypeC_plus_plus_14
r"""ISO C++:2014."""
eLanguageTypeFortran03 = _lldb.eLanguageTypeFortran03
r"""ISO Fortran 2003."""
eLanguageTypeFortran08 = _lldb.eLanguageTypeFortran08
r"""ISO Fortran 2008."""
eLanguageTypeRenderScript = _lldb.eLanguageTypeRenderScript

eLanguageTypeBLISS = _lldb.eLanguageTypeBLISS

eLanguageTypeKotlin = _lldb.eLanguageTypeKotlin

eLanguageTypeZig = _lldb.eLanguageTypeZig

eLanguageTypeCrystal = _lldb.eLanguageTypeCrystal

eLanguageTypeC_plus_plus_17 = _lldb.eLanguageTypeC_plus_plus_17
r"""ISO C++:2017."""
eLanguageTypeC_plus_plus_20 = _lldb.eLanguageTypeC_plus_plus_20
r"""ISO C++:2020."""
eLanguageTypeC17 = _lldb.eLanguageTypeC17

eLanguageTypeFortran18 = _lldb.eLanguageTypeFortran18

eLanguageTypeAda2005 = _lldb.eLanguageTypeAda2005

eLanguageTypeAda2012 = _lldb.eLanguageTypeAda2012

eLanguageTypeHIP = _lldb.eLanguageTypeHIP

eLanguageTypeAssembly = _lldb.eLanguageTypeAssembly

eLanguageTypeC_sharp = _lldb.eLanguageTypeC_sharp

eLanguageTypeMojo = _lldb.eLanguageTypeMojo

eLanguageTypeMipsAssembler = _lldb.eLanguageTypeMipsAssembler
r"""Mips_Assembler."""
eNumLanguageTypes = _lldb.eNumLanguageTypes

eInstrumentationRuntimeTypeAddressSanitizer = _lldb.eInstrumentationRuntimeTypeAddressSanitizer

eInstrumentationRuntimeTypeThreadSanitizer = _lldb.eInstrumentationRuntimeTypeThreadSanitizer

eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = _lldb.eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer

eInstrumentationRuntimeTypeMainThreadChecker = _lldb.eInstrumentationRuntimeTypeMainThreadChecker

eInstrumentationRuntimeTypeSwiftRuntimeReporting = _lldb.eInstrumentationRuntimeTypeSwiftRuntimeReporting

eInstrumentationRuntimeTypeLibsanitizersAsan = _lldb.eInstrumentationRuntimeTypeLibsanitizersAsan

eNumInstrumentationRuntimeTypes = _lldb.eNumInstrumentationRuntimeTypes

eNoDynamicValues = _lldb.eNoDynamicValues

eDynamicCanRunTarget = _lldb.eDynamicCanRunTarget

eDynamicDontRunTarget = _lldb.eDynamicDontRunTarget

eStopShowColumnAnsiOrCaret = _lldb.eStopShowColumnAnsiOrCaret

eStopShowColumnAnsi = _lldb.eStopShowColumnAnsi

eStopShowColumnCaret = _lldb.eStopShowColumnCaret

eStopShowColumnNone = _lldb.eStopShowColumnNone

eAccessNone = _lldb.eAccessNone

eAccessPublic = _lldb.eAccessPublic

eAccessPrivate = _lldb.eAccessPrivate

eAccessProtected = _lldb.eAccessProtected

eAccessPackage = _lldb.eAccessPackage

eArgTypeAddress = _lldb.eArgTypeAddress

eArgTypeAddressOrExpression = _lldb.eArgTypeAddressOrExpression

eArgTypeAliasName = _lldb.eArgTypeAliasName

eArgTypeAliasOptions = _lldb.eArgTypeAliasOptions

eArgTypeArchitecture = _lldb.eArgTypeArchitecture

eArgTypeBoolean = _lldb.eArgTypeBoolean

eArgTypeBreakpointID = _lldb.eArgTypeBreakpointID

eArgTypeBreakpointIDRange = _lldb.eArgTypeBreakpointIDRange

eArgTypeBreakpointName = _lldb.eArgTypeBreakpointName

eArgTypeByteSize = _lldb.eArgTypeByteSize

eArgTypeClassName = _lldb.eArgTypeClassName

eArgTypeCommandName = _lldb.eArgTypeCommandName

eArgTypeCount = _lldb.eArgTypeCount

eArgTypeDescriptionVerbosity = _lldb.eArgTypeDescriptionVerbosity

eArgTypeDirectoryName = _lldb.eArgTypeDirectoryName

eArgTypeDisassemblyFlavor = _lldb.eArgTypeDisassemblyFlavor

eArgTypeEndAddress = _lldb.eArgTypeEndAddress

eArgTypeExpression = _lldb.eArgTypeExpression

eArgTypeExpressionPath = _lldb.eArgTypeExpressionPath

eArgTypeExprFormat = _lldb.eArgTypeExprFormat

eArgTypeFileLineColumn = _lldb.eArgTypeFileLineColumn

eArgTypeFilename = _lldb.eArgTypeFilename

eArgTypeFormat = _lldb.eArgTypeFormat

eArgTypeFrameIndex = _lldb.eArgTypeFrameIndex

eArgTypeFullName = _lldb.eArgTypeFullName

eArgTypeFunctionName = _lldb.eArgTypeFunctionName

eArgTypeFunctionOrSymbol = _lldb.eArgTypeFunctionOrSymbol

eArgTypeGDBFormat = _lldb.eArgTypeGDBFormat

eArgTypeHelpText = _lldb.eArgTypeHelpText

eArgTypeIndex = _lldb.eArgTypeIndex

eArgTypeLanguage = _lldb.eArgTypeLanguage

eArgTypeLineNum = _lldb.eArgTypeLineNum

eArgTypeLogCategory = _lldb.eArgTypeLogCategory

eArgTypeLogChannel = _lldb.eArgTypeLogChannel

eArgTypeMethod = _lldb.eArgTypeMethod

eArgTypeName = _lldb.eArgTypeName

eArgTypeNewPathPrefix = _lldb.eArgTypeNewPathPrefix

eArgTypeNumLines = _lldb.eArgTypeNumLines

eArgTypeNumberPerLine = _lldb.eArgTypeNumberPerLine

eArgTypeOffset = _lldb.eArgTypeOffset

eArgTypeOldPathPrefix = _lldb.eArgTypeOldPathPrefix

eArgTypeOneLiner = _lldb.eArgTypeOneLiner

eArgTypePath = _lldb.eArgTypePath

eArgTypePermissionsNumber = _lldb.eArgTypePermissionsNumber

eArgTypePermissionsString = _lldb.eArgTypePermissionsString

eArgTypePid = _lldb.eArgTypePid

eArgTypePlugin = _lldb.eArgTypePlugin

eArgTypeProcessName = _lldb.eArgTypeProcessName

eArgTypePythonClass = _lldb.eArgTypePythonClass

eArgTypePythonFunction = _lldb.eArgTypePythonFunction

eArgTypePythonScript = _lldb.eArgTypePythonScript

eArgTypeQueueName = _lldb.eArgTypeQueueName

eArgTypeRegisterName = _lldb.eArgTypeRegisterName

eArgTypeRegularExpression = _lldb.eArgTypeRegularExpression

eArgTypeRunArgs = _lldb.eArgTypeRunArgs

eArgTypeRunMode = _lldb.eArgTypeRunMode

eArgTypeScriptedCommandSynchronicity = _lldb.eArgTypeScriptedCommandSynchronicity

eArgTypeScriptLang = _lldb.eArgTypeScriptLang

eArgTypeSearchWord = _lldb.eArgTypeSearchWord

eArgTypeSelector = _lldb.eArgTypeSelector

eArgTypeSettingIndex = _lldb.eArgTypeSettingIndex

eArgTypeSettingKey = _lldb.eArgTypeSettingKey

eArgTypeSettingPrefix = _lldb.eArgTypeSettingPrefix

eArgTypeSettingVariableName = _lldb.eArgTypeSettingVariableName

eArgTypeShlibName = _lldb.eArgTypeShlibName

eArgTypeSourceFile = _lldb.eArgTypeSourceFile

eArgTypeSortOrder = _lldb.eArgTypeSortOrder

eArgTypeStartAddress = _lldb.eArgTypeStartAddress

eArgTypeSummaryString = _lldb.eArgTypeSummaryString

eArgTypeSymbol = _lldb.eArgTypeSymbol

eArgTypeThreadID = _lldb.eArgTypeThreadID

eArgTypeThreadIndex = _lldb.eArgTypeThreadIndex

eArgTypeThreadName = _lldb.eArgTypeThreadName

eArgTypeTypeName = _lldb.eArgTypeTypeName

eArgTypeUnsignedInteger = _lldb.eArgTypeUnsignedInteger

eArgTypeUnixSignal = _lldb.eArgTypeUnixSignal

eArgTypeVarName = _lldb.eArgTypeVarName

eArgTypeValue = _lldb.eArgTypeValue

eArgTypeWidth = _lldb.eArgTypeWidth

eArgTypeNone = _lldb.eArgTypeNone

eArgTypePlatform = _lldb.eArgTypePlatform

eArgTypeWatchpointID = _lldb.eArgTypeWatchpointID

eArgTypeWatchpointIDRange = _lldb.eArgTypeWatchpointIDRange

eArgTypeWatchType = _lldb.eArgTypeWatchType

eArgRawInput = _lldb.eArgRawInput

eArgTypeCommand = _lldb.eArgTypeCommand

eArgTypeColumnNum = _lldb.eArgTypeColumnNum

eArgTypeModuleUUID = _lldb.eArgTypeModuleUUID

eArgTypeSaveCoreStyle = _lldb.eArgTypeSaveCoreStyle

eArgTypeLogHandler = _lldb.eArgTypeLogHandler

eArgTypeSEDStylePair = _lldb.eArgTypeSEDStylePair

eArgTypeRecognizerID = _lldb.eArgTypeRecognizerID

eArgTypeConnectURL = _lldb.eArgTypeConnectURL

eArgTypeTargetID = _lldb.eArgTypeTargetID

eArgTypeStopHookID = _lldb.eArgTypeStopHookID

eArgTypeCompletionType = _lldb.eArgTypeCompletionType

eArgTypeRemotePath = _lldb.eArgTypeRemotePath

eArgTypeRemoteFilename = _lldb.eArgTypeRemoteFilename

eArgTypeModule = _lldb.eArgTypeModule

eArgTypeCPUName = _lldb.eArgTypeCPUName

eArgTypeCPUFeatures = _lldb.eArgTypeCPUFeatures

eArgTypeManagedPlugin = _lldb.eArgTypeManagedPlugin

eArgTypeProtocol = _lldb.eArgTypeProtocol

eArgTypeLastArg = _lldb.eArgTypeLastArg

eSymbolTypeAny = _lldb.eSymbolTypeAny

eSymbolTypeInvalid = _lldb.eSymbolTypeInvalid

eSymbolTypeAbsolute = _lldb.eSymbolTypeAbsolute

eSymbolTypeCode = _lldb.eSymbolTypeCode

eSymbolTypeResolver = _lldb.eSymbolTypeResolver

eSymbolTypeData = _lldb.eSymbolTypeData

eSymbolTypeTrampoline = _lldb.eSymbolTypeTrampoline

eSymbolTypeRuntime = _lldb.eSymbolTypeRuntime

eSymbolTypeException = _lldb.eSymbolTypeException

eSymbolTypeSourceFile = _lldb.eSymbolTypeSourceFile

eSymbolTypeHeaderFile = _lldb.eSymbolTypeHeaderFile

eSymbolTypeObjectFile = _lldb.eSymbolTypeObjectFile

eSymbolTypeCommonBlock = _lldb.eSymbolTypeCommonBlock

eSymbolTypeBlock = _lldb.eSymbolTypeBlock

eSymbolTypeLocal = _lldb.eSymbolTypeLocal

eSymbolTypeParam = _lldb.eSymbolTypeParam

eSymbolTypeVariable = _lldb.eSymbolTypeVariable

eSymbolTypeVariableType = _lldb.eSymbolTypeVariableType

eSymbolTypeLineEntry = _lldb.eSymbolTypeLineEntry

eSymbolTypeLineHeader = _lldb.eSymbolTypeLineHeader

eSymbolTypeScopeBegin = _lldb.eSymbolTypeScopeBegin

eSymbolTypeScopeEnd = _lldb.eSymbolTypeScopeEnd

eSymbolTypeAdditional = _lldb.eSymbolTypeAdditional
r"""
    When symbols take more than one entry, the extra
    entries get this type
    """
eSymbolTypeCompiler = _lldb.eSymbolTypeCompiler

eSymbolTypeInstrumentation = _lldb.eSymbolTypeInstrumentation

eSymbolTypeUndefined = _lldb.eSymbolTypeUndefined

eSymbolTypeObjCClass = _lldb.eSymbolTypeObjCClass

eSymbolTypeObjCMetaClass = _lldb.eSymbolTypeObjCMetaClass

eSymbolTypeObjCIVar = _lldb.eSymbolTypeObjCIVar

eSymbolTypeReExported = _lldb.eSymbolTypeReExported

eSectionTypeInvalid = _lldb.eSectionTypeInvalid

eSectionTypeCode = _lldb.eSectionTypeCode

eSectionTypeContainer = _lldb.eSectionTypeContainer
r"""The section contains child sections"""
eSectionTypeData = _lldb.eSectionTypeData

eSectionTypeDataCString = _lldb.eSectionTypeDataCString
r"""Inlined C string data"""
eSectionTypeDataCStringPointers = _lldb.eSectionTypeDataCStringPointers
r"""Pointers to C string data"""
eSectionTypeDataSymbolAddress = _lldb.eSectionTypeDataSymbolAddress
r"""Address of a symbol in the symbol table"""
eSectionTypeData4 = _lldb.eSectionTypeData4

eSectionTypeData8 = _lldb.eSectionTypeData8

eSectionTypeData16 = _lldb.eSectionTypeData16

eSectionTypeDataPointers = _lldb.eSectionTypeDataPointers

eSectionTypeDebug = _lldb.eSectionTypeDebug

eSectionTypeZeroFill = _lldb.eSectionTypeZeroFill

eSectionTypeDataObjCMessageRefs = _lldb.eSectionTypeDataObjCMessageRefs
r"""Pointer to function pointer + selector"""
eSectionTypeDataObjCCFStrings = _lldb.eSectionTypeDataObjCCFStrings
r"""
    Objective-C const CFString/NSString
    objects
    """
eSectionTypeDWARFDebugAbbrev = _lldb.eSectionTypeDWARFDebugAbbrev

eSectionTypeDWARFDebugAddr = _lldb.eSectionTypeDWARFDebugAddr

eSectionTypeDWARFDebugAranges = _lldb.eSectionTypeDWARFDebugAranges

eSectionTypeDWARFDebugCuIndex = _lldb.eSectionTypeDWARFDebugCuIndex

eSectionTypeDWARFDebugFrame = _lldb.eSectionTypeDWARFDebugFrame

eSectionTypeDWARFDebugInfo = _lldb.eSectionTypeDWARFDebugInfo

eSectionTypeDWARFDebugLine = _lldb.eSectionTypeDWARFDebugLine

eSectionTypeDWARFDebugLoc = _lldb.eSectionTypeDWARFDebugLoc

eSectionTypeDWARFDebugMacInfo = _lldb.eSectionTypeDWARFDebugMacInfo

eSectionTypeDWARFDebugMacro = _lldb.eSectionTypeDWARFDebugMacro

eSectionTypeDWARFDebugPubNames = _lldb.eSectionTypeDWARFDebugPubNames

eSectionTypeDWARFDebugPubTypes = _lldb.eSectionTypeDWARFDebugPubTypes

eSectionTypeDWARFDebugRanges = _lldb.eSectionTypeDWARFDebugRanges

eSectionTypeDWARFDebugStr = _lldb.eSectionTypeDWARFDebugStr

eSectionTypeDWARFDebugStrOffsets = _lldb.eSectionTypeDWARFDebugStrOffsets

eSectionTypeDWARFAppleNames = _lldb.eSectionTypeDWARFAppleNames

eSectionTypeDWARFAppleTypes = _lldb.eSectionTypeDWARFAppleTypes

eSectionTypeDWARFAppleNamespaces = _lldb.eSectionTypeDWARFAppleNamespaces

eSectionTypeDWARFAppleObjC = _lldb.eSectionTypeDWARFAppleObjC

eSectionTypeELFSymbolTable = _lldb.eSectionTypeELFSymbolTable
r"""Elf SHT_SYMTAB section"""
eSectionTypeELFDynamicSymbols = _lldb.eSectionTypeELFDynamicSymbols
r"""Elf SHT_DYNSYM section"""
eSectionTypeELFRelocationEntries = _lldb.eSectionTypeELFRelocationEntries
r"""Elf SHT_REL or SHT_REL section"""
eSectionTypeELFDynamicLinkInfo = _lldb.eSectionTypeELFDynamicLinkInfo
r"""Elf SHT_DYNAMIC section"""
eSectionTypeEHFrame = _lldb.eSectionTypeEHFrame

eSectionTypeARMexidx = _lldb.eSectionTypeARMexidx

eSectionTypeARMextab = _lldb.eSectionTypeARMextab

eSectionTypeCompactUnwind = _lldb.eSectionTypeCompactUnwind
r"""
    compact unwind section in Mach-O,
    __TEXT,__unwind_info
    """
eSectionTypeGoSymtab = _lldb.eSectionTypeGoSymtab

eSectionTypeAbsoluteAddress = _lldb.eSectionTypeAbsoluteAddress
r"""
    Dummy section for symbols with absolute
    address
    """
eSectionTypeDWARFGNUDebugAltLink = _lldb.eSectionTypeDWARFGNUDebugAltLink

eSectionTypeDWARFDebugTypes = _lldb.eSectionTypeDWARFDebugTypes
r"""DWARF .debug_types section"""
eSectionTypeDWARFDebugNames = _lldb.eSectionTypeDWARFDebugNames
r"""DWARF v5 .debug_names"""
eSectionTypeOther = _lldb.eSectionTypeOther

eSectionTypeDWARFDebugLineStr = _lldb.eSectionTypeDWARFDebugLineStr
r"""DWARF v5 .debug_line_str"""
eSectionTypeDWARFDebugRngLists = _lldb.eSectionTypeDWARFDebugRngLists
r"""DWARF v5 .debug_rnglists"""
eSectionTypeDWARFDebugLocLists = _lldb.eSectionTypeDWARFDebugLocLists
r"""DWARF v5 .debug_loclists"""
eSectionTypeDWARFDebugAbbrevDwo = _lldb.eSectionTypeDWARFDebugAbbrevDwo

eSectionTypeDWARFDebugInfoDwo = _lldb.eSectionTypeDWARFDebugInfoDwo

eSectionTypeDWARFDebugStrDwo = _lldb.eSectionTypeDWARFDebugStrDwo

eSectionTypeDWARFDebugStrOffsetsDwo = _lldb.eSectionTypeDWARFDebugStrOffsetsDwo

eSectionTypeDWARFDebugTypesDwo = _lldb.eSectionTypeDWARFDebugTypesDwo

eSectionTypeDWARFDebugRngListsDwo = _lldb.eSectionTypeDWARFDebugRngListsDwo

eSectionTypeDWARFDebugLocDwo = _lldb.eSectionTypeDWARFDebugLocDwo

eSectionTypeDWARFDebugLocListsDwo = _lldb.eSectionTypeDWARFDebugLocListsDwo

eSectionTypeDWARFDebugTuIndex = _lldb.eSectionTypeDWARFDebugTuIndex

eSectionTypeCTF = _lldb.eSectionTypeCTF

eSectionTypeLLDBTypeSummaries = _lldb.eSectionTypeLLDBTypeSummaries

eSectionTypeLLDBFormatters = _lldb.eSectionTypeLLDBFormatters

eSectionTypeSwiftModules = _lldb.eSectionTypeSwiftModules

eEmulateInstructionOptionNone = _lldb.eEmulateInstructionOptionNone

eEmulateInstructionOptionAutoAdvancePC = _lldb.eEmulateInstructionOptionAutoAdvancePC

eEmulateInstructionOptionIgnoreConditions = _lldb.eEmulateInstructionOptionIgnoreConditions

eFunctionNameTypeNone = _lldb.eFunctionNameTypeNone

eFunctionNameTypeAuto = _lldb.eFunctionNameTypeAuto
r"""
    Automatically figure out which FunctionNameType
    bits to set based on the function name.
    """
eFunctionNameTypeFull = _lldb.eFunctionNameTypeFull
r"""
    The function name.
    For C this is the same as just the name of the function For C++ this is
    the mangled or demangled version of the mangled name. For ObjC this is
    the full function signature with the + or - and the square brackets and
    the class and selector
    """
eFunctionNameTypeBase = _lldb.eFunctionNameTypeBase
r"""
    The function name only, no namespaces
    or arguments and no class
    methods or selectors will be searched.
    """
eFunctionNameTypeMethod = _lldb.eFunctionNameTypeMethod
r"""
    Find function by method name (C++)
    with no namespace or arguments
    """
eFunctionNameTypeSelector = _lldb.eFunctionNameTypeSelector
r"""Find function by selector name (ObjC) names"""
eFunctionNameTypeAny = _lldb.eFunctionNameTypeAny
r"""DEPRECATED: use eFunctionNameTypeAuto"""
eBasicTypeInvalid = _lldb.eBasicTypeInvalid

eBasicTypeVoid = _lldb.eBasicTypeVoid

eBasicTypeChar = _lldb.eBasicTypeChar

eBasicTypeSignedChar = _lldb.eBasicTypeSignedChar

eBasicTypeUnsignedChar = _lldb.eBasicTypeUnsignedChar

eBasicTypeWChar = _lldb.eBasicTypeWChar

eBasicTypeSignedWChar = _lldb.eBasicTypeSignedWChar

eBasicTypeUnsignedWChar = _lldb.eBasicTypeUnsignedWChar

eBasicTypeChar16 = _lldb.eBasicTypeChar16

eBasicTypeChar32 = _lldb.eBasicTypeChar32

eBasicTypeChar8 = _lldb.eBasicTypeChar8

eBasicTypeShort = _lldb.eBasicTypeShort

eBasicTypeUnsignedShort = _lldb.eBasicTypeUnsignedShort

eBasicTypeInt = _lldb.eBasicTypeInt

eBasicTypeUnsignedInt = _lldb.eBasicTypeUnsignedInt

eBasicTypeLong = _lldb.eBasicTypeLong

eBasicTypeUnsignedLong = _lldb.eBasicTypeUnsignedLong

eBasicTypeLongLong = _lldb.eBasicTypeLongLong

eBasicTypeUnsignedLongLong = _lldb.eBasicTypeUnsignedLongLong

eBasicTypeInt128 = _lldb.eBasicTypeInt128

eBasicTypeUnsignedInt128 = _lldb.eBasicTypeUnsignedInt128

eBasicTypeBool = _lldb.eBasicTypeBool

eBasicTypeHalf = _lldb.eBasicTypeHalf

eBasicTypeFloat = _lldb.eBasicTypeFloat

eBasicTypeDouble = _lldb.eBasicTypeDouble

eBasicTypeLongDouble = _lldb.eBasicTypeLongDouble

eBasicTypeFloatComplex = _lldb.eBasicTypeFloatComplex

eBasicTypeDoubleComplex = _lldb.eBasicTypeDoubleComplex

eBasicTypeLongDoubleComplex = _lldb.eBasicTypeLongDoubleComplex

eBasicTypeObjCID = _lldb.eBasicTypeObjCID

eBasicTypeObjCClass = _lldb.eBasicTypeObjCClass

eBasicTypeObjCSel = _lldb.eBasicTypeObjCSel

eBasicTypeNullPtr = _lldb.eBasicTypeNullPtr

eBasicTypeOther = _lldb.eBasicTypeOther

eTraceTypeNone = _lldb.eTraceTypeNone

eTraceTypeProcessorTrace = _lldb.eTraceTypeProcessorTrace
r"""Intel Processor Trace"""
eStructuredDataTypeInvalid = _lldb.eStructuredDataTypeInvalid

eStructuredDataTypeNull = _lldb.eStructuredDataTypeNull

eStructuredDataTypeGeneric = _lldb.eStructuredDataTypeGeneric

eStructuredDataTypeArray = _lldb.eStructuredDataTypeArray

eStructuredDataTypeInteger = _lldb.eStructuredDataTypeInteger

eStructuredDataTypeFloat = _lldb.eStructuredDataTypeFloat

eStructuredDataTypeBoolean = _lldb.eStructuredDataTypeBoolean

eStructuredDataTypeString = _lldb.eStructuredDataTypeString

eStructuredDataTypeDictionary = _lldb.eStructuredDataTypeDictionary

eStructuredDataTypeSignedInteger = _lldb.eStructuredDataTypeSignedInteger

eStructuredDataTypeUnsignedInteger = _lldb.eStructuredDataTypeUnsignedInteger

eTypeClassInvalid = _lldb.eTypeClassInvalid

eTypeClassArray = _lldb.eTypeClassArray

eTypeClassBlockPointer = _lldb.eTypeClassBlockPointer

eTypeClassBuiltin = _lldb.eTypeClassBuiltin

eTypeClassClass = _lldb.eTypeClassClass

eTypeClassComplexFloat = _lldb.eTypeClassComplexFloat

eTypeClassComplexInteger = _lldb.eTypeClassComplexInteger

eTypeClassEnumeration = _lldb.eTypeClassEnumeration

eTypeClassFunction = _lldb.eTypeClassFunction

eTypeClassMemberPointer = _lldb.eTypeClassMemberPointer

eTypeClassObjCObject = _lldb.eTypeClassObjCObject

eTypeClassObjCInterface = _lldb.eTypeClassObjCInterface

eTypeClassObjCObjectPointer = _lldb.eTypeClassObjCObjectPointer

eTypeClassPointer = _lldb.eTypeClassPointer

eTypeClassReference = _lldb.eTypeClassReference

eTypeClassStruct = _lldb.eTypeClassStruct

eTypeClassTypedef = _lldb.eTypeClassTypedef

eTypeClassUnion = _lldb.eTypeClassUnion

eTypeClassVector = _lldb.eTypeClassVector

eTypeClassOther = _lldb.eTypeClassOther

eTypeClassAny = _lldb.eTypeClassAny

eTemplateArgumentKindNull = _lldb.eTemplateArgumentKindNull

eTemplateArgumentKindType = _lldb.eTemplateArgumentKindType

eTemplateArgumentKindDeclaration = _lldb.eTemplateArgumentKindDeclaration

eTemplateArgumentKindIntegral = _lldb.eTemplateArgumentKindIntegral

eTemplateArgumentKindTemplate = _lldb.eTemplateArgumentKindTemplate

eTemplateArgumentKindTemplateExpansion = _lldb.eTemplateArgumentKindTemplateExpansion

eTemplateArgumentKindExpression = _lldb.eTemplateArgumentKindExpression

eTemplateArgumentKindPack = _lldb.eTemplateArgumentKindPack

eTemplateArgumentKindNullPtr = _lldb.eTemplateArgumentKindNullPtr

eTemplateArgumentKindStructuralValue = _lldb.eTemplateArgumentKindStructuralValue

eFormatterMatchExact = _lldb.eFormatterMatchExact

eFormatterMatchRegex = _lldb.eFormatterMatchRegex

eFormatterMatchCallback = _lldb.eFormatterMatchCallback

eLastFormatterMatchType = _lldb.eLastFormatterMatchType

eTypeOptionNone = _lldb.eTypeOptionNone

eTypeOptionCascade = _lldb.eTypeOptionCascade

eTypeOptionSkipPointers = _lldb.eTypeOptionSkipPointers

eTypeOptionSkipReferences = _lldb.eTypeOptionSkipReferences

eTypeOptionHideChildren = _lldb.eTypeOptionHideChildren

eTypeOptionHideValue = _lldb.eTypeOptionHideValue

eTypeOptionShowOneLiner = _lldb.eTypeOptionShowOneLiner

eTypeOptionHideNames = _lldb.eTypeOptionHideNames

eTypeOptionNonCacheable = _lldb.eTypeOptionNonCacheable

eTypeOptionHideEmptyAggregates = _lldb.eTypeOptionHideEmptyAggregates

eTypeOptionFrontEndWantsDereference = _lldb.eTypeOptionFrontEndWantsDereference

eFrameCompareInvalid = _lldb.eFrameCompareInvalid

eFrameCompareUnknown = _lldb.eFrameCompareUnknown

eFrameCompareEqual = _lldb.eFrameCompareEqual

eFrameCompareSameParent = _lldb.eFrameCompareSameParent

eFrameCompareYounger = _lldb.eFrameCompareYounger

eFrameCompareOlder = _lldb.eFrameCompareOlder

eFilePermissionsUserRead = _lldb.eFilePermissionsUserRead

eFilePermissionsUserWrite = _lldb.eFilePermissionsUserWrite

eFilePermissionsUserExecute = _lldb.eFilePermissionsUserExecute

eFilePermissionsGroupRead = _lldb.eFilePermissionsGroupRead

eFilePermissionsGroupWrite = _lldb.eFilePermissionsGroupWrite

eFilePermissionsGroupExecute = _lldb.eFilePermissionsGroupExecute

eFilePermissionsWorldRead = _lldb.eFilePermissionsWorldRead

eFilePermissionsWorldWrite = _lldb.eFilePermissionsWorldWrite

eFilePermissionsWorldExecute = _lldb.eFilePermissionsWorldExecute

eFilePermissionsUserRW = _lldb.eFilePermissionsUserRW

eFileFilePermissionsUserRX = _lldb.eFileFilePermissionsUserRX

eFilePermissionsUserRWX = _lldb.eFilePermissionsUserRWX

eFilePermissionsGroupRW = _lldb.eFilePermissionsGroupRW

eFilePermissionsGroupRX = _lldb.eFilePermissionsGroupRX

eFilePermissionsGroupRWX = _lldb.eFilePermissionsGroupRWX

eFilePermissionsWorldRW = _lldb.eFilePermissionsWorldRW

eFilePermissionsWorldRX = _lldb.eFilePermissionsWorldRX

eFilePermissionsWorldRWX = _lldb.eFilePermissionsWorldRWX

eFilePermissionsEveryoneR = _lldb.eFilePermissionsEveryoneR

eFilePermissionsEveryoneW = _lldb.eFilePermissionsEveryoneW

eFilePermissionsEveryoneX = _lldb.eFilePermissionsEveryoneX

eFilePermissionsEveryoneRW = _lldb.eFilePermissionsEveryoneRW

eFilePermissionsEveryoneRX = _lldb.eFilePermissionsEveryoneRX

eFilePermissionsEveryoneRWX = _lldb.eFilePermissionsEveryoneRWX

eFilePermissionsFileDefault = _lldb.eFilePermissionsFileDefault

eFilePermissionsDirectoryDefault = _lldb.eFilePermissionsDirectoryDefault

eQueueItemKindUnknown = _lldb.eQueueItemKindUnknown

eQueueItemKindFunction = _lldb.eQueueItemKindFunction

eQueueItemKindBlock = _lldb.eQueueItemKindBlock

eQueueKindUnknown = _lldb.eQueueKindUnknown

eQueueKindSerial = _lldb.eQueueKindSerial

eQueueKindConcurrent = _lldb.eQueueKindConcurrent

eExpressionEvaluationParse = _lldb.eExpressionEvaluationParse

eExpressionEvaluationIRGen = _lldb.eExpressionEvaluationIRGen

eExpressionEvaluationExecution = _lldb.eExpressionEvaluationExecution

eExpressionEvaluationComplete = _lldb.eExpressionEvaluationComplete

eInstructionControlFlowKindUnknown = _lldb.eInstructionControlFlowKindUnknown
r"""The instruction could not be classified."""
eInstructionControlFlowKindOther = _lldb.eInstructionControlFlowKindOther
r"""
    The instruction is something not listed below, i.e. it's a sequential
    instruction that doesn't affect the control flow of the program.
    """
eInstructionControlFlowKindCall = _lldb.eInstructionControlFlowKindCall
r"""The instruction is a near (function) call."""
eInstructionControlFlowKindReturn = _lldb.eInstructionControlFlowKindReturn
r"""The instruction is a near (function) return."""
eInstructionControlFlowKindJump = _lldb.eInstructionControlFlowKindJump
r"""The instruction is a near unconditional jump."""
eInstructionControlFlowKindCondJump = _lldb.eInstructionControlFlowKindCondJump
r"""The instruction is a near conditional jump."""
eInstructionControlFlowKindFarCall = _lldb.eInstructionControlFlowKindFarCall
r"""
    The instruction is a call-like far transfer.
    E.g. SYSCALL, SYSENTER, or FAR CALL.
    """
eInstructionControlFlowKindFarReturn = _lldb.eInstructionControlFlowKindFarReturn
r"""
    The instruction is a return-like far transfer.
    E.g. SYSRET, SYSEXIT, IRET, or FAR RET.
    """
eInstructionControlFlowKindFarJump = _lldb.eInstructionControlFlowKindFarJump
r"""
    The instruction is a jump-like far transfer.
    E.g. FAR JMP.
    """
eWatchpointKindWrite = _lldb.eWatchpointKindWrite

eWatchpointKindRead = _lldb.eWatchpointKindRead

eGdbSignalBadAccess = _lldb.eGdbSignalBadAccess

eGdbSignalBadInstruction = _lldb.eGdbSignalBadInstruction

eGdbSignalArithmetic = _lldb.eGdbSignalArithmetic

eGdbSignalEmulation = _lldb.eGdbSignalEmulation

eGdbSignalSoftware = _lldb.eGdbSignalSoftware

eGdbSignalBreakpoint = _lldb.eGdbSignalBreakpoint

ePathTypeLLDBShlibDir = _lldb.ePathTypeLLDBShlibDir
r"""
    The directory where the lldb.so (unix) or LLDB
    mach-o file in LLDB.framework (MacOSX) exists
    """
ePathTypeSupportExecutableDir = _lldb.ePathTypeSupportExecutableDir
r"""
    Find LLDB support executable directory
    (debugserver, etc)
    """
ePathTypeHeaderDir = _lldb.ePathTypeHeaderDir
r"""Find LLDB header file directory"""
ePathTypePythonDir = _lldb.ePathTypePythonDir
r"""Find Python modules (PYTHONPATH) directory"""
ePathTypeLLDBSystemPlugins = _lldb.ePathTypeLLDBSystemPlugins
r"""System plug-ins directory"""
ePathTypeLLDBUserPlugins = _lldb.ePathTypeLLDBUserPlugins
r"""User plug-ins directory"""
ePathTypeLLDBTempSystemDir = _lldb.ePathTypeLLDBTempSystemDir
r"""
    The LLDB temp directory for this system that
    will be cleaned up on exit
    """
ePathTypeGlobalLLDBTempSystemDir = _lldb.ePathTypeGlobalLLDBTempSystemDir
r"""
    The LLDB temp directory for this
    system, NOT cleaned up on a process
    exit.
    """
ePathTypeClangDir = _lldb.ePathTypeClangDir
r"""Find path to Clang builtin headers"""
eMemberFunctionKindUnknown = _lldb.eMemberFunctionKindUnknown
r"""Not sure what the type of this is"""
eMemberFunctionKindConstructor = _lldb.eMemberFunctionKindConstructor
r"""A function used to create instances"""
eMemberFunctionKindDestructor = _lldb.eMemberFunctionKindDestructor
r"""
    A function used to tear down existing
    instances
    """
eMemberFunctionKindInstanceMethod = _lldb.eMemberFunctionKindInstanceMethod
r"""
    A function that applies to a specific
    instance
    """
eMemberFunctionKindStaticMethod = _lldb.eMemberFunctionKindStaticMethod
r"""
    A function that applies to a type rather
    than any instance
    """
eMatchTypeNormal = _lldb.eMatchTypeNormal

eMatchTypeRegex = _lldb.eMatchTypeRegex

eMatchTypeStartsWith = _lldb.eMatchTypeStartsWith

eMatchTypeRegexInsensitive = _lldb.eMatchTypeRegexInsensitive

eTypeHasChildren = _lldb.eTypeHasChildren

eTypeHasValue = _lldb.eTypeHasValue

eTypeIsArray = _lldb.eTypeIsArray

eTypeIsBlock = _lldb.eTypeIsBlock

eTypeIsBuiltIn = _lldb.eTypeIsBuiltIn

eTypeIsClass = _lldb.eTypeIsClass

eTypeIsCPlusPlus = _lldb.eTypeIsCPlusPlus

eTypeIsEnumeration = _lldb.eTypeIsEnumeration

eTypeIsFuncPrototype = _lldb.eTypeIsFuncPrototype

eTypeIsMember = _lldb.eTypeIsMember

eTypeIsObjC = _lldb.eTypeIsObjC

eTypeIsPointer = _lldb.eTypeIsPointer

eTypeIsReference = _lldb.eTypeIsReference

eTypeIsStructUnion = _lldb.eTypeIsStructUnion

eTypeIsTemplate = _lldb.eTypeIsTemplate

eTypeIsTypedef = _lldb.eTypeIsTypedef

eTypeIsVector = _lldb.eTypeIsVector

eTypeIsScalar = _lldb.eTypeIsScalar

eTypeIsInteger = _lldb.eTypeIsInteger

eTypeIsFloat = _lldb.eTypeIsFloat

eTypeIsComplex = _lldb.eTypeIsComplex

eTypeIsSigned = _lldb.eTypeIsSigned

eTypeInstanceIsPointer = _lldb.eTypeInstanceIsPointer

eCommandRequiresTarget = _lldb.eCommandRequiresTarget
r"""
    eCommandRequiresTarget

    Ensures a valid target is contained in m_exe_ctx prior to executing the
    command. If a target doesn't exist or is invalid, the command will fail
    and CommandObject::GetInvalidTargetDescription() will be returned as the
    error. CommandObject subclasses can override the virtual function for
    GetInvalidTargetDescription() to provide custom strings when needed.
    """
eCommandRequiresProcess = _lldb.eCommandRequiresProcess
r"""
    eCommandRequiresProcess

    Ensures a valid process is contained in m_exe_ctx prior to executing the
    command. If a process doesn't exist or is invalid, the command will fail
    and CommandObject::GetInvalidProcessDescription() will be returned as
    the error. CommandObject subclasses can override the virtual function
    for GetInvalidProcessDescription() to provide custom strings when
    needed.
    """
eCommandRequiresThread = _lldb.eCommandRequiresThread
r"""
    eCommandRequiresThread

    Ensures a valid thread is contained in m_exe_ctx prior to executing the
    command. If a thread doesn't exist or is invalid, the command will fail
    and CommandObject::GetInvalidThreadDescription() will be returned as the
    error. CommandObject subclasses can override the virtual function for
    GetInvalidThreadDescription() to provide custom strings when needed.
    """
eCommandRequiresFrame = _lldb.eCommandRequiresFrame
r"""
    eCommandRequiresFrame

    Ensures a valid frame is contained in m_exe_ctx prior to executing the
    command. If a frame doesn't exist or is invalid, the command will fail
    and CommandObject::GetInvalidFrameDescription() will be returned as the
    error. CommandObject subclasses can override the virtual function for
    GetInvalidFrameDescription() to provide custom strings when needed.
    """
eCommandRequiresRegContext = _lldb.eCommandRequiresRegContext
r"""
    eCommandRequiresRegContext

    Ensures a valid register context (from the selected frame if there is a
    frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is
    available from m_exe_ctx prior to executing the command. If a target
    doesn't exist or is invalid, the command will fail and
    CommandObject::GetInvalidRegContextDescription() will be returned as the
    error. CommandObject subclasses can override the virtual function for
    GetInvalidRegContextDescription() to provide custom strings when needed.
    """
eCommandTryTargetAPILock = _lldb.eCommandTryTargetAPILock
r"""
    eCommandTryTargetAPILock

    Attempts to acquire the target lock if a target is selected in the
    command interpreter. If the command object fails to acquire the API
    lock, the command will fail with an appropriate error message.
    """
eCommandProcessMustBeLaunched = _lldb.eCommandProcessMustBeLaunched
r"""
    eCommandProcessMustBeLaunched

    Verifies that there is a launched process in m_exe_ctx, if there isn't,
    the command will fail with an appropriate error message.
    """
eCommandProcessMustBePaused = _lldb.eCommandProcessMustBePaused
r"""
    eCommandProcessMustBePaused

    Verifies that there is a paused process in m_exe_ctx, if there isn't,
    the command will fail with an appropriate error message.
    """
eCommandProcessMustBeTraced = _lldb.eCommandProcessMustBeTraced
r"""
    eCommandProcessMustBeTraced

    Verifies that the process is being traced by a Trace plug-in, if it
    isn't the command will fail with an appropriate error message.
    """
eTypeSummaryCapped = _lldb.eTypeSummaryCapped

eTypeSummaryUncapped = _lldb.eTypeSummaryUncapped

eCommandInterpreterResultSuccess = _lldb.eCommandInterpreterResultSuccess
r"""Command interpreter finished successfully."""
eCommandInterpreterResultInferiorCrash = _lldb.eCommandInterpreterResultInferiorCrash
r"""
    Stopped because the corresponding option was set and the inferior
    crashed.
    """
eCommandInterpreterResultCommandError = _lldb.eCommandInterpreterResultCommandError
r"""
    Stopped because the corresponding option was set and a command returned
    an error.
    """
eCommandInterpreterResultQuitRequested = _lldb.eCommandInterpreterResultQuitRequested
r"""Stopped because quit was requested."""
eSaveCoreUnspecified = _lldb.eSaveCoreUnspecified

eSaveCoreFull = _lldb.eSaveCoreFull

eSaveCoreDirtyOnly = _lldb.eSaveCoreDirtyOnly

eSaveCoreStackOnly = _lldb.eSaveCoreStackOnly

eSaveCoreCustomOnly = _lldb.eSaveCoreCustomOnly

eTraceEventDisabledSW = _lldb.eTraceEventDisabledSW
r"""Tracing was disabled for some time due to a software trigger."""
eTraceEventDisabledHW = _lldb.eTraceEventDisabledHW
r"""Tracing was disable for some time due to a hardware trigger."""
eTraceEventCPUChanged = _lldb.eTraceEventCPUChanged
r"""
    Event due to CPU change for a thread. This event is also fired when
    suddenly it's not possible to identify the cpu of a given thread.
    """
eTraceEventHWClockTick = _lldb.eTraceEventHWClockTick
r"""Event due to a CPU HW clock tick."""
eTraceEventSyncPoint = _lldb.eTraceEventSyncPoint
r"""
    The underlying tracing technology emitted a synchronization event used by
    trace processors.
    """
eTraceItemKindError = _lldb.eTraceItemKindError

eTraceItemKindEvent = _lldb.eTraceItemKindEvent

eTraceItemKindInstruction = _lldb.eTraceItemKindInstruction

eTraceCursorSeekTypeBeginning = _lldb.eTraceCursorSeekTypeBeginning
r"""The beginning of the trace, i.e the oldest item."""
eTraceCursorSeekTypeCurrent = _lldb.eTraceCursorSeekTypeCurrent
r"""The current position in the trace."""
eTraceCursorSeekTypeEnd = _lldb.eTraceCursorSeekTypeEnd
r"""The end of the trace, i.e the most recent item."""
eDWIMPrintVerbosityNone = _lldb.eDWIMPrintVerbosityNone
r"""Run `dwim-print` with no verbosity."""
eDWIMPrintVerbosityExpression = _lldb.eDWIMPrintVerbosityExpression
r"""Print a message when `dwim-print` uses `expression` evaluation."""
eDWIMPrintVerbosityFull = _lldb.eDWIMPrintVerbosityFull
r"""
    Always print a message indicating how `dwim-print` is evaluating its
    expression.
    """
eWatchPointValueKindInvalid = _lldb.eWatchPointValueKindInvalid
r"""Watchpoint was created watching a variable"""
eWatchPointValueKindVariable = _lldb.eWatchPointValueKindVariable
r"""
    Watchpoint was created watching the result of an expression that was
    evaluated at creation time.
    """
eWatchPointValueKindExpression = _lldb.eWatchPointValueKindExpression

eNoCompletion = _lldb.eNoCompletion

eSourceFileCompletion = _lldb.eSourceFileCompletion

eDiskFileCompletion = _lldb.eDiskFileCompletion

eDiskDirectoryCompletion = _lldb.eDiskDirectoryCompletion

eSymbolCompletion = _lldb.eSymbolCompletion

eModuleCompletion = _lldb.eModuleCompletion

eSettingsNameCompletion = _lldb.eSettingsNameCompletion

ePlatformPluginCompletion = _lldb.ePlatformPluginCompletion

eArchitectureCompletion = _lldb.eArchitectureCompletion

eVariablePathCompletion = _lldb.eVariablePathCompletion

eRegisterCompletion = _lldb.eRegisterCompletion

eBreakpointCompletion = _lldb.eBreakpointCompletion

eProcessPluginCompletion = _lldb.eProcessPluginCompletion

eDisassemblyFlavorCompletion = _lldb.eDisassemblyFlavorCompletion

eTypeLanguageCompletion = _lldb.eTypeLanguageCompletion

eFrameIndexCompletion = _lldb.eFrameIndexCompletion

eModuleUUIDCompletion = _lldb.eModuleUUIDCompletion

eStopHookIDCompletion = _lldb.eStopHookIDCompletion

eThreadIndexCompletion = _lldb.eThreadIndexCompletion

eWatchpointIDCompletion = _lldb.eWatchpointIDCompletion

eBreakpointNameCompletion = _lldb.eBreakpointNameCompletion

eProcessIDCompletion = _lldb.eProcessIDCompletion

eProcessNameCompletion = _lldb.eProcessNameCompletion

eRemoteDiskFileCompletion = _lldb.eRemoteDiskFileCompletion

eRemoteDiskDirectoryCompletion = _lldb.eRemoteDiskDirectoryCompletion

eTypeCategoryNameCompletion = _lldb.eTypeCategoryNameCompletion

eCustomCompletion = _lldb.eCustomCompletion

eThreadIDCompletion = _lldb.eThreadIDCompletion

eTerminatorCompletion = _lldb.eTerminatorCompletion

eRefetch = _lldb.eRefetch
r"""Children need to be recomputed dynamically."""
eReuse = _lldb.eReuse
r"""
    Children did not change and don't need to be recomputed;
    re-use what we computed the last time we called Update.
    """
eSymbolDownloadOff = _lldb.eSymbolDownloadOff

eSymbolDownloadBackground = _lldb.eSymbolDownloadBackground

eSymbolDownloadForeground = _lldb.eSymbolDownloadForeground

eAddressMaskTypeCode = _lldb.eAddressMaskTypeCode

eAddressMaskTypeData = _lldb.eAddressMaskTypeData

eAddressMaskTypeAny = _lldb.eAddressMaskTypeAny

eAddressMaskTypeAll = _lldb.eAddressMaskTypeAll

eAddressMaskRangeLow = _lldb.eAddressMaskRangeLow

eAddressMaskRangeHigh = _lldb.eAddressMaskRangeHigh

eAddressMaskRangeAny = _lldb.eAddressMaskRangeAny

eAddressMaskRangeAll = _lldb.eAddressMaskRangeAll

eBroadcastBitProgress = _lldb.eBroadcastBitProgress

eBroadcastBitWarning = _lldb.eBroadcastBitWarning

eBroadcastBitError = _lldb.eBroadcastBitError

eBroadcastSymbolChange = _lldb.eBroadcastSymbolChange

eBroadcastBitProgressCategory = _lldb.eBroadcastBitProgressCategory
r"""Deprecated"""
eBroadcastBitExternalProgress = _lldb.eBroadcastBitExternalProgress

eBroadcastBitExternalProgressCategory = _lldb.eBroadcastBitExternalProgressCategory
r"""Deprecated"""
eSeverityError = _lldb.eSeverityError

eSeverityWarning = _lldb.eSeverityWarning

eSeverityInfo = _lldb.eSeverityInfo

eCommandReturnObjectPrintCallbackSkipped = _lldb.eCommandReturnObjectPrintCallbackSkipped
r"""The callback deferred printing the command return object."""
eCommandReturnObjectPrintCallbackHandled = _lldb.eCommandReturnObjectPrintCallbackHandled
r"""The callback handled printing the command return object."""
eStopDisassemblyTypeNever = _lldb.eStopDisassemblyTypeNever

eStopDisassemblyTypeNoDebugInfo = _lldb.eStopDisassemblyTypeNoDebugInfo

eStopDisassemblyTypeNoSource = _lldb.eStopDisassemblyTypeNoSource

eStopDisassemblyTypeAlways = _lldb.eStopDisassemblyTypeAlways

class SBAddress(object):
    r"""
    A section + offset based address class.

    The SBAddress class allows addresses to be relative to a section
    that can move during runtime due to images (executables, shared
    libraries, bundles, frameworks) being loaded at different
    addresses than the addresses found in the object file that
    represents them on disk. There are currently two types of addresses
    for a section:

    * file addresses
    * load addresses

    File addresses represents the virtual addresses that are in the 'on
    disk' object files. These virtual addresses are converted to be
    relative to unique sections scoped to the object file so that
    when/if the addresses slide when the images are loaded/unloaded
    in memory, we can easily track these changes without having to
    update every object (compile unit ranges, line tables, function
    address ranges, lexical block and inlined subroutine address
    ranges, global and static variables) each time an image is loaded or
    unloaded.

    Load addresses represents the virtual addresses where each section
    ends up getting loaded at runtime. Before executing a program, it
    is common for all of the load addresses to be unresolved. When a
    DynamicLoader plug-in receives notification that shared libraries
    have been loaded/unloaded, the load addresses of the main executable
    and any images (shared libraries) will be  resolved/unresolved. When
    this happens, breakpoints that are in one of these sections can be
    set/cleared.

    See docstring of SBFunction for example usage of SBAddress.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBAddress self) -> SBAddress
        __init__(SBAddress self, SBAddress rhs) -> SBAddress
        __init__(SBAddress self, SBSection section, lldb::addr_t offset) -> SBAddress
        __init__(SBAddress self, lldb::addr_t load_addr, SBTarget target) -> SBAddress

            Create an address by resolving a load address using the supplied target.
        """
        _lldb.SBAddress_swiginit(self, _lldb.new_SBAddress(*args))
    __swig_destroy__ = _lldb.delete_SBAddress

    def __nonzero__(self):
        return _lldb.SBAddress___nonzero__(self)
    __bool__ = __nonzero__



    def __ne__(self, rhs):
        r"""__ne__(SBAddress self, SBAddress rhs) -> bool"""
        return _lldb.SBAddress___ne__(self, rhs)

    def IsValid(self):
        r"""IsValid(SBAddress self) -> bool"""
        return _lldb.SBAddress_IsValid(self)

    def Clear(self):
        r"""Clear(SBAddress self)"""
        return _lldb.SBAddress_Clear(self)

    def GetFileAddress(self):
        r"""GetFileAddress(SBAddress self) -> lldb::addr_t"""
        return _lldb.SBAddress_GetFileAddress(self)

    def GetLoadAddress(self, target):
        r"""GetLoadAddress(SBAddress self, SBTarget target) -> lldb::addr_t"""
        return _lldb.SBAddress_GetLoadAddress(self, target)

    def SetAddress(self, section, offset):
        r"""SetAddress(SBAddress self, SBSection section, lldb::addr_t offset)"""
        return _lldb.SBAddress_SetAddress(self, section, offset)

    def SetLoadAddress(self, load_addr, target):
        r"""SetLoadAddress(SBAddress self, lldb::addr_t load_addr, SBTarget target)"""
        return _lldb.SBAddress_SetLoadAddress(self, load_addr, target)

    def OffsetAddress(self, offset):
        r"""OffsetAddress(SBAddress self, lldb::addr_t offset) -> bool"""
        return _lldb.SBAddress_OffsetAddress(self, offset)

    def GetDescription(self, description):
        r"""GetDescription(SBAddress self, SBStream description) -> bool"""
        return _lldb.SBAddress_GetDescription(self, description)

    def GetSymbolContext(self, resolve_scope):
        r"""
        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 :py:class:`SBAddress.SetLoadAddress' or
            :py:class:`SBTarget.ResolveLoadAddress`.
        """
        return _lldb.SBAddress_GetSymbolContext(self, resolve_scope)

    def GetSection(self):
        r"""GetSection(SBAddress self) -> SBSection"""
        return _lldb.SBAddress_GetSection(self)

    def GetOffset(self):
        r"""GetOffset(SBAddress self) -> lldb::addr_t"""
        return _lldb.SBAddress_GetOffset(self)

    def GetModule(self):
        r"""
        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 :py:class:`SBAddress.GetSymbolContext` or
            :py:class:`SBTarget.ResolveSymbolContextForAddress` when you want multiple
            debug symbol related objects for an address.
            One or more bits from the SymbolContextItem enumerations can be logically
            OR'ed together to more efficiently retrieve multiple symbol objects.
        """
        return _lldb.SBAddress_GetModule(self)

    def GetCompileUnit(self):
        r"""GetCompileUnit(SBAddress self) -> SBCompileUnit"""
        return _lldb.SBAddress_GetCompileUnit(self)

    def GetFunction(self):
        r"""GetFunction(SBAddress self) -> SBFunction"""
        return _lldb.SBAddress_GetFunction(self)

    def GetBlock(self):
        r"""GetBlock(SBAddress self) -> SBBlock"""
        return _lldb.SBAddress_GetBlock(self)

    def GetSymbol(self):
        r"""GetSymbol(SBAddress self) -> SBSymbol"""
        return _lldb.SBAddress_GetSymbol(self)

    def GetLineEntry(self):
        r"""GetLineEntry(SBAddress self) -> SBLineEntry"""
        return _lldb.SBAddress_GetLineEntry(self)

    def __repr__(self):
        r"""__repr__(SBAddress self) -> std::string"""
        return _lldb.SBAddress___repr__(self)

        # operator== is a free function, which swig does not handle, so we inject
        # our own equality operator here
    def __eq__(self, other):
      return not self.__ne__(other)


    __runtime_error_str = 'This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'

    def __get_load_addr_property__ (self):
        '''Get the load address for a lldb.SBAddress using the current target. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'''
        if not target:
            raise RuntimeError(self.__runtime_error_str)
        return self.GetLoadAddress (target)

    def __set_load_addr_property__ (self, load_addr):
        '''Set the load address for a lldb.SBAddress using the current target. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'''
        if not target:
            raise RuntimeError(self.__runtime_error_str)
        return self.SetLoadAddress (load_addr, target)

    def __int__(self):
        '''Convert an address to a load address if there is a process and that process is alive, or to a file address otherwise. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'''
        if not process or not target:
            raise RuntimeError(self.__runtime_error_str)
        if process.is_alive:
            return self.GetLoadAddress (target)
        return self.GetFileAddress ()

    def __oct__(self):
        '''Convert the address to an octal string. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'''
        return '%o' % int(self)

    def __hex__(self):
        '''Convert the address to an hex string. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.'''
        return '0x%x' % int(self)

    module = property(GetModule, None, doc='''A read only property that returns an lldb object that represents the module (lldb.SBModule) that this address resides within.''')
    compile_unit = property(GetCompileUnit, None, doc='''A read only property that returns an lldb object that represents the compile unit (lldb.SBCompileUnit) that this address resides within.''')
    line_entry = property(GetLineEntry, None, doc='''A read only property that returns an lldb object that represents the line entry (lldb.SBLineEntry) that this address resides within.''')
    function = property(GetFunction, None, doc='''A read only property that returns an lldb object that represents the function (lldb.SBFunction) that this address resides within.''')
    block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the block (lldb.SBBlock) that this address resides within.''')
    symbol = property(GetSymbol, None, doc='''A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) that this address resides within.''')
    offset = property(GetOffset, None, doc='''A read only property that returns the section offset in bytes as an integer.''')
    section = property(GetSection, None, doc='''A read only property that returns an lldb object that represents the section (lldb.SBSection) that this address resides within.''')
    file_addr = property(GetFileAddress, None, doc='''A read only property that returns file address for the section as an integer. This is the address that represents the address as it is found in the object file that defines it.''')
    load_addr = property(__get_load_addr_property__, __set_load_addr_property__, doc='''A read/write property that gets/sets the SBAddress using load address. This resolves the SBAddress using the SBTarget from lldb.target so this property can ONLY be used in the interactive script interpreter (i.e. under the lldb script command). For things like Python based commands and breakpoint callbacks use GetLoadAddress instead.''')


# Register SBAddress in _lldb:
_lldb.SBAddress_swigregister(SBAddress)
class SBAddressRange(object):
    r"""API clients can get address range information."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBAddressRange self) -> SBAddressRange
        __init__(SBAddressRange self, SBAddressRange rhs) -> SBAddressRange
        __init__(SBAddressRange self, SBAddress addr, lldb::addr_t byte_size) -> SBAddressRange
        """
        _lldb.SBAddressRange_swiginit(self, _lldb.new_SBAddressRange(*args))
    __swig_destroy__ = _lldb.delete_SBAddressRange

    def Clear(self):
        r"""Clear(SBAddressRange self)"""
        return _lldb.SBAddressRange_Clear(self)

    def IsValid(self):
        r"""
        Check the address range refers to a valid base address and has a byte
        size greater than zero.

        :rtype: boolean
        :return: 
                True if the address range is valid, false otherwise.
        """
        return _lldb.SBAddressRange_IsValid(self)

    def GetBaseAddress(self):
        r"""
        Get the base address of the range.

        :rtype: :py:class:`SBAddress`
        :return: 
                Base address object.
        """
        return _lldb.SBAddressRange_GetBaseAddress(self)

    def GetByteSize(self):
        r"""
        Get the byte size of this range.

        :rtype: int
        :return: 
                The size in bytes of this address range.
        """
        return _lldb.SBAddressRange_GetByteSize(self)

    def __eq__(self, rhs):
        r"""__eq__(SBAddressRange self, SBAddressRange rhs) -> bool"""
        return _lldb.SBAddressRange___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBAddressRange self, SBAddressRange rhs) -> bool"""
        return _lldb.SBAddressRange___ne__(self, rhs)

    def GetDescription(self, description, target):
        r"""GetDescription(SBAddressRange self, SBStream description, SBTarget target) -> bool"""
        return _lldb.SBAddressRange_GetDescription(self, description, target)

    def __repr__(self):
      import lldb
      stream = lldb.SBStream()
      self.GetDescription(stream, lldb.target if lldb.target else lldb.SBTarget())
      return stream.GetData()


# Register SBAddressRange in _lldb:
_lldb.SBAddressRange_swigregister(SBAddressRange)
class SBAddressRangeList(object):
    r"""Represents a list of :py:class:`SBAddressRange`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBAddressRangeList self) -> SBAddressRangeList
        __init__(SBAddressRangeList self, SBAddressRangeList rhs) -> SBAddressRangeList
        """
        _lldb.SBAddressRangeList_swiginit(self, _lldb.new_SBAddressRangeList(*args))
    __swig_destroy__ = _lldb.delete_SBAddressRangeList

    def GetSize(self):
        r"""GetSize(SBAddressRangeList self) -> uint32_t"""
        return _lldb.SBAddressRangeList_GetSize(self)

    def Clear(self):
        r"""Clear(SBAddressRangeList self)"""
        return _lldb.SBAddressRangeList_Clear(self)

    def GetAddressRangeAtIndex(self, idx):
        r"""GetAddressRangeAtIndex(SBAddressRangeList self, uint64_t idx) -> SBAddressRange"""
        return _lldb.SBAddressRangeList_GetAddressRangeAtIndex(self, idx)

    def Append(self, *args):
        r"""
        Append(SBAddressRangeList self, SBAddressRange addr_range)
        Append(SBAddressRangeList self, SBAddressRangeList addr_range_list)
        """
        return _lldb.SBAddressRangeList_Append(self, *args)

    def GetDescription(self, description, target):
        r"""GetDescription(SBAddressRangeList self, SBStream description, SBTarget target) -> bool"""
        return _lldb.SBAddressRangeList_GetDescription(self, description, target)

    def __len__(self):
      '''Return the number of address ranges in a lldb.SBAddressRangeList object.'''
      return self.GetSize()

    def __iter__(self):
      '''Iterate over all the address ranges in a lldb.SBAddressRangeList object.'''
      return lldb_iter(self, 'GetSize', 'GetAddressRangeAtIndex')

    def __getitem__(self, idx):
      '''Get the address range at a given index in an lldb.SBAddressRangeList object.'''
      if not isinstance(idx, int):
        raise TypeError("unsupported index type: %s" % type(idx))
      count = len(self)
      if not (-count <= idx < count):
        raise IndexError("list index out of range")
      idx %= count
      return self.GetAddressRangeAtIndex(idx)

    def __repr__(self):
      import lldb
      stream = lldb.SBStream()
      self.GetDescription(stream, lldb.target if lldb.target else lldb.SBTarget())
      return stream.GetData()


# Register SBAddressRangeList in _lldb:
_lldb.SBAddressRangeList_swigregister(SBAddressRangeList)
class SBAttachInfo(object):
    r"""Describes how to attach when calling :py:class:`SBTarget.Attach`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBAttachInfo self) -> SBAttachInfo
        __init__(SBAttachInfo self, lldb::pid_t pid) -> SBAttachInfo
        __init__(SBAttachInfo self, char const * path, bool wait_for) -> SBAttachInfo
        __init__(SBAttachInfo self, char const * path, bool wait_for, bool _async) -> SBAttachInfo
        __init__(SBAttachInfo self, SBAttachInfo rhs) -> SBAttachInfo
        """
        _lldb.SBAttachInfo_swiginit(self, _lldb.new_SBAttachInfo(*args))
    __swig_destroy__ = _lldb.delete_SBAttachInfo

    def GetProcessID(self):
        r"""GetProcessID(SBAttachInfo self) -> lldb::pid_t"""
        return _lldb.SBAttachInfo_GetProcessID(self)

    def SetProcessID(self, pid):
        r"""SetProcessID(SBAttachInfo self, lldb::pid_t pid)"""
        return _lldb.SBAttachInfo_SetProcessID(self, pid)

    def SetExecutable(self, *args):
        r"""
        SetExecutable(SBAttachInfo self, char const * path)
        SetExecutable(SBAttachInfo self, SBFileSpec exe_file)
        """
        return _lldb.SBAttachInfo_SetExecutable(self, *args)

    def GetWaitForLaunch(self):
        r"""GetWaitForLaunch(SBAttachInfo self) -> bool"""
        return _lldb.SBAttachInfo_GetWaitForLaunch(self)

    def SetWaitForLaunch(self, *args):
        r"""
        *Overload 1:*
        Set attach by process name settings.

        Designed to be used after a call to SBAttachInfo::SetExecutable().
        This function implies that a call to SBTarget::Attach(...) will
        be synchronous.

        :type b: boolean, in
        :param b:
                If **false**, attach to an existing process whose name matches.
                If **true**, then wait for the next process whose name matches.

        |

        *Overload 2:*
        Set attach by process name settings.

        Designed to be used after a call to SBAttachInfo::SetExecutable().
        Future calls to SBTarget::Attach(...) will be synchronous or
        asynchronous depending on the *async* argument.

        :type b: boolean, in
        :param b:
                If **false**, attach to an existing process whose name matches.
                If **true**, then wait for the next process whose name matches.

        :type async: boolean, in
        :param async:
                If **false**, then the SBTarget::Attach(...) call will be a
                synchronous call with no way to cancel the attach in
                progress.
                If **true**, then the SBTarget::Attach(...) function will
                return immediately and clients are expected to wait for a
                process eStateStopped event if a suitable process is
                eventually found. If the client wants to cancel the event,
                SBProcess::Stop() can be called and an eStateExited process
                event will be delivered.
        """
        return _lldb.SBAttachInfo_SetWaitForLaunch(self, *args)

    def GetIgnoreExisting(self):
        r"""GetIgnoreExisting(SBAttachInfo self) -> bool"""
        return _lldb.SBAttachInfo_GetIgnoreExisting(self)

    def SetIgnoreExisting(self, b):
        r"""SetIgnoreExisting(SBAttachInfo self, bool b)"""
        return _lldb.SBAttachInfo_SetIgnoreExisting(self, b)

    def GetResumeCount(self):
        r"""GetResumeCount(SBAttachInfo self) -> uint32_t"""
        return _lldb.SBAttachInfo_GetResumeCount(self)

    def SetResumeCount(self, c):
        r"""SetResumeCount(SBAttachInfo self, uint32_t c)"""
        return _lldb.SBAttachInfo_SetResumeCount(self, c)

    def GetProcessPluginName(self):
        r"""GetProcessPluginName(SBAttachInfo self) -> char const *"""
        return _lldb.SBAttachInfo_GetProcessPluginName(self)

    def SetProcessPluginName(self, plugin_name):
        r"""SetProcessPluginName(SBAttachInfo self, char const * plugin_name)"""
        return _lldb.SBAttachInfo_SetProcessPluginName(self, plugin_name)

    def GetUserID(self):
        r"""GetUserID(SBAttachInfo self) -> uint32_t"""
        return _lldb.SBAttachInfo_GetUserID(self)

    def GetGroupID(self):
        r"""GetGroupID(SBAttachInfo self) -> uint32_t"""
        return _lldb.SBAttachInfo_GetGroupID(self)

    def UserIDIsValid(self):
        r"""UserIDIsValid(SBAttachInfo self) -> bool"""
        return _lldb.SBAttachInfo_UserIDIsValid(self)

    def GroupIDIsValid(self):
        r"""GroupIDIsValid(SBAttachInfo self) -> bool"""
        return _lldb.SBAttachInfo_GroupIDIsValid(self)

    def SetUserID(self, uid):
        r"""SetUserID(SBAttachInfo self, uint32_t uid)"""
        return _lldb.SBAttachInfo_SetUserID(self, uid)

    def SetGroupID(self, gid):
        r"""SetGroupID(SBAttachInfo self, uint32_t gid)"""
        return _lldb.SBAttachInfo_SetGroupID(self, gid)

    def GetEffectiveUserID(self):
        r"""GetEffectiveUserID(SBAttachInfo self) -> uint32_t"""
        return _lldb.SBAttachInfo_GetEffectiveUserID(self)

    def GetEffectiveGroupID(self):
        r"""GetEffectiveGroupID(SBAttachInfo self) -> uint32_t"""
        return _lldb.SBAttachInfo_GetEffectiveGroupID(self)

    def EffectiveUserIDIsValid(self):
        r"""EffectiveUserIDIsValid(SBAttachInfo self) -> bool"""
        return _lldb.SBAttachInfo_EffectiveUserIDIsValid(self)

    def EffectiveGroupIDIsValid(self):
        r"""EffectiveGroupIDIsValid(SBAttachInfo self) -> bool"""
        return _lldb.SBAttachInfo_EffectiveGroupIDIsValid(self)

    def SetEffectiveUserID(self, uid):
        r"""SetEffectiveUserID(SBAttachInfo self, uint32_t uid)"""
        return _lldb.SBAttachInfo_SetEffectiveUserID(self, uid)

    def SetEffectiveGroupID(self, gid):
        r"""SetEffectiveGroupID(SBAttachInfo self, uint32_t gid)"""
        return _lldb.SBAttachInfo_SetEffectiveGroupID(self, gid)

    def GetParentProcessID(self):
        r"""GetParentProcessID(SBAttachInfo self) -> lldb::pid_t"""
        return _lldb.SBAttachInfo_GetParentProcessID(self)

    def SetParentProcessID(self, pid):
        r"""SetParentProcessID(SBAttachInfo self, lldb::pid_t pid)"""
        return _lldb.SBAttachInfo_SetParentProcessID(self, pid)

    def ParentProcessIDIsValid(self):
        r"""ParentProcessIDIsValid(SBAttachInfo self) -> bool"""
        return _lldb.SBAttachInfo_ParentProcessIDIsValid(self)

    def GetListener(self):
        r"""
        Get the listener that will be used to receive process events.

        If no listener has been set via a call to
        SBAttachInfo::SetListener(), then an invalid SBListener will be
        returned (SBListener::IsValid() will return false). If a listener
        has been set, then the valid listener object will be returned.
        """
        return _lldb.SBAttachInfo_GetListener(self)

    def SetListener(self, listener):
        r"""
        Set the listener that will be used to receive process events.

        By default the SBDebugger, which has a listener, that the SBTarget
        belongs to will listen for the process events. Calling this function
        allows a different listener to be used to listen for process events.
        """
        return _lldb.SBAttachInfo_SetListener(self, listener)

    def GetShadowListener(self):
        r"""
        Get the shadow listener that receive public process events,
        additionally to the default process event listener.

        If no listener has been set via a call to
        SBLaunchInfo::SetShadowListener(), then an invalid SBListener will
        be returned (SBListener::IsValid() will return false). If a listener
        has been set, then the valid listener object will be returned.
        """
        return _lldb.SBAttachInfo_GetShadowListener(self)

    def SetShadowListener(self, listener):
        r"""
        Set the shadow listener that will receive public process events,
        additionally to the default process event listener.

        By default a process have no shadow event listener.
        Calling this function allows public process events to be broadcasted to an
        additional listener on top of the default process event listener.
        If the `listener` argument is invalid (SBListener::IsValid() will
        return false), this will clear the shadow listener.
        """
        return _lldb.SBAttachInfo_SetShadowListener(self, listener)

    def GetScriptedProcessClassName(self):
        r"""GetScriptedProcessClassName(SBAttachInfo self) -> char const *"""
        return _lldb.SBAttachInfo_GetScriptedProcessClassName(self)

    def SetScriptedProcessClassName(self, class_name):
        r"""SetScriptedProcessClassName(SBAttachInfo self, char const * class_name)"""
        return _lldb.SBAttachInfo_SetScriptedProcessClassName(self, class_name)

    def GetScriptedProcessDictionary(self):
        r"""GetScriptedProcessDictionary(SBAttachInfo self) -> SBStructuredData"""
        return _lldb.SBAttachInfo_GetScriptedProcessDictionary(self)

    def SetScriptedProcessDictionary(self, dict):
        r"""SetScriptedProcessDictionary(SBAttachInfo self, SBStructuredData dict)"""
        return _lldb.SBAttachInfo_SetScriptedProcessDictionary(self, dict)

# Register SBAttachInfo in _lldb:
_lldb.SBAttachInfo_swigregister(SBAttachInfo)
class SBBlock(object):
    r"""Represents a lexical block. SBFunction contains SBBlock(s)."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBBlock self) -> SBBlock
        __init__(SBBlock self, SBBlock rhs) -> SBBlock
        """
        _lldb.SBBlock_swiginit(self, _lldb.new_SBBlock(*args))
    __swig_destroy__ = _lldb.delete_SBBlock

    def IsInlined(self):
        r"""
        IsInlined(SBBlock self) -> bool
        Is this block contained within an inlined function?
        """
        return _lldb.SBBlock_IsInlined(self)

    def __nonzero__(self):
        return _lldb.SBBlock___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBBlock self) -> bool"""
        return _lldb.SBBlock_IsValid(self)

    def GetInlinedName(self):
        r"""
        GetInlinedName(SBBlock self) -> char const *

            Get the function name if this block represents an inlined function;
            otherwise, return None.
        """
        return _lldb.SBBlock_GetInlinedName(self)

    def GetInlinedCallSiteFile(self):
        r"""
        GetInlinedCallSiteFile(SBBlock self) -> SBFileSpec

            Get the call site file if this block represents an inlined function;
            otherwise, return an invalid file spec.
        """
        return _lldb.SBBlock_GetInlinedCallSiteFile(self)

    def GetInlinedCallSiteLine(self):
        r"""
        GetInlinedCallSiteLine(SBBlock self) -> uint32_t

            Get the call site line if this block represents an inlined function;
            otherwise, return 0.
        """
        return _lldb.SBBlock_GetInlinedCallSiteLine(self)

    def GetInlinedCallSiteColumn(self):
        r"""
        GetInlinedCallSiteColumn(SBBlock self) -> uint32_t

            Get the call site column if this block represents an inlined function;
            otherwise, return 0.
        """
        return _lldb.SBBlock_GetInlinedCallSiteColumn(self)

    def GetParent(self):
        r"""
        GetParent(SBBlock self) -> SBBlock
        Get the parent block.
        """
        return _lldb.SBBlock_GetParent(self)

    def GetSibling(self):
        r"""
        GetSibling(SBBlock self) -> SBBlock
        Get the sibling block for this block.
        """
        return _lldb.SBBlock_GetSibling(self)

    def GetFirstChild(self):
        r"""
        GetFirstChild(SBBlock self) -> SBBlock
        Get the first child block.
        """
        return _lldb.SBBlock_GetFirstChild(self)

    def GetNumRanges(self):
        r"""GetNumRanges(SBBlock self) -> uint32_t"""
        return _lldb.SBBlock_GetNumRanges(self)

    def GetRangeStartAddress(self, idx):
        r"""GetRangeStartAddress(SBBlock self, uint32_t idx) -> SBAddress"""
        return _lldb.SBBlock_GetRangeStartAddress(self, idx)

    def GetRangeEndAddress(self, idx):
        r"""GetRangeEndAddress(SBBlock self, uint32_t idx) -> SBAddress"""
        return _lldb.SBBlock_GetRangeEndAddress(self, idx)

    def GetRanges(self):
        r"""GetRanges(SBBlock self) -> SBAddressRangeList"""
        return _lldb.SBBlock_GetRanges(self)

    def GetRangeIndexForBlockAddress(self, block_addr):
        r"""GetRangeIndexForBlockAddress(SBBlock self, SBAddress block_addr) -> uint32_t"""
        return _lldb.SBBlock_GetRangeIndexForBlockAddress(self, block_addr)

    def GetVariables(self, *args):
        r"""
        GetVariables(SBBlock self, SBFrame frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) -> SBValueList
        GetVariables(SBBlock self, SBTarget target, bool arguments, bool locals, bool statics) -> SBValueList
        """
        return _lldb.SBBlock_GetVariables(self, *args)

    def GetContainingInlinedBlock(self):
        r"""
        GetContainingInlinedBlock(SBBlock self) -> SBBlock
        Get the inlined block that is or contains this block.
        """
        return _lldb.SBBlock_GetContainingInlinedBlock(self)

    def GetDescription(self, description):
        r"""GetDescription(SBBlock self, SBStream description) -> bool"""
        return _lldb.SBBlock_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBBlock self) -> std::string"""
        return _lldb.SBBlock___repr__(self)

    def get_range_at_index(self, idx):
        if idx < self.GetNumRanges():
            return [self.GetRangeStartAddress(idx), self.GetRangeEndAddress(idx)]
        return []

    class ranges_access(object):
        '''A helper object that will lazily hand out an array of lldb.SBAddress that represent address ranges for a block.'''
        def __init__(self, sbblock):
            self.sbblock = sbblock

        def __len__(self):
            if self.sbblock:
                return int(self.sbblock.GetNumRanges())
            return 0

        def __getitem__(self, key):
            count = len(self)
            if type(key) is int:
                return self.sbblock.get_range_at_index (key);
            if isinstance(key, SBAddress):
                range_idx = self.sbblock.GetRangeIndexForBlockAddress(key);
                if range_idx < len(self):
                    return [self.sbblock.GetRangeStartAddress(range_idx), self.sbblock.GetRangeEndAddress(range_idx)]
            else:
                print("error: unsupported item type: %s" % type(key))
            return None

    def get_ranges_access_object(self):
        '''An accessor function that returns a ranges_access() object which allows lazy block address ranges access.'''
        return self.ranges_access (self)

    def get_ranges_array(self):
        '''An accessor function that returns an array object that contains all ranges in this block object.'''
        if not hasattr(self, 'ranges_array'):
            self.ranges_array = []
            for idx in range(self.num_ranges):
                self.ranges_array.append ([self.GetRangeStartAddress(idx), self.GetRangeEndAddress(idx)])
        return self.ranges_array

    def get_call_site(self):
        return declaration(self.GetInlinedCallSiteFile(), self.GetInlinedCallSiteLine(), self.GetInlinedCallSiteColumn())

    parent = property(GetParent, None, doc='''A read only property that returns the same result as GetParent().''')
    first_child = property(GetFirstChild, None, doc='''A read only property that returns the same result as GetFirstChild().''')
    call_site = property(get_call_site, None, doc='''A read only property that returns a lldb.declaration object that contains the inlined call site file, line and column.''')
    sibling = property(GetSibling, None, doc='''A read only property that returns the same result as GetSibling().''')
    name = property(GetInlinedName, None, doc='''A read only property that returns the same result as GetInlinedName().''')
    inlined_block = property(GetContainingInlinedBlock, None, doc='''A read only property that returns the same result as GetContainingInlinedBlock().''')
    range = property(get_ranges_access_object, None, doc='''A read only property that allows item access to the address ranges for a block by integer (range = block.range[0]) and by lldb.SBAddress (find the range that contains the specified lldb.SBAddress like "pc_range = lldb.frame.block.range[frame.addr]").''')
    ranges = property(get_ranges_array, None, doc='''A read only property that returns a list() object that contains all of the address ranges for the block.''')
    num_ranges = property(GetNumRanges, None, doc='''A read only property that returns the same result as GetNumRanges().''')


# Register SBBlock in _lldb:
_lldb.SBBlock_swigregister(SBBlock)
class SBBreakpoint(object):
    r"""
    Represents a logical breakpoint and its associated settings.

    For example (from test/functionalities/breakpoint/breakpoint_ignore_count/
    TestBreakpointIgnoreCount.py),::

        def breakpoint_ignore_count_python(self):
            '''Use Python APIs to set breakpoint ignore count.'''
            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            # Now create a breakpoint on main.c by name 'c'.
            breakpoint = target.BreakpointCreateByName('c', 'a.out')
            self.assertTrue(breakpoint and
                            breakpoint.GetNumLocations() == 1,
                            VALID_BREAKPOINT)

            # Get the breakpoint location from breakpoint after we verified that,
            # indeed, it has one location.
            location = breakpoint.GetLocationAtIndex(0)
            self.assertTrue(location and
                            location.IsEnabled(),
                            VALID_BREAKPOINT_LOCATION)

            # Set the ignore count on the breakpoint location.
            location.SetIgnoreCount(2)
            self.assertTrue(location.GetIgnoreCount() == 2,
                            'SetIgnoreCount() works correctly')

            # Now launch the process, and do not stop at entry point.
            process = target.LaunchSimple(None, None, os.getcwd())
            self.assertTrue(process, PROCESS_IS_VALID)

            # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and
            # frame#2 should be on main.c:48.
            #lldbutil.print_stacktraces(process)
            from lldbutil import get_stopped_thread
            thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
            self.assertTrue(thread is not None, 'There should be a thread stopped due to breakpoint')
            frame0 = thread.GetFrameAtIndex(0)
            frame1 = thread.GetFrameAtIndex(1)
            frame2 = thread.GetFrameAtIndex(2)
            self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and
                            frame1.GetLineEntry().GetLine() == self.line3 and
                            frame2.GetLineEntry().GetLine() == self.line4,
                            STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT)

            # The hit count for the breakpoint should be 3.
            self.assertTrue(breakpoint.GetHitCount() == 3)

            process.Continue()

    SBBreakpoint supports breakpoint location iteration, for example,::

        for bl in breakpoint:
            print('breakpoint location load addr: %s' % hex(bl.GetLoadAddress()))
            print('breakpoint location condition: %s' % hex(bl.GetCondition()))

    and rich comparison methods which allow the API program to use,::

        if aBreakpoint == bBreakpoint:
            ...

    to compare two breakpoints for equality.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBBreakpoint self) -> SBBreakpoint
        __init__(SBBreakpoint self, SBBreakpoint rhs) -> SBBreakpoint
        """
        _lldb.SBBreakpoint_swiginit(self, _lldb.new_SBBreakpoint(*args))
    __swig_destroy__ = _lldb.delete_SBBreakpoint

    def __eq__(self, rhs):
        r"""__eq__(SBBreakpoint self, SBBreakpoint rhs) -> bool"""
        return _lldb.SBBreakpoint___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBBreakpoint self, SBBreakpoint rhs) -> bool"""
        return _lldb.SBBreakpoint___ne__(self, rhs)

    def GetID(self):
        r"""GetID(SBBreakpoint self) -> lldb::break_id_t"""
        return _lldb.SBBreakpoint_GetID(self)

    def __nonzero__(self):
        return _lldb.SBBreakpoint___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBBreakpoint self) -> bool"""
        return _lldb.SBBreakpoint_IsValid(self)

    def ClearAllBreakpointSites(self):
        r"""ClearAllBreakpointSites(SBBreakpoint self)"""
        return _lldb.SBBreakpoint_ClearAllBreakpointSites(self)

    def GetTarget(self):
        r"""GetTarget(SBBreakpoint self) -> SBTarget"""
        return _lldb.SBBreakpoint_GetTarget(self)

    def FindLocationByAddress(self, vm_addr):
        r"""FindLocationByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> SBBreakpointLocation"""
        return _lldb.SBBreakpoint_FindLocationByAddress(self, vm_addr)

    def FindLocationIDByAddress(self, vm_addr):
        r"""FindLocationIDByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> lldb::break_id_t"""
        return _lldb.SBBreakpoint_FindLocationIDByAddress(self, vm_addr)

    def FindLocationByID(self, bp_loc_id):
        r"""FindLocationByID(SBBreakpoint self, lldb::break_id_t bp_loc_id) -> SBBreakpointLocation"""
        return _lldb.SBBreakpoint_FindLocationByID(self, bp_loc_id)

    def GetLocationAtIndex(self, index):
        r"""GetLocationAtIndex(SBBreakpoint self, uint32_t index) -> SBBreakpointLocation"""
        return _lldb.SBBreakpoint_GetLocationAtIndex(self, index)

    def SetEnabled(self, enable):
        r"""SetEnabled(SBBreakpoint self, bool enable)"""
        return _lldb.SBBreakpoint_SetEnabled(self, enable)

    def IsEnabled(self):
        r"""IsEnabled(SBBreakpoint self) -> bool"""
        return _lldb.SBBreakpoint_IsEnabled(self)

    def SetOneShot(self, one_shot):
        r"""SetOneShot(SBBreakpoint self, bool one_shot)"""
        return _lldb.SBBreakpoint_SetOneShot(self, one_shot)

    def IsOneShot(self):
        r"""IsOneShot(SBBreakpoint self) -> bool"""
        return _lldb.SBBreakpoint_IsOneShot(self)

    def IsInternal(self):
        r"""IsInternal(SBBreakpoint self) -> bool"""
        return _lldb.SBBreakpoint_IsInternal(self)

    def GetHitCount(self):
        r"""GetHitCount(SBBreakpoint self) -> uint32_t"""
        return _lldb.SBBreakpoint_GetHitCount(self)

    def SetIgnoreCount(self, count):
        r"""SetIgnoreCount(SBBreakpoint self, uint32_t count)"""
        return _lldb.SBBreakpoint_SetIgnoreCount(self, count)

    def GetIgnoreCount(self):
        r"""GetIgnoreCount(SBBreakpoint self) -> uint32_t"""
        return _lldb.SBBreakpoint_GetIgnoreCount(self)

    def SetCondition(self, condition):
        r"""
        SetCondition(SBBreakpoint self, char const * condition)

            The breakpoint stops only if the condition expression evaluates to true.
        """
        return _lldb.SBBreakpoint_SetCondition(self, condition)

    def GetCondition(self):
        r"""
        GetCondition(SBBreakpoint self) -> char const *

            Get the condition expression for the breakpoint.
        """
        return _lldb.SBBreakpoint_GetCondition(self)

    def SetAutoContinue(self, auto_continue):
        r"""SetAutoContinue(SBBreakpoint self, bool auto_continue)"""
        return _lldb.SBBreakpoint_SetAutoContinue(self, auto_continue)

    def GetAutoContinue(self):
        r"""GetAutoContinue(SBBreakpoint self) -> bool"""
        return _lldb.SBBreakpoint_GetAutoContinue(self)

    def SetThreadID(self, sb_thread_id):
        r"""SetThreadID(SBBreakpoint self, lldb::tid_t sb_thread_id)"""
        return _lldb.SBBreakpoint_SetThreadID(self, sb_thread_id)

    def GetThreadID(self):
        r"""GetThreadID(SBBreakpoint self) -> lldb::tid_t"""
        return _lldb.SBBreakpoint_GetThreadID(self)

    def SetThreadIndex(self, index):
        r"""SetThreadIndex(SBBreakpoint self, uint32_t index)"""
        return _lldb.SBBreakpoint_SetThreadIndex(self, index)

    def GetThreadIndex(self):
        r"""GetThreadIndex(SBBreakpoint self) -> uint32_t"""
        return _lldb.SBBreakpoint_GetThreadIndex(self)

    def SetThreadName(self, thread_name):
        r"""SetThreadName(SBBreakpoint self, char const * thread_name)"""
        return _lldb.SBBreakpoint_SetThreadName(self, thread_name)

    def GetThreadName(self):
        r"""GetThreadName(SBBreakpoint self) -> char const *"""
        return _lldb.SBBreakpoint_GetThreadName(self)

    def SetQueueName(self, queue_name):
        r"""SetQueueName(SBBreakpoint self, char const * queue_name)"""
        return _lldb.SBBreakpoint_SetQueueName(self, queue_name)

    def GetQueueName(self):
        r"""GetQueueName(SBBreakpoint self) -> char const *"""
        return _lldb.SBBreakpoint_GetQueueName(self)

    def SetScriptCallbackFunction(self, *args):
        r"""
        SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name)
        SetScriptCallbackFunction(SBBreakpoint self, char const * callback_function_name, SBStructuredData extra_args) -> SBError

            Set the name of the script function to be called when the breakpoint is hit.
            To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
            when the breakpoint is hit the extra_args will be passed to the callback function.
        """
        return _lldb.SBBreakpoint_SetScriptCallbackFunction(self, *args)

    def SetCommandLineCommands(self, commands):
        r"""SetCommandLineCommands(SBBreakpoint self, SBStringList commands)"""
        return _lldb.SBBreakpoint_SetCommandLineCommands(self, commands)

    def GetCommandLineCommands(self, commands):
        r"""GetCommandLineCommands(SBBreakpoint self, SBStringList commands) -> bool"""
        return _lldb.SBBreakpoint_GetCommandLineCommands(self, commands)

    def SetScriptCallbackBody(self, script_body_text):
        r"""
        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.
        """
        return _lldb.SBBreakpoint_SetScriptCallbackBody(self, script_body_text)

    def AddName(self, new_name):
        r"""AddName(SBBreakpoint self, char const * new_name) -> bool"""
        return _lldb.SBBreakpoint_AddName(self, new_name)

    def AddNameWithErrorHandling(self, new_name):
        r"""AddNameWithErrorHandling(SBBreakpoint self, char const * new_name) -> SBError"""
        return _lldb.SBBreakpoint_AddNameWithErrorHandling(self, new_name)

    def RemoveName(self, name_to_remove):
        r"""RemoveName(SBBreakpoint self, char const * name_to_remove)"""
        return _lldb.SBBreakpoint_RemoveName(self, name_to_remove)

    def MatchesName(self, name):
        r"""MatchesName(SBBreakpoint self, char const * name) -> bool"""
        return _lldb.SBBreakpoint_MatchesName(self, name)

    def GetNames(self, names):
        r"""GetNames(SBBreakpoint self, SBStringList names)"""
        return _lldb.SBBreakpoint_GetNames(self, names)

    def GetNumResolvedLocations(self):
        r"""GetNumResolvedLocations(SBBreakpoint self) -> size_t"""
        return _lldb.SBBreakpoint_GetNumResolvedLocations(self)

    def GetNumLocations(self):
        r"""GetNumLocations(SBBreakpoint self) -> size_t"""
        return _lldb.SBBreakpoint_GetNumLocations(self)

    def GetDescription(self, *args):
        r"""
        GetDescription(SBBreakpoint self, SBStream description) -> bool
        GetDescription(SBBreakpoint self, SBStream description, bool include_locations) -> bool
        """
        return _lldb.SBBreakpoint_GetDescription(self, *args)

    @staticmethod
    def EventIsBreakpointEvent(event):
        r"""EventIsBreakpointEvent(SBEvent event) -> bool"""
        return _lldb.SBBreakpoint_EventIsBreakpointEvent(event)

    @staticmethod
    def GetBreakpointEventTypeFromEvent(event):
        r"""GetBreakpointEventTypeFromEvent(SBEvent event) -> lldb::BreakpointEventType"""
        return _lldb.SBBreakpoint_GetBreakpointEventTypeFromEvent(event)

    @staticmethod
    def GetBreakpointFromEvent(event):
        r"""GetBreakpointFromEvent(SBEvent event) -> SBBreakpoint"""
        return _lldb.SBBreakpoint_GetBreakpointFromEvent(event)

    @staticmethod
    def GetBreakpointLocationAtIndexFromEvent(event, loc_idx):
        r"""GetBreakpointLocationAtIndexFromEvent(SBEvent event, uint32_t loc_idx) -> SBBreakpointLocation"""
        return _lldb.SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(event, loc_idx)

    @staticmethod
    def GetNumBreakpointLocationsFromEvent(event_sp):
        r"""GetNumBreakpointLocationsFromEvent(SBEvent event_sp) -> uint32_t"""
        return _lldb.SBBreakpoint_GetNumBreakpointLocationsFromEvent(event_sp)

    def IsHardware(self):
        r"""IsHardware(SBBreakpoint self) -> bool"""
        return _lldb.SBBreakpoint_IsHardware(self)

    def SetIsHardware(self, is_hardware):
        r"""
        Make this breakpoint a hardware breakpoint. This will replace all existing
        breakpoint locations with hardware breakpoints. Returns an error if this
        fails, e.g. when there aren't enough hardware resources available.
        """
        return _lldb.SBBreakpoint_SetIsHardware(self, is_hardware)

    def AddLocation(self, address):
        r"""AddLocation(SBBreakpoint self, SBAddress address) -> SBError"""
        return _lldb.SBBreakpoint_AddLocation(self, address)

    def SerializeToStructuredData(self):
        r"""SerializeToStructuredData(SBBreakpoint self) -> SBStructuredData"""
        return _lldb.SBBreakpoint_SerializeToStructuredData(self)

    def __repr__(self):
        r"""__repr__(SBBreakpoint self) -> std::string"""
        return _lldb.SBBreakpoint___repr__(self)


    class locations_access(object):
        '''A helper object that will lazily hand out locations for a breakpoint when supplied an index.'''
        def __init__(self, sbbreakpoint):
            self.sbbreakpoint = sbbreakpoint

        def __len__(self):
            if self.sbbreakpoint:
                return int(self.sbbreakpoint.GetNumLocations())
            return 0

        def __getitem__(self, key):
            if isinstance(key, int):
                count = len(self)
                if -count <= key < count:
                    key %= count
                    return self.sbbreakpoint.GetLocationAtIndex(key)
            return None

    def get_locations_access_object(self):
        '''An accessor function that returns a locations_access() object which allows lazy location access from a lldb.SBBreakpoint object.'''
        return self.locations_access (self)

    def get_breakpoint_location_list(self):
        '''An accessor function that returns a list() that contains all locations in a lldb.SBBreakpoint object.'''
        locations = []
        accessor = self.get_locations_access_object()
        for idx in range(len(accessor)):
            locations.append(accessor[idx])
        return locations

    def __iter__(self):
        '''Iterate over all breakpoint locations in a lldb.SBBreakpoint
        object.'''
        return lldb_iter(self, 'GetNumLocations', 'GetLocationAtIndex')

    def __len__(self):
        '''Return the number of breakpoint locations in a lldb.SBBreakpoint
        object.'''
        return self.GetNumLocations()

    locations = property(get_breakpoint_location_list, None, doc='''A read only property that returns a list() of lldb.SBBreakpointLocation objects for this breakpoint.''')
    location = property(get_locations_access_object, None, doc='''A read only property that returns an object that can access locations by index (not location ID) (location = bkpt.location[12]).''')
    id = property(GetID, None, doc='''A read only property that returns the ID of this breakpoint.''')
    enabled = property(IsEnabled, SetEnabled, doc='''A read/write property that configures whether this breakpoint is enabled or not.''')
    one_shot = property(IsOneShot, SetOneShot, doc='''A read/write property that configures whether this breakpoint is one-shot (deleted when hit) or not.''')
    num_locations = property(GetNumLocations, None, doc='''A read only property that returns the count of locations of this breakpoint.''')
    auto_continue = property(GetAutoContinue, SetAutoContinue, doc='A read/write property that configures the auto-continue property of this breakpoint.')
    condition = property(GetCondition, SetCondition, doc='A read/write property that configures the condition of this breakpoint.')
    hit_count = property(GetHitCount, doc='A read only property that returns the hit count of this breakpoint.')
    ignore_count = property(GetIgnoreCount, SetIgnoreCount, doc='A read/write property that configures the ignore count of this breakpoint.')
    queue_name = property(GetQueueName, SetQueueName, doc='A read/write property that configures the queue name criteria of this breakpoint.')
    target = property(GetTarget, doc='A read only property that returns the target of this breakpoint.')
    thread_id = property(GetThreadID, SetThreadID, doc='A read/write property that configures the thread id criteria of this breakpoint.')
    thread_index = property(GetThreadIndex, SetThreadIndex, doc='A read/write property that configures the thread index criteria of this breakpoint.')
    thread_name = property(GetThreadName, SetThreadName, doc='A read/write property that configures the thread name criteria of this breakpoint.')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBBreakpoint in _lldb:
_lldb.SBBreakpoint_swigregister(SBBreakpoint)
class SBBreakpointList(object):
    r"""Represents a list of :py:class:`SBBreakpoint`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, target):
        r"""__init__(SBBreakpointList self, SBTarget target) -> SBBreakpointList"""
        _lldb.SBBreakpointList_swiginit(self, _lldb.new_SBBreakpointList(target))
    __swig_destroy__ = _lldb.delete_SBBreakpointList

    def GetSize(self):
        r"""GetSize(SBBreakpointList self) -> size_t"""
        return _lldb.SBBreakpointList_GetSize(self)

    def GetBreakpointAtIndex(self, idx):
        r"""GetBreakpointAtIndex(SBBreakpointList self, size_t idx) -> SBBreakpoint"""
        return _lldb.SBBreakpointList_GetBreakpointAtIndex(self, idx)

    def FindBreakpointByID(self, arg2):
        r"""FindBreakpointByID(SBBreakpointList self, lldb::break_id_t arg2) -> SBBreakpoint"""
        return _lldb.SBBreakpointList_FindBreakpointByID(self, arg2)

    def Append(self, sb_bkpt):
        r"""Append(SBBreakpointList self, SBBreakpoint sb_bkpt)"""
        return _lldb.SBBreakpointList_Append(self, sb_bkpt)

    def AppendIfUnique(self, sb_bkpt):
        r"""AppendIfUnique(SBBreakpointList self, SBBreakpoint sb_bkpt) -> bool"""
        return _lldb.SBBreakpointList_AppendIfUnique(self, sb_bkpt)

    def AppendByID(self, id):
        r"""AppendByID(SBBreakpointList self, lldb::break_id_t id)"""
        return _lldb.SBBreakpointList_AppendByID(self, id)

    def Clear(self):
        r"""Clear(SBBreakpointList self)"""
        return _lldb.SBBreakpointList_Clear(self)

    def __len__(self):
        '''Return the number of breakpoints in a lldb.SBBreakpointList object.'''
        return self.GetSize()

    def __iter__(self):
        '''Iterate over all breakpoints in a lldb.SBBreakpointList object.'''
        return lldb_iter(self, 'GetSize', 'GetBreakpointAtIndex')


# Register SBBreakpointList in _lldb:
_lldb.SBBreakpointList_swigregister(SBBreakpointList)
class SBBreakpointLocation(object):
    r"""
    Represents one unique instance (by address) of a logical breakpoint.

    A breakpoint location is defined by the breakpoint that produces it,
    and the address that resulted in this particular instantiation.
    Each breakpoint location has its settable options.

    :py:class:`SBBreakpoint` contains SBBreakpointLocation(s). See docstring of SBBreakpoint
    for retrieval of an SBBreakpointLocation from an SBBreakpoint.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBBreakpointLocation self) -> SBBreakpointLocation
        __init__(SBBreakpointLocation self, SBBreakpointLocation rhs) -> SBBreakpointLocation
        """
        _lldb.SBBreakpointLocation_swiginit(self, _lldb.new_SBBreakpointLocation(*args))
    __swig_destroy__ = _lldb.delete_SBBreakpointLocation

    def GetID(self):
        r"""GetID(SBBreakpointLocation self) -> lldb::break_id_t"""
        return _lldb.SBBreakpointLocation_GetID(self)

    def __nonzero__(self):
        return _lldb.SBBreakpointLocation___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBBreakpointLocation self) -> bool"""
        return _lldb.SBBreakpointLocation_IsValid(self)

    def GetAddress(self):
        r"""GetAddress(SBBreakpointLocation self) -> SBAddress"""
        return _lldb.SBBreakpointLocation_GetAddress(self)

    def GetLoadAddress(self):
        r"""GetLoadAddress(SBBreakpointLocation self) -> lldb::addr_t"""
        return _lldb.SBBreakpointLocation_GetLoadAddress(self)

    def SetEnabled(self, enabled):
        r"""SetEnabled(SBBreakpointLocation self, bool enabled)"""
        return _lldb.SBBreakpointLocation_SetEnabled(self, enabled)

    def IsEnabled(self):
        r"""IsEnabled(SBBreakpointLocation self) -> bool"""
        return _lldb.SBBreakpointLocation_IsEnabled(self)

    def GetHitCount(self):
        r"""GetHitCount(SBBreakpointLocation self) -> uint32_t"""
        return _lldb.SBBreakpointLocation_GetHitCount(self)

    def GetIgnoreCount(self):
        r"""GetIgnoreCount(SBBreakpointLocation self) -> uint32_t"""
        return _lldb.SBBreakpointLocation_GetIgnoreCount(self)

    def SetIgnoreCount(self, n):
        r"""SetIgnoreCount(SBBreakpointLocation self, uint32_t n)"""
        return _lldb.SBBreakpointLocation_SetIgnoreCount(self, n)

    def SetCondition(self, condition):
        r"""
        SetCondition(SBBreakpointLocation self, char const * condition)

            The breakpoint location stops only if the condition expression evaluates
            to true.
        """
        return _lldb.SBBreakpointLocation_SetCondition(self, condition)

    def GetCondition(self):
        r"""
        GetCondition(SBBreakpointLocation self) -> char const *

            Get the condition expression for the breakpoint location.
        """
        return _lldb.SBBreakpointLocation_GetCondition(self)

    def SetAutoContinue(self, auto_continue):
        r"""SetAutoContinue(SBBreakpointLocation self, bool auto_continue)"""
        return _lldb.SBBreakpointLocation_SetAutoContinue(self, auto_continue)

    def GetAutoContinue(self):
        r"""GetAutoContinue(SBBreakpointLocation self) -> bool"""
        return _lldb.SBBreakpointLocation_GetAutoContinue(self)

    def SetScriptCallbackFunction(self, *args):
        r"""
        SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name)
        SetScriptCallbackFunction(SBBreakpointLocation self, char const * callback_function_name, SBStructuredData extra_args) -> SBError

            Set the name of the script function to be called when the breakpoint is hit.
            To use this variant, the function should take (frame, bp_loc, extra_args, internal_dict) and
            when the breakpoint is hit the extra_args will be passed to the callback function.
        """
        return _lldb.SBBreakpointLocation_SetScriptCallbackFunction(self, *args)

    def SetScriptCallbackBody(self, script_body_text):
        r"""
        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.
        """
        return _lldb.SBBreakpointLocation_SetScriptCallbackBody(self, script_body_text)

    def SetCommandLineCommands(self, commands):
        r"""SetCommandLineCommands(SBBreakpointLocation self, SBStringList commands)"""
        return _lldb.SBBreakpointLocation_SetCommandLineCommands(self, commands)

    def GetCommandLineCommands(self, commands):
        r"""GetCommandLineCommands(SBBreakpointLocation self, SBStringList commands) -> bool"""
        return _lldb.SBBreakpointLocation_GetCommandLineCommands(self, commands)

    def SetThreadID(self, sb_thread_id):
        r"""SetThreadID(SBBreakpointLocation self, lldb::tid_t sb_thread_id)"""
        return _lldb.SBBreakpointLocation_SetThreadID(self, sb_thread_id)

    def GetThreadID(self):
        r"""GetThreadID(SBBreakpointLocation self) -> lldb::tid_t"""
        return _lldb.SBBreakpointLocation_GetThreadID(self)

    def SetThreadIndex(self, index):
        r"""SetThreadIndex(SBBreakpointLocation self, uint32_t index)"""
        return _lldb.SBBreakpointLocation_SetThreadIndex(self, index)

    def GetThreadIndex(self):
        r"""GetThreadIndex(SBBreakpointLocation self) -> uint32_t"""
        return _lldb.SBBreakpointLocation_GetThreadIndex(self)

    def SetThreadName(self, thread_name):
        r"""SetThreadName(SBBreakpointLocation self, char const * thread_name)"""
        return _lldb.SBBreakpointLocation_SetThreadName(self, thread_name)

    def GetThreadName(self):
        r"""GetThreadName(SBBreakpointLocation self) -> char const *"""
        return _lldb.SBBreakpointLocation_GetThreadName(self)

    def SetQueueName(self, queue_name):
        r"""SetQueueName(SBBreakpointLocation self, char const * queue_name)"""
        return _lldb.SBBreakpointLocation_SetQueueName(self, queue_name)

    def GetQueueName(self):
        r"""GetQueueName(SBBreakpointLocation self) -> char const *"""
        return _lldb.SBBreakpointLocation_GetQueueName(self)

    def IsResolved(self):
        r"""IsResolved(SBBreakpointLocation self) -> bool"""
        return _lldb.SBBreakpointLocation_IsResolved(self)

    def GetDescription(self, description, level):
        r"""GetDescription(SBBreakpointLocation self, SBStream description, lldb::DescriptionLevel level) -> bool"""
        return _lldb.SBBreakpointLocation_GetDescription(self, description, level)

    def GetBreakpoint(self):
        r"""GetBreakpoint(SBBreakpointLocation self) -> SBBreakpoint"""
        return _lldb.SBBreakpointLocation_GetBreakpoint(self)

    def __repr__(self):
        r"""__repr__(SBBreakpointLocation self) -> std::string"""
        return _lldb.SBBreakpointLocation___repr__(self)

        # operator== is a free function, which swig does not handle, so we inject
        # our own equality operator here
    def __eq__(self, other):
      return not self.__ne__(other)

    addr = property(GetAddress, doc='A read only property that returns the address of this breakpoint location.')
    auto_continue = property(GetAutoContinue, SetAutoContinue, doc='A read/write property that configures the auto-continue property of this breakpoint location.')
    breakpoint = property(GetBreakpoint, doc='A read only property that returns the parent breakpoint of this breakpoint location.')
    condition = property(GetCondition, SetCondition, doc='A read/write property that configures the condition of this breakpoint location.')
    hit_count = property(GetHitCount, doc='A read only property that returns the hit count of this breakpoint location.')
    id = property(GetID, doc='A read only property that returns the id of this breakpoint location.')
    ignore_count = property(GetIgnoreCount, SetIgnoreCount, doc='A read/write property that configures the ignore count of this breakpoint location.')
    load_addr = property(GetLoadAddress, doc='A read only property that returns the load address of this breakpoint location.')
    queue_name = property(GetQueueName, SetQueueName, doc='A read/write property that configures the queue name criteria of this breakpoint location.')
    thread_id = property(GetThreadID, SetThreadID, doc='A read/write property that configures the thread id criteria of this breakpoint location.')
    thread_index = property(GetThreadIndex, SetThreadIndex, doc='A read/write property that configures the thread index criteria of this breakpoint location.')
    thread_name = property(GetThreadName, SetThreadName, doc='A read/write property that configures the thread name criteria of this breakpoint location.')


# Register SBBreakpointLocation in _lldb:
_lldb.SBBreakpointLocation_swigregister(SBBreakpointLocation)
class SBBreakpointName(object):
    r"""
    Represents a breakpoint name registered in a given :py:class:`SBTarget`.

    Breakpoint names provide a way to act on groups of breakpoints.  When you add a
    name to a group of breakpoints, you can then use the name in all the command
    line lldb commands for that name.  You can also configure the SBBreakpointName
    options and those options will be propagated to any :py:class:`SBBreakpoint` s currently
    using that name.  Adding a name to a breakpoint will also apply any of the
    set options to that breakpoint.

    You can also set permissions on a breakpoint name to disable listing, deleting
    and disabling breakpoints.  That will disallow the given operation for breakpoints
    except when the breakpoint is mentioned by ID.  So for instance deleting all the
    breakpoints won't delete breakpoints so marked.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBBreakpointName self) -> SBBreakpointName
        __init__(SBBreakpointName self, SBTarget target, char const * name) -> SBBreakpointName
        __init__(SBBreakpointName self, SBBreakpoint bkpt, char const * name) -> SBBreakpointName
        __init__(SBBreakpointName self, SBBreakpointName rhs) -> SBBreakpointName
        """
        _lldb.SBBreakpointName_swiginit(self, _lldb.new_SBBreakpointName(*args))
    __swig_destroy__ = _lldb.delete_SBBreakpointName

    def __eq__(self, rhs):
        r"""__eq__(SBBreakpointName self, SBBreakpointName rhs) -> bool"""
        return _lldb.SBBreakpointName___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBBreakpointName self, SBBreakpointName rhs) -> bool"""
        return _lldb.SBBreakpointName___ne__(self, rhs)

    def __nonzero__(self):
        return _lldb.SBBreakpointName___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBBreakpointName self) -> bool"""
        return _lldb.SBBreakpointName_IsValid(self)

    def GetName(self):
        r"""GetName(SBBreakpointName self) -> char const *"""
        return _lldb.SBBreakpointName_GetName(self)

    def SetEnabled(self, enable):
        r"""SetEnabled(SBBreakpointName self, bool enable)"""
        return _lldb.SBBreakpointName_SetEnabled(self, enable)

    def IsEnabled(self):
        r"""IsEnabled(SBBreakpointName self) -> bool"""
        return _lldb.SBBreakpointName_IsEnabled(self)

    def SetOneShot(self, one_shot):
        r"""SetOneShot(SBBreakpointName self, bool one_shot)"""
        return _lldb.SBBreakpointName_SetOneShot(self, one_shot)

    def IsOneShot(self):
        r"""IsOneShot(SBBreakpointName self) -> bool"""
        return _lldb.SBBreakpointName_IsOneShot(self)

    def SetIgnoreCount(self, count):
        r"""SetIgnoreCount(SBBreakpointName self, uint32_t count)"""
        return _lldb.SBBreakpointName_SetIgnoreCount(self, count)

    def GetIgnoreCount(self):
        r"""GetIgnoreCount(SBBreakpointName self) -> uint32_t"""
        return _lldb.SBBreakpointName_GetIgnoreCount(self)

    def SetCondition(self, condition):
        r"""SetCondition(SBBreakpointName self, char const * condition)"""
        return _lldb.SBBreakpointName_SetCondition(self, condition)

    def GetCondition(self):
        r"""GetCondition(SBBreakpointName self) -> char const *"""
        return _lldb.SBBreakpointName_GetCondition(self)

    def SetAutoContinue(self, auto_continue):
        r"""SetAutoContinue(SBBreakpointName self, bool auto_continue)"""
        return _lldb.SBBreakpointName_SetAutoContinue(self, auto_continue)

    def GetAutoContinue(self):
        r"""GetAutoContinue(SBBreakpointName self) -> bool"""
        return _lldb.SBBreakpointName_GetAutoContinue(self)

    def SetThreadID(self, sb_thread_id):
        r"""SetThreadID(SBBreakpointName self, lldb::tid_t sb_thread_id)"""
        return _lldb.SBBreakpointName_SetThreadID(self, sb_thread_id)

    def GetThreadID(self):
        r"""GetThreadID(SBBreakpointName self) -> lldb::tid_t"""
        return _lldb.SBBreakpointName_GetThreadID(self)

    def SetThreadIndex(self, index):
        r"""SetThreadIndex(SBBreakpointName self, uint32_t index)"""
        return _lldb.SBBreakpointName_SetThreadIndex(self, index)

    def GetThreadIndex(self):
        r"""GetThreadIndex(SBBreakpointName self) -> uint32_t"""
        return _lldb.SBBreakpointName_GetThreadIndex(self)

    def SetThreadName(self, thread_name):
        r"""SetThreadName(SBBreakpointName self, char const * thread_name)"""
        return _lldb.SBBreakpointName_SetThreadName(self, thread_name)

    def GetThreadName(self):
        r"""GetThreadName(SBBreakpointName self) -> char const *"""
        return _lldb.SBBreakpointName_GetThreadName(self)

    def SetQueueName(self, queue_name):
        r"""SetQueueName(SBBreakpointName self, char const * queue_name)"""
        return _lldb.SBBreakpointName_SetQueueName(self, queue_name)

    def GetQueueName(self):
        r"""GetQueueName(SBBreakpointName self) -> char const *"""
        return _lldb.SBBreakpointName_GetQueueName(self)

    def SetScriptCallbackFunction(self, *args):
        r"""
        SetScriptCallbackFunction(SBBreakpointName self, char const * callback_function_name)
        SetScriptCallbackFunction(SBBreakpointName self, char const * callback_function_name, SBStructuredData extra_args) -> SBError
        """
        return _lldb.SBBreakpointName_SetScriptCallbackFunction(self, *args)

    def SetCommandLineCommands(self, commands):
        r"""SetCommandLineCommands(SBBreakpointName self, SBStringList commands)"""
        return _lldb.SBBreakpointName_SetCommandLineCommands(self, commands)

    def GetCommandLineCommands(self, commands):
        r"""GetCommandLineCommands(SBBreakpointName self, SBStringList commands) -> bool"""
        return _lldb.SBBreakpointName_GetCommandLineCommands(self, commands)

    def SetScriptCallbackBody(self, script_body_text):
        r"""SetScriptCallbackBody(SBBreakpointName self, char const * script_body_text) -> SBError"""
        return _lldb.SBBreakpointName_SetScriptCallbackBody(self, script_body_text)

    def GetHelpString(self):
        r"""GetHelpString(SBBreakpointName self) -> char const *"""
        return _lldb.SBBreakpointName_GetHelpString(self)

    def SetHelpString(self, help_string):
        r"""SetHelpString(SBBreakpointName self, char const * help_string)"""
        return _lldb.SBBreakpointName_SetHelpString(self, help_string)

    def GetAllowList(self):
        r"""GetAllowList(SBBreakpointName self) -> bool"""
        return _lldb.SBBreakpointName_GetAllowList(self)

    def SetAllowList(self, value):
        r"""SetAllowList(SBBreakpointName self, bool value)"""
        return _lldb.SBBreakpointName_SetAllowList(self, value)

    def GetAllowDelete(self):
        r"""GetAllowDelete(SBBreakpointName self) -> bool"""
        return _lldb.SBBreakpointName_GetAllowDelete(self)

    def SetAllowDelete(self, value):
        r"""SetAllowDelete(SBBreakpointName self, bool value)"""
        return _lldb.SBBreakpointName_SetAllowDelete(self, value)

    def GetAllowDisable(self):
        r"""GetAllowDisable(SBBreakpointName self) -> bool"""
        return _lldb.SBBreakpointName_GetAllowDisable(self)

    def SetAllowDisable(self, value):
        r"""SetAllowDisable(SBBreakpointName self, bool value)"""
        return _lldb.SBBreakpointName_SetAllowDisable(self, value)

    def GetDescription(self, description):
        r"""GetDescription(SBBreakpointName self, SBStream description) -> bool"""
        return _lldb.SBBreakpointName_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBBreakpointName self) -> std::string"""
        return _lldb.SBBreakpointName___repr__(self)

        # operator== is a free function, which swig does not handle, so we inject
        # our own equality operator here
    def __eq__(self, other):
      return not self.__ne__(other)

    auto_continue = property(GetAutoContinue, SetAutoContinue, doc='A read/write property that configures the auto-continue property of this breakpoint name.')
    condition = property(GetCondition, SetCondition, doc='A read/write property that configures the condition of this breakpoint name.')
    enabled = property(IsEnabled, SetEnabled, doc='''A read/write property that configures whether this breakpoint name is enabled or not.''')
    ignore_count = property(GetIgnoreCount, SetIgnoreCount, doc='A read/write property that configures the ignore count of this breakpoint name.')
    one_shot = property(IsOneShot, SetOneShot, doc='''A read/write property that configures whether this breakpoint name is one-shot (deleted when hit) or not.''')
    queue_name = property(GetQueueName, SetQueueName, doc='A read/write property that configures the queue name criteria of this breakpoint name.')
    thread_id = property(GetThreadID, SetThreadID, doc='A read/write property that configures the thread id criteria of this breakpoint name.')
    thread_index = property(GetThreadIndex, SetThreadIndex, doc='A read/write property that configures the thread index criteria of this breakpoint name.')
    thread_name = property(GetThreadName, SetThreadName, doc='A read/write property that configures the thread name criteria of this breakpoint name.')


# Register SBBreakpointName in _lldb:
_lldb.SBBreakpointName_swigregister(SBBreakpointName)
class SBBroadcaster(object):
    r"""
    Represents an entity which can broadcast events.

    A default broadcaster is
    associated with an SBCommandInterpreter, SBProcess, and SBTarget.  For
    example, use ::

        broadcaster = process.GetBroadcaster()

    to retrieve the process's broadcaster.

    See also SBEvent for example usage of interacting with a broadcaster.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBBroadcaster self) -> SBBroadcaster
        __init__(SBBroadcaster self, char const * name) -> SBBroadcaster
        __init__(SBBroadcaster self, SBBroadcaster rhs) -> SBBroadcaster
        """
        _lldb.SBBroadcaster_swiginit(self, _lldb.new_SBBroadcaster(*args))
    __swig_destroy__ = _lldb.delete_SBBroadcaster

    def __nonzero__(self):
        return _lldb.SBBroadcaster___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBBroadcaster self) -> bool"""
        return _lldb.SBBroadcaster_IsValid(self)

    def Clear(self):
        r"""Clear(SBBroadcaster self)"""
        return _lldb.SBBroadcaster_Clear(self)

    def BroadcastEventByType(self, event_type, unique=False):
        r"""BroadcastEventByType(SBBroadcaster self, uint32_t event_type, bool unique=False)"""
        return _lldb.SBBroadcaster_BroadcastEventByType(self, event_type, unique)

    def BroadcastEvent(self, event, unique=False):
        r"""BroadcastEvent(SBBroadcaster self, SBEvent event, bool unique=False)"""
        return _lldb.SBBroadcaster_BroadcastEvent(self, event, unique)

    def AddInitialEventsToListener(self, listener, requested_events):
        r"""AddInitialEventsToListener(SBBroadcaster self, SBListener listener, uint32_t requested_events)"""
        return _lldb.SBBroadcaster_AddInitialEventsToListener(self, listener, requested_events)

    def AddListener(self, listener, event_mask):
        r"""AddListener(SBBroadcaster self, SBListener listener, uint32_t event_mask) -> uint32_t"""
        return _lldb.SBBroadcaster_AddListener(self, listener, event_mask)

    def GetName(self):
        r"""GetName(SBBroadcaster self) -> char const *"""
        return _lldb.SBBroadcaster_GetName(self)

    def EventTypeHasListeners(self, event_type):
        r"""EventTypeHasListeners(SBBroadcaster self, uint32_t event_type) -> bool"""
        return _lldb.SBBroadcaster_EventTypeHasListeners(self, event_type)

    def RemoveListener(self, *args):
        r"""RemoveListener(SBBroadcaster self, SBListener listener, uint32_t event_mask=4294967295U) -> bool"""
        return _lldb.SBBroadcaster_RemoveListener(self, *args)

    def __eq__(self, rhs):
        r"""__eq__(SBBroadcaster self, SBBroadcaster rhs) -> bool"""
        return _lldb.SBBroadcaster___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBBroadcaster self, SBBroadcaster rhs) -> bool"""
        return _lldb.SBBroadcaster___ne__(self, rhs)

    def __lt__(self, rhs):
        r"""__lt__(SBBroadcaster self, SBBroadcaster rhs) -> bool"""
        return _lldb.SBBroadcaster___lt__(self, rhs)

        # operator== is a free function, which swig does not handle, so we inject
        # our own equality operator here
    def __eq__(self, other):
      return not self.__ne__(other)


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBBroadcaster in _lldb:
_lldb.SBBroadcaster_swigregister(SBBroadcaster)
class SBCommandInterpreter(object):
    r"""
    SBCommandInterpreter handles/interprets commands for lldb.

    You get the command interpreter from the :py:class:`SBDebugger` instance.

    For example (from test/ python_api/interpreter/TestCommandInterpreterAPI.py),::

        def command_interpreter_api(self):
            '''Test the SBCommandInterpreter APIs.'''
            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            # Retrieve the associated command interpreter from our debugger.
            ci = self.dbg.GetCommandInterpreter()
            self.assertTrue(ci, VALID_COMMAND_INTERPRETER)

            # Exercise some APIs....

            self.assertTrue(ci.HasCommands())
            self.assertTrue(ci.HasAliases())
            self.assertTrue(ci.HasAliasOptions())
            self.assertTrue(ci.CommandExists('breakpoint'))
            self.assertTrue(ci.CommandExists('target'))
            self.assertTrue(ci.CommandExists('platform'))
            self.assertTrue(ci.AliasExists('file'))
            self.assertTrue(ci.AliasExists('run'))
            self.assertTrue(ci.AliasExists('bt'))

            res = lldb.SBCommandReturnObject()
            ci.HandleCommand('breakpoint set -f main.c -l %d' % self.line, res)
            self.assertTrue(res.Succeeded())
            ci.HandleCommand('process launch', res)
            self.assertTrue(res.Succeeded())

            process = ci.GetProcess()
            self.assertTrue(process)

            ...

    The HandleCommand() instance method takes two args: the command string and
    an SBCommandReturnObject instance which encapsulates the result of command
    execution.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    eBroadcastBitThreadShouldExit = _lldb.SBCommandInterpreter_eBroadcastBitThreadShouldExit
    
    eBroadcastBitResetPrompt = _lldb.SBCommandInterpreter_eBroadcastBitResetPrompt
    
    eBroadcastBitQuitCommandReceived = _lldb.SBCommandInterpreter_eBroadcastBitQuitCommandReceived
    
    eBroadcastBitAsynchronousOutputData = _lldb.SBCommandInterpreter_eBroadcastBitAsynchronousOutputData
    
    eBroadcastBitAsynchronousErrorData = _lldb.SBCommandInterpreter_eBroadcastBitAsynchronousErrorData
    

    def __init__(self, *args):
        r"""
        __init__(SBCommandInterpreter self) -> SBCommandInterpreter
        __init__(SBCommandInterpreter self, SBCommandInterpreter rhs) -> SBCommandInterpreter
        """
        _lldb.SBCommandInterpreter_swiginit(self, _lldb.new_SBCommandInterpreter(*args))
    __swig_destroy__ = _lldb.delete_SBCommandInterpreter

    @staticmethod
    def GetArgumentTypeAsCString(arg_type):
        r"""GetArgumentTypeAsCString(lldb::CommandArgumentType const arg_type) -> char const *"""
        return _lldb.SBCommandInterpreter_GetArgumentTypeAsCString(arg_type)

    @staticmethod
    def GetArgumentDescriptionAsCString(arg_type):
        r"""GetArgumentDescriptionAsCString(lldb::CommandArgumentType const arg_type) -> char const *"""
        return _lldb.SBCommandInterpreter_GetArgumentDescriptionAsCString(arg_type)

    @staticmethod
    def EventIsCommandInterpreterEvent(event):
        r"""EventIsCommandInterpreterEvent(SBEvent event) -> bool"""
        return _lldb.SBCommandInterpreter_EventIsCommandInterpreterEvent(event)

    def __nonzero__(self):
        return _lldb.SBCommandInterpreter___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBCommandInterpreter self) -> bool"""
        return _lldb.SBCommandInterpreter_IsValid(self)

    def CommandExists(self, cmd):
        r"""
        Return whether a built-in command with the passed in
        name or command path exists.

        :type cmd: string, in
        :param cmd:
              The command or command path to search for.

        :rtype: boolean
        :return: 
              **true** if the command exists, **false** otherwise.
        """
        return _lldb.SBCommandInterpreter_CommandExists(self, cmd)

    def UserCommandExists(self, cmd):
        r"""
        Return whether a user defined command with the passed in
        name or command path exists.

        :type cmd: string, in
        :param cmd:
              The command or command path to search for.

        :rtype: boolean
        :return: 
              **true** if the command exists, **false** otherwise.
        """
        return _lldb.SBCommandInterpreter_UserCommandExists(self, cmd)

    def AliasExists(self, cmd):
        r"""
        Return whether the passed in name or command path
        exists and is an alias to some other command.

        :type cmd: string, in
        :param cmd:
              The command or command path to search for.

        :rtype: boolean
        :return: 
              **true** if the command exists, **false** otherwise.
        """
        return _lldb.SBCommandInterpreter_AliasExists(self, cmd)

    def GetBroadcaster(self):
        r"""GetBroadcaster(SBCommandInterpreter self) -> SBBroadcaster"""
        return _lldb.SBCommandInterpreter_GetBroadcaster(self)

    @staticmethod
    def GetBroadcasterClass():
        r"""GetBroadcasterClass() -> char const *"""
        return _lldb.SBCommandInterpreter_GetBroadcasterClass()

    def HasCommands(self):
        r"""HasCommands(SBCommandInterpreter self) -> bool"""
        return _lldb.SBCommandInterpreter_HasCommands(self)

    def HasAliases(self):
        r"""HasAliases(SBCommandInterpreter self) -> bool"""
        return _lldb.SBCommandInterpreter_HasAliases(self)

    def HasAliasOptions(self):
        r"""HasAliasOptions(SBCommandInterpreter self) -> bool"""
        return _lldb.SBCommandInterpreter_HasAliasOptions(self)

    def IsInteractive(self):
        r"""IsInteractive(SBCommandInterpreter self) -> bool"""
        return _lldb.SBCommandInterpreter_IsInteractive(self)

    def GetProcess(self):
        r"""GetProcess(SBCommandInterpreter self) -> SBProcess"""
        return _lldb.SBCommandInterpreter_GetProcess(self)

    def GetDebugger(self):
        r"""GetDebugger(SBCommandInterpreter self) -> SBDebugger"""
        return _lldb.SBCommandInterpreter_GetDebugger(self)

    def SourceInitFileInHomeDirectory(self, *args):
        r"""
        SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result)
        SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result, bool is_repl)
        """
        return _lldb.SBCommandInterpreter_SourceInitFileInHomeDirectory(self, *args)

    def SourceInitFileInCurrentWorkingDirectory(self, result):
        r"""SourceInitFileInCurrentWorkingDirectory(SBCommandInterpreter self, SBCommandReturnObject result)"""
        return _lldb.SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(self, result)

    def HandleCommand(self, *args):
        r"""
        HandleCommand(SBCommandInterpreter self, char const * command_line, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus
        HandleCommand(SBCommandInterpreter self, char const * command_line, SBExecutionContext exe_ctx, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus
        """
        return _lldb.SBCommandInterpreter_HandleCommand(self, *args)

    def HandleCommandsFromFile(self, file, override_context, options, result):
        r"""HandleCommandsFromFile(SBCommandInterpreter self, SBFileSpec file, SBExecutionContext override_context, SBCommandInterpreterRunOptions options, SBCommandReturnObject result)"""
        return _lldb.SBCommandInterpreter_HandleCommandsFromFile(self, file, override_context, options, result)

    def HandleCompletion(self, current_line, cursor_pos, match_start_point, max_return_elements, matches):
        r"""HandleCompletion(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList matches) -> int"""
        return _lldb.SBCommandInterpreter_HandleCompletion(self, current_line, cursor_pos, match_start_point, max_return_elements, matches)

    def HandleCompletionWithDescriptions(self, current_line, cursor_pos, match_start_point, max_return_elements, matches, descriptions):
        r"""HandleCompletionWithDescriptions(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, int max_return_elements, SBStringList matches, SBStringList descriptions) -> int"""
        return _lldb.SBCommandInterpreter_HandleCompletionWithDescriptions(self, current_line, cursor_pos, match_start_point, max_return_elements, matches, descriptions)

    def WasInterrupted(self):
        r"""
        Returns whether an interrupt flag was raised either by the SBDebugger -
        when the function is not running on the RunCommandInterpreter thread, or
        by SBCommandInterpreter::InterruptCommand if it is.  If your code is doing
        interruptible work, check this API periodically, and interrupt if it
        returns true.
        """
        return _lldb.SBCommandInterpreter_WasInterrupted(self)

    def InterruptCommand(self):
        r"""
        Interrupts the command currently executing in the RunCommandInterpreter
        thread.

        :rtype: boolean
        :return: 
              **true** if there was a command in progress to recieve the interrupt.
              **false** if there's no command currently in flight.
        """
        return _lldb.SBCommandInterpreter_InterruptCommand(self)

    def SetCommandOverrideCallback(self, command_name, callback):
        r"""SetCommandOverrideCallback(SBCommandInterpreter self, char const * command_name, lldb::CommandOverrideCallback callback) -> bool"""
        return _lldb.SBCommandInterpreter_SetCommandOverrideCallback(self, command_name, callback)

    def IsActive(self):
        r"""
        Return true if the command interpreter is the active IO handler.

        This indicates that any input coming into the debugger handles will
        go to the command interpreter and will result in LLDB command line
        commands being executed.
        """
        return _lldb.SBCommandInterpreter_IsActive(self)

    def GetIOHandlerControlSequence(self, ch):
        r"""
        Get the string that needs to be written to the debugger stdin file
        handle when a control character is typed.

        Some GUI programs will intercept "control + char" sequences and want
        to have them do what normally would happen when using a real
        terminal, so this function allows GUI programs to emulate this
        functionality.

        :type ch: char, in
        :param ch:
                The character that was typed along with the control key

        :rtype: string
        :return: 
                The string that should be written into the file handle that is
                feeding the input stream for the debugger, or nullptr if there is
                no string for this control key.
        """
        return _lldb.SBCommandInterpreter_GetIOHandlerControlSequence(self, ch)

    def GetPromptOnQuit(self):
        r"""GetPromptOnQuit(SBCommandInterpreter self) -> bool"""
        return _lldb.SBCommandInterpreter_GetPromptOnQuit(self)

    def SetPromptOnQuit(self, b):
        r"""SetPromptOnQuit(SBCommandInterpreter self, bool b)"""
        return _lldb.SBCommandInterpreter_SetPromptOnQuit(self, b)

    def AllowExitCodeOnQuit(self, allow):
        r"""
        Sets whether the command interpreter should allow custom exit codes
        for the 'quit' command.
        """
        return _lldb.SBCommandInterpreter_AllowExitCodeOnQuit(self, allow)

    def HasCustomQuitExitCode(self):
        r"""
        Returns true if the user has called the 'quit' command with a custom exit
        code.
        """
        return _lldb.SBCommandInterpreter_HasCustomQuitExitCode(self)

    def GetQuitStatus(self):
        r"""
        Returns the exit code that the user has specified when running the
        'quit' command. Returns 0 if the user hasn't called 'quit' at all or
        without a custom exit code.
        """
        return _lldb.SBCommandInterpreter_GetQuitStatus(self)

    def ResolveCommand(self, command_line, result):
        r"""
        Resolve the command just as HandleCommand would, expanding abbreviations
        and aliases.  If successful, result->GetOutput has the full expansion.
        """
        return _lldb.SBCommandInterpreter_ResolveCommand(self, command_line, result)

    def GetStatistics(self):
        r"""GetStatistics(SBCommandInterpreter self) -> SBStructuredData"""
        return _lldb.SBCommandInterpreter_GetStatistics(self)

    def GetTranscript(self):
        r"""
        Returns a list of handled commands, output and error. Each element in
        the list is a dictionary with the following keys/values:
        - "command" (string): The command that was given by the user.
        - "commandName" (string): The name of the executed command.
        - "commandArguments" (string): The arguments of the executed command.
        - "output" (string): The output of the command. Empty ("") if no output.
        - "error" (string): The error of the command. Empty ("") if no error.
        - "durationInSeconds" (float): The time it took to execute the command.
        - "timestampInEpochSeconds" (int): The timestamp when the command is
          executed.

        Turn on settings `interpreter.save-transcript` for LLDB to populate
        this list. Otherwise this list is empty.
        """
        return _lldb.SBCommandInterpreter_GetTranscript(self)

    def SetPrintCallback(self, callback):
        r"""SetPrintCallback(SBCommandInterpreter self, lldb::SBCommandPrintCallback callback)"""
        return _lldb.SBCommandInterpreter_SetPrintCallback(self, callback)

# Register SBCommandInterpreter in _lldb:
_lldb.SBCommandInterpreter_swigregister(SBCommandInterpreter)
class SBCommandInterpreterRunOptions(object):
    r"""
    SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.

    A default SBCommandInterpreterRunOptions object has:

    * StopOnContinue: false
    * StopOnError:    false
    * StopOnCrash:    false
    * EchoCommands:   true
    * PrintResults:   true
    * PrintErrors:    true
    * AddToHistory:   true
    * AllowRepeats    false

    Interactive debug sessions always allow repeats, the AllowRepeats
    run option only affects non-interactive sessions.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBCommandInterpreterRunOptions self) -> SBCommandInterpreterRunOptions
        __init__(SBCommandInterpreterRunOptions self, SBCommandInterpreterRunOptions rhs) -> SBCommandInterpreterRunOptions
        """
        _lldb.SBCommandInterpreterRunOptions_swiginit(self, _lldb.new_SBCommandInterpreterRunOptions(*args))
    __swig_destroy__ = _lldb.delete_SBCommandInterpreterRunOptions

    def GetStopOnContinue(self):
        r"""GetStopOnContinue(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetStopOnContinue(self)

    def SetStopOnContinue(self, arg2):
        r"""SetStopOnContinue(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetStopOnContinue(self, arg2)

    def GetStopOnError(self):
        r"""GetStopOnError(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetStopOnError(self)

    def SetStopOnError(self, arg2):
        r"""SetStopOnError(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetStopOnError(self, arg2)

    def GetStopOnCrash(self):
        r"""GetStopOnCrash(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetStopOnCrash(self)

    def SetStopOnCrash(self, arg2):
        r"""SetStopOnCrash(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetStopOnCrash(self, arg2)

    def GetEchoCommands(self):
        r"""GetEchoCommands(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetEchoCommands(self)

    def SetEchoCommands(self, arg2):
        r"""SetEchoCommands(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetEchoCommands(self, arg2)

    def GetEchoCommentCommands(self):
        r"""GetEchoCommentCommands(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetEchoCommentCommands(self)

    def SetEchoCommentCommands(self, echo):
        r"""SetEchoCommentCommands(SBCommandInterpreterRunOptions self, bool echo)"""
        return _lldb.SBCommandInterpreterRunOptions_SetEchoCommentCommands(self, echo)

    def GetPrintResults(self):
        r"""GetPrintResults(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetPrintResults(self)

    def SetPrintResults(self, arg2):
        r"""SetPrintResults(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetPrintResults(self, arg2)

    def GetPrintErrors(self):
        r"""GetPrintErrors(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetPrintErrors(self)

    def SetPrintErrors(self, arg2):
        r"""SetPrintErrors(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetPrintErrors(self, arg2)

    def GetAddToHistory(self):
        r"""GetAddToHistory(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetAddToHistory(self)

    def SetAddToHistory(self, arg2):
        r"""SetAddToHistory(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetAddToHistory(self, arg2)

    def GetAutoHandleEvents(self):
        r"""GetAutoHandleEvents(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetAutoHandleEvents(self)

    def SetAutoHandleEvents(self, arg2):
        r"""SetAutoHandleEvents(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetAutoHandleEvents(self, arg2)

    def GetSpawnThread(self):
        r"""GetSpawnThread(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetSpawnThread(self)

    def SetSpawnThread(self, arg2):
        r"""SetSpawnThread(SBCommandInterpreterRunOptions self, bool arg2)"""
        return _lldb.SBCommandInterpreterRunOptions_SetSpawnThread(self, arg2)

    def GetAllowRepeats(self):
        r"""GetAllowRepeats(SBCommandInterpreterRunOptions self) -> bool"""
        return _lldb.SBCommandInterpreterRunOptions_GetAllowRepeats(self)

    def SetAllowRepeats(self, arg2):
        r"""
        By default, RunCommandInterpreter will discard repeats if the
        IOHandler being used is not interactive.  Setting AllowRepeats to true
        will override this behavior and always process empty lines in the input
        as a repeat command.
        """
        return _lldb.SBCommandInterpreterRunOptions_SetAllowRepeats(self, arg2)

# Register SBCommandInterpreterRunOptions in _lldb:
_lldb.SBCommandInterpreterRunOptions_swigregister(SBCommandInterpreterRunOptions)
class SBCommandReturnObject(object):
    r"""
    Represents a container which holds the result from command execution.
    It works with :py:class:`SBCommandInterpreter.HandleCommand()` to encapsulate the result
    of command execution.

    See :py:class:`SBCommandInterpreter` for example usage of SBCommandReturnObject.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBCommandReturnObject self) -> SBCommandReturnObject
        __init__(SBCommandReturnObject self, SBCommandReturnObject rhs) -> SBCommandReturnObject
        """
        _lldb.SBCommandReturnObject_swiginit(self, _lldb.new_SBCommandReturnObject(*args))
    __swig_destroy__ = _lldb.delete_SBCommandReturnObject

    def __nonzero__(self):
        return _lldb.SBCommandReturnObject___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBCommandReturnObject self) -> bool"""
        return _lldb.SBCommandReturnObject_IsValid(self)

    def GetCommand(self):
        r"""
        Get the command as the user typed it. Empty string if commands were run on
        behalf of lldb.
        """
        return _lldb.SBCommandReturnObject_GetCommand(self)

    def GetErrorData(self):
        r"""GetErrorData(SBCommandReturnObject self) -> SBStructuredData"""
        return _lldb.SBCommandReturnObject_GetErrorData(self)

    def PutOutput(self, *args):
        r"""
        PutOutput(SBCommandReturnObject self, SBFile file) -> size_t
        PutOutput(SBCommandReturnObject self, lldb::FileSP BORROWED) -> size_t
        """
        return _lldb.SBCommandReturnObject_PutOutput(self, *args)

    def GetOutputSize(self):
        r"""GetOutputSize(SBCommandReturnObject self) -> size_t"""
        return _lldb.SBCommandReturnObject_GetOutputSize(self)

    def GetErrorSize(self):
        r"""GetErrorSize(SBCommandReturnObject self) -> size_t"""
        return _lldb.SBCommandReturnObject_GetErrorSize(self)

    def PutError(self, *args):
        r"""
        PutError(SBCommandReturnObject self, SBFile file) -> size_t
        PutError(SBCommandReturnObject self, lldb::FileSP BORROWED) -> size_t
        """
        return _lldb.SBCommandReturnObject_PutError(self, *args)

    def Clear(self):
        r"""Clear(SBCommandReturnObject self)"""
        return _lldb.SBCommandReturnObject_Clear(self)

    def GetStatus(self):
        r"""GetStatus(SBCommandReturnObject self) -> lldb::ReturnStatus"""
        return _lldb.SBCommandReturnObject_GetStatus(self)

    def SetStatus(self, status):
        r"""SetStatus(SBCommandReturnObject self, lldb::ReturnStatus status)"""
        return _lldb.SBCommandReturnObject_SetStatus(self, status)

    def Succeeded(self):
        r"""Succeeded(SBCommandReturnObject self) -> bool"""
        return _lldb.SBCommandReturnObject_Succeeded(self)

    def HasResult(self):
        r"""HasResult(SBCommandReturnObject self) -> bool"""
        return _lldb.SBCommandReturnObject_HasResult(self)

    def AppendMessage(self, message):
        r"""AppendMessage(SBCommandReturnObject self, char const * message)"""
        return _lldb.SBCommandReturnObject_AppendMessage(self, message)

    def AppendWarning(self, message):
        r"""AppendWarning(SBCommandReturnObject self, char const * message)"""
        return _lldb.SBCommandReturnObject_AppendWarning(self, message)

    def GetDescription(self, description):
        r"""GetDescription(SBCommandReturnObject self, SBStream description) -> bool"""
        return _lldb.SBCommandReturnObject_GetDescription(self, description)

    def PutCString(self, string):
        r"""PutCString(SBCommandReturnObject self, char const * string)"""
        return _lldb.SBCommandReturnObject_PutCString(self, string)

    def GetOutput(self, *args):
        r"""
        GetOutput(SBCommandReturnObject self) -> char const
        GetOutput(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *
        """
        return _lldb.SBCommandReturnObject_GetOutput(self, *args)

    def GetError(self, *args):
        r"""
        GetError(SBCommandReturnObject self) -> char const
        GetError(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *
        """
        return _lldb.SBCommandReturnObject_GetError(self, *args)

    def SetError(self, *args):
        r"""
        SetError(SBCommandReturnObject self, SBError error, char const * fallback_error_cstr=None)
        SetError(SBCommandReturnObject self, char const * error_cstr)
        """
        return _lldb.SBCommandReturnObject_SetError(self, *args)

    def GetValues(self, use_dynamic):
        r"""GetValues(SBCommandReturnObject self, lldb::DynamicValueType use_dynamic) -> SBValueList"""
        return _lldb.SBCommandReturnObject_GetValues(self, use_dynamic)

    def __repr__(self):
        r"""__repr__(SBCommandReturnObject self) -> std::string"""
        return _lldb.SBCommandReturnObject___repr__(self)

    def SetImmediateOutputFile(self, *args):
        r"""
        SetImmediateOutputFile(SBCommandReturnObject self, SBFile file)
        SetImmediateOutputFile(SBCommandReturnObject self, lldb::FileSP BORROWED)
        SetImmediateOutputFile(SBCommandReturnObject self, lldb::FileSP BORROWED, bool transfer_ownership)
        """
        return _lldb.SBCommandReturnObject_SetImmediateOutputFile(self, *args)

    def SetImmediateErrorFile(self, *args):
        r"""
        SetImmediateErrorFile(SBCommandReturnObject self, SBFile file)
        SetImmediateErrorFile(SBCommandReturnObject self, lldb::FileSP BORROWED)
        SetImmediateErrorFile(SBCommandReturnObject self, lldb::FileSP BORROWED, bool transfer_ownership)
        """
        return _lldb.SBCommandReturnObject_SetImmediateErrorFile(self, *args)

    def Print(self, str):
        r"""Print(SBCommandReturnObject self, char const * str)"""
        return _lldb.SBCommandReturnObject_Print(self, str)

    def write(self, str):
        r"""write(SBCommandReturnObject self, char const * str)"""
        return _lldb.SBCommandReturnObject_write(self, str)

    def flush(self):
        r"""flush(SBCommandReturnObject self)"""
        return _lldb.SBCommandReturnObject_flush(self)

# Register SBCommandReturnObject in _lldb:
_lldb.SBCommandReturnObject_swigregister(SBCommandReturnObject)
class SBCommunication(object):
    r"""Allows sending/receiving data."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    eBroadcastBitDisconnected = _lldb.SBCommunication_eBroadcastBitDisconnected
    r"""Sent when the communications connection is lost."""
    eBroadcastBitReadThreadGotBytes = _lldb.SBCommunication_eBroadcastBitReadThreadGotBytes
    r"""Sent by the read thread when bytes become available."""
    eBroadcastBitReadThreadDidExit = _lldb.SBCommunication_eBroadcastBitReadThreadDidExit
    r"""Sent by the read thread when it exits to inform clients."""
    eBroadcastBitReadThreadShouldExit = _lldb.SBCommunication_eBroadcastBitReadThreadShouldExit
    r"""Sent by clients that need to cancel the read thread."""
    eBroadcastBitPacketAvailable = _lldb.SBCommunication_eBroadcastBitPacketAvailable
    r"""Sent when data received makes a complete packet."""
    eAllEventBits = _lldb.SBCommunication_eAllEventBits
    

    def __init__(self, *args):
        r"""
        __init__(SBCommunication self) -> SBCommunication
        __init__(SBCommunication self, char const * broadcaster_name) -> SBCommunication
        """
        _lldb.SBCommunication_swiginit(self, _lldb.new_SBCommunication(*args))
    __swig_destroy__ = _lldb.delete_SBCommunication

    def __nonzero__(self):
        return _lldb.SBCommunication___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBCommunication self) -> bool"""
        return _lldb.SBCommunication_IsValid(self)

    def GetBroadcaster(self):
        r"""GetBroadcaster(SBCommunication self) -> SBBroadcaster"""
        return _lldb.SBCommunication_GetBroadcaster(self)

    @staticmethod
    def GetBroadcasterClass():
        r"""GetBroadcasterClass() -> char const *"""
        return _lldb.SBCommunication_GetBroadcasterClass()

    def AdoptFileDesriptor(self, fd, owns_fd):
        r"""AdoptFileDesriptor(SBCommunication self, int fd, bool owns_fd) -> lldb::ConnectionStatus"""
        return _lldb.SBCommunication_AdoptFileDesriptor(self, fd, owns_fd)

    def Connect(self, url):
        r"""Connect(SBCommunication self, char const * url) -> lldb::ConnectionStatus"""
        return _lldb.SBCommunication_Connect(self, url)

    def Disconnect(self):
        r"""Disconnect(SBCommunication self) -> lldb::ConnectionStatus"""
        return _lldb.SBCommunication_Disconnect(self)

    def IsConnected(self):
        r"""IsConnected(SBCommunication self) -> bool"""
        return _lldb.SBCommunication_IsConnected(self)

    def GetCloseOnEOF(self):
        r"""GetCloseOnEOF(SBCommunication self) -> bool"""
        return _lldb.SBCommunication_GetCloseOnEOF(self)

    def SetCloseOnEOF(self, b):
        r"""SetCloseOnEOF(SBCommunication self, bool b)"""
        return _lldb.SBCommunication_SetCloseOnEOF(self, b)

    def Read(self, dst, dst_len, timeout_usec, status):
        r"""Read(SBCommunication self, void * dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus & status) -> size_t"""
        return _lldb.SBCommunication_Read(self, dst, dst_len, timeout_usec, status)

    def Write(self, src, src_len, status):
        r"""Write(SBCommunication self, void const * src, size_t src_len, lldb::ConnectionStatus & status) -> size_t"""
        return _lldb.SBCommunication_Write(self, src, src_len, status)

    def ReadThreadStart(self):
        r"""ReadThreadStart(SBCommunication self) -> bool"""
        return _lldb.SBCommunication_ReadThreadStart(self)

    def ReadThreadStop(self):
        r"""ReadThreadStop(SBCommunication self) -> bool"""
        return _lldb.SBCommunication_ReadThreadStop(self)

    def ReadThreadIsRunning(self):
        r"""ReadThreadIsRunning(SBCommunication self) -> bool"""
        return _lldb.SBCommunication_ReadThreadIsRunning(self)

    def SetReadThreadBytesReceivedCallback(self, callback, callback_baton):
        r"""SetReadThreadBytesReceivedCallback(SBCommunication self, lldb::SBCommunication::ReadThreadBytesReceived callback, void * callback_baton) -> bool"""
        return _lldb.SBCommunication_SetReadThreadBytesReceivedCallback(self, callback, callback_baton)

# Register SBCommunication in _lldb:
_lldb.SBCommunication_swigregister(SBCommunication)
class SBCompileUnit(object):
    r"""
    Represents a compilation unit, or compiled source file.

    SBCompileUnit supports line entry iteration. For example,::

        # Now get the SBSymbolContext from this frame.  We want everything. :-)
        context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
        ...

        compileUnit = context.GetCompileUnit()

        for lineEntry in compileUnit:
            print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
                                        lineEntry.GetLine()))
            print('start addr: %s' % str(lineEntry.GetStartAddress()))
            print('end   addr: %s' % str(lineEntry.GetEndAddress()))

    produces: ::

      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
      start addr: a.out[0x100000d98]
      end   addr: a.out[0x100000da3]
      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
      start addr: a.out[0x100000da3]
      end   addr: a.out[0x100000da9]
      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
      start addr: a.out[0x100000da9]
      end   addr: a.out[0x100000db6]
      line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
      start addr: a.out[0x100000db6]
      end   addr: a.out[0x100000dbc]
      ...

    See also :py:class:`SBSymbolContext` and :py:class:`SBLineEntry`
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBCompileUnit self) -> SBCompileUnit
        __init__(SBCompileUnit self, SBCompileUnit rhs) -> SBCompileUnit
        """
        _lldb.SBCompileUnit_swiginit(self, _lldb.new_SBCompileUnit(*args))
    __swig_destroy__ = _lldb.delete_SBCompileUnit

    def __nonzero__(self):
        return _lldb.SBCompileUnit___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBCompileUnit self) -> bool"""
        return _lldb.SBCompileUnit_IsValid(self)

    def GetFileSpec(self):
        r"""GetFileSpec(SBCompileUnit self) -> SBFileSpec"""
        return _lldb.SBCompileUnit_GetFileSpec(self)

    def GetNumLineEntries(self):
        r"""GetNumLineEntries(SBCompileUnit self) -> uint32_t"""
        return _lldb.SBCompileUnit_GetNumLineEntries(self)

    def GetLineEntryAtIndex(self, idx):
        r"""GetLineEntryAtIndex(SBCompileUnit self, uint32_t idx) -> SBLineEntry"""
        return _lldb.SBCompileUnit_GetLineEntryAtIndex(self, idx)

    def FindLineEntryIndex(self, *args):
        r"""
        FindLineEntryIndex(SBCompileUnit self, SBLineEntry line_entry, bool exact=False) -> uint32_t
        FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec) -> uint32_t
        FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec, bool exact) -> uint32_t

             Get the index for a provided line entry in this compile unit.

             @param[in] line_entry
                The SBLineEntry object for which we are looking for the index.

             @param[in] exact
                An optional boolean defaulting to false that ensures that the provided
                line entry has a perfect match in the compile unit.

             @return
                The index of the user-provided line entry. UINT32_MAX if the line entry
                was not found in the compile unit.
        """
        return _lldb.SBCompileUnit_FindLineEntryIndex(self, *args)

    def GetSupportFileAtIndex(self, idx):
        r"""GetSupportFileAtIndex(SBCompileUnit self, uint32_t idx) -> SBFileSpec"""
        return _lldb.SBCompileUnit_GetSupportFileAtIndex(self, idx)

    def GetNumSupportFiles(self):
        r"""GetNumSupportFiles(SBCompileUnit self) -> uint32_t"""
        return _lldb.SBCompileUnit_GetNumSupportFiles(self)

    def FindSupportFileIndex(self, start_idx, sb_file, full):
        r"""FindSupportFileIndex(SBCompileUnit self, uint32_t start_idx, SBFileSpec sb_file, bool full) -> uint32_t"""
        return _lldb.SBCompileUnit_FindSupportFileIndex(self, start_idx, sb_file, full)

    def GetTypes(self, *args):
        r"""
        GetTypes(SBCompileUnit self, uint32_t type_mask=eTypeClassAny) -> 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
        """
        return _lldb.SBCompileUnit_GetTypes(self, *args)

    def GetLanguage(self):
        r"""GetLanguage(SBCompileUnit self) -> lldb::LanguageType"""
        return _lldb.SBCompileUnit_GetLanguage(self)

    def __eq__(self, rhs):
        r"""__eq__(SBCompileUnit self, SBCompileUnit rhs) -> bool"""
        return _lldb.SBCompileUnit___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBCompileUnit self, SBCompileUnit rhs) -> bool"""
        return _lldb.SBCompileUnit___ne__(self, rhs)

    def GetDescription(self, description):
        r"""GetDescription(SBCompileUnit self, SBStream description) -> bool"""
        return _lldb.SBCompileUnit_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBCompileUnit self) -> std::string"""
        return _lldb.SBCompileUnit___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __iter__(self):
        '''Iterate over all line entries in a lldb.SBCompileUnit object.'''
        return lldb_iter(self, 'GetNumLineEntries', 'GetLineEntryAtIndex')

    def __len__(self):
        '''Return the number of line entries in a lldb.SBCompileUnit
        object.'''
        return self.GetNumLineEntries()

    file = property(GetFileSpec, None, doc='''A read only property that returns the same result an lldb object that represents the source file (lldb.SBFileSpec) for the compile unit.''')
    num_line_entries = property(GetNumLineEntries, None, doc='''A read only property that returns the number of line entries in a compile unit as an integer.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBCompileUnit in _lldb:
_lldb.SBCompileUnit_swigregister(SBCompileUnit)
class SBSaveCoreOptions(object):
    r"""
    A container to specify how to save a core file.

    SBSaveCoreOptions includes API's to specify the memory regions and threads to include
    when generating a core file. It extends the existing SaveCoreStyle option.

    * eSaveCoreFull will save off all thread and memory regions, ignoring the memory regions and threads in the options object.

    * eSaveCoreDirtyOnly pages will capture all threads and all rw- memory regions, in addition to the regions specified in the options object if they are not already captured.

    * eSaveCoreStackOnly will capture all threads, but no memory regions unless specified.

    * eSaveCoreCustomOnly Custom defers entirely to the SBSaveCoreOptions object and will only save what is specified. Picking custom and specifying nothing will result in an error being returned.

    Note that currently ELF Core files are not supported.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBSaveCoreOptions self) -> SBSaveCoreOptions
        __init__(SBSaveCoreOptions self, SBSaveCoreOptions rhs) -> SBSaveCoreOptions
        """
        _lldb.SBSaveCoreOptions_swiginit(self, _lldb.new_SBSaveCoreOptions(*args))
    __swig_destroy__ = _lldb.delete_SBSaveCoreOptions

    def SetPluginName(self, plugin):
        r"""
        SetPluginName(SBSaveCoreOptions self, char const * plugin) -> SBError

            Set the plugin name to save a Core file with. Only plugins registered with Plugin manager will be accepted
            Examples are Minidump and Mach-O.
        """
        return _lldb.SBSaveCoreOptions_SetPluginName(self, plugin)

    def GetPluginName(self):
        r"""
        GetPluginName(SBSaveCoreOptions self) -> char const *

            Get the specified plugin name, or None if the name is not set.
        """
        return _lldb.SBSaveCoreOptions_GetPluginName(self)

    def SetStyle(self, style):
        r"""
        SetStyle(SBSaveCoreOptions self, lldb::SaveCoreStyle style)

            Set the lldb.SaveCoreStyle.
        """
        return _lldb.SBSaveCoreOptions_SetStyle(self, style)

    def GetStyle(self):
        r"""
        GetStyle(SBSaveCoreOptions self) -> lldb::SaveCoreStyle

            Get the specified lldb.SaveCoreStyle, or eSaveCoreUnspecified if not set.
        """
        return _lldb.SBSaveCoreOptions_GetStyle(self)

    def SetOutputFile(self, output_file):
        r"""
        SetOutputFile(SBSaveCoreOptions self, SBFileSpec output_file)

            Set the file path to save the Core file at.
        """
        return _lldb.SBSaveCoreOptions_SetOutputFile(self, output_file)

    def GetOutputFile(self):
        r"""
        GetOutputFile(SBSaveCoreOptions self) -> SBFileSpec

            Get an SBFileSpec corresponding to the specified output path, or none if not set.
        """
        return _lldb.SBSaveCoreOptions_GetOutputFile(self)

    def SetProcess(self, process):
        r"""
        SetProcess(SBSaveCoreOptions self, SBProcess process) -> SBError

            Set the process to save, or unset a process by providing a default SBProcess. 
            Resetting will result in the reset of all process specific options, such as Threads to save.
        """
        return _lldb.SBSaveCoreOptions_SetProcess(self, process)

    def AddThread(self, thread):
        r"""
        AddThread(SBSaveCoreOptions self, SBThread thread) -> SBError

            Add an SBThread to be saved, an error will be returned if an SBThread from a different process is specified. 
            The process is set either by the first SBThread added to the options container, or explicitly by the SetProcess call.
        """
        return _lldb.SBSaveCoreOptions_AddThread(self, thread)

    def RemoveThread(self, thread):
        r"""
        RemoveThread(SBSaveCoreOptions self, SBThread thread) -> bool

            Remove an SBthread if present in the container, returns true if a matching thread was found and removed.
        """
        return _lldb.SBSaveCoreOptions_RemoveThread(self, thread)

    def AddMemoryRegionToSave(self, region):
        r"""
        AddMemoryRegionToSave(SBSaveCoreOptions self, SBMemoryRegionInfo region) -> SBError

            Add a memory region to save, an error will be returned in the region is invalid. 
            Ranges that overlap will be unioned into a single region.
        """
        return _lldb.SBSaveCoreOptions_AddMemoryRegionToSave(self, region)

    def GetThreadsToSave(self):
        r"""
        GetThreadsToSave(SBSaveCoreOptions self) -> SBThreadCollection

            Get an SBThreadCollection of all threads marked to be saved. This collection is not sorted according to insertion order.
        """
        return _lldb.SBSaveCoreOptions_GetThreadsToSave(self)

    def GetCurrentSizeInBytes(self, error):
        r"""
        GetCurrentSizeInBytes(SBSaveCoreOptions self, SBError error) -> uint64_t

            Get the current total number of bytes the core is expected to have, excluding the overhead of the core file format.
            Requires both a Process and a Style to be specified. An error will be returned if the provided options would result in no data being saved.
        """
        return _lldb.SBSaveCoreOptions_GetCurrentSizeInBytes(self, error)

    def Clear(self):
        r"""
        Clear(SBSaveCoreOptions self)

            Unset all options.
        """
        return _lldb.SBSaveCoreOptions_Clear(self)

# Register SBSaveCoreOptions in _lldb:
_lldb.SBSaveCoreOptions_swigregister(SBSaveCoreOptions)
class SBData(object):
    r"""Represents a data buffer."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBData self) -> SBData
        __init__(SBData self, SBData rhs) -> SBData
        """
        _lldb.SBData_swiginit(self, _lldb.new_SBData(*args))
    __swig_destroy__ = _lldb.delete_SBData

    def GetAddressByteSize(self):
        r"""GetAddressByteSize(SBData self) -> uint8_t"""
        return _lldb.SBData_GetAddressByteSize(self)

    def SetAddressByteSize(self, addr_byte_size):
        r"""SetAddressByteSize(SBData self, uint8_t addr_byte_size)"""
        return _lldb.SBData_SetAddressByteSize(self, addr_byte_size)

    def Clear(self):
        r"""Clear(SBData self)"""
        return _lldb.SBData_Clear(self)

    def __nonzero__(self):
        return _lldb.SBData___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBData self) -> bool"""
        return _lldb.SBData_IsValid(self)

    def GetByteSize(self):
        r"""GetByteSize(SBData self) -> size_t"""
        return _lldb.SBData_GetByteSize(self)

    def GetByteOrder(self):
        r"""GetByteOrder(SBData self) -> lldb::ByteOrder"""
        return _lldb.SBData_GetByteOrder(self)

    def SetByteOrder(self, endian):
        r"""SetByteOrder(SBData self, lldb::ByteOrder endian)"""
        return _lldb.SBData_SetByteOrder(self, endian)

    def GetFloat(self, error, offset):
        r"""GetFloat(SBData self, SBError error, lldb::offset_t offset) -> float"""
        return _lldb.SBData_GetFloat(self, error, offset)

    def GetDouble(self, error, offset):
        r"""GetDouble(SBData self, SBError error, lldb::offset_t offset) -> double"""
        return _lldb.SBData_GetDouble(self, error, offset)

    def GetLongDouble(self, error, offset):
        r"""GetLongDouble(SBData self, SBError error, lldb::offset_t offset) -> long double"""
        return _lldb.SBData_GetLongDouble(self, error, offset)

    def GetAddress(self, error, offset):
        r"""GetAddress(SBData self, SBError error, lldb::offset_t offset) -> lldb::addr_t"""
        return _lldb.SBData_GetAddress(self, error, offset)

    def GetUnsignedInt8(self, error, offset):
        r"""GetUnsignedInt8(SBData self, SBError error, lldb::offset_t offset) -> uint8_t"""
        return _lldb.SBData_GetUnsignedInt8(self, error, offset)

    def GetUnsignedInt16(self, error, offset):
        r"""GetUnsignedInt16(SBData self, SBError error, lldb::offset_t offset) -> uint16_t"""
        return _lldb.SBData_GetUnsignedInt16(self, error, offset)

    def GetUnsignedInt32(self, error, offset):
        r"""GetUnsignedInt32(SBData self, SBError error, lldb::offset_t offset) -> uint32_t"""
        return _lldb.SBData_GetUnsignedInt32(self, error, offset)

    def GetUnsignedInt64(self, error, offset):
        r"""GetUnsignedInt64(SBData self, SBError error, lldb::offset_t offset) -> uint64_t"""
        return _lldb.SBData_GetUnsignedInt64(self, error, offset)

    def GetSignedInt8(self, error, offset):
        r"""GetSignedInt8(SBData self, SBError error, lldb::offset_t offset) -> int8_t"""
        return _lldb.SBData_GetSignedInt8(self, error, offset)

    def GetSignedInt16(self, error, offset):
        r"""GetSignedInt16(SBData self, SBError error, lldb::offset_t offset) -> int16_t"""
        return _lldb.SBData_GetSignedInt16(self, error, offset)

    def GetSignedInt32(self, error, offset):
        r"""GetSignedInt32(SBData self, SBError error, lldb::offset_t offset) -> int32_t"""
        return _lldb.SBData_GetSignedInt32(self, error, offset)

    def GetSignedInt64(self, error, offset):
        r"""GetSignedInt64(SBData self, SBError error, lldb::offset_t offset) -> int64_t"""
        return _lldb.SBData_GetSignedInt64(self, error, offset)

    def GetString(self, error, offset):
        r"""GetString(SBData self, SBError error, lldb::offset_t offset) -> char const *"""
        return _lldb.SBData_GetString(self, error, offset)

    def ReadRawData(self, error, offset, buf):
        r"""ReadRawData(SBData self, SBError error, lldb::offset_t offset, void * buf) -> size_t"""
        return _lldb.SBData_ReadRawData(self, error, offset, buf)

    def GetDescription(self, *args):
        r"""GetDescription(SBData self, SBStream description, lldb::addr_t base_addr=18446744073709551615ULL) -> bool"""
        return _lldb.SBData_GetDescription(self, *args)

    def SetData(self, error, buf, endian, addr_size):
        r"""SetData(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)"""
        return _lldb.SBData_SetData(self, error, buf, endian, addr_size)

    def SetDataWithOwnership(self, error, buf, endian, addr_size):
        r"""SetDataWithOwnership(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)"""
        return _lldb.SBData_SetDataWithOwnership(self, error, buf, endian, addr_size)

    def Append(self, rhs):
        r"""Append(SBData self, SBData rhs) -> bool"""
        return _lldb.SBData_Append(self, rhs)

    @staticmethod
    def CreateDataFromCString(endian, addr_byte_size, data):
        r"""CreateDataFromCString(lldb::ByteOrder endian, uint32_t addr_byte_size, char const * data) -> SBData"""
        return _lldb.SBData_CreateDataFromCString(endian, addr_byte_size, data)

    @staticmethod
    def CreateDataFromUInt64Array(endian, addr_byte_size, array):
        r"""CreateDataFromUInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t * array) -> SBData"""
        return _lldb.SBData_CreateDataFromUInt64Array(endian, addr_byte_size, array)

    @staticmethod
    def CreateDataFromUInt32Array(endian, addr_byte_size, array):
        r"""CreateDataFromUInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t * array) -> SBData"""
        return _lldb.SBData_CreateDataFromUInt32Array(endian, addr_byte_size, array)

    @staticmethod
    def CreateDataFromSInt64Array(endian, addr_byte_size, array):
        r"""CreateDataFromSInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t * array) -> SBData"""
        return _lldb.SBData_CreateDataFromSInt64Array(endian, addr_byte_size, array)

    @staticmethod
    def CreateDataFromSInt32Array(endian, addr_byte_size, array):
        r"""CreateDataFromSInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t * array) -> SBData"""
        return _lldb.SBData_CreateDataFromSInt32Array(endian, addr_byte_size, array)

    @staticmethod
    def CreateDataFromDoubleArray(endian, addr_byte_size, array):
        r"""CreateDataFromDoubleArray(lldb::ByteOrder endian, uint32_t addr_byte_size, double * array) -> SBData"""
        return _lldb.SBData_CreateDataFromDoubleArray(endian, addr_byte_size, array)

    def SetDataFromCString(self, data):
        r"""SetDataFromCString(SBData self, char const * data) -> bool"""
        return _lldb.SBData_SetDataFromCString(self, data)

    def SetDataFromUInt64Array(self, array):
        r"""SetDataFromUInt64Array(SBData self, uint64_t * array) -> bool"""
        return _lldb.SBData_SetDataFromUInt64Array(self, array)

    def SetDataFromUInt32Array(self, array):
        r"""SetDataFromUInt32Array(SBData self, uint32_t * array) -> bool"""
        return _lldb.SBData_SetDataFromUInt32Array(self, array)

    def SetDataFromSInt64Array(self, array):
        r"""SetDataFromSInt64Array(SBData self, int64_t * array) -> bool"""
        return _lldb.SBData_SetDataFromSInt64Array(self, array)

    def SetDataFromSInt32Array(self, array):
        r"""SetDataFromSInt32Array(SBData self, int32_t * array) -> bool"""
        return _lldb.SBData_SetDataFromSInt32Array(self, array)

    def SetDataFromDoubleArray(self, array):
        r"""SetDataFromDoubleArray(SBData self, double * array) -> bool"""
        return _lldb.SBData_SetDataFromDoubleArray(self, array)

    def __repr__(self):
        r"""__repr__(SBData self) -> std::string"""
        return _lldb.SBData___repr__(self)

    def __len__(self):
        return self.GetByteSize()

    class read_data_helper:
        def __init__(self, sbdata, readerfunc, item_size):
            self.sbdata = sbdata
            self.readerfunc = readerfunc
            self.item_size = item_size
        def __getitem__(self,key):
            if isinstance(key,slice):
                list = []
                for x in range(*key.indices(self.__len__())):
                    list.append(self.__getitem__(x))
                return list
            if not (isinstance(key, int)):
                raise TypeError('must be int')
            key = key * self.item_size # SBData uses byte-based indexes, but we want to use itemsize-based indexes here
            error = SBError()
            my_data = self.readerfunc(self.sbdata,error,key)
            if error.Fail():
                raise IndexError(error.GetCString())
            else:
                return my_data
        def __len__(self):
            return int(self.sbdata.GetByteSize()/self.item_size)
        def all(self):
            return self[0:len(self)]

    @classmethod
    def CreateDataFromInt (cls, value, size = None, target = None, ptr_size = None, endian = None):
        import sys
        lldbmodule = sys.modules[cls.__module__]
        lldbdict = lldbmodule.__dict__
        if 'target' in lldbdict:
            lldbtarget = lldbdict['target']
        else:
            lldbtarget = None
        if target is None and lldbtarget is not None and lldbtarget.IsValid():
            target = lldbtarget
        if ptr_size is None:
            if target and target.IsValid():
                ptr_size = target.addr_size
            else:
                ptr_size = 8
        if endian is None:
            if target and target.IsValid():
                endian = target.byte_order
            else:
                endian = lldbdict['eByteOrderLittle']
        if size is None:
            if value > 2147483647:
                size = 8
            elif value < -2147483648:
                size = 8
            elif value > 4294967295:
                size = 8
            else:
                size = 4
        if size == 4:
            if value < 0:
                return SBData().CreateDataFromSInt32Array(endian, ptr_size, [value])
            return SBData().CreateDataFromUInt32Array(endian, ptr_size, [value])
        if size == 8:
            if value < 0:
                return SBData().CreateDataFromSInt64Array(endian, ptr_size, [value])
            return SBData().CreateDataFromUInt64Array(endian, ptr_size, [value])
        return None

    def _make_helper(self, sbdata, getfunc, itemsize):
        return self.read_data_helper(sbdata, getfunc, itemsize)

    def _make_helper_uint8(self):
        return self._make_helper(self, SBData.GetUnsignedInt8, 1)

    def _make_helper_uint16(self):
        return self._make_helper(self, SBData.GetUnsignedInt16, 2)

    def _make_helper_uint32(self):
        return self._make_helper(self, SBData.GetUnsignedInt32, 4)

    def _make_helper_uint64(self):
        return self._make_helper(self, SBData.GetUnsignedInt64, 8)

    def _make_helper_sint8(self):
        return self._make_helper(self, SBData.GetSignedInt8, 1)

    def _make_helper_sint16(self):
        return self._make_helper(self, SBData.GetSignedInt16, 2)

    def _make_helper_sint32(self):
        return self._make_helper(self, SBData.GetSignedInt32, 4)

    def _make_helper_sint64(self):
        return self._make_helper(self, SBData.GetSignedInt64, 8)

    def _make_helper_float(self):
        return self._make_helper(self, SBData.GetFloat, 4)

    def _make_helper_double(self):
        return self._make_helper(self, SBData.GetDouble, 8)

    def _read_all_uint8(self):
        return self._make_helper_uint8().all()

    def _read_all_uint16(self):
        return self._make_helper_uint16().all()

    def _read_all_uint32(self):
        return self._make_helper_uint32().all()

    def _read_all_uint64(self):
        return self._make_helper_uint64().all()

    def _read_all_sint8(self):
        return self._make_helper_sint8().all()

    def _read_all_sint16(self):
        return self._make_helper_sint16().all()

    def _read_all_sint32(self):
        return self._make_helper_sint32().all()

    def _read_all_sint64(self):
        return self._make_helper_sint64().all()

    def _read_all_float(self):
        return self._make_helper_float().all()

    def _read_all_double(self):
        return self._make_helper_double().all()

    uint8 = property(_make_helper_uint8, None, doc='''A read only property that returns an array-like object out of which you can read uint8 values.''')
    uint16 = property(_make_helper_uint16, None, doc='''A read only property that returns an array-like object out of which you can read uint16 values.''')
    uint32 = property(_make_helper_uint32, None, doc='''A read only property that returns an array-like object out of which you can read uint32 values.''')
    uint64 = property(_make_helper_uint64, None, doc='''A read only property that returns an array-like object out of which you can read uint64 values.''')
    sint8 = property(_make_helper_sint8, None, doc='''A read only property that returns an array-like object out of which you can read sint8 values.''')
    sint16 = property(_make_helper_sint16, None, doc='''A read only property that returns an array-like object out of which you can read sint16 values.''')
    sint32 = property(_make_helper_sint32, None, doc='''A read only property that returns an array-like object out of which you can read sint32 values.''')
    sint64 = property(_make_helper_sint64, None, doc='''A read only property that returns an array-like object out of which you can read sint64 values.''')
    float = property(_make_helper_float, None, doc='''A read only property that returns an array-like object out of which you can read float values.''')
    double = property(_make_helper_double, None, doc='''A read only property that returns an array-like object out of which you can read double values.''')
    uint8s = property(_read_all_uint8, None, doc='''A read only property that returns an array with all the contents of this SBData represented as uint8 values.''')
    uint16s = property(_read_all_uint16, None, doc='''A read only property that returns an array with all the contents of this SBData represented as uint16 values.''')
    uint32s = property(_read_all_uint32, None, doc='''A read only property that returns an array with all the contents of this SBData represented as uint32 values.''')
    uint64s = property(_read_all_uint64, None, doc='''A read only property that returns an array with all the contents of this SBData represented as uint64 values.''')
    sint8s = property(_read_all_sint8, None, doc='''A read only property that returns an array with all the contents of this SBData represented as sint8 values.''')
    sint16s = property(_read_all_sint16, None, doc='''A read only property that returns an array with all the contents of this SBData represented as sint16 values.''')
    sint32s = property(_read_all_sint32, None, doc='''A read only property that returns an array with all the contents of this SBData represented as sint32 values.''')
    sint64s = property(_read_all_sint64, None, doc='''A read only property that returns an array with all the contents of this SBData represented as sint64 values.''')
    floats = property(_read_all_float, None, doc='''A read only property that returns an array with all the contents of this SBData represented as float values.''')
    doubles = property(_read_all_double, None, doc='''A read only property that returns an array with all the contents of this SBData represented as double values.''')
    byte_order = property(GetByteOrder, SetByteOrder, doc='''A read/write property getting and setting the endianness of this SBData (data.byte_order = lldb.eByteOrderLittle).''')
    size = property(GetByteSize, None, doc='''A read only property that returns the size the same result as GetByteSize().''')


# Register SBData in _lldb:
_lldb.SBData_swigregister(SBData)
class SBDebugger(object):
    r"""
    SBDebugger is the primordial object that creates SBTargets and provides
    access to them.  It also manages the overall debugging experiences.

    For example (from example/disasm.py),::

        import lldb
        import os
        import sys

        def disassemble_instructions (insts):
            for i in insts:
                print i

        ...

        # Create a new debugger instance
        debugger = lldb.SBDebugger.Create()

        # When we step or continue, don't return from the function until the process
        # stops. We do this by setting the async mode to false.
        debugger.SetAsync (False)

        # Create a target from a file and arch
        print('Creating a target for '%s'' % exe)

        target = debugger.CreateTargetWithFileAndArch (exe, lldb.LLDB_ARCH_DEFAULT)

        if target:
            # If the target is valid set a breakpoint at main
            main_bp = target.BreakpointCreateByName (fname, target.GetExecutable().GetFilename());

            print main_bp

            # Launch the process. Since we specified synchronous mode, we won't return
            # from this function until we hit the breakpoint at main
            process = target.LaunchSimple (None, None, os.getcwd())

            # Make sure the launch went ok
            if process:
                # Print some simple process info
                state = process.GetState ()
                print process
                if state == lldb.eStateStopped:
                    # Get the first thread
                    thread = process.GetThreadAtIndex (0)
                    if thread:
                        # Print some simple thread info
                        print thread
                        # Get the first frame
                        frame = thread.GetFrameAtIndex (0)
                        if frame:
                            # Print some simple frame info
                            print frame
                            function = frame.GetFunction()
                            # See if we have debug info (a function)
                            if function:
                                # We do have a function, print some info for the function
                                print function
                                # Now get all instructions for this function and print them
                                insts = function.GetInstructions(target)
                                disassemble_instructions (insts)
                            else:
                                # See if we have a symbol in the symbol table for where we stopped
                                symbol = frame.GetSymbol();
                                if symbol:
                                    # We do have a symbol, print some info for the symbol
                                    print symbol
                                    # Now get all instructions for this symbol and print them
                                    insts = symbol.GetInstructions(target)
                                    disassemble_instructions (insts)

                            registerList = frame.GetRegisters()
                            print('Frame registers (size of register set = %d):' % registerList.GetSize())
                            for value in registerList:
                                #print value
                                print('%s (number of children = %d):' % (value.GetName(), value.GetNumChildren()))
                                for child in value:
                                    print('Name: ', child.GetName(), ' Value: ', child.GetValue())

                    print('Hit the breakpoint at main, enter to continue and wait for program to exit or 'Ctrl-D'/'quit' to terminate the program')
                    next = sys.stdin.readline()
                    if not next or next.rstrip('\n') == 'quit':
                        print('Terminating the inferior process...')
                        process.Kill()
                    else:
                        # Now continue to the program exit
                        process.Continue()
                        # When we return from the above function we will hopefully be at the
                        # program exit. Print out some process info
                        print process
                elif state == lldb.eStateExited:
                    print('Didn't hit the breakpoint at main, program has exited...')
                else:
                    print('Unexpected process state: %s, killing process...' % debugger.StateAsCString (state))
                    process.Kill()

    Sometimes you need to create an empty target that will get filled in later.  The most common use for this
    is to attach to a process by name or pid where you don't know the executable up front.  The most convenient way
    to do this is: ::

        target = debugger.CreateTarget('')
        error = lldb.SBError()
        process = target.AttachToProcessWithName(debugger.GetListener(), 'PROCESS_NAME', False, error)

    or the equivalent arguments for :py:class:`SBTarget.AttachToProcessWithID` .
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    eBroadcastBitProgress = _lldb.SBDebugger_eBroadcastBitProgress
    
    eBroadcastBitWarning = _lldb.SBDebugger_eBroadcastBitWarning
    
    eBroadcastBitError = _lldb.SBDebugger_eBroadcastBitError
    
    eBroadcastBitProgressCategory = _lldb.SBDebugger_eBroadcastBitProgressCategory
    
    eBroadcastBitExternalProgress = _lldb.SBDebugger_eBroadcastBitExternalProgress
    
    eBroadcastBitExternalProgressCategory = _lldb.SBDebugger_eBroadcastBitExternalProgressCategory
    

    def __init__(self, *args):
        r"""
        __init__(SBDebugger self) -> SBDebugger
        __init__(SBDebugger self, SBDebugger rhs) -> SBDebugger
        """
        _lldb.SBDebugger_swiginit(self, _lldb.new_SBDebugger(*args))
    __swig_destroy__ = _lldb.delete_SBDebugger

    @staticmethod
    def GetBroadcasterClass():
        r"""Get the broadcaster class name."""
        return _lldb.SBDebugger_GetBroadcasterClass()

    @staticmethod
    def SupportsLanguage(language):
        r"""Check if a specific language is supported by LLDB."""
        return _lldb.SBDebugger_SupportsLanguage(language)

    def GetBroadcaster(self):
        r"""
        Get the broadcaster that allows subscribing to events from this
        debugger.
        """
        return _lldb.SBDebugger_GetBroadcaster(self)

    @staticmethod
    def GetProgressFromEvent(event):
        r"""
        Get progress data from a SBEvent whose type is eBroadcastBitProgress.

        :param [in]: event
              The event to extract the progress information from.

        :param [out]: progress_id
              The unique integer identifier for the progress to report.

        :param [out]: completed
              The amount of work completed. If *completed* is zero, then this event
              is a progress started event. If *completed* is equal to *total*, then
              this event is a progress end event. Otherwise completed indicates the
              current progress update.

        :param [out]: total
              The total amount of work units that need to be completed. If this value
              is UINT64_MAX, then an indeterminate progress indicator should be
              displayed.

        :param [out]: is_debugger_specific
              Set to true if this progress is specific to this debugger only. Many
              progress events are not specific to a debugger instance, like any
              progress events for loading information in modules since LLDB has a
              global module cache that all debuggers use.

        :rtype: string
        :return: The message for the progress. If the returned value is NULL, then
              *event* was not a eBroadcastBitProgress event.
        """
        return _lldb.SBDebugger_GetProgressFromEvent(event)

    @staticmethod
    def GetProgressDataFromEvent(event):
        r"""Get progress data from an event."""
        return _lldb.SBDebugger_GetProgressDataFromEvent(event)

    @staticmethod
    def GetDiagnosticFromEvent(event):
        r"""Get diagnostic information from an event."""
        return _lldb.SBDebugger_GetDiagnosticFromEvent(event)

    @staticmethod
    def Initialize():
        r"""
        Initialize LLDB and its subsystems.

        This function should be called before any other LLDB functions. It
        initializes all required subsystems for proper LLDB functionality.
        """
        return _lldb.SBDebugger_Initialize()

    @staticmethod
    def InitializeWithErrorHandling():
        r"""
        Initialize the LLDB debugger subsystem with error handling.

        Similar to Initialize(), but returns an error if initialization fails.
        """
        return _lldb.SBDebugger_InitializeWithErrorHandling()

    @staticmethod
    def PrintStackTraceOnError():
        r"""Configure LLDB to print a stack trace when it crashes."""
        return _lldb.SBDebugger_PrintStackTraceOnError()

    @staticmethod
    def PrintDiagnosticsOnError():
        r"""Configure LLDB to print diagnostic information when it crashes."""
        return _lldb.SBDebugger_PrintDiagnosticsOnError()

    @staticmethod
    def Terminate():
        r"""
        Terminate LLDB and its subsystems.

        This should be called when LLDB is no longer needed.
        """
        return _lldb.SBDebugger_Terminate()

    @staticmethod
    def Create(*args):
        r"""
        *Overload 1:*
        Create a new debugger instance (deprecated).

        |

        *Overload 2:*
        Create a new debugger instance.

        If source_init_files is true, the debugger will source .lldbinit files
        from the home directory and current directory.

        |

        *Overload 3:*
        Create a new debugger instance with a custom log handler and user data
        passed to the log callback.

        If source_init_files is true, the debugger will source .lldbinit files
        from the home directory and current directory.
        """
        return _lldb.SBDebugger_Create(*args)

    @staticmethod
    def Destroy(debugger):
        r"""Destroy a debugger instance."""
        return _lldb.SBDebugger_Destroy(debugger)

    @staticmethod
    def MemoryPressureDetected():
        r"""
        Notify the debugger that system memory pressure has been detected.

        This can be used to free up memory resources by clearing caches.
        """
        return _lldb.SBDebugger_MemoryPressureDetected()

    def __nonzero__(self):
        return _lldb.SBDebugger___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""Check if this is a valid SBDebugger object."""
        return _lldb.SBDebugger_IsValid(self)

    def Clear(self):
        r"""
        Clear this debugger instance.

        This will close all IO handlers and reset the debugger to its initial
        state.
        """
        return _lldb.SBDebugger_Clear(self)

    def GetSetting(self, setting=None):
        r"""
        Get debugger settings as structured data.

        Client can specify empty string or null to get all settings.

        Example usages:
        lldb::SBStructuredData settings = debugger.GetSetting();
        lldb::SBStructuredData settings = debugger.GetSetting(nullptr);
        lldb::SBStructuredData settings = debugger.GetSetting("");
        lldb::SBStructuredData settings = debugger.GetSetting("target.arg0");
        lldb::SBStructuredData settings = debugger.GetSetting("target");
        """
        return _lldb.SBDebugger_GetSetting(self, setting)

    def SetAsync(self, b):
        r"""
        Set whether the debugger should run in asynchronous mode.

        When in asynchronous mode, events are processed on a background thread.
        """
        return _lldb.SBDebugger_SetAsync(self, b)

    def GetAsync(self):
        r"""Get whether the debugger is running in asynchronous mode."""
        return _lldb.SBDebugger_GetAsync(self)

    def SkipLLDBInitFiles(self, b):
        r"""Set whether to skip loading .lldbinit files."""
        return _lldb.SBDebugger_SkipLLDBInitFiles(self, b)

    def SkipAppInitFiles(self, b):
        r"""Set whether to skip loading application-specific .lldbinit files."""
        return _lldb.SBDebugger_SkipAppInitFiles(self, b)

    def SetInputString(self, data):
        r"""Set the input from a string."""
        return _lldb.SBDebugger_SetInputString(self, data)

    def SetInputFile(self, *args):
        r"""
        *Overload 1:*
        Set the input file for the debugger.

        |

        *Overload 2:*
        Set the input file for the debugger using a FileSP.
        """
        return _lldb.SBDebugger_SetInputFile(self, *args)

    def SetOutputFile(self, *args):
        r"""
        *Overload 1:*
        Set the output file for the debugger.

        |

        *Overload 2:*
        Set the output file for the debugger using a FileSP.
        """
        return _lldb.SBDebugger_SetOutputFile(self, *args)

    def SetErrorFile(self, *args):
        r"""
        *Overload 1:*
        Set the error file for the debugger.

        |

        *Overload 2:*
        Set the error file for the debugger using a FileSP.
        """
        return _lldb.SBDebugger_SetErrorFile(self, *args)

    def GetInputFile(self):
        r"""Get the input file for the debugger."""
        return _lldb.SBDebugger_GetInputFile(self)

    def GetOutputFile(self):
        r"""Get the output file for the debugger."""
        return _lldb.SBDebugger_GetOutputFile(self)

    def GetErrorFile(self):
        r"""Get the error file for the debugger."""
        return _lldb.SBDebugger_GetErrorFile(self)

    def SaveInputTerminalState(self):
        r"""
        Save the current terminal state.

        This should be called before modifying terminal settings.
        """
        return _lldb.SBDebugger_SaveInputTerminalState(self)

    def RestoreInputTerminalState(self):
        r"""Restore the previously saved terminal state."""
        return _lldb.SBDebugger_RestoreInputTerminalState(self)

    def GetCommandInterpreter(self):
        r"""Get the command interpreter for this debugger."""
        return _lldb.SBDebugger_GetCommandInterpreter(self)

    def HandleCommand(self, command):
        r"""Execute a command in the command interpreter."""
        return _lldb.SBDebugger_HandleCommand(self, command)

    def RequestInterrupt(self):
        r"""Request an interrupt of the current operation."""
        return _lldb.SBDebugger_RequestInterrupt(self)

    def CancelInterruptRequest(self):
        r"""Cancel a previously requested interrupt."""
        return _lldb.SBDebugger_CancelInterruptRequest(self)

    def InterruptRequested(self):
        r"""Check if an interrupt has been requested."""
        return _lldb.SBDebugger_InterruptRequested(self)

    def GetListener(self):
        r"""Get the listener associated with this debugger."""
        return _lldb.SBDebugger_GetListener(self)

    def HandleProcessEvent(self, *args):
        r"""
        *Overload 1:*
        Handle a process event.

        |

        *Overload 2:*
        Handle a process event using FileSP objects.
        """
        return _lldb.SBDebugger_HandleProcessEvent(self, *args)

    def CreateTargetWithFileAndTargetTriple(self, filename, target_triple):
        r"""Create a target with the specified file and target triple."""
        return _lldb.SBDebugger_CreateTargetWithFileAndTargetTriple(self, filename, target_triple)

    def CreateTargetWithFileAndArch(self, filename, archname):
        r"""Create a target with the specified file and architecture."""
        return _lldb.SBDebugger_CreateTargetWithFileAndArch(self, filename, archname)

    def CreateTarget(self, *args):
        r"""
        *Overload 1:*
        Create a target with the specified parameters.

        |

        *Overload 2:*
        Create a target with the specified file.
        """
        return _lldb.SBDebugger_CreateTarget(self, *args)

    def GetDummyTarget(self):
        r"""
        GetDummyTarget(SBDebugger self) -> SBTarget
        The dummy target holds breakpoints and breakpoint names that will prime newly created targets.
        """
        return _lldb.SBDebugger_GetDummyTarget(self)

    def DeleteTarget(self, target):
        r"""
        DeleteTarget(SBDebugger self, SBTarget target) -> bool
        Return true if target is deleted from the target list of the debugger.
        """
        return _lldb.SBDebugger_DeleteTarget(self, target)

    def GetTargetAtIndex(self, idx):
        r"""Get a target by index."""
        return _lldb.SBDebugger_GetTargetAtIndex(self, idx)

    def GetIndexOfTarget(self, target):
        r"""Get the index of a target."""
        return _lldb.SBDebugger_GetIndexOfTarget(self, target)

    def FindTargetWithProcessID(self, pid):
        r"""Find a target with the specified process ID."""
        return _lldb.SBDebugger_FindTargetWithProcessID(self, pid)

    def FindTargetWithFileAndArch(self, filename, arch):
        r"""Find a target with the specified file and architecture."""
        return _lldb.SBDebugger_FindTargetWithFileAndArch(self, filename, arch)

    def GetNumTargets(self):
        r"""Get the number of targets in the debugger."""
        return _lldb.SBDebugger_GetNumTargets(self)

    def GetSelectedTarget(self):
        r"""Get the currently selected target."""
        return _lldb.SBDebugger_GetSelectedTarget(self)

    def SetSelectedTarget(self, target):
        r"""Set the selected target."""
        return _lldb.SBDebugger_SetSelectedTarget(self, target)

    def GetSelectedPlatform(self):
        r"""Get the selected platform."""
        return _lldb.SBDebugger_GetSelectedPlatform(self)

    def SetSelectedPlatform(self, platform):
        r"""Set the selected platform."""
        return _lldb.SBDebugger_SetSelectedPlatform(self, platform)

    def GetNumPlatforms(self):
        r"""
        GetNumPlatforms(SBDebugger self) -> uint32_t
        Get the number of currently active platforms.
        """
        return _lldb.SBDebugger_GetNumPlatforms(self)

    def GetPlatformAtIndex(self, idx):
        r"""
        GetPlatformAtIndex(SBDebugger self, uint32_t idx) -> SBPlatform
        Get one of the currently active platforms.
        """
        return _lldb.SBDebugger_GetPlatformAtIndex(self, idx)

    def GetNumAvailablePlatforms(self):
        r"""
        GetNumAvailablePlatforms(SBDebugger self) -> uint32_t
        Get the number of available platforms.
        """
        return _lldb.SBDebugger_GetNumAvailablePlatforms(self)

    def GetAvailablePlatformInfoAtIndex(self, idx):
        r"""
        GetAvailablePlatformInfoAtIndex(SBDebugger self, uint32_t idx) -> SBStructuredData

            Get the name and description of one of the available platforms.

            @param idx Zero-based index of the platform for which info should be
                       retrieved, must be less than the value returned by
                       GetNumAvailablePlatforms().
        """
        return _lldb.SBDebugger_GetAvailablePlatformInfoAtIndex(self, idx)

    def GetSourceManager(self):
        r"""Get the source manager for this debugger."""
        return _lldb.SBDebugger_GetSourceManager(self)

    def SetCurrentPlatform(self, platform_name):
        r"""Set the current platform by name."""
        return _lldb.SBDebugger_SetCurrentPlatform(self, platform_name)

    def SetCurrentPlatformSDKRoot(self, sysroot):
        r"""Set the SDK root for the current platform."""
        return _lldb.SBDebugger_SetCurrentPlatformSDKRoot(self, sysroot)

    def SetUseExternalEditor(self, input):
        r"""Set whether to use an external editor."""
        return _lldb.SBDebugger_SetUseExternalEditor(self, input)

    def GetUseExternalEditor(self):
        r"""Get whether an external editor is being used."""
        return _lldb.SBDebugger_GetUseExternalEditor(self)

    def SetUseColor(self, use_color):
        r"""Set whether to use color in output."""
        return _lldb.SBDebugger_SetUseColor(self, use_color)

    def GetUseColor(self):
        r"""Get whether color is being used in output."""
        return _lldb.SBDebugger_GetUseColor(self)

    def SetShowInlineDiagnostics(self, b):
        r"""Set whether to show inline diagnostics."""
        return _lldb.SBDebugger_SetShowInlineDiagnostics(self, b)

    def SetUseSourceCache(self, use_source_cache):
        r"""Set whether to use the source cache."""
        return _lldb.SBDebugger_SetUseSourceCache(self, use_source_cache)

    def GetUseSourceCache(self):
        r"""Get whether the source cache is being used."""
        return _lldb.SBDebugger_GetUseSourceCache(self)

    @staticmethod
    def GetDefaultArchitecture(arch_name, arch_name_len):
        r"""Get the default architecture."""
        return _lldb.SBDebugger_GetDefaultArchitecture(arch_name, arch_name_len)

    @staticmethod
    def SetDefaultArchitecture(arch_name):
        r"""Set the default architecture."""
        return _lldb.SBDebugger_SetDefaultArchitecture(arch_name)

    def GetScriptingLanguage(self, script_language_name):
        r"""Get the scripting language by name."""
        return _lldb.SBDebugger_GetScriptingLanguage(self, script_language_name)

    def GetScriptInterpreterInfo(self, language):
        r"""Get information about a script interpreter as structured data."""
        return _lldb.SBDebugger_GetScriptInterpreterInfo(self, language)

    @staticmethod
    def GetVersionString():
        r"""Get the LLDB version string."""
        return _lldb.SBDebugger_GetVersionString()

    @staticmethod
    def StateAsCString(state):
        r"""Convert a state type to a string."""
        return _lldb.SBDebugger_StateAsCString(state)

    @staticmethod
    def GetBuildConfiguration():
        r"""Get the build configuration as structured data."""
        return _lldb.SBDebugger_GetBuildConfiguration()

    @staticmethod
    def StateIsRunningState(state):
        r"""Check if a state is a running state."""
        return _lldb.SBDebugger_StateIsRunningState(state)

    @staticmethod
    def StateIsStoppedState(state):
        r"""Check if a state is a stopped state."""
        return _lldb.SBDebugger_StateIsStoppedState(state)

    def EnableLog(self, channel, categories):
        r"""Enable logging for a specific channel and category."""
        return _lldb.SBDebugger_EnableLog(self, channel, categories)

    def SetLoggingCallback(self, log_callback):
        r"""Set a callback for log output."""
        return _lldb.SBDebugger_SetLoggingCallback(self, log_callback)

    def SetDestroyCallback(self, destroy_callback):
        r"""Set a callback for when the debugger is destroyed (deprecated)."""
        return _lldb.SBDebugger_SetDestroyCallback(self, destroy_callback)

    def AddDestroyCallback(self, destroy_callback):
        r"""
        Add a callback for when the debugger is destroyed. Returns a token that
        can be used to remove the callback.
        """
        return _lldb.SBDebugger_AddDestroyCallback(self, destroy_callback)

    def RemoveDestroyCallback(self, token):
        r"""Remove a destroy callback."""
        return _lldb.SBDebugger_RemoveDestroyCallback(self, token)

    def DispatchInput(self, data):
        r"""Dispatch input to the debugger."""
        return _lldb.SBDebugger_DispatchInput(self, data)

    def DispatchInputInterrupt(self):
        r"""Interrupt the current input dispatch."""
        return _lldb.SBDebugger_DispatchInputInterrupt(self)

    def DispatchInputEndOfFile(self):
        r"""Signal end-of-file to the current input dispatch."""
        return _lldb.SBDebugger_DispatchInputEndOfFile(self)

    def GetInstanceName(self):
        r"""Get the instance name of this debugger."""
        return _lldb.SBDebugger_GetInstanceName(self)

    @staticmethod
    def FindDebuggerWithID(id):
        r"""Find a debugger by ID. Returns an invalid debugger if not found."""
        return _lldb.SBDebugger_FindDebuggerWithID(id)

    @staticmethod
    def SetInternalVariable(var_name, value, debugger_instance_name):
        r"""Set an internal variable."""
        return _lldb.SBDebugger_SetInternalVariable(var_name, value, debugger_instance_name)

    @staticmethod
    def GetInternalVariableValue(var_name, debugger_instance_name):
        r"""Get the value of an internal variable."""
        return _lldb.SBDebugger_GetInternalVariableValue(var_name, debugger_instance_name)

    def GetDescription(self, description):
        r"""Get a description of this debugger."""
        return _lldb.SBDebugger_GetDescription(self, description)

    def GetTerminalWidth(self):
        r"""Get the terminal width."""
        return _lldb.SBDebugger_GetTerminalWidth(self)

    def SetTerminalWidth(self, term_width):
        r"""Set the terminal width."""
        return _lldb.SBDebugger_SetTerminalWidth(self, term_width)

    def GetTerminalHeight(self):
        r"""Get the terminal height."""
        return _lldb.SBDebugger_GetTerminalHeight(self)

    def SetTerminalHeight(self, term_height):
        r"""Set the terminal height."""
        return _lldb.SBDebugger_SetTerminalHeight(self, term_height)

    def GetID(self):
        r"""Get the unique ID of this debugger."""
        return _lldb.SBDebugger_GetID(self)

    def GetPrompt(self):
        r"""Get the command prompt string."""
        return _lldb.SBDebugger_GetPrompt(self)

    def SetPrompt(self, prompt):
        r"""Set the command prompt string."""
        return _lldb.SBDebugger_SetPrompt(self, prompt)

    def GetReproducerPath(self):
        r"""Get the path to the reproducer."""
        return _lldb.SBDebugger_GetReproducerPath(self)

    def GetScriptLanguage(self):
        r"""Get the current scripting language."""
        return _lldb.SBDebugger_GetScriptLanguage(self)

    def SetScriptLanguage(self, script_lang):
        r"""Set the current scripting language."""
        return _lldb.SBDebugger_SetScriptLanguage(self, script_lang)

    def GetREPLLanguage(self):
        r"""Get the current REPL language."""
        return _lldb.SBDebugger_GetREPLLanguage(self)

    def SetREPLLanguage(self, repl_lang):
        r"""Set the current REPL language."""
        return _lldb.SBDebugger_SetREPLLanguage(self, repl_lang)

    def GetCloseInputOnEOF(self):
        r"""Get whether to close input on EOF (deprecated)."""
        return _lldb.SBDebugger_GetCloseInputOnEOF(self)

    def SetCloseInputOnEOF(self, b):
        r"""Set whether to close input on EOF (deprecated)."""
        return _lldb.SBDebugger_SetCloseInputOnEOF(self, b)

    def GetCategory(self, *args):
        r"""
        *Overload 1:*
        Get a type category by name.

        |

        *Overload 2:*
        Get a type category by language.
        """
        return _lldb.SBDebugger_GetCategory(self, *args)

    def CreateCategory(self, category_name):
        r"""Create a new type category."""
        return _lldb.SBDebugger_CreateCategory(self, category_name)

    def DeleteCategory(self, category_name):
        r"""Delete a type category."""
        return _lldb.SBDebugger_DeleteCategory(self, category_name)

    def GetNumCategories(self):
        r"""Get the number of type categories."""
        return _lldb.SBDebugger_GetNumCategories(self)

    def GetCategoryAtIndex(self, index):
        r"""Get a type category by index."""
        return _lldb.SBDebugger_GetCategoryAtIndex(self, index)

    def GetDefaultCategory(self):
        r"""Get the default type category."""
        return _lldb.SBDebugger_GetDefaultCategory(self)

    def GetFormatForType(self, type_name_spec):
        r"""Get the format for a type."""
        return _lldb.SBDebugger_GetFormatForType(self, type_name_spec)

    def GetSummaryForType(self, type_name_spec):
        r"""Get the summary for a type."""
        return _lldb.SBDebugger_GetSummaryForType(self, type_name_spec)

    def GetFilterForType(self, type_name_spec):
        r"""Get the filter for a type."""
        return _lldb.SBDebugger_GetFilterForType(self, type_name_spec)

    def GetSyntheticForType(self, type_name_spec):
        r"""Get the synthetic for a type."""
        return _lldb.SBDebugger_GetSyntheticForType(self, type_name_spec)

    def ResetStatistics(self):
        r"""
        Clear collected statistics for targets belonging to this debugger.

        This includes clearing symbol table and debug info parsing/index time for
        all modules, breakpoint resolve time, and target statistics.
        """
        return _lldb.SBDebugger_ResetStatistics(self)

    def RunCommandInterpreter(self, auto_handle_events, spawn_thread, options, num_errors, quit_requested, stopped_for_crash):
        r"""
        RunCommandInterpreter(SBDebugger self, bool auto_handle_events, bool spawn_thread, SBCommandInterpreterRunOptions options, int & num_errors, bool & quit_requested, bool & stopped_for_crash)
        Launch a command interpreter session. Commands are read from standard input or
        from the input handle specified for the debugger object. Output/errors are
        similarly redirected to standard output/error or the configured handles.

        @param[in] auto_handle_events If true, automatically handle resulting events.
        @param[in] spawn_thread If true, start a new thread for IO handling.
        @param[in] options Parameter collection of type SBCommandInterpreterRunOptions.
        @param[in] num_errors Initial error counter.
        @param[in] quit_requested Initial quit request flag.
        @param[in] stopped_for_crash Initial crash flag.

        @return
        A tuple with the number of errors encountered by the interpreter, a boolean
        indicating whether quitting the interpreter was requested and another boolean
        set to True in case of a crash.

        Example: ::

            # Start an interactive lldb session from a script (with a valid debugger object
            # created beforehand):
            n_errors, quit_requested, has_crashed = debugger.RunCommandInterpreter(True,
                False, lldb.SBCommandInterpreterRunOptions(), 0, False, False)
        """
        return _lldb.SBDebugger_RunCommandInterpreter(self, auto_handle_events, spawn_thread, options, num_errors, quit_requested, stopped_for_crash)

    def RunREPL(self, language, repl_options):
        r"""Run a REPL (Read-Eval-Print Loop) for the specified language."""
        return _lldb.SBDebugger_RunREPL(self, language, repl_options)

    def LoadTraceFromFile(self, error, trace_description_file):
        r"""
        Load a trace from a trace description file.

        This will create Targets, Processes and Threads based on the contents of
        the file.

        :type error: :py:class:`SBError`, out
        :param error:
              An error if the trace could not be created.

        :type trace_description_file: :py:class:`SBFileSpec`, in
        :param trace_description_file:
              The file containing the necessary information to load the trace.

        :rtype: :py:class:`SBTrace`
        :return: 
              An SBTrace object representing the loaded trace.
        """
        return _lldb.SBDebugger_LoadTraceFromFile(self, error, trace_description_file)

    def __repr__(self):
        r"""__repr__(SBDebugger self) -> std::string"""
        return _lldb.SBDebugger___repr__(self)

    def SetOutputFileHandle(self, file, transfer_ownership):
        "DEPRECATED, use SetOutputFile"
        if file is None:
            import sys
            file = sys.stdout
        self.SetOutputFile(SBFile.Create(file, borrow=True))

    def SetInputFileHandle(self, file, transfer_ownership):
        "DEPRECATED, use SetInputFile"
        if file is None:
            import sys
            file = sys.stdin
        self.SetInputFile(SBFile.Create(file, borrow=True))

    def SetErrorFileHandle(self, file, transfer_ownership):
        "DEPRECATED, use SetErrorFile"
        if file is None:
            import sys
            file = sys.stderr
        self.SetErrorFile(SBFile.Create(file, borrow=True))

    def __iter__(self):
        '''Iterate over all targets in a lldb.SBDebugger object.'''
        return lldb_iter(self, 'GetNumTargets', 'GetTargetAtIndex')

    def __len__(self):
        '''Return the number of targets in a lldb.SBDebugger object.'''
        return self.GetNumTargets()


    def GetInputFileHandle(self):
        r"""GetInputFileHandle(SBDebugger self) -> lldb::FileSP"""
        return _lldb.SBDebugger_GetInputFileHandle(self)

    def GetOutputFileHandle(self):
        r"""GetOutputFileHandle(SBDebugger self) -> lldb::FileSP"""
        return _lldb.SBDebugger_GetOutputFileHandle(self)

    def GetErrorFileHandle(self):
        r"""GetErrorFileHandle(SBDebugger self) -> lldb::FileSP"""
        return _lldb.SBDebugger_GetErrorFileHandle(self)

    class staticproperty:
        def __init__(self, func):
            self.func = func
        def __get__(self, instance, owner):
            return self.func()
    @staticproperty
    def version():
        return SBDebugger.GetVersionString()


# Register SBDebugger in _lldb:
_lldb.SBDebugger_swigregister(SBDebugger)
class SBDeclaration(object):
    r"""Specifies an association with a line and column for a variable."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBDeclaration self) -> SBDeclaration
        __init__(SBDeclaration self, SBDeclaration rhs) -> SBDeclaration
        """
        _lldb.SBDeclaration_swiginit(self, _lldb.new_SBDeclaration(*args))
    __swig_destroy__ = _lldb.delete_SBDeclaration

    def __nonzero__(self):
        return _lldb.SBDeclaration___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBDeclaration self) -> bool"""
        return _lldb.SBDeclaration_IsValid(self)

    def GetFileSpec(self):
        r"""GetFileSpec(SBDeclaration self) -> SBFileSpec"""
        return _lldb.SBDeclaration_GetFileSpec(self)

    def GetLine(self):
        r"""GetLine(SBDeclaration self) -> uint32_t"""
        return _lldb.SBDeclaration_GetLine(self)

    def GetColumn(self):
        r"""GetColumn(SBDeclaration self) -> uint32_t"""
        return _lldb.SBDeclaration_GetColumn(self)

    def SetFileSpec(self, filespec):
        r"""SetFileSpec(SBDeclaration self, SBFileSpec filespec)"""
        return _lldb.SBDeclaration_SetFileSpec(self, filespec)

    def SetLine(self, line):
        r"""SetLine(SBDeclaration self, uint32_t line)"""
        return _lldb.SBDeclaration_SetLine(self, line)

    def SetColumn(self, column):
        r"""SetColumn(SBDeclaration self, uint32_t column)"""
        return _lldb.SBDeclaration_SetColumn(self, column)

    def __eq__(self, rhs):
        r"""__eq__(SBDeclaration self, SBDeclaration rhs) -> bool"""
        return _lldb.SBDeclaration___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBDeclaration self, SBDeclaration rhs) -> bool"""
        return _lldb.SBDeclaration___ne__(self, rhs)

    def GetDescription(self, description):
        r"""GetDescription(SBDeclaration self, SBStream description) -> bool"""
        return _lldb.SBDeclaration_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBDeclaration self) -> std::string"""
        return _lldb.SBDeclaration___repr__(self)

                # operator== is a free function, which swig does not handle, so we inject
                # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
    line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
    column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBDeclaration in _lldb:
_lldb.SBDeclaration_swigregister(SBDeclaration)
class SBError(object):
    r"""
    Represents a container for holding any error code.

    For example (from test/python_api/hello_world/TestHelloWorld.py), ::

        def hello_world_attach_with_id_api(self):
            '''Create target, spawn a process, and attach to it by id.'''

            target = self.dbg.CreateTarget(self.exe)

            # Spawn a new process and don't display the stdout if not in TraceOn() mode.
            import subprocess
            popen = subprocess.Popen(
                [self.exe, 'abc', 'xyz'],
                stdout=subprocess.DEVNULL if not self.TraceOn() else None,
            )

            listener = lldb.SBListener('my.attach.listener')
            error = lldb.SBError()
            process = target.AttachToProcessWithID(listener, popen.pid, error)

            self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

            # Let's check the stack traces of the attached process.
            import lldbutil
            stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
            self.expect(stacktraces, exe=False,
                substrs = ['main.c:%d' % self.line2,
                           '(int)argc=3'])

            listener = lldb.SBListener('my.attach.listener')
            error = lldb.SBError()
            process = target.AttachToProcessWithID(listener, popen.pid, error)

            self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

    checks that after the attach, there is no error condition by asserting
    that error.Success() is True and we get back a valid process object.

    And (from test/python_api/event/TestEvent.py), ::

            # Now launch the process, and do not stop at entry point.
            error = lldb.SBError()
            process = target.Launch(listener, None, None, None, None, None, None, 0, False, error)
            self.assertTrue(error.Success() and process, PROCESS_IS_VALID)

    checks that after calling the target.Launch() method there's no error
    condition and we get back a void process object.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBError self) -> SBError
        __init__(SBError self, SBError rhs) -> SBError
        __init__(SBError self, char const * message) -> SBError
        """
        _lldb.SBError_swiginit(self, _lldb.new_SBError(*args))
    __swig_destroy__ = _lldb.delete_SBError

    def GetCString(self):
        r"""
        Get the error string as a NULL terminated UTF8 c-string.

        This SBError object owns the returned string and this object must be kept
        around long enough to use the returned string.
        """
        return _lldb.SBError_GetCString(self)

    def Clear(self):
        r"""Clear(SBError self)"""
        return _lldb.SBError_Clear(self)

    def Fail(self):
        r"""Fail(SBError self) -> bool"""
        return _lldb.SBError_Fail(self)

    def Success(self):
        r"""Success(SBError self) -> bool"""
        return _lldb.SBError_Success(self)

    def GetError(self):
        r"""Get the error code."""
        return _lldb.SBError_GetError(self)

    def GetErrorData(self):
        r"""
        Get the error in machine-readable form. Particularly useful for
        compiler diagnostics.
        """
        return _lldb.SBError_GetErrorData(self)

    def GetType(self):
        r"""GetType(SBError self) -> lldb::ErrorType"""
        return _lldb.SBError_GetType(self)

    def SetError(self, err, type):
        r"""SetError(SBError self, uint32_t err, lldb::ErrorType type)"""
        return _lldb.SBError_SetError(self, err, type)

    def SetErrorToErrno(self):
        r"""SetErrorToErrno(SBError self)"""
        return _lldb.SBError_SetErrorToErrno(self)

    def SetErrorToGenericError(self):
        r"""SetErrorToGenericError(SBError self)"""
        return _lldb.SBError_SetErrorToGenericError(self)

    def SetErrorString(self, err_str):
        r"""SetErrorString(SBError self, char const * err_str)"""
        return _lldb.SBError_SetErrorString(self, err_str)

    def SetErrorStringWithFormat(self, format, str1=None, str2=None, str3=None):
        r"""SetErrorStringWithFormat(SBError self, char const * format, char * str1=None, char * str2=None, char * str3=None) -> int"""
        return _lldb.SBError_SetErrorStringWithFormat(self, format, str1, str2, str3)

    def __nonzero__(self):
        return _lldb.SBError___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBError self) -> bool"""
        return _lldb.SBError_IsValid(self)

    def GetDescription(self, description):
        r"""GetDescription(SBError self, SBStream description) -> bool"""
        return _lldb.SBError_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBError self) -> std::string"""
        return _lldb.SBError___repr__(self)

    def __int__(self):
        return self.GetError()

    value = property(GetError, None, doc='''A read only property that returns the same result as GetError().''')
    fail = property(Fail, None, doc='''A read only property that returns the same result as Fail().''')
    success = property(Success, None, doc='''A read only property that returns the same result as Success().''')
    description = property(GetCString, None, doc='''A read only property that returns the same result as GetCString().''')
    type = property(GetType, None, doc='''A read only property that returns the same result as GetType().''')


# Register SBError in _lldb:
_lldb.SBError_swigregister(SBError)
class SBEnvironment(object):
    r"""
    Represents the environment of a certain process.

    Example: ::

      for entry in lldb.debugger.GetSelectedTarget().GetEnvironment().GetEntries():
        print(entry)


    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBEnvironment self) -> SBEnvironment
        __init__(SBEnvironment self, SBEnvironment rhs) -> SBEnvironment
        """
        _lldb.SBEnvironment_swiginit(self, _lldb.new_SBEnvironment(*args))
    __swig_destroy__ = _lldb.delete_SBEnvironment

    def Get(self, name):
        r"""
        Return the value of a given environment variable.

        :param [in]: name
                The name of the environment variable.

        :rtype: string
        :return: 
                The value of the environment variable or null if not present.
                If the environment variable has no value but is present, a valid
                pointer to an empty string will be returned.
        """
        return _lldb.SBEnvironment_Get(self, name)

    def GetNumValues(self):
        r"""
        :rtype: int
        :return: 
                The number of environment variables.
        """
        return _lldb.SBEnvironment_GetNumValues(self)

    def GetNameAtIndex(self, index):
        r"""
        Return the name of the environment variable at a given index from the
        internal list of environment variables.

        :param [in]: index
                The index of the environment variable in the internal list.

        :rtype: string
        :return: 
                The name at the given index or null if the index is invalid.
        """
        return _lldb.SBEnvironment_GetNameAtIndex(self, index)

    def GetValueAtIndex(self, index):
        r"""
        Return the value of the environment variable at a given index from the
        internal list of environment variables.

        :param [in]: index
                The index of the environment variable in the internal list.

        :rtype: string
        :return: 
                The value at the given index or null if the index is invalid.
                If the environment variable has no value but is present, a valid
                pointer to an empty string will be returned.
        """
        return _lldb.SBEnvironment_GetValueAtIndex(self, index)

    def GetEntries(self):
        r"""
        Return all environment variables contained in this object. Each variable
        is returned as a string with the following format
            name=value

        :rtype: :py:class:`SBStringList`
        :return: 
                Return an lldb::SBStringList object with the environment variables.
        """
        return _lldb.SBEnvironment_GetEntries(self)

    def PutEntry(self, name_and_value):
        r"""
        Add or replace an existing environment variable. The input must be a
        string with the format
            name=value

        :param [in]: name_and_value
                The entry to set which conforms to the format mentioned above.
        """
        return _lldb.SBEnvironment_PutEntry(self, name_and_value)

    def SetEntries(self, entries, append):
        r"""
        Update this object with the given environment variables. The input is a
        list of entries with the same format required by SBEnvironment::PutEntry.

        If append is false, the provided environment will replace the existing
        environment. Otherwise, existing values will be updated of left untouched
        accordingly.

        :param [in]: entries
                The environment variable entries.

        :param [in]: append
                Flag that controls whether to replace the existing environment.
        """
        return _lldb.SBEnvironment_SetEntries(self, entries, append)

    def Set(self, name, value, overwrite):
        r"""
        Set the value of a given environment variable.
        If the variable exists, its value is updated only if overwrite is true.

        :param [in]: name
                The name of the environment variable to set.

        :param [in]: value
                The value of the environment variable to set.

        :param [in]: overwrite
                Flag that indicates whether to overwrite an existing environment
                variable.

        :rtype: boolean
        :return: 
                Return whether the variable was added or modified.
        """
        return _lldb.SBEnvironment_Set(self, name, value, overwrite)

    def Unset(self, name):
        r"""
        Unset an environment variable if exists.

        :param [in]: name
                The name of the environment variable to unset.

        :rtype: boolean
        :return: 
                Return whether a variable was actually unset.
        """
        return _lldb.SBEnvironment_Unset(self, name)

    def Clear(self):
        r"""Delete all the environment variables."""
        return _lldb.SBEnvironment_Clear(self)

# Register SBEnvironment in _lldb:
_lldb.SBEnvironment_swigregister(SBEnvironment)
class SBEvent(object):
    r"""
    API clients can register to receive events.

    For example, check out the following output: ::

        Try wait for event...
        Event description: 0x103d0bb70 Event: broadcaster = 0x1009c8410, type = 0x00000001, data = { process = 0x1009c8400 (pid = 21528), state = running}
        Event data flavor: Process::ProcessEventData
        Process state: running

        Try wait for event...
        Event description: 0x103a700a0 Event: broadcaster = 0x1009c8410, type = 0x00000001, data = { process = 0x1009c8400 (pid = 21528), state = stopped}
        Event data flavor: Process::ProcessEventData
        Process state: stopped

        Try wait for event...
        Event description: 0x103d0d4a0 Event: broadcaster = 0x1009c8410, type = 0x00000001, data = { process = 0x1009c8400 (pid = 21528), state = exited}
        Event data flavor: Process::ProcessEventData
        Process state: exited

        Try wait for event...
        timeout occurred waiting for event...

    from test/python_api/event/TestEventspy: ::

        def do_listen_for_and_print_event(self):
            '''Create a listener and use SBEvent API to print the events received.'''
            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            # Now create a breakpoint on main.c by name 'c'.
            breakpoint = target.BreakpointCreateByName('c', 'a.out')

            # Now launch the process, and do not stop at the entry point.
            process = target.LaunchSimple(None, None, os.getcwd())
            self.assertTrue(process.GetState() == lldb.eStateStopped,
                            PROCESS_STOPPED)

            # Get a handle on the process's broadcaster.
            broadcaster = process.GetBroadcaster()

            # Create an empty event object.
            event = lldb.SBEvent()

            # Create a listener object and register with the broadcaster.
            listener = lldb.SBListener('my listener')
            rc = broadcaster.AddListener(listener, lldb.SBProcess.eBroadcastBitStateChanged)
            self.assertTrue(rc, 'AddListener successfully retruns')

            traceOn = self.TraceOn()
            if traceOn:
                lldbutil.print_stacktraces(process)

            # Create MyListeningThread class to wait for any kind of event.
            import threading
            class MyListeningThread(threading.Thread):
                def run(self):
                    count = 0
                    # Let's only try at most 4 times to retrieve any kind of event.
                    # After that, the thread exits.
                    while not count > 3:
                        if traceOn:
                            print('Try wait for event...')
                        if listener.WaitForEventForBroadcasterWithType(5,
                                                                       broadcaster,
                                                                       lldb.SBProcess.eBroadcastBitStateChanged,
                                                                       event):
                            if traceOn:
                                desc = lldbutil.get_description(event))
                                print('Event description:', desc)
                                print('Event data flavor:', event.GetDataFlavor())
                                print('Process state:', lldbutil.state_type_to_str(process.GetState()))
                                print()
                        else:
                            if traceOn:
                                print 'timeout occurred waiting for event...'
                        count = count + 1
                    return

            # Let's start the listening thread to retrieve the events.
            my_thread = MyListeningThread()
            my_thread.start()

            # Use Python API to continue the process.  The listening thread should be
            # able to receive the state changed events.
            process.Continue()

            # Use Python API to kill the process.  The listening thread should be
            # able to receive the state changed event, too.
            process.Kill()

            # Wait until the 'MyListeningThread' terminates.
            my_thread.join()
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)__init__(self, int type, str data) -> SBEvent (make an event that contains a C string)"""
        _lldb.SBEvent_swiginit(self, _lldb.new_SBEvent(*args))
    __swig_destroy__ = _lldb.delete_SBEvent

    def __nonzero__(self):
        return _lldb.SBEvent___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBEvent self) -> bool"""
        return _lldb.SBEvent_IsValid(self)

    def GetDataFlavor(self):
        r"""GetDataFlavor(SBEvent self) -> char const *"""
        return _lldb.SBEvent_GetDataFlavor(self)

    def GetType(self):
        r"""GetType(SBEvent self) -> uint32_t"""
        return _lldb.SBEvent_GetType(self)

    def GetBroadcaster(self):
        r"""GetBroadcaster(SBEvent self) -> SBBroadcaster"""
        return _lldb.SBEvent_GetBroadcaster(self)

    def GetBroadcasterClass(self):
        r"""GetBroadcasterClass(SBEvent self) -> char const *"""
        return _lldb.SBEvent_GetBroadcasterClass(self)

    def BroadcasterMatchesRef(self, broadcaster):
        r"""BroadcasterMatchesRef(SBEvent self, SBBroadcaster broadcaster) -> bool"""
        return _lldb.SBEvent_BroadcasterMatchesRef(self, broadcaster)

    def Clear(self):
        r"""Clear(SBEvent self)"""
        return _lldb.SBEvent_Clear(self)

    @staticmethod
    def GetCStringFromEvent(event):
        r"""GetCStringFromEvent(SBEvent event) -> char const *"""
        return _lldb.SBEvent_GetCStringFromEvent(event)

    def GetDescription(self, *args):
        r"""
        GetDescription(SBEvent self, SBStream description) -> bool
        GetDescription(SBEvent self, SBStream description) -> bool
        """
        return _lldb.SBEvent_GetDescription(self, *args)

# Register SBEvent in _lldb:
_lldb.SBEvent_swigregister(SBEvent)
class SBExecutionContext(object):
    r"""Describes the program context in which a command should be executed."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBExecutionContext self) -> SBExecutionContext
        __init__(SBExecutionContext self, SBExecutionContext rhs) -> SBExecutionContext
        __init__(SBExecutionContext self, SBTarget target) -> SBExecutionContext
        __init__(SBExecutionContext self, SBProcess process) -> SBExecutionContext
        __init__(SBExecutionContext self, SBThread thread) -> SBExecutionContext
        __init__(SBExecutionContext self, SBFrame frame) -> SBExecutionContext
        """
        _lldb.SBExecutionContext_swiginit(self, _lldb.new_SBExecutionContext(*args))
    __swig_destroy__ = _lldb.delete_SBExecutionContext

    def GetTarget(self):
        r"""GetTarget(SBExecutionContext self) -> SBTarget"""
        return _lldb.SBExecutionContext_GetTarget(self)

    def GetProcess(self):
        r"""GetProcess(SBExecutionContext self) -> SBProcess"""
        return _lldb.SBExecutionContext_GetProcess(self)

    def GetThread(self):
        r"""GetThread(SBExecutionContext self) -> SBThread"""
        return _lldb.SBExecutionContext_GetThread(self)

    def GetFrame(self):
        r"""GetFrame(SBExecutionContext self) -> SBFrame"""
        return _lldb.SBExecutionContext_GetFrame(self)

    target = property(GetTarget, None, doc='''A read only property that returns the same result as GetTarget().''')
    process = property(GetProcess, None, doc='''A read only property that returns the same result as GetProcess().''')
    thread = property(GetThread, None, doc='''A read only property that returns the same result as GetThread().''')
    frame = property(GetFrame, None, doc='''A read only property that returns the same result as GetFrame().''')


# Register SBExecutionContext in _lldb:
_lldb.SBExecutionContext_swigregister(SBExecutionContext)
class SBExpressionOptions(object):
    r"""A container for options to use when evaluating expressions."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBExpressionOptions self) -> SBExpressionOptions
        __init__(SBExpressionOptions self, SBExpressionOptions rhs) -> SBExpressionOptions
        """
        _lldb.SBExpressionOptions_swiginit(self, _lldb.new_SBExpressionOptions(*args))
    __swig_destroy__ = _lldb.delete_SBExpressionOptions

    def GetCoerceResultToId(self):
        r"""GetCoerceResultToId(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetCoerceResultToId(self)

    def SetCoerceResultToId(self, coerce=True):
        r"""
        SetCoerceResultToId(SBExpressionOptions self, bool coerce=True)
        Sets whether to coerce the expression result to ObjC id type after evaluation.
        """
        return _lldb.SBExpressionOptions_SetCoerceResultToId(self, coerce)

    def GetUnwindOnError(self):
        r"""GetUnwindOnError(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetUnwindOnError(self)

    def SetUnwindOnError(self, unwind=True):
        r"""
        SetUnwindOnError(SBExpressionOptions self, bool unwind=True)
        Sets whether to unwind the expression stack on error.
        """
        return _lldb.SBExpressionOptions_SetUnwindOnError(self, unwind)

    def GetIgnoreBreakpoints(self):
        r"""GetIgnoreBreakpoints(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetIgnoreBreakpoints(self)

    def SetIgnoreBreakpoints(self, ignore=True):
        r"""
        SetIgnoreBreakpoints(SBExpressionOptions self, bool ignore=True)
        Sets whether to ignore breakpoint hits while running expressions.
        """
        return _lldb.SBExpressionOptions_SetIgnoreBreakpoints(self, ignore)

    def GetFetchDynamicValue(self):
        r"""GetFetchDynamicValue(SBExpressionOptions self) -> lldb::DynamicValueType"""
        return _lldb.SBExpressionOptions_GetFetchDynamicValue(self)

    def SetFetchDynamicValue(self, *args):
        r"""
        SetFetchDynamicValue(SBExpressionOptions self, lldb::DynamicValueType dynamic=eDynamicCanRunTarget)
        Sets whether to cast the expression result to its dynamic type.
        """
        return _lldb.SBExpressionOptions_SetFetchDynamicValue(self, *args)

    def GetTimeoutInMicroSeconds(self):
        r"""GetTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t"""
        return _lldb.SBExpressionOptions_GetTimeoutInMicroSeconds(self)

    def SetTimeoutInMicroSeconds(self, timeout=0):
        r"""
        SetTimeoutInMicroSeconds(SBExpressionOptions self, uint32_t timeout=0)
        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 expression will finish.
        """
        return _lldb.SBExpressionOptions_SetTimeoutInMicroSeconds(self, timeout)

    def GetOneThreadTimeoutInMicroSeconds(self):
        r"""GetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t"""
        return _lldb.SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(self)

    def SetOneThreadTimeoutInMicroSeconds(self, timeout=0):
        r"""
        SetOneThreadTimeoutInMicroSeconds(SBExpressionOptions self, uint32_t timeout=0)
        Sets the timeout in microseconds to run the expression on one thread before either timing out or trying all threads.
        """
        return _lldb.SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds(self, timeout)

    def GetTryAllThreads(self):
        r"""GetTryAllThreads(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetTryAllThreads(self)

    def SetTryAllThreads(self, run_others=True):
        r"""
        SetTryAllThreads(SBExpressionOptions self, bool run_others=True)
        Sets whether to run all threads if the expression does not complete on one thread.
        """
        return _lldb.SBExpressionOptions_SetTryAllThreads(self, run_others)

    def GetStopOthers(self):
        r"""GetStopOthers(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetStopOthers(self)

    def SetStopOthers(self, stop_others=True):
        r"""
        SetStopOthers(SBExpressionOptions self, bool stop_others=True)
        Sets whether to stop other threads at all while running expressions.  If false, TryAllThreads does nothing.
        """
        return _lldb.SBExpressionOptions_SetStopOthers(self, stop_others)

    def GetTrapExceptions(self):
        r"""GetTrapExceptions(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetTrapExceptions(self)

    def SetTrapExceptions(self, trap_exceptions=True):
        r"""
        SetTrapExceptions(SBExpressionOptions self, bool trap_exceptions=True)
        Sets whether to abort expression evaluation if an exception is thrown while executing.  Don't set this to false unless you know the function you are calling traps all exceptions itself.
        """
        return _lldb.SBExpressionOptions_SetTrapExceptions(self, trap_exceptions)

    def SetLanguage(self, *args):
        r"""
        SetLanguage(SBExpressionOptions self, lldb::LanguageType language)
        SetLanguage(SBExpressionOptions self, lldb::SBSourceLanguageName name, uint32_t version)
        Sets the language that LLDB should assume the expression is written in
        """
        return _lldb.SBExpressionOptions_SetLanguage(self, *args)

    def GetGenerateDebugInfo(self):
        r"""GetGenerateDebugInfo(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetGenerateDebugInfo(self)

    def SetGenerateDebugInfo(self, b=True):
        r"""
        SetGenerateDebugInfo(SBExpressionOptions self, bool b=True)
        Sets whether to generate debug information for the expression and also controls if a SBModule is generated.
        """
        return _lldb.SBExpressionOptions_SetGenerateDebugInfo(self, b)

    def GetSuppressPersistentResult(self):
        r"""GetSuppressPersistentResult(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetSuppressPersistentResult(self)

    def SetSuppressPersistentResult(self, b=False):
        r"""
        SetSuppressPersistentResult(SBExpressionOptions self, bool b=False)
        Sets whether to produce a persistent result that can be used in future expressions.
        """
        return _lldb.SBExpressionOptions_SetSuppressPersistentResult(self, b)

    def GetPrefix(self):
        r"""
        GetPrefix(SBExpressionOptions self) -> char const *
        Gets the prefix to use for this expression.
        """
        return _lldb.SBExpressionOptions_GetPrefix(self)

    def SetPrefix(self, prefix):
        r"""
        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.
        """
        return _lldb.SBExpressionOptions_SetPrefix(self, prefix)

    def SetAutoApplyFixIts(self, b=True):
        r"""
        SetAutoApplyFixIts(SBExpressionOptions self, bool b=True)
        Sets whether to auto-apply fix-it hints to the expression being evaluated.
        """
        return _lldb.SBExpressionOptions_SetAutoApplyFixIts(self, b)

    def GetAutoApplyFixIts(self):
        r"""
        GetAutoApplyFixIts(SBExpressionOptions self) -> bool
        Gets whether to auto-apply fix-it hints to an expression.
        """
        return _lldb.SBExpressionOptions_GetAutoApplyFixIts(self)

    def SetRetriesWithFixIts(self, retries):
        r"""
        SetRetriesWithFixIts(SBExpressionOptions self, uint64_t retries)
        Sets how often LLDB should retry applying fix-its to an expression.
        """
        return _lldb.SBExpressionOptions_SetRetriesWithFixIts(self, retries)

    def GetRetriesWithFixIts(self):
        r"""
        GetRetriesWithFixIts(SBExpressionOptions self) -> uint64_t
        Gets how often LLDB will retry applying fix-its to an expression.
        """
        return _lldb.SBExpressionOptions_GetRetriesWithFixIts(self)

    def GetTopLevel(self):
        r"""GetTopLevel(SBExpressionOptions self) -> bool"""
        return _lldb.SBExpressionOptions_GetTopLevel(self)

    def SetTopLevel(self, b=True):
        r"""SetTopLevel(SBExpressionOptions self, bool b=True)"""
        return _lldb.SBExpressionOptions_SetTopLevel(self, b)

    def GetAllowJIT(self):
        r"""
        GetAllowJIT(SBExpressionOptions self) -> bool
        Gets whether to JIT an expression if it cannot be interpreted.
        """
        return _lldb.SBExpressionOptions_GetAllowJIT(self)

    def SetAllowJIT(self, allow):
        r"""
        SetAllowJIT(SBExpressionOptions self, bool allow)
        Sets whether to JIT an expression if it cannot be interpreted.
        """
        return _lldb.SBExpressionOptions_SetAllowJIT(self, allow)

# Register SBExpressionOptions in _lldb:
_lldb.SBExpressionOptions_swigregister(SBExpressionOptions)
class SBFile(object):
    r"""Represents a file."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBFile self) -> SBFile
        __init__(SBFile self, lldb::FileSP file_sp) -> SBFile
        __init__(SBFile self, int fd, char const * mode, bool transfer_ownership) -> SBFile
        initialize a SBFile from a python file object
        """
        _lldb.SBFile_swiginit(self, _lldb.new_SBFile(*args))
    __swig_destroy__ = _lldb.delete_SBFile

    def Read(self, buf):
        r"""Read(buffer) -> SBError, bytes_read"""
        return _lldb.SBFile_Read(self, buf)

    def Write(self, buf):
        r"""Write(buffer) -> SBError, written_read"""
        return _lldb.SBFile_Write(self, buf)

    def Flush(self):
        r"""Flush(SBFile self) -> SBError"""
        return _lldb.SBFile_Flush(self)

    def IsValid(self):
        r"""IsValid(SBFile self) -> bool"""
        return _lldb.SBFile_IsValid(self)

    def Close(self):
        r"""Close(SBFile self) -> SBError"""
        return _lldb.SBFile_Close(self)

    def __nonzero__(self):
        return _lldb.SBFile___nonzero__(self)
    __bool__ = __nonzero__



    def GetFile(self):
        r"""
        GetFile(SBFile self) -> lldb::FileSP

            Convert this SBFile into a python io.IOBase file object.

            If the SBFile is itself a wrapper around a python file object,
            this will return that original object.

            The file returned from here should be considered borrowed,
            in the sense that you may read and write to it, and flush it,
            etc, but you should not close it.   If you want to close the
            SBFile, call SBFile.Close().

            If there is no underlying python file to unwrap, GetFile will
            use the file descriptor, if available to create a new python
            file object using ``open(fd, mode=..., closefd=False)``

        """
        return _lldb.SBFile_GetFile(self)

    @staticmethod
    def MakeBorrowed(BORROWED):
        r"""MakeBorrowed(lldb::FileSP BORROWED) -> SBFile"""
        return _lldb.SBFile_MakeBorrowed(BORROWED)

    @staticmethod
    def MakeForcingIOMethods(FORCE_IO_METHODS):
        r"""MakeForcingIOMethods(lldb::FileSP FORCE_IO_METHODS) -> SBFile"""
        return _lldb.SBFile_MakeForcingIOMethods(FORCE_IO_METHODS)

    @staticmethod
    def MakeBorrowedForcingIOMethods(BORROWED_FORCE_IO_METHODS):
        r"""MakeBorrowedForcingIOMethods(lldb::FileSP BORROWED_FORCE_IO_METHODS) -> SBFile"""
        return _lldb.SBFile_MakeBorrowedForcingIOMethods(BORROWED_FORCE_IO_METHODS)

    @classmethod
    def Create(cls, file, borrow=False, force_io_methods=False):
        """
        Create a SBFile from a python file object, with options.

        If borrow is set then the underlying file will
        not be closed when the SBFile is closed or destroyed.

        If force_scripting_io is set then the python read/write
        methods will be called even if a file descriptor is available.
        """
        if borrow:
            if force_io_methods:
                return cls.MakeBorrowedForcingIOMethods(file)
            else:
                return cls.MakeBorrowed(file)
        else:
            if force_io_methods:
                return cls.MakeForcingIOMethods(file)
            else:
                return cls(file)


# Register SBFile in _lldb:
_lldb.SBFile_swigregister(SBFile)
class SBFileSpec(object):
    r"""
    Represents a file specification that divides the path into a directory and
    basename.  The string values of the paths are put into uniqued string pools
    for fast comparisons and efficient memory usage.

    For example, the following code ::

            lineEntry = context.GetLineEntry()
            self.expect(lineEntry.GetFileSpec().GetDirectory(), 'The line entry should have the correct directory',
                        exe=False,
                substrs = [self.mydir])
            self.expect(lineEntry.GetFileSpec().GetFilename(), 'The line entry should have the correct filename',
                        exe=False,
                substrs = ['main.c'])
            self.assertTrue(lineEntry.GetLine() == self.line,
                            'The line entry's line number should match ')

    gets the line entry from the symbol context when a thread is stopped.
    It gets the file spec corresponding to the line entry and checks that
    the filename and the directory matches what we expect.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBFileSpec self) -> SBFileSpec
        __init__(SBFileSpec self, SBFileSpec rhs) -> SBFileSpec
        __init__(SBFileSpec self, char const * path) -> SBFileSpec
        __init__(SBFileSpec self, char const * path, bool resolve) -> SBFileSpec
        """
        _lldb.SBFileSpec_swiginit(self, _lldb.new_SBFileSpec(*args))
    __swig_destroy__ = _lldb.delete_SBFileSpec

    def __nonzero__(self):
        return _lldb.SBFileSpec___nonzero__(self)
    __bool__ = __nonzero__



    def __eq__(self, rhs):
        r"""__eq__(SBFileSpec self, SBFileSpec rhs) -> bool"""
        return _lldb.SBFileSpec___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBFileSpec self, SBFileSpec rhs) -> bool"""
        return _lldb.SBFileSpec___ne__(self, rhs)

    def IsValid(self):
        r"""IsValid(SBFileSpec self) -> bool"""
        return _lldb.SBFileSpec_IsValid(self)

    def Exists(self):
        r"""Exists(SBFileSpec self) -> bool"""
        return _lldb.SBFileSpec_Exists(self)

    def ResolveExecutableLocation(self):
        r"""ResolveExecutableLocation(SBFileSpec self) -> bool"""
        return _lldb.SBFileSpec_ResolveExecutableLocation(self)

    def GetFilename(self):
        r"""GetFilename(SBFileSpec self) -> char const *"""
        return _lldb.SBFileSpec_GetFilename(self)

    def GetDirectory(self):
        r"""GetDirectory(SBFileSpec self) -> char const *"""
        return _lldb.SBFileSpec_GetDirectory(self)

    def SetFilename(self, filename):
        r"""SetFilename(SBFileSpec self, char const * filename)"""
        return _lldb.SBFileSpec_SetFilename(self, filename)

    def SetDirectory(self, directory):
        r"""SetDirectory(SBFileSpec self, char const * directory)"""
        return _lldb.SBFileSpec_SetDirectory(self, directory)

    def GetPath(self, dst_path, dst_len):
        r"""GetPath(SBFileSpec self, char * dst_path, size_t dst_len) -> uint32_t"""
        return _lldb.SBFileSpec_GetPath(self, dst_path, dst_len)

    @staticmethod
    def ResolvePath(src_path, dst_path, dst_len):
        r"""ResolvePath(char const * src_path, char * dst_path, size_t dst_len) -> int"""
        return _lldb.SBFileSpec_ResolvePath(src_path, dst_path, dst_len)

    def GetDescription(self, description):
        r"""GetDescription(SBFileSpec self, SBStream description) -> bool"""
        return _lldb.SBFileSpec_GetDescription(self, description)

    def AppendPathComponent(self, file_or_directory):
        r"""AppendPathComponent(SBFileSpec self, char const * file_or_directory)"""
        return _lldb.SBFileSpec_AppendPathComponent(self, file_or_directory)

    def __repr__(self):
        r"""__repr__(SBFileSpec self) -> std::string"""
        return _lldb.SBFileSpec___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    fullpath = property(str, None, doc='''A read only property that returns the fullpath as a python string.''')
    basename = property(GetFilename, None, doc='''A read only property that returns the path basename as a python string.''')
    dirname = property(GetDirectory, None, doc='''A read only property that returns the path directory name as a python string.''')
    exists = property(Exists, None, doc='''A read only property that returns a boolean value that indicates if the file exists.''')


# Register SBFileSpec in _lldb:
_lldb.SBFileSpec_swigregister(SBFileSpec)
class SBFileSpecList(object):
    r"""Represents a list of :py:class:`SBFileSpec`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBFileSpecList self) -> SBFileSpecList
        __init__(SBFileSpecList self, SBFileSpecList rhs) -> SBFileSpecList
        """
        _lldb.SBFileSpecList_swiginit(self, _lldb.new_SBFileSpecList(*args))
    __swig_destroy__ = _lldb.delete_SBFileSpecList

    def GetSize(self):
        r"""GetSize(SBFileSpecList self) -> uint32_t"""
        return _lldb.SBFileSpecList_GetSize(self)

    def GetDescription(self, description):
        r"""GetDescription(SBFileSpecList self, SBStream description) -> bool"""
        return _lldb.SBFileSpecList_GetDescription(self, description)

    def Append(self, sb_file):
        r"""Append(SBFileSpecList self, SBFileSpec sb_file)"""
        return _lldb.SBFileSpecList_Append(self, sb_file)

    def AppendIfUnique(self, sb_file):
        r"""AppendIfUnique(SBFileSpecList self, SBFileSpec sb_file) -> bool"""
        return _lldb.SBFileSpecList_AppendIfUnique(self, sb_file)

    def Clear(self):
        r"""Clear(SBFileSpecList self)"""
        return _lldb.SBFileSpecList_Clear(self)

    def FindFileIndex(self, idx, sb_file, full):
        r"""FindFileIndex(SBFileSpecList self, uint32_t idx, SBFileSpec sb_file, bool full) -> uint32_t"""
        return _lldb.SBFileSpecList_FindFileIndex(self, idx, sb_file, full)

    def GetFileSpecAtIndex(self, idx):
        r"""GetFileSpecAtIndex(SBFileSpecList self, uint32_t idx) -> SBFileSpec"""
        return _lldb.SBFileSpecList_GetFileSpecAtIndex(self, idx)

    def __repr__(self):
        r"""__repr__(SBFileSpecList self) -> std::string"""
        return _lldb.SBFileSpecList___repr__(self)

    def __len__(self):
      '''Return the number of FileSpec in a lldb.SBFileSpecList object.'''
      return self.GetSize()

    def __iter__(self):
      '''Iterate over all FileSpecs in a lldb.SBFileSpecList object.'''
      return lldb_iter(self, 'GetSize', 'GetFileSpecAtIndex')


# Register SBFileSpecList in _lldb:
_lldb.SBFileSpecList_swigregister(SBFileSpecList)
class SBFormat(object):
    r"""Class that represents a format string that can be used to generate descriptions of objects like frames and threads. See https://lldb.llvm.org/use/formatting.html for more information."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBFormat self) -> SBFormat
        __init__(SBFormat self, char const * format, SBError error) -> SBFormat
        __init__(SBFormat self, SBFormat rhs) -> SBFormat
        """
        _lldb.SBFormat_swiginit(self, _lldb.new_SBFormat(*args))
    __swig_destroy__ = _lldb.delete_SBFormat

    def __nonzero__(self):
        return _lldb.SBFormat___nonzero__(self)
    __bool__ = __nonzero__



# Register SBFormat in _lldb:
_lldb.SBFormat_swigregister(SBFormat)
class SBFrame(object):
    r"""
    Represents one of the stack frames associated with a thread.

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

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

            ...

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

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

            ...

    And, ::

        for frame in thread:
            print frame

    See also SBThread.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBFrame self) -> SBFrame
        __init__(SBFrame self, SBFrame rhs) -> SBFrame
        """
        _lldb.SBFrame_swiginit(self, _lldb.new_SBFrame(*args))
    __swig_destroy__ = _lldb.delete_SBFrame

    def IsEqual(self, that):
        r"""IsEqual(SBFrame self, SBFrame that) -> bool"""
        return _lldb.SBFrame_IsEqual(self, that)

    def __nonzero__(self):
        return _lldb.SBFrame___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBFrame self) -> bool"""
        return _lldb.SBFrame_IsValid(self)

    def GetFrameID(self):
        r"""GetFrameID(SBFrame self) -> uint32_t"""
        return _lldb.SBFrame_GetFrameID(self)

    def GetCFA(self):
        r"""
        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.
        """
        return _lldb.SBFrame_GetCFA(self)

    def GetPC(self):
        r"""GetPC(SBFrame self) -> lldb::addr_t"""
        return _lldb.SBFrame_GetPC(self)

    def SetPC(self, new_pc):
        r"""SetPC(SBFrame self, lldb::addr_t new_pc) -> bool"""
        return _lldb.SBFrame_SetPC(self, new_pc)

    def GetSP(self):
        r"""GetSP(SBFrame self) -> lldb::addr_t"""
        return _lldb.SBFrame_GetSP(self)

    def GetFP(self):
        r"""GetFP(SBFrame self) -> lldb::addr_t"""
        return _lldb.SBFrame_GetFP(self)

    def GetPCAddress(self):
        r"""GetPCAddress(SBFrame self) -> SBAddress"""
        return _lldb.SBFrame_GetPCAddress(self)

    def GetSymbolContext(self, resolve_scope):
        r"""GetSymbolContext(SBFrame self, uint32_t resolve_scope) -> SBSymbolContext"""
        return _lldb.SBFrame_GetSymbolContext(self, resolve_scope)

    def GetModule(self):
        r"""GetModule(SBFrame self) -> SBModule"""
        return _lldb.SBFrame_GetModule(self)

    def GetCompileUnit(self):
        r"""GetCompileUnit(SBFrame self) -> SBCompileUnit"""
        return _lldb.SBFrame_GetCompileUnit(self)

    def GetFunction(self):
        r"""GetFunction(SBFrame self) -> SBFunction"""
        return _lldb.SBFrame_GetFunction(self)

    def GetSymbol(self):
        r"""GetSymbol(SBFrame self) -> SBSymbol"""
        return _lldb.SBFrame_GetSymbol(self)

    def GetBlock(self):
        r"""
        GetBlock(SBFrame self) -> SBBlock

            Gets the deepest block that contains the frame PC.

            See also GetFrameBlock().
        """
        return _lldb.SBFrame_GetBlock(self)

    def GetDisplayFunctionName(self):
        r"""GetDisplayFunctionName(SBFrame self) -> char const *"""
        return _lldb.SBFrame_GetDisplayFunctionName(self)

    def GetFunctionName(self, *args):
        r"""
        GetFunctionName(SBFrame self) -> char const
        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().
        """
        return _lldb.SBFrame_GetFunctionName(self, *args)

    def GuessLanguage(self):
        r"""
        GuessLanguage(SBFrame self) -> lldb::LanguageType

            Returns the language of the frame's SBFunction, or if there.
            is no SBFunction, guess the language from the mangled name.
            .
        """
        return _lldb.SBFrame_GuessLanguage(self)

    def IsInlined(self, *args):
        r"""
        IsInlined(SBFrame self) -> bool
        IsInlined(SBFrame self) -> bool

            Return true if this frame represents an inlined function.

            See also GetFunctionName().
        """
        return _lldb.SBFrame_IsInlined(self, *args)

    def IsArtificial(self, *args):
        r"""
        IsArtificial(SBFrame self) -> bool
        IsArtificial(SBFrame self) -> bool

            Return true if this frame is artificial (e.g a frame synthesized to
            capture a tail call). Local variables may not be available in an artificial
            frame.
        """
        return _lldb.SBFrame_IsArtificial(self, *args)

    def IsHidden(self):
        r"""
        Return whether a frame recognizer decided this frame should not
        be displayes in backtraces etc.
        """
        return _lldb.SBFrame_IsHidden(self)

    def EvaluateExpression(self, *args):
        r"""
        EvaluateExpression(SBFrame self, char const * expr) -> SBValue
        EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic) -> SBValue
        EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) -> SBValue
        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.
        """
        return _lldb.SBFrame_EvaluateExpression(self, *args)

    def GetLanguageSpecificData(self):
        r"""
        Language plugins can use this API to report language-specific
        runtime information about this compile unit, such as additional
        language version details or feature flags.
        """
        return _lldb.SBFrame_GetLanguageSpecificData(self)

    def GetFrameBlock(self):
        r"""
        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.
        """
        return _lldb.SBFrame_GetFrameBlock(self)

    def GetLineEntry(self):
        r"""GetLineEntry(SBFrame self) -> SBLineEntry"""
        return _lldb.SBFrame_GetLineEntry(self)

    def GetThread(self):
        r"""GetThread(SBFrame self) -> SBThread"""
        return _lldb.SBFrame_GetThread(self)

    def Disassemble(self):
        r"""Disassemble(SBFrame self) -> char const *"""
        return _lldb.SBFrame_Disassemble(self)

    def Clear(self):
        r"""Clear(SBFrame self)"""
        return _lldb.SBFrame_Clear(self)

    def __eq__(self, rhs):
        r"""__eq__(SBFrame self, SBFrame rhs) -> bool"""
        return _lldb.SBFrame___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBFrame self, SBFrame rhs) -> bool"""
        return _lldb.SBFrame___ne__(self, rhs)

    def GetVariables(self, *args):
        r"""
        GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only) -> SBValueList
        GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) -> SBValueList
        GetVariables(SBFrame self, SBVariablesOptions options) -> SBValueList

            The version that doesn't supply a 'use_dynamic' value will use the
            target's default.
        """
        return _lldb.SBFrame_GetVariables(self, *args)

    def GetRegisters(self):
        r"""
        GetRegisters(SBFrame self) -> SBValueList

            Returns an SBValueList which is an array of one or more register
            sets that exist for this thread.  
            Each SBValue in the SBValueList represents one register-set. 
            The first register-set will be the general purpose registers -- 
            the registers printed by the `register read` command-line in lldb, with 
            no additional arguments.  
            The register-set SBValue will have a name, e.g. 
            SBFrame::GetRegisters().GetValueAtIndex(0).GetName() 
            By convention, certain stubs choose to name their general-purpose 
            register-set the 'General Purpose Registers', but that is not required.
            A register-set SBValue will have children, one child per register 
            in the register-set.
        """
        return _lldb.SBFrame_GetRegisters(self)

    def FindRegister(self, name):
        r"""FindRegister(SBFrame self, char const * name) -> SBValue"""
        return _lldb.SBFrame_FindRegister(self, name)

    def FindVariable(self, *args):
        r"""
        FindVariable(SBFrame self, char const * var_name) -> SBValue
        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.
        """
        return _lldb.SBFrame_FindVariable(self, *args)

    def GetValueForVariablePath(self, *args):
        r"""
        GetValueForVariablePath(SBFrame self, char const * var_expr_cstr, lldb::DynamicValueType use_dynamic) -> SBValue
        GetValueForVariablePath(SBFrame self, char const * var_path) -> 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 :py:class:`SBValue` objects
            with constant copies of the values at the time of evaluation,
            the result of this function is a value that will continue to
            track the current value of the value as execution progresses
            in the current frame.
        """
        return _lldb.SBFrame_GetValueForVariablePath(self, *args)

    def FindValue(self, *args):
        r"""
        FindValue(SBFrame self, char const * name, lldb::ValueType value_type) -> SBValue
        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.
        """
        return _lldb.SBFrame_FindValue(self, *args)

    def GetDescription(self, description):
        r"""GetDescription(SBFrame self, SBStream description) -> bool"""
        return _lldb.SBFrame_GetDescription(self, description)

    def GetDescriptionWithFormat(self, format, output):
        r"""
        Similar to *GetDescription()* but the format of the description can be
        configured via the ``format`` parameter. See
        https://lldb.llvm.org/use/formatting.html for more information on format
        strings.

        :type format: :py:class:`SBFormat`, in
        :param format:
              The format to use for generating the description.

        :type output: :py:class:`SBStream`, out
        :param output:
              The stream where the description will be written to.

        :rtype: :py:class:`SBError`
        :return: 
              An error object with an error message in case of failures.
        """
        return _lldb.SBFrame_GetDescriptionWithFormat(self, format, output)

    def __repr__(self):
        r"""__repr__(SBFrame self) -> std::string"""
        return _lldb.SBFrame___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __int__(self):
        return self.GetFrameID()

    def __hex__(self):
        return self.GetPC()

    def get_all_variables(self):
        return self.GetVariables(True,True,True,True)

    def get_parent_frame(self):
        parent_idx = self.idx + 1
        if parent_idx >= 0 and parent_idx < len(self.thread.frame):
            return self.thread.frame[parent_idx]
        else:
            return SBFrame()

    def get_arguments(self):
        return self.GetVariables(True,False,False,False)

    def get_locals(self):
        return self.GetVariables(False,True,False,False)

    def get_statics(self):
        return self.GetVariables(False,False,True,False)

    def var(self, var_expr_path):
        '''Calls through to lldb.SBFrame.GetValueForVariablePath() and returns
        a value that represents the variable expression path'''
        return self.GetValueForVariablePath(var_expr_path)

    def get_registers_access(self):
        class registers_access(object):
            '''A helper object that exposes a flattened view of registers, masking away the notion of register sets for easy scripting.'''
            def __init__(self, regs):
                self.regs = regs

            def __iter__(self):
                return self.get_registers()

            def get_registers(self):
                for i in range(0,len(self.regs)):
                    rs = self.regs[i]
                    for j in range (0,rs.num_children):
                        reg = rs.GetChildAtIndex(j)
                        yield reg

            def __getitem__(self, key):
                if type(key) is str:
                    for i in range(0,len(self.regs)):
                        rs = self.regs[i]
                        for j in range (0,rs.num_children):
                            reg = rs.GetChildAtIndex(j)
                            if reg.name == key: return reg
                else:
                    return SBValue()

        return registers_access(self.registers)

    pc = property(GetPC, SetPC)
    addr = property(GetPCAddress, None, doc='''A read only property that returns the program counter (PC) as a section offset address (lldb.SBAddress).''')
    fp = property(GetFP, None, doc='''A read only property that returns the frame pointer (FP) as an unsigned integer.''')
    sp = property(GetSP, None, doc='''A read only property that returns the stack pointer (SP) as an unsigned integer.''')
    module = property(GetModule, None, doc='''A read only property that returns an lldb object that represents the module (lldb.SBModule) for this stack frame.''')
    compile_unit = property(GetCompileUnit, None, doc='''A read only property that returns an lldb object that represents the compile unit (lldb.SBCompileUnit) for this stack frame.''')
    function = property(GetFunction, None, doc='''A read only property that returns an lldb object that represents the function (lldb.SBFunction) for this stack frame.''')
    symbol = property(GetSymbol, None, doc='''A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) for this stack frame.''')
    block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the block (lldb.SBBlock) for this stack frame.''')
    is_inlined = property(IsInlined, None, doc='''A read only property that returns an boolean that indicates if the block frame is an inlined function.''')
    name = property(GetFunctionName, None, doc='''A read only property that retuns the name for the function that this frame represents. Inlined stack frame might have a concrete function that differs from the name of the inlined function (a named lldb.SBBlock).''')
    line_entry = property(GetLineEntry, None, doc='''A read only property that returns an lldb object that represents the line table entry (lldb.SBLineEntry) for this stack frame.''')
    thread = property(GetThread, None, doc='''A read only property that returns an lldb object that represents the thread (lldb.SBThread) for this stack frame.''')
    disassembly = property(Disassemble, None, doc='''A read only property that returns the disassembly for this stack frame as a python string.''')
    idx = property(GetFrameID, None, doc='''A read only property that returns the zero based stack frame index.''')
    variables = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
    vars = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
    locals = property(get_locals, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the local variables in this stack frame.''')
    args = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
    arguments = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
    statics = property(get_statics, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the static variables in this stack frame.''')
    registers = property(GetRegisters, None, doc='''Returns the register sets for this thread as a list().  See SBFrame::GetRegisters() for details.''')
    regs = property(GetRegisters, None, doc='''Returns the register sets for this thread as a list().  See SBFrame::GetRegisters() for details.''')
    register = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame.''')
    reg = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame''')
    parent = property(get_parent_frame, None, doc='''A read only property that returns the parent (caller) frame of the current frame.''')


# Register SBFrame in _lldb:
_lldb.SBFrame_swigregister(SBFrame)
class SBFunction(object):
    r"""
    Represents a generic function, which can be inlined or not.

    For example (from test/lldbutil.py, but slightly modified for doc purpose),::

            ...

            frame = thread.GetFrameAtIndex(i)
            addr = frame.GetPCAddress()
            load_addr = addr.GetLoadAddress(target)
            function = frame.GetFunction()
            mod_name = frame.GetModule().GetFileSpec().GetFilename()

            if not function:
                # No debug info for 'function'.
                symbol = frame.GetSymbol()
                file_addr = addr.GetFileAddress()
                start_addr = symbol.GetStartAddress().GetFileAddress()
                symbol_name = symbol.GetName()
                symbol_offset = file_addr - start_addr
                print >> output, '  frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
                    num=i, addr=load_addr, mod=mod_name, symbol=symbol_name, offset=symbol_offset)
            else:
                # Debug info is available for 'function'.
                func_name = frame.GetFunctionName()
                file_name = frame.GetLineEntry().GetFileSpec().GetFilename()
                line_num = frame.GetLineEntry().GetLine()
                print >> output, '  frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
                    num=i, addr=load_addr, mod=mod_name,
                    func='%s [inlined]' % func_name] if frame.IsInlined() else func_name,
                    file=file_name, line=line_num, args=get_args_as_string(frame, showFuncName=False))

            ...
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBFunction self) -> SBFunction
        __init__(SBFunction self, SBFunction rhs) -> SBFunction
        """
        _lldb.SBFunction_swiginit(self, _lldb.new_SBFunction(*args))
    __swig_destroy__ = _lldb.delete_SBFunction

    def __nonzero__(self):
        return _lldb.SBFunction___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBFunction self) -> bool"""
        return _lldb.SBFunction_IsValid(self)

    def GetName(self):
        r"""GetName(SBFunction self) -> char const *"""
        return _lldb.SBFunction_GetName(self)

    def GetDisplayName(self):
        r"""GetDisplayName(SBFunction self) -> char const *"""
        return _lldb.SBFunction_GetDisplayName(self)

    def GetMangledName(self):
        r"""GetMangledName(SBFunction self) -> char const *"""
        return _lldb.SBFunction_GetMangledName(self)

    def GetInstructions(self, *args):
        r"""
        GetInstructions(SBFunction self, SBTarget target) -> SBInstructionList
        GetInstructions(SBFunction self, SBTarget target, char const * flavor) -> SBInstructionList
        """
        return _lldb.SBFunction_GetInstructions(self, *args)

    def GetStartAddress(self):
        r"""GetStartAddress(SBFunction self) -> SBAddress"""
        return _lldb.SBFunction_GetStartAddress(self)

    def GetEndAddress(self):
        r"""GetEndAddress(SBFunction self) -> SBAddress"""
        return _lldb.SBFunction_GetEndAddress(self)

    def GetRanges(self):
        r"""GetRanges(SBFunction self) -> SBAddressRangeList"""
        return _lldb.SBFunction_GetRanges(self)

    def GetArgumentName(self, arg_idx):
        r"""GetArgumentName(SBFunction self, uint32_t arg_idx) -> char const *"""
        return _lldb.SBFunction_GetArgumentName(self, arg_idx)

    def GetPrologueByteSize(self):
        r"""GetPrologueByteSize(SBFunction self) -> uint32_t"""
        return _lldb.SBFunction_GetPrologueByteSize(self)

    def GetType(self):
        r"""GetType(SBFunction self) -> SBType"""
        return _lldb.SBFunction_GetType(self)

    def GetBlock(self):
        r"""GetBlock(SBFunction self) -> SBBlock"""
        return _lldb.SBFunction_GetBlock(self)

    def GetLanguage(self):
        r"""GetLanguage(SBFunction self) -> lldb::LanguageType"""
        return _lldb.SBFunction_GetLanguage(self)

    def GetIsOptimized(self):
        r"""
        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.
        """
        return _lldb.SBFunction_GetIsOptimized(self)

    def __eq__(self, rhs):
        r"""__eq__(SBFunction self, SBFunction rhs) -> bool"""
        return _lldb.SBFunction___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBFunction self, SBFunction rhs) -> bool"""
        return _lldb.SBFunction___ne__(self, rhs)

    def GetDescription(self, description):
        r"""GetDescription(SBFunction self, SBStream description) -> bool"""
        return _lldb.SBFunction_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBFunction self) -> std::string"""
        return _lldb.SBFunction___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def get_instructions_from_current_target (self):
        return self.GetInstructions (target)

    addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this function.''')
    end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this function.''')
    block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the top level lexical block (lldb.SBBlock) for this function.''')
    instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this function.''')
    mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this function as a string.''')
    name = property(GetName, None, doc='''A read only property that returns the name for this function as a string.''')
    prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''')
    type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the return type (lldb.SBType) for this function.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBFunction in _lldb:
_lldb.SBFunction_swigregister(SBFunction)
class SBHostOS(object):
    r"""Provides information about the host system."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def GetProgramFileSpec():
        r"""GetProgramFileSpec() -> SBFileSpec"""
        return _lldb.SBHostOS_GetProgramFileSpec()

    @staticmethod
    def GetLLDBPythonPath():
        r"""GetLLDBPythonPath() -> SBFileSpec"""
        return _lldb.SBHostOS_GetLLDBPythonPath()

    @staticmethod
    def GetLLDBPath(path_type):
        r"""GetLLDBPath(lldb::PathType path_type) -> SBFileSpec"""
        return _lldb.SBHostOS_GetLLDBPath(path_type)

    @staticmethod
    def GetUserHomeDirectory():
        r"""GetUserHomeDirectory() -> SBFileSpec"""
        return _lldb.SBHostOS_GetUserHomeDirectory()

    @staticmethod
    def ThreadCreated(name):
        r"""ThreadCreated(char const * name)"""
        return _lldb.SBHostOS_ThreadCreated(name)

    @staticmethod
    def ThreadCreate(name, thread_function, thread_arg, err):
        r"""ThreadCreate(char const * name, lldb::thread_func_t thread_function, void * thread_arg, SBError err) -> lldb::thread_t"""
        return _lldb.SBHostOS_ThreadCreate(name, thread_function, thread_arg, err)

    @staticmethod
    def ThreadCancel(thread, err):
        r"""ThreadCancel(lldb::thread_t thread, SBError err) -> bool"""
        return _lldb.SBHostOS_ThreadCancel(thread, err)

    @staticmethod
    def ThreadDetach(thread, err):
        r"""ThreadDetach(lldb::thread_t thread, SBError err) -> bool"""
        return _lldb.SBHostOS_ThreadDetach(thread, err)

    @staticmethod
    def ThreadJoin(thread, result, err):
        r"""ThreadJoin(lldb::thread_t thread, lldb::thread_result_t * result, SBError err) -> bool"""
        return _lldb.SBHostOS_ThreadJoin(thread, result, err)

    def __init__(self):
        r"""__init__(SBHostOS self) -> SBHostOS"""
        _lldb.SBHostOS_swiginit(self, _lldb.new_SBHostOS())
    __swig_destroy__ = _lldb.delete_SBHostOS

# Register SBHostOS in _lldb:
_lldb.SBHostOS_swigregister(SBHostOS)
class SBInstruction(object):
    r"""Represents a (machine language) instruction."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBInstruction self) -> SBInstruction
        __init__(SBInstruction self, SBInstruction rhs) -> SBInstruction
        """
        _lldb.SBInstruction_swiginit(self, _lldb.new_SBInstruction(*args))
    __swig_destroy__ = _lldb.delete_SBInstruction

    def __nonzero__(self):
        return _lldb.SBInstruction___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBInstruction self) -> bool"""
        return _lldb.SBInstruction_IsValid(self)

    def GetAddress(self):
        r"""GetAddress(SBInstruction self) -> SBAddress"""
        return _lldb.SBInstruction_GetAddress(self)

    def GetMnemonic(self, target):
        r"""GetMnemonic(SBInstruction self, SBTarget target) -> char const *"""
        return _lldb.SBInstruction_GetMnemonic(self, target)

    def GetOperands(self, target):
        r"""GetOperands(SBInstruction self, SBTarget target) -> char const *"""
        return _lldb.SBInstruction_GetOperands(self, target)

    def GetComment(self, target):
        r"""GetComment(SBInstruction self, SBTarget target) -> char const *"""
        return _lldb.SBInstruction_GetComment(self, target)

    def GetControlFlowKind(self, target):
        r"""GetControlFlowKind(SBInstruction self, SBTarget target) -> lldb::InstructionControlFlowKind"""
        return _lldb.SBInstruction_GetControlFlowKind(self, target)

    def GetData(self, target):
        r"""GetData(SBInstruction self, SBTarget target) -> SBData"""
        return _lldb.SBInstruction_GetData(self, target)

    def GetByteSize(self):
        r"""GetByteSize(SBInstruction self) -> size_t"""
        return _lldb.SBInstruction_GetByteSize(self)

    def DoesBranch(self):
        r"""DoesBranch(SBInstruction self) -> bool"""
        return _lldb.SBInstruction_DoesBranch(self)

    def HasDelaySlot(self):
        r"""HasDelaySlot(SBInstruction self) -> bool"""
        return _lldb.SBInstruction_HasDelaySlot(self)

    def CanSetBreakpoint(self):
        r"""CanSetBreakpoint(SBInstruction self) -> bool"""
        return _lldb.SBInstruction_CanSetBreakpoint(self)

    def Print(self, *args):
        r"""
        Print(SBInstruction self, SBFile out)
        Print(SBInstruction self, lldb::FileSP BORROWED)
        """
        return _lldb.SBInstruction_Print(self, *args)

    def GetDescription(self, description):
        r"""GetDescription(SBInstruction self, SBStream description) -> bool"""
        return _lldb.SBInstruction_GetDescription(self, description)

    def EmulateWithFrame(self, frame, evaluate_options):
        r"""EmulateWithFrame(SBInstruction self, SBFrame frame, uint32_t evaluate_options) -> bool"""
        return _lldb.SBInstruction_EmulateWithFrame(self, frame, evaluate_options)

    def DumpEmulation(self, triple):
        r"""DumpEmulation(SBInstruction self, char const * triple) -> bool"""
        return _lldb.SBInstruction_DumpEmulation(self, triple)

    def TestEmulation(self, output_stream, test_file):
        r"""TestEmulation(SBInstruction self, SBStream output_stream, char const * test_file) -> bool"""
        return _lldb.SBInstruction_TestEmulation(self, output_stream, test_file)

    def __repr__(self):
        r"""__repr__(SBInstruction self) -> std::string"""
        return _lldb.SBInstruction___repr__(self)

    def __hex__(self):
        """ Returns the address of the instruction. """
        return self.GetAddress()

    def __len__(self):
        """ Returns the size of the instruction. """
        return self.GetByteSize()

    def __mnemonic_property__ (self):
        return self.GetMnemonic (target)
    def __operands_property__ (self):
        return self.GetOperands (target)
    def __comment_property__ (self):
        return self.GetComment (target)
    def __file_addr_property__ (self):
        return self.GetAddress ().GetFileAddress()
    def __load_adrr_property__ (self):
        return self.GetComment (target)

    mnemonic = property(__mnemonic_property__, None, doc='''A read only property that returns the mnemonic for this instruction as a string.''')
    operands = property(__operands_property__, None, doc='''A read only property that returns the operands for this instruction as a string.''')
    comment = property(__comment_property__, None, doc='''A read only property that returns the comment for this instruction as a string.''')
    addr = property(GetAddress, None, doc='''A read only property that returns an lldb object that represents the address (lldb.SBAddress) for this instruction.''')
    size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes for this instruction as an integer.''')
    is_branch = property(DoesBranch, None, doc='''A read only property that returns a boolean value that indicates if this instruction is a branch instruction.''')


# Register SBInstruction in _lldb:
_lldb.SBInstruction_swigregister(SBInstruction)
class SBInstructionList(object):
    r"""
    Represents a list of machine instructions.  SBFunction and SBSymbol have
    GetInstructions() methods which return SBInstructionList instances.

    SBInstructionList supports instruction (:py:class:`SBInstruction` instance) iteration.
    For example (see also :py:class:`SBDebugger` for a more complete example), ::

        def disassemble_instructions (insts):
            for i in insts:
                print i

    defines a function which takes an SBInstructionList instance and prints out
    the machine instructions in assembly format.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBInstructionList self) -> SBInstructionList
        __init__(SBInstructionList self, SBInstructionList rhs) -> SBInstructionList
        """
        _lldb.SBInstructionList_swiginit(self, _lldb.new_SBInstructionList(*args))
    __swig_destroy__ = _lldb.delete_SBInstructionList

    def __nonzero__(self):
        return _lldb.SBInstructionList___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBInstructionList self) -> bool"""
        return _lldb.SBInstructionList_IsValid(self)

    def GetSize(self):
        r"""GetSize(SBInstructionList self) -> size_t"""
        return _lldb.SBInstructionList_GetSize(self)

    def GetInstructionAtIndex(self, idx):
        r"""GetInstructionAtIndex(SBInstructionList self, uint32_t idx) -> SBInstruction"""
        return _lldb.SBInstructionList_GetInstructionAtIndex(self, idx)

    def GetInstructionsCount(self, start, end, canSetBreakpoint=False):
        r"""GetInstructionsCount(SBInstructionList self, SBAddress start, SBAddress end, bool canSetBreakpoint=False) -> size_t"""
        return _lldb.SBInstructionList_GetInstructionsCount(self, start, end, canSetBreakpoint)

    def Clear(self):
        r"""Clear(SBInstructionList self)"""
        return _lldb.SBInstructionList_Clear(self)

    def AppendInstruction(self, inst):
        r"""AppendInstruction(SBInstructionList self, SBInstruction inst)"""
        return _lldb.SBInstructionList_AppendInstruction(self, inst)

    def Print(self, *args):
        r"""
        Print(SBInstructionList self, SBFile out)
        Print(SBInstructionList self, lldb::FileSP BORROWED)
        """
        return _lldb.SBInstructionList_Print(self, *args)

    def GetDescription(self, *args):
        r"""
        GetDescription(SBInstructionList self, SBStream description) -> bool
        GetDescription(SBInstructionList self, SBStream description, SBExecutionContext exe_ctx) -> bool
        """
        return _lldb.SBInstructionList_GetDescription(self, *args)

    def DumpEmulationForAllInstructions(self, triple):
        r"""DumpEmulationForAllInstructions(SBInstructionList self, char const * triple) -> bool"""
        return _lldb.SBInstructionList_DumpEmulationForAllInstructions(self, triple)

    def __repr__(self):
        r"""__repr__(SBInstructionList self) -> std::string"""
        return _lldb.SBInstructionList___repr__(self)

    def __iter__(self):
        '''Iterate over all instructions in a lldb.SBInstructionList
        object.'''
        return lldb_iter(self, 'GetSize', 'GetInstructionAtIndex')

    def __len__(self):
        '''Access len of the instruction list.'''
        return int(self.GetSize())

    def __getitem__(self, key):
        '''Access instructions by integer index for array access or by lldb.SBAddress to find an instruction that matches a section offset address object.'''
        if type(key) is int:
    # Find an instruction by index
            count = len(self)
            if -count <= key < count:
                key %= count
                return self.GetInstructionAtIndex(key)
        elif type(key) is SBAddress:
    # Find an instruction using a lldb.SBAddress object
            lookup_file_addr = key.file_addr
            closest_inst = None
            for idx in range(self.GetSize()):
                inst = self.GetInstructionAtIndex(idx)
                inst_file_addr = inst.addr.file_addr
                if inst_file_addr == lookup_file_addr:
                    return inst
                elif inst_file_addr > lookup_file_addr:
                    return closest_inst
                else:
                    closest_inst = inst
        return None


# Register SBInstructionList in _lldb:
_lldb.SBInstructionList_swigregister(SBInstructionList)
class SBLanguageRuntime(object):
    r"""Utility functions for :ref:`LanguageType`"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def GetLanguageTypeFromString(string):
        r"""GetLanguageTypeFromString(char const * string) -> lldb::LanguageType"""
        return _lldb.SBLanguageRuntime_GetLanguageTypeFromString(string)

    @staticmethod
    def GetNameForLanguageType(language):
        r"""GetNameForLanguageType(lldb::LanguageType language) -> char const *"""
        return _lldb.SBLanguageRuntime_GetNameForLanguageType(language)

    @staticmethod
    def LanguageIsCPlusPlus(language):
        r"""Returns whether the given language is any version of C++."""
        return _lldb.SBLanguageRuntime_LanguageIsCPlusPlus(language)

    @staticmethod
    def LanguageIsObjC(language):
        r"""Returns whether the given language is Obj-C or Obj-C++."""
        return _lldb.SBLanguageRuntime_LanguageIsObjC(language)

    @staticmethod
    def LanguageIsCFamily(language):
        r"""Returns whether the given language is any version of C, C++ or Obj-C."""
        return _lldb.SBLanguageRuntime_LanguageIsCFamily(language)

    @staticmethod
    def SupportsExceptionBreakpointsOnThrow(language):
        r"""
        Returns whether the given language supports exception breakpoints on
        throw statements.
        """
        return _lldb.SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow(language)

    @staticmethod
    def SupportsExceptionBreakpointsOnCatch(language):
        r"""
        Returns whether the given language supports exception breakpoints on
        catch statements.
        """
        return _lldb.SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch(language)

    @staticmethod
    def GetThrowKeywordForLanguage(language):
        r"""
        Returns the keyword used for throw statements in the given language, e.g.
        Python uses **raise**. Returns **nullptr** if the language is not supported.
        """
        return _lldb.SBLanguageRuntime_GetThrowKeywordForLanguage(language)

    @staticmethod
    def GetCatchKeywordForLanguage(language):
        r"""
        Returns the keyword used for catch statements in the given language, e.g.
        Python uses **except**. Returns **nullptr** if the language is not
        supported.
        """
        return _lldb.SBLanguageRuntime_GetCatchKeywordForLanguage(language)

    def __init__(self):
        r"""__init__(SBLanguageRuntime self) -> SBLanguageRuntime"""
        _lldb.SBLanguageRuntime_swiginit(self, _lldb.new_SBLanguageRuntime())
    __swig_destroy__ = _lldb.delete_SBLanguageRuntime

# Register SBLanguageRuntime in _lldb:
_lldb.SBLanguageRuntime_swigregister(SBLanguageRuntime)
eLanguageNameAda = _lldb.eLanguageNameAda
r"""ISO Ada."""
eLanguageNameBLISS = _lldb.eLanguageNameBLISS
r"""BLISS."""
eLanguageNameC = _lldb.eLanguageNameC
r"""C (K&R and ISO)."""
eLanguageNameC_plus_plus = _lldb.eLanguageNameC_plus_plus
r"""ISO C++."""
eLanguageNameCobol = _lldb.eLanguageNameCobol
r"""ISO Cobol."""
eLanguageNameCrystal = _lldb.eLanguageNameCrystal
r"""Crystal."""
eLanguageNameD = _lldb.eLanguageNameD
r"""D."""
eLanguageNameDylan = _lldb.eLanguageNameDylan
r"""Dylan."""
eLanguageNameFortran = _lldb.eLanguageNameFortran
r"""ISO Fortran."""
eLanguageNameGo = _lldb.eLanguageNameGo
r"""Go."""
eLanguageNameHaskell = _lldb.eLanguageNameHaskell
r"""Haskell."""
eLanguageNameJava = _lldb.eLanguageNameJava
r"""Java."""
eLanguageNameJulia = _lldb.eLanguageNameJulia
r"""Julia."""
eLanguageNameKotlin = _lldb.eLanguageNameKotlin
r"""Kotlin."""
eLanguageNameModula2 = _lldb.eLanguageNameModula2
r"""Modula 2."""
eLanguageNameModula3 = _lldb.eLanguageNameModula3
r"""Modula 3."""
eLanguageNameObjC = _lldb.eLanguageNameObjC
r"""Objective C."""
eLanguageNameObjC_plus_plus = _lldb.eLanguageNameObjC_plus_plus
r"""Objective C++."""
eLanguageNameOCaml = _lldb.eLanguageNameOCaml
r"""OCaml."""
eLanguageNameOpenCL_C = _lldb.eLanguageNameOpenCL_C
r"""OpenCL C."""
eLanguageNamePascal = _lldb.eLanguageNamePascal
r"""ISO Pascal."""
eLanguageNamePLI = _lldb.eLanguageNamePLI
r"""ANSI PL/I."""
eLanguageNamePython = _lldb.eLanguageNamePython
r"""Python."""
eLanguageNameRenderScript = _lldb.eLanguageNameRenderScript
r"""RenderScript Kernel Language."""
eLanguageNameRust = _lldb.eLanguageNameRust
r"""Rust."""
eLanguageNameSwift = _lldb.eLanguageNameSwift
r"""Swift."""
eLanguageNameUPC = _lldb.eLanguageNameUPC
r"""Unified Parallel C (UPC)."""
eLanguageNameZig = _lldb.eLanguageNameZig
r"""Zig."""
eLanguageNameAssembly = _lldb.eLanguageNameAssembly
r"""Assembly."""
eLanguageNameC_sharp = _lldb.eLanguageNameC_sharp
r"""C#."""
eLanguageNameMojo = _lldb.eLanguageNameMojo
r"""Mojo."""
eLanguageNameGLSL = _lldb.eLanguageNameGLSL
r"""OpenGL Shading Language."""
eLanguageNameGLSL_ES = _lldb.eLanguageNameGLSL_ES
r"""OpenGL ES Shading Language."""
eLanguageNameHLSL = _lldb.eLanguageNameHLSL
r"""High Level Shading Language."""
eLanguageNameOpenCL_CPP = _lldb.eLanguageNameOpenCL_CPP
r"""OpenCL C++."""
eLanguageNameCPP_for_OpenCL = _lldb.eLanguageNameCPP_for_OpenCL
r"""C++ for OpenCL."""
eLanguageNameSYCL = _lldb.eLanguageNameSYCL
r"""SYCL."""
eLanguageNameRuby = _lldb.eLanguageNameRuby
r"""Ruby."""
eLanguageNameMove = _lldb.eLanguageNameMove
r"""Move."""
eLanguageNameHylo = _lldb.eLanguageNameHylo
r"""Hylo."""
eLanguageNameMetal = _lldb.eLanguageNameMetal
r"""Metal."""
class SBLaunchInfo(object):
    r"""Describes how a target or program should be launched."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, argv):
        r"""__init__(SBLaunchInfo self, char const ** argv) -> SBLaunchInfo"""
        _lldb.SBLaunchInfo_swiginit(self, _lldb.new_SBLaunchInfo(argv))
    __swig_destroy__ = _lldb.delete_SBLaunchInfo

    def GetProcessID(self):
        r"""GetProcessID(SBLaunchInfo self) -> lldb::pid_t"""
        return _lldb.SBLaunchInfo_GetProcessID(self)

    def GetUserID(self):
        r"""GetUserID(SBLaunchInfo self) -> uint32_t"""
        return _lldb.SBLaunchInfo_GetUserID(self)

    def GetGroupID(self):
        r"""GetGroupID(SBLaunchInfo self) -> uint32_t"""
        return _lldb.SBLaunchInfo_GetGroupID(self)

    def UserIDIsValid(self):
        r"""UserIDIsValid(SBLaunchInfo self) -> bool"""
        return _lldb.SBLaunchInfo_UserIDIsValid(self)

    def GroupIDIsValid(self):
        r"""GroupIDIsValid(SBLaunchInfo self) -> bool"""
        return _lldb.SBLaunchInfo_GroupIDIsValid(self)

    def SetUserID(self, uid):
        r"""SetUserID(SBLaunchInfo self, uint32_t uid)"""
        return _lldb.SBLaunchInfo_SetUserID(self, uid)

    def SetGroupID(self, gid):
        r"""SetGroupID(SBLaunchInfo self, uint32_t gid)"""
        return _lldb.SBLaunchInfo_SetGroupID(self, gid)

    def GetExecutableFile(self):
        r"""GetExecutableFile(SBLaunchInfo self) -> SBFileSpec"""
        return _lldb.SBLaunchInfo_GetExecutableFile(self)

    def SetExecutableFile(self, exe_file, add_as_first_arg):
        r"""
        Set the executable file that will be used to launch the process and
        optionally set it as the first argument in the argument vector.

        This only needs to be specified if clients wish to carefully control
        the exact path will be used to launch a binary. If you create a
        target with a symlink, that symlink will get resolved in the target
        and the resolved path will get used to launch the process. Calling
        this function can help you still launch your process using the
        path of your choice.

        If this function is not called prior to launching with
        SBTarget::Launch(...), the target will use the resolved executable
        path that was used to create the target.

        :type exe_file: :py:class:`SBFileSpec`, in
        :param exe_file:
                The override path to use when launching the executable.

        :type add_as_first_arg: boolean, in
        :param add_as_first_arg:
                If true, then the path will be inserted into the argument vector
                prior to launching. Otherwise the argument vector will be left
                alone.
        """
        return _lldb.SBLaunchInfo_SetExecutableFile(self, exe_file, add_as_first_arg)

    def GetListener(self):
        r"""
        Get the listener that will be used to receive process events.

        If no listener has been set via a call to
        SBLaunchInfo::SetListener(), then an invalid SBListener will be
        returned (SBListener::IsValid() will return false). If a listener
        has been set, then the valid listener object will be returned.
        """
        return _lldb.SBLaunchInfo_GetListener(self)

    def SetListener(self, listener):
        r"""
        Set the listener that will be used to receive process events.

        By default the SBDebugger, which has a listener, that the SBTarget
        belongs to will listen for the process events. Calling this function
        allows a different listener to be used to listen for process events.
        """
        return _lldb.SBLaunchInfo_SetListener(self, listener)

    def GetShadowListener(self):
        r"""
        Get the shadow listener that receive public process events,
        additionally to the default process event listener.

        If no listener has been set via a call to
        SBLaunchInfo::SetShadowListener(), then an invalid SBListener will
        be returned (SBListener::IsValid() will return false). If a listener
        has been set, then the valid listener object will be returned.
        """
        return _lldb.SBLaunchInfo_GetShadowListener(self)

    def SetShadowListener(self, listener):
        r"""
        Set the shadow listener that will receive public process events,
        additionally to the default process event listener.

        By default a process have no shadow event listener.
        Calling this function allows public process events to be broadcasted to an
        additional listener on top of the default process event listener.
        If the `listener` argument is invalid (SBListener::IsValid() will
        return false), this will clear the shadow listener.
        """
        return _lldb.SBLaunchInfo_SetShadowListener(self, listener)

    def GetNumArguments(self):
        r"""GetNumArguments(SBLaunchInfo self) -> uint32_t"""
        return _lldb.SBLaunchInfo_GetNumArguments(self)

    def GetArgumentAtIndex(self, idx):
        r"""GetArgumentAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *"""
        return _lldb.SBLaunchInfo_GetArgumentAtIndex(self, idx)

    def SetArguments(self, argv, append):
        r"""SetArguments(SBLaunchInfo self, char const ** argv, bool append)"""
        return _lldb.SBLaunchInfo_SetArguments(self, argv, append)

    def GetNumEnvironmentEntries(self):
        r"""GetNumEnvironmentEntries(SBLaunchInfo self) -> uint32_t"""
        return _lldb.SBLaunchInfo_GetNumEnvironmentEntries(self)

    def GetEnvironmentEntryAtIndex(self, idx):
        r"""GetEnvironmentEntryAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *"""
        return _lldb.SBLaunchInfo_GetEnvironmentEntryAtIndex(self, idx)

    def SetEnvironmentEntries(self, envp, append):
        r"""
        Update this object with the given environment variables.

        If append is false, the provided environment will replace the existing
        environment. Otherwise, existing values will be updated of left untouched
        accordingly.

        :param [in]: envp
                The new environment variables as a list of strings with the following
                format
                    name=value

        :param [in]: append
                Flag that controls whether to replace the existing environment.
        """
        return _lldb.SBLaunchInfo_SetEnvironmentEntries(self, envp, append)

    def SetEnvironment(self, env, append):
        r"""
        Update this object with the given environment variables.

        If append is false, the provided environment will replace the existing
        environment. Otherwise, existing values will be updated of left untouched
        accordingly.

        :param [in]: env
                The new environment variables.

        :param [in]: append
                Flag that controls whether to replace the existing environment.
        """
        return _lldb.SBLaunchInfo_SetEnvironment(self, env, append)

    def GetEnvironment(self):
        r"""
        Return the environment variables of this object.

        :rtype: :py:class:`SBEnvironment`
        :return: 
                An lldb::SBEnvironment object which is a copy of the SBLaunchInfo's
                environment.
        """
        return _lldb.SBLaunchInfo_GetEnvironment(self)

    def Clear(self):
        r"""Clear(SBLaunchInfo self)"""
        return _lldb.SBLaunchInfo_Clear(self)

    def GetWorkingDirectory(self):
        r"""GetWorkingDirectory(SBLaunchInfo self) -> char const *"""
        return _lldb.SBLaunchInfo_GetWorkingDirectory(self)

    def SetWorkingDirectory(self, working_dir):
        r"""SetWorkingDirectory(SBLaunchInfo self, char const * working_dir)"""
        return _lldb.SBLaunchInfo_SetWorkingDirectory(self, working_dir)

    def GetLaunchFlags(self):
        r"""GetLaunchFlags(SBLaunchInfo self) -> uint32_t"""
        return _lldb.SBLaunchInfo_GetLaunchFlags(self)

    def SetLaunchFlags(self, flags):
        r"""SetLaunchFlags(SBLaunchInfo self, uint32_t flags)"""
        return _lldb.SBLaunchInfo_SetLaunchFlags(self, flags)

    def GetProcessPluginName(self):
        r"""GetProcessPluginName(SBLaunchInfo self) -> char const *"""
        return _lldb.SBLaunchInfo_GetProcessPluginName(self)

    def SetProcessPluginName(self, plugin_name):
        r"""SetProcessPluginName(SBLaunchInfo self, char const * plugin_name)"""
        return _lldb.SBLaunchInfo_SetProcessPluginName(self, plugin_name)

    def GetShell(self):
        r"""GetShell(SBLaunchInfo self) -> char const *"""
        return _lldb.SBLaunchInfo_GetShell(self)

    def SetShell(self, path):
        r"""SetShell(SBLaunchInfo self, char const * path)"""
        return _lldb.SBLaunchInfo_SetShell(self, path)

    def GetShellExpandArguments(self):
        r"""GetShellExpandArguments(SBLaunchInfo self) -> bool"""
        return _lldb.SBLaunchInfo_GetShellExpandArguments(self)

    def SetShellExpandArguments(self, expand):
        r"""SetShellExpandArguments(SBLaunchInfo self, bool expand)"""
        return _lldb.SBLaunchInfo_SetShellExpandArguments(self, expand)

    def GetResumeCount(self):
        r"""GetResumeCount(SBLaunchInfo self) -> uint32_t"""
        return _lldb.SBLaunchInfo_GetResumeCount(self)

    def SetResumeCount(self, c):
        r"""SetResumeCount(SBLaunchInfo self, uint32_t c)"""
        return _lldb.SBLaunchInfo_SetResumeCount(self, c)

    def AddCloseFileAction(self, fd):
        r"""AddCloseFileAction(SBLaunchInfo self, int fd) -> bool"""
        return _lldb.SBLaunchInfo_AddCloseFileAction(self, fd)

    def AddDuplicateFileAction(self, fd, dup_fd):
        r"""AddDuplicateFileAction(SBLaunchInfo self, int fd, int dup_fd) -> bool"""
        return _lldb.SBLaunchInfo_AddDuplicateFileAction(self, fd, dup_fd)

    def AddOpenFileAction(self, fd, path, read, write):
        r"""AddOpenFileAction(SBLaunchInfo self, int fd, char const * path, bool read, bool write) -> bool"""
        return _lldb.SBLaunchInfo_AddOpenFileAction(self, fd, path, read, write)

    def AddSuppressFileAction(self, fd, read, write):
        r"""AddSuppressFileAction(SBLaunchInfo self, int fd, bool read, bool write) -> bool"""
        return _lldb.SBLaunchInfo_AddSuppressFileAction(self, fd, read, write)

    def SetLaunchEventData(self, data):
        r"""SetLaunchEventData(SBLaunchInfo self, char const * data)"""
        return _lldb.SBLaunchInfo_SetLaunchEventData(self, data)

    def GetLaunchEventData(self):
        r"""GetLaunchEventData(SBLaunchInfo self) -> char const *"""
        return _lldb.SBLaunchInfo_GetLaunchEventData(self)

    def GetDetachOnError(self):
        r"""GetDetachOnError(SBLaunchInfo self) -> bool"""
        return _lldb.SBLaunchInfo_GetDetachOnError(self)

    def SetDetachOnError(self, enable):
        r"""SetDetachOnError(SBLaunchInfo self, bool enable)"""
        return _lldb.SBLaunchInfo_SetDetachOnError(self, enable)

    def GetScriptedProcessClassName(self):
        r"""GetScriptedProcessClassName(SBLaunchInfo self) -> char const *"""
        return _lldb.SBLaunchInfo_GetScriptedProcessClassName(self)

    def SetScriptedProcessClassName(self, class_name):
        r"""SetScriptedProcessClassName(SBLaunchInfo self, char const * class_name)"""
        return _lldb.SBLaunchInfo_SetScriptedProcessClassName(self, class_name)

    def GetScriptedProcessDictionary(self):
        r"""GetScriptedProcessDictionary(SBLaunchInfo self) -> SBStructuredData"""
        return _lldb.SBLaunchInfo_GetScriptedProcessDictionary(self)

    def SetScriptedProcessDictionary(self, dict):
        r"""SetScriptedProcessDictionary(SBLaunchInfo self, SBStructuredData dict)"""
        return _lldb.SBLaunchInfo_SetScriptedProcessDictionary(self, dict)

# Register SBLaunchInfo in _lldb:
_lldb.SBLaunchInfo_swigregister(SBLaunchInfo)
class SBLineEntry(object):
    r"""
    Specifies an association with a contiguous range of instructions and
    a source file location.

    :py:class:`SBCompileUnit` contains SBLineEntry(s). For example, ::

        for lineEntry in compileUnit:
            print('line entry: %s:%d' % (str(lineEntry.GetFileSpec()),
                                        lineEntry.GetLine()))
            print('start addr: %s' % str(lineEntry.GetStartAddress()))
            print('end   addr: %s' % str(lineEntry.GetEndAddress()))

    produces: ::

        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:20
        start addr: a.out[0x100000d98]
        end   addr: a.out[0x100000da3]
        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:21
        start addr: a.out[0x100000da3]
        end   addr: a.out[0x100000da9]
        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:22
        start addr: a.out[0x100000da9]
        end   addr: a.out[0x100000db6]
        line entry: /Volumes/data/lldb/svn/trunk/test/python_api/symbol-context/main.c:23
        start addr: a.out[0x100000db6]
        end   addr: a.out[0x100000dbc]
        ...

    See also :py:class:`SBCompileUnit` .
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBLineEntry self) -> SBLineEntry
        __init__(SBLineEntry self, SBLineEntry rhs) -> SBLineEntry
        """
        _lldb.SBLineEntry_swiginit(self, _lldb.new_SBLineEntry(*args))
    __swig_destroy__ = _lldb.delete_SBLineEntry

    def GetStartAddress(self):
        r"""GetStartAddress(SBLineEntry self) -> SBAddress"""
        return _lldb.SBLineEntry_GetStartAddress(self)

    def GetEndAddress(self):
        r"""GetEndAddress(SBLineEntry self) -> SBAddress"""
        return _lldb.SBLineEntry_GetEndAddress(self)

    def GetSameLineContiguousAddressRangeEnd(self, include_inlined_functions):
        r"""GetSameLineContiguousAddressRangeEnd(SBLineEntry self, bool include_inlined_functions) -> SBAddress"""
        return _lldb.SBLineEntry_GetSameLineContiguousAddressRangeEnd(self, include_inlined_functions)

    def __nonzero__(self):
        return _lldb.SBLineEntry___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBLineEntry self) -> bool"""
        return _lldb.SBLineEntry_IsValid(self)

    def GetFileSpec(self):
        r"""GetFileSpec(SBLineEntry self) -> SBFileSpec"""
        return _lldb.SBLineEntry_GetFileSpec(self)

    def GetLine(self):
        r"""GetLine(SBLineEntry self) -> uint32_t"""
        return _lldb.SBLineEntry_GetLine(self)

    def GetColumn(self):
        r"""GetColumn(SBLineEntry self) -> uint32_t"""
        return _lldb.SBLineEntry_GetColumn(self)

    def SetFileSpec(self, filespec):
        r"""SetFileSpec(SBLineEntry self, SBFileSpec filespec)"""
        return _lldb.SBLineEntry_SetFileSpec(self, filespec)

    def SetLine(self, line):
        r"""SetLine(SBLineEntry self, uint32_t line)"""
        return _lldb.SBLineEntry_SetLine(self, line)

    def SetColumn(self, column):
        r"""SetColumn(SBLineEntry self, uint32_t column)"""
        return _lldb.SBLineEntry_SetColumn(self, column)

    def __eq__(self, rhs):
        r"""__eq__(SBLineEntry self, SBLineEntry rhs) -> bool"""
        return _lldb.SBLineEntry___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBLineEntry self, SBLineEntry rhs) -> bool"""
        return _lldb.SBLineEntry___ne__(self, rhs)

    def GetDescription(self, description):
        r"""GetDescription(SBLineEntry self, SBStream description) -> bool"""
        return _lldb.SBLineEntry_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBLineEntry self) -> std::string"""
        return _lldb.SBLineEntry___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __int__(self):
        return self.GetLine()

    def __hex__(self):
        return self.GetStartAddress()
    file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this line entry.''')
    line = property(GetLine, None, doc='''A read only property that returns the 1 based line number for this line entry, a return value of zero indicates that no line information is available.''')
    column = property(GetColumn, None, doc='''A read only property that returns the 1 based column number for this line entry, a return value of zero indicates that no column information is available.''')
    addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this line entry.''')
    end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this line entry.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBLineEntry in _lldb:
_lldb.SBLineEntry_swigregister(SBLineEntry)
class SBListener(object):
    r"""
    API clients can register its own listener to debugger events.

    See also :py:class:`SBEvent` for example usage of creating and adding a listener.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBListener self) -> SBListener
        __init__(SBListener self, char const * name) -> SBListener
        __init__(SBListener self, SBListener rhs) -> SBListener
        """
        _lldb.SBListener_swiginit(self, _lldb.new_SBListener(*args))
    __swig_destroy__ = _lldb.delete_SBListener

    def AddEvent(self, event):
        r"""AddEvent(SBListener self, SBEvent event)"""
        return _lldb.SBListener_AddEvent(self, event)

    def Clear(self):
        r"""Clear(SBListener self)"""
        return _lldb.SBListener_Clear(self)

    def __nonzero__(self):
        return _lldb.SBListener___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBListener self) -> bool"""
        return _lldb.SBListener_IsValid(self)

    def StartListeningForEventClass(self, debugger, broadcaster_class, event_mask):
        r"""StartListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> uint32_t"""
        return _lldb.SBListener_StartListeningForEventClass(self, debugger, broadcaster_class, event_mask)

    def StopListeningForEventClass(self, debugger, broadcaster_class, event_mask):
        r"""StopListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> bool"""
        return _lldb.SBListener_StopListeningForEventClass(self, debugger, broadcaster_class, event_mask)

    def StartListeningForEvents(self, broadcaster, event_mask):
        r"""StartListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> uint32_t"""
        return _lldb.SBListener_StartListeningForEvents(self, broadcaster, event_mask)

    def StopListeningForEvents(self, broadcaster, event_mask):
        r"""StopListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> bool"""
        return _lldb.SBListener_StopListeningForEvents(self, broadcaster, event_mask)

    def WaitForEvent(self, num_seconds, event):
        r"""WaitForEvent(SBListener self, uint32_t num_seconds, SBEvent event) -> bool"""
        return _lldb.SBListener_WaitForEvent(self, num_seconds, event)

    def WaitForEventForBroadcaster(self, num_seconds, broadcaster, sb_event):
        r"""WaitForEventForBroadcaster(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_WaitForEventForBroadcaster(self, num_seconds, broadcaster, sb_event)

    def WaitForEventForBroadcasterWithType(self, num_seconds, broadcaster, event_type_mask, sb_event):
        r"""WaitForEventForBroadcasterWithType(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_WaitForEventForBroadcasterWithType(self, num_seconds, broadcaster, event_type_mask, sb_event)

    def PeekAtNextEvent(self, sb_event):
        r"""PeekAtNextEvent(SBListener self, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_PeekAtNextEvent(self, sb_event)

    def PeekAtNextEventForBroadcaster(self, broadcaster, sb_event):
        r"""PeekAtNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_PeekAtNextEventForBroadcaster(self, broadcaster, sb_event)

    def PeekAtNextEventForBroadcasterWithType(self, broadcaster, event_type_mask, sb_event):
        r"""PeekAtNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_PeekAtNextEventForBroadcasterWithType(self, broadcaster, event_type_mask, sb_event)

    def GetNextEvent(self, sb_event):
        r"""GetNextEvent(SBListener self, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_GetNextEvent(self, sb_event)

    def GetNextEventForBroadcaster(self, broadcaster, sb_event):
        r"""GetNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_GetNextEventForBroadcaster(self, broadcaster, sb_event)

    def GetNextEventForBroadcasterWithType(self, broadcaster, event_type_mask, sb_event):
        r"""GetNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool"""
        return _lldb.SBListener_GetNextEventForBroadcasterWithType(self, broadcaster, event_type_mask, sb_event)

    def HandleBroadcastEvent(self, event):
        r"""HandleBroadcastEvent(SBListener self, SBEvent event) -> bool"""
        return _lldb.SBListener_HandleBroadcastEvent(self, event)

# Register SBListener in _lldb:
_lldb.SBListener_swigregister(SBListener)
class SBMemoryRegionInfo(object):
    r"""API clients can get information about memory regions in processes."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBMemoryRegionInfo self) -> SBMemoryRegionInfo
        __init__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> SBMemoryRegionInfo
        __init__(SBMemoryRegionInfo self, char const * name, lldb::addr_t begin, lldb::addr_t end, uint32_t permissions, bool mapped, bool stack_memory=False) -> SBMemoryRegionInfo
        """
        _lldb.SBMemoryRegionInfo_swiginit(self, _lldb.new_SBMemoryRegionInfo(*args))
    __swig_destroy__ = _lldb.delete_SBMemoryRegionInfo

    def Clear(self):
        r"""Clear(SBMemoryRegionInfo self)"""
        return _lldb.SBMemoryRegionInfo_Clear(self)

    def GetRegionBase(self):
        r"""
        Get the base address of this memory range.

        :rtype: int
        :return: 
                The base address of this memory range.
        """
        return _lldb.SBMemoryRegionInfo_GetRegionBase(self)

    def GetRegionEnd(self):
        r"""
        Get the end address of this memory range.

        :rtype: int
        :return: 
                The base address of this memory range.
        """
        return _lldb.SBMemoryRegionInfo_GetRegionEnd(self)

    def IsReadable(self):
        r"""
        Check if this memory address is marked readable to the process.

        :rtype: boolean
        :return: 
                true if this memory address is marked readable
        """
        return _lldb.SBMemoryRegionInfo_IsReadable(self)

    def IsWritable(self):
        r"""
        Check if this memory address is marked writable to the process.

        :rtype: boolean
        :return: 
                true if this memory address is marked writable
        """
        return _lldb.SBMemoryRegionInfo_IsWritable(self)

    def IsExecutable(self):
        r"""
        Check if this memory address is marked executable to the process.

        :rtype: boolean
        :return: 
                true if this memory address is marked executable
        """
        return _lldb.SBMemoryRegionInfo_IsExecutable(self)

    def IsMapped(self):
        r"""
        Check if this memory address is mapped into the process address
        space.

        :rtype: boolean
        :return: 
                true if this memory address is in the process address space.
        """
        return _lldb.SBMemoryRegionInfo_IsMapped(self)

    def GetName(self):
        r"""
        Returns the name of the memory region mapped at the given
        address.

        :rtype: string
        :return: 
                In case of memory mapped files it is the absolute path of
                the file otherwise it is a name associated with the memory
                region. If no name can be determined the returns nullptr.
        """
        return _lldb.SBMemoryRegionInfo_GetName(self)

    def HasDirtyMemoryPageList(self):
        r"""
        HasDirtyMemoryPageList(SBMemoryRegionInfo self) -> bool

                Returns whether this memory region has a list of modified (dirty)
                pages available or not.  When calling GetNumDirtyPages(), you will
                have 0 returned for both "dirty page list is not known" and 
                "empty dirty page list" (that is, no modified pages in this
                memory region).  You must use this method to disambiguate.
        """
        return _lldb.SBMemoryRegionInfo_HasDirtyMemoryPageList(self)

    def GetNumDirtyPages(self):
        r"""
        GetNumDirtyPages(SBMemoryRegionInfo self) -> uint32_t

                Return the number of dirty (modified) memory pages in this
                memory region, if available.  You must use the 
                SBMemoryRegionInfo::HasDirtyMemoryPageList() method to
                determine if a dirty memory list is available; it will depend
                on the target system can provide this information.
        """
        return _lldb.SBMemoryRegionInfo_GetNumDirtyPages(self)

    def GetDirtyPageAddressAtIndex(self, idx):
        r"""
        GetDirtyPageAddressAtIndex(SBMemoryRegionInfo self, uint32_t idx) -> lldb::addr_t

                Return the address of a modified, or dirty, page of memory.
                If the provided index is out of range, or this memory region 
                does not have dirty page information, LLDB_INVALID_ADDRESS 
                is returned.
        """
        return _lldb.SBMemoryRegionInfo_GetDirtyPageAddressAtIndex(self, idx)

    def GetPageSize(self):
        r"""
        GetPageSize(SBMemoryRegionInfo self) -> int

                Return the size of pages in this memory region.  0 will be returned
                if this information was unavailable.
        """
        return _lldb.SBMemoryRegionInfo_GetPageSize(self)

    def __eq__(self, rhs):
        r"""__eq__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool"""
        return _lldb.SBMemoryRegionInfo___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBMemoryRegionInfo self, SBMemoryRegionInfo rhs) -> bool"""
        return _lldb.SBMemoryRegionInfo___ne__(self, rhs)

    def GetDescription(self, description):
        r"""GetDescription(SBMemoryRegionInfo self, SBStream description) -> bool"""
        return _lldb.SBMemoryRegionInfo_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBMemoryRegionInfo self) -> std::string"""
        return _lldb.SBMemoryRegionInfo___repr__(self)

        # operator== is a free function, which swig does not handle, so we inject
        # our own equality operator here
    def __eq__(self, other):
      return not self.__ne__(other)

    def __hex__(self):
      return self.GetRegionBase()

    def __len__(self):
      return self.GetRegionEnd() - self.GetRegionBase()


# Register SBMemoryRegionInfo in _lldb:
_lldb.SBMemoryRegionInfo_swigregister(SBMemoryRegionInfo)
class SBMemoryRegionInfoList(object):
    r"""Represents a list of :py:class:`SBMemoryRegionInfo`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBMemoryRegionInfoList self) -> SBMemoryRegionInfoList
        __init__(SBMemoryRegionInfoList self, SBMemoryRegionInfoList rhs) -> SBMemoryRegionInfoList
        """
        _lldb.SBMemoryRegionInfoList_swiginit(self, _lldb.new_SBMemoryRegionInfoList(*args))
    __swig_destroy__ = _lldb.delete_SBMemoryRegionInfoList

    def GetSize(self):
        r"""GetSize(SBMemoryRegionInfoList self) -> uint32_t"""
        return _lldb.SBMemoryRegionInfoList_GetSize(self)

    def GetMemoryRegionContainingAddress(self, addr, region_info):
        r"""GetMemoryRegionContainingAddress(SBMemoryRegionInfoList self, lldb::addr_t addr, SBMemoryRegionInfo region_info) -> bool"""
        return _lldb.SBMemoryRegionInfoList_GetMemoryRegionContainingAddress(self, addr, region_info)

    def GetMemoryRegionAtIndex(self, idx, region_info):
        r"""GetMemoryRegionAtIndex(SBMemoryRegionInfoList self, uint32_t idx, SBMemoryRegionInfo region_info) -> bool"""
        return _lldb.SBMemoryRegionInfoList_GetMemoryRegionAtIndex(self, idx, region_info)

    def Append(self, *args):
        r"""
        Append(SBMemoryRegionInfoList self, SBMemoryRegionInfo region)
        Append(SBMemoryRegionInfoList self, SBMemoryRegionInfoList region_list)
        """
        return _lldb.SBMemoryRegionInfoList_Append(self, *args)

    def Clear(self):
        r"""Clear(SBMemoryRegionInfoList self)"""
        return _lldb.SBMemoryRegionInfoList_Clear(self)

    def __len__(self):
      '''Return the number of memory region info in a lldb.SBMemoryRegionInfoList object.'''
      return self.GetSize()

    def __iter__(self):
      '''Iterate over all the memory regions in a lldb.SBMemoryRegionInfoList object.'''
      import lldb
      size = self.GetSize()
      for i in range(size):
        region = lldb.SBMemoryRegionInfo()
        self.GetMemoryRegionAtIndex(i, region)
        yield region


# Register SBMemoryRegionInfoList in _lldb:
_lldb.SBMemoryRegionInfoList_swigregister(SBMemoryRegionInfoList)
class SBModule(object):
    r"""
    Represents an executable image and its associated object and symbol files.

    The module is designed to be able to select a single slice of an
    executable image as it would appear on disk and during program
    execution.

    You can retrieve SBModule from :py:class:`SBSymbolContext` , which in turn is available
    from SBFrame.

    SBModule supports symbol iteration, for example, ::

        for symbol in module:
            name = symbol.GetName()
            saddr = symbol.GetStartAddress()
            eaddr = symbol.GetEndAddress()

    and rich comparison methods which allow the API program to use, ::

        if thisModule == thatModule:
            print('This module is the same as that module')

    to test module equality.  A module also contains object file sections, namely
    :py:class:`SBSection` .  SBModule supports section iteration through section_iter(), for
    example, ::

        print('Number of sections: %d' % module.GetNumSections())
        for sec in module.section_iter():
            print(sec)

    And to iterate the symbols within a SBSection, use symbol_in_section_iter(), ::

        # Iterates the text section and prints each symbols within each sub-section.
        for subsec in text_sec:
            print(INDENT + repr(subsec))
            for sym in exe_module.symbol_in_section_iter(subsec):
                print(INDENT2 + repr(sym))
                print(INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType()))

    produces this following output: ::

        [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
            id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870)
            symbol type: code
            id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0)
            symbol type: code
            id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c)
            symbol type: code
            id = {0x00000023}, name = 'start', address = 0x0000000100001780
            symbol type: code
        [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
            id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62)
            symbol type: trampoline
            id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68)
            symbol type: trampoline
            id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e)
            symbol type: trampoline
            id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74)
            symbol type: trampoline
            id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a)
            symbol type: trampoline
            id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80)
            symbol type: trampoline
            id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86)
            symbol type: trampoline
            id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c)
            symbol type: trampoline
            id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92)
            symbol type: trampoline
            id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98)
            symbol type: trampoline
            id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e)
            symbol type: trampoline
            id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4)
            symbol type: trampoline
        [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
        [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
        [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
        [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBModule self) -> SBModule
        __init__(SBModule self, SBModule rhs) -> SBModule
        __init__(SBModule self, SBModuleSpec module_spec) -> SBModule
        __init__(SBModule self, SBProcess process, lldb::addr_t header_addr) -> SBModule
        """
        _lldb.SBModule_swiginit(self, _lldb.new_SBModule(*args))
    __swig_destroy__ = _lldb.delete_SBModule

    def __nonzero__(self):
        return _lldb.SBModule___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBModule self) -> bool"""
        return _lldb.SBModule_IsValid(self)

    def Clear(self):
        r"""Clear(SBModule self)"""
        return _lldb.SBModule_Clear(self)

    def IsFileBacked(self):
        r"""
        IsFileBacked(SBModule self) -> bool

            Check if the module is file backed.

            @return

                True, if the module is backed by an object file on disk.
                False, if the module is backed by an object file in memory.
        """
        return _lldb.SBModule_IsFileBacked(self)

    def GetFileSpec(self):
        r"""
        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.
        """
        return _lldb.SBModule_GetFileSpec(self)

    def GetPlatformFileSpec(self):
        r"""
        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.
        """
        return _lldb.SBModule_GetPlatformFileSpec(self)

    def SetPlatformFileSpec(self, platform_file):
        r"""SetPlatformFileSpec(SBModule self, SBFileSpec platform_file) -> bool"""
        return _lldb.SBModule_SetPlatformFileSpec(self, platform_file)

    def GetRemoteInstallFileSpec(self):
        r"""
        Get accessor for the remote install path for a module.

        When debugging to a remote platform by connecting to a remote
        platform, the install path of the module can be set. If the
        install path is set, every time the process is about to launch
        the target will install this module on the remote platform prior
        to launching.

        :rtype: :py:class:`SBFileSpec`
        :return: 
                A file specification object.
        """
        return _lldb.SBModule_GetRemoteInstallFileSpec(self)

    def SetRemoteInstallFileSpec(self, file):
        r"""
        Set accessor for the remote install path for a module.

        When debugging to a remote platform by connecting to a remote
        platform, the install path of the module can be set. If the
        install path is set, every time the process is about to launch
        the target will install this module on the remote platform prior
        to launching.

        If *file* specifies a full path to an install location, the
        module will be installed to this path. If the path is relative
        (no directory specified, or the path is partial like "usr/lib"
        or "./usr/lib", then the install path will be resolved using
        the platform's current working directory as the base path.

        :type file: :py:class:`SBFileSpec`, in
        :param file:
                A file specification object.
        """
        return _lldb.SBModule_SetRemoteInstallFileSpec(self, file)

    def GetByteOrder(self):
        r"""GetByteOrder(SBModule self) -> lldb::ByteOrder"""
        return _lldb.SBModule_GetByteOrder(self)

    def GetAddressByteSize(self):
        r"""GetAddressByteSize(SBModule self) -> uint32_t"""
        return _lldb.SBModule_GetAddressByteSize(self)

    def GetTriple(self):
        r"""GetTriple(SBModule self) -> char const *"""
        return _lldb.SBModule_GetTriple(self)

    def GetUUIDBytes(self):
        r"""GetUUIDBytes(SBModule self) -> uint8_t const *"""
        return _lldb.SBModule_GetUUIDBytes(self)

    def GetUUIDString(self):
        r"""
        GetUUIDString(SBModule self) -> char const *
        Returns the UUID of the module as a Python string.
        """
        return _lldb.SBModule_GetUUIDString(self)

    def __eq__(self, rhs):
        r"""__eq__(SBModule self, SBModule rhs) -> bool"""
        return _lldb.SBModule___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBModule self, SBModule rhs) -> bool"""
        return _lldb.SBModule___ne__(self, rhs)

    def FindSection(self, sect_name):
        r"""FindSection(SBModule self, char const * sect_name) -> SBSection"""
        return _lldb.SBModule_FindSection(self, sect_name)

    def ResolveFileAddress(self, vm_addr):
        r"""ResolveFileAddress(SBModule self, lldb::addr_t vm_addr) -> SBAddress"""
        return _lldb.SBModule_ResolveFileAddress(self, vm_addr)

    def ResolveSymbolContextForAddress(self, addr, resolve_scope):
        r"""ResolveSymbolContextForAddress(SBModule self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext"""
        return _lldb.SBModule_ResolveSymbolContextForAddress(self, addr, resolve_scope)

    def GetDescription(self, description):
        r"""GetDescription(SBModule self, SBStream description) -> bool"""
        return _lldb.SBModule_GetDescription(self, description)

    def GetNumCompileUnits(self):
        r"""GetNumCompileUnits(SBModule self) -> uint32_t"""
        return _lldb.SBModule_GetNumCompileUnits(self)

    def GetCompileUnitAtIndex(self, arg2):
        r"""GetCompileUnitAtIndex(SBModule self, uint32_t arg2) -> SBCompileUnit"""
        return _lldb.SBModule_GetCompileUnitAtIndex(self, arg2)

    def FindCompileUnits(self, sb_file_spec):
        r"""
        FindCompileUnits(SBModule self, SBFileSpec sb_file_spec) -> SBSymbolContextList

            Find compile units related to this module and passed source
            file.

            @param[in] sb_file_spec
                A :py:class:`SBFileSpec` object that contains source file
                specification.

            @return
                A :py:class:`SBSymbolContextList` that gets filled in with all of
                the symbol contexts for all the matches.
        """
        return _lldb.SBModule_FindCompileUnits(self, sb_file_spec)

    def GetNumSymbols(self):
        r"""GetNumSymbols(SBModule self) -> size_t"""
        return _lldb.SBModule_GetNumSymbols(self)

    def GetSymbolAtIndex(self, idx):
        r"""GetSymbolAtIndex(SBModule self, size_t idx) -> SBSymbol"""
        return _lldb.SBModule_GetSymbolAtIndex(self, idx)

    def FindSymbol(self, *args):
        r"""FindSymbol(SBModule self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbol"""
        return _lldb.SBModule_FindSymbol(self, *args)

    def FindSymbols(self, *args):
        r"""FindSymbols(SBModule self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList"""
        return _lldb.SBModule_FindSymbols(self, *args)

    def GetNumSections(self):
        r"""GetNumSections(SBModule self) -> size_t"""
        return _lldb.SBModule_GetNumSections(self)

    def GetSectionAtIndex(self, idx):
        r"""GetSectionAtIndex(SBModule self, size_t idx) -> SBSection"""
        return _lldb.SBModule_GetSectionAtIndex(self, idx)

    def FindFunctions(self, *args):
        r"""
        FindFunctions(SBModule self, char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> 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.
        """
        return _lldb.SBModule_FindFunctions(self, *args)

    def FindGlobalVariables(self, target, name, max_matches):
        r"""
        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.
        """
        return _lldb.SBModule_FindGlobalVariables(self, target, name, max_matches)

    def FindFirstGlobalVariable(self, target, name):
        r"""
        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).
        """
        return _lldb.SBModule_FindFirstGlobalVariable(self, target, name)

    def FindFirstType(self, name):
        r"""FindFirstType(SBModule self, char const * name) -> SBType"""
        return _lldb.SBModule_FindFirstType(self, name)

    def FindTypes(self, type):
        r"""FindTypes(SBModule self, char const * type) -> SBTypeList"""
        return _lldb.SBModule_FindTypes(self, type)

    def GetTypeByID(self, uid):
        r"""
        Get a type using its type ID.

        Each symbol file reader will assign different user IDs to their
        types, but it is sometimes useful when debugging type issues to
        be able to grab a type using its type ID.

        For DWARF debug info, the type ID is the DIE offset.

        :type uid: int, in
        :param uid:
                The type user ID.

        :rtype: :py:class:`SBType`
        :return: 
                An SBType for the given type ID, or an empty SBType if the
                type was not found.
        """
        return _lldb.SBModule_GetTypeByID(self, uid)

    def GetBasicType(self, type):
        r"""GetBasicType(SBModule self, lldb::BasicType type) -> SBType"""
        return _lldb.SBModule_GetBasicType(self, type)

    def GetTypes(self, *args):
        r"""
        GetTypes(SBModule self, uint32_t type_mask=eTypeClassAny) -> 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
        """
        return _lldb.SBModule_GetTypes(self, *args)

    def GetVersion(self):
        r"""
        Get the module version numbers.

        Many object files have a set of version numbers that describe
        the version of the executable or shared library. Typically there
        are major, minor and build, but there may be more. This function
        will extract the versions from object files if they are available.

        If *versions* is NULL, or if *num_versions* is 0, the return
        value will indicate how many version numbers are available in
        this object file. Then a subsequent call can be made to this
        function with a value of *versions* and *num_versions* that
        has enough storage to store some or all version numbers.

        :type versions: int, out
        :param versions:
                A pointer to an array of uint32_t types that is *num_versions*
                long. If this value is NULL, the return value will indicate
                how many version numbers are required for a subsequent call
                to this function so that all versions can be retrieved. If
                the value is non-NULL, then at most *num_versions* of the
                existing versions numbers will be filled into *versions*.
                If there is no version information available, *versions*
                will be filled with *num_versions* UINT32_MAX values
                and zero will be returned.

        :type num_versions: int, in
        :param num_versions:
                The maximum number of entries to fill into *versions*. If
                this value is zero, then the return value will indicate
                how many version numbers there are in total so another call
                to this function can be make with adequate storage in
                *versions* to get all of the version numbers. If
           *num_versions* is less than the actual number of version
                numbers in this object file, only *num_versions* will be
                filled into *versions* (if *versions* is non-NULL).

        :rtype: int
        :return: 
                This function always returns the number of version numbers
                that this object file has regardless of the number of
                version numbers that were copied into *versions*.
        """
        return _lldb.SBModule_GetVersion(self)

    def GetSymbolFileSpec(self):
        r"""
        Get accessor for the symbol file specification.

        When debugging an object file an additional debug information can
        be provided in separate file. Therefore if you debugging something
        like '/usr/lib/liba.dylib' then debug information can be located
        in folder like '/usr/lib/liba.dylib.dSYM/'.

        :rtype: :py:class:`SBFileSpec`
        :return: 
                A const reference to the file specification object.
        """
        return _lldb.SBModule_GetSymbolFileSpec(self)

    def GetObjectFileHeaderAddress(self):
        r"""GetObjectFileHeaderAddress(SBModule self) -> SBAddress"""
        return _lldb.SBModule_GetObjectFileHeaderAddress(self)

    def GetObjectFileEntryPointAddress(self):
        r"""GetObjectFileEntryPointAddress(SBModule self) -> SBAddress"""
        return _lldb.SBModule_GetObjectFileEntryPointAddress(self)

    @staticmethod
    def GetNumberAllocatedModules():
        r"""
        GetNumberAllocatedModules() -> uint32_t

            Returns the number of modules in the module cache. This is an
            implementation detail exposed for testing and should not be relied upon.

            @return
                The number of modules in the module cache.
        """
        return _lldb.SBModule_GetNumberAllocatedModules()

    @staticmethod
    def GarbageCollectAllocatedModules():
        r"""
        GarbageCollectAllocatedModules()

            Removes all modules which are no longer needed by any part of LLDB from
            the module cache.

            This is an implementation detail exposed for testing and should not be
            relied upon. Use SBDebugger::MemoryPressureDetected instead to reduce
            LLDB's memory consumption during execution.

        """
        return _lldb.SBModule_GarbageCollectAllocatedModules()

    def __repr__(self):
        r"""__repr__(SBModule self) -> std::string"""
        return _lldb.SBModule___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __len__(self):
        '''Return the number of symbols in a lldb.SBModule object.'''
        return self.GetNumSymbols()

    def __iter__(self):
        '''Iterate over all symbols in a lldb.SBModule object.'''
        return lldb_iter(self, 'GetNumSymbols', 'GetSymbolAtIndex')

    def section_iter(self):
        '''Iterate over all sections in a lldb.SBModule object.'''
        return lldb_iter(self, 'GetNumSections', 'GetSectionAtIndex')

    def compile_unit_iter(self):
        '''Iterate over all compile units in a lldb.SBModule object.'''
        return lldb_iter(self, 'GetNumCompileUnits', 'GetCompileUnitAtIndex')

    def symbol_in_section_iter(self, section):
        '''Given a module and its contained section, returns an iterator on the
        symbols within the section.'''
        for sym in self:
            if in_range(sym, section):
                yield sym

    class symbols_access(object):
        re_compile_type = type(re.compile('.'))
        '''A helper object that will lazily hand out lldb.SBSymbol objects for a module when supplied an index, name, or regular expression.'''
        def __init__(self, sbmodule):
            self.sbmodule = sbmodule

        def __len__(self):
            if self.sbmodule:
                return int(self.sbmodule.GetNumSymbols())
            return 0

        def __getitem__(self, key):
            count = len(self)
            if type(key) is int:
                if -count <= key < count:
                    key %= count
                    return self.sbmodule.GetSymbolAtIndex(key)
            elif type(key) is str:
                matches = []
                sc_list = self.sbmodule.FindSymbols(key)
                for sc in sc_list:
                    symbol = sc.symbol
                    if symbol:
                        matches.append(symbol)
                return matches
            elif isinstance(key, self.re_compile_type):
                matches = []
                for idx in range(count):
                    symbol = self.sbmodule.GetSymbolAtIndex(idx)
                    added = False
                    name = symbol.name
                    if name:
                        re_match = key.search(name)
                        if re_match:
                            matches.append(symbol)
                            added = True
                    if not added:
                        mangled = symbol.mangled
                        if mangled:
                            re_match = key.search(mangled)
                            if re_match:
                                matches.append(symbol)
                return matches
            else:
                print("error: unsupported item type: %s" % type(key))
            return None

    def get_symbols_access_object(self):
        '''An accessor function that returns a symbols_access() object which allows lazy symbol access from a lldb.SBModule object.'''
        return self.symbols_access (self)

    def get_compile_units_access_object (self):
        '''An accessor function that returns a compile_units_access() object which allows lazy compile unit access from a lldb.SBModule object.'''
        return self.compile_units_access (self)

    def get_symbols_array(self):
        '''An accessor function that returns a list() that contains all symbols in a lldb.SBModule object.'''
        symbols = []
        for idx in range(self.num_symbols):
            symbols.append(self.GetSymbolAtIndex(idx))
        return symbols

    class sections_access(object):
        re_compile_type = type(re.compile('.'))
        '''A helper object that will lazily hand out lldb.SBSection objects for a module when supplied an index, name, or regular expression.'''
        def __init__(self, sbmodule):
            self.sbmodule = sbmodule

        def __len__(self):
            if self.sbmodule:
                return int(self.sbmodule.GetNumSections())
            return 0

        def __getitem__(self, key):
            count = len(self)
            if type(key) is int:
                if -count <= key < count:
                    key %= count
                    return self.sbmodule.GetSectionAtIndex(key)
            elif type(key) is str:
                for idx in range(count):
                    section = self.sbmodule.GetSectionAtIndex(idx)
                    if section.name == key:
                        return section
            elif isinstance(key, self.re_compile_type):
                matches = []
                for idx in range(count):
                    section = self.sbmodule.GetSectionAtIndex(idx)
                    name = section.name
                    if name:
                        re_match = key.search(name)
                        if re_match:
                            matches.append(section)
                return matches
            else:
                print("error: unsupported item type: %s" % type(key))
            return None

    class compile_units_access(object):
        re_compile_type = type(re.compile('.'))
        '''A helper object that will lazily hand out lldb.SBCompileUnit objects for a module when supplied an index, full or partial path, or regular expression.'''
        def __init__(self, sbmodule):
            self.sbmodule = sbmodule

        def __len__(self):
            if self.sbmodule:
                return int(self.sbmodule.GetNumCompileUnits())
            return 0

        def __getitem__(self, key):
            count = len(self)
            if type(key) is int:
                if -count <= key < count:
                    key %= count
                    return self.sbmodule.GetCompileUnitAtIndex(key)
            elif type(key) is str:
                is_full_path = key[0] == '/'
                for idx in range(count):
                    comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx)
                    if is_full_path:
                        if comp_unit.file.fullpath == key:
                            return comp_unit
                    else:
                        if comp_unit.file.basename == key:
                            return comp_unit
            elif isinstance(key, self.re_compile_type):
                matches = []
                for idx in range(count):
                    comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx)
                    fullpath = comp_unit.file.fullpath
                    if fullpath:
                        re_match = key.search(fullpath)
                        if re_match:
                            matches.append(comp_unit)
                return matches
            else:
                print("error: unsupported item type: %s" % type(key))
            return None

    def get_sections_access_object(self):
        '''An accessor function that returns a sections_access() object which allows lazy section array access.'''
        return self.sections_access (self)

    def get_sections_array(self):
        '''An accessor function that returns an array object that contains all sections in this module object.'''
        if not hasattr(self, 'sections_array'):
            self.sections_array = []
            for idx in range(self.num_sections):
                self.sections_array.append(self.GetSectionAtIndex(idx))
        return self.sections_array

    def get_compile_units_array(self):
        '''An accessor function that returns an array object that contains all compile_units in this module object.'''
        if not hasattr(self, 'compile_units_array'):
            self.compile_units_array = []
            for idx in range(self.GetNumCompileUnits()):
                self.compile_units_array.append(self.GetCompileUnitAtIndex(idx))
        return self.compile_units_array

    symbols = property(get_symbols_array, None, doc='''A read only property that returns a list() of lldb.SBSymbol objects contained in this module.''')
    symbol = property(get_symbols_access_object, None, doc='''A read only property that can be used to access symbols by index ("symbol = module.symbol[0]"), name ("symbols = module.symbol['main']"), or using a regular expression ("symbols = module.symbol[re.compile(...)]"). The return value is a single lldb.SBSymbol object for array access, and a list() of lldb.SBSymbol objects for name and regular expression access''')
    sections = property(get_sections_array, None, doc='''A read only property that returns a list() of lldb.SBSection objects contained in this module.''')
    compile_units = property(get_compile_units_array, None, doc='''A read only property that returns a list() of lldb.SBCompileUnit objects contained in this module.''')
    section = property(get_sections_access_object, None, doc='''A read only property that can be used to access symbols by index ("section = module.section[0]"), name ("sections = module.section[\'main\']"), or using a regular expression ("sections = module.section[re.compile(...)]"). The return value is a single lldb.SBSection object for array access, and a list() of lldb.SBSection objects for name and regular expression access''')
    section = property(get_sections_access_object, None, doc='''A read only property that can be used to access compile units by index ("compile_unit = module.compile_unit[0]"), name ("compile_unit = module.compile_unit[\'main.cpp\']"), or using a regular expression ("compile_unit = module.compile_unit[re.compile(...)]"). The return value is a single lldb.SBCompileUnit object for array access or by full or partial path, and a list() of lldb.SBCompileUnit objects regular expressions.''')

    def get_uuid(self):
        return uuid.UUID (self.GetUUIDString())

    uuid = property(get_uuid, None, doc='''A read only property that returns a standard python uuid.UUID object that represents the UUID of this module.''')
    file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented where it is being debugged.''')
    platform_file = property(GetPlatformFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented on the current host system.''')
    byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this module.''')
    addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this module.''')
    triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this module.''')
    num_symbols = property(GetNumSymbols, None, doc='''A read only property that returns number of symbols in the module symbol table as an integer.''')
    num_sections = property(GetNumSections, None, doc='''A read only property that returns number of sections in the module as an integer.''')



    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBModule in _lldb:
_lldb.SBModule_swigregister(SBModule)
class SBModuleSpec(object):
    r"""Proxy of C++ lldb::SBModuleSpec class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBModuleSpec self) -> SBModuleSpec
        __init__(SBModuleSpec self, SBModuleSpec rhs) -> SBModuleSpec
        """
        _lldb.SBModuleSpec_swiginit(self, _lldb.new_SBModuleSpec(*args))
    __swig_destroy__ = _lldb.delete_SBModuleSpec

    def __nonzero__(self):
        return _lldb.SBModuleSpec___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBModuleSpec self) -> bool"""
        return _lldb.SBModuleSpec_IsValid(self)

    def Clear(self):
        r"""Clear(SBModuleSpec self)"""
        return _lldb.SBModuleSpec_Clear(self)

    def GetFileSpec(self):
        r"""
        GetFileSpec(SBModuleSpec self) -> SBFileSpec

            Get const accessor for the module file.

            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.
        """
        return _lldb.SBModuleSpec_GetFileSpec(self)

    def SetFileSpec(self, fspec):
        r"""SetFileSpec(SBModuleSpec self, SBFileSpec fspec)"""
        return _lldb.SBModuleSpec_SetFileSpec(self, fspec)

    def GetPlatformFileSpec(self):
        r"""
        GetPlatformFileSpec(SBModuleSpec self) -> SBFileSpec

            Get accessor for the module platform file.

            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.
        """
        return _lldb.SBModuleSpec_GetPlatformFileSpec(self)

    def SetPlatformFileSpec(self, fspec):
        r"""SetPlatformFileSpec(SBModuleSpec self, SBFileSpec fspec)"""
        return _lldb.SBModuleSpec_SetPlatformFileSpec(self, fspec)

    def GetSymbolFileSpec(self):
        r"""GetSymbolFileSpec(SBModuleSpec self) -> SBFileSpec"""
        return _lldb.SBModuleSpec_GetSymbolFileSpec(self)

    def SetSymbolFileSpec(self, fspec):
        r"""SetSymbolFileSpec(SBModuleSpec self, SBFileSpec fspec)"""
        return _lldb.SBModuleSpec_SetSymbolFileSpec(self, fspec)

    def GetObjectName(self):
        r"""GetObjectName(SBModuleSpec self) -> char const *"""
        return _lldb.SBModuleSpec_GetObjectName(self)

    def SetObjectName(self, name):
        r"""SetObjectName(SBModuleSpec self, char const * name)"""
        return _lldb.SBModuleSpec_SetObjectName(self, name)

    def GetTriple(self):
        r"""GetTriple(SBModuleSpec self) -> char const *"""
        return _lldb.SBModuleSpec_GetTriple(self)

    def SetTriple(self, triple):
        r"""SetTriple(SBModuleSpec self, char const * triple)"""
        return _lldb.SBModuleSpec_SetTriple(self, triple)

    def GetUUIDBytes(self):
        r"""GetUUIDBytes(SBModuleSpec self) -> uint8_t const *"""
        return _lldb.SBModuleSpec_GetUUIDBytes(self)

    def GetUUIDLength(self):
        r"""GetUUIDLength(SBModuleSpec self) -> size_t"""
        return _lldb.SBModuleSpec_GetUUIDLength(self)

    def SetUUIDBytes(self, uuid, uuid_len):
        r"""SetUUIDBytes(SBModuleSpec self, uint8_t const * uuid, size_t uuid_len) -> bool"""
        return _lldb.SBModuleSpec_SetUUIDBytes(self, uuid, uuid_len)

    def GetObjectOffset(self):
        r"""GetObjectOffset(SBModuleSpec self) -> uint64_t"""
        return _lldb.SBModuleSpec_GetObjectOffset(self)

    def SetObjectOffset(self, object_offset):
        r"""SetObjectOffset(SBModuleSpec self, uint64_t object_offset)"""
        return _lldb.SBModuleSpec_SetObjectOffset(self, object_offset)

    def GetObjectSize(self):
        r"""GetObjectSize(SBModuleSpec self) -> uint64_t"""
        return _lldb.SBModuleSpec_GetObjectSize(self)

    def SetObjectSize(self, object_size):
        r"""SetObjectSize(SBModuleSpec self, uint64_t object_size)"""
        return _lldb.SBModuleSpec_SetObjectSize(self, object_size)

    def GetDescription(self, description):
        r"""GetDescription(SBModuleSpec self, SBStream description) -> bool"""
        return _lldb.SBModuleSpec_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBModuleSpec self) -> std::string"""
        return _lldb.SBModuleSpec___repr__(self)

# Register SBModuleSpec in _lldb:
_lldb.SBModuleSpec_swigregister(SBModuleSpec)
class SBModuleSpecList(object):
    r"""Represents a list of :py:class:`SBModuleSpec`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBModuleSpecList self) -> SBModuleSpecList
        __init__(SBModuleSpecList self, SBModuleSpecList rhs) -> SBModuleSpecList
        """
        _lldb.SBModuleSpecList_swiginit(self, _lldb.new_SBModuleSpecList(*args))
    __swig_destroy__ = _lldb.delete_SBModuleSpecList

    @staticmethod
    def GetModuleSpecifications(path):
        r"""GetModuleSpecifications(char const * path) -> SBModuleSpecList"""
        return _lldb.SBModuleSpecList_GetModuleSpecifications(path)

    def Append(self, *args):
        r"""
        Append(SBModuleSpecList self, SBModuleSpec spec)
        Append(SBModuleSpecList self, SBModuleSpecList spec_list)
        """
        return _lldb.SBModuleSpecList_Append(self, *args)

    def FindFirstMatchingSpec(self, match_spec):
        r"""FindFirstMatchingSpec(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpec"""
        return _lldb.SBModuleSpecList_FindFirstMatchingSpec(self, match_spec)

    def FindMatchingSpecs(self, match_spec):
        r"""FindMatchingSpecs(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpecList"""
        return _lldb.SBModuleSpecList_FindMatchingSpecs(self, match_spec)

    def GetSize(self):
        r"""GetSize(SBModuleSpecList self) -> size_t"""
        return _lldb.SBModuleSpecList_GetSize(self)

    def GetSpecAtIndex(self, i):
        r"""GetSpecAtIndex(SBModuleSpecList self, size_t i) -> SBModuleSpec"""
        return _lldb.SBModuleSpecList_GetSpecAtIndex(self, i)

    def GetDescription(self, description):
        r"""GetDescription(SBModuleSpecList self, SBStream description) -> bool"""
        return _lldb.SBModuleSpecList_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBModuleSpecList self) -> std::string"""
        return _lldb.SBModuleSpecList___repr__(self)

    def __len__(self):
      '''Return the number of ModuleSpec in a lldb.SBModuleSpecList object.'''
      return self.GetSize()

    def __iter__(self):
      '''Iterate over all ModuleSpecs in a lldb.SBModuleSpecList object.'''
      return lldb_iter(self, 'GetSize', 'GetSpecAtIndex')


# Register SBModuleSpecList in _lldb:
_lldb.SBModuleSpecList_swigregister(SBModuleSpecList)
class SBMutex(object):
    r"""Proxy of C++ lldb::SBMutex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBMutex self) -> SBMutex
        __init__(SBMutex self, SBMutex rhs) -> SBMutex
        """
        _lldb.SBMutex_swiginit(self, _lldb.new_SBMutex(*args))
    __swig_destroy__ = _lldb.delete_SBMutex

    def IsValid(self):
        r"""Returns true if this lock has ownership of the underlying mutex."""
        return _lldb.SBMutex_IsValid(self)

    def lock(self):
        r"""Blocking operation that takes ownership of this lock."""
        return _lldb.SBMutex_lock(self)

    def unlock(self):
        r"""Releases ownership of this lock."""
        return _lldb.SBMutex_unlock(self)

    def __enter__(self):
        self.lock()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.unlock()


# Register SBMutex in _lldb:
_lldb.SBMutex_swigregister(SBMutex)
class SBPlatformConnectOptions(object):
    r"""Describes how :py:class:`SBPlatform.ConnectRemote` connects to a remote platform."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBPlatformConnectOptions self, char const * url) -> SBPlatformConnectOptions
        __init__(SBPlatformConnectOptions self, SBPlatformConnectOptions rhs) -> SBPlatformConnectOptions
        """
        _lldb.SBPlatformConnectOptions_swiginit(self, _lldb.new_SBPlatformConnectOptions(*args))
    __swig_destroy__ = _lldb.delete_SBPlatformConnectOptions

    def GetURL(self):
        r"""GetURL(SBPlatformConnectOptions self) -> char const *"""
        return _lldb.SBPlatformConnectOptions_GetURL(self)

    def SetURL(self, url):
        r"""SetURL(SBPlatformConnectOptions self, char const * url)"""
        return _lldb.SBPlatformConnectOptions_SetURL(self, url)

    def GetRsyncEnabled(self):
        r"""GetRsyncEnabled(SBPlatformConnectOptions self) -> bool"""
        return _lldb.SBPlatformConnectOptions_GetRsyncEnabled(self)

    def EnableRsync(self, options, remote_path_prefix, omit_remote_hostname):
        r"""EnableRsync(SBPlatformConnectOptions self, char const * options, char const * remote_path_prefix, bool omit_remote_hostname)"""
        return _lldb.SBPlatformConnectOptions_EnableRsync(self, options, remote_path_prefix, omit_remote_hostname)

    def DisableRsync(self):
        r"""DisableRsync(SBPlatformConnectOptions self)"""
        return _lldb.SBPlatformConnectOptions_DisableRsync(self)

    def GetLocalCacheDirectory(self):
        r"""GetLocalCacheDirectory(SBPlatformConnectOptions self) -> char const *"""
        return _lldb.SBPlatformConnectOptions_GetLocalCacheDirectory(self)

    def SetLocalCacheDirectory(self, path):
        r"""SetLocalCacheDirectory(SBPlatformConnectOptions self, char const * path)"""
        return _lldb.SBPlatformConnectOptions_SetLocalCacheDirectory(self, path)

# Register SBPlatformConnectOptions in _lldb:
_lldb.SBPlatformConnectOptions_swigregister(SBPlatformConnectOptions)
class SBPlatformShellCommand(object):
    r"""Represents a shell command that can be run by :py:class:`SBPlatform.Run`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBPlatformShellCommand self, char const * shell, char const * shell_command) -> SBPlatformShellCommand
        __init__(SBPlatformShellCommand self, char const * shell_command) -> SBPlatformShellCommand
        __init__(SBPlatformShellCommand self, SBPlatformShellCommand rhs) -> SBPlatformShellCommand
        """
        _lldb.SBPlatformShellCommand_swiginit(self, _lldb.new_SBPlatformShellCommand(*args))
    __swig_destroy__ = _lldb.delete_SBPlatformShellCommand

    def Clear(self):
        r"""Clear(SBPlatformShellCommand self)"""
        return _lldb.SBPlatformShellCommand_Clear(self)

    def GetShell(self):
        r"""GetShell(SBPlatformShellCommand self) -> char const *"""
        return _lldb.SBPlatformShellCommand_GetShell(self)

    def SetShell(self, shell):
        r"""SetShell(SBPlatformShellCommand self, char const * shell)"""
        return _lldb.SBPlatformShellCommand_SetShell(self, shell)

    def GetCommand(self):
        r"""GetCommand(SBPlatformShellCommand self) -> char const *"""
        return _lldb.SBPlatformShellCommand_GetCommand(self)

    def SetCommand(self, shell_command):
        r"""SetCommand(SBPlatformShellCommand self, char const * shell_command)"""
        return _lldb.SBPlatformShellCommand_SetCommand(self, shell_command)

    def GetWorkingDirectory(self):
        r"""GetWorkingDirectory(SBPlatformShellCommand self) -> char const *"""
        return _lldb.SBPlatformShellCommand_GetWorkingDirectory(self)

    def SetWorkingDirectory(self, path):
        r"""SetWorkingDirectory(SBPlatformShellCommand self, char const * path)"""
        return _lldb.SBPlatformShellCommand_SetWorkingDirectory(self, path)

    def GetTimeoutSeconds(self):
        r"""GetTimeoutSeconds(SBPlatformShellCommand self) -> uint32_t"""
        return _lldb.SBPlatformShellCommand_GetTimeoutSeconds(self)

    def SetTimeoutSeconds(self, sec):
        r"""SetTimeoutSeconds(SBPlatformShellCommand self, uint32_t sec)"""
        return _lldb.SBPlatformShellCommand_SetTimeoutSeconds(self, sec)

    def GetSignal(self):
        r"""GetSignal(SBPlatformShellCommand self) -> int"""
        return _lldb.SBPlatformShellCommand_GetSignal(self)

    def GetStatus(self):
        r"""GetStatus(SBPlatformShellCommand self) -> int"""
        return _lldb.SBPlatformShellCommand_GetStatus(self)

    def GetOutput(self):
        r"""GetOutput(SBPlatformShellCommand self) -> char const *"""
        return _lldb.SBPlatformShellCommand_GetOutput(self)

# Register SBPlatformShellCommand in _lldb:
_lldb.SBPlatformShellCommand_swigregister(SBPlatformShellCommand)
class SBPlatform(object):
    r"""
    A class that represents a platform that can represent the current host or a remote host debug platform.

    The SBPlatform class represents the current host, or a remote host.
    It can be connected to a remote platform in order to provide ways
    to remotely launch and attach to processes, upload/download files,
    create directories, run remote shell commands, find locally cached
    versions of files from the remote system, and much more.

    SBPlatform objects can be created and then used to connect to a remote
    platform which allows the SBPlatform to be used to get a list of the
    current processes on the remote host, attach to one of those processes,
    install programs on the remote system, attach and launch processes,
    and much more.

    Every :py:class:`SBTarget` has a corresponding SBPlatform. The platform can be
    specified upon target creation, or the currently selected platform
    will attempt to be used when creating the target automatically as long
    as the currently selected platform matches the target architecture
    and executable type. If the architecture or executable type do not match,
    a suitable platform will be found automatically.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBPlatform self) -> SBPlatform
        __init__(SBPlatform self, char const * platform_name) -> SBPlatform
        __init__(SBPlatform self, SBPlatform rhs) -> SBPlatform
        """
        _lldb.SBPlatform_swiginit(self, _lldb.new_SBPlatform(*args))
    __swig_destroy__ = _lldb.delete_SBPlatform

    @staticmethod
    def GetHostPlatform():
        r"""GetHostPlatform() -> SBPlatform"""
        return _lldb.SBPlatform_GetHostPlatform()

    def __nonzero__(self):
        return _lldb.SBPlatform___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBPlatform self) -> bool"""
        return _lldb.SBPlatform_IsValid(self)

    def Clear(self):
        r"""Clear(SBPlatform self)"""
        return _lldb.SBPlatform_Clear(self)

    def GetWorkingDirectory(self):
        r"""GetWorkingDirectory(SBPlatform self) -> char const *"""
        return _lldb.SBPlatform_GetWorkingDirectory(self)

    def SetWorkingDirectory(self, path):
        r"""SetWorkingDirectory(SBPlatform self, char const * path) -> bool"""
        return _lldb.SBPlatform_SetWorkingDirectory(self, path)

    def GetName(self):
        r"""GetName(SBPlatform self) -> char const *"""
        return _lldb.SBPlatform_GetName(self)

    def ConnectRemote(self, connect_options):
        r"""ConnectRemote(SBPlatform self, SBPlatformConnectOptions connect_options) -> SBError"""
        return _lldb.SBPlatform_ConnectRemote(self, connect_options)

    def DisconnectRemote(self):
        r"""DisconnectRemote(SBPlatform self)"""
        return _lldb.SBPlatform_DisconnectRemote(self)

    def IsConnected(self):
        r"""IsConnected(SBPlatform self) -> bool"""
        return _lldb.SBPlatform_IsConnected(self)

    def GetTriple(self):
        r"""GetTriple(SBPlatform self) -> char const *"""
        return _lldb.SBPlatform_GetTriple(self)

    def GetHostname(self):
        r"""GetHostname(SBPlatform self) -> char const *"""
        return _lldb.SBPlatform_GetHostname(self)

    def GetOSBuild(self):
        r"""GetOSBuild(SBPlatform self) -> char const *"""
        return _lldb.SBPlatform_GetOSBuild(self)

    def GetOSDescription(self):
        r"""GetOSDescription(SBPlatform self) -> char const *"""
        return _lldb.SBPlatform_GetOSDescription(self)

    def GetOSMajorVersion(self):
        r"""GetOSMajorVersion(SBPlatform self) -> uint32_t"""
        return _lldb.SBPlatform_GetOSMajorVersion(self)

    def GetOSMinorVersion(self):
        r"""GetOSMinorVersion(SBPlatform self) -> uint32_t"""
        return _lldb.SBPlatform_GetOSMinorVersion(self)

    def GetOSUpdateVersion(self):
        r"""GetOSUpdateVersion(SBPlatform self) -> uint32_t"""
        return _lldb.SBPlatform_GetOSUpdateVersion(self)

    def SetSDKRoot(self, sysroot):
        r"""SetSDKRoot(SBPlatform self, char const * sysroot)"""
        return _lldb.SBPlatform_SetSDKRoot(self, sysroot)

    def Put(self, src, dst):
        r"""Put(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"""
        return _lldb.SBPlatform_Put(self, src, dst)

    def Get(self, src, dst):
        r"""Get(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"""
        return _lldb.SBPlatform_Get(self, src, dst)

    def Install(self, src, dst):
        r"""Install(SBPlatform self, SBFileSpec src, SBFileSpec dst) -> SBError"""
        return _lldb.SBPlatform_Install(self, src, dst)

    def Run(self, shell_command):
        r"""Run(SBPlatform self, SBPlatformShellCommand shell_command) -> SBError"""
        return _lldb.SBPlatform_Run(self, shell_command)

    def Launch(self, launch_info):
        r"""Launch(SBPlatform self, SBLaunchInfo launch_info) -> SBError"""
        return _lldb.SBPlatform_Launch(self, launch_info)

    def Attach(self, attach_info, debugger, target, error):
        r"""Attach(SBPlatform self, SBAttachInfo attach_info, SBDebugger debugger, SBTarget target, SBError error) -> SBProcess"""
        return _lldb.SBPlatform_Attach(self, attach_info, debugger, target, error)

    def GetAllProcesses(self, error):
        r"""GetAllProcesses(SBPlatform self, SBError error) -> SBProcessInfoList"""
        return _lldb.SBPlatform_GetAllProcesses(self, error)

    def Kill(self, pid):
        r"""Kill(SBPlatform self, lldb::pid_t const pid) -> SBError"""
        return _lldb.SBPlatform_Kill(self, pid)

    def MakeDirectory(self, *args):
        r"""MakeDirectory(SBPlatform self, char const * path, uint32_t file_permissions=eFilePermissionsDirectoryDefault) -> SBError"""
        return _lldb.SBPlatform_MakeDirectory(self, *args)

    def GetFilePermissions(self, path):
        r"""GetFilePermissions(SBPlatform self, char const * path) -> uint32_t"""
        return _lldb.SBPlatform_GetFilePermissions(self, path)

    def SetFilePermissions(self, path, file_permissions):
        r"""SetFilePermissions(SBPlatform self, char const * path, uint32_t file_permissions) -> SBError"""
        return _lldb.SBPlatform_SetFilePermissions(self, path, file_permissions)

    def GetUnixSignals(self):
        r"""GetUnixSignals(SBPlatform self) -> SBUnixSignals"""
        return _lldb.SBPlatform_GetUnixSignals(self)

    def GetEnvironment(self):
        r"""
        Return the environment variables of the remote platform connection
        process.

        :rtype: :py:class:`SBEnvironment`
        :return: 
                An lldb::SBEnvironment object which is a copy of the platform's
                environment.
        """
        return _lldb.SBPlatform_GetEnvironment(self)

    def SetLocateModuleCallback(self, callback):
        r"""
        Set a callback as an implementation for locating module in order to
        implement own module cache system. For example, to leverage distributed
        build system, to bypass pulling files from remote platform, or to search
        symbol files from symbol servers. The target will call this callback to
        get a module file and a symbol file, and it will fallback to the LLDB
        implementation when this callback failed or returned non-existent file.
        This callback can set either module_file_spec or symbol_file_spec, or both
        module_file_spec and symbol_file_spec. The callback will be cleared if
        nullptr or None is set.
        """
        return _lldb.SBPlatform_SetLocateModuleCallback(self, callback)

# Register SBPlatform in _lldb:
_lldb.SBPlatform_swigregister(SBPlatform)
class SBProcess(object):
    r"""
    Represents the process associated with the target program.

    SBProcess supports thread iteration. For example (from test/lldbutil.py), ::

        # ==================================================
        # Utility functions related to Threads and Processes
        # ==================================================

        def get_stopped_threads(process, reason):
            '''Returns the thread(s) with the specified stop reason in a list.

            The list can be empty if no such thread exists.
            '''
            threads = []
            for t in process:
                if t.GetStopReason() == reason:
                    threads.append(t)
            return threads

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    eBroadcastBitStateChanged = _lldb.SBProcess_eBroadcastBitStateChanged
    
    eBroadcastBitInterrupt = _lldb.SBProcess_eBroadcastBitInterrupt
    
    eBroadcastBitSTDOUT = _lldb.SBProcess_eBroadcastBitSTDOUT
    
    eBroadcastBitSTDERR = _lldb.SBProcess_eBroadcastBitSTDERR
    
    eBroadcastBitProfileData = _lldb.SBProcess_eBroadcastBitProfileData
    
    eBroadcastBitStructuredData = _lldb.SBProcess_eBroadcastBitStructuredData
    

    def __init__(self, *args):
        r"""
        __init__(SBProcess self) -> SBProcess
        __init__(SBProcess self, SBProcess rhs) -> SBProcess
        """
        _lldb.SBProcess_swiginit(self, _lldb.new_SBProcess(*args))
    __swig_destroy__ = _lldb.delete_SBProcess

    @staticmethod
    def GetBroadcasterClassName():
        r"""GetBroadcasterClassName() -> char const *"""
        return _lldb.SBProcess_GetBroadcasterClassName()

    def GetPluginName(self):
        r"""GetPluginName(SBProcess self) -> char const *"""
        return _lldb.SBProcess_GetPluginName(self)

    def GetShortPluginName(self):
        r"""GetShortPluginName(SBProcess self) -> char const *"""
        return _lldb.SBProcess_GetShortPluginName(self)

    def Clear(self):
        r"""Clear(SBProcess self)"""
        return _lldb.SBProcess_Clear(self)

    def __nonzero__(self):
        return _lldb.SBProcess___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBProcess self) -> bool"""
        return _lldb.SBProcess_IsValid(self)

    def GetTarget(self):
        r"""GetTarget(SBProcess self) -> SBTarget"""
        return _lldb.SBProcess_GetTarget(self)

    def GetByteOrder(self):
        r"""GetByteOrder(SBProcess self) -> lldb::ByteOrder"""
        return _lldb.SBProcess_GetByteOrder(self)

    def PutSTDIN(self, src):
        r"""
        PutSTDIN(SBProcess self, char const * src) -> size_t

            Writes data into the current process's stdin. API client specifies a Python
            string as the only argument.
        """
        return _lldb.SBProcess_PutSTDIN(self, src)

    def GetSTDOUT(self, dst):
        r"""
        GetSTDOUT(SBProcess self, char * dst) -> size_t

            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.
        """
        return _lldb.SBProcess_GetSTDOUT(self, dst)

    def GetSTDERR(self, dst):
        r"""
        GetSTDERR(SBProcess self, char * dst) -> size_t

            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.
        """
        return _lldb.SBProcess_GetSTDERR(self, dst)

    def GetAsyncProfileData(self, dst):
        r"""GetAsyncProfileData(SBProcess self, char * dst) -> size_t"""
        return _lldb.SBProcess_GetAsyncProfileData(self, dst)

    def ReportEventState(self, *args):
        r"""
        ReportEventState(SBProcess self, SBEvent event, SBFile file)
        ReportEventState(SBProcess self, SBEvent event, lldb::FileSP BORROWED)
        """
        return _lldb.SBProcess_ReportEventState(self, *args)

    def AppendEventStateReport(self, event, result):
        r"""AppendEventStateReport(SBProcess self, SBEvent event, SBCommandReturnObject result)"""
        return _lldb.SBProcess_AppendEventStateReport(self, event, result)

    def RemoteAttachToProcessWithID(self, pid, error):
        r"""
        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.
        """
        return _lldb.SBProcess_RemoteAttachToProcessWithID(self, pid, error)

    def RemoteLaunch(self, argv, envp, stdin_path, stdout_path, stderr_path, working_directory, launch_flags, stop_at_entry, error):
        r"""
        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.
        """
        return _lldb.SBProcess_RemoteLaunch(self, argv, envp, stdin_path, stdout_path, stderr_path, working_directory, launch_flags, stop_at_entry, error)

    def GetNumThreads(self):
        r"""GetNumThreads(SBProcess self) -> uint32_t"""
        return _lldb.SBProcess_GetNumThreads(self)

    def GetThreadAtIndex(self, index):
        r"""
        GetThreadAtIndex(SBProcess self, size_t index) -> SBThread

            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.
        """
        return _lldb.SBProcess_GetThreadAtIndex(self, index)

    def GetThreadByID(self, sb_thread_id):
        r"""
        GetThreadByID(SBProcess self, lldb::tid_t sb_thread_id) -> SBThread

            Returns the thread with the given thread ID.
        """
        return _lldb.SBProcess_GetThreadByID(self, sb_thread_id)

    def GetThreadByIndexID(self, index_id):
        r"""
        GetThreadByIndexID(SBProcess self, uint32_t index_id) -> SBThread

            Returns the thread with the given thread IndexID.
        """
        return _lldb.SBProcess_GetThreadByIndexID(self, index_id)

    def GetSelectedThread(self):
        r"""
        GetSelectedThread(SBProcess self) -> SBThread

            Returns the currently selected thread.
        """
        return _lldb.SBProcess_GetSelectedThread(self)

    def CreateOSPluginThread(self, tid, context):
        r"""
        CreateOSPluginThread(SBProcess self, lldb::tid_t tid, lldb::addr_t context) -> SBThread

            Lazily create a thread on demand through the current OperatingSystem plug-in, if the current OperatingSystem plug-in supports it.
        """
        return _lldb.SBProcess_CreateOSPluginThread(self, tid, context)

    def SetSelectedThread(self, thread):
        r"""SetSelectedThread(SBProcess self, SBThread thread) -> bool"""
        return _lldb.SBProcess_SetSelectedThread(self, thread)

    def SetSelectedThreadByID(self, tid):
        r"""SetSelectedThreadByID(SBProcess self, lldb::tid_t tid) -> bool"""
        return _lldb.SBProcess_SetSelectedThreadByID(self, tid)

    def SetSelectedThreadByIndexID(self, index_id):
        r"""SetSelectedThreadByIndexID(SBProcess self, uint32_t index_id) -> bool"""
        return _lldb.SBProcess_SetSelectedThreadByIndexID(self, index_id)

    def GetNumQueues(self):
        r"""GetNumQueues(SBProcess self) -> uint32_t"""
        return _lldb.SBProcess_GetNumQueues(self)

    def GetQueueAtIndex(self, index):
        r"""GetQueueAtIndex(SBProcess self, size_t index) -> SBQueue"""
        return _lldb.SBProcess_GetQueueAtIndex(self, index)

    def GetState(self):
        r"""GetState(SBProcess self) -> lldb::StateType"""
        return _lldb.SBProcess_GetState(self)

    def GetExitStatus(self):
        r"""GetExitStatus(SBProcess self) -> int"""
        return _lldb.SBProcess_GetExitStatus(self)

    def GetExitDescription(self):
        r"""GetExitDescription(SBProcess self) -> char const *"""
        return _lldb.SBProcess_GetExitDescription(self)

    def GetProcessID(self):
        r"""
        GetProcessID(SBProcess self) -> lldb::pid_t

            Returns the process ID of the process.
        """
        return _lldb.SBProcess_GetProcessID(self)

    def GetUniqueID(self):
        r"""
        GetUniqueID(SBProcess self) -> uint32_t

            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.
        """
        return _lldb.SBProcess_GetUniqueID(self)

    def GetAddressByteSize(self):
        r"""GetAddressByteSize(SBProcess self) -> uint32_t"""
        return _lldb.SBProcess_GetAddressByteSize(self)

    def Destroy(self):
        r"""
        Destroy(SBProcess self) -> SBError

            Kills the process and shuts down all threads that were spawned to
            track and monitor process.
        """
        return _lldb.SBProcess_Destroy(self)

    def Continue(self):
        r"""Continue(SBProcess self) -> SBError"""
        return _lldb.SBProcess_Continue(self)

    def ContinueInDirection(self, direction):
        r"""ContinueInDirection(SBProcess self, lldb::RunDirection direction) -> SBError"""
        return _lldb.SBProcess_ContinueInDirection(self, direction)

    def Stop(self):
        r"""Stop(SBProcess self) -> SBError"""
        return _lldb.SBProcess_Stop(self)

    def Kill(self):
        r"""
        Kill(SBProcess self) -> SBError
        Same as Destroy(self).
        """
        return _lldb.SBProcess_Kill(self)

    def Detach(self, *args):
        r"""
        Detach(SBProcess self) -> SBError
        Detach(SBProcess self, bool keep_stopped) -> SBError
        """
        return _lldb.SBProcess_Detach(self, *args)

    def Signal(self, signal):
        r"""
        Signal(SBProcess self, int signal) -> SBError
        Sends the process a unix signal.
        """
        return _lldb.SBProcess_Signal(self, signal)

    def GetUnixSignals(self):
        r"""GetUnixSignals(SBProcess self) -> SBUnixSignals"""
        return _lldb.SBProcess_GetUnixSignals(self)

    def SendAsyncInterrupt(self):
        r"""SendAsyncInterrupt(SBProcess self)"""
        return _lldb.SBProcess_SendAsyncInterrupt(self)

    def GetStopID(self, include_expression_stops=False):
        r"""
        GetStopID(SBProcess self, bool include_expression_stops=False) -> 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.
        """
        return _lldb.SBProcess_GetStopID(self, include_expression_stops)

    def GetStopEventForStopID(self, stop_id):
        r"""
        Gets the stop event corresponding to stop ID.
        Note that it wasn't fully implemented and tracks only the stop
        event for the last natural stop ID.

        :param [in]: stop_id
              The ID of the stop event to return.

        :rtype: :py:class:`SBEvent`
        :return: 
              The stop event corresponding to stop ID.
        """
        return _lldb.SBProcess_GetStopEventForStopID(self, stop_id)

    def ForceScriptedState(self, new_state):
        r"""
        If the process is a scripted process, changes its state to the new state.
        No-op otherwise.

        :param [in]: new_state
              The new state that the scripted process should be set to.
        """
        return _lldb.SBProcess_ForceScriptedState(self, new_state)

    def ReadMemory(self, addr, buf, error):
        r"""
        ReadMemory(SBProcess self, lldb::addr_t addr, void * buf, SBError error) -> size_t

            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)
        """
        return _lldb.SBProcess_ReadMemory(self, addr, buf, error)

    def WriteMemory(self, addr, buf, error):
        r"""
        WriteMemory(SBProcess self, lldb::addr_t addr, void const * buf, SBError error) -> size_t

            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!')
        """
        return _lldb.SBProcess_WriteMemory(self, addr, buf, error)

    def ReadCStringFromMemory(self, addr, char_buf, error):
        r"""
        ReadCStringFromMemory(SBProcess self, lldb::addr_t addr, void * char_buf, SBError error) -> size_t

            Reads a NUL 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)
        """
        return _lldb.SBProcess_ReadCStringFromMemory(self, addr, char_buf, error)

    def ReadUnsignedFromMemory(self, addr, byte_size, error):
        r"""
        ReadUnsignedFromMemory(SBProcess self, lldb::addr_t addr, uint32_t byte_size, SBError error) -> uint64_t

            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)
        """
        return _lldb.SBProcess_ReadUnsignedFromMemory(self, addr, byte_size, error)

    def ReadPointerFromMemory(self, addr, error):
        r"""
        ReadPointerFromMemory(SBProcess self, lldb::addr_t addr, SBError error) -> lldb::addr_t

            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)
        """
        return _lldb.SBProcess_ReadPointerFromMemory(self, addr, error)

    def FindRangesInMemory(self, buf, ranges, alignment, max_matches, error):
        r"""FindRangesInMemory(SBProcess self, void const * buf, SBAddressRangeList ranges, uint32_t alignment, uint32_t max_matches, SBError error) -> SBAddressRangeList"""
        return _lldb.SBProcess_FindRangesInMemory(self, buf, ranges, alignment, max_matches, error)

    def FindInMemory(self, buf, range, alignment, error):
        r"""FindInMemory(SBProcess self, void const * buf, SBAddressRange range, uint32_t alignment, SBError error) -> lldb::addr_t"""
        return _lldb.SBProcess_FindInMemory(self, buf, range, alignment, error)

    @staticmethod
    def GetStateFromEvent(event):
        r"""GetStateFromEvent(SBEvent event) -> lldb::StateType"""
        return _lldb.SBProcess_GetStateFromEvent(event)

    @staticmethod
    def GetRestartedFromEvent(event):
        r"""GetRestartedFromEvent(SBEvent event) -> bool"""
        return _lldb.SBProcess_GetRestartedFromEvent(event)

    @staticmethod
    def GetNumRestartedReasonsFromEvent(event):
        r"""GetNumRestartedReasonsFromEvent(SBEvent event) -> size_t"""
        return _lldb.SBProcess_GetNumRestartedReasonsFromEvent(event)

    @staticmethod
    def GetRestartedReasonAtIndexFromEvent(event, idx):
        r"""GetRestartedReasonAtIndexFromEvent(SBEvent event, size_t idx) -> char const *"""
        return _lldb.SBProcess_GetRestartedReasonAtIndexFromEvent(event, idx)

    @staticmethod
    def GetProcessFromEvent(event):
        r"""GetProcessFromEvent(SBEvent event) -> SBProcess"""
        return _lldb.SBProcess_GetProcessFromEvent(event)

    @staticmethod
    def GetInterruptedFromEvent(event):
        r"""GetInterruptedFromEvent(SBEvent event) -> bool"""
        return _lldb.SBProcess_GetInterruptedFromEvent(event)

    @staticmethod
    def GetStructuredDataFromEvent(event):
        r"""GetStructuredDataFromEvent(SBEvent event) -> SBStructuredData"""
        return _lldb.SBProcess_GetStructuredDataFromEvent(event)

    @staticmethod
    def EventIsProcessEvent(event):
        r"""EventIsProcessEvent(SBEvent event) -> bool"""
        return _lldb.SBProcess_EventIsProcessEvent(event)

    @staticmethod
    def EventIsStructuredDataEvent(event):
        r"""EventIsStructuredDataEvent(SBEvent event) -> bool"""
        return _lldb.SBProcess_EventIsStructuredDataEvent(event)

    def GetBroadcaster(self):
        r"""GetBroadcaster(SBProcess self) -> SBBroadcaster"""
        return _lldb.SBProcess_GetBroadcaster(self)

    @staticmethod
    def GetBroadcasterClass():
        r"""
        GetBroadcasterClass() -> char const *
        Get default process broadcaster class name (lldb.process).
        """
        return _lldb.SBProcess_GetBroadcasterClass()

    def GetDescription(self, description):
        r"""GetDescription(SBProcess self, SBStream description) -> bool"""
        return _lldb.SBProcess_GetDescription(self, description)

    def GetExtendedCrashInformation(self):
        r"""
        GetExtendedCrashInformation(SBProcess self) -> SBStructuredData

            Returns the process' extended crash information.
        """
        return _lldb.SBProcess_GetExtendedCrashInformation(self)

    def GetNumSupportedHardwareWatchpoints(self, error):
        r"""GetNumSupportedHardwareWatchpoints(SBProcess self, SBError error) -> uint32_t"""
        return _lldb.SBProcess_GetNumSupportedHardwareWatchpoints(self, error)

    def LoadImage(self, *args):
        r"""
        *Overload 1:*
        Load a shared library into this process.

        :type remote_image_spec: :py:class:`SBFileSpec`, in
        :param remote_image_spec:
                The path for the shared library on the target what you want
                to load.

        :type error: :py:class:`SBError`, out
        :param error:
                An error object that gets filled in with any errors that
                might occur when trying to load the shared library.

        :rtype: int
        :return: 
                A token that represents the shared library that can be
                later used to unload the shared library. A value of
                LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
                library can't be opened.

        |

        *Overload 2:*
        Load a shared library into this process.

        :type local_image_spec: :py:class:`SBFileSpec`, in
        :param local_image_spec:
                The file spec that points to the shared library that you
                want to load if the library is located on the host. The
                library will be copied over to the location specified by
                remote_image_spec or into the current working directory with
                the same filename if the remote_image_spec isn't specified.

        :type remote_image_spec: :py:class:`SBFileSpec`, in
        :param remote_image_spec:
                If local_image_spec is specified then the location where the
                library should be copied over from the host. If
                local_image_spec isn't specified, then the path for the
                shared library on the target what you want to load.

        :type error: :py:class:`SBError`, out
        :param error:
                An error object that gets filled in with any errors that
                might occur when trying to load the shared library.

        :rtype: int
        :return: 
                A token that represents the shared library that can be
                later used to unload the shared library. A value of
                LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
                library can't be opened.
        """
        return _lldb.SBProcess_LoadImage(self, *args)

    def LoadImageUsingPaths(self, image_spec, paths, loaded_path, error):
        r"""
        LoadImageUsingPaths(SBProcess self, SBFileSpec image_spec, SBStringList paths, SBFileSpec loaded_path, SBError error) -> uint32_t

            Load the library whose filename is given by image_spec looking in all the
            paths supplied in the paths argument.  If successful, return a token that
            can be passed to UnloadImage and fill loaded_path with the path that was
            successfully loaded.  On failure, return
            lldb.LLDB_INVALID_IMAGE_TOKEN.
        """
        return _lldb.SBProcess_LoadImageUsingPaths(self, image_spec, paths, loaded_path, error)

    def UnloadImage(self, image_token):
        r"""UnloadImage(SBProcess self, uint32_t image_token) -> SBError"""
        return _lldb.SBProcess_UnloadImage(self, image_token)

    def SendEventData(self, data):
        r"""SendEventData(SBProcess self, char const * data) -> SBError"""
        return _lldb.SBProcess_SendEventData(self, data)

    def GetNumExtendedBacktraceTypes(self):
        r"""
        GetNumExtendedBacktraceTypes(SBProcess self) -> uint32_t

            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).
        """
        return _lldb.SBProcess_GetNumExtendedBacktraceTypes(self)

    def GetExtendedBacktraceTypeAtIndex(self, idx):
        r"""
        GetExtendedBacktraceTypeAtIndex(SBProcess self, uint32_t idx) -> char const *

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

    def GetHistoryThreads(self, addr):
        r"""GetHistoryThreads(SBProcess self, lldb::addr_t addr) -> SBThreadCollection"""
        return _lldb.SBProcess_GetHistoryThreads(self, addr)

    def IsInstrumentationRuntimePresent(self, type):
        r"""IsInstrumentationRuntimePresent(SBProcess self, lldb::InstrumentationRuntimeType type) -> bool"""
        return _lldb.SBProcess_IsInstrumentationRuntimePresent(self, type)

    def SaveCore(self, *args):
        r"""
        *Overload 1:*
        Save the state of the process in a core file.

        :type file_name: string, in
        :param file_name: - The name of the file to save the core file to.

        :type flavor: string, in
        :param flavor: - Specify the flavor of a core file plug-in to save.
            Currently supported flavors include "mach-o" and "minidump"

        :type core_style: int, in
        :param core_style: - Specify the style of a core file to save.

        |

        *Overload 2:*
        Save the state of the process with the a flavor that matches the
        current process' main executable (if supported).

        :type file_name: string, in
        :param file_name: - The name of the file to save the core file to.

        |

        *Overload 3:*
        Save the state of the process with the desired settings
        as defined in the options object.

        :type options: :py:class:`SBSaveCoreOptions`, in
        :param options: - The options to use when saving the core file.
        """
        return _lldb.SBProcess_SaveCore(self, *args)

    def GetMemoryRegionInfo(self, load_addr, region_info):
        r"""
        Query the address load_addr and store the details of the memory
        region that contains it in the supplied SBMemoryRegionInfo object.
        To iterate over all memory regions use GetMemoryRegionList.

        :type load_addr: int, in
        :param load_addr:
                The address to be queried.

        :type region_info: :py:class:`SBMemoryRegionInfo`, out
        :param region_info:
                A reference to an SBMemoryRegionInfo object that will contain
                the details of the memory region containing load_addr.

        :rtype: :py:class:`SBError`
        :return: 
                An error object describes any errors that occurred while
                querying load_addr.
        """
        return _lldb.SBProcess_GetMemoryRegionInfo(self, load_addr, region_info)

    def GetMemoryRegions(self):
        r"""
        GetMemoryRegions(SBProcess self) -> SBMemoryRegionInfoList

            Get a list of all the memory regions associated with this process. ::

                readable_regions = []
                for region in process.GetMemoryRegions():
                    if region.IsReadable():
                        readable_regions.append(region)


        """
        return _lldb.SBProcess_GetMemoryRegions(self)

    def GetProcessInfo(self):
        r"""
        GetProcessInfo(SBProcess self) -> SBProcessInfo

            Get information about the process.
            Valid process info will only be returned when the process is alive,
            use IsValid() to check if the info returned is valid. ::

                process_info = process.GetProcessInfo()
                if process_info.IsValid():
                    process_info.GetProcessID()
        """
        return _lldb.SBProcess_GetProcessInfo(self)

    def GetCoreFile(self):
        r"""
        Get the file specification for the core file that is currently being used
        for the process. If the process is not loaded from a core file, then an
        invalid file specification will be returned.

        :rtype: :py:class:`SBFileSpec`
        :return: 
                The path to the core file for this target or an invalid file spec if
                the process isn't loaded from a core file.
        """
        return _lldb.SBProcess_GetCoreFile(self)

    def GetAddressMask(self, *args):
        r"""
        GetAddressMask(SBProcess self, lldb::AddressMaskType type, lldb::AddressMaskRange addr_range=eAddressMaskRangeLow) -> lldb::addr_t

            Get the current address mask in this Process of a given type.
            There are lldb.eAddressMaskTypeCode and lldb.eAddressMaskTypeData address
            masks, and on most Targets, the the Data address mask is more general
            because there are no alignment restrictions, as there can be with Code
            addresses.
            lldb.eAddressMaskTypeAny may be used to get the most general mask.
            The bits which are not used for addressing are set to 1 in the returned
            mask.
            In an unusual environment with different address masks for high and low
            memory, this may also be specified.  This is uncommon, default is
            lldb.eAddressMaskRangeLow.
        """
        return _lldb.SBProcess_GetAddressMask(self, *args)

    def SetAddressMask(self, *args):
        r"""
        SetAddressMask(SBProcess self, lldb::AddressMaskType type, lldb::addr_t mask, lldb::AddressMaskRange addr_range=eAddressMaskRangeLow)

            Set the current address mask in this Process for a given type,
            lldb.eAddressMaskTypeCode or lldb.eAddressMaskTypeData.  Bits that are not
            used for addressing should be set to 1 in the mask.
            When setting all masks, lldb.eAddressMaskTypeAll may be specified.
            In an unusual environment with different address masks for high and low
            memory, this may also be specified.  This is uncommon, default is
            lldb.eAddressMaskRangeLow.
        """
        return _lldb.SBProcess_SetAddressMask(self, *args)

    def SetAddressableBits(self, *args):
        r"""
        SetAddressableBits(SBProcess self, lldb::AddressMaskType type, uint32_t num_bits, lldb::AddressMaskRange addr_range=eAddressMaskRangeLow)

            Set the number of low bits relevant for addressing in this Process 
            for a given type, lldb.eAddressMaskTypeCode or lldb.eAddressMaskTypeData.
            When setting all masks, lldb.eAddressMaskTypeAll may be specified.
            In an unusual environment with different address masks for high and low
            memory, the address range  may also be specified.  This is uncommon, 
            default is lldb.eAddressMaskRangeLow.
        """
        return _lldb.SBProcess_SetAddressableBits(self, *args)

    def FixAddress(self, *args):
        r"""
        FixAddress(SBProcess self, lldb::addr_t addr, lldb::AddressMaskType type=eAddressMaskTypeAny) -> lldb::addr_t

            Given a virtual address, clear the bits that are not used for addressing
            (and may be used for metadata, memory tagging, point authentication, etc).
            By default the most general mask, lldb.eAddressMaskTypeAny is used to 
            process the address, but lldb.eAddressMaskTypeData and 
            lldb.eAddressMaskTypeCode may be specified if the type of address is known.
        """
        return _lldb.SBProcess_FixAddress(self, *args)

    def AllocateMemory(self, size, permissions, error):
        r"""
        AllocateMemory(SBProcess self, size_t size, uint32_t permissions, SBError error) -> lldb::addr_t

            Allocates a block of memory within the process, with size and
            access permissions specified in the arguments. The permissions
            argument is an or-combination of zero or more of
            lldb.ePermissionsWritable, lldb.ePermissionsReadable, and
            lldb.ePermissionsExecutable. Returns the address
            of the allocated buffer in the process, or
            lldb.LLDB_INVALID_ADDRESS if the allocation failed.
        """
        return _lldb.SBProcess_AllocateMemory(self, size, permissions, error)

    def DeallocateMemory(self, ptr):
        r"""
        DeallocateMemory(SBProcess self, lldb::addr_t ptr) -> SBError

            Deallocates the block of memory (previously allocated using
            AllocateMemory) given in the argument.
        """
        return _lldb.SBProcess_DeallocateMemory(self, ptr)

    def GetScriptedImplementation(self):
        r"""
        GetScriptedImplementation(SBProcess self) -> SBScriptObject

            Returns the implementation object of the process plugin if available. None
            otherwise.
        """
        return _lldb.SBProcess_GetScriptedImplementation(self)

    def GetStatus(self, status):
        r"""GetStatus(SBProcess self, SBStream status)"""
        return _lldb.SBProcess_GetStatus(self, status)

    def __repr__(self):
        r"""__repr__(SBProcess self) -> std::string"""
        return _lldb.SBProcess___repr__(self)

    def WriteMemoryAsCString(self, addr, str, error):
        '''
          WriteMemoryAsCString(self, addr, str, error):
            This functions the same as `WriteMemory` except a null-terminator is appended
            to the end of the buffer if it is not there already.
        '''
        if not str or len(str) == 0:
            return 0
        if not str[-1] == '\0':
            str += '\0'
        return self.WriteMemory(addr, str, error)

    def __get_is_alive__(self):
        '''Returns "True" if the process is currently alive, "False" otherwise'''
        s = self.GetState()
        if (s == eStateAttaching or
            s == eStateLaunching or
            s == eStateStopped or
            s == eStateRunning or
            s == eStateStepping or
            s == eStateCrashed or
            s == eStateSuspended):
            return True
        return False

    def __get_is_running__(self):
        '''Returns "True" if the process is currently running, "False" otherwise'''
        state = self.GetState()
        if state == eStateRunning or state == eStateStepping:
            return True
        return False

    def __get_is_stopped__(self):
        '''Returns "True" if the process is currently stopped, "False" otherwise'''
        state = self.GetState()
        if state == eStateStopped or state == eStateCrashed or state == eStateSuspended:
            return True
        return False

    class threads_access(object):
        '''A helper object that will lazily hand out thread for a process when supplied an index.'''
        def __init__(self, sbprocess):
            self.sbprocess = sbprocess

        def __len__(self):
            if self.sbprocess:
                return int(self.sbprocess.GetNumThreads())
            return 0

        def __getitem__(self, key):
            if isinstance(key, int):
                count = len(self)
                if -count <= key < count:
                    key %= count
                    return self.sbprocess.GetThreadAtIndex(key)
            return None

    def get_threads_access_object(self):
        '''An accessor function that returns a modules_access() object which allows lazy thread access from a lldb.SBProcess object.'''
        return self.threads_access (self)

    def get_process_thread_list(self):
        '''An accessor function that returns a list() that contains all threads in a lldb.SBProcess object.'''
        threads = []
        accessor = self.get_threads_access_object()
        for idx in range(len(accessor)):
            threads.append(accessor[idx])
        return threads

    def __iter__(self):
        '''Iterate over all threads in a lldb.SBProcess object.'''
        return lldb_iter(self, 'GetNumThreads', 'GetThreadAtIndex')

    def __len__(self):
        '''Return the number of threads in a lldb.SBProcess object.'''
        return self.GetNumThreads()

    def __int__(self):
        return self.GetProcessID()

    threads = property(get_process_thread_list, None, doc='''A read only property that returns a list() of lldb.SBThread objects for this process.''')
    thread = property(get_threads_access_object, None, doc='''A read only property that returns an object that can access threads by thread index (thread = lldb.process.thread[12]).''')
    is_alive = property(__get_is_alive__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently alive.''')
    is_running = property(__get_is_running__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently running.''')
    is_stopped = property(__get_is_stopped__, None, doc='''A read only property that returns a boolean value that indicates if this process is currently stopped.''')
    id = property(GetProcessID, None, doc='''A read only property that returns the process ID as an integer.''')
    target = property(GetTarget, None, doc='''A read only property that an lldb object that represents the target (lldb.SBTarget) that owns this process.''')
    num_threads = property(GetNumThreads, None, doc='''A read only property that returns the number of threads in this process as an integer.''')
    selected_thread = property(GetSelectedThread, SetSelectedThread, doc='''A read/write property that gets/sets the currently selected thread in this process. The getter returns a lldb.SBThread object and the setter takes an lldb.SBThread object.''')
    state = property(GetState, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eState") that represents the current state of this process (running, stopped, exited, etc.).''')
    exit_state = property(GetExitStatus, None, doc='''A read only property that returns an exit status as an integer of this process when the process state is lldb.eStateExited.''')
    exit_description = property(GetExitDescription, None, doc='''A read only property that returns an exit description as a string of this process when the process state is lldb.eStateExited.''')
    broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this process.''')


# Register SBProcess in _lldb:
_lldb.SBProcess_swigregister(SBProcess)
class SBProcessInfo(object):
    r"""
    Describes an existing process and any discoverable information that pertains to
    that process.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBProcessInfo self) -> SBProcessInfo
        __init__(SBProcessInfo self, SBProcessInfo rhs) -> SBProcessInfo
        """
        _lldb.SBProcessInfo_swiginit(self, _lldb.new_SBProcessInfo(*args))
    __swig_destroy__ = _lldb.delete_SBProcessInfo

    def __nonzero__(self):
        return _lldb.SBProcessInfo___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBProcessInfo self) -> bool"""
        return _lldb.SBProcessInfo_IsValid(self)

    def GetName(self):
        r"""GetName(SBProcessInfo self) -> char const *"""
        return _lldb.SBProcessInfo_GetName(self)

    def GetExecutableFile(self):
        r"""GetExecutableFile(SBProcessInfo self) -> SBFileSpec"""
        return _lldb.SBProcessInfo_GetExecutableFile(self)

    def GetProcessID(self):
        r"""GetProcessID(SBProcessInfo self) -> lldb::pid_t"""
        return _lldb.SBProcessInfo_GetProcessID(self)

    def GetUserID(self):
        r"""GetUserID(SBProcessInfo self) -> uint32_t"""
        return _lldb.SBProcessInfo_GetUserID(self)

    def GetGroupID(self):
        r"""GetGroupID(SBProcessInfo self) -> uint32_t"""
        return _lldb.SBProcessInfo_GetGroupID(self)

    def UserIDIsValid(self):
        r"""UserIDIsValid(SBProcessInfo self) -> bool"""
        return _lldb.SBProcessInfo_UserIDIsValid(self)

    def GroupIDIsValid(self):
        r"""GroupIDIsValid(SBProcessInfo self) -> bool"""
        return _lldb.SBProcessInfo_GroupIDIsValid(self)

    def GetEffectiveUserID(self):
        r"""GetEffectiveUserID(SBProcessInfo self) -> uint32_t"""
        return _lldb.SBProcessInfo_GetEffectiveUserID(self)

    def GetEffectiveGroupID(self):
        r"""GetEffectiveGroupID(SBProcessInfo self) -> uint32_t"""
        return _lldb.SBProcessInfo_GetEffectiveGroupID(self)

    def EffectiveUserIDIsValid(self):
        r"""EffectiveUserIDIsValid(SBProcessInfo self) -> bool"""
        return _lldb.SBProcessInfo_EffectiveUserIDIsValid(self)

    def EffectiveGroupIDIsValid(self):
        r"""EffectiveGroupIDIsValid(SBProcessInfo self) -> bool"""
        return _lldb.SBProcessInfo_EffectiveGroupIDIsValid(self)

    def GetParentProcessID(self):
        r"""GetParentProcessID(SBProcessInfo self) -> lldb::pid_t"""
        return _lldb.SBProcessInfo_GetParentProcessID(self)

    def GetTriple(self):
        r"""
        GetTriple(SBProcessInfo self) -> char const *
        Return the target triple (arch-vendor-os) for the described process.
        """
        return _lldb.SBProcessInfo_GetTriple(self)

# Register SBProcessInfo in _lldb:
_lldb.SBProcessInfo_swigregister(SBProcessInfo)
class SBProcessInfoList(object):
    r"""Proxy of C++ lldb::SBProcessInfoList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _lldb.delete_SBProcessInfoList

    def __init__(self, *args):
        r"""
        __init__(SBProcessInfoList self) -> SBProcessInfoList
        __init__(SBProcessInfoList self, SBProcessInfoList rhs) -> SBProcessInfoList
        """
        _lldb.SBProcessInfoList_swiginit(self, _lldb.new_SBProcessInfoList(*args))

    def GetSize(self):
        r"""GetSize(SBProcessInfoList self) -> uint32_t"""
        return _lldb.SBProcessInfoList_GetSize(self)

    def GetProcessInfoAtIndex(self, idx, info):
        r"""GetProcessInfoAtIndex(SBProcessInfoList self, uint32_t idx, SBProcessInfo info) -> bool"""
        return _lldb.SBProcessInfoList_GetProcessInfoAtIndex(self, idx, info)

    def Clear(self):
        r"""Clear(SBProcessInfoList self)"""
        return _lldb.SBProcessInfoList_Clear(self)

    def __len__(self):
      '''Return the number of process info in a lldb.SBProcessInfoListExtensions object.'''
      return self.GetSize()

    def __iter__(self):
      '''Iterate over all the process info in a lldb.SBProcessInfoListExtensions object.'''
      return lldb_iter(self, 'GetSize', 'GetProcessInfoAtIndex')


# Register SBProcessInfoList in _lldb:
_lldb.SBProcessInfoList_swigregister(SBProcessInfoList)
class SBProgress(object):
    r"""
    A Progress indicator helper class.

    Any potentially long running sections of code in LLDB should report
    progress so that clients are aware of delays that might appear during
    debugging. Delays commonly include indexing debug information, parsing
    symbol tables for object files, downloading symbols from remote
    repositories, and many more things.

    The Progress class helps make sure that progress is correctly reported
    and will always send an initial progress update, updates when
    Progress::Increment() is called, and also will make sure that a progress
    completed update is reported even if the user doesn't explicitly cause one
    to be sent.

    Progress can either be deterministic, incrementing up to a known total or non-deterministic
    with an unbounded total. Deterministic is better if you know the items of work in advance, but non-deterministic
    exposes a way to update a user during a long running process that work is taking place.

    For all progresses the details provided in the constructor will be sent until an increment detail
    is provided. This detail will also continue to be broadcasted on any subsequent update that doesn't
    specify a new detail. Some implementations differ on throttling updates and this behavior differs primarily
    if the progress is deterministic or non-deterministic. For DAP, non-deterministic update messages have a higher
    throttling rate than deterministic ones.

    Below are examples in Python for deterministic and non-deterministic progresses. ::

        deterministic_progress1 = lldb.SBProgress('Deterministic Progress', 'Detail', 3, lldb.SBDebugger) 
        for i in range(3): 
            deterministic_progress1.Increment(1, f'Update {i}') 
        # The call to Finalize() is a no-op as we already incremented the right amount of 
        # times and caused the end event to be sent. 
        deterministic_progress1.Finalize()

        deterministic_progress2 = lldb.SBProgress('Deterministic Progress', 'Detail', 10, lldb.SBDebugger) 
        for i in range(3): 
            deterministic_progress2.Increment(1, f'Update {i}')      
        # Cause the progress end event to be sent even if we didn't increment the right 
        # number of times. Real world examples would be in a try-finally block to ensure
        # progress clean-up.
        deterministic_progress2.Finalize() 

    If you don't call Finalize() when the progress is not done, the progress object will eventually get
    garbage collected by the Python runtime, the end event will eventually get sent, but it is best not to 
    rely on the garbage collection when using lldb.SBProgress.

    Non-deterministic progresses behave the same, but omit the total in the constructor. ::

        non_deterministic_progress = lldb.SBProgress('Non deterministic progress', 'Detail', lldb.SBDebugger)
        for i in range(10):
            non_deterministic_progress.Increment(1)
        # Explicitly send a progressEnd, otherwise this will be sent
        # when the python runtime cleans up this object.
        non_deterministic_progress.Finalize()

    Additionally for Python, progress is supported in a with statement. ::
        with lldb.SBProgress('Non deterministic progress', 'Detail', lldb.SBDebugger) as progress:
            for i in range(10):
                progress.Increment(1)
        # The progress object is automatically finalized when the with statement


    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct a progress object with a title, details and a given debugger.
        :type title: string
        :param title:
              The title of the progress object.
        :type details: string
        :param details:
              The details of the progress object.
        :type debugger: :py:class:`SBDebugger`
        :param debugger:
              The debugger for this progress object to report to.

        |

        *Overload 2:*
        Construct a progress object with a title, details, the total units of work
        to be done, and a given debugger.
        :type title: string
        :param title:
              The title of the progress object.
        :type details: string
        :param details:
              The details of the progress object.
        :type total_units: int
        :param total_units:
              The total number of units of work to be done.
        :type debugger: :py:class:`SBDebugger`
        :param debugger:
              The debugger for this progress object to report to.
        """
        _lldb.SBProgress_swiginit(self, _lldb.new_SBProgress(*args))
    __swig_destroy__ = _lldb.delete_SBProgress

    def Increment(self, amount, description=None):
        r"""Increment(SBProgress self, uint64_t amount, char const * description=None)"""
        return _lldb.SBProgress_Increment(self, amount, description)

    def Finalize(self):
        r"""
        Finalize(SBProgress self)
        Finalize the SBProgress, which will cause a progress end event to be emitted. This 
        happens automatically when the SBProcess object is destroyed, but can be done explicitly 
        with Finalize to avoid having to rely on the language semantics for destruction.

        Note once finalized, no further increments will be processed.
        """
        return _lldb.SBProgress_Finalize(self)

    def __enter__(self):
        '''No-op for with statement'''
        pass

    def __exit__(self, exc_type, exc_value, traceback):
        '''Finalize the progress object'''
        self.Finalize()


# Register SBProgress in _lldb:
_lldb.SBProgress_swigregister(SBProgress)
class SBQueue(object):
    r"""Represents a libdispatch queue in the process."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBQueue self) -> SBQueue
        __init__(SBQueue self, SBQueue rhs) -> SBQueue
        """
        _lldb.SBQueue_swiginit(self, _lldb.new_SBQueue(*args))
    __swig_destroy__ = _lldb.delete_SBQueue

    def __nonzero__(self):
        return _lldb.SBQueue___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBQueue self) -> bool"""
        return _lldb.SBQueue_IsValid(self)

    def Clear(self):
        r"""Clear(SBQueue self)"""
        return _lldb.SBQueue_Clear(self)

    def GetProcess(self):
        r"""GetProcess(SBQueue self) -> SBProcess"""
        return _lldb.SBQueue_GetProcess(self)

    def GetQueueID(self):
        r"""
        GetQueueID(SBQueue self) -> lldb::queue_id_t

            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.
        """
        return _lldb.SBQueue_GetQueueID(self)

    def GetName(self):
        r"""GetName(SBQueue self) -> char const *"""
        return _lldb.SBQueue_GetName(self)

    def GetIndexID(self):
        r"""GetIndexID(SBQueue self) -> uint32_t"""
        return _lldb.SBQueue_GetIndexID(self)

    def GetNumThreads(self):
        r"""GetNumThreads(SBQueue self) -> uint32_t"""
        return _lldb.SBQueue_GetNumThreads(self)

    def GetThreadAtIndex(self, arg2):
        r"""GetThreadAtIndex(SBQueue self, uint32_t arg2) -> SBThread"""
        return _lldb.SBQueue_GetThreadAtIndex(self, arg2)

    def GetNumPendingItems(self):
        r"""GetNumPendingItems(SBQueue self) -> uint32_t"""
        return _lldb.SBQueue_GetNumPendingItems(self)

    def GetPendingItemAtIndex(self, arg2):
        r"""GetPendingItemAtIndex(SBQueue self, uint32_t arg2) -> SBQueueItem"""
        return _lldb.SBQueue_GetPendingItemAtIndex(self, arg2)

    def GetNumRunningItems(self):
        r"""GetNumRunningItems(SBQueue self) -> uint32_t"""
        return _lldb.SBQueue_GetNumRunningItems(self)

    def GetKind(self):
        r"""
        GetKind(SBQueue self) -> lldb::QueueKind

            Returns an lldb::QueueKind enumerated value (e.g. eQueueKindUnknown,
            eQueueKindSerial, eQueueKindConcurrent) describing the type of this
            queue.
        """
        return _lldb.SBQueue_GetKind(self)

# Register SBQueue in _lldb:
_lldb.SBQueue_swigregister(SBQueue)
class SBQueueItem(object):
    r"""This class represents an item in an :py:class:`SBQueue`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SBQueueItem self) -> SBQueueItem"""
        _lldb.SBQueueItem_swiginit(self, _lldb.new_SBQueueItem())
    __swig_destroy__ = _lldb.delete_SBQueueItem

    def __nonzero__(self):
        return _lldb.SBQueueItem___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBQueueItem self) -> bool"""
        return _lldb.SBQueueItem_IsValid(self)

    def Clear(self):
        r"""Clear(SBQueueItem self)"""
        return _lldb.SBQueueItem_Clear(self)

    def GetKind(self):
        r"""GetKind(SBQueueItem self) -> lldb::QueueItemKind"""
        return _lldb.SBQueueItem_GetKind(self)

    def SetKind(self, kind):
        r"""SetKind(SBQueueItem self, lldb::QueueItemKind kind)"""
        return _lldb.SBQueueItem_SetKind(self, kind)

    def GetAddress(self):
        r"""GetAddress(SBQueueItem self) -> SBAddress"""
        return _lldb.SBQueueItem_GetAddress(self)

    def SetAddress(self, addr):
        r"""SetAddress(SBQueueItem self, SBAddress addr)"""
        return _lldb.SBQueueItem_SetAddress(self, addr)

    def GetExtendedBacktraceThread(self, type):
        r"""GetExtendedBacktraceThread(SBQueueItem self, char const * type) -> SBThread"""
        return _lldb.SBQueueItem_GetExtendedBacktraceThread(self, type)

    def __hex__(self):
      return self.GetAddress()


# Register SBQueueItem in _lldb:
_lldb.SBQueueItem_swigregister(SBQueueItem)
class SBReproducer(object):
    r"""Controls LLDB's reproducer functionality."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def Capture(path):
        r"""Capture(char const * path) -> char const *"""
        return _lldb.SBReproducer_Capture(path)

    @staticmethod
    def PassiveReplay(path):
        r"""PassiveReplay(char const * path) -> char const *"""
        return _lldb.SBReproducer_PassiveReplay(path)

    @staticmethod
    def SetAutoGenerate(b):
        r"""SetAutoGenerate(bool b) -> bool"""
        return _lldb.SBReproducer_SetAutoGenerate(b)

    @staticmethod
    def SetWorkingDirectory(path):
        r"""
        The working directory is set to the current working directory when the
        reproducers are initialized. This method allows setting a different
        working directory. This is used by the API test suite  which temporarily
        changes the directory to where the test lives. This is a NO-OP in every
        mode but capture.
        """
        return _lldb.SBReproducer_SetWorkingDirectory(path)

    def __init__(self):
        r"""__init__(SBReproducer self) -> SBReproducer"""
        _lldb.SBReproducer_swiginit(self, _lldb.new_SBReproducer())
    __swig_destroy__ = _lldb.delete_SBReproducer

# Register SBReproducer in _lldb:
_lldb.SBReproducer_swigregister(SBReproducer)
class SBScriptObject(object):
    r"""Proxy of C++ lldb::SBScriptObject class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBScriptObject self, lldb::ScriptObjectPtr const ptr, lldb::ScriptLanguage lang) -> SBScriptObject
        __init__(SBScriptObject self, SBScriptObject rhs) -> SBScriptObject
        """
        _lldb.SBScriptObject_swiginit(self, _lldb.new_SBScriptObject(*args))
    __swig_destroy__ = _lldb.delete_SBScriptObject

    def __nonzero__(self):
        return _lldb.SBScriptObject___nonzero__(self)
    __bool__ = __nonzero__



    def __ne__(self, rhs):
        r"""__ne__(SBScriptObject self, SBScriptObject rhs) -> bool"""
        return _lldb.SBScriptObject___ne__(self, rhs)

    def IsValid(self):
        r"""IsValid(SBScriptObject self) -> bool"""
        return _lldb.SBScriptObject_IsValid(self)

    def GetPointer(self):
        r"""GetPointer(SBScriptObject self) -> lldb::ScriptObjectPtr"""
        return _lldb.SBScriptObject_GetPointer(self)

    def GetLanguage(self):
        r"""GetLanguage(SBScriptObject self) -> lldb::ScriptLanguage"""
        return _lldb.SBScriptObject_GetLanguage(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    ptr = property(GetPointer, None, doc='''A read only property that returns the underlying script object.''')
    lang = property(GetLanguage, None, doc='''A read only property that returns the script language associated with with this script object.''')


# Register SBScriptObject in _lldb:
_lldb.SBScriptObject_swigregister(SBScriptObject)
class SBSection(object):
    r"""
    Represents an executable image section.

    SBSection supports iteration through its subsection, represented as SBSection
    as well.  For example, ::

        for sec in exe_module:
            if sec.GetName() == '__TEXT':
                print sec
                break
        print INDENT + 'Number of subsections: %d' % sec.GetNumSubSections()
        for subsec in sec:
            print INDENT + repr(subsec)

    produces: ::

      [0x0000000100000000-0x0000000100002000) a.out.__TEXT
          Number of subsections: 6
          [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
          [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
          [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
          [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
          [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
          [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame

    See also :py:class:`SBModule` .
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBSection self) -> SBSection
        __init__(SBSection self, SBSection rhs) -> SBSection
        """
        _lldb.SBSection_swiginit(self, _lldb.new_SBSection(*args))
    __swig_destroy__ = _lldb.delete_SBSection

    def __nonzero__(self):
        return _lldb.SBSection___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBSection self) -> bool"""
        return _lldb.SBSection_IsValid(self)

    def GetName(self):
        r"""GetName(SBSection self) -> char const *"""
        return _lldb.SBSection_GetName(self)

    def GetParent(self):
        r"""GetParent(SBSection self) -> SBSection"""
        return _lldb.SBSection_GetParent(self)

    def FindSubSection(self, sect_name):
        r"""FindSubSection(SBSection self, char const * sect_name) -> SBSection"""
        return _lldb.SBSection_FindSubSection(self, sect_name)

    def GetNumSubSections(self):
        r"""GetNumSubSections(SBSection self) -> size_t"""
        return _lldb.SBSection_GetNumSubSections(self)

    def GetSubSectionAtIndex(self, idx):
        r"""GetSubSectionAtIndex(SBSection self, size_t idx) -> SBSection"""
        return _lldb.SBSection_GetSubSectionAtIndex(self, idx)

    def GetFileAddress(self):
        r"""GetFileAddress(SBSection self) -> lldb::addr_t"""
        return _lldb.SBSection_GetFileAddress(self)

    def GetLoadAddress(self, target):
        r"""GetLoadAddress(SBSection self, SBTarget target) -> lldb::addr_t"""
        return _lldb.SBSection_GetLoadAddress(self, target)

    def GetByteSize(self):
        r"""GetByteSize(SBSection self) -> lldb::addr_t"""
        return _lldb.SBSection_GetByteSize(self)

    def GetFileOffset(self):
        r"""GetFileOffset(SBSection self) -> uint64_t"""
        return _lldb.SBSection_GetFileOffset(self)

    def GetFileByteSize(self):
        r"""GetFileByteSize(SBSection self) -> uint64_t"""
        return _lldb.SBSection_GetFileByteSize(self)

    def GetSectionData(self, *args):
        r"""
        GetSectionData(SBSection self) -> SBData
        GetSectionData(SBSection self, uint64_t offset, uint64_t size) -> SBData
        """
        return _lldb.SBSection_GetSectionData(self, *args)

    def GetSectionType(self):
        r"""GetSectionType(SBSection self) -> lldb::SectionType"""
        return _lldb.SBSection_GetSectionType(self)

    def GetPermissions(self):
        r"""
        Gets the permissions (RWX) of the section of the object file

        Returns a mask of bits of enum lldb::Permissions for this section.
        Sections for which permissions are not defined, 0 is returned for
        them. The binary representation of this value corresponds to [XRW]
        i.e. for a section having read and execute permissions, the value
        returned is 6

        :rtype: int
        :return: 
                Returns an unsigned value for Permissions for the section.
        """
        return _lldb.SBSection_GetPermissions(self)

    def GetTargetByteSize(self):
        r"""
        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
        """
        return _lldb.SBSection_GetTargetByteSize(self)

    def GetAlignment(self):
        r"""
        Return the alignment of the section in bytes

        :rtype: int
        :return: 
                The alignment of the section in bytes
        """
        return _lldb.SBSection_GetAlignment(self)

    def __eq__(self, rhs):
        r"""__eq__(SBSection self, SBSection rhs) -> bool"""
        return _lldb.SBSection___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBSection self, SBSection rhs) -> bool"""
        return _lldb.SBSection___ne__(self, rhs)

    def GetDescription(self, description):
        r"""GetDescription(SBSection self, SBStream description) -> bool"""
        return _lldb.SBSection_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBSection self) -> std::string"""
        return _lldb.SBSection___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __iter__(self):
        '''Iterate over all subsections in a lldb.SBSection object.'''
        return lldb_iter(self, 'GetNumSubSections', 'GetSubSectionAtIndex')

    def __len__(self):
        '''Return the number of subsections in a lldb.SBSection object.'''
        return self.GetNumSubSections()

    def get_addr(self):
        return SBAddress(self, 0)

    name = property(GetName, None, doc='''A read only property that returns the name of this section as a string.''')
    addr = property(get_addr, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this section.''')
    file_addr = property(GetFileAddress, None, doc='''A read only property that returns an integer that represents the starting "file" address for this section, or the address of the section in the object file in which it is defined.''')
    size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes of this section as an integer.''')
    file_offset = property(GetFileOffset, None, doc='''A read only property that returns the file offset in bytes of this section as an integer.''')
    file_size = property(GetFileByteSize, None, doc='''A read only property that returns the file size in bytes of this section as an integer.''')
    data = property(GetSectionData, None, doc='''A read only property that returns an lldb object that represents the bytes for this section (lldb.SBData) for this section.''')
    type = property(GetSectionType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eSectionType") that represents the type of this section (code, data, etc.).''')
    target_byte_size = property(GetTargetByteSize, None, doc='''A read only property that returns the size of a target byte represented by this section as a number of host bytes.''')
    alignment = property(GetAlignment, None, doc='''A read only property that returns the alignment of this section as a number of host bytes.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBSection in _lldb:
_lldb.SBSection_swigregister(SBSection)
class SBSourceManager(object):
    r"""
    Represents a central authority for displaying source code.

    For example (from test/source-manager/TestSourceManager.py), ::

            # Create the filespec for 'main.c'.
            filespec = lldb.SBFileSpec('main.c', False)
            source_mgr = self.dbg.GetSourceManager()
            # Use a string stream as the destination.
            stream = lldb.SBStream()
            source_mgr.DisplaySourceLinesWithLineNumbers(filespec,
                                                         self.line,
                                                         2, # context before
                                                         2, # context after
                                                         '=>', # prefix for current line
                                                         stream)

            #    2
            #    3    int main(int argc, char const *argv[]) {
            # => 4        printf('Hello world.\n'); // Set break point at this line.
            #    5        return 0;
            #    6    }
            self.expect(stream.GetData(), 'Source code displayed correctly',
                        exe=False,
                patterns = ['=> %d.*Hello world' % self.line])
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBSourceManager self, SBDebugger debugger) -> SBSourceManager
        __init__(SBSourceManager self, SBTarget target) -> SBSourceManager
        __init__(SBSourceManager self, SBSourceManager rhs) -> SBSourceManager
        """
        _lldb.SBSourceManager_swiginit(self, _lldb.new_SBSourceManager(*args))
    __swig_destroy__ = _lldb.delete_SBSourceManager

    def DisplaySourceLinesWithLineNumbers(self, file, line, context_before, context_after, current_line_cstr, s):
        r"""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"""
        return _lldb.SBSourceManager_DisplaySourceLinesWithLineNumbers(self, file, line, context_before, context_after, current_line_cstr, s)

    def DisplaySourceLinesWithLineNumbersAndColumn(self, file, line, column, context_before, context_after, current_line_cstr, s):
        r"""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"""
        return _lldb.SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(self, file, line, column, context_before, context_after, current_line_cstr, s)

# Register SBSourceManager in _lldb:
_lldb.SBSourceManager_swigregister(SBSourceManager)
class SBStatisticsOptions(object):
    r"""A container for options to use when dumping statistics."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBStatisticsOptions self) -> SBStatisticsOptions
        __init__(SBStatisticsOptions self, SBStatisticsOptions rhs) -> SBStatisticsOptions
        """
        _lldb.SBStatisticsOptions_swiginit(self, _lldb.new_SBStatisticsOptions(*args))
    __swig_destroy__ = _lldb.delete_SBStatisticsOptions

    def SetSummaryOnly(self, b):
        r"""
        SetSummaryOnly(SBStatisticsOptions self, bool b)
        Sets whether the statistics should only dump a summary.
        """
        return _lldb.SBStatisticsOptions_SetSummaryOnly(self, b)

    def GetSummaryOnly(self):
        r"""
        GetSummaryOnly(SBStatisticsOptions self) -> bool
        Gets whether the statistics only dump a summary.
        """
        return _lldb.SBStatisticsOptions_GetSummaryOnly(self)

    def SetIncludeTargets(self, b):
        r"""
        If true, dump statistics for the targets, including breakpoints,
        expression evaluations, frame variables, etc.

        Defaults to true, unless the `SummaryOnly` mode is enabled, in which case
        this is turned off unless specified.

        If both `IncludeTargets` and `IncludeModules` are true, a list of module
        identifiers will be added to the "targets" section.
        """
        return _lldb.SBStatisticsOptions_SetIncludeTargets(self, b)

    def GetIncludeTargets(self):
        r"""GetIncludeTargets(SBStatisticsOptions self) -> bool"""
        return _lldb.SBStatisticsOptions_GetIncludeTargets(self)

    def SetIncludeModules(self, b):
        r"""
        If true, dump statistics for the modules, including time and size of
        various aspects of the module and debug information, type system, path,
        etc.

        Defaults to true, unless the `SummaryOnly` mode is enabled, in which case
        this is turned off unless specified.

        If both `IncludeTargets` and `IncludeModules` are true, a list of module
        identifiers will be added to the "targets" section.
        """
        return _lldb.SBStatisticsOptions_SetIncludeModules(self, b)

    def GetIncludeModules(self):
        r"""GetIncludeModules(SBStatisticsOptions self) -> bool"""
        return _lldb.SBStatisticsOptions_GetIncludeModules(self)

    def SetIncludeTranscript(self, b):
        r"""
        If true and the setting `interpreter.save-transcript` is enabled, include
        a JSON array with all commands the user and/or scripts executed during a
        debug session.

        Defaults to false.
        """
        return _lldb.SBStatisticsOptions_SetIncludeTranscript(self, b)

    def GetIncludeTranscript(self):
        r"""GetIncludeTranscript(SBStatisticsOptions self) -> bool"""
        return _lldb.SBStatisticsOptions_GetIncludeTranscript(self)

    def SetReportAllAvailableDebugInfo(self, b):
        r"""
        SetReportAllAvailableDebugInfo(SBStatisticsOptions self, bool b)

            Sets whether the statistics will force loading all possible debug info.
        """
        return _lldb.SBStatisticsOptions_SetReportAllAvailableDebugInfo(self, b)

    def GetReportAllAvailableDebugInfo(self):
        r"""
        GetReportAllAvailableDebugInfo(SBStatisticsOptions self) -> bool

            Gets whether the statistics will force loading all possible debug info.
        """
        return _lldb.SBStatisticsOptions_GetReportAllAvailableDebugInfo(self)

# Register SBStatisticsOptions in _lldb:
_lldb.SBStatisticsOptions_swigregister(SBStatisticsOptions)
class SBStream(object):
    r"""
    Represents a destination for streaming data output to. By default, a string
    stream is created.

    For example (from test/source-manager/TestSourceManager.py), ::

            # Create the filespec for 'main.c'.
            filespec = lldb.SBFileSpec('main.c', False)
            source_mgr = self.dbg.GetSourceManager()
            # Use a string stream as the destination.
            stream = lldb.SBStream()
            source_mgr.DisplaySourceLinesWithLineNumbers(filespec,
                                                         self.line,
                                                         2, # context before
                                                         2, # context after
                                                         '=>', # prefix for current line
                                                         stream)

            #    2
            #    3    int main(int argc, char const *argv[]) {
            # => 4        printf('Hello world.\n'); // Set break point at this line.
            #    5        return 0;
            #    6    }
            self.expect(stream.GetData(), 'Source code displayed correctly',
                        exe=False,
                patterns = ['=> %d.*Hello world' % self.line])
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SBStream self) -> SBStream"""
        _lldb.SBStream_swiginit(self, _lldb.new_SBStream())
    __swig_destroy__ = _lldb.delete_SBStream

    def __nonzero__(self):
        return _lldb.SBStream___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBStream self) -> bool"""
        return _lldb.SBStream_IsValid(self)

    def GetData(self):
        r"""
        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.
        """
        return _lldb.SBStream_GetData(self)

    def GetSize(self):
        r"""
        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.
        """
        return _lldb.SBStream_GetSize(self)

    def Print(self, str):
        r"""Print(SBStream self, char const * str)"""
        return _lldb.SBStream_Print(self, str)

    def RedirectToFile(self, *args):
        r"""
        RedirectToFile(SBStream self, char const * path, bool append)
        RedirectToFile(SBStream self, SBFile file)
        RedirectToFile(SBStream self, lldb::FileSP file)
        """
        return _lldb.SBStream_RedirectToFile(self, *args)

    def RedirectToFileDescriptor(self, fd, transfer_fh_ownership):
        r"""RedirectToFileDescriptor(SBStream self, int fd, bool transfer_fh_ownership)"""
        return _lldb.SBStream_RedirectToFileDescriptor(self, fd, transfer_fh_ownership)

    def Clear(self):
        r"""
        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.
        """
        return _lldb.SBStream_Clear(self)

    def __len__(self):
      return self.GetSize()


    def RedirectToFileHandle(self, file, transfer_fh_ownership):
        r"""DEPRECATED, use RedirectToFile"""
        return _lldb.SBStream_RedirectToFileHandle(self, file, transfer_fh_ownership)

    def write(self, str):
        r"""write(SBStream self, char const * str)"""
        return _lldb.SBStream_write(self, str)

    def flush(self):
        r"""flush(SBStream self)"""
        return _lldb.SBStream_flush(self)

# Register SBStream in _lldb:
_lldb.SBStream_swigregister(SBStream)
class SBStringList(object):
    r"""Represents a list of strings."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBStringList self) -> SBStringList
        __init__(SBStringList self, SBStringList rhs) -> SBStringList
        """
        _lldb.SBStringList_swiginit(self, _lldb.new_SBStringList(*args))
    __swig_destroy__ = _lldb.delete_SBStringList

    def __nonzero__(self):
        return _lldb.SBStringList___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBStringList self) -> bool"""
        return _lldb.SBStringList_IsValid(self)

    def AppendString(self, str):
        r"""AppendString(SBStringList self, char const * str)"""
        return _lldb.SBStringList_AppendString(self, str)

    def AppendList(self, *args):
        r"""
        AppendList(SBStringList self, char const ** strv, int strc)
        AppendList(SBStringList self, SBStringList strings)
        """
        return _lldb.SBStringList_AppendList(self, *args)

    def GetSize(self):
        r"""GetSize(SBStringList self) -> uint32_t"""
        return _lldb.SBStringList_GetSize(self)

    def GetStringAtIndex(self, *args):
        r"""
        GetStringAtIndex(SBStringList self, size_t idx) -> char const
        GetStringAtIndex(SBStringList self, size_t idx) -> char const *
        """
        return _lldb.SBStringList_GetStringAtIndex(self, *args)

    def Clear(self):
        r"""Clear(SBStringList self)"""
        return _lldb.SBStringList_Clear(self)

    def __iter__(self):
        '''Iterate over all strings in a lldb.SBStringList object.'''
        return lldb_iter(self, 'GetSize', 'GetStringAtIndex')

    def __len__(self):
        '''Return the number of strings in a lldb.SBStringList object.'''
        return self.GetSize()


# Register SBStringList in _lldb:
_lldb.SBStringList_swigregister(SBStringList)
class SBStructuredData(object):
    r"""
    A class representing a StructuredData event.

    This class wraps the event type generated by StructuredData features.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBStructuredData self) -> SBStructuredData
        __init__(SBStructuredData self, SBStructuredData rhs) -> SBStructuredData
        __init__(SBStructuredData self, SBScriptObject obj, SBDebugger debugger) -> SBStructuredData
        """
        _lldb.SBStructuredData_swiginit(self, _lldb.new_SBStructuredData(*args))
    __swig_destroy__ = _lldb.delete_SBStructuredData

    def __nonzero__(self):
        return _lldb.SBStructuredData___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBStructuredData self) -> bool"""
        return _lldb.SBStructuredData_IsValid(self)

    def SetFromJSON(self, *args):
        r"""
        SetFromJSON(SBStructuredData self, SBStream stream) -> SBError
        SetFromJSON(SBStructuredData self, char const * json) -> SBError
        """
        return _lldb.SBStructuredData_SetFromJSON(self, *args)

    def Clear(self):
        r"""Clear(SBStructuredData self)"""
        return _lldb.SBStructuredData_Clear(self)

    def GetAsJSON(self, stream):
        r"""GetAsJSON(SBStructuredData self, SBStream stream) -> SBError"""
        return _lldb.SBStructuredData_GetAsJSON(self, stream)

    def GetDescription(self, stream):
        r"""GetDescription(SBStructuredData self, SBStream stream) -> SBError"""
        return _lldb.SBStructuredData_GetDescription(self, stream)

    def GetType(self):
        r"""Return the type of data in this data structure"""
        return _lldb.SBStructuredData_GetType(self)

    def GetSize(self):
        r"""
        Return the size (i.e. number of elements) in this data structure
        if it is an array or dictionary type. For other types, 0 will be
        """
        return _lldb.SBStructuredData_GetSize(self)

    def GetKeys(self, keys):
        r"""
        Fill keys with the keys in this object and return true if this data
        structure is a dictionary.  Returns false otherwise.
        """
        return _lldb.SBStructuredData_GetKeys(self, keys)

    def GetValueForKey(self, key):
        r"""
        Return the value corresponding to a key if this data structure
        is a dictionary type.
        """
        return _lldb.SBStructuredData_GetValueForKey(self, key)

    def GetItemAtIndex(self, idx):
        r"""
        Return the value corresponding to an index if this data structure
        is array.
        """
        return _lldb.SBStructuredData_GetItemAtIndex(self, idx)

    def GetUnsignedIntegerValue(self, fail_value=0):
        r"""Return the integer value if this data structure is an integer type."""
        return _lldb.SBStructuredData_GetUnsignedIntegerValue(self, fail_value)

    def GetSignedIntegerValue(self, fail_value=0):
        r"""Return the integer value if this data structure is an integer type."""
        return _lldb.SBStructuredData_GetSignedIntegerValue(self, fail_value)

    def GetIntegerValue(self, fail_value=0):
        r"""GetIntegerValue(SBStructuredData self, uint64_t fail_value=0) -> uint64_t"""
        return _lldb.SBStructuredData_GetIntegerValue(self, fail_value)

    def GetFloatValue(self, fail_value=0.0):
        r"""
        Return the floating point value if this data structure is a floating
        type.
        """
        return _lldb.SBStructuredData_GetFloatValue(self, fail_value)

    def GetBooleanValue(self, fail_value=False):
        r"""Return the boolean value if this data structure is a boolean type."""
        return _lldb.SBStructuredData_GetBooleanValue(self, fail_value)

    def GetStringValue(self, dst):
        r"""
        Provides the string value if this data structure is a string type.

        :type dst: string, out
        :param dst:
                pointer where the string value will be written. In case it is null,
                nothing will be written at *dst*.

        :type dst_len: int, in
        :param dst_len:
                max number of characters that can be written at *dst*. In case it is
                zero, nothing will be written at *dst*. If this length is not enough
                to write the complete string value, (*dst_len* - 1) bytes of the
                string value will be written at *dst* followed by a null character.

        :rtype: int
        :return: 
                Returns the byte size needed to completely write the string value at
                *dst* in all cases.
        """
        return _lldb.SBStructuredData_GetStringValue(self, dst)

    def GetGenericValue(self):
        r"""Return the generic pointer if this data structure is a generic type."""
        return _lldb.SBStructuredData_GetGenericValue(self)

    def __repr__(self):
        r"""__repr__(SBStructuredData self) -> std::string"""
        return _lldb.SBStructuredData___repr__(self)

    def __int__(self):
      return self.GetSignedInteger()

    def __len__(self):
      '''Return the number of element in a lldb.SBStructuredData object.'''
      return self.GetSize()

    def __iter__(self):
        '''Iterate over all the elements in a lldb.SBStructuredData object.'''
        return lldb_iter(self, 'GetSize', 'GetItemAtIndex')


# Register SBStructuredData in _lldb:
_lldb.SBStructuredData_swigregister(SBStructuredData)
class SBSymbol(object):
    r"""
    Represents the symbol possibly associated with a stack frame.
    :py:class:`SBModule` contains SBSymbol(s). SBSymbol can also be retrieved from :py:class:`SBFrame` .
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __swig_destroy__ = _lldb.delete_SBSymbol

    def __init__(self, *args):
        r"""
        __init__(SBSymbol self) -> SBSymbol
        __init__(SBSymbol self, SBSymbol rhs) -> SBSymbol
        """
        _lldb.SBSymbol_swiginit(self, _lldb.new_SBSymbol(*args))

    def __nonzero__(self):
        return _lldb.SBSymbol___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBSymbol self) -> bool"""
        return _lldb.SBSymbol_IsValid(self)

    def GetName(self):
        r"""GetName(SBSymbol self) -> char const *"""
        return _lldb.SBSymbol_GetName(self)

    def GetDisplayName(self):
        r"""GetDisplayName(SBSymbol self) -> char const *"""
        return _lldb.SBSymbol_GetDisplayName(self)

    def GetMangledName(self):
        r"""GetMangledName(SBSymbol self) -> char const *"""
        return _lldb.SBSymbol_GetMangledName(self)

    def GetInstructions(self, *args):
        r"""
        GetInstructions(SBSymbol self, SBTarget target) -> SBInstructionList
        GetInstructions(SBSymbol self, SBTarget target, char const * flavor_string) -> SBInstructionList
        """
        return _lldb.SBSymbol_GetInstructions(self, *args)

    def GetStartAddress(self):
        r"""
        Get the start address of this symbol

        :rtype: :py:class:`SBAddress`
        :return: 
              If the symbol's value is not an address, an invalid SBAddress object
              will be returned. If the symbol's value is an address, a valid SBAddress
              object will be returned.
        """
        return _lldb.SBSymbol_GetStartAddress(self)

    def GetEndAddress(self):
        r"""
        Get the end address of this symbol

        :rtype: :py:class:`SBAddress`
        :return: 
              If the symbol's value is not an address, an invalid SBAddress object
              will be returned. If the symbol's value is an address, a valid SBAddress
              object will be returned.
        """
        return _lldb.SBSymbol_GetEndAddress(self)

    def GetValue(self):
        r"""
        Get the raw value of a symbol.

        This accessor allows direct access to the symbol's value from the symbol
        table regardless of what the value is. The value can be a file address or
        it can be an integer value that depends on what the symbol's type is. Some
        symbol values are not addresses, but absolute values or integer values
        that can be mean different things. The GetStartAddress() accessor will
        only return a valid SBAddress if the symbol's value is an address, so this
        accessor provides a way to access the symbol's value when the value is
        not an address.

        :rtype: int
        :return: 
              Returns the raw integer value of a symbol from the symbol table.
        """
        return _lldb.SBSymbol_GetValue(self)

    def GetSize(self):
        r"""
        Get the size of the symbol.

        This accessor allows direct access to the symbol's size from the symbol
        table regardless of what the value is (address or integer value).

        :rtype: int
        :return: 
              Returns the size of a symbol from the symbol table.
        """
        return _lldb.SBSymbol_GetSize(self)

    def GetPrologueByteSize(self):
        r"""GetPrologueByteSize(SBSymbol self) -> uint32_t"""
        return _lldb.SBSymbol_GetPrologueByteSize(self)

    def GetType(self):
        r"""GetType(SBSymbol self) -> lldb::SymbolType"""
        return _lldb.SBSymbol_GetType(self)

    def __eq__(self, rhs):
        r"""__eq__(SBSymbol self, SBSymbol rhs) -> bool"""
        return _lldb.SBSymbol___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBSymbol self, SBSymbol rhs) -> bool"""
        return _lldb.SBSymbol___ne__(self, rhs)

    def GetDescription(self, description):
        r"""GetDescription(SBSymbol self, SBStream description) -> bool"""
        return _lldb.SBSymbol_GetDescription(self, description)

    def IsExternal(self):
        r"""IsExternal(SBSymbol self) -> bool"""
        return _lldb.SBSymbol_IsExternal(self)

    def IsSynthetic(self):
        r"""IsSynthetic(SBSymbol self) -> bool"""
        return _lldb.SBSymbol_IsSynthetic(self)

    def __repr__(self):
        r"""__repr__(SBSymbol self) -> std::string"""
        return _lldb.SBSymbol___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __hex__(self):
        return self.GetStartAddress()

    def get_instructions_from_current_target (self):
        return self.GetInstructions (target)

    name = property(GetName, None, doc='''A read only property that returns the name for this symbol as a string.''')
    mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this symbol as a string.''')
    type = property(GetType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eSymbolType") that represents the type of this symbol.''')
    addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this symbol.''')
    end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this symbol.''')
    prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''')
    instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this symbol.''')
    external = property(IsExternal, None, doc='''A read only property that returns a boolean value that indicates if this symbol is externally visiable (exported) from the module that contains it.''')
    synthetic = property(IsSynthetic, None, doc='''A read only property that returns a boolean value that indicates if this symbol was synthetically created from information in module that contains it.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBSymbol in _lldb:
_lldb.SBSymbol_swigregister(SBSymbol)
class SBSymbolContext(object):
    r"""
    A context object that provides access to core debugger entities.

    Many debugger functions require a context when doing lookups. This class
    provides a common structure that can be used as the result of a query that
    can contain a single result.

    For example, ::

            exe = os.path.join(os.getcwd(), 'a.out')

            # Create a target for the debugger.
            target = self.dbg.CreateTarget(exe)

            # Now create a breakpoint on main.c by name 'c'.
            breakpoint = target.BreakpointCreateByName('c', 'a.out')

            # Now launch the process, and do not stop at entry point.
            process = target.LaunchSimple(None, None, os.getcwd())

            # The inferior should stop on 'c'.
            from lldbutil import get_stopped_thread
            thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
            frame0 = thread.GetFrameAtIndex(0)

            # Now get the SBSymbolContext from this frame.  We want everything. :-)
            context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)

            # Get the module.
            module = context.GetModule()
            ...

            # And the compile unit associated with the frame.
            compileUnit = context.GetCompileUnit()
            ...

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBSymbolContext self) -> SBSymbolContext
        __init__(SBSymbolContext self, SBSymbolContext rhs) -> SBSymbolContext
        """
        _lldb.SBSymbolContext_swiginit(self, _lldb.new_SBSymbolContext(*args))
    __swig_destroy__ = _lldb.delete_SBSymbolContext

    def __nonzero__(self):
        return _lldb.SBSymbolContext___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBSymbolContext self) -> bool"""
        return _lldb.SBSymbolContext_IsValid(self)

    def GetModule(self):
        r"""GetModule(SBSymbolContext self) -> SBModule"""
        return _lldb.SBSymbolContext_GetModule(self)

    def GetCompileUnit(self):
        r"""GetCompileUnit(SBSymbolContext self) -> SBCompileUnit"""
        return _lldb.SBSymbolContext_GetCompileUnit(self)

    def GetFunction(self):
        r"""GetFunction(SBSymbolContext self) -> SBFunction"""
        return _lldb.SBSymbolContext_GetFunction(self)

    def GetBlock(self):
        r"""GetBlock(SBSymbolContext self) -> SBBlock"""
        return _lldb.SBSymbolContext_GetBlock(self)

    def GetLineEntry(self):
        r"""GetLineEntry(SBSymbolContext self) -> SBLineEntry"""
        return _lldb.SBSymbolContext_GetLineEntry(self)

    def GetSymbol(self):
        r"""GetSymbol(SBSymbolContext self) -> SBSymbol"""
        return _lldb.SBSymbolContext_GetSymbol(self)

    def SetModule(self, module):
        r"""SetModule(SBSymbolContext self, SBModule module)"""
        return _lldb.SBSymbolContext_SetModule(self, module)

    def SetCompileUnit(self, compile_unit):
        r"""SetCompileUnit(SBSymbolContext self, SBCompileUnit compile_unit)"""
        return _lldb.SBSymbolContext_SetCompileUnit(self, compile_unit)

    def SetFunction(self, function):
        r"""SetFunction(SBSymbolContext self, SBFunction function)"""
        return _lldb.SBSymbolContext_SetFunction(self, function)

    def SetBlock(self, block):
        r"""SetBlock(SBSymbolContext self, SBBlock block)"""
        return _lldb.SBSymbolContext_SetBlock(self, block)

    def SetLineEntry(self, line_entry):
        r"""SetLineEntry(SBSymbolContext self, SBLineEntry line_entry)"""
        return _lldb.SBSymbolContext_SetLineEntry(self, line_entry)

    def SetSymbol(self, symbol):
        r"""SetSymbol(SBSymbolContext self, SBSymbol symbol)"""
        return _lldb.SBSymbolContext_SetSymbol(self, symbol)

    def GetParentOfInlinedScope(self, curr_frame_pc, parent_frame_addr):
        r"""GetParentOfInlinedScope(SBSymbolContext self, SBAddress curr_frame_pc, SBAddress parent_frame_addr) -> SBSymbolContext"""
        return _lldb.SBSymbolContext_GetParentOfInlinedScope(self, curr_frame_pc, parent_frame_addr)

    def GetDescription(self, description):
        r"""GetDescription(SBSymbolContext self, SBStream description) -> bool"""
        return _lldb.SBSymbolContext_GetDescription(self, description)

    def __repr__(self):
        r"""__repr__(SBSymbolContext self) -> std::string"""
        return _lldb.SBSymbolContext___repr__(self)

    module = property(GetModule, SetModule, doc='''A read/write property that allows the getting/setting of the module (lldb.SBModule) in this symbol context.''')
    compile_unit = property(GetCompileUnit, SetCompileUnit, doc='''A read/write property that allows the getting/setting of the compile unit (lldb.SBCompileUnit) in this symbol context.''')
    function = property(GetFunction, SetFunction, doc='''A read/write property that allows the getting/setting of the function (lldb.SBFunction) in this symbol context.''')
    block = property(GetBlock, SetBlock, doc='''A read/write property that allows the getting/setting of the block (lldb.SBBlock) in this symbol context.''')
    symbol = property(GetSymbol, SetSymbol, doc='''A read/write property that allows the getting/setting of the symbol (lldb.SBSymbol) in this symbol context.''')
    line_entry = property(GetLineEntry, SetLineEntry, doc='''A read/write property that allows the getting/setting of the line entry (lldb.SBLineEntry) in this symbol context.''')


# Register SBSymbolContext in _lldb:
_lldb.SBSymbolContext_swigregister(SBSymbolContext)
class SBSymbolContextList(object):
    r"""
    Represents a list of symbol context object. See also SBSymbolContext.

    For example (from test/python_api/target/TestTargetAPI.py), ::

        def find_functions(self, exe_name):
            '''Exercise SBTarget.FindFunctions() API.'''
            exe = os.path.join(os.getcwd(), exe_name)

            # Create a target by the debugger.
            target = self.dbg.CreateTarget(exe)
            self.assertTrue(target, VALID_TARGET)

            list = lldb.SBSymbolContextList()
            num = target.FindFunctions('c', lldb.eFunctionNameTypeAuto, False, list)
            self.assertTrue(num == 1 and list.GetSize() == 1)

            for sc in list:
                self.assertTrue(sc.GetModule().GetFileSpec().GetFilename() == exe_name)
                self.assertTrue(sc.GetSymbol().GetName() == 'c')
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBSymbolContextList self) -> SBSymbolContextList
        __init__(SBSymbolContextList self, SBSymbolContextList rhs) -> SBSymbolContextList
        """
        _lldb.SBSymbolContextList_swiginit(self, _lldb.new_SBSymbolContextList(*args))
    __swig_destroy__ = _lldb.delete_SBSymbolContextList

    def __nonzero__(self):
        return _lldb.SBSymbolContextList___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBSymbolContextList self) -> bool"""
        return _lldb.SBSymbolContextList_IsValid(self)

    def GetSize(self):
        r"""GetSize(SBSymbolContextList self) -> uint32_t"""
        return _lldb.SBSymbolContextList_GetSize(self)

    def GetContextAtIndex(self, idx):
        r"""GetContextAtIndex(SBSymbolContextList self, uint32_t idx) -> SBSymbolContext"""
        return _lldb.SBSymbolContextList_GetContextAtIndex(self, idx)

    def GetDescription(self, description):
        r"""GetDescription(SBSymbolContextList self, SBStream description) -> bool"""
        return _lldb.SBSymbolContextList_GetDescription(self, description)

    def Append(self, *args):
        r"""
        Append(SBSymbolContextList self, SBSymbolContext sc)
        Append(SBSymbolContextList self, SBSymbolContextList sc_list)
        """
        return _lldb.SBSymbolContextList_Append(self, *args)

    def Clear(self):
        r"""Clear(SBSymbolContextList self)"""
        return _lldb.SBSymbolContextList_Clear(self)

    def __repr__(self):
        r"""__repr__(SBSymbolContextList self) -> std::string"""
        return _lldb.SBSymbolContextList___repr__(self)

    def __iter__(self):
        '''Iterate over all symbol contexts in a lldb.SBSymbolContextList
        object.'''
        return lldb_iter(self, 'GetSize', 'GetContextAtIndex')

    def __len__(self):
        return int(self.GetSize())

    def __getitem__(self, key):
        count = len(self)
        if isinstance(key, int):
            if -count <= key < count:
                key %= count
                return self.GetContextAtIndex(key)
            else:
                raise IndexError
        raise TypeError

    def get_module_array(self):
        a = []
        for i in range(len(self)):
            obj = self.GetContextAtIndex(i).module
            if obj:
                a.append(obj)
        return a

    def get_compile_unit_array(self):
        a = []
        for i in range(len(self)):
            obj = self.GetContextAtIndex(i).compile_unit
            if obj:
                a.append(obj)
        return a
    def get_function_array(self):
        a = []
        for i in range(len(self)):
            obj = self.GetContextAtIndex(i).function
            if obj:
                a.append(obj)
        return a
    def get_block_array(self):
        a = []
        for i in range(len(self)):
            obj = self.GetContextAtIndex(i).block
            if obj:
                a.append(obj)
        return a
    def get_symbol_array(self):
        a = []
        for i in range(len(self)):
            obj = self.GetContextAtIndex(i).symbol
            if obj:
                a.append(obj)
        return a
    def get_line_entry_array(self):
        a = []
        for i in range(len(self)):
            obj = self.GetContextAtIndex(i).line_entry
            if obj:
                a.append(obj)
        return a

    modules = property(get_module_array, None, doc='''Returns a list() of lldb.SBModule objects, one for each module in each SBSymbolContext object in this list.''')
    compile_units = property(get_compile_unit_array, None, doc='''Returns a list() of lldb.SBCompileUnit objects, one for each compile unit in each SBSymbolContext object in this list.''')
    functions = property(get_function_array, None, doc='''Returns a list() of lldb.SBFunction objects, one for each function in each SBSymbolContext object in this list.''')
    blocks = property(get_block_array, None, doc='''Returns a list() of lldb.SBBlock objects, one for each block in each SBSymbolContext object in this list.''')
    line_entries = property(get_line_entry_array, None, doc='''Returns a list() of lldb.SBLineEntry objects, one for each line entry in each SBSymbolContext object in this list.''')
    symbols = property(get_symbol_array, None, doc='''Returns a list() of lldb.SBSymbol objects, one for each symbol in each SBSymbolContext object in this list.''')


# Register SBSymbolContextList in _lldb:
_lldb.SBSymbolContextList_swigregister(SBSymbolContextList)
class SBTarget(object):
    r"""
    Represents the target program running under the debugger.

    SBTarget supports module, breakpoint, and watchpoint iterations. For example, ::

        for m in target.module_iter():
            print m

    produces: ::

        (x86_64) /Volumes/data/lldb/svn/trunk/test/python_api/lldbutil/iter/a.out
        (x86_64) /usr/lib/dyld
        (x86_64) /usr/lib/libstdc++.6.dylib
        (x86_64) /usr/lib/libSystem.B.dylib
        (x86_64) /usr/lib/system/libmathCommon.A.dylib
        (x86_64) /usr/lib/libSystem.B.dylib(__commpage)

    and, ::

        for b in target.breakpoint_iter():
            print b

    produces: ::

        SBBreakpoint: id = 1, file ='main.cpp', line = 66, locations = 1
        SBBreakpoint: id = 2, file ='main.cpp', line = 85, locations = 1

    and, ::

        for wp_loc in target.watchpoint_iter():
            print wp_loc

    produces: ::

        Watchpoint 1: addr = 0x1034ca048 size = 4 state = enabled type = rw
            declare @ '/Volumes/data/lldb/svn/trunk/test/python_api/watchpoint/main.c:12'
            hit_count = 2     ignore_count = 0
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    eBroadcastBitBreakpointChanged = _lldb.SBTarget_eBroadcastBitBreakpointChanged
    
    eBroadcastBitModulesLoaded = _lldb.SBTarget_eBroadcastBitModulesLoaded
    
    eBroadcastBitModulesUnloaded = _lldb.SBTarget_eBroadcastBitModulesUnloaded
    
    eBroadcastBitWatchpointChanged = _lldb.SBTarget_eBroadcastBitWatchpointChanged
    
    eBroadcastBitSymbolsLoaded = _lldb.SBTarget_eBroadcastBitSymbolsLoaded
    
    eBroadcastBitSymbolsChanged = _lldb.SBTarget_eBroadcastBitSymbolsChanged
    

    def __init__(self, *args):
        r"""
        __init__(SBTarget self) -> SBTarget
        __init__(SBTarget self, SBTarget rhs) -> SBTarget
        """
        _lldb.SBTarget_swiginit(self, _lldb.new_SBTarget(*args))
    __swig_destroy__ = _lldb.delete_SBTarget

    def __nonzero__(self):
        return _lldb.SBTarget___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTarget self) -> bool"""
        return _lldb.SBTarget_IsValid(self)

    @staticmethod
    def EventIsTargetEvent(event):
        r"""EventIsTargetEvent(SBEvent event) -> bool"""
        return _lldb.SBTarget_EventIsTargetEvent(event)

    @staticmethod
    def GetTargetFromEvent(event):
        r"""GetTargetFromEvent(SBEvent event) -> SBTarget"""
        return _lldb.SBTarget_GetTargetFromEvent(event)

    @staticmethod
    def GetNumModulesFromEvent(event):
        r"""GetNumModulesFromEvent(SBEvent event) -> uint32_t"""
        return _lldb.SBTarget_GetNumModulesFromEvent(event)

    @staticmethod
    def GetModuleAtIndexFromEvent(idx, event):
        r"""GetModuleAtIndexFromEvent(uint32_t const idx, SBEvent event) -> SBModule"""
        return _lldb.SBTarget_GetModuleAtIndexFromEvent(idx, event)

    @staticmethod
    def GetBroadcasterClassName():
        r"""GetBroadcasterClassName() -> char const *"""
        return _lldb.SBTarget_GetBroadcasterClassName()

    def GetProcess(self):
        r"""GetProcess(SBTarget self) -> SBProcess"""
        return _lldb.SBTarget_GetProcess(self)

    def SetCollectingStats(self, v):
        r"""
        Sets whether we should collect statistics on lldb or not.

        :type v: boolean, in
        :param v:
                A boolean to control the collection.
        """
        return _lldb.SBTarget_SetCollectingStats(self, v)

    def GetCollectingStats(self):
        r"""
        Returns whether statistics collection are enabled.

        :rtype: boolean
        :return: 
                true if statistics are currently being collected, false
                otherwise.
        """
        return _lldb.SBTarget_GetCollectingStats(self)

    def GetStatistics(self, *args):
        r"""
        *Overload 1:*
        Returns a dump of the collected statistics.

        :rtype: :py:class:`SBStructuredData`
        :return: 
                A SBStructuredData with the statistics collected.

        |

        *Overload 2:*
        Returns a dump of the collected statistics.

        :type options: :py:class:`SBStatisticsOptions`, in
        :param options:
              An objects object that contains all options for the statistics dumping.

        :rtype: :py:class:`SBStructuredData`
        :return: 
                A SBStructuredData with the statistics collected.
        """
        return _lldb.SBTarget_GetStatistics(self, *args)

    def ResetStatistics(self):
        r"""
        Reset the statistics collected for this target.
        This includes clearing symbol table and debug info parsing/index time for
        all modules, breakpoint resolve time and target statistics.
        """
        return _lldb.SBTarget_ResetStatistics(self)

    def GetPlatform(self):
        r"""
        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.
        """
        return _lldb.SBTarget_GetPlatform(self)

    def GetEnvironment(self):
        r"""
        Return the environment variables that would be used to launch a new
        process.

        :rtype: :py:class:`SBEnvironment`
        :return: 
                An lldb::SBEnvironment object which is a copy of the target's
                environment.
        """
        return _lldb.SBTarget_GetEnvironment(self)

    def Install(self):
        r"""
        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.
        """
        return _lldb.SBTarget_Install(self)

    def LoadCore(self, *args):
        r"""
        LoadCore(SBTarget self, char const * core_file) -> SBProcess
        LoadCore(SBTarget self, char const * core_file, SBError error) -> SBProcess

            Load a core file

            @param[in] core_file
                File path of the core dump.

            @param[out] error
                An error explaining what went wrong if the operation fails.
                (Optional)

            @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.
        """
        return _lldb.SBTarget_LoadCore(self, *args)

    def LaunchSimple(self, argv, envp, working_directory):
        r"""
        LaunchSimple(SBTarget self, char const ** argv, char const ** envp, char const * working_directory) -> SBProcess

            Launch a new process with sensible defaults.

            :param argv: The argument array.
            :param envp: The environment array.
            :param working_directory: The working directory to have the child process run in
            :return: The newly created process.
            :rtype: SBProcess

            A pseudo terminal will be used as stdin/stdout/stderr.
            No launch flags are passed and the target's debuger is used as a listener.

            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.
        """
        return _lldb.SBTarget_LaunchSimple(self, argv, envp, working_directory)

    def Launch(self, *args):
        r"""
        Launch(SBTarget self, 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
        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.
        """
        return _lldb.SBTarget_Launch(self, *args)

    def Attach(self, attach_info, error):
        r"""Attach(SBTarget self, SBAttachInfo attach_info, SBError error) -> SBProcess"""
        return _lldb.SBTarget_Attach(self, attach_info, error)

    def AttachToProcessWithID(self, listener, pid, error):
        r"""
        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.
        """
        return _lldb.SBTarget_AttachToProcessWithID(self, listener, pid, error)

    def AttachToProcessWithName(self, listener, name, wait_for, error):
        r"""
        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.
        """
        return _lldb.SBTarget_AttachToProcessWithName(self, listener, name, wait_for, error)

    def ConnectRemote(self, listener, url, plugin_name, error):
        r"""
        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.
        """
        return _lldb.SBTarget_ConnectRemote(self, listener, url, plugin_name, error)

    def GetExecutable(self):
        r"""GetExecutable(SBTarget self) -> SBFileSpec"""
        return _lldb.SBTarget_GetExecutable(self)

    def AppendImageSearchPath(self, _from, to, error):
        r"""
        AppendImageSearchPath(SBTarget self, char const * _from, char const * to, SBError error)

            Append the path mapping (from -> to) to the target's paths mapping list.
        """
        return _lldb.SBTarget_AppendImageSearchPath(self, _from, to, error)

    def AddModule(self, *args):
        r"""
        AddModule(SBTarget self, SBModule module) -> bool
        AddModule(SBTarget self, char const * path, char const * triple, char const * uuid) -> SBModule
        AddModule(SBTarget self, char const * path, char const * triple, char const * uuid_cstr, char const * symfile) -> SBModule
        AddModule(SBTarget self, SBModuleSpec module_spec) -> SBModule
        """
        return _lldb.SBTarget_AddModule(self, *args)

    def GetNumModules(self):
        r"""GetNumModules(SBTarget self) -> uint32_t"""
        return _lldb.SBTarget_GetNumModules(self)

    def GetModuleAtIndex(self, idx):
        r"""GetModuleAtIndex(SBTarget self, uint32_t idx) -> SBModule"""
        return _lldb.SBTarget_GetModuleAtIndex(self, idx)

    def RemoveModule(self, module):
        r"""RemoveModule(SBTarget self, SBModule module) -> bool"""
        return _lldb.SBTarget_RemoveModule(self, module)

    def GetDebugger(self):
        r"""GetDebugger(SBTarget self) -> SBDebugger"""
        return _lldb.SBTarget_GetDebugger(self)

    def FindModule(self, file_spec):
        r"""FindModule(SBTarget self, SBFileSpec file_spec) -> SBModule"""
        return _lldb.SBTarget_FindModule(self, file_spec)

    def FindCompileUnits(self, sb_file_spec):
        r"""
        FindCompileUnits(SBTarget self, SBFileSpec sb_file_spec) -> SBSymbolContextList

            Find compile units related to this target and passed source
            file.

            :param sb_file_spec: A :py:class:`lldb::SBFileSpec` object that contains source file
                specification.
            :return: The symbol contexts for all the matches.
            :rtype: SBSymbolContextList
        """
        return _lldb.SBTarget_FindCompileUnits(self, sb_file_spec)

    def GetByteOrder(self):
        r"""GetByteOrder(SBTarget self) -> lldb::ByteOrder"""
        return _lldb.SBTarget_GetByteOrder(self)

    def GetAddressByteSize(self):
        r"""GetAddressByteSize(SBTarget self) -> uint32_t"""
        return _lldb.SBTarget_GetAddressByteSize(self)

    def GetTriple(self):
        r"""GetTriple(SBTarget self) -> char const *"""
        return _lldb.SBTarget_GetTriple(self)

    def GetABIName(self):
        r"""GetABIName(SBTarget self) -> char const *"""
        return _lldb.SBTarget_GetABIName(self)

    def GetLabel(self):
        r"""GetLabel(SBTarget self) -> char const *"""
        return _lldb.SBTarget_GetLabel(self)

    def SetLabel(self, label):
        r"""SetLabel(SBTarget self, char const * label) -> SBError"""
        return _lldb.SBTarget_SetLabel(self, label)

    def GetMinimumOpcodeByteSize(self):
        r"""
        Architecture opcode byte size width accessor

        :rtype: int
        :return: 
            The minimum size in 8-bit (host) bytes of an opcode.
        """
        return _lldb.SBTarget_GetMinimumOpcodeByteSize(self)

    def GetMaximumOpcodeByteSize(self):
        r"""
        Architecture opcode byte size width accessor

        :rtype: int
        :return: 
            The maximum size in 8-bit (host) bytes of an opcode.
        """
        return _lldb.SBTarget_GetMaximumOpcodeByteSize(self)

    def GetDataByteSize(self):
        r"""
        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.


        """
        return _lldb.SBTarget_GetDataByteSize(self)

    def GetCodeByteSize(self):
        r"""
        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.


        """
        return _lldb.SBTarget_GetCodeByteSize(self)

    def GetMaximumNumberOfChildrenToDisplay(self):
        r"""
        Gets the target.max-children-count value
        It should be used to limit the number of
        children of large data structures to be displayed.
        """
        return _lldb.SBTarget_GetMaximumNumberOfChildrenToDisplay(self)

    def SetSectionLoadAddress(self, section, section_base_addr):
        r"""
        Set the base load address for a module section.

        :type section: :py:class:`SBSection`, in
        :param section:
                The section whose base load address will be set within this
                target.

        :type section_base_addr: int, in
        :param section_base_addr:
                The base address for the section.

        :rtype: :py:class:`SBError`
        :return: 
                 An error to indicate success, fail, and any reason for
                failure.
        """
        return _lldb.SBTarget_SetSectionLoadAddress(self, section, section_base_addr)

    def ClearSectionLoadAddress(self, section):
        r"""
        Clear the base load address for a module section.

        :type section: :py:class:`SBSection`, in
        :param section:
                The section whose base load address will be cleared within
                this target.

        :rtype: :py:class:`SBError`
        :return: 
                 An error to indicate success, fail, and any reason for
                failure.
        """
        return _lldb.SBTarget_ClearSectionLoadAddress(self, section)

    def SetModuleLoadAddress(self, module, sections_offset):
        r"""
        Slide all file addresses for all module sections so that *module*
        appears to loaded at these slide addresses.

        When you need all sections within a module to be loaded at a
        rigid slide from the addresses found in the module object file,
        this function will allow you to easily and quickly slide all
        module sections.

        :type module: :py:class:`SBModule`, in
        :param module:
                The module to load.

        :type sections_offset: int, in
        :param sections_offset:
                An offset that will be applied to all section file addresses
                (the virtual addresses found in the object file itself).

        :rtype: :py:class:`SBError`
        :return: 
                An error to indicate success, fail, and any reason for
                failure.
        """
        return _lldb.SBTarget_SetModuleLoadAddress(self, module, sections_offset)

    def ClearModuleLoadAddress(self, module):
        r"""
        Clear the section base load addresses for all sections in a module.

        :type module: :py:class:`SBModule`, in
        :param module:
                The module to unload.

        :rtype: :py:class:`SBError`
        :return: 
                An error to indicate success, fail, and any reason for
                failure.
        """
        return _lldb.SBTarget_ClearModuleLoadAddress(self, module)

    def FindFunctions(self, *args):
        r"""
        FindFunctions(SBTarget self, char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList

            Find functions by name.

            :param name: The name of the function we are looking for.

            :param 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.
        """
        return _lldb.SBTarget_FindFunctions(self, *args)

    def FindFirstGlobalVariable(self, name):
        r"""
        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).
        """
        return _lldb.SBTarget_FindFirstGlobalVariable(self, name)

    def FindGlobalVariables(self, *args):
        r"""
        FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches) -> SBValueList
        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.
        """
        return _lldb.SBTarget_FindGlobalVariables(self, *args)

    def FindGlobalFunctions(self, name, max_matches, matchtype):
        r"""
        Find global functions by their name with pattern matching.

        :type name: string, in
        :param name:
                The pattern to search for global or static variables

        :type max_matches: int, in
        :param max_matches:
                Allow the number of matches to be limited to *max_matches*.

        :type matchtype: int, in
        :param matchtype:
                The match type to use.

        :rtype: :py:class:`SBSymbolContextList`
        :return: 
                A list of matched variables in an SBValueList.
        """
        return _lldb.SBTarget_FindGlobalFunctions(self, name, max_matches, matchtype)

    def Clear(self):
        r"""Clear(SBTarget self)"""
        return _lldb.SBTarget_Clear(self)

    def ResolveFileAddress(self, file_addr):
        r"""
        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...
        """
        return _lldb.SBTarget_ResolveFileAddress(self, file_addr)

    def ResolveLoadAddress(self, vm_addr):
        r"""
        Resolve a current load address into a section offset address.

        :type vm_addr: int, in
        :param vm_addr:
                A virtual address from the current process state that is to
                be translated into a section offset address.

        :rtype: :py:class:`SBAddress`
        :return: 
                An SBAddress which will be valid if *vm_addr* was
                successfully resolved into a section offset address, or an
                invalid SBAddress if *vm_addr* doesn't resolve to a section
                in a module.
        """
        return _lldb.SBTarget_ResolveLoadAddress(self, vm_addr)

    def ResolvePastLoadAddress(self, stop_id, vm_addr):
        r"""
        Resolve a current load address into a section offset address
        using the process stop ID to identify a time in the past.

        :type stop_id: int, in
        :param stop_id:
                Each time a process stops, the process stop ID integer gets
                incremented. These stop IDs are used to identify past times
                and can be used in history objects as a cheap way to store
                the time at which the sample was taken. Specifying
                UINT32_MAX will always resolve the address using the
                currently loaded sections.

        :type vm_addr: int, in
        :param vm_addr:
                A virtual address from the current process state that is to
                be translated into a section offset address.

        :rtype: :py:class:`SBAddress`
        :return: 
                An SBAddress which will be valid if *vm_addr* was
                successfully resolved into a section offset address, or an
                invalid SBAddress if *vm_addr* doesn't resolve to a section
                in a module.
        """
        return _lldb.SBTarget_ResolvePastLoadAddress(self, stop_id, vm_addr)

    def ResolveSymbolContextForAddress(self, addr, resolve_scope):
        r"""ResolveSymbolContextForAddress(SBTarget self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext"""
        return _lldb.SBTarget_ResolveSymbolContextForAddress(self, addr, resolve_scope)

    def ReadMemory(self, addr, buf, error):
        r"""
        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.
        """
        return _lldb.SBTarget_ReadMemory(self, addr, buf, error)

    def BreakpointCreateByLocation(self, *args):
        r"""
        BreakpointCreateByLocation(SBTarget self, char const * file, uint32_t line) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint
        BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList module_list, bool move_to_nearest_code) -> SBBreakpoint
        """
        return _lldb.SBTarget_BreakpointCreateByLocation(self, *args)

    def BreakpointCreateByName(self, *args):
        r"""
        BreakpointCreateByName(SBTarget self, char const * symbol_name, char const * module_name=None) -> SBBreakpoint
        BreakpointCreateByName(SBTarget self, char const * symbol_name, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        """
        return _lldb.SBTarget_BreakpointCreateByName(self, *args)

    def BreakpointCreateByNames(self, *args):
        r"""
        BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        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
        """
        return _lldb.SBTarget_BreakpointCreateByNames(self, *args)

    def BreakpointCreateByRegex(self, *args):
        r"""
        BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, char const * module_name=None) -> SBBreakpoint
        BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, lldb::LanguageType symbol_language, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
        """
        return _lldb.SBTarget_BreakpointCreateByRegex(self, *args)

    def BreakpointCreateBySourceRegex(self, *args):
        r"""
        BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpec source_file, char const * module_name=None) -> SBBreakpoint
        BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file) -> SBBreakpoint
        BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file, SBStringList func_names) -> SBBreakpoint
        """
        return _lldb.SBTarget_BreakpointCreateBySourceRegex(self, *args)

    def BreakpointCreateForException(self, language, catch_bp, throw_bp):
        r"""BreakpointCreateForException(SBTarget self, lldb::LanguageType language, bool catch_bp, bool throw_bp) -> SBBreakpoint"""
        return _lldb.SBTarget_BreakpointCreateForException(self, language, catch_bp, throw_bp)

    def BreakpointCreateByAddress(self, address):
        r"""BreakpointCreateByAddress(SBTarget self, lldb::addr_t address) -> SBBreakpoint"""
        return _lldb.SBTarget_BreakpointCreateByAddress(self, address)

    def BreakpointCreateBySBAddress(self, address):
        r"""BreakpointCreateBySBAddress(SBTarget self, SBAddress address) -> SBBreakpoint"""
        return _lldb.SBTarget_BreakpointCreateBySBAddress(self, address)

    def BreakpointCreateFromScript(self, class_name, extra_args, module_list, file_list, request_hardware=False):
        r"""
        BreakpointCreateFromScript(SBTarget self, char const * class_name, SBStructuredData extra_args, SBFileSpecList module_list, SBFileSpecList file_list, bool request_hardware=False) -> SBBreakpoint

            Create a breakpoint using a scripted resolver.

            @param[in] class_name
               This is the name of the class that implements a scripted resolver.
               The class should have the following signature: ::

                   class Resolver:
                       def __init__(self, bkpt, extra_args):
                           # bkpt - the breakpoint for which this is the resolver.  When
                           # the resolver finds an interesting address, call AddLocation
                           # on this breakpoint to add it.
                           #
                           # extra_args - an SBStructuredData that can be used to
                           # parametrize this instance.  Same as the extra_args passed
                           # to BreakpointCreateFromScript.

                       def __get_depth__ (self):
                           # This is optional, but if defined, you should return the
                           # depth at which you want the callback to be called.  The
                           # available options are:
                           #    lldb.eSearchDepthModule
                           #    lldb.eSearchDepthCompUnit
                           # The default if you don't implement this method is
                           # eSearchDepthModule.

                       def __callback__(self, sym_ctx):
                           # sym_ctx - an SBSymbolContext that is the cursor in the
                           # search through the program to resolve breakpoints.
                           # The sym_ctx will be filled out to the depth requested in
                           # __get_depth__.
                           # Look in this sym_ctx for new breakpoint locations,
                           # and if found use bkpt.AddLocation to add them.
                           # Note, you will only get called for modules/compile_units that
                           # pass the SearchFilter provided by the module_list & file_list
                           # passed into BreakpointCreateFromScript.

                       def get_short_help(self):
                           # Optional, but if implemented return a short string that will
                           # be printed at the beginning of the break list output for the
                           # breakpoint.

            @param[in] extra_args
               This is an SBStructuredData object that will get passed to the
               constructor of the class in class_name.  You can use this to
               reuse the same class, parametrizing it with entries from this
               dictionary.

            @param module_list
               If this is non-empty, this will be used as the module filter in the
               SearchFilter created for this breakpoint.

            @param file_list
               If this is non-empty, this will be used as the comp unit filter in the
               SearchFilter created for this breakpoint.

            @return
                An SBBreakpoint that will set locations based on the logic in the
                resolver's search callback.
        """
        return _lldb.SBTarget_BreakpointCreateFromScript(self, class_name, extra_args, module_list, file_list, request_hardware)

    def BreakpointsCreateFromFile(self, *args):
        r"""
        BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBBreakpointList new_bps) -> SBError
        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[in] matching_names
               Only read in breakpoints whose names match one of the names in this
               list.

            @param[out] bkpt_list
               A list of the newly created breakpoints.

            @return
                An SBError detailing any errors in reading in the breakpoints.
        """
        return _lldb.SBTarget_BreakpointsCreateFromFile(self, *args)

    def BreakpointsWriteToFile(self, *args):
        r"""
        BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file) -> SBError
        BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file, SBBreakpointList bkpt_list, bool append=False) -> SBError

            Write breakpoints listed in bkpt_list to dest_file.

            @param[in] dest_file
               The file to which to write the breakpoints.

            @param[in] bkpt_list
               Only write breakpoints from this list.

            @param[in] append
               If true, append the breakpoints in bkpt_list to the others
               serialized in dest_file.  If dest_file doesn't exist, then a new
               file will be created and the breakpoints in bkpt_list written to it.

            @return
                An SBError detailing any errors in writing in the breakpoints.
        """
        return _lldb.SBTarget_BreakpointsWriteToFile(self, *args)

    def GetNumBreakpoints(self):
        r"""GetNumBreakpoints(SBTarget self) -> uint32_t"""
        return _lldb.SBTarget_GetNumBreakpoints(self)

    def GetBreakpointAtIndex(self, idx):
        r"""GetBreakpointAtIndex(SBTarget self, uint32_t idx) -> SBBreakpoint"""
        return _lldb.SBTarget_GetBreakpointAtIndex(self, idx)

    def BreakpointDelete(self, break_id):
        r"""BreakpointDelete(SBTarget self, lldb::break_id_t break_id) -> bool"""
        return _lldb.SBTarget_BreakpointDelete(self, break_id)

    def FindBreakpointByID(self, break_id):
        r"""FindBreakpointByID(SBTarget self, lldb::break_id_t break_id) -> SBBreakpoint"""
        return _lldb.SBTarget_FindBreakpointByID(self, break_id)

    def FindBreakpointsByName(self, name, bkpt_list):
        r"""FindBreakpointsByName(SBTarget self, char const * name, SBBreakpointList bkpt_list) -> bool"""
        return _lldb.SBTarget_FindBreakpointsByName(self, name, bkpt_list)

    def GetBreakpointNames(self, names):
        r"""GetBreakpointNames(SBTarget self, SBStringList names)"""
        return _lldb.SBTarget_GetBreakpointNames(self, names)

    def DeleteBreakpointName(self, name):
        r"""DeleteBreakpointName(SBTarget self, char const * name)"""
        return _lldb.SBTarget_DeleteBreakpointName(self, name)

    def EnableAllBreakpoints(self):
        r"""EnableAllBreakpoints(SBTarget self) -> bool"""
        return _lldb.SBTarget_EnableAllBreakpoints(self)

    def DisableAllBreakpoints(self):
        r"""DisableAllBreakpoints(SBTarget self) -> bool"""
        return _lldb.SBTarget_DisableAllBreakpoints(self)

    def DeleteAllBreakpoints(self):
        r"""DeleteAllBreakpoints(SBTarget self) -> bool"""
        return _lldb.SBTarget_DeleteAllBreakpoints(self)

    def GetNumWatchpoints(self):
        r"""GetNumWatchpoints(SBTarget self) -> uint32_t"""
        return _lldb.SBTarget_GetNumWatchpoints(self)

    def GetWatchpointAtIndex(self, idx):
        r"""GetWatchpointAtIndex(SBTarget self, uint32_t idx) -> SBWatchpoint"""
        return _lldb.SBTarget_GetWatchpointAtIndex(self, idx)

    def DeleteWatchpoint(self, watch_id):
        r"""DeleteWatchpoint(SBTarget self, lldb::watch_id_t watch_id) -> bool"""
        return _lldb.SBTarget_DeleteWatchpoint(self, watch_id)

    def FindWatchpointByID(self, watch_id):
        r"""FindWatchpointByID(SBTarget self, lldb::watch_id_t watch_id) -> SBWatchpoint"""
        return _lldb.SBTarget_FindWatchpointByID(self, watch_id)

    def WatchAddress(self, addr, size, read, modify, error):
        r"""WatchAddress(SBTarget self, lldb::addr_t addr, size_t size, bool read, bool modify, SBError error) -> SBWatchpoint"""
        return _lldb.SBTarget_WatchAddress(self, addr, size, read, modify, error)

    def WatchpointCreateByAddress(self, addr, size, options, error):
        r"""WatchpointCreateByAddress(SBTarget self, lldb::addr_t addr, size_t size, SBWatchpointOptions options, SBError error) -> SBWatchpoint"""
        return _lldb.SBTarget_WatchpointCreateByAddress(self, addr, size, options, error)

    def EnableAllWatchpoints(self):
        r"""EnableAllWatchpoints(SBTarget self) -> bool"""
        return _lldb.SBTarget_EnableAllWatchpoints(self)

    def DisableAllWatchpoints(self):
        r"""DisableAllWatchpoints(SBTarget self) -> bool"""
        return _lldb.SBTarget_DisableAllWatchpoints(self)

    def DeleteAllWatchpoints(self):
        r"""DeleteAllWatchpoints(SBTarget self) -> bool"""
        return _lldb.SBTarget_DeleteAllWatchpoints(self)

    def GetBroadcaster(self):
        r"""GetBroadcaster(SBTarget self) -> SBBroadcaster"""
        return _lldb.SBTarget_GetBroadcaster(self)

    def FindFirstType(self, type):
        r"""FindFirstType(SBTarget self, char const * type) -> SBType"""
        return _lldb.SBTarget_FindFirstType(self, type)

    def FindTypes(self, type):
        r"""FindTypes(SBTarget self, char const * type) -> SBTypeList"""
        return _lldb.SBTarget_FindTypes(self, type)

    def GetBasicType(self, type):
        r"""GetBasicType(SBTarget self, lldb::BasicType type) -> SBType"""
        return _lldb.SBTarget_GetBasicType(self, type)

    def CreateValueFromAddress(self, name, addr, type):
        r"""
        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.
        """
        return _lldb.SBTarget_CreateValueFromAddress(self, name, addr, type)

    def CreateValueFromData(self, name, data, type):
        r"""CreateValueFromData(SBTarget self, char const * name, SBData data, SBType type) -> SBValue"""
        return _lldb.SBTarget_CreateValueFromData(self, name, data, type)

    def CreateValueFromExpression(self, name, expr):
        r"""CreateValueFromExpression(SBTarget self, char const * name, char const * expr) -> SBValue"""
        return _lldb.SBTarget_CreateValueFromExpression(self, name, expr)

    def GetSourceManager(self):
        r"""GetSourceManager(SBTarget self) -> SBSourceManager"""
        return _lldb.SBTarget_GetSourceManager(self)

    def ReadInstructions(self, *args):
        r"""
        ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count) -> SBInstructionList
        ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, char const * flavor_string) -> SBInstructionList
        ReadInstructions(SBTarget self, SBAddress start_addr, SBAddress end_addr, char const * flavor_string) -> SBInstructionList

            Disassemble a specified number of instructions starting at an address.

            :param base_addr: the address to start disassembly from.
            :param count: the number of instructions to disassemble.
            :param flavor_string: may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
            :rtype: SBInstructionList

        """
        return _lldb.SBTarget_ReadInstructions(self, *args)

    def GetInstructions(self, base_addr, buf):
        r"""
        GetInstructions(SBTarget self, SBAddress base_addr, void const * buf) -> SBInstructionList

            Disassemble the bytes in a buffer and return them in an SBInstructionList.

            :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
            :param buf: bytes to be disassembled.
            :param size: (C++) size of the buffer.
            :rtype: SBInstructionList

        """
        return _lldb.SBTarget_GetInstructions(self, base_addr, buf)

    def GetInstructionsWithFlavor(self, base_addr, flavor_string, buf):
        r"""
        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.

            :param base_addr: used for symbolicating the offsets in the byte stream when disassembling.
            :param flavor:  may be 'intel' or 'att' on x86 targets to specify that style of disassembly.
            :param buf: bytes to be disassembled.
            :param size: (C++) size of the buffer.
            :rtype: SBInstructionList

        """
        return _lldb.SBTarget_GetInstructionsWithFlavor(self, base_addr, flavor_string, buf)

    def FindSymbols(self, *args):
        r"""FindSymbols(SBTarget self, char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList"""
        return _lldb.SBTarget_FindSymbols(self, *args)

    def __eq__(self, rhs):
        r"""__eq__(SBTarget self, SBTarget rhs) -> bool"""
        return _lldb.SBTarget___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBTarget self, SBTarget rhs) -> bool"""
        return _lldb.SBTarget___ne__(self, rhs)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTarget self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTarget_GetDescription(self, description, description_level)

    def EvaluateExpression(self, *args):
        r"""
        EvaluateExpression(SBTarget self, char const * expr) -> SBValue
        EvaluateExpression(SBTarget self, char const * expr, SBExpressionOptions options) -> SBValue
        """
        return _lldb.SBTarget_EvaluateExpression(self, *args)

    def GetStackRedZoneSize(self):
        r"""GetStackRedZoneSize(SBTarget self) -> lldb::addr_t"""
        return _lldb.SBTarget_GetStackRedZoneSize(self)

    def IsLoaded(self, module):
        r"""
        IsLoaded(SBTarget self, SBModule module) -> bool

            Returns true if the module has been loaded in this `SBTarget`.
            A module can be loaded either by the dynamic loader or by being manually
            added to the target (see `SBTarget.AddModule` and the ``target module add`` command).

            :rtype: bool

        """
        return _lldb.SBTarget_IsLoaded(self, module)

    def GetLaunchInfo(self):
        r"""GetLaunchInfo(SBTarget self) -> SBLaunchInfo"""
        return _lldb.SBTarget_GetLaunchInfo(self)

    def SetLaunchInfo(self, launch_info):
        r"""SetLaunchInfo(SBTarget self, SBLaunchInfo launch_info)"""
        return _lldb.SBTarget_SetLaunchInfo(self, launch_info)

    def GetTrace(self):
        r"""
        Get a *SBTrace* object the can manage the processor trace information of
        this target.

        :rtype: :py:class:`SBTrace`
        :return: 
              The trace object. The returned SBTrace object might not be valid, so it
              should be checked with a call to "bool SBTrace::IsValid()".
        """
        return _lldb.SBTarget_GetTrace(self)

    def CreateTrace(self, error):
        r"""
        Create a *Trace* object for the current target using the using the
        default supported tracing technology for this process.

        :type error: :py:class:`SBError`, out
        :param error:
                An error if a Trace already exists or the trace couldn't be created.
        """
        return _lldb.SBTarget_CreateTrace(self, error)

    def GetAPIMutex(self):
        r"""GetAPIMutex(SBTarget self) -> SBMutex"""
        return _lldb.SBTarget_GetAPIMutex(self)

    def __repr__(self):
        r"""__repr__(SBTarget self) -> std::string"""
        return _lldb.SBTarget___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    class modules_access(object):
        '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.'''
        def __init__(self, sbtarget):
            self.sbtarget = sbtarget

        def __len__(self):
            if self.sbtarget:
                return int(self.sbtarget.GetNumModules())
            return 0

        def __getitem__(self, key):
            num_modules = self.sbtarget.GetNumModules()
            if type(key) is int:
                if -num_modules <= key < num_modules:
                    key %= num_modules
                    return self.sbtarget.GetModuleAtIndex(key)
            elif type(key) is str:
                if key.find('/') == -1:
                    for idx in range(num_modules):
                        module = self.sbtarget.GetModuleAtIndex(idx)
                        if module.file.basename == key:
                            return module
                else:
                    for idx in range(num_modules):
                        module = self.sbtarget.GetModuleAtIndex(idx)
                        if module.file.fullpath == key:
                            return module
    # See if the string is a UUID
                try:
                    the_uuid = uuid.UUID(key)
                    if the_uuid:
                        for idx in range(num_modules):
                            module = self.sbtarget.GetModuleAtIndex(idx)
                            if module.uuid == the_uuid:
                                return module
                except:
                    return None
            elif type(key) is uuid.UUID:
                for idx in range(num_modules):
                    module = self.sbtarget.GetModuleAtIndex(idx)
                    if module.uuid == key:
                        return module
            elif isinstance(key, type(re.compile(''))):
                matching_modules = []
                for idx in range(num_modules):
                    module = self.sbtarget.GetModuleAtIndex(idx)
                    re_match = key.search(module.file.fullpath)
                    if re_match:
                        matching_modules.append(module)
                return matching_modules
            else:
                print("error: unsupported item type: %s" % type(key))
            return None

    def get_modules_access_object(self):
        '''An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object.'''
        return self.modules_access(self)

    def get_modules_array(self):
        '''An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.'''
        modules = []
        for idx in range(self.GetNumModules()):
            modules.append(self.GetModuleAtIndex(idx))
        return modules

    def module_iter(self):
        '''Returns an iterator over all modules in a lldb.SBTarget
        object.'''
        return lldb_iter(self, 'GetNumModules', 'GetModuleAtIndex')

    def breakpoint_iter(self):
        '''Returns an iterator over all breakpoints in a lldb.SBTarget
        object.'''
        return lldb_iter(self, 'GetNumBreakpoints', 'GetBreakpointAtIndex')

    class bkpts_access(object):
        '''A helper object that will lazily hand out bkpts for a target when supplied an index.'''
        def __init__(self, sbtarget):
            self.sbtarget = sbtarget

        def __len__(self):
            if self.sbtarget:
                return int(self.sbtarget.GetNumBreakpoints())
            return 0

        def __getitem__(self, key):
            if isinstance(key, int):
                count = len(self)
                if -count <= key < count:
                    key %= count
                    return self.sbtarget.GetBreakpointAtIndex(key)
            return None

    def get_bkpts_access_object(self):
        '''An accessor function that returns a bkpts_access() object which allows lazy bkpt access from a lldb.SBtarget object.'''
        return self.bkpts_access(self)

    def get_target_bkpts(self):
        '''An accessor function that returns a list() that contains all bkpts in a lldb.SBtarget object.'''
        bkpts = []
        for idx in range(self.GetNumBreakpoints()):
            bkpts.append(self.GetBreakpointAtIndex(idx))
        return bkpts

    def watchpoint_iter(self):
        '''Returns an iterator over all watchpoints in a lldb.SBTarget
        object.'''
        return lldb_iter(self, 'GetNumWatchpoints', 'GetWatchpointAtIndex')

    class watchpoints_access(object):
        '''A helper object that will lazily hand out watchpoints for a target when supplied an index.'''
        def __init__(self, sbtarget):
            self.sbtarget = sbtarget

        def __len__(self):
            if self.sbtarget:
                return int(self.sbtarget.GetNumWatchpoints())
            return 0

        def __getitem__(self, key):
            if isinstance(key, int):
                count = len(self)
                if -count <= key < count:
                    key %= count
                    return self.sbtarget.GetWatchpointAtIndex(key)
            return None

    def get_watchpoints_access_object(self):
        '''An accessor function that returns a watchpoints_access() object which allows lazy watchpoint access from a lldb.SBtarget object.'''
        return self.watchpoints_access(self)

    def get_target_watchpoints(self):
        '''An accessor function that returns a list() that contains all watchpoints in a lldb.SBtarget object.'''
        watchpoints = []
        for idx in range(self.GetNumWatchpoints()):
            watchpoints.append(self.GetWatchpointAtIndex(idx))
        return watchpoints

    modules = property(get_modules_array, None, doc='''A read only property that returns a list() of lldb.SBModule objects contained in this target. This list is a list all modules that the target currently is tracking (the main executable and all dependent shared libraries).''')
    module = property(get_modules_access_object, None, doc=r'''A read only property that returns an object that implements python operator overloading with the square brackets().\n    target.module[<int>] allows array access to any modules.\n    target.module[<str>] allows access to modules by basename, full path, or uuid string value.\n    target.module[uuid.UUID()] allows module access by UUID.\n    target.module[re] allows module access using a regular expression that matches the module full path.''')
    process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns.''')
    executable = property(GetExecutable, None, doc='''A read only property that returns an lldb object that represents the main executable module (lldb.SBModule) for this target.''')
    debugger = property(GetDebugger, None, doc='''A read only property that returns an lldb object that represents the debugger (lldb.SBDebugger) that owns this target.''')
    num_breakpoints = property(GetNumBreakpoints, None, doc='''A read only property that returns the number of breakpoints that this target has as an integer.''')
    breakpoints = property(get_target_bkpts, None, doc='''A read only property that returns a list() of lldb.SBBreakpoint objects for all breakpoints in this target.''')
    breakpoint = property(get_bkpts_access_object, None, doc='''A read only property that returns an object that can be used to access breakpoints as an array ("bkpt_12 = lldb.target.bkpt[12]").''')
    num_watchpoints = property(GetNumWatchpoints, None, doc='''A read only property that returns the number of watchpoints that this target has as an integer.''')
    watchpoints = property(get_target_watchpoints, None, doc='''A read only property that returns a list() of lldb.SBwatchpoint objects for all watchpoints in this target.''')
    watchpoint = property(get_watchpoints_access_object, None, doc='''A read only property that returns an object that can be used to access watchpoints as an array ("watchpoint_12 = lldb.target.watchpoint[12]").''')
    broadcaster = property(GetBroadcaster, None, doc='''A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target.''')
    byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this target.''')
    addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this target.''')
    triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this target as a string.''')
    data_byte_size = property(GetDataByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the data address space for this target.''')
    code_byte_size = property(GetCodeByteSize, None, doc='''A read only property that returns the size in host bytes of a byte in the code address space for this target.''')
    platform = property(GetPlatform, None, doc='''A read only property that returns the platform associated with with this target.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBTarget in _lldb:
_lldb.SBTarget_swigregister(SBTarget)
class SBThread(object):
    r"""
    Represents a thread of execution. :py:class:`SBProcess` contains SBThread(s).

    SBThreads can be referred to by their ID, which maps to the system specific thread
    identifier, or by IndexID.  The ID may or may not be unique depending on whether the
    system reuses its thread identifiers.  The IndexID is a monotonically increasing identifier
    that will always uniquely reference a particular thread, and when that thread goes
    away it will not be reused.

    SBThread supports frame iteration. For example (from test/python_api/
    lldbutil/iter/TestLLDBIterator.py), ::

            from lldbutil import print_stacktrace
            stopped_due_to_breakpoint = False
            for thread in process:
                if self.TraceOn():
                    print_stacktrace(thread)
                ID = thread.GetThreadID()
                if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
                    stopped_due_to_breakpoint = True
                for frame in thread:
                    self.assertTrue(frame.GetThread().GetThreadID() == ID)
                    if self.TraceOn():
                        print frame

            self.assertTrue(stopped_due_to_breakpoint)

    See also :py:class:`SBFrame` .
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    eBroadcastBitStackChanged = _lldb.SBThread_eBroadcastBitStackChanged
    
    eBroadcastBitThreadSuspended = _lldb.SBThread_eBroadcastBitThreadSuspended
    
    eBroadcastBitThreadResumed = _lldb.SBThread_eBroadcastBitThreadResumed
    
    eBroadcastBitSelectedFrameChanged = _lldb.SBThread_eBroadcastBitSelectedFrameChanged
    
    eBroadcastBitThreadSelected = _lldb.SBThread_eBroadcastBitThreadSelected
    

    @staticmethod
    def GetBroadcasterClassName():
        r"""GetBroadcasterClassName() -> char const *"""
        return _lldb.SBThread_GetBroadcasterClassName()

    def __init__(self, *args):
        r"""
        __init__(SBThread self) -> SBThread
        __init__(SBThread self, SBThread thread) -> SBThread
        """
        _lldb.SBThread_swiginit(self, _lldb.new_SBThread(*args))
    __swig_destroy__ = _lldb.delete_SBThread

    def GetQueue(self):
        r"""
        GetQueue(SBThread self) -> SBQueue

            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.
        """
        return _lldb.SBThread_GetQueue(self)

    def __nonzero__(self):
        return _lldb.SBThread___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBThread self) -> bool"""
        return _lldb.SBThread_IsValid(self)

    def Clear(self):
        r"""Clear(SBThread self)"""
        return _lldb.SBThread_Clear(self)

    def GetStopReason(self):
        r"""GetStopReason(SBThread self) -> lldb::StopReason"""
        return _lldb.SBThread_GetStopReason(self)

    def GetStopReasonDataCount(self):
        r"""
        GetStopReasonDataCount(SBThread self) -> size_t

            Get the number of words associated with the stop reason.
            See also GetStopReasonDataAtIndex().
        """
        return _lldb.SBThread_GetStopReasonDataCount(self)

    def GetStopReasonDataAtIndex(self, idx):
        r"""
        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
            eStopReasonFork          1     pid of the child process
            eStopReasonVFork         1     pid of the child process
            eStopReasonVForkDone     0
            eStopReasonPlanComplete  0
        """
        return _lldb.SBThread_GetStopReasonDataAtIndex(self, idx)

    def GetStopReasonExtendedInfoAsJSON(self, stream):
        r"""
        GetStopReasonExtendedInfoAsJSON(SBThread self, SBStream stream) -> bool

            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.
        """
        return _lldb.SBThread_GetStopReasonExtendedInfoAsJSON(self, stream)

    def GetStopReasonExtendedBacktraces(self, type):
        r"""
        GetStopReasonExtendedBacktraces(SBThread self, lldb::InstrumentationRuntimeType type) -> SBThreadCollection

            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.
        """
        return _lldb.SBThread_GetStopReasonExtendedBacktraces(self, type)

    def GetStopDescription(self, dst_or_null):
        r"""
        GetStopDescription(SBThread self, char * dst_or_null) -> size_t

            Pass only an (int)length and expect to get a Python string describing the
            stop reason.
        """
        return _lldb.SBThread_GetStopDescription(self, dst_or_null)

    def GetStopReturnValue(self):
        r"""GetStopReturnValue(SBThread self) -> SBValue"""
        return _lldb.SBThread_GetStopReturnValue(self)

    def GetThreadID(self):
        r"""
        GetThreadID(SBThread self) -> lldb::tid_t

            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.
        """
        return _lldb.SBThread_GetThreadID(self)

    def GetIndexID(self):
        r"""
        GetIndexID(SBThread self) -> uint32_t

            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.
        """
        return _lldb.SBThread_GetIndexID(self)

    def GetName(self):
        r"""GetName(SBThread self) -> char const *"""
        return _lldb.SBThread_GetName(self)

    def GetQueueName(self):
        r"""
        GetQueueName(SBThread self) -> char const *

            Return the queue name associated with this thread, if any, as a str.
            For example, with a libdispatch (aka Grand Central Dispatch) queue.
        """
        return _lldb.SBThread_GetQueueName(self)

    def GetQueueID(self):
        r"""
        GetQueueID(SBThread self) -> lldb::queue_id_t

            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.
        """
        return _lldb.SBThread_GetQueueID(self)

    def GetInfoItemByPathAsString(self, path, strm):
        r"""
        GetInfoItemByPathAsString(SBThread self, char const * path, SBStream strm) -> bool

            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).
        """
        return _lldb.SBThread_GetInfoItemByPathAsString(self, path, strm)

    def StepOver(self, *args):
        r"""
        StepOver(SBThread self, lldb::RunMode stop_other_threads=eOnlyDuringStepping)
        StepOver(SBThread self, lldb::RunMode stop_other_threads, SBError error)
        Do a source level single step over in the currently selected thread.
        """
        return _lldb.SBThread_StepOver(self, *args)

    def StepInto(self, *args):
        r"""
        StepInto(SBThread self, lldb::RunMode stop_other_threads=eOnlyDuringStepping)
        StepInto(SBThread self, char const * target_name, lldb::RunMode stop_other_threads=eOnlyDuringStepping)
        StepInto(SBThread self, char const * target_name, uint32_t end_line, SBError error, lldb::RunMode stop_other_threads=eOnlyDuringStepping)

            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.
        """
        return _lldb.SBThread_StepInto(self, *args)

    def StepOut(self, *args):
        r"""
        StepOut(SBThread self)
        StepOut(SBThread self, SBError error)
        Step out of the currently selected thread.
        """
        return _lldb.SBThread_StepOut(self, *args)

    def StepOutOfFrame(self, *args):
        r"""
        StepOutOfFrame(SBThread self, SBFrame frame)
        StepOutOfFrame(SBThread self, SBFrame frame, SBError error)
        Step out of the specified frame.
        """
        return _lldb.SBThread_StepOutOfFrame(self, *args)

    def StepInstruction(self, *args):
        r"""
        StepInstruction(SBThread self, bool step_over)
        StepInstruction(SBThread self, bool step_over, SBError error)
        Do an instruction level single step in the currently selected thread.
        """
        return _lldb.SBThread_StepInstruction(self, *args)

    def StepOverUntil(self, frame, file_spec, line):
        r"""StepOverUntil(SBThread self, SBFrame frame, SBFileSpec file_spec, uint32_t line) -> SBError"""
        return _lldb.SBThread_StepOverUntil(self, frame, file_spec, line)

    def StepUsingScriptedThreadPlan(self, *args):
        r"""
        StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name) -> SBError
        StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name, bool resume_immediately) -> SBError
        StepUsingScriptedThreadPlan(SBThread self, char const * script_class_name, SBStructuredData args_data, bool resume_immediately) -> SBError
        """
        return _lldb.SBThread_StepUsingScriptedThreadPlan(self, *args)

    def JumpToLine(self, file_spec, line):
        r"""JumpToLine(SBThread self, SBFileSpec file_spec, uint32_t line) -> SBError"""
        return _lldb.SBThread_JumpToLine(self, file_spec, line)

    def RunToAddress(self, *args):
        r"""
        RunToAddress(SBThread self, lldb::addr_t addr)
        RunToAddress(SBThread self, lldb::addr_t addr, SBError error)
        """
        return _lldb.SBThread_RunToAddress(self, *args)

    def ReturnFromFrame(self, frame, return_value):
        r"""
        ReturnFromFrame(SBThread self, SBFrame frame, SBValue return_value) -> SBError

            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.
        """
        return _lldb.SBThread_ReturnFromFrame(self, frame, return_value)

    def UnwindInnermostExpression(self):
        r"""
        UnwindInnermostExpression(SBThread self) -> SBError

            Unwind the stack frames from the innermost expression evaluation.
            This API is equivalent to 'thread return -x'.
        """
        return _lldb.SBThread_UnwindInnermostExpression(self)

    def Suspend(self, *args):
        r"""
        Suspend(SBThread self) -> bool
        Suspend(SBThread self, SBError error) -> 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.
        """
        return _lldb.SBThread_Suspend(self, *args)

    def Resume(self, *args):
        r"""
        Resume(SBThread self) -> bool
        Resume(SBThread self, SBError error) -> bool
        """
        return _lldb.SBThread_Resume(self, *args)

    def IsSuspended(self):
        r"""IsSuspended(SBThread self) -> bool"""
        return _lldb.SBThread_IsSuspended(self)

    def IsStopped(self):
        r"""IsStopped(SBThread self) -> bool"""
        return _lldb.SBThread_IsStopped(self)

    def GetNumFrames(self):
        r"""GetNumFrames(SBThread self) -> uint32_t"""
        return _lldb.SBThread_GetNumFrames(self)

    def GetFrameAtIndex(self, idx):
        r"""GetFrameAtIndex(SBThread self, uint32_t idx) -> SBFrame"""
        return _lldb.SBThread_GetFrameAtIndex(self, idx)

    def GetSelectedFrame(self):
        r"""GetSelectedFrame(SBThread self) -> SBFrame"""
        return _lldb.SBThread_GetSelectedFrame(self)

    def SetSelectedFrame(self, frame_idx):
        r"""SetSelectedFrame(SBThread self, uint32_t frame_idx) -> SBFrame"""
        return _lldb.SBThread_SetSelectedFrame(self, frame_idx)

    @staticmethod
    def EventIsThreadEvent(event):
        r"""EventIsThreadEvent(SBEvent event) -> bool"""
        return _lldb.SBThread_EventIsThreadEvent(event)

    @staticmethod
    def GetStackFrameFromEvent(event):
        r"""GetStackFrameFromEvent(SBEvent event) -> SBFrame"""
        return _lldb.SBThread_GetStackFrameFromEvent(event)

    @staticmethod
    def GetThreadFromEvent(event):
        r"""GetThreadFromEvent(SBEvent event) -> SBThread"""
        return _lldb.SBThread_GetThreadFromEvent(event)

    def GetProcess(self):
        r"""GetProcess(SBThread self) -> SBProcess"""
        return _lldb.SBThread_GetProcess(self)

    def __eq__(self, rhs):
        r"""__eq__(SBThread self, SBThread rhs) -> bool"""
        return _lldb.SBThread___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBThread self, SBThread rhs) -> bool"""
        return _lldb.SBThread___ne__(self, rhs)

    def GetDescription(self, *args):
        r"""
        GetDescription(SBThread self, SBStream description) -> bool
        GetDescription(SBThread self, SBStream description, bool stop_format) -> bool

            Get the description strings for this thread that match what the
            lldb driver will present, using the thread-format (stop_format==false)
            or thread-stop-format (stop_format = true).
        """
        return _lldb.SBThread_GetDescription(self, *args)

    def GetDescriptionWithFormat(self, format, output):
        r"""
        Similar to *GetDescription()* but the format of the description can be
        configured via the ``format`` parameter. See
        https://lldb.llvm.org/use/formatting.html for more information on format
        strings.

        :type format: :py:class:`SBFormat`, in
        :param format:
              The format to use for generating the description.

        :type output: :py:class:`SBStream`, out
        :param output:
              The stream where the description will be written to.

        :rtype: :py:class:`SBError`
        :return: 
              An error object with an error message in case of failures.
        """
        return _lldb.SBThread_GetDescriptionWithFormat(self, format, output)

    def GetStatus(self, status):
        r"""GetStatus(SBThread self, SBStream status) -> bool"""
        return _lldb.SBThread_GetStatus(self, status)

    def GetExtendedBacktraceThread(self, type):
        r"""
        GetExtendedBacktraceThread(SBThread self, char const * type) -> SBThread

            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.
        """
        return _lldb.SBThread_GetExtendedBacktraceThread(self, type)

    def GetExtendedBacktraceOriginatingIndexID(self):
        r"""
        GetExtendedBacktraceOriginatingIndexID(SBThread self) -> 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.
        """
        return _lldb.SBThread_GetExtendedBacktraceOriginatingIndexID(self)

    def GetCurrentException(self):
        r"""
        GetCurrentException(SBThread self) -> SBValue

            Returns an SBValue object represeting the current exception for the thread,
            if there is any. Currently, this works for Obj-C code and returns an SBValue
            representing the NSException object at the throw site or that's currently
            being processes.
        """
        return _lldb.SBThread_GetCurrentException(self)

    def GetCurrentExceptionBacktrace(self):
        r"""
        GetCurrentExceptionBacktrace(SBThread self) -> SBThread

            Returns a historical (fake) SBThread representing the stack trace of an
            exception, if there is one for the thread. Currently, this works for Obj-C
            code, and can retrieve the throw-site backtrace of an NSException object
            even when the program is no longer at the throw site.
        """
        return _lldb.SBThread_GetCurrentExceptionBacktrace(self)

    def SafeToCallFunctions(self):
        r"""
        SafeToCallFunctions(SBThread self) -> 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.
        """
        return _lldb.SBThread_SafeToCallFunctions(self)

    def GetSiginfo(self):
        r"""
        GetSiginfo(SBThread self) -> SBValue

            Returns a SBValue object representing the siginfo for the current signal.

        """
        return _lldb.SBThread_GetSiginfo(self)

    def __repr__(self):
        r"""__repr__(SBThread self) -> std::string"""
        return _lldb.SBThread___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __iter__(self):
        '''Iterate over all frames in a lldb.SBThread object.'''
        return lldb_iter(self, 'GetNumFrames', 'GetFrameAtIndex')

    def __len__(self):
        '''Return the number of frames in a lldb.SBThread object.'''
        return self.GetNumFrames()

    class frames_access(object):
        '''A helper object that will lazily hand out frames for a thread when supplied an index.'''
        def __init__(self, sbthread):
            self.sbthread = sbthread

        def __len__(self):
            if self.sbthread:
                return int(self.sbthread.GetNumFrames())
            return 0

        def __getitem__(self, key):
            if isinstance(key, int):
                count = len(self)
                if -count <= key < count:
                    key %= count
                    return self.sbthread.GetFrameAtIndex(key)
            return None

    def get_frames_access_object(self):
        '''An accessor function that returns a frames_access() object which allows lazy frame access from a lldb.SBThread object.'''
        return self.frames_access (self)

    def get_thread_frames(self):
        '''An accessor function that returns a list() that contains all frames in a lldb.SBThread object.'''
        frames = []
        for frame in self:
            frames.append(frame)
        return frames

    def get_stop_reason_data(self):
        return [
            self.GetStopReasonDataAtIndex(idx)
            for idx in range(self.GetStopReasonDataCount())
        ]

    def set_selected_frame(self, frame):
        if isinstance(frame, SBFrame):
            if frame.thread != self:
                raise ValueError("cannot select frame from different thread")
            self.SetSelectedFrame(frame.idx)
        else:
            self.SetSelectedFrame(frame)

    id = property(GetThreadID, None, doc='''A read only property that returns the thread ID as an integer.''')
    idx = property(GetIndexID, None, doc='''A read only property that returns the thread index ID as an integer. Thread index ID values start at 1 and increment as threads come and go and can be used to uniquely identify threads.''')
    return_value = property(GetStopReturnValue, None, doc='''A read only property that returns an lldb object that represents the return value from the last stop (lldb.SBValue) if we just stopped due to stepping out of a function.''')
    process = property(GetProcess, None, doc='''A read only property that returns an lldb object that represents the process (lldb.SBProcess) that owns this thread.''')
    num_frames = property(GetNumFrames, None, doc='''A read only property that returns the number of stack frames in this thread as an integer.''')
    frames = property(get_thread_frames, None, doc='''A read only property that returns a list() of lldb.SBFrame objects for all frames in this thread.''')
    frame = property(get_frames_access_object, None, doc='''A read only property that returns an object that can be used to access frames as an array ("frame_12 = lldb.thread.frame[12]").''')
    name = property(GetName, None, doc='''A read only property that returns the name of this thread as a string.''')
    queue = property(GetQueueName, None, doc='''A read only property that returns the dispatch queue name of this thread as a string.''')
    queue_id = property(GetQueueID, None, doc='''A read only property that returns the dispatch queue id of this thread as an integer.''')
    stop_reason = property(GetStopReason, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eStopReason") that represents the reason this thread stopped.''')
    stop_reason_data = property(get_stop_reason_data, None, doc='''A read only property that returns the stop reason data as a list.''')
    is_suspended = property(IsSuspended, None, doc='''A read only property that returns a boolean value that indicates if this thread is suspended.''')
    is_stopped = property(IsStopped, None, doc='''A read only property that returns a boolean value that indicates if this thread is stopped but not exited.''')
    selected_frame = property(GetSelectedFrame, set_selected_frame, doc='''A read/write property that gets and sets the selected frame of this SBThread.''')


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBThread in _lldb:
_lldb.SBThread_swigregister(SBThread)
class SBThreadCollection(object):
    r"""Represents a collection of SBThread objects."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBThreadCollection self) -> SBThreadCollection
        __init__(SBThreadCollection self, SBThreadCollection rhs) -> SBThreadCollection
        """
        _lldb.SBThreadCollection_swiginit(self, _lldb.new_SBThreadCollection(*args))
    __swig_destroy__ = _lldb.delete_SBThreadCollection

    def __nonzero__(self):
        return _lldb.SBThreadCollection___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBThreadCollection self) -> bool"""
        return _lldb.SBThreadCollection_IsValid(self)

    def GetSize(self):
        r"""GetSize(SBThreadCollection self) -> size_t"""
        return _lldb.SBThreadCollection_GetSize(self)

    def GetThreadAtIndex(self, idx):
        r"""GetThreadAtIndex(SBThreadCollection self, size_t idx) -> SBThread"""
        return _lldb.SBThreadCollection_GetThreadAtIndex(self, idx)


    def __iter__(self):
        '''Iterate over all threads in a lldb.SBThreadCollection object.'''
        return lldb_iter(self, 'GetSize', 'GetThreadAtIndex')

    def __len__(self):
        '''Return the number of threads in a lldb.SBThreadCollection object.'''
        return self.GetSize()


# Register SBThreadCollection in _lldb:
_lldb.SBThreadCollection_swigregister(SBThreadCollection)
class SBThreadPlan(object):
    r"""
    Represents a plan for the execution control of a given thread.

    See also :py:class:`SBThread` and :py:class:`SBFrame`.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBThreadPlan self) -> SBThreadPlan
        __init__(SBThreadPlan self, SBThreadPlan threadPlan) -> SBThreadPlan
        __init__(SBThreadPlan self, SBThread thread, char const * class_name) -> SBThreadPlan
        __init__(SBThreadPlan self, SBThread thread, char const * class_name, SBStructuredData args_data) -> SBThreadPlan
        """
        _lldb.SBThreadPlan_swiginit(self, _lldb.new_SBThreadPlan(*args))
    __swig_destroy__ = _lldb.delete_SBThreadPlan

    def __nonzero__(self):
        return _lldb.SBThreadPlan___nonzero__(self)
    __bool__ = __nonzero__



    def Clear(self):
        r"""Clear(SBThreadPlan self)"""
        return _lldb.SBThreadPlan_Clear(self)

    def GetStopReason(self):
        r"""GetStopReason(SBThreadPlan self) -> lldb::StopReason"""
        return _lldb.SBThreadPlan_GetStopReason(self)

    def GetStopReasonDataCount(self):
        r"""
        GetStopReasonDataCount(SBThreadPlan self) -> size_t

            Get the number of words associated with the stop reason.
            See also GetStopReasonDataAtIndex().
        """
        return _lldb.SBThreadPlan_GetStopReasonDataCount(self)

    def GetStopReasonDataAtIndex(self, idx):
        r"""
        GetStopReasonDataAtIndex(SBThreadPlan 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
            eStopReasonFork          1     pid of the child process
            eStopReasonVFork         1     pid of the child process
            eStopReasonVForkDone     0
            eStopReasonPlanComplete  0
        """
        return _lldb.SBThreadPlan_GetStopReasonDataAtIndex(self, idx)

    def GetThread(self):
        r"""GetThread(SBThreadPlan self) -> SBThread"""
        return _lldb.SBThreadPlan_GetThread(self)

    def GetDescription(self, description):
        r"""GetDescription(SBThreadPlan self, SBStream description) -> bool"""
        return _lldb.SBThreadPlan_GetDescription(self, description)

    def SetPlanComplete(self, success):
        r"""SetPlanComplete(SBThreadPlan self, bool success)"""
        return _lldb.SBThreadPlan_SetPlanComplete(self, success)

    def IsPlanComplete(self):
        r"""IsPlanComplete(SBThreadPlan self) -> bool"""
        return _lldb.SBThreadPlan_IsPlanComplete(self)

    def IsPlanStale(self):
        r"""IsPlanStale(SBThreadPlan self) -> bool"""
        return _lldb.SBThreadPlan_IsPlanStale(self)

    def IsValid(self, *args):
        r"""
        IsValid(SBThreadPlan self) -> bool
        IsValid(SBThreadPlan self) -> bool
        """
        return _lldb.SBThreadPlan_IsValid(self, *args)

    def GetStopOthers(self):
        r"""
        GetStopOthers(SBThreadPlan self) -> bool
        Return whether this plan will ask to stop other threads when it runs.
        """
        return _lldb.SBThreadPlan_GetStopOthers(self)

    def SetStopOthers(self, stop_others):
        r"""
        SetStopOthers(SBThreadPlan self, bool stop_others)
        Set whether this plan will ask to stop other threads when it runs.
        """
        return _lldb.SBThreadPlan_SetStopOthers(self, stop_others)

    def QueueThreadPlanForStepOverRange(self, *args):
        r"""
        QueueThreadPlanForStepOverRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan
        QueueThreadPlanForStepOverRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size, SBError error) -> SBThreadPlan
        """
        return _lldb.SBThreadPlan_QueueThreadPlanForStepOverRange(self, *args)

    def QueueThreadPlanForStepInRange(self, *args):
        r"""
        QueueThreadPlanForStepInRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size) -> SBThreadPlan
        QueueThreadPlanForStepInRange(SBThreadPlan self, SBAddress start_address, lldb::addr_t range_size, SBError error) -> SBThreadPlan
        """
        return _lldb.SBThreadPlan_QueueThreadPlanForStepInRange(self, *args)

    def QueueThreadPlanForStepOut(self, *args):
        r"""
        QueueThreadPlanForStepOut(SBThreadPlan self, uint32_t frame_idx_to_step_to, bool first_insn=False) -> SBThreadPlan
        QueueThreadPlanForStepOut(SBThreadPlan self, uint32_t frame_idx_to_step_to, bool first_insn, SBError error) -> SBThreadPlan
        """
        return _lldb.SBThreadPlan_QueueThreadPlanForStepOut(self, *args)

    def QueueThreadPlanForStepSingleInstruction(self, step_over, error):
        r"""QueueThreadPlanForStepSingleInstruction(SBThreadPlan self, bool step_over, SBError error) -> SBThreadPlan"""
        return _lldb.SBThreadPlan_QueueThreadPlanForStepSingleInstruction(self, step_over, error)

    def QueueThreadPlanForRunToAddress(self, *args):
        r"""
        QueueThreadPlanForRunToAddress(SBThreadPlan self, SBAddress address) -> SBThreadPlan
        QueueThreadPlanForRunToAddress(SBThreadPlan self, SBAddress address, SBError error) -> SBThreadPlan
        """
        return _lldb.SBThreadPlan_QueueThreadPlanForRunToAddress(self, *args)

    def QueueThreadPlanForStepScripted(self, *args):
        r"""
        QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name) -> SBThreadPlan
        QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name, SBError error) -> SBThreadPlan
        QueueThreadPlanForStepScripted(SBThreadPlan self, char const * script_class_name, SBStructuredData args_data, SBError error) -> SBThreadPlan
        """
        return _lldb.SBThreadPlan_QueueThreadPlanForStepScripted(self, *args)

# Register SBThreadPlan in _lldb:
_lldb.SBThreadPlan_swigregister(SBThreadPlan)
class SBTrace(object):
    r"""Represents a processor trace."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""Default constructor for an invalid Trace object."""
        _lldb.SBTrace_swiginit(self, _lldb.new_SBTrace())

    @staticmethod
    def LoadTraceFromFile(error, debugger, trace_description_file):
        r"""See SBDebugger::LoadTraceFromFile."""
        return _lldb.SBTrace_LoadTraceFromFile(error, debugger, trace_description_file)

    def CreateNewCursor(self, error, thread):
        r"""
        Get a *TraceCursor* for the given thread's trace.

        :type error: :py:class:`SBError`, out
        :param error:
              This will be set with an error in case of failures.
        :type thread: :py:class:`SBThread`, in
        :param thread:
              The thread to get a *TraceCursor* for.
        :rtype: :py:class:`SBTraceCursor`
        :return: 
                A *SBTraceCursor*. If the thread is not traced or its trace
                information failed to load, an invalid *SBTraceCursor* is returned
                and the ``error`` parameter is set.
        """
        return _lldb.SBTrace_CreateNewCursor(self, error, thread)

    def SaveToDisk(self, error, bundle_dir, compact=False):
        r"""
        Save the trace to the specified directory, which will be created if
        needed. This will also create a file <directory>/trace.json with the
        main properties of the trace session, along with others files which
        contain the actual trace data. The trace.json file can be used later as
        input for the "trace load" command to load the trace in LLDB, or for the
        method *SBDebugger.LoadTraceFromFile()*.

        :type error: :py:class:`SBError`, out
        :param error:
              This will be set with an error in case of failures.

        :type bundle_dir: :py:class:`SBFileSpec`, in
        :param bundle_dir:
              The directory where the trace files will be saved.

        :type compact: boolean, in, optional
        :param compact:
              Try not to save to disk information irrelevant to the traced processes.
              Each trace plug-in implements this in a different fashion.

        :rtype: :py:class:`SBFileSpec`
        :return: 
              A *SBFileSpec* pointing to the bundle description file.
        """
        return _lldb.SBTrace_SaveToDisk(self, error, bundle_dir, compact)

    def GetStartConfigurationHelp(self):
        r"""
        :rtype: string
        :return: 
                A description of the parameters to use for the *SBTrace::Start*
                method, or **null** if the object is invalid.
        """
        return _lldb.SBTrace_GetStartConfigurationHelp(self)

    def Start(self, *args):
        r"""
        *Overload 1:*
         Start tracing all current and future threads in a live process using a
         provided configuration. This is referred as "process tracing" in the
         documentation.

         This is equivalent to the command "process trace start".

         This operation fails if it is invoked twice in a row without
         first stopping the process trace with *SBTrace::Stop()*.

         If a thread is already being traced explicitly, e.g. with
        *SBTrace::Start(const* SBThread &thread, const SBStructuredData
         &configuration), it is left unaffected by this operation.

         :type configuration: :py:class:`SBStructuredData`, in
         :param configuration:
                 Dictionary object with custom fields for the corresponding trace
                 technology.

             Full details for the trace start parameters that can be set can be
             retrieved by calling *SBTrace::GetStartConfigurationHelp()*.

         :rtype: :py:class:`SBError`
         :return: 
                 An error explaining any failures.

        |

        *Overload 2:*
         Start tracing a specific thread in a live process using a provided
         configuration. This is referred as "thread tracing" in the documentation.

         This is equivalent to the command "thread trace start".

         If the thread is already being traced by a "process tracing" operation,
         e.g. with *SBTrace::Start(const* SBStructuredData &configuration), this
         operation fails.

         :type configuration: :py:class:`SBStructuredData`, in
         :param configuration:
                 Dictionary object with custom fields for the corresponding trace
                 technology.

             Full details for the trace start parameters that can be set can be
             retrieved by calling *SBTrace::GetStartConfigurationHelp()*.

         :rtype: :py:class:`SBError`
         :return: 
                 An error explaining any failures.
        """
        return _lldb.SBTrace_Start(self, *args)

    def Stop(self, *args):
        r"""
        *Overload 1:*
        Stop tracing all threads in a live process.

        If a "process tracing" operation is active, e.g. *SBTrace::Start(const*
        SBStructuredData &configuration), this effectively prevents future threads
        from being traced.

        This is equivalent to the command "process trace stop".

        :rtype: :py:class:`SBError`
        :return: 
                An error explaining any failures.

        |

        *Overload 2:*
        Stop tracing a specific thread in a live process regardless of whether the
        thread was traced explicitly or as part of a "process tracing" operation.

        This is equivalent to the command "thread trace stop".

        :rtype: :py:class:`SBError`
        :return: 
                An error explaining any failures.
        """
        return _lldb.SBTrace_Stop(self, *args)

    def __nonzero__(self):
        return _lldb.SBTrace___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTrace self) -> bool"""
        return _lldb.SBTrace_IsValid(self)
    __swig_destroy__ = _lldb.delete_SBTrace

# Register SBTrace in _lldb:
_lldb.SBTrace_swigregister(SBTrace)
class SBTraceCursor(object):
    r"""Represents a trace cursor."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""Default constructor for an invalid *SBTraceCursor* object."""
        _lldb.SBTraceCursor_swiginit(self, _lldb.new_SBTraceCursor())

    def SetForwards(self, forwards):
        r"""
        Set the direction to use in the *SBTraceCursor::Next()* method.

        :type forwards: boolean, in
        :param forwards:
                If **true**, then the traversal will be forwards, otherwise backwards.
        """
        return _lldb.SBTraceCursor_SetForwards(self, forwards)

    def IsForwards(self):
        r"""
        Check if the direction to use in the *SBTraceCursor::Next()* method is
        forwards.

        :rtype: boolean
        :return: 
                **true** if the current direction is forwards, **false** if backwards.
        """
        return _lldb.SBTraceCursor_IsForwards(self)

    def Next(self):
        r"""
        Move the cursor to the next item (instruction or error).

        Direction:
            The traversal is done following the current direction of the trace. If
            it is forwards, the instructions are visited forwards
            chronologically. Otherwise, the traversal is done in
            the opposite direction. By default, a cursor moves backwards unless
            changed with *SBTraceCursor::SetForwards()*.
        """
        return _lldb.SBTraceCursor_Next(self)

    def HasValue(self):
        r"""
        :rtype: boolean
        :return: 
                **true** if the cursor is pointing to a valid item. **false** if the
                cursor has reached the end of the trace.
        """
        return _lldb.SBTraceCursor_HasValue(self)

    def GoToId(self, id):
        r"""
         Instruction identifiers:

         When building complex higher level tools, fast random accesses in the
         trace might be needed, for which each instruction requires a unique
         identifier within its thread trace. For example, a tool might want to
         repeatedly inspect random consecutive portions of a trace. This means that
         it will need to first move quickly to the beginning of each section and
         then start its iteration. Given that the number of instructions can be in
         the order of hundreds of millions, fast random access is necessary.

         An example of such a tool could be an inspector of the call graph of a
         trace, where each call is represented with its start and end instructions.
         Inspecting all the instructions of a call requires moving to its first
         instruction and then iterating until the last instruction, which following
         the pattern explained above.

         Instead of using 0-based indices as identifiers, each Trace plug-in can
         decide the nature of these identifiers and thus no assumptions can be made
         regarding their ordering and sequentiality. The reason is that an
         instruction might be encoded by the plug-in in a way that hides its actual
         0-based index in the trace, but it's still possible to efficiently find
         it.

         Requirements:
         - For a given thread, no two instructions have the same id.
         - In terms of efficiency, moving the cursor to a given id should be as
           fast as possible, but not necessarily O(1). That's why the recommended
           way to traverse sequential instructions is to use the
        *SBTraceCursor::Next()* method and only use *SBTraceCursor::GoToId(id)*
           sparingly.
         Make the cursor point to the item whose identifier is ``id``.

         :rtype: boolean
         :return: 
                 **true** if the given identifier exists and the cursor effectively
                 moved to it. Otherwise, **false** is returned and the cursor now points
                 to an invalid item, i.e. calling *HasValue()* will return **false**.
        """
        return _lldb.SBTraceCursor_GoToId(self, id)

    def HasId(self, id):
        r"""
        :rtype: boolean
        :return: 
                **true** if and only if there's an instruction item with the given
           ``id``.
        """
        return _lldb.SBTraceCursor_HasId(self, id)

    def GetId(self):
        r"""
        :rtype: int
        :return: 
                A unique identifier for the instruction or error this cursor is
                pointing to.
        """
        return _lldb.SBTraceCursor_GetId(self)

    def Seek(self, offset, origin):
        r"""
        Make the cursor point to an item in the trace based on an origin point and
        an offset.

        The resulting position of the trace is
            origin + offset

        If this resulting position would be out of bounds, the trace then points
        to an invalid item, i.e. calling *HasValue()* returns **false**.

        :type offset: int, in
        :param offset:
                How many items to move forwards (if positive) or backwards (if
                negative) from the given origin point. For example, if origin is
           **End**, then a negative offset would move backward in the trace, but a
                positive offset would move past the trace to an invalid item.

        :type origin: int, in
        :param origin:
                The reference point to use when moving the cursor.

        :rtype: boolean
        :return: 
                **true** if and only if the cursor ends up pointing to a valid item.
        """
        return _lldb.SBTraceCursor_Seek(self, offset, origin)

    def GetItemKind(self):
        r"""
        Trace item information (instructions, errors and events)

        :rtype: int
        :return: 
                The kind of item the cursor is pointing at.
        """
        return _lldb.SBTraceCursor_GetItemKind(self)

    def IsError(self):
        r"""
        :rtype: boolean
        :return: 
                Whether the cursor points to an error or not.
        """
        return _lldb.SBTraceCursor_IsError(self)

    def GetError(self):
        r"""
        :rtype: string
        :return: 
                The error message the cursor is pointing at.
        """
        return _lldb.SBTraceCursor_GetError(self)

    def IsEvent(self):
        r"""
        :rtype: boolean
        :return: 
                Whether the cursor points to an event or not.
        """
        return _lldb.SBTraceCursor_IsEvent(self)

    def GetEventType(self):
        r"""
        :rtype: int
        :return: 
                The specific kind of event the cursor is pointing at.
        """
        return _lldb.SBTraceCursor_GetEventType(self)

    def GetEventTypeAsString(self):
        r"""
        :rtype: string
        :return: 
                A human-readable description of the event this cursor is pointing at.
        """
        return _lldb.SBTraceCursor_GetEventTypeAsString(self)

    def IsInstruction(self):
        r"""
        :rtype: boolean
        :return: 
                Whether the cursor points to an instruction.
        """
        return _lldb.SBTraceCursor_IsInstruction(self)

    def GetLoadAddress(self):
        r"""
        :rtype: int
        :return: 
                The load address of the instruction the cursor is pointing at.
        """
        return _lldb.SBTraceCursor_GetLoadAddress(self)

    def GetCPU(self):
        r"""
        :rtype: int
        :return: 
               The requested CPU id, or LLDB_INVALID_CPU_ID if this information is
               not available for the current item.
        """
        return _lldb.SBTraceCursor_GetCPU(self)

    def IsValid(self):
        r"""IsValid(SBTraceCursor self) -> bool"""
        return _lldb.SBTraceCursor_IsValid(self)

    def __nonzero__(self):
        return _lldb.SBTraceCursor___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _lldb.delete_SBTraceCursor

# Register SBTraceCursor in _lldb:
_lldb.SBTraceCursor_swigregister(SBTraceCursor)
class SBTypeMember(object):
    r"""Represents a member of a type."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBTypeMember self) -> SBTypeMember
        __init__(SBTypeMember self, SBTypeMember rhs) -> SBTypeMember
        """
        _lldb.SBTypeMember_swiginit(self, _lldb.new_SBTypeMember(*args))
    __swig_destroy__ = _lldb.delete_SBTypeMember

    def __nonzero__(self):
        return _lldb.SBTypeMember___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeMember self) -> bool"""
        return _lldb.SBTypeMember_IsValid(self)

    def GetName(self):
        r"""GetName(SBTypeMember self) -> char const *"""
        return _lldb.SBTypeMember_GetName(self)

    def GetType(self):
        r"""GetType(SBTypeMember self) -> SBType"""
        return _lldb.SBTypeMember_GetType(self)

    def GetOffsetInBytes(self):
        r"""GetOffsetInBytes(SBTypeMember self) -> uint64_t"""
        return _lldb.SBTypeMember_GetOffsetInBytes(self)

    def GetOffsetInBits(self):
        r"""GetOffsetInBits(SBTypeMember self) -> uint64_t"""
        return _lldb.SBTypeMember_GetOffsetInBits(self)

    def IsBitfield(self):
        r"""IsBitfield(SBTypeMember self) -> bool"""
        return _lldb.SBTypeMember_IsBitfield(self)

    def GetBitfieldSizeInBits(self):
        r"""GetBitfieldSizeInBits(SBTypeMember self) -> uint32_t"""
        return _lldb.SBTypeMember_GetBitfieldSizeInBits(self)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeMember self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeMember_GetDescription(self, description, description_level)

    def __repr__(self):
        r"""__repr__(SBTypeMember self) -> std::string"""
        return _lldb.SBTypeMember___repr__(self)

            # operator== is a free function, which swig does not handle, so we inject
            # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    name = property(GetName, None, doc='''A read only property that returns the name for this member as a string.''')
    type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this member.''')
    byte_offset = property(GetOffsetInBytes, None, doc='''A read only property that returns offset in bytes for this member as an integer.''')
    bit_offset = property(GetOffsetInBits, None, doc='''A read only property that returns offset in bits for this member as an integer.''')
    is_bitfield = property(IsBitfield, None, doc='''A read only property that returns true if this member is a bitfield.''')
    bitfield_bit_size = property(GetBitfieldSizeInBits, None, doc='''A read only property that returns the bitfield size in bits for this member as an integer, or zero if this member is not a bitfield.''')


# Register SBTypeMember in _lldb:
_lldb.SBTypeMember_swigregister(SBTypeMember)
class SBTypeMemberFunction(object):
    r"""Represents a member function of a type."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBTypeMemberFunction self) -> SBTypeMemberFunction
        __init__(SBTypeMemberFunction self, SBTypeMemberFunction rhs) -> SBTypeMemberFunction
        """
        _lldb.SBTypeMemberFunction_swiginit(self, _lldb.new_SBTypeMemberFunction(*args))
    __swig_destroy__ = _lldb.delete_SBTypeMemberFunction

    def __nonzero__(self):
        return _lldb.SBTypeMemberFunction___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeMemberFunction self) -> bool"""
        return _lldb.SBTypeMemberFunction_IsValid(self)

    def GetName(self):
        r"""GetName(SBTypeMemberFunction self) -> char const *"""
        return _lldb.SBTypeMemberFunction_GetName(self)

    def GetDemangledName(self):
        r"""GetDemangledName(SBTypeMemberFunction self) -> char const *"""
        return _lldb.SBTypeMemberFunction_GetDemangledName(self)

    def GetMangledName(self):
        r"""GetMangledName(SBTypeMemberFunction self) -> char const *"""
        return _lldb.SBTypeMemberFunction_GetMangledName(self)

    def GetType(self):
        r"""GetType(SBTypeMemberFunction self) -> SBType"""
        return _lldb.SBTypeMemberFunction_GetType(self)

    def GetReturnType(self):
        r"""GetReturnType(SBTypeMemberFunction self) -> SBType"""
        return _lldb.SBTypeMemberFunction_GetReturnType(self)

    def GetNumberOfArguments(self):
        r"""GetNumberOfArguments(SBTypeMemberFunction self) -> uint32_t"""
        return _lldb.SBTypeMemberFunction_GetNumberOfArguments(self)

    def GetArgumentTypeAtIndex(self, arg2):
        r"""GetArgumentTypeAtIndex(SBTypeMemberFunction self, uint32_t arg2) -> SBType"""
        return _lldb.SBTypeMemberFunction_GetArgumentTypeAtIndex(self, arg2)

    def GetKind(self):
        r"""GetKind(SBTypeMemberFunction self) -> lldb::MemberFunctionKind"""
        return _lldb.SBTypeMemberFunction_GetKind(self)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeMemberFunction self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeMemberFunction_GetDescription(self, description, description_level)

    def __repr__(self):
        r"""__repr__(SBTypeMemberFunction self) -> std::string"""
        return _lldb.SBTypeMemberFunction___repr__(self)

          # operator== is a free function, which swig does not handle, so we inject
          # our own equality operator here
    def __eq__(self, other):
      return not self.__ne__(other)



# Register SBTypeMemberFunction in _lldb:
_lldb.SBTypeMemberFunction_swigregister(SBTypeMemberFunction)
class SBTypeStaticField(object):
    r"""Proxy of C++ lldb::SBTypeStaticField class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBTypeStaticField self) -> SBTypeStaticField
        __init__(SBTypeStaticField self, SBTypeStaticField rhs) -> SBTypeStaticField
        """
        _lldb.SBTypeStaticField_swiginit(self, _lldb.new_SBTypeStaticField(*args))
    __swig_destroy__ = _lldb.delete_SBTypeStaticField

    def __nonzero__(self):
        return _lldb.SBTypeStaticField___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeStaticField self) -> bool"""
        return _lldb.SBTypeStaticField_IsValid(self)

    def GetName(self):
        r"""GetName(SBTypeStaticField self) -> char const *"""
        return _lldb.SBTypeStaticField_GetName(self)

    def GetMangledName(self):
        r"""GetMangledName(SBTypeStaticField self) -> char const *"""
        return _lldb.SBTypeStaticField_GetMangledName(self)

    def GetType(self):
        r"""GetType(SBTypeStaticField self) -> SBType"""
        return _lldb.SBTypeStaticField_GetType(self)

    def GetConstantValue(self, target):
        r"""GetConstantValue(SBTypeStaticField self, SBTarget target) -> SBValue"""
        return _lldb.SBTypeStaticField_GetConstantValue(self, target)

# Register SBTypeStaticField in _lldb:
_lldb.SBTypeStaticField_swigregister(SBTypeStaticField)
class SBType(object):
    r"""
    Represents a data type in lldb.

    The actual characteristics of each type are defined by the semantics of the
    programming language and the specific language implementation that was used
    to compile the target program. See the language-specific notes in the
    documentation of each method.

    SBType instances can be obtained by a variety of methods.
    `SBTarget.FindFirstType` and `SBModule.FindFirstType` can be used to create
    `SBType` representations of types in executables/libraries with debug
    information. For some languages such as C, C++ and Objective-C it is possible
    to create new types by evaluating expressions that define a new type.

    Note that most `SBType` properties are computed independently of any runtime
    information so for dynamic languages the functionality can be very limited.
    `SBValue` can be used to represent runtime values which then can be more
    accurately queried for certain information such as byte size.


    SBType supports the eq/ne operator. For example,::

        //main.cpp:

        class Task {
        public:
            int id;
            Task *next;
            Task(int i, Task *n):
                id(i),
                next(n)
            {}
        };

        int main (int argc, char const *argv[])
        {
            Task *task_head = new Task(-1, NULL);
            Task *task1 = new Task(1, NULL);
            Task *task2 = new Task(2, NULL);
            Task *task3 = new Task(3, NULL); // Orphaned.
            Task *task4 = new Task(4, NULL);
            Task *task5 = new Task(5, NULL);

            task_head->next = task1;
            task1->next = task2;
            task2->next = task4;
            task4->next = task5;

            int total = 0;
            Task *t = task_head;
            while (t != NULL) {
                if (t->id >= 0)
                    ++total;
                t = t->next;
            }
            printf('We have a total number of %d tasks\n', total);

            // This corresponds to an empty task list.
            Task *empty_task_head = new Task(-1, NULL);

            return 0; // Break at this line
        }

        # find_type.py:

                # Get the type 'Task'.
                task_type = target.FindFirstType('Task')
                self.assertTrue(task_type)

                # Get the variable 'task_head'.
                frame0.FindVariable('task_head')
                task_head_type = task_head.GetType()
                self.assertTrue(task_head_type.IsPointerType())

                # task_head_type is 'Task *'.
                task_pointer_type = task_type.GetPointerType()
                self.assertTrue(task_head_type == task_pointer_type)

                # Get the child mmember 'id' from 'task_head'.
                id = task_head.GetChildMemberWithName('id')
                id_type = id.GetType()

                # SBType.GetBasicType() takes an enum 'BasicType' (lldb-enumerations.h).
                int_type = id_type.GetBasicType(lldb.eBasicTypeInt)
                # id_type and int_type should be the same type!
                self.assertTrue(id_type == int_type)


    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBType self) -> SBType
        __init__(SBType self, SBType rhs) -> SBType
        """
        _lldb.SBType_swiginit(self, _lldb.new_SBType(*args))
    __swig_destroy__ = _lldb.delete_SBType

    def __nonzero__(self):
        return _lldb.SBType___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBType self) -> bool"""
        return _lldb.SBType_IsValid(self)

    def GetByteSize(self):
        r"""
        GetByteSize(SBType self) -> uint64_t
        Returns the number of bytes a variable with the given types occupies in memory.

            Returns ``0`` if the size can't be determined.

            If a type occupies ``N`` bytes + ``M`` bits in memory, this function returns
            the rounded up amount of bytes (i.e., if ``M`` is ``0``,
            this function returns ``N`` and otherwise ``N + 1``).

            Language-specific behaviour:

            * C: The output is expected to match the value of ``sizeof(Type)``. If
              ``sizeof(Type)`` is not a valid expression for the given type, the
              function returns ``0``.
            * C++: Same as in C.
            * Objective-C: Same as in C. For Objective-C classes this always returns
              ``0`` as the actual size depends on runtime information.

        """
        return _lldb.SBType_GetByteSize(self)

    def GetByteAlign(self):
        r"""GetByteAlign(SBType self) -> uint64_t"""
        return _lldb.SBType_GetByteAlign(self)

    def IsPointerType(self):
        r"""
        IsPointerType(SBType self) -> bool
        Returns true if this type is a pointer type.

            Language-specific behaviour:

            * C: Returns true for C pointer types (or typedefs of these types).
            * C++: Pointer types include the C pointer types as well as pointers to data
              mebers or member functions.
            * Objective-C: Pointer types include the C pointer types. ``id``, ``Class``
              and pointers to blocks are also considered pointer types.

        """
        return _lldb.SBType_IsPointerType(self)

    def IsReferenceType(self):
        r"""
        IsReferenceType(SBType self) -> bool
        Returns true if this type is a reference type.

            Language-specific behaviour:

            * C: Returns false for all types.
            * C++: Both l-value and r-value references are considered reference types.
            * Objective-C: Returns false for all types.

        """
        return _lldb.SBType_IsReferenceType(self)

    def IsFunctionType(self):
        r"""IsFunctionType(SBType self) -> bool"""
        return _lldb.SBType_IsFunctionType(self)

    def IsPolymorphicClass(self):
        r"""
        IsPolymorphicClass(SBType self) -> bool
        Returns true if this type is a polymorphic type.

            Language-specific behaviour:

            * C: Returns false for all types.
            * C++: Returns true if the type is a class type that contains at least one
              virtual member function or if at least one of its base classes is
              considered a polymorphic type.
            * Objective-C: Returns false for all types.

        """
        return _lldb.SBType_IsPolymorphicClass(self)

    def IsArrayType(self):
        r"""
        IsArrayType(SBType self) -> bool
        Returns true if this type is an array type.

            Language-specific behaviour:

            * C: Returns true if the types is an array type. This includes incomplete
              array types ``T[]`` and array types with integer (``T[1]``) or variable
              length (``T[some_variable]``). Pointer types are not considered arrays.
            * C++: Includes C's array types and dependent array types (i.e., array types
              in templates which size depends on template arguments).
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_IsArrayType(self)

    def IsVectorType(self):
        r"""
        IsVectorType(SBType self) -> bool
        Returns true if this type is a vector type.

            Language-specific behaviour:

            * C: Returns true if the types is a vector type created with
              GCC's ``vector_size`` or Clang's ``ext_vector_type`` feature.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_IsVectorType(self)

    def IsTypedefType(self):
        r"""
        IsTypedefType(SBType self) -> bool
        Returns true if this type is a typedef.

            Language-specific behaviour:

            * C: Returns true if the type is a C typedef.
            * C++: Same as in C. Also treats type aliases as typedefs.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_IsTypedefType(self)

    def IsAnonymousType(self):
        r"""
        IsAnonymousType(SBType self) -> bool
        Returns true if this type is an anonymous type.

            Language-specific behaviour:

            * C: Returns true for anonymous unions. Also returns true for
              anonymous structs (which are a GNU language extension).
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_IsAnonymousType(self)

    def IsScopedEnumerationType(self):
        r"""
        IsScopedEnumerationType(SBType self) -> bool
        Returns true if this type is a scoped enum.

            Language-specific behaviour:

            * C: Returns false for all types.
            * C++: Return true only for C++11 scoped enums.
            * Objective-C: Returns false for all types.

        """
        return _lldb.SBType_IsScopedEnumerationType(self)

    def IsAggregateType(self):
        r"""
        IsAggregateType(SBType self) -> bool
        Returns true if this type is an aggregate type.

            Language-specific behaviour:

            * C: Returns true for struct values, arrays, and vectors.
            * C++: Same a C. Also includes class instances.
            * Objective-C: Same as C. Also includes class instances.

        """
        return _lldb.SBType_IsAggregateType(self)

    def GetPointerType(self):
        r"""
        GetPointerType(SBType self) -> SBType
        Returns a type that represents a pointer to this type.

            If the type system of the current language can't represent a pointer to this
            type or this type is invalid, an invalid `SBType` is returned.

            Language-specific behaviour:

            * C: Returns the pointer type of this type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetPointerType(self)

    def GetPointeeType(self):
        r"""
        GetPointeeType(SBType self) -> SBType
        Returns the underlying pointee type.

            If this type is a pointer type as specified by `IsPointerType` then this
            returns the underlying type. If this is not a pointer type or an invalid
            `SBType` then this returns an invalid `SBType`.

            Language-specific behaviour:

            * C: Returns the underlying type for for C pointer types or typedefs of
              these types). For example, ``int *`` will return ``int``.
            * C++: Same as in C. Returns an `SBType` representation for data members/
              member functions in case the `SBType` is a pointer to data member or
              pointer to member function.
            * Objective-C: Same as in C. The pointee type of ``id`` and ``Class`` is
              an invalid `SBType`. The pointee type of pointers Objective-C types is an
              `SBType` for the non-pointer type of the respective type. For example,
              ``NSString *`` will return ``NSString`` as a pointee type.

        """
        return _lldb.SBType_GetPointeeType(self)

    def GetReferenceType(self):
        r"""
        GetReferenceType(SBType self) -> SBType
        Returns a type that represents a reference to this type.

            If the type system of the current language can't represent a reference to
            this type, an invalid `SBType` is returned.

            Language-specific behaviour:

            * C: Currently assumes the type system is C++ and returns an l-value
              reference type. For example, ``int`` will return ``int&``. This behavior
              is likely to change in the future and shouldn't be relied on.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetReferenceType(self)

    def GetTypedefedType(self):
        r"""
        GetTypedefedType(SBType self) -> SBType
        Returns the underlying type of a typedef.

            If this type is a typedef as designated by `IsTypedefType`, then the
            underlying type is being returned. Otherwise an invalid `SBType` is
            returned.

            Language-specific behaviour:

            * C: Returns the underlying type of a typedef type.
            * C++: Same as in C. For type aliases, the underlying type is returned.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetTypedefedType(self)

    def GetDereferencedType(self):
        r"""
        GetDereferencedType(SBType self) -> SBType
        Returns the underlying type of a reference type.

            If this type is a reference as designated by `IsReferenceType`, then the
            underlying type is being returned. Otherwise an invalid `SBType` is
            returned.

            Language-specific behaviour:

            * C: Always returns an invalid type.
            * C++: For l-value and r-value references the underlying type is returned.
              For example, ``int &`` will return ``int``.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetDereferencedType(self)

    def GetUnqualifiedType(self):
        r"""
        GetUnqualifiedType(SBType self) -> SBType
        Returns the unqualified version of this type.

            Language-specific behaviour:

            * C: If this type with any const or volatile specifier removed.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetUnqualifiedType(self)

    def GetArrayElementType(self):
        r"""
        GetArrayElementType(SBType self) -> SBType
        Returns the array element type if this type is an array type.

            Otherwise returns an invalid `SBType` if this type is invalid or not an
            array type.

            Language-specific behaviour:

            * C: If this is an array type (see `IsArrayType`) such as ``T[]``, returns
              the element type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

            See also `IsArrayType`.

        """
        return _lldb.SBType_GetArrayElementType(self)

    def GetArrayType(self, size):
        r"""
        GetArrayType(SBType self, uint64_t size) -> SBType
        Returns the array type with the given constant size.

            Language-specific behaviour:

            * C: Returns a constant-size array ``T[size]`` for any non-void type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

            See also `IsArrayType` and `GetArrayElementType`.

        """
        return _lldb.SBType_GetArrayType(self, size)

    def GetVectorElementType(self):
        r"""
        GetVectorElementType(SBType self) -> SBType
        Returns the vector element type if this type is a vector type.

            Otherwise returns an invalid `SBType` if this type is invalid or not a
            vector type.

            Language-specific behaviour:

            * C: If this is a vector type (see `IsVectorType`), returns the element
              type.
            * C++: Same as in C.
            * Objective-C: Same as in C.

            See also `IsVectorType`.

        """
        return _lldb.SBType_GetVectorElementType(self)

    def GetCanonicalType(self):
        r"""GetCanonicalType(SBType self) -> SBType"""
        return _lldb.SBType_GetCanonicalType(self)

    def GetEnumerationIntegerType(self):
        r"""
        GetEnumerationIntegerType(SBType self) -> SBType
        Returns the underlying integer type if this is an enumeration type.

            If this type is an invalid `SBType` or not an enumeration type an invalid
            `SBType` is returned.

            Language-specific behaviour:

            * C: Returns the underlying type for enums.
            * C++: Same as in C but also returns the underlying type for scoped enums.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetEnumerationIntegerType(self)

    def GetBasicType(self, *args):
        r"""
        GetBasicType(SBType self) -> lldb::BasicType
        GetBasicType(SBType self, lldb::BasicType type) -> SBType
        Returns the `BasicType` value that is most appropriate to this type.

            Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this
            type is invalid. See the `BasicType` documentation for the language-specific
            meaning of each `BasicType` value.

            **Overload behaviour:** When called with a `BasicType` parameter, the
            following behaviour applies:

            Returns the `SBType` that represents the passed `BasicType` value. Returns
            an invalid `SBType` if no fitting `SBType` could be created.

            Language-specific behaviour:

            * C: Returns the respective builtin type. Note that some types
              (e.g. ``__uint128_t``) might even be successfully created even if they are
              not available on the target platform. C++ and Objective-C specific types
              might also be created even if the target program is not written in C++ or
              Objective-C.
            * C++: Same as in C.
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetBasicType(self, *args)

    def GetNumberOfFields(self):
        r"""
        GetNumberOfFields(SBType self) -> uint32_t
        Returns the number of fields of this type.

            Returns ``0`` if this type does not have fields.

            Language-specific behaviour:

            * C: Returns the number of fields if the type is a struct. If the type
              contains an anonymous struct/union it only counts as a single field (even
              if the struct/union contains several fields).
            * C++: Returns the number of non-static fields if the type is a
              struct/class. If the type contains an anonymous struct/union it only
              counts as a single field (even if the struct/union contains several
              fields). The fields of any base classes are not included in the count.
            * Objective-C: Same as in C for structs. For Objective-C classes the number
              of ivars is returned.

            See also `GetFieldAtIndex`.

        """
        return _lldb.SBType_GetNumberOfFields(self)

    def GetNumberOfDirectBaseClasses(self):
        r"""
        GetNumberOfDirectBaseClasses(SBType self) -> uint32_t
        Returns the number of base/parent classes of this type.

            Returns ``0`` if this type doesn't have any base classes.

            Language-specific behaviour:

            * C: Returns always ``0``.
            * C++: The number of direct non-virtual base classes if this type is
              a class.
            * Objective-C: The number of super classes for Objective-C classes.
              As Objective-C doesn't have multiple inheritance this is usually returns 1
              except for NSObject.

        """
        return _lldb.SBType_GetNumberOfDirectBaseClasses(self)

    def GetNumberOfVirtualBaseClasses(self):
        r"""
        GetNumberOfVirtualBaseClasses(SBType self) -> uint32_t
        Returns the number of virtual base/parent classes of this type

            Returns ``0`` if this type doesn't have any base classes.

            Language-specific behaviour:

            * C: Returns always ``0``.
            * C++: The number of direct virtual base classes if this type is a
              class.
            * Objective-C: Returns always ``0``.

        """
        return _lldb.SBType_GetNumberOfVirtualBaseClasses(self)

    def GetFieldAtIndex(self, idx):
        r"""
        GetFieldAtIndex(SBType self, uint32_t idx) -> SBTypeMember
        Returns the field at the given index.

            Returns an invalid `SBType` if the index is out of range or the current
            type doesn't have any fields.

            Language-specific behaviour:

            * C: Returns the field with the given index for struct types. Fields are
              ordered/indexed starting from ``0`` for the first field in a struct (as
              declared in the definition).
            * C++: Returns the non-static field with the given index for struct types.
              Fields are ordered/indexed starting from ``0`` for the first field in a
              struct (as declared in the definition).
            * Objective-C: Same as in C for structs. For Objective-C classes the ivar
              with the given index is returned. ivars are indexed starting from ``0``.

        """
        return _lldb.SBType_GetFieldAtIndex(self, idx)

    def GetDirectBaseClassAtIndex(self, idx):
        r"""
        GetDirectBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember
        Returns the direct base class as indexed by `GetNumberOfDirectBaseClasses`.

            Returns an invalid SBTypeMember if the index is invalid or this SBType is
            invalid.

        """
        return _lldb.SBType_GetDirectBaseClassAtIndex(self, idx)

    def GetVirtualBaseClassAtIndex(self, idx):
        r"""
        GetVirtualBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember
        Returns the virtual base class as indexed by
            `GetNumberOfVirtualBaseClasses`.

            Returns an invalid SBTypeMember if the index is invalid or this SBType is
            invalid.

        """
        return _lldb.SBType_GetVirtualBaseClassAtIndex(self, idx)

    def GetStaticFieldWithName(self, name):
        r"""GetStaticFieldWithName(SBType self, char const * name) -> SBTypeStaticField"""
        return _lldb.SBType_GetStaticFieldWithName(self, name)

    def GetEnumMembers(self):
        r"""GetEnumMembers(SBType self) -> SBTypeEnumMemberList"""
        return _lldb.SBType_GetEnumMembers(self)

    def GetNumberOfTemplateArguments(self):
        r"""
        GetNumberOfTemplateArguments(SBType self) -> uint32_t
        Returns the number of template arguments of this type.

            Returns ``0`` if this type is not a template.

            Language-specific behaviour:

            * C: Always returns ``0``.
            * C++: If this type is a class template instantiation then this returns the
              number of template parameters that were used in this instantiation. This
              includes both explicit and implicit template parameters.
            * Objective-C: Always returns ``0``.

        """
        return _lldb.SBType_GetNumberOfTemplateArguments(self)

    def GetTemplateArgumentType(self, idx):
        r"""
        GetTemplateArgumentType(SBType self, uint32_t idx) -> SBType
        Returns the type of the template argument with the given index.

            Returns an invalid `SBType` if there is no template argument with the given
            index or this type is not a template. The first template  argument has the
            index ``0``.

            Language-specific behaviour:

            * C: Always returns an invalid SBType.
            * C++: If this type is a class template instantiation and the template
              parameter with the given index is a type template parameter, then this
              returns the type of that parameter. Otherwise returns an invalid `SBType`.
            * Objective-C: Always returns an invalid SBType.

        """
        return _lldb.SBType_GetTemplateArgumentType(self, idx)

    def GetTemplateArgumentValue(self, target, idx):
        r"""
        Returns the value of the non-type template parameter at index ``idx``.
        If ``idx`` is out-of-bounds or the template parameter doesn't have
        a value, returns an empty SBValue.

        This function will expand parameter packs.
        """
        return _lldb.SBType_GetTemplateArgumentValue(self, target, idx)

    def GetTemplateArgumentKind(self, idx):
        r"""
        GetTemplateArgumentKind(SBType self, uint32_t idx) -> lldb::TemplateArgumentKind
        Returns the kind of the template argument with the given index.

            Returns `eTemplateArgumentKindNull` if there is no template argument
            with the given index or this type is not a template. The first template
            argument has the index ``0``.

            Language-specific behaviour:

            * C: Always returns `eTemplateArgumentKindNull`.
            * C++: If this type is a class template instantiation then this returns
              the appropriate `TemplateArgument` value for the parameter with the given
              index. See the documentation of `TemplateArgument` for how certain C++
              template parameter kinds are mapped to `TemplateArgument` values.
            * Objective-C: Always returns `eTemplateArgumentKindNull`.

        """
        return _lldb.SBType_GetTemplateArgumentKind(self, idx)

    def GetFunctionReturnType(self):
        r"""
        GetFunctionReturnType(SBType self) -> SBType
        Returns the return type if this type represents a function.

            Returns an invalid `SBType` if this type is not a function type or invalid.

            Language-specific behaviour:

            * C: For functions return the return type. Returns an invalid `SBType` if
              this type is a function pointer type.
            * C++: Same as in C for functions and instantiated template functions.
              Member functions are also considered functions. For functions that have
              their return type specified by a placeholder type specifier (``auto``)
              this returns the deduced return type.
            * Objective-C: Same as in C for functions. For Objective-C methods this
              returns the return type of the method.

        """
        return _lldb.SBType_GetFunctionReturnType(self)

    def GetFunctionArgumentTypes(self):
        r"""
        GetFunctionArgumentTypes(SBType self) -> SBTypeList
        Returns the list of argument types if this type represents a function.

            Returns an invalid `SBType` if this type is not a function type or invalid.

            Language-specific behaviour:

            * C: For functions return the types of each parameter. Returns an invalid
              `SBType` if this type is a function pointer. For variadic functions this
              just returns the list of parameters before the variadic arguments.
            * C++: Same as in C for functions and instantiated template functions.
              Member functions are also considered functions.
            * Objective-C: Always returns an invalid SBType for Objective-C methods.

        """
        return _lldb.SBType_GetFunctionArgumentTypes(self)

    def GetNumberOfMemberFunctions(self):
        r"""
        GetNumberOfMemberFunctions(SBType self) -> uint32_t
        Returns the number of member functions of this type.

            Returns ``0`` if an error occurred or this type is invalid.

            Language-specific behaviour:

            * C: Always returns ``0``.
            * C++: If this type represents a struct/class, then the number of
              member functions (static and non-static) is returned. The count includes
              constructors and destructors (both explicit and implicit). Member
              functions of base classes are not included in the count.
            * Objective-C: If this type represents a struct/class, then the
              number of methods is returned. Methods in categories or super classes
              are not counted.

        """
        return _lldb.SBType_GetNumberOfMemberFunctions(self)

    def GetMemberFunctionAtIndex(self, idx):
        r"""
        GetMemberFunctionAtIndex(SBType self, uint32_t idx) -> SBTypeMemberFunction
        Returns the member function of this type with the given index.

            Returns an invalid `SBTypeMemberFunction` if the index is invalid or this
            type is invalid.

            Language-specific behaviour:

            * C: Always returns an invalid `SBTypeMemberFunction`.
            * C++: Returns the member function or constructor/destructor with the given
              index.
            * Objective-C: Returns the method with the given index.

            See `GetNumberOfMemberFunctions` for what functions can be queried by this
            function.

        """
        return _lldb.SBType_GetMemberFunctionAtIndex(self, idx)

    def GetModule(self):
        r"""
        GetModule(SBType self) -> SBModule
        Returns the `SBModule` this `SBType` belongs to.

            Returns no `SBModule` if this type does not belong to any specific
            `SBModule` or this `SBType` is invalid. An invalid `SBModule` might also
            indicate that once came from an `SBModule` but LLDB could no longer
            determine the original module.

        """
        return _lldb.SBType_GetModule(self)

    def GetName(self):
        r"""
        GetName() -> string
        Returns the name of this type.

            Returns an empty string if an error occurred or this type is invalid.

            Use this function when trying to match a specific type by name in a script.
            The names returned by this function try to uniquely identify a name but
            conflicts can occur (for example, if a C++ program contains two different
            classes with the same name in different translation units. `GetName` can
            return the same name for both class types.)


            Language-specific behaviour:

            * C: The name of the type. For structs the ``struct`` prefix is omitted.
            * C++: Returns the qualified name of the type (including anonymous/inline
              namespaces and all template arguments).
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetName(self)

    def GetDisplayTypeName(self):
        r"""
        GetDisplayTypeName() -> string
        Returns the name of this type in a user-friendly format.

            Returns an empty string if an error occurred or this type is invalid.

            Use this function when displaying a type name to the user.

            Language-specific behaviour:

            * C: Returns the type name. For structs the ``struct`` prefix is omitted.
            * C++: Returns the qualified name. Anonymous/inline namespaces are omitted.
              Template arguments that match their default value might also be hidden
              (this functionality depends on whether LLDB can determine the template's
              default arguments).
            * Objective-C: Same as in C.

        """
        return _lldb.SBType_GetDisplayTypeName(self)

    def GetTypeClass(self):
        r"""
        GetTypeClass() -> TypeClass
        Returns the `TypeClass` for this type.

            Returns an `eTypeClassInvalid` if this `SBType` is invalid.

            See `TypeClass` for the language-specific meaning of each `TypeClass` value.

        """
        return _lldb.SBType_GetTypeClass(self)

    def IsTypeComplete(self):
        r"""
        IsTypeComplete(SBType self) -> bool
        Returns true if the type is completely defined.

            Language-specific behaviour:

            * C: Returns false for struct types that were only forward declared in the
              type's `SBTarget`/`SBModule`. Otherwise returns true.
            * C++: Returns false for template/non-template struct/class types and
              scoped enums that were only forward declared inside the type's
              `SBTarget`/`SBModule`. Otherwise returns true.
            * Objective-C: Follows the same behavior as C for struct types. Objective-C
              classes are considered complete unless they were only forward declared via
              ``@class ClassName`` in the type's `SBTarget`/`SBModule`. Otherwise
              returns true.

        """
        return _lldb.SBType_IsTypeComplete(self)

    def GetTypeFlags(self):
        r"""
        GetTypeFlags(SBType self) -> uint32_t
        Returns the `TypeFlags` values for this type.

            See the respective `TypeFlags` values for what values can be set. Returns an
            integer in which each `TypeFlags` value is represented by a bit. Specific
            flags can be checked via Python's bitwise operators. For example, the
            `eTypeIsInteger` flag can be checked like this:

            ``(an_sb_type.GetTypeFlags() & lldb.eTypeIsInteger) != 0``

            If this type is invalid this returns ``0``.

            See the different values for `TypeFlags` for the language-specific meanings
            of each `TypeFlags` value.

        """
        return _lldb.SBType_GetTypeFlags(self)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBType self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBType_GetDescription(self, description, description_level)

    def FindDirectNestedType(self, name):
        r"""
        FindDirectNestedType(SBType self, char const * name) -> SBType
        Searches for a directly nested type that has the provided name.

            Returns the type if it was found.
            Returns invalid type if nothing was found.

        """
        return _lldb.SBType_FindDirectNestedType(self, name)

    def __eq__(self, rhs):
        r"""__eq__(SBType self, SBType rhs) -> bool"""
        return _lldb.SBType___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBType self, SBType rhs) -> bool"""
        return _lldb.SBType___ne__(self, rhs)

    def __repr__(self):
        r"""__repr__(SBType self) -> std::string"""
        return _lldb.SBType___repr__(self)

    def template_arg_array(self):
        num_args = self.num_template_args
        if num_args:
            template_args = []
            for i in range(num_args):
                template_args.append(self.GetTemplateArgumentType(i))
            return template_args
        return None

    # operator== is a free function, which swig does not handle, so we inject
    # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __len__(self):
        return self.GetByteSize()

    module = property(GetModule, None, doc='''A read only property that returns the module in which type is defined.''')
    name = property(GetName, None, doc='''A read only property that returns the name for this type as a string.''')
    size = property(GetByteSize, None, doc='''A read only property that returns size in bytes for this type as an integer.''')
    is_pointer = property(IsPointerType, None, doc='''A read only property that returns a boolean value that indicates if this type is a pointer type.''')
    is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a reference type.''')
    is_reference = property(IsReferenceType, None, doc='''A read only property that returns a boolean value that indicates if this type is a function type.''')
    num_fields = property(GetNumberOfFields, None, doc='''A read only property that returns number of fields in this type as an integer.''')
    num_bases = property(GetNumberOfDirectBaseClasses, None, doc='''A read only property that returns number of direct base classes in this type as an integer.''')
    num_vbases = property(GetNumberOfVirtualBaseClasses, None, doc='''A read only property that returns number of virtual base classes in this type as an integer.''')
    num_template_args = property(GetNumberOfTemplateArguments, None, doc='''A read only property that returns number of template arguments in this type as an integer.''')
    template_args = property(template_arg_array, None, doc='''A read only property that returns a list() of lldb.SBType objects that represent all template arguments in this type.''')
    type = property(GetTypeClass, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eTypeClass") that represents a classification for this type.''')
    is_complete = property(IsTypeComplete, None, doc='''A read only property that returns a boolean value that indicates if this type is a complete type (True) or a forward declaration (False).''')

    def get_bases_array(self):
        '''An accessor function that returns a list() that contains all direct base classes in a lldb.SBType object.'''
        bases = []
        for idx in range(self.GetNumberOfDirectBaseClasses()):
            bases.append(self.GetDirectBaseClassAtIndex(idx))
        return bases

    def get_vbases_array(self):
        '''An accessor function that returns a list() that contains all fields in a lldb.SBType object.'''
        vbases = []
        for idx in range(self.GetNumberOfVirtualBaseClasses()):
            vbases.append(self.GetVirtualBaseClassAtIndex(idx))
        return vbases

    def get_fields_array(self):
        '''An accessor function that returns a list() that contains all fields in a lldb.SBType object.'''
        fields = []
        for idx in range(self.GetNumberOfFields()):
            fields.append(self.GetFieldAtIndex(idx))
        return fields

    def get_members_array(self):
        '''An accessor function that returns a list() that contains all members (base classes and fields) in a lldb.SBType object in ascending bit offset order.'''
        members = []
        bases = self.get_bases_array()
        fields = self.get_fields_array()
        vbases = self.get_vbases_array()
        for base in bases:
            bit_offset = base.bit_offset
            added = False
            for idx, member in enumerate(members):
                if member.bit_offset > bit_offset:
                    members.insert(idx, base)
                    added = True
                    break
            if not added:
                members.append(base)
        for vbase in vbases:
            bit_offset = vbase.bit_offset
            added = False
            for idx, member in enumerate(members):
                if member.bit_offset > bit_offset:
                    members.insert(idx, vbase)
                    added = True
                    break
            if not added:
                members.append(vbase)
        for field in fields:
            bit_offset = field.bit_offset
            added = False
            for idx, member in enumerate(members):
                if member.bit_offset > bit_offset:
                    members.insert(idx, field)
                    added = True
                    break
            if not added:
                members.append(field)
        return members

    def get_enum_members_array(self):
        '''An accessor function that returns a list() that contains all enum members in an lldb.SBType object.'''
        enum_members_list = []
        sb_enum_members = self.GetEnumMembers()
        for idx in range(sb_enum_members.GetSize()):
            enum_members_list.append(sb_enum_members.GetTypeEnumMemberAtIndex(idx))
        return enum_members_list

    bases = property(get_bases_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the direct base classes for this type.''')
    vbases = property(get_vbases_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the virtual base classes for this type.''')
    fields = property(get_fields_array, None, doc='''A read only property that returns a list() of lldb.SBTypeMember objects that represent all of the fields for this type.''')
    members = property(get_members_array, None, doc='''A read only property that returns a list() of all lldb.SBTypeMember objects that represent all of the base classes, virtual base classes and fields for this type in ascending bit offset order.''')
    enum_members = property(get_enum_members_array, None, doc='''A read only property that returns a list() of all lldb.SBTypeEnumMember objects that represent the enum members for this type.''')


# Register SBType in _lldb:
_lldb.SBType_swigregister(SBType)
class SBTypeList(object):
    r"""
    Represents a list of :py:class:`SBType` s.

    The FindTypes() method of :py:class:`SBTarget`/:py:class:`SBModule` returns a SBTypeList.

    SBTypeList supports :py:class:`SBType` iteration. For example,

    .. code-block:: cpp

        // main.cpp:

        class Task {
        public:
            int id;
            Task *next;
            Task(int i, Task *n):
                id(i),
                next(n)
            {}
        };

    .. code-block:: python

        # find_type.py:

        # Get the type 'Task'.
        type_list = target.FindTypes('Task')
        self.assertTrue(len(type_list) == 1)
        # To illustrate the SBType iteration.
        for type in type_list:
            # do something with type


    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBTypeList self) -> SBTypeList
        __init__(SBTypeList self, SBTypeList rhs) -> SBTypeList
        """
        _lldb.SBTypeList_swiginit(self, _lldb.new_SBTypeList(*args))
    __swig_destroy__ = _lldb.delete_SBTypeList

    def __nonzero__(self):
        return _lldb.SBTypeList___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeList self) -> bool"""
        return _lldb.SBTypeList_IsValid(self)

    def Append(self, type):
        r"""Append(SBTypeList self, SBType type)"""
        return _lldb.SBTypeList_Append(self, type)

    def GetTypeAtIndex(self, index):
        r"""GetTypeAtIndex(SBTypeList self, uint32_t index) -> SBType"""
        return _lldb.SBTypeList_GetTypeAtIndex(self, index)

    def GetSize(self):
        r"""GetSize(SBTypeList self) -> uint32_t"""
        return _lldb.SBTypeList_GetSize(self)

        # operator== is a free function, which swig does not handle, so we inject
        # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    def __iter__(self):
        '''Iterate over all types in a lldb.SBTypeList object.'''
        return lldb_iter(self, 'GetSize', 'GetTypeAtIndex')

    def __len__(self):
        '''Return the number of types in a lldb.SBTypeList object.'''
        return self.GetSize()


# Register SBTypeList in _lldb:
_lldb.SBTypeList_swigregister(SBTypeList)
class SBTypeCategory(object):
    r"""Represents a category that can contain formatters for types."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBTypeCategory self) -> SBTypeCategory
        __init__(SBTypeCategory self, SBTypeCategory rhs) -> SBTypeCategory
        """
        _lldb.SBTypeCategory_swiginit(self, _lldb.new_SBTypeCategory(*args))
    __swig_destroy__ = _lldb.delete_SBTypeCategory

    def __nonzero__(self):
        return _lldb.SBTypeCategory___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeCategory self) -> bool"""
        return _lldb.SBTypeCategory_IsValid(self)

    def GetEnabled(self):
        r"""GetEnabled(SBTypeCategory self) -> bool"""
        return _lldb.SBTypeCategory_GetEnabled(self)

    def SetEnabled(self, arg2):
        r"""SetEnabled(SBTypeCategory self, bool arg2)"""
        return _lldb.SBTypeCategory_SetEnabled(self, arg2)

    def GetName(self):
        r"""GetName(SBTypeCategory self) -> char const *"""
        return _lldb.SBTypeCategory_GetName(self)

    def GetLanguageAtIndex(self, idx):
        r"""GetLanguageAtIndex(SBTypeCategory self, uint32_t idx) -> lldb::LanguageType"""
        return _lldb.SBTypeCategory_GetLanguageAtIndex(self, idx)

    def GetNumLanguages(self):
        r"""GetNumLanguages(SBTypeCategory self) -> uint32_t"""
        return _lldb.SBTypeCategory_GetNumLanguages(self)

    def AddLanguage(self, language):
        r"""AddLanguage(SBTypeCategory self, lldb::LanguageType language)"""
        return _lldb.SBTypeCategory_AddLanguage(self, language)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeCategory self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeCategory_GetDescription(self, description, description_level)

    def GetNumFormats(self):
        r"""GetNumFormats(SBTypeCategory self) -> uint32_t"""
        return _lldb.SBTypeCategory_GetNumFormats(self)

    def GetNumSummaries(self):
        r"""GetNumSummaries(SBTypeCategory self) -> uint32_t"""
        return _lldb.SBTypeCategory_GetNumSummaries(self)

    def GetNumFilters(self):
        r"""GetNumFilters(SBTypeCategory self) -> uint32_t"""
        return _lldb.SBTypeCategory_GetNumFilters(self)

    def GetNumSynthetics(self):
        r"""GetNumSynthetics(SBTypeCategory self) -> uint32_t"""
        return _lldb.SBTypeCategory_GetNumSynthetics(self)

    def GetTypeNameSpecifierForFilterAtIndex(self, arg2):
        r"""GetTypeNameSpecifierForFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
        return _lldb.SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(self, arg2)

    def GetTypeNameSpecifierForFormatAtIndex(self, arg2):
        r"""GetTypeNameSpecifierForFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
        return _lldb.SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(self, arg2)

    def GetTypeNameSpecifierForSummaryAtIndex(self, arg2):
        r"""GetTypeNameSpecifierForSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
        return _lldb.SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(self, arg2)

    def GetTypeNameSpecifierForSyntheticAtIndex(self, arg2):
        r"""GetTypeNameSpecifierForSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier"""
        return _lldb.SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(self, arg2)

    def GetFilterForType(self, arg2):
        r"""GetFilterForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFilter"""
        return _lldb.SBTypeCategory_GetFilterForType(self, arg2)

    def GetFormatForType(self, arg2):
        r"""GetFormatForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFormat"""
        return _lldb.SBTypeCategory_GetFormatForType(self, arg2)

    def GetSummaryForType(self, arg2):
        r"""GetSummaryForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSummary"""
        return _lldb.SBTypeCategory_GetSummaryForType(self, arg2)

    def GetSyntheticForType(self, arg2):
        r"""GetSyntheticForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic"""
        return _lldb.SBTypeCategory_GetSyntheticForType(self, arg2)

    def GetFilterAtIndex(self, arg2):
        r"""GetFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFilter"""
        return _lldb.SBTypeCategory_GetFilterAtIndex(self, arg2)

    def GetFormatAtIndex(self, arg2):
        r"""GetFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFormat"""
        return _lldb.SBTypeCategory_GetFormatAtIndex(self, arg2)

    def GetSummaryAtIndex(self, arg2):
        r"""GetSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSummary"""
        return _lldb.SBTypeCategory_GetSummaryAtIndex(self, arg2)

    def GetSyntheticAtIndex(self, arg2):
        r"""GetSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSynthetic"""
        return _lldb.SBTypeCategory_GetSyntheticAtIndex(self, arg2)

    def AddTypeFormat(self, arg2, arg3):
        r"""AddTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFormat arg3) -> bool"""
        return _lldb.SBTypeCategory_AddTypeFormat(self, arg2, arg3)

    def DeleteTypeFormat(self, arg2):
        r"""DeleteTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
        return _lldb.SBTypeCategory_DeleteTypeFormat(self, arg2)

    def AddTypeSummary(self, arg2, arg3):
        r"""AddTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSummary arg3) -> bool"""
        return _lldb.SBTypeCategory_AddTypeSummary(self, arg2, arg3)

    def DeleteTypeSummary(self, arg2):
        r"""DeleteTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
        return _lldb.SBTypeCategory_DeleteTypeSummary(self, arg2)

    def AddTypeFilter(self, arg2, arg3):
        r"""AddTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFilter arg3) -> bool"""
        return _lldb.SBTypeCategory_AddTypeFilter(self, arg2, arg3)

    def DeleteTypeFilter(self, arg2):
        r"""DeleteTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
        return _lldb.SBTypeCategory_DeleteTypeFilter(self, arg2)

    def AddTypeSynthetic(self, arg2, arg3):
        r"""AddTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSynthetic arg3) -> bool"""
        return _lldb.SBTypeCategory_AddTypeSynthetic(self, arg2, arg3)

    def DeleteTypeSynthetic(self, arg2):
        r"""DeleteTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool"""
        return _lldb.SBTypeCategory_DeleteTypeSynthetic(self, arg2)

    def __eq__(self, rhs):
        r"""__eq__(SBTypeCategory self, SBTypeCategory rhs) -> bool"""
        return _lldb.SBTypeCategory___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBTypeCategory self, SBTypeCategory rhs) -> bool"""
        return _lldb.SBTypeCategory___ne__(self, rhs)

    def __repr__(self):
        r"""__repr__(SBTypeCategory self) -> std::string"""
        return _lldb.SBTypeCategory___repr__(self)

                # operator== is a free function, which swig does not handle, so we inject
                # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)


    class formatters_access_class(object):
        '''A helper object that will lazily hand out formatters for a specific category.'''
        def __init__(self, sbcategory, get_count_function, get_at_index_function, get_by_name_function):
            self.sbcategory = sbcategory
            self.get_count_function = get_count_function
            self.get_at_index_function = get_at_index_function
            self.get_by_name_function = get_by_name_function
            self.regex_type = type(re.compile('.'))


        def __len__(self):
            if self.sbcategory and self.get_count_function:
                return int(self.get_count_function(self.sbcategory))
            return 0

        def __getitem__(self, key):
            num_items = len(self)
            if type(key) is int:
                if -num_items <= key < num_items:
                    key %= num_items
                    return self.get_at_index_function(self.sbcategory,key)
            elif type(key) is str:
                return self.get_by_name_function(self.sbcategory,SBTypeNameSpecifier(key))
            elif isinstance(key,self.regex_type):
                return self.get_by_name_function(self.sbcategory,SBTypeNameSpecifier(key.pattern,True))
            else:
                print("error: unsupported item type: %s" % type(key))
            return None

    def get_formats_access_object(self):
        '''An accessor function that returns an accessor object which allows lazy format access from a lldb.SBTypeCategory object.'''
        return self.formatters_access_class (self,self.__class__.GetNumFormats,self.__class__.GetFormatAtIndex,self.__class__.GetFormatForType)

    def get_formats_array(self):
        '''An accessor function that returns a list() that contains all formats in a lldb.SBCategory object.'''
        formats = []
        for idx in range(self.GetNumFormats()):
            formats.append(self.GetFormatAtIndex(idx))
        return formats

    def get_summaries_access_object(self):
        '''An accessor function that returns an accessor object which allows lazy summary access from a lldb.SBTypeCategory object.'''
        return self.formatters_access_class (self,self.__class__.GetNumSummaries,self.__class__.GetSummaryAtIndex,self.__class__.GetSummaryForType)

    def get_summaries_array(self):
        '''An accessor function that returns a list() that contains all summaries in a lldb.SBCategory object.'''
        summaries = []
        for idx in range(self.GetNumSummaries()):
            summaries.append(self.GetSummaryAtIndex(idx))
        return summaries

    def get_synthetics_access_object(self):
        '''An accessor function that returns an accessor object which allows lazy synthetic children provider access from a lldb.SBTypeCategory object.'''
        return self.formatters_access_class (self,self.__class__.GetNumSynthetics,self.__class__.GetSyntheticAtIndex,self.__class__.GetSyntheticForType)

    def get_synthetics_array(self):
        '''An accessor function that returns a list() that contains all synthetic children providers in a lldb.SBCategory object.'''
        synthetics = []
        for idx in range(self.GetNumSynthetics()):
            synthetics.append(self.GetSyntheticAtIndex(idx))
        return synthetics

    def get_filters_access_object(self):
        '''An accessor function that returns an accessor object which allows lazy filter access from a lldb.SBTypeCategory object.'''
        return self.formatters_access_class (self,self.__class__.GetNumFilters,self.__class__.GetFilterAtIndex,self.__class__.GetFilterForType)

    def get_filters_array(self):
        '''An accessor function that returns a list() that contains all filters in a lldb.SBCategory object.'''
        filters = []
        for idx in range(self.GetNumFilters()):
            filters.append(self.GetFilterAtIndex(idx))
        return filters

    formats = property(get_formats_array, None, doc='''A read only property that returns a list() of lldb.SBTypeFormat objects contained in this category''')
    format = property(get_formats_access_object, None, doc=r'''A read only property that returns an object that you can use to look for formats by index or type name.''')
    summaries = property(get_summaries_array, None, doc='''A read only property that returns a list() of lldb.SBTypeSummary objects contained in this category''')
    summary = property(get_summaries_access_object, None, doc=r'''A read only property that returns an object that you can use to look for summaries by index or type name or regular expression.''')
    filters = property(get_filters_array, None, doc='''A read only property that returns a list() of lldb.SBTypeFilter objects contained in this category''')
    filter = property(get_filters_access_object, None, doc=r'''A read only property that returns an object that you can use to look for filters by index or type name or regular expression.''')
    synthetics = property(get_synthetics_array, None, doc='''A read only property that returns a list() of lldb.SBTypeSynthetic objects contained in this category''')
    synthetic = property(get_synthetics_access_object, None, doc=r'''A read only property that returns an object that you can use to look for synthetic children provider by index or type name or regular expression.''')
    num_formats = property(GetNumFormats, None)
    num_summaries = property(GetNumSummaries, None)
    num_filters = property(GetNumFilters, None)
    num_synthetics = property(GetNumSynthetics, None)
    name = property(GetName, None)
    enabled = property(GetEnabled, SetEnabled)


# Register SBTypeCategory in _lldb:
_lldb.SBTypeCategory_swigregister(SBTypeCategory)
class SBTypeEnumMember(object):
    r"""Represents a member of an enum in lldb."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBTypeEnumMember self) -> SBTypeEnumMember
        __init__(SBTypeEnumMember self, SBTypeEnumMember rhs) -> SBTypeEnumMember
        """
        _lldb.SBTypeEnumMember_swiginit(self, _lldb.new_SBTypeEnumMember(*args))
    __swig_destroy__ = _lldb.delete_SBTypeEnumMember

    def __nonzero__(self):
        return _lldb.SBTypeEnumMember___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeEnumMember self) -> bool"""
        return _lldb.SBTypeEnumMember_IsValid(self)

    def GetValueAsSigned(self):
        r"""GetValueAsSigned(SBTypeEnumMember self) -> int64_t"""
        return _lldb.SBTypeEnumMember_GetValueAsSigned(self)

    def GetValueAsUnsigned(self):
        r"""GetValueAsUnsigned(SBTypeEnumMember self) -> uint64_t"""
        return _lldb.SBTypeEnumMember_GetValueAsUnsigned(self)

    def GetName(self):
        r"""GetName(SBTypeEnumMember self) -> char const *"""
        return _lldb.SBTypeEnumMember_GetName(self)

    def GetType(self):
        r"""GetType(SBTypeEnumMember self) -> SBType"""
        return _lldb.SBTypeEnumMember_GetType(self)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeEnumMember self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeEnumMember_GetDescription(self, description, description_level)

    def __repr__(self):
        r"""__repr__(SBTypeEnumMember self) -> std::string"""
        return _lldb.SBTypeEnumMember___repr__(self)

    def __iter__(self):
        '''Iterate over all members in a lldb.SBTypeEnumMemberList object.'''
        return lldb_iter(self, 'GetSize', 'GetTypeEnumMemberAtIndex')

    def __len__(self):
        '''Return the number of members in a lldb.SBTypeEnumMemberList object.'''
        return self.GetSize()

    name = property(GetName, None, doc='''A read only property that returns the name for this enum member as a string.''')
    type = property(GetType, None, doc='''A read only property that returns an lldb object that represents the type (lldb.SBType) for this enum member.''')
    signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this enum member as a signed integer.''')
    unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this enum member as a unsigned integer.''')


# Register SBTypeEnumMember in _lldb:
_lldb.SBTypeEnumMember_swigregister(SBTypeEnumMember)
class SBTypeEnumMemberList(object):
    r"""
    Represents a list of SBTypeEnumMembers.

    SBTypeEnumMemberList supports SBTypeEnumMember iteration.
    It also supports [] access either by index, or by enum
    element name by doing: ::

      myType = target.FindFirstType('MyEnumWithElementA')
      members = myType.GetEnumMembers()
      first_elem = members[0]
      elem_A = members['A']


    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBTypeEnumMemberList self) -> SBTypeEnumMemberList
        __init__(SBTypeEnumMemberList self, SBTypeEnumMemberList rhs) -> SBTypeEnumMemberList
        """
        _lldb.SBTypeEnumMemberList_swiginit(self, _lldb.new_SBTypeEnumMemberList(*args))
    __swig_destroy__ = _lldb.delete_SBTypeEnumMemberList

    def __nonzero__(self):
        return _lldb.SBTypeEnumMemberList___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeEnumMemberList self) -> bool"""
        return _lldb.SBTypeEnumMemberList_IsValid(self)

    def Append(self, entry):
        r"""Append(SBTypeEnumMemberList self, SBTypeEnumMember entry)"""
        return _lldb.SBTypeEnumMemberList_Append(self, entry)

    def GetTypeEnumMemberAtIndex(self, index):
        r"""GetTypeEnumMemberAtIndex(SBTypeEnumMemberList self, uint32_t index) -> SBTypeEnumMember"""
        return _lldb.SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(self, index)

    def GetSize(self):
        r"""GetSize(SBTypeEnumMemberList self) -> uint32_t"""
        return _lldb.SBTypeEnumMemberList_GetSize(self)

    def __iter__(self):
        '''Iterate over all members in a lldb.SBTypeEnumMemberList object.'''
        return lldb_iter(self, 'GetSize', 'GetTypeEnumMemberAtIndex')

    def __len__(self):
        '''Return the number of members in a lldb.SBTypeEnumMemberList object.'''
        return self.GetSize()

    def __getitem__(self, key):
      num_elements = self.GetSize()
      if type(key) is int:
          if -num_elements <= key < num_elements:
              key %= num_elements
              return self.GetTypeEnumMemberAtIndex(key)
      elif type(key) is str:
          for idx in range(num_elements):
              item = self.GetTypeEnumMemberAtIndex(idx)
              if item.name == key:
                  return item
      return None


# Register SBTypeEnumMemberList in _lldb:
_lldb.SBTypeEnumMemberList_swigregister(SBTypeEnumMemberList)
class SBTypeFilter(object):
    r"""Represents a filter that can be associated to one or more types."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBTypeFilter self) -> SBTypeFilter
        __init__(SBTypeFilter self, uint32_t options) -> SBTypeFilter
        __init__(SBTypeFilter self, SBTypeFilter rhs) -> SBTypeFilter
        """
        _lldb.SBTypeFilter_swiginit(self, _lldb.new_SBTypeFilter(*args))
    __swig_destroy__ = _lldb.delete_SBTypeFilter

    def __nonzero__(self):
        return _lldb.SBTypeFilter___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeFilter self) -> bool"""
        return _lldb.SBTypeFilter_IsValid(self)

    def GetNumberOfExpressionPaths(self):
        r"""GetNumberOfExpressionPaths(SBTypeFilter self) -> uint32_t"""
        return _lldb.SBTypeFilter_GetNumberOfExpressionPaths(self)

    def GetExpressionPathAtIndex(self, i):
        r"""GetExpressionPathAtIndex(SBTypeFilter self, uint32_t i) -> char const *"""
        return _lldb.SBTypeFilter_GetExpressionPathAtIndex(self, i)

    def ReplaceExpressionPathAtIndex(self, i, item):
        r"""ReplaceExpressionPathAtIndex(SBTypeFilter self, uint32_t i, char const * item) -> bool"""
        return _lldb.SBTypeFilter_ReplaceExpressionPathAtIndex(self, i, item)

    def AppendExpressionPath(self, item):
        r"""AppendExpressionPath(SBTypeFilter self, char const * item)"""
        return _lldb.SBTypeFilter_AppendExpressionPath(self, item)

    def Clear(self):
        r"""Clear(SBTypeFilter self)"""
        return _lldb.SBTypeFilter_Clear(self)

    def GetOptions(self):
        r"""GetOptions(SBTypeFilter self) -> uint32_t"""
        return _lldb.SBTypeFilter_GetOptions(self)

    def SetOptions(self, arg2):
        r"""SetOptions(SBTypeFilter self, uint32_t arg2)"""
        return _lldb.SBTypeFilter_SetOptions(self, arg2)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeFilter self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeFilter_GetDescription(self, description, description_level)

    def IsEqualTo(self, rhs):
        r"""IsEqualTo(SBTypeFilter self, SBTypeFilter rhs) -> bool"""
        return _lldb.SBTypeFilter_IsEqualTo(self, rhs)

    def __eq__(self, rhs):
        r"""__eq__(SBTypeFilter self, SBTypeFilter rhs) -> bool"""
        return _lldb.SBTypeFilter___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBTypeFilter self, SBTypeFilter rhs) -> bool"""
        return _lldb.SBTypeFilter___ne__(self, rhs)

    def __repr__(self):
        r"""__repr__(SBTypeFilter self) -> std::string"""
        return _lldb.SBTypeFilter___repr__(self)

                # operator== is a free function, which swig does not handle, so we inject
                # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    options = property(GetOptions, SetOptions)
    count = property(GetNumberOfExpressionPaths)


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBTypeFilter in _lldb:
_lldb.SBTypeFilter_swigregister(SBTypeFilter)
class SBTypeFormat(object):
    r"""Represents a format that can be associated to one or more types."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBTypeFormat self) -> SBTypeFormat
        __init__(SBTypeFormat self, lldb::Format format, uint32_t options=0) -> SBTypeFormat
        __init__(SBTypeFormat self, char const * type, uint32_t options=0) -> SBTypeFormat
        __init__(SBTypeFormat self, SBTypeFormat rhs) -> SBTypeFormat
        """
        _lldb.SBTypeFormat_swiginit(self, _lldb.new_SBTypeFormat(*args))
    __swig_destroy__ = _lldb.delete_SBTypeFormat

    def __nonzero__(self):
        return _lldb.SBTypeFormat___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeFormat self) -> bool"""
        return _lldb.SBTypeFormat_IsValid(self)

    def GetFormat(self):
        r"""GetFormat(SBTypeFormat self) -> lldb::Format"""
        return _lldb.SBTypeFormat_GetFormat(self)

    def GetTypeName(self):
        r"""GetTypeName(SBTypeFormat self) -> char const *"""
        return _lldb.SBTypeFormat_GetTypeName(self)

    def GetOptions(self):
        r"""GetOptions(SBTypeFormat self) -> uint32_t"""
        return _lldb.SBTypeFormat_GetOptions(self)

    def SetFormat(self, arg2):
        r"""SetFormat(SBTypeFormat self, lldb::Format arg2)"""
        return _lldb.SBTypeFormat_SetFormat(self, arg2)

    def SetTypeName(self, arg2):
        r"""SetTypeName(SBTypeFormat self, char const * arg2)"""
        return _lldb.SBTypeFormat_SetTypeName(self, arg2)

    def SetOptions(self, arg2):
        r"""SetOptions(SBTypeFormat self, uint32_t arg2)"""
        return _lldb.SBTypeFormat_SetOptions(self, arg2)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeFormat self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeFormat_GetDescription(self, description, description_level)

    def IsEqualTo(self, rhs):
        r"""IsEqualTo(SBTypeFormat self, SBTypeFormat rhs) -> bool"""
        return _lldb.SBTypeFormat_IsEqualTo(self, rhs)

    def __eq__(self, rhs):
        r"""__eq__(SBTypeFormat self, SBTypeFormat rhs) -> bool"""
        return _lldb.SBTypeFormat___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBTypeFormat self, SBTypeFormat rhs) -> bool"""
        return _lldb.SBTypeFormat___ne__(self, rhs)

    def __repr__(self):
        r"""__repr__(SBTypeFormat self) -> std::string"""
        return _lldb.SBTypeFormat___repr__(self)

                # operator== is a free function, which swig does not handle, so we inject
                # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    format = property(GetFormat, SetFormat)
    options = property(GetOptions, SetOptions)


# Register SBTypeFormat in _lldb:
_lldb.SBTypeFormat_swigregister(SBTypeFormat)
class SBTypeNameSpecifier(object):
    r"""Represents a general way to provide a type name to LLDB APIs."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBTypeNameSpecifier self) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, char const * name, bool is_regex=False) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, char const * name, lldb::FormatterMatchType match_type) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, SBType type) -> SBTypeNameSpecifier
        __init__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> SBTypeNameSpecifier
        """
        _lldb.SBTypeNameSpecifier_swiginit(self, _lldb.new_SBTypeNameSpecifier(*args))
    __swig_destroy__ = _lldb.delete_SBTypeNameSpecifier

    def __nonzero__(self):
        return _lldb.SBTypeNameSpecifier___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeNameSpecifier self) -> bool"""
        return _lldb.SBTypeNameSpecifier_IsValid(self)

    def GetName(self):
        r"""GetName(SBTypeNameSpecifier self) -> char const *"""
        return _lldb.SBTypeNameSpecifier_GetName(self)

    def GetType(self):
        r"""GetType(SBTypeNameSpecifier self) -> SBType"""
        return _lldb.SBTypeNameSpecifier_GetType(self)

    def GetMatchType(self):
        r"""GetMatchType(SBTypeNameSpecifier self) -> lldb::FormatterMatchType"""
        return _lldb.SBTypeNameSpecifier_GetMatchType(self)

    def IsRegex(self):
        r"""IsRegex(SBTypeNameSpecifier self) -> bool"""
        return _lldb.SBTypeNameSpecifier_IsRegex(self)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeNameSpecifier self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeNameSpecifier_GetDescription(self, description, description_level)

    def IsEqualTo(self, rhs):
        r"""IsEqualTo(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"""
        return _lldb.SBTypeNameSpecifier_IsEqualTo(self, rhs)

    def __eq__(self, rhs):
        r"""__eq__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"""
        return _lldb.SBTypeNameSpecifier___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool"""
        return _lldb.SBTypeNameSpecifier___ne__(self, rhs)

    def __repr__(self):
        r"""__repr__(SBTypeNameSpecifier self) -> std::string"""
        return _lldb.SBTypeNameSpecifier___repr__(self)

                # operator== is a free function, which swig does not handle, so we inject
                # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    name = property(GetName)
    is_regex = property(IsRegex)


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBTypeNameSpecifier in _lldb:
_lldb.SBTypeNameSpecifier_swigregister(SBTypeNameSpecifier)
class SBTypeSummaryOptions(object):
    r"""Proxy of C++ lldb::SBTypeSummaryOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBTypeSummaryOptions self) -> SBTypeSummaryOptions
        __init__(SBTypeSummaryOptions self, SBTypeSummaryOptions rhs) -> SBTypeSummaryOptions
        """
        _lldb.SBTypeSummaryOptions_swiginit(self, _lldb.new_SBTypeSummaryOptions(*args))
    __swig_destroy__ = _lldb.delete_SBTypeSummaryOptions

    def __nonzero__(self):
        return _lldb.SBTypeSummaryOptions___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeSummaryOptions self) -> bool"""
        return _lldb.SBTypeSummaryOptions_IsValid(self)

    def GetLanguage(self):
        r"""GetLanguage(SBTypeSummaryOptions self) -> lldb::LanguageType"""
        return _lldb.SBTypeSummaryOptions_GetLanguage(self)

    def GetCapping(self):
        r"""GetCapping(SBTypeSummaryOptions self) -> lldb::TypeSummaryCapping"""
        return _lldb.SBTypeSummaryOptions_GetCapping(self)

    def SetLanguage(self, arg2):
        r"""SetLanguage(SBTypeSummaryOptions self, lldb::LanguageType arg2)"""
        return _lldb.SBTypeSummaryOptions_SetLanguage(self, arg2)

    def SetCapping(self, arg2):
        r"""SetCapping(SBTypeSummaryOptions self, lldb::TypeSummaryCapping arg2)"""
        return _lldb.SBTypeSummaryOptions_SetCapping(self, arg2)

# Register SBTypeSummaryOptions in _lldb:
_lldb.SBTypeSummaryOptions_swigregister(SBTypeSummaryOptions)
class SBTypeSummary(object):
    r"""Represents a summary that can be associated to one or more types."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    @staticmethod
    def CreateWithSummaryString(data, options=0):
        r"""CreateWithSummaryString(char const * data, uint32_t options=0) -> SBTypeSummary"""
        return _lldb.SBTypeSummary_CreateWithSummaryString(data, options)

    @staticmethod
    def CreateWithFunctionName(data, options=0):
        r"""CreateWithFunctionName(char const * data, uint32_t options=0) -> SBTypeSummary"""
        return _lldb.SBTypeSummary_CreateWithFunctionName(data, options)

    @staticmethod
    def CreateWithScriptCode(data, options=0):
        r"""CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSummary"""
        return _lldb.SBTypeSummary_CreateWithScriptCode(data, options)

    def __init__(self, *args):
        r"""
        __init__(SBTypeSummary self) -> SBTypeSummary
        __init__(SBTypeSummary self, SBTypeSummary rhs) -> SBTypeSummary
        """
        _lldb.SBTypeSummary_swiginit(self, _lldb.new_SBTypeSummary(*args))
    __swig_destroy__ = _lldb.delete_SBTypeSummary

    def __nonzero__(self):
        return _lldb.SBTypeSummary___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeSummary self) -> bool"""
        return _lldb.SBTypeSummary_IsValid(self)

    def IsFunctionCode(self):
        r"""IsFunctionCode(SBTypeSummary self) -> bool"""
        return _lldb.SBTypeSummary_IsFunctionCode(self)

    def IsFunctionName(self):
        r"""IsFunctionName(SBTypeSummary self) -> bool"""
        return _lldb.SBTypeSummary_IsFunctionName(self)

    def IsSummaryString(self):
        r"""IsSummaryString(SBTypeSummary self) -> bool"""
        return _lldb.SBTypeSummary_IsSummaryString(self)

    def GetData(self):
        r"""GetData(SBTypeSummary self) -> char const *"""
        return _lldb.SBTypeSummary_GetData(self)

    def SetSummaryString(self, data):
        r"""SetSummaryString(SBTypeSummary self, char const * data)"""
        return _lldb.SBTypeSummary_SetSummaryString(self, data)

    def SetFunctionName(self, data):
        r"""SetFunctionName(SBTypeSummary self, char const * data)"""
        return _lldb.SBTypeSummary_SetFunctionName(self, data)

    def SetFunctionCode(self, data):
        r"""SetFunctionCode(SBTypeSummary self, char const * data)"""
        return _lldb.SBTypeSummary_SetFunctionCode(self, data)

    def GetPtrMatchDepth(self):
        r"""GetPtrMatchDepth(SBTypeSummary self) -> uint32_t"""
        return _lldb.SBTypeSummary_GetPtrMatchDepth(self)

    def SetPtrMatchDepth(self, ptr_match_depth):
        r"""SetPtrMatchDepth(SBTypeSummary self, uint32_t ptr_match_depth)"""
        return _lldb.SBTypeSummary_SetPtrMatchDepth(self, ptr_match_depth)

    def GetOptions(self):
        r"""GetOptions(SBTypeSummary self) -> uint32_t"""
        return _lldb.SBTypeSummary_GetOptions(self)

    def SetOptions(self, arg2):
        r"""SetOptions(SBTypeSummary self, uint32_t arg2)"""
        return _lldb.SBTypeSummary_SetOptions(self, arg2)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeSummary self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeSummary_GetDescription(self, description, description_level)

    def DoesPrintValue(self, value):
        r"""DoesPrintValue(SBTypeSummary self, SBValue value) -> bool"""
        return _lldb.SBTypeSummary_DoesPrintValue(self, value)

    def IsEqualTo(self, rhs):
        r"""IsEqualTo(SBTypeSummary self, SBTypeSummary rhs) -> bool"""
        return _lldb.SBTypeSummary_IsEqualTo(self, rhs)

    def __eq__(self, rhs):
        r"""__eq__(SBTypeSummary self, SBTypeSummary rhs) -> bool"""
        return _lldb.SBTypeSummary___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBTypeSummary self, SBTypeSummary rhs) -> bool"""
        return _lldb.SBTypeSummary___ne__(self, rhs)

    def __repr__(self):
        r"""__repr__(SBTypeSummary self) -> std::string"""
        return _lldb.SBTypeSummary___repr__(self)

                # operator== is a free function, which swig does not handle, so we inject
                # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    options = property(GetOptions, SetOptions)
    is_summary_string = property(IsSummaryString)
    is_function_name = property(IsFunctionName)
    is_function_name = property(IsFunctionCode)
    summary_data = property(GetData)


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBTypeSummary in _lldb:
_lldb.SBTypeSummary_swigregister(SBTypeSummary)
class SBTypeSynthetic(object):
    r"""Represents a summary that can be associated to one or more types."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    @staticmethod
    def CreateWithClassName(data, options=0):
        r"""CreateWithClassName(char const * data, uint32_t options=0) -> SBTypeSynthetic"""
        return _lldb.SBTypeSynthetic_CreateWithClassName(data, options)

    @staticmethod
    def CreateWithScriptCode(data, options=0):
        r"""CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSynthetic"""
        return _lldb.SBTypeSynthetic_CreateWithScriptCode(data, options)

    def __init__(self, *args):
        r"""
        __init__(SBTypeSynthetic self) -> SBTypeSynthetic
        __init__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> SBTypeSynthetic
        """
        _lldb.SBTypeSynthetic_swiginit(self, _lldb.new_SBTypeSynthetic(*args))
    __swig_destroy__ = _lldb.delete_SBTypeSynthetic

    def __nonzero__(self):
        return _lldb.SBTypeSynthetic___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBTypeSynthetic self) -> bool"""
        return _lldb.SBTypeSynthetic_IsValid(self)

    def IsClassCode(self):
        r"""IsClassCode(SBTypeSynthetic self) -> bool"""
        return _lldb.SBTypeSynthetic_IsClassCode(self)

    def IsClassName(self):
        r"""IsClassName(SBTypeSynthetic self) -> bool"""
        return _lldb.SBTypeSynthetic_IsClassName(self)

    def GetData(self):
        r"""GetData(SBTypeSynthetic self) -> char const *"""
        return _lldb.SBTypeSynthetic_GetData(self)

    def SetClassName(self, data):
        r"""SetClassName(SBTypeSynthetic self, char const * data)"""
        return _lldb.SBTypeSynthetic_SetClassName(self, data)

    def SetClassCode(self, data):
        r"""SetClassCode(SBTypeSynthetic self, char const * data)"""
        return _lldb.SBTypeSynthetic_SetClassCode(self, data)

    def GetOptions(self):
        r"""GetOptions(SBTypeSynthetic self) -> uint32_t"""
        return _lldb.SBTypeSynthetic_GetOptions(self)

    def SetOptions(self, arg2):
        r"""SetOptions(SBTypeSynthetic self, uint32_t arg2)"""
        return _lldb.SBTypeSynthetic_SetOptions(self, arg2)

    def GetDescription(self, description, description_level):
        r"""GetDescription(SBTypeSynthetic self, SBStream description, lldb::DescriptionLevel description_level) -> bool"""
        return _lldb.SBTypeSynthetic_GetDescription(self, description, description_level)

    def IsEqualTo(self, rhs):
        r"""IsEqualTo(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"""
        return _lldb.SBTypeSynthetic_IsEqualTo(self, rhs)

    def __eq__(self, rhs):
        r"""__eq__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"""
        return _lldb.SBTypeSynthetic___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool"""
        return _lldb.SBTypeSynthetic___ne__(self, rhs)

    def __repr__(self):
        r"""__repr__(SBTypeSynthetic self) -> std::string"""
        return _lldb.SBTypeSynthetic___repr__(self)

                # operator== is a free function, which swig does not handle, so we inject
                # our own equality operator here
    def __eq__(self, other):
        return not self.__ne__(other)

    options = property(GetOptions, SetOptions)
    contains_code = property(IsClassCode, None)
    synthetic_data = property(GetData, None)


    def __eq__(self, rhs):
        if not isinstance(rhs, type(self)):
            return False

        return getattr(_lldb,self.__class__.__name__+"___eq__")(self, rhs)

    def __ne__(self, rhs):
        if not isinstance(rhs, type(self)):
            return True

        return getattr(_lldb,self.__class__.__name__+"___ne__")(self, rhs)


# Register SBTypeSynthetic in _lldb:
_lldb.SBTypeSynthetic_swigregister(SBTypeSynthetic)
class SBUnixSignals(object):
    r"""Allows you to manipulate LLDB's signal disposition"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBUnixSignals self) -> SBUnixSignals
        __init__(SBUnixSignals self, SBUnixSignals rhs) -> SBUnixSignals
        """
        _lldb.SBUnixSignals_swiginit(self, _lldb.new_SBUnixSignals(*args))
    __swig_destroy__ = _lldb.delete_SBUnixSignals

    def Clear(self):
        r"""Clear(SBUnixSignals self)"""
        return _lldb.SBUnixSignals_Clear(self)

    def __nonzero__(self):
        return _lldb.SBUnixSignals___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBUnixSignals self) -> bool"""
        return _lldb.SBUnixSignals_IsValid(self)

    def GetSignalAsCString(self, signo):
        r"""GetSignalAsCString(SBUnixSignals self, int32_t signo) -> char const *"""
        return _lldb.SBUnixSignals_GetSignalAsCString(self, signo)

    def GetSignalNumberFromName(self, name):
        r"""GetSignalNumberFromName(SBUnixSignals self, char const * name) -> int32_t"""
        return _lldb.SBUnixSignals_GetSignalNumberFromName(self, name)

    def GetShouldSuppress(self, signo):
        r"""GetShouldSuppress(SBUnixSignals self, int32_t signo) -> bool"""
        return _lldb.SBUnixSignals_GetShouldSuppress(self, signo)

    def SetShouldSuppress(self, signo, value):
        r"""SetShouldSuppress(SBUnixSignals self, int32_t signo, bool value) -> bool"""
        return _lldb.SBUnixSignals_SetShouldSuppress(self, signo, value)

    def GetShouldStop(self, signo):
        r"""GetShouldStop(SBUnixSignals self, int32_t signo) -> bool"""
        return _lldb.SBUnixSignals_GetShouldStop(self, signo)

    def SetShouldStop(self, signo, value):
        r"""SetShouldStop(SBUnixSignals self, int32_t signo, bool value) -> bool"""
        return _lldb.SBUnixSignals_SetShouldStop(self, signo, value)

    def GetShouldNotify(self, signo):
        r"""GetShouldNotify(SBUnixSignals self, int32_t signo) -> bool"""
        return _lldb.SBUnixSignals_GetShouldNotify(self, signo)

    def SetShouldNotify(self, signo, value):
        r"""SetShouldNotify(SBUnixSignals self, int32_t signo, bool value) -> bool"""
        return _lldb.SBUnixSignals_SetShouldNotify(self, signo, value)

    def GetNumSignals(self):
        r"""GetNumSignals(SBUnixSignals self) -> int32_t"""
        return _lldb.SBUnixSignals_GetNumSignals(self)

    def GetSignalAtIndex(self, index):
        r"""GetSignalAtIndex(SBUnixSignals self, int32_t index) -> int32_t"""
        return _lldb.SBUnixSignals_GetSignalAtIndex(self, index)

    def __iter__(self):
        '''Iterate over all signals in a lldb.SBUnixSignals object.'''
        return lldb_iter(self, 'GetNumSignals', 'GetSignalAtIndex')

    def __len__(self):
        return self.GetNumSignals()

    def get_unix_signals_list(self):
        signals = []
        for idx in range(0, self.GetNumSignals()):
            signals.append(self.GetSignalAtIndex(sig))
        return signals

    threads = property(get_unix_signals_list, None, doc='''A read only property that returns a list() of valid signal numbers for this platform.''')


# Register SBUnixSignals in _lldb:
_lldb.SBUnixSignals_swigregister(SBUnixSignals)
class SBValue(object):
    r"""
    Represents the value of a variable, a register, or an expression.

    SBValue supports iteration through its child, which in turn is represented
    as an SBValue.  For example, we can get the general purpose registers of a
    frame as an SBValue, and iterate through all the registers,::

        registerSet = frame.registers # Returns an SBValueList.
        for regs in registerSet:
            if 'general purpose registers' in regs.name.lower():
                GPRs = regs
                break

        print('%s (number of children = %d):' % (GPRs.name, GPRs.num_children))
        for reg in GPRs:
            print('Name: ', reg.name, ' Value: ', reg.value)

    produces the output: ::

        General Purpose Registers (number of children = 21):
        Name:  rax  Value:  0x0000000100000c5c
        Name:  rbx  Value:  0x0000000000000000
        Name:  rcx  Value:  0x00007fff5fbffec0
        Name:  rdx  Value:  0x00007fff5fbffeb8
        Name:  rdi  Value:  0x0000000000000001
        Name:  rsi  Value:  0x00007fff5fbffea8
        Name:  rbp  Value:  0x00007fff5fbffe80
        Name:  rsp  Value:  0x00007fff5fbffe60
        Name:  r8  Value:  0x0000000008668682
        Name:  r9  Value:  0x0000000000000000
        Name:  r10  Value:  0x0000000000001200
        Name:  r11  Value:  0x0000000000000206
        Name:  r12  Value:  0x0000000000000000
        Name:  r13  Value:  0x0000000000000000
        Name:  r14  Value:  0x0000000000000000
        Name:  r15  Value:  0x0000000000000000
        Name:  rip  Value:  0x0000000100000dae
        Name:  rflags  Value:  0x0000000000000206
        Name:  cs  Value:  0x0000000000000027
        Name:  fs  Value:  0x0000000000000010
        Name:  gs  Value:  0x0000000000000048

    See also linked_list_iter() for another perspective on how to iterate through an
    SBValue instance which interprets the value object as representing the head of a
    linked list.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBValue self) -> SBValue
        __init__(SBValue self, SBValue rhs) -> SBValue
        """
        _lldb.SBValue_swiginit(self, _lldb.new_SBValue(*args))
    __swig_destroy__ = _lldb.delete_SBValue

    def __nonzero__(self):
        return _lldb.SBValue___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBValue self) -> bool"""
        return _lldb.SBValue_IsValid(self)

    def Clear(self):
        r"""Clear(SBValue self)"""
        return _lldb.SBValue_Clear(self)

    def GetError(self):
        r"""GetError(SBValue self) -> SBError"""
        return _lldb.SBValue_GetError(self)

    def GetID(self):
        r"""GetID(SBValue self) -> lldb::user_id_t"""
        return _lldb.SBValue_GetID(self)

    def GetName(self):
        r"""GetName(SBValue self) -> char const *"""
        return _lldb.SBValue_GetName(self)

    def GetTypeName(self):
        r"""GetTypeName(SBValue self) -> char const *"""
        return _lldb.SBValue_GetTypeName(self)

    def GetDisplayTypeName(self):
        r"""GetDisplayTypeName(SBValue self) -> char const *"""
        return _lldb.SBValue_GetDisplayTypeName(self)

    def GetByteSize(self):
        r"""GetByteSize(SBValue self) -> size_t"""
        return _lldb.SBValue_GetByteSize(self)

    def IsInScope(self):
        r"""IsInScope(SBValue self) -> bool"""
        return _lldb.SBValue_IsInScope(self)

    def GetFormat(self):
        r"""GetFormat(SBValue self) -> lldb::Format"""
        return _lldb.SBValue_GetFormat(self)

    def SetFormat(self, format):
        r"""SetFormat(SBValue self, lldb::Format format)"""
        return _lldb.SBValue_SetFormat(self, format)

    def GetValue(self):
        r"""GetValue(SBValue self) -> char const *"""
        return _lldb.SBValue_GetValue(self)

    def GetValueAsSigned(self, *args):
        r"""
        GetValueAsSigned(SBValue self, SBError error, int64_t fail_value=0) -> int64_t
        GetValueAsSigned(SBValue self, int64_t fail_value=0) -> int64_t
        """
        return _lldb.SBValue_GetValueAsSigned(self, *args)

    def GetValueAsUnsigned(self, *args):
        r"""
        GetValueAsUnsigned(SBValue self, SBError error, uint64_t fail_value=0) -> uint64_t
        GetValueAsUnsigned(SBValue self, uint64_t fail_value=0) -> uint64_t
        """
        return _lldb.SBValue_GetValueAsUnsigned(self, *args)

    def GetValueAsAddress(self):
        r"""
        GetValueAsAddress(SBValue self) -> lldb::addr_t

              Return the value as an address.  On failure, LLDB_INVALID_ADDRESS
              will be returned.  On architectures like AArch64, where the
              top (unaddressable) bits can be used for authentication,
              memory tagging, or top byte ignore,  this method will return
              the value with those top bits cleared.

              GetValueAsUnsigned returns the actual value, with the
              authentication/Top Byte Ignore/Memory Tagging Extension bits.

              Calling this on a random value which is not a pointer is
              incorrect.  Call GetType().IsPointerType() if in doubt.

              An SB API program may want to show both the literal byte value
              and the address it refers to in memory.  These two SBValue
              methods allow SB API writers to behave appropriately for their
              interface.
        """
        return _lldb.SBValue_GetValueAsAddress(self)

    def GetValueType(self):
        r"""GetValueType(SBValue self) -> lldb::ValueType"""
        return _lldb.SBValue_GetValueType(self)

    def GetValueDidChange(self):
        r"""GetValueDidChange(SBValue self) -> bool"""
        return _lldb.SBValue_GetValueDidChange(self)

    def GetSummary(self, *args):
        r"""
        GetSummary(SBValue self) -> char const
        GetSummary(SBValue self, SBStream stream, SBTypeSummaryOptions options) -> char const *
        """
        return _lldb.SBValue_GetSummary(self, *args)

    def GetObjectDescription(self):
        r"""GetObjectDescription(SBValue self) -> char const *"""
        return _lldb.SBValue_GetObjectDescription(self)

    def GetDynamicValue(self, use_dynamic):
        r"""GetDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic) -> SBValue"""
        return _lldb.SBValue_GetDynamicValue(self, use_dynamic)

    def GetStaticValue(self):
        r"""GetStaticValue(SBValue self) -> SBValue"""
        return _lldb.SBValue_GetStaticValue(self)

    def GetNonSyntheticValue(self):
        r"""GetNonSyntheticValue(SBValue self) -> SBValue"""
        return _lldb.SBValue_GetNonSyntheticValue(self)

    def GetSyntheticValue(self):
        r"""GetSyntheticValue(SBValue self) -> SBValue"""
        return _lldb.SBValue_GetSyntheticValue(self)

    def GetPreferDynamicValue(self):
        r"""GetPreferDynamicValue(SBValue self) -> lldb::DynamicValueType"""
        return _lldb.SBValue_GetPreferDynamicValue(self)

    def SetPreferDynamicValue(self, use_dynamic):
        r"""SetPreferDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic)"""
        return _lldb.SBValue_SetPreferDynamicValue(self, use_dynamic)

    def GetPreferSyntheticValue(self):
        r"""GetPreferSyntheticValue(SBValue self) -> bool"""
        return _lldb.SBValue_GetPreferSyntheticValue(self)

    def SetPreferSyntheticValue(self, use_synthetic):
        r"""SetPreferSyntheticValue(SBValue self, bool use_synthetic)"""
        return _lldb.SBValue_SetPreferSyntheticValue(self, use_synthetic)

    def IsDynamic(self):
        r"""IsDynamic(SBValue self) -> bool"""
        return _lldb.SBValue_IsDynamic(self)

    def IsSynthetic(self):
        r"""IsSynthetic(SBValue self) -> bool"""
        return _lldb.SBValue_IsSynthetic(self)

    def IsSyntheticChildrenGenerated(self):
        r"""IsSyntheticChildrenGenerated(SBValue self) -> bool"""
        return _lldb.SBValue_IsSyntheticChildrenGenerated(self)

    def SetSyntheticChildrenGenerated(self, arg2):
        r"""SetSyntheticChildrenGenerated(SBValue self, bool arg2)"""
        return _lldb.SBValue_SetSyntheticChildrenGenerated(self, arg2)

    def GetLocation(self):
        r"""GetLocation(SBValue self) -> char const *"""
        return _lldb.SBValue_GetLocation(self)

    def SetValueFromCString(self, *args):
        r"""
        SetValueFromCString(SBValue self, char const * value_str) -> bool
        SetValueFromCString(SBValue self, char const * value_str, SBError error) -> bool
        """
        return _lldb.SBValue_SetValueFromCString(self, *args)

    def GetTypeFormat(self):
        r"""GetTypeFormat(SBValue self) -> SBTypeFormat"""
        return _lldb.SBValue_GetTypeFormat(self)

    def GetTypeSummary(self):
        r"""GetTypeSummary(SBValue self) -> SBTypeSummary"""
        return _lldb.SBValue_GetTypeSummary(self)

    def GetTypeFilter(self):
        r"""GetTypeFilter(SBValue self) -> SBTypeFilter"""
        return _lldb.SBValue_GetTypeFilter(self)

    def GetTypeSynthetic(self):
        r"""GetTypeSynthetic(SBValue self) -> SBTypeSynthetic"""
        return _lldb.SBValue_GetTypeSynthetic(self)

    def CreateChildAtOffset(self, name, offset, type):
        r"""CreateChildAtOffset(SBValue self, char const * name, uint32_t offset, SBType type) -> SBValue"""
        return _lldb.SBValue_CreateChildAtOffset(self, name, offset, type)

    def Cast(self, type):
        r"""Cast(SBValue self, SBType type) -> SBValue"""
        return _lldb.SBValue_Cast(self, type)

    def CreateValueFromExpression(self, *args):
        r"""
        CreateValueFromExpression(SBValue self, char const * name, char const * expression) -> SBValue
        CreateValueFromExpression(SBValue self, char const * name, char const * expression, SBExpressionOptions options) -> SBValue
        """
        return _lldb.SBValue_CreateValueFromExpression(self, *args)

    def CreateValueFromAddress(self, name, address, type):
        r"""CreateValueFromAddress(SBValue self, char const * name, lldb::addr_t address, SBType type) -> SBValue"""
        return _lldb.SBValue_CreateValueFromAddress(self, name, address, type)

    def CreateValueFromData(self, name, data, type):
        r"""CreateValueFromData(SBValue self, char const * name, SBData data, SBType type) -> SBValue"""
        return _lldb.SBValue_CreateValueFromData(self, name, data, type)

    def CreateBoolValue(self, name, value):
        r"""CreateBoolValue(SBValue self, char const * name, bool value) -> SBValue"""
        return _lldb.SBValue_CreateBoolValue(self, name, value)

    def GetChildAtIndex(self, *args):
        r"""
        GetChildAtIndex(SBValue self, uint32_t idx) -> SBValue
        GetChildAtIndex(SBValue self, uint32_t idx, lldb::DynamicValueType use_dynamic, bool treat_as_array) -> SBValue

            Get a child value by index from a value.

            Structs, unions, classes, arrays and pointers have child
            values that can be access by index.

            Structs and unions access child members using a zero based index
            for each child member. For

            Classes reserve the first indexes for base classes that have
            members (empty base classes are omitted), and all members of the
            current class will then follow the base classes.

            Pointers differ depending on what they point to. If the pointer
            points to a simple type, the child at index zero
            is the only child value available, unless synthetic_allowed
            is true, in which case the pointer will be used as an array
            and can create 'synthetic' child values using positive or
            negative indexes. If the pointer points to an aggregate type
            (an array, class, union, struct), then the pointee is
            transparently skipped and any children are going to be the indexes
            of the child values within the aggregate type. For example if
            we have a 'Point' type and we have a SBValue that contains a
            pointer to a 'Point' type, then the child at index zero will be
            the 'x' member, and the child at index 1 will be the 'y' member
            (the child at index zero won't be a 'Point' instance).

            If you actually need an SBValue that represents the type pointed
            to by a SBValue for which GetType().IsPointeeType() returns true,
            regardless of the pointee type, you can do that with the SBValue.Dereference
            method (or the equivalent deref property).

            Arrays have a preset number of children that can be accessed by
            index and will returns invalid child values for indexes that are
            out of bounds unless the synthetic_allowed is true. In this
            case the array can create 'synthetic' child values for indexes
            that aren't in the array bounds using positive or negative
            indexes.

            @param[in] idx
                The index of the child value to get

            @param[in] use_dynamic
                An enumeration that specifies whether to get dynamic values,
                and also if the target can be run to figure out the dynamic
                type of the child value.

            @param[in] synthetic_allowed
                If true, then allow child values to be created by index
                for pointers and arrays for indexes that normally wouldn't
                be allowed.

            @return
                A new SBValue object that represents the child member value.
        """
        return _lldb.SBValue_GetChildAtIndex(self, *args)

    def GetIndexOfChildWithName(self, name):
        r"""
        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.
        """
        return _lldb.SBValue_GetIndexOfChildWithName(self, name)

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

            Returns the child member value.

            Matches child members of this object and child members of any base
            classes.

            @param[in] name
                The name of the child value to get

            @param[in] use_dynamic
                An enumeration that specifies whether to get dynamic values,
                and also if the target can be run to figure out the dynamic
                type of the child value.

            @return
                A new SBValue object that represents the child member value.
        """
        return _lldb.SBValue_GetChildMemberWithName(self, *args)

    def GetValueForExpressionPath(self, expr_path):
        r"""
        GetValueForExpressionPath(SBValue self, char const * expr_path) -> SBValue
        Expands nested expressions like .a->b[0].c[1]->d.
        """
        return _lldb.SBValue_GetValueForExpressionPath(self, expr_path)

    def AddressOf(self):
        r"""AddressOf(SBValue self) -> SBValue"""
        return _lldb.SBValue_AddressOf(self)

    def GetLoadAddress(self):
        r"""GetLoadAddress(SBValue self) -> lldb::addr_t"""
        return _lldb.SBValue_GetLoadAddress(self)

    def GetAddress(self):
        r"""GetAddress(SBValue self) -> SBAddress"""
        return _lldb.SBValue_GetAddress(self)

    def GetPointeeData(self, item_idx=0, item_count=1):
        r"""
        GetPointeeData(SBValue self, uint32_t item_idx=0, uint32_t item_count=1) -> 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 :py:class:`SBData`.

            :param item_idx: The index of the first item to retrieve. For an array
                this is equivalent to array[item_idx], for a pointer
                to ``\*(pointer + item_idx)``. In either case, the measurement
                unit for item_idx is the ``sizeof(T)`` rather than the byte
            :param item_count: How many items should be copied into the output. By default
                only one item is copied, but more can be asked for.
            :return: The contents of the copied items on success. An empty :py:class:`SBData` otherwise.
            :rtype: SBData

        """
        return _lldb.SBValue_GetPointeeData(self, item_idx, item_count)

    def GetData(self):
        r"""
        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.
        """
        return _lldb.SBValue_GetData(self)

    def SetData(self, data, error):
        r"""SetData(SBValue self, SBData data, SBError error) -> bool"""
        return _lldb.SBValue_SetData(self, data, error)

    def Clone(self, new_name):
        r"""
        Creates a copy of the SBValue with a new name and setting the current
        SBValue as its parent. It should be used when we want to change the
        name of a SBValue without modifying the actual SBValue itself
        (e.g. sythetic child provider).
        """
        return _lldb.SBValue_Clone(self, new_name)

    def GetDeclaration(self):
        r"""GetDeclaration(SBValue self) -> SBDeclaration"""
        return _lldb.SBValue_GetDeclaration(self)

    def MightHaveChildren(self):
        r"""
        Find out if a SBValue might have children.

        This call is much more efficient than GetNumChildren() as it
        doesn't need to complete the underlying type. This is designed
        to be used in a UI environment in order to detect if the
        disclosure triangle should be displayed or not.

        This function returns true for class, union, structure,
        pointers, references, arrays and more. Again, it does so without
        doing any expensive type completion.

        :rtype: boolean
        :return: 
                Returns **true** if the SBValue might have children, or
           **false** otherwise.
        """
        return _lldb.SBValue_MightHaveChildren(self)

    def IsRuntimeSupportValue(self):
        r"""IsRuntimeSupportValue(SBValue self) -> bool"""
        return _lldb.SBValue_IsRuntimeSupportValue(self)

    def GetNumChildren(self, *args):
        r"""
        *Overload 1:*
        Return the number of children of this variable. Note that for some
        variables this operation can be expensive. If possible, prefer calling
        GetNumChildren(max) with the maximum number of children you are interested
        in.

        |

        *Overload 2:*
        Return the numer of children of this variable, with a hint that the
        caller is interested in at most *max* children. Use this function to
        avoid expensive child computations in some cases. For example, if you know
        you will only ever display 100 elements, calling GetNumChildren(100) can
        avoid enumerating all the other children. If the returned value is smaller
        than *max*, then it represents the true number of children, otherwise it
        indicates that their number is at least *max*. Do not assume the returned
        number will always be less than or equal to *max*, as the implementation
        may choose to return a larger (but still smaller than the actual number of
        children) value.
        """
        return _lldb.SBValue_GetNumChildren(self, *args)

    def GetOpaqueType(self):
        r"""GetOpaqueType(SBValue self) -> void *"""
        return _lldb.SBValue_GetOpaqueType(self)

    def GetTarget(self):
        r"""GetTarget(SBValue self) -> SBTarget"""
        return _lldb.SBValue_GetTarget(self)

    def GetProcess(self):
        r"""GetProcess(SBValue self) -> SBProcess"""
        return _lldb.SBValue_GetProcess(self)

    def GetThread(self):
        r"""GetThread(SBValue self) -> SBThread"""
        return _lldb.SBValue_GetThread(self)

    def GetFrame(self):
        r"""GetFrame(SBValue self) -> SBFrame"""
        return _lldb.SBValue_GetFrame(self)

    def Dereference(self):
        r"""Dereference(SBValue self) -> SBValue"""
        return _lldb.SBValue_Dereference(self)

    def TypeIsPointerType(self):
        r"""TypeIsPointerType(SBValue self) -> bool"""
        return _lldb.SBValue_TypeIsPointerType(self)

    def GetType(self):
        r"""GetType(SBValue self) -> SBType"""
        return _lldb.SBValue_GetType(self)

    def Persist(self):
        r"""Persist(SBValue self) -> SBValue"""
        return _lldb.SBValue_Persist(self)

    def GetDescription(self, description):
        r"""GetDescription(SBValue self, SBStream description) -> bool"""
        return _lldb.SBValue_GetDescription(self, description)

    def GetExpressionPath(self, *args):
        r"""
        GetExpressionPath(SBValue self, SBStream description) -> bool
        GetExpressionPath(SBValue self, SBStream description, bool qualify_cxx_base_classes) -> bool
        Returns an expression path for this value.
        """
        return _lldb.SBValue_GetExpressionPath(self, *args)

    def EvaluateExpression(self, *args):
        r"""
        EvaluateExpression(SBValue self, char const * expr) -> SBValue
        EvaluateExpression(SBValue self, char const * expr, SBExpressionOptions options) -> SBValue
        EvaluateExpression(SBValue self, char const * expr, SBExpressionOptions options, char const * name) -> SBValue
        """
        return _lldb.SBValue_EvaluateExpression(self, *args)

    def Watch(self, *args):
        r"""
        Watch(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint
        Watch(SBValue self, bool resolve_location, bool read, bool write) -> SBWatchpoint

            Find and watch a variable.
            It returns an SBWatchpoint, which may be invalid.
        """
        return _lldb.SBValue_Watch(self, *args)

    def WatchPointee(self, resolve_location, read, write, error):
        r"""
        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.
        """
        return _lldb.SBValue_WatchPointee(self, resolve_location, read, write, error)

    def GetVTable(self):
        r"""
        If this value represents a C++ class that has a vtable, return an value
        that represents the virtual function table.

        SBValue::GetError() will be in the success state if this value represents
        a C++ class with a vtable, or an appropriate error describing that the
        object isn't a C++ class with a vtable or not a C++ class.

        SBValue::GetName() will be the demangled symbol name for the virtual
        function table like "vtable for <classname>".

        SBValue::GetValue() will be the address of the first vtable entry if the
        current SBValue is a class with a vtable, or nothing the current SBValue
        is not a C++ class or not a C++ class that has a vtable.

        SBValue::GetValueAtUnsigned(...) will return the address of the first
        vtable entry.

        SBValue::GetLoadAddress() will return the address of the vtable pointer
        found in the parent SBValue.

        SBValue::GetNumChildren() will return the number of virtual function
        pointers in the vtable, or zero on error.

        SBValue::GetChildAtIndex(...) will return each virtual function pointer
        as a SBValue object.

        The child SBValue objects will have the following values:

        SBValue::GetError() will indicate success if the vtable entry was
        successfully read from memory, or an error if not.

        SBValue::GetName() will be the vtable function index in the form "[%u]"
        where %u is the index.

        SBValue::GetValue() will be the virtual function pointer value as a
        string.

        SBValue::GetValueAtUnsigned(...) will return the virtual function
        pointer value.

        SBValue::GetLoadAddress() will return the address of the virtual function
        pointer.

        SBValue::GetNumChildren() returns 0
        """
        return _lldb.SBValue_GetVTable(self)

    def __repr__(self):
        r"""__repr__(SBValue self) -> std::string"""
        return _lldb.SBValue___repr__(self)

    def __get_dynamic__ (self):
        '''Helper function for the "SBValue.dynamic" property.'''
        return self.GetDynamicValue (eDynamicCanRunTarget)

    class children_access(object):
        '''A helper object that will lazily hand out child values when supplied an index.'''

        def __init__(self, sbvalue):
            self.sbvalue = sbvalue

        def __len__(self):
            if self.sbvalue:
                return int(self.sbvalue.GetNumChildren())
            return 0

        def __getitem__(self, key):
            if isinstance(key, int):
                count = len(self)
                if -count <= key < count:
                    key %= count
                    return self.sbvalue.GetChildAtIndex(key)
            return None

    def get_child_access_object(self):
        '''An accessor function that returns a children_access() object which allows lazy member variable access from a lldb.SBValue object.'''
        return self.children_access (self)

    def get_member_access_object(self):
        '''An accessor function that returns an interface which provides subscript based lookup of child members.'''
        class member_access:
            def __init__(self, valobj):
                self.valobj = valobj

            def __getitem__(self, key):
                if isinstance(key, str):
                    return self.valobj.GetChildMemberWithName(key)
                raise TypeError("member key must be a string")

        return member_access(self)

    def get_value_child_list(self):
        '''An accessor function that returns a list() that contains all children in a lldb.SBValue object.'''
        children = []
        accessor = self.get_child_access_object()
        for idx in range(len(accessor)):
            children.append(accessor[idx])
        return children

    def __hex__(self):
        return self.GetAddress()

    def __iter__(self):
        '''Iterate over all child values of a lldb.SBValue object.'''
        return lldb_iter(self, 'GetNumChildren', 'GetChildAtIndex')

    def __len__(self):
        '''Return the number of child values of a lldb.SBValue object.'''
        return self.GetNumChildren()

    children = property(get_value_child_list, None, doc='''A read only property that returns a list() of lldb.SBValue objects for the children of the value.''')
    child = property(get_child_access_object, None, doc='''A read only property that returns an object that can access children of a variable by index (child_value = value.children[12]).''')
    member = property(get_member_access_object, None, doc='''A read only property that returns an object that can access child members by name.''')
    name = property(GetName, None, doc='''A read only property that returns the name of this value as a string.''')
    type = property(GetType, None, doc='''A read only property that returns a lldb.SBType object that represents the type for this value.''')
    size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes of this value.''')
    is_in_scope = property(IsInScope, None, doc='''A read only property that returns a boolean value that indicates whether this value is currently lexically in scope.''')
    format = property(GetName, SetFormat, doc='''A read/write property that gets/sets the format used for lldb.SBValue().GetValue() for this value. See enumerations that start with "lldb.eFormat".''')
    value = property(GetValue, SetValueFromCString, doc='''A read/write property that gets/sets value from a string.''')
    value_type = property(GetValueType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eValueType") that represents the type of this value (local, argument, global, register, etc.).''')
    changed = property(GetValueDidChange, None, doc='''A read only property that returns a boolean value that indicates if this value has changed since it was last updated.''')
    data = property(GetData, None, doc='''A read only property that returns an lldb object (lldb.SBData) that represents the bytes that make up the value for this object.''')
    load_addr = property(GetLoadAddress, None, doc='''A read only property that returns the load address of this value as an integer.''')
    addr = property(GetAddress, None, doc='''A read only property that returns an lldb.SBAddress that represents the address of this value if it is in memory.''')
    deref = property(Dereference, None, doc='''A read only property that returns an lldb.SBValue that is created by dereferencing this value.''')
    address_of = property(AddressOf, None, doc='''A read only property that returns an lldb.SBValue that represents the address-of this value.''')
    error = property(GetError, None, doc='''A read only property that returns the lldb.SBError that represents the error from the last time the variable value was calculated.''')
    summary = property(GetSummary, None, doc='''A read only property that returns the summary for this value as a string''')
    description = property(GetObjectDescription, None, doc='''A read only property that returns the language-specific description of this value as a string''')
    dynamic = property(__get_dynamic__, None, doc='''A read only property that returns an lldb.SBValue that is created by finding the dynamic type of this value.''')
    location = property(GetLocation, None, doc='''A read only property that returns the location of this value as a string.''')
    target = property(GetTarget, None, doc='''A read only property that returns the lldb.SBTarget that this value is associated with.''')
    process = property(GetProcess, None, doc='''A read only property that returns the lldb.SBProcess that this value is associated with, the returned value might be invalid and should be tested.''')
    thread = property(GetThread, None, doc='''A read only property that returns the lldb.SBThread that this value is associated with, the returned value might be invalid and should be tested.''')
    frame = property(GetFrame, None, doc='''A read only property that returns the lldb.SBFrame that this value is associated with, the returned value might be invalid and should be tested.''')
    num_children = property(GetNumChildren, None, doc='''A read only property that returns the number of child lldb.SBValues that this value has.''')
    unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this SBValue as an usigned integer.''')
    signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this SBValue as a signed integer.''')

    def get_expr_path(self):
        s = SBStream()
        self.GetExpressionPath (s)
        return s.GetData()

    path = property(get_expr_path, None, doc='''A read only property that returns the expression path that one can use to reach this value in an expression.''')

    def synthetic_child_from_expression(self, name, expr, options=None):
        if options is None: options = lldb.SBExpressionOptions()
        child = self.CreateValueFromExpression(name, expr, options)
        child.SetSyntheticChildrenGenerated(True)
        return child

    def synthetic_child_from_data(self, name, data, type):
        child = self.CreateValueFromData(name, data, type)
        child.SetSyntheticChildrenGenerated(True)
        return child

    def synthetic_child_from_address(self, name, addr, type):
        child = self.CreateValueFromAddress(name, addr, type)
        child.SetSyntheticChildrenGenerated(True)
        return child

    def __eol_test(val):
        """Default function for end of list test takes an SBValue object.

        Return True if val is invalid or it corresponds to a null pointer.
        Otherwise, return False.
        """
        if not val or val.GetValueAsUnsigned() == 0:
            return True
        else:
            return False

    # ==================================================
    # Iterator for lldb.SBValue treated as a linked list
    # ==================================================
    def linked_list_iter(self, next_item_name, end_of_list_test=__eol_test):
        """Generator adaptor to support iteration for SBValue as a linked list.

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

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

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

        For example,

    # Get Frame #0.
        ...

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

        for t in task_head.linked_list_iter('next'):
            print t
        """
        if end_of_list_test(self):
            return
        item = self
        visited = set()
        try:
            while not end_of_list_test(item) and not item.GetValueAsUnsigned() in visited:
                visited.add(item.GetValueAsUnsigned())
                yield item
    # Prepare for the next iteration.
                item = item.GetChildMemberWithName(next_item_name)
        except:
    # Exception occurred.  Stop the generator.
            pass

        return


# Register SBValue in _lldb:
_lldb.SBValue_swigregister(SBValue)
class SBValueList(object):
    r"""
    Represents a collection of SBValues.  Both :py:class:`SBFrame.GetVariables()` and
    :py:class:`SBFrame.GetRegisters()` return a SBValueList.

    SBValueList supports :py:class:`SBValue` iteration. For example (from test/lldbutil.py),::

        def get_registers(frame, kind):
            '''Returns the registers given the frame and the kind of registers desired.

            Returns None if there's no such kind.
            '''
            registerSet = frame.GetRegisters() # Return type of SBValueList.
            for value in registerSet:
                if kind.lower() in value.GetName().lower():
                    return value

            return None

        def get_GPRs(frame):
            '''Returns the general purpose registers of the frame as an SBValue.

            The returned SBValue object is iterable.  An example:
                ...
                from lldbutil import get_GPRs
                regs = get_GPRs(frame)
                for reg in regs:
                    print('%s => %s' % (reg.GetName(), reg.GetValue()))
                ...
            '''
            return get_registers(frame, 'general purpose')

        def get_FPRs(frame):
            '''Returns the floating point registers of the frame as an SBValue.

            The returned SBValue object is iterable.  An example:
                ...
                from lldbutil import get_FPRs
                regs = get_FPRs(frame)
                for reg in regs:
                    print('%s => %s' % (reg.GetName(), reg.GetValue()))
                ...
            '''
            return get_registers(frame, 'floating point')

        def get_ESRs(frame):
            '''Returns the exception state registers of the frame as an SBValue.

            The returned SBValue object is iterable.  An example:
                ...
                from lldbutil import get_ESRs
                regs = get_ESRs(frame)
                for reg in regs:
                    print('%s => %s' % (reg.GetName(), reg.GetValue()))
                ...
            '''
            return get_registers(frame, 'exception state')

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBValueList self) -> SBValueList
        __init__(SBValueList self, SBValueList rhs) -> SBValueList
        """
        _lldb.SBValueList_swiginit(self, _lldb.new_SBValueList(*args))
    __swig_destroy__ = _lldb.delete_SBValueList

    def __nonzero__(self):
        return _lldb.SBValueList___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBValueList self) -> bool"""
        return _lldb.SBValueList_IsValid(self)

    def Clear(self):
        r"""Clear(SBValueList self)"""
        return _lldb.SBValueList_Clear(self)

    def Append(self, *args):
        r"""
        Append(SBValueList self, SBValue val_obj)
        Append(SBValueList self, SBValueList value_list)
        """
        return _lldb.SBValueList_Append(self, *args)

    def GetSize(self):
        r"""GetSize(SBValueList self) -> uint32_t"""
        return _lldb.SBValueList_GetSize(self)

    def GetValueAtIndex(self, idx):
        r"""GetValueAtIndex(SBValueList self, uint32_t idx) -> SBValue"""
        return _lldb.SBValueList_GetValueAtIndex(self, idx)

    def GetFirstValueByName(self, name):
        r"""GetFirstValueByName(SBValueList self, char const * name) -> SBValue"""
        return _lldb.SBValueList_GetFirstValueByName(self, name)

    def FindValueObjectByUID(self, uid):
        r"""FindValueObjectByUID(SBValueList self, lldb::user_id_t uid) -> SBValue"""
        return _lldb.SBValueList_FindValueObjectByUID(self, uid)

    def GetError(self):
        r"""GetError(SBValueList self) -> SBError"""
        return _lldb.SBValueList_GetError(self)

    def __str__(self):
        r"""__str__(SBValueList self) -> std::string"""
        return _lldb.SBValueList___str__(self)

    def __iter__(self):
        '''Iterate over all values in a lldb.SBValueList object.'''
        return lldb_iter(self, 'GetSize', 'GetValueAtIndex')

    def __len__(self):
        return int(self.GetSize())

    def __getitem__(self, key):
        count = len(self)
    #------------------------------------------------------------
    # Access with "int" to get Nth item in the list
    #------------------------------------------------------------
        if type(key) is int:
            if -count <= key < count:
                key %= count
                return self.GetValueAtIndex(key)
    #------------------------------------------------------------
    # Access with "str" to get values by name
    #------------------------------------------------------------
        elif type(key) is str:
            matches = []
            for idx in range(count):
                value = self.GetValueAtIndex(idx)
                if value.name == key:
                    matches.append(value)
            return matches
    #------------------------------------------------------------
    # Match with regex
    #------------------------------------------------------------
        elif isinstance(key, type(re.compile('.'))):
            matches = []
            for idx in range(count):
                value = self.GetValueAtIndex(idx)
                re_match = key.search(value.name)
                if re_match:
                    matches.append(value)
            return matches



# Register SBValueList in _lldb:
_lldb.SBValueList_swigregister(SBValueList)
class SBVariablesOptions(object):
    r"""Describes which variables should be returned from :py:class:`SBFrame.GetVariables`."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBVariablesOptions self) -> SBVariablesOptions
        __init__(SBVariablesOptions self, SBVariablesOptions options) -> SBVariablesOptions
        """
        _lldb.SBVariablesOptions_swiginit(self, _lldb.new_SBVariablesOptions(*args))
    __swig_destroy__ = _lldb.delete_SBVariablesOptions

    def __nonzero__(self):
        return _lldb.SBVariablesOptions___nonzero__(self)
    __bool__ = __nonzero__



    def IsValid(self):
        r"""IsValid(SBVariablesOptions self) -> bool"""
        return _lldb.SBVariablesOptions_IsValid(self)

    def GetIncludeArguments(self):
        r"""GetIncludeArguments(SBVariablesOptions self) -> bool"""
        return _lldb.SBVariablesOptions_GetIncludeArguments(self)

    def SetIncludeArguments(self, arg2):
        r"""SetIncludeArguments(SBVariablesOptions self, bool arg2)"""
        return _lldb.SBVariablesOptions_SetIncludeArguments(self, arg2)

    def GetIncludeRecognizedArguments(self, arg2):
        r"""GetIncludeRecognizedArguments(SBVariablesOptions self, SBTarget arg2) -> bool"""
        return _lldb.SBVariablesOptions_GetIncludeRecognizedArguments(self, arg2)

    def SetIncludeRecognizedArguments(self, arg2):
        r"""SetIncludeRecognizedArguments(SBVariablesOptions self, bool arg2)"""
        return _lldb.SBVariablesOptions_SetIncludeRecognizedArguments(self, arg2)

    def GetIncludeLocals(self):
        r"""GetIncludeLocals(SBVariablesOptions self) -> bool"""
        return _lldb.SBVariablesOptions_GetIncludeLocals(self)

    def SetIncludeLocals(self, arg2):
        r"""SetIncludeLocals(SBVariablesOptions self, bool arg2)"""
        return _lldb.SBVariablesOptions_SetIncludeLocals(self, arg2)

    def GetIncludeStatics(self):
        r"""GetIncludeStatics(SBVariablesOptions self) -> bool"""
        return _lldb.SBVariablesOptions_GetIncludeStatics(self)

    def SetIncludeStatics(self, arg2):
        r"""SetIncludeStatics(SBVariablesOptions self, bool arg2)"""
        return _lldb.SBVariablesOptions_SetIncludeStatics(self, arg2)

    def GetInScopeOnly(self):
        r"""GetInScopeOnly(SBVariablesOptions self) -> bool"""
        return _lldb.SBVariablesOptions_GetInScopeOnly(self)

    def SetInScopeOnly(self, arg2):
        r"""SetInScopeOnly(SBVariablesOptions self, bool arg2)"""
        return _lldb.SBVariablesOptions_SetInScopeOnly(self, arg2)

    def GetIncludeRuntimeSupportValues(self):
        r"""GetIncludeRuntimeSupportValues(SBVariablesOptions self) -> bool"""
        return _lldb.SBVariablesOptions_GetIncludeRuntimeSupportValues(self)

    def SetIncludeRuntimeSupportValues(self, arg2):
        r"""SetIncludeRuntimeSupportValues(SBVariablesOptions self, bool arg2)"""
        return _lldb.SBVariablesOptions_SetIncludeRuntimeSupportValues(self, arg2)

    def GetUseDynamic(self):
        r"""GetUseDynamic(SBVariablesOptions self) -> lldb::DynamicValueType"""
        return _lldb.SBVariablesOptions_GetUseDynamic(self)

    def SetUseDynamic(self, arg2):
        r"""SetUseDynamic(SBVariablesOptions self, lldb::DynamicValueType arg2)"""
        return _lldb.SBVariablesOptions_SetUseDynamic(self, arg2)

# Register SBVariablesOptions in _lldb:
_lldb.SBVariablesOptions_swigregister(SBVariablesOptions)
class SBWatchpoint(object):
    r"""
    Represents an instance of watchpoint for a specific target program.

    A watchpoint is determined by the address and the byte size that resulted in
    this particular instantiation.  Each watchpoint has its settable options.

    See also :py:class:`SBTarget.watchpoint_iter()` for example usage of iterating through the
    watchpoints of the target.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SBWatchpoint self) -> SBWatchpoint
        __init__(SBWatchpoint self, SBWatchpoint rhs) -> SBWatchpoint
        """
        _lldb.SBWatchpoint_swiginit(self, _lldb.new_SBWatchpoint(*args))
    __swig_destroy__ = _lldb.delete_SBWatchpoint

    def __nonzero__(self):
        return _lldb.SBWatchpoint___nonzero__(self)
    __bool__ = __nonzero__



    def __eq__(self, rhs):
        r"""__eq__(SBWatchpoint self, SBWatchpoint rhs) -> bool"""
        return _lldb.SBWatchpoint___eq__(self, rhs)

    def __ne__(self, rhs):
        r"""__ne__(SBWatchpoint self, SBWatchpoint rhs) -> bool"""
        return _lldb.SBWatchpoint___ne__(self, rhs)

    def IsValid(self):
        r"""IsValid(SBWatchpoint self) -> bool"""
        return _lldb.SBWatchpoint_IsValid(self)

    def GetError(self):
        r"""GetError(SBWatchpoint self) -> SBError"""
        return _lldb.SBWatchpoint_GetError(self)

    def GetID(self):
        r"""GetID(SBWatchpoint self) -> lldb::watch_id_t"""
        return _lldb.SBWatchpoint_GetID(self)

    def GetHardwareIndex(self):
        r"""
        GetHardwareIndex(SBWatchpoint self) -> int32_t

            Deprecated.  Previously: Return the hardware index of the 
            watchpoint register.  Now: -1 is always returned.
        """
        return _lldb.SBWatchpoint_GetHardwareIndex(self)

    def GetWatchAddress(self):
        r"""GetWatchAddress(SBWatchpoint self) -> lldb::addr_t"""
        return _lldb.SBWatchpoint_GetWatchAddress(self)

    def GetWatchSize(self):
        r"""GetWatchSize(SBWatchpoint self) -> size_t"""
        return _lldb.SBWatchpoint_GetWatchSize(self)

    def SetEnabled(self, enabled):
        r"""SetEnabled(SBWatchpoint self, bool enabled)"""
        return _lldb.SBWatchpoint_SetEnabled(self, enabled)

    def IsEnabled(self):
        r"""IsEnabled(SBWatchpoint self) -> bool"""
        return _lldb.SBWatchpoint_IsEnabled(self)

    def GetHitCount(self):
        r"""GetHitCount(SBWatchpoint self) -> uint32_t"""
        return _lldb.SBWatchpoint_GetHitCount(self)

    def GetIgnoreCount(self):
        r"""GetIgnoreCount(SBWatchpoint self) -> uint32_t"""
        return _lldb.SBWatchpoint_GetIgnoreCount(self)

    def SetIgnoreCount(self, n):
        r"""SetIgnoreCount(SBWatchpoint self, uint32_t n)"""
        return _lldb.SBWatchpoint_SetIgnoreCount(self, n)

    def GetCondition(self):
        r"""
        GetCondition(SBWatchpoint self) -> char const *

            Get the condition expression for the watchpoint.
        """
        return _lldb.SBWatchpoint_GetCondition(self)

    def SetCondition(self, condition):
        r"""
        SetCondition(SBWatchpoint self, char const * condition)

            The watchpoint stops only if the condition expression evaluates to true.
        """
        return _lldb.SBWatchpoint_SetCondition(self, condition)

    def GetDescription(self, description, level):
        r"""GetDescription(SBWatchpoint self, SBStream description, lldb::DescriptionLevel level) -> bool"""
        return _lldb.SBWatchpoint_GetDescription(self, description, level)

    def Clear(self):
        r"""Clear(SBWatchpoint self)"""
        return _lldb.SBWatchpoint_Clear(self)

    @staticmethod
    def EventIsWatchpointEvent(event):
        r"""EventIsWatchpointEvent(SBEvent event) -> bool"""
        return _lldb.SBWatchpoint_EventIsWatchpointEvent(event)

    @staticmethod
    def GetWatchpointEventTypeFromEvent(event):
        r"""GetWatchpointEventTypeFromEvent(SBEvent event) -> lldb::WatchpointEventType"""
        return _lldb.SBWatchpoint_GetWatchpointEventTypeFromEvent(event)

    @staticmethod
    def GetWatchpointFromEvent(event):
        r"""GetWatchpointFromEvent(SBEvent event) -> SBWatchpoint"""
        return _lldb.SBWatchpoint_GetWatchpointFromEvent(event)

    def GetType(self):
        r"""
        GetType(SBWatchpoint self) -> SBType

            Returns the type recorded when the watchpoint was created. For variable
            watchpoints it is the type of the watched variable. For expression
            watchpoints it is the type of the provided expression.
        """
        return _lldb.SBWatchpoint_GetType(self)

    def GetWatchValueKind(self):
        r"""
        GetWatchValueKind(SBWatchpoint self) -> lldb::WatchpointValueKind

            Returns the kind of value that was watched when the watchpoint was created.
            Returns one of the following eWatchPointValueKindVariable,
            eWatchPointValueKindExpression, eWatchPointValueKindInvalid.

        """
        return _lldb.SBWatchpoint_GetWatchValueKind(self)

    def GetWatchSpec(self):
        r"""
        GetWatchSpec(SBWatchpoint self) -> char const *

            Get the spec for the watchpoint. For variable watchpoints this is the name
            of the variable. For expression watchpoints it is empty
            (may change in the future).
        """
        return _lldb.SBWatchpoint_GetWatchSpec(self)

    def IsWatchingReads(self):
        r"""
        IsWatchingReads(SBWatchpoint self) -> bool

            Returns true if the watchpoint is watching reads. Returns false otherwise.
        """
        return _lldb.SBWatchpoint_IsWatchingReads(self)

    def IsWatchingWrites(self):
        r"""
        IsWatchingWrites(SBWatchpoint self) -> bool

            Returns true if the watchpoint is watching writes. Returns false otherwise.
        """
        return _lldb.SBWatchpoint_IsWatchingWrites(self)

    def __repr__(self):
        r"""__repr__(SBWatchpoint self) -> std::string"""
        return _lldb.SBWatchpoint___repr__(self)

          # operator== is a free function, which swig does not handle, so we inject
          # our own equality operator here
    def __eq__(self, other):
      return not self.__ne__(other)

    def __hex__(self):
      return self.GetWatchAddress()

    def __len__(self):
      return self.GetWatchSize()


# Register SBWatchpoint in _lldb:
_lldb.SBWatchpoint_swigregister(SBWatchpoint)
class SBWatchpointOptions(object):
    r"""A container for options to use when creating watchpoints."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SBWatchpointOptions self) -> SBWatchpointOptions
        __init__(SBWatchpointOptions self, SBWatchpointOptions rhs) -> SBWatchpointOptions
        """
        _lldb.SBWatchpointOptions_swiginit(self, _lldb.new_SBWatchpointOptions(*args))
    __swig_destroy__ = _lldb.delete_SBWatchpointOptions

    def SetWatchpointTypeRead(self, read):
        r"""
        SetWatchpointTypeRead(SBWatchpointOptions self, bool read)
        Sets whether the watchpoint should stop on read accesses.
        """
        return _lldb.SBWatchpointOptions_SetWatchpointTypeRead(self, read)

    def GetWatchpointTypeRead(self):
        r"""
        GetWatchpointTypeRead(SBWatchpointOptions self) -> bool
        Gets whether the watchpoint should stop on read accesses.
        """
        return _lldb.SBWatchpointOptions_GetWatchpointTypeRead(self)

    def SetWatchpointTypeWrite(self, write_type):
        r"""
        SetWatchpointTypeWrite(SBWatchpointOptions self, lldb::WatchpointWriteType write_type)
        Sets whether the watchpoint should stop on write accesses. eWatchpointWriteTypeOnModify is the most commonly useful mode, where lldb will stop when the watched value has changed. eWatchpointWriteTypeAlways will stop on any write to the watched region, even if it's the value is the same.
        """
        return _lldb.SBWatchpointOptions_SetWatchpointTypeWrite(self, write_type)

    def GetWatchpointTypeWrite(self):
        r"""
        GetWatchpointTypeWrite(SBWatchpointOptions self) -> lldb::WatchpointWriteType
        Gets whether the watchpoint should stop on write accesses, returning WatchpointWriteType to indicate the type of write watching that is enabled, or eWatchpointWriteTypeDisabled.
        """
        return _lldb.SBWatchpointOptions_GetWatchpointTypeWrite(self)

# Register SBWatchpointOptions in _lldb:
_lldb.SBWatchpointOptions_swigregister(SBWatchpointOptions)

# ==================================
# Helper function for SBModule class
# ==================================
def in_range(symbol, section):
    """Test whether a symbol is within the range of a section."""
    symSA = symbol.GetStartAddress().GetFileAddress()
    symEA = symbol.GetEndAddress().GetFileAddress()
    secSA = section.GetFileAddress()
    secEA = secSA + section.GetByteSize()

    if symEA != LLDB_INVALID_ADDRESS:
        if secSA <= symSA and symEA <= secEA:
            return True
        else:
            return False
    else:
        if secSA <= symSA and symSA < secEA:
            return True
        else:
            return False



def command(command_name=None, doc=None):
    import lldb
    """A decorator function that registers an LLDB command line
        command that is bound to the function it is attached to."""
    def callable(function):
        """Registers an lldb command for the decorated function."""
        command = "command script add -f %s.%s %s" % (function.__module__, function.__name__, command_name or function.__name__)
        lldb.debugger.HandleCommand(command)
        if doc:
            function.__doc__ = doc
        return function

    return callable

class declaration(object):
    '''A class that represents a source declaration location with file, line and column.'''
    def __init__(self, file, line, col):
        self.file = file
        self.line = line
        self.col = col

class value_iter(object):
    '''Allows iterating over the children of an :py:class:`SBValue`.'''
    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= self.length:
            raise StopIteration()
        child_sbvalue = self.sbvalue.GetChildAtIndex(self.index)
        self.index += 1
        return value(child_sbvalue)

    def next(self):
        return self.__next__()

    def __eq__(self, other):
        return not self.__ne__(other)

    def __len__(self):
        return self.length

    def __init__(self,value):
        self.index = 0
        self.length = 0
        self.sbvalue = value
        if type(self.sbvalue) is value:
            self.sbvalue = self.sbvalue.sbvalue
        self.length = self.sbvalue.GetNumChildren()

class value(object):
    '''Wraps :py:class:`SBValue` objects so the resulting object can be used as a variable would be in code.

    So if you have a Point structure variable in your code in the current frame named "pt",
    you can initialize an instance of this class with it: ::

        pt = lldb.value(lldb.frame.FindVariable("pt"))
        print pt
        print pt.x
        print pt.y

        pt = lldb.value(lldb.frame.FindVariable("rectangle_array"))
        print rectangle_array[12]
        print rectangle_array[5].origin.x'''
    def __init__(self, sbvalue):
        self.sbvalue = sbvalue

    def __nonzero__(self):
        return self.sbvalue.__nonzero__()

    def __bool__(self):
        return self.sbvalue.__bool__()

    def __str__(self):
        return self.sbvalue.__str__()

    def __getitem__(self, key):
# Allow array access if this value has children...
        if type(key) is value:
            key = int(key)
        if type(key) is int:
            child_sbvalue = (self.sbvalue.GetValueForExpressionPath("[%i]" % key))
            if child_sbvalue and child_sbvalue.IsValid():
                return value(child_sbvalue)
            raise IndexError("Index '%d' is out of range" % key)
        raise TypeError("No array item of type %s" % str(type(key)))

    def __iter__(self):
        return value_iter(self.sbvalue)

    def __getattr__(self, name):
        child_sbvalue = self.sbvalue.GetChildMemberWithName (name)
        if child_sbvalue and child_sbvalue.IsValid():
            return value(child_sbvalue)
        raise AttributeError("Attribute '%s' is not defined" % name)

    def __add__(self, other):
        return int(self) + int(other)

    def __sub__(self, other):
        return int(self) - int(other)

    def __mul__(self, other):
        return int(self) * int(other)

    def __floordiv__(self, other):
        return int(self) // int(other)

    def __mod__(self, other):
        return int(self) % int(other)

    def __divmod__(self, other):
        return int(self) % int(other)

    def __pow__(self, other):
        return int(self) ** int(other)

    def __lshift__(self, other):
        return int(self) << int(other)

    def __rshift__(self, other):
        return int(self) >> int(other)

    def __and__(self, other):
        return int(self) & int(other)

    def __xor__(self, other):
        return int(self) ^ int(other)

    def __or__(self, other):
        return int(self) | int(other)

    def __div__(self, other):
        return int(self) / int(other)

    def __truediv__(self, other):
        return int(self) / int(other)

    def __iadd__(self, other):
        result = self.__add__(other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __isub__(self, other):
        result = self.__sub__(other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __imul__(self, other):
        result = self.__mul__(other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __idiv__(self, other):
        result = self.__div__(other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __itruediv__(self, other):
        result = self.__truediv__(other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __ifloordiv__(self, other):
        result =  self.__floordiv__(self, other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __imod__(self, other):
        result =  self.__and__(self, other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __ipow__(self, other):
        result = self.__pow__(self, other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __ipow__(self, other, modulo):
        result = self.__pow__(self, other, modulo)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __ilshift__(self, other):
        result = self.__lshift__(other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __irshift__(self, other):
        result =  self.__rshift__(other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __iand__(self, other):
        result =  self.__and__(self, other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __ixor__(self, other):
        result =  self.__xor__(self, other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __ior__(self, other):
        result =  self.__ior__(self, other)
        self.sbvalue.SetValueFromCString (str(result))
        return result

    def __neg__(self):
        return -int(self)

    def __pos__(self):
        return +int(self)

    def __abs__(self):
        return abs(int(self))

    def __invert__(self):
        return ~int(self)

    def __complex__(self):
        return complex (int(self))

    def __int__(self):
        is_num,is_sign = is_numeric_type(self.sbvalue.GetType().GetCanonicalType().GetBasicType())
        if is_num and not is_sign: return self.sbvalue.GetValueAsUnsigned()
        return self.sbvalue.GetValueAsSigned()

    def __long__(self):
        return self.__int__()

    def __float__(self):
        return float (self.sbvalue.GetValueAsSigned())

    def __oct__(self):
        return '0%o' % self.sbvalue.GetValueAsUnsigned()

    def __hex__(self):
        return '0x%x' % self.sbvalue.GetValueAsUnsigned()

    def __len__(self):
        return self.sbvalue.GetNumChildren()

    def __eq__(self, other):
        if type(other) is int:
                return int(self) == other
        elif type(other) is str:
                return str(self) == other
        elif type(other) is value:
                self_err = SBError()
                other_err = SBError()
                self_val = self.sbvalue.GetValueAsUnsigned(self_err)
                if self_err.fail:
                        raise ValueError("unable to extract value of self")
                other_val = other.sbvalue.GetValueAsUnsigned(other_err)
                if other_err.fail:
                        raise ValueError("unable to extract value of other")
                return self_val == other_val
        raise TypeError("Unknown type %s, No equality operation defined." % str(type(other)))

    def __ne__(self, other):
        return not self.__eq__(other)



class SBSyntheticValueProvider(object):
    def __init__(self,valobj):
        pass

    def num_children(self):
        return 0

    def get_child_index(self,name):
        return None

    def get_child_at_index(self,idx):
        return None

    def update(self):
        pass

    def has_children(self):
        return False

    def __len__(self):
      return self.num_children()

    def __iter__(self):
      '''Iterate over all children in a lldb.SBSyntheticValueProvider object.'''
      return lldb_iter(self, 'num_children', 'get_child_at_index')




# given an lldb.SBBasicType it returns a tuple
# (is_numeric, is_signed)
# the value of is_signed is undefined if is_numeric == false
def is_numeric_type(basic_type):
    if basic_type == eBasicTypeInvalid: return (False,False)
    if basic_type == eBasicTypeVoid: return (False,False)
    if basic_type == eBasicTypeChar: return (True,False)
    if basic_type == eBasicTypeSignedChar: return (True,True)
    if basic_type == eBasicTypeUnsignedChar: return (True,False)
    if basic_type == eBasicTypeWChar: return (True,False)
    if basic_type == eBasicTypeSignedWChar: return (True,True)
    if basic_type == eBasicTypeUnsignedWChar: return (True,False)
    if basic_type == eBasicTypeChar16: return (True,False)
    if basic_type == eBasicTypeChar32: return (True,False)
    if basic_type == eBasicTypeChar8: return (True,False)
    if basic_type == eBasicTypeShort: return (True,True)
    if basic_type == eBasicTypeUnsignedShort: return (True,False)
    if basic_type == eBasicTypeInt: return (True,True)
    if basic_type == eBasicTypeUnsignedInt: return (True,False)
    if basic_type == eBasicTypeLong: return (True,True)
    if basic_type == eBasicTypeUnsignedLong: return (True,False)
    if basic_type == eBasicTypeLongLong: return (True,True)
    if basic_type == eBasicTypeUnsignedLongLong: return (True,False)
    if basic_type == eBasicTypeInt128: return (True,True)
    if basic_type == eBasicTypeUnsignedInt128: return (True,False)
    if basic_type == eBasicTypeBool: return (False,False)
    if basic_type == eBasicTypeHalf: return (True,True)
    if basic_type == eBasicTypeFloat: return (True,True)
    if basic_type == eBasicTypeDouble: return (True,True)
    if basic_type == eBasicTypeLongDouble: return (True,True)
    if basic_type == eBasicTypeFloatComplex: return (True,True)
    if basic_type == eBasicTypeDoubleComplex: return (True,True)
    if basic_type == eBasicTypeLongDoubleComplex: return (True,True)
    if basic_type == eBasicTypeObjCID: return (False,False)
    if basic_type == eBasicTypeObjCClass: return (False,False)
    if basic_type == eBasicTypeObjCSel: return (False,False)
    if basic_type == eBasicTypeNullPtr: return (False,False)
#if basic_type == eBasicTypeOther:
    return (False,False)



debugger_unique_id = 0
SBDebugger.Initialize()
debugger = None
target = None
process = None
thread = None
frame = None


