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