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
;
1052 if (!gdb_python_initialized
)
1055 /* This prevents another thread from freeing the objects we're
1057 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1059 copied_types
= create_copied_types_hash (objfile
);
1063 type_object
*next
= obj
->next
;
1065 htab_empty (copied_types
);
1067 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1075 htab_delete (copied_types
);
1079 set_type (type_object
*obj
, struct type
*type
)
1083 if (type
&& TYPE_OBJFILE (type
))
1085 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1087 obj
->next
= ((struct pyty_type_object
*)
1088 objfile_data (objfile
, typy_objfile_data_key
));
1090 obj
->next
->prev
= obj
;
1091 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1098 typy_dealloc (PyObject
*obj
)
1100 type_object
*type
= (type_object
*) obj
;
1103 type
->prev
->next
= type
->next
;
1104 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1106 /* Must reset head of list. */
1107 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1110 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1113 type
->next
->prev
= type
->prev
;
1115 Py_TYPE (type
)->tp_free (type
);
1118 /* Return number of fields ("length" of the field dictionary). */
1121 typy_length (PyObject
*self
)
1123 struct type
*type
= ((type_object
*) self
)->type
;
1125 type
= typy_get_composite (type
);
1129 return TYPE_NFIELDS (type
);
1132 /* Implements boolean evaluation of gdb.Type. Handle this like other
1133 Python objects that don't have a meaningful truth value -- all
1137 typy_nonzero (PyObject
*self
)
1142 /* Return optimized out value of this type. */
1145 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1147 struct type
*type
= ((type_object
*) self
)->type
;
1149 return value_to_value_object (allocate_optimized_out_value (type
));
1152 /* Return a gdb.Field object for the field named by the argument. */
1155 typy_getitem (PyObject
*self
, PyObject
*key
)
1157 struct type
*type
= ((type_object
*) self
)->type
;
1160 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1164 /* We want just fields of this type, not of base types, so instead of
1165 using lookup_struct_elt_type, portions of that function are
1168 type
= typy_get_composite (type
);
1172 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1174 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1176 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1178 return convert_field (type
, i
);
1181 PyErr_SetObject (PyExc_KeyError
, key
);
1185 /* Implement the "get" method on the type object. This is the
1186 same as getitem if the key is present, but returns the supplied
1187 default value or None if the key is not found. */
1190 typy_get (PyObject
*self
, PyObject
*args
)
1192 PyObject
*key
, *defval
= Py_None
, *result
;
1194 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1197 result
= typy_getitem (self
, key
);
1201 /* typy_getitem returned error status. If the exception is
1202 KeyError, clear the exception status and return the defval
1203 instead. Otherwise return the exception unchanged. */
1204 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1212 /* Implement the "has_key" method on the type object. */
1215 typy_has_key (PyObject
*self
, PyObject
*args
)
1217 struct type
*type
= ((type_object
*) self
)->type
;
1221 if (!PyArg_ParseTuple (args
, "s", &field
))
1224 /* We want just fields of this type, not of base types, so instead of
1225 using lookup_struct_elt_type, portions of that function are
1228 type
= typy_get_composite (type
);
1232 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1234 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1236 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1242 /* Make an iterator object to iterate over keys, values, or items. */
1245 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1247 typy_iterator_object
*typy_iter_obj
;
1249 /* Check that "self" is a structure or union type. */
1250 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1253 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1254 &type_iterator_object_type
);
1255 if (typy_iter_obj
== NULL
)
1258 typy_iter_obj
->field
= 0;
1259 typy_iter_obj
->kind
= kind
;
1261 typy_iter_obj
->source
= (type_object
*) self
;
1263 return (PyObject
*) typy_iter_obj
;
1266 /* iteritems() method. */
1269 typy_iteritems (PyObject
*self
, PyObject
*args
)
1271 return typy_make_iter (self
, iter_items
);
1274 /* iterkeys() method. */
1277 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1279 return typy_make_iter (self
, iter_keys
);
1282 /* Iterating over the class, same as iterkeys except for the function
1286 typy_iter (PyObject
*self
)
1288 return typy_make_iter (self
, iter_keys
);
1291 /* itervalues() method. */
1294 typy_itervalues (PyObject
*self
, PyObject
*args
)
1296 return typy_make_iter (self
, iter_values
);
1299 /* Return a reference to the type iterator. */
1302 typy_iterator_iter (PyObject
*self
)
1308 /* Return the next field in the iteration through the list of fields
1312 typy_iterator_iternext (PyObject
*self
)
1314 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1315 struct type
*type
= iter_obj
->source
->type
;
1318 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1320 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1330 typy_iterator_dealloc (PyObject
*obj
)
1332 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1334 Py_DECREF (iter_obj
->source
);
1337 /* Create a new Type referring to TYPE. */
1339 type_to_type_object (struct type
*type
)
1341 type_object
*type_obj
;
1343 type_obj
= PyObject_New (type_object
, &type_object_type
);
1345 set_type (type_obj
, type
);
1347 return (PyObject
*) type_obj
;
1351 type_object_to_type (PyObject
*obj
)
1353 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1355 return ((type_object
*) obj
)->type
;
1360 /* Implementation of gdb.lookup_type. */
1362 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1364 static char *keywords
[] = { "name", "block", NULL
};
1365 const char *type_name
= NULL
;
1366 struct type
*type
= NULL
;
1367 PyObject
*block_obj
= NULL
;
1368 const struct block
*block
= NULL
;
1370 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1371 &type_name
, &block_obj
))
1376 block
= block_object_to_block (block_obj
);
1379 PyErr_SetString (PyExc_RuntimeError
,
1380 _("'block' argument must be a Block."));
1385 type
= typy_lookup_typename (type_name
, block
);
1389 return (PyObject
*) type_to_type_object (type
);
1393 gdbpy_initialize_types (void)
1397 typy_objfile_data_key
1398 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1400 if (PyType_Ready (&type_object_type
) < 0)
1402 if (PyType_Ready (&field_object_type
) < 0)
1404 if (PyType_Ready (&type_iterator_object_type
) < 0)
1407 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1409 if (PyModule_AddIntConstant (gdb_module
,
1410 /* Cast needed for Python 2.4. */
1411 (char *) pyty_codes
[i
].name
,
1412 pyty_codes
[i
].code
) < 0)
1416 if (gdb_pymodule_addobject (gdb_module
, "Type",
1417 (PyObject
*) &type_object_type
) < 0)
1420 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1421 (PyObject
*) &type_iterator_object_type
) < 0)
1424 return gdb_pymodule_addobject (gdb_module
, "Field",
1425 (PyObject
*) &field_object_type
);
1430 static PyGetSetDef type_object_getset
[] =
1432 { "code", typy_get_code
, NULL
,
1433 "The code for this type.", NULL
},
1434 { "name", typy_get_name
, NULL
,
1435 "The name for this type, or None.", NULL
},
1436 { "sizeof", typy_get_sizeof
, NULL
,
1437 "The size of this type, in bytes.", NULL
},
1438 { "tag", typy_get_tag
, NULL
,
1439 "The tag name for this type, or None.", NULL
},
1443 static PyMethodDef type_object_methods
[] =
1445 { "array", typy_array
, METH_VARARGS
,
1446 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1447 Return a type which represents an array of objects of this type.\n\
1448 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1449 If LOW_BOUND is omitted, a value of zero is used." },
1450 { "vector", typy_vector
, METH_VARARGS
,
1451 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1452 Return a type which represents a vector of objects of this type.\n\
1453 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1454 If LOW_BOUND is omitted, a value of zero is used.\n\
1455 Vectors differ from arrays in that if the current language has C-style\n\
1456 arrays, vectors don't decay to a pointer to the first element.\n\
1457 They are first class values." },
1458 { "__contains__", typy_has_key
, METH_VARARGS
,
1459 "T.__contains__(k) -> True if T has a field named k, else False" },
1460 { "const", typy_const
, METH_NOARGS
,
1461 "const () -> Type\n\
1462 Return a const variant of this type." },
1463 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1464 "optimized_out() -> Value\n\
1465 Return optimized out value of this type." },
1466 { "fields", typy_fields
, METH_NOARGS
,
1467 "fields () -> list\n\
1468 Return a list holding all the fields of this type.\n\
1469 Each field is a gdb.Field object." },
1470 { "get", typy_get
, METH_VARARGS
,
1471 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1472 otherwise returns default, if supplied, or None if not." },
1473 { "has_key", typy_has_key
, METH_VARARGS
,
1474 "T.has_key(k) -> True if T has a field named k, else False" },
1475 { "items", typy_items
, METH_NOARGS
,
1476 "items () -> list\n\
1477 Return a list of (name, field) pairs of this type.\n\
1478 Each field is a gdb.Field object." },
1479 { "iteritems", typy_iteritems
, METH_NOARGS
,
1480 "iteritems () -> an iterator over the (name, field)\n\
1481 pairs of this type. Each field is a gdb.Field object." },
1482 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1483 "iterkeys () -> an iterator over the field names of this type." },
1484 { "itervalues", typy_itervalues
, METH_NOARGS
,
1485 "itervalues () -> an iterator over the fields of this type.\n\
1486 Each field is a gdb.Field object." },
1487 { "keys", typy_field_names
, METH_NOARGS
,
1489 Return a list holding all the fields names of this type." },
1490 { "pointer", typy_pointer
, METH_NOARGS
,
1491 "pointer () -> Type\n\
1492 Return a type of pointer to this type." },
1493 { "range", typy_range
, METH_NOARGS
,
1494 "range () -> tuple\n\
1495 Return a tuple containing the lower and upper range for this type."},
1496 { "reference", typy_reference
, METH_NOARGS
,
1497 "reference () -> Type\n\
1498 Return a type of reference to this type." },
1499 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1500 "strip_typedefs () -> Type\n\
1501 Return a type formed by stripping this type of all typedefs."},
1502 { "target", typy_target
, METH_NOARGS
,
1503 "target () -> Type\n\
1504 Return the target type of this type." },
1505 { "template_argument", typy_template_argument
, METH_VARARGS
,
1506 "template_argument (arg, [block]) -> Type\n\
1507 Return the type of a template argument." },
1508 { "unqualified", typy_unqualified
, METH_NOARGS
,
1509 "unqualified () -> Type\n\
1510 Return a variant of this type without const or volatile attributes." },
1511 { "values", typy_values
, METH_NOARGS
,
1512 "values () -> list\n\
1513 Return a list holding all the fields of this type.\n\
1514 Each field is a gdb.Field object." },
1515 { "volatile", typy_volatile
, METH_NOARGS
,
1516 "volatile () -> Type\n\
1517 Return a volatile variant of this type" },
1521 static PyNumberMethods type_object_as_number
= {
1523 NULL
, /* nb_subtract */
1524 NULL
, /* nb_multiply */
1526 NULL
, /* nb_divide */
1528 NULL
, /* nb_remainder */
1529 NULL
, /* nb_divmod */
1530 NULL
, /* nb_power */
1531 NULL
, /* nb_negative */
1532 NULL
, /* nb_positive */
1533 NULL
, /* nb_absolute */
1534 typy_nonzero
, /* nb_nonzero */
1535 NULL
, /* nb_invert */
1536 NULL
, /* nb_lshift */
1537 NULL
, /* nb_rshift */
1543 NULL
, /* reserved */
1545 NULL
, /* nb_coerce */
1549 NULL
, /* nb_float */
1556 static PyMappingMethods typy_mapping
= {
1559 NULL
/* no "set" method */
1562 PyTypeObject type_object_type
=
1564 PyVarObject_HEAD_INIT (NULL
, 0)
1565 "gdb.Type", /*tp_name*/
1566 sizeof (type_object
), /*tp_basicsize*/
1568 typy_dealloc
, /*tp_dealloc*/
1574 &type_object_as_number
, /*tp_as_number*/
1575 0, /*tp_as_sequence*/
1576 &typy_mapping
, /*tp_as_mapping*/
1579 typy_str
, /*tp_str*/
1583 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1584 "GDB type object", /* tp_doc */
1585 0, /* tp_traverse */
1587 typy_richcompare
, /* tp_richcompare */
1588 0, /* tp_weaklistoffset */
1589 typy_iter
, /* tp_iter */
1590 0, /* tp_iternext */
1591 type_object_methods
, /* tp_methods */
1593 type_object_getset
, /* tp_getset */
1596 0, /* tp_descr_get */
1597 0, /* tp_descr_set */
1598 0, /* tp_dictoffset */
1604 static PyGetSetDef field_object_getset
[] =
1606 { "__dict__", gdb_py_generic_dict
, NULL
,
1607 "The __dict__ for this field.", &field_object_type
},
1611 PyTypeObject field_object_type
=
1613 PyVarObject_HEAD_INIT (NULL
, 0)
1614 "gdb.Field", /*tp_name*/
1615 sizeof (field_object
), /*tp_basicsize*/
1617 field_dealloc
, /*tp_dealloc*/
1624 0, /*tp_as_sequence*/
1625 0, /*tp_as_mapping*/
1632 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1633 "GDB field object", /* tp_doc */
1634 0, /* tp_traverse */
1636 0, /* tp_richcompare */
1637 0, /* tp_weaklistoffset */
1639 0, /* tp_iternext */
1642 field_object_getset
, /* tp_getset */
1645 0, /* tp_descr_get */
1646 0, /* tp_descr_set */
1647 offsetof (field_object
, dict
), /* tp_dictoffset */
1653 PyTypeObject type_iterator_object_type
= {
1654 PyVarObject_HEAD_INIT (NULL
, 0)
1655 "gdb.TypeIterator", /*tp_name*/
1656 sizeof (typy_iterator_object
), /*tp_basicsize*/
1658 typy_iterator_dealloc
, /*tp_dealloc*/
1665 0, /*tp_as_sequence*/
1666 0, /*tp_as_mapping*/
1673 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1674 "GDB type iterator object", /*tp_doc */
1677 0, /*tp_richcompare */
1678 0, /*tp_weaklistoffset */
1679 typy_iterator_iter
, /*tp_iter */
1680 typy_iterator_iternext
, /*tp_iternext */