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