gdb/python/py-type.c

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