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)
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
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
226 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
230 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
232 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
236 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
237 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
241 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
245 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
248 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
252 /* A field can have a NULL type in some situations. */
253 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
259 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
262 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
275 /* Helper function to return the name of a field, as a gdb.Field object.
276 If the field doesn't have a name, None is returned. */
279 field_name (struct type
*type
, int field
)
283 if (TYPE_FIELD_NAME (type
, field
))
284 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
293 /* Helper function for Type standard mapping methods. Returns a
294 Python object for field i of the type. "kind" specifies what to
295 return: the name of the field, a gdb.Field object corresponding to
296 the field, or a tuple consisting of field name and gdb.Field
300 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
302 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
307 key
= field_name (type
, i
);
310 value
= convert_field (type
, i
);
313 item
= PyTuple_New (2);
316 PyTuple_SET_ITEM (item
, 0, key
);
317 PyTuple_SET_ITEM (item
, 1, value
);
320 item
= field_name (type
, i
);
323 item
= convert_field (type
, i
);
326 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
337 /* Return a sequence of all field names, fields, or (name, field) pairs.
338 Each field is a gdb.Field object. */
341 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
343 PyObject
*py_type
= self
;
344 PyObject
*result
= NULL
, *iter
= NULL
;
345 volatile struct gdb_exception except
;
346 struct type
*type
= ((type_object
*) py_type
)->type
;
347 struct type
*checked_type
= type
;
349 TRY_CATCH (except
, RETURN_MASK_ALL
)
351 CHECK_TYPEDEF (checked_type
);
353 GDB_PY_HANDLE_EXCEPTION (except
);
355 if (checked_type
!= type
)
356 py_type
= type_to_type_object (checked_type
);
357 iter
= typy_make_iter (py_type
, kind
);
358 if (checked_type
!= type
)
360 /* Need to wrap this in braces because Py_DECREF isn't wrapped
361 in a do{}while(0). */
366 result
= PySequence_List (iter
);
373 /* Return a sequence of all fields. Each field is a gdb.Field object. */
376 typy_values (PyObject
*self
, PyObject
*args
)
378 return typy_fields_items (self
, iter_values
);
381 /* Return a sequence of all fields. Each field is a gdb.Field object.
382 This method is similar to typy_values, except where the supplied
383 gdb.Type is an array, in which case it returns a list of one entry
384 which is a gdb.Field object for a range (the array bounds). */
387 typy_fields (PyObject
*self
, PyObject
*args
)
389 struct type
*type
= ((type_object
*) self
)->type
;
392 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
393 return typy_fields_items (self
, iter_values
);
395 /* Array type. Handle this as a special case because the common
396 machinery wants struct or union or enum types. Build a list of
397 one entry which is the range for the array. */
398 r
= convert_field (type
, 0);
402 rl
= Py_BuildValue ("[O]", r
);
408 /* Return a sequence of all field names. Each field is a gdb.Field object. */
411 typy_field_names (PyObject
*self
, PyObject
*args
)
413 return typy_fields_items (self
, iter_keys
);
416 /* Return a sequence of all (name, fields) pairs. Each field is a
420 typy_items (PyObject
*self
, PyObject
*args
)
422 return typy_fields_items (self
, iter_items
);
425 /* Return the type's name, or None. */
428 typy_get_name (PyObject
*self
, void *closure
)
430 struct type
*type
= ((type_object
*) self
)->type
;
432 if (TYPE_NAME (type
) == NULL
)
434 return PyString_FromString (TYPE_NAME (type
));
437 /* Return the type's tag, or None. */
439 typy_get_tag (PyObject
*self
, void *closure
)
441 struct type
*type
= ((type_object
*) self
)->type
;
443 if (!TYPE_TAG_NAME (type
))
445 return PyString_FromString (TYPE_TAG_NAME (type
));
448 /* Return the type, stripped of typedefs. */
450 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
452 struct type
*type
= ((type_object
*) self
)->type
;
453 volatile struct gdb_exception except
;
455 TRY_CATCH (except
, RETURN_MASK_ALL
)
457 type
= check_typedef (type
);
459 GDB_PY_HANDLE_EXCEPTION (except
);
461 return type_to_type_object (type
);
464 /* Strip typedefs and pointers/reference from a type. Then check that
465 it is a struct, union, or enum type. If not, raise TypeError. */
468 typy_get_composite (struct type
*type
)
470 volatile struct gdb_exception except
;
474 TRY_CATCH (except
, RETURN_MASK_ALL
)
476 CHECK_TYPEDEF (type
);
478 GDB_PY_HANDLE_EXCEPTION (except
);
480 if (TYPE_CODE (type
) != TYPE_CODE_PTR
481 && TYPE_CODE (type
) != TYPE_CODE_REF
)
483 type
= TYPE_TARGET_TYPE (type
);
486 /* If this is not a struct, union, or enum type, raise TypeError
488 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
489 && TYPE_CODE (type
) != TYPE_CODE_UNION
490 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
492 PyErr_SetString (PyExc_TypeError
,
493 "Type is not a structure, union, or enum type.");
500 /* Helper for typy_array and typy_vector. */
503 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
506 PyObject
*n2_obj
= NULL
;
507 struct type
*array
= NULL
;
508 struct type
*type
= ((type_object
*) self
)->type
;
509 volatile struct gdb_exception except
;
511 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
516 if (!PyInt_Check (n2_obj
))
518 PyErr_SetString (PyExc_RuntimeError
,
519 _("Array bound must be an integer"));
523 if (! gdb_py_int_as_long (n2_obj
, &n2
))
534 PyErr_SetString (PyExc_ValueError
,
535 _("Array length must not be negative"));
539 TRY_CATCH (except
, RETURN_MASK_ALL
)
541 array
= lookup_array_range_type (type
, n1
, n2
);
543 make_vector_type (array
);
545 GDB_PY_HANDLE_EXCEPTION (except
);
547 return type_to_type_object (array
);
550 /* Return an array type. */
553 typy_array (PyObject
*self
, PyObject
*args
)
555 return typy_array_1 (self
, args
, 0);
558 /* Return a vector type. */
561 typy_vector (PyObject
*self
, PyObject
*args
)
563 return typy_array_1 (self
, args
, 1);
566 /* Return a Type object which represents a pointer to SELF. */
568 typy_pointer (PyObject
*self
, PyObject
*args
)
570 struct type
*type
= ((type_object
*) self
)->type
;
571 volatile struct gdb_exception except
;
573 TRY_CATCH (except
, RETURN_MASK_ALL
)
575 type
= lookup_pointer_type (type
);
577 GDB_PY_HANDLE_EXCEPTION (except
);
579 return type_to_type_object (type
);
582 /* Return the range of a type represented by SELF. The return type is
583 a tuple. The first element of the tuple contains the low bound,
584 while the second element of the tuple contains the high bound. */
586 typy_range (PyObject
*self
, PyObject
*args
)
588 struct type
*type
= ((type_object
*) self
)->type
;
590 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
591 /* Initialize these to appease GCC warnings. */
592 LONGEST low
= 0, high
= 0;
594 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
595 && TYPE_CODE (type
) != TYPE_CODE_STRING
596 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
598 PyErr_SetString (PyExc_RuntimeError
,
599 _("This type does not have a range."));
603 switch (TYPE_CODE (type
))
605 case TYPE_CODE_ARRAY
:
606 case TYPE_CODE_STRING
:
607 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
608 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
610 case TYPE_CODE_RANGE
:
611 low
= TYPE_LOW_BOUND (type
);
612 high
= TYPE_HIGH_BOUND (type
);
616 low_bound
= PyLong_FromLong (low
);
620 high_bound
= PyLong_FromLong (high
);
624 result
= PyTuple_New (2);
628 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
633 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
635 Py_DECREF (high_bound
);
642 Py_XDECREF (high_bound
);
643 Py_XDECREF (low_bound
);
647 /* Return a Type object which represents a reference to SELF. */
649 typy_reference (PyObject
*self
, PyObject
*args
)
651 struct type
*type
= ((type_object
*) self
)->type
;
652 volatile struct gdb_exception except
;
654 TRY_CATCH (except
, RETURN_MASK_ALL
)
656 type
= lookup_reference_type (type
);
658 GDB_PY_HANDLE_EXCEPTION (except
);
660 return type_to_type_object (type
);
663 /* Return a Type object which represents the target type of SELF. */
665 typy_target (PyObject
*self
, PyObject
*args
)
667 struct type
*type
= ((type_object
*) self
)->type
;
669 if (!TYPE_TARGET_TYPE (type
))
671 PyErr_SetString (PyExc_RuntimeError
,
672 _("Type does not have a target."));
676 return type_to_type_object (TYPE_TARGET_TYPE (type
));
679 /* Return a const-qualified type variant. */
681 typy_const (PyObject
*self
, PyObject
*args
)
683 struct type
*type
= ((type_object
*) self
)->type
;
684 volatile struct gdb_exception except
;
686 TRY_CATCH (except
, RETURN_MASK_ALL
)
688 type
= make_cv_type (1, 0, type
, NULL
);
690 GDB_PY_HANDLE_EXCEPTION (except
);
692 return type_to_type_object (type
);
695 /* Return a volatile-qualified type variant. */
697 typy_volatile (PyObject
*self
, PyObject
*args
)
699 struct type
*type
= ((type_object
*) self
)->type
;
700 volatile struct gdb_exception except
;
702 TRY_CATCH (except
, RETURN_MASK_ALL
)
704 type
= make_cv_type (0, 1, type
, NULL
);
706 GDB_PY_HANDLE_EXCEPTION (except
);
708 return type_to_type_object (type
);
711 /* Return an unqualified type variant. */
713 typy_unqualified (PyObject
*self
, PyObject
*args
)
715 struct type
*type
= ((type_object
*) self
)->type
;
716 volatile struct gdb_exception except
;
718 TRY_CATCH (except
, RETURN_MASK_ALL
)
720 type
= make_cv_type (0, 0, type
, NULL
);
722 GDB_PY_HANDLE_EXCEPTION (except
);
724 return type_to_type_object (type
);
727 /* Return the size of the type represented by SELF, in bytes. */
729 typy_get_sizeof (PyObject
*self
, void *closure
)
731 struct type
*type
= ((type_object
*) self
)->type
;
732 volatile struct gdb_exception except
;
734 TRY_CATCH (except
, RETURN_MASK_ALL
)
736 check_typedef (type
);
738 /* Ignore exceptions. */
740 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
744 typy_lookup_typename (const char *type_name
, const struct block
*block
)
746 struct type
*type
= NULL
;
747 volatile struct gdb_exception except
;
749 TRY_CATCH (except
, RETURN_MASK_ALL
)
751 if (!strncmp (type_name
, "struct ", 7))
752 type
= lookup_struct (type_name
+ 7, NULL
);
753 else if (!strncmp (type_name
, "union ", 6))
754 type
= lookup_union (type_name
+ 6, NULL
);
755 else if (!strncmp (type_name
, "enum ", 5))
756 type
= lookup_enum (type_name
+ 5, NULL
);
758 type
= lookup_typename (python_language
, python_gdbarch
,
759 type_name
, block
, 0);
761 GDB_PY_HANDLE_EXCEPTION (except
);
767 typy_lookup_type (struct demangle_component
*demangled
,
768 const struct block
*block
)
770 struct type
*type
, *rtype
= NULL
;
771 char *type_name
= NULL
;
772 enum demangle_component_type demangled_type
;
773 volatile struct gdb_exception except
;
775 /* Save the type: typy_lookup_type() may (indirectly) overwrite
776 memory pointed by demangled. */
777 demangled_type
= demangled
->type
;
779 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
780 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
781 || demangled_type
== DEMANGLE_COMPONENT_CONST
782 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
784 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
788 TRY_CATCH (except
, RETURN_MASK_ALL
)
790 /* If the demangled_type matches with one of the types
791 below, run the corresponding function and save the type
792 to return later. We cannot just return here as we are in
793 an exception handler. */
794 switch (demangled_type
)
796 case DEMANGLE_COMPONENT_REFERENCE
:
797 rtype
= lookup_reference_type (type
);
799 case DEMANGLE_COMPONENT_POINTER
:
800 rtype
= lookup_pointer_type (type
);
802 case DEMANGLE_COMPONENT_CONST
:
803 rtype
= make_cv_type (1, 0, type
, NULL
);
805 case DEMANGLE_COMPONENT_VOLATILE
:
806 rtype
= make_cv_type (0, 1, type
, NULL
);
810 GDB_PY_HANDLE_EXCEPTION (except
);
813 /* If we have a type from the switch statement above, just return
818 /* We don't have a type, so lookup the type. */
819 type_name
= cp_comp_to_string (demangled
, 10);
820 type
= typy_lookup_typename (type_name
, block
);
826 /* This is a helper function for typy_template_argument that is used
827 when the type does not have template symbols attached. It works by
828 parsing the type name. This happens with compilers, like older
829 versions of GCC, that do not emit DW_TAG_template_*. */
832 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
836 struct demangle_component
*demangled
;
837 struct demangle_parse_info
*info
= NULL
;
839 struct type
*argtype
;
840 struct cleanup
*cleanup
;
841 volatile struct gdb_exception except
;
843 if (TYPE_NAME (type
) == NULL
)
845 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
849 TRY_CATCH (except
, RETURN_MASK_ALL
)
851 /* Note -- this is not thread-safe. */
852 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
854 GDB_PY_HANDLE_EXCEPTION (except
);
858 PyErr_SetString (PyExc_RuntimeError
, err
);
861 demangled
= info
->tree
;
862 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
864 /* Strip off component names. */
865 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
866 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
867 demangled
= demangled
->u
.s_binary
.right
;
869 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
871 do_cleanups (cleanup
);
872 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
876 /* Skip from the template to the arguments. */
877 demangled
= demangled
->u
.s_binary
.right
;
879 for (i
= 0; demangled
&& i
< argno
; ++i
)
880 demangled
= demangled
->u
.s_binary
.right
;
884 do_cleanups (cleanup
);
885 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
890 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
891 do_cleanups (cleanup
);
895 return type_to_type_object (argtype
);
899 typy_template_argument (PyObject
*self
, PyObject
*args
)
902 struct type
*type
= ((type_object
*) self
)->type
;
903 const struct block
*block
= NULL
;
904 PyObject
*block_obj
= NULL
;
906 struct value
*val
= NULL
;
907 volatile struct gdb_exception except
;
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."));
923 TRY_CATCH (except
, RETURN_MASK_ALL
)
925 type
= check_typedef (type
);
926 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
927 type
= check_typedef (TYPE_TARGET_TYPE (type
));
929 GDB_PY_HANDLE_EXCEPTION (except
);
931 /* We might not have DW_TAG_template_*, so try to parse the type's
932 name. This is inefficient if we do not have a template type --
933 but that is going to wind up as an error anyhow. */
934 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
935 return typy_legacy_template_argument (type
, block
, argno
);
937 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
939 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
944 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
945 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
946 return type_to_type_object (SYMBOL_TYPE (sym
));
947 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
949 PyErr_Format (PyExc_RuntimeError
,
950 _("Template argument is optimized out"));
954 TRY_CATCH (except
, RETURN_MASK_ALL
)
956 val
= value_of_variable (sym
, block
);
958 GDB_PY_HANDLE_EXCEPTION (except
);
960 return value_to_value_object (val
);
964 typy_str (PyObject
*self
)
966 volatile struct gdb_exception except
;
967 char *thetype
= NULL
;
971 TRY_CATCH (except
, RETURN_MASK_ALL
)
973 struct cleanup
*old_chain
;
976 stb
= mem_fileopen ();
977 old_chain
= make_cleanup_ui_file_delete (stb
);
979 LA_PRINT_TYPE (type_object_to_type (self
), "", stb
, -1, 0,
980 &type_print_raw_options
);
982 thetype
= ui_file_xstrdup (stb
, &length
);
983 do_cleanups (old_chain
);
985 if (except
.reason
< 0)
988 GDB_PY_HANDLE_EXCEPTION (except
);
991 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
997 /* Implement the richcompare method. */
1000 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1003 struct type
*type1
= type_object_to_type (self
);
1004 struct type
*type2
= type_object_to_type (other
);
1005 volatile struct gdb_exception except
;
1007 /* We can only compare ourselves to another Type object, and only
1008 for equality or inequality. */
1009 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1011 Py_INCREF (Py_NotImplemented
);
1012 return Py_NotImplemented
;
1019 TRY_CATCH (except
, RETURN_MASK_ALL
)
1021 result
= types_deeply_equal (type1
, type2
);
1023 /* If there is a GDB exception, a comparison is not capable
1024 (or trusted), so exit. */
1025 GDB_PY_HANDLE_EXCEPTION (except
);
1028 if (op
== (result
? Py_EQ
: Py_NE
))
1035 static const struct objfile_data
*typy_objfile_data_key
;
1038 save_objfile_types (struct objfile
*objfile
, void *datum
)
1040 type_object
*obj
= datum
;
1041 htab_t copied_types
;
1042 struct cleanup
*cleanup
;
1044 if (!gdb_python_initialized
)
1047 /* This prevents another thread from freeing the objects we're
1049 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1051 copied_types
= create_copied_types_hash (objfile
);
1055 type_object
*next
= obj
->next
;
1057 htab_empty (copied_types
);
1059 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1067 htab_delete (copied_types
);
1069 do_cleanups (cleanup
);
1073 set_type (type_object
*obj
, struct type
*type
)
1077 if (type
&& TYPE_OBJFILE (type
))
1079 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1081 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1083 obj
->next
->prev
= obj
;
1084 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1091 typy_dealloc (PyObject
*obj
)
1093 type_object
*type
= (type_object
*) obj
;
1096 type
->prev
->next
= type
->next
;
1097 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1099 /* Must reset head of list. */
1100 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1103 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1106 type
->next
->prev
= type
->prev
;
1108 Py_TYPE (type
)->tp_free (type
);
1111 /* Return number of fields ("length" of the field dictionary). */
1114 typy_length (PyObject
*self
)
1116 struct type
*type
= ((type_object
*) self
)->type
;
1118 type
= typy_get_composite (type
);
1122 return TYPE_NFIELDS (type
);
1125 /* Implements boolean evaluation of gdb.Type. Handle this like other
1126 Python objects that don't have a meaningful truth value -- all
1130 typy_nonzero (PyObject
*self
)
1135 /* Return a gdb.Field object for the field named by the argument. */
1138 typy_getitem (PyObject
*self
, PyObject
*key
)
1140 struct type
*type
= ((type_object
*) self
)->type
;
1144 field
= python_string_to_host_string (key
);
1148 /* We want just fields of this type, not of base types, so instead of
1149 using lookup_struct_elt_type, portions of that function are
1152 type
= typy_get_composite (type
);
1156 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1158 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1160 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1162 return convert_field (type
, i
);
1165 PyErr_SetObject (PyExc_KeyError
, key
);
1169 /* Implement the "get" method on the type object. This is the
1170 same as getitem if the key is present, but returns the supplied
1171 default value or None if the key is not found. */
1174 typy_get (PyObject
*self
, PyObject
*args
)
1176 PyObject
*key
, *defval
= Py_None
, *result
;
1178 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1181 result
= typy_getitem (self
, key
);
1185 /* typy_getitem returned error status. If the exception is
1186 KeyError, clear the exception status and return the defval
1187 instead. Otherwise return the exception unchanged. */
1188 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1196 /* Implement the "has_key" method on the type object. */
1199 typy_has_key (PyObject
*self
, PyObject
*args
)
1201 struct type
*type
= ((type_object
*) self
)->type
;
1205 if (!PyArg_ParseTuple (args
, "s", &field
))
1208 /* We want just fields of this type, not of base types, so instead of
1209 using lookup_struct_elt_type, portions of that function are
1212 type
= typy_get_composite (type
);
1216 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1218 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1220 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1226 /* Make an iterator object to iterate over keys, values, or items. */
1229 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1231 typy_iterator_object
*typy_iter_obj
;
1233 /* Check that "self" is a structure or union type. */
1234 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1237 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1238 &type_iterator_object_type
);
1239 if (typy_iter_obj
== NULL
)
1242 typy_iter_obj
->field
= 0;
1243 typy_iter_obj
->kind
= kind
;
1245 typy_iter_obj
->source
= (type_object
*) self
;
1247 return (PyObject
*) typy_iter_obj
;
1250 /* iteritems() method. */
1253 typy_iteritems (PyObject
*self
, PyObject
*args
)
1255 return typy_make_iter (self
, iter_items
);
1258 /* iterkeys() method. */
1261 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1263 return typy_make_iter (self
, iter_keys
);
1266 /* Iterating over the class, same as iterkeys except for the function
1270 typy_iter (PyObject
*self
)
1272 return typy_make_iter (self
, iter_keys
);
1275 /* itervalues() method. */
1278 typy_itervalues (PyObject
*self
, PyObject
*args
)
1280 return typy_make_iter (self
, iter_values
);
1283 /* Return a reference to the type iterator. */
1286 typy_iterator_iter (PyObject
*self
)
1292 /* Return the next field in the iteration through the list of fields
1296 typy_iterator_iternext (PyObject
*self
)
1298 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1299 struct type
*type
= iter_obj
->source
->type
;
1302 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1304 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1314 typy_iterator_dealloc (PyObject
*obj
)
1316 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1318 Py_DECREF (iter_obj
->source
);
1321 /* Create a new Type referring to TYPE. */
1323 type_to_type_object (struct type
*type
)
1325 type_object
*type_obj
;
1327 type_obj
= PyObject_New (type_object
, &type_object_type
);
1329 set_type (type_obj
, type
);
1331 return (PyObject
*) type_obj
;
1335 type_object_to_type (PyObject
*obj
)
1337 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1339 return ((type_object
*) obj
)->type
;
1344 /* Implementation of gdb.lookup_type. */
1346 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1348 static char *keywords
[] = { "name", "block", NULL
};
1349 const char *type_name
= NULL
;
1350 struct type
*type
= NULL
;
1351 PyObject
*block_obj
= NULL
;
1352 const struct block
*block
= NULL
;
1354 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1355 &type_name
, &block_obj
))
1360 block
= block_object_to_block (block_obj
);
1363 PyErr_SetString (PyExc_RuntimeError
,
1364 _("'block' argument must be a Block."));
1369 type
= typy_lookup_typename (type_name
, block
);
1373 return (PyObject
*) type_to_type_object (type
);
1377 gdbpy_initialize_types (void)
1381 typy_objfile_data_key
1382 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1384 if (PyType_Ready (&type_object_type
) < 0)
1386 if (PyType_Ready (&field_object_type
) < 0)
1388 if (PyType_Ready (&type_iterator_object_type
) < 0)
1391 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1393 if (PyModule_AddIntConstant (gdb_module
,
1394 /* Cast needed for Python 2.4. */
1395 (char *) pyty_codes
[i
].name
,
1396 pyty_codes
[i
].code
) < 0)
1400 if (gdb_pymodule_addobject (gdb_module
, "Type",
1401 (PyObject
*) &type_object_type
) < 0)
1404 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1405 (PyObject
*) &type_iterator_object_type
) < 0)
1408 return gdb_pymodule_addobject (gdb_module
, "Field",
1409 (PyObject
*) &field_object_type
);
1414 static PyGetSetDef type_object_getset
[] =
1416 { "code", typy_get_code
, NULL
,
1417 "The code for this type.", NULL
},
1418 { "name", typy_get_name
, NULL
,
1419 "The name for this type, or None.", NULL
},
1420 { "sizeof", typy_get_sizeof
, NULL
,
1421 "The size of this type, in bytes.", NULL
},
1422 { "tag", typy_get_tag
, NULL
,
1423 "The tag name for this type, or None.", NULL
},
1427 static PyMethodDef type_object_methods
[] =
1429 { "array", typy_array
, METH_VARARGS
,
1430 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1431 Return a type which represents an array of objects of this type.\n\
1432 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1433 If LOW_BOUND is omitted, a value of zero is used." },
1434 { "vector", typy_vector
, METH_VARARGS
,
1435 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1436 Return a type which represents a vector of objects of this type.\n\
1437 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1438 If LOW_BOUND is omitted, a value of zero is used.\n\
1439 Vectors differ from arrays in that if the current language has C-style\n\
1440 arrays, vectors don't decay to a pointer to the first element.\n\
1441 They are first class values." },
1442 { "__contains__", typy_has_key
, METH_VARARGS
,
1443 "T.__contains__(k) -> True if T has a field named k, else False" },
1444 { "const", typy_const
, METH_NOARGS
,
1445 "const () -> Type\n\
1446 Return a const variant of this type." },
1447 { "fields", typy_fields
, METH_NOARGS
,
1448 "fields () -> list\n\
1449 Return a list holding all the fields of this type.\n\
1450 Each field is a gdb.Field object." },
1451 { "get", typy_get
, METH_VARARGS
,
1452 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1453 otherwise returns default, if supplied, or None if not." },
1454 { "has_key", typy_has_key
, METH_VARARGS
,
1455 "T.has_key(k) -> True if T has a field named k, else False" },
1456 { "items", typy_items
, METH_NOARGS
,
1457 "items () -> list\n\
1458 Return a list of (name, field) pairs of this type.\n\
1459 Each field is a gdb.Field object." },
1460 { "iteritems", typy_iteritems
, METH_NOARGS
,
1461 "iteritems () -> an iterator over the (name, field)\n\
1462 pairs of this type. Each field is a gdb.Field object." },
1463 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1464 "iterkeys () -> an iterator over the field names of this type." },
1465 { "itervalues", typy_itervalues
, METH_NOARGS
,
1466 "itervalues () -> an iterator over the fields of this type.\n\
1467 Each field is a gdb.Field object." },
1468 { "keys", typy_field_names
, METH_NOARGS
,
1470 Return a list holding all the fields names of this type." },
1471 { "pointer", typy_pointer
, METH_NOARGS
,
1472 "pointer () -> Type\n\
1473 Return a type of pointer to this type." },
1474 { "range", typy_range
, METH_NOARGS
,
1475 "range () -> tuple\n\
1476 Return a tuple containing the lower and upper range for this type."},
1477 { "reference", typy_reference
, METH_NOARGS
,
1478 "reference () -> Type\n\
1479 Return a type of reference to this type." },
1480 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1481 "strip_typedefs () -> Type\n\
1482 Return a type formed by stripping this type of all typedefs."},
1483 { "target", typy_target
, METH_NOARGS
,
1484 "target () -> Type\n\
1485 Return the target type of this type." },
1486 { "template_argument", typy_template_argument
, METH_VARARGS
,
1487 "template_argument (arg, [block]) -> Type\n\
1488 Return the type of a template argument." },
1489 { "unqualified", typy_unqualified
, METH_NOARGS
,
1490 "unqualified () -> Type\n\
1491 Return a variant of this type without const or volatile attributes." },
1492 { "values", typy_values
, METH_NOARGS
,
1493 "values () -> list\n\
1494 Return a list holding all the fields of this type.\n\
1495 Each field is a gdb.Field object." },
1496 { "volatile", typy_volatile
, METH_NOARGS
,
1497 "volatile () -> Type\n\
1498 Return a volatile variant of this type" },
1502 static PyNumberMethods type_object_as_number
= {
1504 NULL
, /* nb_subtract */
1505 NULL
, /* nb_multiply */
1507 NULL
, /* nb_divide */
1509 NULL
, /* nb_remainder */
1510 NULL
, /* nb_divmod */
1511 NULL
, /* nb_power */
1512 NULL
, /* nb_negative */
1513 NULL
, /* nb_positive */
1514 NULL
, /* nb_absolute */
1515 typy_nonzero
, /* nb_nonzero */
1516 NULL
, /* nb_invert */
1517 NULL
, /* nb_lshift */
1518 NULL
, /* nb_rshift */
1524 NULL
, /* reserved */
1526 NULL
, /* nb_coerce */
1530 NULL
, /* nb_float */
1537 static PyMappingMethods typy_mapping
= {
1540 NULL
/* no "set" method */
1543 static PyTypeObject type_object_type
=
1545 PyVarObject_HEAD_INIT (NULL
, 0)
1546 "gdb.Type", /*tp_name*/
1547 sizeof (type_object
), /*tp_basicsize*/
1549 typy_dealloc
, /*tp_dealloc*/
1555 &type_object_as_number
, /*tp_as_number*/
1556 0, /*tp_as_sequence*/
1557 &typy_mapping
, /*tp_as_mapping*/
1560 typy_str
, /*tp_str*/
1564 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1565 "GDB type object", /* tp_doc */
1566 0, /* tp_traverse */
1568 typy_richcompare
, /* tp_richcompare */
1569 0, /* tp_weaklistoffset */
1570 typy_iter
, /* tp_iter */
1571 0, /* tp_iternext */
1572 type_object_methods
, /* tp_methods */
1574 type_object_getset
, /* tp_getset */
1577 0, /* tp_descr_get */
1578 0, /* tp_descr_set */
1579 0, /* tp_dictoffset */
1585 static PyGetSetDef field_object_getset
[] =
1587 { "__dict__", gdb_py_generic_dict
, NULL
,
1588 "The __dict__ for this field.", &field_object_type
},
1592 static PyTypeObject field_object_type
=
1594 PyVarObject_HEAD_INIT (NULL
, 0)
1595 "gdb.Field", /*tp_name*/
1596 sizeof (field_object
), /*tp_basicsize*/
1598 field_dealloc
, /*tp_dealloc*/
1605 0, /*tp_as_sequence*/
1606 0, /*tp_as_mapping*/
1613 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1614 "GDB field object", /* tp_doc */
1615 0, /* tp_traverse */
1617 0, /* tp_richcompare */
1618 0, /* tp_weaklistoffset */
1620 0, /* tp_iternext */
1623 field_object_getset
, /* tp_getset */
1626 0, /* tp_descr_get */
1627 0, /* tp_descr_set */
1628 offsetof (field_object
, dict
), /* tp_dictoffset */
1634 static PyTypeObject type_iterator_object_type
= {
1635 PyVarObject_HEAD_INIT (NULL
, 0)
1636 "gdb.TypeIterator", /*tp_name*/
1637 sizeof (typy_iterator_object
), /*tp_basicsize*/
1639 typy_iterator_dealloc
, /*tp_dealloc*/
1646 0, /*tp_as_sequence*/
1647 0, /*tp_as_mapping*/
1654 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1655 "GDB type iterator object", /*tp_doc */
1658 0, /*tp_richcompare */
1659 0, /*tp_weaklistoffset */
1660 typy_iterator_iter
, /*tp_iter */
1661 typy_iterator_iternext
, /*tp_iternext */