1 /* Python interface to types.
3 Copyright (C) 2008-2014 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 "exceptions.h"
23 #include "python-internal.h"
26 #include "cp-support.h"
31 #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 static PyTypeObject type_object_type
46 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
49 typedef struct pyty_field_object
53 /* Dictionary holding our attributes. */
57 static 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 static 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 PyObject
*result
= field_new ();
178 arg
= type_to_type_object (type
);
181 if (PyObject_SetAttrString (result
, "parent_type", arg
) < 0)
185 if (!field_is_static (&TYPE_FIELD (type
, field
)))
187 const char *attrstring
;
189 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
191 arg
= gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
, field
));
192 attrstring
= "enumval";
196 arg
= gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
, field
));
197 attrstring
= "bitpos";
203 /* At least python-2.4 had the second parameter non-const. */
204 if (PyObject_SetAttrString (result
, (char *) attrstring
, arg
) < 0)
209 if (TYPE_FIELD_NAME (type
, field
))
210 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
218 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
222 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
224 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
228 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
229 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
233 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
237 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
240 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
244 /* A field can have a NULL type in some situations. */
245 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
251 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
254 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
267 /* Helper function to return the name of a field, as a gdb.Field object.
268 If the field doesn't have a name, None is returned. */
271 field_name (struct type
*type
, int field
)
275 if (TYPE_FIELD_NAME (type
, field
))
276 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
285 /* Helper function for Type standard mapping methods. Returns a
286 Python object for field i of the type. "kind" specifies what to
287 return: the name of the field, a gdb.Field object corresponding to
288 the field, or a tuple consisting of field name and gdb.Field
292 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
294 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
299 key
= field_name (type
, i
);
302 value
= convert_field (type
, i
);
305 item
= PyTuple_New (2);
308 PyTuple_SET_ITEM (item
, 0, key
);
309 PyTuple_SET_ITEM (item
, 1, value
);
312 item
= field_name (type
, i
);
315 item
= convert_field (type
, i
);
318 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
329 /* Return a sequence of all field names, fields, or (name, field) pairs.
330 Each field is a gdb.Field object. */
333 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
335 PyObject
*py_type
= self
;
336 PyObject
*result
= NULL
, *iter
= NULL
;
337 volatile struct gdb_exception except
;
338 struct type
*type
= ((type_object
*) py_type
)->type
;
339 struct type
*checked_type
= type
;
341 TRY_CATCH (except
, RETURN_MASK_ALL
)
343 CHECK_TYPEDEF (checked_type
);
345 GDB_PY_HANDLE_EXCEPTION (except
);
347 if (checked_type
!= type
)
348 py_type
= type_to_type_object (checked_type
);
349 iter
= typy_make_iter (py_type
, kind
);
350 if (checked_type
!= type
)
352 /* Need to wrap this in braces because Py_DECREF isn't wrapped
353 in a do{}while(0). */
358 result
= PySequence_List (iter
);
365 /* Return a sequence of all fields. Each field is a gdb.Field object. */
368 typy_values (PyObject
*self
, PyObject
*args
)
370 return typy_fields_items (self
, iter_values
);
373 /* Return a sequence of all fields. Each field is a gdb.Field object.
374 This method is similar to typy_values, except where the supplied
375 gdb.Type is an array, in which case it returns a list of one entry
376 which is a gdb.Field object for a range (the array bounds). */
379 typy_fields (PyObject
*self
, PyObject
*args
)
381 struct type
*type
= ((type_object
*) self
)->type
;
384 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
385 return typy_fields_items (self
, iter_values
);
387 /* Array type. Handle this as a special case because the common
388 machinery wants struct or union or enum types. Build a list of
389 one entry which is the range for the array. */
390 r
= convert_field (type
, 0);
394 rl
= Py_BuildValue ("[O]", r
);
400 /* Return a sequence of all field names. Each field is a gdb.Field object. */
403 typy_field_names (PyObject
*self
, PyObject
*args
)
405 return typy_fields_items (self
, iter_keys
);
408 /* Return a sequence of all (name, fields) pairs. Each field is a
412 typy_items (PyObject
*self
, PyObject
*args
)
414 return typy_fields_items (self
, iter_items
);
417 /* Return the type's name, or None. */
420 typy_get_name (PyObject
*self
, void *closure
)
422 struct type
*type
= ((type_object
*) self
)->type
;
424 if (TYPE_NAME (type
) == NULL
)
426 return PyString_FromString (TYPE_NAME (type
));
429 /* Return the type's tag, or None. */
431 typy_get_tag (PyObject
*self
, void *closure
)
433 struct type
*type
= ((type_object
*) self
)->type
;
435 if (!TYPE_TAG_NAME (type
))
437 return PyString_FromString (TYPE_TAG_NAME (type
));
440 /* Return the type, stripped of typedefs. */
442 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
444 struct type
*type
= ((type_object
*) self
)->type
;
445 volatile struct gdb_exception except
;
447 TRY_CATCH (except
, RETURN_MASK_ALL
)
449 type
= check_typedef (type
);
451 GDB_PY_HANDLE_EXCEPTION (except
);
453 return type_to_type_object (type
);
456 /* Strip typedefs and pointers/reference from a type. Then check that
457 it is a struct, union, or enum type. If not, raise TypeError. */
460 typy_get_composite (struct type
*type
)
462 volatile struct gdb_exception except
;
466 TRY_CATCH (except
, RETURN_MASK_ALL
)
468 CHECK_TYPEDEF (type
);
470 GDB_PY_HANDLE_EXCEPTION (except
);
472 if (TYPE_CODE (type
) != TYPE_CODE_PTR
473 && TYPE_CODE (type
) != TYPE_CODE_REF
)
475 type
= TYPE_TARGET_TYPE (type
);
478 /* If this is not a struct, union, or enum type, raise TypeError
480 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
481 && TYPE_CODE (type
) != TYPE_CODE_UNION
482 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
484 PyErr_SetString (PyExc_TypeError
,
485 "Type is not a structure, union, or enum type.");
492 /* Helper for typy_array and typy_vector. */
495 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
498 PyObject
*n2_obj
= NULL
;
499 struct type
*array
= NULL
;
500 struct type
*type
= ((type_object
*) self
)->type
;
501 volatile struct gdb_exception except
;
503 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
508 if (!PyInt_Check (n2_obj
))
510 PyErr_SetString (PyExc_RuntimeError
,
511 _("Array bound must be an integer"));
515 if (! gdb_py_int_as_long (n2_obj
, &n2
))
526 PyErr_SetString (PyExc_ValueError
,
527 _("Array length must not be negative"));
531 TRY_CATCH (except
, RETURN_MASK_ALL
)
533 array
= lookup_array_range_type (type
, n1
, n2
);
535 make_vector_type (array
);
537 GDB_PY_HANDLE_EXCEPTION (except
);
539 return type_to_type_object (array
);
542 /* Return an array type. */
545 typy_array (PyObject
*self
, PyObject
*args
)
547 return typy_array_1 (self
, args
, 0);
550 /* Return a vector type. */
553 typy_vector (PyObject
*self
, PyObject
*args
)
555 return typy_array_1 (self
, args
, 1);
558 /* Return a Type object which represents a pointer to SELF. */
560 typy_pointer (PyObject
*self
, PyObject
*args
)
562 struct type
*type
= ((type_object
*) self
)->type
;
563 volatile struct gdb_exception except
;
565 TRY_CATCH (except
, RETURN_MASK_ALL
)
567 type
= lookup_pointer_type (type
);
569 GDB_PY_HANDLE_EXCEPTION (except
);
571 return type_to_type_object (type
);
574 /* Return the range of a type represented by SELF. The return type is
575 a tuple. The first element of the tuple contains the low bound,
576 while the second element of the tuple contains the high bound. */
578 typy_range (PyObject
*self
, PyObject
*args
)
580 struct type
*type
= ((type_object
*) self
)->type
;
582 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
583 /* Initialize these to appease GCC warnings. */
584 LONGEST low
= 0, high
= 0;
586 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
587 && TYPE_CODE (type
) != TYPE_CODE_STRING
588 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
590 PyErr_SetString (PyExc_RuntimeError
,
591 _("This type does not have a range."));
595 switch (TYPE_CODE (type
))
597 case TYPE_CODE_ARRAY
:
598 case TYPE_CODE_STRING
:
599 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
600 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
602 case TYPE_CODE_RANGE
:
603 low
= TYPE_LOW_BOUND (type
);
604 high
= TYPE_HIGH_BOUND (type
);
608 low_bound
= PyLong_FromLong (low
);
612 high_bound
= PyLong_FromLong (high
);
616 result
= PyTuple_New (2);
620 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
625 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
627 Py_DECREF (high_bound
);
634 Py_XDECREF (high_bound
);
635 Py_XDECREF (low_bound
);
639 /* Return a Type object which represents a reference to SELF. */
641 typy_reference (PyObject
*self
, PyObject
*args
)
643 struct type
*type
= ((type_object
*) self
)->type
;
644 volatile struct gdb_exception except
;
646 TRY_CATCH (except
, RETURN_MASK_ALL
)
648 type
= lookup_reference_type (type
);
650 GDB_PY_HANDLE_EXCEPTION (except
);
652 return type_to_type_object (type
);
655 /* Return a Type object which represents the target type of SELF. */
657 typy_target (PyObject
*self
, PyObject
*args
)
659 struct type
*type
= ((type_object
*) self
)->type
;
661 if (!TYPE_TARGET_TYPE (type
))
663 PyErr_SetString (PyExc_RuntimeError
,
664 _("Type does not have a target."));
668 return type_to_type_object (TYPE_TARGET_TYPE (type
));
671 /* Return a const-qualified type variant. */
673 typy_const (PyObject
*self
, PyObject
*args
)
675 struct type
*type
= ((type_object
*) self
)->type
;
676 volatile struct gdb_exception except
;
678 TRY_CATCH (except
, RETURN_MASK_ALL
)
680 type
= make_cv_type (1, 0, type
, NULL
);
682 GDB_PY_HANDLE_EXCEPTION (except
);
684 return type_to_type_object (type
);
687 /* Return a volatile-qualified type variant. */
689 typy_volatile (PyObject
*self
, PyObject
*args
)
691 struct type
*type
= ((type_object
*) self
)->type
;
692 volatile struct gdb_exception except
;
694 TRY_CATCH (except
, RETURN_MASK_ALL
)
696 type
= make_cv_type (0, 1, type
, NULL
);
698 GDB_PY_HANDLE_EXCEPTION (except
);
700 return type_to_type_object (type
);
703 /* Return an unqualified type variant. */
705 typy_unqualified (PyObject
*self
, PyObject
*args
)
707 struct type
*type
= ((type_object
*) self
)->type
;
708 volatile struct gdb_exception except
;
710 TRY_CATCH (except
, RETURN_MASK_ALL
)
712 type
= make_cv_type (0, 0, type
, NULL
);
714 GDB_PY_HANDLE_EXCEPTION (except
);
716 return type_to_type_object (type
);
719 /* Return the size of the type represented by SELF, in bytes. */
721 typy_get_sizeof (PyObject
*self
, void *closure
)
723 struct type
*type
= ((type_object
*) self
)->type
;
724 volatile struct gdb_exception except
;
726 TRY_CATCH (except
, RETURN_MASK_ALL
)
728 check_typedef (type
);
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
;
739 volatile struct gdb_exception except
;
741 TRY_CATCH (except
, RETURN_MASK_ALL
)
743 if (!strncmp (type_name
, "struct ", 7))
744 type
= lookup_struct (type_name
+ 7, NULL
);
745 else if (!strncmp (type_name
, "union ", 6))
746 type
= lookup_union (type_name
+ 6, NULL
);
747 else if (!strncmp (type_name
, "enum ", 5))
748 type
= lookup_enum (type_name
+ 5, NULL
);
750 type
= lookup_typename (python_language
, python_gdbarch
,
751 type_name
, block
, 0);
753 GDB_PY_HANDLE_EXCEPTION (except
);
759 typy_lookup_type (struct demangle_component
*demangled
,
760 const struct block
*block
)
762 struct type
*type
, *rtype
= NULL
;
763 char *type_name
= NULL
;
764 enum demangle_component_type demangled_type
;
765 volatile struct gdb_exception except
;
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
);
780 TRY_CATCH (except
, RETURN_MASK_ALL
)
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 GDB_PY_HANDLE_EXCEPTION (except
);
805 /* If we have a type from the switch statement above, just return
810 /* We don't have a type, so lookup the type. */
811 type_name
= cp_comp_to_string (demangled
, 10);
812 type
= typy_lookup_typename (type_name
, block
);
818 /* This is a helper function for typy_template_argument that is used
819 when the type does not have template symbols attached. It works by
820 parsing the type name. This happens with compilers, like older
821 versions of GCC, that do not emit DW_TAG_template_*. */
824 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
828 struct demangle_component
*demangled
;
829 struct demangle_parse_info
*info
= NULL
;
831 struct type
*argtype
;
832 struct cleanup
*cleanup
;
833 volatile struct gdb_exception except
;
835 if (TYPE_NAME (type
) == NULL
)
837 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
841 TRY_CATCH (except
, RETURN_MASK_ALL
)
843 /* Note -- this is not thread-safe. */
844 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
846 GDB_PY_HANDLE_EXCEPTION (except
);
850 PyErr_SetString (PyExc_RuntimeError
, err
);
853 demangled
= info
->tree
;
854 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
856 /* Strip off component names. */
857 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
858 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
859 demangled
= demangled
->u
.s_binary
.right
;
861 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
863 do_cleanups (cleanup
);
864 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
868 /* Skip from the template to the arguments. */
869 demangled
= demangled
->u
.s_binary
.right
;
871 for (i
= 0; demangled
&& i
< argno
; ++i
)
872 demangled
= demangled
->u
.s_binary
.right
;
876 do_cleanups (cleanup
);
877 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
882 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
883 do_cleanups (cleanup
);
887 return type_to_type_object (argtype
);
891 typy_template_argument (PyObject
*self
, PyObject
*args
)
894 struct type
*type
= ((type_object
*) self
)->type
;
895 const struct block
*block
= NULL
;
896 PyObject
*block_obj
= NULL
;
898 struct value
*val
= NULL
;
899 volatile struct gdb_exception except
;
901 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
906 block
= block_object_to_block (block_obj
);
909 PyErr_SetString (PyExc_RuntimeError
,
910 _("Second argument must be block."));
915 TRY_CATCH (except
, RETURN_MASK_ALL
)
917 type
= check_typedef (type
);
918 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
919 type
= check_typedef (TYPE_TARGET_TYPE (type
));
921 GDB_PY_HANDLE_EXCEPTION (except
);
923 /* We might not have DW_TAG_template_*, so try to parse the type's
924 name. This is inefficient if we do not have a template type --
925 but that is going to wind up as an error anyhow. */
926 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
927 return typy_legacy_template_argument (type
, block
, argno
);
929 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
931 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
936 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
937 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
938 return type_to_type_object (SYMBOL_TYPE (sym
));
939 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
941 PyErr_Format (PyExc_RuntimeError
,
942 _("Template argument is optimized out"));
946 TRY_CATCH (except
, RETURN_MASK_ALL
)
948 val
= value_of_variable (sym
, block
);
950 GDB_PY_HANDLE_EXCEPTION (except
);
952 return value_to_value_object (val
);
956 typy_str (PyObject
*self
)
958 volatile struct gdb_exception except
;
959 char *thetype
= NULL
;
963 TRY_CATCH (except
, RETURN_MASK_ALL
)
965 struct cleanup
*old_chain
;
968 stb
= mem_fileopen ();
969 old_chain
= make_cleanup_ui_file_delete (stb
);
971 LA_PRINT_TYPE (type_object_to_type (self
), "", stb
, -1, 0,
972 &type_print_raw_options
);
974 thetype
= ui_file_xstrdup (stb
, &length
);
975 do_cleanups (old_chain
);
977 if (except
.reason
< 0)
980 GDB_PY_HANDLE_EXCEPTION (except
);
983 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
989 /* Implement the richcompare method. */
992 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
995 struct type
*type1
= type_object_to_type (self
);
996 struct type
*type2
= type_object_to_type (other
);
997 volatile struct gdb_exception except
;
999 /* We can only compare ourselves to another Type object, and only
1000 for equality or inequality. */
1001 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1003 Py_INCREF (Py_NotImplemented
);
1004 return Py_NotImplemented
;
1011 TRY_CATCH (except
, RETURN_MASK_ALL
)
1013 result
= types_deeply_equal (type1
, type2
);
1015 /* If there is a GDB exception, a comparison is not capable
1016 (or trusted), so exit. */
1017 GDB_PY_HANDLE_EXCEPTION (except
);
1020 if (op
== (result
? Py_EQ
: Py_NE
))
1027 static const struct objfile_data
*typy_objfile_data_key
;
1030 save_objfile_types (struct objfile
*objfile
, void *datum
)
1032 type_object
*obj
= datum
;
1033 htab_t copied_types
;
1034 struct cleanup
*cleanup
;
1036 if (!gdb_python_initialized
)
1039 /* This prevents another thread from freeing the objects we're
1041 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1043 copied_types
= create_copied_types_hash (objfile
);
1047 type_object
*next
= obj
->next
;
1049 htab_empty (copied_types
);
1051 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1059 htab_delete (copied_types
);
1061 do_cleanups (cleanup
);
1065 set_type (type_object
*obj
, struct type
*type
)
1069 if (type
&& TYPE_OBJFILE (type
))
1071 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1073 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1075 obj
->next
->prev
= obj
;
1076 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1083 typy_dealloc (PyObject
*obj
)
1085 type_object
*type
= (type_object
*) obj
;
1088 type
->prev
->next
= type
->next
;
1089 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1091 /* Must reset head of list. */
1092 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1095 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1098 type
->next
->prev
= type
->prev
;
1100 Py_TYPE (type
)->tp_free (type
);
1103 /* Return number of fields ("length" of the field dictionary). */
1106 typy_length (PyObject
*self
)
1108 struct type
*type
= ((type_object
*) self
)->type
;
1110 type
= typy_get_composite (type
);
1114 return TYPE_NFIELDS (type
);
1117 /* Implements boolean evaluation of gdb.Type. Handle this like other
1118 Python objects that don't have a meaningful truth value -- all
1122 typy_nonzero (PyObject
*self
)
1127 /* Return a gdb.Field object for the field named by the argument. */
1130 typy_getitem (PyObject
*self
, PyObject
*key
)
1132 struct type
*type
= ((type_object
*) self
)->type
;
1136 field
= python_string_to_host_string (key
);
1140 /* We want just fields of this type, not of base types, so instead of
1141 using lookup_struct_elt_type, portions of that function are
1144 type
= typy_get_composite (type
);
1148 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1150 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1152 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1154 return convert_field (type
, i
);
1157 PyErr_SetObject (PyExc_KeyError
, key
);
1161 /* Implement the "get" method on the type object. This is the
1162 same as getitem if the key is present, but returns the supplied
1163 default value or None if the key is not found. */
1166 typy_get (PyObject
*self
, PyObject
*args
)
1168 PyObject
*key
, *defval
= Py_None
, *result
;
1170 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1173 result
= typy_getitem (self
, key
);
1177 /* typy_getitem returned error status. If the exception is
1178 KeyError, clear the exception status and return the defval
1179 instead. Otherwise return the exception unchanged. */
1180 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1188 /* Implement the "has_key" method on the type object. */
1191 typy_has_key (PyObject
*self
, PyObject
*args
)
1193 struct type
*type
= ((type_object
*) self
)->type
;
1197 if (!PyArg_ParseTuple (args
, "s", &field
))
1200 /* We want just fields of this type, not of base types, so instead of
1201 using lookup_struct_elt_type, portions of that function are
1204 type
= typy_get_composite (type
);
1208 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1210 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1212 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1218 /* Make an iterator object to iterate over keys, values, or items. */
1221 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1223 typy_iterator_object
*typy_iter_obj
;
1225 /* Check that "self" is a structure or union type. */
1226 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1229 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1230 &type_iterator_object_type
);
1231 if (typy_iter_obj
== NULL
)
1234 typy_iter_obj
->field
= 0;
1235 typy_iter_obj
->kind
= kind
;
1237 typy_iter_obj
->source
= (type_object
*) self
;
1239 return (PyObject
*) typy_iter_obj
;
1242 /* iteritems() method. */
1245 typy_iteritems (PyObject
*self
, PyObject
*args
)
1247 return typy_make_iter (self
, iter_items
);
1250 /* iterkeys() method. */
1253 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1255 return typy_make_iter (self
, iter_keys
);
1258 /* Iterating over the class, same as iterkeys except for the function
1262 typy_iter (PyObject
*self
)
1264 return typy_make_iter (self
, iter_keys
);
1267 /* itervalues() method. */
1270 typy_itervalues (PyObject
*self
, PyObject
*args
)
1272 return typy_make_iter (self
, iter_values
);
1275 /* Return a reference to the type iterator. */
1278 typy_iterator_iter (PyObject
*self
)
1284 /* Return the next field in the iteration through the list of fields
1288 typy_iterator_iternext (PyObject
*self
)
1290 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1291 struct type
*type
= iter_obj
->source
->type
;
1294 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1296 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1306 typy_iterator_dealloc (PyObject
*obj
)
1308 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1310 Py_DECREF (iter_obj
->source
);
1313 /* Create a new Type referring to TYPE. */
1315 type_to_type_object (struct type
*type
)
1317 type_object
*type_obj
;
1319 type_obj
= PyObject_New (type_object
, &type_object_type
);
1321 set_type (type_obj
, type
);
1323 return (PyObject
*) type_obj
;
1327 type_object_to_type (PyObject
*obj
)
1329 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1331 return ((type_object
*) obj
)->type
;
1336 /* Implementation of gdb.lookup_type. */
1338 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1340 static char *keywords
[] = { "name", "block", NULL
};
1341 const char *type_name
= NULL
;
1342 struct type
*type
= NULL
;
1343 PyObject
*block_obj
= NULL
;
1344 const struct block
*block
= NULL
;
1346 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1347 &type_name
, &block_obj
))
1352 block
= block_object_to_block (block_obj
);
1355 PyErr_SetString (PyExc_RuntimeError
,
1356 _("'block' argument must be a Block."));
1361 type
= typy_lookup_typename (type_name
, block
);
1365 return (PyObject
*) type_to_type_object (type
);
1369 gdbpy_initialize_types (void)
1373 typy_objfile_data_key
1374 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1376 if (PyType_Ready (&type_object_type
) < 0)
1378 if (PyType_Ready (&field_object_type
) < 0)
1380 if (PyType_Ready (&type_iterator_object_type
) < 0)
1383 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1385 if (PyModule_AddIntConstant (gdb_module
,
1386 /* Cast needed for Python 2.4. */
1387 (char *) pyty_codes
[i
].name
,
1388 pyty_codes
[i
].code
) < 0)
1392 if (gdb_pymodule_addobject (gdb_module
, "Type",
1393 (PyObject
*) &type_object_type
) < 0)
1396 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1397 (PyObject
*) &type_iterator_object_type
) < 0)
1400 return gdb_pymodule_addobject (gdb_module
, "Field",
1401 (PyObject
*) &field_object_type
);
1406 static PyGetSetDef type_object_getset
[] =
1408 { "code", typy_get_code
, NULL
,
1409 "The code for this type.", NULL
},
1410 { "name", typy_get_name
, NULL
,
1411 "The name for this type, or None.", NULL
},
1412 { "sizeof", typy_get_sizeof
, NULL
,
1413 "The size of this type, in bytes.", NULL
},
1414 { "tag", typy_get_tag
, NULL
,
1415 "The tag name for this type, or None.", NULL
},
1419 static PyMethodDef type_object_methods
[] =
1421 { "array", typy_array
, METH_VARARGS
,
1422 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1423 Return a type which represents an array of objects of this type.\n\
1424 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1425 If LOW_BOUND is omitted, a value of zero is used." },
1426 { "vector", typy_vector
, METH_VARARGS
,
1427 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1428 Return a type which represents a vector of objects of this type.\n\
1429 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1430 If LOW_BOUND is omitted, a value of zero is used.\n\
1431 Vectors differ from arrays in that if the current language has C-style\n\
1432 arrays, vectors don't decay to a pointer to the first element.\n\
1433 They are first class values." },
1434 { "__contains__", typy_has_key
, METH_VARARGS
,
1435 "T.__contains__(k) -> True if T has a field named k, else False" },
1436 { "const", typy_const
, METH_NOARGS
,
1437 "const () -> Type\n\
1438 Return a const variant of this type." },
1439 { "fields", typy_fields
, METH_NOARGS
,
1440 "fields () -> list\n\
1441 Return a list holding all the fields of this type.\n\
1442 Each field is a gdb.Field object." },
1443 { "get", typy_get
, METH_VARARGS
,
1444 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1445 otherwise returns default, if supplied, or None if not." },
1446 { "has_key", typy_has_key
, METH_VARARGS
,
1447 "T.has_key(k) -> True if T has a field named k, else False" },
1448 { "items", typy_items
, METH_NOARGS
,
1449 "items () -> list\n\
1450 Return a list of (name, field) pairs of this type.\n\
1451 Each field is a gdb.Field object." },
1452 { "iteritems", typy_iteritems
, METH_NOARGS
,
1453 "iteritems () -> an iterator over the (name, field)\n\
1454 pairs of this type. Each field is a gdb.Field object." },
1455 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1456 "iterkeys () -> an iterator over the field names of this type." },
1457 { "itervalues", typy_itervalues
, METH_NOARGS
,
1458 "itervalues () -> an iterator over the fields of this type.\n\
1459 Each field is a gdb.Field object." },
1460 { "keys", typy_field_names
, METH_NOARGS
,
1462 Return a list holding all the fields names of this type." },
1463 { "pointer", typy_pointer
, METH_NOARGS
,
1464 "pointer () -> Type\n\
1465 Return a type of pointer to this type." },
1466 { "range", typy_range
, METH_NOARGS
,
1467 "range () -> tuple\n\
1468 Return a tuple containing the lower and upper range for this type."},
1469 { "reference", typy_reference
, METH_NOARGS
,
1470 "reference () -> Type\n\
1471 Return a type of reference to this type." },
1472 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1473 "strip_typedefs () -> Type\n\
1474 Return a type formed by stripping this type of all typedefs."},
1475 { "target", typy_target
, METH_NOARGS
,
1476 "target () -> Type\n\
1477 Return the target type of this type." },
1478 { "template_argument", typy_template_argument
, METH_VARARGS
,
1479 "template_argument (arg, [block]) -> Type\n\
1480 Return the type of a template argument." },
1481 { "unqualified", typy_unqualified
, METH_NOARGS
,
1482 "unqualified () -> Type\n\
1483 Return a variant of this type without const or volatile attributes." },
1484 { "values", typy_values
, METH_NOARGS
,
1485 "values () -> list\n\
1486 Return a list holding all the fields of this type.\n\
1487 Each field is a gdb.Field object." },
1488 { "volatile", typy_volatile
, METH_NOARGS
,
1489 "volatile () -> Type\n\
1490 Return a volatile variant of this type" },
1494 static PyNumberMethods type_object_as_number
= {
1496 NULL
, /* nb_subtract */
1497 NULL
, /* nb_multiply */
1499 NULL
, /* nb_divide */
1501 NULL
, /* nb_remainder */
1502 NULL
, /* nb_divmod */
1503 NULL
, /* nb_power */
1504 NULL
, /* nb_negative */
1505 NULL
, /* nb_positive */
1506 NULL
, /* nb_absolute */
1507 typy_nonzero
, /* nb_nonzero */
1508 NULL
, /* nb_invert */
1509 NULL
, /* nb_lshift */
1510 NULL
, /* nb_rshift */
1516 NULL
, /* reserved */
1518 NULL
, /* nb_coerce */
1522 NULL
, /* nb_float */
1529 static PyMappingMethods typy_mapping
= {
1532 NULL
/* no "set" method */
1535 static PyTypeObject type_object_type
=
1537 PyVarObject_HEAD_INIT (NULL
, 0)
1538 "gdb.Type", /*tp_name*/
1539 sizeof (type_object
), /*tp_basicsize*/
1541 typy_dealloc
, /*tp_dealloc*/
1547 &type_object_as_number
, /*tp_as_number*/
1548 0, /*tp_as_sequence*/
1549 &typy_mapping
, /*tp_as_mapping*/
1552 typy_str
, /*tp_str*/
1556 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1557 "GDB type object", /* tp_doc */
1558 0, /* tp_traverse */
1560 typy_richcompare
, /* tp_richcompare */
1561 0, /* tp_weaklistoffset */
1562 typy_iter
, /* tp_iter */
1563 0, /* tp_iternext */
1564 type_object_methods
, /* tp_methods */
1566 type_object_getset
, /* tp_getset */
1569 0, /* tp_descr_get */
1570 0, /* tp_descr_set */
1571 0, /* tp_dictoffset */
1577 static PyGetSetDef field_object_getset
[] =
1579 { "__dict__", gdb_py_generic_dict
, NULL
,
1580 "The __dict__ for this field.", &field_object_type
},
1584 static PyTypeObject field_object_type
=
1586 PyVarObject_HEAD_INIT (NULL
, 0)
1587 "gdb.Field", /*tp_name*/
1588 sizeof (field_object
), /*tp_basicsize*/
1590 field_dealloc
, /*tp_dealloc*/
1597 0, /*tp_as_sequence*/
1598 0, /*tp_as_mapping*/
1605 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1606 "GDB field object", /* tp_doc */
1607 0, /* tp_traverse */
1609 0, /* tp_richcompare */
1610 0, /* tp_weaklistoffset */
1612 0, /* tp_iternext */
1615 field_object_getset
, /* tp_getset */
1618 0, /* tp_descr_get */
1619 0, /* tp_descr_set */
1620 offsetof (field_object
, dict
), /* tp_dictoffset */
1626 static PyTypeObject type_iterator_object_type
= {
1627 PyVarObject_HEAD_INIT (NULL
, 0)
1628 "gdb.TypeIterator", /*tp_name*/
1629 sizeof (typy_iterator_object
), /*tp_basicsize*/
1631 typy_iterator_dealloc
, /*tp_dealloc*/
1638 0, /*tp_as_sequence*/
1639 0, /*tp_as_mapping*/
1646 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1647 "GDB type iterator object", /*tp_doc */
1650 0, /*tp_richcompare */
1651 0, /*tp_weaklistoffset */
1652 typy_iterator_iter
, /*tp_iter */
1653 typy_iterator_iternext
, /*tp_iternext */