1 /* Python interface to types.
3 Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "exceptions.h"
23 #include "python-internal.h"
26 #include "cp-support.h"
33 typedef struct pyty_type_object
38 /* If a Type object is associated with an objfile, it is kept on a
39 doubly-linked list, rooted in the objfile. This lets us copy the
40 underlying struct type when the objfile is deleted. */
41 struct pyty_type_object
*prev
;
42 struct pyty_type_object
*next
;
45 static PyTypeObject type_object_type
;
48 typedef struct pyty_field_object
52 /* Dictionary holding our attributes. */
56 static PyTypeObject field_object_type
;
58 /* A type iterator object. */
61 /* The current field index. */
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
;
69 static PyTypeObject type_iterator_object_type
;
71 /* This is used to initialize various gdb.TYPE_ constants. */
80 #define ENTRY(X) { X, #X }
82 static struct pyty_code pyty_codes
[] =
84 ENTRY (TYPE_CODE_PTR
),
85 ENTRY (TYPE_CODE_ARRAY
),
86 ENTRY (TYPE_CODE_STRUCT
),
87 ENTRY (TYPE_CODE_UNION
),
88 ENTRY (TYPE_CODE_ENUM
),
89 ENTRY (TYPE_CODE_FLAGS
),
90 ENTRY (TYPE_CODE_FUNC
),
91 ENTRY (TYPE_CODE_INT
),
92 ENTRY (TYPE_CODE_FLT
),
93 ENTRY (TYPE_CODE_VOID
),
94 ENTRY (TYPE_CODE_SET
),
95 ENTRY (TYPE_CODE_RANGE
),
96 ENTRY (TYPE_CODE_STRING
),
97 ENTRY (TYPE_CODE_BITSTRING
),
98 ENTRY (TYPE_CODE_ERROR
),
99 ENTRY (TYPE_CODE_METHOD
),
100 ENTRY (TYPE_CODE_METHODPTR
),
101 ENTRY (TYPE_CODE_MEMBERPTR
),
102 ENTRY (TYPE_CODE_REF
),
103 ENTRY (TYPE_CODE_CHAR
),
104 ENTRY (TYPE_CODE_BOOL
),
105 ENTRY (TYPE_CODE_COMPLEX
),
106 ENTRY (TYPE_CODE_TYPEDEF
),
107 ENTRY (TYPE_CODE_NAMESPACE
),
108 ENTRY (TYPE_CODE_DECFLOAT
),
109 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
110 { TYPE_CODE_UNDEF
, NULL
}
116 field_dealloc (PyObject
*obj
)
118 field_object
*f
= (field_object
*) obj
;
120 Py_XDECREF (f
->dict
);
121 f
->ob_type
->tp_free (obj
);
127 field_object
*result
= PyObject_New (field_object
, &field_object_type
);
131 result
->dict
= PyDict_New ();
138 return (PyObject
*) result
;
143 /* Return the code for this type. */
145 typy_get_code (PyObject
*self
, void *closure
)
147 struct type
*type
= ((type_object
*) self
)->type
;
149 return PyInt_FromLong (TYPE_CODE (type
));
152 /* Helper function for typy_fields which converts a single field to a
153 gdb.Field object. Returns NULL on error. */
156 convert_field (struct type
*type
, int field
)
158 PyObject
*result
= field_new ();
164 if (!field_is_static (&TYPE_FIELD (type
, field
)))
166 arg
= PyLong_FromLong (TYPE_FIELD_BITPOS (type
, field
));
170 if (PyObject_SetAttrString (result
, "bitpos", arg
) < 0)
174 if (TYPE_FIELD_NAME (type
, field
))
175 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
183 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
186 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
188 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
191 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
192 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
196 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
199 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
202 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
205 /* A field can have a NULL type in some situations. */
206 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
212 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
215 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
227 /* Helper function to return the name of a field, as a gdb.Field object.
228 If the field doesn't have a name, None is returned. */
231 field_name (struct type
*type
, int field
)
235 if (TYPE_FIELD_NAME (type
, field
))
236 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
245 /* Helper function for Type standard mapping methods. Returns a
246 Python object for field i of the type. "kind" specifies what to
247 return: the name of the field, a gdb.Field object corresponding to
248 the field, or a tuple consisting of field name and gdb.Field
252 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
254 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
259 key
= field_name (type
, i
);
262 value
= convert_field (type
, i
);
265 item
= PyTuple_New (2);
268 PyTuple_SET_ITEM (item
, 0, key
);
269 PyTuple_SET_ITEM (item
, 1, value
);
272 item
= field_name (type
, i
);
275 item
= convert_field (type
, i
);
287 /* Return a sequence of all field names, fields, or (name, field) pairs.
288 Each field is a gdb.Field object. */
291 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
293 PyObject
*result
= NULL
, *item
= NULL
;
295 struct type
*type
= ((type_object
*) self
)->type
;
296 volatile struct gdb_exception except
;
298 TRY_CATCH (except
, RETURN_MASK_ALL
)
300 CHECK_TYPEDEF (type
);
302 GDB_PY_HANDLE_EXCEPTION (except
);
304 /* We would like to make a tuple here, make fields immutable, and
305 then memoize the result (and perhaps make Field.type() lazy).
306 However, that can lead to cycles. */
307 result
= PyList_New (0);
311 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
313 item
= make_fielditem (type
, i
, kind
);
316 if (PyList_Append (result
, item
))
329 /* Return a sequence of all fields. Each field is a gdb.Field object. */
332 typy_fields (PyObject
*self
, PyObject
*args
)
334 return typy_fields_items (self
, iter_values
);
337 /* Return a sequence of all field names. Each field is a gdb.Field object. */
340 typy_field_names (PyObject
*self
, PyObject
*args
)
342 return typy_fields_items (self
, iter_keys
);
345 /* Return a sequence of all (name, fields) pairs. Each field is a
349 typy_items (PyObject
*self
, PyObject
*args
)
351 return typy_fields_items (self
, iter_items
);
354 /* Return the type's tag, or None. */
356 typy_get_tag (PyObject
*self
, void *closure
)
358 struct type
*type
= ((type_object
*) self
)->type
;
360 if (!TYPE_TAG_NAME (type
))
362 return PyString_FromString (TYPE_TAG_NAME (type
));
365 /* Return the type, stripped of typedefs. */
367 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
369 struct type
*type
= ((type_object
*) self
)->type
;
371 return type_to_type_object (check_typedef (type
));
374 /* Return an array type. */
377 typy_array (PyObject
*self
, PyObject
*args
)
380 PyObject
*n2_obj
= NULL
;
381 struct type
*array
= NULL
;
382 struct type
*type
= ((type_object
*) self
)->type
;
383 volatile struct gdb_exception except
;
385 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
390 if (!PyInt_Check (n2_obj
))
392 PyErr_SetString (PyExc_RuntimeError
,
393 _("Array bound must be an integer"));
397 if (! gdb_py_int_as_long (n2_obj
, &n2
))
408 PyErr_SetString (PyExc_ValueError
,
409 _("Array length must not be negative"));
413 TRY_CATCH (except
, RETURN_MASK_ALL
)
415 array
= lookup_array_range_type (type
, n1
, n2
);
417 GDB_PY_HANDLE_EXCEPTION (except
);
419 return type_to_type_object (array
);
422 /* Return a Type object which represents a pointer to SELF. */
424 typy_pointer (PyObject
*self
, PyObject
*args
)
426 struct type
*type
= ((type_object
*) self
)->type
;
427 volatile struct gdb_exception except
;
429 TRY_CATCH (except
, RETURN_MASK_ALL
)
431 type
= lookup_pointer_type (type
);
433 GDB_PY_HANDLE_EXCEPTION (except
);
435 return type_to_type_object (type
);
438 /* Return the range of a type represented by SELF. The return type is
439 a tuple. The first element of the tuple contains the low bound,
440 while the second element of the tuple contains the high bound. */
442 typy_range (PyObject
*self
, PyObject
*args
)
444 struct type
*type
= ((type_object
*) self
)->type
;
446 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
447 /* Initialize these to appease GCC warnings. */
448 LONGEST low
= 0, high
= 0;
450 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
451 && TYPE_CODE (type
) != TYPE_CODE_STRING
452 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
454 PyErr_SetString (PyExc_RuntimeError
,
455 _("This type does not have a range."));
459 switch (TYPE_CODE (type
))
461 case TYPE_CODE_ARRAY
:
462 case TYPE_CODE_STRING
:
463 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
464 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
466 case TYPE_CODE_RANGE
:
467 low
= TYPE_LOW_BOUND (type
);
468 high
= TYPE_HIGH_BOUND (type
);
472 low_bound
= PyLong_FromLong (low
);
476 high_bound
= PyLong_FromLong (high
);
480 result
= PyTuple_New (2);
484 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
489 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
491 Py_DECREF (high_bound
);
498 Py_XDECREF (high_bound
);
499 Py_XDECREF (low_bound
);
503 /* Return a Type object which represents a reference to SELF. */
505 typy_reference (PyObject
*self
, PyObject
*args
)
507 struct type
*type
= ((type_object
*) self
)->type
;
508 volatile struct gdb_exception except
;
510 TRY_CATCH (except
, RETURN_MASK_ALL
)
512 type
= lookup_reference_type (type
);
514 GDB_PY_HANDLE_EXCEPTION (except
);
516 return type_to_type_object (type
);
519 /* Return a Type object which represents the target type of SELF. */
521 typy_target (PyObject
*self
, PyObject
*args
)
523 struct type
*type
= ((type_object
*) self
)->type
;
525 if (!TYPE_TARGET_TYPE (type
))
527 PyErr_SetString (PyExc_RuntimeError
,
528 _("Type does not have a target."));
532 return type_to_type_object (TYPE_TARGET_TYPE (type
));
535 /* Return a const-qualified type variant. */
537 typy_const (PyObject
*self
, PyObject
*args
)
539 struct type
*type
= ((type_object
*) self
)->type
;
540 volatile struct gdb_exception except
;
542 TRY_CATCH (except
, RETURN_MASK_ALL
)
544 type
= make_cv_type (1, 0, type
, NULL
);
546 GDB_PY_HANDLE_EXCEPTION (except
);
548 return type_to_type_object (type
);
551 /* Return a volatile-qualified type variant. */
553 typy_volatile (PyObject
*self
, PyObject
*args
)
555 struct type
*type
= ((type_object
*) self
)->type
;
556 volatile struct gdb_exception except
;
558 TRY_CATCH (except
, RETURN_MASK_ALL
)
560 type
= make_cv_type (0, 1, type
, NULL
);
562 GDB_PY_HANDLE_EXCEPTION (except
);
564 return type_to_type_object (type
);
567 /* Return an unqualified type variant. */
569 typy_unqualified (PyObject
*self
, PyObject
*args
)
571 struct type
*type
= ((type_object
*) self
)->type
;
572 volatile struct gdb_exception except
;
574 TRY_CATCH (except
, RETURN_MASK_ALL
)
576 type
= make_cv_type (0, 0, type
, NULL
);
578 GDB_PY_HANDLE_EXCEPTION (except
);
580 return type_to_type_object (type
);
583 /* Return the size of the type represented by SELF, in bytes. */
585 typy_get_sizeof (PyObject
*self
, void *closure
)
587 struct type
*type
= ((type_object
*) self
)->type
;
588 volatile struct gdb_exception except
;
590 TRY_CATCH (except
, RETURN_MASK_ALL
)
592 check_typedef (type
);
594 /* Ignore exceptions. */
596 return PyLong_FromLong (TYPE_LENGTH (type
));
600 typy_lookup_typename (const char *type_name
, struct block
*block
)
602 struct type
*type
= NULL
;
603 volatile struct gdb_exception except
;
605 TRY_CATCH (except
, RETURN_MASK_ALL
)
607 if (!strncmp (type_name
, "struct ", 7))
608 type
= lookup_struct (type_name
+ 7, NULL
);
609 else if (!strncmp (type_name
, "union ", 6))
610 type
= lookup_union (type_name
+ 6, NULL
);
611 else if (!strncmp (type_name
, "enum ", 5))
612 type
= lookup_enum (type_name
+ 5, NULL
);
614 type
= lookup_typename (python_language
, python_gdbarch
,
615 type_name
, block
, 0);
617 if (except
.reason
< 0)
619 PyErr_Format (except
.reason
== RETURN_QUIT
620 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
621 "%s", except
.message
);
629 typy_lookup_type (struct demangle_component
*demangled
,
634 enum demangle_component_type demangled_type
;
636 /* Save the type: typy_lookup_type() may (indirectly) overwrite
637 memory pointed by demangled. */
638 demangled_type
= demangled
->type
;
640 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
641 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
642 || demangled_type
== DEMANGLE_COMPONENT_CONST
643 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
645 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
649 switch (demangled_type
)
651 case DEMANGLE_COMPONENT_REFERENCE
:
652 return lookup_reference_type (type
);
653 case DEMANGLE_COMPONENT_POINTER
:
654 return lookup_pointer_type (type
);
655 case DEMANGLE_COMPONENT_CONST
:
656 return make_cv_type (1, 0, type
, NULL
);
657 case DEMANGLE_COMPONENT_VOLATILE
:
658 return make_cv_type (0, 1, type
, NULL
);
662 type_name
= cp_comp_to_string (demangled
, 10);
663 type
= typy_lookup_typename (type_name
, block
);
669 /* This is a helper function for typy_template_argument that is used
670 when the type does not have template symbols attached. It works by
671 parsing the type name. This happens with compilers, like older
672 versions of GCC, that do not emit DW_TAG_template_*. */
675 typy_legacy_template_argument (struct type
*type
, struct block
*block
,
679 struct demangle_component
*demangled
;
680 struct demangle_parse_info
*info
;
682 struct type
*argtype
;
683 struct cleanup
*cleanup
;
685 if (TYPE_NAME (type
) == NULL
)
687 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
691 /* Note -- this is not thread-safe. */
692 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
695 PyErr_SetString (PyExc_RuntimeError
, err
);
698 demangled
= info
->tree
;
699 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
701 /* Strip off component names. */
702 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
703 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
704 demangled
= demangled
->u
.s_binary
.right
;
706 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
708 do_cleanups (cleanup
);
709 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
713 /* Skip from the template to the arguments. */
714 demangled
= demangled
->u
.s_binary
.right
;
716 for (i
= 0; demangled
&& i
< argno
; ++i
)
717 demangled
= demangled
->u
.s_binary
.right
;
721 do_cleanups (cleanup
);
722 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
727 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
728 do_cleanups (cleanup
);
732 return type_to_type_object (argtype
);
736 typy_template_argument (PyObject
*self
, PyObject
*args
)
739 struct type
*type
= ((type_object
*) self
)->type
;
740 struct block
*block
= NULL
;
741 PyObject
*block_obj
= NULL
;
743 struct value
*val
= NULL
;
744 volatile struct gdb_exception except
;
746 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
751 block
= block_object_to_block (block_obj
);
754 PyErr_SetString (PyExc_RuntimeError
,
755 _("Second argument must be block."));
760 TRY_CATCH (except
, RETURN_MASK_ALL
)
762 type
= check_typedef (type
);
763 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
764 type
= check_typedef (TYPE_TARGET_TYPE (type
));
766 GDB_PY_HANDLE_EXCEPTION (except
);
768 /* We might not have DW_TAG_template_*, so try to parse the type's
769 name. This is inefficient if we do not have a template type --
770 but that is going to wind up as an error anyhow. */
771 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
772 return typy_legacy_template_argument (type
, block
, argno
);
774 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
776 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
781 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
782 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
783 return type_to_type_object (SYMBOL_TYPE (sym
));
784 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
786 PyErr_Format (PyExc_RuntimeError
,
787 _("Template argument is optimized out"));
791 TRY_CATCH (except
, RETURN_MASK_ALL
)
793 val
= value_of_variable (sym
, block
);
795 GDB_PY_HANDLE_EXCEPTION (except
);
797 return value_to_value_object (val
);
801 typy_str (PyObject
*self
)
803 volatile struct gdb_exception except
;
804 char *thetype
= NULL
;
808 TRY_CATCH (except
, RETURN_MASK_ALL
)
810 struct cleanup
*old_chain
;
813 stb
= mem_fileopen ();
814 old_chain
= make_cleanup_ui_file_delete (stb
);
816 type_print (type_object_to_type (self
), "", stb
, -1);
818 thetype
= ui_file_xstrdup (stb
, &length
);
819 do_cleanups (old_chain
);
821 if (except
.reason
< 0)
824 GDB_PY_HANDLE_EXCEPTION (except
);
827 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
833 /* An entry in the type-equality bcache. */
835 typedef struct type_equality_entry
837 struct type
*type1
, *type2
;
838 } type_equality_entry_d
;
840 DEF_VEC_O (type_equality_entry_d
);
842 /* A helper function to compare two strings. Returns 1 if they are
843 the same, 0 otherwise. Handles NULLs properly. */
846 compare_strings (const char *s
, const char *t
)
848 if (s
== NULL
&& t
!= NULL
)
850 else if (s
!= NULL
&& t
== NULL
)
852 else if (s
== NULL
&& t
== NULL
)
854 return strcmp (s
, t
) == 0;
857 /* A helper function for typy_richcompare that checks two types for
858 "deep" equality. Returns Py_EQ if the types are considered the
859 same, Py_NE otherwise. */
862 check_types_equal (struct type
*type1
, struct type
*type2
,
863 VEC (type_equality_entry_d
) **worklist
)
865 CHECK_TYPEDEF (type1
);
866 CHECK_TYPEDEF (type2
);
871 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
872 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
873 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
874 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
875 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
876 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
877 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
878 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
879 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
882 if (!compare_strings (TYPE_TAG_NAME (type1
), TYPE_TAG_NAME (type2
)))
884 if (!compare_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
887 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
889 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
890 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
897 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
899 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
900 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
901 struct type_equality_entry entry
;
903 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
904 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
905 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
907 if (!compare_strings (FIELD_NAME (*field1
), FIELD_NAME (*field2
)))
909 switch (FIELD_LOC_KIND (*field1
))
911 case FIELD_LOC_KIND_BITPOS
:
912 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
915 case FIELD_LOC_KIND_PHYSADDR
:
916 if (FIELD_STATIC_PHYSADDR (*field1
)
917 != FIELD_STATIC_PHYSADDR (*field2
))
920 case FIELD_LOC_KIND_PHYSNAME
:
921 if (!compare_strings (FIELD_STATIC_PHYSNAME (*field1
),
922 FIELD_STATIC_PHYSNAME (*field2
)))
927 entry
.type1
= FIELD_TYPE (*field1
);
928 entry
.type2
= FIELD_TYPE (*field2
);
929 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
933 if (TYPE_TARGET_TYPE (type1
) != NULL
)
935 struct type_equality_entry entry
;
938 if (TYPE_TARGET_TYPE (type2
) == NULL
)
941 entry
.type1
= TYPE_TARGET_TYPE (type1
);
942 entry
.type2
= TYPE_TARGET_TYPE (type2
);
943 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
945 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
951 /* Check types on a worklist for equality. Returns Py_NE if any pair
952 is not equal, Py_EQ if they are all considered equal. */
955 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
956 struct bcache
*cache
)
958 while (!VEC_empty (type_equality_entry_d
, *worklist
))
960 struct type_equality_entry entry
;
963 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
964 VEC_pop (type_equality_entry_d
, *worklist
);
966 /* If the type pair has already been visited, we know it is
968 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
972 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
979 /* Implement the richcompare method. */
982 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
985 struct type
*type1
= type_object_to_type (self
);
986 struct type
*type2
= type_object_to_type (other
);
987 volatile struct gdb_exception except
;
989 /* We can only compare ourselves to another Type object, and only
990 for equality or inequality. */
991 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
993 Py_INCREF (Py_NotImplemented
);
994 return Py_NotImplemented
;
1001 struct bcache
*cache
;
1002 VEC (type_equality_entry_d
) *worklist
= NULL
;
1003 struct type_equality_entry entry
;
1005 cache
= bcache_xmalloc (NULL
, NULL
);
1007 entry
.type1
= type1
;
1008 entry
.type2
= type2
;
1009 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1011 TRY_CATCH (except
, RETURN_MASK_ALL
)
1013 result
= check_types_worklist (&worklist
, cache
);
1015 if (except
.reason
< 0)
1018 bcache_xfree (cache
);
1019 VEC_free (type_equality_entry_d
, worklist
);
1029 static const struct objfile_data
*typy_objfile_data_key
;
1032 save_objfile_types (struct objfile
*objfile
, void *datum
)
1034 type_object
*obj
= datum
;
1035 htab_t copied_types
;
1036 struct cleanup
*cleanup
;
1038 /* This prevents another thread from freeing the objects we're
1040 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1042 copied_types
= create_copied_types_hash (objfile
);
1046 type_object
*next
= obj
->next
;
1048 htab_empty (copied_types
);
1050 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1058 htab_delete (copied_types
);
1060 do_cleanups (cleanup
);
1064 set_type (type_object
*obj
, struct type
*type
)
1068 if (type
&& TYPE_OBJFILE (type
))
1070 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1072 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1074 obj
->next
->prev
= obj
;
1075 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1082 typy_dealloc (PyObject
*obj
)
1084 type_object
*type
= (type_object
*) obj
;
1087 type
->prev
->next
= type
->next
;
1088 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1090 /* Must reset head of list. */
1091 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1094 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1097 type
->next
->prev
= type
->prev
;
1099 type
->ob_type
->tp_free (type
);
1102 /* Return number of fields ("length" of the field dictionary). */
1105 typy_length (PyObject
*self
)
1107 struct type
*type
= ((type_object
*) self
)->type
;
1109 return TYPE_NFIELDS (type
);
1112 /* Return a gdb.Field object for the field named by the argument. */
1115 typy_getitem (PyObject
*self
, PyObject
*key
)
1117 struct type
*type
= ((type_object
*) self
)->type
;
1121 field
= python_string_to_host_string (key
);
1125 /* We want just fields of this type, not of base types, so instead of
1126 using lookup_struct_elt_type, portions of that function are
1131 CHECK_TYPEDEF (type
);
1132 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1133 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1135 type
= TYPE_TARGET_TYPE (type
);
1138 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1140 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1142 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1144 return convert_field (type
, i
);
1147 PyErr_SetObject (PyExc_KeyError
, key
);
1151 /* Implement the "get" method on the type object. This is the
1152 same as getitem if the key is present, but returns the supplied
1153 default value or None if the key is not found. */
1156 typy_get (PyObject
*self
, PyObject
*args
)
1158 PyObject
*key
, *defval
= Py_None
, *result
;
1160 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1163 result
= typy_getitem (self
, key
);
1167 /* typy_getitem returned error status. If the exception is
1168 KeyError, clear the exception status and return the defval
1169 instead. Otherwise return the exception unchanged. */
1170 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1178 /* Implement the "has_key" method on the type object. */
1181 typy_has_key (PyObject
*self
, PyObject
*args
)
1183 struct type
*type
= ((type_object
*) self
)->type
;
1187 if (!PyArg_ParseTuple (args
, "s", &field
))
1190 /* We want just fields of this type, not of base types, so instead of
1191 using lookup_struct_elt_type, portions of that function are
1196 CHECK_TYPEDEF (type
);
1197 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1198 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1200 type
= TYPE_TARGET_TYPE (type
);
1203 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1205 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1207 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1213 /* Make an iterator object to iterate over keys, values, or items. */
1216 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1218 typy_iterator_object
*typy_iter_obj
;
1220 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1221 &type_iterator_object_type
);
1222 if (typy_iter_obj
== NULL
)
1225 typy_iter_obj
->field
= 0;
1226 typy_iter_obj
->kind
= kind
;
1228 typy_iter_obj
->source
= (type_object
*) self
;
1230 return (PyObject
*) typy_iter_obj
;
1233 /* iteritems() method. */
1236 typy_iteritems (PyObject
*self
, PyObject
*args
)
1238 return typy_make_iter (self
, iter_items
);
1241 /* iterkeys() method. */
1244 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1246 return typy_make_iter (self
, iter_keys
);
1249 /* Iterating over the class, same as iterkeys except for the function
1253 typy_iter (PyObject
*self
)
1255 return typy_make_iter (self
, iter_keys
);
1258 /* itervalues() method. */
1261 typy_itervalues (PyObject
*self
, PyObject
*args
)
1263 return typy_make_iter (self
, iter_values
);
1266 /* Return a reference to the type iterator. */
1269 typy_iterator_iter (PyObject
*self
)
1275 /* Return the next field in the iteration through the list of fields
1279 typy_iterator_iternext (PyObject
*self
)
1281 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1282 struct type
*type
= iter_obj
->source
->type
;
1286 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1288 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1298 typy_iterator_dealloc (PyObject
*obj
)
1300 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1302 Py_DECREF (iter_obj
->source
);
1305 /* Create a new Type referring to TYPE. */
1307 type_to_type_object (struct type
*type
)
1309 type_object
*type_obj
;
1311 type_obj
= PyObject_New (type_object
, &type_object_type
);
1313 set_type (type_obj
, type
);
1315 return (PyObject
*) type_obj
;
1319 type_object_to_type (PyObject
*obj
)
1321 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1323 return ((type_object
*) obj
)->type
;
1328 /* Implementation of gdb.lookup_type. */
1330 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1332 static char *keywords
[] = { "name", "block", NULL
};
1333 const char *type_name
= NULL
;
1334 struct type
*type
= NULL
;
1335 PyObject
*block_obj
= NULL
;
1336 struct block
*block
= NULL
;
1338 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1339 &type_name
, &block_obj
))
1344 block
= block_object_to_block (block_obj
);
1347 PyErr_SetString (PyExc_RuntimeError
,
1348 _("'block' argument must be a Block."));
1353 type
= typy_lookup_typename (type_name
, block
);
1357 return (PyObject
*) type_to_type_object (type
);
1361 gdbpy_initialize_types (void)
1365 typy_objfile_data_key
1366 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1368 if (PyType_Ready (&type_object_type
) < 0)
1370 if (PyType_Ready (&field_object_type
) < 0)
1372 if (PyType_Ready (&type_iterator_object_type
) < 0)
1375 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1377 if (PyModule_AddIntConstant (gdb_module
,
1378 /* Cast needed for Python 2.4. */
1379 (char *) pyty_codes
[i
].name
,
1380 pyty_codes
[i
].code
) < 0)
1384 Py_INCREF (&type_object_type
);
1385 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1387 Py_INCREF (&type_iterator_object_type
);
1388 PyModule_AddObject (gdb_module
, "TypeIterator",
1389 (PyObject
*) &type_iterator_object_type
);
1391 Py_INCREF (&field_object_type
);
1392 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1397 static PyGetSetDef type_object_getset
[] =
1399 { "code", typy_get_code
, NULL
,
1400 "The code for this type.", NULL
},
1401 { "sizeof", typy_get_sizeof
, NULL
,
1402 "The size of this type, in bytes.", NULL
},
1403 { "tag", typy_get_tag
, NULL
,
1404 "The tag name for this type, or None.", NULL
},
1408 static PyMethodDef type_object_methods
[] =
1410 { "array", typy_array
, METH_VARARGS
,
1411 "array (N) -> Type\n\
1412 Return a type which represents an array of N objects of this type." },
1413 { "__contains__", typy_has_key
, METH_VARARGS
,
1414 "T.__contains__(k) -> True if T has a field named k, else False" },
1415 { "const", typy_const
, METH_NOARGS
,
1416 "const () -> Type\n\
1417 Return a const variant of this type." },
1418 { "fields", typy_fields
, METH_NOARGS
,
1419 "fields () -> list\n\
1420 Return a list holding all the fields of this type.\n\
1421 Each field is a gdb.Field object." },
1422 { "get", typy_get
, METH_VARARGS
,
1423 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1424 otherwise returns default, if supplied, or None if not." },
1425 { "has_key", typy_has_key
, METH_VARARGS
,
1426 "T.has_key(k) -> True if T has a field named k, else False" },
1427 { "items", typy_items
, METH_NOARGS
,
1428 "items () -> list\n\
1429 Return a list of (name, field) pairs of this type.\n\
1430 Each field is a gdb.Field object." },
1431 { "iteritems", typy_iteritems
, METH_NOARGS
,
1432 "iteritems () -> an iterator over the (name, field)\n\
1433 pairs of this type. Each field is a gdb.Field object." },
1434 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1435 "iterkeys () -> an iterator over the field names of this type." },
1436 { "itervalues", typy_itervalues
, METH_NOARGS
,
1437 "itervalues () -> an iterator over the fields of this type.\n\
1438 Each field is a gdb.Field object." },
1439 { "keys", typy_field_names
, METH_NOARGS
,
1441 Return a list holding all the fields names of this type." },
1442 { "pointer", typy_pointer
, METH_NOARGS
,
1443 "pointer () -> Type\n\
1444 Return a type of pointer to this type." },
1445 { "range", typy_range
, METH_NOARGS
,
1446 "range () -> tuple\n\
1447 Return a tuple containing the lower and upper range for this type."},
1448 { "reference", typy_reference
, METH_NOARGS
,
1449 "reference () -> Type\n\
1450 Return a type of reference to this type." },
1451 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1452 "strip_typedefs () -> Type\n\
1453 Return a type formed by stripping this type of all typedefs."},
1454 { "target", typy_target
, METH_NOARGS
,
1455 "target () -> Type\n\
1456 Return the target type of this type." },
1457 { "template_argument", typy_template_argument
, METH_VARARGS
,
1458 "template_argument (arg, [block]) -> Type\n\
1459 Return the type of a template argument." },
1460 { "unqualified", typy_unqualified
, METH_NOARGS
,
1461 "unqualified () -> Type\n\
1462 Return a variant of this type without const or volatile attributes." },
1463 { "values", typy_fields
, METH_NOARGS
,
1464 "values () -> list\n\
1465 Return a list holding all the fields of this type.\n\
1466 Each field is a gdb.Field object." },
1467 { "volatile", typy_volatile
, METH_NOARGS
,
1468 "volatile () -> Type\n\
1469 Return a volatile variant of this type" },
1473 static PyMappingMethods typy_mapping
= {
1476 NULL
/* no "set" method */
1479 static PyTypeObject type_object_type
=
1481 PyObject_HEAD_INIT (NULL
)
1483 "gdb.Type", /*tp_name*/
1484 sizeof (type_object
), /*tp_basicsize*/
1486 typy_dealloc
, /*tp_dealloc*/
1493 0, /*tp_as_sequence*/
1494 &typy_mapping
, /*tp_as_mapping*/
1497 typy_str
, /*tp_str*/
1501 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1502 "GDB type object", /* tp_doc */
1503 0, /* tp_traverse */
1505 typy_richcompare
, /* tp_richcompare */
1506 0, /* tp_weaklistoffset */
1507 typy_iter
, /* tp_iter */
1508 0, /* tp_iternext */
1509 type_object_methods
, /* tp_methods */
1511 type_object_getset
, /* tp_getset */
1514 0, /* tp_descr_get */
1515 0, /* tp_descr_set */
1516 0, /* tp_dictoffset */
1522 static PyTypeObject field_object_type
=
1524 PyObject_HEAD_INIT (NULL
)
1526 "gdb.Field", /*tp_name*/
1527 sizeof (field_object
), /*tp_basicsize*/
1529 field_dealloc
, /*tp_dealloc*/
1536 0, /*tp_as_sequence*/
1537 0, /*tp_as_mapping*/
1544 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1545 "GDB field object", /* tp_doc */
1546 0, /* tp_traverse */
1548 0, /* tp_richcompare */
1549 0, /* tp_weaklistoffset */
1551 0, /* tp_iternext */
1557 0, /* tp_descr_get */
1558 0, /* tp_descr_set */
1559 offsetof (field_object
, dict
), /* tp_dictoffset */
1565 static PyTypeObject type_iterator_object_type
= {
1566 PyObject_HEAD_INIT (NULL
)
1568 "gdb.TypeIterator", /*tp_name*/
1569 sizeof (typy_iterator_object
), /*tp_basicsize*/
1571 typy_iterator_dealloc
, /*tp_dealloc*/
1578 0, /*tp_as_sequence*/
1579 0, /*tp_as_mapping*/
1586 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1587 "GDB type iterator object", /*tp_doc */
1590 0, /*tp_richcompare */
1591 0, /*tp_weaklistoffset */
1592 typy_iterator_iter
, /*tp_iter */
1593 typy_iterator_iternext
, /*tp_iternext */