/* Python interface to values.
- Copyright (C) 2008-2019 Free Software Foundation, Inc.
+ Copyright (C) 2008-2020 Free Software Foundation, Inc.
This file is part of GDB.
{
PyObject *result = NULL;
- TRY
+ try
{
struct value *res_val;
scoped_value_mark free_values;
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;
}
{
PyObject *result = NULL;
- TRY
+ try
{
struct value *self_val, *res_val;
scoped_value_mark free_values;
self_val = ((value_object *) self)->value;
- switch (TYPE_CODE (check_typedef (value_type (self_val))))
+ switch (check_typedef (value_type (self_val))->code ())
{
case TYPE_CODE_PTR:
res_val = value_ind (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;
}
{
PyObject *result = NULL;
- TRY
+ try
{
struct value *self_val;
scoped_value_mark free_values;
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;
}
{
PyObject *result = NULL;
- TRY
+ try
{
struct value *self_val, *res_val;
scoped_value_mark free_values;
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;
}
if (!val_obj->address)
{
- TRY
+ try
{
struct value *res_val;
scoped_value_mark free_values;
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);
return obj->dynamic_type;
}
- TRY
+ try
{
struct value *val = obj->value;
scoped_value_mark free_values;
type = value_type (val);
type = check_typedef (type);
- if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
- && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
+ if (((type->code () == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
+ && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT))
{
struct value *target;
- int was_pointer = TYPE_CODE (type) == TYPE_CODE_PTR;
+ int was_pointer = type->code () == TYPE_CODE_PTR;
if (was_pointer)
target = value_ind (val);
type = lookup_lvalue_reference_type (type);
}
}
- else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ else if (type->code () == TYPE_CODE_STRUCT)
type = value_rtti_type (val, NULL, NULL, NULL);
else
{
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);
return NULL;
}
- TRY
+ try
{
scoped_value_mark free_values;
struct type *type, *realtype;
type = value_type (value);
realtype = check_typedef (type);
- switch (TYPE_CODE (realtype))
+ switch (realtype->code ())
{
case TYPE_CODE_ARRAY:
{
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;
}
&user_encoding, &errors, &length))
return NULL;
- TRY
+ try
{
- LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
+ c_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 (),
encoding, errors);
}
+/* Given a Python object, copy its truth value to a C bool (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 (bool *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 *
return NULL;
}
- TRY
+ try
{
struct value *val = ((value_object *) self)->value;
struct value *res_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;
}
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));
+ if (TYPE_IS_REFERENCE (val_type) || val_type->code () == TYPE_CODE_PTR)
+ val_type = check_typedef (TYPE_TARGET_TYPE (val_type));
- type_code = TYPE_CODE (val_type);
+ type_code = val_type->code ();
if ((type_code == TYPE_CODE_STRUCT || type_code == TYPE_CODE_UNION)
&& types_equal (val_type, parent_type))
has_field = 1;
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;
}
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<char> field;
struct type *base_class_type = NULL, *field_type = NULL;
}
}
- TRY
+ try
{
struct value *tmp = self_value->value;
struct value *res_val = NULL;
struct type *val_type;
val_type = check_typedef (value_type (tmp));
- if (TYPE_CODE (val_type) == TYPE_CODE_PTR)
+ if (val_type->code () == TYPE_CODE_PTR)
res_val = value_cast (lookup_pointer_type (base_class_type), tmp);
- else if (TYPE_CODE (val_type) == TYPE_CODE_REF)
+ else if (val_type->code () == TYPE_CODE_REF)
res_val = value_cast (lookup_lvalue_reference_type (base_class_type),
tmp);
- else if (TYPE_CODE (val_type) == TYPE_CODE_RVALUE_REF)
+ else if (val_type->code () == TYPE_CODE_RVALUE_REF)
res_val = value_cast (lookup_rvalue_reference_type (base_class_type),
tmp);
else
tmp = coerce_ref (tmp);
type = check_typedef (value_type (tmp));
- if (TYPE_CODE (type) != TYPE_CODE_ARRAY
- && TYPE_CODE (type) != TYPE_CODE_PTR)
+ if (type->code () != TYPE_CODE_ARRAY
+ && type->code () != TYPE_CODE_PTR)
error (_("Cannot subscript requested type."));
else
res_val = value_subscript (tmp, value_as_long (idx));
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);
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)
+ if (ftype->code () != TYPE_CODE_FUNC)
{
PyErr_SetString (PyExc_RuntimeError,
_("Value is not callable (not TYPE_CODE_FUNC)."));
}
}
- TRY
+ try
{
scoped_value_mark free_values;
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;
}
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);
}
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;
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;
{
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;
}
rtype = STRIP_REFERENCE (rtype);
handled = 1;
- if (TYPE_CODE (ltype) == TYPE_CODE_PTR
+ if (ltype->code () == TYPE_CODE_PTR
&& is_integral_type (rtype))
res_val = value_ptradd (arg1, value_as_long (arg2));
- else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
+ else if (rtype->code () == TYPE_CODE_PTR
&& is_integral_type (ltype))
res_val = value_ptradd (arg2, value_as_long (arg1));
else
rtype = STRIP_REFERENCE (rtype);
handled = 1;
- if (TYPE_CODE (ltype) == TYPE_CODE_PTR
- && TYPE_CODE (rtype) == TYPE_CODE_PTR)
+ if (ltype->code () == TYPE_CODE_PTR
+ && rtype->code () == TYPE_CODE_PTR)
/* A ptrdiff_t for the target would be preferable here. */
res_val = value_from_longest (builtin_type_pyint,
value_ptrdiff (arg1, arg2));
- else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
+ else if (ltype->code () == TYPE_CODE_PTR
&& is_integral_type (rtype))
res_val = value_ptradd (arg1, - value_as_long (arg2));
else
{
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;
}
{
PyObject *result = NULL;
- TRY
+ try
{
/* Perhaps overkill, but consistency has some virtue. */
scoped_value_mark free_values;
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;
}
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);
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));
- if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (is_integral_type (type) || type->code () == TYPE_CODE_PTR)
nonzero = !!value_as_long (self_value->value);
else if (is_floating_value (self_value->value))
nonzero = !target_float_is_zero (value_contents (self_value->value),
/* 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
{
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);
}
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)
struct type *type = value_type (value);
LONGEST l = 0;
- TRY
+ try
{
if (is_floating_value (value))
{
}
if (!is_integral_type (type)
- && TYPE_CODE (type) != TYPE_CODE_PTR)
+ && type->code () != TYPE_CODE_PTR)
error (_("Cannot convert value to int."));
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 ();
struct type *type = value_type (value);
LONGEST l = 0;
- TRY
+ try
{
if (is_floating_value (value))
{
type = check_typedef (type);
if (!is_integral_type (type)
- && TYPE_CODE (type) != TYPE_CODE_PTR)
+ && type->code () != TYPE_CODE_PTR)
error (_("Cannot convert value to long."));
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);
struct type *type = value_type (value);
double d = 0;
- TRY
+ try
{
type = check_typedef (type);
- if (TYPE_CODE (type) == TYPE_CODE_FLT && is_floating_value (value))
+ if (type->code () == TYPE_CODE_FLT && is_floating_value (value))
d = target_float_to_host_double (value_contents (value), type);
- else if (TYPE_CODE (type) == TYPE_CODE_INT)
+ else if (type->code () == TYPE_CODE_INT)
{
/* Note that valpy_long accepts TYPE_CODE_PTR and some
others here here -- but casting a pointer or bool to a
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);
}
return (PyObject *) val_obj;
}
+/* Returns an object for a value, but without releasing it from the
+ all_values chain. */
+PyObject *
+value_to_value_object_no_release (struct value *val)
+{
+ value_object *val_obj;
+
+ val_obj = PyObject_New (value_object, &value_object_type);
+ if (val_obj != NULL)
+ {
+ value_incref (val);
+ val_obj->value = val;
+ val_obj->address = NULL;
+ val_obj->type = NULL;
+ val_obj->dynamic_type = NULL;
+ note_value (val_obj);
+ }
+
+ return (PyObject *) val_obj;
+}
+
/* Returns a borrowed reference to the struct value corresponding to
the given value object. */
struct value *
gdb_assert (obj != NULL);
- TRY
+ try
{
if (PyBool_Check (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))
{
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;
}
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);
}
if (!PyArg_ParseTuple (args, "s", &varname))
return NULL;
- TRY
+ try
{
struct internalvar *var = lookup_only_internalvar (varname);
if (var != NULL)
{
res_val = value_of_internalvar (python_gdbarch, var);
- if (TYPE_CODE (value_type (res_val)) == TYPE_CODE_VOID)
+ if (value_type (res_val)->code () == TYPE_CODE_VOID)
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;
return NULL;
}
- TRY
+ try
{
if (value == NULL)
{
set_internalvar (var, value);
}
}
- CATCH (except, RETURN_MASK_ALL)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
- END_CATCH
Py_RETURN_NONE;
}
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 */
};