From be759fcf73cbf7ac59863c57389cd97c70c09a47 Mon Sep 17 00:00:00 2001 From: Phil Muldoon Date: Thu, 14 Jan 2010 08:03:37 +0000 Subject: 2010-01-13 Phil Muldoon PR python/10705 * python/python-internal.h: Add lazy_string_object_type definition. (create_lazy_string_object, gdbpy_initialize_lazy_string) (gdbpy_is_lazystring, gdbpy_extract_lazy_string): Define. * python/py-value.c (valpy_lazy_string): New function. (convert_value_from_python): Add lazy string conversion. * python/py-prettyprint.c (pretty_print_one_value): Check if return is also a lazy string. (print_string_repr): Add lazy string printing branch. (print_children): Likewise. * python/py-lazy-string.c: New file. Implement lazy strings. * python/python.c (_initialize_python): Call gdbpy_initialize_lazy_string. * varobj.c (value_get_print_value): Add lazy string printing branch. Account for encoding. * c-lang.c (c_printstr): Account for new encoding argument. If encoding is NULL, find encoding suited for type, otherwise use user encoding. * language.h (language_defn): Add encoding argument. (LA_PRINT_STRING): Likewise. * language.c (unk_lang_printstr): Update to reflect new encoding argument to language_defn. * ada-lang.h (ada_printstr): Likewise. * c-lang.h (c_printstr): Likewise. * p-lang.h (pascal_printstr); * f-lang.c (f_printstr): Likewise. * m2-lang.c (m2_printstr): Likewise. * objc-lang.c (objc_printstr): Likewise. * p-lang.c (pascal_printstr): Likewise. * scm-lang.c (scm_printstr): Likewise. * c-valprint.c (c_val_print): Update LA_PRINT_STRING call for encoding argument. * ada-valprint.c (ada_printstr): Likewise. * f-valprint.c (f_val_print): Likewise * m2-valprint.c (m2_val_print): Likewise. * p-valprint.c (pascal_val_print): Likewise. * expprint.c (print_subexp_standard): Likewise. * valprint.c (val_print_string): Likewise. * Makefile.in (SUBDIR_PYTHON_OBS): Add py-lazy-string. (SUBDIR_PYTHON_SRCS): Likewise. (py-lazy-string.o): New rule. 2010-01-13 Phil Muldoon * gdb.texinfo (Values From Inferior): Document lazy_string value method. (Python API): Add Lazy strings menu item. (Lazy Strings In Python): New node. 2010-01-13 Phil Muldoon * gdb.python/py-value.exp (test_lazy_strings): Add lazy string test. * gdb.python/py-prettyprint.py (pp_ls): New printer. * gdb.python/py-prettyprint.exp (run_lang_tests): Add lazy string test. * gdb.python/py-prettyprint.c: Define lazystring test structure. * gdb.python/py-mi.exp: Add lazy string test. --- gdb/python/py-value.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) (limited to 'gdb/python/py-value.c') diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c index af649b0..a792819 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -220,6 +220,36 @@ valpy_get_type (PyObject *self, void *closure) return obj->type; } +/* Implementation of gdb.Value.lazy_string ([encoding] [, length]) -> + string. Return a PyObject representing a lazy_string_object type. + A lazy string is a pointer to a string with an optional encoding and + length. If ENCODING is not given, encoding is set to None. If an + ENCODING is provided the encoding parameter is set to ENCODING, but + the string is not encoded. If LENGTH is provided then the length + parameter is set to LENGTH, otherwise length will be set to -1 (first + null of appropriate with). */ +static PyObject * +valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw) +{ + int length = -1; + struct value *value = ((value_object *) self)->value; + const char *user_encoding = NULL; + static char *keywords[] = { "encoding", "length", NULL }; + PyObject *str_obj; + + if (!PyArg_ParseTupleAndKeywords (args, kw, "|si", keywords, + &user_encoding, &length)) + return NULL; + + if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR) + value = value_ind (value); + + str_obj = gdbpy_create_lazy_string_object (value_address (value), length, + user_encoding, value_type (value)); + + return (PyObject *) str_obj; +} + /* Implementation of gdb.Value.string ([encoding] [, errors] [, length]) -> string. Return Unicode string with value contents. If ENCODING is not given, the string is assumed to be encoded in @@ -939,6 +969,13 @@ convert_value_from_python (PyObject *obj) } else if (PyObject_TypeCheck (obj, &value_object_type)) value = value_copy (((value_object *) obj)->value); + else if (gdbpy_is_lazy_string (obj)) + { + PyObject *result; + PyObject *function = PyString_FromString ("value"); + result = PyObject_CallMethodObjArgs (obj, function, NULL); + value = value_copy (((value_object *) result)->value); + } else PyErr_Format (PyExc_TypeError, _("Could not convert Python object: %s"), PyString_AsString (PyObject_Str (obj))); @@ -1001,6 +1038,9 @@ static PyGetSetDef value_object_getset[] = { static PyMethodDef value_object_methods[] = { { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." }, { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." }, + { "lazy_string", (PyCFunction) valpy_lazy_string, METH_VARARGS | METH_KEYWORDS, + "lazy_string ([encoding] [, length]) -> lazy_string\n\ +Return a lazy string representation of the value." }, { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS, "string ([encoding] [, errors] [, length]) -> string\n\ Return Unicode string representation of the value." }, -- cgit v1.1