/* Python interface to types.
- Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "value.h"
-#include "exceptions.h"
#include "python-internal.h"
#include "charset.h"
#include "gdbtypes.h"
#include "demangle.h"
#include "objfiles.h"
#include "language.h"
+#include "common/vec.h"
+#include "typeprint.h"
typedef struct pyty_type_object
{
struct pyty_type_object *next;
} type_object;
-static PyTypeObject type_object_type;
+extern PyTypeObject type_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
/* A Field object. */
typedef struct pyty_field_object
PyObject *dict;
} field_object;
-static PyTypeObject field_object_type;
+extern PyTypeObject field_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
+
+/* A type iterator object. */
+typedef struct {
+ PyObject_HEAD
+ /* The current field index. */
+ int field;
+ /* What to return. */
+ enum gdbpy_iter_kind kind;
+ /* Pointer back to the original source type object. */
+ struct pyty_type_object *source;
+} typy_iterator_object;
+
+extern PyTypeObject type_iterator_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
/* This is used to initialize various gdb.TYPE_ constants. */
struct pyty_code
const char *name;
};
+/* Forward declarations. */
+static PyObject *typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind);
+
#define ENTRY(X) { X, #X }
static struct pyty_code pyty_codes[] =
{
+ ENTRY (TYPE_CODE_BITSTRING),
ENTRY (TYPE_CODE_PTR),
ENTRY (TYPE_CODE_ARRAY),
ENTRY (TYPE_CODE_STRUCT),
ENTRY (TYPE_CODE_SET),
ENTRY (TYPE_CODE_RANGE),
ENTRY (TYPE_CODE_STRING),
- ENTRY (TYPE_CODE_BITSTRING),
ENTRY (TYPE_CODE_ERROR),
ENTRY (TYPE_CODE_METHOD),
ENTRY (TYPE_CODE_METHODPTR),
ENTRY (TYPE_CODE_MEMBERPTR),
ENTRY (TYPE_CODE_REF),
+ ENTRY (TYPE_CODE_RVALUE_REF),
ENTRY (TYPE_CODE_CHAR),
ENTRY (TYPE_CODE_BOOL),
ENTRY (TYPE_CODE_COMPLEX),
field_dealloc (PyObject *obj)
{
field_object *f = (field_object *) obj;
+
Py_XDECREF (f->dict);
- f->ob_type->tp_free (obj);
+ Py_TYPE (obj)->tp_free (obj);
}
static PyObject *
field_new (void)
{
- field_object *result = PyObject_New (field_object, &field_object_type);
- if (result)
+ gdbpy_ref<field_object> result (PyObject_New (field_object,
+ &field_object_type));
+
+ if (result != NULL)
{
result->dict = PyDict_New ();
if (!result->dict)
- {
- Py_DECREF (result);
- result = NULL;
- }
+ return NULL;
}
- return (PyObject *) result;
+ return (PyObject *) result.release ();
}
\f
+/* Return true if OBJ is of type gdb.Field, false otherwise. */
+
+int
+gdbpy_is_field (PyObject *obj)
+{
+ return PyObject_TypeCheck (obj, &field_object_type);
+}
+
/* Return the code for this type. */
static PyObject *
typy_get_code (PyObject *self, void *closure)
{
struct type *type = ((type_object *) self)->type;
+
return PyInt_FromLong (TYPE_CODE (type));
}
/* Helper function for typy_fields which converts a single field to a
- dictionary. Returns NULL on error. */
-static PyObject *
+ gdb.Field object. Returns NULL on error. */
+
+static gdbpy_ref<>
convert_field (struct type *type, int field)
{
- PyObject *result = field_new ();
- PyObject *arg;
+ gdbpy_ref<> result (field_new ());
- if (!result)
+ if (result == NULL)
+ return NULL;
+
+ gdbpy_ref<> arg (type_to_type_object (type));
+ if (arg == NULL)
+ return NULL;
+ if (PyObject_SetAttrString (result.get (), "parent_type", arg.get ()) < 0)
return NULL;
if (!field_is_static (&TYPE_FIELD (type, field)))
{
- arg = PyLong_FromLong (TYPE_FIELD_BITPOS (type, field));
- if (!arg)
- goto fail;
+ const char *attrstring;
+
+ if (TYPE_CODE (type) == TYPE_CODE_ENUM)
+ {
+ arg.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type,
+ field)));
+ attrstring = "enumval";
+ }
+ else
+ {
+ arg.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type,
+ field)));
+ attrstring = "bitpos";
+ }
+
+ if (arg == NULL)
+ return NULL;
- if (PyObject_SetAttrString (result, "bitpos", arg) < 0)
- goto failarg;
+ /* At least python-2.4 had the second parameter non-const. */
+ if (PyObject_SetAttrString (result.get (), (char *) attrstring,
+ arg.get ()) < 0)
+ return NULL;
}
+ arg.reset (NULL);
if (TYPE_FIELD_NAME (type, field))
- arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
- else
{
- arg = Py_None;
- Py_INCREF (arg);
+ const char *field_name = TYPE_FIELD_NAME (type, field);
+
+ if (field_name[0] != '\0')
+ {
+ arg.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
+ if (arg == NULL)
+ return NULL;
+ }
}
- if (!arg)
- goto fail;
- if (PyObject_SetAttrString (result, "name", arg) < 0)
- goto failarg;
+ if (arg == NULL)
+ arg = gdbpy_ref<>::new_reference (Py_None);
+
+ if (PyObject_SetAttrString (result.get (), "name", arg.get ()) < 0)
+ return NULL;
- arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
- Py_INCREF (arg);
- if (PyObject_SetAttrString (result, "artificial", arg) < 0)
- goto failarg;
+ arg = gdbpy_ref<>::new_reference (TYPE_FIELD_ARTIFICIAL (type, field)
+ ? Py_True : Py_False);
+ if (PyObject_SetAttrString (result.get (), "artificial", arg.get ()) < 0)
+ return NULL;
- if (TYPE_CODE (type) == TYPE_CODE_CLASS)
- arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ arg = gdbpy_ref<>::new_reference (field < TYPE_N_BASECLASSES (type)
+ ? Py_True : Py_False);
else
- arg = Py_False;
- Py_INCREF (arg);
- if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
- goto failarg;
+ arg = gdbpy_ref<>::new_reference (Py_False);
+ if (PyObject_SetAttrString (result.get (), "is_base_class", arg.get ()) < 0)
+ return NULL;
- arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
- if (!arg)
- goto fail;
- if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
- goto failarg;
+ arg.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field)));
+ if (arg == NULL)
+ return NULL;
+ if (PyObject_SetAttrString (result.get (), "bitsize", arg.get ()) < 0)
+ return NULL;
/* A field can have a NULL type in some situations. */
if (TYPE_FIELD_TYPE (type, field) == NULL)
- {
- arg = Py_None;
- Py_INCREF (arg);
- }
+ arg = gdbpy_ref<>::new_reference (Py_None);
else
- arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
- if (!arg)
- goto fail;
- if (PyObject_SetAttrString (result, "type", arg) < 0)
- goto failarg;
+ arg.reset (type_to_type_object (TYPE_FIELD_TYPE (type, field)));
+ if (arg == NULL)
+ return NULL;
+ if (PyObject_SetAttrString (result.get (), "type", arg.get ()) < 0)
+ return NULL;
return result;
-
- failarg:
- Py_DECREF (arg);
- fail:
- Py_DECREF (result);
- return NULL;
}
-/* Return a sequence of all fields. Each field is a dictionary with
- some pre-defined keys. */
-static PyObject *
-typy_fields (PyObject *self, PyObject *args)
+/* Helper function to return the name of a field, as a gdb.Field object.
+ If the field doesn't have a name, None is returned. */
+
+static gdbpy_ref<>
+field_name (struct type *type, int field)
{
- PyObject *result;
- int i;
- struct type *type = ((type_object *) self)->type;
+ gdbpy_ref<> result;
- /* We would like to make a tuple here, make fields immutable, and
- then memoize the result (and perhaps make Field.type() lazy).
- However, that can lead to cycles. */
- result = PyList_New (0);
+ if (TYPE_FIELD_NAME (type, field))
+ result.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
+ else
+ result = gdbpy_ref<>::new_reference (Py_None);
- for (i = 0; i < TYPE_NFIELDS (type); ++i)
+ return result;
+}
+
+/* Helper function for Type standard mapping methods. Returns a
+ Python object for field i of the type. "kind" specifies what to
+ return: the name of the field, a gdb.Field object corresponding to
+ the field, or a tuple consisting of field name and gdb.Field
+ object. */
+
+static gdbpy_ref<>
+make_fielditem (struct type *type, int i, enum gdbpy_iter_kind kind)
+{
+ switch (kind)
{
- PyObject *dict = convert_field (type, i);
- if (!dict)
- {
- Py_DECREF (result);
+ case iter_items:
+ {
+ gdbpy_ref<> key (field_name (type, i));
+ if (key == NULL)
return NULL;
- }
- if (PyList_Append (result, dict))
- {
- Py_DECREF (dict);
- Py_DECREF (result);
+ gdbpy_ref<> value = convert_field (type, i);
+ if (value == NULL)
return NULL;
- }
+ gdbpy_ref<> item (PyTuple_New (2));
+ if (item == NULL)
+ return NULL;
+ PyTuple_SET_ITEM (item.get (), 0, key.release ());
+ PyTuple_SET_ITEM (item.get (), 1, value.release ());
+ return item;
+ }
+ case iter_keys:
+ return field_name (type, i);
+ case iter_values:
+ return convert_field (type, i);
}
+ gdb_assert_not_reached ("invalid gdbpy_iter_kind");
+}
- return result;
+/* Return a sequence of all field names, fields, or (name, field) pairs.
+ Each field is a gdb.Field object. */
+
+static PyObject *
+typy_fields_items (PyObject *self, enum gdbpy_iter_kind kind)
+{
+ PyObject *py_type = self;
+ struct type *type = ((type_object *) py_type)->type;
+ struct type *checked_type = type;
+
+ TRY
+ {
+ checked_type = check_typedef (checked_type);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ gdbpy_ref<> type_holder;
+ if (checked_type != type)
+ {
+ type_holder.reset (type_to_type_object (checked_type));
+ if (type_holder == nullptr)
+ return nullptr;
+ py_type = type_holder.get ();
+ }
+ gdbpy_ref<> iter (typy_make_iter (py_type, kind));
+ if (iter == nullptr)
+ return nullptr;
+
+ return PySequence_List (iter.get ());
+}
+
+/* Return a sequence of all fields. Each field is a gdb.Field object. */
+
+static PyObject *
+typy_values (PyObject *self, PyObject *args)
+{
+ return typy_fields_items (self, iter_values);
+}
+
+/* Return a sequence of all fields. Each field is a gdb.Field object.
+ This method is similar to typy_values, except where the supplied
+ gdb.Type is an array, in which case it returns a list of one entry
+ which is a gdb.Field object for a range (the array bounds). */
+
+static PyObject *
+typy_fields (PyObject *self, PyObject *args)
+{
+ struct type *type = ((type_object *) self)->type;
+
+ if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ return typy_fields_items (self, iter_values);
+
+ /* Array type. Handle this as a special case because the common
+ machinery wants struct or union or enum types. Build a list of
+ one entry which is the range for the array. */
+ gdbpy_ref<> r = convert_field (type, 0);
+ if (r == NULL)
+ return NULL;
+
+ return Py_BuildValue ("[O]", r.get ());
+}
+
+/* Return a sequence of all field names. Each field is a gdb.Field object. */
+
+static PyObject *
+typy_field_names (PyObject *self, PyObject *args)
+{
+ return typy_fields_items (self, iter_keys);
+}
+
+/* Return a sequence of all (name, fields) pairs. Each field is a
+ gdb.Field object. */
+
+static PyObject *
+typy_items (PyObject *self, PyObject *args)
+{
+ return typy_fields_items (self, iter_items);
+}
+
+/* Return the type's name, or None. */
+
+static PyObject *
+typy_get_name (PyObject *self, void *closure)
+{
+ struct type *type = ((type_object *) self)->type;
+
+ if (TYPE_NAME (type) == NULL)
+ Py_RETURN_NONE;
+ return PyString_FromString (TYPE_NAME (type));
}
/* Return the type's tag, or None. */
typy_get_tag (PyObject *self, void *closure)
{
struct type *type = ((type_object *) self)->type;
- if (!TYPE_TAG_NAME (type))
+ const char *tagname = nullptr;
+
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION
+ || TYPE_CODE (type) == TYPE_CODE_ENUM)
+ tagname = TYPE_NAME (type);
+
+ if (tagname == nullptr)
Py_RETURN_NONE;
- return PyString_FromString (TYPE_TAG_NAME (type));
+ return PyString_FromString (tagname);
}
/* Return the type, stripped of typedefs. */
{
struct type *type = ((type_object *) self)->type;
- return type_to_type_object (check_typedef (type));
+ TRY
+ {
+ type = check_typedef (type);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ return type_to_type_object (type);
+}
+
+/* Strip typedefs and pointers/reference from a type. Then check that
+ it is a struct, union, or enum type. If not, raise TypeError. */
+
+static struct type *
+typy_get_composite (struct type *type)
+{
+
+ for (;;)
+ {
+ TRY
+ {
+ type = check_typedef (type);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
+ break;
+ type = TYPE_TARGET_TYPE (type);
+ }
+
+ /* If this is not a struct, union, or enum type, raise TypeError
+ exception. */
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION
+ && TYPE_CODE (type) != TYPE_CODE_ENUM
+ && TYPE_CODE (type) != TYPE_CODE_FUNC)
+ {
+ PyErr_SetString (PyExc_TypeError,
+ "Type is not a structure, union, enum, or function type.");
+ return NULL;
+ }
+
+ return type;
+}
+
+/* Helper for typy_array and typy_vector. */
+
+static PyObject *
+typy_array_1 (PyObject *self, PyObject *args, int is_vector)
+{
+ long n1, n2;
+ PyObject *n2_obj = NULL;
+ struct type *array = NULL;
+ struct type *type = ((type_object *) self)->type;
+
+ if (! PyArg_ParseTuple (args, "l|O", &n1, &n2_obj))
+ return NULL;
+
+ if (n2_obj)
+ {
+ if (!PyInt_Check (n2_obj))
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Array bound must be an integer"));
+ return NULL;
+ }
+
+ if (! gdb_py_int_as_long (n2_obj, &n2))
+ return NULL;
+ }
+ else
+ {
+ n2 = n1;
+ n1 = 0;
+ }
+
+ if (n2 < n1 - 1) /* Note: An empty array has n2 == n1 - 1. */
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("Array length must not be negative"));
+ return NULL;
+ }
+
+ TRY
+ {
+ array = lookup_array_range_type (type, n1, n2);
+ if (is_vector)
+ make_vector_type (array);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ return type_to_type_object (array);
+}
+
+/* Return an array type. */
+
+static PyObject *
+typy_array (PyObject *self, PyObject *args)
+{
+ return typy_array_1 (self, args, 0);
+}
+
+/* Return a vector type. */
+
+static PyObject *
+typy_vector (PyObject *self, PyObject *args)
+{
+ return typy_array_1 (self, args, 1);
}
/* Return a Type object which represents a pointer to SELF. */
typy_pointer (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = lookup_pointer_type (type);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_range (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- PyObject *result;
- PyObject *low_bound = NULL, *high_bound = NULL;
/* Initialize these to appease GCC warnings. */
LONGEST low = 0, high = 0;
&& TYPE_CODE (type) != TYPE_CODE_RANGE)
{
PyErr_SetString (PyExc_RuntimeError,
- "This type does not have a range.");
+ _("This type does not have a range."));
return NULL;
}
break;
}
- low_bound = PyLong_FromLong (low);
- if (!low_bound)
- goto failarg;
+ gdbpy_ref<> low_bound (PyLong_FromLong (low));
+ if (low_bound == NULL)
+ return NULL;
- high_bound = PyLong_FromLong (high);
- if (!high_bound)
- goto failarg;
+ gdbpy_ref<> high_bound (PyLong_FromLong (high));
+ if (high_bound == NULL)
+ return NULL;
- result = PyTuple_New (2);
- if (!result)
- goto failarg;
+ gdbpy_ref<> result (PyTuple_New (2));
+ if (result == NULL)
+ return NULL;
- if (PyTuple_SetItem (result, 0, low_bound) != 0)
- {
- Py_DECREF (result);
- goto failarg;
- }
- if (PyTuple_SetItem (result, 1, high_bound) != 0)
- {
- Py_DECREF (high_bound);
- Py_DECREF (result);
- return NULL;
- }
- return result;
-
- failarg:
- Py_XDECREF (high_bound);
- Py_XDECREF (low_bound);
- return NULL;
+ if (PyTuple_SetItem (result.get (), 0, low_bound.release ()) != 0
+ || PyTuple_SetItem (result.get (), 1, high_bound.release ()) != 0)
+ return NULL;
+ return result.release ();
}
/* Return a Type object which represents a reference to SELF. */
typy_reference (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
- type = lookup_reference_type (type);
+ type = lookup_lvalue_reference_type (type);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
if (!TYPE_TARGET_TYPE (type))
{
- PyErr_SetString (PyExc_RuntimeError, "type does not have a target");
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Type does not have a target."));
return NULL;
}
typy_const (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = make_cv_type (1, 0, type, NULL);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_volatile (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = make_cv_type (0, 1, type, NULL);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_unqualified (PyObject *self, PyObject *args)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
type = make_cv_type (0, 0, type, NULL);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return type_to_type_object (type);
}
typy_get_sizeof (PyObject *self, void *closure)
{
struct type *type = ((type_object *) self)->type;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
check_typedef (type);
}
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ }
+ END_CATCH
+
+ /* Ignore exceptions. */
+
+ return gdb_py_long_from_longest (TYPE_LENGTH (type));
+}
+
+/* Return the alignment of the type represented by SELF, in bytes. */
+static PyObject *
+typy_get_alignof (PyObject *self, void *closure)
+{
+ struct type *type = ((type_object *) self)->type;
+
+ ULONGEST align = 0;
+ TRY
+ {
+ align = type_align (type);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ align = 0;
+ }
+ END_CATCH
+
/* Ignore exceptions. */
- return PyLong_FromLong (TYPE_LENGTH (type));
+ return gdb_py_object_from_ulongest (align).release ();
}
static struct type *
-typy_lookup_typename (char *type_name)
+typy_lookup_typename (const char *type_name, const struct block *block)
{
struct type *type = NULL;
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ALL)
+
+ TRY
{
- if (!strncmp (type_name, "struct ", 7))
+ if (startswith (type_name, "struct "))
type = lookup_struct (type_name + 7, NULL);
- else if (!strncmp (type_name, "union ", 6))
+ else if (startswith (type_name, "union "))
type = lookup_union (type_name + 6, NULL);
- else if (!strncmp (type_name, "enum ", 5))
+ else if (startswith (type_name, "enum "))
type = lookup_enum (type_name + 5, NULL);
else
type = lookup_typename (python_language, python_gdbarch,
- type_name, NULL, 0);
+ type_name, block, 0);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
- PyErr_Format (except.reason == RETURN_QUIT
- ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
- "%s", except.message);
- return NULL;
+ GDB_PY_HANDLE_EXCEPTION (except);
}
+ END_CATCH
return type;
}
static struct type *
-typy_lookup_type (struct demangle_component *demangled)
+typy_lookup_type (struct demangle_component *demangled,
+ const struct block *block)
{
- struct type *type;
- char *type_name;
+ struct type *type, *rtype = NULL;
enum demangle_component_type demangled_type;
/* Save the type: typy_lookup_type() may (indirectly) overwrite
if (demangled_type == DEMANGLE_COMPONENT_POINTER
|| demangled_type == DEMANGLE_COMPONENT_REFERENCE
+ || demangled_type == DEMANGLE_COMPONENT_RVALUE_REFERENCE
|| demangled_type == DEMANGLE_COMPONENT_CONST
|| demangled_type == DEMANGLE_COMPONENT_VOLATILE)
{
- type = typy_lookup_type (demangled->u.s_binary.left);
+ type = typy_lookup_type (demangled->u.s_binary.left, block);
if (! type)
return NULL;
- switch (demangled_type)
+ TRY
+ {
+ /* If the demangled_type matches with one of the types
+ below, run the corresponding function and save the type
+ to return later. We cannot just return here as we are in
+ an exception handler. */
+ switch (demangled_type)
+ {
+ case DEMANGLE_COMPONENT_REFERENCE:
+ rtype = lookup_lvalue_reference_type (type);
+ break;
+ case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
+ rtype = lookup_rvalue_reference_type (type);
+ break;
+ case DEMANGLE_COMPONENT_POINTER:
+ rtype = lookup_pointer_type (type);
+ break;
+ case DEMANGLE_COMPONENT_CONST:
+ rtype = make_cv_type (1, 0, type, NULL);
+ break;
+ case DEMANGLE_COMPONENT_VOLATILE:
+ rtype = make_cv_type (0, 1, type, NULL);
+ break;
+ }
+ }
+ CATCH (except, RETURN_MASK_ALL)
{
- case DEMANGLE_COMPONENT_REFERENCE:
- return lookup_reference_type (type);
- case DEMANGLE_COMPONENT_POINTER:
- return lookup_pointer_type (type);
- case DEMANGLE_COMPONENT_CONST:
- return make_cv_type (1, 0, type, NULL);
- case DEMANGLE_COMPONENT_VOLATILE:
- return make_cv_type (0, 1, type, NULL);
+ GDB_PY_HANDLE_EXCEPTION (except);
}
+ END_CATCH
}
- type_name = cp_comp_to_string (demangled, 10);
- type = typy_lookup_typename (type_name);
- xfree (type_name);
+ /* If we have a type from the switch statement above, just return
+ that. */
+ if (rtype)
+ return rtype;
- return type;
+ /* We don't have a type, so lookup the type. */
+ gdb::unique_xmalloc_ptr<char> type_name = cp_comp_to_string (demangled, 10);
+ return typy_lookup_typename (type_name.get (), block);
}
+/* This is a helper function for typy_template_argument that is used
+ when the type does not have template symbols attached. It works by
+ parsing the type name. This happens with compilers, like older
+ versions of GCC, that do not emit DW_TAG_template_*. */
+
static PyObject *
-typy_template_argument (PyObject *self, PyObject *args)
+typy_legacy_template_argument (struct type *type, const struct block *block,
+ int argno)
{
- int i, argno, n_pointers;
- struct type *type = ((type_object *) self)->type;
+ int i;
struct demangle_component *demangled;
- const char *err;
+ std::unique_ptr<demangle_parse_info> info;
+ std::string err;
struct type *argtype;
- if (! PyArg_ParseTuple (args, "i", &argno))
- return NULL;
-
- type = check_typedef (type);
- if (TYPE_CODE (type) == TYPE_CODE_REF)
- type = check_typedef (TYPE_TARGET_TYPE (type));
-
if (TYPE_NAME (type) == NULL)
{
- PyErr_SetString (PyExc_RuntimeError, "null type name");
+ PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
return NULL;
}
- /* Note -- this is not thread-safe. */
- demangled = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
- if (! demangled)
+ TRY
+ {
+ /* Note -- this is not thread-safe. */
+ info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ if (! info)
{
- PyErr_SetString (PyExc_RuntimeError, err);
+ PyErr_SetString (PyExc_RuntimeError, err.c_str ());
return NULL;
}
+ demangled = info->tree;
/* Strip off component names. */
while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
{
- PyErr_SetString (PyExc_RuntimeError, "type is not a template");
+ PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
return NULL;
}
if (! demangled)
{
- PyErr_Format (PyExc_RuntimeError, "no argument %d in template",
+ PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
argno);
return NULL;
}
- argtype = typy_lookup_type (demangled->u.s_binary.left);
+ argtype = typy_lookup_type (demangled->u.s_binary.left, block);
if (! argtype)
return NULL;
}
static PyObject *
-typy_str (PyObject *self)
+typy_template_argument (PyObject *self, PyObject *args)
{
- volatile struct gdb_exception except;
- char *thetype = NULL;
- long length = 0;
- PyObject *result;
+ int argno;
+ struct type *type = ((type_object *) self)->type;
+ const struct block *block = NULL;
+ PyObject *block_obj = NULL;
+ struct symbol *sym;
+ struct value *val = NULL;
+
+ if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
+ return NULL;
+
+ if (argno < 0)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Template argument number must be non-negative"));
+ return NULL;
+ }
+
+ if (block_obj)
+ {
+ block = block_object_to_block (block_obj);
+ if (! block)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Second argument must be block."));
+ return NULL;
+ }
+ }
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
+ {
+ type = check_typedef (type);
+ if (TYPE_IS_REFERENCE (type))
+ type = check_typedef (TYPE_TARGET_TYPE (type));
+ }
+ CATCH (except, RETURN_MASK_ALL)
{
- struct cleanup *old_chain;
- struct ui_file *stb;
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
- stb = mem_fileopen ();
- old_chain = make_cleanup_ui_file_delete (stb);
+ /* We might not have DW_TAG_template_*, so try to parse the type's
+ name. This is inefficient if we do not have a template type --
+ but that is going to wind up as an error anyhow. */
+ if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
+ return typy_legacy_template_argument (type, block, argno);
- type_print (type_object_to_type (self), "", stb, -1);
+ if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
+ {
+ PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
+ argno);
+ return NULL;
+ }
- thetype = ui_file_xstrdup (stb, &length);
- do_cleanups (old_chain);
+ sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
+ if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ return type_to_type_object (SYMBOL_TYPE (sym));
+ else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
+ {
+ PyErr_Format (PyExc_RuntimeError,
+ _("Template argument is optimized out"));
+ return NULL;
+ }
+
+ TRY
+ {
+ val = value_of_variable (sym, block);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
- xfree (thetype);
GDB_PY_HANDLE_EXCEPTION (except);
}
+ END_CATCH
- result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
- xfree (thetype);
+ return value_to_value_object (val);
+}
- return result;
+static PyObject *
+typy_str (PyObject *self)
+{
+ string_file thetype;
+
+ TRY
+ {
+ LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
+ &type_print_raw_options);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ return PyUnicode_Decode (thetype.c_str (), thetype.size (),
+ host_charset (), NULL);
+}
+
+/* Implement the richcompare method. */
+
+static PyObject *
+typy_richcompare (PyObject *self, PyObject *other, int op)
+{
+ bool result = false;
+ struct type *type1 = type_object_to_type (self);
+ struct type *type2 = type_object_to_type (other);
+
+ /* We can only compare ourselves to another Type object, and only
+ for equality or inequality. */
+ if (type2 == NULL || (op != Py_EQ && op != Py_NE))
+ {
+ Py_INCREF (Py_NotImplemented);
+ return Py_NotImplemented;
+ }
+
+ if (type1 == type2)
+ result = true;
+ else
+ {
+ TRY
+ {
+ result = types_deeply_equal (type1, type2);
+ }
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ /* If there is a GDB exception, a comparison is not capable
+ (or trusted), so exit. */
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+ }
+
+ if (op == (result ? Py_EQ : Py_NE))
+ Py_RETURN_TRUE;
+ Py_RETURN_FALSE;
}
\f
static void
save_objfile_types (struct objfile *objfile, void *datum)
{
- type_object *obj = datum;
+ type_object *obj = (type_object *) datum;
htab_t copied_types;
- struct cleanup *cleanup;
+
+ if (!gdb_python_initialized)
+ return;
/* This prevents another thread from freeing the objects we're
operating on. */
- cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
+ gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
copied_types = create_copied_types_hash (objfile);
}
htab_delete (copied_types);
-
- do_cleanups (cleanup);
}
static void
{
struct objfile *objfile = TYPE_OBJFILE (type);
- obj->next = objfile_data (objfile, typy_objfile_data_key);
+ obj->next = ((struct pyty_type_object *)
+ objfile_data (objfile, typy_objfile_data_key));
if (obj->next)
obj->next->prev = obj;
set_objfile_data (objfile, typy_objfile_data_key, obj);
{
/* Must reset head of list. */
struct objfile *objfile = TYPE_OBJFILE (type->type);
+
if (objfile)
set_objfile_data (objfile, typy_objfile_data_key, type->next);
}
if (type->next)
type->next->prev = type->prev;
- type->ob_type->tp_free (type);
+ Py_TYPE (type)->tp_free (type);
+}
+
+/* Return number of fields ("length" of the field dictionary). */
+
+static Py_ssize_t
+typy_length (PyObject *self)
+{
+ struct type *type = ((type_object *) self)->type;
+
+ type = typy_get_composite (type);
+ if (type == NULL)
+ return -1;
+
+ return TYPE_NFIELDS (type);
+}
+
+/* Implements boolean evaluation of gdb.Type. Handle this like other
+ Python objects that don't have a meaningful truth value -- all
+ values are true. */
+
+static int
+typy_nonzero (PyObject *self)
+{
+ return 1;
+}
+
+/* Return optimized out value of this type. */
+
+static PyObject *
+typy_optimized_out (PyObject *self, PyObject *args)
+{
+ struct type *type = ((type_object *) self)->type;
+
+ return value_to_value_object (allocate_optimized_out_value (type));
+}
+
+/* Return a gdb.Field object for the field named by the argument. */
+
+static PyObject *
+typy_getitem (PyObject *self, PyObject *key)
+{
+ struct type *type = ((type_object *) self)->type;
+ int i;
+
+ gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
+ if (field == NULL)
+ return NULL;
+
+ /* We want just fields of this type, not of base types, so instead of
+ using lookup_struct_elt_type, portions of that function are
+ copied here. */
+
+ type = typy_get_composite (type);
+ if (type == NULL)
+ return NULL;
+
+ for (i = 0; i < TYPE_NFIELDS (type); i++)
+ {
+ const char *t_field_name = TYPE_FIELD_NAME (type, i);
+
+ if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
+ return convert_field (type, i).release ();
+ }
+ PyErr_SetObject (PyExc_KeyError, key);
+ return NULL;
+}
+
+/* Implement the "get" method on the type object. This is the
+ same as getitem if the key is present, but returns the supplied
+ default value or None if the key is not found. */
+
+static PyObject *
+typy_get (PyObject *self, PyObject *args)
+{
+ PyObject *key, *defval = Py_None, *result;
+
+ if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
+ return NULL;
+
+ result = typy_getitem (self, key);
+ if (result != NULL)
+ return result;
+
+ /* typy_getitem returned error status. If the exception is
+ KeyError, clear the exception status and return the defval
+ instead. Otherwise return the exception unchanged. */
+ if (!PyErr_ExceptionMatches (PyExc_KeyError))
+ return NULL;
+
+ PyErr_Clear ();
+ Py_INCREF (defval);
+ return defval;
+}
+
+/* Implement the "has_key" method on the type object. */
+
+static PyObject *
+typy_has_key (PyObject *self, PyObject *args)
+{
+ struct type *type = ((type_object *) self)->type;
+ const char *field;
+ int i;
+
+ if (!PyArg_ParseTuple (args, "s", &field))
+ return NULL;
+
+ /* We want just fields of this type, not of base types, so instead of
+ using lookup_struct_elt_type, portions of that function are
+ copied here. */
+
+ type = typy_get_composite (type);
+ if (type == NULL)
+ return NULL;
+
+ for (i = 0; i < TYPE_NFIELDS (type); i++)
+ {
+ const char *t_field_name = TYPE_FIELD_NAME (type, i);
+
+ if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
+ Py_RETURN_TRUE;
+ }
+ Py_RETURN_FALSE;
+}
+
+/* Make an iterator object to iterate over keys, values, or items. */
+
+static PyObject *
+typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind)
+{
+ typy_iterator_object *typy_iter_obj;
+
+ /* Check that "self" is a structure or union type. */
+ if (typy_get_composite (((type_object *) self)->type) == NULL)
+ return NULL;
+
+ typy_iter_obj = PyObject_New (typy_iterator_object,
+ &type_iterator_object_type);
+ if (typy_iter_obj == NULL)
+ return NULL;
+
+ typy_iter_obj->field = 0;
+ typy_iter_obj->kind = kind;
+ Py_INCREF (self);
+ typy_iter_obj->source = (type_object *) self;
+
+ return (PyObject *) typy_iter_obj;
+}
+
+/* iteritems() method. */
+
+static PyObject *
+typy_iteritems (PyObject *self, PyObject *args)
+{
+ return typy_make_iter (self, iter_items);
+}
+
+/* iterkeys() method. */
+
+static PyObject *
+typy_iterkeys (PyObject *self, PyObject *args)
+{
+ return typy_make_iter (self, iter_keys);
+}
+
+/* Iterating over the class, same as iterkeys except for the function
+ signature. */
+
+static PyObject *
+typy_iter (PyObject *self)
+{
+ return typy_make_iter (self, iter_keys);
+}
+
+/* itervalues() method. */
+
+static PyObject *
+typy_itervalues (PyObject *self, PyObject *args)
+{
+ return typy_make_iter (self, iter_values);
+}
+
+/* Return a reference to the type iterator. */
+
+static PyObject *
+typy_iterator_iter (PyObject *self)
+{
+ Py_INCREF (self);
+ return self;
+}
+
+/* Return the next field in the iteration through the list of fields
+ of the type. */
+
+static PyObject *
+typy_iterator_iternext (PyObject *self)
+{
+ typy_iterator_object *iter_obj = (typy_iterator_object *) self;
+ struct type *type = iter_obj->source->type;
+
+ if (iter_obj->field < TYPE_NFIELDS (type))
+ {
+ gdbpy_ref<> result = make_fielditem (type, iter_obj->field,
+ iter_obj->kind);
+ if (result != NULL)
+ iter_obj->field++;
+ return result.release ();
+ }
+
+ return NULL;
+}
+
+static void
+typy_iterator_dealloc (PyObject *obj)
+{
+ typy_iterator_object *iter_obj = (typy_iterator_object *) obj;
+
+ Py_DECREF (iter_obj->source);
}
/* Create a new Type referring to TYPE. */
PyObject *
gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
{
- static char *keywords[] = { "name", NULL };
- char *type_name = NULL;
+ static const char *keywords[] = { "name", "block", NULL };
+ const char *type_name = NULL;
struct type *type = NULL;
+ PyObject *block_obj = NULL;
+ const struct block *block = NULL;
- if (! PyArg_ParseTupleAndKeywords (args, kw, "s", keywords, &type_name))
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
+ &type_name, &block_obj))
return NULL;
- type = typy_lookup_typename (type_name);
+ if (block_obj)
+ {
+ block = block_object_to_block (block_obj);
+ if (! block)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("'block' argument must be a Block."));
+ return NULL;
+ }
+ }
+
+ type = typy_lookup_typename (type_name, block);
if (! type)
return NULL;
- return (PyObject *) type_to_type_object (type);
+ return type_to_type_object (type);
}
-void
+int
gdbpy_initialize_types (void)
{
int i;
= register_objfile_data_with_cleanup (save_objfile_types, NULL);
if (PyType_Ready (&type_object_type) < 0)
- return;
+ return -1;
if (PyType_Ready (&field_object_type) < 0)
- return;
+ return -1;
+ if (PyType_Ready (&type_iterator_object_type) < 0)
+ return -1;
for (i = 0; pyty_codes[i].name; ++i)
{
/* Cast needed for Python 2.4. */
(char *) pyty_codes[i].name,
pyty_codes[i].code) < 0)
- return;
+ return -1;
}
- Py_INCREF (&type_object_type);
- PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
+ if (gdb_pymodule_addobject (gdb_module, "Type",
+ (PyObject *) &type_object_type) < 0)
+ return -1;
- Py_INCREF (&field_object_type);
- PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
+ if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
+ (PyObject *) &type_iterator_object_type) < 0)
+ return -1;
+
+ return gdb_pymodule_addobject (gdb_module, "Field",
+ (PyObject *) &field_object_type);
}
\f
-static PyGetSetDef type_object_getset[] =
+static gdb_PyGetSetDef type_object_getset[] =
{
+ { "alignof", typy_get_alignof, NULL,
+ "The alignment of this type, in bytes.", NULL },
{ "code", typy_get_code, NULL,
"The code for this type.", NULL },
+ { "name", typy_get_name, NULL,
+ "The name for this type, or None.", NULL },
{ "sizeof", typy_get_sizeof, NULL,
"The size of this type, in bytes.", NULL },
{ "tag", typy_get_tag, NULL,
static PyMethodDef type_object_methods[] =
{
+ { "array", typy_array, METH_VARARGS,
+ "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
+Return a type which represents an array of objects of this type.\n\
+The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
+If LOW_BOUND is omitted, a value of zero is used." },
+ { "vector", typy_vector, METH_VARARGS,
+ "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
+Return a type which represents a vector of objects of this type.\n\
+The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
+If LOW_BOUND is omitted, a value of zero is used.\n\
+Vectors differ from arrays in that if the current language has C-style\n\
+arrays, vectors don't decay to a pointer to the first element.\n\
+They are first class values." },
+ { "__contains__", typy_has_key, METH_VARARGS,
+ "T.__contains__(k) -> True if T has a field named k, else False" },
{ "const", typy_const, METH_NOARGS,
"const () -> Type\n\
Return a const variant of this type." },
+ { "optimized_out", typy_optimized_out, METH_NOARGS,
+ "optimized_out() -> Value\n\
+Return optimized out value of this type." },
{ "fields", typy_fields, METH_NOARGS,
- "field () -> list\n\
-Return a sequence holding all the fields of this type.\n\
-Each field is a dictionary." },
+ "fields () -> list\n\
+Return a list holding all the fields of this type.\n\
+Each field is a gdb.Field object." },
+ { "get", typy_get, METH_VARARGS,
+ "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
+otherwise returns default, if supplied, or None if not." },
+ { "has_key", typy_has_key, METH_VARARGS,
+ "T.has_key(k) -> True if T has a field named k, else False" },
+ { "items", typy_items, METH_NOARGS,
+ "items () -> list\n\
+Return a list of (name, field) pairs of this type.\n\
+Each field is a gdb.Field object." },
+ { "iteritems", typy_iteritems, METH_NOARGS,
+ "iteritems () -> an iterator over the (name, field)\n\
+pairs of this type. Each field is a gdb.Field object." },
+ { "iterkeys", typy_iterkeys, METH_NOARGS,
+ "iterkeys () -> an iterator over the field names of this type." },
+ { "itervalues", typy_itervalues, METH_NOARGS,
+ "itervalues () -> an iterator over the fields of this type.\n\
+Each field is a gdb.Field object." },
+ { "keys", typy_field_names, METH_NOARGS,
+ "keys () -> list\n\
+Return a list holding all the fields names of this type." },
{ "pointer", typy_pointer, METH_NOARGS,
"pointer () -> Type\n\
Return a type of pointer to this type." },
"target () -> Type\n\
Return the target type of this type." },
{ "template_argument", typy_template_argument, METH_VARARGS,
- "template_argument (arg) -> Type\n\
+ "template_argument (arg, [block]) -> Type\n\
Return the type of a template argument." },
{ "unqualified", typy_unqualified, METH_NOARGS,
"unqualified () -> Type\n\
Return a variant of this type without const or volatile attributes." },
+ { "values", typy_values, METH_NOARGS,
+ "values () -> list\n\
+Return a list holding all the fields of this type.\n\
+Each field is a gdb.Field object." },
{ "volatile", typy_volatile, METH_NOARGS,
"volatile () -> Type\n\
Return a volatile variant of this type" },
{ NULL }
};
-static PyTypeObject type_object_type =
+static PyNumberMethods type_object_as_number = {
+ NULL, /* nb_add */
+ NULL, /* nb_subtract */
+ NULL, /* nb_multiply */
+#ifndef IS_PY3K
+ NULL, /* nb_divide */
+#endif
+ NULL, /* nb_remainder */
+ NULL, /* nb_divmod */
+ NULL, /* nb_power */
+ NULL, /* nb_negative */
+ NULL, /* nb_positive */
+ NULL, /* nb_absolute */
+ typy_nonzero, /* nb_nonzero */
+ NULL, /* nb_invert */
+ NULL, /* nb_lshift */
+ NULL, /* nb_rshift */
+ NULL, /* nb_and */
+ NULL, /* nb_xor */
+ NULL, /* nb_or */
+#ifdef IS_PY3K
+ NULL, /* nb_int */
+ NULL, /* reserved */
+#else
+ NULL, /* nb_coerce */
+ NULL, /* nb_int */
+ NULL, /* nb_long */
+#endif
+ NULL, /* nb_float */
+#ifndef IS_PY3K
+ NULL, /* nb_oct */
+ NULL /* nb_hex */
+#endif
+};
+
+static PyMappingMethods typy_mapping = {
+ typy_length,
+ typy_getitem,
+ NULL /* no "set" method */
+};
+
+PyTypeObject type_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Type", /*tp_name*/
sizeof (type_object), /*tp_basicsize*/
0, /*tp_itemsize*/
0, /*tp_setattr*/
0, /*tp_compare*/
0, /*tp_repr*/
- 0, /*tp_as_number*/
+ &type_object_as_number, /*tp_as_number*/
0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
+ &typy_mapping, /*tp_as_mapping*/
0, /*tp_hash */
0, /*tp_call*/
typy_str, /*tp_str*/
"GDB type object", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
- 0, /* tp_richcompare */
+ typy_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
- 0, /* tp_iter */
+ typy_iter, /* tp_iter */
0, /* tp_iternext */
type_object_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_new */
};
-static PyTypeObject field_object_type =
+static gdb_PyGetSetDef field_object_getset[] =
+{
+ { "__dict__", gdb_py_generic_dict, NULL,
+ "The __dict__ for this field.", &field_object_type },
+ { NULL }
+};
+
+PyTypeObject field_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Field", /*tp_name*/
sizeof (field_object), /*tp_basicsize*/
0, /*tp_itemsize*/
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
- 0, /* tp_getset */
+ field_object_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_alloc */
0, /* tp_new */
};
+
+PyTypeObject type_iterator_object_type = {
+ PyVarObject_HEAD_INIT (NULL, 0)
+ "gdb.TypeIterator", /*tp_name*/
+ sizeof (typy_iterator_object), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ typy_iterator_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash */
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
+ "GDB type iterator object", /*tp_doc */
+ 0, /*tp_traverse */
+ 0, /*tp_clear */
+ 0, /*tp_richcompare */
+ 0, /*tp_weaklistoffset */
+ typy_iterator_iter, /*tp_iter */
+ typy_iterator_iternext, /*tp_iternext */
+ 0 /*tp_methods */
+};