1 /* Python interface to values.
3 Copyright (C) 2008, 2009, 2010 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"
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 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 #define builtin_type_pybool \
47 language_bool_type (python_language, python_gdbarch)
49 #define builtin_type_pychar \
50 language_string_char_type (python_language, python_gdbarch)
52 typedef struct value_object
{
54 struct value_object
*next
;
55 struct value_object
*prev
;
61 /* List of all values which are currently exposed to Python. It is
62 maintained so that when an objfile is discarded, preserve_values
63 can copy the values' types if needed. */
64 /* This variable is unnecessarily initialized to NULL in order to
65 work around a linker bug on MacOS. */
66 static value_object
*values_in_python
= NULL
;
68 /* Called by the Python interpreter when deallocating a value object. */
70 valpy_dealloc (PyObject
*obj
)
72 value_object
*self
= (value_object
*) obj
;
74 /* Remove SELF from the global list. */
76 self
->prev
->next
= self
->next
;
79 gdb_assert (values_in_python
== self
);
80 values_in_python
= self
->next
;
83 self
->next
->prev
= self
->prev
;
85 value_free (self
->value
);
88 /* Use braces to appease gcc warning. *sigh* */
90 Py_DECREF (self
->address
);
95 Py_DECREF (self
->type
);
98 self
->ob_type
->tp_free (self
);
101 /* Helper to push a Value object on the global list. */
103 note_value (value_object
*value_obj
)
105 value_obj
->next
= values_in_python
;
107 value_obj
->next
->prev
= value_obj
;
108 value_obj
->prev
= NULL
;
109 values_in_python
= value_obj
;
112 /* Called when a new gdb.Value object needs to be allocated. */
114 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
116 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
117 value_object
*value_obj
;
119 if (PyTuple_Size (args
) != 1)
121 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
126 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
127 if (value_obj
== NULL
)
129 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
130 "create Value object."));
134 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
137 subtype
->tp_free (value_obj
);
141 value_obj
->value
= value
;
142 value_incref (value
);
143 value_obj
->address
= NULL
;
144 value_obj
->type
= NULL
;
145 note_value (value_obj
);
147 return (PyObject
*) value_obj
;
150 /* Iterate over all the Value objects, calling preserve_one_value on
153 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
157 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
158 preserve_one_value (iter
->value
, objfile
, copied_types
);
161 /* Given a value of a pointer type, apply the C unary * operator to it. */
163 valpy_dereference (PyObject
*self
, PyObject
*args
)
165 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
166 volatile struct gdb_exception except
;
168 TRY_CATCH (except
, RETURN_MASK_ALL
)
170 res_val
= value_ind (((value_object
*) self
)->value
);
172 GDB_PY_HANDLE_EXCEPTION (except
);
174 return value_to_value_object (res_val
);
177 /* Return "&value". */
179 valpy_get_address (PyObject
*self
, void *closure
)
181 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
182 value_object
*val_obj
= (value_object
*) self
;
183 volatile struct gdb_exception except
;
185 if (!val_obj
->address
)
187 TRY_CATCH (except
, RETURN_MASK_ALL
)
189 res_val
= value_addr (val_obj
->value
);
191 if (except
.reason
< 0)
193 val_obj
->address
= Py_None
;
197 val_obj
->address
= value_to_value_object (res_val
);
200 Py_INCREF (val_obj
->address
);
202 return val_obj
->address
;
205 /* Return type of the value. */
207 valpy_get_type (PyObject
*self
, void *closure
)
209 value_object
*obj
= (value_object
*) self
;
212 obj
->type
= type_to_type_object (value_type (obj
->value
));
216 Py_INCREF (obj
->type
);
219 Py_INCREF (obj
->type
);
223 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
224 string. Return a PyObject representing a lazy_string_object type.
225 A lazy string is a pointer to a string with an optional encoding and
226 length. If ENCODING is not given, encoding is set to None. If an
227 ENCODING is provided the encoding parameter is set to ENCODING, but
228 the string is not encoded. If LENGTH is provided then the length
229 parameter is set to LENGTH, otherwise length will be set to -1 (first
230 null of appropriate with). */
232 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
235 struct value
*value
= ((value_object
*) self
)->value
;
236 const char *user_encoding
= NULL
;
237 static char *keywords
[] = { "encoding", "length", NULL
};
240 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|si", keywords
,
241 &user_encoding
, &length
))
244 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
245 value
= value_ind (value
);
247 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
248 user_encoding
, value_type (value
));
250 return (PyObject
*) str_obj
;
253 /* Implementation of gdb.Value.string ([encoding] [, errors]
254 [, length]) -> string. Return Unicode string with value contents.
255 If ENCODING is not given, the string is assumed to be encoded in
256 the target's charset. If LENGTH is provided, only fetch string to
257 the length provided. */
260 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
264 struct value
*value
= ((value_object
*) self
)->value
;
265 volatile struct gdb_exception except
;
267 const char *encoding
= NULL
;
268 const char *errors
= NULL
;
269 const char *user_encoding
= NULL
;
270 const char *la_encoding
= NULL
;
271 struct type
*char_type
;
272 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
274 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
275 &user_encoding
, &errors
, &length
))
278 TRY_CATCH (except
, RETURN_MASK_ALL
)
280 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
282 GDB_PY_HANDLE_EXCEPTION (except
);
284 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
285 unicode
= PyUnicode_Decode (buffer
, length
* TYPE_LENGTH (char_type
),
292 /* Cast a value to a given type. */
294 valpy_cast (PyObject
*self
, PyObject
*args
)
298 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
299 volatile struct gdb_exception except
;
301 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
304 type
= type_object_to_type (type_obj
);
307 PyErr_SetString (PyExc_RuntimeError
,
308 _("Argument must be a type."));
312 TRY_CATCH (except
, RETURN_MASK_ALL
)
314 res_val
= value_cast (type
, ((value_object
*) self
)->value
);
316 GDB_PY_HANDLE_EXCEPTION (except
);
318 return value_to_value_object (res_val
);
322 valpy_length (PyObject
*self
)
324 /* We don't support getting the number of elements in a struct / class. */
325 PyErr_SetString (PyExc_NotImplementedError
,
326 _("Invalid operation on gdb.Value."));
330 /* Given string name of an element inside structure, return its value
333 valpy_getitem (PyObject
*self
, PyObject
*key
)
335 value_object
*self_value
= (value_object
*) self
;
337 struct value
*res_val
= NULL
;
338 volatile struct gdb_exception except
;
340 if (gdbpy_is_string (key
))
342 field
= python_string_to_host_string (key
);
347 TRY_CATCH (except
, RETURN_MASK_ALL
)
349 struct value
*tmp
= self_value
->value
;
352 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
355 /* Assume we are attempting an array access, and let the
356 value code throw an exception if the index has an invalid
358 struct value
*idx
= convert_value_from_python (key
);
361 /* Check the value's type is something that can be accessed via
364 tmp
= coerce_ref (tmp
);
365 type
= check_typedef (value_type (tmp
));
366 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
367 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
368 error( _("Cannot subscript requested type."));
370 res_val
= value_subscript (tmp
, value_as_long (idx
));
376 GDB_PY_HANDLE_EXCEPTION (except
);
378 return res_val
? value_to_value_object (res_val
) : NULL
;
382 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
384 PyErr_Format (PyExc_NotImplementedError
,
385 _("Setting of struct elements is not currently supported."));
389 /* Called by the Python interpreter to obtain string representation
392 valpy_str (PyObject
*self
)
396 struct cleanup
*old_chain
;
398 struct value_print_options opts
;
399 volatile struct gdb_exception except
;
401 get_user_print_options (&opts
);
404 stb
= mem_fileopen ();
405 old_chain
= make_cleanup_ui_file_delete (stb
);
407 TRY_CATCH (except
, RETURN_MASK_ALL
)
409 common_val_print (((value_object
*) self
)->value
, stb
, 0,
410 &opts
, python_language
);
411 s
= ui_file_xstrdup (stb
, NULL
);
413 GDB_PY_HANDLE_EXCEPTION (except
);
415 do_cleanups (old_chain
);
417 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
423 /* Implements gdb.Value.is_optimized_out. */
425 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
427 struct value
*value
= ((value_object
*) self
)->value
;
429 if (value_optimized_out (value
))
435 /* Calculate and return the address of the PyObject as the value of
436 the builtin __hash__ call. */
438 valpy_hash (PyObject
*self
)
440 return (long) (intptr_t) self
;
458 /* If TYPE is a reference, return the target; otherwise return TYPE. */
459 #define STRIP_REFERENCE(TYPE) \
460 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
462 /* Returns a value object which is the result of applying the operation
463 specified by OPCODE to the given arguments. */
465 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
467 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
468 volatile struct gdb_exception except
;
470 TRY_CATCH (except
, RETURN_MASK_ALL
)
472 struct value
*arg1
, *arg2
;
474 /* If the gdb.Value object is the second operand, then it will be passed
475 to us as the OTHER argument, and SELF will be an entirely different
476 kind of object, altogether. Because of this, we can't assume self is
477 a gdb.Value object and need to convert it from python as well. */
478 arg1
= convert_value_from_python (self
);
482 arg2
= convert_value_from_python (other
);
490 struct type
*ltype
= value_type (arg1
);
491 struct type
*rtype
= value_type (arg2
);
493 CHECK_TYPEDEF (ltype
);
494 ltype
= STRIP_REFERENCE (ltype
);
495 CHECK_TYPEDEF (rtype
);
496 rtype
= STRIP_REFERENCE (rtype
);
498 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
499 && is_integral_type (rtype
))
500 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
501 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
502 && is_integral_type (ltype
))
503 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
505 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
510 struct type
*ltype
= value_type (arg1
);
511 struct type
*rtype
= value_type (arg2
);
513 CHECK_TYPEDEF (ltype
);
514 ltype
= STRIP_REFERENCE (ltype
);
515 CHECK_TYPEDEF (rtype
);
516 rtype
= STRIP_REFERENCE (rtype
);
518 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
519 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
520 /* A ptrdiff_t for the target would be preferable here. */
521 res_val
= value_from_longest (builtin_type_pyint
,
522 value_ptrdiff (arg1
, arg2
));
523 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
524 && is_integral_type (rtype
))
525 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
527 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
531 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
534 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
537 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
540 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
543 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
546 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
549 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
552 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
555 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
559 GDB_PY_HANDLE_EXCEPTION (except
);
561 return res_val
? value_to_value_object (res_val
) : NULL
;
565 valpy_add (PyObject
*self
, PyObject
*other
)
567 return valpy_binop (VALPY_ADD
, self
, other
);
571 valpy_subtract (PyObject
*self
, PyObject
*other
)
573 return valpy_binop (VALPY_SUB
, self
, other
);
577 valpy_multiply (PyObject
*self
, PyObject
*other
)
579 return valpy_binop (VALPY_MUL
, self
, other
);
583 valpy_divide (PyObject
*self
, PyObject
*other
)
585 return valpy_binop (VALPY_DIV
, self
, other
);
589 valpy_remainder (PyObject
*self
, PyObject
*other
)
591 return valpy_binop (VALPY_REM
, self
, other
);
595 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
597 /* We don't support the ternary form of pow. I don't know how to express
598 that, so let's just throw NotImplementedError to at least do something
600 if (unused
!= Py_None
)
602 PyErr_SetString (PyExc_NotImplementedError
,
603 "Invalid operation on gdb.Value.");
607 return valpy_binop (VALPY_POW
, self
, other
);
611 valpy_negative (PyObject
*self
)
613 struct value
*val
= NULL
;
614 volatile struct gdb_exception except
;
616 TRY_CATCH (except
, RETURN_MASK_ALL
)
618 val
= value_neg (((value_object
*) self
)->value
);
620 GDB_PY_HANDLE_EXCEPTION (except
);
622 return value_to_value_object (val
);
626 valpy_positive (PyObject
*self
)
628 return value_to_value_object (((value_object
*) self
)->value
);
632 valpy_absolute (PyObject
*self
)
634 struct value
*value
= ((value_object
*) self
)->value
;
635 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
636 return valpy_negative (self
);
638 return valpy_positive (self
);
641 /* Implements boolean evaluation of gdb.Value. */
643 valpy_nonzero (PyObject
*self
)
645 value_object
*self_value
= (value_object
*) self
;
648 type
= check_typedef (value_type (self_value
->value
));
650 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
651 return !!value_as_long (self_value
->value
);
652 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
653 return value_as_double (self_value
->value
) != 0;
654 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
655 return !decimal_is_zero (value_contents (self_value
->value
),
657 gdbarch_byte_order (get_type_arch (type
)));
660 PyErr_SetString (PyExc_TypeError
, _("Attempted truth testing on invalid "
666 /* Implements ~ for value objects. */
668 valpy_invert (PyObject
*self
)
670 struct value
*val
= NULL
;
671 volatile struct gdb_exception except
;
673 TRY_CATCH (except
, RETURN_MASK_ALL
)
675 val
= value_complement (((value_object
*) self
)->value
);
677 GDB_PY_HANDLE_EXCEPTION (except
);
679 return value_to_value_object (val
);
682 /* Implements left shift for value objects. */
684 valpy_lsh (PyObject
*self
, PyObject
*other
)
686 return valpy_binop (VALPY_LSH
, self
, other
);
689 /* Implements right shift for value objects. */
691 valpy_rsh (PyObject
*self
, PyObject
*other
)
693 return valpy_binop (VALPY_RSH
, self
, other
);
696 /* Implements bitwise and for value objects. */
698 valpy_and (PyObject
*self
, PyObject
*other
)
700 return valpy_binop (VALPY_BITAND
, self
, other
);
703 /* Implements bitwise or for value objects. */
705 valpy_or (PyObject
*self
, PyObject
*other
)
707 return valpy_binop (VALPY_BITOR
, self
, other
);
710 /* Implements bitwise xor for value objects. */
712 valpy_xor (PyObject
*self
, PyObject
*other
)
714 return valpy_binop (VALPY_BITXOR
, self
, other
);
717 /* Implements comparison operations for value objects. */
719 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
722 struct value
*value_other
;
723 volatile struct gdb_exception except
;
725 if (other
== Py_None
)
726 /* Comparing with None is special. From what I can tell, in Python
727 None is smaller than anything else. */
739 PyErr_SetString (PyExc_NotImplementedError
,
740 _("Invalid operation on gdb.Value."));
744 TRY_CATCH (except
, RETURN_MASK_ALL
)
746 value_other
= convert_value_from_python (other
);
747 if (value_other
== NULL
)
755 result
= value_less (((value_object
*) self
)->value
, value_other
);
758 result
= value_less (((value_object
*) self
)->value
, value_other
)
759 || value_equal (((value_object
*) self
)->value
, value_other
);
762 result
= value_equal (((value_object
*) self
)->value
, value_other
);
765 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
768 result
= value_less (value_other
, ((value_object
*) self
)->value
);
771 result
= value_less (value_other
, ((value_object
*) self
)->value
)
772 || value_equal (((value_object
*) self
)->value
, value_other
);
776 PyErr_SetString (PyExc_NotImplementedError
,
777 _("Invalid operation on gdb.Value."));
782 GDB_PY_HANDLE_EXCEPTION (except
);
784 /* In this case, the Python exception has already been set. */
794 /* Helper function to determine if a type is "int-like". */
796 is_intlike (struct type
*type
, int ptr_ok
)
798 CHECK_TYPEDEF (type
);
799 return (TYPE_CODE (type
) == TYPE_CODE_INT
800 || TYPE_CODE (type
) == TYPE_CODE_ENUM
801 || TYPE_CODE (type
) == TYPE_CODE_BOOL
802 || TYPE_CODE (type
) == TYPE_CODE_CHAR
803 || (ptr_ok
&& TYPE_CODE (type
) == TYPE_CODE_PTR
));
806 /* Implements conversion to int. */
808 valpy_int (PyObject
*self
)
810 struct value
*value
= ((value_object
*) self
)->value
;
811 struct type
*type
= value_type (value
);
813 volatile struct gdb_exception except
;
815 CHECK_TYPEDEF (type
);
816 if (!is_intlike (type
, 0))
818 PyErr_SetString (PyExc_RuntimeError
,
819 _("Cannot convert value to int."));
823 TRY_CATCH (except
, RETURN_MASK_ALL
)
825 l
= value_as_long (value
);
827 GDB_PY_HANDLE_EXCEPTION (except
);
829 #ifdef HAVE_LONG_LONG /* Defined by Python. */
830 /* If we have 'long long', and the value overflows a 'long', use a
831 Python Long; otherwise use a Python Int. */
832 if (sizeof (l
) > sizeof (long) && (l
> PyInt_GetMax ()
833 || l
< (- (LONGEST
) PyInt_GetMax ()) - 1))
834 return PyLong_FromLongLong (l
);
836 return PyInt_FromLong (l
);
839 /* Implements conversion to long. */
841 valpy_long (PyObject
*self
)
843 struct value
*value
= ((value_object
*) self
)->value
;
844 struct type
*type
= value_type (value
);
846 volatile struct gdb_exception except
;
848 if (!is_intlike (type
, 1))
850 PyErr_SetString (PyExc_RuntimeError
,
851 _("Cannot convert value to long."));
855 TRY_CATCH (except
, RETURN_MASK_ALL
)
857 l
= value_as_long (value
);
859 GDB_PY_HANDLE_EXCEPTION (except
);
861 #ifdef HAVE_LONG_LONG /* Defined by Python. */
862 return PyLong_FromLongLong (l
);
864 return PyLong_FromLong (l
);
868 /* Implements conversion to float. */
870 valpy_float (PyObject
*self
)
872 struct value
*value
= ((value_object
*) self
)->value
;
873 struct type
*type
= value_type (value
);
875 volatile struct gdb_exception except
;
877 CHECK_TYPEDEF (type
);
878 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
880 PyErr_SetString (PyExc_RuntimeError
,
881 _("Cannot convert value to float."));
885 TRY_CATCH (except
, RETURN_MASK_ALL
)
887 d
= value_as_double (value
);
889 GDB_PY_HANDLE_EXCEPTION (except
);
891 return PyFloat_FromDouble (d
);
894 /* Returns an object for a value which is released from the all_values chain,
895 so its lifetime is not bound to the execution of a command. */
897 value_to_value_object (struct value
*val
)
899 value_object
*val_obj
;
901 val_obj
= PyObject_New (value_object
, &value_object_type
);
904 val_obj
->value
= val
;
906 val_obj
->address
= NULL
;
907 val_obj
->type
= NULL
;
908 note_value (val_obj
);
911 return (PyObject
*) val_obj
;
914 /* Returns a borrowed reference to the struct value corresponding to
915 the given value object. */
917 value_object_to_value (PyObject
*self
)
920 if (! PyObject_TypeCheck (self
, &value_object_type
))
922 real
= (value_object
*) self
;
926 /* Try to convert a Python value to a gdb value. If the value cannot
927 be converted, set a Python exception and return NULL. Returns a
928 reference to a new value on the all_values chain. */
931 convert_value_from_python (PyObject
*obj
)
933 struct value
*value
= NULL
; /* -Wall */
935 volatile struct gdb_exception except
;
938 gdb_assert (obj
!= NULL
);
940 TRY_CATCH (except
, RETURN_MASK_ALL
)
942 if (PyBool_Check (obj
))
944 cmp
= PyObject_IsTrue (obj
);
946 value
= value_from_longest (builtin_type_pybool
, cmp
);
948 else if (PyInt_Check (obj
))
950 long l
= PyInt_AsLong (obj
);
952 if (! PyErr_Occurred ())
953 value
= value_from_longest (builtin_type_pyint
, l
);
955 else if (PyLong_Check (obj
))
957 LONGEST l
= PyLong_AsLongLong (obj
);
959 if (! PyErr_Occurred ())
960 value
= value_from_longest (builtin_type_pylong
, l
);
962 else if (PyFloat_Check (obj
))
964 double d
= PyFloat_AsDouble (obj
);
966 if (! PyErr_Occurred ())
967 value
= value_from_double (builtin_type_pyfloat
, d
);
969 else if (gdbpy_is_string (obj
))
973 s
= python_string_to_target_string (obj
);
976 old
= make_cleanup (xfree
, s
);
977 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
981 else if (PyObject_TypeCheck (obj
, &value_object_type
))
982 value
= value_copy (((value_object
*) obj
)->value
);
983 else if (gdbpy_is_lazy_string (obj
))
986 PyObject
*function
= PyString_FromString ("value");
987 result
= PyObject_CallMethodObjArgs (obj
, function
, NULL
);
988 value
= value_copy (((value_object
*) result
)->value
);
991 PyErr_Format (PyExc_TypeError
, _("Could not convert Python object: %s."),
992 PyString_AsString (PyObject_Str (obj
)));
994 if (except
.reason
< 0)
996 PyErr_Format (except
.reason
== RETURN_QUIT
997 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
998 "%s", except
.message
);
1005 /* Returns value object in the ARGth position in GDB's history. */
1007 gdbpy_history (PyObject
*self
, PyObject
*args
)
1010 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1011 volatile struct gdb_exception except
;
1013 if (!PyArg_ParseTuple (args
, "i", &i
))
1016 TRY_CATCH (except
, RETURN_MASK_ALL
)
1018 res_val
= access_value_history (i
);
1020 GDB_PY_HANDLE_EXCEPTION (except
);
1022 return value_to_value_object (res_val
);
1026 gdbpy_initialize_values (void)
1028 if (PyType_Ready (&value_object_type
) < 0)
1031 Py_INCREF (&value_object_type
);
1032 PyModule_AddObject (gdb_module
, "Value", (PyObject
*) &value_object_type
);
1034 values_in_python
= NULL
;
1039 static PyGetSetDef value_object_getset
[] = {
1040 { "address", valpy_get_address
, NULL
, "The address of the value.",
1042 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1043 "Boolean telling whether the value is optimized out (i.e., not available).",
1045 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1046 {NULL
} /* Sentinel */
1049 static PyMethodDef value_object_methods
[] = {
1050 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1051 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1052 { "lazy_string", (PyCFunction
) valpy_lazy_string
, METH_VARARGS
| METH_KEYWORDS
,
1053 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1054 Return a lazy string representation of the value." },
1055 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1056 "string ([encoding] [, errors] [, length]) -> string\n\
1057 Return Unicode string representation of the value." },
1058 {NULL
} /* Sentinel */
1061 static PyNumberMethods value_object_as_number
= {
1067 NULL
, /* nb_divmod */
1068 valpy_power
, /* nb_power */
1069 valpy_negative
, /* nb_negative */
1070 valpy_positive
, /* nb_positive */
1071 valpy_absolute
, /* nb_absolute */
1072 valpy_nonzero
, /* nb_nonzero */
1073 valpy_invert
, /* nb_invert */
1074 valpy_lsh
, /* nb_lshift */
1075 valpy_rsh
, /* nb_rshift */
1076 valpy_and
, /* nb_and */
1077 valpy_xor
, /* nb_xor */
1078 valpy_or
, /* nb_or */
1079 NULL
, /* nb_coerce */
1080 valpy_int
, /* nb_int */
1081 valpy_long
, /* nb_long */
1082 valpy_float
, /* nb_float */
1087 static PyMappingMethods value_object_as_mapping
= {
1093 PyTypeObject value_object_type
= {
1094 PyObject_HEAD_INIT (NULL
)
1096 "gdb.Value", /*tp_name*/
1097 sizeof (value_object
), /*tp_basicsize*/
1099 valpy_dealloc
, /*tp_dealloc*/
1105 &value_object_as_number
, /*tp_as_number*/
1106 0, /*tp_as_sequence*/
1107 &value_object_as_mapping
, /*tp_as_mapping*/
1108 valpy_hash
, /*tp_hash*/
1110 valpy_str
, /*tp_str*/
1114 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
, /*tp_flags*/
1115 "GDB value object", /* tp_doc */
1116 0, /* tp_traverse */
1118 valpy_richcompare
, /* tp_richcompare */
1119 0, /* tp_weaklistoffset */
1121 0, /* tp_iternext */
1122 value_object_methods
, /* tp_methods */
1124 value_object_getset
, /* tp_getset */
1127 0, /* tp_descr_get */
1128 0, /* tp_descr_set */
1129 0, /* tp_dictoffset */
1132 valpy_new
/* tp_new */
1138 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
1143 #endif /* HAVE_PYTHON */