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 field_object
*result
= PyObject_New (field_object
, &field_object_type
);
137 result
->dict
= PyDict_New ();
144 return (PyObject
*) result
;
149 /* Return true if OBJ is of type gdb.Field, false otherwise. */
152 gdbpy_is_field (PyObject
*obj
)
154 return PyObject_TypeCheck (obj
, &field_object_type
);
157 /* Return the code for this type. */
159 typy_get_code (PyObject
*self
, void *closure
)
161 struct type
*type
= ((type_object
*) self
)->type
;
163 return PyInt_FromLong (TYPE_CODE (type
));
166 /* Helper function for typy_fields which converts a single field to a
167 gdb.Field object. Returns NULL on error. */
170 convert_field (struct type
*type
, int field
)
172 gdbpy_ref
result (field_new ());
177 gdbpy_ref
arg (type_to_type_object (type
));
180 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
183 if (!field_is_static (&TYPE_FIELD (type
, field
)))
185 const char *attrstring
;
187 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
189 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
191 attrstring
= "enumval";
195 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
197 attrstring
= "bitpos";
203 /* At least python-2.4 had the second parameter non-const. */
204 if (PyObject_SetAttrString (result
.get (), (char *) attrstring
,
210 if (TYPE_FIELD_NAME (type
, field
))
212 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
214 if (field_name
[0] != '\0')
216 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
224 Py_INCREF (arg
.get ());
226 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
229 arg
.reset (TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
);
230 Py_INCREF (arg
.get ());
231 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
234 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
235 arg
.reset (field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
);
237 arg
.reset (Py_False
);
238 Py_INCREF (arg
.get ());
239 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
242 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
245 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
248 /* A field can have a NULL type in some situations. */
249 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
252 Py_INCREF (arg
.get ());
255 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
258 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
261 return result
.release ();
264 /* Helper function to return the name of a field, as a gdb.Field object.
265 If the field doesn't have a name, None is returned. */
268 field_name (struct type
*type
, int field
)
272 if (TYPE_FIELD_NAME (type
, field
))
273 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
282 /* Helper function for Type standard mapping methods. Returns a
283 Python object for field i of the type. "kind" specifies what to
284 return: the name of the field, a gdb.Field object corresponding to
285 the field, or a tuple consisting of field name and gdb.Field
289 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
295 gdbpy_ref
key (field_name (type
, i
));
298 gdbpy_ref
value (convert_field (type
, i
));
301 gdbpy_ref
item (PyTuple_New (2));
304 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
305 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
306 return item
.release ();
309 return field_name (type
, i
);
311 return convert_field (type
, i
);
313 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
316 /* Return a sequence of all field names, fields, or (name, field) pairs.
317 Each field is a gdb.Field object. */
320 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
322 PyObject
*py_type
= self
;
323 PyObject
*result
= NULL
, *iter
= NULL
;
324 struct type
*type
= ((type_object
*) py_type
)->type
;
325 struct type
*checked_type
= type
;
329 checked_type
= check_typedef (checked_type
);
331 CATCH (except
, RETURN_MASK_ALL
)
333 GDB_PY_HANDLE_EXCEPTION (except
);
337 if (checked_type
!= type
)
338 py_type
= type_to_type_object (checked_type
);
339 iter
= typy_make_iter (py_type
, kind
);
340 if (checked_type
!= type
)
342 /* Need to wrap this in braces because Py_DECREF isn't wrapped
343 in a do{}while(0). */
348 result
= PySequence_List (iter
);
355 /* Return a sequence of all fields. Each field is a gdb.Field object. */
358 typy_values (PyObject
*self
, PyObject
*args
)
360 return typy_fields_items (self
, iter_values
);
363 /* Return a sequence of all fields. Each field is a gdb.Field object.
364 This method is similar to typy_values, except where the supplied
365 gdb.Type is an array, in which case it returns a list of one entry
366 which is a gdb.Field object for a range (the array bounds). */
369 typy_fields (PyObject
*self
, PyObject
*args
)
371 struct type
*type
= ((type_object
*) self
)->type
;
373 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
374 return typy_fields_items (self
, iter_values
);
376 /* Array type. Handle this as a special case because the common
377 machinery wants struct or union or enum types. Build a list of
378 one entry which is the range for the array. */
379 gdbpy_ref
r (convert_field (type
, 0));
383 return Py_BuildValue ("[O]", r
.get ());
386 /* Return a sequence of all field names. Each field is a gdb.Field object. */
389 typy_field_names (PyObject
*self
, PyObject
*args
)
391 return typy_fields_items (self
, iter_keys
);
394 /* Return a sequence of all (name, fields) pairs. Each field is a
398 typy_items (PyObject
*self
, PyObject
*args
)
400 return typy_fields_items (self
, iter_items
);
403 /* Return the type's name, or None. */
406 typy_get_name (PyObject
*self
, void *closure
)
408 struct type
*type
= ((type_object
*) self
)->type
;
410 if (TYPE_NAME (type
) == NULL
)
412 return PyString_FromString (TYPE_NAME (type
));
415 /* Return the type's tag, or None. */
417 typy_get_tag (PyObject
*self
, void *closure
)
419 struct type
*type
= ((type_object
*) self
)->type
;
421 if (!TYPE_TAG_NAME (type
))
423 return PyString_FromString (TYPE_TAG_NAME (type
));
426 /* Return the type, stripped of typedefs. */
428 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
430 struct type
*type
= ((type_object
*) self
)->type
;
434 type
= check_typedef (type
);
436 CATCH (except
, RETURN_MASK_ALL
)
438 GDB_PY_HANDLE_EXCEPTION (except
);
442 return type_to_type_object (type
);
445 /* Strip typedefs and pointers/reference from a type. Then check that
446 it is a struct, union, or enum type. If not, raise TypeError. */
449 typy_get_composite (struct type
*type
)
456 type
= check_typedef (type
);
458 CATCH (except
, RETURN_MASK_ALL
)
460 GDB_PY_HANDLE_EXCEPTION (except
);
464 if (TYPE_CODE (type
) != TYPE_CODE_PTR
465 && TYPE_CODE (type
) != TYPE_CODE_REF
)
467 type
= TYPE_TARGET_TYPE (type
);
470 /* If this is not a struct, union, or enum type, raise TypeError
472 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
473 && TYPE_CODE (type
) != TYPE_CODE_UNION
474 && TYPE_CODE (type
) != TYPE_CODE_ENUM
475 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
477 PyErr_SetString (PyExc_TypeError
,
478 "Type is not a structure, union, enum, or function type.");
485 /* Helper for typy_array and typy_vector. */
488 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
491 PyObject
*n2_obj
= NULL
;
492 struct type
*array
= NULL
;
493 struct type
*type
= ((type_object
*) self
)->type
;
495 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
500 if (!PyInt_Check (n2_obj
))
502 PyErr_SetString (PyExc_RuntimeError
,
503 _("Array bound must be an integer"));
507 if (! gdb_py_int_as_long (n2_obj
, &n2
))
516 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
518 PyErr_SetString (PyExc_ValueError
,
519 _("Array length must not be negative"));
525 array
= lookup_array_range_type (type
, n1
, n2
);
527 make_vector_type (array
);
529 CATCH (except
, RETURN_MASK_ALL
)
531 GDB_PY_HANDLE_EXCEPTION (except
);
535 return type_to_type_object (array
);
538 /* Return an array type. */
541 typy_array (PyObject
*self
, PyObject
*args
)
543 return typy_array_1 (self
, args
, 0);
546 /* Return a vector type. */
549 typy_vector (PyObject
*self
, PyObject
*args
)
551 return typy_array_1 (self
, args
, 1);
554 /* Return a Type object which represents a pointer to SELF. */
556 typy_pointer (PyObject
*self
, PyObject
*args
)
558 struct type
*type
= ((type_object
*) self
)->type
;
562 type
= lookup_pointer_type (type
);
564 CATCH (except
, RETURN_MASK_ALL
)
566 GDB_PY_HANDLE_EXCEPTION (except
);
570 return type_to_type_object (type
);
573 /* Return the range of a type represented by SELF. The return type is
574 a tuple. The first element of the tuple contains the low bound,
575 while the second element of the tuple contains the high bound. */
577 typy_range (PyObject
*self
, PyObject
*args
)
579 struct type
*type
= ((type_object
*) self
)->type
;
580 /* Initialize these to appease GCC warnings. */
581 LONGEST low
= 0, high
= 0;
583 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
584 && TYPE_CODE (type
) != TYPE_CODE_STRING
585 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
587 PyErr_SetString (PyExc_RuntimeError
,
588 _("This type does not have a range."));
592 switch (TYPE_CODE (type
))
594 case TYPE_CODE_ARRAY
:
595 case TYPE_CODE_STRING
:
596 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
597 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
599 case TYPE_CODE_RANGE
:
600 low
= TYPE_LOW_BOUND (type
);
601 high
= TYPE_HIGH_BOUND (type
);
605 gdbpy_ref
low_bound (PyLong_FromLong (low
));
606 if (low_bound
== NULL
)
609 gdbpy_ref
high_bound (PyLong_FromLong (high
));
610 if (high_bound
== NULL
)
613 gdbpy_ref
result (PyTuple_New (2));
617 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
618 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
620 return result
.release ();
623 /* Return a Type object which represents a reference to SELF. */
625 typy_reference (PyObject
*self
, PyObject
*args
)
627 struct type
*type
= ((type_object
*) self
)->type
;
631 type
= lookup_reference_type (type
);
633 CATCH (except
, RETURN_MASK_ALL
)
635 GDB_PY_HANDLE_EXCEPTION (except
);
639 return type_to_type_object (type
);
642 /* Return a Type object which represents the target type of SELF. */
644 typy_target (PyObject
*self
, PyObject
*args
)
646 struct type
*type
= ((type_object
*) self
)->type
;
648 if (!TYPE_TARGET_TYPE (type
))
650 PyErr_SetString (PyExc_RuntimeError
,
651 _("Type does not have a target."));
655 return type_to_type_object (TYPE_TARGET_TYPE (type
));
658 /* Return a const-qualified type variant. */
660 typy_const (PyObject
*self
, PyObject
*args
)
662 struct type
*type
= ((type_object
*) self
)->type
;
666 type
= make_cv_type (1, 0, type
, NULL
);
668 CATCH (except
, RETURN_MASK_ALL
)
670 GDB_PY_HANDLE_EXCEPTION (except
);
674 return type_to_type_object (type
);
677 /* Return a volatile-qualified type variant. */
679 typy_volatile (PyObject
*self
, PyObject
*args
)
681 struct type
*type
= ((type_object
*) self
)->type
;
685 type
= make_cv_type (0, 1, type
, NULL
);
687 CATCH (except
, RETURN_MASK_ALL
)
689 GDB_PY_HANDLE_EXCEPTION (except
);
693 return type_to_type_object (type
);
696 /* Return an unqualified type variant. */
698 typy_unqualified (PyObject
*self
, PyObject
*args
)
700 struct type
*type
= ((type_object
*) self
)->type
;
704 type
= make_cv_type (0, 0, type
, NULL
);
706 CATCH (except
, RETURN_MASK_ALL
)
708 GDB_PY_HANDLE_EXCEPTION (except
);
712 return type_to_type_object (type
);
715 /* Return the size of the type represented by SELF, in bytes. */
717 typy_get_sizeof (PyObject
*self
, void *closure
)
719 struct type
*type
= ((type_object
*) self
)->type
;
723 check_typedef (type
);
725 CATCH (except
, RETURN_MASK_ALL
)
730 /* Ignore exceptions. */
732 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
736 typy_lookup_typename (const char *type_name
, const struct block
*block
)
738 struct type
*type
= NULL
;
742 if (startswith (type_name
, "struct "))
743 type
= lookup_struct (type_name
+ 7, NULL
);
744 else if (startswith (type_name
, "union "))
745 type
= lookup_union (type_name
+ 6, NULL
);
746 else if (startswith (type_name
, "enum "))
747 type
= lookup_enum (type_name
+ 5, NULL
);
749 type
= lookup_typename (python_language
, python_gdbarch
,
750 type_name
, block
, 0);
752 CATCH (except
, RETURN_MASK_ALL
)
754 GDB_PY_HANDLE_EXCEPTION (except
);
762 typy_lookup_type (struct demangle_component
*demangled
,
763 const struct block
*block
)
765 struct type
*type
, *rtype
= NULL
;
766 char *type_name
= NULL
;
767 enum demangle_component_type demangled_type
;
769 /* Save the type: typy_lookup_type() may (indirectly) overwrite
770 memory pointed by demangled. */
771 demangled_type
= demangled
->type
;
773 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
774 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
775 || demangled_type
== DEMANGLE_COMPONENT_CONST
776 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
778 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
784 /* If the demangled_type matches with one of the types
785 below, run the corresponding function and save the type
786 to return later. We cannot just return here as we are in
787 an exception handler. */
788 switch (demangled_type
)
790 case DEMANGLE_COMPONENT_REFERENCE
:
791 rtype
= lookup_reference_type (type
);
793 case DEMANGLE_COMPONENT_POINTER
:
794 rtype
= lookup_pointer_type (type
);
796 case DEMANGLE_COMPONENT_CONST
:
797 rtype
= make_cv_type (1, 0, type
, NULL
);
799 case DEMANGLE_COMPONENT_VOLATILE
:
800 rtype
= make_cv_type (0, 1, type
, NULL
);
804 CATCH (except
, RETURN_MASK_ALL
)
806 GDB_PY_HANDLE_EXCEPTION (except
);
811 /* If we have a type from the switch statement above, just return
816 /* We don't have a type, so lookup the type. */
817 type_name
= cp_comp_to_string (demangled
, 10);
818 type
= typy_lookup_typename (type_name
, block
);
824 /* This is a helper function for typy_template_argument that is used
825 when the type does not have template symbols attached. It works by
826 parsing the type name. This happens with compilers, like older
827 versions of GCC, that do not emit DW_TAG_template_*. */
830 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
834 struct demangle_component
*demangled
;
835 struct demangle_parse_info
*info
= NULL
;
837 struct type
*argtype
;
838 struct cleanup
*cleanup
;
840 if (TYPE_NAME (type
) == NULL
)
842 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
848 /* Note -- this is not thread-safe. */
849 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
851 CATCH (except
, RETURN_MASK_ALL
)
853 GDB_PY_HANDLE_EXCEPTION (except
);
859 PyErr_SetString (PyExc_RuntimeError
, err
);
862 demangled
= info
->tree
;
863 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
865 /* Strip off component names. */
866 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
867 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
868 demangled
= demangled
->u
.s_binary
.right
;
870 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
872 do_cleanups (cleanup
);
873 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
877 /* Skip from the template to the arguments. */
878 demangled
= demangled
->u
.s_binary
.right
;
880 for (i
= 0; demangled
&& i
< argno
; ++i
)
881 demangled
= demangled
->u
.s_binary
.right
;
885 do_cleanups (cleanup
);
886 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
891 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
892 do_cleanups (cleanup
);
896 return type_to_type_object (argtype
);
900 typy_template_argument (PyObject
*self
, PyObject
*args
)
903 struct type
*type
= ((type_object
*) self
)->type
;
904 const struct block
*block
= NULL
;
905 PyObject
*block_obj
= NULL
;
907 struct value
*val
= NULL
;
909 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
914 block
= block_object_to_block (block_obj
);
917 PyErr_SetString (PyExc_RuntimeError
,
918 _("Second argument must be block."));
925 type
= check_typedef (type
);
926 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
927 type
= check_typedef (TYPE_TARGET_TYPE (type
));
929 CATCH (except
, RETURN_MASK_ALL
)
931 GDB_PY_HANDLE_EXCEPTION (except
);
935 /* We might not have DW_TAG_template_*, so try to parse the type's
936 name. This is inefficient if we do not have a template type --
937 but that is going to wind up as an error anyhow. */
938 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
939 return typy_legacy_template_argument (type
, block
, argno
);
941 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
943 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
948 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
949 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
950 return type_to_type_object (SYMBOL_TYPE (sym
));
951 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
953 PyErr_Format (PyExc_RuntimeError
,
954 _("Template argument is optimized out"));
960 val
= value_of_variable (sym
, block
);
962 CATCH (except
, RETURN_MASK_ALL
)
964 GDB_PY_HANDLE_EXCEPTION (except
);
968 return value_to_value_object (val
);
972 typy_str (PyObject
*self
)
979 struct cleanup
*old_chain
;
982 stb
= mem_fileopen ();
983 old_chain
= make_cleanup_ui_file_delete (stb
);
985 LA_PRINT_TYPE (type_object_to_type (self
), "", stb
, -1, 0,
986 &type_print_raw_options
);
988 thetype
= ui_file_as_string (stb
);
989 do_cleanups (old_chain
);
991 CATCH (except
, RETURN_MASK_ALL
)
993 GDB_PY_HANDLE_EXCEPTION (except
);
997 result
= PyUnicode_Decode (thetype
.c_str (), thetype
.length (),
998 host_charset (), NULL
);
1003 /* Implement the richcompare method. */
1006 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1009 struct type
*type1
= type_object_to_type (self
);
1010 struct type
*type2
= type_object_to_type (other
);
1012 /* We can only compare ourselves to another Type object, and only
1013 for equality or inequality. */
1014 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1016 Py_INCREF (Py_NotImplemented
);
1017 return Py_NotImplemented
;
1026 result
= types_deeply_equal (type1
, type2
);
1028 CATCH (except
, RETURN_MASK_ALL
)
1030 /* If there is a GDB exception, a comparison is not capable
1031 (or trusted), so exit. */
1032 GDB_PY_HANDLE_EXCEPTION (except
);
1037 if (op
== (result
? Py_EQ
: Py_NE
))
1044 static const struct objfile_data
*typy_objfile_data_key
;
1047 save_objfile_types (struct objfile
*objfile
, void *datum
)
1049 type_object
*obj
= (type_object
*) datum
;
1050 htab_t copied_types
;
1051 struct cleanup
*cleanup
;
1053 if (!gdb_python_initialized
)
1056 /* This prevents another thread from freeing the objects we're
1058 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1060 copied_types
= create_copied_types_hash (objfile
);
1064 type_object
*next
= obj
->next
;
1066 htab_empty (copied_types
);
1068 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1076 htab_delete (copied_types
);
1078 do_cleanups (cleanup
);
1082 set_type (type_object
*obj
, struct type
*type
)
1086 if (type
&& TYPE_OBJFILE (type
))
1088 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1090 obj
->next
= ((struct pyty_type_object
*)
1091 objfile_data (objfile
, typy_objfile_data_key
));
1093 obj
->next
->prev
= obj
;
1094 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1101 typy_dealloc (PyObject
*obj
)
1103 type_object
*type
= (type_object
*) obj
;
1106 type
->prev
->next
= type
->next
;
1107 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1109 /* Must reset head of list. */
1110 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1113 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1116 type
->next
->prev
= type
->prev
;
1118 Py_TYPE (type
)->tp_free (type
);
1121 /* Return number of fields ("length" of the field dictionary). */
1124 typy_length (PyObject
*self
)
1126 struct type
*type
= ((type_object
*) self
)->type
;
1128 type
= typy_get_composite (type
);
1132 return TYPE_NFIELDS (type
);
1135 /* Implements boolean evaluation of gdb.Type. Handle this like other
1136 Python objects that don't have a meaningful truth value -- all
1140 typy_nonzero (PyObject
*self
)
1145 /* Return optimized out value of this type. */
1148 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1150 struct type
*type
= ((type_object
*) self
)->type
;
1152 return value_to_value_object (allocate_optimized_out_value (type
));
1155 /* Return a gdb.Field object for the field named by the argument. */
1158 typy_getitem (PyObject
*self
, PyObject
*key
)
1160 struct type
*type
= ((type_object
*) self
)->type
;
1163 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1167 /* We want just fields of this type, not of base types, so instead of
1168 using lookup_struct_elt_type, portions of that function are
1171 type
= typy_get_composite (type
);
1175 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1177 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1179 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1181 return convert_field (type
, i
);
1184 PyErr_SetObject (PyExc_KeyError
, key
);
1188 /* Implement the "get" method on the type object. This is the
1189 same as getitem if the key is present, but returns the supplied
1190 default value or None if the key is not found. */
1193 typy_get (PyObject
*self
, PyObject
*args
)
1195 PyObject
*key
, *defval
= Py_None
, *result
;
1197 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1200 result
= typy_getitem (self
, key
);
1204 /* typy_getitem returned error status. If the exception is
1205 KeyError, clear the exception status and return the defval
1206 instead. Otherwise return the exception unchanged. */
1207 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1215 /* Implement the "has_key" method on the type object. */
1218 typy_has_key (PyObject
*self
, PyObject
*args
)
1220 struct type
*type
= ((type_object
*) self
)->type
;
1224 if (!PyArg_ParseTuple (args
, "s", &field
))
1227 /* We want just fields of this type, not of base types, so instead of
1228 using lookup_struct_elt_type, portions of that function are
1231 type
= typy_get_composite (type
);
1235 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1237 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1239 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1245 /* Make an iterator object to iterate over keys, values, or items. */
1248 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1250 typy_iterator_object
*typy_iter_obj
;
1252 /* Check that "self" is a structure or union type. */
1253 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1256 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1257 &type_iterator_object_type
);
1258 if (typy_iter_obj
== NULL
)
1261 typy_iter_obj
->field
= 0;
1262 typy_iter_obj
->kind
= kind
;
1264 typy_iter_obj
->source
= (type_object
*) self
;
1266 return (PyObject
*) typy_iter_obj
;
1269 /* iteritems() method. */
1272 typy_iteritems (PyObject
*self
, PyObject
*args
)
1274 return typy_make_iter (self
, iter_items
);
1277 /* iterkeys() method. */
1280 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1282 return typy_make_iter (self
, iter_keys
);
1285 /* Iterating over the class, same as iterkeys except for the function
1289 typy_iter (PyObject
*self
)
1291 return typy_make_iter (self
, iter_keys
);
1294 /* itervalues() method. */
1297 typy_itervalues (PyObject
*self
, PyObject
*args
)
1299 return typy_make_iter (self
, iter_values
);
1302 /* Return a reference to the type iterator. */
1305 typy_iterator_iter (PyObject
*self
)
1311 /* Return the next field in the iteration through the list of fields
1315 typy_iterator_iternext (PyObject
*self
)
1317 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1318 struct type
*type
= iter_obj
->source
->type
;
1321 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1323 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1333 typy_iterator_dealloc (PyObject
*obj
)
1335 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1337 Py_DECREF (iter_obj
->source
);
1340 /* Create a new Type referring to TYPE. */
1342 type_to_type_object (struct type
*type
)
1344 type_object
*type_obj
;
1346 type_obj
= PyObject_New (type_object
, &type_object_type
);
1348 set_type (type_obj
, type
);
1350 return (PyObject
*) type_obj
;
1354 type_object_to_type (PyObject
*obj
)
1356 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1358 return ((type_object
*) obj
)->type
;
1363 /* Implementation of gdb.lookup_type. */
1365 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1367 static char *keywords
[] = { "name", "block", NULL
};
1368 const char *type_name
= NULL
;
1369 struct type
*type
= NULL
;
1370 PyObject
*block_obj
= NULL
;
1371 const struct block
*block
= NULL
;
1373 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1374 &type_name
, &block_obj
))
1379 block
= block_object_to_block (block_obj
);
1382 PyErr_SetString (PyExc_RuntimeError
,
1383 _("'block' argument must be a Block."));
1388 type
= typy_lookup_typename (type_name
, block
);
1392 return (PyObject
*) type_to_type_object (type
);
1396 gdbpy_initialize_types (void)
1400 typy_objfile_data_key
1401 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1403 if (PyType_Ready (&type_object_type
) < 0)
1405 if (PyType_Ready (&field_object_type
) < 0)
1407 if (PyType_Ready (&type_iterator_object_type
) < 0)
1410 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1412 if (PyModule_AddIntConstant (gdb_module
,
1413 /* Cast needed for Python 2.4. */
1414 (char *) pyty_codes
[i
].name
,
1415 pyty_codes
[i
].code
) < 0)
1419 if (gdb_pymodule_addobject (gdb_module
, "Type",
1420 (PyObject
*) &type_object_type
) < 0)
1423 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1424 (PyObject
*) &type_iterator_object_type
) < 0)
1427 return gdb_pymodule_addobject (gdb_module
, "Field",
1428 (PyObject
*) &field_object_type
);
1433 static PyGetSetDef type_object_getset
[] =
1435 { "code", typy_get_code
, NULL
,
1436 "The code for this type.", NULL
},
1437 { "name", typy_get_name
, NULL
,
1438 "The name for this type, or None.", NULL
},
1439 { "sizeof", typy_get_sizeof
, NULL
,
1440 "The size of this type, in bytes.", NULL
},
1441 { "tag", typy_get_tag
, NULL
,
1442 "The tag name for this type, or None.", NULL
},
1446 static PyMethodDef type_object_methods
[] =
1448 { "array", typy_array
, METH_VARARGS
,
1449 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1450 Return a type which represents an array of objects of this type.\n\
1451 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1452 If LOW_BOUND is omitted, a value of zero is used." },
1453 { "vector", typy_vector
, METH_VARARGS
,
1454 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1455 Return a type which represents a vector of objects of this type.\n\
1456 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1457 If LOW_BOUND is omitted, a value of zero is used.\n\
1458 Vectors differ from arrays in that if the current language has C-style\n\
1459 arrays, vectors don't decay to a pointer to the first element.\n\
1460 They are first class values." },
1461 { "__contains__", typy_has_key
, METH_VARARGS
,
1462 "T.__contains__(k) -> True if T has a field named k, else False" },
1463 { "const", typy_const
, METH_NOARGS
,
1464 "const () -> Type\n\
1465 Return a const variant of this type." },
1466 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1467 "optimized_out() -> Value\n\
1468 Return optimized out value of this type." },
1469 { "fields", typy_fields
, METH_NOARGS
,
1470 "fields () -> list\n\
1471 Return a list holding all the fields of this type.\n\
1472 Each field is a gdb.Field object." },
1473 { "get", typy_get
, METH_VARARGS
,
1474 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1475 otherwise returns default, if supplied, or None if not." },
1476 { "has_key", typy_has_key
, METH_VARARGS
,
1477 "T.has_key(k) -> True if T has a field named k, else False" },
1478 { "items", typy_items
, METH_NOARGS
,
1479 "items () -> list\n\
1480 Return a list of (name, field) pairs of this type.\n\
1481 Each field is a gdb.Field object." },
1482 { "iteritems", typy_iteritems
, METH_NOARGS
,
1483 "iteritems () -> an iterator over the (name, field)\n\
1484 pairs of this type. Each field is a gdb.Field object." },
1485 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1486 "iterkeys () -> an iterator over the field names of this type." },
1487 { "itervalues", typy_itervalues
, METH_NOARGS
,
1488 "itervalues () -> an iterator over the fields of this type.\n\
1489 Each field is a gdb.Field object." },
1490 { "keys", typy_field_names
, METH_NOARGS
,
1492 Return a list holding all the fields names of this type." },
1493 { "pointer", typy_pointer
, METH_NOARGS
,
1494 "pointer () -> Type\n\
1495 Return a type of pointer to this type." },
1496 { "range", typy_range
, METH_NOARGS
,
1497 "range () -> tuple\n\
1498 Return a tuple containing the lower and upper range for this type."},
1499 { "reference", typy_reference
, METH_NOARGS
,
1500 "reference () -> Type\n\
1501 Return a type of reference to this type." },
1502 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1503 "strip_typedefs () -> Type\n\
1504 Return a type formed by stripping this type of all typedefs."},
1505 { "target", typy_target
, METH_NOARGS
,
1506 "target () -> Type\n\
1507 Return the target type of this type." },
1508 { "template_argument", typy_template_argument
, METH_VARARGS
,
1509 "template_argument (arg, [block]) -> Type\n\
1510 Return the type of a template argument." },
1511 { "unqualified", typy_unqualified
, METH_NOARGS
,
1512 "unqualified () -> Type\n\
1513 Return a variant of this type without const or volatile attributes." },
1514 { "values", typy_values
, METH_NOARGS
,
1515 "values () -> list\n\
1516 Return a list holding all the fields of this type.\n\
1517 Each field is a gdb.Field object." },
1518 { "volatile", typy_volatile
, METH_NOARGS
,
1519 "volatile () -> Type\n\
1520 Return a volatile variant of this type" },
1524 static PyNumberMethods type_object_as_number
= {
1526 NULL
, /* nb_subtract */
1527 NULL
, /* nb_multiply */
1529 NULL
, /* nb_divide */
1531 NULL
, /* nb_remainder */
1532 NULL
, /* nb_divmod */
1533 NULL
, /* nb_power */
1534 NULL
, /* nb_negative */
1535 NULL
, /* nb_positive */
1536 NULL
, /* nb_absolute */
1537 typy_nonzero
, /* nb_nonzero */
1538 NULL
, /* nb_invert */
1539 NULL
, /* nb_lshift */
1540 NULL
, /* nb_rshift */
1546 NULL
, /* reserved */
1548 NULL
, /* nb_coerce */
1552 NULL
, /* nb_float */
1559 static PyMappingMethods typy_mapping
= {
1562 NULL
/* no "set" method */
1565 PyTypeObject type_object_type
=
1567 PyVarObject_HEAD_INIT (NULL
, 0)
1568 "gdb.Type", /*tp_name*/
1569 sizeof (type_object
), /*tp_basicsize*/
1571 typy_dealloc
, /*tp_dealloc*/
1577 &type_object_as_number
, /*tp_as_number*/
1578 0, /*tp_as_sequence*/
1579 &typy_mapping
, /*tp_as_mapping*/
1582 typy_str
, /*tp_str*/
1586 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1587 "GDB type object", /* tp_doc */
1588 0, /* tp_traverse */
1590 typy_richcompare
, /* tp_richcompare */
1591 0, /* tp_weaklistoffset */
1592 typy_iter
, /* tp_iter */
1593 0, /* tp_iternext */
1594 type_object_methods
, /* tp_methods */
1596 type_object_getset
, /* tp_getset */
1599 0, /* tp_descr_get */
1600 0, /* tp_descr_set */
1601 0, /* tp_dictoffset */
1607 static PyGetSetDef field_object_getset
[] =
1609 { "__dict__", gdb_py_generic_dict
, NULL
,
1610 "The __dict__ for this field.", &field_object_type
},
1614 PyTypeObject field_object_type
=
1616 PyVarObject_HEAD_INIT (NULL
, 0)
1617 "gdb.Field", /*tp_name*/
1618 sizeof (field_object
), /*tp_basicsize*/
1620 field_dealloc
, /*tp_dealloc*/
1627 0, /*tp_as_sequence*/
1628 0, /*tp_as_mapping*/
1635 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1636 "GDB field object", /* tp_doc */
1637 0, /* tp_traverse */
1639 0, /* tp_richcompare */
1640 0, /* tp_weaklistoffset */
1642 0, /* tp_iternext */
1645 field_object_getset
, /* tp_getset */
1648 0, /* tp_descr_get */
1649 0, /* tp_descr_set */
1650 offsetof (field_object
, dict
), /* tp_dictoffset */
1656 PyTypeObject type_iterator_object_type
= {
1657 PyVarObject_HEAD_INIT (NULL
, 0)
1658 "gdb.TypeIterator", /*tp_name*/
1659 sizeof (typy_iterator_object
), /*tp_basicsize*/
1661 typy_iterator_dealloc
, /*tp_dealloc*/
1668 0, /*tp_as_sequence*/
1669 0, /*tp_as_mapping*/
1676 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1677 "GDB type iterator object", /*tp_doc */
1680 0, /*tp_richcompare */
1681 0, /*tp_weaklistoffset */
1682 typy_iterator_iter
, /*tp_iter */
1683 typy_iterator_iternext
, /*tp_iternext */