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