gdb/python/py-type.c

   1 /* Python interface to types.
   2
   3    Copyright (C) 2008-2017 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_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 PyObject *
 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       /* At least python-2.4 had the second parameter non-const.  */
 202       if (PyObject_SetAttrString (result.get (), (char *) attrstring,
 203                                   arg.get ()) < 0)
 204         return NULL;
 205     }
 206
 207   arg.reset (NULL);
 208   if (TYPE_FIELD_NAME (type, field))
 209     {
 210       const char *field_name = TYPE_FIELD_NAME (type, field);
 211
 212       if (field_name[0] != '\0')
 213         {
 214           arg.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
 215           if (arg == NULL)
 216             return NULL;
 217         }
 218     }
 219   if (arg == NULL)
 220     {
 221       arg.reset (Py_None);
 222       Py_INCREF (arg.get ());
 223     }
 224   if (PyObject_SetAttrString (result.get (), "name", arg.get ()) < 0)
 225     return NULL;
 226
 227   arg.reset (TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False);
 228   Py_INCREF (arg.get ());
 229   if (PyObject_SetAttrString (result.get (), "artificial", arg.get ()) < 0)
 230     return NULL;
 231
 232   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 233     arg.reset (field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False);
 234   else
 235     arg.reset (Py_False);
 236   Py_INCREF (arg.get ());
 237   if (PyObject_SetAttrString (result.get (), "is_base_class", arg.get ()) < 0)
 238     return NULL;
 239
 240   arg.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field)));
 241   if (arg == NULL)
 242     return NULL;
 243   if (PyObject_SetAttrString (result.get (), "bitsize", arg.get ()) < 0)
 244     return NULL;
 245
 246   /* A field can have a NULL type in some situations.  */
 247   if (TYPE_FIELD_TYPE (type, field) == NULL)
 248     {
 249       arg.reset (Py_None);
 250       Py_INCREF (arg.get ());
 251     }
 252   else
 253     arg.reset (type_to_type_object (TYPE_FIELD_TYPE (type, field)));
 254   if (arg == NULL)
 255     return NULL;
 256   if (PyObject_SetAttrString (result.get (), "type", arg.get ()) < 0)
 257     return NULL;
 258
 259   return result.release ();
 260 }
 261
 262 /* Helper function to return the name of a field, as a gdb.Field object.
 263    If the field doesn't have a name, None is returned.  */
 264
 265 static PyObject *
 266 field_name (struct type *type, int field)
 267 {
 268   PyObject *result;
 269
 270   if (TYPE_FIELD_NAME (type, field))
 271     result = PyString_FromString (TYPE_FIELD_NAME (type, field));
 272   else
 273     {
 274       result = Py_None;
 275       Py_INCREF (result);
 276     }
 277   return result;
 278 }
 279
 280 /* Helper function for Type standard mapping methods.  Returns a
 281    Python object for field i of the type.  "kind" specifies what to
 282    return: the name of the field, a gdb.Field object corresponding to
 283    the field, or a tuple consisting of field name and gdb.Field
 284    object.  */
 285
 286 static PyObject *
 287 make_fielditem (struct type *type, int i, enum gdbpy_iter_kind kind)
 288 {
 289   switch (kind)
 290     {
 291     case iter_items:
 292       {
 293         gdbpy_ref<> key (field_name (type, i));
 294         if (key == NULL)
 295           return NULL;
 296         gdbpy_ref<> value (convert_field (type, i));
 297         if (value == NULL)
 298           return NULL;
 299         gdbpy_ref<> item (PyTuple_New (2));
 300         if (item == NULL)
 301           return NULL;
 302         PyTuple_SET_ITEM (item.get (), 0, key.release ());
 303         PyTuple_SET_ITEM (item.get (), 1, value.release ());
 304         return item.release ();
 305       }
 306     case iter_keys:
 307       return field_name (type, i);
 308     case iter_values:
 309       return convert_field (type, i);
 310     }
 311   gdb_assert_not_reached ("invalid gdbpy_iter_kind");
 312 }
 313
 314 /* Return a sequence of all field names, fields, or (name, field) pairs.
 315    Each field is a gdb.Field object.  */
 316
 317 static PyObject *
 318 typy_fields_items (PyObject *self, enum gdbpy_iter_kind kind)
 319 {
 320   PyObject *py_type = self;
 321   PyObject *result = NULL, *iter = NULL;
 322   struct type *type = ((type_object *) py_type)->type;
 323   struct type *checked_type = type;
 324
 325   TRY
 326     {
 327       checked_type = check_typedef (checked_type);
 328     }
 329   CATCH (except, RETURN_MASK_ALL)
 330     {
 331       GDB_PY_HANDLE_EXCEPTION (except);
 332     }
 333   END_CATCH
 334
 335   if (checked_type != type)
 336     py_type = type_to_type_object (checked_type);
 337   iter = typy_make_iter (py_type, kind);
 338   if (checked_type != type)
 339     {
 340       /* Need to wrap this in braces because Py_DECREF isn't wrapped
 341          in a do{}while(0).  */
 342       Py_DECREF (py_type);
 343     }
 344   if (iter != NULL)
 345     {
 346       result = PySequence_List (iter);
 347       Py_DECREF (iter);
 348     }
 349
 350   return result;
 351 }
 352
 353 /* Return a sequence of all fields.  Each field is a gdb.Field object.  */
 354
 355 static PyObject *
 356 typy_values (PyObject *self, PyObject *args)
 357 {
 358   return typy_fields_items (self, iter_values);
 359 }
 360
 361 /* Return a sequence of all fields.  Each field is a gdb.Field object.
 362    This method is similar to typy_values, except where the supplied
 363    gdb.Type is an array, in which case it returns a list of one entry
 364    which is a gdb.Field object for a range (the array bounds).  */
 365
 366 static PyObject *
 367 typy_fields (PyObject *self, PyObject *args)
 368 {
 369   struct type *type = ((type_object *) self)->type;
 370
 371   if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
 372     return typy_fields_items (self, iter_values);
 373
 374   /* Array type.  Handle this as a special case because the common
 375      machinery wants struct or union or enum types.  Build a list of
 376      one entry which is the range for the array.  */
 377   gdbpy_ref<> r (convert_field (type, 0));
 378   if (r == NULL)
 379     return NULL;
 380
 381   return Py_BuildValue ("[O]", r.get ());
 382 }
 383
 384 /* Return a sequence of all field names.  Each field is a gdb.Field object.  */
 385
 386 static PyObject *
 387 typy_field_names (PyObject *self, PyObject *args)
 388 {
 389   return typy_fields_items (self, iter_keys);
 390 }
 391
 392 /* Return a sequence of all (name, fields) pairs.  Each field is a
 393    gdb.Field object.  */
 394
 395 static PyObject *
 396 typy_items (PyObject *self, PyObject *args)
 397 {
 398   return typy_fields_items (self, iter_items);
 399 }
 400
 401 /* Return the type's name, or None.  */
 402
 403 static PyObject *
 404 typy_get_name (PyObject *self, void *closure)
 405 {
 406   struct type *type = ((type_object *) self)->type;
 407
 408   if (TYPE_NAME (type) == NULL)
 409     Py_RETURN_NONE;
 410   return PyString_FromString (TYPE_NAME (type));
 411 }
 412
 413 /* Return the type's tag, or None.  */
 414 static PyObject *
 415 typy_get_tag (PyObject *self, void *closure)
 416 {
 417   struct type *type = ((type_object *) self)->type;
 418
 419   if (!TYPE_TAG_NAME (type))
 420     Py_RETURN_NONE;
 421   return PyString_FromString (TYPE_TAG_NAME (type));
 422 }
 423
 424 /* Return the type, stripped of typedefs. */
 425 static PyObject *
 426 typy_strip_typedefs (PyObject *self, PyObject *args)
 427 {
 428   struct type *type = ((type_object *) self)->type;
 429
 430   TRY
 431     {
 432       type = check_typedef (type);
 433     }
 434   CATCH (except, RETURN_MASK_ALL)
 435     {
 436       GDB_PY_HANDLE_EXCEPTION (except);
 437     }
 438   END_CATCH
 439
 440   return type_to_type_object (type);
 441 }
 442
 443 /* Strip typedefs and pointers/reference from a type.  Then check that
 444    it is a struct, union, or enum type.  If not, raise TypeError.  */
 445
 446 static struct type *
 447 typy_get_composite (struct type *type)
 448 {
 449
 450   for (;;)
 451     {
 452       TRY
 453         {
 454           type = check_typedef (type);
 455         }
 456       CATCH (except, RETURN_MASK_ALL)
 457         {
 458           GDB_PY_HANDLE_EXCEPTION (except);
 459         }
 460       END_CATCH
 461
 462       if (TYPE_CODE (type) != TYPE_CODE_PTR
 463           && TYPE_CODE (type) != TYPE_CODE_REF)
 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_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 static struct type *
 734 typy_lookup_typename (const char *type_name, const struct block *block)
 735 {
 736   struct type *type = NULL;
 737
 738   TRY
 739     {
 740       if (startswith (type_name, "struct "))
 741         type = lookup_struct (type_name + 7, NULL);
 742       else if (startswith (type_name, "union "))
 743         type = lookup_union (type_name + 6, NULL);
 744       else if (startswith (type_name, "enum "))
 745         type = lookup_enum (type_name + 5, NULL);
 746       else
 747         type = lookup_typename (python_language, python_gdbarch,
 748                                 type_name, block, 0);
 749     }
 750   CATCH (except, RETURN_MASK_ALL)
 751     {
 752       GDB_PY_HANDLE_EXCEPTION (except);
 753     }
 754   END_CATCH
 755
 756   return type;
 757 }
 758
 759 static struct type *
 760 typy_lookup_type (struct demangle_component *demangled,
 761                   const struct block *block)
 762 {
 763   struct type *type, *rtype = NULL;
 764   char *type_name = NULL;
 765   enum demangle_component_type demangled_type;
 766
 767   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 768      memory pointed by demangled.  */
 769   demangled_type = demangled->type;
 770
 771   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 772       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 773       || demangled_type == DEMANGLE_COMPONENT_CONST
 774       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 775     {
 776       type = typy_lookup_type (demangled->u.s_binary.left, block);
 777       if (! type)
 778         return NULL;
 779
 780       TRY
 781         {
 782           /* If the demangled_type matches with one of the types
 783              below, run the corresponding function and save the type
 784              to return later.  We cannot just return here as we are in
 785              an exception handler.  */
 786           switch (demangled_type)
 787             {
 788             case DEMANGLE_COMPONENT_REFERENCE:
 789               rtype =  lookup_reference_type (type);
 790               break;
 791             case DEMANGLE_COMPONENT_POINTER:
 792               rtype = lookup_pointer_type (type);
 793               break;
 794             case DEMANGLE_COMPONENT_CONST:
 795               rtype = make_cv_type (1, 0, type, NULL);
 796               break;
 797             case DEMANGLE_COMPONENT_VOLATILE:
 798               rtype = make_cv_type (0, 1, type, NULL);
 799               break;
 800             }
 801         }
 802       CATCH (except, RETURN_MASK_ALL)
 803         {
 804           GDB_PY_HANDLE_EXCEPTION (except);
 805         }
 806       END_CATCH
 807     }
 808
 809   /* If we have a type from the switch statement above, just return
 810      that.  */
 811   if (rtype)
 812     return rtype;
 813
 814   /* We don't have a type, so lookup the type.  */
 815   type_name = cp_comp_to_string (demangled, 10);
 816   type = typy_lookup_typename (type_name, block);
 817   xfree (type_name);
 818
 819   return type;
 820 }
 821
 822 /* This is a helper function for typy_template_argument that is used
 823    when the type does not have template symbols attached.  It works by
 824    parsing the type name.  This happens with compilers, like older
 825    versions of GCC, that do not emit DW_TAG_template_*.  */
 826
 827 static PyObject *
 828 typy_legacy_template_argument (struct type *type, const struct block *block,
 829                                int argno)
 830 {
 831   int i;
 832   struct demangle_component *demangled;
 833   std::unique_ptr<demangle_parse_info> info;
 834   const char *err;
 835   struct type *argtype;
 836
 837   if (TYPE_NAME (type) == NULL)
 838     {
 839       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 840       return NULL;
 841     }
 842
 843   TRY
 844     {
 845       /* Note -- this is not thread-safe.  */
 846       info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
 847     }
 848   CATCH (except, RETURN_MASK_ALL)
 849     {
 850       GDB_PY_HANDLE_EXCEPTION (except);
 851     }
 852   END_CATCH
 853
 854   if (! info)
 855     {
 856       PyErr_SetString (PyExc_RuntimeError, err);
 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 (block_obj)
 906     {
 907       block = block_object_to_block (block_obj);
 908       if (! block)
 909         {
 910           PyErr_SetString (PyExc_RuntimeError,
 911                            _("Second argument must be block."));
 912           return NULL;
 913         }
 914     }
 915
 916   TRY
 917     {
 918       type = check_typedef (type);
 919       if (TYPE_CODE (type) == TYPE_CODE_REF)
 920         type = check_typedef (TYPE_TARGET_TYPE (type));
 921     }
 922   CATCH (except, RETURN_MASK_ALL)
 923     {
 924       GDB_PY_HANDLE_EXCEPTION (except);
 925     }
 926   END_CATCH
 927
 928   /* We might not have DW_TAG_template_*, so try to parse the type's
 929      name.  This is inefficient if we do not have a template type --
 930      but that is going to wind up as an error anyhow.  */
 931   if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
 932     return typy_legacy_template_argument (type, block, argno);
 933
 934   if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
 935     {
 936       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 937                     argno);
 938       return NULL;
 939     }
 940
 941   sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
 942   if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 943     return type_to_type_object (SYMBOL_TYPE (sym));
 944   else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
 945     {
 946       PyErr_Format (PyExc_RuntimeError,
 947                     _("Template argument is optimized out"));
 948       return NULL;
 949     }
 950
 951   TRY
 952     {
 953       val = value_of_variable (sym, block);
 954     }
 955   CATCH (except, RETURN_MASK_ALL)
 956     {
 957       GDB_PY_HANDLE_EXCEPTION (except);
 958     }
 959   END_CATCH
 960
 961   return value_to_value_object (val);
 962 }
 963
 964 static PyObject *
 965 typy_str (PyObject *self)
 966 {
 967   string_file thetype;
 968   PyObject *result;
 969
 970   TRY
 971     {
 972       LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
 973                      &type_print_raw_options);
 974     }
 975   CATCH (except, RETURN_MASK_ALL)
 976     {
 977       GDB_PY_HANDLE_EXCEPTION (except);
 978     }
 979   END_CATCH
 980
 981   return PyUnicode_Decode (thetype.c_str (), thetype.size (),
 982                            host_charset (), NULL);
 983 }
 984
 985 /* Implement the richcompare method.  */
 986
 987 static PyObject *
 988 typy_richcompare (PyObject *self, PyObject *other, int op)
 989 {
 990   int result = Py_NE;
 991   struct type *type1 = type_object_to_type (self);
 992   struct type *type2 = type_object_to_type (other);
 993
 994   /* We can only compare ourselves to another Type object, and only
 995      for equality or inequality.  */
 996   if (type2 == NULL || (op != Py_EQ && op != Py_NE))
 997     {
 998       Py_INCREF (Py_NotImplemented);
 999       return Py_NotImplemented;
1000     }
1001
1002   if (type1 == type2)
1003     result = Py_EQ;
1004   else
1005     {
1006       TRY
1007         {
1008           result = types_deeply_equal (type1, type2);
1009         }
1010       CATCH (except, RETURN_MASK_ALL)
1011         {
1012           /* If there is a GDB exception, a comparison is not capable
1013              (or trusted), so exit.  */
1014           GDB_PY_HANDLE_EXCEPTION (except);
1015         }
1016       END_CATCH
1017     }
1018
1019   if (op == (result ? Py_EQ : Py_NE))
1020     Py_RETURN_TRUE;
1021   Py_RETURN_FALSE;
1022 }
1023
1024 \f
1025
1026 static const struct objfile_data *typy_objfile_data_key;
1027
1028 static void
1029 save_objfile_types (struct objfile *objfile, void *datum)
1030 {
1031   type_object *obj = (type_object *) datum;
1032   htab_t copied_types;
1033
1034   if (!gdb_python_initialized)
1035     return;
1036
1037   /* This prevents another thread from freeing the objects we're
1038      operating on.  */
1039   gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
1040
1041   copied_types = create_copied_types_hash (objfile);
1042
1043   while (obj)
1044     {
1045       type_object *next = obj->next;
1046
1047       htab_empty (copied_types);
1048
1049       obj->type = copy_type_recursive (objfile, obj->type, copied_types);
1050
1051       obj->next = NULL;
1052       obj->prev = NULL;
1053
1054       obj = next;
1055     }
1056
1057   htab_delete (copied_types);
1058 }
1059
1060 static void
1061 set_type (type_object *obj, struct type *type)
1062 {
1063   obj->type = type;
1064   obj->prev = NULL;
1065   if (type && TYPE_OBJFILE (type))
1066     {
1067       struct objfile *objfile = TYPE_OBJFILE (type);
1068
1069       obj->next = ((struct pyty_type_object *)
1070                    objfile_data (objfile, typy_objfile_data_key));
1071       if (obj->next)
1072         obj->next->prev = obj;
1073       set_objfile_data (objfile, typy_objfile_data_key, obj);
1074     }
1075   else
1076     obj->next = NULL;
1077 }
1078
1079 static void
1080 typy_dealloc (PyObject *obj)
1081 {
1082   type_object *type = (type_object *) obj;
1083
1084   if (type->prev)
1085     type->prev->next = type->next;
1086   else if (type->type && TYPE_OBJFILE (type->type))
1087     {
1088       /* Must reset head of list.  */
1089       struct objfile *objfile = TYPE_OBJFILE (type->type);
1090
1091       if (objfile)
1092         set_objfile_data (objfile, typy_objfile_data_key, type->next);
1093     }
1094   if (type->next)
1095     type->next->prev = type->prev;
1096
1097   Py_TYPE (type)->tp_free (type);
1098 }
1099
1100 /* Return number of fields ("length" of the field dictionary).  */
1101
1102 static Py_ssize_t
1103 typy_length (PyObject *self)
1104 {
1105   struct type *type = ((type_object *) self)->type;
1106
1107   type = typy_get_composite (type);
1108   if (type == NULL)
1109     return -1;
1110
1111   return TYPE_NFIELDS (type);
1112 }
1113
1114 /* Implements boolean evaluation of gdb.Type.  Handle this like other
1115    Python objects that don't have a meaningful truth value -- all
1116    values are true.  */
1117
1118 static int
1119 typy_nonzero (PyObject *self)
1120 {
1121   return 1;
1122 }
1123
1124 /* Return optimized out value of this type.  */
1125
1126 static PyObject *
1127 typy_optimized_out (PyObject *self, PyObject *args)
1128 {
1129   struct type *type = ((type_object *) self)->type;
1130
1131   return value_to_value_object (allocate_optimized_out_value (type));
1132 }
1133
1134 /* Return a gdb.Field object for the field named by the argument.  */
1135
1136 static PyObject *
1137 typy_getitem (PyObject *self, PyObject *key)
1138 {
1139   struct type *type = ((type_object *) self)->type;
1140   int i;
1141
1142   gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
1143   if (field == NULL)
1144     return NULL;
1145
1146   /* We want just fields of this type, not of base types, so instead of
1147      using lookup_struct_elt_type, portions of that function are
1148      copied here.  */
1149
1150   type = typy_get_composite (type);
1151   if (type == NULL)
1152     return NULL;
1153
1154   for (i = 0; i < TYPE_NFIELDS (type); i++)
1155     {
1156       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1157
1158       if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
1159         {
1160           return convert_field (type, i);
1161         }
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   PyObject *result;
1299
1300   if (iter_obj->field < TYPE_NFIELDS (type))
1301     {
1302       result = make_fielditem (type, iter_obj->field, iter_obj->kind);
1303       if (result != NULL)
1304         iter_obj->field++;
1305       return result;
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 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 (! 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 (PyObject *) 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,
1392                                    /* Cast needed for Python 2.4.  */
1393                                    (char *) pyty_codes[i].name,
1394                                    pyty_codes[i].code) < 0)
1395         return -1;
1396     }
1397
1398   if (gdb_pymodule_addobject (gdb_module, "Type",
1399                               (PyObject *) &type_object_type) < 0)
1400     return -1;
1401
1402   if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
1403                               (PyObject *) &type_iterator_object_type) < 0)
1404     return -1;
1405
1406   return gdb_pymodule_addobject (gdb_module, "Field",
1407                                  (PyObject *) &field_object_type);
1408 }
1409
1410 \f
1411
1412 static PyGetSetDef type_object_getset[] =
1413 {
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 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 };