gdb/python/py-type.c

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