1 /* Python interface to types.
3 Copyright (C) 2008-2019 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 struct type
*type
= ((type_object
*) py_type
)->type
;
323 struct type
*checked_type
= type
;
327 checked_type
= check_typedef (checked_type
);
329 CATCH (except
, RETURN_MASK_ALL
)
331 GDB_PY_HANDLE_EXCEPTION (except
);
335 gdbpy_ref
<> type_holder
;
336 if (checked_type
!= type
)
338 type_holder
.reset (type_to_type_object (checked_type
));
339 if (type_holder
== nullptr)
341 py_type
= type_holder
.get ();
343 gdbpy_ref
<> iter (typy_make_iter (py_type
, kind
));
347 return PySequence_List (iter
.get ());
350 /* Return a sequence of all fields. Each field is a gdb.Field object. */
353 typy_values (PyObject
*self
, PyObject
*args
)
355 return typy_fields_items (self
, iter_values
);
358 /* Return a sequence of all fields. Each field is a gdb.Field object.
359 This method is similar to typy_values, except where the supplied
360 gdb.Type is an array, in which case it returns a list of one entry
361 which is a gdb.Field object for a range (the array bounds). */
364 typy_fields (PyObject
*self
, PyObject
*args
)
366 struct type
*type
= ((type_object
*) self
)->type
;
368 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
369 return typy_fields_items (self
, iter_values
);
371 /* Array type. Handle this as a special case because the common
372 machinery wants struct or union or enum types. Build a list of
373 one entry which is the range for the array. */
374 gdbpy_ref
<> r (convert_field (type
, 0));
378 return Py_BuildValue ("[O]", r
.get ());
381 /* Return a sequence of all field names. Each field is a gdb.Field object. */
384 typy_field_names (PyObject
*self
, PyObject
*args
)
386 return typy_fields_items (self
, iter_keys
);
389 /* Return a sequence of all (name, fields) pairs. Each field is a
393 typy_items (PyObject
*self
, PyObject
*args
)
395 return typy_fields_items (self
, iter_items
);
398 /* Return the type's name, or None. */
401 typy_get_name (PyObject
*self
, void *closure
)
403 struct type
*type
= ((type_object
*) self
)->type
;
405 if (TYPE_NAME (type
) == NULL
)
407 return PyString_FromString (TYPE_NAME (type
));
410 /* Return the type's tag, or None. */
412 typy_get_tag (PyObject
*self
, void *closure
)
414 struct type
*type
= ((type_object
*) self
)->type
;
415 const char *tagname
= nullptr;
417 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
418 || TYPE_CODE (type
) == TYPE_CODE_UNION
419 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
420 tagname
= TYPE_NAME (type
);
422 if (tagname
== nullptr)
424 return PyString_FromString (tagname
);
427 /* Return the type, stripped of typedefs. */
429 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
431 struct type
*type
= ((type_object
*) self
)->type
;
435 type
= check_typedef (type
);
437 CATCH (except
, RETURN_MASK_ALL
)
439 GDB_PY_HANDLE_EXCEPTION (except
);
443 return type_to_type_object (type
);
446 /* Strip typedefs and pointers/reference from a type. Then check that
447 it is a struct, union, or enum type. If not, raise TypeError. */
450 typy_get_composite (struct type
*type
)
457 type
= check_typedef (type
);
459 CATCH (except
, RETURN_MASK_ALL
)
461 GDB_PY_HANDLE_EXCEPTION (except
);
465 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
467 type
= TYPE_TARGET_TYPE (type
);
470 /* If this is not a struct, union, or enum type, raise TypeError
472 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
473 && TYPE_CODE (type
) != TYPE_CODE_UNION
474 && TYPE_CODE (type
) != TYPE_CODE_ENUM
475 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
477 PyErr_SetString (PyExc_TypeError
,
478 "Type is not a structure, union, enum, or function type.");
485 /* Helper for typy_array and typy_vector. */
488 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
491 PyObject
*n2_obj
= NULL
;
492 struct type
*array
= NULL
;
493 struct type
*type
= ((type_object
*) self
)->type
;
495 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
500 if (!PyInt_Check (n2_obj
))
502 PyErr_SetString (PyExc_RuntimeError
,
503 _("Array bound must be an integer"));
507 if (! gdb_py_int_as_long (n2_obj
, &n2
))
516 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
518 PyErr_SetString (PyExc_ValueError
,
519 _("Array length must not be negative"));
525 array
= lookup_array_range_type (type
, n1
, n2
);
527 make_vector_type (array
);
529 CATCH (except
, RETURN_MASK_ALL
)
531 GDB_PY_HANDLE_EXCEPTION (except
);
535 return type_to_type_object (array
);
538 /* Return an array type. */
541 typy_array (PyObject
*self
, PyObject
*args
)
543 return typy_array_1 (self
, args
, 0);
546 /* Return a vector type. */
549 typy_vector (PyObject
*self
, PyObject
*args
)
551 return typy_array_1 (self
, args
, 1);
554 /* Return a Type object which represents a pointer to SELF. */
556 typy_pointer (PyObject
*self
, PyObject
*args
)
558 struct type
*type
= ((type_object
*) self
)->type
;
562 type
= lookup_pointer_type (type
);
564 CATCH (except
, RETURN_MASK_ALL
)
566 GDB_PY_HANDLE_EXCEPTION (except
);
570 return type_to_type_object (type
);
573 /* Return the range of a type represented by SELF. The return type is
574 a tuple. The first element of the tuple contains the low bound,
575 while the second element of the tuple contains the high bound. */
577 typy_range (PyObject
*self
, PyObject
*args
)
579 struct type
*type
= ((type_object
*) self
)->type
;
580 /* Initialize these to appease GCC warnings. */
581 LONGEST low
= 0, high
= 0;
583 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
584 && TYPE_CODE (type
) != TYPE_CODE_STRING
585 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
587 PyErr_SetString (PyExc_RuntimeError
,
588 _("This type does not have a range."));
592 switch (TYPE_CODE (type
))
594 case TYPE_CODE_ARRAY
:
595 case TYPE_CODE_STRING
:
596 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
597 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
599 case TYPE_CODE_RANGE
:
600 low
= TYPE_LOW_BOUND (type
);
601 high
= TYPE_HIGH_BOUND (type
);
605 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
606 if (low_bound
== NULL
)
609 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
610 if (high_bound
== NULL
)
613 gdbpy_ref
<> result (PyTuple_New (2));
617 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
618 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
620 return result
.release ();
623 /* Return a Type object which represents a reference to SELF. */
625 typy_reference (PyObject
*self
, PyObject
*args
)
627 struct type
*type
= ((type_object
*) self
)->type
;
631 type
= lookup_lvalue_reference_type (type
);
633 CATCH (except
, RETURN_MASK_ALL
)
635 GDB_PY_HANDLE_EXCEPTION (except
);
639 return type_to_type_object (type
);
642 /* Return a Type object which represents the target type of SELF. */
644 typy_target (PyObject
*self
, PyObject
*args
)
646 struct type
*type
= ((type_object
*) self
)->type
;
648 if (!TYPE_TARGET_TYPE (type
))
650 PyErr_SetString (PyExc_RuntimeError
,
651 _("Type does not have a target."));
655 return type_to_type_object (TYPE_TARGET_TYPE (type
));
658 /* Return a const-qualified type variant. */
660 typy_const (PyObject
*self
, PyObject
*args
)
662 struct type
*type
= ((type_object
*) self
)->type
;
666 type
= make_cv_type (1, 0, type
, NULL
);
668 CATCH (except
, RETURN_MASK_ALL
)
670 GDB_PY_HANDLE_EXCEPTION (except
);
674 return type_to_type_object (type
);
677 /* Return a volatile-qualified type variant. */
679 typy_volatile (PyObject
*self
, PyObject
*args
)
681 struct type
*type
= ((type_object
*) self
)->type
;
685 type
= make_cv_type (0, 1, type
, NULL
);
687 CATCH (except
, RETURN_MASK_ALL
)
689 GDB_PY_HANDLE_EXCEPTION (except
);
693 return type_to_type_object (type
);
696 /* Return an unqualified type variant. */
698 typy_unqualified (PyObject
*self
, PyObject
*args
)
700 struct type
*type
= ((type_object
*) self
)->type
;
704 type
= make_cv_type (0, 0, type
, NULL
);
706 CATCH (except
, RETURN_MASK_ALL
)
708 GDB_PY_HANDLE_EXCEPTION (except
);
712 return type_to_type_object (type
);
715 /* Return the size of the type represented by SELF, in bytes. */
717 typy_get_sizeof (PyObject
*self
, void *closure
)
719 struct type
*type
= ((type_object
*) self
)->type
;
723 check_typedef (type
);
725 CATCH (except
, RETURN_MASK_ALL
)
730 /* Ignore exceptions. */
732 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
735 /* Return the alignment of the type represented by SELF, in bytes. */
737 typy_get_alignof (PyObject
*self
, void *closure
)
739 struct type
*type
= ((type_object
*) self
)->type
;
744 align
= type_align (type
);
746 CATCH (except
, RETURN_MASK_ALL
)
752 /* Ignore exceptions. */
754 return gdb_py_object_from_ulongest (align
).release ();
758 typy_lookup_typename (const char *type_name
, const struct block
*block
)
760 struct type
*type
= NULL
;
764 if (startswith (type_name
, "struct "))
765 type
= lookup_struct (type_name
+ 7, NULL
);
766 else if (startswith (type_name
, "union "))
767 type
= lookup_union (type_name
+ 6, NULL
);
768 else if (startswith (type_name
, "enum "))
769 type
= lookup_enum (type_name
+ 5, NULL
);
771 type
= lookup_typename (python_language
, python_gdbarch
,
772 type_name
, block
, 0);
774 CATCH (except
, RETURN_MASK_ALL
)
776 GDB_PY_HANDLE_EXCEPTION (except
);
784 typy_lookup_type (struct demangle_component
*demangled
,
785 const struct block
*block
)
787 struct type
*type
, *rtype
= NULL
;
788 enum demangle_component_type demangled_type
;
790 /* Save the type: typy_lookup_type() may (indirectly) overwrite
791 memory pointed by demangled. */
792 demangled_type
= demangled
->type
;
794 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
795 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
796 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
797 || demangled_type
== DEMANGLE_COMPONENT_CONST
798 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
800 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
806 /* If the demangled_type matches with one of the types
807 below, run the corresponding function and save the type
808 to return later. We cannot just return here as we are in
809 an exception handler. */
810 switch (demangled_type
)
812 case DEMANGLE_COMPONENT_REFERENCE
:
813 rtype
= lookup_lvalue_reference_type (type
);
815 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
816 rtype
= lookup_rvalue_reference_type (type
);
818 case DEMANGLE_COMPONENT_POINTER
:
819 rtype
= lookup_pointer_type (type
);
821 case DEMANGLE_COMPONENT_CONST
:
822 rtype
= make_cv_type (1, 0, type
, NULL
);
824 case DEMANGLE_COMPONENT_VOLATILE
:
825 rtype
= make_cv_type (0, 1, type
, NULL
);
829 CATCH (except
, RETURN_MASK_ALL
)
831 GDB_PY_HANDLE_EXCEPTION (except
);
836 /* If we have a type from the switch statement above, just return
841 /* We don't have a type, so lookup the type. */
842 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
843 return typy_lookup_typename (type_name
.get (), block
);
846 /* This is a helper function for typy_template_argument that is used
847 when the type does not have template symbols attached. It works by
848 parsing the type name. This happens with compilers, like older
849 versions of GCC, that do not emit DW_TAG_template_*. */
852 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
856 struct demangle_component
*demangled
;
857 std::unique_ptr
<demangle_parse_info
> info
;
859 struct type
*argtype
;
861 if (TYPE_NAME (type
) == NULL
)
863 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
869 /* Note -- this is not thread-safe. */
870 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
872 CATCH (except
, RETURN_MASK_ALL
)
874 GDB_PY_HANDLE_EXCEPTION (except
);
880 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
883 demangled
= info
->tree
;
885 /* Strip off component names. */
886 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
887 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
888 demangled
= demangled
->u
.s_binary
.right
;
890 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
892 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
896 /* Skip from the template to the arguments. */
897 demangled
= demangled
->u
.s_binary
.right
;
899 for (i
= 0; demangled
&& i
< argno
; ++i
)
900 demangled
= demangled
->u
.s_binary
.right
;
904 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
909 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
913 return type_to_type_object (argtype
);
917 typy_template_argument (PyObject
*self
, PyObject
*args
)
920 struct type
*type
= ((type_object
*) self
)->type
;
921 const struct block
*block
= NULL
;
922 PyObject
*block_obj
= NULL
;
924 struct value
*val
= NULL
;
926 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
931 PyErr_SetString (PyExc_RuntimeError
,
932 _("Template argument number must be non-negative"));
938 block
= block_object_to_block (block_obj
);
941 PyErr_SetString (PyExc_RuntimeError
,
942 _("Second argument must be block."));
949 type
= check_typedef (type
);
950 if (TYPE_IS_REFERENCE (type
))
951 type
= check_typedef (TYPE_TARGET_TYPE (type
));
953 CATCH (except
, RETURN_MASK_ALL
)
955 GDB_PY_HANDLE_EXCEPTION (except
);
959 /* We might not have DW_TAG_template_*, so try to parse the type's
960 name. This is inefficient if we do not have a template type --
961 but that is going to wind up as an error anyhow. */
962 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
963 return typy_legacy_template_argument (type
, block
, argno
);
965 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
967 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
972 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
973 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
974 return type_to_type_object (SYMBOL_TYPE (sym
));
975 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
977 PyErr_Format (PyExc_RuntimeError
,
978 _("Template argument is optimized out"));
984 val
= value_of_variable (sym
, block
);
986 CATCH (except
, RETURN_MASK_ALL
)
988 GDB_PY_HANDLE_EXCEPTION (except
);
992 return value_to_value_object (val
);
996 typy_str (PyObject
*self
)
1002 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
1003 &type_print_raw_options
);
1005 CATCH (except
, RETURN_MASK_ALL
)
1007 GDB_PY_HANDLE_EXCEPTION (except
);
1011 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1012 host_charset (), NULL
);
1015 /* Implement the richcompare method. */
1018 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1020 bool result
= false;
1021 struct type
*type1
= type_object_to_type (self
);
1022 struct type
*type2
= type_object_to_type (other
);
1024 /* We can only compare ourselves to another Type object, and only
1025 for equality or inequality. */
1026 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1028 Py_INCREF (Py_NotImplemented
);
1029 return Py_NotImplemented
;
1038 result
= types_deeply_equal (type1
, type2
);
1040 CATCH (except
, RETURN_MASK_ALL
)
1042 /* If there is a GDB exception, a comparison is not capable
1043 (or trusted), so exit. */
1044 GDB_PY_HANDLE_EXCEPTION (except
);
1049 if (op
== (result
? Py_EQ
: Py_NE
))
1056 static const struct objfile_data
*typy_objfile_data_key
;
1059 save_objfile_types (struct objfile
*objfile
, void *datum
)
1061 type_object
*obj
= (type_object
*) datum
;
1062 htab_t copied_types
;
1064 if (!gdb_python_initialized
)
1067 /* This prevents another thread from freeing the objects we're
1069 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1071 copied_types
= create_copied_types_hash (objfile
);
1075 type_object
*next
= obj
->next
;
1077 htab_empty (copied_types
);
1079 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1087 htab_delete (copied_types
);
1091 set_type (type_object
*obj
, struct type
*type
)
1095 if (type
&& TYPE_OBJFILE (type
))
1097 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1099 obj
->next
= ((struct pyty_type_object
*)
1100 objfile_data (objfile
, typy_objfile_data_key
));
1102 obj
->next
->prev
= obj
;
1103 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1110 typy_dealloc (PyObject
*obj
)
1112 type_object
*type
= (type_object
*) obj
;
1115 type
->prev
->next
= type
->next
;
1116 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1118 /* Must reset head of list. */
1119 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1122 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1125 type
->next
->prev
= type
->prev
;
1127 Py_TYPE (type
)->tp_free (type
);
1130 /* Return number of fields ("length" of the field dictionary). */
1133 typy_length (PyObject
*self
)
1135 struct type
*type
= ((type_object
*) self
)->type
;
1137 type
= typy_get_composite (type
);
1141 return TYPE_NFIELDS (type
);
1144 /* Implements boolean evaluation of gdb.Type. Handle this like other
1145 Python objects that don't have a meaningful truth value -- all
1149 typy_nonzero (PyObject
*self
)
1154 /* Return optimized out value of this type. */
1157 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1159 struct type
*type
= ((type_object
*) self
)->type
;
1161 return value_to_value_object (allocate_optimized_out_value (type
));
1164 /* Return a gdb.Field object for the field named by the argument. */
1167 typy_getitem (PyObject
*self
, PyObject
*key
)
1169 struct type
*type
= ((type_object
*) self
)->type
;
1172 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1176 /* We want just fields of this type, not of base types, so instead of
1177 using lookup_struct_elt_type, portions of that function are
1180 type
= typy_get_composite (type
);
1184 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1186 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1188 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1190 return convert_field (type
, i
);
1193 PyErr_SetObject (PyExc_KeyError
, key
);
1197 /* Implement the "get" method on the type object. This is the
1198 same as getitem if the key is present, but returns the supplied
1199 default value or None if the key is not found. */
1202 typy_get (PyObject
*self
, PyObject
*args
)
1204 PyObject
*key
, *defval
= Py_None
, *result
;
1206 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1209 result
= typy_getitem (self
, key
);
1213 /* typy_getitem returned error status. If the exception is
1214 KeyError, clear the exception status and return the defval
1215 instead. Otherwise return the exception unchanged. */
1216 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1224 /* Implement the "has_key" method on the type object. */
1227 typy_has_key (PyObject
*self
, PyObject
*args
)
1229 struct type
*type
= ((type_object
*) self
)->type
;
1233 if (!PyArg_ParseTuple (args
, "s", &field
))
1236 /* We want just fields of this type, not of base types, so instead of
1237 using lookup_struct_elt_type, portions of that function are
1240 type
= typy_get_composite (type
);
1244 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1246 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1248 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1254 /* Make an iterator object to iterate over keys, values, or items. */
1257 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1259 typy_iterator_object
*typy_iter_obj
;
1261 /* Check that "self" is a structure or union type. */
1262 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1265 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1266 &type_iterator_object_type
);
1267 if (typy_iter_obj
== NULL
)
1270 typy_iter_obj
->field
= 0;
1271 typy_iter_obj
->kind
= kind
;
1273 typy_iter_obj
->source
= (type_object
*) self
;
1275 return (PyObject
*) typy_iter_obj
;
1278 /* iteritems() method. */
1281 typy_iteritems (PyObject
*self
, PyObject
*args
)
1283 return typy_make_iter (self
, iter_items
);
1286 /* iterkeys() method. */
1289 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1291 return typy_make_iter (self
, iter_keys
);
1294 /* Iterating over the class, same as iterkeys except for the function
1298 typy_iter (PyObject
*self
)
1300 return typy_make_iter (self
, iter_keys
);
1303 /* itervalues() method. */
1306 typy_itervalues (PyObject
*self
, PyObject
*args
)
1308 return typy_make_iter (self
, iter_values
);
1311 /* Return a reference to the type iterator. */
1314 typy_iterator_iter (PyObject
*self
)
1320 /* Return the next field in the iteration through the list of fields
1324 typy_iterator_iternext (PyObject
*self
)
1326 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1327 struct type
*type
= iter_obj
->source
->type
;
1330 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1332 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1342 typy_iterator_dealloc (PyObject
*obj
)
1344 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1346 Py_DECREF (iter_obj
->source
);
1349 /* Create a new Type referring to TYPE. */
1351 type_to_type_object (struct type
*type
)
1353 type_object
*type_obj
;
1355 type_obj
= PyObject_New (type_object
, &type_object_type
);
1357 set_type (type_obj
, type
);
1359 return (PyObject
*) type_obj
;
1363 type_object_to_type (PyObject
*obj
)
1365 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1367 return ((type_object
*) obj
)->type
;
1372 /* Implementation of gdb.lookup_type. */
1374 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1376 static const char *keywords
[] = { "name", "block", NULL
};
1377 const char *type_name
= NULL
;
1378 struct type
*type
= NULL
;
1379 PyObject
*block_obj
= NULL
;
1380 const struct block
*block
= NULL
;
1382 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1383 &type_name
, &block_obj
))
1388 block
= block_object_to_block (block_obj
);
1391 PyErr_SetString (PyExc_RuntimeError
,
1392 _("'block' argument must be a Block."));
1397 type
= typy_lookup_typename (type_name
, block
);
1401 return type_to_type_object (type
);
1405 gdbpy_initialize_types (void)
1409 typy_objfile_data_key
1410 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1412 if (PyType_Ready (&type_object_type
) < 0)
1414 if (PyType_Ready (&field_object_type
) < 0)
1416 if (PyType_Ready (&type_iterator_object_type
) < 0)
1419 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1421 if (PyModule_AddIntConstant (gdb_module
,
1422 /* Cast needed for Python 2.4. */
1423 (char *) pyty_codes
[i
].name
,
1424 pyty_codes
[i
].code
) < 0)
1428 if (gdb_pymodule_addobject (gdb_module
, "Type",
1429 (PyObject
*) &type_object_type
) < 0)
1432 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1433 (PyObject
*) &type_iterator_object_type
) < 0)
1436 return gdb_pymodule_addobject (gdb_module
, "Field",
1437 (PyObject
*) &field_object_type
);
1442 static gdb_PyGetSetDef type_object_getset
[] =
1444 { "alignof", typy_get_alignof
, NULL
,
1445 "The alignment of this type, in bytes.", NULL
},
1446 { "code", typy_get_code
, NULL
,
1447 "The code for this type.", NULL
},
1448 { "name", typy_get_name
, NULL
,
1449 "The name for this type, or None.", NULL
},
1450 { "sizeof", typy_get_sizeof
, NULL
,
1451 "The size of this type, in bytes.", NULL
},
1452 { "tag", typy_get_tag
, NULL
,
1453 "The tag name for this type, or None.", NULL
},
1457 static PyMethodDef type_object_methods
[] =
1459 { "array", typy_array
, METH_VARARGS
,
1460 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1461 Return a type which represents an array of objects of this type.\n\
1462 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1463 If LOW_BOUND is omitted, a value of zero is used." },
1464 { "vector", typy_vector
, METH_VARARGS
,
1465 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1466 Return a type which represents a vector of objects of this type.\n\
1467 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1468 If LOW_BOUND is omitted, a value of zero is used.\n\
1469 Vectors differ from arrays in that if the current language has C-style\n\
1470 arrays, vectors don't decay to a pointer to the first element.\n\
1471 They are first class values." },
1472 { "__contains__", typy_has_key
, METH_VARARGS
,
1473 "T.__contains__(k) -> True if T has a field named k, else False" },
1474 { "const", typy_const
, METH_NOARGS
,
1475 "const () -> Type\n\
1476 Return a const variant of this type." },
1477 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1478 "optimized_out() -> Value\n\
1479 Return optimized out value of this type." },
1480 { "fields", typy_fields
, METH_NOARGS
,
1481 "fields () -> list\n\
1482 Return a list holding all the fields of this type.\n\
1483 Each field is a gdb.Field object." },
1484 { "get", typy_get
, METH_VARARGS
,
1485 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1486 otherwise returns default, if supplied, or None if not." },
1487 { "has_key", typy_has_key
, METH_VARARGS
,
1488 "T.has_key(k) -> True if T has a field named k, else False" },
1489 { "items", typy_items
, METH_NOARGS
,
1490 "items () -> list\n\
1491 Return a list of (name, field) pairs of this type.\n\
1492 Each field is a gdb.Field object." },
1493 { "iteritems", typy_iteritems
, METH_NOARGS
,
1494 "iteritems () -> an iterator over the (name, field)\n\
1495 pairs of this type. Each field is a gdb.Field object." },
1496 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1497 "iterkeys () -> an iterator over the field names of this type." },
1498 { "itervalues", typy_itervalues
, METH_NOARGS
,
1499 "itervalues () -> an iterator over the fields of this type.\n\
1500 Each field is a gdb.Field object." },
1501 { "keys", typy_field_names
, METH_NOARGS
,
1503 Return a list holding all the fields names of this type." },
1504 { "pointer", typy_pointer
, METH_NOARGS
,
1505 "pointer () -> Type\n\
1506 Return a type of pointer to this type." },
1507 { "range", typy_range
, METH_NOARGS
,
1508 "range () -> tuple\n\
1509 Return a tuple containing the lower and upper range for this type."},
1510 { "reference", typy_reference
, METH_NOARGS
,
1511 "reference () -> Type\n\
1512 Return a type of reference to this type." },
1513 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1514 "strip_typedefs () -> Type\n\
1515 Return a type formed by stripping this type of all typedefs."},
1516 { "target", typy_target
, METH_NOARGS
,
1517 "target () -> Type\n\
1518 Return the target type of this type." },
1519 { "template_argument", typy_template_argument
, METH_VARARGS
,
1520 "template_argument (arg, [block]) -> Type\n\
1521 Return the type of a template argument." },
1522 { "unqualified", typy_unqualified
, METH_NOARGS
,
1523 "unqualified () -> Type\n\
1524 Return a variant of this type without const or volatile attributes." },
1525 { "values", typy_values
, METH_NOARGS
,
1526 "values () -> list\n\
1527 Return a list holding all the fields of this type.\n\
1528 Each field is a gdb.Field object." },
1529 { "volatile", typy_volatile
, METH_NOARGS
,
1530 "volatile () -> Type\n\
1531 Return a volatile variant of this type" },
1535 static PyNumberMethods type_object_as_number
= {
1537 NULL
, /* nb_subtract */
1538 NULL
, /* nb_multiply */
1540 NULL
, /* nb_divide */
1542 NULL
, /* nb_remainder */
1543 NULL
, /* nb_divmod */
1544 NULL
, /* nb_power */
1545 NULL
, /* nb_negative */
1546 NULL
, /* nb_positive */
1547 NULL
, /* nb_absolute */
1548 typy_nonzero
, /* nb_nonzero */
1549 NULL
, /* nb_invert */
1550 NULL
, /* nb_lshift */
1551 NULL
, /* nb_rshift */
1557 NULL
, /* reserved */
1559 NULL
, /* nb_coerce */
1563 NULL
, /* nb_float */
1570 static PyMappingMethods typy_mapping
= {
1573 NULL
/* no "set" method */
1576 PyTypeObject type_object_type
=
1578 PyVarObject_HEAD_INIT (NULL
, 0)
1579 "gdb.Type", /*tp_name*/
1580 sizeof (type_object
), /*tp_basicsize*/
1582 typy_dealloc
, /*tp_dealloc*/
1588 &type_object_as_number
, /*tp_as_number*/
1589 0, /*tp_as_sequence*/
1590 &typy_mapping
, /*tp_as_mapping*/
1593 typy_str
, /*tp_str*/
1597 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1598 "GDB type object", /* tp_doc */
1599 0, /* tp_traverse */
1601 typy_richcompare
, /* tp_richcompare */
1602 0, /* tp_weaklistoffset */
1603 typy_iter
, /* tp_iter */
1604 0, /* tp_iternext */
1605 type_object_methods
, /* tp_methods */
1607 type_object_getset
, /* tp_getset */
1610 0, /* tp_descr_get */
1611 0, /* tp_descr_set */
1612 0, /* tp_dictoffset */
1618 static gdb_PyGetSetDef field_object_getset
[] =
1620 { "__dict__", gdb_py_generic_dict
, NULL
,
1621 "The __dict__ for this field.", &field_object_type
},
1625 PyTypeObject field_object_type
=
1627 PyVarObject_HEAD_INIT (NULL
, 0)
1628 "gdb.Field", /*tp_name*/
1629 sizeof (field_object
), /*tp_basicsize*/
1631 field_dealloc
, /*tp_dealloc*/
1638 0, /*tp_as_sequence*/
1639 0, /*tp_as_mapping*/
1646 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1647 "GDB field object", /* tp_doc */
1648 0, /* tp_traverse */
1650 0, /* tp_richcompare */
1651 0, /* tp_weaklistoffset */
1653 0, /* tp_iternext */
1656 field_object_getset
, /* tp_getset */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 offsetof (field_object
, dict
), /* tp_dictoffset */
1667 PyTypeObject type_iterator_object_type
= {
1668 PyVarObject_HEAD_INIT (NULL
, 0)
1669 "gdb.TypeIterator", /*tp_name*/
1670 sizeof (typy_iterator_object
), /*tp_basicsize*/
1672 typy_iterator_dealloc
, /*tp_dealloc*/
1679 0, /*tp_as_sequence*/
1680 0, /*tp_as_mapping*/
1687 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1688 "GDB type iterator object", /*tp_doc */
1691 0, /*tp_richcompare */
1692 0, /*tp_weaklistoffset */
1693 typy_iterator_iter
, /*tp_iter */
1694 typy_iterator_iternext
, /*tp_iternext */