gdb/python/py-type.c

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