/* 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.
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);
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;
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;
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 unicode;
+ return PyUnicode_Decode ((const char *) buffer.get (),
+ length * TYPE_LENGTH (char_type),
+ encoding, errors);
}
/* A helper function that implements the various cast operators. */
TRY
{
scoped_value_mark free_values;
- struct value *return_value;
- return_value = call_function_by_hand (function, NULL,
- 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)
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);
}
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
TRY
{
+ if (is_floating_value (value))
+ {
+ type = builtin_type_pylong;
+ value = value_cast (type, value);
+ }
+
type = check_typedef (type);
if (!is_integral_type (type)
{
type = check_typedef (type);
- if (TYPE_CODE (type) != TYPE_CODE_FLT || !is_floating_value (value))
+ 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 = target_float_to_host_double (value_contents (value), type);
}
CATCH (except, RETURN_MASK_ALL)
{
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;
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
}
CATCH (except, RETURN_MASK_ALL)
{
- PyErr_Format (except.reason == RETURN_QUIT
- ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
- "%s", except.message);
+ gdbpy_convert_exception (except);
return NULL;
}
END_CATCH
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 (except, RETURN_MASK_ALL)
+ {
+ 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 (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
+ Py_RETURN_NONE;
+}
+
/* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
int
projects / deliverable / binutils-gdb.git / blobdiff