vagd.gdb.types

Classes

`_TypePrinter`	Base class for protocol classes.
`_TypeRecognizer`	Base class for protocol classes.
`TypePrinter`

Functions

`get_basic_type`(→ gdb.Type)
`has_field`(→ bool)
`make_enum_dict`(→ dict[str, int])
`deep_items`(→ collections.abc.Iterator[tuple[str, ...)
`get_type_recognizers`(→ list[_TypeRecognizer])
`apply_type_recognizers`(→ str \| None)
`register_type_printer`(→ None)

Module Contents

vagd.gdb.types.get_basic_type(type_: gdb.Type) → gdb.Type

vagd.gdb.types.has_field(type_: gdb.Type, field: str) → bool

vagd.gdb.types.make_enum_dict(type_: gdb.Type) → dict[str, int]

vagd.gdb.types.deep_items(type_: gdb.Type) → collections.abc.Iterator[tuple[str, gdb.Field]]

vagd.gdb.types.get_type_recognizers() → list[_TypeRecognizer]

vagd.gdb.types.apply_type_recognizers(recognizers: list[_TypeRecognizer], type_obj: gdb.Type) → str | None

vagd.gdb.types.register_type_printer(locus: gdb.Objfile | gdb.Progspace | None, printer: _TypePrinter) → None

class vagd.gdb.types._TypePrinter

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

enabled: bool

name: str

instantiate() → _TypeRecognizer | None

class vagd.gdb.types._TypeRecognizer