1 /* Python interface to values.
3 Copyright (C) 2008-2019 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/>. */
24 #include "target-float.h"
27 #include "expression.h"
31 #include "python-internal.h"
34 /* Even though Python scalar types directly map to host types, we use
35 target types here to remain consistent with the values system in
36 GDB (which uses target arithmetic). */
38 /* Python's integer type corresponds to C's long type. */
39 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
41 /* Python's float type corresponds to C's double type. */
42 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
44 /* Python's long type corresponds to C's long long type. */
45 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
47 /* Python's long type corresponds to C's long long type. Unsigned version. */
48 #define builtin_type_upylong builtin_type \
49 (python_gdbarch)->builtin_unsigned_long_long
51 #define builtin_type_pybool \
52 language_bool_type (python_language, python_gdbarch)
54 #define builtin_type_pychar \
55 language_string_char_type (python_language, python_gdbarch)
57 typedef struct value_object
{
59 struct value_object
*next
;
60 struct value_object
*prev
;
64 PyObject
*dynamic_type
;
67 /* List of all values which are currently exposed to Python. It is
68 maintained so that when an objfile is discarded, preserve_values
69 can copy the values' types if needed. */
70 /* This variable is unnecessarily initialized to NULL in order to
71 work around a linker bug on MacOS. */
72 static value_object
*values_in_python
= NULL
;
74 /* Called by the Python interpreter when deallocating a value object. */
76 valpy_dealloc (PyObject
*obj
)
78 value_object
*self
= (value_object
*) obj
;
80 /* Remove SELF from the global list. */
82 self
->prev
->next
= self
->next
;
85 gdb_assert (values_in_python
== self
);
86 values_in_python
= self
->next
;
89 self
->next
->prev
= self
->prev
;
91 value_decref (self
->value
);
93 Py_XDECREF (self
->address
);
94 Py_XDECREF (self
->type
);
95 Py_XDECREF (self
->dynamic_type
);
97 Py_TYPE (self
)->tp_free (self
);
100 /* Helper to push a Value object on the global list. */
102 note_value (value_object
*value_obj
)
104 value_obj
->next
= values_in_python
;
106 value_obj
->next
->prev
= value_obj
;
107 value_obj
->prev
= NULL
;
108 values_in_python
= value_obj
;
111 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
112 error, with a python exception set. */
114 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
116 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
117 value_object
*value_obj
;
119 if (PyTuple_Size (args
) != 1)
121 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
126 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
127 if (value_obj
== NULL
)
129 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
130 "create Value object."));
134 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
137 subtype
->tp_free (value_obj
);
141 value_obj
->value
= release_value (value
).release ();
142 value_obj
->address
= NULL
;
143 value_obj
->type
= NULL
;
144 value_obj
->dynamic_type
= NULL
;
145 note_value (value_obj
);
147 return (PyObject
*) value_obj
;
150 /* Iterate over all the Value objects, calling preserve_one_value on
153 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
154 struct objfile
*objfile
, htab_t copied_types
)
158 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
159 preserve_one_value (iter
->value
, objfile
, copied_types
);
162 /* Given a value of a pointer type, apply the C unary * operator to it. */
164 valpy_dereference (PyObject
*self
, PyObject
*args
)
166 PyObject
*result
= NULL
;
170 struct value
*res_val
;
171 scoped_value_mark free_values
;
173 res_val
= value_ind (((value_object
*) self
)->value
);
174 result
= value_to_value_object (res_val
);
176 CATCH (except
, RETURN_MASK_ALL
)
178 GDB_PY_HANDLE_EXCEPTION (except
);
185 /* Given a value of a pointer type or a reference type, return the value
186 referenced. The difference between this function and valpy_dereference is
187 that the latter applies * unary operator to a value, which need not always
188 result in the value referenced. For example, for a value which is a reference
189 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
190 type 'int' while valpy_referenced_value will result in a value of type
194 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
196 PyObject
*result
= NULL
;
200 struct value
*self_val
, *res_val
;
201 scoped_value_mark free_values
;
203 self_val
= ((value_object
*) self
)->value
;
204 switch (TYPE_CODE (check_typedef (value_type (self_val
))))
207 res_val
= value_ind (self_val
);
210 case TYPE_CODE_RVALUE_REF
:
211 res_val
= coerce_ref (self_val
);
214 error(_("Trying to get the referenced value from a value which is "
215 "neither a pointer nor a reference."));
218 result
= value_to_value_object (res_val
);
220 CATCH (except
, RETURN_MASK_ALL
)
222 GDB_PY_HANDLE_EXCEPTION (except
);
229 /* Return a value which is a reference to the value. */
232 valpy_reference_value (PyObject
*self
, PyObject
*args
, enum type_code refcode
)
234 PyObject
*result
= NULL
;
238 struct value
*self_val
;
239 scoped_value_mark free_values
;
241 self_val
= ((value_object
*) self
)->value
;
242 result
= value_to_value_object (value_ref (self_val
, refcode
));
244 CATCH (except
, RETURN_MASK_ALL
)
246 GDB_PY_HANDLE_EXCEPTION (except
);
254 valpy_lvalue_reference_value (PyObject
*self
, PyObject
*args
)
256 return valpy_reference_value (self
, args
, TYPE_CODE_REF
);
260 valpy_rvalue_reference_value (PyObject
*self
, PyObject
*args
)
262 return valpy_reference_value (self
, args
, TYPE_CODE_RVALUE_REF
);
265 /* Return a "const" qualified version of the value. */
268 valpy_const_value (PyObject
*self
, PyObject
*args
)
270 PyObject
*result
= NULL
;
274 struct value
*self_val
, *res_val
;
275 scoped_value_mark free_values
;
277 self_val
= ((value_object
*) self
)->value
;
278 res_val
= make_cv_value (1, 0, self_val
);
279 result
= value_to_value_object (res_val
);
281 CATCH (except
, RETURN_MASK_ALL
)
283 GDB_PY_HANDLE_EXCEPTION (except
);
290 /* Return "&value". */
292 valpy_get_address (PyObject
*self
, void *closure
)
294 value_object
*val_obj
= (value_object
*) self
;
296 if (!val_obj
->address
)
300 struct value
*res_val
;
301 scoped_value_mark free_values
;
303 res_val
= value_addr (val_obj
->value
);
304 val_obj
->address
= value_to_value_object (res_val
);
306 CATCH (except
, RETURN_MASK_ALL
)
308 val_obj
->address
= Py_None
;
314 Py_XINCREF (val_obj
->address
);
316 return val_obj
->address
;
319 /* Return type of the value. */
321 valpy_get_type (PyObject
*self
, void *closure
)
323 value_object
*obj
= (value_object
*) self
;
327 obj
->type
= type_to_type_object (value_type (obj
->value
));
331 Py_INCREF (obj
->type
);
335 /* Return dynamic type of the value. */
338 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
340 value_object
*obj
= (value_object
*) self
;
341 struct type
*type
= NULL
;
343 if (obj
->dynamic_type
!= NULL
)
345 Py_INCREF (obj
->dynamic_type
);
346 return obj
->dynamic_type
;
351 struct value
*val
= obj
->value
;
352 scoped_value_mark free_values
;
354 type
= value_type (val
);
355 type
= check_typedef (type
);
357 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
358 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
360 struct value
*target
;
361 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
364 target
= value_ind (val
);
366 target
= coerce_ref (val
);
367 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
372 type
= lookup_pointer_type (type
);
374 type
= lookup_lvalue_reference_type (type
);
377 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
378 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
381 /* Re-use object's static type. */
385 CATCH (except
, RETURN_MASK_ALL
)
387 GDB_PY_HANDLE_EXCEPTION (except
);
392 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
394 obj
->dynamic_type
= type_to_type_object (type
);
396 Py_XINCREF (obj
->dynamic_type
);
397 return obj
->dynamic_type
;
400 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
401 string. Return a PyObject representing a lazy_string_object type.
402 A lazy string is a pointer to a string with an optional encoding and
403 length. If ENCODING is not given, encoding is set to None. If an
404 ENCODING is provided the encoding parameter is set to ENCODING, but
405 the string is not encoded.
406 If LENGTH is provided then the length parameter is set to LENGTH.
407 Otherwise if the value is an array of known length then the array's length
408 is used. Otherwise the length will be set to -1 (meaning first null of
411 Note: In order to not break any existing uses this allows creating
412 lazy strings from anything. PR 20769. E.g.,
413 gdb.parse_and_eval("my_int_variable").lazy_string().
414 "It's easier to relax restrictions than it is to impose them after the
415 fact." So we should be flagging any unintended uses as errors, but it's
416 perhaps too late for that. */
419 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
421 gdb_py_longest length
= -1;
422 struct value
*value
= ((value_object
*) self
)->value
;
423 const char *user_encoding
= NULL
;
424 static const char *keywords
[] = { "encoding", "length", NULL
};
425 PyObject
*str_obj
= NULL
;
427 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
,
428 keywords
, &user_encoding
, &length
))
433 PyErr_SetString (PyExc_ValueError
, _("Invalid length."));
439 scoped_value_mark free_values
;
440 struct type
*type
, *realtype
;
443 type
= value_type (value
);
444 realtype
= check_typedef (type
);
446 switch (TYPE_CODE (realtype
))
448 case TYPE_CODE_ARRAY
:
450 LONGEST array_length
= -1;
451 LONGEST low_bound
, high_bound
;
453 /* PR 20786: There's no way to specify an array of length zero.
454 Record a length of [0,-1] which is how Ada does it. Anything
455 we do is broken, but this one possible solution. */
456 if (get_array_bounds (realtype
, &low_bound
, &high_bound
))
457 array_length
= high_bound
- low_bound
+ 1;
459 length
= array_length
;
460 else if (array_length
== -1)
462 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
465 else if (length
!= array_length
)
467 /* We need to create a new array type with the
469 if (length
> array_length
)
470 error (_("Length is larger than array size."));
471 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
473 low_bound
+ length
- 1);
475 addr
= value_address (value
);
479 /* If a length is specified we defer creating an array of the
480 specified width until we need to. */
481 addr
= value_as_address (value
);
484 /* Should flag an error here. PR 20769. */
485 addr
= value_address (value
);
489 str_obj
= gdbpy_create_lazy_string_object (addr
, length
, user_encoding
,
492 CATCH (except
, RETURN_MASK_ALL
)
494 GDB_PY_HANDLE_EXCEPTION (except
);
501 /* Implementation of gdb.Value.string ([encoding] [, errors]
502 [, length]) -> string. Return Unicode string with value contents.
503 If ENCODING is not given, the string is assumed to be encoded in
504 the target's charset. If LENGTH is provided, only fetch string to
505 the length provided. */
508 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
511 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
;
512 struct value
*value
= ((value_object
*) self
)->value
;
513 const char *encoding
= NULL
;
514 const char *errors
= NULL
;
515 const char *user_encoding
= NULL
;
516 const char *la_encoding
= NULL
;
517 struct type
*char_type
;
518 static const char *keywords
[] = { "encoding", "errors", "length", NULL
};
520 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
521 &user_encoding
, &errors
, &length
))
526 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
528 CATCH (except
, RETURN_MASK_ALL
)
530 GDB_PY_HANDLE_EXCEPTION (except
);
534 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
535 return PyUnicode_Decode ((const char *) buffer
.get (),
536 length
* TYPE_LENGTH (char_type
),
540 /* A helper function that implements the various cast operators. */
543 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
545 PyObject
*type_obj
, *result
= NULL
;
548 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
551 type
= type_object_to_type (type_obj
);
554 PyErr_SetString (PyExc_RuntimeError
,
555 _("Argument must be a type."));
561 struct value
*val
= ((value_object
*) self
)->value
;
562 struct value
*res_val
;
563 scoped_value_mark free_values
;
565 if (op
== UNOP_DYNAMIC_CAST
)
566 res_val
= value_dynamic_cast (type
, val
);
567 else if (op
== UNOP_REINTERPRET_CAST
)
568 res_val
= value_reinterpret_cast (type
, val
);
571 gdb_assert (op
== UNOP_CAST
);
572 res_val
= value_cast (type
, val
);
575 result
= value_to_value_object (res_val
);
577 CATCH (except
, RETURN_MASK_ALL
)
579 GDB_PY_HANDLE_EXCEPTION (except
);
586 /* Implementation of the "cast" method. */
589 valpy_cast (PyObject
*self
, PyObject
*args
)
591 return valpy_do_cast (self
, args
, UNOP_CAST
);
594 /* Implementation of the "dynamic_cast" method. */
597 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
599 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
602 /* Implementation of the "reinterpret_cast" method. */
605 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
607 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
611 valpy_length (PyObject
*self
)
613 /* We don't support getting the number of elements in a struct / class. */
614 PyErr_SetString (PyExc_NotImplementedError
,
615 _("Invalid operation on gdb.Value."));
619 /* Return 1 if the gdb.Field object FIELD is present in the value V.
620 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
623 value_has_field (struct value
*v
, PyObject
*field
)
625 struct type
*parent_type
, *val_type
;
626 enum type_code type_code
;
627 gdbpy_ref
<> type_object (PyObject_GetAttrString (field
, "parent_type"));
630 if (type_object
== NULL
)
633 parent_type
= type_object_to_type (type_object
.get ());
634 if (parent_type
== NULL
)
636 PyErr_SetString (PyExc_TypeError
,
637 _("'parent_type' attribute of gdb.Field object is not a"
638 "gdb.Type object."));
644 val_type
= value_type (v
);
645 val_type
= check_typedef (val_type
);
646 if (TYPE_IS_REFERENCE (val_type
) || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
647 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
649 type_code
= TYPE_CODE (val_type
);
650 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
651 && types_equal (val_type
, parent_type
))
656 CATCH (except
, RETURN_MASK_ALL
)
658 GDB_PY_SET_HANDLE_EXCEPTION (except
);
665 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
666 Returns 1 if the flag value is true, 0 if it is false, and -1 if
667 a Python error occurs. */
670 get_field_flag (PyObject
*field
, const char *flag_name
)
672 gdbpy_ref
<> flag_object (PyObject_GetAttrString (field
, flag_name
));
674 if (flag_object
== NULL
)
677 return PyObject_IsTrue (flag_object
.get ());
680 /* Return the "type" attribute of a gdb.Field object.
681 Returns NULL on error, with a Python exception set. */
684 get_field_type (PyObject
*field
)
686 gdbpy_ref
<> ftype_obj (PyObject_GetAttrString (field
, "type"));
689 if (ftype_obj
== NULL
)
691 ftype
= type_object_to_type (ftype_obj
.get ());
693 PyErr_SetString (PyExc_TypeError
,
694 _("'type' attribute of gdb.Field object is not a "
695 "gdb.Type object."));
700 /* Given string name or a gdb.Field object corresponding to an element inside
701 a structure, return its value object. Returns NULL on error, with a python
705 valpy_getitem (PyObject
*self
, PyObject
*key
)
707 struct gdb_exception except
= exception_none
;
708 value_object
*self_value
= (value_object
*) self
;
709 gdb::unique_xmalloc_ptr
<char> field
;
710 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
712 PyObject
*result
= NULL
;
714 if (gdbpy_is_string (key
))
716 field
= python_string_to_host_string (key
);
720 else if (gdbpy_is_field (key
))
722 int is_base_class
, valid_field
;
724 valid_field
= value_has_field (self_value
->value
, key
);
727 else if (valid_field
== 0)
729 PyErr_SetString (PyExc_TypeError
,
730 _("Invalid lookup for a field not contained in "
736 is_base_class
= get_field_flag (key
, "is_base_class");
737 if (is_base_class
< 0)
739 else if (is_base_class
> 0)
741 base_class_type
= get_field_type (key
);
742 if (base_class_type
== NULL
)
747 gdbpy_ref
<> name_obj (PyObject_GetAttrString (key
, "name"));
749 if (name_obj
== NULL
)
752 if (name_obj
!= Py_None
)
754 field
= python_string_to_host_string (name_obj
.get ());
760 if (!PyObject_HasAttrString (key
, "bitpos"))
762 PyErr_SetString (PyExc_AttributeError
,
763 _("gdb.Field object has no name and no "
764 "'bitpos' attribute."));
768 gdbpy_ref
<> bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
769 if (bitpos_obj
== NULL
)
771 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
774 field_type
= get_field_type (key
);
775 if (field_type
== NULL
)
783 struct value
*tmp
= self_value
->value
;
784 struct value
*res_val
= NULL
;
785 scoped_value_mark free_values
;
788 res_val
= value_struct_elt (&tmp
, NULL
, field
.get (), NULL
,
789 "struct/class/union");
790 else if (bitpos
>= 0)
791 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
792 "struct/class/union");
793 else if (base_class_type
!= NULL
)
795 struct type
*val_type
;
797 val_type
= check_typedef (value_type (tmp
));
798 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
799 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
800 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
801 res_val
= value_cast (lookup_lvalue_reference_type (base_class_type
),
803 else if (TYPE_CODE (val_type
) == TYPE_CODE_RVALUE_REF
)
804 res_val
= value_cast (lookup_rvalue_reference_type (base_class_type
),
807 res_val
= value_cast (base_class_type
, tmp
);
811 /* Assume we are attempting an array access, and let the
812 value code throw an exception if the index has an invalid
814 struct value
*idx
= convert_value_from_python (key
);
818 /* Check the value's type is something that can be accessed via
822 tmp
= coerce_ref (tmp
);
823 type
= check_typedef (value_type (tmp
));
824 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
825 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
826 error (_("Cannot subscript requested type."));
828 res_val
= value_subscript (tmp
, value_as_long (idx
));
833 result
= value_to_value_object (res_val
);
835 CATCH (ex
, RETURN_MASK_ALL
)
841 GDB_PY_HANDLE_EXCEPTION (except
);
847 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
849 PyErr_Format (PyExc_NotImplementedError
,
850 _("Setting of struct elements is not currently supported."));
854 /* Called by the Python interpreter to perform an inferior function
855 call on the value. Returns NULL on error, with a python exception set. */
857 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
859 Py_ssize_t args_count
;
860 struct value
*function
= ((value_object
*) self
)->value
;
861 struct value
**vargs
= NULL
;
862 struct type
*ftype
= NULL
;
863 PyObject
*result
= NULL
;
867 ftype
= check_typedef (value_type (function
));
869 CATCH (except
, RETURN_MASK_ALL
)
871 GDB_PY_HANDLE_EXCEPTION (except
);
875 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
877 PyErr_SetString (PyExc_RuntimeError
,
878 _("Value is not callable (not TYPE_CODE_FUNC)."));
882 if (! PyTuple_Check (args
))
884 PyErr_SetString (PyExc_TypeError
,
885 _("Inferior arguments must be provided in a tuple."));
889 args_count
= PyTuple_Size (args
);
894 vargs
= XALLOCAVEC (struct value
*, args_count
);
895 for (i
= 0; i
< args_count
; i
++)
897 PyObject
*item
= PyTuple_GetItem (args
, i
);
902 vargs
[i
] = convert_value_from_python (item
);
903 if (vargs
[i
] == NULL
)
910 scoped_value_mark free_values
;
913 = call_function_by_hand (function
, NULL
,
914 gdb::make_array_view (vargs
, args_count
));
915 result
= value_to_value_object (return_value
);
917 CATCH (except
, RETURN_MASK_ALL
)
919 GDB_PY_HANDLE_EXCEPTION (except
);
926 /* Called by the Python interpreter to obtain string representation
929 valpy_str (PyObject
*self
)
931 struct value_print_options opts
;
933 get_user_print_options (&opts
);
940 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
941 &opts
, python_language
);
943 CATCH (except
, RETURN_MASK_ALL
)
945 GDB_PY_HANDLE_EXCEPTION (except
);
949 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
952 /* Implements gdb.Value.is_optimized_out. */
954 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
956 struct value
*value
= ((value_object
*) self
)->value
;
961 opt
= value_optimized_out (value
);
963 CATCH (except
, RETURN_MASK_ALL
)
965 GDB_PY_HANDLE_EXCEPTION (except
);
975 /* Implements gdb.Value.is_lazy. */
977 valpy_get_is_lazy (PyObject
*self
, void *closure
)
979 struct value
*value
= ((value_object
*) self
)->value
;
984 opt
= value_lazy (value
);
986 CATCH (except
, RETURN_MASK_ALL
)
988 GDB_PY_HANDLE_EXCEPTION (except
);
998 /* Implements gdb.Value.fetch_lazy (). */
1000 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
1002 struct value
*value
= ((value_object
*) self
)->value
;
1006 if (value_lazy (value
))
1007 value_fetch_lazy (value
);
1009 CATCH (except
, RETURN_MASK_ALL
)
1011 GDB_PY_HANDLE_EXCEPTION (except
);
1018 /* Calculate and return the address of the PyObject as the value of
1019 the builtin __hash__ call. */
1021 valpy_hash (PyObject
*self
)
1023 return (intptr_t) self
;
1041 /* If TYPE is a reference, return the target; otherwise return TYPE. */
1042 #define STRIP_REFERENCE(TYPE) \
1043 (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
1045 /* Helper for valpy_binop. Returns a value object which is the result
1046 of applying the operation specified by OPCODE to the given
1047 arguments. Throws a GDB exception on error. */
1050 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1052 PyObject
*result
= NULL
;
1054 struct value
*arg1
, *arg2
;
1055 struct value
*res_val
= NULL
;
1056 enum exp_opcode op
= OP_NULL
;
1059 scoped_value_mark free_values
;
1061 /* If the gdb.Value object is the second operand, then it will be
1062 passed to us as the OTHER argument, and SELF will be an entirely
1063 different kind of object, altogether. Because of this, we can't
1064 assume self is a gdb.Value object and need to convert it from
1066 arg1
= convert_value_from_python (self
);
1070 arg2
= convert_value_from_python (other
);
1078 struct type
*ltype
= value_type (arg1
);
1079 struct type
*rtype
= value_type (arg2
);
1081 ltype
= check_typedef (ltype
);
1082 ltype
= STRIP_REFERENCE (ltype
);
1083 rtype
= check_typedef (rtype
);
1084 rtype
= STRIP_REFERENCE (rtype
);
1087 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1088 && is_integral_type (rtype
))
1089 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1090 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
1091 && is_integral_type (ltype
))
1092 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1102 struct type
*ltype
= value_type (arg1
);
1103 struct type
*rtype
= value_type (arg2
);
1105 ltype
= check_typedef (ltype
);
1106 ltype
= STRIP_REFERENCE (ltype
);
1107 rtype
= check_typedef (rtype
);
1108 rtype
= STRIP_REFERENCE (rtype
);
1111 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1112 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
1113 /* A ptrdiff_t for the target would be preferable here. */
1114 res_val
= value_from_longest (builtin_type_pyint
,
1115 value_ptrdiff (arg1
, arg2
));
1116 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1117 && is_integral_type (rtype
))
1118 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1145 op
= BINOP_BITWISE_AND
;
1148 op
= BINOP_BITWISE_IOR
;
1151 op
= BINOP_BITWISE_XOR
;
1157 if (binop_user_defined_p (op
, arg1
, arg2
))
1158 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1160 res_val
= value_binop (arg1
, arg2
, op
);
1164 result
= value_to_value_object (res_val
);
1169 /* Returns a value object which is the result of applying the operation
1170 specified by OPCODE to the given arguments. Returns NULL on error, with
1171 a python exception set. */
1173 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1175 PyObject
*result
= NULL
;
1179 result
= valpy_binop_throw (opcode
, self
, other
);
1181 CATCH (except
, RETURN_MASK_ALL
)
1183 GDB_PY_HANDLE_EXCEPTION (except
);
1191 valpy_add (PyObject
*self
, PyObject
*other
)
1193 return valpy_binop (VALPY_ADD
, self
, other
);
1197 valpy_subtract (PyObject
*self
, PyObject
*other
)
1199 return valpy_binop (VALPY_SUB
, self
, other
);
1203 valpy_multiply (PyObject
*self
, PyObject
*other
)
1205 return valpy_binop (VALPY_MUL
, self
, other
);
1209 valpy_divide (PyObject
*self
, PyObject
*other
)
1211 return valpy_binop (VALPY_DIV
, self
, other
);
1215 valpy_remainder (PyObject
*self
, PyObject
*other
)
1217 return valpy_binop (VALPY_REM
, self
, other
);
1221 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1223 /* We don't support the ternary form of pow. I don't know how to express
1224 that, so let's just throw NotImplementedError to at least do something
1226 if (unused
!= Py_None
)
1228 PyErr_SetString (PyExc_NotImplementedError
,
1229 "Invalid operation on gdb.Value.");
1233 return valpy_binop (VALPY_POW
, self
, other
);
1237 valpy_negative (PyObject
*self
)
1239 PyObject
*result
= NULL
;
1243 /* Perhaps overkill, but consistency has some virtue. */
1244 scoped_value_mark free_values
;
1247 val
= value_neg (((value_object
*) self
)->value
);
1248 result
= value_to_value_object (val
);
1250 CATCH (except
, RETURN_MASK_ALL
)
1252 GDB_PY_HANDLE_EXCEPTION (except
);
1260 valpy_positive (PyObject
*self
)
1262 return value_to_value_object (((value_object
*) self
)->value
);
1266 valpy_absolute (PyObject
*self
)
1268 struct value
*value
= ((value_object
*) self
)->value
;
1273 scoped_value_mark free_values
;
1275 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1278 CATCH (except
, RETURN_MASK_ALL
)
1280 GDB_PY_HANDLE_EXCEPTION (except
);
1285 return valpy_positive (self
);
1287 return valpy_negative (self
);
1290 /* Implements boolean evaluation of gdb.Value. */
1292 valpy_nonzero (PyObject
*self
)
1294 struct gdb_exception except
= exception_none
;
1295 value_object
*self_value
= (value_object
*) self
;
1297 int nonzero
= 0; /* Appease GCC warning. */
1301 type
= check_typedef (value_type (self_value
->value
));
1303 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1304 nonzero
= !!value_as_long (self_value
->value
);
1305 else if (is_floating_value (self_value
->value
))
1306 nonzero
= !target_float_is_zero (value_contents (self_value
->value
),
1309 /* All other values are True. */
1312 CATCH (ex
, RETURN_MASK_ALL
)
1318 /* This is not documented in the Python documentation, but if this
1319 function fails, return -1 as slot_nb_nonzero does (the default
1320 Python nonzero function). */
1321 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1326 /* Implements ~ for value objects. */
1328 valpy_invert (PyObject
*self
)
1330 struct value
*val
= NULL
;
1334 val
= value_complement (((value_object
*) self
)->value
);
1336 CATCH (except
, RETURN_MASK_ALL
)
1338 GDB_PY_HANDLE_EXCEPTION (except
);
1342 return value_to_value_object (val
);
1345 /* Implements left shift for value objects. */
1347 valpy_lsh (PyObject
*self
, PyObject
*other
)
1349 return valpy_binop (VALPY_LSH
, self
, other
);
1352 /* Implements right shift for value objects. */
1354 valpy_rsh (PyObject
*self
, PyObject
*other
)
1356 return valpy_binop (VALPY_RSH
, self
, other
);
1359 /* Implements bitwise and for value objects. */
1361 valpy_and (PyObject
*self
, PyObject
*other
)
1363 return valpy_binop (VALPY_BITAND
, self
, other
);
1366 /* Implements bitwise or for value objects. */
1368 valpy_or (PyObject
*self
, PyObject
*other
)
1370 return valpy_binop (VALPY_BITOR
, self
, other
);
1373 /* Implements bitwise xor for value objects. */
1375 valpy_xor (PyObject
*self
, PyObject
*other
)
1377 return valpy_binop (VALPY_BITXOR
, self
, other
);
1380 /* Helper for valpy_richcompare. Implements comparison operations for
1381 value objects. Returns true/false on success. Returns -1 with a
1382 Python exception set if a Python error is detected. Throws a GDB
1383 exception on other errors (memory error, etc.). */
1386 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1389 struct value
*value_other
;
1390 struct value
*value_self
;
1392 scoped_value_mark free_values
;
1394 value_other
= convert_value_from_python (other
);
1395 if (value_other
== NULL
)
1398 value_self
= ((value_object
*) self
)->value
;
1403 result
= value_less (value_self
, value_other
);
1406 result
= value_less (value_self
, value_other
)
1407 || value_equal (value_self
, value_other
);
1410 result
= value_equal (value_self
, value_other
);
1413 result
= !value_equal (value_self
, value_other
);
1416 result
= value_less (value_other
, value_self
);
1419 result
= (value_less (value_other
, value_self
)
1420 || value_equal (value_self
, value_other
));
1424 PyErr_SetString (PyExc_NotImplementedError
,
1425 _("Invalid operation on gdb.Value."));
1434 /* Implements comparison operations for value objects. Returns NULL on error,
1435 with a python exception set. */
1437 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1441 if (other
== Py_None
)
1442 /* Comparing with None is special. From what I can tell, in Python
1443 None is smaller than anything else. */
1455 PyErr_SetString (PyExc_NotImplementedError
,
1456 _("Invalid operation on gdb.Value."));
1462 result
= valpy_richcompare_throw (self
, other
, op
);
1464 CATCH (except
, RETURN_MASK_ALL
)
1466 GDB_PY_HANDLE_EXCEPTION (except
);
1470 /* In this case, the Python exception has already been set. */
1481 /* Implements conversion to int. */
1483 valpy_int (PyObject
*self
)
1485 struct value
*value
= ((value_object
*) self
)->value
;
1486 struct type
*type
= value_type (value
);
1491 if (is_floating_value (value
))
1493 type
= builtin_type_pylong
;
1494 value
= value_cast (type
, value
);
1497 if (!is_integral_type (type
)
1498 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1499 error (_("Cannot convert value to int."));
1501 l
= value_as_long (value
);
1503 CATCH (except
, RETURN_MASK_ALL
)
1505 GDB_PY_HANDLE_EXCEPTION (except
);
1509 if (TYPE_UNSIGNED (type
))
1510 return gdb_py_object_from_ulongest (l
).release ();
1512 return gdb_py_object_from_longest (l
).release ();
1516 /* Implements conversion to long. */
1518 valpy_long (PyObject
*self
)
1520 struct value
*value
= ((value_object
*) self
)->value
;
1521 struct type
*type
= value_type (value
);
1526 if (is_floating_value (value
))
1528 type
= builtin_type_pylong
;
1529 value
= value_cast (type
, value
);
1532 type
= check_typedef (type
);
1534 if (!is_integral_type (type
)
1535 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1536 error (_("Cannot convert value to long."));
1538 l
= value_as_long (value
);
1540 CATCH (except
, RETURN_MASK_ALL
)
1542 GDB_PY_HANDLE_EXCEPTION (except
);
1546 if (TYPE_UNSIGNED (type
))
1547 return gdb_py_long_from_ulongest (l
);
1549 return gdb_py_long_from_longest (l
);
1552 /* Implements conversion to float. */
1554 valpy_float (PyObject
*self
)
1556 struct value
*value
= ((value_object
*) self
)->value
;
1557 struct type
*type
= value_type (value
);
1562 type
= check_typedef (type
);
1564 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& is_floating_value (value
))
1565 d
= target_float_to_host_double (value_contents (value
), type
);
1566 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1568 /* Note that valpy_long accepts TYPE_CODE_PTR and some
1569 others here here -- but casting a pointer or bool to a
1570 float seems wrong. */
1571 d
= value_as_long (value
);
1574 error (_("Cannot convert value to float."));
1576 CATCH (except
, RETURN_MASK_ALL
)
1578 GDB_PY_HANDLE_EXCEPTION (except
);
1582 return PyFloat_FromDouble (d
);
1585 /* Returns an object for a value which is released from the all_values chain,
1586 so its lifetime is not bound to the execution of a command. */
1588 value_to_value_object (struct value
*val
)
1590 value_object
*val_obj
;
1592 val_obj
= PyObject_New (value_object
, &value_object_type
);
1593 if (val_obj
!= NULL
)
1595 val_obj
->value
= release_value (val
).release ();
1596 val_obj
->address
= NULL
;
1597 val_obj
->type
= NULL
;
1598 val_obj
->dynamic_type
= NULL
;
1599 note_value (val_obj
);
1602 return (PyObject
*) val_obj
;
1605 /* Returns a borrowed reference to the struct value corresponding to
1606 the given value object. */
1608 value_object_to_value (PyObject
*self
)
1612 if (! PyObject_TypeCheck (self
, &value_object_type
))
1614 real
= (value_object
*) self
;
1618 /* Try to convert a Python value to a gdb value. If the value cannot
1619 be converted, set a Python exception and return NULL. Returns a
1620 reference to a new value on the all_values chain. */
1623 convert_value_from_python (PyObject
*obj
)
1625 struct value
*value
= NULL
; /* -Wall */
1628 gdb_assert (obj
!= NULL
);
1632 if (PyBool_Check (obj
))
1634 cmp
= PyObject_IsTrue (obj
);
1636 value
= value_from_longest (builtin_type_pybool
, cmp
);
1638 /* Make a long logic check first. In Python 3.x, internally,
1639 all integers are represented as longs. In Python 2.x, there
1640 is still a differentiation internally between a PyInt and a
1641 PyLong. Explicitly do this long check conversion first. In
1642 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1643 to be done first to ensure we do not lose information in the
1644 conversion process. */
1645 else if (PyLong_Check (obj
))
1647 LONGEST l
= PyLong_AsLongLong (obj
);
1649 if (PyErr_Occurred ())
1651 /* If the error was an overflow, we can try converting to
1652 ULONGEST instead. */
1653 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1655 gdbpy_err_fetch fetched_error
;
1656 gdbpy_ref
<> zero (PyInt_FromLong (0));
1658 /* Check whether obj is positive. */
1659 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1663 ul
= PyLong_AsUnsignedLongLong (obj
);
1664 if (! PyErr_Occurred ())
1665 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1669 /* There's nothing we can do. */
1670 fetched_error
.restore ();
1675 value
= value_from_longest (builtin_type_pylong
, l
);
1677 #if PY_MAJOR_VERSION == 2
1678 else if (PyInt_Check (obj
))
1680 long l
= PyInt_AsLong (obj
);
1682 if (! PyErr_Occurred ())
1683 value
= value_from_longest (builtin_type_pyint
, l
);
1686 else if (PyFloat_Check (obj
))
1688 double d
= PyFloat_AsDouble (obj
);
1690 if (! PyErr_Occurred ())
1692 value
= allocate_value (builtin_type_pyfloat
);
1693 target_float_from_host_double (value_contents_raw (value
),
1694 value_type (value
), d
);
1697 else if (gdbpy_is_string (obj
))
1699 gdb::unique_xmalloc_ptr
<char> s
1700 = python_string_to_target_string (obj
);
1702 value
= value_cstring (s
.get (), strlen (s
.get ()),
1703 builtin_type_pychar
);
1705 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1706 value
= value_copy (((value_object
*) obj
)->value
);
1707 else if (gdbpy_is_lazy_string (obj
))
1711 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1712 value
= value_copy (((value_object
*) result
)->value
);
1716 PyErr_Format (PyExc_TypeError
,
1717 _("Could not convert Python object: %S."), obj
);
1719 PyErr_Format (PyExc_TypeError
,
1720 _("Could not convert Python object: %s."),
1721 PyString_AsString (PyObject_Str (obj
)));
1724 CATCH (except
, RETURN_MASK_ALL
)
1726 gdbpy_convert_exception (except
);
1734 /* Returns value object in the ARGth position in GDB's history. */
1736 gdbpy_history (PyObject
*self
, PyObject
*args
)
1739 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1741 if (!PyArg_ParseTuple (args
, "i", &i
))
1746 res_val
= access_value_history (i
);
1748 CATCH (except
, RETURN_MASK_ALL
)
1750 GDB_PY_HANDLE_EXCEPTION (except
);
1754 return value_to_value_object (res_val
);
1757 /* Return the value of a convenience variable. */
1759 gdbpy_convenience_variable (PyObject
*self
, PyObject
*args
)
1761 const char *varname
;
1762 struct value
*res_val
= NULL
;
1764 if (!PyArg_ParseTuple (args
, "s", &varname
))
1769 struct internalvar
*var
= lookup_only_internalvar (varname
);
1773 res_val
= value_of_internalvar (python_gdbarch
, var
);
1774 if (TYPE_CODE (value_type (res_val
)) == TYPE_CODE_VOID
)
1778 CATCH (except
, RETURN_MASK_ALL
)
1780 GDB_PY_HANDLE_EXCEPTION (except
);
1784 if (res_val
== NULL
)
1787 return value_to_value_object (res_val
);
1790 /* Set the value of a convenience variable. */
1792 gdbpy_set_convenience_variable (PyObject
*self
, PyObject
*args
)
1794 const char *varname
;
1795 PyObject
*value_obj
;
1796 struct value
*value
= NULL
;
1798 if (!PyArg_ParseTuple (args
, "sO", &varname
, &value_obj
))
1801 /* None means to clear the variable. */
1802 if (value_obj
!= Py_None
)
1804 value
= convert_value_from_python (value_obj
);
1813 struct internalvar
*var
= lookup_only_internalvar (varname
);
1816 clear_internalvar (var
);
1820 struct internalvar
*var
= lookup_internalvar (varname
);
1822 set_internalvar (var
, value
);
1825 CATCH (except
, RETURN_MASK_ALL
)
1827 GDB_PY_HANDLE_EXCEPTION (except
);
1834 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1837 gdbpy_is_value_object (PyObject
*obj
)
1839 return PyObject_TypeCheck (obj
, &value_object_type
);
1843 gdbpy_initialize_values (void)
1845 if (PyType_Ready (&value_object_type
) < 0)
1848 return gdb_pymodule_addobject (gdb_module
, "Value",
1849 (PyObject
*) &value_object_type
);
1854 static gdb_PyGetSetDef value_object_getset
[] = {
1855 { "address", valpy_get_address
, NULL
, "The address of the value.",
1857 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1858 "Boolean telling whether the value is optimized "
1859 "out (i.e., not available).",
1861 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1862 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1863 "Dynamic type of the value.", NULL
},
1864 { "is_lazy", valpy_get_is_lazy
, NULL
,
1865 "Boolean telling whether the value is lazy (not fetched yet\n\
1866 from the inferior). A lazy value is fetched when needed, or when\n\
1867 the \"fetch_lazy()\" method is called.", NULL
},
1868 {NULL
} /* Sentinel */
1871 static PyMethodDef value_object_methods
[] = {
1872 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1873 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1874 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1875 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1877 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1878 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1879 Cast the value to the supplied type, as if by the C++\n\
1880 reinterpret_cast operator."
1882 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1883 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1884 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1885 { "reference_value", valpy_lvalue_reference_value
, METH_NOARGS
,
1886 "Return a value of type TYPE_CODE_REF referencing this value." },
1887 { "rvalue_reference_value", valpy_rvalue_reference_value
, METH_NOARGS
,
1888 "Return a value of type TYPE_CODE_RVALUE_REF referencing this value." },
1889 { "const_value", valpy_const_value
, METH_NOARGS
,
1890 "Return a 'const' qualied version of the same value." },
1891 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1892 METH_VARARGS
| METH_KEYWORDS
,
1893 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1894 Return a lazy string representation of the value." },
1895 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1896 "string ([encoding] [, errors] [, length]) -> string\n\
1897 Return Unicode string representation of the value." },
1898 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1899 "Fetches the value from the inferior, if it was lazy." },
1900 {NULL
} /* Sentinel */
1903 static PyNumberMethods value_object_as_number
= {
1911 NULL
, /* nb_divmod */
1912 valpy_power
, /* nb_power */
1913 valpy_negative
, /* nb_negative */
1914 valpy_positive
, /* nb_positive */
1915 valpy_absolute
, /* nb_absolute */
1916 valpy_nonzero
, /* nb_nonzero */
1917 valpy_invert
, /* nb_invert */
1918 valpy_lsh
, /* nb_lshift */
1919 valpy_rsh
, /* nb_rshift */
1920 valpy_and
, /* nb_and */
1921 valpy_xor
, /* nb_xor */
1922 valpy_or
, /* nb_or */
1924 valpy_long
, /* nb_int */
1925 NULL
, /* reserved */
1927 NULL
, /* nb_coerce */
1928 valpy_int
, /* nb_int */
1929 valpy_long
, /* nb_long */
1931 valpy_float
, /* nb_float */
1936 NULL
, /* nb_inplace_add */
1937 NULL
, /* nb_inplace_subtract */
1938 NULL
, /* nb_inplace_multiply */
1940 NULL
, /* nb_inplace_divide */
1942 NULL
, /* nb_inplace_remainder */
1943 NULL
, /* nb_inplace_power */
1944 NULL
, /* nb_inplace_lshift */
1945 NULL
, /* nb_inplace_rshift */
1946 NULL
, /* nb_inplace_and */
1947 NULL
, /* nb_inplace_xor */
1948 NULL
, /* nb_inplace_or */
1949 NULL
, /* nb_floor_divide */
1950 valpy_divide
, /* nb_true_divide */
1951 NULL
, /* nb_inplace_floor_divide */
1952 NULL
, /* nb_inplace_true_divide */
1953 #ifndef HAVE_LIBPYTHON2_4
1954 /* This was added in Python 2.5. */
1955 valpy_long
, /* nb_index */
1956 #endif /* HAVE_LIBPYTHON2_4 */
1959 static PyMappingMethods value_object_as_mapping
= {
1965 PyTypeObject value_object_type
= {
1966 PyVarObject_HEAD_INIT (NULL
, 0)
1967 "gdb.Value", /*tp_name*/
1968 sizeof (value_object
), /*tp_basicsize*/
1970 valpy_dealloc
, /*tp_dealloc*/
1976 &value_object_as_number
, /*tp_as_number*/
1977 0, /*tp_as_sequence*/
1978 &value_object_as_mapping
, /*tp_as_mapping*/
1979 valpy_hash
, /*tp_hash*/
1980 valpy_call
, /*tp_call*/
1981 valpy_str
, /*tp_str*/
1985 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1986 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1987 "GDB value object", /* tp_doc */
1988 0, /* tp_traverse */
1990 valpy_richcompare
, /* tp_richcompare */
1991 0, /* tp_weaklistoffset */
1993 0, /* tp_iternext */
1994 value_object_methods
, /* tp_methods */
1996 value_object_getset
, /* tp_getset */
1999 0, /* tp_descr_get */
2000 0, /* tp_descr_set */
2001 0, /* tp_dictoffset */
2004 valpy_new
/* tp_new */