1 /* Python interface to types.
3 Copyright (C) 2008-2018 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 "python-internal.h"
25 #include "cp-support.h"
30 #include "typeprint.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 extern PyTypeObject type_object_type
46 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
49 typedef struct pyty_field_object
53 /* Dictionary holding our attributes. */
57 extern PyTypeObject field_object_type
58 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
60 /* A type iterator object. */
63 /* The current field index. */
66 enum gdbpy_iter_kind kind
;
67 /* Pointer back to the original source type object. */
68 struct pyty_type_object
*source
;
69 } typy_iterator_object
;
71 extern PyTypeObject type_iterator_object_type
72 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
74 /* This is used to initialize various gdb.TYPE_ constants. */
83 /* Forward declarations. */
84 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
86 #define ENTRY(X) { X, #X }
88 static struct pyty_code pyty_codes
[] =
90 ENTRY (TYPE_CODE_BITSTRING
),
91 ENTRY (TYPE_CODE_PTR
),
92 ENTRY (TYPE_CODE_ARRAY
),
93 ENTRY (TYPE_CODE_STRUCT
),
94 ENTRY (TYPE_CODE_UNION
),
95 ENTRY (TYPE_CODE_ENUM
),
96 ENTRY (TYPE_CODE_FLAGS
),
97 ENTRY (TYPE_CODE_FUNC
),
98 ENTRY (TYPE_CODE_INT
),
99 ENTRY (TYPE_CODE_FLT
),
100 ENTRY (TYPE_CODE_VOID
),
101 ENTRY (TYPE_CODE_SET
),
102 ENTRY (TYPE_CODE_RANGE
),
103 ENTRY (TYPE_CODE_STRING
),
104 ENTRY (TYPE_CODE_ERROR
),
105 ENTRY (TYPE_CODE_METHOD
),
106 ENTRY (TYPE_CODE_METHODPTR
),
107 ENTRY (TYPE_CODE_MEMBERPTR
),
108 ENTRY (TYPE_CODE_REF
),
109 ENTRY (TYPE_CODE_RVALUE_REF
),
110 ENTRY (TYPE_CODE_CHAR
),
111 ENTRY (TYPE_CODE_BOOL
),
112 ENTRY (TYPE_CODE_COMPLEX
),
113 ENTRY (TYPE_CODE_TYPEDEF
),
114 ENTRY (TYPE_CODE_NAMESPACE
),
115 ENTRY (TYPE_CODE_DECFLOAT
),
116 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
117 { TYPE_CODE_UNDEF
, NULL
}
123 field_dealloc (PyObject
*obj
)
125 field_object
*f
= (field_object
*) obj
;
127 Py_XDECREF (f
->dict
);
128 Py_TYPE (obj
)->tp_free (obj
);
134 gdbpy_ref
<field_object
> result (PyObject_New (field_object
,
135 &field_object_type
));
139 result
->dict
= PyDict_New ();
143 return (PyObject
*) result
.release ();
148 /* Return true if OBJ is of type gdb.Field, false otherwise. */
151 gdbpy_is_field (PyObject
*obj
)
153 return PyObject_TypeCheck (obj
, &field_object_type
);
156 /* Return the code for this type. */
158 typy_get_code (PyObject
*self
, void *closure
)
160 struct type
*type
= ((type_object
*) self
)->type
;
162 return PyInt_FromLong (TYPE_CODE (type
));
165 /* Helper function for typy_fields which converts a single field to a
166 gdb.Field object. Returns NULL on error. */
169 convert_field (struct type
*type
, int field
)
171 gdbpy_ref
<> result (field_new ());
176 gdbpy_ref
<> arg (type_to_type_object (type
));
179 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
182 if (!field_is_static (&TYPE_FIELD (type
, field
)))
184 const char *attrstring
;
186 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
188 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
190 attrstring
= "enumval";
194 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
196 attrstring
= "bitpos";
202 /* At least python-2.4 had the second parameter non-const. */
203 if (PyObject_SetAttrString (result
.get (), (char *) attrstring
,
209 if (TYPE_FIELD_NAME (type
, field
))
211 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
213 if (field_name
[0] != '\0')
215 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
223 Py_INCREF (arg
.get ());
225 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
228 arg
.reset (TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
);
229 Py_INCREF (arg
.get ());
230 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
233 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
234 arg
.reset (field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
);
236 arg
.reset (Py_False
);
237 Py_INCREF (arg
.get ());
238 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
241 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
244 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
247 /* A field can have a NULL type in some situations. */
248 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
251 Py_INCREF (arg
.get ());
254 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
257 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
260 return result
.release ();
263 /* Helper function to return the name of a field, as a gdb.Field object.
264 If the field doesn't have a name, None is returned. */
267 field_name (struct type
*type
, int field
)
271 if (TYPE_FIELD_NAME (type
, field
))
272 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
281 /* Helper function for Type standard mapping methods. Returns a
282 Python object for field i of the type. "kind" specifies what to
283 return: the name of the field, a gdb.Field object corresponding to
284 the field, or a tuple consisting of field name and gdb.Field
288 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
294 gdbpy_ref
<> key (field_name (type
, i
));
297 gdbpy_ref
<> value (convert_field (type
, i
));
300 gdbpy_ref
<> item (PyTuple_New (2));
303 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
304 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
305 return item
.release ();
308 return field_name (type
, i
);
310 return convert_field (type
, i
);
312 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
315 /* Return a sequence of all field names, fields, or (name, field) pairs.
316 Each field is a gdb.Field object. */
319 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
321 PyObject
*py_type
= self
;
322 PyObject
*result
= NULL
, *iter
= NULL
;
323 struct type
*type
= ((type_object
*) py_type
)->type
;
324 struct type
*checked_type
= type
;
328 checked_type
= check_typedef (checked_type
);
330 CATCH (except
, RETURN_MASK_ALL
)
332 GDB_PY_HANDLE_EXCEPTION (except
);
336 if (checked_type
!= type
)
337 py_type
= type_to_type_object (checked_type
);
338 iter
= typy_make_iter (py_type
, kind
);
339 if (checked_type
!= type
)
341 /* Need to wrap this in braces because Py_DECREF isn't wrapped
342 in a do{}while(0). */
347 result
= PySequence_List (iter
);
354 /* Return a sequence of all fields. Each field is a gdb.Field object. */
357 typy_values (PyObject
*self
, PyObject
*args
)
359 return typy_fields_items (self
, iter_values
);
362 /* Return a sequence of all fields. Each field is a gdb.Field object.
363 This method is similar to typy_values, except where the supplied
364 gdb.Type is an array, in which case it returns a list of one entry
365 which is a gdb.Field object for a range (the array bounds). */
368 typy_fields (PyObject
*self
, PyObject
*args
)
370 struct type
*type
= ((type_object
*) self
)->type
;
372 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
373 return typy_fields_items (self
, iter_values
);
375 /* Array type. Handle this as a special case because the common
376 machinery wants struct or union or enum types. Build a list of
377 one entry which is the range for the array. */
378 gdbpy_ref
<> r (convert_field (type
, 0));
382 return Py_BuildValue ("[O]", r
.get ());
385 /* Return a sequence of all field names. Each field is a gdb.Field object. */
388 typy_field_names (PyObject
*self
, PyObject
*args
)
390 return typy_fields_items (self
, iter_keys
);
393 /* Return a sequence of all (name, fields) pairs. Each field is a
397 typy_items (PyObject
*self
, PyObject
*args
)
399 return typy_fields_items (self
, iter_items
);
402 /* Return the type's name, or None. */
405 typy_get_name (PyObject
*self
, void *closure
)
407 struct type
*type
= ((type_object
*) self
)->type
;
409 if (TYPE_NAME (type
) == NULL
)
411 return PyString_FromString (TYPE_NAME (type
));
414 /* Return the type's tag, or None. */
416 typy_get_tag (PyObject
*self
, void *closure
)
418 struct type
*type
= ((type_object
*) self
)->type
;
420 if (!TYPE_TAG_NAME (type
))
422 return PyString_FromString (TYPE_TAG_NAME (type
));
425 /* Return the type, stripped of typedefs. */
427 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
429 struct type
*type
= ((type_object
*) self
)->type
;
433 type
= check_typedef (type
);
435 CATCH (except
, RETURN_MASK_ALL
)
437 GDB_PY_HANDLE_EXCEPTION (except
);
441 return type_to_type_object (type
);
444 /* Strip typedefs and pointers/reference from a type. Then check that
445 it is a struct, union, or enum type. If not, raise TypeError. */
448 typy_get_composite (struct type
*type
)
455 type
= check_typedef (type
);
457 CATCH (except
, RETURN_MASK_ALL
)
459 GDB_PY_HANDLE_EXCEPTION (except
);
463 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
465 type
= TYPE_TARGET_TYPE (type
);
468 /* If this is not a struct, union, or enum type, raise TypeError
470 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
471 && TYPE_CODE (type
) != TYPE_CODE_UNION
472 && TYPE_CODE (type
) != TYPE_CODE_ENUM
473 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
475 PyErr_SetString (PyExc_TypeError
,
476 "Type is not a structure, union, enum, or function type.");
483 /* Helper for typy_array and typy_vector. */
486 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
489 PyObject
*n2_obj
= NULL
;
490 struct type
*array
= NULL
;
491 struct type
*type
= ((type_object
*) self
)->type
;
493 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
498 if (!PyInt_Check (n2_obj
))
500 PyErr_SetString (PyExc_RuntimeError
,
501 _("Array bound must be an integer"));
505 if (! gdb_py_int_as_long (n2_obj
, &n2
))
514 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
516 PyErr_SetString (PyExc_ValueError
,
517 _("Array length must not be negative"));
523 array
= lookup_array_range_type (type
, n1
, n2
);
525 make_vector_type (array
);
527 CATCH (except
, RETURN_MASK_ALL
)
529 GDB_PY_HANDLE_EXCEPTION (except
);
533 return type_to_type_object (array
);
536 /* Return an array type. */
539 typy_array (PyObject
*self
, PyObject
*args
)
541 return typy_array_1 (self
, args
, 0);
544 /* Return a vector type. */
547 typy_vector (PyObject
*self
, PyObject
*args
)
549 return typy_array_1 (self
, args
, 1);
552 /* Return a Type object which represents a pointer to SELF. */
554 typy_pointer (PyObject
*self
, PyObject
*args
)
556 struct type
*type
= ((type_object
*) self
)->type
;
560 type
= lookup_pointer_type (type
);
562 CATCH (except
, RETURN_MASK_ALL
)
564 GDB_PY_HANDLE_EXCEPTION (except
);
568 return type_to_type_object (type
);
571 /* Return the range of a type represented by SELF. The return type is
572 a tuple. The first element of the tuple contains the low bound,
573 while the second element of the tuple contains the high bound. */
575 typy_range (PyObject
*self
, PyObject
*args
)
577 struct type
*type
= ((type_object
*) self
)->type
;
578 /* Initialize these to appease GCC warnings. */
579 LONGEST low
= 0, high
= 0;
581 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
582 && TYPE_CODE (type
) != TYPE_CODE_STRING
583 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
585 PyErr_SetString (PyExc_RuntimeError
,
586 _("This type does not have a range."));
590 switch (TYPE_CODE (type
))
592 case TYPE_CODE_ARRAY
:
593 case TYPE_CODE_STRING
:
594 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
595 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
597 case TYPE_CODE_RANGE
:
598 low
= TYPE_LOW_BOUND (type
);
599 high
= TYPE_HIGH_BOUND (type
);
603 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
604 if (low_bound
== NULL
)
607 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
608 if (high_bound
== NULL
)
611 gdbpy_ref
<> result (PyTuple_New (2));
615 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
616 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
618 return result
.release ();
621 /* Return a Type object which represents a reference to SELF. */
623 typy_reference (PyObject
*self
, PyObject
*args
)
625 struct type
*type
= ((type_object
*) self
)->type
;
629 type
= lookup_lvalue_reference_type (type
);
631 CATCH (except
, RETURN_MASK_ALL
)
633 GDB_PY_HANDLE_EXCEPTION (except
);
637 return type_to_type_object (type
);
640 /* Return a Type object which represents the target type of SELF. */
642 typy_target (PyObject
*self
, PyObject
*args
)
644 struct type
*type
= ((type_object
*) self
)->type
;
646 if (!TYPE_TARGET_TYPE (type
))
648 PyErr_SetString (PyExc_RuntimeError
,
649 _("Type does not have a target."));
653 return type_to_type_object (TYPE_TARGET_TYPE (type
));
656 /* Return a const-qualified type variant. */
658 typy_const (PyObject
*self
, PyObject
*args
)
660 struct type
*type
= ((type_object
*) self
)->type
;
664 type
= make_cv_type (1, 0, type
, NULL
);
666 CATCH (except
, RETURN_MASK_ALL
)
668 GDB_PY_HANDLE_EXCEPTION (except
);
672 return type_to_type_object (type
);
675 /* Return a volatile-qualified type variant. */
677 typy_volatile (PyObject
*self
, PyObject
*args
)
679 struct type
*type
= ((type_object
*) self
)->type
;
683 type
= make_cv_type (0, 1, type
, NULL
);
685 CATCH (except
, RETURN_MASK_ALL
)
687 GDB_PY_HANDLE_EXCEPTION (except
);
691 return type_to_type_object (type
);
694 /* Return an unqualified type variant. */
696 typy_unqualified (PyObject
*self
, PyObject
*args
)
698 struct type
*type
= ((type_object
*) self
)->type
;
702 type
= make_cv_type (0, 0, type
, NULL
);
704 CATCH (except
, RETURN_MASK_ALL
)
706 GDB_PY_HANDLE_EXCEPTION (except
);
710 return type_to_type_object (type
);
713 /* Return the size of the type represented by SELF, in bytes. */
715 typy_get_sizeof (PyObject
*self
, void *closure
)
717 struct type
*type
= ((type_object
*) self
)->type
;
721 check_typedef (type
);
723 CATCH (except
, RETURN_MASK_ALL
)
728 /* Ignore exceptions. */
730 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
734 typy_lookup_typename (const char *type_name
, const struct block
*block
)
736 struct type
*type
= NULL
;
740 if (startswith (type_name
, "struct "))
741 type
= lookup_struct (type_name
+ 7, NULL
);
742 else if (startswith (type_name
, "union "))
743 type
= lookup_union (type_name
+ 6, NULL
);
744 else if (startswith (type_name
, "enum "))
745 type
= lookup_enum (type_name
+ 5, NULL
);
747 type
= lookup_typename (python_language
, python_gdbarch
,
748 type_name
, block
, 0);
750 CATCH (except
, RETURN_MASK_ALL
)
752 GDB_PY_HANDLE_EXCEPTION (except
);
760 typy_lookup_type (struct demangle_component
*demangled
,
761 const struct block
*block
)
763 struct type
*type
, *rtype
= NULL
;
764 enum demangle_component_type demangled_type
;
766 /* Save the type: typy_lookup_type() may (indirectly) overwrite
767 memory pointed by demangled. */
768 demangled_type
= demangled
->type
;
770 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
771 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
772 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
773 || demangled_type
== DEMANGLE_COMPONENT_CONST
774 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
776 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
782 /* If the demangled_type matches with one of the types
783 below, run the corresponding function and save the type
784 to return later. We cannot just return here as we are in
785 an exception handler. */
786 switch (demangled_type
)
788 case DEMANGLE_COMPONENT_REFERENCE
:
789 rtype
= lookup_lvalue_reference_type (type
);
791 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
792 rtype
= lookup_rvalue_reference_type (type
);
794 case DEMANGLE_COMPONENT_POINTER
:
795 rtype
= lookup_pointer_type (type
);
797 case DEMANGLE_COMPONENT_CONST
:
798 rtype
= make_cv_type (1, 0, type
, NULL
);
800 case DEMANGLE_COMPONENT_VOLATILE
:
801 rtype
= make_cv_type (0, 1, type
, NULL
);
805 CATCH (except
, RETURN_MASK_ALL
)
807 GDB_PY_HANDLE_EXCEPTION (except
);
812 /* If we have a type from the switch statement above, just return
817 /* We don't have a type, so lookup the type. */
818 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
819 return typy_lookup_typename (type_name
.get (), block
);
822 /* This is a helper function for typy_template_argument that is used
823 when the type does not have template symbols attached. It works by
824 parsing the type name. This happens with compilers, like older
825 versions of GCC, that do not emit DW_TAG_template_*. */
828 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
832 struct demangle_component
*demangled
;
833 std::unique_ptr
<demangle_parse_info
> info
;
835 struct type
*argtype
;
837 if (TYPE_NAME (type
) == NULL
)
839 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
845 /* Note -- this is not thread-safe. */
846 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
848 CATCH (except
, RETURN_MASK_ALL
)
850 GDB_PY_HANDLE_EXCEPTION (except
);
856 PyErr_SetString (PyExc_RuntimeError
, err
);
859 demangled
= info
->tree
;
861 /* Strip off component names. */
862 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
863 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
864 demangled
= demangled
->u
.s_binary
.right
;
866 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
868 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
872 /* Skip from the template to the arguments. */
873 demangled
= demangled
->u
.s_binary
.right
;
875 for (i
= 0; demangled
&& i
< argno
; ++i
)
876 demangled
= demangled
->u
.s_binary
.right
;
880 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
885 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
889 return type_to_type_object (argtype
);
893 typy_template_argument (PyObject
*self
, PyObject
*args
)
896 struct type
*type
= ((type_object
*) self
)->type
;
897 const struct block
*block
= NULL
;
898 PyObject
*block_obj
= NULL
;
900 struct value
*val
= NULL
;
902 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
907 block
= block_object_to_block (block_obj
);
910 PyErr_SetString (PyExc_RuntimeError
,
911 _("Second argument must be block."));
918 type
= check_typedef (type
);
919 if (TYPE_IS_REFERENCE (type
))
920 type
= check_typedef (TYPE_TARGET_TYPE (type
));
922 CATCH (except
, RETURN_MASK_ALL
)
924 GDB_PY_HANDLE_EXCEPTION (except
);
928 /* We might not have DW_TAG_template_*, so try to parse the type's
929 name. This is inefficient if we do not have a template type --
930 but that is going to wind up as an error anyhow. */
931 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
932 return typy_legacy_template_argument (type
, block
, argno
);
934 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
936 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
941 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
942 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
943 return type_to_type_object (SYMBOL_TYPE (sym
));
944 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
946 PyErr_Format (PyExc_RuntimeError
,
947 _("Template argument is optimized out"));
953 val
= value_of_variable (sym
, block
);
955 CATCH (except
, RETURN_MASK_ALL
)
957 GDB_PY_HANDLE_EXCEPTION (except
);
961 return value_to_value_object (val
);
965 typy_str (PyObject
*self
)
971 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
972 &type_print_raw_options
);
974 CATCH (except
, RETURN_MASK_ALL
)
976 GDB_PY_HANDLE_EXCEPTION (except
);
980 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
981 host_charset (), NULL
);
984 /* Implement the richcompare method. */
987 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
990 struct type
*type1
= type_object_to_type (self
);
991 struct type
*type2
= type_object_to_type (other
);
993 /* We can only compare ourselves to another Type object, and only
994 for equality or inequality. */
995 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
997 Py_INCREF (Py_NotImplemented
);
998 return Py_NotImplemented
;
1007 result
= types_deeply_equal (type1
, type2
);
1009 CATCH (except
, RETURN_MASK_ALL
)
1011 /* If there is a GDB exception, a comparison is not capable
1012 (or trusted), so exit. */
1013 GDB_PY_HANDLE_EXCEPTION (except
);
1018 if (op
== (result
? Py_EQ
: Py_NE
))
1025 static const struct objfile_data
*typy_objfile_data_key
;
1028 save_objfile_types (struct objfile
*objfile
, void *datum
)
1030 type_object
*obj
= (type_object
*) datum
;
1031 htab_t copied_types
;
1033 if (!gdb_python_initialized
)
1036 /* This prevents another thread from freeing the objects we're
1038 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1040 copied_types
= create_copied_types_hash (objfile
);
1044 type_object
*next
= obj
->next
;
1046 htab_empty (copied_types
);
1048 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1056 htab_delete (copied_types
);
1060 set_type (type_object
*obj
, struct type
*type
)
1064 if (type
&& TYPE_OBJFILE (type
))
1066 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1068 obj
->next
= ((struct pyty_type_object
*)
1069 objfile_data (objfile
, typy_objfile_data_key
));
1071 obj
->next
->prev
= obj
;
1072 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1079 typy_dealloc (PyObject
*obj
)
1081 type_object
*type
= (type_object
*) obj
;
1084 type
->prev
->next
= type
->next
;
1085 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1087 /* Must reset head of list. */
1088 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1091 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1094 type
->next
->prev
= type
->prev
;
1096 Py_TYPE (type
)->tp_free (type
);
1099 /* Return number of fields ("length" of the field dictionary). */
1102 typy_length (PyObject
*self
)
1104 struct type
*type
= ((type_object
*) self
)->type
;
1106 type
= typy_get_composite (type
);
1110 return TYPE_NFIELDS (type
);
1113 /* Implements boolean evaluation of gdb.Type. Handle this like other
1114 Python objects that don't have a meaningful truth value -- all
1118 typy_nonzero (PyObject
*self
)
1123 /* Return optimized out value of this type. */
1126 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1128 struct type
*type
= ((type_object
*) self
)->type
;
1130 return value_to_value_object (allocate_optimized_out_value (type
));
1133 /* Return a gdb.Field object for the field named by the argument. */
1136 typy_getitem (PyObject
*self
, PyObject
*key
)
1138 struct type
*type
= ((type_object
*) self
)->type
;
1141 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1145 /* We want just fields of this type, not of base types, so instead of
1146 using lookup_struct_elt_type, portions of that function are
1149 type
= typy_get_composite (type
);
1153 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1155 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1157 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1159 return convert_field (type
, i
);
1162 PyErr_SetObject (PyExc_KeyError
, key
);
1166 /* Implement the "get" method on the type object. This is the
1167 same as getitem if the key is present, but returns the supplied
1168 default value or None if the key is not found. */
1171 typy_get (PyObject
*self
, PyObject
*args
)
1173 PyObject
*key
, *defval
= Py_None
, *result
;
1175 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1178 result
= typy_getitem (self
, key
);
1182 /* typy_getitem returned error status. If the exception is
1183 KeyError, clear the exception status and return the defval
1184 instead. Otherwise return the exception unchanged. */
1185 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1193 /* Implement the "has_key" method on the type object. */
1196 typy_has_key (PyObject
*self
, PyObject
*args
)
1198 struct type
*type
= ((type_object
*) self
)->type
;
1202 if (!PyArg_ParseTuple (args
, "s", &field
))
1205 /* We want just fields of this type, not of base types, so instead of
1206 using lookup_struct_elt_type, portions of that function are
1209 type
= typy_get_composite (type
);
1213 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1215 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1217 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1223 /* Make an iterator object to iterate over keys, values, or items. */
1226 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1228 typy_iterator_object
*typy_iter_obj
;
1230 /* Check that "self" is a structure or union type. */
1231 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1234 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1235 &type_iterator_object_type
);
1236 if (typy_iter_obj
== NULL
)
1239 typy_iter_obj
->field
= 0;
1240 typy_iter_obj
->kind
= kind
;
1242 typy_iter_obj
->source
= (type_object
*) self
;
1244 return (PyObject
*) typy_iter_obj
;
1247 /* iteritems() method. */
1250 typy_iteritems (PyObject
*self
, PyObject
*args
)
1252 return typy_make_iter (self
, iter_items
);
1255 /* iterkeys() method. */
1258 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1260 return typy_make_iter (self
, iter_keys
);
1263 /* Iterating over the class, same as iterkeys except for the function
1267 typy_iter (PyObject
*self
)
1269 return typy_make_iter (self
, iter_keys
);
1272 /* itervalues() method. */
1275 typy_itervalues (PyObject
*self
, PyObject
*args
)
1277 return typy_make_iter (self
, iter_values
);
1280 /* Return a reference to the type iterator. */
1283 typy_iterator_iter (PyObject
*self
)
1289 /* Return the next field in the iteration through the list of fields
1293 typy_iterator_iternext (PyObject
*self
)
1295 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1296 struct type
*type
= iter_obj
->source
->type
;
1299 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1301 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1311 typy_iterator_dealloc (PyObject
*obj
)
1313 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1315 Py_DECREF (iter_obj
->source
);
1318 /* Create a new Type referring to TYPE. */
1320 type_to_type_object (struct type
*type
)
1322 type_object
*type_obj
;
1324 type_obj
= PyObject_New (type_object
, &type_object_type
);
1326 set_type (type_obj
, type
);
1328 return (PyObject
*) type_obj
;
1332 type_object_to_type (PyObject
*obj
)
1334 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1336 return ((type_object
*) obj
)->type
;
1341 /* Implementation of gdb.lookup_type. */
1343 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1345 static const char *keywords
[] = { "name", "block", NULL
};
1346 const char *type_name
= NULL
;
1347 struct type
*type
= NULL
;
1348 PyObject
*block_obj
= NULL
;
1349 const struct block
*block
= NULL
;
1351 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1352 &type_name
, &block_obj
))
1357 block
= block_object_to_block (block_obj
);
1360 PyErr_SetString (PyExc_RuntimeError
,
1361 _("'block' argument must be a Block."));
1366 type
= typy_lookup_typename (type_name
, block
);
1370 return (PyObject
*) type_to_type_object (type
);
1374 gdbpy_initialize_types (void)
1378 typy_objfile_data_key
1379 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1381 if (PyType_Ready (&type_object_type
) < 0)
1383 if (PyType_Ready (&field_object_type
) < 0)
1385 if (PyType_Ready (&type_iterator_object_type
) < 0)
1388 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1390 if (PyModule_AddIntConstant (gdb_module
,
1391 /* Cast needed for Python 2.4. */
1392 (char *) pyty_codes
[i
].name
,
1393 pyty_codes
[i
].code
) < 0)
1397 if (gdb_pymodule_addobject (gdb_module
, "Type",
1398 (PyObject
*) &type_object_type
) < 0)
1401 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1402 (PyObject
*) &type_iterator_object_type
) < 0)
1405 return gdb_pymodule_addobject (gdb_module
, "Field",
1406 (PyObject
*) &field_object_type
);
1411 static gdb_PyGetSetDef type_object_getset
[] =
1413 { "code", typy_get_code
, NULL
,
1414 "The code for this type.", NULL
},
1415 { "name", typy_get_name
, NULL
,
1416 "The name for this type, or None.", NULL
},
1417 { "sizeof", typy_get_sizeof
, NULL
,
1418 "The size of this type, in bytes.", NULL
},
1419 { "tag", typy_get_tag
, NULL
,
1420 "The tag name for this type, or None.", NULL
},
1424 static PyMethodDef type_object_methods
[] =
1426 { "array", typy_array
, METH_VARARGS
,
1427 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1428 Return a type which represents an array of objects of this type.\n\
1429 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1430 If LOW_BOUND is omitted, a value of zero is used." },
1431 { "vector", typy_vector
, METH_VARARGS
,
1432 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1433 Return a type which represents a vector of objects of this type.\n\
1434 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1435 If LOW_BOUND is omitted, a value of zero is used.\n\
1436 Vectors differ from arrays in that if the current language has C-style\n\
1437 arrays, vectors don't decay to a pointer to the first element.\n\
1438 They are first class values." },
1439 { "__contains__", typy_has_key
, METH_VARARGS
,
1440 "T.__contains__(k) -> True if T has a field named k, else False" },
1441 { "const", typy_const
, METH_NOARGS
,
1442 "const () -> Type\n\
1443 Return a const variant of this type." },
1444 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1445 "optimized_out() -> Value\n\
1446 Return optimized out value of this type." },
1447 { "fields", typy_fields
, METH_NOARGS
,
1448 "fields () -> list\n\
1449 Return a list holding all the fields of this type.\n\
1450 Each field is a gdb.Field object." },
1451 { "get", typy_get
, METH_VARARGS
,
1452 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1453 otherwise returns default, if supplied, or None if not." },
1454 { "has_key", typy_has_key
, METH_VARARGS
,
1455 "T.has_key(k) -> True if T has a field named k, else False" },
1456 { "items", typy_items
, METH_NOARGS
,
1457 "items () -> list\n\
1458 Return a list of (name, field) pairs of this type.\n\
1459 Each field is a gdb.Field object." },
1460 { "iteritems", typy_iteritems
, METH_NOARGS
,
1461 "iteritems () -> an iterator over the (name, field)\n\
1462 pairs of this type. Each field is a gdb.Field object." },
1463 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1464 "iterkeys () -> an iterator over the field names of this type." },
1465 { "itervalues", typy_itervalues
, METH_NOARGS
,
1466 "itervalues () -> an iterator over the fields of this type.\n\
1467 Each field is a gdb.Field object." },
1468 { "keys", typy_field_names
, METH_NOARGS
,
1470 Return a list holding all the fields names of this type." },
1471 { "pointer", typy_pointer
, METH_NOARGS
,
1472 "pointer () -> Type\n\
1473 Return a type of pointer to this type." },
1474 { "range", typy_range
, METH_NOARGS
,
1475 "range () -> tuple\n\
1476 Return a tuple containing the lower and upper range for this type."},
1477 { "reference", typy_reference
, METH_NOARGS
,
1478 "reference () -> Type\n\
1479 Return a type of reference to this type." },
1480 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1481 "strip_typedefs () -> Type\n\
1482 Return a type formed by stripping this type of all typedefs."},
1483 { "target", typy_target
, METH_NOARGS
,
1484 "target () -> Type\n\
1485 Return the target type of this type." },
1486 { "template_argument", typy_template_argument
, METH_VARARGS
,
1487 "template_argument (arg, [block]) -> Type\n\
1488 Return the type of a template argument." },
1489 { "unqualified", typy_unqualified
, METH_NOARGS
,
1490 "unqualified () -> Type\n\
1491 Return a variant of this type without const or volatile attributes." },
1492 { "values", typy_values
, METH_NOARGS
,
1493 "values () -> list\n\
1494 Return a list holding all the fields of this type.\n\
1495 Each field is a gdb.Field object." },
1496 { "volatile", typy_volatile
, METH_NOARGS
,
1497 "volatile () -> Type\n\
1498 Return a volatile variant of this type" },
1502 static PyNumberMethods type_object_as_number
= {
1504 NULL
, /* nb_subtract */
1505 NULL
, /* nb_multiply */
1507 NULL
, /* nb_divide */
1509 NULL
, /* nb_remainder */
1510 NULL
, /* nb_divmod */
1511 NULL
, /* nb_power */
1512 NULL
, /* nb_negative */
1513 NULL
, /* nb_positive */
1514 NULL
, /* nb_absolute */
1515 typy_nonzero
, /* nb_nonzero */
1516 NULL
, /* nb_invert */
1517 NULL
, /* nb_lshift */
1518 NULL
, /* nb_rshift */
1524 NULL
, /* reserved */
1526 NULL
, /* nb_coerce */
1530 NULL
, /* nb_float */
1537 static PyMappingMethods typy_mapping
= {
1540 NULL
/* no "set" method */
1543 PyTypeObject type_object_type
=
1545 PyVarObject_HEAD_INIT (NULL
, 0)
1546 "gdb.Type", /*tp_name*/
1547 sizeof (type_object
), /*tp_basicsize*/
1549 typy_dealloc
, /*tp_dealloc*/
1555 &type_object_as_number
, /*tp_as_number*/
1556 0, /*tp_as_sequence*/
1557 &typy_mapping
, /*tp_as_mapping*/
1560 typy_str
, /*tp_str*/
1564 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1565 "GDB type object", /* tp_doc */
1566 0, /* tp_traverse */
1568 typy_richcompare
, /* tp_richcompare */
1569 0, /* tp_weaklistoffset */
1570 typy_iter
, /* tp_iter */
1571 0, /* tp_iternext */
1572 type_object_methods
, /* tp_methods */
1574 type_object_getset
, /* tp_getset */
1577 0, /* tp_descr_get */
1578 0, /* tp_descr_set */
1579 0, /* tp_dictoffset */
1585 static gdb_PyGetSetDef field_object_getset
[] =
1587 { "__dict__", gdb_py_generic_dict
, NULL
,
1588 "The __dict__ for this field.", &field_object_type
},
1592 PyTypeObject field_object_type
=
1594 PyVarObject_HEAD_INIT (NULL
, 0)
1595 "gdb.Field", /*tp_name*/
1596 sizeof (field_object
), /*tp_basicsize*/
1598 field_dealloc
, /*tp_dealloc*/
1605 0, /*tp_as_sequence*/
1606 0, /*tp_as_mapping*/
1613 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1614 "GDB field object", /* tp_doc */
1615 0, /* tp_traverse */
1617 0, /* tp_richcompare */
1618 0, /* tp_weaklistoffset */
1620 0, /* tp_iternext */
1623 field_object_getset
, /* tp_getset */
1626 0, /* tp_descr_get */
1627 0, /* tp_descr_set */
1628 offsetof (field_object
, dict
), /* tp_dictoffset */
1634 PyTypeObject type_iterator_object_type
= {
1635 PyVarObject_HEAD_INIT (NULL
, 0)
1636 "gdb.TypeIterator", /*tp_name*/
1637 sizeof (typy_iterator_object
), /*tp_basicsize*/
1639 typy_iterator_dealloc
, /*tp_dealloc*/
1646 0, /*tp_as_sequence*/
1647 0, /*tp_as_mapping*/
1654 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1655 "GDB type iterator object", /*tp_doc */
1658 0, /*tp_richcompare */
1659 0, /*tp_weaklistoffset */
1660 typy_iterator_iter
, /*tp_iter */
1661 typy_iterator_iternext
, /*tp_iternext */