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"
29 #include "common/vec.h"
30 #include "typeprint.h"
32 typedef struct pyty_type_object
37 /* If a Type object is associated with an objfile, it is kept on a
38 doubly-linked list, rooted in the objfile. This lets us copy the
39 underlying struct type when the objfile is deleted. */
40 struct pyty_type_object
*prev
;
41 struct pyty_type_object
*next
;
44 extern PyTypeObject type_object_type
45 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
48 typedef struct pyty_field_object
52 /* Dictionary holding our attributes. */
56 extern PyTypeObject field_object_type
57 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
59 /* A type iterator object. */
62 /* The current field index. */
65 enum gdbpy_iter_kind kind
;
66 /* Pointer back to the original source type object. */
67 struct pyty_type_object
*source
;
68 } typy_iterator_object
;
70 extern PyTypeObject type_iterator_object_type
71 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
73 /* This is used to initialize various gdb.TYPE_ constants. */
82 /* Forward declarations. */
83 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
85 #define ENTRY(X) { X, #X }
87 static struct pyty_code pyty_codes
[] =
89 ENTRY (TYPE_CODE_BITSTRING
),
90 ENTRY (TYPE_CODE_PTR
),
91 ENTRY (TYPE_CODE_ARRAY
),
92 ENTRY (TYPE_CODE_STRUCT
),
93 ENTRY (TYPE_CODE_UNION
),
94 ENTRY (TYPE_CODE_ENUM
),
95 ENTRY (TYPE_CODE_FLAGS
),
96 ENTRY (TYPE_CODE_FUNC
),
97 ENTRY (TYPE_CODE_INT
),
98 ENTRY (TYPE_CODE_FLT
),
99 ENTRY (TYPE_CODE_VOID
),
100 ENTRY (TYPE_CODE_SET
),
101 ENTRY (TYPE_CODE_RANGE
),
102 ENTRY (TYPE_CODE_STRING
),
103 ENTRY (TYPE_CODE_ERROR
),
104 ENTRY (TYPE_CODE_METHOD
),
105 ENTRY (TYPE_CODE_METHODPTR
),
106 ENTRY (TYPE_CODE_MEMBERPTR
),
107 ENTRY (TYPE_CODE_REF
),
108 ENTRY (TYPE_CODE_RVALUE_REF
),
109 ENTRY (TYPE_CODE_CHAR
),
110 ENTRY (TYPE_CODE_BOOL
),
111 ENTRY (TYPE_CODE_COMPLEX
),
112 ENTRY (TYPE_CODE_TYPEDEF
),
113 ENTRY (TYPE_CODE_NAMESPACE
),
114 ENTRY (TYPE_CODE_DECFLOAT
),
115 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
116 { TYPE_CODE_UNDEF
, NULL
}
122 field_dealloc (PyObject
*obj
)
124 field_object
*f
= (field_object
*) obj
;
126 Py_XDECREF (f
->dict
);
127 Py_TYPE (obj
)->tp_free (obj
);
133 gdbpy_ref
<field_object
> result (PyObject_New (field_object
,
134 &field_object_type
));
138 result
->dict
= PyDict_New ();
142 return (PyObject
*) result
.release ();
147 /* Return true if OBJ is of type gdb.Field, false otherwise. */
150 gdbpy_is_field (PyObject
*obj
)
152 return PyObject_TypeCheck (obj
, &field_object_type
);
155 /* Return the code for this type. */
157 typy_get_code (PyObject
*self
, void *closure
)
159 struct type
*type
= ((type_object
*) self
)->type
;
161 return PyInt_FromLong (TYPE_CODE (type
));
164 /* Helper function for typy_fields which converts a single field to a
165 gdb.Field object. Returns NULL on error. */
168 convert_field (struct type
*type
, int field
)
170 gdbpy_ref
<> result (field_new ());
175 gdbpy_ref
<> arg (type_to_type_object (type
));
178 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
181 if (!field_is_static (&TYPE_FIELD (type
, field
)))
183 const char *attrstring
;
185 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
187 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
189 attrstring
= "enumval";
193 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
195 attrstring
= "bitpos";
201 /* At least python-2.4 had the second parameter non-const. */
202 if (PyObject_SetAttrString (result
.get (), (char *) attrstring
,
208 if (TYPE_FIELD_NAME (type
, field
))
210 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
212 if (field_name
[0] != '\0')
214 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
220 arg
= gdbpy_ref
<>::new_reference (Py_None
);
222 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
225 arg
= gdbpy_ref
<>::new_reference (TYPE_FIELD_ARTIFICIAL (type
, field
)
226 ? Py_True
: Py_False
);
227 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
230 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
231 arg
= gdbpy_ref
<>::new_reference (field
< TYPE_N_BASECLASSES (type
)
232 ? Py_True
: Py_False
);
234 arg
= gdbpy_ref
<>::new_reference (Py_False
);
235 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
238 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
241 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
244 /* A field can have a NULL type in some situations. */
245 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
246 arg
= gdbpy_ref
<>::new_reference (Py_None
);
248 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
251 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
257 /* Helper function to return the name of a field, as a gdb.Field object.
258 If the field doesn't have a name, None is returned. */
261 field_name (struct type
*type
, int field
)
265 if (TYPE_FIELD_NAME (type
, field
))
266 result
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
268 result
= gdbpy_ref
<>::new_reference (Py_None
);
273 /* Helper function for Type standard mapping methods. Returns a
274 Python object for field i of the type. "kind" specifies what to
275 return: the name of the field, a gdb.Field object corresponding to
276 the field, or a tuple consisting of field name and gdb.Field
280 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
286 gdbpy_ref
<> key (field_name (type
, i
));
289 gdbpy_ref
<> value
= convert_field (type
, i
);
292 gdbpy_ref
<> item (PyTuple_New (2));
295 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
296 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
300 return field_name (type
, i
);
302 return convert_field (type
, i
);
304 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
307 /* Return a sequence of all field names, fields, or (name, field) pairs.
308 Each field is a gdb.Field object. */
311 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
313 PyObject
*py_type
= self
;
314 struct type
*type
= ((type_object
*) py_type
)->type
;
315 struct type
*checked_type
= type
;
319 checked_type
= check_typedef (checked_type
);
321 CATCH (except
, RETURN_MASK_ALL
)
323 GDB_PY_HANDLE_EXCEPTION (except
);
327 gdbpy_ref
<> type_holder
;
328 if (checked_type
!= type
)
330 type_holder
.reset (type_to_type_object (checked_type
));
331 if (type_holder
== nullptr)
333 py_type
= type_holder
.get ();
335 gdbpy_ref
<> iter (typy_make_iter (py_type
, kind
));
339 return PySequence_List (iter
.get ());
342 /* Return a sequence of all fields. Each field is a gdb.Field object. */
345 typy_values (PyObject
*self
, PyObject
*args
)
347 return typy_fields_items (self
, iter_values
);
350 /* Return a sequence of all fields. Each field is a gdb.Field object.
351 This method is similar to typy_values, except where the supplied
352 gdb.Type is an array, in which case it returns a list of one entry
353 which is a gdb.Field object for a range (the array bounds). */
356 typy_fields (PyObject
*self
, PyObject
*args
)
358 struct type
*type
= ((type_object
*) self
)->type
;
360 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
361 return typy_fields_items (self
, iter_values
);
363 /* Array type. Handle this as a special case because the common
364 machinery wants struct or union or enum types. Build a list of
365 one entry which is the range for the array. */
366 gdbpy_ref
<> r
= convert_field (type
, 0);
370 return Py_BuildValue ("[O]", r
.get ());
373 /* Return a sequence of all field names. Each field is a gdb.Field object. */
376 typy_field_names (PyObject
*self
, PyObject
*args
)
378 return typy_fields_items (self
, iter_keys
);
381 /* Return a sequence of all (name, fields) pairs. Each field is a
385 typy_items (PyObject
*self
, PyObject
*args
)
387 return typy_fields_items (self
, iter_items
);
390 /* Return the type's name, or None. */
393 typy_get_name (PyObject
*self
, void *closure
)
395 struct type
*type
= ((type_object
*) self
)->type
;
397 if (TYPE_NAME (type
) == NULL
)
399 return PyString_FromString (TYPE_NAME (type
));
402 /* Return the type's tag, or None. */
404 typy_get_tag (PyObject
*self
, void *closure
)
406 struct type
*type
= ((type_object
*) self
)->type
;
407 const char *tagname
= nullptr;
409 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
410 || TYPE_CODE (type
) == TYPE_CODE_UNION
411 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
412 tagname
= TYPE_NAME (type
);
414 if (tagname
== nullptr)
416 return PyString_FromString (tagname
);
419 /* Return the type, stripped of typedefs. */
421 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
423 struct type
*type
= ((type_object
*) self
)->type
;
427 type
= check_typedef (type
);
429 CATCH (except
, RETURN_MASK_ALL
)
431 GDB_PY_HANDLE_EXCEPTION (except
);
435 return type_to_type_object (type
);
438 /* Strip typedefs and pointers/reference from a type. Then check that
439 it is a struct, union, or enum type. If not, raise TypeError. */
442 typy_get_composite (struct type
*type
)
449 type
= check_typedef (type
);
451 CATCH (except
, RETURN_MASK_ALL
)
453 GDB_PY_HANDLE_EXCEPTION (except
);
457 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
459 type
= TYPE_TARGET_TYPE (type
);
462 /* If this is not a struct, union, or enum type, raise TypeError
464 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
465 && TYPE_CODE (type
) != TYPE_CODE_UNION
466 && TYPE_CODE (type
) != TYPE_CODE_ENUM
467 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
469 PyErr_SetString (PyExc_TypeError
,
470 "Type is not a structure, union, enum, or function type.");
477 /* Helper for typy_array and typy_vector. */
480 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
483 PyObject
*n2_obj
= NULL
;
484 struct type
*array
= NULL
;
485 struct type
*type
= ((type_object
*) self
)->type
;
487 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
492 if (!PyInt_Check (n2_obj
))
494 PyErr_SetString (PyExc_RuntimeError
,
495 _("Array bound must be an integer"));
499 if (! gdb_py_int_as_long (n2_obj
, &n2
))
508 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
510 PyErr_SetString (PyExc_ValueError
,
511 _("Array length must not be negative"));
517 array
= lookup_array_range_type (type
, n1
, n2
);
519 make_vector_type (array
);
521 CATCH (except
, RETURN_MASK_ALL
)
523 GDB_PY_HANDLE_EXCEPTION (except
);
527 return type_to_type_object (array
);
530 /* Return an array type. */
533 typy_array (PyObject
*self
, PyObject
*args
)
535 return typy_array_1 (self
, args
, 0);
538 /* Return a vector type. */
541 typy_vector (PyObject
*self
, PyObject
*args
)
543 return typy_array_1 (self
, args
, 1);
546 /* Return a Type object which represents a pointer to SELF. */
548 typy_pointer (PyObject
*self
, PyObject
*args
)
550 struct type
*type
= ((type_object
*) self
)->type
;
554 type
= lookup_pointer_type (type
);
556 CATCH (except
, RETURN_MASK_ALL
)
558 GDB_PY_HANDLE_EXCEPTION (except
);
562 return type_to_type_object (type
);
565 /* Return the range of a type represented by SELF. The return type is
566 a tuple. The first element of the tuple contains the low bound,
567 while the second element of the tuple contains the high bound. */
569 typy_range (PyObject
*self
, PyObject
*args
)
571 struct type
*type
= ((type_object
*) self
)->type
;
572 /* Initialize these to appease GCC warnings. */
573 LONGEST low
= 0, high
= 0;
575 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
576 && TYPE_CODE (type
) != TYPE_CODE_STRING
577 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
579 PyErr_SetString (PyExc_RuntimeError
,
580 _("This type does not have a range."));
584 switch (TYPE_CODE (type
))
586 case TYPE_CODE_ARRAY
:
587 case TYPE_CODE_STRING
:
588 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
589 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
591 case TYPE_CODE_RANGE
:
592 low
= TYPE_LOW_BOUND (type
);
593 high
= TYPE_HIGH_BOUND (type
);
597 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
598 if (low_bound
== NULL
)
601 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
602 if (high_bound
== NULL
)
605 gdbpy_ref
<> result (PyTuple_New (2));
609 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
610 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
612 return result
.release ();
615 /* Return a Type object which represents a reference to SELF. */
617 typy_reference (PyObject
*self
, PyObject
*args
)
619 struct type
*type
= ((type_object
*) self
)->type
;
623 type
= lookup_lvalue_reference_type (type
);
625 CATCH (except
, RETURN_MASK_ALL
)
627 GDB_PY_HANDLE_EXCEPTION (except
);
631 return type_to_type_object (type
);
634 /* Return a Type object which represents the target type of SELF. */
636 typy_target (PyObject
*self
, PyObject
*args
)
638 struct type
*type
= ((type_object
*) self
)->type
;
640 if (!TYPE_TARGET_TYPE (type
))
642 PyErr_SetString (PyExc_RuntimeError
,
643 _("Type does not have a target."));
647 return type_to_type_object (TYPE_TARGET_TYPE (type
));
650 /* Return a const-qualified type variant. */
652 typy_const (PyObject
*self
, PyObject
*args
)
654 struct type
*type
= ((type_object
*) self
)->type
;
658 type
= make_cv_type (1, 0, type
, NULL
);
660 CATCH (except
, RETURN_MASK_ALL
)
662 GDB_PY_HANDLE_EXCEPTION (except
);
666 return type_to_type_object (type
);
669 /* Return a volatile-qualified type variant. */
671 typy_volatile (PyObject
*self
, PyObject
*args
)
673 struct type
*type
= ((type_object
*) self
)->type
;
677 type
= make_cv_type (0, 1, type
, NULL
);
679 CATCH (except
, RETURN_MASK_ALL
)
681 GDB_PY_HANDLE_EXCEPTION (except
);
685 return type_to_type_object (type
);
688 /* Return an unqualified type variant. */
690 typy_unqualified (PyObject
*self
, PyObject
*args
)
692 struct type
*type
= ((type_object
*) self
)->type
;
696 type
= make_cv_type (0, 0, type
, NULL
);
698 CATCH (except
, RETURN_MASK_ALL
)
700 GDB_PY_HANDLE_EXCEPTION (except
);
704 return type_to_type_object (type
);
707 /* Return the size of the type represented by SELF, in bytes. */
709 typy_get_sizeof (PyObject
*self
, void *closure
)
711 struct type
*type
= ((type_object
*) self
)->type
;
715 check_typedef (type
);
717 CATCH (except
, RETURN_MASK_ALL
)
722 /* Ignore exceptions. */
724 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
727 /* Return the alignment of the type represented by SELF, in bytes. */
729 typy_get_alignof (PyObject
*self
, void *closure
)
731 struct type
*type
= ((type_object
*) self
)->type
;
736 align
= type_align (type
);
738 CATCH (except
, RETURN_MASK_ALL
)
744 /* Ignore exceptions. */
746 return gdb_py_object_from_ulongest (align
).release ();
750 typy_lookup_typename (const char *type_name
, const struct block
*block
)
752 struct type
*type
= NULL
;
756 if (startswith (type_name
, "struct "))
757 type
= lookup_struct (type_name
+ 7, NULL
);
758 else if (startswith (type_name
, "union "))
759 type
= lookup_union (type_name
+ 6, NULL
);
760 else if (startswith (type_name
, "enum "))
761 type
= lookup_enum (type_name
+ 5, NULL
);
763 type
= lookup_typename (python_language
, python_gdbarch
,
764 type_name
, block
, 0);
766 CATCH (except
, RETURN_MASK_ALL
)
768 GDB_PY_HANDLE_EXCEPTION (except
);
776 typy_lookup_type (struct demangle_component
*demangled
,
777 const struct block
*block
)
779 struct type
*type
, *rtype
= NULL
;
780 enum demangle_component_type demangled_type
;
782 /* Save the type: typy_lookup_type() may (indirectly) overwrite
783 memory pointed by demangled. */
784 demangled_type
= demangled
->type
;
786 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
787 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
788 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
789 || demangled_type
== DEMANGLE_COMPONENT_CONST
790 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
792 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
798 /* If the demangled_type matches with one of the types
799 below, run the corresponding function and save the type
800 to return later. We cannot just return here as we are in
801 an exception handler. */
802 switch (demangled_type
)
804 case DEMANGLE_COMPONENT_REFERENCE
:
805 rtype
= lookup_lvalue_reference_type (type
);
807 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
808 rtype
= lookup_rvalue_reference_type (type
);
810 case DEMANGLE_COMPONENT_POINTER
:
811 rtype
= lookup_pointer_type (type
);
813 case DEMANGLE_COMPONENT_CONST
:
814 rtype
= make_cv_type (1, 0, type
, NULL
);
816 case DEMANGLE_COMPONENT_VOLATILE
:
817 rtype
= make_cv_type (0, 1, type
, NULL
);
821 CATCH (except
, RETURN_MASK_ALL
)
823 GDB_PY_HANDLE_EXCEPTION (except
);
828 /* If we have a type from the switch statement above, just return
833 /* We don't have a type, so lookup the type. */
834 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
835 return typy_lookup_typename (type_name
.get (), block
);
838 /* This is a helper function for typy_template_argument that is used
839 when the type does not have template symbols attached. It works by
840 parsing the type name. This happens with compilers, like older
841 versions of GCC, that do not emit DW_TAG_template_*. */
844 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
848 struct demangle_component
*demangled
;
849 std::unique_ptr
<demangle_parse_info
> info
;
851 struct type
*argtype
;
853 if (TYPE_NAME (type
) == NULL
)
855 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
861 /* Note -- this is not thread-safe. */
862 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
864 CATCH (except
, RETURN_MASK_ALL
)
866 GDB_PY_HANDLE_EXCEPTION (except
);
872 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
875 demangled
= info
->tree
;
877 /* Strip off component names. */
878 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
879 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
880 demangled
= demangled
->u
.s_binary
.right
;
882 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
884 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
888 /* Skip from the template to the arguments. */
889 demangled
= demangled
->u
.s_binary
.right
;
891 for (i
= 0; demangled
&& i
< argno
; ++i
)
892 demangled
= demangled
->u
.s_binary
.right
;
896 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
901 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
905 return type_to_type_object (argtype
);
909 typy_template_argument (PyObject
*self
, PyObject
*args
)
912 struct type
*type
= ((type_object
*) self
)->type
;
913 const struct block
*block
= NULL
;
914 PyObject
*block_obj
= NULL
;
916 struct value
*val
= NULL
;
918 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
923 PyErr_SetString (PyExc_RuntimeError
,
924 _("Template argument number must be non-negative"));
930 block
= block_object_to_block (block_obj
);
933 PyErr_SetString (PyExc_RuntimeError
,
934 _("Second argument must be block."));
941 type
= check_typedef (type
);
942 if (TYPE_IS_REFERENCE (type
))
943 type
= check_typedef (TYPE_TARGET_TYPE (type
));
945 CATCH (except
, RETURN_MASK_ALL
)
947 GDB_PY_HANDLE_EXCEPTION (except
);
951 /* We might not have DW_TAG_template_*, so try to parse the type's
952 name. This is inefficient if we do not have a template type --
953 but that is going to wind up as an error anyhow. */
954 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
955 return typy_legacy_template_argument (type
, block
, argno
);
957 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
959 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
964 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
965 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
966 return type_to_type_object (SYMBOL_TYPE (sym
));
967 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
969 PyErr_Format (PyExc_RuntimeError
,
970 _("Template argument is optimized out"));
976 val
= value_of_variable (sym
, block
);
978 CATCH (except
, RETURN_MASK_ALL
)
980 GDB_PY_HANDLE_EXCEPTION (except
);
984 return value_to_value_object (val
);
988 typy_str (PyObject
*self
)
994 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
995 &type_print_raw_options
);
997 CATCH (except
, RETURN_MASK_ALL
)
999 GDB_PY_HANDLE_EXCEPTION (except
);
1003 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1004 host_charset (), NULL
);
1007 /* Implement the richcompare method. */
1010 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1012 bool result
= false;
1013 struct type
*type1
= type_object_to_type (self
);
1014 struct type
*type2
= type_object_to_type (other
);
1016 /* We can only compare ourselves to another Type object, and only
1017 for equality or inequality. */
1018 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1020 Py_INCREF (Py_NotImplemented
);
1021 return Py_NotImplemented
;
1030 result
= types_deeply_equal (type1
, type2
);
1032 CATCH (except
, RETURN_MASK_ALL
)
1034 /* If there is a GDB exception, a comparison is not capable
1035 (or trusted), so exit. */
1036 GDB_PY_HANDLE_EXCEPTION (except
);
1041 if (op
== (result
? Py_EQ
: Py_NE
))
1048 static const struct objfile_data
*typy_objfile_data_key
;
1051 save_objfile_types (struct objfile
*objfile
, void *datum
)
1053 type_object
*obj
= (type_object
*) datum
;
1054 htab_t copied_types
;
1056 if (!gdb_python_initialized
)
1059 /* This prevents another thread from freeing the objects we're
1061 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1063 copied_types
= create_copied_types_hash (objfile
);
1067 type_object
*next
= obj
->next
;
1069 htab_empty (copied_types
);
1071 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1079 htab_delete (copied_types
);
1083 set_type (type_object
*obj
, struct type
*type
)
1087 if (type
&& TYPE_OBJFILE (type
))
1089 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1091 obj
->next
= ((struct pyty_type_object
*)
1092 objfile_data (objfile
, typy_objfile_data_key
));
1094 obj
->next
->prev
= obj
;
1095 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1102 typy_dealloc (PyObject
*obj
)
1104 type_object
*type
= (type_object
*) obj
;
1107 type
->prev
->next
= type
->next
;
1108 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1110 /* Must reset head of list. */
1111 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1114 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1117 type
->next
->prev
= type
->prev
;
1119 Py_TYPE (type
)->tp_free (type
);
1122 /* Return number of fields ("length" of the field dictionary). */
1125 typy_length (PyObject
*self
)
1127 struct type
*type
= ((type_object
*) self
)->type
;
1129 type
= typy_get_composite (type
);
1133 return TYPE_NFIELDS (type
);
1136 /* Implements boolean evaluation of gdb.Type. Handle this like other
1137 Python objects that don't have a meaningful truth value -- all
1141 typy_nonzero (PyObject
*self
)
1146 /* Return optimized out value of this type. */
1149 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1151 struct type
*type
= ((type_object
*) self
)->type
;
1153 return value_to_value_object (allocate_optimized_out_value (type
));
1156 /* Return a gdb.Field object for the field named by the argument. */
1159 typy_getitem (PyObject
*self
, PyObject
*key
)
1161 struct type
*type
= ((type_object
*) self
)->type
;
1164 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1168 /* We want just fields of this type, not of base types, so instead of
1169 using lookup_struct_elt_type, portions of that function are
1172 type
= typy_get_composite (type
);
1176 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1178 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1180 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1181 return convert_field (type
, i
).release ();
1183 PyErr_SetObject (PyExc_KeyError
, key
);
1187 /* Implement the "get" method on the type object. This is the
1188 same as getitem if the key is present, but returns the supplied
1189 default value or None if the key is not found. */
1192 typy_get (PyObject
*self
, PyObject
*args
)
1194 PyObject
*key
, *defval
= Py_None
, *result
;
1196 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1199 result
= typy_getitem (self
, key
);
1203 /* typy_getitem returned error status. If the exception is
1204 KeyError, clear the exception status and return the defval
1205 instead. Otherwise return the exception unchanged. */
1206 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1214 /* Implement the "has_key" method on the type object. */
1217 typy_has_key (PyObject
*self
, PyObject
*args
)
1219 struct type
*type
= ((type_object
*) self
)->type
;
1223 if (!PyArg_ParseTuple (args
, "s", &field
))
1226 /* We want just fields of this type, not of base types, so instead of
1227 using lookup_struct_elt_type, portions of that function are
1230 type
= typy_get_composite (type
);
1234 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1236 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1238 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1244 /* Make an iterator object to iterate over keys, values, or items. */
1247 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1249 typy_iterator_object
*typy_iter_obj
;
1251 /* Check that "self" is a structure or union type. */
1252 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1255 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1256 &type_iterator_object_type
);
1257 if (typy_iter_obj
== NULL
)
1260 typy_iter_obj
->field
= 0;
1261 typy_iter_obj
->kind
= kind
;
1263 typy_iter_obj
->source
= (type_object
*) self
;
1265 return (PyObject
*) typy_iter_obj
;
1268 /* iteritems() method. */
1271 typy_iteritems (PyObject
*self
, PyObject
*args
)
1273 return typy_make_iter (self
, iter_items
);
1276 /* iterkeys() method. */
1279 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1281 return typy_make_iter (self
, iter_keys
);
1284 /* Iterating over the class, same as iterkeys except for the function
1288 typy_iter (PyObject
*self
)
1290 return typy_make_iter (self
, iter_keys
);
1293 /* itervalues() method. */
1296 typy_itervalues (PyObject
*self
, PyObject
*args
)
1298 return typy_make_iter (self
, iter_values
);
1301 /* Return a reference to the type iterator. */
1304 typy_iterator_iter (PyObject
*self
)
1310 /* Return the next field in the iteration through the list of fields
1314 typy_iterator_iternext (PyObject
*self
)
1316 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1317 struct type
*type
= iter_obj
->source
->type
;
1319 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1321 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1325 return result
.release ();
1332 typy_iterator_dealloc (PyObject
*obj
)
1334 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1336 Py_DECREF (iter_obj
->source
);
1339 /* Create a new Type referring to TYPE. */
1341 type_to_type_object (struct type
*type
)
1343 type_object
*type_obj
;
1345 type_obj
= PyObject_New (type_object
, &type_object_type
);
1347 set_type (type_obj
, type
);
1349 return (PyObject
*) type_obj
;
1353 type_object_to_type (PyObject
*obj
)
1355 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1357 return ((type_object
*) obj
)->type
;
1362 /* Implementation of gdb.lookup_type. */
1364 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1366 static const char *keywords
[] = { "name", "block", NULL
};
1367 const char *type_name
= NULL
;
1368 struct type
*type
= NULL
;
1369 PyObject
*block_obj
= NULL
;
1370 const struct block
*block
= NULL
;
1372 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1373 &type_name
, &block_obj
))
1378 block
= block_object_to_block (block_obj
);
1381 PyErr_SetString (PyExc_RuntimeError
,
1382 _("'block' argument must be a Block."));
1387 type
= typy_lookup_typename (type_name
, block
);
1391 return type_to_type_object (type
);
1395 gdbpy_initialize_types (void)
1399 typy_objfile_data_key
1400 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1402 if (PyType_Ready (&type_object_type
) < 0)
1404 if (PyType_Ready (&field_object_type
) < 0)
1406 if (PyType_Ready (&type_iterator_object_type
) < 0)
1409 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1411 if (PyModule_AddIntConstant (gdb_module
,
1412 /* Cast needed for Python 2.4. */
1413 (char *) pyty_codes
[i
].name
,
1414 pyty_codes
[i
].code
) < 0)
1418 if (gdb_pymodule_addobject (gdb_module
, "Type",
1419 (PyObject
*) &type_object_type
) < 0)
1422 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1423 (PyObject
*) &type_iterator_object_type
) < 0)
1426 return gdb_pymodule_addobject (gdb_module
, "Field",
1427 (PyObject
*) &field_object_type
);
1432 static gdb_PyGetSetDef type_object_getset
[] =
1434 { "alignof", typy_get_alignof
, NULL
,
1435 "The alignment of this type, in bytes.", NULL
},
1436 { "code", typy_get_code
, NULL
,
1437 "The code for this type.", NULL
},
1438 { "name", typy_get_name
, NULL
,
1439 "The name for this type, or None.", NULL
},
1440 { "sizeof", typy_get_sizeof
, NULL
,
1441 "The size of this type, in bytes.", NULL
},
1442 { "tag", typy_get_tag
, NULL
,
1443 "The tag name for this type, or None.", NULL
},
1447 static PyMethodDef type_object_methods
[] =
1449 { "array", typy_array
, METH_VARARGS
,
1450 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1451 Return a type which represents an array of objects of this type.\n\
1452 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1453 If LOW_BOUND is omitted, a value of zero is used." },
1454 { "vector", typy_vector
, METH_VARARGS
,
1455 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1456 Return a type which represents a vector of objects of this type.\n\
1457 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1458 If LOW_BOUND is omitted, a value of zero is used.\n\
1459 Vectors differ from arrays in that if the current language has C-style\n\
1460 arrays, vectors don't decay to a pointer to the first element.\n\
1461 They are first class values." },
1462 { "__contains__", typy_has_key
, METH_VARARGS
,
1463 "T.__contains__(k) -> True if T has a field named k, else False" },
1464 { "const", typy_const
, METH_NOARGS
,
1465 "const () -> Type\n\
1466 Return a const variant of this type." },
1467 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1468 "optimized_out() -> Value\n\
1469 Return optimized out value of this type." },
1470 { "fields", typy_fields
, METH_NOARGS
,
1471 "fields () -> list\n\
1472 Return a list holding all the fields of this type.\n\
1473 Each field is a gdb.Field object." },
1474 { "get", typy_get
, METH_VARARGS
,
1475 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1476 otherwise returns default, if supplied, or None if not." },
1477 { "has_key", typy_has_key
, METH_VARARGS
,
1478 "T.has_key(k) -> True if T has a field named k, else False" },
1479 { "items", typy_items
, METH_NOARGS
,
1480 "items () -> list\n\
1481 Return a list of (name, field) pairs of this type.\n\
1482 Each field is a gdb.Field object." },
1483 { "iteritems", typy_iteritems
, METH_NOARGS
,
1484 "iteritems () -> an iterator over the (name, field)\n\
1485 pairs of this type. Each field is a gdb.Field object." },
1486 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1487 "iterkeys () -> an iterator over the field names of this type." },
1488 { "itervalues", typy_itervalues
, METH_NOARGS
,
1489 "itervalues () -> an iterator over the fields of this type.\n\
1490 Each field is a gdb.Field object." },
1491 { "keys", typy_field_names
, METH_NOARGS
,
1493 Return a list holding all the fields names of this type." },
1494 { "pointer", typy_pointer
, METH_NOARGS
,
1495 "pointer () -> Type\n\
1496 Return a type of pointer to this type." },
1497 { "range", typy_range
, METH_NOARGS
,
1498 "range () -> tuple\n\
1499 Return a tuple containing the lower and upper range for this type."},
1500 { "reference", typy_reference
, METH_NOARGS
,
1501 "reference () -> Type\n\
1502 Return a type of reference to this type." },
1503 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1504 "strip_typedefs () -> Type\n\
1505 Return a type formed by stripping this type of all typedefs."},
1506 { "target", typy_target
, METH_NOARGS
,
1507 "target () -> Type\n\
1508 Return the target type of this type." },
1509 { "template_argument", typy_template_argument
, METH_VARARGS
,
1510 "template_argument (arg, [block]) -> Type\n\
1511 Return the type of a template argument." },
1512 { "unqualified", typy_unqualified
, METH_NOARGS
,
1513 "unqualified () -> Type\n\
1514 Return a variant of this type without const or volatile attributes." },
1515 { "values", typy_values
, METH_NOARGS
,
1516 "values () -> list\n\
1517 Return a list holding all the fields of this type.\n\
1518 Each field is a gdb.Field object." },
1519 { "volatile", typy_volatile
, METH_NOARGS
,
1520 "volatile () -> Type\n\
1521 Return a volatile variant of this type" },
1525 static PyNumberMethods type_object_as_number
= {
1527 NULL
, /* nb_subtract */
1528 NULL
, /* nb_multiply */
1530 NULL
, /* nb_divide */
1532 NULL
, /* nb_remainder */
1533 NULL
, /* nb_divmod */
1534 NULL
, /* nb_power */
1535 NULL
, /* nb_negative */
1536 NULL
, /* nb_positive */
1537 NULL
, /* nb_absolute */
1538 typy_nonzero
, /* nb_nonzero */
1539 NULL
, /* nb_invert */
1540 NULL
, /* nb_lshift */
1541 NULL
, /* nb_rshift */
1547 NULL
, /* reserved */
1549 NULL
, /* nb_coerce */
1553 NULL
, /* nb_float */
1560 static PyMappingMethods typy_mapping
= {
1563 NULL
/* no "set" method */
1566 PyTypeObject type_object_type
=
1568 PyVarObject_HEAD_INIT (NULL
, 0)
1569 "gdb.Type", /*tp_name*/
1570 sizeof (type_object
), /*tp_basicsize*/
1572 typy_dealloc
, /*tp_dealloc*/
1578 &type_object_as_number
, /*tp_as_number*/
1579 0, /*tp_as_sequence*/
1580 &typy_mapping
, /*tp_as_mapping*/
1583 typy_str
, /*tp_str*/
1587 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1588 "GDB type object", /* tp_doc */
1589 0, /* tp_traverse */
1591 typy_richcompare
, /* tp_richcompare */
1592 0, /* tp_weaklistoffset */
1593 typy_iter
, /* tp_iter */
1594 0, /* tp_iternext */
1595 type_object_methods
, /* tp_methods */
1597 type_object_getset
, /* tp_getset */
1600 0, /* tp_descr_get */
1601 0, /* tp_descr_set */
1602 0, /* tp_dictoffset */
1608 static gdb_PyGetSetDef field_object_getset
[] =
1610 { "__dict__", gdb_py_generic_dict
, NULL
,
1611 "The __dict__ for this field.", &field_object_type
},
1615 PyTypeObject field_object_type
=
1617 PyVarObject_HEAD_INIT (NULL
, 0)
1618 "gdb.Field", /*tp_name*/
1619 sizeof (field_object
), /*tp_basicsize*/
1621 field_dealloc
, /*tp_dealloc*/
1628 0, /*tp_as_sequence*/
1629 0, /*tp_as_mapping*/
1636 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1637 "GDB field object", /* tp_doc */
1638 0, /* tp_traverse */
1640 0, /* tp_richcompare */
1641 0, /* tp_weaklistoffset */
1643 0, /* tp_iternext */
1646 field_object_getset
, /* tp_getset */
1649 0, /* tp_descr_get */
1650 0, /* tp_descr_set */
1651 offsetof (field_object
, dict
), /* tp_dictoffset */
1657 PyTypeObject type_iterator_object_type
= {
1658 PyVarObject_HEAD_INIT (NULL
, 0)
1659 "gdb.TypeIterator", /*tp_name*/
1660 sizeof (typy_iterator_object
), /*tp_basicsize*/
1662 typy_iterator_dealloc
, /*tp_dealloc*/
1669 0, /*tp_as_sequence*/
1670 0, /*tp_as_mapping*/
1677 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1678 "GDB type iterator object", /*tp_doc */
1681 0, /*tp_richcompare */
1682 0, /*tp_weaklistoffset */
1683 typy_iterator_iter
, /*tp_iter */
1684 typy_iterator_iternext
, /*tp_iternext */