gdb/python/py-type.c

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