gdb/python/py-type.c

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