1 /* Python pretty-printing
3 Copyright (C) 2008-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "extension-priv.h"
27 #include "python-internal.h"
30 /* Return type of print_string_repr. */
32 enum string_repr_result
34 /* The string method returned None. */
36 /* The string method had an error. */
42 /* Helper function for find_pretty_printer which iterates over a list,
43 calls each function and inspects output. This will return a
44 printer object if one recognizes VALUE. If no printer is found, it
45 will return None. On error, it will set the Python error and
49 search_pp_list (PyObject
*list
, PyObject
*value
)
51 Py_ssize_t pp_list_size
, list_index
;
53 pp_list_size
= PyList_Size (list
);
54 for (list_index
= 0; list_index
< pp_list_size
; list_index
++)
56 PyObject
*function
= PyList_GetItem (list
, list_index
);
60 /* Skip if disabled. */
61 if (PyObject_HasAttr (function
, gdbpy_enabled_cst
))
63 gdbpy_ref
attr (PyObject_GetAttr (function
, gdbpy_enabled_cst
));
68 cmp
= PyObject_IsTrue (attr
.get ());
76 gdbpy_ref
printer (PyObject_CallFunctionObjArgs (function
, value
, NULL
));
79 else if (printer
!= Py_None
)
80 return printer
.release ();
86 /* Subroutine of find_pretty_printer to simplify it.
87 Look for a pretty-printer to print VALUE in all objfiles.
88 The result is NULL if there's an error and the search should be terminated.
89 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
90 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
93 find_pretty_printer_from_objfiles (PyObject
*value
)
99 PyObject
*objf
= objfile_to_objfile_object (obj
);
102 /* Ignore the error and continue. */
107 gdbpy_ref
pp_list (objfpy_get_printers (objf
, NULL
));
108 gdbpy_ref
function (search_pp_list (pp_list
.get (), value
));
110 /* If there is an error in any objfile list, abort the search and exit. */
111 if (function
== NULL
)
114 if (function
!= Py_None
)
115 return function
.release ();
121 /* Subroutine of find_pretty_printer to simplify it.
122 Look for a pretty-printer to print VALUE in the current program space.
123 The result is NULL if there's an error and the search should be terminated.
124 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
125 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
128 find_pretty_printer_from_progspace (PyObject
*value
)
130 PyObject
*obj
= pspace_to_pspace_object (current_program_space
);
134 gdbpy_ref
pp_list (pspy_get_printers (obj
, NULL
));
135 return search_pp_list (pp_list
.get (), value
);
138 /* Subroutine of find_pretty_printer to simplify it.
139 Look for a pretty-printer to print VALUE in the gdb module.
140 The result is NULL if there's an error and the search should be terminated.
141 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
142 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
145 find_pretty_printer_from_gdb (PyObject
*value
)
147 /* Fetch the global pretty printer list. */
148 if (gdb_python_module
== NULL
149 || ! PyObject_HasAttrString (gdb_python_module
, "pretty_printers"))
151 gdbpy_ref
pp_list (PyObject_GetAttrString (gdb_python_module
,
153 if (pp_list
== NULL
|| ! PyList_Check (pp_list
.get ()))
156 return search_pp_list (pp_list
.get (), value
);
159 /* Find the pretty-printing constructor function for VALUE. If no
160 pretty-printer exists, return None. If one exists, return a new
161 reference. On error, set the Python error and return NULL. */
164 find_pretty_printer (PyObject
*value
)
166 /* Look at the pretty-printer list for each objfile
167 in the current program-space. */
168 gdbpy_ref
function (find_pretty_printer_from_objfiles (value
));
169 if (function
== NULL
|| function
!= Py_None
)
170 return function
.release ();
172 /* Look at the pretty-printer list for the current program-space. */
173 function
.reset (find_pretty_printer_from_progspace (value
));
174 if (function
== NULL
|| function
!= Py_None
)
175 return function
.release ();
177 /* Look at the pretty-printer list in the gdb module. */
178 return find_pretty_printer_from_gdb (value
);
181 /* Pretty-print a single value, via the printer object PRINTER.
182 If the function returns a string, a PyObject containing the string
183 is returned. If the function returns Py_NONE that means the pretty
184 printer returned the Python None as a value. Otherwise, if the
185 function returns a value, *OUT_VALUE is set to the value, and NULL
186 is returned. On error, *OUT_VALUE is set to NULL, NULL is
187 returned, with a python exception set. */
190 pretty_print_one_value (PyObject
*printer
, struct value
**out_value
)
192 PyObject
*result
= NULL
;
197 result
= PyObject_CallMethodObjArgs (printer
, gdbpy_to_string_cst
, NULL
);
200 if (! gdbpy_is_string (result
) && ! gdbpy_is_lazy_string (result
)
201 && result
!= Py_None
)
203 *out_value
= convert_value_from_python (result
);
204 if (PyErr_Occurred ())
211 CATCH (except
, RETURN_MASK_ALL
)
219 /* Return the display hint for the object printer, PRINTER. Return
220 NULL if there is no display_hint method, or if the method did not
221 return a string. On error, print stack trace and return NULL. On
222 success, return an xmalloc()d string. */
223 gdb::unique_xmalloc_ptr
<char>
224 gdbpy_get_display_hint (PyObject
*printer
)
226 gdb::unique_xmalloc_ptr
<char> result
;
228 if (! PyObject_HasAttr (printer
, gdbpy_display_hint_cst
))
231 gdbpy_ref
hint (PyObject_CallMethodObjArgs (printer
, gdbpy_display_hint_cst
,
235 if (gdbpy_is_string (hint
.get ()))
237 result
= python_string_to_host_string (hint
.get ());
239 gdbpy_print_stack ();
243 gdbpy_print_stack ();
248 /* A wrapper for gdbpy_print_stack that ignores MemoryError. */
251 print_stack_unless_memory_error (struct ui_file
*stream
)
253 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error
))
255 struct cleanup
*cleanup
;
256 PyObject
*type
, *value
, *trace
;
258 PyErr_Fetch (&type
, &value
, &trace
);
259 cleanup
= make_cleanup_py_decref (type
);
260 make_cleanup_py_decref (value
);
261 make_cleanup_py_decref (trace
);
263 gdb::unique_xmalloc_ptr
<char>
264 msg (gdbpy_exception_to_string (type
, value
));
266 if (msg
== NULL
|| *msg
== '\0')
267 fprintf_filtered (stream
, _("<error reading variable>"));
269 fprintf_filtered (stream
, _("<error reading variable: %s>"),
272 do_cleanups (cleanup
);
275 gdbpy_print_stack ();
278 /* Helper for gdbpy_apply_val_pretty_printer which calls to_string and
279 formats the result. */
281 static enum string_repr_result
282 print_string_repr (PyObject
*printer
, const char *hint
,
283 struct ui_file
*stream
, int recurse
,
284 const struct value_print_options
*options
,
285 const struct language_defn
*language
,
286 struct gdbarch
*gdbarch
)
288 struct value
*replacement
= NULL
;
289 PyObject
*py_str
= NULL
;
290 enum string_repr_result result
= string_repr_ok
;
292 py_str
= pretty_print_one_value (printer
, &replacement
);
295 struct cleanup
*cleanup
= make_cleanup_py_decref (py_str
);
297 if (py_str
== Py_None
)
298 result
= string_repr_none
;
299 else if (gdbpy_is_lazy_string (py_str
))
304 char *encoding
= NULL
;
305 struct value_print_options local_opts
= *options
;
307 make_cleanup (free_current_contents
, &encoding
);
308 gdbpy_extract_lazy_string (py_str
, &addr
, &type
,
311 local_opts
.addressprint
= 0;
312 val_print_string (type
, encoding
, addr
, (int) length
,
313 stream
, &local_opts
);
319 string
= python_string_to_target_python_string (py_str
);
326 make_cleanup_py_decref (string
);
328 output
= PyBytes_AS_STRING (string
);
329 length
= PyBytes_GET_SIZE (string
);
331 output
= PyString_AsString (string
);
332 length
= PyString_Size (string
);
334 type
= builtin_type (gdbarch
)->builtin_char
;
336 if (hint
&& !strcmp (hint
, "string"))
337 LA_PRINT_STRING (stream
, type
, (gdb_byte
*) output
,
338 length
, NULL
, 0, options
);
340 fputs_filtered (output
, stream
);
344 result
= string_repr_error
;
345 print_stack_unless_memory_error (stream
);
349 do_cleanups (cleanup
);
351 else if (replacement
)
353 struct value_print_options opts
= *options
;
355 opts
.addressprint
= 0;
356 common_val_print (replacement
, stream
, recurse
, &opts
, language
);
360 result
= string_repr_error
;
361 print_stack_unless_memory_error (stream
);
369 py_restore_tstate (void *p
)
371 PyFrameObject
*frame
= (PyFrameObject
*) p
;
372 PyThreadState
*tstate
= PyThreadState_GET ();
374 tstate
->frame
= frame
;
377 /* Create a dummy PyFrameObject, needed to work around
378 a Python-2.4 bug with generators. */
380 push_dummy_python_frame (void)
382 PyObject
*empty_string
, *null_tuple
, *globals
;
384 PyFrameObject
*frame
;
385 PyThreadState
*tstate
;
387 empty_string
= PyString_FromString ("");
391 null_tuple
= PyTuple_New (0);
394 Py_DECREF (empty_string
);
398 code
= PyCode_New (0, /* argcount */
402 empty_string
, /* code */
403 null_tuple
, /* consts */
404 null_tuple
, /* names */
405 null_tuple
, /* varnames */
406 #if PYTHON_API_VERSION >= 1010
407 null_tuple
, /* freevars */
408 null_tuple
, /* cellvars */
410 empty_string
, /* filename */
411 empty_string
, /* name */
413 empty_string
/* lnotab */
416 Py_DECREF (empty_string
);
417 Py_DECREF (null_tuple
);
422 globals
= PyDict_New ();
429 tstate
= PyThreadState_GET ();
431 frame
= PyFrame_New (tstate
, code
, globals
, NULL
);
439 tstate
->frame
= frame
;
440 make_cleanup (py_restore_tstate
, frame
->f_back
);
441 return (PyObject
*) frame
;
445 /* Helper for gdbpy_apply_val_pretty_printer that formats children of the
446 printer, if any exist. If is_py_none is true, then nothing has
447 been printed by to_string, and format output accordingly. */
449 print_children (PyObject
*printer
, const char *hint
,
450 struct ui_file
*stream
, int recurse
,
451 const struct value_print_options
*options
,
452 const struct language_defn
*language
,
455 int is_map
, is_array
, done_flag
, pretty
;
457 PyObject
*children
, *iter
;
461 struct cleanup
*cleanups
;
463 if (! PyObject_HasAttr (printer
, gdbpy_children_cst
))
466 /* If we are printing a map or an array, we want some special
468 is_map
= hint
&& ! strcmp (hint
, "map");
469 is_array
= hint
&& ! strcmp (hint
, "array");
471 children
= PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
475 print_stack_unless_memory_error (stream
);
479 cleanups
= make_cleanup_py_decref (children
);
481 iter
= PyObject_GetIter (children
);
484 print_stack_unless_memory_error (stream
);
487 make_cleanup_py_decref (iter
);
489 /* Use the prettyformat_arrays option if we are printing an array,
490 and the pretty option otherwise. */
492 pretty
= options
->prettyformat_arrays
;
495 if (options
->prettyformat
== Val_prettyformat
)
498 pretty
= options
->prettyformat_structs
;
501 /* Manufacture a dummy Python frame to work around Python 2.4 bug,
502 where it insists on having a non-NULL tstate->frame when
503 a generator is called. */
505 frame
= push_dummy_python_frame ();
508 gdbpy_print_stack ();
511 make_cleanup_py_decref (frame
);
515 for (i
= 0; i
< options
->print_max
; ++i
)
517 PyObject
*py_v
, *item
= PyIter_Next (iter
);
519 struct cleanup
*inner_cleanup
;
523 if (PyErr_Occurred ())
524 print_stack_unless_memory_error (stream
);
525 /* Set a flag so we can know whether we printed all the
526 available elements. */
532 if (! PyTuple_Check (item
) || PyTuple_Size (item
) != 2)
534 PyErr_SetString (PyExc_TypeError
,
535 _("Result of children iterator not a tuple"
536 " of two elements."));
537 gdbpy_print_stack ();
541 if (! PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
543 /* The user won't necessarily get a stack trace here, so provide
545 if (gdbpy_print_python_errors_p ())
546 fprintf_unfiltered (gdb_stderr
,
547 _("Bad result from children iterator.\n"));
548 gdbpy_print_stack ();
552 inner_cleanup
= make_cleanup_py_decref (item
);
554 /* Print initial "{". For other elements, there are three
556 1. Maps. Print a "," after each value element.
557 2. Arrays. Always print a ",".
558 3. Other. Always print a ",". */
562 fputs_filtered ("{", stream
);
564 fputs_filtered (" = {", stream
);
567 else if (! is_map
|| i
% 2 == 0)
568 fputs_filtered (pretty
? "," : ", ", stream
);
570 /* In summary mode, we just want to print "= {...}" if there is
572 if (options
->summary
)
574 /* This increment tricks the post-loop logic to print what
582 if (! is_map
|| i
% 2 == 0)
586 fputs_filtered ("\n", stream
);
587 print_spaces_filtered (2 + 2 * recurse
, stream
);
590 wrap_here (n_spaces (2 + 2 *recurse
));
593 if (is_map
&& i
% 2 == 0)
594 fputs_filtered ("[", stream
);
597 /* We print the index, not whatever the child method
598 returned as the name. */
599 if (options
->print_array_indexes
)
600 fprintf_filtered (stream
, "[%d] = ", i
);
604 fputs_filtered (name
, stream
);
605 fputs_filtered (" = ", stream
);
608 if (gdbpy_is_lazy_string (py_v
))
613 char *encoding
= NULL
;
614 struct value_print_options local_opts
= *options
;
616 make_cleanup (free_current_contents
, &encoding
);
617 gdbpy_extract_lazy_string (py_v
, &addr
, &type
, &length
, &encoding
);
619 local_opts
.addressprint
= 0;
620 val_print_string (type
, encoding
, addr
, (int) length
, stream
,
623 else if (gdbpy_is_string (py_v
))
625 gdb::unique_xmalloc_ptr
<char> output
;
627 output
= python_string_to_host_string (py_v
);
629 gdbpy_print_stack ();
631 fputs_filtered (output
.get (), stream
);
635 struct value
*value
= convert_value_from_python (py_v
);
639 gdbpy_print_stack ();
640 error (_("Error while executing Python code."));
643 common_val_print (value
, stream
, recurse
+ 1, options
, language
);
646 if (is_map
&& i
% 2 == 0)
647 fputs_filtered ("] = ", stream
);
649 do_cleanups (inner_cleanup
);
658 fputs_filtered ("\n", stream
);
659 print_spaces_filtered (2 + 2 * recurse
, stream
);
661 fputs_filtered ("...", stream
);
665 fputs_filtered ("\n", stream
);
666 print_spaces_filtered (2 * recurse
, stream
);
668 fputs_filtered ("}", stream
);
672 do_cleanups (cleanups
);
676 gdbpy_apply_val_pretty_printer (const struct extension_language_defn
*extlang
,
678 LONGEST embedded_offset
, CORE_ADDR address
,
679 struct ui_file
*stream
, int recurse
,
681 const struct value_print_options
*options
,
682 const struct language_defn
*language
)
684 struct gdbarch
*gdbarch
= get_type_arch (type
);
686 enum string_repr_result print_result
;
687 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
689 /* No pretty-printer support for unavailable values. */
690 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
691 return EXT_LANG_RC_NOP
;
693 if (!gdb_python_initialized
)
694 return EXT_LANG_RC_NOP
;
696 gdbpy_enter
enter_py (gdbarch
, language
);
698 /* Instantiate the printer. */
699 value
= value_from_component (val
, type
, embedded_offset
);
701 gdbpy_ref
val_obj (value_to_value_object (value
));
704 print_stack_unless_memory_error (stream
);
705 return EXT_LANG_RC_ERROR
;
708 /* Find the constructor. */
709 gdbpy_ref
printer (find_pretty_printer (val_obj
.get ()));
712 print_stack_unless_memory_error (stream
);
713 return EXT_LANG_RC_ERROR
;
716 if (printer
== Py_None
)
717 return EXT_LANG_RC_NOP
;
719 /* If we are printing a map, we want some special formatting. */
720 gdb::unique_xmalloc_ptr
<char> hint (gdbpy_get_display_hint (printer
.get ()));
722 /* Print the section */
723 print_result
= print_string_repr (printer
.get (), hint
.get (), stream
,
724 recurse
, options
, language
, gdbarch
);
725 if (print_result
!= string_repr_error
)
726 print_children (printer
.get (), hint
.get (), stream
, recurse
, options
,
727 language
, print_result
== string_repr_none
);
729 if (PyErr_Occurred ())
730 print_stack_unless_memory_error (stream
);
731 return EXT_LANG_RC_OK
;
735 /* Apply a pretty-printer for the varobj code. PRINTER_OBJ is the
736 print object. It must have a 'to_string' method (but this is
737 checked by varobj, not here) which takes no arguments and
738 returns a string. The printer will return a value and in the case
739 of a Python string being returned, this function will return a
740 PyObject containing the string. For any other type, *REPLACEMENT is
741 set to the replacement value and this function returns NULL. On
742 error, *REPLACEMENT is set to NULL and this function also returns
745 apply_varobj_pretty_printer (PyObject
*printer_obj
,
746 struct value
**replacement
,
747 struct ui_file
*stream
)
749 PyObject
*py_str
= NULL
;
752 py_str
= pretty_print_one_value (printer_obj
, replacement
);
754 if (*replacement
== NULL
&& py_str
== NULL
)
755 print_stack_unless_memory_error (stream
);
760 /* Find a pretty-printer object for the varobj module. Returns a new
761 reference to the object if successful; returns NULL if not. VALUE
762 is the value for which a printer tests to determine if it
763 can pretty-print the value. */
765 gdbpy_get_varobj_pretty_printer (struct value
*value
)
769 value
= value_copy (value
);
771 CATCH (except
, RETURN_MASK_ALL
)
773 GDB_PY_HANDLE_EXCEPTION (except
);
777 gdbpy_ref
val_obj (value_to_value_object (value
));
781 return find_pretty_printer (val_obj
.get ());
784 /* A Python function which wraps find_pretty_printer and instantiates
785 the resulting class. This accepts a Value argument and returns a
786 pretty printer instance, or None. This function is useful as an
787 argument to the MI command -var-set-visualizer. */
789 gdbpy_default_visualizer (PyObject
*self
, PyObject
*args
)
795 if (! PyArg_ParseTuple (args
, "O", &val_obj
))
797 value
= value_object_to_value (val_obj
);
800 PyErr_SetString (PyExc_TypeError
,
801 _("Argument must be a gdb.Value."));
805 cons
= find_pretty_printer (val_obj
);