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 tag, or None. */
419 typy_get_tag (PyObject
*self
, void *closure
)
421 struct type
*type
= ((type_object
*) self
)->type
;
423 if (!TYPE_TAG_NAME (type
))
425 return PyString_FromString (TYPE_TAG_NAME (type
));
428 /* Return the type, stripped of typedefs. */
430 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
432 struct type
*type
= ((type_object
*) self
)->type
;
433 volatile struct gdb_exception except
;
435 TRY_CATCH (except
, RETURN_MASK_ALL
)
437 type
= check_typedef (type
);
439 GDB_PY_HANDLE_EXCEPTION (except
);
441 return type_to_type_object (type
);
444 /* Strip typedefs and pointers/reference from a type. Then check that
445 it is a struct, union, or enum type. If not, raise TypeError. */
448 typy_get_composite (struct type
*type
)
450 volatile struct gdb_exception except
;
454 TRY_CATCH (except
, RETURN_MASK_ALL
)
456 CHECK_TYPEDEF (type
);
458 GDB_PY_HANDLE_EXCEPTION (except
);
460 if (TYPE_CODE (type
) != TYPE_CODE_PTR
461 && TYPE_CODE (type
) != TYPE_CODE_REF
)
463 type
= TYPE_TARGET_TYPE (type
);
466 /* If this is not a struct, union, or enum type, raise TypeError
468 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
469 && TYPE_CODE (type
) != TYPE_CODE_UNION
470 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
472 PyErr_SetString (PyExc_TypeError
,
473 "Type is not a structure, union, or enum type.");
480 /* Helper for typy_array and typy_vector. */
483 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
486 PyObject
*n2_obj
= NULL
;
487 struct type
*array
= NULL
;
488 struct type
*type
= ((type_object
*) self
)->type
;
489 volatile struct gdb_exception except
;
491 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
496 if (!PyInt_Check (n2_obj
))
498 PyErr_SetString (PyExc_RuntimeError
,
499 _("Array bound must be an integer"));
503 if (! gdb_py_int_as_long (n2_obj
, &n2
))
514 PyErr_SetString (PyExc_ValueError
,
515 _("Array length must not be negative"));
519 TRY_CATCH (except
, RETURN_MASK_ALL
)
521 array
= lookup_array_range_type (type
, n1
, n2
);
523 make_vector_type (array
);
525 GDB_PY_HANDLE_EXCEPTION (except
);
527 return type_to_type_object (array
);
530 /* Return an array type. */
533 typy_array (PyObject
*self
, PyObject
*args
)
535 return typy_array_1 (self
, args
, 0);
538 /* Return a vector type. */
541 typy_vector (PyObject
*self
, PyObject
*args
)
543 return typy_array_1 (self
, args
, 1);
546 /* Return a Type object which represents a pointer to SELF. */
548 typy_pointer (PyObject
*self
, PyObject
*args
)
550 struct type
*type
= ((type_object
*) self
)->type
;
551 volatile struct gdb_exception except
;
553 TRY_CATCH (except
, RETURN_MASK_ALL
)
555 type
= lookup_pointer_type (type
);
557 GDB_PY_HANDLE_EXCEPTION (except
);
559 return type_to_type_object (type
);
562 /* Return the range of a type represented by SELF. The return type is
563 a tuple. The first element of the tuple contains the low bound,
564 while the second element of the tuple contains the high bound. */
566 typy_range (PyObject
*self
, PyObject
*args
)
568 struct type
*type
= ((type_object
*) self
)->type
;
570 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
571 /* Initialize these to appease GCC warnings. */
572 LONGEST low
= 0, high
= 0;
574 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
575 && TYPE_CODE (type
) != TYPE_CODE_STRING
576 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
578 PyErr_SetString (PyExc_RuntimeError
,
579 _("This type does not have a range."));
583 switch (TYPE_CODE (type
))
585 case TYPE_CODE_ARRAY
:
586 case TYPE_CODE_STRING
:
587 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
588 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
590 case TYPE_CODE_RANGE
:
591 low
= TYPE_LOW_BOUND (type
);
592 high
= TYPE_HIGH_BOUND (type
);
596 low_bound
= PyLong_FromLong (low
);
600 high_bound
= PyLong_FromLong (high
);
604 result
= PyTuple_New (2);
608 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
613 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
615 Py_DECREF (high_bound
);
622 Py_XDECREF (high_bound
);
623 Py_XDECREF (low_bound
);
627 /* Return a Type object which represents a reference to SELF. */
629 typy_reference (PyObject
*self
, PyObject
*args
)
631 struct type
*type
= ((type_object
*) self
)->type
;
632 volatile struct gdb_exception except
;
634 TRY_CATCH (except
, RETURN_MASK_ALL
)
636 type
= lookup_reference_type (type
);
638 GDB_PY_HANDLE_EXCEPTION (except
);
640 return type_to_type_object (type
);
643 /* Return a Type object which represents the target type of SELF. */
645 typy_target (PyObject
*self
, PyObject
*args
)
647 struct type
*type
= ((type_object
*) self
)->type
;
649 if (!TYPE_TARGET_TYPE (type
))
651 PyErr_SetString (PyExc_RuntimeError
,
652 _("Type does not have a target."));
656 return type_to_type_object (TYPE_TARGET_TYPE (type
));
659 /* Return a const-qualified type variant. */
661 typy_const (PyObject
*self
, PyObject
*args
)
663 struct type
*type
= ((type_object
*) self
)->type
;
664 volatile struct gdb_exception except
;
666 TRY_CATCH (except
, RETURN_MASK_ALL
)
668 type
= make_cv_type (1, 0, type
, NULL
);
670 GDB_PY_HANDLE_EXCEPTION (except
);
672 return type_to_type_object (type
);
675 /* Return a volatile-qualified type variant. */
677 typy_volatile (PyObject
*self
, PyObject
*args
)
679 struct type
*type
= ((type_object
*) self
)->type
;
680 volatile struct gdb_exception except
;
682 TRY_CATCH (except
, RETURN_MASK_ALL
)
684 type
= make_cv_type (0, 1, type
, NULL
);
686 GDB_PY_HANDLE_EXCEPTION (except
);
688 return type_to_type_object (type
);
691 /* Return an unqualified type variant. */
693 typy_unqualified (PyObject
*self
, PyObject
*args
)
695 struct type
*type
= ((type_object
*) self
)->type
;
696 volatile struct gdb_exception except
;
698 TRY_CATCH (except
, RETURN_MASK_ALL
)
700 type
= make_cv_type (0, 0, type
, NULL
);
702 GDB_PY_HANDLE_EXCEPTION (except
);
704 return type_to_type_object (type
);
707 /* Return the size of the type represented by SELF, in bytes. */
709 typy_get_sizeof (PyObject
*self
, void *closure
)
711 struct type
*type
= ((type_object
*) self
)->type
;
712 volatile struct gdb_exception except
;
714 TRY_CATCH (except
, RETURN_MASK_ALL
)
716 check_typedef (type
);
718 /* Ignore exceptions. */
720 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
724 typy_lookup_typename (const char *type_name
, const struct block
*block
)
726 struct type
*type
= NULL
;
727 volatile struct gdb_exception except
;
729 TRY_CATCH (except
, RETURN_MASK_ALL
)
731 if (!strncmp (type_name
, "struct ", 7))
732 type
= lookup_struct (type_name
+ 7, NULL
);
733 else if (!strncmp (type_name
, "union ", 6))
734 type
= lookup_union (type_name
+ 6, NULL
);
735 else if (!strncmp (type_name
, "enum ", 5))
736 type
= lookup_enum (type_name
+ 5, NULL
);
738 type
= lookup_typename (python_language
, python_gdbarch
,
739 type_name
, block
, 0);
741 GDB_PY_HANDLE_EXCEPTION (except
);
747 typy_lookup_type (struct demangle_component
*demangled
,
748 const struct block
*block
)
750 struct type
*type
, *rtype
= NULL
;
751 char *type_name
= NULL
;
752 enum demangle_component_type demangled_type
;
753 volatile struct gdb_exception except
;
755 /* Save the type: typy_lookup_type() may (indirectly) overwrite
756 memory pointed by demangled. */
757 demangled_type
= demangled
->type
;
759 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
760 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
761 || demangled_type
== DEMANGLE_COMPONENT_CONST
762 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
764 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
768 TRY_CATCH (except
, RETURN_MASK_ALL
)
770 /* If the demangled_type matches with one of the types
771 below, run the corresponding function and save the type
772 to return later. We cannot just return here as we are in
773 an exception handler. */
774 switch (demangled_type
)
776 case DEMANGLE_COMPONENT_REFERENCE
:
777 rtype
= lookup_reference_type (type
);
779 case DEMANGLE_COMPONENT_POINTER
:
780 rtype
= lookup_pointer_type (type
);
782 case DEMANGLE_COMPONENT_CONST
:
783 rtype
= make_cv_type (1, 0, type
, NULL
);
785 case DEMANGLE_COMPONENT_VOLATILE
:
786 rtype
= make_cv_type (0, 1, type
, NULL
);
790 GDB_PY_HANDLE_EXCEPTION (except
);
793 /* If we have a type from the switch statement above, just return
798 /* We don't have a type, so lookup the type. */
799 type_name
= cp_comp_to_string (demangled
, 10);
800 type
= typy_lookup_typename (type_name
, block
);
806 /* This is a helper function for typy_template_argument that is used
807 when the type does not have template symbols attached. It works by
808 parsing the type name. This happens with compilers, like older
809 versions of GCC, that do not emit DW_TAG_template_*. */
812 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
816 struct demangle_component
*demangled
;
817 struct demangle_parse_info
*info
= NULL
;
819 struct type
*argtype
;
820 struct cleanup
*cleanup
;
821 volatile struct gdb_exception except
;
823 if (TYPE_NAME (type
) == NULL
)
825 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
829 TRY_CATCH (except
, RETURN_MASK_ALL
)
831 /* Note -- this is not thread-safe. */
832 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
834 GDB_PY_HANDLE_EXCEPTION (except
);
838 PyErr_SetString (PyExc_RuntimeError
, err
);
841 demangled
= info
->tree
;
842 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
844 /* Strip off component names. */
845 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
846 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
847 demangled
= demangled
->u
.s_binary
.right
;
849 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
851 do_cleanups (cleanup
);
852 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
856 /* Skip from the template to the arguments. */
857 demangled
= demangled
->u
.s_binary
.right
;
859 for (i
= 0; demangled
&& i
< argno
; ++i
)
860 demangled
= demangled
->u
.s_binary
.right
;
864 do_cleanups (cleanup
);
865 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
870 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
871 do_cleanups (cleanup
);
875 return type_to_type_object (argtype
);
879 typy_template_argument (PyObject
*self
, PyObject
*args
)
882 struct type
*type
= ((type_object
*) self
)->type
;
883 const struct block
*block
= NULL
;
884 PyObject
*block_obj
= NULL
;
886 struct value
*val
= NULL
;
887 volatile struct gdb_exception except
;
889 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
894 block
= block_object_to_block (block_obj
);
897 PyErr_SetString (PyExc_RuntimeError
,
898 _("Second argument must be block."));
903 TRY_CATCH (except
, RETURN_MASK_ALL
)
905 type
= check_typedef (type
);
906 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
907 type
= check_typedef (TYPE_TARGET_TYPE (type
));
909 GDB_PY_HANDLE_EXCEPTION (except
);
911 /* We might not have DW_TAG_template_*, so try to parse the type's
912 name. This is inefficient if we do not have a template type --
913 but that is going to wind up as an error anyhow. */
914 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
915 return typy_legacy_template_argument (type
, block
, argno
);
917 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
919 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
924 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
925 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
926 return type_to_type_object (SYMBOL_TYPE (sym
));
927 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
929 PyErr_Format (PyExc_RuntimeError
,
930 _("Template argument is optimized out"));
934 TRY_CATCH (except
, RETURN_MASK_ALL
)
936 val
= value_of_variable (sym
, block
);
938 GDB_PY_HANDLE_EXCEPTION (except
);
940 return value_to_value_object (val
);
944 typy_str (PyObject
*self
)
946 volatile struct gdb_exception except
;
947 char *thetype
= NULL
;
951 TRY_CATCH (except
, RETURN_MASK_ALL
)
953 struct cleanup
*old_chain
;
956 stb
= mem_fileopen ();
957 old_chain
= make_cleanup_ui_file_delete (stb
);
959 LA_PRINT_TYPE (type_object_to_type (self
), "", stb
, -1, 0,
960 &type_print_raw_options
);
962 thetype
= ui_file_xstrdup (stb
, &length
);
963 do_cleanups (old_chain
);
965 if (except
.reason
< 0)
968 GDB_PY_HANDLE_EXCEPTION (except
);
971 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
977 /* Implement the richcompare method. */
980 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
983 struct type
*type1
= type_object_to_type (self
);
984 struct type
*type2
= type_object_to_type (other
);
985 volatile struct gdb_exception except
;
987 /* We can only compare ourselves to another Type object, and only
988 for equality or inequality. */
989 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
991 Py_INCREF (Py_NotImplemented
);
992 return Py_NotImplemented
;
999 TRY_CATCH (except
, RETURN_MASK_ALL
)
1001 result
= types_deeply_equal (type1
, type2
);
1003 /* If there is a GDB exception, a comparison is not capable
1004 (or trusted), so exit. */
1005 GDB_PY_HANDLE_EXCEPTION (except
);
1008 if (op
== (result
? Py_EQ
: Py_NE
))
1015 static const struct objfile_data
*typy_objfile_data_key
;
1018 save_objfile_types (struct objfile
*objfile
, void *datum
)
1020 type_object
*obj
= datum
;
1021 htab_t copied_types
;
1022 struct cleanup
*cleanup
;
1024 if (!gdb_python_initialized
)
1027 /* This prevents another thread from freeing the objects we're
1029 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1031 copied_types
= create_copied_types_hash (objfile
);
1035 type_object
*next
= obj
->next
;
1037 htab_empty (copied_types
);
1039 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1047 htab_delete (copied_types
);
1049 do_cleanups (cleanup
);
1053 set_type (type_object
*obj
, struct type
*type
)
1057 if (type
&& TYPE_OBJFILE (type
))
1059 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1061 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1063 obj
->next
->prev
= obj
;
1064 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1071 typy_dealloc (PyObject
*obj
)
1073 type_object
*type
= (type_object
*) obj
;
1076 type
->prev
->next
= type
->next
;
1077 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1079 /* Must reset head of list. */
1080 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1083 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1086 type
->next
->prev
= type
->prev
;
1088 Py_TYPE (type
)->tp_free (type
);
1091 /* Return number of fields ("length" of the field dictionary). */
1094 typy_length (PyObject
*self
)
1096 struct type
*type
= ((type_object
*) self
)->type
;
1098 type
= typy_get_composite (type
);
1102 return TYPE_NFIELDS (type
);
1105 /* Implements boolean evaluation of gdb.Type. Handle this like other
1106 Python objects that don't have a meaningful truth value -- all
1110 typy_nonzero (PyObject
*self
)
1115 /* Return a gdb.Field object for the field named by the argument. */
1118 typy_getitem (PyObject
*self
, PyObject
*key
)
1120 struct type
*type
= ((type_object
*) self
)->type
;
1124 field
= python_string_to_host_string (key
);
1128 /* We want just fields of this type, not of base types, so instead of
1129 using lookup_struct_elt_type, portions of that function are
1132 type
= typy_get_composite (type
);
1136 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1138 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1140 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1142 return convert_field (type
, i
);
1145 PyErr_SetObject (PyExc_KeyError
, key
);
1149 /* Implement the "get" method on the type object. This is the
1150 same as getitem if the key is present, but returns the supplied
1151 default value or None if the key is not found. */
1154 typy_get (PyObject
*self
, PyObject
*args
)
1156 PyObject
*key
, *defval
= Py_None
, *result
;
1158 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1161 result
= typy_getitem (self
, key
);
1165 /* typy_getitem returned error status. If the exception is
1166 KeyError, clear the exception status and return the defval
1167 instead. Otherwise return the exception unchanged. */
1168 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1176 /* Implement the "has_key" method on the type object. */
1179 typy_has_key (PyObject
*self
, PyObject
*args
)
1181 struct type
*type
= ((type_object
*) self
)->type
;
1185 if (!PyArg_ParseTuple (args
, "s", &field
))
1188 /* We want just fields of this type, not of base types, so instead of
1189 using lookup_struct_elt_type, portions of that function are
1192 type
= typy_get_composite (type
);
1196 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1198 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1200 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1206 /* Make an iterator object to iterate over keys, values, or items. */
1209 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1211 typy_iterator_object
*typy_iter_obj
;
1213 /* Check that "self" is a structure or union type. */
1214 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1217 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1218 &type_iterator_object_type
);
1219 if (typy_iter_obj
== NULL
)
1222 typy_iter_obj
->field
= 0;
1223 typy_iter_obj
->kind
= kind
;
1225 typy_iter_obj
->source
= (type_object
*) self
;
1227 return (PyObject
*) typy_iter_obj
;
1230 /* iteritems() method. */
1233 typy_iteritems (PyObject
*self
, PyObject
*args
)
1235 return typy_make_iter (self
, iter_items
);
1238 /* iterkeys() method. */
1241 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1243 return typy_make_iter (self
, iter_keys
);
1246 /* Iterating over the class, same as iterkeys except for the function
1250 typy_iter (PyObject
*self
)
1252 return typy_make_iter (self
, iter_keys
);
1255 /* itervalues() method. */
1258 typy_itervalues (PyObject
*self
, PyObject
*args
)
1260 return typy_make_iter (self
, iter_values
);
1263 /* Return a reference to the type iterator. */
1266 typy_iterator_iter (PyObject
*self
)
1272 /* Return the next field in the iteration through the list of fields
1276 typy_iterator_iternext (PyObject
*self
)
1278 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1279 struct type
*type
= iter_obj
->source
->type
;
1282 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1284 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1294 typy_iterator_dealloc (PyObject
*obj
)
1296 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1298 Py_DECREF (iter_obj
->source
);
1301 /* Create a new Type referring to TYPE. */
1303 type_to_type_object (struct type
*type
)
1305 type_object
*type_obj
;
1307 type_obj
= PyObject_New (type_object
, &type_object_type
);
1309 set_type (type_obj
, type
);
1311 return (PyObject
*) type_obj
;
1315 type_object_to_type (PyObject
*obj
)
1317 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1319 return ((type_object
*) obj
)->type
;
1324 /* Implementation of gdb.lookup_type. */
1326 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1328 static char *keywords
[] = { "name", "block", NULL
};
1329 const char *type_name
= NULL
;
1330 struct type
*type
= NULL
;
1331 PyObject
*block_obj
= NULL
;
1332 const struct block
*block
= NULL
;
1334 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1335 &type_name
, &block_obj
))
1340 block
= block_object_to_block (block_obj
);
1343 PyErr_SetString (PyExc_RuntimeError
,
1344 _("'block' argument must be a Block."));
1349 type
= typy_lookup_typename (type_name
, block
);
1353 return (PyObject
*) type_to_type_object (type
);
1357 gdbpy_initialize_types (void)
1361 typy_objfile_data_key
1362 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1364 if (PyType_Ready (&type_object_type
) < 0)
1366 if (PyType_Ready (&field_object_type
) < 0)
1368 if (PyType_Ready (&type_iterator_object_type
) < 0)
1371 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1373 if (PyModule_AddIntConstant (gdb_module
,
1374 /* Cast needed for Python 2.4. */
1375 (char *) pyty_codes
[i
].name
,
1376 pyty_codes
[i
].code
) < 0)
1380 if (gdb_pymodule_addobject (gdb_module
, "Type",
1381 (PyObject
*) &type_object_type
) < 0)
1384 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1385 (PyObject
*) &type_iterator_object_type
) < 0)
1388 return gdb_pymodule_addobject (gdb_module
, "Field",
1389 (PyObject
*) &field_object_type
);
1394 static PyGetSetDef type_object_getset
[] =
1396 { "code", typy_get_code
, NULL
,
1397 "The code for this type.", NULL
},
1398 { "sizeof", typy_get_sizeof
, NULL
,
1399 "The size of this type, in bytes.", NULL
},
1400 { "tag", typy_get_tag
, NULL
,
1401 "The tag name for this type, or None.", NULL
},
1405 static PyMethodDef type_object_methods
[] =
1407 { "array", typy_array
, METH_VARARGS
,
1408 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1409 Return a type which represents an array of objects of this type.\n\
1410 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1411 If LOW_BOUND is omitted, a value of zero is used." },
1412 { "vector", typy_vector
, METH_VARARGS
,
1413 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1414 Return a type which represents a vector of objects of this type.\n\
1415 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1416 If LOW_BOUND is omitted, a value of zero is used.\n\
1417 Vectors differ from arrays in that if the current language has C-style\n\
1418 arrays, vectors don't decay to a pointer to the first element.\n\
1419 They are first class values." },
1420 { "__contains__", typy_has_key
, METH_VARARGS
,
1421 "T.__contains__(k) -> True if T has a field named k, else False" },
1422 { "const", typy_const
, METH_NOARGS
,
1423 "const () -> Type\n\
1424 Return a const variant of this type." },
1425 { "fields", typy_fields
, METH_NOARGS
,
1426 "fields () -> list\n\
1427 Return a list holding all the fields of this type.\n\
1428 Each field is a gdb.Field object." },
1429 { "get", typy_get
, METH_VARARGS
,
1430 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1431 otherwise returns default, if supplied, or None if not." },
1432 { "has_key", typy_has_key
, METH_VARARGS
,
1433 "T.has_key(k) -> True if T has a field named k, else False" },
1434 { "items", typy_items
, METH_NOARGS
,
1435 "items () -> list\n\
1436 Return a list of (name, field) pairs of this type.\n\
1437 Each field is a gdb.Field object." },
1438 { "iteritems", typy_iteritems
, METH_NOARGS
,
1439 "iteritems () -> an iterator over the (name, field)\n\
1440 pairs of this type. Each field is a gdb.Field object." },
1441 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1442 "iterkeys () -> an iterator over the field names of this type." },
1443 { "itervalues", typy_itervalues
, METH_NOARGS
,
1444 "itervalues () -> an iterator over the fields of this type.\n\
1445 Each field is a gdb.Field object." },
1446 { "keys", typy_field_names
, METH_NOARGS
,
1448 Return a list holding all the fields names of this type." },
1449 { "pointer", typy_pointer
, METH_NOARGS
,
1450 "pointer () -> Type\n\
1451 Return a type of pointer to this type." },
1452 { "range", typy_range
, METH_NOARGS
,
1453 "range () -> tuple\n\
1454 Return a tuple containing the lower and upper range for this type."},
1455 { "reference", typy_reference
, METH_NOARGS
,
1456 "reference () -> Type\n\
1457 Return a type of reference to this type." },
1458 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1459 "strip_typedefs () -> Type\n\
1460 Return a type formed by stripping this type of all typedefs."},
1461 { "target", typy_target
, METH_NOARGS
,
1462 "target () -> Type\n\
1463 Return the target type of this type." },
1464 { "template_argument", typy_template_argument
, METH_VARARGS
,
1465 "template_argument (arg, [block]) -> Type\n\
1466 Return the type of a template argument." },
1467 { "unqualified", typy_unqualified
, METH_NOARGS
,
1468 "unqualified () -> Type\n\
1469 Return a variant of this type without const or volatile attributes." },
1470 { "values", typy_values
, METH_NOARGS
,
1471 "values () -> list\n\
1472 Return a list holding all the fields of this type.\n\
1473 Each field is a gdb.Field object." },
1474 { "volatile", typy_volatile
, METH_NOARGS
,
1475 "volatile () -> Type\n\
1476 Return a volatile variant of this type" },
1480 static PyNumberMethods type_object_as_number
= {
1482 NULL
, /* nb_subtract */
1483 NULL
, /* nb_multiply */
1485 NULL
, /* nb_divide */
1487 NULL
, /* nb_remainder */
1488 NULL
, /* nb_divmod */
1489 NULL
, /* nb_power */
1490 NULL
, /* nb_negative */
1491 NULL
, /* nb_positive */
1492 NULL
, /* nb_absolute */
1493 typy_nonzero
, /* nb_nonzero */
1494 NULL
, /* nb_invert */
1495 NULL
, /* nb_lshift */
1496 NULL
, /* nb_rshift */
1502 NULL
, /* reserved */
1504 NULL
, /* nb_coerce */
1508 NULL
, /* nb_float */
1515 static PyMappingMethods typy_mapping
= {
1518 NULL
/* no "set" method */
1521 static PyTypeObject type_object_type
=
1523 PyVarObject_HEAD_INIT (NULL
, 0)
1524 "gdb.Type", /*tp_name*/
1525 sizeof (type_object
), /*tp_basicsize*/
1527 typy_dealloc
, /*tp_dealloc*/
1533 &type_object_as_number
, /*tp_as_number*/
1534 0, /*tp_as_sequence*/
1535 &typy_mapping
, /*tp_as_mapping*/
1538 typy_str
, /*tp_str*/
1542 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1543 "GDB type object", /* tp_doc */
1544 0, /* tp_traverse */
1546 typy_richcompare
, /* tp_richcompare */
1547 0, /* tp_weaklistoffset */
1548 typy_iter
, /* tp_iter */
1549 0, /* tp_iternext */
1550 type_object_methods
, /* tp_methods */
1552 type_object_getset
, /* tp_getset */
1555 0, /* tp_descr_get */
1556 0, /* tp_descr_set */
1557 0, /* tp_dictoffset */
1563 static PyGetSetDef field_object_getset
[] =
1565 { "__dict__", gdb_py_generic_dict
, NULL
,
1566 "The __dict__ for this field.", &field_object_type
},
1570 static PyTypeObject field_object_type
=
1572 PyVarObject_HEAD_INIT (NULL
, 0)
1573 "gdb.Field", /*tp_name*/
1574 sizeof (field_object
), /*tp_basicsize*/
1576 field_dealloc
, /*tp_dealloc*/
1583 0, /*tp_as_sequence*/
1584 0, /*tp_as_mapping*/
1591 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1592 "GDB field object", /* tp_doc */
1593 0, /* tp_traverse */
1595 0, /* tp_richcompare */
1596 0, /* tp_weaklistoffset */
1598 0, /* tp_iternext */
1601 field_object_getset
, /* tp_getset */
1604 0, /* tp_descr_get */
1605 0, /* tp_descr_set */
1606 offsetof (field_object
, dict
), /* tp_dictoffset */
1612 static PyTypeObject type_iterator_object_type
= {
1613 PyVarObject_HEAD_INIT (NULL
, 0)
1614 "gdb.TypeIterator", /*tp_name*/
1615 sizeof (typy_iterator_object
), /*tp_basicsize*/
1617 typy_iterator_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 type iterator object", /*tp_doc */
1636 0, /*tp_richcompare */
1637 0, /*tp_weaklistoffset */
1638 typy_iterator_iter
, /*tp_iter */
1639 typy_iterator_iternext
, /*tp_iternext */