/* Python pretty-printing
- Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2008-2013 Free Software Foundation, Inc.
This file is part of GDB.
#ifdef HAVE_PYTHON
#include "python-internal.h"
+/* Return type of print_string_repr. */
+
+enum string_repr_result
+ {
+ /* The string method returned None. */
+ string_repr_none,
+ /* The string method had an error. */
+ string_repr_error,
+ /* Everything ok. */
+ string_repr_ok
+ };
+
/* Helper function for find_pretty_printer which iterates over a list,
calls each function and inspects output. This will return a
printer object if one recognizes VALUE. If no printer is found, it
if (!attr)
return NULL;
cmp = PyObject_IsTrue (attr);
+ Py_DECREF (attr);
if (cmp == -1)
return NULL;
if (function != Py_None)
return function;
-
+
Py_DECREF (function);
}
PyObject *pp_list;
PyObject *function;
- /* Fetch the global pretty printer dictionary. */
- if (! PyObject_HasAttrString (gdb_module, "pretty_printers"))
+ /* Fetch the global pretty printer list. */
+ if (gdb_python_module == NULL
+ || ! PyObject_HasAttrString (gdb_python_module, "pretty_printers"))
Py_RETURN_NONE;
- pp_list = PyObject_GetAttrString (gdb_module, "pretty_printers");
+ pp_list = PyObject_GetAttrString (gdb_python_module, "pretty_printers");
if (pp_list == NULL || ! PyList_Check (pp_list))
{
Py_XDECREF (pp_list);
{
PyObject *function;
- /* Look at the pretty-printer dictionary for each objfile
+ /* Look at the pretty-printer list for each objfile
in the current program-space. */
function = find_pretty_printer_from_objfiles (value);
if (function == NULL || function != Py_None)
return function;
Py_DECREF (function);
- /* Look at the pretty-printer dictionary for the current program-space. */
+ /* Look at the pretty-printer list for the current program-space. */
function = find_pretty_printer_from_progspace (value);
if (function == NULL || function != Py_None)
return function;
Py_DECREF (function);
- /* Look at the pretty-printer dictionary in the gdb module. */
+ /* Look at the pretty-printer list in the gdb module. */
function = find_pretty_printer_from_gdb (value);
return function;
}
result = PyObject_CallMethodObjArgs (printer, gdbpy_to_string_cst, NULL);
if (result)
{
- if (! gdbpy_is_string (result) && ! gdbpy_is_lazy_string (result)
+ if (! gdbpy_is_string (result) && ! gdbpy_is_lazy_string (result)
&& result != Py_None)
{
*out_value = convert_value_from_python (result);
return result;
}
+/* A wrapper for gdbpy_print_stack that ignores MemoryError. */
+
+static void
+print_stack_unless_memory_error (struct ui_file *stream)
+{
+ if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
+ {
+ struct cleanup *cleanup;
+ PyObject *type, *value, *trace;
+ char *msg;
+
+ PyErr_Fetch (&type, &value, &trace);
+ cleanup = make_cleanup_py_decref (type);
+ make_cleanup_py_decref (value);
+ make_cleanup_py_decref (trace);
+
+ msg = gdbpy_exception_to_string (type, value);
+ make_cleanup (xfree, msg);
+
+ if (msg == NULL || *msg == '\0')
+ fprintf_filtered (stream, _("<error reading variable>"));
+ else
+ fprintf_filtered (stream, _("<error reading variable: %s>"), msg);
+
+ do_cleanups (cleanup);
+ }
+ else
+ gdbpy_print_stack ();
+}
+
/* Helper for apply_val_pretty_printer which calls to_string and
- formats the result. If the value returnd is Py_None, nothing is
- printed and the function returns a 1; in all other cases data is
- printed as given by the pretty printer and the function returns 0.
-*/
-static int
+ formats the result. */
+
+static enum string_repr_result
print_string_repr (PyObject *printer, const char *hint,
struct ui_file *stream, int recurse,
const struct value_print_options *options,
{
struct value *replacement = NULL;
PyObject *py_str = NULL;
- int is_py_none = 0;
+ enum string_repr_result result = string_repr_ok;
py_str = pretty_print_one_value (printer, &replacement);
if (py_str)
{
+ struct cleanup *cleanup = make_cleanup_py_decref (py_str);
+
if (py_str == Py_None)
- is_py_none = 1;
- else
+ result = string_repr_none;
+ else if (gdbpy_is_lazy_string (py_str))
{
- gdb_byte *output = NULL;
+ CORE_ADDR addr;
long length;
struct type *type;
char *encoding = NULL;
- PyObject *string = NULL;
- int is_lazy;
+ struct value_print_options local_opts = *options;
- is_lazy = gdbpy_is_lazy_string (py_str);
- if (is_lazy)
- output = gdbpy_extract_lazy_string (py_str, &type, &length, &encoding);
- else
- {
- string = python_string_to_target_python_string (py_str);
- if (string)
- {
- output = PyString_AsString (string);
- length = PyString_Size (string);
- type = builtin_type (gdbarch)->builtin_char;
- }
- else
- gdbpy_print_stack ();
-
- }
-
- if (output)
+ make_cleanup (free_current_contents, &encoding);
+ gdbpy_extract_lazy_string (py_str, &addr, &type,
+ &length, &encoding);
+
+ local_opts.addressprint = 0;
+ val_print_string (type, encoding, addr, (int) length,
+ stream, &local_opts);
+ }
+ else
+ {
+ PyObject *string;
+
+ string = python_string_to_target_python_string (py_str);
+ if (string)
{
- if (is_lazy || (hint && !strcmp (hint, "string")))
- LA_PRINT_STRING (stream, type, output, length, encoding,
- 0, options);
+ char *output;
+ long length;
+ struct type *type;
+
+ make_cleanup_py_decref (string);
+#ifdef IS_PY3K
+ output = PyBytes_AS_STRING (string);
+ length = PyBytes_GET_SIZE (string);
+#else
+ output = PyString_AsString (string);
+ length = PyString_Size (string);
+#endif
+ type = builtin_type (gdbarch)->builtin_char;
+
+ if (hint && !strcmp (hint, "string"))
+ LA_PRINT_STRING (stream, type, (gdb_byte *) output,
+ length, NULL, 0, options);
else
fputs_filtered (output, stream);
}
else
- gdbpy_print_stack ();
-
- if (string)
- Py_DECREF (string);
- else
- xfree (output);
-
- xfree (encoding);
- Py_DECREF (py_str);
+ {
+ result = string_repr_error;
+ print_stack_unless_memory_error (stream);
+ }
}
+
+ do_cleanups (cleanup);
}
else if (replacement)
{
common_val_print (replacement, stream, recurse, &opts, language);
}
else
- gdbpy_print_stack ();
+ {
+ result = string_repr_error;
+ print_stack_unless_memory_error (stream);
+ }
- return is_py_none;
+ return result;
}
+#ifndef IS_PY3K
static void
py_restore_tstate (void *p)
{
/* Create a dummy PyFrameObject, needed to work around
a Python-2.4 bug with generators. */
static PyObject *
-push_dummy_python_frame ()
+push_dummy_python_frame (void)
{
PyObject *empty_string, *null_tuple, *globals;
PyCodeObject *code;
make_cleanup (py_restore_tstate, frame->f_back);
return (PyObject *) frame;
}
+#endif
/* Helper for apply_val_pretty_printer that formats children of the
printer, if any exist. If is_py_none is true, then nothing has
{
int is_map, is_array, done_flag, pretty;
unsigned int i;
- PyObject *children, *iter, *frame;
+ PyObject *children, *iter;
+#ifndef IS_PY3K
+ PyObject *frame;
+#endif
struct cleanup *cleanups;
if (! PyObject_HasAttr (printer, gdbpy_children_cst))
NULL);
if (! children)
{
- gdbpy_print_stack ();
+ print_stack_unless_memory_error (stream);
return;
}
iter = PyObject_GetIter (children);
if (!iter)
{
- gdbpy_print_stack ();
+ print_stack_unless_memory_error (stream);
goto done;
}
make_cleanup_py_decref (iter);
- /* Use the prettyprint_arrays option if we are printing an array,
+ /* Use the prettyformat_arrays option if we are printing an array,
and the pretty option otherwise. */
- pretty = is_array ? options->prettyprint_arrays : options->pretty;
+ if (is_array)
+ pretty = options->prettyformat_arrays;
+ else
+ {
+ if (options->prettyformat == Val_prettyformat)
+ pretty = 1;
+ else
+ pretty = options->prettyformat_structs;
+ }
/* Manufacture a dummy Python frame to work around Python 2.4 bug,
where it insists on having a non-NULL tstate->frame when
a generator is called. */
+#ifndef IS_PY3K
frame = push_dummy_python_frame ();
if (!frame)
{
goto done;
}
make_cleanup_py_decref (frame);
+#endif
done_flag = 0;
for (i = 0; i < options->print_max; ++i)
{
PyObject *py_v, *item = PyIter_Next (iter);
- char *name;
+ const char *name;
struct cleanup *inner_cleanup;
if (! item)
{
if (PyErr_Occurred ())
- gdbpy_print_stack ();
+ print_stack_unless_memory_error (stream);
/* Set a flag so we can know whether we printed all the
available elements. */
- else
+ else
done_flag = 1;
break;
}
fputs_filtered (" = ", stream);
}
- if (gdbpy_is_lazy_string (py_v) || gdbpy_is_string (py_v))
+ if (gdbpy_is_lazy_string (py_v))
{
- gdb_byte *output = NULL;
+ CORE_ADDR addr;
+ struct type *type;
+ long length;
+ char *encoding = NULL;
+ struct value_print_options local_opts = *options;
- if (gdbpy_is_lazy_string (py_v))
- {
- struct type *type;
- long length;
- char *encoding = NULL;
-
- output = gdbpy_extract_lazy_string (py_v, &type,
- &length, &encoding);
- if (!output)
- gdbpy_print_stack ();
- LA_PRINT_STRING (stream, type, output, length, encoding,
- 0, options);
- xfree (encoding);
- xfree (output);
- }
+ make_cleanup (free_current_contents, &encoding);
+ gdbpy_extract_lazy_string (py_v, &addr, &type, &length, &encoding);
+
+ local_opts.addressprint = 0;
+ val_print_string (type, encoding, addr, (int) length, stream,
+ &local_opts);
+ }
+ else if (gdbpy_is_string (py_v))
+ {
+ char *output;
+
+ output = python_string_to_host_string (py_v);
+ if (!output)
+ gdbpy_print_stack ();
else
{
- output = python_string_to_host_string (py_v);
- if (!output)
- gdbpy_print_stack ();
- else
- fputs_filtered (output, stream);
+ fputs_filtered (output, stream);
xfree (output);
}
}
char *hint = NULL;
struct cleanup *cleanups;
int result = 0;
- int is_py_none = 0;
+ enum string_repr_result print_result;
+
+ /* No pretty-printer support for unavailable values. */
+ if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
+ return 0;
+
+ if (!gdb_python_initialized)
+ return 0;
+
cleanups = ensure_python_env (gdbarch, language);
/* Instantiate the printer. */
valaddr += embedded_offset;
value = value_from_contents_and_address (type, valaddr,
address + embedded_offset);
- if (val != NULL)
- {
- set_value_component_location (value, val);
- /* set_value_component_location resets the address, so we may
- need to set it again. */
- if (VALUE_LVAL (value) != lval_internalvar
- && VALUE_LVAL (value) != lval_internalvar_component
- && VALUE_LVAL (value) != lval_computed)
- set_value_address (value, address + embedded_offset);
- }
+
+ set_value_component_location (value, val);
+ /* set_value_component_location resets the address, so we may
+ need to set it again. */
+ if (VALUE_LVAL (value) != lval_internalvar
+ && VALUE_LVAL (value) != lval_internalvar_component
+ && VALUE_LVAL (value) != lval_computed)
+ set_value_address (value, address + embedded_offset);
val_obj = value_to_value_object (value);
if (! val_obj)
goto done;
-
+
/* Find the constructor. */
printer = find_pretty_printer (val_obj);
Py_DECREF (val_obj);
+
+ if (printer == NULL)
+ goto done;
+
make_cleanup_py_decref (printer);
- if (! printer || printer == Py_None)
+ if (printer == Py_None)
goto done;
/* If we are printing a map, we want some special formatting. */
make_cleanup (free_current_contents, &hint);
/* Print the section */
- is_py_none = print_string_repr (printer, hint, stream, recurse,
- options, language, gdbarch);
- print_children (printer, hint, stream, recurse, options, language,
- is_py_none);
+ print_result = print_string_repr (printer, hint, stream, recurse,
+ options, language, gdbarch);
+ if (print_result != string_repr_error)
+ print_children (printer, hint, stream, recurse, options, language,
+ print_result == string_repr_none);
result = 1;
done:
if (PyErr_Occurred ())
- gdbpy_print_stack ();
+ print_stack_unless_memory_error (stream);
do_cleanups (cleanups);
return result;
}
NULL. */
PyObject *
apply_varobj_pretty_printer (PyObject *printer_obj,
- struct value **replacement)
+ struct value **replacement,
+ struct ui_file *stream)
{
PyObject *py_str = NULL;
py_str = pretty_print_one_value (printer_obj, replacement);
if (*replacement == NULL && py_str == NULL)
- gdbpy_print_stack ();
+ print_stack_unless_memory_error (stream);
return py_str;
}
/* Find a pretty-printer object for the varobj module. Returns a new
reference to the object if successful; returns NULL if not. VALUE
- is the value for which a printer tests to determine if it
+ is the value for which a printer tests to determine if it
can pretty-print the value. */
PyObject *
gdbpy_get_varobj_pretty_printer (struct value *value)
value = value_copy (value);
}
GDB_PY_HANDLE_EXCEPTION (except);
-
+
val_obj = value_to_value_object (value);
if (! val_obj)
return NULL;
value = value_object_to_value (val_obj);
if (! value)
{
- PyErr_SetString (PyExc_TypeError,
+ PyErr_SetString (PyExc_TypeError,
_("Argument must be a gdb.Value."));
return NULL;
}
projects / deliverable / binutils-gdb.git / blobdiff