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, "type does not have a target");
 366       return NULL;
 367     }
 368
 369   return type_to_type_object (TYPE_TARGET_TYPE (type));
 370 }
 371
 372 /* Return a const-qualified type variant.  */
 373 static PyObject *
 374 typy_const (PyObject *self, PyObject *args)
 375 {
 376   struct type *type = ((type_object *) self)->type;
 377   volatile struct gdb_exception except;
 378
 379   TRY_CATCH (except, RETURN_MASK_ALL)
 380     {
 381       type = make_cv_type (1, 0, type, NULL);
 382     }
 383   GDB_PY_HANDLE_EXCEPTION (except);
 384
 385   return type_to_type_object (type);
 386 }
 387
 388 /* Return a volatile-qualified type variant.  */
 389 static PyObject *
 390 typy_volatile (PyObject *self, PyObject *args)
 391 {
 392   struct type *type = ((type_object *) self)->type;
 393   volatile struct gdb_exception except;
 394
 395   TRY_CATCH (except, RETURN_MASK_ALL)
 396     {
 397       type = make_cv_type (0, 1, type, NULL);
 398     }
 399   GDB_PY_HANDLE_EXCEPTION (except);
 400
 401   return type_to_type_object (type);
 402 }
 403
 404 /* Return an unqualified type variant.  */
 405 static PyObject *
 406 typy_unqualified (PyObject *self, PyObject *args)
 407 {
 408   struct type *type = ((type_object *) self)->type;
 409   volatile struct gdb_exception except;
 410
 411   TRY_CATCH (except, RETURN_MASK_ALL)
 412     {
 413       type = make_cv_type (0, 0, type, NULL);
 414     }
 415   GDB_PY_HANDLE_EXCEPTION (except);
 416
 417   return type_to_type_object (type);
 418 }
 419
 420 /* Return the size of the type represented by SELF, in bytes.  */
 421 static PyObject *
 422 typy_get_sizeof (PyObject *self, void *closure)
 423 {
 424   struct type *type = ((type_object *) self)->type;
 425   volatile struct gdb_exception except;
 426
 427   TRY_CATCH (except, RETURN_MASK_ALL)
 428     {
 429       check_typedef (type);
 430     }
 431   /* Ignore exceptions.  */
 432
 433   return PyLong_FromLong (TYPE_LENGTH (type));
 434 }
 435
 436 static struct type *
 437 typy_lookup_typename (char *type_name, struct block *block)
 438 {
 439   struct type *type = NULL;
 440   volatile struct gdb_exception except;
 441   TRY_CATCH (except, RETURN_MASK_ALL)
 442     {
 443       if (!strncmp (type_name, "struct ", 7))
 444         type = lookup_struct (type_name + 7, NULL);
 445       else if (!strncmp (type_name, "union ", 6))
 446         type = lookup_union (type_name + 6, NULL);
 447       else if (!strncmp (type_name, "enum ", 5))
 448         type = lookup_enum (type_name + 5, NULL);
 449       else
 450         type = lookup_typename (python_language, python_gdbarch,
 451                                 type_name, block, 0);
 452     }
 453   if (except.reason < 0)
 454     {
 455       PyErr_Format (except.reason == RETURN_QUIT
 456                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 457                     "%s", except.message);
 458       return NULL;
 459     }
 460
 461   return type;
 462 }
 463
 464 static struct type *
 465 typy_lookup_type (struct demangle_component *demangled,
 466                   struct block *block)
 467 {
 468   struct type *type;
 469   char *type_name;
 470   enum demangle_component_type demangled_type;
 471
 472   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 473      memory pointed by demangled.  */
 474   demangled_type = demangled->type;
 475
 476   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 477       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 478       || demangled_type == DEMANGLE_COMPONENT_CONST
 479       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 480     {
 481       type = typy_lookup_type (demangled->u.s_binary.left, block);
 482       if (! type)
 483         return NULL;
 484
 485       switch (demangled_type)
 486         {
 487         case DEMANGLE_COMPONENT_REFERENCE:
 488           return lookup_reference_type (type);
 489         case DEMANGLE_COMPONENT_POINTER:
 490           return lookup_pointer_type (type);
 491         case DEMANGLE_COMPONENT_CONST:
 492           return make_cv_type (1, 0, type, NULL);
 493         case DEMANGLE_COMPONENT_VOLATILE:
 494           return make_cv_type (0, 1, type, NULL);
 495         }
 496     }
 497
 498   type_name = cp_comp_to_string (demangled, 10);
 499   type = typy_lookup_typename (type_name, block);
 500   xfree (type_name);
 501
 502   return type;
 503 }
 504
 505 static PyObject *
 506 typy_template_argument (PyObject *self, PyObject *args)
 507 {
 508   int i, argno, n_pointers;
 509   struct type *type = ((type_object *) self)->type;
 510   struct demangle_component *demangled;
 511   const char *err;
 512   struct type *argtype;
 513   struct block *block = NULL;
 514   PyObject *block_obj = NULL;
 515
 516   if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
 517     return NULL;
 518
 519   if (block_obj)
 520     {
 521       block = block_object_to_block (block_obj);
 522       if (! block)
 523         {
 524           PyErr_SetString (PyExc_RuntimeError,
 525                            _("Second argument must be block."));
 526           return NULL;
 527         }
 528     }
 529
 530   type = check_typedef (type);
 531   if (TYPE_CODE (type) == TYPE_CODE_REF)
 532     type = check_typedef (TYPE_TARGET_TYPE (type));
 533
 534   if (TYPE_NAME (type) == NULL)
 535     {
 536       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 537       return NULL;
 538     }
 539
 540   /* Note -- this is not thread-safe.  */
 541   demangled = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
 542   if (! demangled)
 543     {
 544       PyErr_SetString (PyExc_RuntimeError, err);
 545       return NULL;
 546     }
 547
 548   /* Strip off component names.  */
 549   while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
 550          || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 551     demangled = demangled->u.s_binary.right;
 552
 553   if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
 554     {
 555       PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
 556       return NULL;
 557     }
 558
 559   /* Skip from the template to the arguments.  */
 560   demangled = demangled->u.s_binary.right;
 561
 562   for (i = 0; demangled && i < argno; ++i)
 563     demangled = demangled->u.s_binary.right;
 564
 565   if (! demangled)
 566     {
 567       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 568                     argno);
 569       return NULL;
 570     }
 571
 572   argtype = typy_lookup_type (demangled->u.s_binary.left, block);
 573   if (! argtype)
 574     return NULL;
 575
 576   return type_to_type_object (argtype);
 577 }
 578
 579 static PyObject *
 580 typy_str (PyObject *self)
 581 {
 582   volatile struct gdb_exception except;
 583   char *thetype = NULL;
 584   long length = 0;
 585   PyObject *result;
 586
 587   TRY_CATCH (except, RETURN_MASK_ALL)
 588     {
 589       struct cleanup *old_chain;
 590       struct ui_file *stb;
 591
 592       stb = mem_fileopen ();
 593       old_chain = make_cleanup_ui_file_delete (stb);
 594
 595       type_print (type_object_to_type (self), "", stb, -1);
 596
 597       thetype = ui_file_xstrdup (stb, &length);
 598       do_cleanups (old_chain);
 599     }
 600   if (except.reason < 0)
 601     {
 602       xfree (thetype);
 603       GDB_PY_HANDLE_EXCEPTION (except);
 604     }
 605
 606   result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
 607   xfree (thetype);
 608
 609   return result;
 610 }
 611
 612 \f
 613
 614 static const struct objfile_data *typy_objfile_data_key;
 615
 616 static void
 617 save_objfile_types (struct objfile *objfile, void *datum)
 618 {
 619   type_object *obj = datum;
 620   htab_t copied_types;
 621   struct cleanup *cleanup;
 622
 623   /* This prevents another thread from freeing the objects we're
 624      operating on.  */
 625   cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
 626
 627   copied_types = create_copied_types_hash (objfile);
 628
 629   while (obj)
 630     {
 631       type_object *next = obj->next;
 632
 633       htab_empty (copied_types);
 634
 635       obj->type = copy_type_recursive (objfile, obj->type, copied_types);
 636
 637       obj->next = NULL;
 638       obj->prev = NULL;
 639
 640       obj = next;
 641     }
 642
 643   htab_delete (copied_types);
 644
 645   do_cleanups (cleanup);
 646 }
 647
 648 static void
 649 set_type (type_object *obj, struct type *type)
 650 {
 651   obj->type = type;
 652   obj->prev = NULL;
 653   if (type && TYPE_OBJFILE (type))
 654     {
 655       struct objfile *objfile = TYPE_OBJFILE (type);
 656
 657       obj->next = objfile_data (objfile, typy_objfile_data_key);
 658       if (obj->next)
 659         obj->next->prev = obj;
 660       set_objfile_data (objfile, typy_objfile_data_key, obj);
 661     }
 662   else
 663     obj->next = NULL;
 664 }
 665
 666 static void
 667 typy_dealloc (PyObject *obj)
 668 {
 669   type_object *type = (type_object *) obj;
 670
 671   if (type->prev)
 672     type->prev->next = type->next;
 673   else if (type->type && TYPE_OBJFILE (type->type))
 674     {
 675       /* Must reset head of list.  */
 676       struct objfile *objfile = TYPE_OBJFILE (type->type);
 677       if (objfile)
 678         set_objfile_data (objfile, typy_objfile_data_key, type->next);
 679     }
 680   if (type->next)
 681     type->next->prev = type->prev;
 682
 683   type->ob_type->tp_free (type);
 684 }
 685
 686 /* Create a new Type referring to TYPE.  */
 687 PyObject *
 688 type_to_type_object (struct type *type)
 689 {
 690   type_object *type_obj;
 691
 692   type_obj = PyObject_New (type_object, &type_object_type);
 693   if (type_obj)
 694     set_type (type_obj, type);
 695
 696   return (PyObject *) type_obj;
 697 }
 698
 699 struct type *
 700 type_object_to_type (PyObject *obj)
 701 {
 702   if (! PyObject_TypeCheck (obj, &type_object_type))
 703     return NULL;
 704   return ((type_object *) obj)->type;
 705 }
 706
 707 \f
 708
 709 /* Implementation of gdb.lookup_type.  */
 710 PyObject *
 711 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
 712 {
 713   static char *keywords[] = { "name", "block", NULL };
 714   char *type_name = NULL;
 715   struct type *type = NULL;
 716   PyObject *block_obj = NULL;
 717   struct block *block = NULL;
 718
 719   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
 720                                      &type_name, &block_obj))
 721     return NULL;
 722
 723   if (block_obj)
 724     {
 725       block = block_object_to_block (block_obj);
 726       if (! block)
 727         {
 728           PyErr_SetString (PyExc_RuntimeError,
 729                            _("'block' argument must be a Block."));
 730           return NULL;
 731         }
 732     }
 733
 734   type = typy_lookup_typename (type_name, block);
 735   if (! type)
 736     return NULL;
 737
 738   return (PyObject *) type_to_type_object (type);
 739 }
 740
 741 void
 742 gdbpy_initialize_types (void)
 743 {
 744   int i;
 745
 746   typy_objfile_data_key
 747     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
 748
 749   if (PyType_Ready (&type_object_type) < 0)
 750     return;
 751   if (PyType_Ready (&field_object_type) < 0)
 752     return;
 753
 754   for (i = 0; pyty_codes[i].name; ++i)
 755     {
 756       if (PyModule_AddIntConstant (gdb_module,
 757                                    /* Cast needed for Python 2.4.  */
 758                                    (char *) pyty_codes[i].name,
 759                                    pyty_codes[i].code) < 0)
 760         return;
 761     }
 762
 763   Py_INCREF (&type_object_type);
 764   PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
 765
 766   Py_INCREF (&field_object_type);
 767   PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
 768 }
 769
 770 \f
 771
 772 static PyGetSetDef type_object_getset[] =
 773 {
 774   { "code", typy_get_code, NULL,
 775     "The code for this type.", NULL },
 776   { "sizeof", typy_get_sizeof, NULL,
 777     "The size of this type, in bytes.", NULL },
 778   { "tag", typy_get_tag, NULL,
 779     "The tag name for this type, or None.", NULL },
 780   { NULL }
 781 };
 782
 783 static PyMethodDef type_object_methods[] =
 784 {
 785   { "const", typy_const, METH_NOARGS,
 786     "const () -> Type\n\
 787 Return a const variant of this type." },
 788   { "fields", typy_fields, METH_NOARGS,
 789     "field () -> list\n\
 790 Return a sequence holding all the fields of this type.\n\
 791 Each field is a dictionary." },
 792   { "pointer", typy_pointer, METH_NOARGS,
 793     "pointer () -> Type\n\
 794 Return a type of pointer to this type." },
 795   { "range", typy_range, METH_NOARGS,
 796     "range () -> tuple\n\
 797 Return a tuple containing the lower and upper range for this type."},
 798   { "reference", typy_reference, METH_NOARGS,
 799     "reference () -> Type\n\
 800 Return a type of reference to this type." },
 801   { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
 802     "strip_typedefs () -> Type\n\
 803 Return a type formed by stripping this type of all typedefs."},
 804   { "target", typy_target, METH_NOARGS,
 805     "target () -> Type\n\
 806 Return the target type of this type." },
 807   { "template_argument", typy_template_argument, METH_VARARGS,
 808     "template_argument (arg, [block]) -> Type\n\
 809 Return the type of a template argument." },
 810   { "unqualified", typy_unqualified, METH_NOARGS,
 811     "unqualified () -> Type\n\
 812 Return a variant of this type without const or volatile attributes." },
 813   { "volatile", typy_volatile, METH_NOARGS,
 814     "volatile () -> Type\n\
 815 Return a volatile variant of this type" },
 816   { NULL }
 817 };
 818
 819 static PyTypeObject type_object_type =
 820 {
 821   PyObject_HEAD_INIT (NULL)
 822   0,                              /*ob_size*/
 823   "gdb.Type",                     /*tp_name*/
 824   sizeof (type_object),           /*tp_basicsize*/
 825   0,                              /*tp_itemsize*/
 826   typy_dealloc,                   /*tp_dealloc*/
 827   0,                              /*tp_print*/
 828   0,                              /*tp_getattr*/
 829   0,                              /*tp_setattr*/
 830   0,                              /*tp_compare*/
 831   0,                              /*tp_repr*/
 832   0,                              /*tp_as_number*/
 833   0,                              /*tp_as_sequence*/
 834   0,                              /*tp_as_mapping*/
 835   0,                              /*tp_hash */
 836   0,                              /*tp_call*/
 837   typy_str,                       /*tp_str*/
 838   0,                              /*tp_getattro*/
 839   0,                              /*tp_setattro*/
 840   0,                              /*tp_as_buffer*/
 841   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
 842   "GDB type object",              /* tp_doc */
 843   0,                              /* tp_traverse */
 844   0,                              /* tp_clear */
 845   0,                              /* tp_richcompare */
 846   0,                              /* tp_weaklistoffset */
 847   0,                              /* tp_iter */
 848   0,                              /* tp_iternext */
 849   type_object_methods,            /* tp_methods */
 850   0,                              /* tp_members */
 851   type_object_getset,             /* tp_getset */
 852   0,                              /* tp_base */
 853   0,                              /* tp_dict */
 854   0,                              /* tp_descr_get */
 855   0,                              /* tp_descr_set */
 856   0,                              /* tp_dictoffset */
 857   0,                              /* tp_init */
 858   0,                              /* tp_alloc */
 859   0,                              /* tp_new */
 860 };
 861
 862 static PyTypeObject field_object_type =
 863 {
 864   PyObject_HEAD_INIT (NULL)
 865   0,                              /*ob_size*/
 866   "gdb.Field",                    /*tp_name*/
 867   sizeof (field_object),          /*tp_basicsize*/
 868   0,                              /*tp_itemsize*/
 869   field_dealloc,                  /*tp_dealloc*/
 870   0,                              /*tp_print*/
 871   0,                              /*tp_getattr*/
 872   0,                              /*tp_setattr*/
 873   0,                              /*tp_compare*/
 874   0,                              /*tp_repr*/
 875   0,                              /*tp_as_number*/
 876   0,                              /*tp_as_sequence*/
 877   0,                              /*tp_as_mapping*/
 878   0,                              /*tp_hash */
 879   0,                              /*tp_call*/
 880   0,                              /*tp_str*/
 881   0,                              /*tp_getattro*/
 882   0,                              /*tp_setattro*/
 883   0,                              /*tp_as_buffer*/
 884   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
 885   "GDB field object",             /* tp_doc */
 886   0,                              /* tp_traverse */
 887   0,                              /* tp_clear */
 888   0,                              /* tp_richcompare */
 889   0,                              /* tp_weaklistoffset */
 890   0,                              /* tp_iter */
 891   0,                              /* tp_iternext */
 892   0,                              /* tp_methods */
 893   0,                              /* tp_members */
 894   0,                              /* tp_getset */
 895   0,                              /* tp_base */
 896   0,                              /* tp_dict */
 897   0,                              /* tp_descr_get */
 898   0,                              /* tp_descr_set */
 899   offsetof (field_object, dict),  /* tp_dictoffset */
 900   0,                              /* tp_init */
 901   0,                              /* tp_alloc */
 902   0,                              /* tp_new */
 903 };