/* Python interface to values.
- Copyright (C) 2008-2017 Free Software Foundation, Inc.
+ Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "charset.h"
#include "value.h"
#include "language.h"
-#include "dfp.h"
+#include "target-float.h"
#include "valprint.h"
#include "infcall.h"
#include "expression.h"
#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
if (self->next)
self->next->prev = self->prev;
- value_free (self->value);
-
- if (self->address)
- /* Use braces to appease gcc warning. *sigh* */
- {
- Py_DECREF (self->address);
- }
-
- if (self->type)
- {
- Py_DECREF (self->type);
- }
+ value_decref (self->value);
+ Py_XDECREF (self->address);
+ Py_XDECREF (self->type);
Py_XDECREF (self->dynamic_type);
Py_TYPE (self)->tp_free (self);
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 "
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;
}
- value_obj->value = value;
- release_value_or_incref (value);
+ value_obj->value = release_value (value).release ();
value_obj->address = NULL;
value_obj->type = NULL;
value_obj->dynamic_type = NULL;
{
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);
gdb_py_longest length = -1;
struct value *value = ((value_object *) self)->value;
const char *user_encoding = NULL;
- static char *keywords[] = { "encoding", "length", NULL };
+ static const char *keywords[] = { "encoding", "length", NULL };
PyObject *str_obj = NULL;
- if (!PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG, keywords,
- &user_encoding, &length))
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG,
+ keywords, &user_encoding, &length))
return NULL;
if (length < -1)
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;
}
valpy_string (PyObject *self, PyObject *args, PyObject *kw)
{
int length = -1;
- gdb_byte *buffer;
+ gdb::unique_xmalloc_ptr<gdb_byte> buffer;
struct value *value = ((value_object *) self)->value;
- PyObject *unicode;
const char *encoding = NULL;
const char *errors = NULL;
const char *user_encoding = NULL;
const char *la_encoding = NULL;
struct type *char_type;
- static char *keywords[] = { "encoding", "errors", "length", NULL };
+ static const char *keywords[] = { "encoding", "errors", "length", NULL };
- if (!PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
- &user_encoding, &errors, &length))
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
+ &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;
- unicode = PyUnicode_Decode ((const char *) buffer,
- length * TYPE_LENGTH (char_type),
- encoding, errors);
- xfree (buffer);
+ return PyUnicode_Decode ((const char *) buffer.get (),
+ length * TYPE_LENGTH (char_type),
+ 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 unicode;
+ return PyUnicode_Decode (stb.c_str (), stb.size (), host_charset (), NULL);
}
/* A helper function that implements the various cast operators. */
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));
+ 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)
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 value *function = ((value_object *) self)->value;
struct value **vargs = NULL;
struct type *ftype = NULL;
- struct value *mark = value_mark ();
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;
- struct value *return_value;
- return_value = call_function_by_hand (function, args_count, vargs);
+ value *return_value
+ = call_function_by_hand (function, NULL,
+ 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));
if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
nonzero = !!value_as_long (self_value->value);
- else if (TYPE_CODE (type) == TYPE_CODE_FLT)
- nonzero = value_as_double (self_value->value) != 0;
- else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
- nonzero = !decimal_is_zero (value_contents (self_value->value),
- TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)));
+ else if (is_floating_value (self_value->value))
+ nonzero = !target_float_is_zero (value_contents (self_value->value),
+ type);
else
/* 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_integral_type (type))
+ if (is_floating_value (value))
+ {
+ type = builtin_type_pylong;
+ value = value_cast (type, value);
+ }
+
+ if (!is_integral_type (type)
+ && TYPE_CODE (type) != 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
- return gdb_py_object_from_longest (l);
+ if (TYPE_UNSIGNED (type))
+ return gdb_py_object_from_ulongest (l).release ();
+ else
+ return gdb_py_object_from_longest (l).release ();
}
#endif
struct type *type = value_type (value);
LONGEST l = 0;
- TRY
+ try
{
+ if (is_floating_value (value))
+ {
+ type = builtin_type_pylong;
+ value = value_cast (type, value);
+ }
+
type = check_typedef (type);
if (!is_integral_type (type)
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)
+ if (TYPE_CODE (type) == 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)
+ {
+ /* Note that valpy_long accepts TYPE_CODE_PTR and some
+ others here here -- but casting a pointer or bool to a
+ float seems wrong. */
+ d = value_as_long (value);
+ }
+ else
error (_("Cannot convert value to float."));
-
- d = value_as_double (value);
}
- CATCH (except, RETURN_MASK_ALL)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
- END_CATCH
return PyFloat_FromDouble (d);
}
val_obj = PyObject_New (value_object, &value_object_type);
if (val_obj != NULL)
{
- val_obj->value = val;
- release_value_or_incref (val);
+ val_obj->value = release_value (val).release ();
val_obj->address = NULL;
val_obj->type = NULL;
val_obj->dynamic_type = NULL;
gdb_assert (obj != NULL);
- TRY
+ try
{
if (PyBool_Check (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. */
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
double d = PyFloat_AsDouble (obj);
if (! PyErr_Occurred ())
- value = value_from_double (builtin_type_pyfloat, 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)
{
- PyErr_Format (except.reason == RETURN_QUIT
- ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
- "%s", except.message);
+ 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);
+ }
+
+ return value_to_value_object (res_val);
+}
+
+/* Return the value of a convenience variable. */
+PyObject *
+gdbpy_convenience_variable (PyObject *self, PyObject *args)
+{
+ const char *varname;
+ struct value *res_val = NULL;
+
+ if (!PyArg_ParseTuple (args, "s", &varname))
+ return NULL;
+
+ 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)
+ res_val = NULL;
+ }
+ }
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
- END_CATCH
+
+ if (res_val == NULL)
+ Py_RETURN_NONE;
return value_to_value_object (res_val);
}
+/* Set the value of a convenience variable. */
+PyObject *
+gdbpy_set_convenience_variable (PyObject *self, PyObject *args)
+{
+ const char *varname;
+ PyObject *value_obj;
+ struct value *value = NULL;
+
+ if (!PyArg_ParseTuple (args, "sO", &varname, &value_obj))
+ return NULL;
+
+ /* None means to clear the variable. */
+ if (value_obj != Py_None)
+ {
+ value = convert_value_from_python (value_obj);
+ if (value == NULL)
+ return NULL;
+ }
+
+ try
+ {
+ if (value == NULL)
+ {
+ struct internalvar *var = lookup_only_internalvar (varname);
+
+ if (var != NULL)
+ clear_internalvar (var);
+ }
+ else
+ {
+ struct internalvar *var = lookup_internalvar (varname);
+
+ set_internalvar (var, value);
+ }
+ }
+ catch (const gdb_exception &except)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+
+ Py_RETURN_NONE;
+}
+
/* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
int
\f
-static PyGetSetDef value_object_getset[] = {
+static gdb_PyGetSetDef value_object_getset[] = {
{ "address", valpy_get_address, NULL, "The address of the value.",
NULL },
{ "is_optimized_out", valpy_get_is_optimized_out, NULL,
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 */
};
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 = {
projects / deliverable / binutils-gdb.git / blobdiff