1 /* Python interface to values.
3 Copyright (C) 2008-2022 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)
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 /* Clear out an old GDB value stored within SELF, and reset the fields to
74 nullptr. This should be called when a gdb.Value is deallocated, and
75 also if a gdb.Value is reinitialized with a new value. */
78 valpy_clear_value (value_object
*self
)
80 /* Indicate we are no longer interested in the value object. */
81 value_decref (self
->value
);
82 self
->value
= nullptr;
84 Py_CLEAR (self
->address
);
85 Py_CLEAR (self
->type
);
86 Py_CLEAR (self
->dynamic_type
);
89 /* Called by the Python interpreter when deallocating a value object. */
91 valpy_dealloc (PyObject
*obj
)
93 value_object
*self
= (value_object
*) obj
;
95 /* If SELF failed to initialize correctly then it may not have a value
96 contained within it. */
97 if (self
->value
!= nullptr)
99 /* Remove SELF from the global list of values. */
100 if (self
->prev
!= nullptr)
101 self
->prev
->next
= self
->next
;
104 gdb_assert (values_in_python
== self
);
105 values_in_python
= self
->next
;
107 if (self
->next
!= nullptr)
108 self
->next
->prev
= self
->prev
;
110 /* Release the value object and any cached Python objects. */
111 valpy_clear_value (self
);
114 Py_TYPE (self
)->tp_free (self
);
117 /* Helper to push a gdb.Value object on to the global list of values. If
118 VALUE_OBJ is already on the lit then this does nothing. */
121 note_value (value_object
*value_obj
)
123 if (value_obj
->next
== nullptr)
125 gdb_assert (value_obj
->prev
== nullptr);
126 value_obj
->next
= values_in_python
;
127 if (value_obj
->next
!= nullptr)
128 value_obj
->next
->prev
= value_obj
;
129 values_in_python
= value_obj
;
133 /* Convert a python object OBJ with type TYPE to a gdb value. The
134 python object in question must conform to the python buffer
135 protocol. On success, return the converted value, otherwise
138 static struct value
*
139 convert_buffer_and_type_to_value (PyObject
*obj
, struct type
*type
)
141 Py_buffer_up buffer_up
;
144 if (PyObject_CheckBuffer (obj
)
145 && PyObject_GetBuffer (obj
, &py_buf
, PyBUF_SIMPLE
) == 0)
147 /* Got a buffer, py_buf, out of obj. Cause it to be released
148 when it goes out of scope. */
149 buffer_up
.reset (&py_buf
);
153 PyErr_SetString (PyExc_TypeError
,
154 _("Object must support the python buffer protocol."));
158 if (TYPE_LENGTH (type
) > py_buf
.len
)
160 PyErr_SetString (PyExc_ValueError
,
161 _("Size of type is larger than that of buffer object."));
165 return value_from_contents (type
, (const gdb_byte
*) py_buf
.buf
);
168 /* Implement gdb.Value.__init__. */
171 valpy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
173 static const char *keywords
[] = { "val", "type", NULL
};
174 PyObject
*val_obj
= nullptr;
175 PyObject
*type_obj
= nullptr;
177 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kwds
, "O|O", keywords
,
178 &val_obj
, &type_obj
))
181 struct type
*type
= nullptr;
182 if (type_obj
!= nullptr && type_obj
!= Py_None
)
184 type
= type_object_to_type (type_obj
);
187 PyErr_SetString (PyExc_TypeError
,
188 _("type argument must be a gdb.Type."));
195 value
= convert_value_from_python (val_obj
);
197 value
= convert_buffer_and_type_to_value (val_obj
, type
);
198 if (value
== nullptr)
200 gdb_assert (PyErr_Occurred ());
204 /* There might be a previous value here. */
205 value_object
*value_obj
= (value_object
*) self
;
206 if (value_obj
->value
!= nullptr)
207 valpy_clear_value (value_obj
);
209 /* Store the value into this Python object. */
210 value_obj
->value
= release_value (value
).release ();
212 /* Ensure that this gdb.Value is in the set of all gdb.Value objects. If
213 we are already in the set then this is call does nothing. */
214 note_value (value_obj
);
219 /* Iterate over all the Value objects, calling preserve_one_value on
222 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
223 struct objfile
*objfile
, htab_t copied_types
)
227 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
228 preserve_one_value (iter
->value
, objfile
, copied_types
);
231 /* Given a value of a pointer type, apply the C unary * operator to it. */
233 valpy_dereference (PyObject
*self
, PyObject
*args
)
235 PyObject
*result
= NULL
;
239 struct value
*res_val
;
240 scoped_value_mark free_values
;
242 res_val
= value_ind (((value_object
*) self
)->value
);
243 result
= value_to_value_object (res_val
);
245 catch (const gdb_exception
&except
)
247 GDB_PY_HANDLE_EXCEPTION (except
);
253 /* Given a value of a pointer type or a reference type, return the value
254 referenced. The difference between this function and valpy_dereference is
255 that the latter applies * unary operator to a value, which need not always
256 result in the value referenced. For example, for a value which is a reference
257 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
258 type 'int' while valpy_referenced_value will result in a value of type
262 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
264 PyObject
*result
= NULL
;
268 struct value
*self_val
, *res_val
;
269 scoped_value_mark free_values
;
271 self_val
= ((value_object
*) self
)->value
;
272 switch (check_typedef (value_type (self_val
))->code ())
275 res_val
= value_ind (self_val
);
278 case TYPE_CODE_RVALUE_REF
:
279 res_val
= coerce_ref (self_val
);
282 error(_("Trying to get the referenced value from a value which is "
283 "neither a pointer nor a reference."));
286 result
= value_to_value_object (res_val
);
288 catch (const gdb_exception
&except
)
290 GDB_PY_HANDLE_EXCEPTION (except
);
296 /* Return a value which is a reference to the value. */
299 valpy_reference_value (PyObject
*self
, PyObject
*args
, enum type_code refcode
)
301 PyObject
*result
= NULL
;
305 struct value
*self_val
;
306 scoped_value_mark free_values
;
308 self_val
= ((value_object
*) self
)->value
;
309 result
= value_to_value_object (value_ref (self_val
, refcode
));
311 catch (const gdb_exception
&except
)
313 GDB_PY_HANDLE_EXCEPTION (except
);
320 valpy_lvalue_reference_value (PyObject
*self
, PyObject
*args
)
322 return valpy_reference_value (self
, args
, TYPE_CODE_REF
);
326 valpy_rvalue_reference_value (PyObject
*self
, PyObject
*args
)
328 return valpy_reference_value (self
, args
, TYPE_CODE_RVALUE_REF
);
331 /* Return a "const" qualified version of the value. */
334 valpy_const_value (PyObject
*self
, PyObject
*args
)
336 PyObject
*result
= NULL
;
340 struct value
*self_val
, *res_val
;
341 scoped_value_mark free_values
;
343 self_val
= ((value_object
*) self
)->value
;
344 res_val
= make_cv_value (1, 0, self_val
);
345 result
= value_to_value_object (res_val
);
347 catch (const gdb_exception
&except
)
349 GDB_PY_HANDLE_EXCEPTION (except
);
355 /* Return "&value". */
357 valpy_get_address (PyObject
*self
, void *closure
)
359 value_object
*val_obj
= (value_object
*) self
;
361 if (!val_obj
->address
)
365 struct value
*res_val
;
366 scoped_value_mark free_values
;
368 res_val
= value_addr (val_obj
->value
);
369 val_obj
->address
= value_to_value_object (res_val
);
371 catch (const gdb_exception
&except
)
373 val_obj
->address
= Py_None
;
378 Py_XINCREF (val_obj
->address
);
380 return val_obj
->address
;
383 /* Return type of the value. */
385 valpy_get_type (PyObject
*self
, void *closure
)
387 value_object
*obj
= (value_object
*) self
;
391 obj
->type
= type_to_type_object (value_type (obj
->value
));
395 Py_INCREF (obj
->type
);
399 /* Return dynamic type of the value. */
402 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
404 value_object
*obj
= (value_object
*) self
;
405 struct type
*type
= NULL
;
407 if (obj
->dynamic_type
!= NULL
)
409 Py_INCREF (obj
->dynamic_type
);
410 return obj
->dynamic_type
;
415 struct value
*val
= obj
->value
;
416 scoped_value_mark free_values
;
418 type
= value_type (val
);
419 type
= check_typedef (type
);
421 if (type
->is_pointer_or_reference ()
422 && (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_STRUCT
))
424 struct value
*target
;
425 int was_pointer
= type
->code () == TYPE_CODE_PTR
;
428 target
= value_ind (val
);
430 target
= coerce_ref (val
);
431 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
436 type
= lookup_pointer_type (type
);
438 type
= lookup_lvalue_reference_type (type
);
441 else if (type
->code () == TYPE_CODE_STRUCT
)
442 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
445 /* Re-use object's static type. */
449 catch (const gdb_exception
&except
)
451 GDB_PY_HANDLE_EXCEPTION (except
);
455 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
457 obj
->dynamic_type
= type_to_type_object (type
);
459 Py_XINCREF (obj
->dynamic_type
);
460 return obj
->dynamic_type
;
463 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
464 string. Return a PyObject representing a lazy_string_object type.
465 A lazy string is a pointer to a string with an optional encoding and
466 length. If ENCODING is not given, encoding is set to None. If an
467 ENCODING is provided the encoding parameter is set to ENCODING, but
468 the string is not encoded.
469 If LENGTH is provided then the length parameter is set to LENGTH.
470 Otherwise if the value is an array of known length then the array's length
471 is used. Otherwise the length will be set to -1 (meaning first null of
474 Note: In order to not break any existing uses this allows creating
475 lazy strings from anything. PR 20769. E.g.,
476 gdb.parse_and_eval("my_int_variable").lazy_string().
477 "It's easier to relax restrictions than it is to impose them after the
478 fact." So we should be flagging any unintended uses as errors, but it's
479 perhaps too late for that. */
482 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
484 gdb_py_longest length
= -1;
485 struct value
*value
= ((value_object
*) self
)->value
;
486 const char *user_encoding
= NULL
;
487 static const char *keywords
[] = { "encoding", "length", NULL
};
488 PyObject
*str_obj
= NULL
;
490 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
,
491 keywords
, &user_encoding
, &length
))
496 PyErr_SetString (PyExc_ValueError
, _("Invalid length."));
502 scoped_value_mark free_values
;
503 struct type
*type
, *realtype
;
506 type
= value_type (value
);
507 realtype
= check_typedef (type
);
509 switch (realtype
->code ())
511 case TYPE_CODE_ARRAY
:
513 LONGEST array_length
= -1;
514 LONGEST low_bound
, high_bound
;
516 /* PR 20786: There's no way to specify an array of length zero.
517 Record a length of [0,-1] which is how Ada does it. Anything
518 we do is broken, but this one possible solution. */
519 if (get_array_bounds (realtype
, &low_bound
, &high_bound
))
520 array_length
= high_bound
- low_bound
+ 1;
522 length
= array_length
;
523 else if (array_length
== -1)
525 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
528 else if (length
!= array_length
)
530 /* We need to create a new array type with the
532 if (length
> array_length
)
533 error (_("Length is larger than array size."));
534 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
536 low_bound
+ length
- 1);
538 addr
= value_address (value
);
542 /* If a length is specified we defer creating an array of the
543 specified width until we need to. */
544 addr
= value_as_address (value
);
547 /* Should flag an error here. PR 20769. */
548 addr
= value_address (value
);
552 str_obj
= gdbpy_create_lazy_string_object (addr
, length
, user_encoding
,
555 catch (const gdb_exception
&except
)
557 GDB_PY_HANDLE_EXCEPTION (except
);
563 /* Implementation of gdb.Value.string ([encoding] [, errors]
564 [, length]) -> string. Return Unicode string with value contents.
565 If ENCODING is not given, the string is assumed to be encoded in
566 the target's charset. If LENGTH is provided, only fetch string to
567 the length provided. */
570 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
573 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
;
574 struct value
*value
= ((value_object
*) self
)->value
;
575 const char *encoding
= NULL
;
576 const char *errors
= NULL
;
577 const char *user_encoding
= NULL
;
578 const char *la_encoding
= NULL
;
579 struct type
*char_type
;
580 static const char *keywords
[] = { "encoding", "errors", "length", NULL
};
582 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
583 &user_encoding
, &errors
, &length
))
588 c_get_string (value
, &buffer
, &length
, &char_type
, &la_encoding
);
590 catch (const gdb_exception
&except
)
592 GDB_PY_HANDLE_EXCEPTION (except
);
595 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
596 return PyUnicode_Decode ((const char *) buffer
.get (),
597 length
* TYPE_LENGTH (char_type
),
601 /* Given a Python object, copy its truth value to a C bool (the value
603 If src_obj is NULL, then *dest is not modified.
605 Return true in case of success (including src_obj being NULL), false
609 copy_py_bool_obj (bool *dest
, PyObject
*src_obj
)
613 int cmp
= PyObject_IsTrue (src_obj
);
622 /* Implementation of gdb.Value.format_string (...) -> string.
623 Return Unicode string with value contents formatted using the
624 keyword-only arguments. */
627 valpy_format_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
629 static const char *keywords
[] =
631 /* Basic C/C++ options. */
632 "raw", /* See the /r option to print. */
633 "pretty_arrays", /* See set print array on|off. */
634 "pretty_structs", /* See set print pretty on|off. */
635 "array_indexes", /* See set print array-indexes on|off. */
636 "symbols", /* See set print symbol on|off. */
637 "unions", /* See set print union on|off. */
638 "address", /* See set print address on|off. */
640 "deref_refs", /* No corresponding setting. */
641 "actual_objects", /* See set print object on|off. */
642 "static_members", /* See set print static-members on|off. */
643 /* C non-bool options. */
644 "max_elements", /* See set print elements N. */
645 "max_depth", /* See set print max-depth N. */
646 "repeat_threshold", /* See set print repeats. */
647 "format", /* The format passed to the print command. */
651 /* This function has too many arguments to be useful as positionals, so
652 the user should specify them all as keyword arguments.
653 Python 3.3 and later have a way to specify it (both in C and Python
654 itself), but we could be compiled with older versions, so we just
655 check that the args tuple is empty. */
656 Py_ssize_t positional_count
= PyObject_Length (args
);
657 if (positional_count
< 0)
659 else if (positional_count
> 0)
661 /* This matches the error message that Python 3.3 raises when
662 passing positionals to functions expecting keyword-only
664 PyErr_Format (PyExc_TypeError
,
665 "format_string() takes 0 positional arguments but %zu were given",
670 struct value_print_options opts
;
671 get_user_print_options (&opts
);
674 /* We need objects for booleans as the "p" flag for bools is new in
676 PyObject
*raw_obj
= NULL
;
677 PyObject
*pretty_arrays_obj
= NULL
;
678 PyObject
*pretty_structs_obj
= NULL
;
679 PyObject
*array_indexes_obj
= NULL
;
680 PyObject
*symbols_obj
= NULL
;
681 PyObject
*unions_obj
= NULL
;
682 PyObject
*address_obj
= NULL
;
683 PyObject
*deref_refs_obj
= NULL
;
684 PyObject
*actual_objects_obj
= NULL
;
685 PyObject
*static_members_obj
= NULL
;
687 if (!gdb_PyArg_ParseTupleAndKeywords (args
,
689 "|O!O!O!O!O!O!O!O!O!O!IIIs",
691 &PyBool_Type
, &raw_obj
,
692 &PyBool_Type
, &pretty_arrays_obj
,
693 &PyBool_Type
, &pretty_structs_obj
,
694 &PyBool_Type
, &array_indexes_obj
,
695 &PyBool_Type
, &symbols_obj
,
696 &PyBool_Type
, &unions_obj
,
697 &PyBool_Type
, &address_obj
,
698 &PyBool_Type
, &deref_refs_obj
,
699 &PyBool_Type
, &actual_objects_obj
,
700 &PyBool_Type
, &static_members_obj
,
703 &opts
.repeat_count_threshold
,
707 /* Set boolean arguments. */
708 if (!copy_py_bool_obj (&opts
.raw
, raw_obj
))
710 if (!copy_py_bool_obj (&opts
.prettyformat_arrays
, pretty_arrays_obj
))
712 if (!copy_py_bool_obj (&opts
.prettyformat_structs
, pretty_structs_obj
))
714 if (!copy_py_bool_obj (&opts
.print_array_indexes
, array_indexes_obj
))
716 if (!copy_py_bool_obj (&opts
.symbol_print
, symbols_obj
))
718 if (!copy_py_bool_obj (&opts
.unionprint
, unions_obj
))
720 if (!copy_py_bool_obj (&opts
.addressprint
, address_obj
))
722 if (!copy_py_bool_obj (&opts
.deref_ref
, deref_refs_obj
))
724 if (!copy_py_bool_obj (&opts
.objectprint
, actual_objects_obj
))
726 if (!copy_py_bool_obj (&opts
.static_field_print
, static_members_obj
))
729 /* Numeric arguments for which 0 means unlimited (which we represent as
730 UINT_MAX). Note that the max-depth numeric argument uses -1 as
731 unlimited, and 0 is a valid choice. */
732 if (opts
.print_max
== 0)
733 opts
.print_max
= UINT_MAX
;
734 if (opts
.repeat_count_threshold
== 0)
735 opts
.repeat_count_threshold
= UINT_MAX
;
737 /* Other arguments. */
740 if (strlen (format
) == 1)
741 opts
.format
= format
[0];
744 /* Mimic the message on standard Python ones for similar
746 PyErr_SetString (PyExc_ValueError
,
747 "a single character is required");
756 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
757 &opts
, python_language
);
759 catch (const gdb_exception
&except
)
761 GDB_PY_HANDLE_EXCEPTION (except
);
764 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
767 /* A helper function that implements the various cast operators. */
770 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
772 PyObject
*type_obj
, *result
= NULL
;
775 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
778 type
= type_object_to_type (type_obj
);
781 PyErr_SetString (PyExc_RuntimeError
,
782 _("Argument must be a type."));
788 struct value
*val
= ((value_object
*) self
)->value
;
789 struct value
*res_val
;
790 scoped_value_mark free_values
;
792 if (op
== UNOP_DYNAMIC_CAST
)
793 res_val
= value_dynamic_cast (type
, val
);
794 else if (op
== UNOP_REINTERPRET_CAST
)
795 res_val
= value_reinterpret_cast (type
, val
);
798 gdb_assert (op
== UNOP_CAST
);
799 res_val
= value_cast (type
, val
);
802 result
= value_to_value_object (res_val
);
804 catch (const gdb_exception
&except
)
806 GDB_PY_HANDLE_EXCEPTION (except
);
812 /* Implementation of the "cast" method. */
815 valpy_cast (PyObject
*self
, PyObject
*args
)
817 return valpy_do_cast (self
, args
, UNOP_CAST
);
820 /* Implementation of the "dynamic_cast" method. */
823 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
825 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
828 /* Implementation of the "reinterpret_cast" method. */
831 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
833 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
837 valpy_length (PyObject
*self
)
839 /* We don't support getting the number of elements in a struct / class. */
840 PyErr_SetString (PyExc_NotImplementedError
,
841 _("Invalid operation on gdb.Value."));
845 /* Return 1 if the gdb.Field object FIELD is present in the value V.
846 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
849 value_has_field (struct value
*v
, PyObject
*field
)
851 struct type
*parent_type
, *val_type
;
852 enum type_code type_code
;
853 gdbpy_ref
<> type_object (PyObject_GetAttrString (field
, "parent_type"));
856 if (type_object
== NULL
)
859 parent_type
= type_object_to_type (type_object
.get ());
860 if (parent_type
== NULL
)
862 PyErr_SetString (PyExc_TypeError
,
863 _("'parent_type' attribute of gdb.Field object is not a"
864 "gdb.Type object."));
870 val_type
= value_type (v
);
871 val_type
= check_typedef (val_type
);
872 if (val_type
->is_pointer_or_reference ())
873 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
875 type_code
= val_type
->code ();
876 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
877 && types_equal (val_type
, parent_type
))
882 catch (const gdb_exception
&except
)
884 GDB_PY_SET_HANDLE_EXCEPTION (except
);
890 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
891 Returns 1 if the flag value is true, 0 if it is false, and -1 if
892 a Python error occurs. */
895 get_field_flag (PyObject
*field
, const char *flag_name
)
897 gdbpy_ref
<> flag_object (PyObject_GetAttrString (field
, flag_name
));
899 if (flag_object
== NULL
)
902 return PyObject_IsTrue (flag_object
.get ());
905 /* Return the "type" attribute of a gdb.Field object.
906 Returns NULL on error, with a Python exception set. */
909 get_field_type (PyObject
*field
)
911 gdbpy_ref
<> ftype_obj (PyObject_GetAttrString (field
, "type"));
914 if (ftype_obj
== NULL
)
916 ftype
= type_object_to_type (ftype_obj
.get ());
918 PyErr_SetString (PyExc_TypeError
,
919 _("'type' attribute of gdb.Field object is not a "
920 "gdb.Type object."));
925 /* Given string name or a gdb.Field object corresponding to an element inside
926 a structure, return its value object. Returns NULL on error, with a python
930 valpy_getitem (PyObject
*self
, PyObject
*key
)
932 struct gdb_exception except
;
933 value_object
*self_value
= (value_object
*) self
;
934 gdb::unique_xmalloc_ptr
<char> field
;
935 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
937 PyObject
*result
= NULL
;
939 if (gdbpy_is_string (key
))
941 field
= python_string_to_host_string (key
);
945 else if (gdbpy_is_field (key
))
947 int is_base_class
, valid_field
;
949 valid_field
= value_has_field (self_value
->value
, key
);
952 else if (valid_field
== 0)
954 PyErr_SetString (PyExc_TypeError
,
955 _("Invalid lookup for a field not contained in "
961 is_base_class
= get_field_flag (key
, "is_base_class");
962 if (is_base_class
< 0)
964 else if (is_base_class
> 0)
966 base_class_type
= get_field_type (key
);
967 if (base_class_type
== NULL
)
972 gdbpy_ref
<> name_obj (PyObject_GetAttrString (key
, "name"));
974 if (name_obj
== NULL
)
977 if (name_obj
!= Py_None
)
979 field
= python_string_to_host_string (name_obj
.get ());
985 if (!PyObject_HasAttrString (key
, "bitpos"))
987 PyErr_SetString (PyExc_AttributeError
,
988 _("gdb.Field object has no name and no "
989 "'bitpos' attribute."));
993 gdbpy_ref
<> bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
994 if (bitpos_obj
== NULL
)
996 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
999 field_type
= get_field_type (key
);
1000 if (field_type
== NULL
)
1008 struct value
*tmp
= self_value
->value
;
1009 struct value
*res_val
= NULL
;
1010 scoped_value_mark free_values
;
1013 res_val
= value_struct_elt (&tmp
, {}, field
.get (), NULL
,
1014 "struct/class/union");
1015 else if (bitpos
>= 0)
1016 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
1017 "struct/class/union");
1018 else if (base_class_type
!= NULL
)
1020 struct type
*val_type
;
1022 val_type
= check_typedef (value_type (tmp
));
1023 if (val_type
->code () == TYPE_CODE_PTR
)
1024 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
1025 else if (val_type
->code () == TYPE_CODE_REF
)
1026 res_val
= value_cast (lookup_lvalue_reference_type (base_class_type
),
1028 else if (val_type
->code () == TYPE_CODE_RVALUE_REF
)
1029 res_val
= value_cast (lookup_rvalue_reference_type (base_class_type
),
1032 res_val
= value_cast (base_class_type
, tmp
);
1036 /* Assume we are attempting an array access, and let the
1037 value code throw an exception if the index has an invalid
1039 struct value
*idx
= convert_value_from_python (key
);
1043 /* Check the value's type is something that can be accessed via
1047 tmp
= coerce_ref (tmp
);
1048 type
= check_typedef (value_type (tmp
));
1049 if (type
->code () != TYPE_CODE_ARRAY
1050 && type
->code () != TYPE_CODE_PTR
)
1051 error (_("Cannot subscript requested type."));
1053 res_val
= value_subscript (tmp
, value_as_long (idx
));
1058 result
= value_to_value_object (res_val
);
1060 catch (gdb_exception
&ex
)
1062 except
= std::move (ex
);
1065 GDB_PY_HANDLE_EXCEPTION (except
);
1071 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
1073 PyErr_Format (PyExc_NotImplementedError
,
1074 _("Setting of struct elements is not currently supported."));
1078 /* Called by the Python interpreter to perform an inferior function
1079 call on the value. Returns NULL on error, with a python exception set. */
1081 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
1083 Py_ssize_t args_count
;
1084 struct value
*function
= ((value_object
*) self
)->value
;
1085 struct value
**vargs
= NULL
;
1086 struct type
*ftype
= NULL
;
1087 PyObject
*result
= NULL
;
1091 ftype
= check_typedef (value_type (function
));
1093 catch (const gdb_exception
&except
)
1095 GDB_PY_HANDLE_EXCEPTION (except
);
1098 if (ftype
->code () != TYPE_CODE_FUNC
)
1100 PyErr_SetString (PyExc_RuntimeError
,
1101 _("Value is not callable (not TYPE_CODE_FUNC)."));
1105 if (! PyTuple_Check (args
))
1107 PyErr_SetString (PyExc_TypeError
,
1108 _("Inferior arguments must be provided in a tuple."));
1112 args_count
= PyTuple_Size (args
);
1117 vargs
= XALLOCAVEC (struct value
*, args_count
);
1118 for (i
= 0; i
< args_count
; i
++)
1120 PyObject
*item
= PyTuple_GetItem (args
, i
);
1125 vargs
[i
] = convert_value_from_python (item
);
1126 if (vargs
[i
] == NULL
)
1133 scoped_value_mark free_values
;
1136 = call_function_by_hand (function
, NULL
,
1137 gdb::make_array_view (vargs
, args_count
));
1138 result
= value_to_value_object (return_value
);
1140 catch (const gdb_exception
&except
)
1142 GDB_PY_HANDLE_EXCEPTION (except
);
1148 /* Called by the Python interpreter to obtain string representation
1151 valpy_str (PyObject
*self
)
1153 struct value_print_options opts
;
1155 get_user_print_options (&opts
);
1162 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
1163 &opts
, python_language
);
1165 catch (const gdb_exception
&except
)
1167 GDB_PY_HANDLE_EXCEPTION (except
);
1170 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
1173 /* Implements gdb.Value.is_optimized_out. */
1175 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
1177 struct value
*value
= ((value_object
*) self
)->value
;
1182 opt
= value_optimized_out (value
);
1184 catch (const gdb_exception
&except
)
1186 GDB_PY_HANDLE_EXCEPTION (except
);
1195 /* Implements gdb.Value.is_lazy. */
1197 valpy_get_is_lazy (PyObject
*self
, void *closure
)
1199 struct value
*value
= ((value_object
*) self
)->value
;
1204 opt
= value_lazy (value
);
1206 catch (const gdb_exception
&except
)
1208 GDB_PY_HANDLE_EXCEPTION (except
);
1217 /* Implements gdb.Value.fetch_lazy (). */
1219 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
1221 struct value
*value
= ((value_object
*) self
)->value
;
1225 if (value_lazy (value
))
1226 value_fetch_lazy (value
);
1228 catch (const gdb_exception
&except
)
1230 GDB_PY_HANDLE_EXCEPTION (except
);
1236 /* Calculate and return the address of the PyObject as the value of
1237 the builtin __hash__ call. */
1239 valpy_hash (PyObject
*self
)
1241 return (intptr_t) self
;
1259 /* If TYPE is a reference, return the target; otherwise return TYPE. */
1260 #define STRIP_REFERENCE(TYPE) \
1261 (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
1263 /* Helper for valpy_binop. Returns a value object which is the result
1264 of applying the operation specified by OPCODE to the given
1265 arguments. Throws a GDB exception on error. */
1268 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1270 PyObject
*result
= NULL
;
1272 struct value
*arg1
, *arg2
;
1273 struct value
*res_val
= NULL
;
1274 enum exp_opcode op
= OP_NULL
;
1277 scoped_value_mark free_values
;
1279 /* If the gdb.Value object is the second operand, then it will be
1280 passed to us as the OTHER argument, and SELF will be an entirely
1281 different kind of object, altogether. Because of this, we can't
1282 assume self is a gdb.Value object and need to convert it from
1284 arg1
= convert_value_from_python (self
);
1288 arg2
= convert_value_from_python (other
);
1296 struct type
*ltype
= value_type (arg1
);
1297 struct type
*rtype
= value_type (arg2
);
1299 ltype
= check_typedef (ltype
);
1300 ltype
= STRIP_REFERENCE (ltype
);
1301 rtype
= check_typedef (rtype
);
1302 rtype
= STRIP_REFERENCE (rtype
);
1305 if (ltype
->code () == TYPE_CODE_PTR
1306 && is_integral_type (rtype
))
1307 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1308 else if (rtype
->code () == TYPE_CODE_PTR
1309 && is_integral_type (ltype
))
1310 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1320 struct type
*ltype
= value_type (arg1
);
1321 struct type
*rtype
= value_type (arg2
);
1323 ltype
= check_typedef (ltype
);
1324 ltype
= STRIP_REFERENCE (ltype
);
1325 rtype
= check_typedef (rtype
);
1326 rtype
= STRIP_REFERENCE (rtype
);
1329 if (ltype
->code () == TYPE_CODE_PTR
1330 && rtype
->code () == TYPE_CODE_PTR
)
1331 /* A ptrdiff_t for the target would be preferable here. */
1332 res_val
= value_from_longest (builtin_type_pyint
,
1333 value_ptrdiff (arg1
, arg2
));
1334 else if (ltype
->code () == TYPE_CODE_PTR
1335 && is_integral_type (rtype
))
1336 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1363 op
= BINOP_BITWISE_AND
;
1366 op
= BINOP_BITWISE_IOR
;
1369 op
= BINOP_BITWISE_XOR
;
1375 if (binop_user_defined_p (op
, arg1
, arg2
))
1376 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1378 res_val
= value_binop (arg1
, arg2
, op
);
1382 result
= value_to_value_object (res_val
);
1387 /* Returns a value object which is the result of applying the operation
1388 specified by OPCODE to the given arguments. Returns NULL on error, with
1389 a python exception set. */
1391 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1393 PyObject
*result
= NULL
;
1397 result
= valpy_binop_throw (opcode
, self
, other
);
1399 catch (const gdb_exception
&except
)
1401 GDB_PY_HANDLE_EXCEPTION (except
);
1408 valpy_add (PyObject
*self
, PyObject
*other
)
1410 return valpy_binop (VALPY_ADD
, self
, other
);
1414 valpy_subtract (PyObject
*self
, PyObject
*other
)
1416 return valpy_binop (VALPY_SUB
, self
, other
);
1420 valpy_multiply (PyObject
*self
, PyObject
*other
)
1422 return valpy_binop (VALPY_MUL
, self
, other
);
1426 valpy_divide (PyObject
*self
, PyObject
*other
)
1428 return valpy_binop (VALPY_DIV
, self
, other
);
1432 valpy_remainder (PyObject
*self
, PyObject
*other
)
1434 return valpy_binop (VALPY_REM
, self
, other
);
1438 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1440 /* We don't support the ternary form of pow. I don't know how to express
1441 that, so let's just throw NotImplementedError to at least do something
1443 if (unused
!= Py_None
)
1445 PyErr_SetString (PyExc_NotImplementedError
,
1446 "Invalid operation on gdb.Value.");
1450 return valpy_binop (VALPY_POW
, self
, other
);
1454 valpy_negative (PyObject
*self
)
1456 PyObject
*result
= NULL
;
1460 /* Perhaps overkill, but consistency has some virtue. */
1461 scoped_value_mark free_values
;
1464 val
= value_neg (((value_object
*) self
)->value
);
1465 result
= value_to_value_object (val
);
1467 catch (const gdb_exception
&except
)
1469 GDB_PY_HANDLE_EXCEPTION (except
);
1476 valpy_positive (PyObject
*self
)
1478 return value_to_value_object (((value_object
*) self
)->value
);
1482 valpy_absolute (PyObject
*self
)
1484 struct value
*value
= ((value_object
*) self
)->value
;
1489 scoped_value_mark free_values
;
1491 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1494 catch (const gdb_exception
&except
)
1496 GDB_PY_HANDLE_EXCEPTION (except
);
1500 return valpy_positive (self
);
1502 return valpy_negative (self
);
1505 /* Implements boolean evaluation of gdb.Value. */
1507 valpy_nonzero (PyObject
*self
)
1509 struct gdb_exception except
;
1510 value_object
*self_value
= (value_object
*) self
;
1512 int nonzero
= 0; /* Appease GCC warning. */
1516 type
= check_typedef (value_type (self_value
->value
));
1518 if (is_integral_type (type
) || type
->code () == TYPE_CODE_PTR
)
1519 nonzero
= !!value_as_long (self_value
->value
);
1520 else if (is_floating_value (self_value
->value
))
1521 nonzero
= !target_float_is_zero
1522 (value_contents (self_value
->value
).data (), type
);
1524 /* All other values are True. */
1527 catch (gdb_exception
&ex
)
1529 except
= std::move (ex
);
1532 /* This is not documented in the Python documentation, but if this
1533 function fails, return -1 as slot_nb_nonzero does (the default
1534 Python nonzero function). */
1535 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1540 /* Implements ~ for value objects. */
1542 valpy_invert (PyObject
*self
)
1544 struct value
*val
= NULL
;
1548 val
= value_complement (((value_object
*) self
)->value
);
1550 catch (const gdb_exception
&except
)
1552 GDB_PY_HANDLE_EXCEPTION (except
);
1555 return value_to_value_object (val
);
1558 /* Implements left shift for value objects. */
1560 valpy_lsh (PyObject
*self
, PyObject
*other
)
1562 return valpy_binop (VALPY_LSH
, self
, other
);
1565 /* Implements right shift for value objects. */
1567 valpy_rsh (PyObject
*self
, PyObject
*other
)
1569 return valpy_binop (VALPY_RSH
, self
, other
);
1572 /* Implements bitwise and for value objects. */
1574 valpy_and (PyObject
*self
, PyObject
*other
)
1576 return valpy_binop (VALPY_BITAND
, self
, other
);
1579 /* Implements bitwise or for value objects. */
1581 valpy_or (PyObject
*self
, PyObject
*other
)
1583 return valpy_binop (VALPY_BITOR
, self
, other
);
1586 /* Implements bitwise xor for value objects. */
1588 valpy_xor (PyObject
*self
, PyObject
*other
)
1590 return valpy_binop (VALPY_BITXOR
, self
, other
);
1593 /* Helper for valpy_richcompare. Implements comparison operations for
1594 value objects. Returns true/false on success. Returns -1 with a
1595 Python exception set if a Python error is detected. Throws a GDB
1596 exception on other errors (memory error, etc.). */
1599 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1602 struct value
*value_other
;
1603 struct value
*value_self
;
1605 scoped_value_mark free_values
;
1607 value_other
= convert_value_from_python (other
);
1608 if (value_other
== NULL
)
1611 value_self
= ((value_object
*) self
)->value
;
1616 result
= value_less (value_self
, value_other
);
1619 result
= value_less (value_self
, value_other
)
1620 || value_equal (value_self
, value_other
);
1623 result
= value_equal (value_self
, value_other
);
1626 result
= !value_equal (value_self
, value_other
);
1629 result
= value_less (value_other
, value_self
);
1632 result
= (value_less (value_other
, value_self
)
1633 || value_equal (value_self
, value_other
));
1637 PyErr_SetString (PyExc_NotImplementedError
,
1638 _("Invalid operation on gdb.Value."));
1647 /* Implements comparison operations for value objects. Returns NULL on error,
1648 with a python exception set. */
1650 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1654 if (other
== Py_None
)
1655 /* Comparing with None is special. From what I can tell, in Python
1656 None is smaller than anything else. */
1668 PyErr_SetString (PyExc_NotImplementedError
,
1669 _("Invalid operation on gdb.Value."));
1675 result
= valpy_richcompare_throw (self
, other
, op
);
1677 catch (const gdb_exception
&except
)
1679 GDB_PY_HANDLE_EXCEPTION (except
);
1682 /* In this case, the Python exception has already been set. */
1693 /* Implements conversion to int. */
1695 valpy_int (PyObject
*self
)
1697 struct value
*value
= ((value_object
*) self
)->value
;
1698 struct type
*type
= value_type (value
);
1703 if (is_floating_value (value
))
1705 type
= builtin_type_pylong
;
1706 value
= value_cast (type
, value
);
1709 if (!is_integral_type (type
)
1710 && type
->code () != TYPE_CODE_PTR
)
1711 error (_("Cannot convert value to int."));
1713 l
= value_as_long (value
);
1715 catch (const gdb_exception
&except
)
1717 GDB_PY_HANDLE_EXCEPTION (except
);
1720 if (type
->is_unsigned ())
1721 return gdb_py_object_from_ulongest (l
).release ();
1723 return gdb_py_object_from_longest (l
).release ();
1727 /* Implements conversion to long. */
1729 valpy_long (PyObject
*self
)
1731 struct value
*value
= ((value_object
*) self
)->value
;
1732 struct type
*type
= value_type (value
);
1737 if (is_floating_value (value
))
1739 type
= builtin_type_pylong
;
1740 value
= value_cast (type
, value
);
1743 type
= check_typedef (type
);
1745 if (!is_integral_type (type
)
1746 && type
->code () != TYPE_CODE_PTR
)
1747 error (_("Cannot convert value to long."));
1749 l
= value_as_long (value
);
1751 catch (const gdb_exception
&except
)
1753 GDB_PY_HANDLE_EXCEPTION (except
);
1756 if (type
->is_unsigned ())
1757 return gdb_py_object_from_ulongest (l
).release ();
1759 return gdb_py_object_from_longest (l
).release ();
1762 /* Implements conversion to float. */
1764 valpy_float (PyObject
*self
)
1766 struct value
*value
= ((value_object
*) self
)->value
;
1767 struct type
*type
= value_type (value
);
1772 type
= check_typedef (type
);
1774 if (type
->code () == TYPE_CODE_FLT
&& is_floating_value (value
))
1775 d
= target_float_to_host_double (value_contents (value
).data (), type
);
1776 else if (type
->code () == TYPE_CODE_INT
)
1778 /* Note that valpy_long accepts TYPE_CODE_PTR and some
1779 others here here -- but casting a pointer or bool to a
1780 float seems wrong. */
1781 d
= value_as_long (value
);
1784 error (_("Cannot convert value to float."));
1786 catch (const gdb_exception
&except
)
1788 GDB_PY_HANDLE_EXCEPTION (except
);
1791 return PyFloat_FromDouble (d
);
1794 /* Returns an object for a value which is released from the all_values chain,
1795 so its lifetime is not bound to the execution of a command. */
1797 value_to_value_object (struct value
*val
)
1799 value_object
*val_obj
;
1801 val_obj
= PyObject_New (value_object
, &value_object_type
);
1802 if (val_obj
!= NULL
)
1804 val_obj
->value
= release_value (val
).release ();
1805 val_obj
->next
= nullptr;
1806 val_obj
->prev
= nullptr;
1807 val_obj
->address
= NULL
;
1808 val_obj
->type
= NULL
;
1809 val_obj
->dynamic_type
= NULL
;
1810 note_value (val_obj
);
1813 return (PyObject
*) val_obj
;
1816 /* Returns an object for a value, but without releasing it from the
1817 all_values chain. */
1819 value_to_value_object_no_release (struct value
*val
)
1821 value_object
*val_obj
;
1823 val_obj
= PyObject_New (value_object
, &value_object_type
);
1824 if (val_obj
!= NULL
)
1827 val_obj
->value
= val
;
1828 val_obj
->next
= nullptr;
1829 val_obj
->prev
= nullptr;
1830 val_obj
->address
= NULL
;
1831 val_obj
->type
= NULL
;
1832 val_obj
->dynamic_type
= NULL
;
1833 note_value (val_obj
);
1836 return (PyObject
*) val_obj
;
1839 /* Returns a borrowed reference to the struct value corresponding to
1840 the given value object. */
1842 value_object_to_value (PyObject
*self
)
1846 if (! PyObject_TypeCheck (self
, &value_object_type
))
1848 real
= (value_object
*) self
;
1852 /* Try to convert a Python value to a gdb value. If the value cannot
1853 be converted, set a Python exception and return NULL. Returns a
1854 reference to a new value on the all_values chain. */
1857 convert_value_from_python (PyObject
*obj
)
1859 struct value
*value
= NULL
; /* -Wall */
1862 gdb_assert (obj
!= NULL
);
1866 if (PyBool_Check (obj
))
1868 cmp
= PyObject_IsTrue (obj
);
1870 value
= value_from_longest (builtin_type_pybool
, cmp
);
1872 /* Make a long logic check first. In Python 3.x, internally,
1873 all integers are represented as longs. In Python 2.x, there
1874 is still a differentiation internally between a PyInt and a
1875 PyLong. Explicitly do this long check conversion first. In
1876 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1877 to be done first to ensure we do not lose information in the
1878 conversion process. */
1879 else if (PyLong_Check (obj
))
1881 LONGEST l
= PyLong_AsLongLong (obj
);
1883 if (PyErr_Occurred ())
1885 /* If the error was an overflow, we can try converting to
1886 ULONGEST instead. */
1887 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1889 gdbpy_err_fetch fetched_error
;
1890 gdbpy_ref
<> zero
= gdb_py_object_from_longest (0);
1892 /* Check whether obj is positive. */
1893 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1897 ul
= PyLong_AsUnsignedLongLong (obj
);
1898 if (! PyErr_Occurred ())
1899 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1903 /* There's nothing we can do. */
1904 fetched_error
.restore ();
1909 value
= value_from_longest (builtin_type_pylong
, l
);
1911 #if PY_MAJOR_VERSION == 2
1912 else if (PyInt_Check (obj
))
1914 long l
= PyInt_AsLong (obj
);
1916 if (! PyErr_Occurred ())
1917 value
= value_from_longest (builtin_type_pyint
, l
);
1920 else if (PyFloat_Check (obj
))
1922 double d
= PyFloat_AsDouble (obj
);
1924 if (! PyErr_Occurred ())
1925 value
= value_from_host_double (builtin_type_pyfloat
, d
);
1927 else if (gdbpy_is_string (obj
))
1929 gdb::unique_xmalloc_ptr
<char> s
1930 = python_string_to_target_string (obj
);
1932 value
= value_cstring (s
.get (), strlen (s
.get ()),
1933 builtin_type_pychar
);
1935 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1936 value
= value_copy (((value_object
*) obj
)->value
);
1937 else if (gdbpy_is_lazy_string (obj
))
1941 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1942 value
= value_copy (((value_object
*) result
)->value
);
1946 PyErr_Format (PyExc_TypeError
,
1947 _("Could not convert Python object: %S."), obj
);
1949 PyErr_Format (PyExc_TypeError
,
1950 _("Could not convert Python object: %s."),
1951 PyString_AsString (PyObject_Str (obj
)));
1954 catch (const gdb_exception
&except
)
1956 gdbpy_convert_exception (except
);
1963 /* Returns value object in the ARGth position in GDB's history. */
1965 gdbpy_history (PyObject
*self
, PyObject
*args
)
1968 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1970 if (!PyArg_ParseTuple (args
, "i", &i
))
1975 res_val
= access_value_history (i
);
1977 catch (const gdb_exception
&except
)
1979 GDB_PY_HANDLE_EXCEPTION (except
);
1982 return value_to_value_object (res_val
);
1985 /* Add a gdb.Value into GDB's history, and return (as an integer) the
1986 position of the newly added value. */
1988 gdbpy_add_history (PyObject
*self
, PyObject
*args
)
1990 PyObject
*value_obj
;
1992 if (!PyArg_ParseTuple (args
, "O", &value_obj
))
1995 struct value
*value
= convert_value_from_python (value_obj
);
1996 if (value
== nullptr)
2001 int idx
= record_latest_value (value
);
2002 return gdb_py_object_from_longest (idx
).release ();
2004 catch (const gdb_exception
&except
)
2006 GDB_PY_HANDLE_EXCEPTION (except
);
2012 /* Return the value of a convenience variable. */
2014 gdbpy_convenience_variable (PyObject
*self
, PyObject
*args
)
2016 const char *varname
;
2017 struct value
*res_val
= NULL
;
2019 if (!PyArg_ParseTuple (args
, "s", &varname
))
2024 struct internalvar
*var
= lookup_only_internalvar (varname
);
2028 res_val
= value_of_internalvar (python_gdbarch
, var
);
2029 if (value_type (res_val
)->code () == TYPE_CODE_VOID
)
2033 catch (const gdb_exception
&except
)
2035 GDB_PY_HANDLE_EXCEPTION (except
);
2038 if (res_val
== NULL
)
2041 return value_to_value_object (res_val
);
2044 /* Set the value of a convenience variable. */
2046 gdbpy_set_convenience_variable (PyObject
*self
, PyObject
*args
)
2048 const char *varname
;
2049 PyObject
*value_obj
;
2050 struct value
*value
= NULL
;
2052 if (!PyArg_ParseTuple (args
, "sO", &varname
, &value_obj
))
2055 /* None means to clear the variable. */
2056 if (value_obj
!= Py_None
)
2058 value
= convert_value_from_python (value_obj
);
2067 struct internalvar
*var
= lookup_only_internalvar (varname
);
2070 clear_internalvar (var
);
2074 struct internalvar
*var
= lookup_internalvar (varname
);
2076 set_internalvar (var
, value
);
2079 catch (const gdb_exception
&except
)
2081 GDB_PY_HANDLE_EXCEPTION (except
);
2087 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
2090 gdbpy_is_value_object (PyObject
*obj
)
2092 return PyObject_TypeCheck (obj
, &value_object_type
);
2096 gdbpy_initialize_values (void)
2098 if (PyType_Ready (&value_object_type
) < 0)
2101 return gdb_pymodule_addobject (gdb_module
, "Value",
2102 (PyObject
*) &value_object_type
);
2107 static gdb_PyGetSetDef value_object_getset
[] = {
2108 { "address", valpy_get_address
, NULL
, "The address of the value.",
2110 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
2111 "Boolean telling whether the value is optimized "
2112 "out (i.e., not available).",
2114 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
2115 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
2116 "Dynamic type of the value.", NULL
},
2117 { "is_lazy", valpy_get_is_lazy
, NULL
,
2118 "Boolean telling whether the value is lazy (not fetched yet\n\
2119 from the inferior). A lazy value is fetched when needed, or when\n\
2120 the \"fetch_lazy()\" method is called.", NULL
},
2121 {NULL
} /* Sentinel */
2124 static PyMethodDef value_object_methods
[] = {
2125 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
2126 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
2127 "dynamic_cast (gdb.Type) -> gdb.Value\n\
2128 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
2130 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
2131 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
2132 Cast the value to the supplied type, as if by the C++\n\
2133 reinterpret_cast operator."
2135 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
2136 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
2137 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
2138 { "reference_value", valpy_lvalue_reference_value
, METH_NOARGS
,
2139 "Return a value of type TYPE_CODE_REF referencing this value." },
2140 { "rvalue_reference_value", valpy_rvalue_reference_value
, METH_NOARGS
,
2141 "Return a value of type TYPE_CODE_RVALUE_REF referencing this value." },
2142 { "const_value", valpy_const_value
, METH_NOARGS
,
2143 "Return a 'const' qualied version of the same value." },
2144 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
2145 METH_VARARGS
| METH_KEYWORDS
,
2146 "lazy_string ([encoding] [, length]) -> lazy_string\n\
2147 Return a lazy string representation of the value." },
2148 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
2149 "string ([encoding] [, errors] [, length]) -> string\n\
2150 Return Unicode string representation of the value." },
2151 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
2152 "Fetches the value from the inferior, if it was lazy." },
2153 { "format_string", (PyCFunction
) valpy_format_string
,
2154 METH_VARARGS
| METH_KEYWORDS
,
2155 "format_string (...) -> string\n\
2156 Return a string representation of the value using the specified\n\
2157 formatting options" },
2158 {NULL
} /* Sentinel */
2161 static PyNumberMethods value_object_as_number
= {
2169 NULL
, /* nb_divmod */
2170 valpy_power
, /* nb_power */
2171 valpy_negative
, /* nb_negative */
2172 valpy_positive
, /* nb_positive */
2173 valpy_absolute
, /* nb_absolute */
2174 valpy_nonzero
, /* nb_nonzero */
2175 valpy_invert
, /* nb_invert */
2176 valpy_lsh
, /* nb_lshift */
2177 valpy_rsh
, /* nb_rshift */
2178 valpy_and
, /* nb_and */
2179 valpy_xor
, /* nb_xor */
2180 valpy_or
, /* nb_or */
2182 valpy_long
, /* nb_int */
2183 NULL
, /* reserved */
2185 NULL
, /* nb_coerce */
2186 valpy_int
, /* nb_int */
2187 valpy_long
, /* nb_long */
2189 valpy_float
, /* nb_float */
2194 NULL
, /* nb_inplace_add */
2195 NULL
, /* nb_inplace_subtract */
2196 NULL
, /* nb_inplace_multiply */
2198 NULL
, /* nb_inplace_divide */
2200 NULL
, /* nb_inplace_remainder */
2201 NULL
, /* nb_inplace_power */
2202 NULL
, /* nb_inplace_lshift */
2203 NULL
, /* nb_inplace_rshift */
2204 NULL
, /* nb_inplace_and */
2205 NULL
, /* nb_inplace_xor */
2206 NULL
, /* nb_inplace_or */
2207 NULL
, /* nb_floor_divide */
2208 valpy_divide
, /* nb_true_divide */
2209 NULL
, /* nb_inplace_floor_divide */
2210 NULL
, /* nb_inplace_true_divide */
2211 valpy_long
, /* nb_index */
2214 static PyMappingMethods value_object_as_mapping
= {
2220 PyTypeObject value_object_type
= {
2221 PyVarObject_HEAD_INIT (NULL
, 0)
2222 "gdb.Value", /*tp_name*/
2223 sizeof (value_object
), /*tp_basicsize*/
2225 valpy_dealloc
, /*tp_dealloc*/
2231 &value_object_as_number
, /*tp_as_number*/
2232 0, /*tp_as_sequence*/
2233 &value_object_as_mapping
, /*tp_as_mapping*/
2234 valpy_hash
, /*tp_hash*/
2235 valpy_call
, /*tp_call*/
2236 valpy_str
, /*tp_str*/
2240 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
2241 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
2242 "GDB value object", /* tp_doc */
2243 0, /* tp_traverse */
2245 valpy_richcompare
, /* tp_richcompare */
2246 0, /* tp_weaklistoffset */
2248 0, /* tp_iternext */
2249 value_object_methods
, /* tp_methods */
2251 value_object_getset
, /* tp_getset */
2254 0, /* tp_descr_get */
2255 0, /* tp_descr_set */
2256 0, /* tp_dictoffset */
2257 valpy_init
, /* tp_init */
2259 PyType_GenericNew
, /* tp_new */