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