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
)
262 int length
= -1, ret
= 0;
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
, "argument must be a Type");
311 TRY_CATCH (except
, RETURN_MASK_ALL
)
313 res_val
= value_cast (type
, ((value_object
*) self
)->value
);
315 GDB_PY_HANDLE_EXCEPTION (except
);
317 return value_to_value_object (res_val
);
321 valpy_length (PyObject
*self
)
323 /* We don't support getting the number of elements in a struct / class. */
324 PyErr_SetString (PyExc_NotImplementedError
,
325 "Invalid operation on gdb.Value.");
329 /* Given string name of an element inside structure, return its value
332 valpy_getitem (PyObject
*self
, PyObject
*key
)
334 value_object
*self_value
= (value_object
*) self
;
336 struct value
*res_val
= NULL
;
337 volatile struct gdb_exception except
;
339 if (gdbpy_is_string (key
))
341 field
= python_string_to_host_string (key
);
346 TRY_CATCH (except
, RETURN_MASK_ALL
)
348 struct value
*tmp
= self_value
->value
;
351 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
354 /* Assume we are attempting an array access, and let the
355 value code throw an exception if the index has an invalid
357 struct value
*idx
= convert_value_from_python (key
);
360 /* Check the value's type is something that can be accessed via
363 tmp
= coerce_ref (tmp
);
364 type
= check_typedef (value_type (tmp
));
365 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
366 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
367 error( _("Cannot subscript requested type"));
369 res_val
= value_subscript (tmp
, value_as_long (idx
));
375 GDB_PY_HANDLE_EXCEPTION (except
);
377 return res_val
? value_to_value_object (res_val
) : NULL
;
381 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
383 PyErr_Format (PyExc_NotImplementedError
,
384 _("Setting of struct elements is not currently supported."));
388 /* Called by the Python interpreter to obtain string representation
391 valpy_str (PyObject
*self
)
395 struct cleanup
*old_chain
;
397 struct value_print_options opts
;
398 volatile struct gdb_exception except
;
400 get_user_print_options (&opts
);
403 stb
= mem_fileopen ();
404 old_chain
= make_cleanup_ui_file_delete (stb
);
406 TRY_CATCH (except
, RETURN_MASK_ALL
)
408 common_val_print (((value_object
*) self
)->value
, stb
, 0,
409 &opts
, python_language
);
410 s
= ui_file_xstrdup (stb
, NULL
);
412 GDB_PY_HANDLE_EXCEPTION (except
);
414 do_cleanups (old_chain
);
416 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
422 /* Implements gdb.Value.is_optimized_out. */
424 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
426 struct value
*value
= ((value_object
*) self
)->value
;
428 if (value_optimized_out (value
))
449 /* If TYPE is a reference, return the target; otherwise return TYPE. */
450 #define STRIP_REFERENCE(TYPE) \
451 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
453 /* Returns a value object which is the result of applying the operation
454 specified by OPCODE to the given arguments. */
456 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
458 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
459 volatile struct gdb_exception except
;
461 TRY_CATCH (except
, RETURN_MASK_ALL
)
463 struct value
*arg1
, *arg2
;
465 /* If the gdb.Value object is the second operand, then it will be passed
466 to us as the OTHER argument, and SELF will be an entirely different
467 kind of object, altogether. Because of this, we can't assume self is
468 a gdb.Value object and need to convert it from python as well. */
469 arg1
= convert_value_from_python (self
);
473 arg2
= convert_value_from_python (other
);
481 struct type
*ltype
= value_type (arg1
);
482 struct type
*rtype
= value_type (arg2
);
484 CHECK_TYPEDEF (ltype
);
485 ltype
= STRIP_REFERENCE (ltype
);
486 CHECK_TYPEDEF (rtype
);
487 rtype
= STRIP_REFERENCE (rtype
);
489 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
490 && is_integral_type (rtype
))
491 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
492 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
493 && is_integral_type (ltype
))
494 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
496 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
501 struct type
*ltype
= value_type (arg1
);
502 struct type
*rtype
= value_type (arg2
);
504 CHECK_TYPEDEF (ltype
);
505 ltype
= STRIP_REFERENCE (ltype
);
506 CHECK_TYPEDEF (rtype
);
507 rtype
= STRIP_REFERENCE (rtype
);
509 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
510 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
511 /* A ptrdiff_t for the target would be preferable here. */
512 res_val
= value_from_longest (builtin_type_pyint
,
513 value_ptrdiff (arg1
, arg2
));
514 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
515 && is_integral_type (rtype
))
516 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
518 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
522 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
525 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
528 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
531 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
534 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
537 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
540 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
543 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
546 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
550 GDB_PY_HANDLE_EXCEPTION (except
);
552 return res_val
? value_to_value_object (res_val
) : NULL
;
556 valpy_add (PyObject
*self
, PyObject
*other
)
558 return valpy_binop (VALPY_ADD
, self
, other
);
562 valpy_subtract (PyObject
*self
, PyObject
*other
)
564 return valpy_binop (VALPY_SUB
, self
, other
);
568 valpy_multiply (PyObject
*self
, PyObject
*other
)
570 return valpy_binop (VALPY_MUL
, self
, other
);
574 valpy_divide (PyObject
*self
, PyObject
*other
)
576 return valpy_binop (VALPY_DIV
, self
, other
);
580 valpy_remainder (PyObject
*self
, PyObject
*other
)
582 return valpy_binop (VALPY_REM
, self
, other
);
586 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
588 /* We don't support the ternary form of pow. I don't know how to express
589 that, so let's just throw NotImplementedError to at least do something
591 if (unused
!= Py_None
)
593 PyErr_SetString (PyExc_NotImplementedError
,
594 "Invalid operation on gdb.Value.");
598 return valpy_binop (VALPY_POW
, self
, other
);
602 valpy_negative (PyObject
*self
)
604 struct value
*val
= NULL
;
605 volatile struct gdb_exception except
;
607 TRY_CATCH (except
, RETURN_MASK_ALL
)
609 val
= value_neg (((value_object
*) self
)->value
);
611 GDB_PY_HANDLE_EXCEPTION (except
);
613 return value_to_value_object (val
);
617 valpy_positive (PyObject
*self
)
619 return value_to_value_object (((value_object
*) self
)->value
);
623 valpy_absolute (PyObject
*self
)
625 struct value
*value
= ((value_object
*) self
)->value
;
626 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
627 return valpy_negative (self
);
629 return valpy_positive (self
);
632 /* Implements boolean evaluation of gdb.Value. */
634 valpy_nonzero (PyObject
*self
)
636 value_object
*self_value
= (value_object
*) self
;
639 type
= check_typedef (value_type (self_value
->value
));
641 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
642 return !!value_as_long (self_value
->value
);
643 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
644 return value_as_double (self_value
->value
) != 0;
645 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
646 return !decimal_is_zero (value_contents (self_value
->value
),
648 gdbarch_byte_order (get_type_arch (type
)));
651 PyErr_SetString (PyExc_TypeError
, _("Attempted truth testing on invalid "
657 /* Implements ~ for value objects. */
659 valpy_invert (PyObject
*self
)
661 struct value
*val
= NULL
;
662 volatile struct gdb_exception except
;
664 TRY_CATCH (except
, RETURN_MASK_ALL
)
666 val
= value_complement (((value_object
*) self
)->value
);
668 GDB_PY_HANDLE_EXCEPTION (except
);
670 return value_to_value_object (val
);
673 /* Implements left shift for value objects. */
675 valpy_lsh (PyObject
*self
, PyObject
*other
)
677 return valpy_binop (VALPY_LSH
, self
, other
);
680 /* Implements right shift for value objects. */
682 valpy_rsh (PyObject
*self
, PyObject
*other
)
684 return valpy_binop (VALPY_RSH
, self
, other
);
687 /* Implements bitwise and for value objects. */
689 valpy_and (PyObject
*self
, PyObject
*other
)
691 return valpy_binop (VALPY_BITAND
, self
, other
);
694 /* Implements bitwise or for value objects. */
696 valpy_or (PyObject
*self
, PyObject
*other
)
698 return valpy_binop (VALPY_BITOR
, self
, other
);
701 /* Implements bitwise xor for value objects. */
703 valpy_xor (PyObject
*self
, PyObject
*other
)
705 return valpy_binop (VALPY_BITXOR
, self
, other
);
708 /* Implements comparison operations for value objects. */
710 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
713 struct value
*value_other
;
714 volatile struct gdb_exception except
;
716 if (other
== Py_None
)
717 /* Comparing with None is special. From what I can tell, in Python
718 None is smaller than anything else. */
730 PyErr_SetString (PyExc_NotImplementedError
,
731 "Invalid operation on gdb.Value.");
735 TRY_CATCH (except
, RETURN_MASK_ALL
)
737 value_other
= convert_value_from_python (other
);
738 if (value_other
== NULL
)
746 result
= value_less (((value_object
*) self
)->value
, value_other
);
749 result
= value_less (((value_object
*) self
)->value
, value_other
)
750 || value_equal (((value_object
*) self
)->value
, value_other
);
753 result
= value_equal (((value_object
*) self
)->value
, value_other
);
756 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
759 result
= value_less (value_other
, ((value_object
*) self
)->value
);
762 result
= value_less (value_other
, ((value_object
*) self
)->value
)
763 || value_equal (((value_object
*) self
)->value
, value_other
);
767 PyErr_SetString (PyExc_NotImplementedError
,
768 "Invalid operation on gdb.Value.");
773 GDB_PY_HANDLE_EXCEPTION (except
);
775 /* In this case, the Python exception has already been set. */
785 /* Helper function to determine if a type is "int-like". */
787 is_intlike (struct type
*type
, int ptr_ok
)
789 CHECK_TYPEDEF (type
);
790 return (TYPE_CODE (type
) == TYPE_CODE_INT
791 || TYPE_CODE (type
) == TYPE_CODE_ENUM
792 || TYPE_CODE (type
) == TYPE_CODE_BOOL
793 || TYPE_CODE (type
) == TYPE_CODE_CHAR
794 || (ptr_ok
&& TYPE_CODE (type
) == TYPE_CODE_PTR
));
797 /* Implements conversion to int. */
799 valpy_int (PyObject
*self
)
801 struct value
*value
= ((value_object
*) self
)->value
;
802 struct type
*type
= value_type (value
);
804 volatile struct gdb_exception except
;
806 CHECK_TYPEDEF (type
);
807 if (!is_intlike (type
, 0))
809 PyErr_SetString (PyExc_RuntimeError
, "cannot convert value to int");
813 TRY_CATCH (except
, RETURN_MASK_ALL
)
815 l
= value_as_long (value
);
817 GDB_PY_HANDLE_EXCEPTION (except
);
819 #ifdef HAVE_LONG_LONG /* Defined by Python. */
820 /* If we have 'long long', and the value overflows a 'long', use a
821 Python Long; otherwise use a Python Int. */
822 if (sizeof (l
) > sizeof (long) && (l
> PyInt_GetMax ()
823 || l
< (- (LONGEST
) PyInt_GetMax ()) - 1))
824 return PyLong_FromLongLong (l
);
826 return PyInt_FromLong (l
);
829 /* Implements conversion to long. */
831 valpy_long (PyObject
*self
)
833 struct value
*value
= ((value_object
*) self
)->value
;
834 struct type
*type
= value_type (value
);
836 volatile struct gdb_exception except
;
838 if (!is_intlike (type
, 1))
840 PyErr_SetString (PyExc_RuntimeError
, "cannot convert value to long");
844 TRY_CATCH (except
, RETURN_MASK_ALL
)
846 l
= value_as_long (value
);
848 GDB_PY_HANDLE_EXCEPTION (except
);
850 #ifdef HAVE_LONG_LONG /* Defined by Python. */
851 return PyLong_FromLongLong (l
);
853 return PyLong_FromLong (l
);
857 /* Implements conversion to float. */
859 valpy_float (PyObject
*self
)
861 struct value
*value
= ((value_object
*) self
)->value
;
862 struct type
*type
= value_type (value
);
864 volatile struct gdb_exception except
;
866 CHECK_TYPEDEF (type
);
867 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
869 PyErr_SetString (PyExc_RuntimeError
, "cannot convert value to float");
873 TRY_CATCH (except
, RETURN_MASK_ALL
)
875 d
= value_as_double (value
);
877 GDB_PY_HANDLE_EXCEPTION (except
);
879 return PyFloat_FromDouble (d
);
882 /* Returns an object for a value which is released from the all_values chain,
883 so its lifetime is not bound to the execution of a command. */
885 value_to_value_object (struct value
*val
)
887 value_object
*val_obj
;
889 val_obj
= PyObject_New (value_object
, &value_object_type
);
892 val_obj
->value
= val
;
894 val_obj
->address
= NULL
;
895 val_obj
->type
= NULL
;
896 note_value (val_obj
);
899 return (PyObject
*) val_obj
;
902 /* Returns a borrowed reference to the struct value corresponding to
903 the given value object. */
905 value_object_to_value (PyObject
*self
)
908 if (! PyObject_TypeCheck (self
, &value_object_type
))
910 real
= (value_object
*) self
;
914 /* Try to convert a Python value to a gdb value. If the value cannot
915 be converted, set a Python exception and return NULL. Returns a
916 reference to a new value on the all_values chain. */
919 convert_value_from_python (PyObject
*obj
)
921 struct value
*value
= NULL
; /* -Wall */
922 PyObject
*target_str
, *unicode_str
;
924 volatile struct gdb_exception except
;
927 gdb_assert (obj
!= NULL
);
929 TRY_CATCH (except
, RETURN_MASK_ALL
)
931 if (PyBool_Check (obj
))
933 cmp
= PyObject_IsTrue (obj
);
935 value
= value_from_longest (builtin_type_pybool
, cmp
);
937 else if (PyInt_Check (obj
))
939 long l
= PyInt_AsLong (obj
);
941 if (! PyErr_Occurred ())
942 value
= value_from_longest (builtin_type_pyint
, l
);
944 else if (PyLong_Check (obj
))
946 LONGEST l
= PyLong_AsLongLong (obj
);
948 if (! PyErr_Occurred ())
949 value
= value_from_longest (builtin_type_pylong
, l
);
951 else if (PyFloat_Check (obj
))
953 double d
= PyFloat_AsDouble (obj
);
955 if (! PyErr_Occurred ())
956 value
= value_from_double (builtin_type_pyfloat
, d
);
958 else if (gdbpy_is_string (obj
))
962 s
= python_string_to_target_string (obj
);
965 old
= make_cleanup (xfree
, s
);
966 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
970 else if (PyObject_TypeCheck (obj
, &value_object_type
))
971 value
= value_copy (((value_object
*) obj
)->value
);
972 else if (gdbpy_is_lazy_string (obj
))
975 PyObject
*function
= PyString_FromString ("value");
976 result
= PyObject_CallMethodObjArgs (obj
, function
, NULL
);
977 value
= value_copy (((value_object
*) result
)->value
);
980 PyErr_Format (PyExc_TypeError
, _("Could not convert Python object: %s"),
981 PyString_AsString (PyObject_Str (obj
)));
983 if (except
.reason
< 0)
985 PyErr_Format (except
.reason
== RETURN_QUIT
986 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
987 "%s", except
.message
);
994 /* Returns value object in the ARGth position in GDB's history. */
996 gdbpy_history (PyObject
*self
, PyObject
*args
)
999 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1000 volatile struct gdb_exception except
;
1002 if (!PyArg_ParseTuple (args
, "i", &i
))
1005 TRY_CATCH (except
, RETURN_MASK_ALL
)
1007 res_val
= access_value_history (i
);
1009 GDB_PY_HANDLE_EXCEPTION (except
);
1011 return value_to_value_object (res_val
);
1015 gdbpy_initialize_values (void)
1017 if (PyType_Ready (&value_object_type
) < 0)
1020 Py_INCREF (&value_object_type
);
1021 PyModule_AddObject (gdb_module
, "Value", (PyObject
*) &value_object_type
);
1023 values_in_python
= NULL
;
1028 static PyGetSetDef value_object_getset
[] = {
1029 { "address", valpy_get_address
, NULL
, "The address of the value.",
1031 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1032 "Boolean telling whether the value is optimized out (i.e., not available).",
1034 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1035 {NULL
} /* Sentinel */
1038 static PyMethodDef value_object_methods
[] = {
1039 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1040 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1041 { "lazy_string", (PyCFunction
) valpy_lazy_string
, METH_VARARGS
| METH_KEYWORDS
,
1042 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1043 Return a lazy string representation of the value." },
1044 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1045 "string ([encoding] [, errors] [, length]) -> string\n\
1046 Return Unicode string representation of the value." },
1047 {NULL
} /* Sentinel */
1050 static PyNumberMethods value_object_as_number
= {
1056 NULL
, /* nb_divmod */
1057 valpy_power
, /* nb_power */
1058 valpy_negative
, /* nb_negative */
1059 valpy_positive
, /* nb_positive */
1060 valpy_absolute
, /* nb_absolute */
1061 valpy_nonzero
, /* nb_nonzero */
1062 valpy_invert
, /* nb_invert */
1063 valpy_lsh
, /* nb_lshift */
1064 valpy_rsh
, /* nb_rshift */
1065 valpy_and
, /* nb_and */
1066 valpy_xor
, /* nb_xor */
1067 valpy_or
, /* nb_or */
1068 NULL
, /* nb_coerce */
1069 valpy_int
, /* nb_int */
1070 valpy_long
, /* nb_long */
1071 valpy_float
, /* nb_float */
1076 static PyMappingMethods value_object_as_mapping
= {
1082 PyTypeObject value_object_type
= {
1083 PyObject_HEAD_INIT (NULL
)
1085 "gdb.Value", /*tp_name*/
1086 sizeof (value_object
), /*tp_basicsize*/
1088 valpy_dealloc
, /*tp_dealloc*/
1094 &value_object_as_number
, /*tp_as_number*/
1095 0, /*tp_as_sequence*/
1096 &value_object_as_mapping
, /*tp_as_mapping*/
1099 valpy_str
, /*tp_str*/
1103 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
, /*tp_flags*/
1104 "GDB value object", /* tp_doc */
1105 0, /* tp_traverse */
1107 valpy_richcompare
, /* tp_richcompare */
1108 0, /* tp_weaklistoffset */
1110 0, /* tp_iternext */
1111 value_object_methods
, /* tp_methods */
1113 value_object_getset
, /* tp_getset */
1116 0, /* tp_descr_get */
1117 0, /* tp_descr_set */
1118 0, /* tp_dictoffset */
1121 valpy_new
/* tp_new */
1127 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
1132 #endif /* HAVE_PYTHON */