1 /* Python interface to types.
3 Copyright (C) 2008-2017 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_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
)));
222 Py_INCREF (arg
.get ());
224 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
227 arg
.reset (TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
);
228 Py_INCREF (arg
.get ());
229 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
232 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
233 arg
.reset (field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
);
235 arg
.reset (Py_False
);
236 Py_INCREF (arg
.get ());
237 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
240 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
243 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
246 /* A field can have a NULL type in some situations. */
247 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
250 Py_INCREF (arg
.get ());
253 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
256 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
259 return result
.release ();
262 /* Helper function to return the name of a field, as a gdb.Field object.
263 If the field doesn't have a name, None is returned. */
266 field_name (struct type
*type
, int field
)
270 if (TYPE_FIELD_NAME (type
, field
))
271 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
280 /* Helper function for Type standard mapping methods. Returns a
281 Python object for field i of the type. "kind" specifies what to
282 return: the name of the field, a gdb.Field object corresponding to
283 the field, or a tuple consisting of field name and gdb.Field
287 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
293 gdbpy_ref
<> key (field_name (type
, i
));
296 gdbpy_ref
<> value (convert_field (type
, i
));
299 gdbpy_ref
<> item (PyTuple_New (2));
302 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
303 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
304 return item
.release ();
307 return field_name (type
, i
);
309 return convert_field (type
, i
);
311 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
314 /* Return a sequence of all field names, fields, or (name, field) pairs.
315 Each field is a gdb.Field object. */
318 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
320 PyObject
*py_type
= self
;
321 PyObject
*result
= NULL
, *iter
= NULL
;
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 if (checked_type
!= type
)
336 py_type
= type_to_type_object (checked_type
);
337 iter
= typy_make_iter (py_type
, kind
);
338 if (checked_type
!= type
)
340 /* Need to wrap this in braces because Py_DECREF isn't wrapped
341 in a do{}while(0). */
346 result
= PySequence_List (iter
);
353 /* Return a sequence of all fields. Each field is a gdb.Field object. */
356 typy_values (PyObject
*self
, PyObject
*args
)
358 return typy_fields_items (self
, iter_values
);
361 /* Return a sequence of all fields. Each field is a gdb.Field object.
362 This method is similar to typy_values, except where the supplied
363 gdb.Type is an array, in which case it returns a list of one entry
364 which is a gdb.Field object for a range (the array bounds). */
367 typy_fields (PyObject
*self
, PyObject
*args
)
369 struct type
*type
= ((type_object
*) self
)->type
;
371 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
372 return typy_fields_items (self
, iter_values
);
374 /* Array type. Handle this as a special case because the common
375 machinery wants struct or union or enum types. Build a list of
376 one entry which is the range for the array. */
377 gdbpy_ref
<> r (convert_field (type
, 0));
381 return Py_BuildValue ("[O]", r
.get ());
384 /* Return a sequence of all field names. Each field is a gdb.Field object. */
387 typy_field_names (PyObject
*self
, PyObject
*args
)
389 return typy_fields_items (self
, iter_keys
);
392 /* Return a sequence of all (name, fields) pairs. Each field is a
396 typy_items (PyObject
*self
, PyObject
*args
)
398 return typy_fields_items (self
, iter_items
);
401 /* Return the type's name, or None. */
404 typy_get_name (PyObject
*self
, void *closure
)
406 struct type
*type
= ((type_object
*) self
)->type
;
408 if (TYPE_NAME (type
) == NULL
)
410 return PyString_FromString (TYPE_NAME (type
));
413 /* Return the type's tag, or None. */
415 typy_get_tag (PyObject
*self
, void *closure
)
417 struct type
*type
= ((type_object
*) self
)->type
;
419 if (!TYPE_TAG_NAME (type
))
421 return PyString_FromString (TYPE_TAG_NAME (type
));
424 /* Return the type, stripped of typedefs. */
426 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
428 struct type
*type
= ((type_object
*) self
)->type
;
432 type
= check_typedef (type
);
434 CATCH (except
, RETURN_MASK_ALL
)
436 GDB_PY_HANDLE_EXCEPTION (except
);
440 return type_to_type_object (type
);
443 /* Strip typedefs and pointers/reference from a type. Then check that
444 it is a struct, union, or enum type. If not, raise TypeError. */
447 typy_get_composite (struct type
*type
)
454 type
= check_typedef (type
);
456 CATCH (except
, RETURN_MASK_ALL
)
458 GDB_PY_HANDLE_EXCEPTION (except
);
462 if (TYPE_CODE (type
) != TYPE_CODE_PTR
463 && TYPE_CODE (type
) != TYPE_CODE_REF
)
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_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 char *type_name
= NULL
;
765 enum demangle_component_type demangled_type
;
767 /* Save the type: typy_lookup_type() may (indirectly) overwrite
768 memory pointed by demangled. */
769 demangled_type
= demangled
->type
;
771 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
772 || demangled_type
== DEMANGLE_COMPONENT_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_reference_type (type
);
791 case DEMANGLE_COMPONENT_POINTER
:
792 rtype
= lookup_pointer_type (type
);
794 case DEMANGLE_COMPONENT_CONST
:
795 rtype
= make_cv_type (1, 0, type
, NULL
);
797 case DEMANGLE_COMPONENT_VOLATILE
:
798 rtype
= make_cv_type (0, 1, type
, NULL
);
802 CATCH (except
, RETURN_MASK_ALL
)
804 GDB_PY_HANDLE_EXCEPTION (except
);
809 /* If we have a type from the switch statement above, just return
814 /* We don't have a type, so lookup the type. */
815 type_name
= cp_comp_to_string (demangled
, 10);
816 type
= typy_lookup_typename (type_name
, 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
;
836 struct cleanup
*cleanup
;
838 if (TYPE_NAME (type
) == NULL
)
840 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
846 /* Note -- this is not thread-safe. */
847 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
849 CATCH (except
, RETURN_MASK_ALL
)
851 GDB_PY_HANDLE_EXCEPTION (except
);
857 PyErr_SetString (PyExc_RuntimeError
, err
);
860 demangled
= info
->tree
;
862 /* Strip off component names. */
863 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
864 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
865 demangled
= demangled
->u
.s_binary
.right
;
867 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
869 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
873 /* Skip from the template to the arguments. */
874 demangled
= demangled
->u
.s_binary
.right
;
876 for (i
= 0; demangled
&& i
< argno
; ++i
)
877 demangled
= demangled
->u
.s_binary
.right
;
881 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
886 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
890 return type_to_type_object (argtype
);
894 typy_template_argument (PyObject
*self
, PyObject
*args
)
897 struct type
*type
= ((type_object
*) self
)->type
;
898 const struct block
*block
= NULL
;
899 PyObject
*block_obj
= NULL
;
901 struct value
*val
= NULL
;
903 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
908 block
= block_object_to_block (block_obj
);
911 PyErr_SetString (PyExc_RuntimeError
,
912 _("Second argument must be block."));
919 type
= check_typedef (type
);
920 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
921 type
= check_typedef (TYPE_TARGET_TYPE (type
));
923 CATCH (except
, RETURN_MASK_ALL
)
925 GDB_PY_HANDLE_EXCEPTION (except
);
929 /* We might not have DW_TAG_template_*, so try to parse the type's
930 name. This is inefficient if we do not have a template type --
931 but that is going to wind up as an error anyhow. */
932 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
933 return typy_legacy_template_argument (type
, block
, argno
);
935 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
937 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
942 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
943 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
944 return type_to_type_object (SYMBOL_TYPE (sym
));
945 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
947 PyErr_Format (PyExc_RuntimeError
,
948 _("Template argument is optimized out"));
954 val
= value_of_variable (sym
, block
);
956 CATCH (except
, RETURN_MASK_ALL
)
958 GDB_PY_HANDLE_EXCEPTION (except
);
962 return value_to_value_object (val
);
966 typy_str (PyObject
*self
)
973 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
974 &type_print_raw_options
);
976 CATCH (except
, RETURN_MASK_ALL
)
978 GDB_PY_HANDLE_EXCEPTION (except
);
982 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
983 host_charset (), NULL
);
986 /* Implement the richcompare method. */
989 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
992 struct type
*type1
= type_object_to_type (self
);
993 struct type
*type2
= type_object_to_type (other
);
995 /* We can only compare ourselves to another Type object, and only
996 for equality or inequality. */
997 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
999 Py_INCREF (Py_NotImplemented
);
1000 return Py_NotImplemented
;
1009 result
= types_deeply_equal (type1
, type2
);
1011 CATCH (except
, RETURN_MASK_ALL
)
1013 /* If there is a GDB exception, a comparison is not capable
1014 (or trusted), so exit. */
1015 GDB_PY_HANDLE_EXCEPTION (except
);
1020 if (op
== (result
? Py_EQ
: Py_NE
))
1027 static const struct objfile_data
*typy_objfile_data_key
;
1030 save_objfile_types (struct objfile
*objfile
, void *datum
)
1032 type_object
*obj
= (type_object
*) datum
;
1033 htab_t copied_types
;
1035 if (!gdb_python_initialized
)
1038 /* This prevents another thread from freeing the objects we're
1040 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1042 copied_types
= create_copied_types_hash (objfile
);
1046 type_object
*next
= obj
->next
;
1048 htab_empty (copied_types
);
1050 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1058 htab_delete (copied_types
);
1062 set_type (type_object
*obj
, struct type
*type
)
1066 if (type
&& TYPE_OBJFILE (type
))
1068 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1070 obj
->next
= ((struct pyty_type_object
*)
1071 objfile_data (objfile
, typy_objfile_data_key
));
1073 obj
->next
->prev
= obj
;
1074 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1081 typy_dealloc (PyObject
*obj
)
1083 type_object
*type
= (type_object
*) obj
;
1086 type
->prev
->next
= type
->next
;
1087 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1089 /* Must reset head of list. */
1090 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1093 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1096 type
->next
->prev
= type
->prev
;
1098 Py_TYPE (type
)->tp_free (type
);
1101 /* Return number of fields ("length" of the field dictionary). */
1104 typy_length (PyObject
*self
)
1106 struct type
*type
= ((type_object
*) self
)->type
;
1108 type
= typy_get_composite (type
);
1112 return TYPE_NFIELDS (type
);
1115 /* Implements boolean evaluation of gdb.Type. Handle this like other
1116 Python objects that don't have a meaningful truth value -- all
1120 typy_nonzero (PyObject
*self
)
1125 /* Return optimized out value of this type. */
1128 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1130 struct type
*type
= ((type_object
*) self
)->type
;
1132 return value_to_value_object (allocate_optimized_out_value (type
));
1135 /* Return a gdb.Field object for the field named by the argument. */
1138 typy_getitem (PyObject
*self
, PyObject
*key
)
1140 struct type
*type
= ((type_object
*) self
)->type
;
1143 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1147 /* We want just fields of this type, not of base types, so instead of
1148 using lookup_struct_elt_type, portions of that function are
1151 type
= typy_get_composite (type
);
1155 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1157 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1159 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1161 return convert_field (type
, i
);
1164 PyErr_SetObject (PyExc_KeyError
, key
);
1168 /* Implement the "get" method on the type object. This is the
1169 same as getitem if the key is present, but returns the supplied
1170 default value or None if the key is not found. */
1173 typy_get (PyObject
*self
, PyObject
*args
)
1175 PyObject
*key
, *defval
= Py_None
, *result
;
1177 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1180 result
= typy_getitem (self
, key
);
1184 /* typy_getitem returned error status. If the exception is
1185 KeyError, clear the exception status and return the defval
1186 instead. Otherwise return the exception unchanged. */
1187 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1195 /* Implement the "has_key" method on the type object. */
1198 typy_has_key (PyObject
*self
, PyObject
*args
)
1200 struct type
*type
= ((type_object
*) self
)->type
;
1204 if (!PyArg_ParseTuple (args
, "s", &field
))
1207 /* We want just fields of this type, not of base types, so instead of
1208 using lookup_struct_elt_type, portions of that function are
1211 type
= typy_get_composite (type
);
1215 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1217 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1219 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1225 /* Make an iterator object to iterate over keys, values, or items. */
1228 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1230 typy_iterator_object
*typy_iter_obj
;
1232 /* Check that "self" is a structure or union type. */
1233 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1236 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1237 &type_iterator_object_type
);
1238 if (typy_iter_obj
== NULL
)
1241 typy_iter_obj
->field
= 0;
1242 typy_iter_obj
->kind
= kind
;
1244 typy_iter_obj
->source
= (type_object
*) self
;
1246 return (PyObject
*) typy_iter_obj
;
1249 /* iteritems() method. */
1252 typy_iteritems (PyObject
*self
, PyObject
*args
)
1254 return typy_make_iter (self
, iter_items
);
1257 /* iterkeys() method. */
1260 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1262 return typy_make_iter (self
, iter_keys
);
1265 /* Iterating over the class, same as iterkeys except for the function
1269 typy_iter (PyObject
*self
)
1271 return typy_make_iter (self
, iter_keys
);
1274 /* itervalues() method. */
1277 typy_itervalues (PyObject
*self
, PyObject
*args
)
1279 return typy_make_iter (self
, iter_values
);
1282 /* Return a reference to the type iterator. */
1285 typy_iterator_iter (PyObject
*self
)
1291 /* Return the next field in the iteration through the list of fields
1295 typy_iterator_iternext (PyObject
*self
)
1297 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1298 struct type
*type
= iter_obj
->source
->type
;
1301 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1303 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1313 typy_iterator_dealloc (PyObject
*obj
)
1315 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1317 Py_DECREF (iter_obj
->source
);
1320 /* Create a new Type referring to TYPE. */
1322 type_to_type_object (struct type
*type
)
1324 type_object
*type_obj
;
1326 type_obj
= PyObject_New (type_object
, &type_object_type
);
1328 set_type (type_obj
, type
);
1330 return (PyObject
*) type_obj
;
1334 type_object_to_type (PyObject
*obj
)
1336 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1338 return ((type_object
*) obj
)->type
;
1343 /* Implementation of gdb.lookup_type. */
1345 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1347 static char *keywords
[] = { "name", "block", NULL
};
1348 const char *type_name
= NULL
;
1349 struct type
*type
= NULL
;
1350 PyObject
*block_obj
= NULL
;
1351 const struct block
*block
= NULL
;
1353 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1354 &type_name
, &block_obj
))
1359 block
= block_object_to_block (block_obj
);
1362 PyErr_SetString (PyExc_RuntimeError
,
1363 _("'block' argument must be a Block."));
1368 type
= typy_lookup_typename (type_name
, block
);
1372 return (PyObject
*) type_to_type_object (type
);
1376 gdbpy_initialize_types (void)
1380 typy_objfile_data_key
1381 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1383 if (PyType_Ready (&type_object_type
) < 0)
1385 if (PyType_Ready (&field_object_type
) < 0)
1387 if (PyType_Ready (&type_iterator_object_type
) < 0)
1390 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1392 if (PyModule_AddIntConstant (gdb_module
,
1393 /* Cast needed for Python 2.4. */
1394 (char *) pyty_codes
[i
].name
,
1395 pyty_codes
[i
].code
) < 0)
1399 if (gdb_pymodule_addobject (gdb_module
, "Type",
1400 (PyObject
*) &type_object_type
) < 0)
1403 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1404 (PyObject
*) &type_iterator_object_type
) < 0)
1407 return gdb_pymodule_addobject (gdb_module
, "Field",
1408 (PyObject
*) &field_object_type
);
1413 static PyGetSetDef type_object_getset
[] =
1415 { "code", typy_get_code
, NULL
,
1416 "The code for this type.", NULL
},
1417 { "name", typy_get_name
, NULL
,
1418 "The name for this type, or None.", NULL
},
1419 { "sizeof", typy_get_sizeof
, NULL
,
1420 "The size of this type, in bytes.", NULL
},
1421 { "tag", typy_get_tag
, NULL
,
1422 "The tag name for this type, or None.", NULL
},
1426 static PyMethodDef type_object_methods
[] =
1428 { "array", typy_array
, METH_VARARGS
,
1429 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1430 Return a type which represents an array of objects of this type.\n\
1431 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1432 If LOW_BOUND is omitted, a value of zero is used." },
1433 { "vector", typy_vector
, METH_VARARGS
,
1434 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1435 Return a type which represents a vector of objects of this type.\n\
1436 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1437 If LOW_BOUND is omitted, a value of zero is used.\n\
1438 Vectors differ from arrays in that if the current language has C-style\n\
1439 arrays, vectors don't decay to a pointer to the first element.\n\
1440 They are first class values." },
1441 { "__contains__", typy_has_key
, METH_VARARGS
,
1442 "T.__contains__(k) -> True if T has a field named k, else False" },
1443 { "const", typy_const
, METH_NOARGS
,
1444 "const () -> Type\n\
1445 Return a const variant of this type." },
1446 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1447 "optimized_out() -> Value\n\
1448 Return optimized out value of this type." },
1449 { "fields", typy_fields
, METH_NOARGS
,
1450 "fields () -> list\n\
1451 Return a list holding all the fields of this type.\n\
1452 Each field is a gdb.Field object." },
1453 { "get", typy_get
, METH_VARARGS
,
1454 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1455 otherwise returns default, if supplied, or None if not." },
1456 { "has_key", typy_has_key
, METH_VARARGS
,
1457 "T.has_key(k) -> True if T has a field named k, else False" },
1458 { "items", typy_items
, METH_NOARGS
,
1459 "items () -> list\n\
1460 Return a list of (name, field) pairs of this type.\n\
1461 Each field is a gdb.Field object." },
1462 { "iteritems", typy_iteritems
, METH_NOARGS
,
1463 "iteritems () -> an iterator over the (name, field)\n\
1464 pairs of this type. Each field is a gdb.Field object." },
1465 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1466 "iterkeys () -> an iterator over the field names of this type." },
1467 { "itervalues", typy_itervalues
, METH_NOARGS
,
1468 "itervalues () -> an iterator over the fields of this type.\n\
1469 Each field is a gdb.Field object." },
1470 { "keys", typy_field_names
, METH_NOARGS
,
1472 Return a list holding all the fields names of this type." },
1473 { "pointer", typy_pointer
, METH_NOARGS
,
1474 "pointer () -> Type\n\
1475 Return a type of pointer to this type." },
1476 { "range", typy_range
, METH_NOARGS
,
1477 "range () -> tuple\n\
1478 Return a tuple containing the lower and upper range for this type."},
1479 { "reference", typy_reference
, METH_NOARGS
,
1480 "reference () -> Type\n\
1481 Return a type of reference to this type." },
1482 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1483 "strip_typedefs () -> Type\n\
1484 Return a type formed by stripping this type of all typedefs."},
1485 { "target", typy_target
, METH_NOARGS
,
1486 "target () -> Type\n\
1487 Return the target type of this type." },
1488 { "template_argument", typy_template_argument
, METH_VARARGS
,
1489 "template_argument (arg, [block]) -> Type\n\
1490 Return the type of a template argument." },
1491 { "unqualified", typy_unqualified
, METH_NOARGS
,
1492 "unqualified () -> Type\n\
1493 Return a variant of this type without const or volatile attributes." },
1494 { "values", typy_values
, METH_NOARGS
,
1495 "values () -> list\n\
1496 Return a list holding all the fields of this type.\n\
1497 Each field is a gdb.Field object." },
1498 { "volatile", typy_volatile
, METH_NOARGS
,
1499 "volatile () -> Type\n\
1500 Return a volatile variant of this type" },
1504 static PyNumberMethods type_object_as_number
= {
1506 NULL
, /* nb_subtract */
1507 NULL
, /* nb_multiply */
1509 NULL
, /* nb_divide */
1511 NULL
, /* nb_remainder */
1512 NULL
, /* nb_divmod */
1513 NULL
, /* nb_power */
1514 NULL
, /* nb_negative */
1515 NULL
, /* nb_positive */
1516 NULL
, /* nb_absolute */
1517 typy_nonzero
, /* nb_nonzero */
1518 NULL
, /* nb_invert */
1519 NULL
, /* nb_lshift */
1520 NULL
, /* nb_rshift */
1526 NULL
, /* reserved */
1528 NULL
, /* nb_coerce */
1532 NULL
, /* nb_float */
1539 static PyMappingMethods typy_mapping
= {
1542 NULL
/* no "set" method */
1545 PyTypeObject type_object_type
=
1547 PyVarObject_HEAD_INIT (NULL
, 0)
1548 "gdb.Type", /*tp_name*/
1549 sizeof (type_object
), /*tp_basicsize*/
1551 typy_dealloc
, /*tp_dealloc*/
1557 &type_object_as_number
, /*tp_as_number*/
1558 0, /*tp_as_sequence*/
1559 &typy_mapping
, /*tp_as_mapping*/
1562 typy_str
, /*tp_str*/
1566 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1567 "GDB type object", /* tp_doc */
1568 0, /* tp_traverse */
1570 typy_richcompare
, /* tp_richcompare */
1571 0, /* tp_weaklistoffset */
1572 typy_iter
, /* tp_iter */
1573 0, /* tp_iternext */
1574 type_object_methods
, /* tp_methods */
1576 type_object_getset
, /* tp_getset */
1579 0, /* tp_descr_get */
1580 0, /* tp_descr_set */
1581 0, /* tp_dictoffset */
1587 static PyGetSetDef field_object_getset
[] =
1589 { "__dict__", gdb_py_generic_dict
, NULL
,
1590 "The __dict__ for this field.", &field_object_type
},
1594 PyTypeObject field_object_type
=
1596 PyVarObject_HEAD_INIT (NULL
, 0)
1597 "gdb.Field", /*tp_name*/
1598 sizeof (field_object
), /*tp_basicsize*/
1600 field_dealloc
, /*tp_dealloc*/
1607 0, /*tp_as_sequence*/
1608 0, /*tp_as_mapping*/
1615 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1616 "GDB field object", /* tp_doc */
1617 0, /* tp_traverse */
1619 0, /* tp_richcompare */
1620 0, /* tp_weaklistoffset */
1622 0, /* tp_iternext */
1625 field_object_getset
, /* tp_getset */
1628 0, /* tp_descr_get */
1629 0, /* tp_descr_set */
1630 offsetof (field_object
, dict
), /* tp_dictoffset */
1636 PyTypeObject type_iterator_object_type
= {
1637 PyVarObject_HEAD_INIT (NULL
, 0)
1638 "gdb.TypeIterator", /*tp_name*/
1639 sizeof (typy_iterator_object
), /*tp_basicsize*/
1641 typy_iterator_dealloc
, /*tp_dealloc*/
1648 0, /*tp_as_sequence*/
1649 0, /*tp_as_mapping*/
1656 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1657 "GDB type iterator object", /*tp_doc */
1660 0, /*tp_richcompare */
1661 0, /*tp_weaklistoffset */
1662 typy_iterator_iter
, /*tp_iter */
1663 typy_iterator_iternext
, /*tp_iternext */