1 /* Python interface to types.
3 Copyright (C) 2008-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "python-internal.h"
25 #include "cp-support.h"
30 #include "typeprint.h"
32 typedef struct pyty_type_object
37 /* If a Type object is associated with an objfile, it is kept on a
38 doubly-linked list, rooted in the objfile. This lets us copy the
39 underlying struct type when the objfile is deleted. */
40 struct pyty_type_object *prev;
41 struct pyty_type_object *next;
44 extern PyTypeObject type_object_type
45 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
48 typedef struct pyty_field_object
52 /* Dictionary holding our attributes. */
56 extern PyTypeObject field_object_type
57 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
59 /* A type iterator object. */
62 /* The current field index. */
65 enum gdbpy_iter_kind kind;
66 /* Pointer back to the original source type object. */
67 struct pyty_type_object *source;
68 } typy_iterator_object;
70 extern PyTypeObject type_iterator_object_type
71 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
73 /* This is used to initialize various gdb.TYPE_ constants. */
82 /* Forward declarations. */
83 static PyObject *typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind);
85 #define ENTRY(X) { X, #X }
87 static struct pyty_code pyty_codes[] =
89 ENTRY (TYPE_CODE_BITSTRING),
90 ENTRY (TYPE_CODE_PTR),
91 ENTRY (TYPE_CODE_ARRAY),
92 ENTRY (TYPE_CODE_STRUCT),
93 ENTRY (TYPE_CODE_UNION),
94 ENTRY (TYPE_CODE_ENUM),
95 ENTRY (TYPE_CODE_FLAGS),
96 ENTRY (TYPE_CODE_FUNC),
97 ENTRY (TYPE_CODE_INT),
98 ENTRY (TYPE_CODE_FLT),
99 ENTRY (TYPE_CODE_VOID),
100 ENTRY (TYPE_CODE_SET),
101 ENTRY (TYPE_CODE_RANGE),
102 ENTRY (TYPE_CODE_STRING),
103 ENTRY (TYPE_CODE_ERROR),
104 ENTRY (TYPE_CODE_METHOD),
105 ENTRY (TYPE_CODE_METHODPTR),
106 ENTRY (TYPE_CODE_MEMBERPTR),
107 ENTRY (TYPE_CODE_REF),
108 ENTRY (TYPE_CODE_CHAR),
109 ENTRY (TYPE_CODE_BOOL),
110 ENTRY (TYPE_CODE_COMPLEX),
111 ENTRY (TYPE_CODE_TYPEDEF),
112 ENTRY (TYPE_CODE_NAMESPACE),
113 ENTRY (TYPE_CODE_DECFLOAT),
114 ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
115 { TYPE_CODE_UNDEF, NULL }
121 field_dealloc (PyObject *obj)
123 field_object *f = (field_object *) obj;
125 Py_XDECREF (f->dict);
126 Py_TYPE (obj)->tp_free (obj);
132 field_object *result = PyObject_New (field_object, &field_object_type);
136 result->dict = PyDict_New ();
143 return (PyObject *) result;
148 /* Return true if OBJ is of type gdb.Field, false otherwise. */
151 gdbpy_is_field (PyObject *obj)
153 return PyObject_TypeCheck (obj, &field_object_type);
156 /* Return the code for this type. */
158 typy_get_code (PyObject *self, void *closure)
160 struct type *type = ((type_object *) self)->type;
162 return PyInt_FromLong (TYPE_CODE (type));
165 /* Helper function for typy_fields which converts a single field to a
166 gdb.Field object. Returns NULL on error. */
169 convert_field (struct type *type, int field)
171 PyObject *result = field_new ();
177 arg = type_to_type_object (type);
180 if (PyObject_SetAttrString (result, "parent_type", arg) < 0)
184 if (!field_is_static (&TYPE_FIELD (type, field)))
186 const char *attrstring;
188 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
190 arg = gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type, field));
191 attrstring = "enumval";
195 arg = gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type, field));
196 attrstring = "bitpos";
202 /* At least python-2.4 had the second parameter non-const. */
203 if (PyObject_SetAttrString (result, (char *) attrstring, arg) < 0)
209 if (TYPE_FIELD_NAME (type, field))
211 const char *field_name = TYPE_FIELD_NAME (type, field);
213 if (field_name[0] != '\0')
215 arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
225 if (PyObject_SetAttrString (result, "name", arg) < 0)
229 arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
231 if (PyObject_SetAttrString (result, "artificial", arg) < 0)
235 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
236 arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
240 if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
244 arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
247 if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
251 /* A field can have a NULL type in some situations. */
252 if (TYPE_FIELD_TYPE (type, field) == NULL)
258 arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
261 if (PyObject_SetAttrString (result, "type", arg) < 0)
274 /* Helper function to return the name of a field, as a gdb.Field object.
275 If the field doesn't have a name, None is returned. */
278 field_name (struct type *type, int field)
282 if (TYPE_FIELD_NAME (type, field))
283 result = PyString_FromString (TYPE_FIELD_NAME (type, field));
292 /* Helper function for Type standard mapping methods. Returns a
293 Python object for field i of the type. "kind" specifies what to
294 return: the name of the field, a gdb.Field object corresponding to
295 the field, or a tuple consisting of field name and gdb.Field
299 make_fielditem (struct type *type, int i, enum gdbpy_iter_kind kind)
301 PyObject *item = NULL, *key = NULL, *value = NULL;
306 key = field_name (type, i);
309 value = convert_field (type, i);
312 item = PyTuple_New (2);
315 PyTuple_SET_ITEM (item, 0, key);
316 PyTuple_SET_ITEM (item, 1, value);
319 item = field_name (type, i);
322 item = convert_field (type, i);
325 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
336 /* Return a sequence of all field names, fields, or (name, field) pairs.
337 Each field is a gdb.Field object. */
340 typy_fields_items (PyObject *self, enum gdbpy_iter_kind kind)
342 PyObject *py_type = self;
343 PyObject *result = NULL, *iter = NULL;
344 volatile struct gdb_exception except;
345 struct type *type = ((type_object *) py_type)->type;
346 struct type *checked_type = type;
348 TRY_CATCH (except, RETURN_MASK_ALL)
350 CHECK_TYPEDEF (checked_type);
352 GDB_PY_HANDLE_EXCEPTION (except);
354 if (checked_type != type)
355 py_type = type_to_type_object (checked_type);
356 iter = typy_make_iter (py_type, kind);
357 if (checked_type != type)
359 /* Need to wrap this in braces because Py_DECREF isn't wrapped
360 in a do{}while(0). */
365 result = PySequence_List (iter);
372 /* Return a sequence of all fields. Each field is a gdb.Field object. */
375 typy_values (PyObject *self, PyObject *args)
377 return typy_fields_items (self, iter_values);
380 /* Return a sequence of all fields. Each field is a gdb.Field object.
381 This method is similar to typy_values, except where the supplied
382 gdb.Type is an array, in which case it returns a list of one entry
383 which is a gdb.Field object for a range (the array bounds). */
386 typy_fields (PyObject *self, PyObject *args)
388 struct type *type = ((type_object *) self)->type;
391 if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
392 return typy_fields_items (self, iter_values);
394 /* Array type. Handle this as a special case because the common
395 machinery wants struct or union or enum types. Build a list of
396 one entry which is the range for the array. */
397 r = convert_field (type, 0);
401 rl = Py_BuildValue ("[O]", r);
407 /* Return a sequence of all field names. Each field is a gdb.Field object. */
410 typy_field_names (PyObject *self, PyObject *args)
412 return typy_fields_items (self, iter_keys);
415 /* Return a sequence of all (name, fields) pairs. Each field is a
419 typy_items (PyObject *self, PyObject *args)
421 return typy_fields_items (self, iter_items);
424 /* Return the type's name, or None. */
427 typy_get_name (PyObject *self, void *closure)
429 struct type *type = ((type_object *) self)->type;
431 if (TYPE_NAME (type) == NULL)
433 return PyString_FromString (TYPE_NAME (type));
436 /* Return the type's tag, or None. */
438 typy_get_tag (PyObject *self, void *closure)
440 struct type *type = ((type_object *) self)->type;
442 if (!TYPE_TAG_NAME (type))
444 return PyString_FromString (TYPE_TAG_NAME (type));
447 /* Return the type, stripped of typedefs. */
449 typy_strip_typedefs (PyObject *self, PyObject *args)
451 struct type *type = ((type_object *) self)->type;
452 volatile struct gdb_exception except;
454 TRY_CATCH (except, RETURN_MASK_ALL)
456 type = check_typedef (type);
458 GDB_PY_HANDLE_EXCEPTION (except);
460 return type_to_type_object (type);
463 /* Strip typedefs and pointers/reference from a type. Then check that
464 it is a struct, union, or enum type. If not, raise TypeError. */
467 typy_get_composite (struct type *type)
469 volatile struct gdb_exception except;
473 TRY_CATCH (except, RETURN_MASK_ALL)
475 CHECK_TYPEDEF (type);
477 GDB_PY_HANDLE_EXCEPTION (except);
479 if (TYPE_CODE (type) != TYPE_CODE_PTR
480 && TYPE_CODE (type) != TYPE_CODE_REF)
482 type = TYPE_TARGET_TYPE (type);
485 /* If this is not a struct, union, or enum type, raise TypeError
487 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
488 && TYPE_CODE (type) != TYPE_CODE_UNION
489 && TYPE_CODE (type) != TYPE_CODE_ENUM)
491 PyErr_SetString (PyExc_TypeError,
492 "Type is not a structure, union, or enum type.");
499 /* Helper for typy_array and typy_vector. */
502 typy_array_1 (PyObject *self, PyObject *args, int is_vector)
505 PyObject *n2_obj = NULL;
506 struct type *array = NULL;
507 struct type *type = ((type_object *) self)->type;
508 volatile struct gdb_exception except;
510 if (! PyArg_ParseTuple (args, "l|O", &n1, &n2_obj))
515 if (!PyInt_Check (n2_obj))
517 PyErr_SetString (PyExc_RuntimeError,
518 _("Array bound must be an integer"));
522 if (! gdb_py_int_as_long (n2_obj, &n2))
531 if (n2 < n1 - 1) /* Note: An empty array has n2 == n1 - 1. */
533 PyErr_SetString (PyExc_ValueError,
534 _("Array length must not be negative"));
538 TRY_CATCH (except, RETURN_MASK_ALL)
540 array = lookup_array_range_type (type, n1, n2);
542 make_vector_type (array);
544 GDB_PY_HANDLE_EXCEPTION (except);
546 return type_to_type_object (array);
549 /* Return an array type. */
552 typy_array (PyObject *self, PyObject *args)
554 return typy_array_1 (self, args, 0);
557 /* Return a vector type. */
560 typy_vector (PyObject *self, PyObject *args)
562 return typy_array_1 (self, args, 1);
565 /* Return a Type object which represents a pointer to SELF. */
567 typy_pointer (PyObject *self, PyObject *args)
569 struct type *type = ((type_object *) self)->type;
570 volatile struct gdb_exception except;
572 TRY_CATCH (except, RETURN_MASK_ALL)
574 type = lookup_pointer_type (type);
576 GDB_PY_HANDLE_EXCEPTION (except);
578 return type_to_type_object (type);
581 /* Return the range of a type represented by SELF. The return type is
582 a tuple. The first element of the tuple contains the low bound,
583 while the second element of the tuple contains the high bound. */
585 typy_range (PyObject *self, PyObject *args)
587 struct type *type = ((type_object *) self)->type;
589 PyObject *low_bound = NULL, *high_bound = NULL;
590 /* Initialize these to appease GCC warnings. */
591 LONGEST low = 0, high = 0;
593 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
594 && TYPE_CODE (type) != TYPE_CODE_STRING
595 && TYPE_CODE (type) != TYPE_CODE_RANGE)
597 PyErr_SetString (PyExc_RuntimeError,
598 _("This type does not have a range."));
602 switch (TYPE_CODE (type))
604 case TYPE_CODE_ARRAY:
605 case TYPE_CODE_STRING:
606 low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
607 high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type));
609 case TYPE_CODE_RANGE:
610 low = TYPE_LOW_BOUND (type);
611 high = TYPE_HIGH_BOUND (type);
615 low_bound = PyLong_FromLong (low);
619 high_bound = PyLong_FromLong (high);
623 result = PyTuple_New (2);
627 if (PyTuple_SetItem (result, 0, low_bound) != 0)
632 if (PyTuple_SetItem (result, 1, high_bound) != 0)
634 Py_DECREF (high_bound);
641 Py_XDECREF (high_bound);
642 Py_XDECREF (low_bound);
646 /* Return a Type object which represents a reference to SELF. */
648 typy_reference (PyObject *self, PyObject *args)
650 struct type *type = ((type_object *) self)->type;
651 volatile struct gdb_exception except;
653 TRY_CATCH (except, RETURN_MASK_ALL)
655 type = lookup_reference_type (type);
657 GDB_PY_HANDLE_EXCEPTION (except);
659 return type_to_type_object (type);
662 /* Return a Type object which represents the target type of SELF. */
664 typy_target (PyObject *self, PyObject *args)
666 struct type *type = ((type_object *) self)->type;
668 if (!TYPE_TARGET_TYPE (type))
670 PyErr_SetString (PyExc_RuntimeError,
671 _("Type does not have a target."));
675 return type_to_type_object (TYPE_TARGET_TYPE (type));
678 /* Return a const-qualified type variant. */
680 typy_const (PyObject *self, PyObject *args)
682 struct type *type = ((type_object *) self)->type;
683 volatile struct gdb_exception except;
685 TRY_CATCH (except, RETURN_MASK_ALL)
687 type = make_cv_type (1, 0, type, NULL);
689 GDB_PY_HANDLE_EXCEPTION (except);
691 return type_to_type_object (type);
694 /* Return a volatile-qualified type variant. */
696 typy_volatile (PyObject *self, PyObject *args)
698 struct type *type = ((type_object *) self)->type;
699 volatile struct gdb_exception except;
701 TRY_CATCH (except, RETURN_MASK_ALL)
703 type = make_cv_type (0, 1, type, NULL);
705 GDB_PY_HANDLE_EXCEPTION (except);
707 return type_to_type_object (type);
710 /* Return an unqualified type variant. */
712 typy_unqualified (PyObject *self, PyObject *args)
714 struct type *type = ((type_object *) self)->type;
715 volatile struct gdb_exception except;
717 TRY_CATCH (except, RETURN_MASK_ALL)
719 type = make_cv_type (0, 0, type, NULL);
721 GDB_PY_HANDLE_EXCEPTION (except);
723 return type_to_type_object (type);
726 /* Return the size of the type represented by SELF, in bytes. */
728 typy_get_sizeof (PyObject *self, void *closure)
730 struct type *type = ((type_object *) self)->type;
731 volatile struct gdb_exception except;
733 TRY_CATCH (except, RETURN_MASK_ALL)
735 check_typedef (type);
737 /* Ignore exceptions. */
739 return gdb_py_long_from_longest (TYPE_LENGTH (type));
743 typy_lookup_typename (const char *type_name, const struct block *block)
745 struct type *type = NULL;
746 volatile struct gdb_exception except;
748 TRY_CATCH (except, RETURN_MASK_ALL)
750 if (!strncmp (type_name, "struct ", 7))
751 type = lookup_struct (type_name + 7, NULL);
752 else if (!strncmp (type_name, "union ", 6))
753 type = lookup_union (type_name + 6, NULL);
754 else if (!strncmp (type_name, "enum ", 5))
755 type = lookup_enum (type_name + 5, NULL);
757 type = lookup_typename (python_language, python_gdbarch,
758 type_name, block, 0);
760 GDB_PY_HANDLE_EXCEPTION (except);
766 typy_lookup_type (struct demangle_component *demangled,
767 const struct block *block)
769 struct type *type, *rtype = NULL;
770 char *type_name = NULL;
771 enum demangle_component_type demangled_type;
772 volatile struct gdb_exception except;
774 /* Save the type: typy_lookup_type() may (indirectly) overwrite
775 memory pointed by demangled. */
776 demangled_type = demangled->type;
778 if (demangled_type == DEMANGLE_COMPONENT_POINTER
779 || demangled_type == DEMANGLE_COMPONENT_REFERENCE
780 || demangled_type == DEMANGLE_COMPONENT_CONST
781 || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
783 type = typy_lookup_type (demangled->u.s_binary.left, block);
787 TRY_CATCH (except, RETURN_MASK_ALL)
789 /* If the demangled_type matches with one of the types
790 below, run the corresponding function and save the type
791 to return later. We cannot just return here as we are in
792 an exception handler. */
793 switch (demangled_type)
795 case DEMANGLE_COMPONENT_REFERENCE:
796 rtype = lookup_reference_type (type);
798 case DEMANGLE_COMPONENT_POINTER:
799 rtype = lookup_pointer_type (type);
801 case DEMANGLE_COMPONENT_CONST:
802 rtype = make_cv_type (1, 0, type, NULL);
804 case DEMANGLE_COMPONENT_VOLATILE:
805 rtype = make_cv_type (0, 1, type, NULL);
809 GDB_PY_HANDLE_EXCEPTION (except);
812 /* If we have a type from the switch statement above, just return
817 /* We don't have a type, so lookup the type. */
818 type_name = cp_comp_to_string (demangled, 10);
819 type = typy_lookup_typename (type_name, block);
825 /* This is a helper function for typy_template_argument that is used
826 when the type does not have template symbols attached. It works by
827 parsing the type name. This happens with compilers, like older
828 versions of GCC, that do not emit DW_TAG_template_*. */
831 typy_legacy_template_argument (struct type *type, const struct block *block,
835 struct demangle_component *demangled;
836 struct demangle_parse_info *info = NULL;
838 struct type *argtype;
839 struct cleanup *cleanup;
840 volatile struct gdb_exception except;
842 if (TYPE_NAME (type) == NULL)
844 PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
848 TRY_CATCH (except, RETURN_MASK_ALL)
850 /* Note -- this is not thread-safe. */
851 info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
853 GDB_PY_HANDLE_EXCEPTION (except);
857 PyErr_SetString (PyExc_RuntimeError, err);
860 demangled = info->tree;
861 cleanup = make_cleanup_cp_demangled_name_parse_free (info);
863 /* Strip off component names. */
864 while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
865 || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
866 demangled = demangled->u.s_binary.right;
868 if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
870 do_cleanups (cleanup);
871 PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
875 /* Skip from the template to the arguments. */
876 demangled = demangled->u.s_binary.right;
878 for (i = 0; demangled && i < argno; ++i)
879 demangled = demangled->u.s_binary.right;
883 do_cleanups (cleanup);
884 PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
889 argtype = typy_lookup_type (demangled->u.s_binary.left, block);
890 do_cleanups (cleanup);
894 return type_to_type_object (argtype);
898 typy_template_argument (PyObject *self, PyObject *args)
901 struct type *type = ((type_object *) self)->type;
902 const struct block *block = NULL;
903 PyObject *block_obj = NULL;
905 struct value *val = NULL;
906 volatile struct gdb_exception except;
908 if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
913 block = block_object_to_block (block_obj);
916 PyErr_SetString (PyExc_RuntimeError,
917 _("Second argument must be block."));
922 TRY_CATCH (except, RETURN_MASK_ALL)
924 type = check_typedef (type);
925 if (TYPE_CODE (type) == TYPE_CODE_REF)
926 type = check_typedef (TYPE_TARGET_TYPE (type));
928 GDB_PY_HANDLE_EXCEPTION (except);
930 /* We might not have DW_TAG_template_*, so try to parse the type's
931 name. This is inefficient if we do not have a template type --
932 but that is going to wind up as an error anyhow. */
933 if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
934 return typy_legacy_template_argument (type, block, argno);
936 if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
938 PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
943 sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
944 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
945 return type_to_type_object (SYMBOL_TYPE (sym));
946 else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
948 PyErr_Format (PyExc_RuntimeError,
949 _("Template argument is optimized out"));
953 TRY_CATCH (except, RETURN_MASK_ALL)
955 val = value_of_variable (sym, block);
957 GDB_PY_HANDLE_EXCEPTION (except);
959 return value_to_value_object (val);
963 typy_str (PyObject *self)
965 volatile struct gdb_exception except;
966 char *thetype = NULL;
970 TRY_CATCH (except, RETURN_MASK_ALL)
972 struct cleanup *old_chain;
975 stb = mem_fileopen ();
976 old_chain = make_cleanup_ui_file_delete (stb);
978 LA_PRINT_TYPE (type_object_to_type (self), "", stb, -1, 0,
979 &type_print_raw_options);
981 thetype = ui_file_xstrdup (stb, &length);
982 do_cleanups (old_chain);
984 if (except.reason < 0)
987 GDB_PY_HANDLE_EXCEPTION (except);
990 result = PyUnicode_Decode (thetype, length, host_charset (), NULL);
996 /* Implement the richcompare method. */
999 typy_richcompare (PyObject *self, PyObject *other, int op)
1002 struct type *type1 = type_object_to_type (self);
1003 struct type *type2 = type_object_to_type (other);
1004 volatile struct gdb_exception except;
1006 /* We can only compare ourselves to another Type object, and only
1007 for equality or inequality. */
1008 if (type2 == NULL || (op != Py_EQ && op != Py_NE))
1010 Py_INCREF (Py_NotImplemented);
1011 return Py_NotImplemented;
1018 TRY_CATCH (except, RETURN_MASK_ALL)
1020 result = types_deeply_equal (type1, type2);
1022 /* If there is a GDB exception, a comparison is not capable
1023 (or trusted), so exit. */
1024 GDB_PY_HANDLE_EXCEPTION (except);
1027 if (op == (result ? Py_EQ : Py_NE))
1034 static const struct objfile_data *typy_objfile_data_key;
1037 save_objfile_types (struct objfile *objfile, void *datum)
1039 type_object *obj = datum;
1040 htab_t copied_types;
1041 struct cleanup *cleanup;
1043 if (!gdb_python_initialized)
1046 /* This prevents another thread from freeing the objects we're
1048 cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
1050 copied_types = create_copied_types_hash (objfile);
1054 type_object *next = obj->next;
1056 htab_empty (copied_types);
1058 obj->type = copy_type_recursive (objfile, obj->type, copied_types);
1066 htab_delete (copied_types);
1068 do_cleanups (cleanup);
1072 set_type (type_object *obj, struct type *type)
1076 if (type && TYPE_OBJFILE (type))
1078 struct objfile *objfile = TYPE_OBJFILE (type);
1080 obj->next = objfile_data (objfile, typy_objfile_data_key);
1082 obj->next->prev = obj;
1083 set_objfile_data (objfile, typy_objfile_data_key, obj);
1090 typy_dealloc (PyObject *obj)
1092 type_object *type = (type_object *) obj;
1095 type->prev->next = type->next;
1096 else if (type->type && TYPE_OBJFILE (type->type))
1098 /* Must reset head of list. */
1099 struct objfile *objfile = TYPE_OBJFILE (type->type);
1102 set_objfile_data (objfile, typy_objfile_data_key, type->next);
1105 type->next->prev = type->prev;
1107 Py_TYPE (type)->tp_free (type);
1110 /* Return number of fields ("length" of the field dictionary). */
1113 typy_length (PyObject *self)
1115 struct type *type = ((type_object *) self)->type;
1117 type = typy_get_composite (type);
1121 return TYPE_NFIELDS (type);
1124 /* Implements boolean evaluation of gdb.Type. Handle this like other
1125 Python objects that don't have a meaningful truth value -- all
1129 typy_nonzero (PyObject *self)
1134 /* Return a gdb.Field object for the field named by the argument. */
1137 typy_getitem (PyObject *self, PyObject *key)
1139 struct type *type = ((type_object *) self)->type;
1143 field = python_string_to_host_string (key);
1147 /* We want just fields of this type, not of base types, so instead of
1148 using lookup_struct_elt_type, portions of that function are
1151 type = typy_get_composite (type);
1155 for (i = 0; i < TYPE_NFIELDS (type); i++)
1157 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1159 if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
1161 return convert_field (type, i);
1164 PyErr_SetObject (PyExc_KeyError, key);
1168 /* Implement the "get" method on the type object. This is the
1169 same as getitem if the key is present, but returns the supplied
1170 default value or None if the key is not found. */
1173 typy_get (PyObject *self, PyObject *args)
1175 PyObject *key, *defval = Py_None, *result;
1177 if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
1180 result = typy_getitem (self, key);
1184 /* typy_getitem returned error status. If the exception is
1185 KeyError, clear the exception status and return the defval
1186 instead. Otherwise return the exception unchanged. */
1187 if (!PyErr_ExceptionMatches (PyExc_KeyError))
1195 /* Implement the "has_key" method on the type object. */
1198 typy_has_key (PyObject *self, PyObject *args)
1200 struct type *type = ((type_object *) self)->type;
1204 if (!PyArg_ParseTuple (args, "s", &field))
1207 /* We want just fields of this type, not of base types, so instead of
1208 using lookup_struct_elt_type, portions of that function are
1211 type = typy_get_composite (type);
1215 for (i = 0; i < TYPE_NFIELDS (type); i++)
1217 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1219 if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
1225 /* Make an iterator object to iterate over keys, values, or items. */
1228 typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind)
1230 typy_iterator_object *typy_iter_obj;
1232 /* Check that "self" is a structure or union type. */
1233 if (typy_get_composite (((type_object *) self)->type) == NULL)
1236 typy_iter_obj = PyObject_New (typy_iterator_object,
1237 &type_iterator_object_type);
1238 if (typy_iter_obj == NULL)
1241 typy_iter_obj->field = 0;
1242 typy_iter_obj->kind = kind;
1244 typy_iter_obj->source = (type_object *) self;
1246 return (PyObject *) typy_iter_obj;
1249 /* iteritems() method. */
1252 typy_iteritems (PyObject *self, PyObject *args)
1254 return typy_make_iter (self, iter_items);
1257 /* iterkeys() method. */
1260 typy_iterkeys (PyObject *self, PyObject *args)
1262 return typy_make_iter (self, iter_keys);
1265 /* Iterating over the class, same as iterkeys except for the function
1269 typy_iter (PyObject *self)
1271 return typy_make_iter (self, iter_keys);
1274 /* itervalues() method. */
1277 typy_itervalues (PyObject *self, PyObject *args)
1279 return typy_make_iter (self, iter_values);
1282 /* Return a reference to the type iterator. */
1285 typy_iterator_iter (PyObject *self)
1291 /* Return the next field in the iteration through the list of fields
1295 typy_iterator_iternext (PyObject *self)
1297 typy_iterator_object *iter_obj = (typy_iterator_object *) self;
1298 struct type *type = iter_obj->source->type;
1301 if (iter_obj->field < TYPE_NFIELDS (type))
1303 result = make_fielditem (type, iter_obj->field, iter_obj->kind);
1313 typy_iterator_dealloc (PyObject *obj)
1315 typy_iterator_object *iter_obj = (typy_iterator_object *) obj;
1317 Py_DECREF (iter_obj->source);
1320 /* Create a new Type referring to TYPE. */
1322 type_to_type_object (struct type *type)
1324 type_object *type_obj;
1326 type_obj = PyObject_New (type_object, &type_object_type);
1328 set_type (type_obj, type);
1330 return (PyObject *) type_obj;
1334 type_object_to_type (PyObject *obj)
1336 if (! PyObject_TypeCheck (obj, &type_object_type))
1338 return ((type_object *) obj)->type;
1343 /* Implementation of gdb.lookup_type. */
1345 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
1347 static char *keywords[] = { "name", "block", NULL };
1348 const char *type_name = NULL;
1349 struct type *type = NULL;
1350 PyObject *block_obj = NULL;
1351 const struct block *block = NULL;
1353 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
1354 &type_name, &block_obj))
1359 block = block_object_to_block (block_obj);
1362 PyErr_SetString (PyExc_RuntimeError,
1363 _("'block' argument must be a Block."));
1368 type = typy_lookup_typename (type_name, block);
1372 return (PyObject *) type_to_type_object (type);
1376 gdbpy_initialize_types (void)
1380 typy_objfile_data_key
1381 = register_objfile_data_with_cleanup (save_objfile_types, NULL);
1383 if (PyType_Ready (&type_object_type) < 0)
1385 if (PyType_Ready (&field_object_type) < 0)
1387 if (PyType_Ready (&type_iterator_object_type) < 0)
1390 for (i = 0; pyty_codes[i].name; ++i)
1392 if (PyModule_AddIntConstant (gdb_module,
1393 /* Cast needed for Python 2.4. */
1394 (char *) pyty_codes[i].name,
1395 pyty_codes[i].code) < 0)
1399 if (gdb_pymodule_addobject (gdb_module, "Type",
1400 (PyObject *) &type_object_type) < 0)
1403 if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
1404 (PyObject *) &type_iterator_object_type) < 0)
1407 return gdb_pymodule_addobject (gdb_module, "Field",
1408 (PyObject *) &field_object_type);
1413 static PyGetSetDef type_object_getset[] =
1415 { "code", typy_get_code, NULL,
1416 "The code for this type.", NULL },
1417 { "name", typy_get_name, NULL,
1418 "The name for this type, or None.", NULL },
1419 { "sizeof", typy_get_sizeof, NULL,
1420 "The size of this type, in bytes.", NULL },
1421 { "tag", typy_get_tag, NULL,
1422 "The tag name for this type, or None.", NULL },
1426 static PyMethodDef type_object_methods[] =
1428 { "array", typy_array, METH_VARARGS,
1429 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1430 Return a type which represents an array of objects of this type.\n\
1431 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1432 If LOW_BOUND is omitted, a value of zero is used." },
1433 { "vector", typy_vector, METH_VARARGS,
1434 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1435 Return a type which represents a vector of objects of this type.\n\
1436 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1437 If LOW_BOUND is omitted, a value of zero is used.\n\
1438 Vectors differ from arrays in that if the current language has C-style\n\
1439 arrays, vectors don't decay to a pointer to the first element.\n\
1440 They are first class values." },
1441 { "__contains__", typy_has_key, METH_VARARGS,
1442 "T.__contains__(k) -> True if T has a field named k, else False" },
1443 { "const", typy_const, METH_NOARGS,
1444 "const () -> Type\n\
1445 Return a const variant of this type." },
1446 { "fields", typy_fields, METH_NOARGS,
1447 "fields () -> list\n\
1448 Return a list holding all the fields of this type.\n\
1449 Each field is a gdb.Field object." },
1450 { "get", typy_get, METH_VARARGS,
1451 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1452 otherwise returns default, if supplied, or None if not." },
1453 { "has_key", typy_has_key, METH_VARARGS,
1454 "T.has_key(k) -> True if T has a field named k, else False" },
1455 { "items", typy_items, METH_NOARGS,
1456 "items () -> list\n\
1457 Return a list of (name, field) pairs of this type.\n\
1458 Each field is a gdb.Field object." },
1459 { "iteritems", typy_iteritems, METH_NOARGS,
1460 "iteritems () -> an iterator over the (name, field)\n\
1461 pairs of this type. Each field is a gdb.Field object." },
1462 { "iterkeys", typy_iterkeys, METH_NOARGS,
1463 "iterkeys () -> an iterator over the field names of this type." },
1464 { "itervalues", typy_itervalues, METH_NOARGS,
1465 "itervalues () -> an iterator over the fields of this type.\n\
1466 Each field is a gdb.Field object." },
1467 { "keys", typy_field_names, METH_NOARGS,
1469 Return a list holding all the fields names of this type." },
1470 { "pointer", typy_pointer, METH_NOARGS,
1471 "pointer () -> Type\n\
1472 Return a type of pointer to this type." },
1473 { "range", typy_range, METH_NOARGS,
1474 "range () -> tuple\n\
1475 Return a tuple containing the lower and upper range for this type."},
1476 { "reference", typy_reference, METH_NOARGS,
1477 "reference () -> Type\n\
1478 Return a type of reference to this type." },
1479 { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
1480 "strip_typedefs () -> Type\n\
1481 Return a type formed by stripping this type of all typedefs."},
1482 { "target", typy_target, METH_NOARGS,
1483 "target () -> Type\n\
1484 Return the target type of this type." },
1485 { "template_argument", typy_template_argument, METH_VARARGS,
1486 "template_argument (arg, [block]) -> Type\n\
1487 Return the type of a template argument." },
1488 { "unqualified", typy_unqualified, METH_NOARGS,
1489 "unqualified () -> Type\n\
1490 Return a variant of this type without const or volatile attributes." },
1491 { "values", typy_values, METH_NOARGS,
1492 "values () -> list\n\
1493 Return a list holding all the fields of this type.\n\
1494 Each field is a gdb.Field object." },
1495 { "volatile", typy_volatile, METH_NOARGS,
1496 "volatile () -> Type\n\
1497 Return a volatile variant of this type" },
1501 static PyNumberMethods type_object_as_number = {
1503 NULL, /* nb_subtract */
1504 NULL, /* nb_multiply */
1506 NULL, /* nb_divide */
1508 NULL, /* nb_remainder */
1509 NULL, /* nb_divmod */
1510 NULL, /* nb_power */
1511 NULL, /* nb_negative */
1512 NULL, /* nb_positive */
1513 NULL, /* nb_absolute */
1514 typy_nonzero, /* nb_nonzero */
1515 NULL, /* nb_invert */
1516 NULL, /* nb_lshift */
1517 NULL, /* nb_rshift */
1523 NULL, /* reserved */
1525 NULL, /* nb_coerce */
1529 NULL, /* nb_float */
1536 static PyMappingMethods typy_mapping = {
1539 NULL /* no "set" method */
1542 PyTypeObject type_object_type =
1544 PyVarObject_HEAD_INIT (NULL, 0)
1545 "gdb.Type", /*tp_name*/
1546 sizeof (type_object), /*tp_basicsize*/
1548 typy_dealloc, /*tp_dealloc*/
1554 &type_object_as_number, /*tp_as_number*/
1555 0, /*tp_as_sequence*/
1556 &typy_mapping, /*tp_as_mapping*/
1559 typy_str, /*tp_str*/
1563 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
1564 "GDB type object", /* tp_doc */
1565 0, /* tp_traverse */
1567 typy_richcompare, /* tp_richcompare */
1568 0, /* tp_weaklistoffset */
1569 typy_iter, /* tp_iter */
1570 0, /* tp_iternext */
1571 type_object_methods, /* tp_methods */
1573 type_object_getset, /* tp_getset */
1576 0, /* tp_descr_get */
1577 0, /* tp_descr_set */
1578 0, /* tp_dictoffset */
1584 static PyGetSetDef field_object_getset[] =
1586 { "__dict__", gdb_py_generic_dict, NULL,
1587 "The __dict__ for this field.", &field_object_type },
1591 PyTypeObject field_object_type =
1593 PyVarObject_HEAD_INIT (NULL, 0)
1594 "gdb.Field", /*tp_name*/
1595 sizeof (field_object), /*tp_basicsize*/
1597 field_dealloc, /*tp_dealloc*/
1604 0, /*tp_as_sequence*/
1605 0, /*tp_as_mapping*/
1612 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
1613 "GDB field object", /* tp_doc */
1614 0, /* tp_traverse */
1616 0, /* tp_richcompare */
1617 0, /* tp_weaklistoffset */
1619 0, /* tp_iternext */
1622 field_object_getset, /* tp_getset */
1625 0, /* tp_descr_get */
1626 0, /* tp_descr_set */
1627 offsetof (field_object, dict), /* tp_dictoffset */
1633 PyTypeObject type_iterator_object_type = {
1634 PyVarObject_HEAD_INIT (NULL, 0)
1635 "gdb.TypeIterator", /*tp_name*/
1636 sizeof (typy_iterator_object), /*tp_basicsize*/
1638 typy_iterator_dealloc, /*tp_dealloc*/
1645 0, /*tp_as_sequence*/
1646 0, /*tp_as_mapping*/
1653 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
1654 "GDB type iterator object", /*tp_doc */
1657 0, /*tp_richcompare */
1658 0, /*tp_weaklistoffset */
1659 typy_iterator_iter, /*tp_iter */
1660 typy_iterator_iternext, /*tp_iternext */