1 /* Python interface to types.
3 Copyright (C) 2008, 2009, 2010, 2011 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"
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
;
48 typedef struct pyty_field_object
52 /* Dictionary holding our attributes. */
56 static PyTypeObject field_object_type
;
58 /* This is used to initialize various gdb.TYPE_ constants. */
67 #define ENTRY(X) { X, #X }
69 static struct pyty_code pyty_codes
[] =
71 ENTRY (TYPE_CODE_PTR
),
72 ENTRY (TYPE_CODE_ARRAY
),
73 ENTRY (TYPE_CODE_STRUCT
),
74 ENTRY (TYPE_CODE_UNION
),
75 ENTRY (TYPE_CODE_ENUM
),
76 ENTRY (TYPE_CODE_FLAGS
),
77 ENTRY (TYPE_CODE_FUNC
),
78 ENTRY (TYPE_CODE_INT
),
79 ENTRY (TYPE_CODE_FLT
),
80 ENTRY (TYPE_CODE_VOID
),
81 ENTRY (TYPE_CODE_SET
),
82 ENTRY (TYPE_CODE_RANGE
),
83 ENTRY (TYPE_CODE_STRING
),
84 ENTRY (TYPE_CODE_BITSTRING
),
85 ENTRY (TYPE_CODE_ERROR
),
86 ENTRY (TYPE_CODE_METHOD
),
87 ENTRY (TYPE_CODE_METHODPTR
),
88 ENTRY (TYPE_CODE_MEMBERPTR
),
89 ENTRY (TYPE_CODE_REF
),
90 ENTRY (TYPE_CODE_CHAR
),
91 ENTRY (TYPE_CODE_BOOL
),
92 ENTRY (TYPE_CODE_COMPLEX
),
93 ENTRY (TYPE_CODE_TYPEDEF
),
94 ENTRY (TYPE_CODE_NAMESPACE
),
95 ENTRY (TYPE_CODE_DECFLOAT
),
96 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
97 { TYPE_CODE_UNDEF
, NULL
}
103 field_dealloc (PyObject
*obj
)
105 field_object
*f
= (field_object
*) obj
;
107 Py_XDECREF (f
->dict
);
108 f
->ob_type
->tp_free (obj
);
114 field_object
*result
= PyObject_New (field_object
, &field_object_type
);
118 result
->dict
= PyDict_New ();
125 return (PyObject
*) result
;
130 /* Return the code for this type. */
132 typy_get_code (PyObject
*self
, void *closure
)
134 struct type
*type
= ((type_object
*) self
)->type
;
136 return PyInt_FromLong (TYPE_CODE (type
));
139 /* Helper function for typy_fields which converts a single field to a
140 dictionary. Returns NULL on error. */
142 convert_field (struct type
*type
, int field
)
144 PyObject
*result
= field_new ();
150 if (!field_is_static (&TYPE_FIELD (type
, field
)))
152 arg
= PyLong_FromLong (TYPE_FIELD_BITPOS (type
, field
));
156 if (PyObject_SetAttrString (result
, "bitpos", arg
) < 0)
160 if (TYPE_FIELD_NAME (type
, field
))
161 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
169 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
172 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
174 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
177 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
178 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
182 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
185 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
188 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
191 /* A field can have a NULL type in some situations. */
192 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
198 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
201 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
213 /* Return a sequence of all fields. Each field is a dictionary with
214 some pre-defined keys. */
216 typy_fields (PyObject
*self
, PyObject
*args
)
220 struct type
*type
= ((type_object
*) self
)->type
;
221 volatile struct gdb_exception except
;
223 TRY_CATCH (except
, RETURN_MASK_ALL
)
225 CHECK_TYPEDEF (type
);
227 GDB_PY_HANDLE_EXCEPTION (except
);
229 /* We would like to make a tuple here, make fields immutable, and
230 then memoize the result (and perhaps make Field.type() lazy).
231 However, that can lead to cycles. */
232 result
= PyList_New (0);
234 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
236 PyObject
*dict
= convert_field (type
, i
);
243 if (PyList_Append (result
, dict
))
254 /* Return the type's tag, or None. */
256 typy_get_tag (PyObject
*self
, void *closure
)
258 struct type
*type
= ((type_object
*) self
)->type
;
260 if (!TYPE_TAG_NAME (type
))
262 return PyString_FromString (TYPE_TAG_NAME (type
));
265 /* Return the type, stripped of typedefs. */
267 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
269 struct type
*type
= ((type_object
*) self
)->type
;
271 return type_to_type_object (check_typedef (type
));
274 /* Return an array type. */
277 typy_array (PyObject
*self
, PyObject
*args
)
280 PyObject
*n2_obj
= NULL
;
281 struct type
*array
= NULL
;
282 struct type
*type
= ((type_object
*) self
)->type
;
283 volatile struct gdb_exception except
;
285 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
290 if (!PyInt_Check (n2_obj
))
292 PyErr_SetString (PyExc_RuntimeError
,
293 _("Array bound must be an integer"));
297 if (! gdb_py_int_as_long (n2_obj
, &n2
))
308 PyErr_SetString (PyExc_ValueError
,
309 _("Array length must not be negative"));
313 TRY_CATCH (except
, RETURN_MASK_ALL
)
315 array
= lookup_array_range_type (type
, n1
, n2
);
317 GDB_PY_HANDLE_EXCEPTION (except
);
319 return type_to_type_object (array
);
322 /* Return a Type object which represents a pointer to SELF. */
324 typy_pointer (PyObject
*self
, PyObject
*args
)
326 struct type
*type
= ((type_object
*) self
)->type
;
327 volatile struct gdb_exception except
;
329 TRY_CATCH (except
, RETURN_MASK_ALL
)
331 type
= lookup_pointer_type (type
);
333 GDB_PY_HANDLE_EXCEPTION (except
);
335 return type_to_type_object (type
);
338 /* Return the range of a type represented by SELF. The return type is
339 a tuple. The first element of the tuple contains the low bound,
340 while the second element of the tuple contains the high bound. */
342 typy_range (PyObject
*self
, PyObject
*args
)
344 struct type
*type
= ((type_object
*) self
)->type
;
346 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
347 /* Initialize these to appease GCC warnings. */
348 LONGEST low
= 0, high
= 0;
350 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
351 && TYPE_CODE (type
) != TYPE_CODE_STRING
352 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
354 PyErr_SetString (PyExc_RuntimeError
,
355 _("This type does not have a range."));
359 switch (TYPE_CODE (type
))
361 case TYPE_CODE_ARRAY
:
362 case TYPE_CODE_STRING
:
363 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
364 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
366 case TYPE_CODE_RANGE
:
367 low
= TYPE_LOW_BOUND (type
);
368 high
= TYPE_HIGH_BOUND (type
);
372 low_bound
= PyLong_FromLong (low
);
376 high_bound
= PyLong_FromLong (high
);
380 result
= PyTuple_New (2);
384 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
389 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
391 Py_DECREF (high_bound
);
398 Py_XDECREF (high_bound
);
399 Py_XDECREF (low_bound
);
403 /* Return a Type object which represents a reference to SELF. */
405 typy_reference (PyObject
*self
, PyObject
*args
)
407 struct type
*type
= ((type_object
*) self
)->type
;
408 volatile struct gdb_exception except
;
410 TRY_CATCH (except
, RETURN_MASK_ALL
)
412 type
= lookup_reference_type (type
);
414 GDB_PY_HANDLE_EXCEPTION (except
);
416 return type_to_type_object (type
);
419 /* Return a Type object which represents the target type of SELF. */
421 typy_target (PyObject
*self
, PyObject
*args
)
423 struct type
*type
= ((type_object
*) self
)->type
;
425 if (!TYPE_TARGET_TYPE (type
))
427 PyErr_SetString (PyExc_RuntimeError
,
428 _("Type does not have a target."));
432 return type_to_type_object (TYPE_TARGET_TYPE (type
));
435 /* Return a const-qualified type variant. */
437 typy_const (PyObject
*self
, PyObject
*args
)
439 struct type
*type
= ((type_object
*) self
)->type
;
440 volatile struct gdb_exception except
;
442 TRY_CATCH (except
, RETURN_MASK_ALL
)
444 type
= make_cv_type (1, 0, type
, NULL
);
446 GDB_PY_HANDLE_EXCEPTION (except
);
448 return type_to_type_object (type
);
451 /* Return a volatile-qualified type variant. */
453 typy_volatile (PyObject
*self
, PyObject
*args
)
455 struct type
*type
= ((type_object
*) self
)->type
;
456 volatile struct gdb_exception except
;
458 TRY_CATCH (except
, RETURN_MASK_ALL
)
460 type
= make_cv_type (0, 1, type
, NULL
);
462 GDB_PY_HANDLE_EXCEPTION (except
);
464 return type_to_type_object (type
);
467 /* Return an unqualified type variant. */
469 typy_unqualified (PyObject
*self
, PyObject
*args
)
471 struct type
*type
= ((type_object
*) self
)->type
;
472 volatile struct gdb_exception except
;
474 TRY_CATCH (except
, RETURN_MASK_ALL
)
476 type
= make_cv_type (0, 0, type
, NULL
);
478 GDB_PY_HANDLE_EXCEPTION (except
);
480 return type_to_type_object (type
);
483 /* Return the size of the type represented by SELF, in bytes. */
485 typy_get_sizeof (PyObject
*self
, void *closure
)
487 struct type
*type
= ((type_object
*) self
)->type
;
488 volatile struct gdb_exception except
;
490 TRY_CATCH (except
, RETURN_MASK_ALL
)
492 check_typedef (type
);
494 /* Ignore exceptions. */
496 return PyLong_FromLong (TYPE_LENGTH (type
));
500 typy_lookup_typename (char *type_name
, struct block
*block
)
502 struct type
*type
= NULL
;
503 volatile struct gdb_exception except
;
505 TRY_CATCH (except
, RETURN_MASK_ALL
)
507 if (!strncmp (type_name
, "struct ", 7))
508 type
= lookup_struct (type_name
+ 7, NULL
);
509 else if (!strncmp (type_name
, "union ", 6))
510 type
= lookup_union (type_name
+ 6, NULL
);
511 else if (!strncmp (type_name
, "enum ", 5))
512 type
= lookup_enum (type_name
+ 5, NULL
);
514 type
= lookup_typename (python_language
, python_gdbarch
,
515 type_name
, block
, 0);
517 if (except
.reason
< 0)
519 PyErr_Format (except
.reason
== RETURN_QUIT
520 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
521 "%s", except
.message
);
529 typy_lookup_type (struct demangle_component
*demangled
,
534 enum demangle_component_type demangled_type
;
536 /* Save the type: typy_lookup_type() may (indirectly) overwrite
537 memory pointed by demangled. */
538 demangled_type
= demangled
->type
;
540 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
541 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
542 || demangled_type
== DEMANGLE_COMPONENT_CONST
543 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
545 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
549 switch (demangled_type
)
551 case DEMANGLE_COMPONENT_REFERENCE
:
552 return lookup_reference_type (type
);
553 case DEMANGLE_COMPONENT_POINTER
:
554 return lookup_pointer_type (type
);
555 case DEMANGLE_COMPONENT_CONST
:
556 return make_cv_type (1, 0, type
, NULL
);
557 case DEMANGLE_COMPONENT_VOLATILE
:
558 return make_cv_type (0, 1, type
, NULL
);
562 type_name
= cp_comp_to_string (demangled
, 10);
563 type
= typy_lookup_typename (type_name
, block
);
569 /* This is a helper function for typy_template_argument that is used
570 when the type does not have template symbols attached. It works by
571 parsing the type name. This happens with compilers, like older
572 versions of GCC, that do not emit DW_TAG_template_*. */
575 typy_legacy_template_argument (struct type
*type
, struct block
*block
,
579 struct demangle_component
*demangled
;
581 struct type
*argtype
;
583 if (TYPE_NAME (type
) == NULL
)
585 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
589 /* Note -- this is not thread-safe. */
590 demangled
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
593 PyErr_SetString (PyExc_RuntimeError
, err
);
597 /* Strip off component names. */
598 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
599 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
600 demangled
= demangled
->u
.s_binary
.right
;
602 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
604 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
608 /* Skip from the template to the arguments. */
609 demangled
= demangled
->u
.s_binary
.right
;
611 for (i
= 0; demangled
&& i
< argno
; ++i
)
612 demangled
= demangled
->u
.s_binary
.right
;
616 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
621 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
625 return type_to_type_object (argtype
);
629 typy_template_argument (PyObject
*self
, PyObject
*args
)
632 struct type
*type
= ((type_object
*) self
)->type
;
633 struct block
*block
= NULL
;
634 PyObject
*block_obj
= NULL
;
636 struct value
*val
= NULL
;
637 volatile struct gdb_exception except
;
639 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
644 block
= block_object_to_block (block_obj
);
647 PyErr_SetString (PyExc_RuntimeError
,
648 _("Second argument must be block."));
653 TRY_CATCH (except
, RETURN_MASK_ALL
)
655 type
= check_typedef (type
);
656 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
657 type
= check_typedef (TYPE_TARGET_TYPE (type
));
659 GDB_PY_HANDLE_EXCEPTION (except
);
661 /* We might not have DW_TAG_template_*, so try to parse the type's
662 name. This is inefficient if we do not have a template type --
663 but that is going to wind up as an error anyhow. */
664 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
665 return typy_legacy_template_argument (type
, block
, argno
);
667 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
669 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
674 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
675 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
676 return type_to_type_object (SYMBOL_TYPE (sym
));
677 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
679 PyErr_Format (PyExc_RuntimeError
,
680 _("Template argument is optimized out"));
684 TRY_CATCH (except
, RETURN_MASK_ALL
)
686 val
= value_of_variable (sym
, block
);
688 GDB_PY_HANDLE_EXCEPTION (except
);
690 return value_to_value_object (val
);
694 typy_str (PyObject
*self
)
696 volatile struct gdb_exception except
;
697 char *thetype
= NULL
;
701 TRY_CATCH (except
, RETURN_MASK_ALL
)
703 struct cleanup
*old_chain
;
706 stb
= mem_fileopen ();
707 old_chain
= make_cleanup_ui_file_delete (stb
);
709 type_print (type_object_to_type (self
), "", stb
, -1);
711 thetype
= ui_file_xstrdup (stb
, &length
);
712 do_cleanups (old_chain
);
714 if (except
.reason
< 0)
717 GDB_PY_HANDLE_EXCEPTION (except
);
720 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
726 /* An entry in the type-equality bcache. */
728 typedef struct type_equality_entry
730 struct type
*type1
, *type2
;
731 } type_equality_entry_d
;
733 DEF_VEC_O (type_equality_entry_d
);
735 /* A helper function to compare two strings. Returns 1 if they are
736 the same, 0 otherwise. Handles NULLs properly. */
739 compare_strings (const char *s
, const char *t
)
741 if (s
== NULL
&& t
!= NULL
)
743 else if (s
!= NULL
&& t
== NULL
)
745 else if (s
== NULL
&& t
== NULL
)
747 return strcmp (s
, t
) == 0;
750 /* A helper function for typy_richcompare that checks two types for
751 "deep" equality. Returns Py_EQ if the types are considered the
752 same, Py_NE otherwise. */
755 check_types_equal (struct type
*type1
, struct type
*type2
,
756 VEC (type_equality_entry_d
) **worklist
)
758 CHECK_TYPEDEF (type1
);
759 CHECK_TYPEDEF (type2
);
764 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
765 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
766 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
767 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
768 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
769 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
770 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
771 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
772 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
775 if (!compare_strings (TYPE_TAG_NAME (type1
), TYPE_TAG_NAME (type2
)))
777 if (!compare_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
780 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
782 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
783 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
790 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
792 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
793 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
794 struct type_equality_entry entry
;
796 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
797 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
798 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
800 if (!compare_strings (FIELD_NAME (*field1
), FIELD_NAME (*field2
)))
802 switch (FIELD_LOC_KIND (*field1
))
804 case FIELD_LOC_KIND_BITPOS
:
805 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
808 case FIELD_LOC_KIND_PHYSADDR
:
809 if (FIELD_STATIC_PHYSADDR (*field1
)
810 != FIELD_STATIC_PHYSADDR (*field2
))
813 case FIELD_LOC_KIND_PHYSNAME
:
814 if (!compare_strings (FIELD_STATIC_PHYSNAME (*field1
),
815 FIELD_STATIC_PHYSNAME (*field2
)))
820 entry
.type1
= FIELD_TYPE (*field1
);
821 entry
.type2
= FIELD_TYPE (*field2
);
822 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
826 if (TYPE_TARGET_TYPE (type1
) != NULL
)
828 struct type_equality_entry entry
;
831 if (TYPE_TARGET_TYPE (type2
) == NULL
)
834 entry
.type1
= TYPE_TARGET_TYPE (type1
);
835 entry
.type2
= TYPE_TARGET_TYPE (type2
);
836 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
838 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
844 /* Check types on a worklist for equality. Returns Py_NE if any pair
845 is not equal, Py_EQ if they are all considered equal. */
848 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
849 struct bcache
*cache
)
851 while (!VEC_empty (type_equality_entry_d
, *worklist
))
853 struct type_equality_entry entry
;
856 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
857 VEC_pop (type_equality_entry_d
, *worklist
);
859 /* If the type pair has already been visited, we know it is
861 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
865 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
872 /* Implement the richcompare method. */
875 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
878 struct type
*type1
= type_object_to_type (self
);
879 struct type
*type2
= type_object_to_type (other
);
880 volatile struct gdb_exception except
;
882 /* We can only compare ourselves to another Type object, and only
883 for equality or inequality. */
884 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
886 Py_INCREF (Py_NotImplemented
);
887 return Py_NotImplemented
;
894 struct bcache
*cache
;
895 VEC (type_equality_entry_d
) *worklist
= NULL
;
896 struct type_equality_entry entry
;
898 cache
= bcache_xmalloc (NULL
, NULL
);
902 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
904 TRY_CATCH (except
, RETURN_MASK_ALL
)
906 result
= check_types_worklist (&worklist
, cache
);
908 if (except
.reason
< 0)
911 bcache_xfree (cache
);
912 VEC_free (type_equality_entry_d
, worklist
);
922 static const struct objfile_data
*typy_objfile_data_key
;
925 save_objfile_types (struct objfile
*objfile
, void *datum
)
927 type_object
*obj
= datum
;
929 struct cleanup
*cleanup
;
931 /* This prevents another thread from freeing the objects we're
933 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
935 copied_types
= create_copied_types_hash (objfile
);
939 type_object
*next
= obj
->next
;
941 htab_empty (copied_types
);
943 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
951 htab_delete (copied_types
);
953 do_cleanups (cleanup
);
957 set_type (type_object
*obj
, struct type
*type
)
961 if (type
&& TYPE_OBJFILE (type
))
963 struct objfile
*objfile
= TYPE_OBJFILE (type
);
965 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
967 obj
->next
->prev
= obj
;
968 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
975 typy_dealloc (PyObject
*obj
)
977 type_object
*type
= (type_object
*) obj
;
980 type
->prev
->next
= type
->next
;
981 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
983 /* Must reset head of list. */
984 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
987 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
990 type
->next
->prev
= type
->prev
;
992 type
->ob_type
->tp_free (type
);
995 /* Create a new Type referring to TYPE. */
997 type_to_type_object (struct type
*type
)
999 type_object
*type_obj
;
1001 type_obj
= PyObject_New (type_object
, &type_object_type
);
1003 set_type (type_obj
, type
);
1005 return (PyObject
*) type_obj
;
1009 type_object_to_type (PyObject
*obj
)
1011 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1013 return ((type_object
*) obj
)->type
;
1018 /* Implementation of gdb.lookup_type. */
1020 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1022 static char *keywords
[] = { "name", "block", NULL
};
1023 char *type_name
= NULL
;
1024 struct type
*type
= NULL
;
1025 PyObject
*block_obj
= NULL
;
1026 struct block
*block
= NULL
;
1028 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1029 &type_name
, &block_obj
))
1034 block
= block_object_to_block (block_obj
);
1037 PyErr_SetString (PyExc_RuntimeError
,
1038 _("'block' argument must be a Block."));
1043 type
= typy_lookup_typename (type_name
, block
);
1047 return (PyObject
*) type_to_type_object (type
);
1051 gdbpy_initialize_types (void)
1055 typy_objfile_data_key
1056 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1058 if (PyType_Ready (&type_object_type
) < 0)
1060 if (PyType_Ready (&field_object_type
) < 0)
1063 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1065 if (PyModule_AddIntConstant (gdb_module
,
1066 /* Cast needed for Python 2.4. */
1067 (char *) pyty_codes
[i
].name
,
1068 pyty_codes
[i
].code
) < 0)
1072 Py_INCREF (&type_object_type
);
1073 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1075 Py_INCREF (&field_object_type
);
1076 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1081 static PyGetSetDef type_object_getset
[] =
1083 { "code", typy_get_code
, NULL
,
1084 "The code for this type.", NULL
},
1085 { "sizeof", typy_get_sizeof
, NULL
,
1086 "The size of this type, in bytes.", NULL
},
1087 { "tag", typy_get_tag
, NULL
,
1088 "The tag name for this type, or None.", NULL
},
1092 static PyMethodDef type_object_methods
[] =
1094 { "array", typy_array
, METH_VARARGS
,
1095 "array (N) -> Type\n\
1096 Return a type which represents an array of N objects of this type." },
1097 { "const", typy_const
, METH_NOARGS
,
1098 "const () -> Type\n\
1099 Return a const variant of this type." },
1100 { "fields", typy_fields
, METH_NOARGS
,
1101 "field () -> list\n\
1102 Return a sequence holding all the fields of this type.\n\
1103 Each field is a dictionary." },
1104 { "pointer", typy_pointer
, METH_NOARGS
,
1105 "pointer () -> Type\n\
1106 Return a type of pointer to this type." },
1107 { "range", typy_range
, METH_NOARGS
,
1108 "range () -> tuple\n\
1109 Return a tuple containing the lower and upper range for this type."},
1110 { "reference", typy_reference
, METH_NOARGS
,
1111 "reference () -> Type\n\
1112 Return a type of reference to this type." },
1113 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1114 "strip_typedefs () -> Type\n\
1115 Return a type formed by stripping this type of all typedefs."},
1116 { "target", typy_target
, METH_NOARGS
,
1117 "target () -> Type\n\
1118 Return the target type of this type." },
1119 { "template_argument", typy_template_argument
, METH_VARARGS
,
1120 "template_argument (arg, [block]) -> Type\n\
1121 Return the type of a template argument." },
1122 { "unqualified", typy_unqualified
, METH_NOARGS
,
1123 "unqualified () -> Type\n\
1124 Return a variant of this type without const or volatile attributes." },
1125 { "volatile", typy_volatile
, METH_NOARGS
,
1126 "volatile () -> Type\n\
1127 Return a volatile variant of this type" },
1131 static PyTypeObject type_object_type
=
1133 PyObject_HEAD_INIT (NULL
)
1135 "gdb.Type", /*tp_name*/
1136 sizeof (type_object
), /*tp_basicsize*/
1138 typy_dealloc
, /*tp_dealloc*/
1145 0, /*tp_as_sequence*/
1146 0, /*tp_as_mapping*/
1149 typy_str
, /*tp_str*/
1153 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1154 "GDB type object", /* tp_doc */
1155 0, /* tp_traverse */
1157 typy_richcompare
, /* tp_richcompare */
1158 0, /* tp_weaklistoffset */
1160 0, /* tp_iternext */
1161 type_object_methods
, /* tp_methods */
1163 type_object_getset
, /* tp_getset */
1166 0, /* tp_descr_get */
1167 0, /* tp_descr_set */
1168 0, /* tp_dictoffset */
1174 static PyTypeObject field_object_type
=
1176 PyObject_HEAD_INIT (NULL
)
1178 "gdb.Field", /*tp_name*/
1179 sizeof (field_object
), /*tp_basicsize*/
1181 field_dealloc
, /*tp_dealloc*/
1188 0, /*tp_as_sequence*/
1189 0, /*tp_as_mapping*/
1196 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1197 "GDB field object", /* tp_doc */
1198 0, /* tp_traverse */
1200 0, /* tp_richcompare */
1201 0, /* tp_weaklistoffset */
1203 0, /* tp_iternext */
1209 0, /* tp_descr_get */
1210 0, /* tp_descr_set */
1211 offsetof (field_object
, dict
), /* tp_dictoffset */