contrib/gdb-7/gdb/python/py-type.c

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