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 (field)))
 181     {
 182       const char *attrstring;
 183
 184       if (type->code () == TYPE_CODE_ENUM)
 185         {
 186           arg = gdb_py_object_from_longest (TYPE_FIELD_ENUMVAL (type, field));
 187           attrstring = "enumval";
 188         }
 189       else
 190         {
 191           if (TYPE_FIELD_LOC_KIND (type, field) == FIELD_LOC_KIND_DWARF_BLOCK)
 192             arg = gdbpy_ref<>::new_reference (Py_None);
 193           else
 194             arg = gdb_py_object_from_longest (TYPE_FIELD_BITPOS (type, 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_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 (field).type () == NULL)
 244     arg = gdbpy_ref<>::new_reference (Py_None);
 245   else
 246     arg.reset (type_to_type_object (type->field (field).type ()));
 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_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 () == NULL)
 395     Py_RETURN_NONE;
 396   return PyString_FromString (type->name ());
 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_CODE_STRUCT
 407       || type->code () == TYPE_CODE_UNION
 408       || type->code () == TYPE_CODE_ENUM)
 409     tagname = type->name ();
 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_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_CODE_STRUCT
 472       && type->code () != TYPE_CODE_UNION
 473       && type->code () != TYPE_CODE_ENUM
 474       && type->code () != 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_CODE_ARRAY
 581       && type->code () != TYPE_CODE_STRING
 582       && type->code () != 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 ())
 590     {
 591     case TYPE_CODE_ARRAY:
 592     case TYPE_CODE_STRING:
 593     case TYPE_CODE_RANGE:
 594       low = type->bounds ()->low.const_val ();
 595       high = type->bounds ()->high.const_val ();;
 596       break;
 597     }
 598
 599   gdbpy_ref<> low_bound (PyLong_FromLong (low));
 600   if (low_bound == NULL)
 601     return NULL;
 602
 603   gdbpy_ref<> high_bound (PyLong_FromLong (high));
 604   if (high_bound == NULL)
 605     return NULL;
 606
 607   gdbpy_ref<> result (PyTuple_New (2));
 608   if (result == NULL)
 609     return NULL;
 610
 611   if (PyTuple_SetItem (result.get (), 0, low_bound.release ()) != 0
 612       || PyTuple_SetItem (result.get (), 1, high_bound.release ()) != 0)
 613     return NULL;
 614   return result.release ();
 615 }
 616
 617 /* Return a Type object which represents a reference to SELF.  */
 618 static PyObject *
 619 typy_reference (PyObject *self, PyObject *args)
 620 {
 621   struct type *type = ((type_object *) self)->type;
 622
 623   try
 624     {
 625       type = lookup_lvalue_reference_type (type);
 626     }
 627   catch (const gdb_exception &except)
 628     {
 629       GDB_PY_HANDLE_EXCEPTION (except);
 630     }
 631
 632   return type_to_type_object (type);
 633 }
 634
 635 /* Return a Type object which represents the target type of SELF.  */
 636 static PyObject *
 637 typy_target (PyObject *self, PyObject *args)
 638 {
 639   struct type *type = ((type_object *) self)->type;
 640
 641   if (!TYPE_TARGET_TYPE (type))
 642     {
 643       PyErr_SetString (PyExc_RuntimeError,
 644                        _("Type does not have a target."));
 645       return NULL;
 646     }
 647
 648   return type_to_type_object (TYPE_TARGET_TYPE (type));
 649 }
 650
 651 /* Return a const-qualified type variant.  */
 652 static PyObject *
 653 typy_const (PyObject *self, PyObject *args)
 654 {
 655   struct type *type = ((type_object *) self)->type;
 656
 657   try
 658     {
 659       type = make_cv_type (1, 0, type, NULL);
 660     }
 661   catch (const gdb_exception &except)
 662     {
 663       GDB_PY_HANDLE_EXCEPTION (except);
 664     }
 665
 666   return type_to_type_object (type);
 667 }
 668
 669 /* Return a volatile-qualified type variant.  */
 670 static PyObject *
 671 typy_volatile (PyObject *self, PyObject *args)
 672 {
 673   struct type *type = ((type_object *) self)->type;
 674
 675   try
 676     {
 677       type = make_cv_type (0, 1, type, NULL);
 678     }
 679   catch (const gdb_exception &except)
 680     {
 681       GDB_PY_HANDLE_EXCEPTION (except);
 682     }
 683
 684   return type_to_type_object (type);
 685 }
 686
 687 /* Return an unqualified type variant.  */
 688 static PyObject *
 689 typy_unqualified (PyObject *self, PyObject *args)
 690 {
 691   struct type *type = ((type_object *) self)->type;
 692
 693   try
 694     {
 695       type = make_cv_type (0, 0, type, NULL);
 696     }
 697   catch (const gdb_exception &except)
 698     {
 699       GDB_PY_HANDLE_EXCEPTION (except);
 700     }
 701
 702   return type_to_type_object (type);
 703 }
 704
 705 /* Return the size of the type represented by SELF, in bytes.  */
 706 static PyObject *
 707 typy_get_sizeof (PyObject *self, void *closure)
 708 {
 709   struct type *type = ((type_object *) self)->type;
 710
 711   bool size_varies = false;
 712   try
 713     {
 714       check_typedef (type);
 715
 716       size_varies = TYPE_HAS_DYNAMIC_LENGTH (type);
 717     }
 718   catch (const gdb_exception &except)
 719     {
 720     }
 721
 722   /* Ignore exceptions.  */
 723
 724   if (size_varies)
 725     Py_RETURN_NONE;
 726   return gdb_py_object_from_longest (TYPE_LENGTH (type)).release ();
 727 }
 728
 729 /* Return the alignment of the type represented by SELF, in bytes.  */
 730 static PyObject *
 731 typy_get_alignof (PyObject *self, void *closure)
 732 {
 733   struct type *type = ((type_object *) self)->type;
 734
 735   ULONGEST align = 0;
 736   try
 737     {
 738       align = type_align (type);
 739     }
 740   catch (const gdb_exception &except)
 741     {
 742       align = 0;
 743     }
 744
 745   /* Ignore exceptions.  */
 746
 747   return gdb_py_object_from_ulongest (align).release ();
 748 }
 749
 750 /* Return whether or not the type is dynamic.  */
 751 static PyObject *
 752 typy_get_dynamic (PyObject *self, void *closure)
 753 {
 754   struct type *type = ((type_object *) self)->type;
 755
 756   bool result = false;
 757   try
 758     {
 759       result = is_dynamic_type (type);
 760     }
 761   catch (const gdb_exception &except)
 762     {
 763       /* Ignore exceptions.  */
 764     }
 765
 766   if (result)
 767     Py_RETURN_TRUE;
 768   Py_RETURN_FALSE;
 769 }
 770
 771 static struct type *
 772 typy_lookup_typename (const char *type_name, const struct block *block)
 773 {
 774   struct type *type = NULL;
 775
 776   try
 777     {
 778       if (startswith (type_name, "struct "))
 779         type = lookup_struct (type_name + 7, NULL);
 780       else if (startswith (type_name, "union "))
 781         type = lookup_union (type_name + 6, NULL);
 782       else if (startswith (type_name, "enum "))
 783         type = lookup_enum (type_name + 5, NULL);
 784       else
 785         type = lookup_typename (python_language,
 786                                 type_name, block, 0);
 787     }
 788   catch (const gdb_exception &except)
 789     {
 790       GDB_PY_HANDLE_EXCEPTION (except);
 791     }
 792
 793   return type;
 794 }
 795
 796 static struct type *
 797 typy_lookup_type (struct demangle_component *demangled,
 798                   const struct block *block)
 799 {
 800   struct type *type, *rtype = NULL;
 801   enum demangle_component_type demangled_type;
 802
 803   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 804      memory pointed by demangled.  */
 805   demangled_type = demangled->type;
 806
 807   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 808       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 809       || demangled_type == DEMANGLE_COMPONENT_RVALUE_REFERENCE
 810       || demangled_type == DEMANGLE_COMPONENT_CONST
 811       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 812     {
 813       type = typy_lookup_type (demangled->u.s_binary.left, block);
 814       if (! type)
 815         return NULL;
 816
 817       try
 818         {
 819           /* If the demangled_type matches with one of the types
 820              below, run the corresponding function and save the type
 821              to return later.  We cannot just return here as we are in
 822              an exception handler.  */
 823           switch (demangled_type)
 824             {
 825             case DEMANGLE_COMPONENT_REFERENCE:
 826               rtype = lookup_lvalue_reference_type (type);
 827               break;
 828             case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 829               rtype = lookup_rvalue_reference_type (type);
 830               break;
 831             case DEMANGLE_COMPONENT_POINTER:
 832               rtype = lookup_pointer_type (type);
 833               break;
 834             case DEMANGLE_COMPONENT_CONST:
 835               rtype = make_cv_type (1, 0, type, NULL);
 836               break;
 837             case DEMANGLE_COMPONENT_VOLATILE:
 838               rtype = make_cv_type (0, 1, type, NULL);
 839               break;
 840             }
 841         }
 842       catch (const gdb_exception &except)
 843         {
 844           GDB_PY_HANDLE_EXCEPTION (except);
 845         }
 846     }
 847
 848   /* If we have a type from the switch statement above, just return
 849      that.  */
 850   if (rtype)
 851     return rtype;
 852
 853   /* We don't have a type, so lookup the type.  */
 854   gdb::unique_xmalloc_ptr<char> type_name = cp_comp_to_string (demangled, 10);
 855   return typy_lookup_typename (type_name.get (), block);
 856 }
 857
 858 /* This is a helper function for typy_template_argument that is used
 859    when the type does not have template symbols attached.  It works by
 860    parsing the type name.  This happens with compilers, like older
 861    versions of GCC, that do not emit DW_TAG_template_*.  */
 862
 863 static PyObject *
 864 typy_legacy_template_argument (struct type *type, const struct block *block,
 865                                int argno)
 866 {
 867   int i;
 868   struct demangle_component *demangled;
 869   std::unique_ptr<demangle_parse_info> info;
 870   std::string err;
 871   struct type *argtype;
 872
 873   if (type->name () == NULL)
 874     {
 875       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 876       return NULL;
 877     }
 878
 879   try
 880     {
 881       /* Note -- this is not thread-safe.  */
 882       info = cp_demangled_name_to_comp (type->name (), &err);
 883     }
 884   catch (const gdb_exception &except)
 885     {
 886       GDB_PY_HANDLE_EXCEPTION (except);
 887     }
 888
 889   if (! info)
 890     {
 891       PyErr_SetString (PyExc_RuntimeError, err.c_str ());
 892       return NULL;
 893     }
 894   demangled = info->tree;
 895
 896   /* Strip off component names.  */
 897   while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
 898          || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 899     demangled = demangled->u.s_binary.right;
 900
 901   if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
 902     {
 903       PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
 904       return NULL;
 905     }
 906
 907   /* Skip from the template to the arguments.  */
 908   demangled = demangled->u.s_binary.right;
 909
 910   for (i = 0; demangled && i < argno; ++i)
 911     demangled = demangled->u.s_binary.right;
 912
 913   if (! demangled)
 914     {
 915       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 916                     argno);
 917       return NULL;
 918     }
 919
 920   argtype = typy_lookup_type (demangled->u.s_binary.left, block);
 921   if (! argtype)
 922     return NULL;
 923
 924   return type_to_type_object (argtype);
 925 }
 926
 927 static PyObject *
 928 typy_template_argument (PyObject *self, PyObject *args)
 929 {
 930   int argno;
 931   struct type *type = ((type_object *) self)->type;
 932   const struct block *block = NULL;
 933   PyObject *block_obj = NULL;
 934   struct symbol *sym;
 935   struct value *val = NULL;
 936
 937   if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
 938     return NULL;
 939
 940   if (argno < 0)
 941     {
 942       PyErr_SetString (PyExc_RuntimeError,
 943                        _("Template argument number must be non-negative"));
 944       return NULL;
 945     }
 946
 947   if (block_obj)
 948     {
 949       block = block_object_to_block (block_obj);
 950       if (! block)
 951         {
 952           PyErr_SetString (PyExc_RuntimeError,
 953                            _("Second argument must be block."));
 954           return NULL;
 955         }
 956     }
 957
 958   try
 959     {
 960       type = check_typedef (type);
 961       if (TYPE_IS_REFERENCE (type))
 962         type = check_typedef (TYPE_TARGET_TYPE (type));
 963     }
 964   catch (const gdb_exception &except)
 965     {
 966       GDB_PY_HANDLE_EXCEPTION (except);
 967     }
 968
 969   /* We might not have DW_TAG_template_*, so try to parse the type's
 970      name.  This is inefficient if we do not have a template type --
 971      but that is going to wind up as an error anyhow.  */
 972   if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
 973     return typy_legacy_template_argument (type, block, argno);
 974
 975   if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
 976     {
 977       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 978                     argno);
 979       return NULL;
 980     }
 981
 982   sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
 983   if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 984     return type_to_type_object (SYMBOL_TYPE (sym));
 985   else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
 986     {
 987       PyErr_Format (PyExc_RuntimeError,
 988                     _("Template argument is optimized out"));
 989       return NULL;
 990     }
 991
 992   try
 993     {
 994       val = value_of_variable (sym, block);
 995     }
 996   catch (const gdb_exception &except)
 997     {
 998       GDB_PY_HANDLE_EXCEPTION (except);
 999     }
