X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fpython%2Fpy-value.c;h=ede4c0e759a97900b389da629dfc54b44f274596;hb=d8f27c6018adbb32a3ebba39a5abac44a6b9e67c;hp=430415b2f9b764e65b280f9cb30f3860b9abd6bd;hpb=ec9c2750b7bab8a55aaf7d2386e809d4e81deb03;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c index 430415b2f9..ede4c0e759 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -1,6 +1,6 @@ /* Python interface to values. - Copyright (C) 2008-2018 Free Software Foundation, Inc. + Copyright (C) 2008-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -29,7 +29,6 @@ #include "python.h" #include "python-internal.h" -#include "py-ref.h" /* Even though Python scalar types directly map to host types, we use target types here to remain consistent with the values system in @@ -90,17 +89,8 @@ valpy_dealloc (PyObject *obj) value_decref (self->value); - if (self->address) - /* Use braces to appease gcc warning. *sigh* */ - { - Py_DECREF (self->address); - } - - if (self->type) - { - Py_DECREF (self->type); - } - + Py_XDECREF (self->address); + Py_XDECREF (self->type); Py_XDECREF (self->dynamic_type); Py_TYPE (self)->tp_free (self); @@ -117,22 +107,68 @@ note_value (value_object *value_obj) values_in_python = value_obj; } +/* Convert a python object OBJ with type TYPE to a gdb value. The + python object in question must conform to the python buffer + protocol. On success, return the converted value, otherwise + nullptr. */ + +static struct value * +convert_buffer_and_type_to_value (PyObject *obj, struct type *type) +{ + Py_buffer_up buffer_up; + Py_buffer py_buf; + + if (PyObject_CheckBuffer (obj) + && PyObject_GetBuffer (obj, &py_buf, PyBUF_SIMPLE) == 0) + { + /* Got a buffer, py_buf, out of obj. Cause it to be released + when it goes out of scope. */ + buffer_up.reset (&py_buf); + } + else + { + PyErr_SetString (PyExc_TypeError, + _("Object must support the python buffer protocol.")); + return nullptr; + } + + if (TYPE_LENGTH (type) > py_buf.len) + { + PyErr_SetString (PyExc_ValueError, + _("Size of type is larger than that of buffer object.")); + return nullptr; + } + + return value_from_contents (type, (const gdb_byte *) py_buf.buf); +} + /* Called when a new gdb.Value object needs to be allocated. Returns NULL on error, with a python exception set. */ static PyObject * -valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) +valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *kwargs) { - struct value *value = NULL; /* Initialize to appease gcc warning. */ - value_object *value_obj; + static const char *keywords[] = { "val", "type", NULL }; + PyObject *val_obj = nullptr; + PyObject *type_obj = nullptr; + + if (!gdb_PyArg_ParseTupleAndKeywords (args, kwargs, "O|O", keywords, + &val_obj, &type_obj)) + return nullptr; + + struct type *type = nullptr; - if (PyTuple_Size (args) != 1) + if (type_obj != nullptr) { - PyErr_SetString (PyExc_TypeError, _("Value object creation takes only " - "1 argument")); - return NULL; + type = type_object_to_type (type_obj); + if (type == nullptr) + { + PyErr_SetString (PyExc_TypeError, + _("type argument must be a gdb.Type.")); + return nullptr; + } } - value_obj = (value_object *) subtype->tp_alloc (subtype, 1); + value_object *value_obj = (value_object *) subtype->tp_alloc (subtype, 1); if (value_obj == NULL) { PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to " @@ -140,8 +176,14 @@ valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) return NULL; } - value = convert_value_from_python (PyTuple_GetItem (args, 0)); - if (value == NULL) + struct value *value; + + if (type == nullptr) + value = convert_value_from_python (val_obj); + else + value = convert_buffer_and_type_to_value (val_obj, type); + + if (value == nullptr) { subtype->tp_free (value_obj); return NULL; @@ -174,7 +216,7 @@ valpy_dereference (PyObject *self, PyObject *args) { PyObject *result = NULL; - TRY + try { struct value *res_val; scoped_value_mark free_values; @@ -182,11 +224,10 @@ valpy_dereference (PyObject *self, PyObject *args) res_val = value_ind (((value_object *) self)->value); result = value_to_value_object (res_val); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -204,7 +245,7 @@ valpy_referenced_value (PyObject *self, PyObject *args) { PyObject *result = NULL; - TRY + try { struct value *self_val, *res_val; scoped_value_mark free_values; @@ -226,11 +267,10 @@ valpy_referenced_value (PyObject *self, PyObject *args) result = value_to_value_object (res_val); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -242,7 +282,7 @@ valpy_reference_value (PyObject *self, PyObject *args, enum type_code refcode) { PyObject *result = NULL; - TRY + try { struct value *self_val; scoped_value_mark free_values; @@ -250,11 +290,10 @@ valpy_reference_value (PyObject *self, PyObject *args, enum type_code refcode) self_val = ((value_object *) self)->value; result = value_to_value_object (value_ref (self_val, refcode)); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -278,7 +317,7 @@ valpy_const_value (PyObject *self, PyObject *args) { PyObject *result = NULL; - TRY + try { struct value *self_val, *res_val; scoped_value_mark free_values; @@ -287,11 +326,10 @@ valpy_const_value (PyObject *self, PyObject *args) res_val = make_cv_value (1, 0, self_val); result = value_to_value_object (res_val); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -304,7 +342,7 @@ valpy_get_address (PyObject *self, void *closure) if (!val_obj->address) { - TRY + try { struct value *res_val; scoped_value_mark free_values; @@ -312,12 +350,11 @@ valpy_get_address (PyObject *self, void *closure) res_val = value_addr (val_obj->value); val_obj->address = value_to_value_object (res_val); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { val_obj->address = Py_None; Py_INCREF (Py_None); } - END_CATCH } Py_XINCREF (val_obj->address); @@ -355,7 +392,7 @@ valpy_get_dynamic_type (PyObject *self, void *closure) return obj->dynamic_type; } - TRY + try { struct value *val = obj->value; scoped_value_mark free_values; @@ -391,11 +428,10 @@ valpy_get_dynamic_type (PyObject *self, void *closure) type = NULL; } } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (type == NULL) obj->dynamic_type = valpy_get_type (self, NULL); @@ -443,7 +479,7 @@ valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw) return NULL; } - TRY + try { scoped_value_mark free_values; struct type *type, *realtype; @@ -498,11 +534,10 @@ valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw) str_obj = gdbpy_create_lazy_string_object (addr, length, user_encoding, type); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return str_obj; } @@ -530,15 +565,14 @@ valpy_string (PyObject *self, PyObject *args, PyObject *kw) &user_encoding, &errors, &length)) return NULL; - TRY + try { LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding; return PyUnicode_Decode ((const char *) buffer.get (), @@ -546,6 +580,167 @@ valpy_string (PyObject *self, PyObject *args, PyObject *kw) encoding, errors); } +/* Given a Python object, copy its truth value to a C int (the value + pointed by dest). + If src_obj is NULL, then *dest is not modified. + + Return true in case of success (including src_obj being NULL), false + in case of error. */ + +static bool +copy_py_bool_obj (int *dest, PyObject *src_obj) +{ + if (src_obj) + { + int cmp = PyObject_IsTrue (src_obj); + if (cmp < 0) + return false; + *dest = cmp; + } + + return true; +} + +/* Implementation of gdb.Value.format_string (...) -> string. + Return Unicode string with value contents formatted using the + keyword-only arguments. */ + +static PyObject * +valpy_format_string (PyObject *self, PyObject *args, PyObject *kw) +{ + static const char *keywords[] = + { + /* Basic C/C++ options. */ + "raw", /* See the /r option to print. */ + "pretty_arrays", /* See set print array on|off. */ + "pretty_structs", /* See set print pretty on|off. */ + "array_indexes", /* See set print array-indexes on|off. */ + "symbols", /* See set print symbol on|off. */ + "unions", /* See set print union on|off. */ + /* C++ options. */ + "deref_refs", /* No corresponding setting. */ + "actual_objects", /* See set print object on|off. */ + "static_members", /* See set print static-members on|off. */ + /* C non-bool options. */ + "max_elements", /* See set print elements N. */ + "max_depth", /* See set print max-depth N. */ + "repeat_threshold", /* See set print repeats. */ + "format", /* The format passed to the print command. */ + NULL + }; + + /* This function has too many arguments to be useful as positionals, so + the user should specify them all as keyword arguments. + Python 3.3 and later have a way to specify it (both in C and Python + itself), but we could be compiled with older versions, so we just + check that the args tuple is empty. */ + Py_ssize_t positional_count = PyObject_Length (args); + if (positional_count < 0) + return NULL; + else if (positional_count > 0) + { + /* This matches the error message that Python 3.3 raises when + passing positionals to functions expecting keyword-only + arguments. */ + PyErr_Format (PyExc_TypeError, + "format_string() takes 0 positional arguments but %zu were given", + positional_count); + return NULL; + } + + struct value_print_options opts; + get_user_print_options (&opts); + opts.deref_ref = 0; + + /* We need objects for booleans as the "p" flag for bools is new in + Python 3.3. */ + PyObject *raw_obj = NULL; + PyObject *pretty_arrays_obj = NULL; + PyObject *pretty_structs_obj = NULL; + PyObject *array_indexes_obj = NULL; + PyObject *symbols_obj = NULL; + PyObject *unions_obj = NULL; + PyObject *deref_refs_obj = NULL; + PyObject *actual_objects_obj = NULL; + PyObject *static_members_obj = NULL; + char *format = NULL; + if (!gdb_PyArg_ParseTupleAndKeywords (args, + kw, + "|O!O!O!O!O!O!O!O!O!IIIs", + keywords, + &PyBool_Type, &raw_obj, + &PyBool_Type, &pretty_arrays_obj, + &PyBool_Type, &pretty_structs_obj, + &PyBool_Type, &array_indexes_obj, + &PyBool_Type, &symbols_obj, + &PyBool_Type, &unions_obj, + &PyBool_Type, &deref_refs_obj, + &PyBool_Type, &actual_objects_obj, + &PyBool_Type, &static_members_obj, + &opts.print_max, + &opts.max_depth, + &opts.repeat_count_threshold, + &format)) + return NULL; + + /* Set boolean arguments. */ + if (!copy_py_bool_obj (&opts.raw, raw_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.prettyformat_arrays, pretty_arrays_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.prettyformat_structs, pretty_structs_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.print_array_indexes, array_indexes_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.symbol_print, symbols_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.unionprint, unions_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.deref_ref, deref_refs_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.objectprint, actual_objects_obj)) + return NULL; + if (!copy_py_bool_obj (&opts.static_field_print, static_members_obj)) + return NULL; + + /* Numeric arguments for which 0 means unlimited (which we represent as + UINT_MAX). Note that the max-depth numeric argument uses -1 as + unlimited, and 0 is a valid choice. */ + if (opts.print_max == 0) + opts.print_max = UINT_MAX; + if (opts.repeat_count_threshold == 0) + opts.repeat_count_threshold = UINT_MAX; + + /* Other arguments. */ + if (format != NULL) + { + if (strlen (format) == 1) + opts.format = format[0]; + else + { + /* Mimic the message on standard Python ones for similar + errors. */ + PyErr_SetString (PyExc_ValueError, + "a single character is required"); + return NULL; + } + } + + string_file stb; + + try + { + common_val_print (((value_object *) self)->value, &stb, 0, + &opts, python_language); + } + catch (const gdb_exception &except) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + + return PyUnicode_Decode (stb.c_str (), stb.size (), host_charset (), NULL); +} + /* A helper function that implements the various cast operators. */ static PyObject * @@ -565,7 +760,7 @@ valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op) return NULL; } - TRY + try { struct value *val = ((value_object *) self)->value; struct value *res_val; @@ -583,11 +778,10 @@ valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op) result = value_to_value_object (res_val); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -648,12 +842,12 @@ value_has_field (struct value *v, PyObject *field) return -1; } - TRY + try { val_type = value_type (v); val_type = check_typedef (val_type); if (TYPE_IS_REFERENCE (val_type) || TYPE_CODE (val_type) == TYPE_CODE_PTR) - val_type = check_typedef (TYPE_TARGET_TYPE (val_type)); + val_type = check_typedef (TYPE_TARGET_TYPE (val_type)); type_code = TYPE_CODE (val_type); if ((type_code == TYPE_CODE_STRUCT || type_code == TYPE_CODE_UNION) @@ -662,11 +856,10 @@ value_has_field (struct value *v, PyObject *field) else has_field = 0; } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_SET_HANDLE_EXCEPTION (except); } - END_CATCH return has_field; } @@ -713,7 +906,7 @@ get_field_type (PyObject *field) static PyObject * valpy_getitem (PyObject *self, PyObject *key) { - struct gdb_exception except = exception_none; + struct gdb_exception except; value_object *self_value = (value_object *) self; gdb::unique_xmalloc_ptr field; struct type *base_class_type = NULL, *field_type = NULL; @@ -787,7 +980,7 @@ valpy_getitem (PyObject *self, PyObject *key) } } - TRY + try { struct value *tmp = self_value->value; struct value *res_val = NULL; @@ -841,11 +1034,10 @@ valpy_getitem (PyObject *self, PyObject *key) if (res_val) result = value_to_value_object (res_val); } - CATCH (ex, RETURN_MASK_ALL) + catch (gdb_exception &ex) { - except = ex; + except = std::move (ex); } - END_CATCH GDB_PY_HANDLE_EXCEPTION (except); @@ -871,15 +1063,14 @@ valpy_call (PyObject *self, PyObject *args, PyObject *keywords) struct type *ftype = NULL; PyObject *result = NULL; - TRY + try { ftype = check_typedef (value_type (function)); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (TYPE_CODE (ftype) != TYPE_CODE_FUNC) { @@ -914,7 +1105,7 @@ valpy_call (PyObject *self, PyObject *args, PyObject *keywords) } } - TRY + try { scoped_value_mark free_values; @@ -923,11 +1114,10 @@ valpy_call (PyObject *self, PyObject *args, PyObject *keywords) gdb::make_array_view (vargs, args_count)); result = value_to_value_object (return_value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -944,16 +1134,15 @@ valpy_str (PyObject *self) string_file stb; - TRY + try { common_val_print (((value_object *) self)->value, &stb, 0, &opts, python_language); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return PyUnicode_Decode (stb.c_str (), stb.size (), host_charset (), NULL); } @@ -965,15 +1154,14 @@ valpy_get_is_optimized_out (PyObject *self, void *closure) struct value *value = ((value_object *) self)->value; int opt = 0; - TRY + try { opt = value_optimized_out (value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (opt) Py_RETURN_TRUE; @@ -988,15 +1176,14 @@ valpy_get_is_lazy (PyObject *self, void *closure) struct value *value = ((value_object *) self)->value; int opt = 0; - TRY + try { opt = value_lazy (value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (opt) Py_RETURN_TRUE; @@ -1010,16 +1197,15 @@ valpy_fetch_lazy (PyObject *self, PyObject *args) { struct value *value = ((value_object *) self)->value; - TRY + try { if (value_lazy (value)) value_fetch_lazy (value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH Py_RETURN_NONE; } @@ -1183,15 +1369,14 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) { PyObject *result = NULL; - TRY + try { result = valpy_binop_throw (opcode, self, other); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -1247,7 +1432,7 @@ valpy_negative (PyObject *self) { PyObject *result = NULL; - TRY + try { /* Perhaps overkill, but consistency has some virtue. */ scoped_value_mark free_values; @@ -1256,11 +1441,10 @@ valpy_negative (PyObject *self) val = value_neg (((value_object *) self)->value); result = value_to_value_object (val); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return result; } @@ -1277,18 +1461,17 @@ valpy_absolute (PyObject *self) struct value *value = ((value_object *) self)->value; int isabs = 1; - TRY + try { scoped_value_mark free_values; if (value_less (value, value_zero (value_type (value), not_lval))) isabs = 0; } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (isabs) return valpy_positive (self); @@ -1300,12 +1483,12 @@ valpy_absolute (PyObject *self) static int valpy_nonzero (PyObject *self) { - struct gdb_exception except = exception_none; + struct gdb_exception except; value_object *self_value = (value_object *) self; struct type *type; int nonzero = 0; /* Appease GCC warning. */ - TRY + try { type = check_typedef (value_type (self_value->value)); @@ -1318,11 +1501,10 @@ valpy_nonzero (PyObject *self) /* All other values are True. */ nonzero = 1; } - CATCH (ex, RETURN_MASK_ALL) + catch (gdb_exception &ex) { - except = ex; + except = std::move (ex); } - END_CATCH /* This is not documented in the Python documentation, but if this function fails, return -1 as slot_nb_nonzero does (the default @@ -1338,15 +1520,14 @@ valpy_invert (PyObject *self) { struct value *val = NULL; - TRY + try { val = value_complement (((value_object *) self)->value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return value_to_value_object (val); } @@ -1466,15 +1647,14 @@ valpy_richcompare (PyObject *self, PyObject *other, int op) return NULL; } - TRY + try { result = valpy_richcompare_throw (self, other, op); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH /* In this case, the Python exception has already been set. */ if (result < 0) @@ -1495,7 +1675,7 @@ valpy_int (PyObject *self) struct type *type = value_type (value); LONGEST l = 0; - TRY + try { if (is_floating_value (value)) { @@ -1509,11 +1689,10 @@ valpy_int (PyObject *self) l = value_as_long (value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (TYPE_UNSIGNED (type)) return gdb_py_object_from_ulongest (l).release (); @@ -1530,7 +1709,7 @@ valpy_long (PyObject *self) struct type *type = value_type (value); LONGEST l = 0; - TRY + try { if (is_floating_value (value)) { @@ -1546,11 +1725,10 @@ valpy_long (PyObject *self) l = value_as_long (value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (TYPE_UNSIGNED (type)) return gdb_py_long_from_ulongest (l); @@ -1566,7 +1744,7 @@ valpy_float (PyObject *self) struct type *type = value_type (value); double d = 0; - TRY + try { type = check_typedef (type); @@ -1582,11 +1760,10 @@ valpy_float (PyObject *self) else error (_("Cannot convert value to float.")); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return PyFloat_FromDouble (d); } @@ -1636,7 +1813,7 @@ convert_value_from_python (PyObject *obj) gdb_assert (obj != NULL); - TRY + try { if (PyBool_Check (obj)) { @@ -1661,9 +1838,7 @@ convert_value_from_python (PyObject *obj) ULONGEST instead. */ if (PyErr_ExceptionMatches (PyExc_OverflowError)) { - PyObject *etype, *evalue, *etraceback; - - PyErr_Fetch (&etype, &evalue, &etraceback); + gdbpy_err_fetch fetched_error; gdbpy_ref<> zero (PyInt_FromLong (0)); /* Check whether obj is positive. */ @@ -1676,8 +1851,10 @@ convert_value_from_python (PyObject *obj) value = value_from_ulongest (builtin_type_upylong, ul); } else - /* There's nothing we can do. */ - PyErr_Restore (etype, evalue, etraceback); + { + /* There's nothing we can do. */ + fetched_error.restore (); + } } } else @@ -1697,11 +1874,7 @@ convert_value_from_python (PyObject *obj) double d = PyFloat_AsDouble (obj); if (! PyErr_Occurred ()) - { - value = allocate_value (builtin_type_pyfloat); - target_float_from_host_double (value_contents_raw (value), - value_type (value), d); - } + value = value_from_host_double (builtin_type_pyfloat, d); } else if (gdbpy_is_string (obj)) { @@ -1730,12 +1903,11 @@ convert_value_from_python (PyObject *obj) PyString_AsString (PyObject_Str (obj))); #endif } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { gdbpy_convert_exception (except); return NULL; } - END_CATCH return value; } @@ -1750,15 +1922,14 @@ gdbpy_history (PyObject *self, PyObject *args) if (!PyArg_ParseTuple (args, "i", &i)) return NULL; - TRY + try { res_val = access_value_history (i); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH return value_to_value_object (res_val); } @@ -1773,7 +1944,7 @@ gdbpy_convenience_variable (PyObject *self, PyObject *args) if (!PyArg_ParseTuple (args, "s", &varname)) return NULL; - TRY + try { struct internalvar *var = lookup_only_internalvar (varname); @@ -1784,11 +1955,10 @@ gdbpy_convenience_variable (PyObject *self, PyObject *args) res_val = NULL; } } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH if (res_val == NULL) Py_RETURN_NONE; @@ -1815,7 +1985,7 @@ gdbpy_set_convenience_variable (PyObject *self, PyObject *args) return NULL; } - TRY + try { if (value == NULL) { @@ -1831,11 +2001,10 @@ gdbpy_set_convenience_variable (PyObject *self, PyObject *args) set_internalvar (var, value); } } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH Py_RETURN_NONE; } @@ -1906,6 +2075,11 @@ Return a lazy string representation of the value." }, Return Unicode string representation of the value." }, { "fetch_lazy", valpy_fetch_lazy, METH_NOARGS, "Fetches the value from the inferior, if it was lazy." }, + { "format_string", (PyCFunction) valpy_format_string, + METH_VARARGS | METH_KEYWORDS, + "format_string (...) -> string\n\ +Return a string representation of the value using the specified\n\ +formatting options" }, {NULL} /* Sentinel */ }; @@ -1959,10 +2133,7 @@ static PyNumberMethods value_object_as_number = { valpy_divide, /* nb_true_divide */ NULL, /* nb_inplace_floor_divide */ NULL, /* nb_inplace_true_divide */ -#ifndef HAVE_LIBPYTHON2_4 - /* This was added in Python 2.5. */ valpy_long, /* nb_index */ -#endif /* HAVE_LIBPYTHON2_4 */ }; static PyMappingMethods value_object_as_mapping = {