Generated Python source for gdb using pystubgen (https://github.com/Lekensteyn/pystubgen)

gdb.py

# Generated from package gdb using pystubgen

"""
# Copyright (C) 2010-2015 Free Software Foundation, Inc.
"""

class Architecture(object):
    """
    GDB architecture object
    """

    def disassemble(__unknown_params__):
        """
        disassemble (start_pc [, end_pc [, count]]) -> List.
        Return a list of at most COUNT disassembled instructions from START_PC to
        END_PC.
        """

    def name(__unknown_params__):
        """
        name () -> String.
        Return the name of the architecture as a string value.
        """

    __new__ = "<built-in method __new__ of type object at 0xbe6540>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

class Block(object):
    """
    GDB block object
    """

    def __iter__(__unknown_params__):
        """
        x.__iter__() <==> iter(x)
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this block is valid, false if not.
        """

    __new__ = "<built-in method __new__ of type object at 0xbe6740>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    end = "<attribute 'end' of 'gdb.Block' objects>" # DATA
    """
    End address of the block.
    """

    function = "<attribute 'function' of 'gdb.Block' objects>" # DATA
    """
    Symbol that names the block, or None.
    """

    global_block = "<attribute 'global_block' of 'gdb.Block' objects>" # DATA
    """
    Block containing the global block.
    """

    is_global = "<attribute 'is_global' of 'gdb.Block' objects>" # DATA
    """
    Whether this block is a global block.
    """

    is_static = "<attribute 'is_static' of 'gdb.Block' objects>" # DATA
    """
    Whether this block is a static block.
    """

    start = "<attribute 'start' of 'gdb.Block' objects>" # DATA
    """
    Start address of the block.
    """

    static_block = "<attribute 'static_block' of 'gdb.Block' objects>" # DATA
    """
    Block containing the static block.
    """

    superblock = "<attribute 'superblock' of 'gdb.Block' objects>" # DATA
    """
    Block containing the block, or None.
    """

class BlockIterator(object):
    """
    GDB block syms iterator object
    """

    def __iter__(__unknown_params__):
        """
        x.__iter__() <==> iter(x)
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this block iterator is valid, false if not.
        """

    def next(__unknown_params__):
        """
        x.next() -> the next value, or raise StopIteration
        """

    __new__ = "<built-in method __new__ of type object at 0xbe6ac0>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

class Breakpoint(object):
    """
    GDB breakpoint object
    """

    def __delattr__(__unknown_params__):
        """
        x.__delattr__('name') <==> del x.name
        """

    def __init__(__unknown_params__):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """

    def __setattr__(__unknown_params__):
        """
        x.__setattr__('name', value) <==> x.name = value
        """

    def delete(__unknown_params__):
        """
        Delete the underlying GDB breakpoint.
        """

    def is_valid(__unknown_params__):
        """
        Return true if this breakpoint is valid, false if not.
        """

    __new__ = "<built-in method __new__ of type object at 0xbe6e80>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    commands = "<attribute 'commands' of 'gdb.Breakpoint' objects>" # DATA
    """
    Commands of the breakpoint, as specified by the user.
    """

    condition = "<attribute 'condition' of 'gdb.Breakpoint' objects>" # DATA
    """
    Condition of the breakpoint, as specified by the user,or None if no condition set.
    """

    enabled = "<attribute 'enabled' of 'gdb.Breakpoint' objects>" # DATA
    """
    Boolean telling whether the breakpoint is enabled.
    """

    expression = "<attribute 'expression' of 'gdb.Breakpoint' objects>" # DATA
    """
    Expression of the breakpoint, as specified by the user.
    """

    hit_count = "<attribute 'hit_count' of 'gdb.Breakpoint' objects>" # DATA
    """
    Number of times the breakpoint has been hit.
    Can be set to zero to clear the count. No other value is valid
    when setting this property.
    """

    ignore_count = "<attribute 'ignore_count' of 'gdb.Breakpoint' objects>" # DATA
    """
    Number of times this breakpoint should be automatically continued.
    """

    location = "<attribute 'location' of 'gdb.Breakpoint' objects>" # DATA
    """
    Location of the breakpoint, as specified by the user.
    """

    number = "<attribute 'number' of 'gdb.Breakpoint' objects>" # DATA
    """
    Breakpoint's number assigned by GDB.
    """

    silent = "<attribute 'silent' of 'gdb.Breakpoint' objects>" # DATA
    """
    Boolean telling whether the breakpoint is silent.
    """

    task = "<attribute 'task' of 'gdb.Breakpoint' objects>" # DATA
    """
    Thread ID for the breakpoint.
    If the value is a task ID (integer), then this is an Ada task-specific breakpoint.
    If the value is None, then this breakpoint is not task-specific.
    No other type of value can be used.
    """

    temporary = "<attribute 'temporary' of 'gdb.Breakpoint' objects>" # DATA
    """
    Whether this breakpoint is a temporary breakpoint.
    """

    thread = "<attribute 'thread' of 'gdb.Breakpoint' objects>" # DATA
    """
    Thread ID for the breakpoint.
    If the value is a thread ID (integer), then this is a thread-specific breakpoint.
    If the value is None, then this breakpoint is not thread-specific.
    No other type of value can be used.
    """

    type = "<attribute 'type' of 'gdb.Breakpoint' objects>" # DATA
    """
    Type of breakpoint.
    """

    visible = "<attribute 'visible' of 'gdb.Breakpoint' objects>" # DATA
    """
    Whether the breakpoint is visible to the user.
    """

class BreakpointEvent(StopEvent):
    """
    GDB breakpoint stop event object
    """

class ClearObjFilesEvent(Event):
    """
    GDB clear object files event object
    """

class Command(object):
    """
    GDB command object
    """

    def __init__(__unknown_params__):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """

    def dont_repeat(__unknown_params__):
        """
        Prevent command repetition when user enters empty line.
        """

    __new__ = "<built-in method __new__ of type object at 0xbe73c0>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

class ContinueEvent(ThreadEvent):
    """
    GDB continue event object
    """

class Event(object):
    """
    GDB event object
    """

class EventRegistry(object):
    """
    GDB event registry object
    """

    def connect(__unknown_params__):
        """
        Add function
        """

    def disconnect(__unknown_params__):
        """
        Remove function
        """

class ExitedEvent(Event):
    """
    GDB exited event object
    """

class Field(object):
    """
    GDB field object
    """

class FinishBreakpoint(Breakpoint):
    """
    GDB finish breakpoint object
    """

    def __init__(__unknown_params__):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """

    return_value = "<attribute 'return_value' of 'gdb.FinishBreakpoint' objects>" # DATA
    """
    gdb.Value object representing the return value, if any. None otherwise.
    """

class Frame(object):
    """
    GDB frame object
    """

    def __eq__(__unknown_params__):
        """
        x.__eq__(y) <==> x==y
        """

    def __ge__(__unknown_params__):
        """
        x.__ge__(y) <==> x>=y
        """

    def __gt__(__unknown_params__):
        """
        x.__gt__(y) <==> x>y
        """

    def __le__(__unknown_params__):
        """
        x.__le__(y) <==> x<=y
        """

    def __lt__(__unknown_params__):
        """
        x.__lt__(y) <==> x<y
        """

    def __ne__(__unknown_params__):
        """
        x.__ne__(y) <==> x!=y
        """

    def __str__(__unknown_params__):
        """
        x.__str__() <==> str(x)
        """

    def architecture(__unknown_params__):
        """
        architecture () -> gdb.Architecture.
        Return the architecture of the frame.
        """

    def block(__unknown_params__):
        """
        block () -> gdb.Block.
        Return the frame's code block.
        """

    def find_sal(__unknown_params__):
        """
        find_sal () -> gdb.Symtab_and_line.
        Return the frame's symtab and line.
        """

    def function(__unknown_params__):
        """
        function () -> gdb.Symbol.
        Returns the symbol for the function corresponding to this frame.
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this frame is valid, false if not.
        """

    def name(__unknown_params__):
        """
        name () -> String.
        Return the function name of the frame, or None if it can't be determined.
        """

    def newer(__unknown_params__):
        """
        newer () -> gdb.Frame.
        Return the frame called by this frame.
        """

    def older(__unknown_params__):
        """
        older () -> gdb.Frame.
        Return the frame that called this frame.
        """

    def pc(__unknown_params__):
        """
        pc () -> Long.
        Return the frame's resume address.
        """

    def read_register(__unknown_params__):
        """
        read_register (register_name) -> gdb.Value
        Return the value of the register in the frame.
        """

    def read_var(__unknown_params__):
        """
        read_var (variable) -> gdb.Value.
        Return the value of the variable in this frame.
        """

    def select(__unknown_params__):
        """
        Select this frame as the user's current frame.
        """

    def type(__unknown_params__):
        """
        type () -> Integer.
        Return the type of the frame.
        """

    def unwind_stop_reason(__unknown_params__):
        """
        unwind_stop_reason () -> Integer.
        Return the reason why it's not possible to find frames older than this.
        """

    __new__ = "<built-in method __new__ of type object at 0xbe8000>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

class Function(object):
    """
    GDB function object
    """

    def __init__(__unknown_params__):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """

    __new__ = "<built-in method __new__ of type object at 0xbe83c0>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

class GdbError(Exception):
    pass

class GdbOutputErrorFile(_GdbFile):
    def write(self, s):
        pass

class GdbOutputFile(_GdbFile):
    def write(self, s):
        pass

class Inferior(object):
    """
    GDB inferior object
    """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this inferior is valid, false if not.
        """

    def read_memory(__unknown_params__):
        """
        read_memory (address, length) -> buffer
        Return a buffer object for reading from the inferior's memory.
        """

    def search_memory(__unknown_params__):
        """
        search_memory (address, length, pattern) -> long
        Return a long with the address of a match, or None.
        """

    def threads(__unknown_params__):
        """
        Return all the threads of this inferior.
        """

    def write_memory(__unknown_params__):
        """
        write_memory (address, buffer [, length])
        Write the given buffer object to the inferior's memory.
        """

    num = "<attribute 'num' of 'gdb.Inferior' objects>" # DATA
    """
    ID of inferior, as assigned by GDB.
    """

    pid = "<attribute 'pid' of 'gdb.Inferior' objects>" # DATA
    """
    PID of inferior, as assigned by the OS.
    """

    was_attached = "<attribute 'was_attached' of 'gdb.Inferior' objects>" # DATA
    """
    True if the inferior was created using 'attach'.
    """

class InferiorCallPostEvent(Event):
    """
    GDB inferior function post-call event object
    """

class InferiorCallPreEvent(Event):
    """
    GDB inferior function pre-call event object
    """

class InferiorThread(object):
    """
    GDB thread object
    """

    def is_exited(__unknown_params__):
        """
        is_exited () -> Boolean
        Return whether the thread is exited.
        """

    def is_running(__unknown_params__):
        """
        is_running () -> Boolean
        Return whether the thread is running.
        """

    def is_stopped(__unknown_params__):
        """
        is_stopped () -> Boolean
        Return whether the thread is stopped.
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this inferior thread is valid, false if not.
        """

    def switch(__unknown_params__):
        """
        switch ()
        Makes this the GDB selected thread.
        """

    name = "<attribute 'name' of 'gdb.InferiorThread' objects>" # DATA
    """
    The name of the thread, as set by the user or the OS.
    """

    num = "<attribute 'num' of 'gdb.InferiorThread' objects>" # DATA
    """
    ID of the thread, as assigned by GDB.
    """

    ptid = "<attribute 'ptid' of 'gdb.InferiorThread' objects>" # DATA
    """
    ID of the thread, as assigned by the OS.
    """

class LineTable(object):
    """
    GDB line table object
    """

    def __iter__(__unknown_params__):
        """
        x.__iter__() <==> iter(x)
        """

    def has_line(__unknown_params__):
        """
        has_line (lineno) -> Boolean
        Return TRUE if this line has executable information, FALSE if not.
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return True if this Linetable is valid, False if not.
        """

    def line(__unknown_params__):
        """
        line (lineno) -> Tuple
        Return executable locations for a given source line.
        """

    def source_lines(__unknown_params__):
        """
        source_lines () -> FrozenSet
        Return a frozen set of all executable source lines.
        """

class LineTableEntry(object):
    """
    GDB line table entry object
    """

    line = "<attribute 'line' of 'gdb.LineTableEntry' objects>" # DATA
    """
    The line number in the source file.
    """

    pc = "<attribute 'pc' of 'gdb.LineTableEntry' objects>" # DATA
    """
    The memory address for this line number.
    """

class LineTableIterator(object):
    """
    GDB line table iterator object
    """

    def __iter__(__unknown_params__):
        """
        x.__iter__() <==> iter(x)
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return True if this Linetable iterator is valid, False if not.
        """

    def next(__unknown_params__):
        """
        x.next() -> the next value, or raise StopIteration
        """

class Membuf(object):
    """
    GDB memory buffer object
    """

    def __str__(__unknown_params__):
        """
        x.__str__() <==> str(x)
        """

    __new__ = "<built-in method __new__ of type object at 0xbe87c0>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

class MemoryChangedEvent(Event):
    """
    GDB memory change event object
    """

class MemoryError(error):
    pass

class NewObjFileEvent(Event):
    """
    GDB new object file event object
    """

class Objfile(object):
    """
    GDB objfile object
    """

    def add_separate_debug_file(__unknown_params__):
        """
        add_separate_debug_file (file_name).
        Add FILE_NAME to the list of files containing debug info for the objfile.
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this object file is valid, false if not.
        """

    __new__ = "<built-in method __new__ of type object at 0xbea540>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    build_id = "<attribute 'build_id' of 'gdb.Objfile' objects>" # DATA
    """
    The objfile's build id, or None.
    """

    filename = "<attribute 'filename' of 'gdb.Objfile' objects>" # DATA
    """
    The objfile's filename, or None.
    """

    frame_filters = "<attribute 'frame_filters' of 'gdb.Objfile' objects>" # DATA
    """
    Frame Filters.
    """

    owner = "<attribute 'owner' of 'gdb.Objfile' objects>" # DATA
    """
    The objfile owner of separate debug info objfiles, or None.
    """

    pretty_printers = "<attribute 'pretty_printers' of 'gdb.Objfile' objects>" # DATA
    """
    Pretty printers.
    """

    progspace = "<attribute 'progspace' of 'gdb.Objfile' objects>" # DATA
    """
    The objfile's progspace, or None.
    """

    type_printers = "<attribute 'type_printers' of 'gdb.Objfile' objects>" # DATA
    """
    Type printers.
    """

    xmethods = "<attribute 'xmethods' of 'gdb.Objfile' objects>" # DATA
    """
    Debug methods.
    """

class Parameter(object):
    """
    GDB parameter object
    """

    def __delattr__(__unknown_params__):
        """
        x.__delattr__('name') <==> del x.name
        """

    def __getattribute__(__unknown_params__):
        """
        x.__getattribute__('name') <==> x.name
        """

    def __init__(__unknown_params__):
        """
        x.__init__(...) initializes x; see help(type(x)) for signature
        """

    def __setattr__(__unknown_params__):
        """
        x.__setattr__('name', value) <==> x.name = value
        """

    __new__ = "<built-in method __new__ of type object at 0xbea700>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

class Progspace(object):
    """
    GDB progspace object
    """

    __new__ = "<built-in method __new__ of type object at 0xbeaac0>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    filename = "<attribute 'filename' of 'gdb.Progspace' objects>" # DATA
    """
    The progspace's main filename, or None.
    """

    frame_filters = "<attribute 'frame_filters' of 'gdb.Progspace' objects>" # DATA
    """
    Frame filters.
    """

    pretty_printers = "<attribute 'pretty_printers' of 'gdb.Progspace' objects>" # DATA
    """
    Pretty printers.
    """

    type_printers = "<attribute 'type_printers' of 'gdb.Progspace' objects>" # DATA
    """
    Type printers.
    """

    xmethods = "<attribute 'xmethods' of 'gdb.Progspace' objects>" # DATA
    """
    Debug methods.
    """

class RegisterChangedEvent(Event):
    """
    GDB register change event object
    """

class SignalEvent(StopEvent):
    """
    GDB signal event object
    """

class StopEvent(ThreadEvent):
    """
    GDB stop event object
    """

class Symbol(object):
    """
    GDB symbol object
    """

    def __str__(__unknown_params__):
        """
        x.__str__() <==> str(x)
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this symbol is valid, false if not.
        """

    def value(__unknown_params__):
        """
        value ([frame]) -> gdb.Value
        Return the value of the symbol.
        """

    addr_class = "<attribute 'addr_class' of 'gdb.Symbol' objects>" # DATA
    """
    Address class of the symbol.
    """

    is_argument = "<attribute 'is_argument' of 'gdb.Symbol' objects>" # DATA
    """
    True if the symbol is an argument of a function.
    """

    is_constant = "<attribute 'is_constant' of 'gdb.Symbol' objects>" # DATA
    """
    True if the symbol is a constant.
    """

    is_function = "<attribute 'is_function' of 'gdb.Symbol' objects>" # DATA
    """
    True if the symbol is a function or method.
    """

    is_variable = "<attribute 'is_variable' of 'gdb.Symbol' objects>" # DATA
    """
    True if the symbol is a variable.
    """

    line = "<attribute 'line' of 'gdb.Symbol' objects>" # DATA
    """
    The source line number at which the symbol was defined.
    """

    linkage_name = "<attribute 'linkage_name' of 'gdb.Symbol' objects>" # DATA
    """
    Name of the symbol, as used by the linker (i.e., may be mangled).
    """

    name = "<attribute 'name' of 'gdb.Symbol' objects>" # DATA
    """
    Name of the symbol, as it appears in the source code.
    """

    needs_frame = "<attribute 'needs_frame' of 'gdb.Symbol' objects>" # DATA
    """
    True if the symbol requires a frame for evaluation.
    """

    print_name = "<attribute 'print_name' of 'gdb.Symbol' objects>" # DATA
    """
    Name of the symbol in a form suitable for output.
    This is either name or linkage_name, depending on whether the user asked GDB
    to display demangled or mangled names.
    """

    symtab = "<attribute 'symtab' of 'gdb.Symbol' objects>" # DATA
    """
    Symbol table in which the symbol appears.
    """

    type = "<attribute 'type' of 'gdb.Symbol' objects>" # DATA
    """
    Type of the symbol.
    """

class Symtab(object):
    """
    GDB symtab object
    """

    def __str__(__unknown_params__):
        """
        x.__str__() <==> str(x)
        """

    def fullname(__unknown_params__):
        """
        fullname () -> String.
        Return the symtab's full source filename.
        """

    def global_block(__unknown_params__):
        """
        global_block () -> gdb.Block.
        Return the global block of the symbol table.
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this symbol table is valid, false if not.
        """

    def linetable(__unknown_params__):
        """
        linetable () -> gdb.Linetable.
        Return the Linetable associated with this symbol table
        """

    def static_block(__unknown_params__):
        """
        static_block () -> gdb.Block.
        Return the static block of the symbol table.
        """

    __new__ = "<built-in method __new__ of type object at 0xbeb940>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    filename = "<attribute 'filename' of 'gdb.Symtab' objects>" # DATA
    """
    The symbol table's source filename.
    """

    objfile = "<attribute 'objfile' of 'gdb.Symtab' objects>" # DATA
    """
    The symtab's objfile.
    """

    producer = "<attribute 'producer' of 'gdb.Symtab' objects>" # DATA
    """
    The name/version of the program that compiled this symtab.
    """

class Symtab_and_line(object):
    """
    GDB symtab_and_line object
    """

    def __str__(__unknown_params__):
        """
        x.__str__() <==> str(x)
        """

    def is_valid(__unknown_params__):
        """
        is_valid () -> Boolean.
        Return true if this symbol table and line is valid, false if not.
        """

    __new__ = "<built-in method __new__ of type object at 0xbeb780>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    last = "<attribute 'last' of 'gdb.Symtab_and_line' objects>" # DATA
    """
    Return the symtab_and_line's last address.
    """

    line = "<attribute 'line' of 'gdb.Symtab_and_line' objects>" # DATA
    """
    Return the symtab_and_line's line.
    """

    pc = "<attribute 'pc' of 'gdb.Symtab_and_line' objects>" # DATA
    """
    Return the symtab_and_line's pc.
    """

    symtab = "<attribute 'symtab' of 'gdb.Symtab_and_line' objects>" # DATA
    """
    Symtab object.
    """

class ThreadEvent(Event):
    """
    GDB thread event object
    """

class Type(object):
    """
    GDB type object
    """

    def __contains__(__unknown_params__):
        """
        T.__contains__(k) -> True if T has a field named k, else False
        """

    def __eq__(__unknown_params__):
        """
        x.__eq__(y) <==> x==y
        """

    def __ge__(__unknown_params__):
        """
        x.__ge__(y) <==> x>=y
        """

    def __getitem__(__unknown_params__):
        """
        x.__getitem__(y) <==> x[y]
        """

    def __gt__(__unknown_params__):
        """
        x.__gt__(y) <==> x>y
        """

    def __iter__(__unknown_params__):
        """
        x.__iter__() <==> iter(x)
        """

    def __le__(__unknown_params__):
        """
        x.__le__(y) <==> x<=y
        """

    def __len__(__unknown_params__):
        """
        x.__len__() <==> len(x)
        """

    def __lt__(__unknown_params__):
        """
        x.__lt__(y) <==> x<y
        """

    def __ne__(__unknown_params__):
        """
        x.__ne__(y) <==> x!=y
        """

    def __nonzero__(__unknown_params__):
        """
        x.__nonzero__() <==> x != 0
        """

    def __str__(__unknown_params__):
        """
        x.__str__() <==> str(x)
        """

    def array(__unknown_params__):
        """
        array ([LOW_BOUND,] HIGH_BOUND) -> Type
        Return a type which represents an array of objects of this type.
        The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.
        If LOW_BOUND is omitted, a value of zero is used.
        """

    def const(__unknown_params__):
        """
        const () -> Type
        Return a const variant of this type.
        """

    def fields(__unknown_params__):
        """
        fields () -> list
        Return a list holding all the fields of this type.
        Each field is a gdb.Field object.
        """

    def get(__unknown_params__):
        """
        T.get(k[,default]) -> returns field named k in T, if it exists;
        otherwise returns default, if supplied, or None if not.
        """

    def has_key(__unknown_params__):
        """
        T.has_key(k) -> True if T has a field named k, else False
        """

    def items(__unknown_params__):
        """
        items () -> list
        Return a list of (name, field) pairs of this type.
        Each field is a gdb.Field object.
        """

    def iteritems(__unknown_params__):
        """
        iteritems () -> an iterator over the (name, field)
        pairs of this type.  Each field is a gdb.Field object.
        """

    def iterkeys(__unknown_params__):
        """
        iterkeys () -> an iterator over the field names of this type.
        """

    def itervalues(__unknown_params__):
        """
        itervalues () -> an iterator over the fields of this type.
        Each field is a gdb.Field object.
        """

    def keys(__unknown_params__):
        """
        keys () -> list
        Return a list holding all the fields names of this type.
        """

    def pointer(__unknown_params__):
        """
        pointer () -> Type
        Return a type of pointer to this type.
        """

    def range(__unknown_params__):
        """
        range () -> tuple
        Return a tuple containing the lower and upper range for this type.
        """

    def reference(__unknown_params__):
        """
        reference () -> Type
        Return a type of reference to this type.
        """

    def strip_typedefs(__unknown_params__):
        """
        strip_typedefs () -> Type
        Return a type formed by stripping this type of all typedefs.
        """

    def target(__unknown_params__):
        """
        target () -> Type
        Return the target type of this type.
        """

    def template_argument(__unknown_params__):
        """
        template_argument (arg, [block]) -> Type
        Return the type of a template argument.
        """

    def unqualified(__unknown_params__):
        """
        unqualified () -> Type
        Return a variant of this type without const or volatile attributes.
        """

    def values(__unknown_params__):
        """
        values () -> list
        Return a list holding all the fields of this type.
        Each field is a gdb.Field object.
        """

    def vector(__unknown_params__):
        """
        vector ([LOW_BOUND,] HIGH_BOUND) -> Type
        Return a type which represents a vector of objects of this type.
        The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.
        If LOW_BOUND is omitted, a value of zero is used.
        Vectors differ from arrays in that if the current language has C-style
        arrays, vectors don't decay to a pointer to the first element.
        They are first class values.
        """

    def volatile(__unknown_params__):
        """
        volatile () -> Type
        Return a volatile variant of this type
        """

    code = "<attribute 'code' of 'gdb.Type' objects>" # DATA
    """
    The code for this type.
    """

    name = "<attribute 'name' of 'gdb.Type' objects>" # DATA
    """
    The name for this type, or None.
    """

    sizeof = "<attribute 'sizeof' of 'gdb.Type' objects>" # DATA
    """
    The size of this type, in bytes.
    """

    tag = "<attribute 'tag' of 'gdb.Type' objects>" # DATA
    """
    The tag name for this type, or None.
    """

class TypeIterator(object):
    """
    GDB type iterator object
    """

    def __iter__(__unknown_params__):
        """
        x.__iter__() <==> iter(x)
        """

    def next(__unknown_params__):
        """
        x.next() -> the next value, or raise StopIteration
        """

class Value(object):
    """
    GDB value object
    """

    def __abs__(__unknown_params__):
        """
        x.__abs__() <==> abs(x)
        """

    def __add__(__unknown_params__):
        """
        x.__add__(y) <==> x+y
        """

    def __and__(__unknown_params__):
        """
        x.__and__(y) <==> x&y
        """

    def __call__(__unknown_params__):
        """
        x.__call__(...) <==> x(...)
        """

    def __delitem__(__unknown_params__):
        """
        x.__delitem__(y) <==> del x[y]
        """

    def __div__(__unknown_params__):
        """
        x.__div__(y) <==> x/y
        """

    def __eq__(__unknown_params__):
        """
        x.__eq__(y) <==> x==y
        """

    def __float__(__unknown_params__):
        """
        x.__float__() <==> float(x)
        """

    def __floordiv__(__unknown_params__):
        """
        x.__floordiv__(y) <==> x//y
        """

    def __ge__(__unknown_params__):
        """
        x.__ge__(y) <==> x>=y
        """

    def __getitem__(__unknown_params__):
        """
        x.__getitem__(y) <==> x[y]
        """

    def __gt__(__unknown_params__):
        """
        x.__gt__(y) <==> x>y
        """

    def __hash__(__unknown_params__):
        """
        x.__hash__() <==> hash(x)
        """

    def __int__(__unknown_params__):
        """
        x.__int__() <==> int(x)
        """

    def __invert__(__unknown_params__):
        """
        x.__invert__() <==> ~x
        """

    def __le__(__unknown_params__):
        """
        x.__le__(y) <==> x<=y
        """

    def __len__(__unknown_params__):
        """
        x.__len__() <==> len(x)
        """

    def __long__(__unknown_params__):
        """
        x.__long__() <==> long(x)
        """

    def __lshift__(__unknown_params__):
        """
        x.__lshift__(y) <==> x<<y
        """

    def __lt__(__unknown_params__):
        """
        x.__lt__(y) <==> x<y
        """

    def __mod__(__unknown_params__):
        """
        x.__mod__(y) <==> x%y
        """

    def __mul__(__unknown_params__):
        """
        x.__mul__(y) <==> x*y
        """

    def __ne__(__unknown_params__):
        """
        x.__ne__(y) <==> x!=y
        """

    def __neg__(__unknown_params__):
        """
        x.__neg__() <==> -x
        """

    def __nonzero__(__unknown_params__):
        """
        x.__nonzero__() <==> x != 0
        """

    def __or__(__unknown_params__):
        """
        x.__or__(y) <==> x|y
        """

    def __pos__(__unknown_params__):
        """
        x.__pos__() <==> +x
        """

    def __pow__(__unknown_params__):
        """
        x.__pow__(y[, z]) <==> pow(x, y[, z])
        """

    def __radd__(__unknown_params__):
        """
        x.__radd__(y) <==> y+x
        """

    def __rand__(__unknown_params__):
        """
        x.__rand__(y) <==> y&x
        """

    def __rdiv__(__unknown_params__):
        """
        x.__rdiv__(y) <==> y/x
        """

    def __rfloordiv__(__unknown_params__):
        """
        x.__rfloordiv__(y) <==> y//x
        """

    def __rlshift__(__unknown_params__):
        """
        x.__rlshift__(y) <==> y<<x
        """

    def __rmod__(__unknown_params__):
        """
        x.__rmod__(y) <==> y%x
        """

    def __rmul__(__unknown_params__):
        """
        x.__rmul__(y) <==> y*x
        """

    def __ror__(__unknown_params__):
        """
        x.__ror__(y) <==> y|x
        """

    def __rpow__(__unknown_params__):
        """
        y.__rpow__(x[, z]) <==> pow(x, y[, z])
        """

    def __rrshift__(__unknown_params__):
        """
        x.__rrshift__(y) <==> y>>x
        """

    def __rshift__(__unknown_params__):
        """
        x.__rshift__(y) <==> x>>y
        """

    def __rsub__(__unknown_params__):
        """
        x.__rsub__(y) <==> y-x
        """

    def __rxor__(__unknown_params__):
        """
        x.__rxor__(y) <==> y^x
        """

    def __setitem__(__unknown_params__):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """

    def __str__(__unknown_params__):
        """
        x.__str__() <==> str(x)
        """

    def __sub__(__unknown_params__):
        """
        x.__sub__(y) <==> x-y
        """

    def __xor__(__unknown_params__):
        """
        x.__xor__(y) <==> x^y
        """

    def cast(__unknown_params__):
        """
        Cast the value to the supplied type.
        """

    def dereference(__unknown_params__):
        """
        Dereferences the value.
        """

    def dynamic_cast(__unknown_params__):
        """
        dynamic_cast (gdb.Type) -> gdb.Value
        Cast the value to the supplied type, as if by the C++ dynamic_cast operator.
        """

    def fetch_lazy(__unknown_params__):
        """
        Fetches the value from the inferior, if it was lazy.
        """

    def lazy_string(__unknown_params__):
        """
        lazy_string ([encoding]  [, length]) -> lazy_string
        Return a lazy string representation of the value.
        """

    def referenced_value(__unknown_params__):
        """
        Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value.
        """

    def reinterpret_cast(__unknown_params__):
        """
        reinterpret_cast (gdb.Type) -> gdb.Value
        Cast the value to the supplied type, as if by the C++
        reinterpret_cast operator.
        """

    def string(__unknown_params__):
        """
        string ([encoding] [, errors] [, length]) -> string
        Return Unicode string representation of the value.
        """

    __new__ = "<built-in method __new__ of type object at 0xbec800>" # DATA
    """
    T.__new__(S, ...) -> a new object with type S, a subtype of T
    """

    address = "<attribute 'address' of 'gdb.Value' objects>" # DATA
    """
    The address of the value.
    """

    dynamic_type = "<attribute 'dynamic_type' of 'gdb.Value' objects>" # DATA
    """
    Dynamic type of the value.
    """

    is_lazy = "<attribute 'is_lazy' of 'gdb.Value' objects>" # DATA
    """
    Boolean telling whether the value is lazy (not fetched yet
    from the inferior).  A lazy value is fetched when needed, or when
    the "fetch_lazy()" method is called.
    """

    is_optimized_out = "<attribute 'is_optimized_out' of 'gdb.Value' objects>" # DATA
    """
    Boolean telling whether the value is optimized out (i.e., not available).
    """

    type = "<attribute 'type' of 'gdb.Value' objects>" # DATA
    """
    Type of the value.
    """

class _GdbFile(object):
    def close(self):
        pass

    def flush(self):
        pass

    def isatty(self):
        pass

    def writelines(self, iterable):
        pass

    encoding = 'UTF-8' # DATA

    errors = 'strict' # DATA

class error(RuntimeError):
    pass