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