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 cleanup
*old_chain
;
559 struct value_print_options opts
;
560 volatile struct gdb_exception except
;
562 get_user_print_options (&opts
);
565 stb
= mem_fileopen ();
566 old_chain
= make_cleanup_ui_file_delete (stb
);
568 TRY_CATCH (except
, RETURN_MASK_ALL
)
570 common_val_print (((value_object
*) self
)->value
, stb
, 0,
571 &opts
, python_language
);
572 s
= ui_file_xstrdup (stb
, NULL
);
574 GDB_PY_HANDLE_EXCEPTION (except
);
576 do_cleanups (old_chain
);
578 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
584 /* Implements gdb.Value.is_optimized_out. */
586 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
588 struct value
*value
= ((value_object
*) self
)->value
;
590 if (value_optimized_out (value
))
596 /* Calculate and return the address of the PyObject as the value of
597 the builtin __hash__ call. */
599 valpy_hash (PyObject
*self
)
601 return (long) (intptr_t) self
;
619 /* If TYPE is a reference, return the target; otherwise return TYPE. */
620 #define STRIP_REFERENCE(TYPE) \
621 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
623 /* Returns a value object which is the result of applying the operation
624 specified by OPCODE to the given arguments. Returns NULL on error, with
625 a python exception set. */
627 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
629 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
630 volatile struct gdb_exception except
;
632 TRY_CATCH (except
, RETURN_MASK_ALL
)
634 struct value
*arg1
, *arg2
;
636 /* If the gdb.Value object is the second operand, then it will be passed
637 to us as the OTHER argument, and SELF will be an entirely different
638 kind of object, altogether. Because of this, we can't assume self is
639 a gdb.Value object and need to convert it from python as well. */
640 arg1
= convert_value_from_python (self
);
644 arg2
= convert_value_from_python (other
);
652 struct type
*ltype
= value_type (arg1
);
653 struct type
*rtype
= value_type (arg2
);
655 CHECK_TYPEDEF (ltype
);
656 ltype
= STRIP_REFERENCE (ltype
);
657 CHECK_TYPEDEF (rtype
);
658 rtype
= STRIP_REFERENCE (rtype
);
660 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
661 && is_integral_type (rtype
))
662 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
663 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
664 && is_integral_type (ltype
))
665 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
667 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
672 struct type
*ltype
= value_type (arg1
);
673 struct type
*rtype
= value_type (arg2
);
675 CHECK_TYPEDEF (ltype
);
676 ltype
= STRIP_REFERENCE (ltype
);
677 CHECK_TYPEDEF (rtype
);
678 rtype
= STRIP_REFERENCE (rtype
);
680 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
681 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
682 /* A ptrdiff_t for the target would be preferable here. */
683 res_val
= value_from_longest (builtin_type_pyint
,
684 value_ptrdiff (arg1
, arg2
));
685 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
686 && is_integral_type (rtype
))
687 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
689 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
693 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
696 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
699 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
702 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
705 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
708 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
711 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
714 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
717 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
721 GDB_PY_HANDLE_EXCEPTION (except
);
723 return res_val
? value_to_value_object (res_val
) : NULL
;
727 valpy_add (PyObject
*self
, PyObject
*other
)
729 return valpy_binop (VALPY_ADD
, self
, other
);
733 valpy_subtract (PyObject
*self
, PyObject
*other
)
735 return valpy_binop (VALPY_SUB
, self
, other
);
739 valpy_multiply (PyObject
*self
, PyObject
*other
)
741 return valpy_binop (VALPY_MUL
, self
, other
);
745 valpy_divide (PyObject
*self
, PyObject
*other
)
747 return valpy_binop (VALPY_DIV
, self
, other
);
751 valpy_remainder (PyObject
*self
, PyObject
*other
)
753 return valpy_binop (VALPY_REM
, self
, other
);
757 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
759 /* We don't support the ternary form of pow. I don't know how to express
760 that, so let's just throw NotImplementedError to at least do something
762 if (unused
!= Py_None
)
764 PyErr_SetString (PyExc_NotImplementedError
,
765 "Invalid operation on gdb.Value.");
769 return valpy_binop (VALPY_POW
, self
, other
);
773 valpy_negative (PyObject
*self
)
775 struct value
*val
= NULL
;
776 volatile struct gdb_exception except
;
778 TRY_CATCH (except
, RETURN_MASK_ALL
)
780 val
= value_neg (((value_object
*) self
)->value
);
782 GDB_PY_HANDLE_EXCEPTION (except
);
784 return value_to_value_object (val
);
788 valpy_positive (PyObject
*self
)
790 return value_to_value_object (((value_object
*) self
)->value
);
794 valpy_absolute (PyObject
*self
)
796 struct value
*value
= ((value_object
*) self
)->value
;
798 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
799 return valpy_negative (self
);
801 return valpy_positive (self
);
804 /* Implements boolean evaluation of gdb.Value. */
806 valpy_nonzero (PyObject
*self
)
808 value_object
*self_value
= (value_object
*) self
;
811 type
= check_typedef (value_type (self_value
->value
));
813 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
814 return !!value_as_long (self_value
->value
);
815 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
816 return value_as_double (self_value
->value
) != 0;
817 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
818 return !decimal_is_zero (value_contents (self_value
->value
),
820 gdbarch_byte_order (get_type_arch (type
)));
822 /* All other values are True. */
826 /* Implements ~ for value objects. */
828 valpy_invert (PyObject
*self
)
830 struct value
*val
= NULL
;
831 volatile struct gdb_exception except
;
833 TRY_CATCH (except
, RETURN_MASK_ALL
)
835 val
= value_complement (((value_object
*) self
)->value
);
837 GDB_PY_HANDLE_EXCEPTION (except
);
839 return value_to_value_object (val
);
842 /* Implements left shift for value objects. */
844 valpy_lsh (PyObject
*self
, PyObject
*other
)
846 return valpy_binop (VALPY_LSH
, self
, other
);
849 /* Implements right shift for value objects. */
851 valpy_rsh (PyObject
*self
, PyObject
*other
)
853 return valpy_binop (VALPY_RSH
, self
, other
);
856 /* Implements bitwise and for value objects. */
858 valpy_and (PyObject
*self
, PyObject
*other
)
860 return valpy_binop (VALPY_BITAND
, self
, other
);
863 /* Implements bitwise or for value objects. */
865 valpy_or (PyObject
*self
, PyObject
*other
)
867 return valpy_binop (VALPY_BITOR
, self
, other
);
870 /* Implements bitwise xor for value objects. */
872 valpy_xor (PyObject
*self
, PyObject
*other
)
874 return valpy_binop (VALPY_BITXOR
, self
, other
);
877 /* Implements comparison operations for value objects. Returns NULL on error,
878 with a python exception set. */
880 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
883 struct value
*value_other
;
884 volatile struct gdb_exception except
;
886 if (other
== Py_None
)
887 /* Comparing with None is special. From what I can tell, in Python
888 None is smaller than anything else. */
900 PyErr_SetString (PyExc_NotImplementedError
,
901 _("Invalid operation on gdb.Value."));
905 TRY_CATCH (except
, RETURN_MASK_ALL
)
907 value_other
= convert_value_from_python (other
);
908 if (value_other
== NULL
)
916 result
= value_less (((value_object
*) self
)->value
, value_other
);
919 result
= value_less (((value_object
*) self
)->value
, value_other
)
920 || value_equal (((value_object
*) self
)->value
, value_other
);
923 result
= value_equal (((value_object
*) self
)->value
, value_other
);
926 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
929 result
= value_less (value_other
, ((value_object
*) self
)->value
);
932 result
= value_less (value_other
, ((value_object
*) self
)->value
)
933 || value_equal (((value_object
*) self
)->value
, value_other
);
937 PyErr_SetString (PyExc_NotImplementedError
,
938 _("Invalid operation on gdb.Value."));
943 GDB_PY_HANDLE_EXCEPTION (except
);
945 /* In this case, the Python exception has already been set. */
955 /* Helper function to determine if a type is "int-like". */
957 is_intlike (struct type
*type
, int ptr_ok
)
959 CHECK_TYPEDEF (type
);
960 return (TYPE_CODE (type
) == TYPE_CODE_INT
961 || TYPE_CODE (type
) == TYPE_CODE_ENUM
962 || TYPE_CODE (type
) == TYPE_CODE_BOOL
963 || TYPE_CODE (type
) == TYPE_CODE_CHAR
964 || (ptr_ok
&& TYPE_CODE (type
) == TYPE_CODE_PTR
));
967 /* Implements conversion to int. */
969 valpy_int (PyObject
*self
)
971 struct value
*value
= ((value_object
*) self
)->value
;
972 struct type
*type
= value_type (value
);
974 volatile struct gdb_exception except
;
976 CHECK_TYPEDEF (type
);
977 if (!is_intlike (type
, 0))
979 PyErr_SetString (PyExc_RuntimeError
,
980 _("Cannot convert value to int."));
984 TRY_CATCH (except
, RETURN_MASK_ALL
)
986 l
= value_as_long (value
);
988 GDB_PY_HANDLE_EXCEPTION (except
);
990 return gdb_py_object_from_longest (l
);
993 /* Implements conversion to long. */
995 valpy_long (PyObject
*self
)
997 struct value
*value
= ((value_object
*) self
)->value
;
998 struct type
*type
= value_type (value
);
1000 volatile struct gdb_exception except
;
1002 if (!is_intlike (type
, 1))
1004 PyErr_SetString (PyExc_RuntimeError
,
1005 _("Cannot convert value to long."));
1009 TRY_CATCH (except
, RETURN_MASK_ALL
)
1011 l
= value_as_long (value
);
1013 GDB_PY_HANDLE_EXCEPTION (except
);
1015 return gdb_py_long_from_longest (l
);
1018 /* Implements conversion to float. */
1020 valpy_float (PyObject
*self
)
1022 struct value
*value
= ((value_object
*) self
)->value
;
1023 struct type
*type
= value_type (value
);
1025 volatile struct gdb_exception except
;
1027 CHECK_TYPEDEF (type
);
1028 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1030 PyErr_SetString (PyExc_RuntimeError
,
1031 _("Cannot convert value to float."));
1035 TRY_CATCH (except
, RETURN_MASK_ALL
)
1037 d
= value_as_double (value
);
1039 GDB_PY_HANDLE_EXCEPTION (except
);
1041 return PyFloat_FromDouble (d
);
1044 /* Returns an object for a value which is released from the all_values chain,
1045 so its lifetime is not bound to the execution of a command. */
1047 value_to_value_object (struct value
*val
)
1049 value_object
*val_obj
;
1051 val_obj
= PyObject_New (value_object
, &value_object_type
);
1052 if (val_obj
!= NULL
)
1054 val_obj
->value
= val
;
1056 val_obj
->address
= NULL
;
1057 val_obj
->type
= NULL
;
1058 val_obj
->dynamic_type
= NULL
;
1059 note_value (val_obj
);
1062 return (PyObject
*) val_obj
;
1065 /* Returns a borrowed reference to the struct value corresponding to
1066 the given value object. */
1068 value_object_to_value (PyObject
*self
)
1072 if (! PyObject_TypeCheck (self
, &value_object_type
))
1074 real
= (value_object
*) self
;
1078 /* Try to convert a Python value to a gdb value. If the value cannot
1079 be converted, set a Python exception and return NULL. Returns a
1080 reference to a new value on the all_values chain. */
1083 convert_value_from_python (PyObject
*obj
)
1085 struct value
*value
= NULL
; /* -Wall */
1086 struct cleanup
*old
;
1087 volatile struct gdb_exception except
;
1090 gdb_assert (obj
!= NULL
);
1092 TRY_CATCH (except
, RETURN_MASK_ALL
)
1094 if (PyBool_Check (obj
))
1096 cmp
= PyObject_IsTrue (obj
);
1098 value
= value_from_longest (builtin_type_pybool
, cmp
);
1100 else if (PyInt_Check (obj
))
1102 long l
= PyInt_AsLong (obj
);
1104 if (! PyErr_Occurred ())
1105 value
= value_from_longest (builtin_type_pyint
, l
);
1107 else if (PyLong_Check (obj
))
1109 LONGEST l
= PyLong_AsLongLong (obj
);
1111 if (PyErr_Occurred ())
1113 /* If the error was an overflow, we can try converting to
1114 ULONGEST instead. */
1115 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1117 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1119 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1120 zero
= PyInt_FromLong (0);
1122 /* Check whether obj is positive. */
1123 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1127 ul
= PyLong_AsUnsignedLongLong (obj
);
1128 if (! PyErr_Occurred ())
1129 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1132 /* There's nothing we can do. */
1133 PyErr_Restore (etype
, evalue
, etraceback
);
1139 value
= value_from_longest (builtin_type_pylong
, l
);
1141 else if (PyFloat_Check (obj
))
1143 double d
= PyFloat_AsDouble (obj
);
1145 if (! PyErr_Occurred ())
1146 value
= value_from_double (builtin_type_pyfloat
, d
);
1148 else if (gdbpy_is_string (obj
))
1152 s
= python_string_to_target_string (obj
);
1155 old
= make_cleanup (xfree
, s
);
1156 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1160 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1161 value
= value_copy (((value_object
*) obj
)->value
);
1162 else if (gdbpy_is_lazy_string (obj
))
1165 PyObject
*function
= PyString_FromString ("value");
1167 result
= PyObject_CallMethodObjArgs (obj
, function
, NULL
);
1168 value
= value_copy (((value_object
*) result
)->value
);
1171 PyErr_Format (PyExc_TypeError
,
1172 _("Could not convert Python object: %s."),
1173 PyString_AsString (PyObject_Str (obj
)));
1175 if (except
.reason
< 0)
1177 PyErr_Format (except
.reason
== RETURN_QUIT
1178 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1179 "%s", except
.message
);
1186 /* Returns value object in the ARGth position in GDB's history. */
1188 gdbpy_history (PyObject
*self
, PyObject
*args
)
1191 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1192 volatile struct gdb_exception except
;
1194 if (!PyArg_ParseTuple (args
, "i", &i
))
1197 TRY_CATCH (except
, RETURN_MASK_ALL
)
1199 res_val
= access_value_history (i
);
1201 GDB_PY_HANDLE_EXCEPTION (except
);
1203 return value_to_value_object (res_val
);
1206 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1209 gdbpy_is_value_object (PyObject
*obj
)
1211 return PyObject_TypeCheck (obj
, &value_object_type
);
1215 gdbpy_initialize_values (void)
1217 if (PyType_Ready (&value_object_type
) < 0)
1220 Py_INCREF (&value_object_type
);
1221 PyModule_AddObject (gdb_module
, "Value", (PyObject
*) &value_object_type
);
1223 values_in_python
= NULL
;
1228 static PyGetSetDef value_object_getset
[] = {
1229 { "address", valpy_get_address
, NULL
, "The address of the value.",
1231 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1232 "Boolean telling whether the value is optimized "
1233 "out (i.e., not available).",
1235 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1236 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1237 "Dynamic type of the value.", NULL
},
1238 {NULL
} /* Sentinel */
1241 static PyMethodDef value_object_methods
[] = {
1242 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1243 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1244 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1245 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1247 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1248 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1249 Cast the value to the supplied type, as if by the C++\n\
1250 reinterpret_cast operator."
1252 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1253 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1254 METH_VARARGS
| METH_KEYWORDS
,
1255 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1256 Return a lazy string representation of the value." },
1257 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1258 "string ([encoding] [, errors] [, length]) -> string\n\
1259 Return Unicode string representation of the value." },
1260 {NULL
} /* Sentinel */
1263 static PyNumberMethods value_object_as_number
= {
1269 NULL
, /* nb_divmod */
1270 valpy_power
, /* nb_power */
1271 valpy_negative
, /* nb_negative */
1272 valpy_positive
, /* nb_positive */
1273 valpy_absolute
, /* nb_absolute */
1274 valpy_nonzero
, /* nb_nonzero */
1275 valpy_invert
, /* nb_invert */
1276 valpy_lsh
, /* nb_lshift */
1277 valpy_rsh
, /* nb_rshift */
1278 valpy_and
, /* nb_and */
1279 valpy_xor
, /* nb_xor */
1280 valpy_or
, /* nb_or */
1281 NULL
, /* nb_coerce */
1282 valpy_int
, /* nb_int */
1283 valpy_long
, /* nb_long */
1284 valpy_float
, /* nb_float */
1289 static PyMappingMethods value_object_as_mapping
= {
1295 PyTypeObject value_object_type
= {
1296 PyObject_HEAD_INIT (NULL
)
1298 "gdb.Value", /*tp_name*/
1299 sizeof (value_object
), /*tp_basicsize*/
1301 valpy_dealloc
, /*tp_dealloc*/
1307 &value_object_as_number
, /*tp_as_number*/
1308 0, /*tp_as_sequence*/
1309 &value_object_as_mapping
, /*tp_as_mapping*/
1310 valpy_hash
, /*tp_hash*/
1311 valpy_call
, /*tp_call*/
1312 valpy_str
, /*tp_str*/
1316 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1317 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1318 "GDB value object", /* tp_doc */
1319 0, /* tp_traverse */
1321 valpy_richcompare
, /* tp_richcompare */
1322 0, /* tp_weaklistoffset */
1324 0, /* tp_iternext */
1325 value_object_methods
, /* tp_methods */
1327 value_object_getset
, /* tp_getset */
1330 0, /* tp_descr_get */
1331 0, /* tp_descr_set */
1332 0, /* tp_dictoffset */
1335 valpy_new
/* tp_new */
1341 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
1346 #endif /* HAVE_PYTHON */