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   struct type *type = ((type_object *) py_type)->type;
 323   struct type *checked_type = type;
 324
 325   TRY
 326     {
 327       checked_type = check_typedef (checked_type);
 328     }
 329   CATCH (except, RETURN_MASK_ALL)
 330     {
 331       GDB_PY_HANDLE_EXCEPTION (except);
 332     }
 333   END_CATCH
 334
 335   gdbpy_ref<> type_holder;
 336   if (checked_type != type)
 337     {
 338       type_holder.reset (type_to_type_object (checked_type));
 339       if (type_holder == nullptr)
 340         return nullptr;
 341       py_type = type_holder.get ();
 342     }
 343   gdbpy_ref<> iter (typy_make_iter (py_type, kind));
 344   if (iter == nullptr)
 345     return nullptr;
 346
 347   return PySequence_List (iter.get ());
 348 }
 349
 350 /* Return a sequence of all fields.  Each field is a gdb.Field object.  */
 351
 352 static PyObject *
 353 typy_values (PyObject *self, PyObject *args)
 354 {
 355   return typy_fields_items (self, iter_values);
 356 }
 357
 358 /* Return a sequence of all fields.  Each field is a gdb.Field object.
 359    This method is similar to typy_values, except where the supplied
 360    gdb.Type is an array, in which case it returns a list of one entry
 361    which is a gdb.Field object for a range (the array bounds).  */
 362
 363 static PyObject *
 364 typy_fields (PyObject *self, PyObject *args)
 365 {
 366   struct type *type = ((type_object *) self)->type;
 367
 368   if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
 369     return typy_fields_items (self, iter_values);
 370
 371   /* Array type.  Handle this as a special case because the common
 372      machinery wants struct or union or enum types.  Build a list of
 373      one entry which is the range for the array.  */
 374   gdbpy_ref<> r (convert_field (type, 0));
 375   if (r == NULL)
 376     return NULL;
 377
 378   return Py_BuildValue ("[O]", r.get ());
 379 }
 380
 381 /* Return a sequence of all field names.  Each field is a gdb.Field object.  */
 382
 383 static PyObject *
 384 typy_field_names (PyObject *self, PyObject *args)
 385 {
 386   return typy_fields_items (self, iter_keys);
 387 }
 388
 389 /* Return a sequence of all (name, fields) pairs.  Each field is a
 390    gdb.Field object.  */
 391
 392 static PyObject *
 393 typy_items (PyObject *self, PyObject *args)
 394 {
 395   return typy_fields_items (self, iter_items);
 396 }
 397
 398 /* Return the type's name, or None.  */
 399
 400 static PyObject *
 401 typy_get_name (PyObject *self, void *closure)
 402 {
 403   struct type *type = ((type_object *) self)->type;
 404
 405   if (TYPE_NAME (type) == NULL)
 406     Py_RETURN_NONE;
 407   return PyString_FromString (TYPE_NAME (type));
 408 }
 409
 410 /* Return the type's tag, or None.  */
 411 static PyObject *
 412 typy_get_tag (PyObject *self, void *closure)
 413 {
 414   struct type *type = ((type_object *) self)->type;
 415   const char *tagname = nullptr;
 416
 417   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 418       || TYPE_CODE (type) == TYPE_CODE_UNION
 419       || TYPE_CODE (type) == TYPE_CODE_ENUM)
 420     tagname = TYPE_NAME (type);
 421
 422   if (tagname == nullptr)
 423     Py_RETURN_NONE;
 424   return PyString_FromString (tagname);
 425 }
 426
 427 /* Return the type, stripped of typedefs. */
 428 static PyObject *
 429 typy_strip_typedefs (PyObject *self, PyObject *args)
 430 {
 431   struct type *type = ((type_object *) self)->type;
 432
 433   TRY
 434     {
 435       type = check_typedef (type);
 436     }
 437   CATCH (except, RETURN_MASK_ALL)
 438     {
 439       GDB_PY_HANDLE_EXCEPTION (except);
 440     }
 441   END_CATCH
 442
 443   return type_to_type_object (type);
 444 }
 445
 446 /* Strip typedefs and pointers/reference from a type.  Then check that
 447    it is a struct, union, or enum type.  If not, raise TypeError.  */
 448
 449 static struct type *
 450 typy_get_composite (struct type *type)
 451 {
 452
 453   for (;;)
 454     {
 455       TRY
 456         {
 457           type = check_typedef (type);
 458         }
 459       CATCH (except, RETURN_MASK_ALL)
 460         {
 461           GDB_PY_HANDLE_EXCEPTION (except);
 462         }
 463       END_CATCH
 464
 465       if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
 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_lvalue_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 /* Return the alignment of the type represented by SELF, in bytes.  */
 736 static PyObject *
 737 typy_get_alignof (PyObject *self, void *closure)
 738 {
 739   struct type *type = ((type_object *) self)->type;
 740
 741   ULONGEST align = 0;
 742   TRY
 743     {
 744       align = type_align (type);
 745     }
 746   CATCH (except, RETURN_MASK_ALL)
 747     {
 748       align = 0;
 749     }
 750   END_CATCH
 751
 752   /* Ignore exceptions.  */
 753
 754   return gdb_py_object_from_ulongest (align).release ();
 755 }
 756
 757 static struct type *
 758 typy_lookup_typename (const char *type_name, const struct block *block)
 759 {
 760   struct type *type = NULL;
 761
 762   TRY
 763     {
 764       if (startswith (type_name, "struct "))
 765         type = lookup_struct (type_name + 7, NULL);
 766       else if (startswith (type_name, "union "))
 767         type = lookup_union (type_name + 6, NULL);
 768       else if (startswith (type_name, "enum "))
 769         type = lookup_enum (type_name + 5, NULL);
 770       else
 771         type = lookup_typename (python_language, python_gdbarch,
 772                                 type_name, block, 0);
 773     }
 774   CATCH (except, RETURN_MASK_ALL)
 775     {
 776       GDB_PY_HANDLE_EXCEPTION (except);
 777     }
 778   END_CATCH
 779
 780   return type;
 781 }
 782
 783 static struct type *
 784 typy_lookup_type (struct demangle_component *demangled,
 785                   const struct block *block)
 786 {
 787   struct type *type, *rtype = NULL;
 788   enum demangle_component_type demangled_type;
 789
 790   /* Save the type: typy_lookup_type() may (indirectly) overwrite
 791      memory pointed by demangled.  */
 792   demangled_type = demangled->type;
 793
 794   if (demangled_type == DEMANGLE_COMPONENT_POINTER
 795       || demangled_type == DEMANGLE_COMPONENT_REFERENCE
 796       || demangled_type == DEMANGLE_COMPONENT_RVALUE_REFERENCE
 797       || demangled_type == DEMANGLE_COMPONENT_CONST
 798       || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
 799     {
 800       type = typy_lookup_type (demangled->u.s_binary.left, block);
 801       if (! type)
 802         return NULL;
 803
 804       TRY
 805         {
 806           /* If the demangled_type matches with one of the types
 807              below, run the corresponding function and save the type
 808              to return later.  We cannot just return here as we are in
 809              an exception handler.  */
 810           switch (demangled_type)
 811             {
 812             case DEMANGLE_COMPONENT_REFERENCE:
 813               rtype = lookup_lvalue_reference_type (type);
 814               break;
 815             case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 816               rtype = lookup_rvalue_reference_type (type);
 817               break;
 818             case DEMANGLE_COMPONENT_POINTER:
 819               rtype = lookup_pointer_type (type);
 820               break;
 821             case DEMANGLE_COMPONENT_CONST:
 822               rtype = make_cv_type (1, 0, type, NULL);
 823               break;
 824             case DEMANGLE_COMPONENT_VOLATILE:
 825               rtype = make_cv_type (0, 1, type, NULL);
 826               break;
 827             }
 828         }
 829       CATCH (except, RETURN_MASK_ALL)
 830         {
 831           GDB_PY_HANDLE_EXCEPTION (except);
 832         }
 833       END_CATCH
 834     }
 835
 836   /* If we have a type from the switch statement above, just return
 837      that.  */
 838   if (rtype)
 839     return rtype;
 840
 841   /* We don't have a type, so lookup the type.  */
 842   gdb::unique_xmalloc_ptr<char> type_name = cp_comp_to_string (demangled, 10);
 843   return typy_lookup_typename (type_name.get (), block);
 844 }
 845
 846 /* This is a helper function for typy_template_argument that is used
 847    when the type does not have template symbols attached.  It works by
 848    parsing the type name.  This happens with compilers, like older
 849    versions of GCC, that do not emit DW_TAG_template_*.  */
 850
 851 static PyObject *
 852 typy_legacy_template_argument (struct type *type, const struct block *block,
 853                                int argno)
 854 {
 855   int i;
 856   struct demangle_component *demangled;
 857   std::unique_ptr<demangle_parse_info> info;
 858   std::string err;
 859   struct type *argtype;
 860
 861   if (TYPE_NAME (type) == NULL)
 862     {
 863       PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
 864       return NULL;
 865     }
 866
 867   TRY
 868     {
 869       /* Note -- this is not thread-safe.  */
 870       info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
 871     }
 872   CATCH (except, RETURN_MASK_ALL)
 873     {
 874       GDB_PY_HANDLE_EXCEPTION (except);
 875     }
 876   END_CATCH
 877
 878   if (! info)
 879     {
 880       PyErr_SetString (PyExc_RuntimeError, err.c_str ());
 881       return NULL;
 882     }
 883   demangled = info->tree;
 884
 885   /* Strip off component names.  */
 886   while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
 887          || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
 888     demangled = demangled->u.s_binary.right;
 889
 890   if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
 891     {
 892       PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
 893       return NULL;
 894     }
 895
 896   /* Skip from the template to the arguments.  */
 897   demangled = demangled->u.s_binary.right;
 898
 899   for (i = 0; demangled && i < argno; ++i)
 900     demangled = demangled->u.s_binary.right;
 901
 902   if (! demangled)
 903     {
 904       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 905                     argno);
 906       return NULL;
 907     }
 908
 909   argtype = typy_lookup_type (demangled->u.s_binary.left, block);
 910   if (! argtype)
 911     return NULL;
 912
 913   return type_to_type_object (argtype);
 914 }
 915
 916 static PyObject *
 917 typy_template_argument (PyObject *self, PyObject *args)
 918 {
 919   int argno;
 920   struct type *type = ((type_object *) self)->type;
 921   const struct block *block = NULL;
 922   PyObject *block_obj = NULL;
 923   struct symbol *sym;
 924   struct value *val = NULL;
 925
 926   if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
 927     return NULL;
 928
 929   if (argno < 0)
 930     {
 931       PyErr_SetString (PyExc_RuntimeError,
 932                        _("Template argument number must be non-negative"));
 933       return NULL;
 934     }
 935
 936   if (block_obj)
 937     {
 938       block = block_object_to_block (block_obj);
 939       if (! block)
 940         {
 941           PyErr_SetString (PyExc_RuntimeError,
 942                            _("Second argument must be block."));
 943           return NULL;
 944         }
 945     }
 946
 947   TRY
 948     {
 949       type = check_typedef (type);
 950       if (TYPE_IS_REFERENCE (type))
 951         type = check_typedef (TYPE_TARGET_TYPE (type));
 952     }
 953   CATCH (except, RETURN_MASK_ALL)
 954     {
 955       GDB_PY_HANDLE_EXCEPTION (except);
 956     }
 957   END_CATCH
 958
 959   /* We might not have DW_TAG_template_*, so try to parse the type's
 960      name.  This is inefficient if we do not have a template type --
 961      but that is going to wind up as an error anyhow.  */
 962   if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
 963     return typy_legacy_template_argument (type, block, argno);
 964
 965   if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
 966     {
 967       PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
 968                     argno);
 969       return NULL;
 970     }
 971
 972   sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
 973   if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 974     return type_to_type_object (SYMBOL_TYPE (sym));
 975   else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
 976     {
 977       PyErr_Format (PyExc_RuntimeError,
 978                     _("Template argument is optimized out"));
 979       return NULL;
 980     }
 981
 982   TRY
 983     {
 984       val = value_of_variable (sym, block);
 985     }
 986   CATCH (except, RETURN_MASK_ALL)
 987     {
 988       GDB_PY_HANDLE_EXCEPTION (except);
 989     }
 990   END_CATCH
 991
 992   return value_to_value_object (val);
 993 }
 994
 995 static PyObject *
 996 typy_str (PyObject *self)
 997 {
 998   string_file thetype;
 999
1000   TRY
1001     {
1002       LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
1003                      &type_print_raw_options);
1004     }
1005   CATCH (except, RETURN_MASK_ALL)
1006     {
1007       GDB_PY_HANDLE_EXCEPTION (except);
1008     }
1009   END_CATCH
1010
1011   return PyUnicode_Decode (thetype.c_str (), thetype.size (),
1012                            host_charset (), NULL);
1013 }
1014
1015 /* Implement the richcompare method.  */
1016
1017 static PyObject *
1018 typy_richcompare (PyObject *self, PyObject *other, int op)
1019 {
1020   bool result = false;
1021   struct type *type1 = type_object_to_type (self);
1022   struct type *type2 = type_object_to_type (other);
1023
1024   /* We can only compare ourselves to another Type object, and only
1025      for equality or inequality.  */
1026   if (type2 == NULL || (op != Py_EQ && op != Py_NE))
1027     {
1028       Py_INCREF (Py_NotImplemented);
1029       return Py_NotImplemented;
1030     }
1031
1032   if (type1 == type2)
1033     result = true;
1034   else
1035     {
1036       TRY
1037         {
1038           result = types_deeply_equal (type1, type2);
1039         }
1040       CATCH (except, RETURN_MASK_ALL)
1041         {
1042           /* If there is a GDB exception, a comparison is not capable
1043              (or trusted), so exit.  */
1044           GDB_PY_HANDLE_EXCEPTION (except);
1045         }
1046       END_CATCH
1047     }
1048
1049   if (op == (result ? Py_EQ : Py_NE))
1050     Py_RETURN_TRUE;
1051   Py_RETURN_FALSE;
1052 }
1053
1054 \f
1055
1056 static const struct objfile_data *typy_objfile_data_key;
1057
1058 static void
1059 save_objfile_types (struct objfile *objfile, void *datum)
1060 {
1061   type_object *obj = (type_object *) datum;
1062   htab_t copied_types;
1063
1064   if (!gdb_python_initialized)
1065     return;
1066
1067   /* This prevents another thread from freeing the objects we're
1068      operating on.  */
1069   gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
1070
1071   copied_types = create_copied_types_hash (objfile);
1072
1073   while (obj)
1074     {
1075       type_object *next = obj->next;
1076
1077       htab_empty (copied_types);
1078
1079       obj->type = copy_type_recursive (objfile, obj->type, copied_types);
1080
1081       obj->next = NULL;
1082       obj->prev = NULL;
1083
1084       obj = next;
1085     }
1086
1087   htab_delete (copied_types);
1088 }
1089
1090 static void
1091 set_type (type_object *obj, struct type *type)
1092 {
1093   obj->type = type;
1094   obj->prev = NULL;
1095   if (type && TYPE_OBJFILE (type))
1096     {
1097       struct objfile *objfile = TYPE_OBJFILE (type);
1098
1099       obj->next = ((struct pyty_type_object *)
1100                    objfile_data (objfile, typy_objfile_data_key));
1101       if (obj->next)
1102         obj->next->prev = obj;
1103       set_objfile_data (objfile, typy_objfile_data_key, obj);
1104     }
1105   else
1106     obj->next = NULL;
1107 }
1108
1109 static void
1110 typy_dealloc (PyObject *obj)
1111 {
1112   type_object *type = (type_object *) obj;
1113
1114   if (type->prev)
1115     type->prev->next = type->next;
1116   else if (type->type && TYPE_OBJFILE (type->type))
1117     {
1118       /* Must reset head of list.  */
1119       struct objfile *objfile = TYPE_OBJFILE (type->type);
1120
1121       if (objfile)
1122         set_objfile_data (objfile, typy_objfile_data_key, type->next);
1123     }
1124   if (type->next)
1125     type->next->prev = type->prev;
1126
1127   Py_TYPE (type)->tp_free (type);
1128 }
1129
1130 /* Return number of fields ("length" of the field dictionary).  */
1131
1132 static Py_ssize_t
1133 typy_length (PyObject *self)
1134 {
1135   struct type *type = ((type_object *) self)->type;
1136
1137   type = typy_get_composite (type);
1138   if (type == NULL)
1139     return -1;
1140
1141   return TYPE_NFIELDS (type);
1142 }
1143
1144 /* Implements boolean evaluation of gdb.Type.  Handle this like other
1145    Python objects that don't have a meaningful truth value -- all
1146    values are true.  */
1147
1148 static int
1149 typy_nonzero (PyObject *self)
1150 {
1151   return 1;
1152 }
1153
1154 /* Return optimized out value of this type.  */
1155
1156 static PyObject *
1157 typy_optimized_out (PyObject *self, PyObject *args)
1158 {
1159   struct type *type = ((type_object *) self)->type;
1160
1161   return value_to_value_object (allocate_optimized_out_value (type));
1162 }
1163
1164 /* Return a gdb.Field object for the field named by the argument.  */
1165
1166 static PyObject *
1167 typy_getitem (PyObject *self, PyObject *key)
1168 {
1169   struct type *type = ((type_object *) self)->type;
1170   int i;
1171
1172   gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
1173   if (field == NULL)
1174     return NULL;
1175
1176   /* We want just fields of this type, not of base types, so instead of
1177      using lookup_struct_elt_type, portions of that function are
1178      copied here.  */
1179
1180   type = typy_get_composite (type);
1181   if (type == NULL)
1182     return NULL;
1183
1184   for (i = 0; i < TYPE_NFIELDS (type); i++)
1185     {
1186       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1187
1188       if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
1189         {
1190           return convert_field (type, i);
1191         }
1192     }
1193   PyErr_SetObject (PyExc_KeyError, key);
1194   return NULL;
1195 }
1196
1197 /* Implement the "get" method on the type object.  This is the
1198    same as getitem if the key is present, but returns the supplied
1199    default value or None if the key is not found.  */
1200
1201 static PyObject *
1202 typy_get (PyObject *self, PyObject *args)
1203 {
1204   PyObject *key, *defval = Py_None, *result;
1205
1206   if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
1207     return NULL;
1208
1209   result = typy_getitem (self, key);
1210   if (result != NULL)
1211     return result;
1212
1213   /* typy_getitem returned error status.  If the exception is
1214      KeyError, clear the exception status and return the defval
1215      instead.  Otherwise return the exception unchanged.  */
1216   if (!PyErr_ExceptionMatches (PyExc_KeyError))
1217     return NULL;
1218
1219   PyErr_Clear ();
1220   Py_INCREF (defval);
1221   return defval;
1222 }
1223
1224 /* Implement the "has_key" method on the type object.  */
1225
1226 static PyObject *
1227 typy_has_key (PyObject *self, PyObject *args)
1228 {
1229   struct type *type = ((type_object *) self)->type;
1230   const char *field;
1231   int i;
1232
1233   if (!PyArg_ParseTuple (args, "s", &field))
1234     return NULL;
1235
1236   /* We want just fields of this type, not of base types, so instead of
1237      using lookup_struct_elt_type, portions of that function are
1238      copied here.  */
1239
1240   type = typy_get_composite (type);
1241   if (type == NULL)
1242     return NULL;
1243
1244   for (i = 0; i < TYPE_NFIELDS (type); i++)
1245     {
1246       const char *t_field_name = TYPE_FIELD_NAME (type, i);
1247
1248       if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
1249         Py_RETURN_TRUE;
1250     }
1251   Py_RETURN_FALSE;
1252 }
1253
1254 /* Make an iterator object to iterate over keys, values, or items.  */
1255
1256 static PyObject *
1257 typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind)
1258 {
1259   typy_iterator_object *typy_iter_obj;
1260
1261   /* Check that "self" is a structure or union type.  */
1262   if (typy_get_composite (((type_object *) self)->type) == NULL)
1263     return NULL;
1264
1265   typy_iter_obj = PyObject_New (typy_iterator_object,
1266                                 &type_iterator_object_type);
1267   if (typy_iter_obj == NULL)
1268       return NULL;
1269
1270   typy_iter_obj->field = 0;
1271   typy_iter_obj->kind = kind;
1272   Py_INCREF (self);
1273   typy_iter_obj->source = (type_object *) self;
1274
1275   return (PyObject *) typy_iter_obj;
1276 }
1277
1278 /* iteritems() method.  */
1279
1280 static PyObject *
1281 typy_iteritems (PyObject *self, PyObject *args)
1282 {
1283   return typy_make_iter (self, iter_items);
1284 }
1285
1286 /* iterkeys() method.  */
1287
1288 static PyObject *
1289 typy_iterkeys (PyObject *self, PyObject *args)
1290 {
1291   return typy_make_iter (self, iter_keys);
1292 }
1293
1294 /* Iterating over the class, same as iterkeys except for the function
1295    signature.  */
1296
1297 static PyObject *
1298 typy_iter (PyObject *self)
1299 {
1300   return typy_make_iter (self, iter_keys);
1301 }
1302
1303 /* itervalues() method.  */
1304
1305 static PyObject *
1306 typy_itervalues (PyObject *self, PyObject *args)
1307 {
1308   return typy_make_iter (self, iter_values);
1309 }
1310
1311 /* Return a reference to the type iterator.  */
1312
1313 static PyObject *
1314 typy_iterator_iter (PyObject *self)
1315 {
1316   Py_INCREF (self);
1317   return self;
1318 }
1319
1320 /* Return the next field in the iteration through the list of fields
1321    of the type.  */
1322
1323 static PyObject *
1324 typy_iterator_iternext (PyObject *self)
1325 {
1326   typy_iterator_object *iter_obj = (typy_iterator_object *) self;
1327   struct type *type = iter_obj->source->type;
1328   PyObject *result;
1329
1330   if (iter_obj->field < TYPE_NFIELDS (type))
1331     {
1332       result = make_fielditem (type, iter_obj->field, iter_obj->kind);
1333       if (result != NULL)
1334         iter_obj->field++;
1335       return result;
1336     }
1337
1338   return NULL;
1339 }
1340
1341 static void
1342 typy_iterator_dealloc (PyObject *obj)
1343 {
1344   typy_iterator_object *iter_obj = (typy_iterator_object *) obj;
1345
1346   Py_DECREF (iter_obj->source);
1347 }
1348
1349 /* Create a new Type referring to TYPE.  */
1350 PyObject *
1351 type_to_type_object (struct type *type)
1352 {
1353   type_object *type_obj;
1354
1355   type_obj = PyObject_New (type_object, &type_object_type);
1356   if (type_obj)
1357     set_type (type_obj, type);
1358
1359   return (PyObject *) type_obj;
1360 }
1361
1362 struct type *
1363 type_object_to_type (PyObject *obj)
1364 {
1365   if (! PyObject_TypeCheck (obj, &type_object_type))
1366     return NULL;
1367   return ((type_object *) obj)->type;
1368 }
1369
1370 \f
1371
1372 /* Implementation of gdb.lookup_type.  */
1373 PyObject *
1374 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
1375 {
1376   static const char *keywords[] = { "name", "block", NULL };
1377   const char *type_name = NULL;
1378   struct type *type = NULL;
1379   PyObject *block_obj = NULL;
1380   const struct block *block = NULL;
1381
1382   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
1383                                         &type_name, &block_obj))
1384     return NULL;
1385
1386   if (block_obj)
1387     {
1388       block = block_object_to_block (block_obj);
1389       if (! block)
1390         {
1391           PyErr_SetString (PyExc_RuntimeError,
1392                            _("'block' argument must be a Block."));
1393           return NULL;
1394         }
1395     }
1396
1397   type = typy_lookup_typename (type_name, block);
1398   if (! type)
1399     return NULL;
1400
1401   return type_to_type_object (type);
1402 }
1403
1404 int
1405 gdbpy_initialize_types (void)
1406 {
1407   int i;
1408
1409   typy_objfile_data_key
1410     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
1411
1412   if (PyType_Ready (&type_object_type) < 0)
1413     return -1;
1414   if (PyType_Ready (&field_object_type) < 0)
1415     return -1;
1416   if (PyType_Ready (&type_iterator_object_type) < 0)
1417     return -1;
1418
1419   for (i = 0; pyty_codes[i].name; ++i)
1420     {
1421       if (PyModule_AddIntConstant (gdb_module,
1422                                    /* Cast needed for Python 2.4.  */
1423                                    (char *) pyty_codes[i].name,
1424                                    pyty_codes[i].code) < 0)
1425         return -1;
1426     }
1427
1428   if (gdb_pymodule_addobject (gdb_module, "Type",
1429                               (PyObject *) &type_object_type) < 0)
1430     return -1;
1431
1432   if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
1433                               (PyObject *) &type_iterator_object_type) < 0)
1434     return -1;
1435
1436   return gdb_pymodule_addobject (gdb_module, "Field",
1437                                  (PyObject *) &field_object_type);
1438 }
1439
1440 \f
1441
1442 static gdb_PyGetSetDef type_object_getset[] =
1443 {
1444   { "alignof", typy_get_alignof, NULL,
1445     "The alignment of this type, in bytes.", NULL },
1446   { "code", typy_get_code, NULL,
1447     "The code for this type.", NULL },
1448   { "name", typy_get_name, NULL,
1449     "The name for this type, or None.", NULL },
1450   { "sizeof", typy_get_sizeof, NULL,
1451     "The size of this type, in bytes.", NULL },
1452   { "tag", typy_get_tag, NULL,
1453     "The tag name for this type, or None.", NULL },
1454   { NULL }
1455 };
1456
1457 static PyMethodDef type_object_methods[] =
1458 {
1459   { "array", typy_array, METH_VARARGS,
1460     "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1461 Return a type which represents an array of objects of this type.\n\
1462 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1463 If LOW_BOUND is omitted, a value of zero is used." },
1464   { "vector", typy_vector, METH_VARARGS,
1465     "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1466 Return a type which represents a vector of objects of this type.\n\
1467 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1468 If LOW_BOUND is omitted, a value of zero is used.\n\
1469 Vectors differ from arrays in that if the current language has C-style\n\
1470 arrays, vectors don't decay to a pointer to the first element.\n\
1471 They are first class values." },
1472    { "__contains__", typy_has_key, METH_VARARGS,
1473      "T.__contains__(k) -> True if T has a field named k, else False" },
1474   { "const", typy_const, METH_NOARGS,
1475     "const () -> Type\n\
1476 Return a const variant of this type." },
1477   { "optimized_out", typy_optimized_out, METH_NOARGS,
1478     "optimized_out() -> Value\n\
1479 Return optimized out value of this type." },
1480   { "fields", typy_fields, METH_NOARGS,
1481     "fields () -> list\n\
1482 Return a list holding all the fields of this type.\n\
1483 Each field is a gdb.Field object." },
1484   { "get", typy_get, METH_VARARGS,
1485     "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1486 otherwise returns default, if supplied, or None if not." },
1487   { "has_key", typy_has_key, METH_VARARGS,
1488     "T.has_key(k) -> True if T has a field named k, else False" },
1489   { "items", typy_items, METH_NOARGS,
1490     "items () -> list\n\
1491 Return a list of (name, field) pairs of this type.\n\
1492 Each field is a gdb.Field object." },
1493   { "iteritems", typy_iteritems, METH_NOARGS,
1494     "iteritems () -> an iterator over the (name, field)\n\
1495 pairs of this type.  Each field is a gdb.Field object." },
1496   { "iterkeys", typy_iterkeys, METH_NOARGS,
1497     "iterkeys () -> an iterator over the field names of this type." },
1498   { "itervalues", typy_itervalues, METH_NOARGS,
1499     "itervalues () -> an iterator over the fields of this type.\n\
1500 Each field is a gdb.Field object." },
1501   { "keys", typy_field_names, METH_NOARGS,
1502     "keys () -> list\n\
1503 Return a list holding all the fields names of this type." },
1504   { "pointer", typy_pointer, METH_NOARGS,
1505     "pointer () -> Type\n\
1506 Return a type of pointer to this type." },
1507   { "range", typy_range, METH_NOARGS,
1508     "range () -> tuple\n\
1509 Return a tuple containing the lower and upper range for this type."},
1510   { "reference", typy_reference, METH_NOARGS,
1511     "reference () -> Type\n\
1512 Return a type of reference to this type." },
1513   { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
1514     "strip_typedefs () -> Type\n\
1515 Return a type formed by stripping this type of all typedefs."},
1516   { "target", typy_target, METH_NOARGS,
1517     "target () -> Type\n\
1518 Return the target type of this type." },
1519   { "template_argument", typy_template_argument, METH_VARARGS,
1520     "template_argument (arg, [block]) -> Type\n\
1521 Return the type of a template argument." },
1522   { "unqualified", typy_unqualified, METH_NOARGS,
1523     "unqualified () -> Type\n\
1524 Return a variant of this type without const or volatile attributes." },
1525   { "values", typy_values, METH_NOARGS,
1526     "values () -> list\n\
1527 Return a list holding all the fields of this type.\n\
1528 Each field is a gdb.Field object." },
1529   { "volatile", typy_volatile, METH_NOARGS,
1530     "volatile () -> Type\n\
1531 Return a volatile variant of this type" },
1532   { NULL }
1533 };
1534
1535 static PyNumberMethods type_object_as_number = {
1536   NULL,                       /* nb_add */
1537   NULL,                       /* nb_subtract */
1538   NULL,                       /* nb_multiply */
1539 #ifndef IS_PY3K
1540   NULL,                       /* nb_divide */
1541 #endif
1542   NULL,                       /* nb_remainder */
1543   NULL,                       /* nb_divmod */
1544   NULL,                       /* nb_power */
1545   NULL,                       /* nb_negative */
1546   NULL,                       /* nb_positive */
1547   NULL,                       /* nb_absolute */
1548   typy_nonzero,               /* nb_nonzero */
1549   NULL,                       /* nb_invert */
1550   NULL,                       /* nb_lshift */
1551   NULL,                       /* nb_rshift */
1552   NULL,                       /* nb_and */
1553   NULL,                       /* nb_xor */
1554   NULL,                       /* nb_or */
1555 #ifdef IS_PY3K
1556   NULL,                       /* nb_int */
1557   NULL,                       /* reserved */
1558 #else
1559   NULL,                       /* nb_coerce */
1560   NULL,                       /* nb_int */
1561   NULL,                       /* nb_long */
1562 #endif
1563   NULL,                       /* nb_float */
1564 #ifndef IS_PY3K
1565   NULL,                       /* nb_oct */
1566   NULL                        /* nb_hex */
1567 #endif
1568 };
1569
1570 static PyMappingMethods typy_mapping = {
1571   typy_length,
1572   typy_getitem,
1573   NULL                            /* no "set" method */
1574 };
1575
1576 PyTypeObject type_object_type =
1577 {
1578   PyVarObject_HEAD_INIT (NULL, 0)
1579   "gdb.Type",                     /*tp_name*/
1580   sizeof (type_object),           /*tp_basicsize*/
1581   0,                              /*tp_itemsize*/
1582   typy_dealloc,                   /*tp_dealloc*/
1583   0,                              /*tp_print*/
1584   0,                              /*tp_getattr*/
1585   0,                              /*tp_setattr*/
1586   0,                              /*tp_compare*/
1587   0,                              /*tp_repr*/
1588   &type_object_as_number,         /*tp_as_number*/
1589   0,                              /*tp_as_sequence*/
1590   &typy_mapping,                  /*tp_as_mapping*/
1591   0,                              /*tp_hash */
1592   0,                              /*tp_call*/
1593   typy_str,                       /*tp_str*/
1594   0,                              /*tp_getattro*/
1595   0,                              /*tp_setattro*/
1596   0,                              /*tp_as_buffer*/
1597   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1598   "GDB type object",              /* tp_doc */
1599   0,                              /* tp_traverse */
1600   0,                              /* tp_clear */
1601   typy_richcompare,               /* tp_richcompare */
1602   0,                              /* tp_weaklistoffset */
1603   typy_iter,                      /* tp_iter */
1604   0,                              /* tp_iternext */
1605   type_object_methods,            /* tp_methods */
1606   0,                              /* tp_members */
1607   type_object_getset,             /* tp_getset */
1608   0,                              /* tp_base */
1609   0,                              /* tp_dict */
1610   0,                              /* tp_descr_get */
1611   0,                              /* tp_descr_set */
1612   0,                              /* tp_dictoffset */
1613   0,                              /* tp_init */
1614   0,                              /* tp_alloc */
1615   0,                              /* tp_new */
1616 };
1617
1618 static gdb_PyGetSetDef field_object_getset[] =
1619 {
1620   { "__dict__", gdb_py_generic_dict, NULL,
1621     "The __dict__ for this field.", &field_object_type },
1622   { NULL }
1623 };
1624
1625 PyTypeObject field_object_type =
1626 {
1627   PyVarObject_HEAD_INIT (NULL, 0)
1628   "gdb.Field",                    /*tp_name*/
1629   sizeof (field_object),          /*tp_basicsize*/
1630   0,                              /*tp_itemsize*/
1631   field_dealloc,                  /*tp_dealloc*/
1632   0,                              /*tp_print*/
1633   0,                              /*tp_getattr*/
1634   0,                              /*tp_setattr*/
1635   0,                              /*tp_compare*/
1636   0,                              /*tp_repr*/
1637   0,                              /*tp_as_number*/
1638   0,                              /*tp_as_sequence*/
1639   0,                              /*tp_as_mapping*/
1640   0,                              /*tp_hash */
1641   0,                              /*tp_call*/
1642   0,                              /*tp_str*/
1643   0,                              /*tp_getattro*/
1644   0,                              /*tp_setattro*/
1645   0,                              /*tp_as_buffer*/
1646   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1647   "GDB field object",             /* tp_doc */
1648   0,                              /* tp_traverse */
1649   0,                              /* tp_clear */
1650   0,                              /* tp_richcompare */
1651   0,                              /* tp_weaklistoffset */
1652   0,                              /* tp_iter */
1653   0,                              /* tp_iternext */
1654   0,                              /* tp_methods */
1655   0,                              /* tp_members */
1656   field_object_getset,            /* tp_getset */
1657   0,                              /* tp_base */
1658   0,                              /* tp_dict */
1659   0,                              /* tp_descr_get */
1660   0,                              /* tp_descr_set */
1661   offsetof (field_object, dict),  /* tp_dictoffset */
1662   0,                              /* tp_init */
1663   0,                              /* tp_alloc */
1664   0,                              /* tp_new */
1665 };
1666
1667 PyTypeObject type_iterator_object_type = {
1668   PyVarObject_HEAD_INIT (NULL, 0)
1669   "gdb.TypeIterator",             /*tp_name*/
1670   sizeof (typy_iterator_object),  /*tp_basicsize*/
1671   0,                              /*tp_itemsize*/
1672   typy_iterator_dealloc,          /*tp_dealloc*/
1673   0,                              /*tp_print*/
1674   0,                              /*tp_getattr*/
1675   0,                              /*tp_setattr*/
1676   0,                              /*tp_compare*/
1677   0,                              /*tp_repr*/
1678   0,                              /*tp_as_number*/
1679   0,                              /*tp_as_sequence*/
1680   0,                              /*tp_as_mapping*/
1681   0,                              /*tp_hash */
1682   0,                              /*tp_call*/
1683   0,                              /*tp_str*/
1684   0,                              /*tp_getattro*/
1685   0,                              /*tp_setattro*/
1686   0,                              /*tp_as_buffer*/
1687   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
1688   "GDB type iterator object",     /*tp_doc */
1689   0,                              /*tp_traverse */
1690   0,                              /*tp_clear */
1691   0,                              /*tp_richcompare */
1692   0,                              /*tp_weaklistoffset */
1693   typy_iterator_iter,             /*tp_iter */
1694   typy_iterator_iternext,         /*tp_iternext */
1695   0                               /*tp_methods */
1696 };