/* Python interface to types.
|
/* Python interface to types.
|
|
|
Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
|
Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "value.h"
|
#include "value.h"
|
#include "exceptions.h"
|
#include "exceptions.h"
|
#include "python-internal.h"
|
#include "python-internal.h"
|
#include "charset.h"
|
#include "charset.h"
|
#include "gdbtypes.h"
|
#include "gdbtypes.h"
|
#include "cp-support.h"
|
#include "cp-support.h"
|
#include "demangle.h"
|
#include "demangle.h"
|
#include "objfiles.h"
|
#include "objfiles.h"
|
#include "language.h"
|
#include "language.h"
|
|
|
typedef struct pyty_type_object
|
typedef struct pyty_type_object
|
{
|
{
|
PyObject_HEAD
|
PyObject_HEAD
|
struct type *type;
|
struct type *type;
|
|
|
/* If a Type object is associated with an objfile, it is kept on a
|
/* If a Type object is associated with an objfile, it is kept on a
|
doubly-linked list, rooted in the objfile. This lets us copy the
|
doubly-linked list, rooted in the objfile. This lets us copy the
|
underlying struct type when the objfile is deleted. */
|
underlying struct type when the objfile is deleted. */
|
struct pyty_type_object *prev;
|
struct pyty_type_object *prev;
|
struct pyty_type_object *next;
|
struct pyty_type_object *next;
|
} type_object;
|
} type_object;
|
|
|
static PyTypeObject type_object_type;
|
static PyTypeObject type_object_type;
|
|
|
/* A Field object. */
|
/* A Field object. */
|
typedef struct pyty_field_object
|
typedef struct pyty_field_object
|
{
|
{
|
PyObject_HEAD
|
PyObject_HEAD
|
|
|
/* Dictionary holding our attributes. */
|
/* Dictionary holding our attributes. */
|
PyObject *dict;
|
PyObject *dict;
|
} field_object;
|
} field_object;
|
|
|
static PyTypeObject field_object_type;
|
static PyTypeObject field_object_type;
|
|
|
/* This is used to initialize various gdb.TYPE_ constants. */
|
/* This is used to initialize various gdb.TYPE_ constants. */
|
struct pyty_code
|
struct pyty_code
|
{
|
{
|
/* The code. */
|
/* The code. */
|
enum type_code code;
|
enum type_code code;
|
/* The name. */
|
/* The name. */
|
const char *name;
|
const char *name;
|
};
|
};
|
|
|
#define ENTRY(X) { X, #X }
|
#define ENTRY(X) { X, #X }
|
|
|
static struct pyty_code pyty_codes[] =
|
static struct pyty_code pyty_codes[] =
|
{
|
{
|
ENTRY (TYPE_CODE_PTR),
|
ENTRY (TYPE_CODE_PTR),
|
ENTRY (TYPE_CODE_ARRAY),
|
ENTRY (TYPE_CODE_ARRAY),
|
ENTRY (TYPE_CODE_STRUCT),
|
ENTRY (TYPE_CODE_STRUCT),
|
ENTRY (TYPE_CODE_UNION),
|
ENTRY (TYPE_CODE_UNION),
|
ENTRY (TYPE_CODE_ENUM),
|
ENTRY (TYPE_CODE_ENUM),
|
ENTRY (TYPE_CODE_FLAGS),
|
ENTRY (TYPE_CODE_FLAGS),
|
ENTRY (TYPE_CODE_FUNC),
|
ENTRY (TYPE_CODE_FUNC),
|
ENTRY (TYPE_CODE_INT),
|
ENTRY (TYPE_CODE_INT),
|
ENTRY (TYPE_CODE_FLT),
|
ENTRY (TYPE_CODE_FLT),
|
ENTRY (TYPE_CODE_VOID),
|
ENTRY (TYPE_CODE_VOID),
|
ENTRY (TYPE_CODE_SET),
|
ENTRY (TYPE_CODE_SET),
|
ENTRY (TYPE_CODE_RANGE),
|
ENTRY (TYPE_CODE_RANGE),
|
ENTRY (TYPE_CODE_STRING),
|
ENTRY (TYPE_CODE_STRING),
|
ENTRY (TYPE_CODE_BITSTRING),
|
ENTRY (TYPE_CODE_BITSTRING),
|
ENTRY (TYPE_CODE_ERROR),
|
ENTRY (TYPE_CODE_ERROR),
|
ENTRY (TYPE_CODE_METHOD),
|
ENTRY (TYPE_CODE_METHOD),
|
ENTRY (TYPE_CODE_METHODPTR),
|
ENTRY (TYPE_CODE_METHODPTR),
|
ENTRY (TYPE_CODE_MEMBERPTR),
|
ENTRY (TYPE_CODE_MEMBERPTR),
|
ENTRY (TYPE_CODE_REF),
|
ENTRY (TYPE_CODE_REF),
|
ENTRY (TYPE_CODE_CHAR),
|
ENTRY (TYPE_CODE_CHAR),
|
ENTRY (TYPE_CODE_BOOL),
|
ENTRY (TYPE_CODE_BOOL),
|
ENTRY (TYPE_CODE_COMPLEX),
|
ENTRY (TYPE_CODE_COMPLEX),
|
ENTRY (TYPE_CODE_TYPEDEF),
|
ENTRY (TYPE_CODE_TYPEDEF),
|
ENTRY (TYPE_CODE_NAMESPACE),
|
ENTRY (TYPE_CODE_NAMESPACE),
|
ENTRY (TYPE_CODE_DECFLOAT),
|
ENTRY (TYPE_CODE_DECFLOAT),
|
ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
|
ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
|
{ TYPE_CODE_UNDEF, NULL }
|
{ TYPE_CODE_UNDEF, NULL }
|
};
|
};
|
|
|
|
|
|
|
static void
|
static void
|
field_dealloc (PyObject *obj)
|
field_dealloc (PyObject *obj)
|
{
|
{
|
field_object *f = (field_object *) obj;
|
field_object *f = (field_object *) obj;
|
Py_XDECREF (f->dict);
|
Py_XDECREF (f->dict);
|
f->ob_type->tp_free (obj);
|
f->ob_type->tp_free (obj);
|
}
|
}
|
|
|
static PyObject *
|
static PyObject *
|
field_new (void)
|
field_new (void)
|
{
|
{
|
field_object *result = PyObject_New (field_object, &field_object_type);
|
field_object *result = PyObject_New (field_object, &field_object_type);
|
if (result)
|
if (result)
|
{
|
{
|
result->dict = PyDict_New ();
|
result->dict = PyDict_New ();
|
if (!result->dict)
|
if (!result->dict)
|
{
|
{
|
Py_DECREF (result);
|
Py_DECREF (result);
|
result = NULL;
|
result = NULL;
|
}
|
}
|
}
|
}
|
return (PyObject *) result;
|
return (PyObject *) result;
|
}
|
}
|
|
|
|
|
|
|
/* Return the code for this type. */
|
/* Return the code for this type. */
|
static PyObject *
|
static PyObject *
|
typy_get_code (PyObject *self, void *closure)
|
typy_get_code (PyObject *self, void *closure)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
return PyInt_FromLong (TYPE_CODE (type));
|
return PyInt_FromLong (TYPE_CODE (type));
|
}
|
}
|
|
|
/* Helper function for typy_fields which converts a single field to a
|
/* Helper function for typy_fields which converts a single field to a
|
dictionary. Returns NULL on error. */
|
dictionary. Returns NULL on error. */
|
static PyObject *
|
static PyObject *
|
convert_field (struct type *type, int field)
|
convert_field (struct type *type, int field)
|
{
|
{
|
PyObject *result = field_new ();
|
PyObject *result = field_new ();
|
PyObject *arg;
|
PyObject *arg;
|
|
|
if (!result)
|
if (!result)
|
return NULL;
|
return NULL;
|
|
|
if (!field_is_static (&TYPE_FIELD (type, field)))
|
if (!field_is_static (&TYPE_FIELD (type, field)))
|
{
|
{
|
arg = PyLong_FromLong (TYPE_FIELD_BITPOS (type, field));
|
arg = PyLong_FromLong (TYPE_FIELD_BITPOS (type, field));
|
if (!arg)
|
if (!arg)
|
goto fail;
|
goto fail;
|
|
|
if (PyObject_SetAttrString (result, "bitpos", arg) < 0)
|
if (PyObject_SetAttrString (result, "bitpos", arg) < 0)
|
goto failarg;
|
goto failarg;
|
}
|
}
|
|
|
if (TYPE_FIELD_NAME (type, field))
|
if (TYPE_FIELD_NAME (type, field))
|
arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
|
arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
|
else
|
else
|
{
|
{
|
arg = Py_None;
|
arg = Py_None;
|
Py_INCREF (arg);
|
Py_INCREF (arg);
|
}
|
}
|
if (!arg)
|
if (!arg)
|
goto fail;
|
goto fail;
|
if (PyObject_SetAttrString (result, "name", arg) < 0)
|
if (PyObject_SetAttrString (result, "name", arg) < 0)
|
goto failarg;
|
goto failarg;
|
|
|
arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
|
arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
|
Py_INCREF (arg);
|
Py_INCREF (arg);
|
if (PyObject_SetAttrString (result, "artificial", arg) < 0)
|
if (PyObject_SetAttrString (result, "artificial", arg) < 0)
|
goto failarg;
|
goto failarg;
|
|
|
if (TYPE_CODE (type) == TYPE_CODE_CLASS)
|
if (TYPE_CODE (type) == TYPE_CODE_CLASS)
|
arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
|
arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
|
else
|
else
|
arg = Py_False;
|
arg = Py_False;
|
Py_INCREF (arg);
|
Py_INCREF (arg);
|
if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
|
if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
|
goto failarg;
|
goto failarg;
|
|
|
arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
|
arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
|
if (!arg)
|
if (!arg)
|
goto fail;
|
goto fail;
|
if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
|
if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
|
goto failarg;
|
goto failarg;
|
|
|
/* A field can have a NULL type in some situations. */
|
/* A field can have a NULL type in some situations. */
|
if (TYPE_FIELD_TYPE (type, field) == NULL)
|
if (TYPE_FIELD_TYPE (type, field) == NULL)
|
{
|
{
|
arg = Py_None;
|
arg = Py_None;
|
Py_INCREF (arg);
|
Py_INCREF (arg);
|
}
|
}
|
else
|
else
|
arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
|
arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
|
if (!arg)
|
if (!arg)
|
goto fail;
|
goto fail;
|
if (PyObject_SetAttrString (result, "type", arg) < 0)
|
if (PyObject_SetAttrString (result, "type", arg) < 0)
|
goto failarg;
|
goto failarg;
|
|
|
return result;
|
return result;
|
|
|
failarg:
|
failarg:
|
Py_DECREF (arg);
|
Py_DECREF (arg);
|
fail:
|
fail:
|
Py_DECREF (result);
|
Py_DECREF (result);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Return a sequence of all fields. Each field is a dictionary with
|
/* Return a sequence of all fields. Each field is a dictionary with
|
some pre-defined keys. */
|
some pre-defined keys. */
|
static PyObject *
|
static PyObject *
|
typy_fields (PyObject *self, PyObject *args)
|
typy_fields (PyObject *self, PyObject *args)
|
{
|
{
|
PyObject *result;
|
PyObject *result;
|
int i;
|
int i;
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
|
|
/* We would like to make a tuple here, make fields immutable, and
|
/* We would like to make a tuple here, make fields immutable, and
|
then memoize the result (and perhaps make Field.type() lazy).
|
then memoize the result (and perhaps make Field.type() lazy).
|
However, that can lead to cycles. */
|
However, that can lead to cycles. */
|
result = PyList_New (0);
|
result = PyList_New (0);
|
|
|
for (i = 0; i < TYPE_NFIELDS (type); ++i)
|
for (i = 0; i < TYPE_NFIELDS (type); ++i)
|
{
|
{
|
PyObject *dict = convert_field (type, i);
|
PyObject *dict = convert_field (type, i);
|
if (!dict)
|
if (!dict)
|
{
|
{
|
Py_DECREF (result);
|
Py_DECREF (result);
|
return NULL;
|
return NULL;
|
}
|
}
|
if (PyList_Append (result, dict))
|
if (PyList_Append (result, dict))
|
{
|
{
|
Py_DECREF (dict);
|
Py_DECREF (dict);
|
Py_DECREF (result);
|
Py_DECREF (result);
|
return NULL;
|
return NULL;
|
}
|
}
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return the type's tag, or None. */
|
/* Return the type's tag, or None. */
|
static PyObject *
|
static PyObject *
|
typy_get_tag (PyObject *self, void *closure)
|
typy_get_tag (PyObject *self, void *closure)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
if (!TYPE_TAG_NAME (type))
|
if (!TYPE_TAG_NAME (type))
|
Py_RETURN_NONE;
|
Py_RETURN_NONE;
|
return PyString_FromString (TYPE_TAG_NAME (type));
|
return PyString_FromString (TYPE_TAG_NAME (type));
|
}
|
}
|
|
|
/* Return the type, stripped of typedefs. */
|
/* Return the type, stripped of typedefs. */
|
static PyObject *
|
static PyObject *
|
typy_strip_typedefs (PyObject *self, PyObject *args)
|
typy_strip_typedefs (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
|
|
return type_to_type_object (check_typedef (type));
|
return type_to_type_object (check_typedef (type));
|
}
|
}
|
|
|
/* Return a Type object which represents a pointer to SELF. */
|
/* Return a Type object which represents a pointer to SELF. */
|
static PyObject *
|
static PyObject *
|
typy_pointer (PyObject *self, PyObject *args)
|
typy_pointer (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
type = lookup_pointer_type (type);
|
type = lookup_pointer_type (type);
|
}
|
}
|
GDB_PY_HANDLE_EXCEPTION (except);
|
GDB_PY_HANDLE_EXCEPTION (except);
|
|
|
return type_to_type_object (type);
|
return type_to_type_object (type);
|
}
|
}
|
|
|
/* Return the range of a type represented by SELF. The return type is
|
/* Return the range of a type represented by SELF. The return type is
|
a tuple. The first element of the tuple contains the low bound,
|
a tuple. The first element of the tuple contains the low bound,
|
while the second element of the tuple contains the high bound. */
|
while the second element of the tuple contains the high bound. */
|
static PyObject *
|
static PyObject *
|
typy_range (PyObject *self, PyObject *args)
|
typy_range (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
PyObject *result;
|
PyObject *result;
|
PyObject *low_bound = NULL, *high_bound = NULL;
|
PyObject *low_bound = NULL, *high_bound = NULL;
|
/* Initialize these to appease GCC warnings. */
|
/* Initialize these to appease GCC warnings. */
|
LONGEST low = 0, high = 0;
|
LONGEST low = 0, high = 0;
|
|
|
if (TYPE_CODE (type) != TYPE_CODE_ARRAY
|
if (TYPE_CODE (type) != TYPE_CODE_ARRAY
|
&& TYPE_CODE (type) != TYPE_CODE_STRING
|
&& TYPE_CODE (type) != TYPE_CODE_STRING
|
&& TYPE_CODE (type) != TYPE_CODE_RANGE)
|
&& TYPE_CODE (type) != TYPE_CODE_RANGE)
|
{
|
{
|
PyErr_SetString (PyExc_RuntimeError,
|
PyErr_SetString (PyExc_RuntimeError,
|
"This type does not have a range.");
|
"This type does not have a range.");
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
switch (TYPE_CODE (type))
|
switch (TYPE_CODE (type))
|
{
|
{
|
case TYPE_CODE_ARRAY:
|
case TYPE_CODE_ARRAY:
|
case TYPE_CODE_STRING:
|
case TYPE_CODE_STRING:
|
low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
|
low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
|
high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type));
|
high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type));
|
break;
|
break;
|
case TYPE_CODE_RANGE:
|
case TYPE_CODE_RANGE:
|
low = TYPE_LOW_BOUND (type);
|
low = TYPE_LOW_BOUND (type);
|
high = TYPE_HIGH_BOUND (type);
|
high = TYPE_HIGH_BOUND (type);
|
break;
|
break;
|
}
|
}
|
|
|
low_bound = PyLong_FromLong (low);
|
low_bound = PyLong_FromLong (low);
|
if (!low_bound)
|
if (!low_bound)
|
goto failarg;
|
goto failarg;
|
|
|
high_bound = PyLong_FromLong (high);
|
high_bound = PyLong_FromLong (high);
|
if (!high_bound)
|
if (!high_bound)
|
goto failarg;
|
goto failarg;
|
|
|
result = PyTuple_New (2);
|
result = PyTuple_New (2);
|
if (!result)
|
if (!result)
|
goto failarg;
|
goto failarg;
|
|
|
if (PyTuple_SetItem (result, 0, low_bound) != 0)
|
if (PyTuple_SetItem (result, 0, low_bound) != 0)
|
{
|
{
|
Py_DECREF (result);
|
Py_DECREF (result);
|
goto failarg;
|
goto failarg;
|
}
|
}
|
if (PyTuple_SetItem (result, 1, high_bound) != 0)
|
if (PyTuple_SetItem (result, 1, high_bound) != 0)
|
{
|
{
|
Py_DECREF (high_bound);
|
Py_DECREF (high_bound);
|
Py_DECREF (result);
|
Py_DECREF (result);
|
return NULL;
|
return NULL;
|
}
|
}
|
return result;
|
return result;
|
|
|
failarg:
|
failarg:
|
Py_XDECREF (high_bound);
|
Py_XDECREF (high_bound);
|
Py_XDECREF (low_bound);
|
Py_XDECREF (low_bound);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Return a Type object which represents a reference to SELF. */
|
/* Return a Type object which represents a reference to SELF. */
|
static PyObject *
|
static PyObject *
|
typy_reference (PyObject *self, PyObject *args)
|
typy_reference (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
type = lookup_reference_type (type);
|
type = lookup_reference_type (type);
|
}
|
}
|
GDB_PY_HANDLE_EXCEPTION (except);
|
GDB_PY_HANDLE_EXCEPTION (except);
|
|
|
return type_to_type_object (type);
|
return type_to_type_object (type);
|
}
|
}
|
|
|
/* Return a Type object which represents the target type of SELF. */
|
/* Return a Type object which represents the target type of SELF. */
|
static PyObject *
|
static PyObject *
|
typy_target (PyObject *self, PyObject *args)
|
typy_target (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
|
|
if (!TYPE_TARGET_TYPE (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;
|
return NULL;
|
}
|
}
|
|
|
return type_to_type_object (TYPE_TARGET_TYPE (type));
|
return type_to_type_object (TYPE_TARGET_TYPE (type));
|
}
|
}
|
|
|
/* Return a const-qualified type variant. */
|
/* Return a const-qualified type variant. */
|
static PyObject *
|
static PyObject *
|
typy_const (PyObject *self, PyObject *args)
|
typy_const (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
type = make_cv_type (1, 0, type, NULL);
|
type = make_cv_type (1, 0, type, NULL);
|
}
|
}
|
GDB_PY_HANDLE_EXCEPTION (except);
|
GDB_PY_HANDLE_EXCEPTION (except);
|
|
|
return type_to_type_object (type);
|
return type_to_type_object (type);
|
}
|
}
|
|
|
/* Return a volatile-qualified type variant. */
|
/* Return a volatile-qualified type variant. */
|
static PyObject *
|
static PyObject *
|
typy_volatile (PyObject *self, PyObject *args)
|
typy_volatile (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
type = make_cv_type (0, 1, type, NULL);
|
type = make_cv_type (0, 1, type, NULL);
|
}
|
}
|
GDB_PY_HANDLE_EXCEPTION (except);
|
GDB_PY_HANDLE_EXCEPTION (except);
|
|
|
return type_to_type_object (type);
|
return type_to_type_object (type);
|
}
|
}
|
|
|
/* Return an unqualified type variant. */
|
/* Return an unqualified type variant. */
|
static PyObject *
|
static PyObject *
|
typy_unqualified (PyObject *self, PyObject *args)
|
typy_unqualified (PyObject *self, PyObject *args)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
type = make_cv_type (0, 0, type, NULL);
|
type = make_cv_type (0, 0, type, NULL);
|
}
|
}
|
GDB_PY_HANDLE_EXCEPTION (except);
|
GDB_PY_HANDLE_EXCEPTION (except);
|
|
|
return type_to_type_object (type);
|
return type_to_type_object (type);
|
}
|
}
|
|
|
/* Return the size of the type represented by SELF, in bytes. */
|
/* Return the size of the type represented by SELF, in bytes. */
|
static PyObject *
|
static PyObject *
|
typy_get_sizeof (PyObject *self, void *closure)
|
typy_get_sizeof (PyObject *self, void *closure)
|
{
|
{
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
check_typedef (type);
|
check_typedef (type);
|
}
|
}
|
/* Ignore exceptions. */
|
/* Ignore exceptions. */
|
|
|
return PyLong_FromLong (TYPE_LENGTH (type));
|
return PyLong_FromLong (TYPE_LENGTH (type));
|
}
|
}
|
|
|
static struct type *
|
static struct type *
|
typy_lookup_typename (char *type_name)
|
typy_lookup_typename (char *type_name)
|
{
|
{
|
struct type *type = NULL;
|
struct type *type = NULL;
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
if (!strncmp (type_name, "struct ", 7))
|
if (!strncmp (type_name, "struct ", 7))
|
type = lookup_struct (type_name + 7, NULL);
|
type = lookup_struct (type_name + 7, NULL);
|
else if (!strncmp (type_name, "union ", 6))
|
else if (!strncmp (type_name, "union ", 6))
|
type = lookup_union (type_name + 6, NULL);
|
type = lookup_union (type_name + 6, NULL);
|
else if (!strncmp (type_name, "enum ", 5))
|
else if (!strncmp (type_name, "enum ", 5))
|
type = lookup_enum (type_name + 5, NULL);
|
type = lookup_enum (type_name + 5, NULL);
|
else
|
else
|
type = lookup_typename (python_language, python_gdbarch,
|
type = lookup_typename (python_language, python_gdbarch,
|
type_name, NULL, 0);
|
type_name, NULL, 0);
|
}
|
}
|
if (except.reason < 0)
|
if (except.reason < 0)
|
{
|
{
|
PyErr_Format (except.reason == RETURN_QUIT
|
PyErr_Format (except.reason == RETURN_QUIT
|
? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
|
? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
|
"%s", except.message);
|
"%s", except.message);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
return type;
|
return type;
|
}
|
}
|
|
|
static struct type *
|
static struct type *
|
typy_lookup_type (struct demangle_component *demangled)
|
typy_lookup_type (struct demangle_component *demangled)
|
{
|
{
|
struct type *type;
|
struct type *type;
|
char *type_name;
|
char *type_name;
|
enum demangle_component_type demangled_type;
|
enum demangle_component_type demangled_type;
|
|
|
/* Save the type: typy_lookup_type() may (indirectly) overwrite
|
/* Save the type: typy_lookup_type() may (indirectly) overwrite
|
memory pointed by demangled. */
|
memory pointed by demangled. */
|
demangled_type = demangled->type;
|
demangled_type = demangled->type;
|
|
|
if (demangled_type == DEMANGLE_COMPONENT_POINTER
|
if (demangled_type == DEMANGLE_COMPONENT_POINTER
|
|| demangled_type == DEMANGLE_COMPONENT_REFERENCE
|
|| demangled_type == DEMANGLE_COMPONENT_REFERENCE
|
|| demangled_type == DEMANGLE_COMPONENT_CONST
|
|| demangled_type == DEMANGLE_COMPONENT_CONST
|
|| demangled_type == DEMANGLE_COMPONENT_VOLATILE)
|
|| demangled_type == DEMANGLE_COMPONENT_VOLATILE)
|
{
|
{
|
type = typy_lookup_type (demangled->u.s_binary.left);
|
type = typy_lookup_type (demangled->u.s_binary.left);
|
if (! type)
|
if (! type)
|
return NULL;
|
return NULL;
|
|
|
switch (demangled_type)
|
switch (demangled_type)
|
{
|
{
|
case DEMANGLE_COMPONENT_REFERENCE:
|
case DEMANGLE_COMPONENT_REFERENCE:
|
return lookup_reference_type (type);
|
return lookup_reference_type (type);
|
case DEMANGLE_COMPONENT_POINTER:
|
case DEMANGLE_COMPONENT_POINTER:
|
return lookup_pointer_type (type);
|
return lookup_pointer_type (type);
|
case DEMANGLE_COMPONENT_CONST:
|
case DEMANGLE_COMPONENT_CONST:
|
return make_cv_type (1, 0, type, NULL);
|
return make_cv_type (1, 0, type, NULL);
|
case DEMANGLE_COMPONENT_VOLATILE:
|
case DEMANGLE_COMPONENT_VOLATILE:
|
return make_cv_type (0, 1, type, NULL);
|
return make_cv_type (0, 1, type, NULL);
|
}
|
}
|
}
|
}
|
|
|
type_name = cp_comp_to_string (demangled, 10);
|
type_name = cp_comp_to_string (demangled, 10);
|
type = typy_lookup_typename (type_name);
|
type = typy_lookup_typename (type_name);
|
xfree (type_name);
|
xfree (type_name);
|
|
|
return type;
|
return type;
|
}
|
}
|
|
|
static PyObject *
|
static PyObject *
|
typy_template_argument (PyObject *self, PyObject *args)
|
typy_template_argument (PyObject *self, PyObject *args)
|
{
|
{
|
int i, argno, n_pointers;
|
int i, argno, n_pointers;
|
struct type *type = ((type_object *) self)->type;
|
struct type *type = ((type_object *) self)->type;
|
struct demangle_component *demangled;
|
struct demangle_component *demangled;
|
const char *err;
|
const char *err;
|
struct type *argtype;
|
struct type *argtype;
|
|
|
if (! PyArg_ParseTuple (args, "i", &argno))
|
if (! PyArg_ParseTuple (args, "i", &argno))
|
return NULL;
|
return NULL;
|
|
|
type = check_typedef (type);
|
type = check_typedef (type);
|
if (TYPE_CODE (type) == TYPE_CODE_REF)
|
if (TYPE_CODE (type) == TYPE_CODE_REF)
|
type = check_typedef (TYPE_TARGET_TYPE (type));
|
type = check_typedef (TYPE_TARGET_TYPE (type));
|
|
|
if (TYPE_NAME (type) == NULL)
|
if (TYPE_NAME (type) == NULL)
|
{
|
{
|
PyErr_SetString (PyExc_RuntimeError, "null type name");
|
PyErr_SetString (PyExc_RuntimeError, "null type name");
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Note -- this is not thread-safe. */
|
/* Note -- this is not thread-safe. */
|
demangled = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
|
demangled = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
|
if (! demangled)
|
if (! demangled)
|
{
|
{
|
PyErr_SetString (PyExc_RuntimeError, err);
|
PyErr_SetString (PyExc_RuntimeError, err);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Strip off component names. */
|
/* Strip off component names. */
|
while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
|
while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
|
|| demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
|
|| demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
|
demangled = demangled->u.s_binary.right;
|
demangled = demangled->u.s_binary.right;
|
|
|
if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
|
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;
|
return NULL;
|
}
|
}
|
|
|
/* Skip from the template to the arguments. */
|
/* Skip from the template to the arguments. */
|
demangled = demangled->u.s_binary.right;
|
demangled = demangled->u.s_binary.right;
|
|
|
for (i = 0; demangled && i < argno; ++i)
|
for (i = 0; demangled && i < argno; ++i)
|
demangled = demangled->u.s_binary.right;
|
demangled = demangled->u.s_binary.right;
|
|
|
if (! demangled)
|
if (! demangled)
|
{
|
{
|
PyErr_Format (PyExc_RuntimeError, "no argument %d in template",
|
PyErr_Format (PyExc_RuntimeError, "no argument %d in template",
|
argno);
|
argno);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
argtype = typy_lookup_type (demangled->u.s_binary.left);
|
argtype = typy_lookup_type (demangled->u.s_binary.left);
|
if (! argtype)
|
if (! argtype)
|
return NULL;
|
return NULL;
|
|
|
return type_to_type_object (argtype);
|
return type_to_type_object (argtype);
|
}
|
}
|
|
|
static PyObject *
|
static PyObject *
|
typy_str (PyObject *self)
|
typy_str (PyObject *self)
|
{
|
{
|
volatile struct gdb_exception except;
|
volatile struct gdb_exception except;
|
char *thetype = NULL;
|
char *thetype = NULL;
|
long length = 0;
|
long length = 0;
|
PyObject *result;
|
PyObject *result;
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
struct ui_file *stb;
|
struct ui_file *stb;
|
|
|
stb = mem_fileopen ();
|
stb = mem_fileopen ();
|
old_chain = make_cleanup_ui_file_delete (stb);
|
old_chain = make_cleanup_ui_file_delete (stb);
|
|
|
type_print (type_object_to_type (self), "", stb, -1);
|
type_print (type_object_to_type (self), "", stb, -1);
|
|
|
thetype = ui_file_xstrdup (stb, &length);
|
thetype = ui_file_xstrdup (stb, &length);
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
if (except.reason < 0)
|
if (except.reason < 0)
|
{
|
{
|
xfree (thetype);
|
xfree (thetype);
|
GDB_PY_HANDLE_EXCEPTION (except);
|
GDB_PY_HANDLE_EXCEPTION (except);
|
}
|
}
|
|
|
result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
|
result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
|
xfree (thetype);
|
xfree (thetype);
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
|
|
|
|
static const struct objfile_data *typy_objfile_data_key;
|
static const struct objfile_data *typy_objfile_data_key;
|
|
|
static void
|
static void
|
save_objfile_types (struct objfile *objfile, void *datum)
|
save_objfile_types (struct objfile *objfile, void *datum)
|
{
|
{
|
type_object *obj = datum;
|
type_object *obj = datum;
|
htab_t copied_types;
|
htab_t copied_types;
|
struct cleanup *cleanup;
|
struct cleanup *cleanup;
|
|
|
/* This prevents another thread from freeing the objects we're
|
/* This prevents another thread from freeing the objects we're
|
operating on. */
|
operating on. */
|
cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
|
cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
|
|
|
copied_types = create_copied_types_hash (objfile);
|
copied_types = create_copied_types_hash (objfile);
|
|
|
while (obj)
|
while (obj)
|
{
|
{
|
type_object *next = obj->next;
|
type_object *next = obj->next;
|
|
|
htab_empty (copied_types);
|
htab_empty (copied_types);
|
|
|
obj->type = copy_type_recursive (objfile, obj->type, copied_types);
|
obj->type = copy_type_recursive (objfile, obj->type, copied_types);
|
|
|
obj->next = NULL;
|
obj->next = NULL;
|
obj->prev = NULL;
|
obj->prev = NULL;
|
|
|
obj = next;
|
obj = next;
|
}
|
}
|
|
|
htab_delete (copied_types);
|
htab_delete (copied_types);
|
|
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
}
|
}
|
|
|
static void
|
static void
|
set_type (type_object *obj, struct type *type)
|
set_type (type_object *obj, struct type *type)
|
{
|
{
|
obj->type = type;
|
obj->type = type;
|
obj->prev = NULL;
|
obj->prev = NULL;
|
if (type && TYPE_OBJFILE (type))
|
if (type && TYPE_OBJFILE (type))
|
{
|
{
|
struct objfile *objfile = TYPE_OBJFILE (type);
|
struct objfile *objfile = TYPE_OBJFILE (type);
|
|
|
obj->next = objfile_data (objfile, typy_objfile_data_key);
|
obj->next = objfile_data (objfile, typy_objfile_data_key);
|
if (obj->next)
|
if (obj->next)
|
obj->next->prev = obj;
|
obj->next->prev = obj;
|
set_objfile_data (objfile, typy_objfile_data_key, obj);
|
set_objfile_data (objfile, typy_objfile_data_key, obj);
|
}
|
}
|
else
|
else
|
obj->next = NULL;
|
obj->next = NULL;
|
}
|
}
|
|
|
static void
|
static void
|
typy_dealloc (PyObject *obj)
|
typy_dealloc (PyObject *obj)
|
{
|
{
|
type_object *type = (type_object *) obj;
|
type_object *type = (type_object *) obj;
|
|
|
if (type->prev)
|
if (type->prev)
|
type->prev->next = type->next;
|
type->prev->next = type->next;
|
else if (type->type && TYPE_OBJFILE (type->type))
|
else if (type->type && TYPE_OBJFILE (type->type))
|
{
|
{
|
/* Must reset head of list. */
|
/* Must reset head of list. */
|
struct objfile *objfile = TYPE_OBJFILE (type->type);
|
struct objfile *objfile = TYPE_OBJFILE (type->type);
|
if (objfile)
|
if (objfile)
|
set_objfile_data (objfile, typy_objfile_data_key, type->next);
|
set_objfile_data (objfile, typy_objfile_data_key, type->next);
|
}
|
}
|
if (type->next)
|
if (type->next)
|
type->next->prev = type->prev;
|
type->next->prev = type->prev;
|
|
|
type->ob_type->tp_free (type);
|
type->ob_type->tp_free (type);
|
}
|
}
|
|
|
/* Create a new Type referring to TYPE. */
|
/* Create a new Type referring to TYPE. */
|
PyObject *
|
PyObject *
|
type_to_type_object (struct type *type)
|
type_to_type_object (struct type *type)
|
{
|
{
|
type_object *type_obj;
|
type_object *type_obj;
|
|
|
type_obj = PyObject_New (type_object, &type_object_type);
|
type_obj = PyObject_New (type_object, &type_object_type);
|
if (type_obj)
|
if (type_obj)
|
set_type (type_obj, type);
|
set_type (type_obj, type);
|
|
|
return (PyObject *) type_obj;
|
return (PyObject *) type_obj;
|
}
|
}
|
|
|
struct type *
|
struct type *
|
type_object_to_type (PyObject *obj)
|
type_object_to_type (PyObject *obj)
|
{
|
{
|
if (! PyObject_TypeCheck (obj, &type_object_type))
|
if (! PyObject_TypeCheck (obj, &type_object_type))
|
return NULL;
|
return NULL;
|
return ((type_object *) obj)->type;
|
return ((type_object *) obj)->type;
|
}
|
}
|
|
|
|
|
|
|
/* Implementation of gdb.lookup_type. */
|
/* Implementation of gdb.lookup_type. */
|
PyObject *
|
PyObject *
|
gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
|
gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
|
{
|
{
|
static char *keywords[] = { "name", NULL };
|
static char *keywords[] = { "name", NULL };
|
char *type_name = NULL;
|
char *type_name = NULL;
|
struct type *type = NULL;
|
struct type *type = NULL;
|
|
|
if (! PyArg_ParseTupleAndKeywords (args, kw, "s", keywords, &type_name))
|
if (! PyArg_ParseTupleAndKeywords (args, kw, "s", keywords, &type_name))
|
return NULL;
|
return NULL;
|
|
|
type = typy_lookup_typename (type_name);
|
type = typy_lookup_typename (type_name);
|
if (! type)
|
if (! type)
|
return NULL;
|
return NULL;
|
|
|
return (PyObject *) type_to_type_object (type);
|
return (PyObject *) type_to_type_object (type);
|
}
|
}
|
|
|
void
|
void
|
gdbpy_initialize_types (void)
|
gdbpy_initialize_types (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
typy_objfile_data_key
|
typy_objfile_data_key
|
= register_objfile_data_with_cleanup (save_objfile_types, NULL);
|
= register_objfile_data_with_cleanup (save_objfile_types, NULL);
|
|
|
if (PyType_Ready (&type_object_type) < 0)
|
if (PyType_Ready (&type_object_type) < 0)
|
return;
|
return;
|
if (PyType_Ready (&field_object_type) < 0)
|
if (PyType_Ready (&field_object_type) < 0)
|
return;
|
return;
|
|
|
for (i = 0; pyty_codes[i].name; ++i)
|
for (i = 0; pyty_codes[i].name; ++i)
|
{
|
{
|
if (PyModule_AddIntConstant (gdb_module,
|
if (PyModule_AddIntConstant (gdb_module,
|
/* Cast needed for Python 2.4. */
|
/* Cast needed for Python 2.4. */
|
(char *) pyty_codes[i].name,
|
(char *) pyty_codes[i].name,
|
pyty_codes[i].code) < 0)
|
pyty_codes[i].code) < 0)
|
return;
|
return;
|
}
|
}
|
|
|
Py_INCREF (&type_object_type);
|
Py_INCREF (&type_object_type);
|
PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
|
PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
|
|
|
Py_INCREF (&field_object_type);
|
Py_INCREF (&field_object_type);
|
PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
|
PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
|
}
|
}
|
|
|
|
|
|
|
static PyGetSetDef type_object_getset[] =
|
static PyGetSetDef type_object_getset[] =
|
{
|
{
|
{ "code", typy_get_code, NULL,
|
{ "code", typy_get_code, NULL,
|
"The code for this type.", NULL },
|
"The code for this type.", NULL },
|
{ "sizeof", typy_get_sizeof, NULL,
|
{ "sizeof", typy_get_sizeof, NULL,
|
"The size of this type, in bytes.", NULL },
|
"The size of this type, in bytes.", NULL },
|
{ "tag", typy_get_tag, NULL,
|
{ "tag", typy_get_tag, NULL,
|
"The tag name for this type, or None.", NULL },
|
"The tag name for this type, or None.", NULL },
|
{ NULL }
|
{ NULL }
|
};
|
};
|
|
|
static PyMethodDef type_object_methods[] =
|
static PyMethodDef type_object_methods[] =
|
{
|
{
|
{ "const", typy_const, METH_NOARGS,
|
{ "const", typy_const, METH_NOARGS,
|
"const () -> Type\n\
|
"const () -> Type\n\
|
Return a const variant of this type." },
|
Return a const variant of this type." },
|
{ "fields", typy_fields, METH_NOARGS,
|
{ "fields", typy_fields, METH_NOARGS,
|
"field () -> list\n\
|
"field () -> list\n\
|
Return a sequence holding all the fields of this type.\n\
|
Return a sequence holding all the fields of this type.\n\
|
Each field is a dictionary." },
|
Each field is a dictionary." },
|
{ "pointer", typy_pointer, METH_NOARGS,
|
{ "pointer", typy_pointer, METH_NOARGS,
|
"pointer () -> Type\n\
|
"pointer () -> Type\n\
|
Return a type of pointer to this type." },
|
Return a type of pointer to this type." },
|
{ "range", typy_range, METH_NOARGS,
|
{ "range", typy_range, METH_NOARGS,
|
"range () -> tuple\n\
|
"range () -> tuple\n\
|
Return a tuple containing the lower and upper range for this type."},
|
Return a tuple containing the lower and upper range for this type."},
|
{ "reference", typy_reference, METH_NOARGS,
|
{ "reference", typy_reference, METH_NOARGS,
|
"reference () -> Type\n\
|
"reference () -> Type\n\
|
Return a type of reference to this type." },
|
Return a type of reference to this type." },
|
{ "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
|
{ "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
|
"strip_typedefs () -> Type\n\
|
"strip_typedefs () -> Type\n\
|
Return a type formed by stripping this type of all typedefs."},
|
Return a type formed by stripping this type of all typedefs."},
|
{ "target", typy_target, METH_NOARGS,
|
{ "target", typy_target, METH_NOARGS,
|
"target () -> Type\n\
|
"target () -> Type\n\
|
Return the target type of this type." },
|
Return the target type of this type." },
|
{ "template_argument", typy_template_argument, METH_VARARGS,
|
{ "template_argument", typy_template_argument, METH_VARARGS,
|
"template_argument (arg) -> Type\n\
|
"template_argument (arg) -> Type\n\
|
Return the type of a template argument." },
|
Return the type of a template argument." },
|
{ "unqualified", typy_unqualified, METH_NOARGS,
|
{ "unqualified", typy_unqualified, METH_NOARGS,
|
"unqualified () -> Type\n\
|
"unqualified () -> Type\n\
|
Return a variant of this type without const or volatile attributes." },
|
Return a variant of this type without const or volatile attributes." },
|
{ "volatile", typy_volatile, METH_NOARGS,
|
{ "volatile", typy_volatile, METH_NOARGS,
|
"volatile () -> Type\n\
|
"volatile () -> Type\n\
|
Return a volatile variant of this type" },
|
Return a volatile variant of this type" },
|
{ NULL }
|
{ NULL }
|
};
|
};
|
|
|
static PyTypeObject type_object_type =
|
static PyTypeObject type_object_type =
|
{
|
{
|
PyObject_HEAD_INIT (NULL)
|
PyObject_HEAD_INIT (NULL)
|
0, /*ob_size*/
|
0, /*ob_size*/
|
"gdb.Type", /*tp_name*/
|
"gdb.Type", /*tp_name*/
|
sizeof (type_object), /*tp_basicsize*/
|
sizeof (type_object), /*tp_basicsize*/
|
0, /*tp_itemsize*/
|
0, /*tp_itemsize*/
|
typy_dealloc, /*tp_dealloc*/
|
typy_dealloc, /*tp_dealloc*/
|
0, /*tp_print*/
|
0, /*tp_print*/
|
0, /*tp_getattr*/
|
0, /*tp_getattr*/
|
0, /*tp_setattr*/
|
0, /*tp_setattr*/
|
0, /*tp_compare*/
|
0, /*tp_compare*/
|
0, /*tp_repr*/
|
0, /*tp_repr*/
|
0, /*tp_as_number*/
|
0, /*tp_as_number*/
|
0, /*tp_as_sequence*/
|
0, /*tp_as_sequence*/
|
0, /*tp_as_mapping*/
|
0, /*tp_as_mapping*/
|
0, /*tp_hash */
|
0, /*tp_hash */
|
0, /*tp_call*/
|
0, /*tp_call*/
|
typy_str, /*tp_str*/
|
typy_str, /*tp_str*/
|
0, /*tp_getattro*/
|
0, /*tp_getattro*/
|
0, /*tp_setattro*/
|
0, /*tp_setattro*/
|
0, /*tp_as_buffer*/
|
0, /*tp_as_buffer*/
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
|
"GDB type object", /* tp_doc */
|
"GDB type object", /* tp_doc */
|
0, /* tp_traverse */
|
0, /* tp_traverse */
|
0, /* tp_clear */
|
0, /* tp_clear */
|
0, /* tp_richcompare */
|
0, /* tp_richcompare */
|
0, /* tp_weaklistoffset */
|
0, /* tp_weaklistoffset */
|
0, /* tp_iter */
|
0, /* tp_iter */
|
0, /* tp_iternext */
|
0, /* tp_iternext */
|
type_object_methods, /* tp_methods */
|
type_object_methods, /* tp_methods */
|
0, /* tp_members */
|
0, /* tp_members */
|
type_object_getset, /* tp_getset */
|
type_object_getset, /* tp_getset */
|
0, /* tp_base */
|
0, /* tp_base */
|
0, /* tp_dict */
|
0, /* tp_dict */
|
0, /* tp_descr_get */
|
0, /* tp_descr_get */
|
0, /* tp_descr_set */
|
0, /* tp_descr_set */
|
0, /* tp_dictoffset */
|
0, /* tp_dictoffset */
|
0, /* tp_init */
|
0, /* tp_init */
|
0, /* tp_alloc */
|
0, /* tp_alloc */
|
0, /* tp_new */
|
0, /* tp_new */
|
};
|
};
|
|
|
static PyTypeObject field_object_type =
|
static PyTypeObject field_object_type =
|
{
|
{
|
PyObject_HEAD_INIT (NULL)
|
PyObject_HEAD_INIT (NULL)
|
0, /*ob_size*/
|
0, /*ob_size*/
|
"gdb.Field", /*tp_name*/
|
"gdb.Field", /*tp_name*/
|
sizeof (field_object), /*tp_basicsize*/
|
sizeof (field_object), /*tp_basicsize*/
|
0, /*tp_itemsize*/
|
0, /*tp_itemsize*/
|
field_dealloc, /*tp_dealloc*/
|
field_dealloc, /*tp_dealloc*/
|
0, /*tp_print*/
|
0, /*tp_print*/
|
0, /*tp_getattr*/
|
0, /*tp_getattr*/
|
0, /*tp_setattr*/
|
0, /*tp_setattr*/
|
0, /*tp_compare*/
|
0, /*tp_compare*/
|
0, /*tp_repr*/
|
0, /*tp_repr*/
|
0, /*tp_as_number*/
|
0, /*tp_as_number*/
|
0, /*tp_as_sequence*/
|
0, /*tp_as_sequence*/
|
0, /*tp_as_mapping*/
|
0, /*tp_as_mapping*/
|
0, /*tp_hash */
|
0, /*tp_hash */
|
0, /*tp_call*/
|
0, /*tp_call*/
|
0, /*tp_str*/
|
0, /*tp_str*/
|
0, /*tp_getattro*/
|
0, /*tp_getattro*/
|
0, /*tp_setattro*/
|
0, /*tp_setattro*/
|
0, /*tp_as_buffer*/
|
0, /*tp_as_buffer*/
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
|
"GDB field object", /* tp_doc */
|
"GDB field object", /* tp_doc */
|
0, /* tp_traverse */
|
0, /* tp_traverse */
|
0, /* tp_clear */
|
0, /* tp_clear */
|
0, /* tp_richcompare */
|
0, /* tp_richcompare */
|
0, /* tp_weaklistoffset */
|
0, /* tp_weaklistoffset */
|
0, /* tp_iter */
|
0, /* tp_iter */
|
0, /* tp_iternext */
|
0, /* tp_iternext */
|
0, /* tp_methods */
|
0, /* tp_methods */
|
0, /* tp_members */
|
0, /* tp_members */
|
0, /* tp_getset */
|
0, /* tp_getset */
|
0, /* tp_base */
|
0, /* tp_base */
|
0, /* tp_dict */
|
0, /* tp_dict */
|
0, /* tp_descr_get */
|
0, /* tp_descr_get */
|
0, /* tp_descr_set */
|
0, /* tp_descr_set */
|
offsetof (field_object, dict), /* tp_dictoffset */
|
offsetof (field_object, dict), /* tp_dictoffset */
|
0, /* tp_init */
|
0, /* tp_init */
|
0, /* tp_alloc */
|
0, /* tp_alloc */
|
0, /* tp_new */
|
0, /* tp_new */
|
};
|
};
|
|
|
