gdb/python/py-type.c

   1 /* Python interface to types.
   2
   3    Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "value.h"
  22 #include "exceptions.h"
  23 #include "python-internal.h"
  24 #include "charset.h"
  25 #include "gdbtypes.h"
  26 #include "cp-support.h"
  27 #include "demangle.h"
  28 #include "objfiles.h"
  29 #include "language.h"
  30
  31 typedef struct pyty_type_object
  32 {
  33   PyObject_HEAD
  34   struct type *type;
  35
  36   /* If a Type object is associated with an objfile, it is kept on a
  37      doubly-linked list, rooted in the objfile.  This lets us copy the
  38      underlying struct type when the objfile is deleted.  */
  39   struct pyty_type_object *prev;
  40   struct pyty_type_object *next;
  41 } type_object;
  42
  43 static PyTypeObject type_object_type;
  44
  45 /* A Field object.  */
  46 typedef struct pyty_field_object
  47 {
  48   PyObject_HEAD
  49
  50   /* Dictionary holding our attributes.  */
  51   PyObject *dict;
  52 } field_object;
  53
  54 static PyTypeObject field_object_type;
  55
  56 /* This is used to initialize various gdb.TYPE_ constants.  */
  57 struct pyty_code
  58 {
  59   /* The code.  */
  60   enum type_code code;
  61   /* The name.  */
  62   const char *name;
  63 };
  64
  65 #define ENTRY(X) { X, #X }
  66
  67 static struct pyty_code pyty_codes[] =
  68 {
  69   ENTRY (TYPE_CODE_PTR),
  70   ENTRY (TYPE_CODE_ARRAY),
  71   ENTRY (TYPE_CODE_STRUCT),
  72   ENTRY (TYPE_CODE_UNION),
  73   ENTRY (TYPE_CODE_ENUM),
  74   ENTRY (TYPE_CODE_FLAGS),
  75   ENTRY (TYPE_CODE_FUNC),
  76   ENTRY (TYPE_CODE_INT),
  77   ENTRY (TYPE_CODE_FLT),
  78   ENTRY (TYPE_CODE_VOID),
  79   ENTRY (TYPE_CODE_SET),
  80   ENTRY (TYPE_CODE_RANGE),
  81   ENTRY (TYPE_CODE_STRING),
  82   ENTRY (TYPE_CODE_BITSTRING),
  83   ENTRY (TYPE_CODE_ERROR),
  84   ENTRY (TYPE_CODE_METHOD),
  85   ENTRY (TYPE_CODE_METHODPTR),
  86   ENTRY (TYPE_CODE_MEMBERPTR),
  87   ENTRY (TYPE_CODE_REF),
  88   ENTRY (TYPE_CODE_CHAR),
  89   ENTRY (TYPE_CODE_BOOL),
  90   ENTRY (TYPE_CODE_COMPLEX),
  91   ENTRY (TYPE_CODE_TYPEDEF),
  92   ENTRY (TYPE_CODE_NAMESPACE),
  93   ENTRY (TYPE_CODE_DECFLOAT),
  94   ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
  95   { TYPE_CODE_UNDEF, NULL }
  96 };
  97
  98 \f
  99
 100 static void
 101 field_dealloc (PyObject *obj)
 102 {
 103   field_object *f = (field_object *) obj;
 104   Py_XDECREF (f->dict);
 105   f->ob_type->tp_free (obj);
 106 }
 107
 108 static PyObject *
 109 field_new (void)
 110 {
 111   field_object *result = PyObject_New (field_object, &field_object_type);
 112   if (result)
 113     {
 114       result->dict = PyDict_New ();
 115       if (!result->dict)
 116         {
 117           Py_DECREF (result);
 118           result = NULL;
 119         }
 120     }
 121   return (PyObject *) result;
 122 }
 123
 124 \f
 125
 126 /* Return the code for this type.  */
 127 static PyObject *
 128 typy_get_code (PyObject *self, void *closure)
 129 {
 130   struct type *type = ((type_object *) self)->type;
 131   return PyInt_FromLong (TYPE_CODE (type));
 132 }
 133
 134 /* Helper function for typy_fields which converts a single field to a
 135    dictionary.  Returns NULL on error.  */
 136 static PyObject *
 137 convert_field (struct type *type, int field)
 138 {
 139   PyObject *result = field_new ();
 140   PyObject *arg;
 141
 142   if (!result)
 143     return NULL;
 144
 145   if (!field_is_static (&TYPE_FIELD (type, field)))
 146     {
 147       arg = PyLong_FromLong (TYPE_FIELD_BITPOS (type, field));
 148       if (!arg)
 149         goto fail;
 150
 151       if (PyObject_SetAttrString (result, "bitpos", arg) < 0)
 152         goto failarg;
 153     }
 154
 155   if (TYPE_FIELD_NAME (type, field))
 156     arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
 157   else
 158     {
 159       arg = Py_None;
 160       Py_INCREF (arg);
 161     }
 162   if (!arg)
 163     goto fail;
 164   if (PyObject_SetAttrString (result, "name", arg) < 0)
 165     goto failarg;
 166
 167   arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
 168   Py_INCREF (arg);
 169   if (PyObject_SetAttrString (result, "artificial", arg) < 0)
 170     goto failarg;
 171
 172   if (TYPE_CODE (type) == TYPE_CODE_CLASS)
 173     arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
 174   else
 175     arg = Py_False;
 176   Py_INCREF (arg);
 177   if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
 178     goto failarg;
 179
 180   arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
 181   if (!arg)
 182     goto fail;
 183   if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
 184     goto failarg;
 185
 186   /* A field can have a NULL type in some situations.  */
 187   if (TYPE_FIELD_TYPE (type, field) == NULL)
 188     {
 189       arg = Py_None;
 190       Py_INCREF (arg);
 191     }
 192   else
 193     arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
 194   if (!arg)
 195     goto fail;
 196   if (PyObject_SetAttrString (result, "type", arg) < 0)
 197     goto failarg;
 198
 199   return result;
 200
 201  failarg:
 202   Py_DECREF (arg);
 203  fail:
 204   Py_DECREF (result);
 205   return NULL;
 206 }
 207
 208 /* Return a sequence of all fields.  Each field is a dictionary with
 209    some pre-defined keys.  */
 210 static PyObject *
 211 typy_fields (PyObject *self, PyObject *args)
 212 {
 213   PyObject *result;
 214   int i;
 215   struct type *type = ((type_object *) self)->type;
 216
 217   /* We would like to make a tuple here, make fields immutable, and
 218      then memoize the result (and perhaps make Field.type() lazy).
 219      However, that can lead to cycles.  */
 220   result = PyList_New (0);
 221
 222   for (i = 0; i < TYPE_NFIELDS (type); ++i)
 223     {
 224       PyObject *dict = convert_field (type, i);
 225       if (!dict)
 226         {
 227           Py_DECREF (result);
 228           return NULL;
 229         }
 230       if (PyList_Append (result, dict))
 231         {
 232           Py_DECREF (dict);
 233           Py_DECREF (result);
 234           return NULL;
 235         }
 236     }
 237
 238   return result;
 239 }
 240
 241 /* Return the type's tag, or None.  */
 242 static PyObject *
 243 typy_get_tag (PyObject *self, void *closure)
 244 {
 245   struct type *type = ((type_object *) self)->type;
 246   if (!TYPE_TAG_NAME (type))
 247     Py_RETURN_NONE;
 248   return PyString_FromString (TYPE_TAG_NAME (type));
 249 }
 250
 251 /* Return the type, stripped of typedefs. */
 252 static PyObject *
 253 typy_strip_typedefs (PyObject *self, PyObject *args)
 254 {
 255   struct type *type = ((type_object *) self)->type;
 256
 257   return type_to_type_object (check_typedef (type));
 258 }
 259
 260 /* Return a Type object which represents a pointer to SELF.  */
 261 static PyObject *
 262 typy_pointer (PyObject *self, PyObject *args)
 263 {
 264   struct type *type = ((type_object *) self)->type;
 265   volatile struct gdb_exception except;
 266
 267   TRY_CATCH (except, RETURN_MASK_ALL)
 268     {
 269       type = lookup_pointer_type (type);
 270     }
 271   GDB_PY_HANDLE_EXCEPTION (except);
 272
 273   return type_to_type_object (type);
 274 }
 275
 276 /* Return the range of a type represented by SELF.  The return type is
 277    a tuple.  The first element of the tuple contains the low bound,
 278    while the second element of the tuple contains the high bound.  */
 279 static PyObject *
 280 typy_range (PyObject *self, PyObject *args)
 281 {
 282   struct type *type = ((type_object *) self)->type;
 283   PyObject *result;
 284   PyObject *low_bound = NULL, *high_bound = NULL;
 285   /* Initialize these to appease GCC warnings.  */
 286   LONGEST low = 0, high = 0;
 287
 288   if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 289       && TYPE_CODE (type) != TYPE_CODE_STRING
 290       && TYPE_CODE (type) != TYPE_CODE_RANGE)
 291     {
 292       PyErr_SetString (PyExc_RuntimeError,
 293                        _("This type does not have a range."));
 294       return NULL;
 295     }
 296
 297   switch (TYPE_CODE (type))
 298     {
 299     case TYPE_CODE_ARRAY:
 300     case TYPE_CODE_STRING:
 301       low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
 302       high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type));
 303       break;
 304     case TYPE_CODE_RANGE:
 305       low = TYPE_LOW_BOUND (type);
 306       high = TYPE_HIGH_BOUND (type);
 307       break;
 308     }
 309
 310   low_bound = PyLong_FromLong (low);
 311   if (!low_bound)
 312     goto failarg;
 313
 314   high_bound = PyLong_FromLong (high);
 315   if (!high_bound)
 316     goto failarg;
 317
 318   result = PyTuple_New (2);
 319   if (!result)
 320     goto failarg;
 321
 322   if (PyTuple_SetItem (result, 0, low_bound) != 0)
 323     {
 324       Py_DECREF (result);
 325       goto failarg;
 326     }
 327   if (PyTuple_SetItem (result, 1, high_bound) != 0)
 328     {
 329       Py_DECREF (high_bound);
 330       Py_DECREF (result);
 331       return NULL;
 332     }
 333   return result;
 334
 335  failarg:
 336   Py_XDECREF (high_bound);
 337   Py_XDECREF (low_bound);
 338   return NULL;
 339 }
 340
 341 /* Return a Type object which represents a reference to SELF.  */
 342 static PyObject *
 343 typy_reference (PyObject *self, PyObject *args)
 344 {
 345   struct type *type = ((type_object *) self)->type;
 346   volatile struct gdb_exception except;
 347
 348   TRY_CATCH (except, RETURN_MASK_ALL)
 349     {
 350       type = lookup_reference_type (type);
 351     }
 352   GDB_PY_HANDLE_EXCEPTION (except);
 353
 354   return type_to_type_object (type);
 355 }
 356
 357 /* Return a Type object which represents the target type of SELF.  */
 358 static PyObject *
 359 typy_target (PyObject *self, PyObject *args)
 360 {
 361   struct type *type = ((type_object *) self)->type;
 362
 363   if (!TYPE_TARGET_TYPE (type))
 364     {
 365       PyErr_SetString (PyExc_RuntimeError,
 366                        _("Type does not have a target."));
 367       return NULL;
 368     }
 369
 370   return type_to_type_object (TYPE_TARGET_TYPE (type));
 371 }
 372
 373 /* Return a const-qualified type variant.  */
 374 static PyObject *
 375 typy_const (PyObject *self, PyObject *args)
 376 {
 377   struct type *type = ((type_object *) self)->type;
 378   volatile struct gdb_exception except;
 379
 380   TRY_CATCH (except, RETURN_MASK_ALL)
 381     {
 382       type = make_cv_type (1, 0, type, NULL);
 383     }
 384   GDB_PY_HANDLE_EXCEPTION (except);
 385
 386   return type_to_type_object (type);
 387 }
 388
 389 /* Return a volatile-qualified type variant.  */
 390 static PyObject *
 391 typy_volatile (PyObject *self, PyObject *args)
 392 {
 393   struct type *type = ((type_object *) self)->type;
 394   volatile struct gdb_exception except;
 395
 396   TRY_CATCH (except, RETURN_MASK_ALL)
 397     {
 398       type = make_cv_type (0, 1, type, NULL);
 399     }
 400   GDB_PY_HANDLE_EXCEPTION (except);
 401
 402   return type_to_type_object (type);
 403 }
 404
 405 /* Return an unqualified type variant.  */
 406 static PyObject *
 407 typy_unqualified (PyObject *self, PyObject *args)
 408 {
 409   struct type *type = ((type_object *) self)->type;
 410   volatile struct gdb_exception except;
 411
 412   TRY_CATCH (except, RETURN_MASK_ALL)
 413     {
 414       type = make_cv_type (0, 0, type, NULL);
 415     }
 416   GDB_PY_HANDLE_EXCEPTION (except);
 417
 418   return type_to_type_object (type);
 419 }
 420
 421 /* Return the size of the type represented by SELF, in bytes.  */
 422 static PyObject *
 423 typy_get_sizeof (PyObject *self, void *closure)
 424 {
 425   struct type *type = ((type_object *) self)->type;
 426   volatile struct gdb_exception except;
 427
 428   TRY_CATCH (except, RETURN_MASK_ALL)
 429     {
 430       check_typedef (type);
 431     }
 432   /* Ignore exceptions.  */
 433
 434   return PyLong_FromLong (TYPE_LENGTH (type));
 435 }
 436
 437 static struct type *
 438 typy_lookup_typename (char *type_name, struct block *block)
 439 {
 440   struct type *type = NULL;
 441   volatile struct gdb_exception except;
 442   TRY_CATCH (except, RETURN_MASK_ALL)
 443     {
 444       if (!strncmp (type_name, "struct ", 7))
 445         type = lookup_struct (type_name + 7, NULL);
 446       else if (!strncmp (type_name, "union ", 6))
 447         type = lookup_union (type_name + 6, NULL);
 448       else if (!strncmp (type_name, "enum ", 5))
 449         type = lookup_enum (type_name + 5, NULL);
 450       else
 451         type = lookup_typename (python_language, python_gdbarch,
 452                                 type_name, block, 0);
 453     }
 454   if (except.reason < 0)
 455     {
 456       PyErr_Format (except.reason == RETURN_QUIT
 457                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 458                     "%s", except.message);
 459       return NULL;
 460     }
 461
 462   return type;
 463 }
 464
 465 static struct type *
 466 typy_lookup_type (struct demangle_component *demangled,
 467                   struct block *block)
 468 {
 469   struct type *type;
 470   char *type_name;
 471   enum demangle_component_type demangled_type;
 472
 473   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 474      memory pointed by demangled.  */
 475   demangled_type = demangled->type;
 476
 477   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 478       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 479       || demangled_type == DEMANGLE_COMPONENT_CONST
 480       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 481     {
 482       type = typy_lookup_type (demangled->u.s_binary.left, block);
 483       if (! type)
 484         return NULL;
 485
 486       switch (demangled_type)
 487         {
 488         case DEMANGLE_COMPONENT_REFERENCE:
 489           return lookup_reference_type (type);
 490         case DEMANGLE_COMPONENT_POINTER:
 491           return lookup_pointer_type (type);
 492         case DEMANGLE_COMPONENT_CONST:
 493           return make_cv_type (1, 0, type, NULL);
 494         case DEMANGLE_COMPONENT_VOLATILE:
 495           return make_cv_type (0, 1, type, NULL);
 496         }
 497     }
 498
 499   type_name = cp_comp_to_string (demangled, 10);
 500   type = typy_lookup_typename (type_name, block);
 501   xfree (type_name);
 502
 503   return type;
 504 }
 505
 506 static PyObject *
 507 typy_template_argument (PyObject *self, PyObject *args)
 508 {
 509   int i, argno;
 510   struct type *type = ((type_object *) self)->type;
 511   struct demangle_component *demangled;
 512   const char *err;
 513   struct type *argtype;
 514   struct block *block = NULL;
 515   PyObject *block_obj = NULL;
 516
 517   if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
 518     return NULL;
 519
 520   if (block_obj)
 521     {
 522       block = block_object_to_block (block_obj);
 523       if (! block)
 524         {
 525           PyErr_SetString (PyExc_RuntimeError,
 526                            _("Second argument must be block."));
 527           return NULL;
 528         }
 529     }
 530
 531   type = check_typedef (type);
 532   if (TYPE_CODE (type) == TYPE_CODE_REF)
 533     type = check_typedef (TYPE_TARGET_TYPE (type));
 534
 535   if (TYPE_NAME (type) == NULL)
 536     {
 537       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 538       return NULL;
 539     }
 540
 541   /* Note -- this is not thread-safe.  */
 542   demangled = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
 543   if (! demangled)
 544     {
 545       PyErr_SetString (PyExc_RuntimeError, err);
 546       return NULL;
 547     }
 548
 549   /* Strip off component names.  */
 550   while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
 551          || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 552     demangled = demangled->u.s_binary.right;
 553
 554   if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
 555     {
 556       PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
 557       return NULL;
 558     }
 559
 560   /* Skip from the template to the arguments.  */
 561   demangled = demangled->u.s_binary.right;
 562
 563   for (i = 0; demangled && i < argno; ++i)
 564     demangled = demangled->u.s_binary.right;
 565
 566   if (! demangled)
 567     {
 568       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 569                     argno);
 570       return NULL;
 571     }
 572
 573   argtype = typy_lookup_type (demangled->u.s_binary.left, block);
 574   if (! argtype)
 575     return NULL;
 576
 577   return type_to_type_object (argtype);
 578 }
 579
 580 static PyObject *
 581 typy_str (PyObject *self)
 582 {
 583   volatile struct gdb_exception except;
 584   char *thetype = NULL;
 585   long length = 0;
 586   PyObject *result;
 587
 588   TRY_CATCH (except, RETURN_MASK_ALL)
 589     {
 590       struct cleanup *old_chain;
 591       struct ui_file *stb;
 592
 593       stb = mem_fileopen ();
 594       old_chain = make_cleanup_ui_file_delete (stb);
 595
 596       type_print (type_object_to_type (self), "", stb, -1);
 597
 598       thetype = ui_file_xstrdup (stb, &length);
 599       do_cleanups (old_chain);
 600     }
 601   if (except.reason < 0)
 602     {
 603       xfree (thetype);
 604       GDB_PY_HANDLE_EXCEPTION (except);
 605     }
 606
 607   result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
 608   xfree (thetype);
 609
 610   return result;
 611 }
 612
 613 \f
 614
 615 static const struct objfile_data *typy_objfile_data_key;
 616
 617 static void
 618 save_objfile_types (struct objfile *objfile, void *datum)
 619 {
 620   type_object *obj = datum;
 621   htab_t copied_types;
 622   struct cleanup *cleanup;
 623
 624   /* This prevents another thread from freeing the objects we're
 625      operating on.  */
 626   cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
 627
 628   copied_types = create_copied_types_hash (objfile);
 629
 630   while (obj)
 631     {
 632       type_object *next = obj->next;
 633
 634       htab_empty (copied_types);
 635
 636       obj->type = copy_type_recursive (objfile, obj->type, copied_types);
 637
 638       obj->next = NULL;
 639       obj->prev = NULL;
 640
 641       obj = next;
 642     }
 643
 644   htab_delete (copied_types);
 645
 646   do_cleanups (cleanup);
 647 }
 648
 649 static void
 650 set_type (type_object *obj, struct type *type)
 651 {
 652   obj->type = type;
 653   obj->prev = NULL;
 654   if (type && TYPE_OBJFILE (type))
 655     {
 656       struct objfile *objfile = TYPE_OBJFILE (type);
 657
 658       obj->next = objfile_data (objfile, typy_objfile_data_key);
 659       if (obj->next)
 660         obj->next->prev = obj;
 661       set_objfile_data (objfile, typy_objfile_data_key, obj);
 662     }
 663   else
 664     obj->next = NULL;
 665 }
 666
 667 static void
 668 typy_dealloc (PyObject *obj)
 669 {
 670   type_object *type = (type_object *) obj;
 671
 672   if (type->prev)
 673     type->prev->next = type->next;
 674   else if (type->type && TYPE_OBJFILE (type->type))
 675     {
 676       /* Must reset head of list.  */
 677       struct objfile *objfile = TYPE_OBJFILE (type->type);
 678       if (objfile)
 679         set_objfile_data (objfile, typy_objfile_data_key, type->next);
 680     }
 681   if (type->next)
 682     type->next->prev = type->prev;
 683
 684   type->ob_type->tp_free (type);
 685 }
 686
 687 /* Create a new Type referring to TYPE.  */
 688 PyObject *
 689 type_to_type_object (struct type *type)
 690 {
 691   type_object *type_obj;
 692
 693   type_obj = PyObject_New (type_object, &type_object_type);
 694   if (type_obj)
 695     set_type (type_obj, type);
 696
 697   return (PyObject *) type_obj;
 698 }
 699
 700 struct type *
 701 type_object_to_type (PyObject *obj)
 702 {
 703   if (! PyObject_TypeCheck (obj, &type_object_type))
 704     return NULL;
 705   return ((type_object *) obj)->type;
 706 }
 707
 708 \f
 709
 710 /* Implementation of gdb.lookup_type.  */
 711 PyObject *
 712 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
 713 {
 714   static char *keywords[] = { "name", "block", NULL };
 715   char *type_name = NULL;
 716   struct type *type = NULL;
 717   PyObject *block_obj = NULL;
 718   struct block *block = NULL;
 719
 720   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
 721                                      &type_name, &block_obj))
 722     return NULL;
 723
 724   if (block_obj)
 725     {
 726       block = block_object_to_block (block_obj);
 727       if (! block)
 728         {
 729           PyErr_SetString (PyExc_RuntimeError,
 730                            _("'block' argument must be a Block."));
 731           return NULL;
 732         }
 733     }
 734
 735   type = typy_lookup_typename (type_name, block);
 736   if (! type)
 737     return NULL;
 738
 739   return (PyObject *) type_to_type_object (type);
 740 }
 741
 742 void
 743 gdbpy_initialize_types (void)
 744 {
 745   int i;
 746
 747   typy_objfile_data_key
 748     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
 749
 750   if (PyType_Ready (&type_object_type) < 0)
 751     return;
 752   if (PyType_Ready (&field_object_type) < 0)
 753     return;
 754
 755   for (i = 0; pyty_codes[i].name; ++i)
 756     {
 757       if (PyModule_AddIntConstant (gdb_module,
 758                                    /* Cast needed for Python 2.4.  */
 759                                    (char *) pyty_codes[i].name,
 760                                    pyty_codes[i].code) < 0)
 761         return;
 762     }
 763
 764   Py_INCREF (&type_object_type);
 765   PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
 766
 767   Py_INCREF (&field_object_type);
 768   PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
 769 }
 770
 771 \f
 772
 773 static PyGetSetDef type_object_getset[] =
 774 {
 775   { "code", typy_get_code, NULL,
 776     "The code for this type.", NULL },
 777   { "sizeof", typy_get_sizeof, NULL,
 778     "The size of this type, in bytes.", NULL },
 779   { "tag", typy_get_tag, NULL,
 780     "The tag name for this type, or None.", NULL },
 781   { NULL }
 782 };
 783
 784 static PyMethodDef type_object_methods[] =
 785 {
 786   { "const", typy_const, METH_NOARGS,
 787     "const () -> Type\n\
 788 Return a const variant of this type." },
 789   { "fields", typy_fields, METH_NOARGS,
 790     "field () -> list\n\
 791 Return a sequence holding all the fields of this type.\n\
 792 Each field is a dictionary." },
 793   { "pointer", typy_pointer, METH_NOARGS,
 794     "pointer () -> Type\n\
 795 Return a type of pointer to this type." },
 796   { "range", typy_range, METH_NOARGS,
 797     "range () -> tuple\n\
 798 Return a tuple containing the lower and upper range for this type."},
 799   { "reference", typy_reference, METH_NOARGS,
 800     "reference () -> Type\n\
 801 Return a type of reference to this type." },
 802   { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
 803     "strip_typedefs () -> Type\n\
 804 Return a type formed by stripping this type of all typedefs."},
 805   { "target", typy_target, METH_NOARGS,
 806     "target () -> Type\n\
 807 Return the target type of this type." },
 808   { "template_argument", typy_template_argument, METH_VARARGS,
 809     "template_argument (arg, [block]) -> Type\n\
 810 Return the type of a template argument." },
 811   { "unqualified", typy_unqualified, METH_NOARGS,
 812     "unqualified () -> Type\n\
 813 Return a variant of this type without const or volatile attributes." },
 814   { "volatile", typy_volatile, METH_NOARGS,
 815     "volatile () -> Type\n\
 816 Return a volatile variant of this type" },
 817   { NULL }
 818 };
 819
 820 static PyTypeObject type_object_type =
 821 {
 822   PyObject_HEAD_INIT (NULL)
 823   0,                              /*ob_size*/
 824   "gdb.Type",                     /*tp_name*/
 825   sizeof (type_object),           /*tp_basicsize*/
 826   0,                              /*tp_itemsize*/
 827   typy_dealloc,                   /*tp_dealloc*/
 828   0,                              /*tp_print*/
 829   0,                              /*tp_getattr*/
 830   0,                              /*tp_setattr*/
 831   0,                              /*tp_compare*/
 832   0,                              /*tp_repr*/
 833   0,                              /*tp_as_number*/
 834   0,                              /*tp_as_sequence*/
 835   0,                              /*tp_as_mapping*/
 836   0,                              /*tp_hash */
 837   0,                              /*tp_call*/
 838   typy_str,                       /*tp_str*/
 839   0,                              /*tp_getattro*/
 840   0,                              /*tp_setattro*/
 841   0,                              /*tp_as_buffer*/
 842   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
 843   "GDB type object",              /* tp_doc */
 844   0,                              /* tp_traverse */
 845   0,                              /* tp_clear */
 846   0,                              /* tp_richcompare */
 847   0,                              /* tp_weaklistoffset */
 848   0,                              /* tp_iter */
 849   0,                              /* tp_iternext */
 850   type_object_methods,            /* tp_methods */
 851   0,                              /* tp_members */
 852   type_object_getset,             /* tp_getset */
 853   0,                              /* tp_base */
 854   0,                              /* tp_dict */
 855   0,                              /* tp_descr_get */
 856   0,                              /* tp_descr_set */
 857   0,                              /* tp_dictoffset */
 858   0,                              /* tp_init */
 859   0,                              /* tp_alloc */
 860   0,                              /* tp_new */
 861 };
 862
 863 static PyTypeObject field_object_type =
 864 {
 865   PyObject_HEAD_INIT (NULL)
 866   0,                              /*ob_size*/
 867   "gdb.Field",                    /*tp_name*/
 868   sizeof (field_object),          /*tp_basicsize*/
 869   0,                              /*tp_itemsize*/
 870   field_dealloc,                  /*tp_dealloc*/
 871   0,                              /*tp_print*/
 872   0,                              /*tp_getattr*/
 873   0,                              /*tp_setattr*/
 874   0,                              /*tp_compare*/
 875   0,                              /*tp_repr*/
 876   0,                              /*tp_as_number*/
 877   0,                              /*tp_as_sequence*/
 878   0,                              /*tp_as_mapping*/
 879   0,                              /*tp_hash */
 880   0,                              /*tp_call*/
 881   0,                              /*tp_str*/
 882   0,                              /*tp_getattro*/
 883   0,                              /*tp_setattro*/
 884   0,                              /*tp_as_buffer*/
 885   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
 886   "GDB field object",             /* tp_doc */
 887   0,                              /* tp_traverse */
 888   0,                              /* tp_clear */
 889   0,                              /* tp_richcompare */
 890   0,                              /* tp_weaklistoffset */
 891   0,                              /* tp_iter */
 892   0,                              /* tp_iternext */
 893   0,                              /* tp_methods */
 894   0,                              /* tp_members */
 895   0,                              /* tp_getset */
 896   0,                              /* tp_base */
 897   0,                              /* tp_dict */
 898   0,                              /* tp_descr_get */
 899   0,                              /* tp_descr_set */
 900   offsetof (field_object, dict),  /* tp_dictoffset */
 901   0,                              /* tp_init */
 902   0,                              /* tp_alloc */
 903   0,                              /* tp_new */
 904 };