gdb/python/py-type.c

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