gdb/python/py-type.c

   1 /* Python interface to types.
   2
   3    Copyright (C) 2008-2019 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 "python-internal.h"
  23 #include "charset.h"
  24 #include "gdbtypes.h"
  25 #include "cp-support.h"
  26 #include "demangle.h"
  27 #include "objfiles.h"
  28 #include "language.h"
  29 #include "gdbsupport/vec.h"
  30 #include "typeprint.h"
  31
  32 typedef struct pyty_type_object
  33 {
  34   PyObject_HEAD
  35   struct type *type;
  36
  37   /* If a Type object is associated with an objfile, it is kept on a
  38      doubly-linked list, rooted in the objfile.  This lets us copy the
  39      underlying struct type when the objfile is deleted.  */
  40   struct pyty_type_object *prev;
  41   struct pyty_type_object *next;
  42 } type_object;
  43
  44 extern PyTypeObject type_object_type
  45     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
  46
  47 /* A Field object.  */
  48 typedef struct pyty_field_object
  49 {
  50   PyObject_HEAD
  51
  52   /* Dictionary holding our attributes.  */
  53   PyObject *dict;
  54 } field_object;
  55
  56 extern PyTypeObject field_object_type
  57     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
  58
  59 /* A type iterator object.  */
  60 typedef struct {
  61   PyObject_HEAD
  62   /* The current field index.  */
  63   int field;
  64   /* What to return.  */
  65   enum gdbpy_iter_kind kind;
  66   /* Pointer back to the original source type object.  */
  67   struct pyty_type_object *source;
  68 } typy_iterator_object;
  69
  70 extern PyTypeObject type_iterator_object_type
  71     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
  72
  73 /* This is used to initialize various gdb.TYPE_ constants.  */
  74 struct pyty_code
  75 {
  76   /* The code.  */
  77   enum type_code code;
  78   /* The name.  */
  79   const char *name;
  80 };
  81
  82 /* Forward declarations.  */
  83 static PyObject *typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind);
  84
  85 #define ENTRY(X) { X, #X }
  86
  87 static struct pyty_code pyty_codes[] =
  88 {
  89   ENTRY (TYPE_CODE_BITSTRING),
  90   ENTRY (TYPE_CODE_PTR),
  91   ENTRY (TYPE_CODE_ARRAY),
  92   ENTRY (TYPE_CODE_STRUCT),
  93   ENTRY (TYPE_CODE_UNION),
  94   ENTRY (TYPE_CODE_ENUM),
  95   ENTRY (TYPE_CODE_FLAGS),
  96   ENTRY (TYPE_CODE_FUNC),
  97   ENTRY (TYPE_CODE_INT),
  98   ENTRY (TYPE_CODE_FLT),
  99   ENTRY (TYPE_CODE_VOID),
 100   ENTRY (TYPE_CODE_SET),
 101   ENTRY (TYPE_CODE_RANGE),
 102   ENTRY (TYPE_CODE_STRING),
 103   ENTRY (TYPE_CODE_ERROR),
 104   ENTRY (TYPE_CODE_METHOD),
 105   ENTRY (TYPE_CODE_METHODPTR),
 106   ENTRY (TYPE_CODE_MEMBERPTR),
 107   ENTRY (TYPE_CODE_REF),
 108   ENTRY (TYPE_CODE_RVALUE_REF),
 109   ENTRY (TYPE_CODE_CHAR),
 110   ENTRY (TYPE_CODE_BOOL),
 111   ENTRY (TYPE_CODE_COMPLEX),
 112   ENTRY (TYPE_CODE_TYPEDEF),
 113   ENTRY (TYPE_CODE_NAMESPACE),
 114   ENTRY (TYPE_CODE_DECFLOAT),
 115   ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
 116   { TYPE_CODE_UNDEF, NULL }
 117 };
 118
 119 \f
 120
 121 static void
 122 field_dealloc (PyObject *obj)
 123 {
 124   field_object *f = (field_object *) obj;
 125
 126   Py_XDECREF (f->dict);
 127   Py_TYPE (obj)->tp_free (obj);
 128 }
 129
 130 static PyObject *
 131 field_new (void)
 132 {
 133   gdbpy_ref<field_object> result (PyObject_New (field_object,
 134                                                 &field_object_type));
 135
 136   if (result != NULL)
 137     {
 138       result->dict = PyDict_New ();
 139       if (!result->dict)
 140         return NULL;
 141     }
 142   return (PyObject *) result.release ();
 143 }
 144
 145 \f
 146
 147 /* Return true if OBJ is of type gdb.Field, false otherwise.  */
 148
 149 int
 150 gdbpy_is_field (PyObject *obj)
 151 {
 152   return PyObject_TypeCheck (obj, &field_object_type);
 153 }
 154
 155 /* Return the code for this type.  */
 156 static PyObject *
 157 typy_get_code (PyObject *self, void *closure)
 158 {
 159   struct type *type = ((type_object *) self)->type;
 160
 161   return PyInt_FromLong (TYPE_CODE (type));
 162 }
 163
 164 /* Helper function for typy_fields which converts a single field to a
 165    gdb.Field object.  Returns NULL on error.  */
 166
 167 static gdbpy_ref<>
 168 convert_field (struct type *type, int field)
 169 {
 170   gdbpy_ref<> result (field_new ());
 171
 172   if (result == NULL)
 173     return NULL;
 174
 175   gdbpy_ref<> arg (type_to_type_object (type));
 176   if (arg == NULL)
 177     return NULL;
 178   if (PyObject_SetAttrString (result.get (), "parent_type", arg.get ()) < 0)
 179     return NULL;
 180
 181   if (!field_is_static (&TYPE_FIELD (type, field)))
 182     {
 183       const char *attrstring;
 184
 185       if (TYPE_CODE (type) == TYPE_CODE_ENUM)
 186         {
 187           arg.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type,
 188                                                                    field)));
 189           attrstring = "enumval";
 190         }
 191       else
 192         {
 193           arg.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type,
 194                                                                   field)));
 195           attrstring = "bitpos";
 196         }
 197
 198       if (arg == NULL)
 199         return NULL;
 200
 201       if (PyObject_SetAttrString (result.get (), attrstring, arg.get ()) < 0)
 202         return NULL;
 203     }
 204
 205   arg.reset (NULL);
 206   if (TYPE_FIELD_NAME (type, field))
 207     {
 208       const char *field_name = TYPE_FIELD_NAME (type, field);
 209
 210       if (field_name[0] != '\0')
 211         {
 212           arg.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
 213           if (arg == NULL)
 214             return NULL;
 215         }
 216     }
 217   if (arg == NULL)
 218     arg = gdbpy_ref<>::new_reference (Py_None);
 219
 220   if (PyObject_SetAttrString (result.get (), "name", arg.get ()) < 0)
 221     return NULL;
 222
 223   arg = gdbpy_ref<>::new_reference (TYPE_FIELD_ARTIFICIAL (type, field)
 224                                     ? Py_True : Py_False);
 225   if (PyObject_SetAttrString (result.get (), "artificial", arg.get ()) < 0)
 226     return NULL;
 227
 228   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 229     arg = gdbpy_ref<>::new_reference (field < TYPE_N_BASECLASSES (type)
 230                                       ? Py_True : Py_False);
 231   else
 232     arg = gdbpy_ref<>::new_reference (Py_False);
 233   if (PyObject_SetAttrString (result.get (), "is_base_class", arg.get ()) < 0)
 234     return NULL;
 235
 236   arg.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field)));
 237   if (arg == NULL)
 238     return NULL;
 239   if (PyObject_SetAttrString (result.get (), "bitsize", arg.get ()) < 0)
 240     return NULL;
 241
 242   /* A field can have a NULL type in some situations.  */
 243   if (TYPE_FIELD_TYPE (type, field) == NULL)
 244     arg = gdbpy_ref<>::new_reference (Py_None);
 245   else
 246     arg.reset (type_to_type_object (TYPE_FIELD_TYPE (type, field)));
 247   if (arg == NULL)
 248     return NULL;
 249   if (PyObject_SetAttrString (result.get (), "type", arg.get ()) < 0)
 250     return NULL;
 251
 252   return result;
 253 }
 254
 255 /* Helper function to return the name of a field, as a gdb.Field object.
 256    If the field doesn't have a name, None is returned.  */
 257
 258 static gdbpy_ref<>
 259 field_name (struct type *type, int field)
 260 {
 261   gdbpy_ref<> result;
 262
 263   if (TYPE_FIELD_NAME (type, field))
 264     result.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
 265   else
 266     result = gdbpy_ref<>::new_reference (Py_None);
 267
 268   return result;
 269 }
 270
 271 /* Helper function for Type standard mapping methods.  Returns a
 272    Python object for field i of the type.  "kind" specifies what to
 273    return: the name of the field, a gdb.Field object corresponding to
 274    the field, or a tuple consisting of field name and gdb.Field
 275    object.  */
 276
 277 static gdbpy_ref<>
 278 make_fielditem (struct type *type, int i, enum gdbpy_iter_kind kind)
 279 {
 280   switch (kind)
 281     {
 282     case iter_items:
 283       {
 284         gdbpy_ref<> key (field_name (type, i));
 285         if (key == NULL)
 286           return NULL;
 287         gdbpy_ref<> value = convert_field (type, i);
 288         if (value == NULL)
 289           return NULL;
 290         gdbpy_ref<> item (PyTuple_New (2));
 291         if (item == NULL)
 292           return NULL;
 293         PyTuple_SET_ITEM (item.get (), 0, key.release ());
 294         PyTuple_SET_ITEM (item.get (), 1, value.release ());
 295         return item;
 296       }
 297     case iter_keys:
 298       return field_name (type, i);
 299     case iter_values:
 300       return convert_field (type, i);
 301     }
 302   gdb_assert_not_reached ("invalid gdbpy_iter_kind");
 303 }
 304
 305 /* Return a sequence of all field names, fields, or (name, field) pairs.
 306    Each field is a gdb.Field object.  */
 307
 308 static PyObject *
 309 typy_fields_items (PyObject *self, enum gdbpy_iter_kind kind)
 310 {
 311   PyObject *py_type = self;
 312   struct type *type = ((type_object *) py_type)->type;
 313   struct type *checked_type = type;
 314
 315   try
 316     {
 317       checked_type = check_typedef (checked_type);
 318     }
 319   catch (const gdb_exception &except)
 320     {
 321       GDB_PY_HANDLE_EXCEPTION (except);
 322     }
 323
 324   gdbpy_ref<> type_holder;
 325   if (checked_type != type)
 326     {
 327       type_holder.reset (type_to_type_object (checked_type));
 328       if (type_holder == nullptr)
 329         return nullptr;
 330       py_type = type_holder.get ();
 331     }
 332   gdbpy_ref<> iter (typy_make_iter (py_type, kind));
 333   if (iter == nullptr)
 334     return nullptr;
 335
 336   return PySequence_List (iter.get ());
 337 }
 338
 339 /* Return a sequence of all fields.  Each field is a gdb.Field object.  */
 340
 341 static PyObject *
 342 typy_values (PyObject *self, PyObject *args)
 343 {
 344   return typy_fields_items (self, iter_values);
 345 }
 346
 347 /* Return a sequence of all fields.  Each field is a gdb.Field object.
 348    This method is similar to typy_values, except where the supplied
 349    gdb.Type is an array, in which case it returns a list of one entry
 350    which is a gdb.Field object for a range (the array bounds).  */
 351
 352 static PyObject *
 353 typy_fields (PyObject *self, PyObject *args)
 354 {
 355   struct type *type = ((type_object *) self)->type;
 356
 357   if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
 358     return typy_fields_items (self, iter_values);
 359
 360   /* Array type.  Handle this as a special case because the common
 361      machinery wants struct or union or enum types.  Build a list of
 362      one entry which is the range for the array.  */
 363   gdbpy_ref<> r = convert_field (type, 0);
 364   if (r == NULL)
 365     return NULL;
 366
 367   return Py_BuildValue ("[O]", r.get ());
 368 }
 369
 370 /* Return a sequence of all field names.  Each field is a gdb.Field object.  */
 371
 372 static PyObject *
 373 typy_field_names (PyObject *self, PyObject *args)
 374 {
 375   return typy_fields_items (self, iter_keys);
 376 }
 377
 378 /* Return a sequence of all (name, fields) pairs.  Each field is a
 379    gdb.Field object.  */
 380
 381 static PyObject *
 382 typy_items (PyObject *self, PyObject *args)
 383 {
 384   return typy_fields_items (self, iter_items);
 385 }
 386
 387 /* Return the type's name, or None.  */
 388
 389 static PyObject *
 390 typy_get_name (PyObject *self, void *closure)
 391 {
 392   struct type *type = ((type_object *) self)->type;
 393
 394   if (TYPE_NAME (type) == NULL)
 395     Py_RETURN_NONE;
 396   return PyString_FromString (TYPE_NAME (type));
 397 }
 398
 399 /* Return the type's tag, or None.  */
 400 static PyObject *
 401 typy_get_tag (PyObject *self, void *closure)
 402 {
 403   struct type *type = ((type_object *) self)->type;
 404   const char *tagname = nullptr;
 405
 406   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 407       || TYPE_CODE (type) == TYPE_CODE_UNION
 408       || TYPE_CODE (type) == TYPE_CODE_ENUM)
 409     tagname = TYPE_NAME (type);
 410
 411   if (tagname == nullptr)
 412     Py_RETURN_NONE;
 413   return PyString_FromString (tagname);
 414 }
 415
 416 /* Return the type's objfile, or None.  */
 417 static PyObject *
 418 typy_get_objfile (PyObject *self, void *closure)
 419 {
 420   struct type *type = ((type_object *) self)->type;
 421   struct objfile *objfile = TYPE_OBJFILE (type);
 422
 423   if (objfile == nullptr)
 424     Py_RETURN_NONE;
 425   return objfile_to_objfile_object (objfile).release ();
 426 }
 427
 428 /* Return the type, stripped of typedefs. */
 429 static PyObject *
 430 typy_strip_typedefs (PyObject *self, PyObject *args)
 431 {
 432   struct type *type = ((type_object *) self)->type;
 433
 434   try
 435     {
 436       type = check_typedef (type);
 437     }
 438   catch (const gdb_exception &except)
 439     {
 440       GDB_PY_HANDLE_EXCEPTION (except);
 441     }
 442
 443   return type_to_type_object (type);
 444 }
 445
 446 /* Strip typedefs and pointers/reference from a type.  Then check that
 447    it is a struct, union, or enum type.  If not, raise TypeError.  */
 448
 449 static struct type *
 450 typy_get_composite (struct type *type)
 451 {
 452
 453   for (;;)
 454     {
 455       try
 456         {
 457           type = check_typedef (type);
 458         }
 459       catch (const gdb_exception &except)
 460         {
 461           GDB_PY_HANDLE_EXCEPTION (except);
 462         }
 463
 464       if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
 465         break;
 466       type = TYPE_TARGET_TYPE (type);
 467     }
 468
 469   /* If this is not a struct, union, or enum type, raise TypeError
 470      exception.  */
 471   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 472       && TYPE_CODE (type) != TYPE_CODE_UNION
 473       && TYPE_CODE (type) != TYPE_CODE_ENUM
 474       && TYPE_CODE (type) != TYPE_CODE_FUNC)
 475     {
 476       PyErr_SetString (PyExc_TypeError,
 477                        "Type is not a structure, union, enum, or function type.");
 478       return NULL;
 479     }
 480
 481   return type;
 482 }
 483
 484 /* Helper for typy_array and typy_vector.  */
 485
 486 static PyObject *
 487 typy_array_1 (PyObject *self, PyObject *args, int is_vector)
 488 {
 489   long n1, n2;
 490   PyObject *n2_obj = NULL;
 491   struct type *array = NULL;
 492   struct type *type = ((type_object *) self)->type;
 493
 494   if (! PyArg_ParseTuple (args, "l|O", &n1, &n2_obj))
 495     return NULL;
 496
 497   if (n2_obj)
 498     {
 499       if (!PyInt_Check (n2_obj))
 500         {
 501           PyErr_SetString (PyExc_RuntimeError,
 502                            _("Array bound must be an integer"));
 503           return NULL;
 504         }
 505
 506       if (! gdb_py_int_as_long (n2_obj, &n2))
 507         return NULL;
 508     }
 509   else
 510     {
 511       n2 = n1;
 512       n1 = 0;
 513     }
 514
 515   if (n2 < n1 - 1) /* Note: An empty array has n2 == n1 - 1.  */
 516     {
 517       PyErr_SetString (PyExc_ValueError,
 518                        _("Array length must not be negative"));
 519       return NULL;
 520     }
 521
 522   try
 523     {
 524       array = lookup_array_range_type (type, n1, n2);
 525       if (is_vector)
 526         make_vector_type (array);
 527     }
 528   catch (const gdb_exception &except)
 529     {
 530       GDB_PY_HANDLE_EXCEPTION (except);
 531     }
 532
 533   return type_to_type_object (array);
 534 }
 535
 536 /* Return an array type.  */
 537
 538 static PyObject *
 539 typy_array (PyObject *self, PyObject *args)
 540 {
 541   return typy_array_1 (self, args, 0);
 542 }
 543
 544 /* Return a vector type.  */
 545
 546 static PyObject *
 547 typy_vector (PyObject *self, PyObject *args)
 548 {
 549   return typy_array_1 (self, args, 1);
 550 }
 551
 552 /* Return a Type object which represents a pointer to SELF.  */
 553 static PyObject *
 554 typy_pointer (PyObject *self, PyObject *args)
 555 {
 556   struct type *type = ((type_object *) self)->type;
 557
 558   try
 559     {
 560       type = lookup_pointer_type (type);
 561     }
 562   catch (const gdb_exception &except)
 563     {
 564       GDB_PY_HANDLE_EXCEPTION (except);
 565     }
 566
 567   return type_to_type_object (type);
 568 }
 569
 570 /* Return the range of a type represented by SELF.  The return type is
 571    a tuple.  The first element of the tuple contains the low bound,
 572    while the second element of the tuple contains the high bound.  */
 573 static PyObject *
 574 typy_range (PyObject *self, PyObject *args)
 575 {
 576   struct type *type = ((type_object *) self)->type;
 577   /* Initialize these to appease GCC warnings.  */
 578   LONGEST low = 0, high = 0;
 579
 580   if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 581       && TYPE_CODE (type) != TYPE_CODE_STRING
 582       && TYPE_CODE (type) != TYPE_CODE_RANGE)
 583     {
 584       PyErr_SetString (PyExc_RuntimeError,
 585                        _("This type does not have a range."));
 586       return NULL;
 587     }
 588
 589   switch (TYPE_CODE (type))
 590     {
 591     case TYPE_CODE_ARRAY:
 592     case TYPE_CODE_STRING:
 593       low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
 594       high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type));
 595       break;
 596     case TYPE_CODE_RANGE:
 597       low = TYPE_LOW_BOUND (type);
 598       high = TYPE_HIGH_BOUND (type);
 599       break;
 600     }
 601
 602   gdbpy_ref<> low_bound (PyLong_FromLong (low));
 603   if (low_bound == NULL)
 604     return NULL;
 605
 606   gdbpy_ref<> high_bound (PyLong_FromLong (high));
 607   if (high_bound == NULL)
 608     return NULL;
 609
 610   gdbpy_ref<> result (PyTuple_New (2));
 611   if (result == NULL)
 612     return NULL;
 613
 614   if (PyTuple_SetItem (result.get (), 0, low_bound.release ()) != 0
 615       || PyTuple_SetItem (result.get (), 1, high_bound.release ()) != 0)
 616     return NULL;
 617   return result.release ();
 618 }
 619
 620 /* Return a Type object which represents a reference to SELF.  */
 621 static PyObject *
 622 typy_reference (PyObject *self, PyObject *args)
 623 {
 624   struct type *type = ((type_object *) self)->type;
 625
 626   try
 627     {
 628       type = lookup_lvalue_reference_type (type);
 629     }
 630   catch (const gdb_exception &except)
 631     {
 632       GDB_PY_HANDLE_EXCEPTION (except);
 633     }
 634
 635   return type_to_type_object (type);
 636 }
 637
 638 /* Return a Type object which represents the target type of SELF.  */
 639 static PyObject *
 640 typy_target (PyObject *self, PyObject *args)
 641 {
 642   struct type *type = ((type_object *) self)->type;
 643
 644   if (!TYPE_TARGET_TYPE (type))
 645     {
 646       PyErr_SetString (PyExc_RuntimeError,
 647                        _("Type does not have a target."));
 648       return NULL;
 649     }
 650
 651   return type_to_type_object (TYPE_TARGET_TYPE (type));
 652 }
 653
 654 /* Return a const-qualified type variant.  */
 655 static PyObject *
 656 typy_const (PyObject *self, PyObject *args)
 657 {
 658   struct type *type = ((type_object *) self)->type;
 659
 660   try
 661     {
 662       type = make_cv_type (1, 0, type, NULL);
 663     }
 664   catch (const gdb_exception &except)
 665     {
 666       GDB_PY_HANDLE_EXCEPTION (except);
 667     }
 668
 669   return type_to_type_object (type);
 670 }
 671
 672 /* Return a volatile-qualified type variant.  */
 673 static PyObject *
 674 typy_volatile (PyObject *self, PyObject *args)
 675 {
 676   struct type *type = ((type_object *) self)->type;
 677
 678   try
 679     {
 680       type = make_cv_type (0, 1, type, NULL);
 681     }
 682   catch (const gdb_exception &except)
 683     {
 684       GDB_PY_HANDLE_EXCEPTION (except);
 685     }
 686
 687   return type_to_type_object (type);
 688 }
 689
 690 /* Return an unqualified type variant.  */
 691 static PyObject *
 692 typy_unqualified (PyObject *self, PyObject *args)
 693 {
 694   struct type *type = ((type_object *) self)->type;
 695
 696   try
 697     {
 698       type = make_cv_type (0, 0, type, NULL);
 699     }
 700   catch (const gdb_exception &except)
 701     {
 702       GDB_PY_HANDLE_EXCEPTION (except);
 703     }
 704
 705   return type_to_type_object (type);
 706 }
 707
 708 /* Return the size of the type represented by SELF, in bytes.  */
 709 static PyObject *
 710 typy_get_sizeof (PyObject *self, void *closure)
 711 {
 712   struct type *type = ((type_object *) self)->type;
 713
 714   try
 715     {
 716       check_typedef (type);
 717     }
 718   catch (const gdb_exception &except)
 719     {
 720     }
 721
 722   /* Ignore exceptions.  */
 723
 724   return gdb_py_long_from_longest (TYPE_LENGTH (type));
 725 }
 726
 727 /* Return the alignment of the type represented by SELF, in bytes.  */
 728 static PyObject *
 729 typy_get_alignof (PyObject *self, void *closure)
 730 {
 731   struct type *type = ((type_object *) self)->type;
 732
 733   ULONGEST align = 0;
 734   try
 735     {
 736       align = type_align (type);
 737     }
 738   catch (const gdb_exception &except)
 739     {
 740       align = 0;
 741     }
 742
 743   /* Ignore exceptions.  */
 744
 745   return gdb_py_object_from_ulongest (align).release ();
 746 }
 747
 748 static struct type *
 749 typy_lookup_typename (const char *type_name, const struct block *block)
 750 {
 751   struct type *type = NULL;
 752
 753   try
 754     {
 755       if (startswith (type_name, "struct "))
 756         type = lookup_struct (type_name + 7, NULL);
 757       else if (startswith (type_name, "union "))
 758         type = lookup_union (type_name + 6, NULL);
 759       else if (startswith (type_name, "enum "))
 760         type = lookup_enum (type_name + 5, NULL);
 761       else
 762         type = lookup_typename (python_language, python_gdbarch,
 763                                 type_name, block, 0);
 764     }
 765   catch (const gdb_exception &except)
 766     {
 767       GDB_PY_HANDLE_EXCEPTION (except);
 768     }
 769
 770   return type;
 771 }
 772
 773 static struct type *
 774 typy_lookup_type (struct demangle_component *demangled,
 775                   const struct block *block)
 776 {
 777   struct type *type, *rtype = NULL;
 778   enum demangle_component_type demangled_type;
 779
 780   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 781      memory pointed by demangled.  */
 782   demangled_type = demangled->type;
 783
 784   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 785       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 786       || demangled_type == DEMANGLE_COMPONENT_RVALUE_REFERENCE
 787       || demangled_type == DEMANGLE_COMPONENT_CONST
 788       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 789     {
 790       type = typy_lookup_type (demangled->u.s_binary.left, block);
 791       if (! type)
 792         return NULL;
 793
 794       try
 795         {
 796           /* If the demangled_type matches with one of the types
 797              below, run the corresponding function and save the type
 798              to return later.  We cannot just return here as we are in
 799              an exception handler.  */
 800           switch (demangled_type)
 801             {
 802             case DEMANGLE_COMPONENT_REFERENCE:
 803               rtype = lookup_lvalue_reference_type (type);
 804               break;
 805             case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 806               rtype = lookup_rvalue_reference_type (type);
 807               break;
 808             case DEMANGLE_COMPONENT_POINTER:
 809               rtype = lookup_pointer_type (type);
 810               break;
 811             case DEMANGLE_COMPONENT_CONST:
 812               rtype = make_cv_type (1, 0, type, NULL);
 813               break;
 814             case DEMANGLE_COMPONENT_VOLATILE:
 815               rtype = make_cv_type (0, 1, type, NULL);
 816               break;
 817             }
 818         }
 819       catch (const gdb_exception &except)
 820         {
 821           GDB_PY_HANDLE_EXCEPTION (except);
 822         }
 823     }
 824
 825   /* If we have a type from the switch statement above, just return
 826      that.  */
 827   if (rtype)
 828     return rtype;
 829
 830   /* We don't have a type, so lookup the type.  */
 831   gdb::unique_xmalloc_ptr<char> type_name = cp_comp_to_string (demangled, 10);
 832   return typy_lookup_typename (type_name.get (), block);
 833 }
 834
 835 /* This is a helper function for typy_template_argument that is used
 836    when the type does not have template symbols attached.  It works by
 837    parsing the type name.  This happens with compilers, like older
 838    versions of GCC, that do not emit DW_TAG_template_*.  */
 839
 840 static PyObject *
 841 typy_legacy_template_argument (struct type *type, const struct block *block,
 842                                int argno)
 843 {
 844   int i;
 845   struct demangle_component *demangled;
 846   std::unique_ptr<demangle_parse_info> info;
 847   std::string err;
 848   struct type *argtype;
 849
 850   if (TYPE_NAME (type) == NULL)
 851     {
 852       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 853       return NULL;
 854     }
 855
 856   try
 857     {
 858       /* Note -- this is not thread-safe.  */
 859       info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
 860     }
 861   catch (const gdb_exception &except)
 862     {
 863       GDB_PY_HANDLE_EXCEPTION (except);
 864     }
 865
 866   if (! info)
 867     {
 868       PyErr_SetString (PyExc_RuntimeError, err.c_str ());
 869       return NULL;
 870     }
 871   demangled = info->tree;
 872
 873   /* Strip off component names.  */
 874   while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
 875          || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 876     demangled = demangled->u.s_binary.right;
 877
 878   if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
 879     {
 880       PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
 881       return NULL;
 882     }
 883
 884   /* Skip from the template to the arguments.  */
 885   demangled = demangled->u.s_binary.right;
 886
 887   for (i = 0; demangled && i < argno; ++i)
 888     demangled = demangled->u.s_binary.right;
 889
 890   if (! demangled)
 891     {
 892       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 893                     argno);
 894       return NULL;
 895     }
 896
 897   argtype = typy_lookup_type (demangled->u.s_binary.left, block);
 898   if (! argtype)
 899     return NULL;
 900
 901   return type_to_type_object (argtype);
 902 }
 903
 904 static PyObject *
 905 typy_template_argument (PyObject *self, PyObject *args)
 906 {
 907   int argno;
 908   struct type *type = ((type_object *) self)->type;
 909   const struct block *block = NULL;
 910   PyObject *block_obj = NULL;
 911   struct symbol *sym;
 912   struct value *val = NULL;
 913
 914   if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
 915     return NULL;
 916
 917   if (argno < 0)
 918     {
 919       PyErr_SetString (PyExc_RuntimeError,
 920                        _("Template argument number must be non-negative"));
 921       return NULL;
 922     }
 923
 924   if (block_obj)
 925     {
 926       block = block_object_to_block (block_obj);
 927       if (! block)
 928         {
 929           PyErr_SetString (PyExc_RuntimeError,
 930                            _("Second argument must be block."));
 931           return NULL;
 932         }
 933     }
 934
 935   try
 936     {
 937       type = check_typedef (type);
 938       if (TYPE_IS_REFERENCE (type))
 939         type = check_typedef (TYPE_TARGET_TYPE (type));
 940     }
 941   catch (const gdb_exception &except)
 942     {
 943       GDB_PY_HANDLE_EXCEPTION (except);
 944     }
 945
 946   /* We might not have DW_TAG_template_*, so try to parse the type's
 947      name.  This is inefficient if we do not have a template type --
 948      but that is going to wind up as an error anyhow.  */
 949   if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
 950     return typy_legacy_template_argument (type, block, argno);
 951
 952   if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
 953     {
 954       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 955                     argno);
 956       return NULL;
 957     }
 958
 959   sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
 960   if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 961     return type_to_type_object (SYMBOL_TYPE (sym));
 962   else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
 963     {
 964       PyErr_Format (PyExc_RuntimeError,
 965                     _("Template argument is optimized out"));
 966       return NULL;
 967     }
 968
 969   try
 970     {
 971       val = value_of_variable (sym, block);
 972     }
 973   catch (const gdb_exception &except)
 974     {
 975       GDB_PY_HANDLE_EXCEPTION (except);
 976     }
 977
 978   return value_to_value_object (val);
 979 }
 980
 981 static PyObject *
 982 typy_str (PyObject *self)
 983 {
 984   string_file thetype;
 985
 986   try
 987     {
 988       LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
 989                      &type_print_raw_options);
 990     }
 991   catch (const gdb_exception &except)
 992     {
 993       GDB_PY_HANDLE_EXCEPTION (except);
 994     }
 995
 996   return PyUnicode_Decode (thetype.c_str (), thetype.size (),
 997                            host_charset (), NULL);
 998 }
 999
