{
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;
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 = 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;
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);
}
- 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 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. */
+ "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!IIs",
+ 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.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). */
+ 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);
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;
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)
{
}
}
- 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;
}
{
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));
/* 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))
{
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))
{
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);
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);
}
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);
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 */
};