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
;
837 if (TYPE_NAME (type
) == NULL
)
839 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
845 /* Note -- this is not thread-safe. */
846 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
848 CATCH (except
, RETURN_MASK_ALL
)
850 GDB_PY_HANDLE_EXCEPTION (except
);
856 PyErr_SetString (PyExc_RuntimeError
, err
);
859 demangled
= info
->tree
;
861 /* Strip off component names. */
862 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
863 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
864 demangled
= demangled
->u
.s_binary
.right
;
866 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
868 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
872 /* Skip from the template to the arguments. */
873 demangled
= demangled
->u
.s_binary
.right
;
875 for (i
= 0; demangled
&& i
< argno
; ++i
)
876 demangled
= demangled
->u
.s_binary
.right
;
880 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
885 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
889 return type_to_type_object (argtype
);
893 typy_template_argument (PyObject
*self
, PyObject
*args
)
896 struct type
*type
= ((type_object
*) self
)->type
;
897 const struct block
*block
= NULL
;
898 PyObject
*block_obj
= NULL
;
900 struct value
*val
= NULL
;
902 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
907 block
= block_object_to_block (block_obj
);
910 PyErr_SetString (PyExc_RuntimeError
,
911 _("Second argument must be block."));
918 type
= check_typedef (type
);
919 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
920 type
= check_typedef (TYPE_TARGET_TYPE (type
));
922 CATCH (except
, RETURN_MASK_ALL
)
924 GDB_PY_HANDLE_EXCEPTION (except
);
928 /* We might not have DW_TAG_template_*, so try to parse the type's
929 name. This is inefficient if we do not have a template type --
930 but that is going to wind up as an error anyhow. */
931 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
932 return typy_legacy_template_argument (type
, block
, argno
);
934 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
936 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
941 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
942 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
943 return type_to_type_object (SYMBOL_TYPE (sym
));
944 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
946 PyErr_Format (PyExc_RuntimeError
,
947 _("Template argument is optimized out"));
953 val
= value_of_variable (sym
, block
);
955 CATCH (except
, RETURN_MASK_ALL
)
957 GDB_PY_HANDLE_EXCEPTION (except
);
961 return value_to_value_object (val
);
965 typy_str (PyObject
*self
)
972 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
973 &type_print_raw_options
);
975 CATCH (except
, RETURN_MASK_ALL
)
977 GDB_PY_HANDLE_EXCEPTION (except
);
981 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
982 host_charset (), NULL
);
985 /* Implement the richcompare method. */
988 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
991 struct type
*type1
= type_object_to_type (self
);
992 struct type
*type2
= type_object_to_type (other
);
994 /* We can only compare ourselves to another Type object, and only
995 for equality or inequality. */
996 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
998 Py_INCREF (Py_NotImplemented
);
999 return Py_NotImplemented
;
1008 result
= types_deeply_equal (type1
, type2
);
1010 CATCH (except
, RETURN_MASK_ALL
)
1012 /* If there is a GDB exception, a comparison is not capable
1013 (or trusted), so exit. */
1014 GDB_PY_HANDLE_EXCEPTION (except
);
1019 if (op
== (result
? Py_EQ
: Py_NE
))
1026 static const struct objfile_data
*typy_objfile_data_key
;
1029 save_objfile_types (struct objfile
*objfile
, void *datum
)
1031 type_object
*obj
= (type_object
*) datum
;
1032 htab_t copied_types
;
1034 if (!gdb_python_initialized
)
1037 /* This prevents another thread from freeing the objects we're
1039 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1041 copied_types
= create_copied_types_hash (objfile
);
1045 type_object
*next
= obj
->next
;
1047 htab_empty (copied_types
);
1049 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1057 htab_delete (copied_types
);
1061 set_type (type_object
*obj
, struct type
*type
)
1065 if (type
&& TYPE_OBJFILE (type
))
1067 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1069 obj
->next
= ((struct pyty_type_object
*)
1070 objfile_data (objfile
, typy_objfile_data_key
));
1072 obj
->next
->prev
= obj
;
1073 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1080 typy_dealloc (PyObject
*obj
)
1082 type_object
*type
= (type_object
*) obj
;
1085 type
->prev
->next
= type
->next
;
1086 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1088 /* Must reset head of list. */
1089 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1092 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1095 type
->next
->prev
= type
->prev
;
1097 Py_TYPE (type
)->tp_free (type
);
1100 /* Return number of fields ("length" of the field dictionary). */
1103 typy_length (PyObject
*self
)
1105 struct type
*type
= ((type_object
*) self
)->type
;
1107 type
= typy_get_composite (type
);
1111 return TYPE_NFIELDS (type
);
1114 /* Implements boolean evaluation of gdb.Type. Handle this like other
1115 Python objects that don't have a meaningful truth value -- all
1119 typy_nonzero (PyObject
*self
)
1124 /* Return optimized out value of this type. */
1127 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1129 struct type
*type
= ((type_object
*) self
)->type
;
1131 return value_to_value_object (allocate_optimized_out_value (type
));
1134 /* Return a gdb.Field object for the field named by the argument. */
1137 typy_getitem (PyObject
*self
, PyObject
*key
)
1139 struct type
*type
= ((type_object
*) self
)->type
;
1142 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1146 /* We want just fields of this type, not of base types, so instead of
1147 using lookup_struct_elt_type, portions of that function are
1150 type
= typy_get_composite (type
);
1154 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1156 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1158 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1160 return convert_field (type
, i
);
1163 PyErr_SetObject (PyExc_KeyError
, key
);
1167 /* Implement the "get" method on the type object. This is the
1168 same as getitem if the key is present, but returns the supplied
1169 default value or None if the key is not found. */
1172 typy_get (PyObject
*self
, PyObject
*args
)
1174 PyObject
*key
, *defval
= Py_None
, *result
;
1176 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1179 result
= typy_getitem (self
, key
);
1183 /* typy_getitem returned error status. If the exception is
1184 KeyError, clear the exception status and return the defval
1185 instead. Otherwise return the exception unchanged. */
1186 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1194 /* Implement the "has_key" method on the type object. */
1197 typy_has_key (PyObject
*self
, PyObject
*args
)
1199 struct type
*type
= ((type_object
*) self
)->type
;
1203 if (!PyArg_ParseTuple (args
, "s", &field
))
1206 /* We want just fields of this type, not of base types, so instead of
1207 using lookup_struct_elt_type, portions of that function are
1210 type
= typy_get_composite (type
);
1214 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1216 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1218 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1224 /* Make an iterator object to iterate over keys, values, or items. */
1227 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1229 typy_iterator_object
*typy_iter_obj
;
1231 /* Check that "self" is a structure or union type. */
1232 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1235 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1236 &type_iterator_object_type
);
1237 if (typy_iter_obj
== NULL
)
1240 typy_iter_obj
->field
= 0;
1241 typy_iter_obj
->kind
= kind
;
1243 typy_iter_obj
->source
= (type_object
*) self
;
1245 return (PyObject
*) typy_iter_obj
;
1248 /* iteritems() method. */
1251 typy_iteritems (PyObject
*self
, PyObject
*args
)
1253 return typy_make_iter (self
, iter_items
);
1256 /* iterkeys() method. */
1259 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1261 return typy_make_iter (self
, iter_keys
);
1264 /* Iterating over the class, same as iterkeys except for the function
1268 typy_iter (PyObject
*self
)
1270 return typy_make_iter (self
, iter_keys
);
1273 /* itervalues() method. */
1276 typy_itervalues (PyObject
*self
, PyObject
*args
)
1278 return typy_make_iter (self
, iter_values
);
1281 /* Return a reference to the type iterator. */
1284 typy_iterator_iter (PyObject
*self
)
1290 /* Return the next field in the iteration through the list of fields
1294 typy_iterator_iternext (PyObject
*self
)
1296 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1297 struct type
*type
= iter_obj
->source
->type
;
1300 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1302 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1312 typy_iterator_dealloc (PyObject
*obj
)
1314 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1316 Py_DECREF (iter_obj
->source
);
1319 /* Create a new Type referring to TYPE. */
1321 type_to_type_object (struct type
*type
)
1323 type_object
*type_obj
;
1325 type_obj
= PyObject_New (type_object
, &type_object_type
);
1327 set_type (type_obj
, type
);
1329 return (PyObject
*) type_obj
;
1333 type_object_to_type (PyObject
*obj
)
1335 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1337 return ((type_object
*) obj
)->type
;
1342 /* Implementation of gdb.lookup_type. */
1344 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1346 static char *keywords
[] = { "name", "block", NULL
};
1347 const char *type_name
= NULL
;
1348 struct type
*type
= NULL
;
1349 PyObject
*block_obj
= NULL
;
1350 const struct block
*block
= NULL
;
1352 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1353 &type_name
, &block_obj
))
1358 block
= block_object_to_block (block_obj
);
1361 PyErr_SetString (PyExc_RuntimeError
,
1362 _("'block' argument must be a Block."));
1367 type
= typy_lookup_typename (type_name
, block
);
1371 return (PyObject
*) type_to_type_object (type
);
1375 gdbpy_initialize_types (void)
1379 typy_objfile_data_key
1380 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1382 if (PyType_Ready (&type_object_type
) < 0)
1384 if (PyType_Ready (&field_object_type
) < 0)
1386 if (PyType_Ready (&type_iterator_object_type
) < 0)
1389 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1391 if (PyModule_AddIntConstant (gdb_module
,
1392 /* Cast needed for Python 2.4. */
1393 (char *) pyty_codes
[i
].name
,
1394 pyty_codes
[i
].code
) < 0)
1398 if (gdb_pymodule_addobject (gdb_module
, "Type",
1399 (PyObject
*) &type_object_type
) < 0)
1402 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1403 (PyObject
*) &type_iterator_object_type
) < 0)
1406 return gdb_pymodule_addobject (gdb_module
, "Field",
1407 (PyObject
*) &field_object_type
);
1412 static PyGetSetDef type_object_getset
[] =
1414 { "code", typy_get_code
, NULL
,
1415 "The code for this type.", NULL
},
1416 { "name", typy_get_name
, NULL
,
1417 "The name for this type, or None.", NULL
},
1418 { "sizeof", typy_get_sizeof
, NULL
,
1419 "The size of this type, in bytes.", NULL
},
1420 { "tag", typy_get_tag
, NULL
,
1421 "The tag name for this type, or None.", NULL
},
1425 static PyMethodDef type_object_methods
[] =
1427 { "array", typy_array
, METH_VARARGS
,
1428 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1429 Return a type which represents an array of objects of this type.\n\
1430 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1431 If LOW_BOUND is omitted, a value of zero is used." },
1432 { "vector", typy_vector
, METH_VARARGS
,
1433 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1434 Return a type which represents a vector of objects of this type.\n\
1435 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1436 If LOW_BOUND is omitted, a value of zero is used.\n\
1437 Vectors differ from arrays in that if the current language has C-style\n\
1438 arrays, vectors don't decay to a pointer to the first element.\n\
1439 They are first class values." },
1440 { "__contains__", typy_has_key
, METH_VARARGS
,
1441 "T.__contains__(k) -> True if T has a field named k, else False" },
1442 { "const", typy_const
, METH_NOARGS
,
1443 "const () -> Type\n\
1444 Return a const variant of this type." },
1445 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1446 "optimized_out() -> Value\n\
1447 Return optimized out value of this type." },
1448 { "fields", typy_fields
, METH_NOARGS
,
1449 "fields () -> list\n\
1450 Return a list holding all the fields of this type.\n\
1451 Each field is a gdb.Field object." },
1452 { "get", typy_get
, METH_VARARGS
,
1453 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1454 otherwise returns default, if supplied, or None if not." },
1455 { "has_key", typy_has_key
, METH_VARARGS
,
1456 "T.has_key(k) -> True if T has a field named k, else False" },
1457 { "items", typy_items
, METH_NOARGS
,
1458 "items () -> list\n\
1459 Return a list of (name, field) pairs of this type.\n\
1460 Each field is a gdb.Field object." },
1461 { "iteritems", typy_iteritems
, METH_NOARGS
,
1462 "iteritems () -> an iterator over the (name, field)\n\
1463 pairs of this type. Each field is a gdb.Field object." },
1464 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1465 "iterkeys () -> an iterator over the field names of this type." },
1466 { "itervalues", typy_itervalues
, METH_NOARGS
,
1467 "itervalues () -> an iterator over the fields of this type.\n\
1468 Each field is a gdb.Field object." },
1469 { "keys", typy_field_names
, METH_NOARGS
,
1471 Return a list holding all the fields names of this type." },
1472 { "pointer", typy_pointer
, METH_NOARGS
,
1473 "pointer () -> Type\n\
1474 Return a type of pointer to this type." },
1475 { "range", typy_range
, METH_NOARGS
,
1476 "range () -> tuple\n\
1477 Return a tuple containing the lower and upper range for this type."},
1478 { "reference", typy_reference
, METH_NOARGS
,
1479 "reference () -> Type\n\
1480 Return a type of reference to this type." },
1481 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1482 "strip_typedefs () -> Type\n\
1483 Return a type formed by stripping this type of all typedefs."},
1484 { "target", typy_target
, METH_NOARGS
,
1485 "target () -> Type\n\
1486 Return the target type of this type." },
1487 { "template_argument", typy_template_argument
, METH_VARARGS
,
1488 "template_argument (arg, [block]) -> Type\n\
1489 Return the type of a template argument." },
1490 { "unqualified", typy_unqualified
, METH_NOARGS
,
1491 "unqualified () -> Type\n\
1492 Return a variant of this type without const or volatile attributes." },
1493 { "values", typy_values
, METH_NOARGS
,
1494 "values () -> list\n\
1495 Return a list holding all the fields of this type.\n\
1496 Each field is a gdb.Field object." },
1497 { "volatile", typy_volatile
, METH_NOARGS
,
1498 "volatile () -> Type\n\
1499 Return a volatile variant of this type" },
1503 static PyNumberMethods type_object_as_number
= {
1505 NULL
, /* nb_subtract */
1506 NULL
, /* nb_multiply */
1508 NULL
, /* nb_divide */
1510 NULL
, /* nb_remainder */
1511 NULL
, /* nb_divmod */
1512 NULL
, /* nb_power */
1513 NULL
, /* nb_negative */
1514 NULL
, /* nb_positive */
1515 NULL
, /* nb_absolute */
1516 typy_nonzero
, /* nb_nonzero */
1517 NULL
, /* nb_invert */
1518 NULL
, /* nb_lshift */
1519 NULL
, /* nb_rshift */
1525 NULL
, /* reserved */
1527 NULL
, /* nb_coerce */
1531 NULL
, /* nb_float */
1538 static PyMappingMethods typy_mapping
= {
1541 NULL
/* no "set" method */
1544 PyTypeObject type_object_type
=
1546 PyVarObject_HEAD_INIT (NULL
, 0)
1547 "gdb.Type", /*tp_name*/
1548 sizeof (type_object
), /*tp_basicsize*/
1550 typy_dealloc
, /*tp_dealloc*/
1556 &type_object_as_number
, /*tp_as_number*/
1557 0, /*tp_as_sequence*/
1558 &typy_mapping
, /*tp_as_mapping*/
1561 typy_str
, /*tp_str*/
1565 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1566 "GDB type object", /* tp_doc */
1567 0, /* tp_traverse */
1569 typy_richcompare
, /* tp_richcompare */
1570 0, /* tp_weaklistoffset */
1571 typy_iter
, /* tp_iter */
1572 0, /* tp_iternext */
1573 type_object_methods
, /* tp_methods */
1575 type_object_getset
, /* tp_getset */
1578 0, /* tp_descr_get */
1579 0, /* tp_descr_set */
1580 0, /* tp_dictoffset */
1586 static PyGetSetDef field_object_getset
[] =
1588 { "__dict__", gdb_py_generic_dict
, NULL
,
1589 "The __dict__ for this field.", &field_object_type
},
1593 PyTypeObject field_object_type
=
1595 PyVarObject_HEAD_INIT (NULL
, 0)
1596 "gdb.Field", /*tp_name*/
1597 sizeof (field_object
), /*tp_basicsize*/
1599 field_dealloc
, /*tp_dealloc*/
1606 0, /*tp_as_sequence*/
1607 0, /*tp_as_mapping*/
1614 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1615 "GDB field object", /* tp_doc */
1616 0, /* tp_traverse */
1618 0, /* tp_richcompare */
1619 0, /* tp_weaklistoffset */
1621 0, /* tp_iternext */
1624 field_object_getset
, /* tp_getset */
1627 0, /* tp_descr_get */
1628 0, /* tp_descr_set */
1629 offsetof (field_object
, dict
), /* tp_dictoffset */
1635 PyTypeObject type_iterator_object_type
= {
1636 PyVarObject_HEAD_INIT (NULL
, 0)
1637 "gdb.TypeIterator", /*tp_name*/
1638 sizeof (typy_iterator_object
), /*tp_basicsize*/
1640 typy_iterator_dealloc
, /*tp_dealloc*/
1647 0, /*tp_as_sequence*/
1648 0, /*tp_as_mapping*/
1655 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1656 "GDB type iterator object", /*tp_doc */
1659 0, /*tp_richcompare */
1660 0, /*tp_weaklistoffset */
1661 typy_iterator_iter
, /*tp_iter */
1662 typy_iterator_iternext
, /*tp_iternext */