1000 /* Implement the richcompare method.  */
1001
1002 static PyObject *
1003 typy_richcompare (PyObject *self, PyObject *other, int op)
1004 {
1005   bool result = false;
1006   struct type *type1 = type_object_to_type (self);
1007   struct type *type2 = type_object_to_type (other);
1008
1009   /* We can only compare ourselves to another Type object, and only
1010      for equality or inequality.  */
1011   if (type2 == NULL || (op != Py_EQ && op != Py_NE))
1012     {
1013       Py_INCREF (Py_NotImplemented);
1014       return Py_NotImplemented;
1015     }
1016
1017   if (type1 == type2)
1018     result = true;
1019   else
1020     {
1021       try
1022         {
1023           result = types_deeply_equal (type1, type2);
1024         }
1025       catch (const gdb_exception &except)
1026         {
1027           /* If there is a GDB exception, a comparison is not capable
1028              (or trusted), so exit.  */
1029           GDB_PY_HANDLE_EXCEPTION (except);
1030         }
1031     }
1032
1033   if (op == (result ? Py_EQ : Py_NE))
1034     Py_RETURN_TRUE;
1035   Py_RETURN_FALSE;
1036 }
1037
1038 \f
1039
1040 static const struct objfile_data *typy_objfile_data_key;
1041
1042 static void
1043 save_objfile_types (struct objfile *objfile, void *datum)
1044 {
1045   type_object *obj = (type_object *) datum;
1046   htab_t copied_types;
1047
1048   if (!gdb_python_initialized)
1049     return;
1050
1051   /* This prevents another thread from freeing the objects we're
1052      operating on.  */
1053   gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
1054
1055   copied_types = create_copied_types_hash (objfile);
1056
1057   while (obj)
1058     {
1059       type_object *next = obj->next;
1060
1061       htab_empty (copied_types);
1062
1063       obj->type = copy_type_recursive (objfile, obj->type, copied_types);
1064
1065       obj->next = NULL;
1066       obj->prev = NULL;
1067
1068       obj = next;
1069     }
1070
1071   htab_delete (copied_types);
1072 }
1073
1074 static void
1075 set_type (type_object *obj, struct type *type)
1076 {
1077   obj->type = type;
1078   obj->prev = NULL;
1079   if (type && TYPE_OBJFILE (type))
1080     {
1081       struct objfile *objfile = TYPE_OBJFILE (type);
1082
1083       obj->next = ((struct pyty_type_object *)
1084                    objfile_data (objfile, typy_objfile_data_key));
1085       if (obj->next)
1086         obj->next->prev = obj;
1087       set_objfile_data (objfile, typy_objfile_data_key, obj);
1088     }
1089   else
1090     obj->next = NULL;
1091 }
1092
1093 static void
1094 typy_dealloc (PyObject *obj)
1095 {
1096   type_object *type = (type_object *) obj;
1097
1098   if (type->prev)
1099     type->prev->next = type->next;
1100   else if (type->type && TYPE_OBJFILE (type->type))
1101     {
1102       /* Must reset head of list.  */
1103       struct objfile *objfile = TYPE_OBJFILE (type->type);
1104
1105       if (objfile)
1106         set_objfile_data (objfile, typy_objfile_data_key, type->next);
1107     }
1108   if (type->next)
1109     type->next->prev = type->prev;
1110
1111   Py_TYPE (type)->tp_free (type);
1112 }
1113
1114 /* Return number of fields ("length" of the field dictionary).  */
1115
1116 static Py_ssize_t
1117 typy_length (PyObject *self)
1118 {
1119   struct type *type = ((type_object *) self)->type;
1120
1121   type = typy_get_composite (type);
1122   if (type == NULL)
1123     return -1;
1124
1125   return TYPE_NFIELDS (type);
1126 }
1127
1128 /* Implements boolean evaluation of gdb.Type.  Handle this like other
1129    Python objects that don't have a meaningful truth value -- all
1130    values are true.  */
1131
1132 static int
1133 typy_nonzero (PyObject *self)
1134 {
1135   return 1;
1136 }
1137
1138 /* Return optimized out value of this type.  */
1139
1140 static PyObject *
1141 typy_optimized_out (PyObject *self, PyObject *args)
1142 {
1143   struct type *type = ((type_object *) self)->type;
1144
1145   return value_to_value_object (allocate_optimized_out_value (type));
1146 }
1147
1148 /* Return a gdb.Field object for the field named by the argument.  */
1149
1150 static PyObject *
1151 typy_getitem (PyObject *self, PyObject *key)
1152 {
1153   struct type *type = ((type_object *) self)->type;
1154   int i;
1155
1156   gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
1157   if (field == NULL)
1158     return NULL;
1159
1160   /* We want just fields of this type, not of base types, so instead of
1161      using lookup_struct_elt_type, portions of that function are
1162      copied here.  */
1163
1164   type = typy_get_composite (type);
1165   if (type == NULL)
1166     return NULL;
1167
1168   for (i = 0; i < TYPE_NFIELDS (type); i++)
1169     {
1170       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1171
1172       if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
1173         return convert_field (type, i).release ();
1174     }
1175   PyErr_SetObject (PyExc_KeyError, key);
1176   return NULL;
1177 }
1178
1179 /* Implement the "get" method on the type object.  This is the
1180    same as getitem if the key is present, but returns the supplied
1181    default value or None if the key is not found.  */
1182
1183 static PyObject *
1184 typy_get (PyObject *self, PyObject *args)
1185 {
1186   PyObject *key, *defval = Py_None, *result;
1187
1188   if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
1189     return NULL;
1190
1191   result = typy_getitem (self, key);
1192   if (result != NULL)
1193     return result;
1194
1195   /* typy_getitem returned error status.  If the exception is
1196      KeyError, clear the exception status and return the defval
1197      instead.  Otherwise return the exception unchanged.  */
1198   if (!PyErr_ExceptionMatches (PyExc_KeyError))
1199     return NULL;
1200
1201   PyErr_Clear ();
1202   Py_INCREF (defval);
1203   return defval;
1204 }
1205
1206 /* Implement the "has_key" method on the type object.  */
1207
1208 static PyObject *
1209 typy_has_key (PyObject *self, PyObject *args)
1210 {
1211   struct type *type = ((type_object *) self)->type;
1212   const char *field;
1213   int i;
1214
1215   if (!PyArg_ParseTuple (args, "s", &field))
1216     return NULL;
1217
1218   /* We want just fields of this type, not of base types, so instead of
1219      using lookup_struct_elt_type, portions of that function are
1220      copied here.  */
1221
1222   type = typy_get_composite (type);
1223   if (type == NULL)
1224     return NULL;
1225
1226   for (i = 0; i < TYPE_NFIELDS (type); i++)
1227     {
1228       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1229
1230       if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
1231         Py_RETURN_TRUE;
1232     }
1233   Py_RETURN_FALSE;
1234 }
1235
1236 /* Make an iterator object to iterate over keys, values, or items.  */
1237
1238 static PyObject *
1239 typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind)
1240 {
1241   typy_iterator_object *typy_iter_obj;
1242
1243   /* Check that "self" is a structure or union type.  */
1244   if (typy_get_composite (((type_object *) self)->type) == NULL)
1245     return NULL;
1246
1247   typy_iter_obj = PyObject_New (typy_iterator_object,
1248                                 &type_iterator_object_type);
1249   if (typy_iter_obj == NULL)
1250       return NULL;
1251
1252   typy_iter_obj->field = 0;
1253   typy_iter_obj->kind = kind;
1254   Py_INCREF (self);
1255   typy_iter_obj->source = (type_object *) self;
1256
1257   return (PyObject *) typy_iter_obj;
1258 }
1259
1260 /* iteritems() method.  */
1261
1262 static PyObject *
1263 typy_iteritems (PyObject *self, PyObject *args)
1264 {
1265   return typy_make_iter (self, iter_items);
1266 }
1267
1268 /* iterkeys() method.  */
1269
1270 static PyObject *
1271 typy_iterkeys (PyObject *self, PyObject *args)
1272 {
1273   return typy_make_iter (self, iter_keys);
1274 }
1275
1276 /* Iterating over the class, same as iterkeys except for the function
1277    signature.  */
1278
1279 static PyObject *
1280 typy_iter (PyObject *self)
1281 {
1282   return typy_make_iter (self, iter_keys);
1283 }
1284
1285 /* itervalues() method.  */
1286
1287 static PyObject *
1288 typy_itervalues (PyObject *self, PyObject *args)
1289 {
1290   return typy_make_iter (self, iter_values);
1291 }
1292
1293 /* Return a reference to the type iterator.  */
1294
1295 static PyObject *
1296 typy_iterator_iter (PyObject *self)
1297 {
1298   Py_INCREF (self);
1299   return self;
1300 }
1301
1302 /* Return the next field in the iteration through the list of fields
1303    of the type.  */
1304
1305 static PyObject *
1306 typy_iterator_iternext (PyObject *self)
1307 {
1308   typy_iterator_object *iter_obj = (typy_iterator_object *) self;
1309   struct type *type = iter_obj->source->type;
1310
1311   if (iter_obj->field < TYPE_NFIELDS (type))
1312     {
1313       gdbpy_ref<> result = make_fielditem (type, iter_obj->field,
1314                                            iter_obj->kind);
1315       if (result != NULL)
1316         iter_obj->field++;
1317       return result.release ();
1318     }
1319
1320   return NULL;
1321 }
1322
1323 static void
1324 typy_iterator_dealloc (PyObject *obj)
1325 {
1326   typy_iterator_object *iter_obj = (typy_iterator_object *) obj;
1327
1328   Py_DECREF (iter_obj->source);
1329 }
1330
1331 /* Create a new Type referring to TYPE.  */
1332 PyObject *
1333 type_to_type_object (struct type *type)
1334 {
1335   type_object *type_obj;
1336
1337   type_obj = PyObject_New (type_object, &type_object_type);
1338   if (type_obj)
1339     set_type (type_obj, type);
1340
1341   return (PyObject *) type_obj;
1342 }
1343
1344 struct type *
1345 type_object_to_type (PyObject *obj)
1346 {
1347   if (! PyObject_TypeCheck (obj, &type_object_type))
1348     return NULL;
1349   return ((type_object *) obj)->type;
1350 }
1351
1352 \f
1353
1354 /* Implementation of gdb.lookup_type.  */
1355 PyObject *
1356 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
1357 {
1358   static const char *keywords[] = { "name", "block", NULL };
1359   const char *type_name = NULL;
1360   struct type *type = NULL;
1361   PyObject *block_obj = NULL;
1362   const struct block *block = NULL;
1363
1364   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
1365                                         &type_name, &block_obj))
1366     return NULL;
1367
1368   if (block_obj)
1369     {
1370       block = block_object_to_block (block_obj);
1371       if (! block)
1372         {
1373           PyErr_SetString (PyExc_RuntimeError,
1374                            _("'block' argument must be a Block."));
1375           return NULL;
1376         }
1377     }
1378
1379   type = typy_lookup_typename (type_name, block);
1380   if (! type)
1381     return NULL;
1382
1383   return type_to_type_object (type);
1384 }
1385
1386 int
1387 gdbpy_initialize_types (void)
1388 {
1389   int i;
1390
1391   typy_objfile_data_key
1392     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
1393
1394   if (PyType_Ready (&type_object_type) < 0)
1395     return -1;
1396   if (PyType_Ready (&field_object_type) < 0)
1397     return -1;
1398   if (PyType_Ready (&type_iterator_object_type) < 0)
1399     return -1;
1400
1401   for (i = 0; pyty_codes[i].name; ++i)
1402     {
1403       if (PyModule_AddIntConstant (gdb_module, pyty_codes[i].name,
1404                                    pyty_codes[i].code) < 0)
1405         return -1;
1406     }
1407
1408   if (gdb_pymodule_addobject (gdb_module, "Type",
1409                               (PyObject *) &type_object_type) < 0)
1410     return -1;
1411
1412   if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
1413                               (PyObject *) &type_iterator_object_type) < 0)
1414     return -1;
1415
1416   return gdb_pymodule_addobject (gdb_module, "Field",
1417                                  (PyObject *) &field_object_type);
1418 }
1419
1420 \f
1421
1422 static gdb_PyGetSetDef type_object_getset[] =
1423 {
1424   { "alignof", typy_get_alignof, NULL,
1425     "The alignment of this type, in bytes.", NULL },
1426   { "code", typy_get_code, NULL,
1427     "The code for this type.", NULL },
1428   { "name", typy_get_name, NULL,
1429     "The name for this type, or None.", NULL },
1430   { "sizeof", typy_get_sizeof, NULL,
1431     "The size of this type, in bytes.", NULL },
1432   { "tag", typy_get_tag, NULL,
1433     "The tag name for this type, or None.", NULL },
1434   { "objfile", typy_get_objfile, NULL,
1435     "The objfile this type was defined in, or None.", NULL },
1436   { NULL }
1437 };
1438
1439 static PyMethodDef type_object_methods[] =
1440 {
1441   { "array", typy_array, METH_VARARGS,
1442     "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1443 Return a type which represents an array of objects of this type.\n\
1444 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1445 If LOW_BOUND is omitted, a value of zero is used." },
1446   { "vector", typy_vector, METH_VARARGS,
1447     "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1448 Return a type which represents a vector of objects of this type.\n\
1449 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1450 If LOW_BOUND is omitted, a value of zero is used.\n\
1451 Vectors differ from arrays in that if the current language has C-style\n\
1452 arrays, vectors don't decay to a pointer to the first element.\n\
1453 They are first class values." },
1454    { "__contains__", typy_has_key, METH_VARARGS,
1455      "T.__contains__(k) -> True if T has a field named k, else False" },
1456   { "const", typy_const, METH_NOARGS,
1457     "const () -> Type\n\
1458 Return a const variant of this type." },
1459   { "optimized_out", typy_optimized_out, METH_NOARGS,
1460     "optimized_out() -> Value\n\
1461 Return optimized out value of this type." },
1462   { "fields", typy_fields, METH_NOARGS,
1463     "fields () -> list\n\
1464 Return a list holding all the fields of this type.\n\
1465 Each field is a gdb.Field object." },
1466   { "get", typy_get, METH_VARARGS,
1467     "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1468 otherwise returns default, if supplied, or None if not." },
1469   { "has_key", typy_has_key, METH_VARARGS,
1470     "T.has_key(k) -> True if T has a field named k, else False" },
1471   { "items", typy_items, METH_NOARGS,
1472     "items () -> list\n\
1473 Return a list of (name, field) pairs of this type.\n\
1474 Each field is a gdb.Field object." },
1475   { "iteritems", typy_iteritems, METH_NOARGS,
1476     "iteritems () -> an iterator over the (name, field)\n\
1477 pairs of this type.  Each field is a gdb.Field object." },
1478   { "iterkeys", typy_iterkeys, METH_NOARGS,
1479     "iterkeys () -> an iterator over the field names of this type." },
1480   { "itervalues", typy_itervalues, METH_NOARGS,
1481     "itervalues () -> an iterator over the fields of this type.\n\
1482 Each field is a gdb.Field object." },
1483   { "keys", typy_field_names, METH_NOARGS,
1484     "keys () -> list\n\
1485 Return a list holding all the fields names of this type." },
1486   { "pointer", typy_pointer, METH_NOARGS,
1487     "pointer () -> Type\n\
1488 Return a type of pointer to this type." },
1489   { "range", typy_range, METH_NOARGS,
1490     "range () -> tuple\n\
1491 Return a tuple containing the lower and upper range for this type."},
1492   { "reference", typy_reference, METH_NOARGS,
1493     "reference () -> Type\n\
1494 Return a type of reference to this type." },
1495   { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
1496     "strip_typedefs () -> Type\n\
1497 Return a type formed by stripping this type of all typedefs."},
1498   { "target", typy_target, METH_NOARGS,
1499     "target () -> Type\n\
1500 Return the target type of this type." },
1501   { "template_argument", typy_template_argument, METH_VARARGS,
1502     "template_argument (arg, [block]) -> Type\n\
1503 Return the type of a template argument." },
1504   { "unqualified", typy_unqualified, METH_NOARGS,
1505     "unqualified () -> Type\n\
1506 Return a variant of this type without const or volatile attributes." },
1507   { "values", typy_values, METH_NOARGS,
1508     "values () -> list\n\
1509 Return a list holding all the fields of this type.\n\
1510 Each field is a gdb.Field object." },
1511   { "volatile", typy_volatile, METH_NOARGS,
1512     "volatile () -> Type\n\
1513 Return a volatile variant of this type" },
1514   { NULL }
1515 };
1516
1517 static PyNumberMethods type_object_as_number = {
1518   NULL,                       /* nb_add */
1519   NULL,                       /* nb_subtract */
1520   NULL,                       /* nb_multiply */
1521 #ifndef IS_PY3K
1522   NULL,                       /* nb_divide */
1523 #endif
1524   NULL,                       /* nb_remainder */
1525   NULL,                       /* nb_divmod */
1526   NULL,                       /* nb_power */
1527   NULL,                       /* nb_negative */
1528   NULL,                       /* nb_positive */
1529   NULL,                       /* nb_absolute */
1530   typy_nonzero,               /* nb_nonzero */
1531   NULL,                       /* nb_invert */
1532   NULL,                       /* nb_lshift */
1533   NULL,                       /* nb_rshift */
1534   NULL,                       /* nb_and */
1535   NULL,                       /* nb_xor */
1536   NULL,                       /* nb_or */
1537 #ifdef IS_PY3K
1538   NULL,                       /* nb_int */
1539   NULL,                       /* reserved */
1540 #else
1541   NULL,                       /* nb_coerce */
1542   NULL,                       /* nb_int */
1543   NULL,                       /* nb_long */
1544 #endif
1545   NULL,                       /* nb_float */
1546 #ifndef IS_PY3K
1547   NULL,                       /* nb_oct */
1548   NULL                        /* nb_hex */
1549 #endif
1550 };
1551
1552 static PyMappingMethods typy_mapping = {
1553   typy_length,
1554   typy_getitem,
1555   NULL                            /* no "set" method */
1556 };
1557
1558 PyTypeObject type_object_type =
1559 {
1560   PyVarObject_HEAD_INIT (NULL, 0)
1561   "gdb.Type",                     /*tp_name*/
1562   sizeof (type_object),           /*tp_basicsize*/
1563   0,                              /*tp_itemsize*/
1564   typy_dealloc,                   /*tp_dealloc*/
1565   0,                              /*tp_print*/
1566   0,                              /*tp_getattr*/
1567   0,                              /*tp_setattr*/
1568   0,                              /*tp_compare*/
1569   0,                              /*tp_repr*/
1570   &type_object_as_number,         /*tp_as_number*/
1571   0,                              /*tp_as_sequence*/
1572   &typy_mapping,                  /*tp_as_mapping*/
1573   0,                              /*tp_hash */
1574   0,                              /*tp_call*/
1575   typy_str,                       /*tp_str*/
1576   0,                              /*tp_getattro*/
1577   0,                              /*tp_setattro*/
1578   0,                              /*tp_as_buffer*/
1579   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1580   "GDB type object",              /* tp_doc */
1581   0,                              /* tp_traverse */
1582   0,                              /* tp_clear */
1583   typy_richcompare,               /* tp_richcompare */
1584   0,                              /* tp_weaklistoffset */
1585   typy_iter,                      /* tp_iter */
1586   0,                              /* tp_iternext */
1587   type_object_methods,            /* tp_methods */
1588   0,                              /* tp_members */
1589   type_object_getset,             /* tp_getset */
1590   0,                              /* tp_base */
1591   0,                              /* tp_dict */
1592   0,                              /* tp_descr_get */
1593   0,                              /* tp_descr_set */
1594   0,                              /* tp_dictoffset */
1595   0,                              /* tp_init */
1596   0,                              /* tp_alloc */
1597   0,                              /* tp_new */
1598 };
1599
1600 static gdb_PyGetSetDef field_object_getset[] =
1601 {
1602   { "__dict__", gdb_py_generic_dict, NULL,
1603     "The __dict__ for this field.", &field_object_type },
1604   { NULL }
1605 };
1606
1607 PyTypeObject field_object_type =
1608 {
1609   PyVarObject_HEAD_INIT (NULL, 0)
1610   "gdb.Field",                    /*tp_name*/
1611   sizeof (field_object),          /*tp_basicsize*/
1612   0,                              /*tp_itemsize*/
1613   field_dealloc,                  /*tp_dealloc*/
1614   0,                              /*tp_print*/
1615   0,                              /*tp_getattr*/
1616   0,                              /*tp_setattr*/
1617   0,                              /*tp_compare*/
1618   0,                              /*tp_repr*/
1619   0,                              /*tp_as_number*/
1620   0,                              /*tp_as_sequence*/
1621   0,                              /*tp_as_mapping*/
1622   0,                              /*tp_hash */
1623   0,                              /*tp_call*/
1624   0,                              /*tp_str*/
1625   0,                              /*tp_getattro*/
1626   0,                              /*tp_setattro*/
1627   0,                              /*tp_as_buffer*/
1628   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1629   "GDB field object",             /* tp_doc */
1630   0,                              /* tp_traverse */
1631   0,                              /* tp_clear */
1632   0,                              /* tp_richcompare */
1633   0,                              /* tp_weaklistoffset */
1634   0,                              /* tp_iter */
1635   0,                              /* tp_iternext */
1636   0,                              /* tp_methods */
1637   0,                              /* tp_members */
1638   field_object_getset,            /* tp_getset */
1639   0,                              /* tp_base */
1640   0,                              /* tp_dict */
1641   0,                              /* tp_descr_get */
1642   0,                              /* tp_descr_set */
1643   offsetof (field_object, dict),  /* tp_dictoffset */
1644   0,                              /* tp_init */
1645   0,                              /* tp_alloc */
1646   0,                              /* tp_new */
1647 };
1648
1649 PyTypeObject type_iterator_object_type = {
1650   PyVarObject_HEAD_INIT (NULL, 0)
1651   "gdb.TypeIterator",             /*tp_name*/
1652   sizeof (typy_iterator_object),  /*tp_basicsize*/
1653   0,                              /*tp_itemsize*/
1654   typy_iterator_dealloc,          /*tp_dealloc*/
1655   0,                              /*tp_print*/
1656   0,                              /*tp_getattr*/
1657   0,                              /*tp_setattr*/
1658   0,                              /*tp_compare*/
1659   0,                              /*tp_repr*/
1660   0,                              /*tp_as_number*/
1661   0,                              /*tp_as_sequence*/
1662   0,                              /*tp_as_mapping*/
1663   0,                              /*tp_hash */
1664   0,                              /*tp_call*/
1665   0,                              /*tp_str*/
1666   0,                              /*tp_getattro*/
1667   0,                              /*tp_setattro*/
1668   0,                              /*tp_as_buffer*/
1669   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1670   "GDB type iterator object",     /*tp_doc */
1671   0,                              /*tp_traverse */
1672   0,                              /*tp_clear */
1673   0,                              /*tp_richcompare */
1674   0,                              /*tp_weaklistoffset */
1675   typy_iterator_iter,             /*tp_iter */
1676   typy_iterator_iternext,         /*tp_iternext */
1677   0                               /*tp_methods */
1678 };