From 08c637dee28a25da97418745fbebb26b2fba8eef Mon Sep 17 00:00:00 2001 From: Thiago Jung Bauermann Date: Wed, 4 Feb 2009 21:55:40 +0000 Subject: [PATCH] gdb/ 2009-02-04 Tom Tromey Thiago Jung Bauermann Phil Muldoon * python/python-internal.h (gdbpy_get_value_from_history): Rename prototype to gdbpy_history. (gdbpy_is_string): Declare. (python_string_to_host_string): Declare. * python/python-utils.c (gdbpy_is_string): New function. (unicode_to_encoded_string): New function. (unicode_to_target_string): Use it. (python_string_to_host_string): New function. * python/python-value.c (valpy_address): New function. (convert_value_from_python): Use gdbpy_is_string. Change to throw Python exception instead of a GDB exception on error. Properly check Python booleans. (valpy_getitem): Convert field name to host string. Handle array accesses. Adapt to new behaviour of convert_value_from_python. (valpy_new): Adapt to new behaviour of convert_value_from_python. (enum valpy_opcode) : New constants. (valpy_binop): Update. Adapt to new behaviour of convert_value_from_python. (valpy_invert): New function. (valpy_lsh): Likewise. (valpy_rsh): Likewise. (valpy_and): Likewise. (valpy_or): Likewise. (valpy_xor): Likewise. (valpy_richcompare): Call convert_value_from_python instead of doing conversions itself. (is_intlike, valpy_int, valpy_long, valpy_float): New functions. (gdbpy_get_value_from_history): Rename function to gdbpy_history. (gdbpy_initialize_values): Don't set tp_new. (value_object_type): Add valpy_new. (value_object_methods): Add `address' entry. (value_object_as_number): Update for new methods. * python/python.c (GdbMethods): Rename entry from `get_value_from_history' to `history'. gdb/doc/ 2009-02-04 Tom Tromey * gdb.texinfo (Basic Python): Document gdb.history. gdb/testsuite/ 2009-02-04 Tom Tromey Thiago Jung Bauermann * gdb.python/python-value.exp: Use `gdb.history' instead of `gdb.value_from_history'. (test_value_numeric_ops): Add test for conversion of enum constant. * gdb.python/python-value.c (enum e): New type. (evalue): New global. (main): Use argv. --- gdb/ChangeLog | 41 +++ gdb/doc/ChangeLog | 4 + gdb/doc/gdb.texinfo | 15 + gdb/python/python-internal.h | 4 +- gdb/python/python-utils.c | 54 ++- gdb/python/python-value.c | 384 ++++++++++++++++------ gdb/python/python.c | 2 +- gdb/testsuite/ChangeLog | 10 + gdb/testsuite/gdb.python/python-value.c | 10 + gdb/testsuite/gdb.python/python-value.exp | 13 +- 10 files changed, 428 insertions(+), 109 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 7ef34c181fc..a83ec975c37 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,44 @@ +2009-02-04 Tom Tromey + Thiago Jung Bauermann + Phil Muldoon + + * python/python-internal.h (gdbpy_get_value_from_history): Rename + prototype to gdbpy_history. + (gdbpy_is_string): Declare. + (python_string_to_host_string): Declare. + * python/python-utils.c (gdbpy_is_string): New function. + (unicode_to_encoded_string): New function. + (unicode_to_target_string): Use it. + (python_string_to_host_string): New function. + * python/python-value.c (valpy_address): New function. + (convert_value_from_python): Use gdbpy_is_string. Change to throw + Python exception instead of a GDB exception on error. Properly check + Python booleans. + (valpy_getitem): Convert field name to host string. Handle array + accesses. Adapt to new behaviour of convert_value_from_python. + (valpy_new): Adapt to new behaviour of convert_value_from_python. + (enum valpy_opcode) : New constants. + (valpy_binop): Update. Adapt to new behaviour of + convert_value_from_python. + (valpy_invert): New function. + (valpy_lsh): Likewise. + (valpy_rsh): Likewise. + (valpy_and): Likewise. + (valpy_or): Likewise. + (valpy_xor): Likewise. + (valpy_richcompare): Call convert_value_from_python instead of doing + conversions itself. + (is_intlike, valpy_int, valpy_long, valpy_float): New functions. + (gdbpy_get_value_from_history): Rename + function to gdbpy_history. + (gdbpy_initialize_values): Don't set tp_new. + (value_object_type): Add valpy_new. + (value_object_methods): Add `address' entry. + (value_object_as_number): Update for new methods. + * python/python.c (GdbMethods): Rename entry from + `get_value_from_history' to `history'. + 2009-02-04 Jerome Guitton * ada-lang.c (ada_template_to_fixed_record_type_1): Check size diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index 69c9d20df66..677d74b9446 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,3 +1,7 @@ +2009-02-04 Tom Tromey + + * gdb.texinfo (Basic Python): Document gdb.history. + 2009-01-30 Vladimir Prus * gdb.texinfo (GDB/MI Thread Commands): Document the diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 166b84d5798..884f50b7d16 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -18097,6 +18097,21 @@ If the named parameter does not exist, this function throws a a Python value of the appropriate type, and returned. @end defun +@findex gdb.history +@defun history number +Return a value from @value{GDBN}'s value history (@pxref{Value +History}). @var{number} indicates which history element to return. +If @var{number} is negative, then @value{GDBN} will take its absolute value +and count backward from the last element (i.e., the most recent element) to +find the value to return. If @var{number} is zero, then @value{GDBN} will +return the most recent element. If the element specified by @value{number} +doesn't exist in the value history, a @code{RuntimeError} exception will be +raised. + +If no exception is raised, the return value is always an instance of +@code{gdb.Value} (@pxref{Values From Inferior}). +@end defun + @findex gdb.write @defun write string Print a string to @value{GDBN}'s paginated standard output stream. diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h index 4e9da3388ae..672d8a41e5d 100644 --- a/gdb/python/python-internal.h +++ b/gdb/python/python-internal.h @@ -63,7 +63,7 @@ struct value; extern PyObject *gdb_module; extern PyTypeObject value_object_type; -PyObject *gdbpy_get_value_from_history (PyObject *self, PyObject *args); +PyObject *gdbpy_history (PyObject *self, PyObject *args); PyObject *value_to_value_object (struct value *v); @@ -90,5 +90,7 @@ void gdbpy_print_stack (void); PyObject *python_string_to_unicode (PyObject *obj); char *unicode_to_target_string (PyObject *unicode_str); char *python_string_to_target_string (PyObject *obj); +char *python_string_to_host_string (PyObject *obj); +int gdbpy_is_string (PyObject *obj); #endif /* GDB_PYTHON_INTERNAL_H */ diff --git a/gdb/python/python-utils.c b/gdb/python/python-utils.c index 9aae43f889d..6a959397b60 100644 --- a/gdb/python/python-utils.c +++ b/gdb/python/python-utils.c @@ -95,26 +95,37 @@ python_string_to_unicode (PyObject *obj) } /* Returns a newly allocated string with the contents of the given unicode - string object converted to the target's charset. If an error occurs during - the conversion, NULL will be returned and a python exception will be set. + string object converted to CHARSET. If an error occurs during the + conversion, NULL will be returned and a python exception will be set. The caller is responsible for xfree'ing the string. */ -char * -unicode_to_target_string (PyObject *unicode_str) +static char * +unicode_to_encoded_string (PyObject *unicode_str, const char *charset) { - char *target_string; + char *result; PyObject *string; - /* Translate string to target's charset. */ - string = PyUnicode_AsEncodedString (unicode_str, target_charset (), NULL); + /* Translate string to named charset. */ + string = PyUnicode_AsEncodedString (unicode_str, charset, NULL); if (string == NULL) return NULL; - target_string = xstrdup (PyString_AsString (string)); + result = xstrdup (PyString_AsString (string)); Py_DECREF (string); - return target_string; + return result; +} + +/* Returns a newly allocated string with the contents of the given unicode + string object converted to the target's charset. If an error occurs during + the conversion, NULL will be returned and a python exception will be set. + + The caller is responsible for xfree'ing the string. */ +char * +unicode_to_target_string (PyObject *unicode_str) +{ + return unicode_to_encoded_string (unicode_str, target_charset ()); } /* Converts a python string (8-bit or unicode) to a target string in @@ -132,3 +143,28 @@ python_string_to_target_string (PyObject *obj) return unicode_to_target_string (str); } + +/* Converts a python string (8-bit or unicode) to a target string in + the host's charset. Returns NULL on error, with a python exception set. + + The caller is responsible for xfree'ing the string. */ +char * +python_string_to_host_string (PyObject *obj) +{ + PyObject *str; + + str = python_string_to_unicode (obj); + if (str == NULL) + return NULL; + + return unicode_to_encoded_string (str, host_charset ()); +} + +/* Return true if OBJ is a Python string or unicode object, false + otherwise. */ + +int +gdbpy_is_string (PyObject *obj) +{ + return PyString_Check (obj) || PyUnicode_Check (obj); +} diff --git a/gdb/python/python-value.c b/gdb/python/python-value.c index 92e0431dcda..420d26f163c 100644 --- a/gdb/python/python-value.c +++ b/gdb/python/python-value.c @@ -18,6 +18,7 @@ along with this program. If not, see . */ #include "defs.h" +#include "gdb_assert.h" #include "charset.h" #include "value.h" #include "exceptions.h" @@ -79,7 +80,6 @@ valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) { struct value *value = NULL; /* Initialize to appease gcc warning. */ value_object *value_obj; - volatile struct gdb_exception except; if (PyTuple_Size (args) != 1) { @@ -96,16 +96,11 @@ valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) return NULL; } - TRY_CATCH (except, RETURN_MASK_ALL) - { - value = convert_value_from_python (PyTuple_GetItem (args, 0)); - } - if (except.reason < 0) + value = convert_value_from_python (PyTuple_GetItem (args, 0)); + if (value == NULL) { subtype->tp_free (value_obj); - return PyErr_Format (except.reason == RETURN_QUIT - ? PyExc_KeyboardInterrupt : PyExc_TypeError, - "%s", except.message); + return NULL; } value_obj->value = value; @@ -132,6 +127,22 @@ valpy_dereference (PyObject *self, PyObject *args) return value_to_value_object (res_val); } +/* Return "&value". */ +static PyObject * +valpy_address (PyObject *self, PyObject *args) +{ + struct value *res_val = NULL; /* Initialize to appease gcc warning. */ + volatile struct gdb_exception except; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + res_val = value_addr (((value_object *) self)->value); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return value_to_value_object (res_val); +} + static Py_ssize_t valpy_length (PyObject *self) { @@ -147,26 +158,40 @@ static PyObject * valpy_getitem (PyObject *self, PyObject *key) { value_object *self_value = (value_object *) self; - char *field; + char *field = NULL; + struct value *idx = NULL; struct value *res_val = NULL; /* Initialize to appease gcc warning. */ - struct cleanup *old; volatile struct gdb_exception except; - field = python_string_to_target_string (key); - if (field == NULL) - return NULL; - - old = make_cleanup (xfree, field); + if (gdbpy_is_string (key)) + { + field = python_string_to_host_string (key); + if (field == NULL) + return NULL; + } TRY_CATCH (except, RETURN_MASK_ALL) { struct value *tmp = self_value->value; - res_val = value_struct_elt (&tmp, NULL, field, 0, NULL); + + if (field) + res_val = value_struct_elt (&tmp, NULL, field, 0, NULL); + else + { + /* Assume we are attempting an array access, and let the + value code throw an exception if the index has an invalid + type. */ + struct value *idx = convert_value_from_python (key); + if (idx == NULL) + return NULL; + + res_val = value_subscript (tmp, idx); + } } + if (field) + xfree (field); GDB_PY_HANDLE_EXCEPTION (except); - do_cleanups (old); - return value_to_value_object (res_val); } @@ -220,7 +245,12 @@ enum valpy_opcode VALPY_MUL, VALPY_DIV, VALPY_REM, - VALPY_POW + VALPY_POW, + VALPY_LSH, + VALPY_RSH, + VALPY_BITAND, + VALPY_BITOR, + VALPY_BITXOR }; /* If TYPE is a reference, return the target; otherwise return TYPE. */ @@ -244,7 +274,12 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) kind of object, altogether. Because of this, we can't assume self is a gdb.Value object and need to convert it from python as well. */ arg1 = convert_value_from_python (self); + if (arg1 == NULL) + return NULL; + arg2 = convert_value_from_python (other); + if (arg2 == NULL) + return NULL; switch (opcode) { @@ -302,6 +337,21 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) case VALPY_POW: res_val = value_binop (arg1, arg2, BINOP_EXP); break; + case VALPY_LSH: + res_val = value_binop (arg1, arg2, BINOP_LSH); + break; + case VALPY_RSH: + res_val = value_binop (arg1, arg2, BINOP_RSH); + break; + case VALPY_BITAND: + res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND); + break; + case VALPY_BITOR: + res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR); + break; + case VALPY_BITXOR: + res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR); + break; } } GDB_PY_HANDLE_EXCEPTION (except); @@ -412,45 +462,66 @@ valpy_nonzero (PyObject *self) } } -/* Implements comparison operations for value objects. */ +/* Implements ~ for value objects. */ static PyObject * -valpy_richcompare (PyObject *self, PyObject *other, int op) +valpy_invert (PyObject *self) { - int result = 0; - struct value *value_self, *value_other; + struct value *val = NULL; volatile struct gdb_exception except; - if (PyObject_TypeCheck (other, &value_object_type)) - value_other = ((value_object *) other)->value; - else if (PyInt_Check (other)) + TRY_CATCH (except, RETURN_MASK_ALL) { - LONGEST l; + val = value_complement (((value_object *) self)->value); + } + GDB_PY_HANDLE_EXCEPTION (except); - l = PyInt_AsLong (other); - if (PyErr_Occurred ()) - return NULL; + return value_to_value_object (val); +} - value_other = value_from_longest (builtin_type_pyint, l); - } - else if (PyFloat_Check (other)) - { - DOUBLEST d; +/* Implements left shift for value objects. */ +static PyObject * +valpy_lsh (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_LSH, self, other); +} - d = PyFloat_AsDouble (other); - if (PyErr_Occurred ()) - return NULL; +/* Implements right shift for value objects. */ +static PyObject * +valpy_rsh (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_RSH, self, other); +} - value_other = value_from_double (builtin_type_pyfloat, d); - } - else if (PyString_Check (other) || PyUnicode_Check (other)) - { - char *str; +/* Implements bitwise and for value objects. */ +static PyObject * +valpy_and (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_BITAND, self, other); +} - str = python_string_to_target_string (other); - value_other = value_from_string (str); - xfree (str); - } - else if (other == Py_None) +/* Implements bitwise or for value objects. */ +static PyObject * +valpy_or (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_BITOR, self, other); +} + +/* Implements bitwise xor for value objects. */ +static PyObject * +valpy_xor (PyObject *self, PyObject *other) +{ + return valpy_binop (VALPY_BITXOR, self, other); +} + +/* Implements comparison operations for value objects. */ +static PyObject * +valpy_richcompare (PyObject *self, PyObject *other, int op) +{ + int result = 0; + struct value *value_other; + volatile struct gdb_exception except; + + if (other == Py_None) /* Comparing with None is special. From what I can tell, in Python None is smaller than anything else. */ switch (op) { @@ -468,15 +539,13 @@ valpy_richcompare (PyObject *self, PyObject *other, int op) "Invalid operation on gdb.Value."); return NULL; } - else - { - PyErr_SetString (PyExc_NotImplementedError, - "Operation not supported on gdb.Value of this type."); - return NULL; - } TRY_CATCH (except, RETURN_MASK_ALL) { + value_other = convert_value_from_python (other); + if (value_other == NULL) + return NULL; + switch (op) { case Py_LT: result = value_less (((value_object *) self)->value, value_other); @@ -513,6 +582,92 @@ valpy_richcompare (PyObject *self, PyObject *other, int op) Py_RETURN_FALSE; } +/* Helper function to determine if a type is "int-like". */ +static int +is_intlike (struct type *type, int ptr_ok) +{ + CHECK_TYPEDEF (type); + return (TYPE_CODE (type) == TYPE_CODE_INT + || TYPE_CODE (type) == TYPE_CODE_ENUM + || TYPE_CODE (type) == TYPE_CODE_BOOL + || TYPE_CODE (type) == TYPE_CODE_CHAR + || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR)); +} + +/* Implements conversion to int. */ +static PyObject * +valpy_int (PyObject *self) +{ + struct value *value = ((value_object *) self)->value; + struct type *type = value_type (value); + LONGEST l = 0; + volatile struct gdb_exception except; + + CHECK_TYPEDEF (type); + if (!is_intlike (type, 0)) + { + PyErr_SetString (PyExc_RuntimeError, "cannot convert value to int"); + return NULL; + } + + TRY_CATCH (except, RETURN_MASK_ALL) + { + l = value_as_long (value); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return PyInt_FromLong (l); +} + +/* Implements conversion to long. */ +static PyObject * +valpy_long (PyObject *self) +{ + struct value *value = ((value_object *) self)->value; + struct type *type = value_type (value); + LONGEST l = 0; + volatile struct gdb_exception except; + + if (!is_intlike (type, 1)) + { + PyErr_SetString (PyExc_RuntimeError, "cannot convert value to long"); + return NULL; + } + + TRY_CATCH (except, RETURN_MASK_ALL) + { + l = value_as_long (value); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return PyLong_FromLong (l); +} + +/* Implements conversion to float. */ +static PyObject * +valpy_float (PyObject *self) +{ + struct value *value = ((value_object *) self)->value; + struct type *type = value_type (value); + double d = 0; + volatile struct gdb_exception except; + + CHECK_TYPEDEF (type); + if (TYPE_CODE (type) != TYPE_CODE_FLT) + { + PyErr_SetString (PyExc_RuntimeError, "cannot convert value to float"); + return NULL; + } + + TRY_CATCH (except, RETURN_MASK_ALL) + { + d = value_as_double (value); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return PyFloat_FromDouble (d); +} + /* Returns an object for a value which is released from the all_values chain, so its lifetime is not bound to the execution of a command. */ PyObject * @@ -533,7 +688,7 @@ value_to_value_object (struct value *val) } /* Try to convert a Python value to a gdb value. If the value cannot - be converted, throw a gdb exception. */ + be converted, set a Python exception and return NULL. */ struct value * convert_value_from_python (PyObject *obj) @@ -541,53 +696,72 @@ convert_value_from_python (PyObject *obj) struct value *value = NULL; /* -Wall */ PyObject *target_str, *unicode_str; struct cleanup *old; + volatile struct gdb_exception except; + int cmp; - if (! obj) - error (_("Internal error while converting Python value.")); + gdb_assert (obj != NULL); - if (PyBool_Check (obj)) - value = value_from_longest (builtin_type_pybool, obj == Py_True); - else if (PyInt_Check (obj)) - value = value_from_longest (builtin_type_pyint, PyInt_AsLong (obj)); - else if (PyLong_Check (obj)) - { - LONGEST l = PyLong_AsLongLong (obj); - if (! PyErr_Occurred ()) - value = value_from_longest (builtin_type_pylong, l); - } - else if (PyFloat_Check (obj)) - { - double d = PyFloat_AsDouble (obj); - if (! PyErr_Occurred ()) - value = value_from_double (builtin_type_pyfloat, d); - } - else if (PyString_Check (obj) || PyUnicode_Check (obj)) + TRY_CATCH (except, RETURN_MASK_ALL) { - char *s; + if (PyBool_Check (obj)) + { + cmp = PyObject_IsTrue (obj); + if (cmp >= 0) + value = value_from_longest (builtin_type_pybool, cmp); + } + else if (PyInt_Check (obj)) + { + long l = PyInt_AsLong (obj); - s = python_string_to_target_string (obj); - if (s == NULL) - return NULL; + if (! PyErr_Occurred ()) + value = value_from_longest (builtin_type_pyint, l); + } + else if (PyLong_Check (obj)) + { + LONGEST l = PyLong_AsLongLong (obj); - old = make_cleanup (xfree, s); - value = value_from_string (s); - do_cleanups (old); - } - else if (PyObject_TypeCheck (obj, &value_object_type)) - value = ((value_object *) obj)->value; - else - error (_("Could not convert Python object: %s"), - PyString_AsString (PyObject_Str (obj))); + if (! PyErr_Occurred ()) + value = value_from_longest (builtin_type_pylong, l); + } + else if (PyFloat_Check (obj)) + { + double d = PyFloat_AsDouble (obj); - if (PyErr_Occurred ()) - error (_("Error converting Python value.")); + if (! PyErr_Occurred ()) + value = value_from_double (builtin_type_pyfloat, d); + } + else if (gdbpy_is_string (obj)) + { + char *s; + + s = python_string_to_target_string (obj); + if (s != NULL) + { + old = make_cleanup (xfree, s); + value = value_from_string (s); + do_cleanups (old); + } + } + else if (PyObject_TypeCheck (obj, &value_object_type)) + value = ((value_object *) obj)->value; + else + PyErr_Format (PyExc_TypeError, _("Could not convert Python object: %s"), + PyString_AsString (PyObject_Str (obj))); + } + if (except.reason < 0) + { + PyErr_Format (except.reason == RETURN_QUIT + ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, + "%s", except.message); + return NULL; + } return value; } /* Returns value object in the ARGth position in GDB's history. */ PyObject * -gdbpy_get_value_from_history (PyObject *self, PyObject *args) +gdbpy_history (PyObject *self, PyObject *args) { int i; struct value *res_val = NULL; /* Initialize to appease gcc warning. */ @@ -608,7 +782,6 @@ gdbpy_get_value_from_history (PyObject *self, PyObject *args) void gdbpy_initialize_values (void) { - value_object_type.tp_new = valpy_new; if (PyType_Ready (&value_object_type) < 0) return; @@ -619,6 +792,7 @@ gdbpy_initialize_values (void) } static PyMethodDef value_object_methods[] = { + { "address", valpy_address, METH_NOARGS, "Return the address of the value." }, { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." }, {NULL} /* Sentinel */ }; @@ -634,7 +808,19 @@ static PyNumberMethods value_object_as_number = { valpy_negative, /* nb_negative */ valpy_positive, /* nb_positive */ valpy_absolute, /* nb_absolute */ - valpy_nonzero /* nb_nonzero */ + valpy_nonzero, /* nb_nonzero */ + valpy_invert, /* nb_invert */ + valpy_lsh, /* nb_lshift */ + valpy_rsh, /* nb_rshift */ + valpy_and, /* nb_and */ + valpy_xor, /* nb_xor */ + valpy_or, /* nb_or */ + NULL, /* nb_coerce */ + valpy_int, /* nb_int */ + valpy_long, /* nb_long */ + valpy_float, /* nb_float */ + NULL, /* nb_oct */ + NULL /* nb_hex */ }; static PyMappingMethods value_object_as_mapping = { @@ -672,7 +858,17 @@ PyTypeObject value_object_type = { 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ - value_object_methods /* tp_methods */ + value_object_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + valpy_new /* tp_new */ }; #endif /* HAVE_PYTHON */ diff --git a/gdb/python/python.c b/gdb/python/python.c index e778ac4f827..991321f3be0 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -52,7 +52,7 @@ static PyObject *gdbpy_flush (PyObject *, PyObject *); static PyMethodDef GdbMethods[] = { - { "get_value_from_history", gdbpy_get_value_from_history, METH_VARARGS, + { "history", gdbpy_history, METH_VARARGS, "Get a value from history" }, { "execute", execute_gdb_command, METH_VARARGS, "Execute a gdb command" }, diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 6600b06d8c4..7fce5208125 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,13 @@ +2009-02-04 Tom Tromey + Thiago Jung Bauermann + + * gdb.python/python-value.exp: Use `gdb.history' instead of + `gdb.value_from_history'. + (test_value_numeric_ops): Add test for conversion of enum constant. + * gdb.python/python-value.c (enum e): New type. + (evalue): New global. + (main): Use argv. + 2009-02-04 Jerome Guitton * gdb.ada/uninitialized_vars: New test program. diff --git a/gdb/testsuite/gdb.python/python-value.c b/gdb/testsuite/gdb.python/python-value.c index 8c109565d2e..17e5c622a22 100644 --- a/gdb/testsuite/gdb.python/python-value.c +++ b/gdb/testsuite/gdb.python/python-value.c @@ -27,6 +27,14 @@ union u float b; }; +enum e + { + ONE = 1, + TWO = 2 + }; + +enum e evalue = TWO; + int main (int argc, char *argv[]) { @@ -37,5 +45,7 @@ main (int argc, char *argv[]) s.b = 5; u.a = 7; + argv[0][0] = 'a'; /* Just to avoid getting argv optimized out. */ + return 0; /* break to inspect struct and union */ } diff --git a/gdb/testsuite/gdb.python/python-value.exp b/gdb/testsuite/gdb.python/python-value.exp index 2057e61d8f4..8f5e0ab53fd 100644 --- a/gdb/testsuite/gdb.python/python-value.exp +++ b/gdb/testsuite/gdb.python/python-value.exp @@ -111,13 +111,18 @@ proc test_value_numeric_ops {} { gdb_test "python print 'result = ' + str(1-i)" " = -4" "subtract python integer from integer value" gdb_test "python print 'result = ' + str(1.5+f)" " = 2.75" "add python float with double value" + # Conversion test. + gdb_test "print evalue" " = TWO" + gdb_test "python evalue = gdb.history (0)" "" + gdb_test "python print int (evalue)" "2" + # Test pointer arithmethic # First, obtain the pointers gdb_test "print (void *) 2" "" "" - gdb_test "python a = gdb.get_value_from_history (0)" "" "" + gdb_test "python a = gdb.history (0)" "" "" gdb_test "print (void *) 5" "" "" - gdb_test "python b = gdb.get_value_from_history (0)" "" "" + gdb_test "python b = gdb.history (0)" "" "" gdb_test "python print 'result = ' + str(a+5)" " = 0x7" "add pointer value with python integer" gdb_test "python print 'result = ' + str(b-2)" " = 0x3" "subtract python integer from pointer value" @@ -205,7 +210,7 @@ proc test_value_in_inferior {} { # Just get inferior variable s in the value history, available to python. gdb_test "print s" " = {a = 3, b = 5}" "" - gdb_py_test_silent_cmd "python s = gdb.get_value_from_history (0)" "get value from history" 1 + gdb_py_test_silent_cmd "python s = gdb.history (0)" "get value from history" 1 gdb_test "python print 'result = ' + str(s\['a'\])" " = 3" "access element inside struct using 8-bit string name" gdb_test "python print 'result = ' + str(s\[u'a'\])" " = 3" "access element inside struct using unicode name" @@ -215,7 +220,7 @@ proc test_value_in_inferior {} { # Just get inferior variable argv the value history, available to python. gdb_test "print argv" " = \\(char \\*\\*\\) 0x.*" "" - gdb_py_test_silent_cmd "python argv = gdb.get_value_from_history (0)" "" 0 + gdb_py_test_silent_cmd "python argv = gdb.history (0)" "" 0 gdb_py_test_silent_cmd "python arg0 = argv.dereference ()" "dereference value" 1 # Check that the dereferenced value is sane -- 2.30.2