1000
1001   return value_to_value_object (val);
1002 }
1003
1004 static PyObject *
1005 typy_str (PyObject *self)
1006 {
1007   string_file thetype;
1008
1009   try
1010     {
1011       LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
1012                      &type_print_raw_options);
1013     }
1014   catch (const gdb_exception &except)
1015     {
1016       GDB_PY_HANDLE_EXCEPTION (except);
1017     }
1018
1019   return PyUnicode_Decode (thetype.c_str (), thetype.size (),
1020                            host_charset (), NULL);
1021 }
1022
1023 /* Implement the richcompare method.  */
1024
1025 static PyObject *
1026 typy_richcompare (PyObject *self, PyObject *other, int op)
1027 {
1028   bool result = false;
1029   struct type *type1 = type_object_to_type (self);
1030   struct type *type2 = type_object_to_type (other);
1031
1032   /* We can only compare ourselves to another Type object, and only
1033      for equality or inequality.  */
1034   if (type2 == NULL || (op != Py_EQ && op != Py_NE))
1035     {
1036       Py_INCREF (Py_NotImplemented);
1037       return Py_NotImplemented;
1038     }
1039
1040   if (type1 == type2)
1041     result = true;
1042   else
1043     {
1044       try
1045         {
1046           result = types_deeply_equal (type1, type2);
1047         }
1048       catch (const gdb_exception &except)
1049         {
1050           /* If there is a GDB exception, a comparison is not capable
1051              (or trusted), so exit.  */
1052           GDB_PY_HANDLE_EXCEPTION (except);
1053         }
1054     }
1055
1056   if (op == (result ? Py_EQ : Py_NE))
1057     Py_RETURN_TRUE;
1058   Py_RETURN_FALSE;
1059 }
1060
1061 \f
1062
1063 static const struct objfile_data *typy_objfile_data_key;
1064
1065 static void
1066 save_objfile_types (struct objfile *objfile, void *datum)
1067 {
1068   type_object *obj = (type_object *) datum;
1069   htab_t copied_types;
1070
1071   if (!gdb_python_initialized)
1072     return;
1073
1074   /* This prevents another thread from freeing the objects we're
1075      operating on.  */
1076   gdbpy_enter enter_py (objfile->arch (), current_language);
1077
1078   copied_types = create_copied_types_hash (objfile);
1079
1080   while (obj)
1081     {
1082       type_object *next = obj->next;
1083
1084       htab_empty (copied_types);
1085
1086       obj->type = copy_type_recursive (objfile, obj->type, copied_types);
1087
1088       obj->next = NULL;
1089       obj->prev = NULL;
1090
1091       obj = next;
1092     }
1093
1094   htab_delete (copied_types);
1095 }
1096
1097 static void
1098 set_type (type_object *obj, struct type *type)
1099 {
1100   obj->type = type;
1101   obj->prev = NULL;
1102   if (type && TYPE_OBJFILE (type))
1103     {
1104       struct objfile *objfile = TYPE_OBJFILE (type);
1105
1106       obj->next = ((struct pyty_type_object *)
1107                    objfile_data (objfile, typy_objfile_data_key));
1108       if (obj->next)
1109         obj->next->prev = obj;
1110       set_objfile_data (objfile, typy_objfile_data_key, obj);
1111     }
1112   else
1113     obj->next = NULL;
1114 }
1115
1116 static void
1117 typy_dealloc (PyObject *obj)
1118 {
1119   type_object *type = (type_object *) obj;
1120
1121   if (type->prev)
1122     type->prev->next = type->next;
1123   else if (type->type && TYPE_OBJFILE (type->type))
1124     {
1125       /* Must reset head of list.  */
1126       struct objfile *objfile = TYPE_OBJFILE (type->type);
1127
1128       if (objfile)
1129         set_objfile_data (objfile, typy_objfile_data_key, type->next);
1130     }
1131   if (type->next)
1132     type->next->prev = type->prev;
1133
1134   Py_TYPE (type)->tp_free (type);
1135 }
1136
1137 /* Return number of fields ("length" of the field dictionary).  */
1138
1139 static Py_ssize_t
1140 typy_length (PyObject *self)
1141 {
1142   struct type *type = ((type_object *) self)->type;
1143
1144   type = typy_get_composite (type);
1145   if (type == NULL)
1146     return -1;
1147
1148   return type->num_fields ();
1149 }
1150
1151 /* Implements boolean evaluation of gdb.Type.  Handle this like other
1152    Python objects that don't have a meaningful truth value -- all
1153    values are true.  */
1154
1155 static int
1156 typy_nonzero (PyObject *self)
1157 {
1158   return 1;
1159 }
1160
1161 /* Return optimized out value of this type.  */
1162
1163 static PyObject *
1164 typy_optimized_out (PyObject *self, PyObject *args)
1165 {
1166   struct type *type = ((type_object *) self)->type;
1167
1168   return value_to_value_object (allocate_optimized_out_value (type));
1169 }
1170
1171 /* Return a gdb.Field object for the field named by the argument.  */
1172
1173 static PyObject *
1174 typy_getitem (PyObject *self, PyObject *key)
1175 {
1176   struct type *type = ((type_object *) self)->type;
1177   int i;
1178
1179   gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
1180   if (field == NULL)
1181     return NULL;
1182
1183   /* We want just fields of this type, not of base types, so instead of
1184      using lookup_struct_elt_type, portions of that function are
1185      copied here.  */
1186
1187   type = typy_get_composite (type);
1188   if (type == NULL)
1189     return NULL;
1190
1191   for (i = 0; i < type->num_fields (); i++)
1192     {
1193       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1194
1195       if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
1196         return convert_field (type, i).release ();
1197     }
1198   PyErr_SetObject (PyExc_KeyError, key);
1199   return NULL;
1200 }
1201
1202 /* Implement the "get" method on the type object.  This is the
1203    same as getitem if the key is present, but returns the supplied
1204    default value or None if the key is not found.  */
1205
1206 static PyObject *
1207 typy_get (PyObject *self, PyObject *args)
1208 {
1209   PyObject *key, *defval = Py_None, *result;
1210
1211   if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
1212     return NULL;
1213
1214   result = typy_getitem (self, key);
1215   if (result != NULL)
1216     return result;
1217
1218   /* typy_getitem returned error status.  If the exception is
1219      KeyError, clear the exception status and return the defval
1220      instead.  Otherwise return the exception unchanged.  */
1221   if (!PyErr_ExceptionMatches (PyExc_KeyError))
1222     return NULL;
1223
1224   PyErr_Clear ();
1225   Py_INCREF (defval);
1226   return defval;
1227 }
1228
1229 /* Implement the "has_key" method on the type object.  */
1230
1231 static PyObject *
1232 typy_has_key (PyObject *self, PyObject *args)
1233 {
1234   struct type *type = ((type_object *) self)->type;
1235   const char *field;
1236   int i;
1237
1238   if (!PyArg_ParseTuple (args, "s", &field))
1239     return NULL;
1240
1241   /* We want just fields of this type, not of base types, so instead of
1242      using lookup_struct_elt_type, portions of that function are
1243      copied here.  */
1244
1245   type = typy_get_composite (type);
1246   if (type == NULL)
1247     return NULL;
1248
1249   for (i = 0; i < type->num_fields (); i++)
1250     {
1251       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1252
1253       if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
1254         Py_RETURN_TRUE;
1255     }
1256   Py_RETURN_FALSE;
1257 }
1258
1259 /* Make an iterator object to iterate over keys, values, or items.  */
1260
1261 static PyObject *
1262 typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind)
1263 {
1264   typy_iterator_object *typy_iter_obj;
1265
1266   /* Check that "self" is a structure or union type.  */
1267   if (typy_get_composite (((type_object *) self)->type) == NULL)
1268     return NULL;
1269
1270   typy_iter_obj = PyObject_New (typy_iterator_object,
1271                                 &type_iterator_object_type);
1272   if (typy_iter_obj == NULL)
1273       return NULL;
1274
1275   typy_iter_obj->field = 0;
1276   typy_iter_obj->kind = kind;
1277   Py_INCREF (self);
1278   typy_iter_obj->source = (type_object *) self;
1279
1280   return (PyObject *) typy_iter_obj;
1281 }
1282
1283 /* iteritems() method.  */
1284
1285 static PyObject *
1286 typy_iteritems (PyObject *self, PyObject *args)
1287 {
1288   return typy_make_iter (self, iter_items);
1289 }
1290
1291 /* iterkeys() method.  */
1292
1293 static PyObject *
1294 typy_iterkeys (PyObject *self, PyObject *args)
1295 {
1296   return typy_make_iter (self, iter_keys);
1297 }
1298
1299 /* Iterating over the class, same as iterkeys except for the function
1300    signature.  */
1301
1302 static PyObject *
1303 typy_iter (PyObject *self)
1304 {
1305   return typy_make_iter (self, iter_keys);
1306 }
1307
1308 /* itervalues() method.  */
1309
1310 static PyObject *
1311 typy_itervalues (PyObject *self, PyObject *args)
1312 {
1313   return typy_make_iter (self, iter_values);
1314 }
1315
1316 /* Return a reference to the type iterator.  */
1317
1318 static PyObject *
1319 typy_iterator_iter (PyObject *self)
1320 {
1321   Py_INCREF (self);
1322   return self;
1323 }
1324
1325 /* Return the next field in the iteration through the list of fields
1326    of the type.  */
1327
1328 static PyObject *
1329 typy_iterator_iternext (PyObject *self)
1330 {
1331   typy_iterator_object *iter_obj = (typy_iterator_object *) self;
1332   struct type *type = iter_obj->source->type;
1333
1334   if (iter_obj->field < type->num_fields ())
1335     {
1336       gdbpy_ref<> result = make_fielditem (type, iter_obj->field,
1337                                            iter_obj->kind);
1338       if (result != NULL)
1339         iter_obj->field++;
1340       return result.release ();
1341     }
1342
1343   return NULL;
1344 }
1345
1346 static void
1347 typy_iterator_dealloc (PyObject *obj)
1348 {
1349   typy_iterator_object *iter_obj = (typy_iterator_object *) obj;
1350
1351   Py_DECREF (iter_obj->source);
1352   Py_TYPE (obj)->tp_free (obj);
1353 }
1354
1355 /* Create a new Type referring to TYPE.  */
1356 PyObject *
1357 type_to_type_object (struct type *type)
1358 {
1359   type_object *type_obj;
1360
1361   try
1362     {
1363       /* Try not to let stub types leak out to Python.  */
1364       if (type->is_stub ())
1365         type = check_typedef (type);
1366     }
1367   catch (...)
1368     {
1369       /* Just ignore failures in check_typedef.  */
1370     }
1371
1372   type_obj = PyObject_New (type_object, &type_object_type);
1373   if (type_obj)
1374     set_type (type_obj, type);
1375
1376   return (PyObject *) type_obj;
1377 }
1378
1379 struct type *
1380 type_object_to_type (PyObject *obj)
1381 {
1382   if (! PyObject_TypeCheck (obj, &type_object_type))
1383     return NULL;
1384   return ((type_object *) obj)->type;
1385 }
1386
1387 \f
1388
1389 /* Implementation of gdb.lookup_type.  */
1390 PyObject *
1391 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
1392 {
1393   static const char *keywords[] = { "name", "block", NULL };
1394   const char *type_name = NULL;
1395   struct type *type = NULL;
1396   PyObject *block_obj = NULL;
1397   const struct block *block = NULL;
1398
1399   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
1400                                         &type_name, &block_obj))
1401     return NULL;
1402
1403   if (block_obj)
1404     {
1405       block = block_object_to_block (block_obj);
1406       if (! block)
1407         {
1408           PyErr_SetString (PyExc_RuntimeError,
1409                            _("'block' argument must be a Block."));
1410           return NULL;
1411         }
1412     }
1413
1414   type = typy_lookup_typename (type_name, block);
1415   if (! type)
1416     return NULL;
1417
1418   return type_to_type_object (type);
1419 }
1420
1421 int
1422 gdbpy_initialize_types (void)
1423 {
1424   int i;
1425
1426   typy_objfile_data_key
1427     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
1428
1429   if (PyType_Ready (&type_object_type) < 0)
1430     return -1;
1431   if (PyType_Ready (&field_object_type) < 0)
1432     return -1;
1433   if (PyType_Ready (&type_iterator_object_type) < 0)
1434     return -1;
1435
1436   for (i = 0; pyty_codes[i].name; ++i)
1437     {
1438       if (PyModule_AddIntConstant (gdb_module, pyty_codes[i].name,
1439                                    pyty_codes[i].code) < 0)
1440         return -1;
1441     }
1442
1443   if (gdb_pymodule_addobject (gdb_module, "Type",
1444                               (PyObject *) &type_object_type) < 0)
1445     return -1;
1446
1447   if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
1448                               (PyObject *) &type_iterator_object_type) < 0)
1449     return -1;
1450
1451   return gdb_pymodule_addobject (gdb_module, "Field",
1452                                  (PyObject *) &field_object_type);
1453 }
1454
1455 \f
1456
1457 static gdb_PyGetSetDef type_object_getset[] =
1458 {
1459   { "alignof", typy_get_alignof, NULL,
1460     "The alignment of this type, in bytes.", NULL },
1461   { "code", typy_get_code, NULL,
1462     "The code for this type.", NULL },
1463   { "dynamic", typy_get_dynamic, NULL,
1464     "Whether this type is dynamic.", NULL },
1465   { "name", typy_get_name, NULL,
1466     "The name for this type, or None.", NULL },
1467   { "sizeof", typy_get_sizeof, NULL,
1468     "The size of this type, in bytes.", NULL },
1469   { "tag", typy_get_tag, NULL,
1470     "The tag name for this type, or None.", NULL },
1471   { "objfile", typy_get_objfile, NULL,
1472     "The objfile this type was defined in, or None.", NULL },
1473   { NULL }
1474 };
1475
1476 static PyMethodDef type_object_methods[] =
1477 {
1478   { "array", typy_array, METH_VARARGS,
1479     "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1480 Return a type which represents an array of objects of this type.\n\
1481 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1482 If LOW_BOUND is omitted, a value of zero is used." },
1483   { "vector", typy_vector, METH_VARARGS,
1484     "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1485 Return a type which represents a vector 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.\n\
1488 Vectors differ from arrays in that if the current language has C-style\n\
1489 arrays, vectors don't decay to a pointer to the first element.\n\
1490 They are first class values." },
1491    { "__contains__", typy_has_key, METH_VARARGS,
1492      "T.__contains__(k) -> True if T has a field named k, else False" },
1493   { "const", typy_const, METH_NOARGS,
1494     "const () -> Type\n\
1495 Return a const variant of this type." },
1496   { "optimized_out", typy_optimized_out, METH_NOARGS,
1497     "optimized_out() -> Value\n\
1498 Return optimized out value of this type." },
1499   { "fields", typy_fields, METH_NOARGS,
1500     "fields () -> list\n\
1501 Return a list holding all the fields of this type.\n\
1502 Each field is a gdb.Field object." },
1503   { "get", typy_get, METH_VARARGS,
1504     "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1505 otherwise returns default, if supplied, or None if not." },
1506   { "has_key", typy_has_key, METH_VARARGS,
1507     "T.has_key(k) -> True if T has a field named k, else False" },
1508   { "items", typy_items, METH_NOARGS,
1509     "items () -> list\n\
1510 Return a list of (name, field) pairs of this type.\n\
1511 Each field is a gdb.Field object." },
1512   { "iteritems", typy_iteritems, METH_NOARGS,
1513     "iteritems () -> an iterator over the (name, field)\n\
1514 pairs of this type.  Each field is a gdb.Field object." },
1515   { "iterkeys", typy_iterkeys, METH_NOARGS,
1516     "iterkeys () -> an iterator over the field names of this type." },
1517   { "itervalues", typy_itervalues, METH_NOARGS,
1518     "itervalues () -> an iterator over the fields of this type.\n\
1519 Each field is a gdb.Field object." },
1520   { "keys", typy_field_names, METH_NOARGS,
1521     "keys () -> list\n\
1522 Return a list holding all the fields names of this type." },
1523   { "pointer", typy_pointer, METH_NOARGS,
1524     "pointer () -> Type\n\
1525 Return a type of pointer to this type." },
1526   { "range", typy_range, METH_NOARGS,
1527     "range () -> tuple\n\
1528 Return a tuple containing the lower and upper range for this type."},
1529   { "reference", typy_reference, METH_NOARGS,
1530     "reference () -> Type\n\
1531 Return a type of reference to this type." },
1532   { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
1533     "strip_typedefs () -> Type\n\
1534 Return a type formed by stripping this type of all typedefs."},
1535   { "target", typy_target, METH_NOARGS,
1536     "target () -> Type\n\
1537 Return the target type of this type." },
1538   { "template_argument", typy_template_argument, METH_VARARGS,
1539     "template_argument (arg, [block]) -> Type\n\
1540 Return the type of a template argument." },
1541   { "unqualified", typy_unqualified, METH_NOARGS,
1542     "unqualified () -> Type\n\
1543 Return a variant of this type without const or volatile attributes." },
1544   { "values", typy_values, METH_NOARGS,
1545     "values () -> list\n\
1546 Return a list holding all the fields of this type.\n\
1547 Each field is a gdb.Field object." },
1548   { "volatile", typy_volatile, METH_NOARGS,
1549     "volatile () -> Type\n\
1550 Return a volatile variant of this type" },
1551   { NULL }
1552 };
1553
1554 static PyNumberMethods type_object_as_number = {
1555   NULL,                       /* nb_add */
1556   NULL,                       /* nb_subtract */
1557   NULL,                       /* nb_multiply */
1558 #ifndef IS_PY3K
1559   NULL,                       /* nb_divide */
1560 #endif
1561   NULL,                       /* nb_remainder */
1562   NULL,                       /* nb_divmod */
1563   NULL,                       /* nb_power */
1564   NULL,                       /* nb_negative */
1565   NULL,                       /* nb_positive */
1566   NULL,                       /* nb_absolute */
1567   typy_nonzero,               /* nb_nonzero */
1568   NULL,                       /* nb_invert */
1569   NULL,                       /* nb_lshift */
1570   NULL,                       /* nb_rshift */
1571   NULL,                       /* nb_and */
1572   NULL,                       /* nb_xor */
1573   NULL,                       /* nb_or */
1574 #ifdef IS_PY3K
1575   NULL,                       /* nb_int */
1576   NULL,                       /* reserved */
1577 #else
1578   NULL,                       /* nb_coerce */
1579   NULL,                       /* nb_int */
1580   NULL,                       /* nb_long */
1581 #endif
1582   NULL,                       /* nb_float */
1583 #ifndef IS_PY3K
1584   NULL,                       /* nb_oct */
1585   NULL                        /* nb_hex */
1586 #endif
1587 };
1588
1589 static PyMappingMethods typy_mapping = {
1590   typy_length,
1591   typy_getitem,
1592   NULL                            /* no "set" method */
1593 };
1594
1595 PyTypeObject type_object_type =
1596 {
1597   PyVarObject_HEAD_INIT (NULL, 0)
1598   "gdb.Type",                     /*tp_name*/
1599   sizeof (type_object),           /*tp_basicsize*/
1600   0,                              /*tp_itemsize*/
1601   typy_dealloc,                   /*tp_dealloc*/
1602   0,                              /*tp_print*/
1603   0,                              /*tp_getattr*/
1604   0,                              /*tp_setattr*/
1605   0,                              /*tp_compare*/
1606   0,                              /*tp_repr*/
1607   &type_object_as_number,         /*tp_as_number*/
1608   0,                              /*tp_as_sequence*/
1609   &typy_mapping,                  /*tp_as_mapping*/
1610   0,                              /*tp_hash */
1611   0,                              /*tp_call*/
1612   typy_str,                       /*tp_str*/
1613   0,                              /*tp_getattro*/
1614   0,                              /*tp_setattro*/
1615   0,                              /*tp_as_buffer*/
1616   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1617   "GDB type object",              /* tp_doc */
1618   0,                              /* tp_traverse */
1619   0,                              /* tp_clear */
1620   typy_richcompare,               /* tp_richcompare */
1621   0,                              /* tp_weaklistoffset */
1622   typy_iter,                      /* tp_iter */
1623   0,                              /* tp_iternext */
1624   type_object_methods,            /* tp_methods */
1625   0,                              /* tp_members */
1626   type_object_getset,             /* tp_getset */
1627   0,                              /* tp_base */
1628   0,                              /* tp_dict */
1629   0,                              /* tp_descr_get */
1630   0,                              /* tp_descr_set */
1631   0,                              /* tp_dictoffset */
1632   0,                              /* tp_init */
1633   0,                              /* tp_alloc */
1634   0,                              /* tp_new */
1635 };
1636
1637 static gdb_PyGetSetDef field_object_getset[] =
1638 {
1639   { "__dict__", gdb_py_generic_dict, NULL,
1640     "The __dict__ for this field.", &field_object_type },
1641   { NULL }
1642 };
1643
1644 PyTypeObject field_object_type =
1645 {
1646   PyVarObject_HEAD_INIT (NULL, 0)
1647   "gdb.Field",                    /*tp_name*/
1648   sizeof (field_object),          /*tp_basicsize*/
1649   0,                              /*tp_itemsize*/
1650   field_dealloc,                  /*tp_dealloc*/
1651   0,                              /*tp_print*/
1652   0,                              /*tp_getattr*/
1653   0,                              /*tp_setattr*/
1654   0,                              /*tp_compare*/
1655   0,                              /*tp_repr*/
1656   0,                              /*tp_as_number*/
1657   0,                              /*tp_as_sequence*/
1658   0,                              /*tp_as_mapping*/
1659   0,                              /*tp_hash */
1660   0,                              /*tp_call*/
1661   0,                              /*tp_str*/
1662   0,                              /*tp_getattro*/
1663   0,                              /*tp_setattro*/
1664   0,                              /*tp_as_buffer*/
1665   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1666   "GDB field object",             /* tp_doc */
1667   0,                              /* tp_traverse */
1668   0,                              /* tp_clear */
1669   0,                              /* tp_richcompare */
1670   0,                              /* tp_weaklistoffset */
1671   0,                              /* tp_iter */
1672   0,                              /* tp_iternext */
1673   0,                              /* tp_methods */
1674   0,                              /* tp_members */
1675   field_object_getset,            /* tp_getset */
1676   0,                              /* tp_base */
1677   0,                              /* tp_dict */
1678   0,                              /* tp_descr_get */
1679   0,                              /* tp_descr_set */
1680   offsetof (field_object, dict),  /* tp_dictoffset */
1681   0,                              /* tp_init */
1682   0,                              /* tp_alloc */
1683   0,                              /* tp_new */
1684 };
1685
1686 PyTypeObject type_iterator_object_type = {
1687   PyVarObject_HEAD_INIT (NULL, 0)
1688   "gdb.TypeIterator",             /*tp_name*/
1689   sizeof (typy_iterator_object),  /*tp_basicsize*/
1690   0,                              /*tp_itemsize*/
1691   typy_iterator_dealloc,          /*tp_dealloc*/
1692   0,                              /*tp_print*/
1693   0,                              /*tp_getattr*/
1694   0,                              /*tp_setattr*/
1695   0,                              /*tp_compare*/
1696   0,                              /*tp_repr*/
1697   0,                              /*tp_as_number*/
1698   0,                              /*tp_as_sequence*/
1699   0,                              /*tp_as_mapping*/
1700   0,                              /*tp_hash */
1701   0,                              /*tp_call*/
1702   0,                              /*tp_str*/
1703   0,                              /*tp_getattro*/
1704   0,                              /*tp_setattro*/
1705   0,                              /*tp_as_buffer*/
1706   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1707   "GDB type iterator object",     /*tp_doc */
1708   0,                              /*tp_traverse */
1709   0,                              /*tp_clear */
1710   0,                              /*tp_richcompare */
1711   0,                              /*tp_weaklistoffset */
1712   typy_iterator_iter,             /*tp_iter */
1713   typy_iterator_iternext,         /*tp_iternext */
1714   0                               /*tp_methods */
1715 };