gdb/python/py-type.c

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