1 /* Python interface to values.
3 Copyright (C) 2008, 2009 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 /* List of all values which are currently exposed to Python. It is
30 maintained so that when an objfile is discarded, preserve_values
31 can copy the values' types if needed. This is declared
32 unconditionally to reduce the number of uses of HAVE_PYTHON in the
34 /* This variable is unnecessarily initialized to NULL in order to
35 work around a linker bug on MacOS. */
36 struct value
*values_in_python
= NULL
;
40 #include "python-internal.h"
42 /* Even though Python scalar types directly map to host types, we use
43 target types here to remain consistent with the the values system in
44 GDB (which uses target arithmetic). */
46 /* Python's integer type corresponds to C's long type. */
47 #define builtin_type_pyint builtin_type (current_gdbarch)->builtin_long
49 /* Python's float type corresponds to C's double type. */
50 #define builtin_type_pyfloat builtin_type (current_gdbarch)->builtin_double
52 /* Python's long type corresponds to C's long long type. */
53 #define builtin_type_pylong builtin_type (current_gdbarch)->builtin_long_long
55 #define builtin_type_pybool \
56 language_bool_type (current_language, current_gdbarch)
64 /* Called by the Python interpreter when deallocating a value object. */
66 valpy_dealloc (PyObject
*obj
)
68 value_object
*self
= (value_object
*) obj
;
70 value_remove_from_list (&values_in_python
, self
->value
);
72 if (!self
->owned_by_gdb
)
73 value_free (self
->value
);
74 self
->ob_type
->tp_free (self
);
77 /* Called when a new gdb.Value object needs to be allocated. */
79 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
81 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
82 value_object
*value_obj
;
84 if (PyTuple_Size (args
) != 1)
86 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
91 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
92 if (value_obj
== NULL
)
94 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
95 "create Value object."));
99 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
102 subtype
->tp_free (value_obj
);
106 value_obj
->value
= value
;
107 value_obj
->owned_by_gdb
= 0;
108 release_value (value
);
109 value_prepend_to_list (&values_in_python
, value
);
111 return (PyObject
*) value_obj
;
114 /* Given a value of a pointer type, apply the C unary * operator to it. */
116 valpy_dereference (PyObject
*self
, PyObject
*args
)
118 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
119 volatile struct gdb_exception except
;
121 TRY_CATCH (except
, RETURN_MASK_ALL
)
123 res_val
= value_ind (((value_object
*) self
)->value
);
125 GDB_PY_HANDLE_EXCEPTION (except
);
127 return value_to_value_object (res_val
);
130 /* Return "&value". */
132 valpy_address (PyObject
*self
, PyObject
*args
)
134 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
135 volatile struct gdb_exception except
;
137 TRY_CATCH (except
, RETURN_MASK_ALL
)
139 res_val
= value_addr (((value_object
*) self
)->value
);
141 GDB_PY_HANDLE_EXCEPTION (except
);
143 return value_to_value_object (res_val
);
146 /* Return Unicode string with value contents (assumed to be encoded in the
147 target's charset). */
149 valpy_string (PyObject
*self
, PyObject
*args
)
153 struct value
*value
= ((value_object
*) self
)->value
;
154 volatile struct gdb_exception except
;
156 const char *encoding
= NULL
;
157 const char *errors
= NULL
;
158 const char *user_encoding
= NULL
;
159 const char *la_encoding
= NULL
;
161 if (!PyArg_ParseTuple (args
, "|ss", &user_encoding
, &errors
))
164 TRY_CATCH (except
, RETURN_MASK_ALL
)
166 LA_GET_STRING (value
, &buffer
, &length
, &la_encoding
);
168 GDB_PY_HANDLE_EXCEPTION (except
);
170 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
171 unicode
= PyUnicode_Decode (buffer
, length
, encoding
, errors
);
178 valpy_length (PyObject
*self
)
180 /* We don't support getting the number of elements in a struct / class. */
181 PyErr_SetString (PyExc_NotImplementedError
,
182 "Invalid operation on gdb.Value.");
186 /* Given string name of an element inside structure, return its value
189 valpy_getitem (PyObject
*self
, PyObject
*key
)
191 value_object
*self_value
= (value_object
*) self
;
193 struct value
*idx
= NULL
;
194 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
195 volatile struct gdb_exception except
;
197 if (gdbpy_is_string (key
))
199 field
= python_string_to_host_string (key
);
204 TRY_CATCH (except
, RETURN_MASK_ALL
)
206 struct value
*tmp
= self_value
->value
;
209 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
212 /* Assume we are attempting an array access, and let the
213 value code throw an exception if the index has an invalid
215 struct value
*idx
= convert_value_from_python (key
);
219 res_val
= value_subscript (tmp
, idx
);
224 GDB_PY_HANDLE_EXCEPTION (except
);
226 return value_to_value_object (res_val
);
230 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
232 PyErr_Format (PyExc_NotImplementedError
,
233 _("Setting of struct elements is not currently supported."));
237 /* Called by the Python interpreter to obtain string representation
240 valpy_str (PyObject
*self
)
245 struct cleanup
*old_chain
;
247 struct value_print_options opts
;
248 volatile struct gdb_exception except
;
250 get_user_print_options (&opts
);
253 stb
= mem_fileopen ();
254 old_chain
= make_cleanup_ui_file_delete (stb
);
256 TRY_CATCH (except
, RETURN_MASK_ALL
)
258 common_val_print (((value_object
*) self
)->value
, stb
, 0,
259 &opts
, current_language
);
260 s
= ui_file_xstrdup (stb
, &dummy
);
262 GDB_PY_HANDLE_EXCEPTION (except
);
264 do_cleanups (old_chain
);
266 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
287 /* If TYPE is a reference, return the target; otherwise return TYPE. */
288 #define STRIP_REFERENCE(TYPE) \
289 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
291 /* Returns a value object which is the result of applying the operation
292 specified by OPCODE to the given arguments. */
294 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
296 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
297 volatile struct gdb_exception except
;
299 TRY_CATCH (except
, RETURN_MASK_ALL
)
301 struct value
*arg1
, *arg2
;
303 /* If the gdb.Value object is the second operand, then it will be passed
304 to us as the OTHER argument, and SELF will be an entirely different
305 kind of object, altogether. Because of this, we can't assume self is
306 a gdb.Value object and need to convert it from python as well. */
307 arg1
= convert_value_from_python (self
);
311 arg2
= convert_value_from_python (other
);
319 struct type
*ltype
= value_type (arg1
);
320 struct type
*rtype
= value_type (arg2
);
322 CHECK_TYPEDEF (ltype
);
323 ltype
= STRIP_REFERENCE (ltype
);
324 CHECK_TYPEDEF (rtype
);
325 rtype
= STRIP_REFERENCE (rtype
);
327 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
)
328 res_val
= value_ptradd (arg1
, arg2
);
329 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
330 res_val
= value_ptradd (arg2
, arg1
);
332 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
337 struct type
*ltype
= value_type (arg1
);
338 struct type
*rtype
= value_type (arg2
);
340 CHECK_TYPEDEF (ltype
);
341 ltype
= STRIP_REFERENCE (ltype
);
342 CHECK_TYPEDEF (rtype
);
343 rtype
= STRIP_REFERENCE (rtype
);
345 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
)
347 if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
348 /* A ptrdiff_t for the target would be preferable
350 res_val
= value_from_longest (builtin_type_pyint
,
351 value_ptrdiff (arg1
, arg2
));
353 res_val
= value_ptrsub (arg1
, arg2
);
356 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
360 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
363 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
366 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
369 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
372 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
375 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
378 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
381 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
384 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
388 GDB_PY_HANDLE_EXCEPTION (except
);
390 return value_to_value_object (res_val
);
394 valpy_add (PyObject
*self
, PyObject
*other
)
396 return valpy_binop (VALPY_ADD
, self
, other
);
400 valpy_subtract (PyObject
*self
, PyObject
*other
)
402 return valpy_binop (VALPY_SUB
, self
, other
);
406 valpy_multiply (PyObject
*self
, PyObject
*other
)
408 return valpy_binop (VALPY_MUL
, self
, other
);
412 valpy_divide (PyObject
*self
, PyObject
*other
)
414 return valpy_binop (VALPY_DIV
, self
, other
);
418 valpy_remainder (PyObject
*self
, PyObject
*other
)
420 return valpy_binop (VALPY_REM
, self
, other
);
424 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
426 /* We don't support the ternary form of pow. I don't know how to express
427 that, so let's just throw NotImplementedError to at least do something
429 if (unused
!= Py_None
)
431 PyErr_SetString (PyExc_NotImplementedError
,
432 "Invalid operation on gdb.Value.");
436 return valpy_binop (VALPY_POW
, self
, other
);
440 valpy_negative (PyObject
*self
)
442 struct value
*val
= NULL
;
443 volatile struct gdb_exception except
;
445 TRY_CATCH (except
, RETURN_MASK_ALL
)
447 val
= value_neg (((value_object
*) self
)->value
);
449 GDB_PY_HANDLE_EXCEPTION (except
);
451 return value_to_value_object (val
);
455 valpy_positive (PyObject
*self
)
457 struct value
*copy
= value_copy (((value_object
*) self
)->value
);
459 return value_to_value_object (copy
);
463 valpy_absolute (PyObject
*self
)
465 if (value_less (((value_object
*) self
)->value
,
466 value_from_longest (builtin_type_int8
, 0)))
467 return valpy_negative (self
);
469 return valpy_positive (self
);
472 /* Implements boolean evaluation of gdb.Value. */
474 valpy_nonzero (PyObject
*self
)
476 value_object
*self_value
= (value_object
*) self
;
479 type
= check_typedef (value_type (self_value
->value
));
481 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
482 return !!value_as_long (self_value
->value
);
483 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
484 return value_as_double (self_value
->value
) != 0;
485 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
486 return !decimal_is_zero (value_contents (self_value
->value
),
490 PyErr_SetString (PyExc_TypeError
, _("Attempted truth testing on invalid "
496 /* Implements ~ for value objects. */
498 valpy_invert (PyObject
*self
)
500 struct value
*val
= NULL
;
501 volatile struct gdb_exception except
;
503 TRY_CATCH (except
, RETURN_MASK_ALL
)
505 val
= value_complement (((value_object
*) self
)->value
);
507 GDB_PY_HANDLE_EXCEPTION (except
);
509 return value_to_value_object (val
);
512 /* Implements left shift for value objects. */
514 valpy_lsh (PyObject
*self
, PyObject
*other
)
516 return valpy_binop (VALPY_LSH
, self
, other
);
519 /* Implements right shift for value objects. */
521 valpy_rsh (PyObject
*self
, PyObject
*other
)
523 return valpy_binop (VALPY_RSH
, self
, other
);
526 /* Implements bitwise and for value objects. */
528 valpy_and (PyObject
*self
, PyObject
*other
)
530 return valpy_binop (VALPY_BITAND
, self
, other
);
533 /* Implements bitwise or for value objects. */
535 valpy_or (PyObject
*self
, PyObject
*other
)
537 return valpy_binop (VALPY_BITOR
, self
, other
);
540 /* Implements bitwise xor for value objects. */
542 valpy_xor (PyObject
*self
, PyObject
*other
)
544 return valpy_binop (VALPY_BITXOR
, self
, other
);
547 /* Implements comparison operations for value objects. */
549 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
552 struct value
*value_other
;
553 volatile struct gdb_exception except
;
555 if (other
== Py_None
)
556 /* Comparing with None is special. From what I can tell, in Python
557 None is smaller than anything else. */
569 PyErr_SetString (PyExc_NotImplementedError
,
570 "Invalid operation on gdb.Value.");
574 TRY_CATCH (except
, RETURN_MASK_ALL
)
576 value_other
= convert_value_from_python (other
);
577 if (value_other
== NULL
)
582 result
= value_less (((value_object
*) self
)->value
, value_other
);
585 result
= value_less (((value_object
*) self
)->value
, value_other
)
586 || value_equal (((value_object
*) self
)->value
, value_other
);
589 result
= value_equal (((value_object
*) self
)->value
, value_other
);
592 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
595 result
= value_less (value_other
, ((value_object
*) self
)->value
);
598 result
= value_less (value_other
, ((value_object
*) self
)->value
)
599 || value_equal (((value_object
*) self
)->value
, value_other
);
603 PyErr_SetString (PyExc_NotImplementedError
,
604 "Invalid operation on gdb.Value.");
608 GDB_PY_HANDLE_EXCEPTION (except
);
616 /* Helper function to determine if a type is "int-like". */
618 is_intlike (struct type
*type
, int ptr_ok
)
620 CHECK_TYPEDEF (type
);
621 return (TYPE_CODE (type
) == TYPE_CODE_INT
622 || TYPE_CODE (type
) == TYPE_CODE_ENUM
623 || TYPE_CODE (type
) == TYPE_CODE_BOOL
624 || TYPE_CODE (type
) == TYPE_CODE_CHAR
625 || (ptr_ok
&& TYPE_CODE (type
) == TYPE_CODE_PTR
));
628 /* Implements conversion to int. */
630 valpy_int (PyObject
*self
)
632 struct value
*value
= ((value_object
*) self
)->value
;
633 struct type
*type
= value_type (value
);
635 volatile struct gdb_exception except
;
637 CHECK_TYPEDEF (type
);
638 if (!is_intlike (type
, 0))
640 PyErr_SetString (PyExc_RuntimeError
, "cannot convert value to int");
644 TRY_CATCH (except
, RETURN_MASK_ALL
)
646 l
= value_as_long (value
);
648 GDB_PY_HANDLE_EXCEPTION (except
);
650 return PyInt_FromLong (l
);
653 /* Implements conversion to long. */
655 valpy_long (PyObject
*self
)
657 struct value
*value
= ((value_object
*) self
)->value
;
658 struct type
*type
= value_type (value
);
660 volatile struct gdb_exception except
;
662 if (!is_intlike (type
, 1))
664 PyErr_SetString (PyExc_RuntimeError
, "cannot convert value to long");
668 TRY_CATCH (except
, RETURN_MASK_ALL
)
670 l
= value_as_long (value
);
672 GDB_PY_HANDLE_EXCEPTION (except
);
674 return PyLong_FromLong (l
);
677 /* Implements conversion to float. */
679 valpy_float (PyObject
*self
)
681 struct value
*value
= ((value_object
*) self
)->value
;
682 struct type
*type
= value_type (value
);
684 volatile struct gdb_exception except
;
686 CHECK_TYPEDEF (type
);
687 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
689 PyErr_SetString (PyExc_RuntimeError
, "cannot convert value to float");
693 TRY_CATCH (except
, RETURN_MASK_ALL
)
695 d
= value_as_double (value
);
697 GDB_PY_HANDLE_EXCEPTION (except
);
699 return PyFloat_FromDouble (d
);
702 /* Returns an object for a value which is released from the all_values chain,
703 so its lifetime is not bound to the execution of a command. */
705 value_to_value_object (struct value
*val
)
707 value_object
*val_obj
;
709 val_obj
= PyObject_New (value_object
, &value_object_type
);
712 val_obj
->value
= val
;
713 val_obj
->owned_by_gdb
= 0;
715 value_prepend_to_list (&values_in_python
, val
);
718 return (PyObject
*) val_obj
;
721 /* Try to convert a Python value to a gdb value. If the value cannot
722 be converted, set a Python exception and return NULL. */
725 convert_value_from_python (PyObject
*obj
)
727 struct value
*value
= NULL
; /* -Wall */
728 PyObject
*target_str
, *unicode_str
;
730 volatile struct gdb_exception except
;
733 gdb_assert (obj
!= NULL
);
735 TRY_CATCH (except
, RETURN_MASK_ALL
)
737 if (PyBool_Check (obj
))
739 cmp
= PyObject_IsTrue (obj
);
741 value
= value_from_longest (builtin_type_pybool
, cmp
);
743 else if (PyInt_Check (obj
))
745 long l
= PyInt_AsLong (obj
);
747 if (! PyErr_Occurred ())
748 value
= value_from_longest (builtin_type_pyint
, l
);
750 else if (PyLong_Check (obj
))
752 LONGEST l
= PyLong_AsLongLong (obj
);
754 if (! PyErr_Occurred ())
755 value
= value_from_longest (builtin_type_pylong
, l
);
757 else if (PyFloat_Check (obj
))
759 double d
= PyFloat_AsDouble (obj
);
761 if (! PyErr_Occurred ())
762 value
= value_from_double (builtin_type_pyfloat
, d
);
764 else if (gdbpy_is_string (obj
))
768 s
= python_string_to_target_string (obj
);
771 old
= make_cleanup (xfree
, s
);
772 value
= value_from_string (s
);
776 else if (PyObject_TypeCheck (obj
, &value_object_type
))
777 value
= ((value_object
*) obj
)->value
;
779 PyErr_Format (PyExc_TypeError
, _("Could not convert Python object: %s"),
780 PyString_AsString (PyObject_Str (obj
)));
782 if (except
.reason
< 0)
784 PyErr_Format (except
.reason
== RETURN_QUIT
785 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
786 "%s", except
.message
);
793 /* Returns value object in the ARGth position in GDB's history. */
795 gdbpy_history (PyObject
*self
, PyObject
*args
)
798 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
799 volatile struct gdb_exception except
;
801 if (!PyArg_ParseTuple (args
, "i", &i
))
804 TRY_CATCH (except
, RETURN_MASK_ALL
)
806 res_val
= access_value_history (i
);
808 GDB_PY_HANDLE_EXCEPTION (except
);
810 return value_to_value_object (res_val
);
814 gdbpy_initialize_values (void)
816 if (PyType_Ready (&value_object_type
) < 0)
819 Py_INCREF (&value_object_type
);
820 PyModule_AddObject (gdb_module
, "Value", (PyObject
*) &value_object_type
);
822 values_in_python
= NULL
;
825 static PyMethodDef value_object_methods
[] = {
826 { "address", valpy_address
, METH_NOARGS
, "Return the address of the value." },
827 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
828 { "string", valpy_string
, METH_VARARGS
,
829 "Return Unicode string representation of the value." },
830 {NULL
} /* Sentinel */
833 static PyNumberMethods value_object_as_number
= {
839 NULL
, /* nb_divmod */
840 valpy_power
, /* nb_power */
841 valpy_negative
, /* nb_negative */
842 valpy_positive
, /* nb_positive */
843 valpy_absolute
, /* nb_absolute */
844 valpy_nonzero
, /* nb_nonzero */
845 valpy_invert
, /* nb_invert */
846 valpy_lsh
, /* nb_lshift */
847 valpy_rsh
, /* nb_rshift */
848 valpy_and
, /* nb_and */
849 valpy_xor
, /* nb_xor */
850 valpy_or
, /* nb_or */
851 NULL
, /* nb_coerce */
852 valpy_int
, /* nb_int */
853 valpy_long
, /* nb_long */
854 valpy_float
, /* nb_float */
859 static PyMappingMethods value_object_as_mapping
= {
865 PyTypeObject value_object_type
= {
866 PyObject_HEAD_INIT (NULL
)
868 "gdb.Value", /*tp_name*/
869 sizeof (value_object
), /*tp_basicsize*/
871 valpy_dealloc
, /*tp_dealloc*/
877 &value_object_as_number
, /*tp_as_number*/
878 0, /*tp_as_sequence*/
879 &value_object_as_mapping
, /*tp_as_mapping*/
882 valpy_str
, /*tp_str*/
886 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
, /*tp_flags*/
887 "GDB value object", /* tp_doc */
890 valpy_richcompare
, /* tp_richcompare */
891 0, /* tp_weaklistoffset */
894 value_object_methods
, /* tp_methods */
899 0, /* tp_descr_get */
900 0, /* tp_descr_set */
901 0, /* tp_dictoffset */
904 valpy_new
/* tp_new */
907 #endif /* HAVE_PYTHON */