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