1 /* Python interface to values.
3 Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_assert.h"
24 #include "exceptions.h"
29 #include "expression.h"
34 #include "python-internal.h"
36 /* Even though Python scalar types directly map to host types, we use
37 target types here to remain consistent with the values system in
38 GDB (which uses target arithmetic). */
40 /* Python's integer type corresponds to C's long type. */
41 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
43 /* Python's float type corresponds to C's double type. */
44 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
46 /* Python's long type corresponds to C's long long type. */
47 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
49 /* Python's long type corresponds to C's long long type. Unsigned version. */
50 #define builtin_type_upylong builtin_type \
51 (python_gdbarch)->builtin_unsigned_long_long
53 #define builtin_type_pybool \
54 language_bool_type (python_language, python_gdbarch)
56 #define builtin_type_pychar \
57 language_string_char_type (python_language, python_gdbarch)
59 typedef struct value_object
{
61 struct value_object
*next
;
62 struct value_object
*prev
;
66 PyObject
*dynamic_type
;
69 /* List of all values which are currently exposed to Python. It is
70 maintained so that when an objfile is discarded, preserve_values
71 can copy the values' types if needed. */
72 /* This variable is unnecessarily initialized to NULL in order to
73 work around a linker bug on MacOS. */
74 static value_object
*values_in_python
= NULL
;
76 /* Called by the Python interpreter when deallocating a value object. */
78 valpy_dealloc (PyObject
*obj
)
80 value_object
*self
= (value_object
*) obj
;
82 /* Remove SELF from the global list. */
84 self
->prev
->next
= self
->next
;
87 gdb_assert (values_in_python
== self
);
88 values_in_python
= self
->next
;
91 self
->next
->prev
= self
->prev
;
93 value_free (self
->value
);
96 /* Use braces to appease gcc warning. *sigh* */
98 Py_DECREF (self
->address
);
103 Py_DECREF (self
->type
);
106 Py_XDECREF (self
->dynamic_type
);
108 self
->ob_type
->tp_free (self
);
111 /* Helper to push a Value object on the global list. */
113 note_value (value_object
*value_obj
)
115 value_obj
->next
= values_in_python
;
117 value_obj
->next
->prev
= value_obj
;
118 value_obj
->prev
= NULL
;
119 values_in_python
= value_obj
;
122 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
123 error, with a python exception set. */
125 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
127 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
128 value_object
*value_obj
;
130 if (PyTuple_Size (args
) != 1)
132 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
137 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
138 if (value_obj
== NULL
)
140 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
141 "create Value object."));
145 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
148 subtype
->tp_free (value_obj
);
152 value_obj
->value
= value
;
153 value_incref (value
);
154 value_obj
->address
= NULL
;
155 value_obj
->type
= NULL
;
156 value_obj
->dynamic_type
= NULL
;
157 note_value (value_obj
);
159 return (PyObject
*) value_obj
;
162 /* Iterate over all the Value objects, calling preserve_one_value on
165 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
169 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
170 preserve_one_value (iter
->value
, objfile
, copied_types
);
173 /* Given a value of a pointer type, apply the C unary * operator to it. */
175 valpy_dereference (PyObject
*self
, PyObject
*args
)
177 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
178 volatile struct gdb_exception except
;
180 TRY_CATCH (except
, RETURN_MASK_ALL
)
182 res_val
= value_ind (((value_object
*) self
)->value
);
184 GDB_PY_HANDLE_EXCEPTION (except
);
186 return value_to_value_object (res_val
);
189 /* Return "&value". */
191 valpy_get_address (PyObject
*self
, void *closure
)
193 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
194 value_object
*val_obj
= (value_object
*) self
;
195 volatile struct gdb_exception except
;
197 if (!val_obj
->address
)
199 TRY_CATCH (except
, RETURN_MASK_ALL
)
201 res_val
= value_addr (val_obj
->value
);
203 if (except
.reason
< 0)
205 val_obj
->address
= Py_None
;
209 val_obj
->address
= value_to_value_object (res_val
);
212 Py_INCREF (val_obj
->address
);
214 return val_obj
->address
;
217 /* Return type of the value. */
219 valpy_get_type (PyObject
*self
, void *closure
)
221 value_object
*obj
= (value_object
*) self
;
225 obj
->type
= type_to_type_object (value_type (obj
->value
));
229 Py_INCREF (obj
->type
);
233 /* Return dynamic type of the value. */
236 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
238 value_object
*obj
= (value_object
*) self
;
239 volatile struct gdb_exception except
;
240 struct type
*type
= NULL
;
242 if (obj
->dynamic_type
!= NULL
)
244 Py_INCREF (obj
->dynamic_type
);
245 return obj
->dynamic_type
;
248 TRY_CATCH (except
, RETURN_MASK_ALL
)
250 struct value
*val
= obj
->value
;
252 type
= value_type (val
);
253 CHECK_TYPEDEF (type
);
255 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
)
256 || (TYPE_CODE (type
) == TYPE_CODE_REF
))
257 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
259 struct value
*target
;
260 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
262 target
= value_ind (val
);
263 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
268 type
= lookup_pointer_type (type
);
270 type
= lookup_reference_type (type
);
273 else if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
274 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
277 /* Re-use object's static type. */
281 GDB_PY_HANDLE_EXCEPTION (except
);
285 /* Ensure that the TYPE field is ready. */
286 if (!valpy_get_type (self
, NULL
))
288 /* We don't need to incref here, because valpy_get_type already
290 obj
->dynamic_type
= obj
->type
;
293 obj
->dynamic_type
= type_to_type_object (type
);
295 Py_INCREF (obj
->dynamic_type
);
296 return obj
->dynamic_type
;
299 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
300 string. Return a PyObject representing a lazy_string_object type.
301 A lazy string is a pointer to a string with an optional encoding and
302 length. If ENCODING is not given, encoding is set to None. If an
303 ENCODING is provided the encoding parameter is set to ENCODING, but
304 the string is not encoded. If LENGTH is provided then the length
305 parameter is set to LENGTH, otherwise length will be set to -1 (first
306 null of appropriate with). */
308 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
310 gdb_py_longest length
= -1;
311 struct value
*value
= ((value_object
*) self
)->value
;
312 const char *user_encoding
= NULL
;
313 static char *keywords
[] = { "encoding", "length", NULL
};
316 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
317 &user_encoding
, &length
))
320 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
321 value
= value_ind (value
);
323 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
327 return (PyObject
*) str_obj
;
330 /* Implementation of gdb.Value.string ([encoding] [, errors]
331 [, length]) -> string. Return Unicode string with value contents.
332 If ENCODING is not given, the string is assumed to be encoded in
333 the target's charset. If LENGTH is provided, only fetch string to
334 the length provided. */
337 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
341 struct value
*value
= ((value_object
*) self
)->value
;
342 volatile struct gdb_exception except
;
344 const char *encoding
= NULL
;
345 const char *errors
= NULL
;
346 const char *user_encoding
= NULL
;
347 const char *la_encoding
= NULL
;
348 struct type
*char_type
;
349 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
351 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
352 &user_encoding
, &errors
, &length
))
355 TRY_CATCH (except
, RETURN_MASK_ALL
)
357 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
359 GDB_PY_HANDLE_EXCEPTION (except
);
361 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
362 unicode
= PyUnicode_Decode (buffer
, length
* TYPE_LENGTH (char_type
),
369 /* A helper function that implements the various cast operators. */
372 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
376 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
377 volatile struct gdb_exception except
;
379 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
382 type
= type_object_to_type (type_obj
);
385 PyErr_SetString (PyExc_RuntimeError
,
386 _("Argument must be a type."));
390 TRY_CATCH (except
, RETURN_MASK_ALL
)
392 struct value
*val
= ((value_object
*) self
)->value
;
394 if (op
== UNOP_DYNAMIC_CAST
)
395 res_val
= value_dynamic_cast (type
, val
);
396 else if (op
== UNOP_REINTERPRET_CAST
)
397 res_val
= value_reinterpret_cast (type
, val
);
400 gdb_assert (op
== UNOP_CAST
);
401 res_val
= value_cast (type
, val
);
404 GDB_PY_HANDLE_EXCEPTION (except
);
406 return value_to_value_object (res_val
);
409 /* Implementation of the "cast" method. */
412 valpy_cast (PyObject
*self
, PyObject
*args
)
414 return valpy_do_cast (self
, args
, UNOP_CAST
);
417 /* Implementation of the "dynamic_cast" method. */
420 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
422 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
425 /* Implementation of the "reinterpret_cast" method. */
428 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
430 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
434 valpy_length (PyObject
*self
)
436 /* We don't support getting the number of elements in a struct / class. */
437 PyErr_SetString (PyExc_NotImplementedError
,
438 _("Invalid operation on gdb.Value."));
442 /* Given string name of an element inside structure, return its value
443 object. Returns NULL on error, with a python exception set. */
445 valpy_getitem (PyObject
*self
, PyObject
*key
)
447 value_object
*self_value
= (value_object
*) self
;
449 struct value
*res_val
= NULL
;
450 volatile struct gdb_exception except
;
452 if (gdbpy_is_string (key
))
454 field
= python_string_to_host_string (key
);
459 TRY_CATCH (except
, RETURN_MASK_ALL
)
461 struct value
*tmp
= self_value
->value
;
464 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
467 /* Assume we are attempting an array access, and let the
468 value code throw an exception if the index has an invalid
470 struct value
*idx
= convert_value_from_python (key
);
474 /* Check the value's type is something that can be accessed via
478 tmp
= coerce_ref (tmp
);
479 type
= check_typedef (value_type (tmp
));
480 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
481 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
482 error (_("Cannot subscript requested type."));
484 res_val
= value_subscript (tmp
, value_as_long (idx
));
490 GDB_PY_HANDLE_EXCEPTION (except
);
492 return res_val
? value_to_value_object (res_val
) : NULL
;
496 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
498 PyErr_Format (PyExc_NotImplementedError
,
499 _("Setting of struct elements is not currently supported."));
503 /* Called by the Python interpreter to perform an inferior function
504 call on the value. Returns NULL on error, with a python exception set. */
506 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
508 struct value
*return_value
= NULL
;
509 Py_ssize_t args_count
;
510 volatile struct gdb_exception except
;
511 struct value
*function
= ((value_object
*) self
)->value
;
512 struct value
**vargs
= NULL
;
513 struct type
*ftype
= check_typedef (value_type (function
));
515 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
517 PyErr_SetString (PyExc_RuntimeError
,
518 _("Value is not callable (not TYPE_CODE_FUNC)."));
522 args_count
= PyTuple_Size (args
);
527 vargs
= alloca (sizeof (struct value
*) * args_count
);
528 for (i
= 0; i
< args_count
; i
++)
530 PyObject
*item
= PyTuple_GetItem (args
, i
);
535 vargs
[i
] = convert_value_from_python (item
);
536 if (vargs
[i
] == NULL
)
541 TRY_CATCH (except
, RETURN_MASK_ALL
)
543 return_value
= call_function_by_hand (function
, args_count
, vargs
);
545 GDB_PY_HANDLE_EXCEPTION (except
);
547 return value_to_value_object (return_value
);
550 /* Called by the Python interpreter to obtain string representation
553 valpy_str (PyObject
*self
)
557 struct value_print_options opts
;
558 volatile struct gdb_exception except
;
560 get_user_print_options (&opts
);
563 TRY_CATCH (except
, RETURN_MASK_ALL
)
565 struct ui_file
*stb
= mem_fileopen ();
566 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
568 common_val_print (((value_object
*) self
)->value
, stb
, 0,
569 &opts
, python_language
);
570 s
= ui_file_xstrdup (stb
, NULL
);
572 do_cleanups (old_chain
);
574 GDB_PY_HANDLE_EXCEPTION (except
);
576 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
582 /* Implements gdb.Value.is_optimized_out. */
584 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
586 struct value
*value
= ((value_object
*) self
)->value
;
588 if (value_optimized_out (value
))
594 /* Calculate and return the address of the PyObject as the value of
595 the builtin __hash__ call. */
597 valpy_hash (PyObject
*self
)
599 return (long) (intptr_t) self
;
617 /* If TYPE is a reference, return the target; otherwise return TYPE. */
618 #define STRIP_REFERENCE(TYPE) \
619 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
621 /* Returns a value object which is the result of applying the operation
622 specified by OPCODE to the given arguments. Returns NULL on error, with
623 a python exception set. */
625 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
627 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
628 volatile struct gdb_exception except
;
630 TRY_CATCH (except
, RETURN_MASK_ALL
)
632 struct value
*arg1
, *arg2
;
634 /* If the gdb.Value object is the second operand, then it will be passed
635 to us as the OTHER argument, and SELF will be an entirely different
636 kind of object, altogether. Because of this, we can't assume self is
637 a gdb.Value object and need to convert it from python as well. */
638 arg1
= convert_value_from_python (self
);
642 arg2
= convert_value_from_python (other
);
650 struct type
*ltype
= value_type (arg1
);
651 struct type
*rtype
= value_type (arg2
);
653 CHECK_TYPEDEF (ltype
);
654 ltype
= STRIP_REFERENCE (ltype
);
655 CHECK_TYPEDEF (rtype
);
656 rtype
= STRIP_REFERENCE (rtype
);
658 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
659 && is_integral_type (rtype
))
660 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
661 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
662 && is_integral_type (ltype
))
663 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
665 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
670 struct type
*ltype
= value_type (arg1
);
671 struct type
*rtype
= value_type (arg2
);
673 CHECK_TYPEDEF (ltype
);
674 ltype
= STRIP_REFERENCE (ltype
);
675 CHECK_TYPEDEF (rtype
);
676 rtype
= STRIP_REFERENCE (rtype
);
678 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
679 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
680 /* A ptrdiff_t for the target would be preferable here. */
681 res_val
= value_from_longest (builtin_type_pyint
,
682 value_ptrdiff (arg1
, arg2
));
683 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
684 && is_integral_type (rtype
))
685 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
687 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
691 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
694 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
697 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
700 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
703 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
706 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
709 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
712 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
715 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
719 GDB_PY_HANDLE_EXCEPTION (except
);
721 return res_val
? value_to_value_object (res_val
) : NULL
;
725 valpy_add (PyObject
*self
, PyObject
*other
)
727 return valpy_binop (VALPY_ADD
, self
, other
);
731 valpy_subtract (PyObject
*self
, PyObject
*other
)
733 return valpy_binop (VALPY_SUB
, self
, other
);
737 valpy_multiply (PyObject
*self
, PyObject
*other
)
739 return valpy_binop (VALPY_MUL
, self
, other
);
743 valpy_divide (PyObject
*self
, PyObject
*other
)
745 return valpy_binop (VALPY_DIV
, self
, other
);
749 valpy_remainder (PyObject
*self
, PyObject
*other
)
751 return valpy_binop (VALPY_REM
, self
, other
);
755 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
757 /* We don't support the ternary form of pow. I don't know how to express
758 that, so let's just throw NotImplementedError to at least do something
760 if (unused
!= Py_None
)
762 PyErr_SetString (PyExc_NotImplementedError
,
763 "Invalid operation on gdb.Value.");
767 return valpy_binop (VALPY_POW
, self
, other
);
771 valpy_negative (PyObject
*self
)
773 struct value
*val
= NULL
;
774 volatile struct gdb_exception except
;
776 TRY_CATCH (except
, RETURN_MASK_ALL
)
778 val
= value_neg (((value_object
*) self
)->value
);
780 GDB_PY_HANDLE_EXCEPTION (except
);
782 return value_to_value_object (val
);
786 valpy_positive (PyObject
*self
)
788 return value_to_value_object (((value_object
*) self
)->value
);
792 valpy_absolute (PyObject
*self
)
794 struct value
*value
= ((value_object
*) self
)->value
;
796 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
797 return valpy_negative (self
);
799 return valpy_positive (self
);
802 /* Implements boolean evaluation of gdb.Value. */
804 valpy_nonzero (PyObject
*self
)
806 value_object
*self_value
= (value_object
*) self
;
809 type
= check_typedef (value_type (self_value
->value
));
811 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
812 return !!value_as_long (self_value
->value
);
813 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
814 return value_as_double (self_value
->value
) != 0;
815 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
816 return !decimal_is_zero (value_contents (self_value
->value
),
818 gdbarch_byte_order (get_type_arch (type
)));
820 /* All other values are True. */
824 /* Implements ~ for value objects. */
826 valpy_invert (PyObject
*self
)
828 struct value
*val
= NULL
;
829 volatile struct gdb_exception except
;
831 TRY_CATCH (except
, RETURN_MASK_ALL
)
833 val
= value_complement (((value_object
*) self
)->value
);
835 GDB_PY_HANDLE_EXCEPTION (except
);
837 return value_to_value_object (val
);
840 /* Implements left shift for value objects. */
842 valpy_lsh (PyObject
*self
, PyObject
*other
)
844 return valpy_binop (VALPY_LSH
, self
, other
);
847 /* Implements right shift for value objects. */
849 valpy_rsh (PyObject
*self
, PyObject
*other
)
851 return valpy_binop (VALPY_RSH
, self
, other
);
854 /* Implements bitwise and for value objects. */
856 valpy_and (PyObject
*self
, PyObject
*other
)
858 return valpy_binop (VALPY_BITAND
, self
, other
);
861 /* Implements bitwise or for value objects. */
863 valpy_or (PyObject
*self
, PyObject
*other
)
865 return valpy_binop (VALPY_BITOR
, self
, other
);
868 /* Implements bitwise xor for value objects. */
870 valpy_xor (PyObject
*self
, PyObject
*other
)
872 return valpy_binop (VALPY_BITXOR
, self
, other
);
875 /* Implements comparison operations for value objects. Returns NULL on error,
876 with a python exception set. */
878 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
881 struct value
*value_other
;
882 volatile struct gdb_exception except
;
884 if (other
== Py_None
)
885 /* Comparing with None is special. From what I can tell, in Python
886 None is smaller than anything else. */
898 PyErr_SetString (PyExc_NotImplementedError
,
899 _("Invalid operation on gdb.Value."));
903 TRY_CATCH (except
, RETURN_MASK_ALL
)
905 value_other
= convert_value_from_python (other
);
906 if (value_other
== NULL
)
914 result
= value_less (((value_object
*) self
)->value
, value_other
);
917 result
= value_less (((value_object
*) self
)->value
, value_other
)
918 || value_equal (((value_object
*) self
)->value
, value_other
);
921 result
= value_equal (((value_object
*) self
)->value
, value_other
);
924 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
927 result
= value_less (value_other
, ((value_object
*) self
)->value
);
930 result
= value_less (value_other
, ((value_object
*) self
)->value
)
931 || value_equal (((value_object
*) self
)->value
, value_other
);
935 PyErr_SetString (PyExc_NotImplementedError
,
936 _("Invalid operation on gdb.Value."));
941 GDB_PY_HANDLE_EXCEPTION (except
);
943 /* In this case, the Python exception has already been set. */
953 /* Helper function to determine if a type is "int-like". */
955 is_intlike (struct type
*type
, int ptr_ok
)
957 CHECK_TYPEDEF (type
);
958 return (TYPE_CODE (type
) == TYPE_CODE_INT
959 || TYPE_CODE (type
) == TYPE_CODE_ENUM
960 || TYPE_CODE (type
) == TYPE_CODE_BOOL
961 || TYPE_CODE (type
) == TYPE_CODE_CHAR
962 || (ptr_ok
&& TYPE_CODE (type
) == TYPE_CODE_PTR
));
965 /* Implements conversion to int. */
967 valpy_int (PyObject
*self
)
969 struct value
*value
= ((value_object
*) self
)->value
;
970 struct type
*type
= value_type (value
);
972 volatile struct gdb_exception except
;
974 CHECK_TYPEDEF (type
);
975 if (!is_intlike (type
, 0))
977 PyErr_SetString (PyExc_RuntimeError
,
978 _("Cannot convert value to int."));
982 TRY_CATCH (except
, RETURN_MASK_ALL
)
984 l
= value_as_long (value
);
986 GDB_PY_HANDLE_EXCEPTION (except
);
988 return gdb_py_object_from_longest (l
);
991 /* Implements conversion to long. */
993 valpy_long (PyObject
*self
)
995 struct value
*value
= ((value_object
*) self
)->value
;
996 struct type
*type
= value_type (value
);
998 volatile struct gdb_exception except
;
1000 if (!is_intlike (type
, 1))
1002 PyErr_SetString (PyExc_RuntimeError
,
1003 _("Cannot convert value to long."));
1007 TRY_CATCH (except
, RETURN_MASK_ALL
)
1009 l
= value_as_long (value
);
1011 GDB_PY_HANDLE_EXCEPTION (except
);
1013 return gdb_py_long_from_longest (l
);
1016 /* Implements conversion to float. */
1018 valpy_float (PyObject
*self
)
1020 struct value
*value
= ((value_object
*) self
)->value
;
1021 struct type
*type
= value_type (value
);
1023 volatile struct gdb_exception except
;
1025 CHECK_TYPEDEF (type
);
1026 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1028 PyErr_SetString (PyExc_RuntimeError
,
1029 _("Cannot convert value to float."));
1033 TRY_CATCH (except
, RETURN_MASK_ALL
)
1035 d
= value_as_double (value
);
1037 GDB_PY_HANDLE_EXCEPTION (except
);
1039 return PyFloat_FromDouble (d
);
1042 /* Returns an object for a value which is released from the all_values chain,
1043 so its lifetime is not bound to the execution of a command. */
1045 value_to_value_object (struct value
*val
)
1047 value_object
*val_obj
;
1049 val_obj
= PyObject_New (value_object
, &value_object_type
);
1050 if (val_obj
!= NULL
)
1052 val_obj
->value
= val
;
1054 val_obj
->address
= NULL
;
1055 val_obj
->type
= NULL
;
1056 val_obj
->dynamic_type
= NULL
;
1057 note_value (val_obj
);
1060 return (PyObject
*) val_obj
;
1063 /* Returns a borrowed reference to the struct value corresponding to
1064 the given value object. */
1066 value_object_to_value (PyObject
*self
)
1070 if (! PyObject_TypeCheck (self
, &value_object_type
))
1072 real
= (value_object
*) self
;
1076 /* Try to convert a Python value to a gdb value. If the value cannot
1077 be converted, set a Python exception and return NULL. Returns a
1078 reference to a new value on the all_values chain. */
1081 convert_value_from_python (PyObject
*obj
)
1083 struct value
*value
= NULL
; /* -Wall */
1084 struct cleanup
*old
;
1085 volatile struct gdb_exception except
;
1088 gdb_assert (obj
!= NULL
);
1090 TRY_CATCH (except
, RETURN_MASK_ALL
)
1092 if (PyBool_Check (obj
))
1094 cmp
= PyObject_IsTrue (obj
);
1096 value
= value_from_longest (builtin_type_pybool
, cmp
);
1098 else if (PyInt_Check (obj
))
1100 long l
= PyInt_AsLong (obj
);
1102 if (! PyErr_Occurred ())
1103 value
= value_from_longest (builtin_type_pyint
, l
);
1105 else if (PyLong_Check (obj
))
1107 LONGEST l
= PyLong_AsLongLong (obj
);
1109 if (PyErr_Occurred ())
1111 /* If the error was an overflow, we can try converting to
1112 ULONGEST instead. */
1113 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1115 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1117 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1118 zero
= PyInt_FromLong (0);
1120 /* Check whether obj is positive. */
1121 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1125 ul
= PyLong_AsUnsignedLongLong (obj
);
1126 if (! PyErr_Occurred ())
1127 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1130 /* There's nothing we can do. */
1131 PyErr_Restore (etype
, evalue
, etraceback
);
1137 value
= value_from_longest (builtin_type_pylong
, l
);
1139 else if (PyFloat_Check (obj
))
1141 double d
= PyFloat_AsDouble (obj
);
1143 if (! PyErr_Occurred ())
1144 value
= value_from_double (builtin_type_pyfloat
, d
);
1146 else if (gdbpy_is_string (obj
))
1150 s
= python_string_to_target_string (obj
);
1153 old
= make_cleanup (xfree
, s
);
1154 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1158 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1159 value
= value_copy (((value_object
*) obj
)->value
);
1160 else if (gdbpy_is_lazy_string (obj
))
1164 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1165 value
= value_copy (((value_object
*) result
)->value
);
1168 PyErr_Format (PyExc_TypeError
,
1169 _("Could not convert Python object: %s."),
1170 PyString_AsString (PyObject_Str (obj
)));
1172 if (except
.reason
< 0)
1174 PyErr_Format (except
.reason
== RETURN_QUIT
1175 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1176 "%s", except
.message
);
1183 /* Returns value object in the ARGth position in GDB's history. */
1185 gdbpy_history (PyObject
*self
, PyObject
*args
)
1188 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1189 volatile struct gdb_exception except
;
1191 if (!PyArg_ParseTuple (args
, "i", &i
))
1194 TRY_CATCH (except
, RETURN_MASK_ALL
)
1196 res_val
= access_value_history (i
);
1198 GDB_PY_HANDLE_EXCEPTION (except
);
1200 return value_to_value_object (res_val
);
1203 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1206 gdbpy_is_value_object (PyObject
*obj
)
1208 return PyObject_TypeCheck (obj
, &value_object_type
);
1212 gdbpy_initialize_values (void)
1214 if (PyType_Ready (&value_object_type
) < 0)
1217 Py_INCREF (&value_object_type
);
1218 PyModule_AddObject (gdb_module
, "Value", (PyObject
*) &value_object_type
);
1220 values_in_python
= NULL
;
1225 static PyGetSetDef value_object_getset
[] = {
1226 { "address", valpy_get_address
, NULL
, "The address of the value.",
1228 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1229 "Boolean telling whether the value is optimized "
1230 "out (i.e., not available).",
1232 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1233 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1234 "Dynamic type of the value.", NULL
},
1235 {NULL
} /* Sentinel */
1238 static PyMethodDef value_object_methods
[] = {
1239 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1240 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1241 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1242 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1244 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1245 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1246 Cast the value to the supplied type, as if by the C++\n\
1247 reinterpret_cast operator."
1249 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1250 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1251 METH_VARARGS
| METH_KEYWORDS
,
1252 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1253 Return a lazy string representation of the value." },
1254 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1255 "string ([encoding] [, errors] [, length]) -> string\n\
1256 Return Unicode string representation of the value." },
1257 {NULL
} /* Sentinel */
1260 static PyNumberMethods value_object_as_number
= {
1266 NULL
, /* nb_divmod */
1267 valpy_power
, /* nb_power */
1268 valpy_negative
, /* nb_negative */
1269 valpy_positive
, /* nb_positive */
1270 valpy_absolute
, /* nb_absolute */
1271 valpy_nonzero
, /* nb_nonzero */
1272 valpy_invert
, /* nb_invert */
1273 valpy_lsh
, /* nb_lshift */
1274 valpy_rsh
, /* nb_rshift */
1275 valpy_and
, /* nb_and */
1276 valpy_xor
, /* nb_xor */
1277 valpy_or
, /* nb_or */
1278 NULL
, /* nb_coerce */
1279 valpy_int
, /* nb_int */
1280 valpy_long
, /* nb_long */
1281 valpy_float
, /* nb_float */
1286 static PyMappingMethods value_object_as_mapping
= {
1292 PyTypeObject value_object_type
= {
1293 PyObject_HEAD_INIT (NULL
)
1295 "gdb.Value", /*tp_name*/
1296 sizeof (value_object
), /*tp_basicsize*/
1298 valpy_dealloc
, /*tp_dealloc*/
1304 &value_object_as_number
, /*tp_as_number*/
1305 0, /*tp_as_sequence*/
1306 &value_object_as_mapping
, /*tp_as_mapping*/
1307 valpy_hash
, /*tp_hash*/
1308 valpy_call
, /*tp_call*/
1309 valpy_str
, /*tp_str*/
1313 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1314 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1315 "GDB value object", /* tp_doc */
1316 0, /* tp_traverse */
1318 valpy_richcompare
, /* tp_richcompare */
1319 0, /* tp_weaklistoffset */
1321 0, /* tp_iternext */
1322 value_object_methods
, /* tp_methods */
1324 value_object_getset
, /* tp_getset */
1327 0, /* tp_descr_get */
1328 0, /* tp_descr_set */
1329 0, /* tp_dictoffset */
1332 valpy_new
/* tp_new */
1338 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
1343 #endif /* HAVE_PYTHON */