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"
33 /* Even though Python scalar types directly map to host types, we use
34 target types here to remain consistent with the values system in
35 GDB (which uses target arithmetic). */
37 /* Python's integer type corresponds to C's long type. */
38 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
40 /* Python's float type corresponds to C's double type. */
41 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
43 /* Python's long type corresponds to C's long long type. */
44 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
46 /* Python's long type corresponds to C's long long type. Unsigned version. */
47 #define builtin_type_upylong builtin_type \
48 (python_gdbarch)->builtin_unsigned_long_long
50 #define builtin_type_pybool \
51 language_bool_type (python_language, python_gdbarch)
53 #define builtin_type_pychar \
54 language_string_char_type (python_language, python_gdbarch)
56 typedef struct value_object
{
58 struct value_object
*next
;
59 struct value_object
*prev
;
63 PyObject
*dynamic_type
;
66 /* List of all values which are currently exposed to Python. It is
67 maintained so that when an objfile is discarded, preserve_values
68 can copy the values' types if needed. */
69 /* This variable is unnecessarily initialized to NULL in order to
70 work around a linker bug on MacOS. */
71 static value_object
*values_in_python
= NULL
;
73 /* Called by the Python interpreter when deallocating a value object. */
75 valpy_dealloc (PyObject
*obj
)
77 value_object
*self
= (value_object
*) obj
;
79 /* Remove SELF from the global list. */
81 self
->prev
->next
= self
->next
;
84 gdb_assert (values_in_python
== self
);
85 values_in_python
= self
->next
;
88 self
->next
->prev
= self
->prev
;
90 value_decref (self
->value
);
92 Py_XDECREF (self
->address
);
93 Py_XDECREF (self
->type
);
94 Py_XDECREF (self
->dynamic_type
);
96 Py_TYPE (self
)->tp_free (self
);
99 /* Helper to push a Value object on the global list. */
101 note_value (value_object
*value_obj
)
103 value_obj
->next
= values_in_python
;
105 value_obj
->next
->prev
= value_obj
;
106 value_obj
->prev
= NULL
;
107 values_in_python
= value_obj
;
110 /* Convert a python object OBJ with type TYPE to a gdb value. The
111 python object in question must conform to the python buffer
112 protocol. On success, return the converted value, otherwise
115 static struct value
*
116 convert_buffer_and_type_to_value (PyObject
*obj
, struct type
*type
)
118 Py_buffer_up buffer_up
;
121 if (PyObject_CheckBuffer (obj
)
122 && PyObject_GetBuffer (obj
, &py_buf
, PyBUF_SIMPLE
) == 0)
124 /* Got a buffer, py_buf, out of obj. Cause it to be released
125 when it goes out of scope. */
126 buffer_up
.reset (&py_buf
);
130 PyErr_SetString (PyExc_TypeError
,
131 _("Object must support the python buffer protocol."));
135 if (TYPE_LENGTH (type
) > py_buf
.len
)
137 PyErr_SetString (PyExc_ValueError
,
138 _("Size of type is larger than that of buffer object."));
142 return value_from_contents (type
, (const gdb_byte
*) py_buf
.buf
);
145 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
146 error, with a python exception set. */
148 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*kwargs
)
150 static const char *keywords
[] = { "val", "type", NULL
};
151 PyObject
*val_obj
= nullptr;
152 PyObject
*type_obj
= nullptr;
154 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kwargs
, "O|O", keywords
,
155 &val_obj
, &type_obj
))
158 struct type
*type
= nullptr;
160 if (type_obj
!= nullptr)
162 type
= type_object_to_type (type_obj
);
165 PyErr_SetString (PyExc_TypeError
,
166 _("type argument must be a gdb.Type."));
171 value_object
*value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
172 if (value_obj
== NULL
)
174 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
175 "create Value object."));
182 value
= convert_value_from_python (val_obj
);
184 value
= convert_buffer_and_type_to_value (val_obj
, type
);
186 if (value
== nullptr)
188 subtype
->tp_free (value_obj
);
192 value_obj
->value
= release_value (value
).release ();
193 value_obj
->address
= NULL
;
194 value_obj
->type
= NULL
;
195 value_obj
->dynamic_type
= NULL
;
196 note_value (value_obj
);
198 return (PyObject
*) value_obj
;
201 /* Iterate over all the Value objects, calling preserve_one_value on
204 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
205 struct objfile
*objfile
, htab_t copied_types
)
209 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
210 preserve_one_value (iter
->value
, objfile
, copied_types
);
213 /* Given a value of a pointer type, apply the C unary * operator to it. */
215 valpy_dereference (PyObject
*self
, PyObject
*args
)
217 PyObject
*result
= NULL
;
221 struct value
*res_val
;
222 scoped_value_mark free_values
;
224 res_val
= value_ind (((value_object
*) self
)->value
);
225 result
= value_to_value_object (res_val
);
227 CATCH (except
, RETURN_MASK_ALL
)
229 GDB_PY_HANDLE_EXCEPTION (except
);
236 /* Given a value of a pointer type or a reference type, return the value
237 referenced. The difference between this function and valpy_dereference is
238 that the latter applies * unary operator to a value, which need not always
239 result in the value referenced. For example, for a value which is a reference
240 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
241 type 'int' while valpy_referenced_value will result in a value of type
245 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
247 PyObject
*result
= NULL
;
251 struct value
*self_val
, *res_val
;
252 scoped_value_mark free_values
;
254 self_val
= ((value_object
*) self
)->value
;
255 switch (TYPE_CODE (check_typedef (value_type (self_val
))))
258 res_val
= value_ind (self_val
);
261 case TYPE_CODE_RVALUE_REF
:
262 res_val
= coerce_ref (self_val
);
265 error(_("Trying to get the referenced value from a value which is "
266 "neither a pointer nor a reference."));
269 result
= value_to_value_object (res_val
);
271 CATCH (except
, RETURN_MASK_ALL
)
273 GDB_PY_HANDLE_EXCEPTION (except
);
280 /* Return a value which is a reference to the value. */
283 valpy_reference_value (PyObject
*self
, PyObject
*args
, enum type_code refcode
)
285 PyObject
*result
= NULL
;
289 struct value
*self_val
;
290 scoped_value_mark free_values
;
292 self_val
= ((value_object
*) self
)->value
;
293 result
= value_to_value_object (value_ref (self_val
, refcode
));
295 CATCH (except
, RETURN_MASK_ALL
)
297 GDB_PY_HANDLE_EXCEPTION (except
);
305 valpy_lvalue_reference_value (PyObject
*self
, PyObject
*args
)
307 return valpy_reference_value (self
, args
, TYPE_CODE_REF
);
311 valpy_rvalue_reference_value (PyObject
*self
, PyObject
*args
)
313 return valpy_reference_value (self
, args
, TYPE_CODE_RVALUE_REF
);
316 /* Return a "const" qualified version of the value. */
319 valpy_const_value (PyObject
*self
, PyObject
*args
)
321 PyObject
*result
= NULL
;
325 struct value
*self_val
, *res_val
;
326 scoped_value_mark free_values
;
328 self_val
= ((value_object
*) self
)->value
;
329 res_val
= make_cv_value (1, 0, self_val
);
330 result
= value_to_value_object (res_val
);
332 CATCH (except
, RETURN_MASK_ALL
)
334 GDB_PY_HANDLE_EXCEPTION (except
);
341 /* Return "&value". */
343 valpy_get_address (PyObject
*self
, void *closure
)
345 value_object
*val_obj
= (value_object
*) self
;
347 if (!val_obj
->address
)
351 struct value
*res_val
;
352 scoped_value_mark free_values
;
354 res_val
= value_addr (val_obj
->value
);
355 val_obj
->address
= value_to_value_object (res_val
);
357 CATCH (except
, RETURN_MASK_ALL
)
359 val_obj
->address
= Py_None
;
365 Py_XINCREF (val_obj
->address
);
367 return val_obj
->address
;
370 /* Return type of the value. */
372 valpy_get_type (PyObject
*self
, void *closure
)
374 value_object
*obj
= (value_object
*) self
;
378 obj
->type
= type_to_type_object (value_type (obj
->value
));
382 Py_INCREF (obj
->type
);
386 /* Return dynamic type of the value. */
389 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
391 value_object
*obj
= (value_object
*) self
;
392 struct type
*type
= NULL
;
394 if (obj
->dynamic_type
!= NULL
)
396 Py_INCREF (obj
->dynamic_type
);
397 return obj
->dynamic_type
;
402 struct value
*val
= obj
->value
;
403 scoped_value_mark free_values
;
405 type
= value_type (val
);
406 type
= check_typedef (type
);
408 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
409 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
411 struct value
*target
;
412 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
415 target
= value_ind (val
);
417 target
= coerce_ref (val
);
418 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
423 type
= lookup_pointer_type (type
);
425 type
= lookup_lvalue_reference_type (type
);
428 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
429 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
432 /* Re-use object's static type. */
436 CATCH (except
, RETURN_MASK_ALL
)
438 GDB_PY_HANDLE_EXCEPTION (except
);
443 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
445 obj
->dynamic_type
= type_to_type_object (type
);
447 Py_XINCREF (obj
->dynamic_type
);
448 return obj
->dynamic_type
;
451 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
452 string. Return a PyObject representing a lazy_string_object type.
453 A lazy string is a pointer to a string with an optional encoding and
454 length. If ENCODING is not given, encoding is set to None. If an
455 ENCODING is provided the encoding parameter is set to ENCODING, but
456 the string is not encoded.
457 If LENGTH is provided then the length parameter is set to LENGTH.
458 Otherwise if the value is an array of known length then the array's length
459 is used. Otherwise the length will be set to -1 (meaning first null of
462 Note: In order to not break any existing uses this allows creating
463 lazy strings from anything. PR 20769. E.g.,
464 gdb.parse_and_eval("my_int_variable").lazy_string().
465 "It's easier to relax restrictions than it is to impose them after the
466 fact." So we should be flagging any unintended uses as errors, but it's
467 perhaps too late for that. */
470 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
472 gdb_py_longest length
= -1;
473 struct value
*value
= ((value_object
*) self
)->value
;
474 const char *user_encoding
= NULL
;
475 static const char *keywords
[] = { "encoding", "length", NULL
};
476 PyObject
*str_obj
= NULL
;
478 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
,
479 keywords
, &user_encoding
, &length
))
484 PyErr_SetString (PyExc_ValueError
, _("Invalid length."));
490 scoped_value_mark free_values
;
491 struct type
*type
, *realtype
;
494 type
= value_type (value
);
495 realtype
= check_typedef (type
);
497 switch (TYPE_CODE (realtype
))
499 case TYPE_CODE_ARRAY
:
501 LONGEST array_length
= -1;
502 LONGEST low_bound
, high_bound
;
504 /* PR 20786: There's no way to specify an array of length zero.
505 Record a length of [0,-1] which is how Ada does it. Anything
506 we do is broken, but this one possible solution. */
507 if (get_array_bounds (realtype
, &low_bound
, &high_bound
))
508 array_length
= high_bound
- low_bound
+ 1;
510 length
= array_length
;
511 else if (array_length
== -1)
513 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
516 else if (length
!= array_length
)
518 /* We need to create a new array type with the
520 if (length
> array_length
)
521 error (_("Length is larger than array size."));
522 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
524 low_bound
+ length
- 1);
526 addr
= value_address (value
);
530 /* If a length is specified we defer creating an array of the
531 specified width until we need to. */
532 addr
= value_as_address (value
);
535 /* Should flag an error here. PR 20769. */
536 addr
= value_address (value
);
540 str_obj
= gdbpy_create_lazy_string_object (addr
, length
, user_encoding
,
543 CATCH (except
, RETURN_MASK_ALL
)
545 GDB_PY_HANDLE_EXCEPTION (except
);
552 /* Implementation of gdb.Value.string ([encoding] [, errors]
553 [, length]) -> string. Return Unicode string with value contents.
554 If ENCODING is not given, the string is assumed to be encoded in
555 the target's charset. If LENGTH is provided, only fetch string to
556 the length provided. */
559 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
562 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
;
563 struct value
*value
= ((value_object
*) self
)->value
;
564 const char *encoding
= NULL
;
565 const char *errors
= NULL
;
566 const char *user_encoding
= NULL
;
567 const char *la_encoding
= NULL
;
568 struct type
*char_type
;
569 static const char *keywords
[] = { "encoding", "errors", "length", NULL
};
571 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
572 &user_encoding
, &errors
, &length
))
577 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
579 CATCH (except
, RETURN_MASK_ALL
)
581 GDB_PY_HANDLE_EXCEPTION (except
);
585 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
586 return PyUnicode_Decode ((const char *) buffer
.get (),
587 length
* TYPE_LENGTH (char_type
),
591 /* A helper function that implements the various cast operators. */
594 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
596 PyObject
*type_obj
, *result
= NULL
;
599 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
602 type
= type_object_to_type (type_obj
);
605 PyErr_SetString (PyExc_RuntimeError
,
606 _("Argument must be a type."));
612 struct value
*val
= ((value_object
*) self
)->value
;
613 struct value
*res_val
;
614 scoped_value_mark free_values
;
616 if (op
== UNOP_DYNAMIC_CAST
)
617 res_val
= value_dynamic_cast (type
, val
);
618 else if (op
== UNOP_REINTERPRET_CAST
)
619 res_val
= value_reinterpret_cast (type
, val
);
622 gdb_assert (op
== UNOP_CAST
);
623 res_val
= value_cast (type
, val
);
626 result
= value_to_value_object (res_val
);
628 CATCH (except
, RETURN_MASK_ALL
)
630 GDB_PY_HANDLE_EXCEPTION (except
);
637 /* Implementation of the "cast" method. */
640 valpy_cast (PyObject
*self
, PyObject
*args
)
642 return valpy_do_cast (self
, args
, UNOP_CAST
);
645 /* Implementation of the "dynamic_cast" method. */
648 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
650 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
653 /* Implementation of the "reinterpret_cast" method. */
656 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
658 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
662 valpy_length (PyObject
*self
)
664 /* We don't support getting the number of elements in a struct / class. */
665 PyErr_SetString (PyExc_NotImplementedError
,
666 _("Invalid operation on gdb.Value."));
670 /* Return 1 if the gdb.Field object FIELD is present in the value V.
671 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
674 value_has_field (struct value
*v
, PyObject
*field
)
676 struct type
*parent_type
, *val_type
;
677 enum type_code type_code
;
678 gdbpy_ref
<> type_object (PyObject_GetAttrString (field
, "parent_type"));
681 if (type_object
== NULL
)
684 parent_type
= type_object_to_type (type_object
.get ());
685 if (parent_type
== NULL
)
687 PyErr_SetString (PyExc_TypeError
,
688 _("'parent_type' attribute of gdb.Field object is not a"
689 "gdb.Type object."));
695 val_type
= value_type (v
);
696 val_type
= check_typedef (val_type
);
697 if (TYPE_IS_REFERENCE (val_type
) || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
698 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
700 type_code
= TYPE_CODE (val_type
);
701 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
702 && types_equal (val_type
, parent_type
))
707 CATCH (except
, RETURN_MASK_ALL
)
709 GDB_PY_SET_HANDLE_EXCEPTION (except
);
716 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
717 Returns 1 if the flag value is true, 0 if it is false, and -1 if
718 a Python error occurs. */
721 get_field_flag (PyObject
*field
, const char *flag_name
)
723 gdbpy_ref
<> flag_object (PyObject_GetAttrString (field
, flag_name
));
725 if (flag_object
== NULL
)
728 return PyObject_IsTrue (flag_object
.get ());
731 /* Return the "type" attribute of a gdb.Field object.
732 Returns NULL on error, with a Python exception set. */
735 get_field_type (PyObject
*field
)
737 gdbpy_ref
<> ftype_obj (PyObject_GetAttrString (field
, "type"));
740 if (ftype_obj
== NULL
)
742 ftype
= type_object_to_type (ftype_obj
.get ());
744 PyErr_SetString (PyExc_TypeError
,
745 _("'type' attribute of gdb.Field object is not a "
746 "gdb.Type object."));
751 /* Given string name or a gdb.Field object corresponding to an element inside
752 a structure, return its value object. Returns NULL on error, with a python
756 valpy_getitem (PyObject
*self
, PyObject
*key
)
758 struct gdb_exception except
= exception_none
;
759 value_object
*self_value
= (value_object
*) self
;
760 gdb::unique_xmalloc_ptr
<char> field
;
761 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
763 PyObject
*result
= NULL
;
765 if (gdbpy_is_string (key
))
767 field
= python_string_to_host_string (key
);
771 else if (gdbpy_is_field (key
))
773 int is_base_class
, valid_field
;
775 valid_field
= value_has_field (self_value
->value
, key
);
778 else if (valid_field
== 0)
780 PyErr_SetString (PyExc_TypeError
,
781 _("Invalid lookup for a field not contained in "
787 is_base_class
= get_field_flag (key
, "is_base_class");
788 if (is_base_class
< 0)
790 else if (is_base_class
> 0)
792 base_class_type
= get_field_type (key
);
793 if (base_class_type
== NULL
)
798 gdbpy_ref
<> name_obj (PyObject_GetAttrString (key
, "name"));
800 if (name_obj
== NULL
)
803 if (name_obj
!= Py_None
)
805 field
= python_string_to_host_string (name_obj
.get ());
811 if (!PyObject_HasAttrString (key
, "bitpos"))
813 PyErr_SetString (PyExc_AttributeError
,
814 _("gdb.Field object has no name and no "
815 "'bitpos' attribute."));
819 gdbpy_ref
<> bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
820 if (bitpos_obj
== NULL
)
822 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
825 field_type
= get_field_type (key
);
826 if (field_type
== NULL
)
834 struct value
*tmp
= self_value
->value
;
835 struct value
*res_val
= NULL
;
836 scoped_value_mark free_values
;
839 res_val
= value_struct_elt (&tmp
, NULL
, field
.get (), NULL
,
840 "struct/class/union");
841 else if (bitpos
>= 0)
842 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
843 "struct/class/union");
844 else if (base_class_type
!= NULL
)
846 struct type
*val_type
;
848 val_type
= check_typedef (value_type (tmp
));
849 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
850 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
851 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
852 res_val
= value_cast (lookup_lvalue_reference_type (base_class_type
),
854 else if (TYPE_CODE (val_type
) == TYPE_CODE_RVALUE_REF
)
855 res_val
= value_cast (lookup_rvalue_reference_type (base_class_type
),
858 res_val
= value_cast (base_class_type
, tmp
);
862 /* Assume we are attempting an array access, and let the
863 value code throw an exception if the index has an invalid
865 struct value
*idx
= convert_value_from_python (key
);
869 /* Check the value's type is something that can be accessed via
873 tmp
= coerce_ref (tmp
);
874 type
= check_typedef (value_type (tmp
));
875 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
876 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
877 error (_("Cannot subscript requested type."));
879 res_val
= value_subscript (tmp
, value_as_long (idx
));
884 result
= value_to_value_object (res_val
);
886 CATCH (ex
, RETURN_MASK_ALL
)
892 GDB_PY_HANDLE_EXCEPTION (except
);
898 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
900 PyErr_Format (PyExc_NotImplementedError
,
901 _("Setting of struct elements is not currently supported."));
905 /* Called by the Python interpreter to perform an inferior function
906 call on the value. Returns NULL on error, with a python exception set. */
908 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
910 Py_ssize_t args_count
;
911 struct value
*function
= ((value_object
*) self
)->value
;
912 struct value
**vargs
= NULL
;
913 struct type
*ftype
= NULL
;
914 PyObject
*result
= NULL
;
918 ftype
= check_typedef (value_type (function
));
920 CATCH (except
, RETURN_MASK_ALL
)
922 GDB_PY_HANDLE_EXCEPTION (except
);
926 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
928 PyErr_SetString (PyExc_RuntimeError
,
929 _("Value is not callable (not TYPE_CODE_FUNC)."));
933 if (! PyTuple_Check (args
))
935 PyErr_SetString (PyExc_TypeError
,
936 _("Inferior arguments must be provided in a tuple."));
940 args_count
= PyTuple_Size (args
);
945 vargs
= XALLOCAVEC (struct value
*, args_count
);
946 for (i
= 0; i
< args_count
; i
++)
948 PyObject
*item
= PyTuple_GetItem (args
, i
);
953 vargs
[i
] = convert_value_from_python (item
);
954 if (vargs
[i
] == NULL
)
961 scoped_value_mark free_values
;
964 = call_function_by_hand (function
, NULL
,
965 gdb::make_array_view (vargs
, args_count
));
966 result
= value_to_value_object (return_value
);
968 CATCH (except
, RETURN_MASK_ALL
)
970 GDB_PY_HANDLE_EXCEPTION (except
);
977 /* Called by the Python interpreter to obtain string representation
980 valpy_str (PyObject
*self
)
982 struct value_print_options opts
;
984 get_user_print_options (&opts
);
991 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
992 &opts
, python_language
);
994 CATCH (except
, RETURN_MASK_ALL
)
996 GDB_PY_HANDLE_EXCEPTION (except
);
1000 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
1003 /* Implements gdb.Value.is_optimized_out. */
1005 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
1007 struct value
*value
= ((value_object
*) self
)->value
;
1012 opt
= value_optimized_out (value
);
1014 CATCH (except
, RETURN_MASK_ALL
)
1016 GDB_PY_HANDLE_EXCEPTION (except
);
1026 /* Implements gdb.Value.is_lazy. */
1028 valpy_get_is_lazy (PyObject
*self
, void *closure
)
1030 struct value
*value
= ((value_object
*) self
)->value
;
1035 opt
= value_lazy (value
);
1037 CATCH (except
, RETURN_MASK_ALL
)
1039 GDB_PY_HANDLE_EXCEPTION (except
);
1049 /* Implements gdb.Value.fetch_lazy (). */
1051 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
1053 struct value
*value
= ((value_object
*) self
)->value
;
1057 if (value_lazy (value
))
1058 value_fetch_lazy (value
);
1060 CATCH (except
, RETURN_MASK_ALL
)
1062 GDB_PY_HANDLE_EXCEPTION (except
);
1069 /* Calculate and return the address of the PyObject as the value of
1070 the builtin __hash__ call. */
1072 valpy_hash (PyObject
*self
)
1074 return (intptr_t) self
;
1092 /* If TYPE is a reference, return the target; otherwise return TYPE. */
1093 #define STRIP_REFERENCE(TYPE) \
1094 (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
1096 /* Helper for valpy_binop. Returns a value object which is the result
1097 of applying the operation specified by OPCODE to the given
1098 arguments. Throws a GDB exception on error. */
1101 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1103 PyObject
*result
= NULL
;
1105 struct value
*arg1
, *arg2
;
1106 struct value
*res_val
= NULL
;
1107 enum exp_opcode op
= OP_NULL
;
1110 scoped_value_mark free_values
;
1112 /* If the gdb.Value object is the second operand, then it will be
1113 passed to us as the OTHER argument, and SELF will be an entirely
1114 different kind of object, altogether. Because of this, we can't
1115 assume self is a gdb.Value object and need to convert it from
1117 arg1
= convert_value_from_python (self
);
1121 arg2
= convert_value_from_python (other
);
1129 struct type
*ltype
= value_type (arg1
);
1130 struct type
*rtype
= value_type (arg2
);
1132 ltype
= check_typedef (ltype
);
1133 ltype
= STRIP_REFERENCE (ltype
);
1134 rtype
= check_typedef (rtype
);
1135 rtype
= STRIP_REFERENCE (rtype
);
1138 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1139 && is_integral_type (rtype
))
1140 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1141 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
1142 && is_integral_type (ltype
))
1143 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1153 struct type
*ltype
= value_type (arg1
);
1154 struct type
*rtype
= value_type (arg2
);
1156 ltype
= check_typedef (ltype
);
1157 ltype
= STRIP_REFERENCE (ltype
);
1158 rtype
= check_typedef (rtype
);
1159 rtype
= STRIP_REFERENCE (rtype
);
1162 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1163 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
1164 /* A ptrdiff_t for the target would be preferable here. */
1165 res_val
= value_from_longest (builtin_type_pyint
,
1166 value_ptrdiff (arg1
, arg2
));
1167 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1168 && is_integral_type (rtype
))
1169 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1196 op
= BINOP_BITWISE_AND
;
1199 op
= BINOP_BITWISE_IOR
;
1202 op
= BINOP_BITWISE_XOR
;
1208 if (binop_user_defined_p (op
, arg1
, arg2
))
1209 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1211 res_val
= value_binop (arg1
, arg2
, op
);
1215 result
= value_to_value_object (res_val
);
1220 /* Returns a value object which is the result of applying the operation
1221 specified by OPCODE to the given arguments. Returns NULL on error, with
1222 a python exception set. */
1224 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1226 PyObject
*result
= NULL
;
1230 result
= valpy_binop_throw (opcode
, self
, other
);
1232 CATCH (except
, RETURN_MASK_ALL
)
1234 GDB_PY_HANDLE_EXCEPTION (except
);
1242 valpy_add (PyObject
*self
, PyObject
*other
)
1244 return valpy_binop (VALPY_ADD
, self
, other
);
1248 valpy_subtract (PyObject
*self
, PyObject
*other
)
1250 return valpy_binop (VALPY_SUB
, self
, other
);
1254 valpy_multiply (PyObject
*self
, PyObject
*other
)
1256 return valpy_binop (VALPY_MUL
, self
, other
);
1260 valpy_divide (PyObject
*self
, PyObject
*other
)
1262 return valpy_binop (VALPY_DIV
, self
, other
);
1266 valpy_remainder (PyObject
*self
, PyObject
*other
)
1268 return valpy_binop (VALPY_REM
, self
, other
);
1272 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1274 /* We don't support the ternary form of pow. I don't know how to express
1275 that, so let's just throw NotImplementedError to at least do something
1277 if (unused
!= Py_None
)
1279 PyErr_SetString (PyExc_NotImplementedError
,
1280 "Invalid operation on gdb.Value.");
1284 return valpy_binop (VALPY_POW
, self
, other
);
1288 valpy_negative (PyObject
*self
)
1290 PyObject
*result
= NULL
;
1294 /* Perhaps overkill, but consistency has some virtue. */
1295 scoped_value_mark free_values
;
1298 val
= value_neg (((value_object
*) self
)->value
);
1299 result
= value_to_value_object (val
);
1301 CATCH (except
, RETURN_MASK_ALL
)
1303 GDB_PY_HANDLE_EXCEPTION (except
);
1311 valpy_positive (PyObject
*self
)
1313 return value_to_value_object (((value_object
*) self
)->value
);
1317 valpy_absolute (PyObject
*self
)
1319 struct value
*value
= ((value_object
*) self
)->value
;
1324 scoped_value_mark free_values
;
1326 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1329 CATCH (except
, RETURN_MASK_ALL
)
1331 GDB_PY_HANDLE_EXCEPTION (except
);
1336 return valpy_positive (self
);
1338 return valpy_negative (self
);
1341 /* Implements boolean evaluation of gdb.Value. */
1343 valpy_nonzero (PyObject
*self
)
1345 struct gdb_exception except
= exception_none
;
1346 value_object
*self_value
= (value_object
*) self
;
1348 int nonzero
= 0; /* Appease GCC warning. */
1352 type
= check_typedef (value_type (self_value
->value
));
1354 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1355 nonzero
= !!value_as_long (self_value
->value
);
1356 else if (is_floating_value (self_value
->value
))
1357 nonzero
= !target_float_is_zero (value_contents (self_value
->value
),
1360 /* All other values are True. */
1363 CATCH (ex
, RETURN_MASK_ALL
)
1369 /* This is not documented in the Python documentation, but if this
1370 function fails, return -1 as slot_nb_nonzero does (the default
1371 Python nonzero function). */
1372 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1377 /* Implements ~ for value objects. */
1379 valpy_invert (PyObject
*self
)
1381 struct value
*val
= NULL
;
1385 val
= value_complement (((value_object
*) self
)->value
);
1387 CATCH (except
, RETURN_MASK_ALL
)
1389 GDB_PY_HANDLE_EXCEPTION (except
);
1393 return value_to_value_object (val
);
1396 /* Implements left shift for value objects. */
1398 valpy_lsh (PyObject
*self
, PyObject
*other
)
1400 return valpy_binop (VALPY_LSH
, self
, other
);
1403 /* Implements right shift for value objects. */
1405 valpy_rsh (PyObject
*self
, PyObject
*other
)
1407 return valpy_binop (VALPY_RSH
, self
, other
);
1410 /* Implements bitwise and for value objects. */
1412 valpy_and (PyObject
*self
, PyObject
*other
)
1414 return valpy_binop (VALPY_BITAND
, self
, other
);
1417 /* Implements bitwise or for value objects. */
1419 valpy_or (PyObject
*self
, PyObject
*other
)
1421 return valpy_binop (VALPY_BITOR
, self
, other
);
1424 /* Implements bitwise xor for value objects. */
1426 valpy_xor (PyObject
*self
, PyObject
*other
)
1428 return valpy_binop (VALPY_BITXOR
, self
, other
);
1431 /* Helper for valpy_richcompare. Implements comparison operations for
1432 value objects. Returns true/false on success. Returns -1 with a
1433 Python exception set if a Python error is detected. Throws a GDB
1434 exception on other errors (memory error, etc.). */
1437 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1440 struct value
*value_other
;
1441 struct value
*value_self
;
1443 scoped_value_mark free_values
;
1445 value_other
= convert_value_from_python (other
);
1446 if (value_other
== NULL
)
1449 value_self
= ((value_object
*) self
)->value
;
1454 result
= value_less (value_self
, value_other
);
1457 result
= value_less (value_self
, value_other
)
1458 || value_equal (value_self
, value_other
);
1461 result
= value_equal (value_self
, value_other
);
1464 result
= !value_equal (value_self
, value_other
);
1467 result
= value_less (value_other
, value_self
);
1470 result
= (value_less (value_other
, value_self
)
1471 || value_equal (value_self
, value_other
));
1475 PyErr_SetString (PyExc_NotImplementedError
,
1476 _("Invalid operation on gdb.Value."));
1485 /* Implements comparison operations for value objects. Returns NULL on error,
1486 with a python exception set. */
1488 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1492 if (other
== Py_None
)
1493 /* Comparing with None is special. From what I can tell, in Python
1494 None is smaller than anything else. */
1506 PyErr_SetString (PyExc_NotImplementedError
,
1507 _("Invalid operation on gdb.Value."));
1513 result
= valpy_richcompare_throw (self
, other
, op
);
1515 CATCH (except
, RETURN_MASK_ALL
)
1517 GDB_PY_HANDLE_EXCEPTION (except
);
1521 /* In this case, the Python exception has already been set. */
1532 /* Implements conversion to int. */
1534 valpy_int (PyObject
*self
)
1536 struct value
*value
= ((value_object
*) self
)->value
;
1537 struct type
*type
= value_type (value
);
1542 if (is_floating_value (value
))
1544 type
= builtin_type_pylong
;
1545 value
= value_cast (type
, value
);
1548 if (!is_integral_type (type
)
1549 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1550 error (_("Cannot convert value to int."));
1552 l
= value_as_long (value
);
1554 CATCH (except
, RETURN_MASK_ALL
)
1556 GDB_PY_HANDLE_EXCEPTION (except
);
1560 if (TYPE_UNSIGNED (type
))
1561 return gdb_py_object_from_ulongest (l
).release ();
1563 return gdb_py_object_from_longest (l
).release ();
1567 /* Implements conversion to long. */
1569 valpy_long (PyObject
*self
)
1571 struct value
*value
= ((value_object
*) self
)->value
;
1572 struct type
*type
= value_type (value
);
1577 if (is_floating_value (value
))
1579 type
= builtin_type_pylong
;
1580 value
= value_cast (type
, value
);
1583 type
= check_typedef (type
);
1585 if (!is_integral_type (type
)
1586 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1587 error (_("Cannot convert value to long."));
1589 l
= value_as_long (value
);
1591 CATCH (except
, RETURN_MASK_ALL
)
1593 GDB_PY_HANDLE_EXCEPTION (except
);
1597 if (TYPE_UNSIGNED (type
))
1598 return gdb_py_long_from_ulongest (l
);
1600 return gdb_py_long_from_longest (l
);
1603 /* Implements conversion to float. */
1605 valpy_float (PyObject
*self
)
1607 struct value
*value
= ((value_object
*) self
)->value
;
1608 struct type
*type
= value_type (value
);
1613 type
= check_typedef (type
);
1615 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& is_floating_value (value
))
1616 d
= target_float_to_host_double (value_contents (value
), type
);
1617 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1619 /* Note that valpy_long accepts TYPE_CODE_PTR and some
1620 others here here -- but casting a pointer or bool to a
1621 float seems wrong. */
1622 d
= value_as_long (value
);
1625 error (_("Cannot convert value to float."));
1627 CATCH (except
, RETURN_MASK_ALL
)
1629 GDB_PY_HANDLE_EXCEPTION (except
);
1633 return PyFloat_FromDouble (d
);
1636 /* Returns an object for a value which is released from the all_values chain,
1637 so its lifetime is not bound to the execution of a command. */
1639 value_to_value_object (struct value
*val
)
1641 value_object
*val_obj
;
1643 val_obj
= PyObject_New (value_object
, &value_object_type
);
1644 if (val_obj
!= NULL
)
1646 val_obj
->value
= release_value (val
).release ();
1647 val_obj
->address
= NULL
;
1648 val_obj
->type
= NULL
;
1649 val_obj
->dynamic_type
= NULL
;
1650 note_value (val_obj
);
1653 return (PyObject
*) val_obj
;
1656 /* Returns a borrowed reference to the struct value corresponding to
1657 the given value object. */
1659 value_object_to_value (PyObject
*self
)
1663 if (! PyObject_TypeCheck (self
, &value_object_type
))
1665 real
= (value_object
*) self
;
1669 /* Try to convert a Python value to a gdb value. If the value cannot
1670 be converted, set a Python exception and return NULL. Returns a
1671 reference to a new value on the all_values chain. */
1674 convert_value_from_python (PyObject
*obj
)
1676 struct value
*value
= NULL
; /* -Wall */
1679 gdb_assert (obj
!= NULL
);
1683 if (PyBool_Check (obj
))
1685 cmp
= PyObject_IsTrue (obj
);
1687 value
= value_from_longest (builtin_type_pybool
, cmp
);
1689 /* Make a long logic check first. In Python 3.x, internally,
1690 all integers are represented as longs. In Python 2.x, there
1691 is still a differentiation internally between a PyInt and a
1692 PyLong. Explicitly do this long check conversion first. In
1693 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1694 to be done first to ensure we do not lose information in the
1695 conversion process. */
1696 else if (PyLong_Check (obj
))
1698 LONGEST l
= PyLong_AsLongLong (obj
);
1700 if (PyErr_Occurred ())
1702 /* If the error was an overflow, we can try converting to
1703 ULONGEST instead. */
1704 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1706 gdbpy_err_fetch fetched_error
;
1707 gdbpy_ref
<> zero (PyInt_FromLong (0));
1709 /* Check whether obj is positive. */
1710 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1714 ul
= PyLong_AsUnsignedLongLong (obj
);
1715 if (! PyErr_Occurred ())
1716 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1720 /* There's nothing we can do. */
1721 fetched_error
.restore ();
1726 value
= value_from_longest (builtin_type_pylong
, l
);
1728 #if PY_MAJOR_VERSION == 2
1729 else if (PyInt_Check (obj
))
1731 long l
= PyInt_AsLong (obj
);
1733 if (! PyErr_Occurred ())
1734 value
= value_from_longest (builtin_type_pyint
, l
);
1737 else if (PyFloat_Check (obj
))
1739 double d
= PyFloat_AsDouble (obj
);
1741 if (! PyErr_Occurred ())
1743 value
= allocate_value (builtin_type_pyfloat
);
1744 target_float_from_host_double (value_contents_raw (value
),
1745 value_type (value
), d
);
1748 else if (gdbpy_is_string (obj
))
1750 gdb::unique_xmalloc_ptr
<char> s
1751 = python_string_to_target_string (obj
);
1753 value
= value_cstring (s
.get (), strlen (s
.get ()),
1754 builtin_type_pychar
);
1756 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1757 value
= value_copy (((value_object
*) obj
)->value
);
1758 else if (gdbpy_is_lazy_string (obj
))
1762 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1763 value
= value_copy (((value_object
*) result
)->value
);
1767 PyErr_Format (PyExc_TypeError
,
1768 _("Could not convert Python object: %S."), obj
);
1770 PyErr_Format (PyExc_TypeError
,
1771 _("Could not convert Python object: %s."),
1772 PyString_AsString (PyObject_Str (obj
)));
1775 CATCH (except
, RETURN_MASK_ALL
)
1777 gdbpy_convert_exception (except
);
1785 /* Returns value object in the ARGth position in GDB's history. */
1787 gdbpy_history (PyObject
*self
, PyObject
*args
)
1790 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1792 if (!PyArg_ParseTuple (args
, "i", &i
))
1797 res_val
= access_value_history (i
);
1799 CATCH (except
, RETURN_MASK_ALL
)
1801 GDB_PY_HANDLE_EXCEPTION (except
);
1805 return value_to_value_object (res_val
);
1808 /* Return the value of a convenience variable. */
1810 gdbpy_convenience_variable (PyObject
*self
, PyObject
*args
)
1812 const char *varname
;
1813 struct value
*res_val
= NULL
;
1815 if (!PyArg_ParseTuple (args
, "s", &varname
))
1820 struct internalvar
*var
= lookup_only_internalvar (varname
);
1824 res_val
= value_of_internalvar (python_gdbarch
, var
);
1825 if (TYPE_CODE (value_type (res_val
)) == TYPE_CODE_VOID
)
1829 CATCH (except
, RETURN_MASK_ALL
)
1831 GDB_PY_HANDLE_EXCEPTION (except
);
1835 if (res_val
== NULL
)
1838 return value_to_value_object (res_val
);
1841 /* Set the value of a convenience variable. */
1843 gdbpy_set_convenience_variable (PyObject
*self
, PyObject
*args
)
1845 const char *varname
;
1846 PyObject
*value_obj
;
1847 struct value
*value
= NULL
;
1849 if (!PyArg_ParseTuple (args
, "sO", &varname
, &value_obj
))
1852 /* None means to clear the variable. */
1853 if (value_obj
!= Py_None
)
1855 value
= convert_value_from_python (value_obj
);
1864 struct internalvar
*var
= lookup_only_internalvar (varname
);
1867 clear_internalvar (var
);
1871 struct internalvar
*var
= lookup_internalvar (varname
);
1873 set_internalvar (var
, value
);
1876 CATCH (except
, RETURN_MASK_ALL
)
1878 GDB_PY_HANDLE_EXCEPTION (except
);
1885 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1888 gdbpy_is_value_object (PyObject
*obj
)
1890 return PyObject_TypeCheck (obj
, &value_object_type
);
1894 gdbpy_initialize_values (void)
1896 if (PyType_Ready (&value_object_type
) < 0)
1899 return gdb_pymodule_addobject (gdb_module
, "Value",
1900 (PyObject
*) &value_object_type
);
1905 static gdb_PyGetSetDef value_object_getset
[] = {
1906 { "address", valpy_get_address
, NULL
, "The address of the value.",
1908 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1909 "Boolean telling whether the value is optimized "
1910 "out (i.e., not available).",
1912 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1913 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1914 "Dynamic type of the value.", NULL
},
1915 { "is_lazy", valpy_get_is_lazy
, NULL
,
1916 "Boolean telling whether the value is lazy (not fetched yet\n\
1917 from the inferior). A lazy value is fetched when needed, or when\n\
1918 the \"fetch_lazy()\" method is called.", NULL
},
1919 {NULL
} /* Sentinel */
1922 static PyMethodDef value_object_methods
[] = {
1923 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1924 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1925 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1926 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1928 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1929 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1930 Cast the value to the supplied type, as if by the C++\n\
1931 reinterpret_cast operator."
1933 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1934 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1935 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1936 { "reference_value", valpy_lvalue_reference_value
, METH_NOARGS
,
1937 "Return a value of type TYPE_CODE_REF referencing this value." },
1938 { "rvalue_reference_value", valpy_rvalue_reference_value
, METH_NOARGS
,
1939 "Return a value of type TYPE_CODE_RVALUE_REF referencing this value." },
1940 { "const_value", valpy_const_value
, METH_NOARGS
,
1941 "Return a 'const' qualied version of the same value." },
1942 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1943 METH_VARARGS
| METH_KEYWORDS
,
1944 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1945 Return a lazy string representation of the value." },
1946 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1947 "string ([encoding] [, errors] [, length]) -> string\n\
1948 Return Unicode string representation of the value." },
1949 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1950 "Fetches the value from the inferior, if it was lazy." },
1951 {NULL
} /* Sentinel */
1954 static PyNumberMethods value_object_as_number
= {
1962 NULL
, /* nb_divmod */
1963 valpy_power
, /* nb_power */
1964 valpy_negative
, /* nb_negative */
1965 valpy_positive
, /* nb_positive */
1966 valpy_absolute
, /* nb_absolute */
1967 valpy_nonzero
, /* nb_nonzero */
1968 valpy_invert
, /* nb_invert */
1969 valpy_lsh
, /* nb_lshift */
1970 valpy_rsh
, /* nb_rshift */
1971 valpy_and
, /* nb_and */
1972 valpy_xor
, /* nb_xor */
1973 valpy_or
, /* nb_or */
1975 valpy_long
, /* nb_int */
1976 NULL
, /* reserved */
1978 NULL
, /* nb_coerce */
1979 valpy_int
, /* nb_int */
1980 valpy_long
, /* nb_long */
1982 valpy_float
, /* nb_float */
1987 NULL
, /* nb_inplace_add */
1988 NULL
, /* nb_inplace_subtract */
1989 NULL
, /* nb_inplace_multiply */
1991 NULL
, /* nb_inplace_divide */
1993 NULL
, /* nb_inplace_remainder */
1994 NULL
, /* nb_inplace_power */
1995 NULL
, /* nb_inplace_lshift */
1996 NULL
, /* nb_inplace_rshift */
1997 NULL
, /* nb_inplace_and */
1998 NULL
, /* nb_inplace_xor */
1999 NULL
, /* nb_inplace_or */
2000 NULL
, /* nb_floor_divide */
2001 valpy_divide
, /* nb_true_divide */
2002 NULL
, /* nb_inplace_floor_divide */
2003 NULL
, /* nb_inplace_true_divide */
2004 valpy_long
, /* nb_index */
2007 static PyMappingMethods value_object_as_mapping
= {
2013 PyTypeObject value_object_type
= {
2014 PyVarObject_HEAD_INIT (NULL
, 0)
2015 "gdb.Value", /*tp_name*/
2016 sizeof (value_object
), /*tp_basicsize*/
2018 valpy_dealloc
, /*tp_dealloc*/
2024 &value_object_as_number
, /*tp_as_number*/
2025 0, /*tp_as_sequence*/
2026 &value_object_as_mapping
, /*tp_as_mapping*/
2027 valpy_hash
, /*tp_hash*/
2028 valpy_call
, /*tp_call*/
2029 valpy_str
, /*tp_str*/
2033 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
2034 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
2035 "GDB value object", /* tp_doc */
2036 0, /* tp_traverse */
2038 valpy_richcompare
, /* tp_richcompare */
2039 0, /* tp_weaklistoffset */
2041 0, /* tp_iternext */
2042 value_object_methods
, /* tp_methods */
2044 value_object_getset
, /* tp_getset */
2047 0, /* tp_descr_get */
2048 0, /* tp_descr_set */
2049 0, /* tp_dictoffset */
2052 valpy_new
/* tp_new */