1 /* Python pretty-printing
3 Copyright (C) 2008-2019 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
,
80 else if (printer
!= Py_None
)
84 return gdbpy_ref
<>::new_reference (Py_None
);
87 /* Subroutine of find_pretty_printer to simplify it.
88 Look for a pretty-printer to print VALUE in all objfiles.
89 The result is NULL if there's an error and the search should be terminated.
90 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
91 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
94 find_pretty_printer_from_objfiles (PyObject
*value
)
96 for (objfile
*obj
: current_program_space
->objfiles ())
98 gdbpy_ref
<> objf
= objfile_to_objfile_object (obj
);
101 /* Ignore the error and continue. */
106 gdbpy_ref
<> pp_list (objfpy_get_printers (objf
.get (), NULL
));
107 gdbpy_ref
<> function (search_pp_list (pp_list
.get (), value
));
109 /* If there is an error in any objfile list, abort the search and exit. */
110 if (function
== NULL
)
113 if (function
!= Py_None
)
114 return function
.release ();
120 /* Subroutine of find_pretty_printer to simplify it.
121 Look for a pretty-printer to print VALUE in the current program space.
122 The result is NULL if there's an error and the search should be terminated.
123 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
124 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
127 find_pretty_printer_from_progspace (PyObject
*value
)
129 gdbpy_ref
<> obj
= pspace_to_pspace_object (current_program_space
);
133 gdbpy_ref
<> pp_list (pspy_get_printers (obj
.get (), NULL
));
134 return search_pp_list (pp_list
.get (), value
);
137 /* Subroutine of find_pretty_printer to simplify it.
138 Look for a pretty-printer to print VALUE in the gdb module.
139 The result is NULL if there's an error and the search should be terminated.
140 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
141 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
144 find_pretty_printer_from_gdb (PyObject
*value
)
146 /* Fetch the global pretty printer list. */
147 if (gdb_python_module
== NULL
148 || ! PyObject_HasAttrString (gdb_python_module
, "pretty_printers"))
149 return gdbpy_ref
<>::new_reference (Py_None
);
150 gdbpy_ref
<> pp_list (PyObject_GetAttrString (gdb_python_module
,
152 if (pp_list
== NULL
|| ! PyList_Check (pp_list
.get ()))
153 return gdbpy_ref
<>::new_reference (Py_None
);
155 return search_pp_list (pp_list
.get (), value
);
158 /* Find the pretty-printing constructor function for VALUE. If no
159 pretty-printer exists, return None. If one exists, return a new
160 reference. On error, set the Python error and return NULL. */
163 find_pretty_printer (PyObject
*value
)
165 /* Look at the pretty-printer list for each objfile
166 in the current program-space. */
167 gdbpy_ref
<> function (find_pretty_printer_from_objfiles (value
));
168 if (function
== NULL
|| function
!= Py_None
)
171 /* Look at the pretty-printer list for the current program-space. */
172 function
= find_pretty_printer_from_progspace (value
);
173 if (function
== NULL
|| function
!= Py_None
)
176 /* Look at the pretty-printer list in the gdb module. */
177 return find_pretty_printer_from_gdb (value
);
180 /* Pretty-print a single value, via the printer object PRINTER.
181 If the function returns a string, a PyObject containing the string
182 is returned. If the function returns Py_NONE that means the pretty
183 printer returned the Python None as a value. Otherwise, if the
184 function returns a value, *OUT_VALUE is set to the value, and NULL
185 is returned. On error, *OUT_VALUE is set to NULL, NULL is
186 returned, with a python exception set. */
189 pretty_print_one_value (PyObject
*printer
, struct value
**out_value
)
196 if (!PyObject_HasAttr (printer
, gdbpy_to_string_cst
))
197 result
= gdbpy_ref
<>::new_reference (Py_None
);
200 result
.reset (PyObject_CallMethodObjArgs (printer
, gdbpy_to_string_cst
,
204 if (! gdbpy_is_string (result
.get ())
205 && ! gdbpy_is_lazy_string (result
.get ())
206 && result
!= Py_None
)
208 *out_value
= convert_value_from_python (result
.get ());
209 if (PyErr_Occurred ())
216 CATCH (except
, RETURN_MASK_ALL
)
224 /* Return the display hint for the object printer, PRINTER. Return
225 NULL if there is no display_hint method, or if the method did not
226 return a string. On error, print stack trace and return NULL. On
227 success, return an xmalloc()d string. */
228 gdb::unique_xmalloc_ptr
<char>
229 gdbpy_get_display_hint (PyObject
*printer
)
231 gdb::unique_xmalloc_ptr
<char> result
;
233 if (! PyObject_HasAttr (printer
, gdbpy_display_hint_cst
))
236 gdbpy_ref
<> hint (PyObject_CallMethodObjArgs (printer
, gdbpy_display_hint_cst
,
240 if (gdbpy_is_string (hint
.get ()))
242 result
= python_string_to_host_string (hint
.get ());
244 gdbpy_print_stack ();
248 gdbpy_print_stack ();
253 /* A wrapper for gdbpy_print_stack that ignores MemoryError. */
256 print_stack_unless_memory_error (struct ui_file
*stream
)
258 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error
))
260 gdbpy_err_fetch fetched_error
;
261 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
263 if (msg
== NULL
|| *msg
== '\0')
264 fprintf_filtered (stream
, _("<error reading variable>"));
266 fprintf_filtered (stream
, _("<error reading variable: %s>"),
270 gdbpy_print_stack ();
273 /* Helper for gdbpy_apply_val_pretty_printer which calls to_string and
274 formats the result. */
276 static enum string_repr_result
277 print_string_repr (PyObject
*printer
, const char *hint
,
278 struct ui_file
*stream
, int recurse
,
279 const struct value_print_options
*options
,
280 const struct language_defn
*language
,
281 struct gdbarch
*gdbarch
)
283 struct value
*replacement
= NULL
;
284 enum string_repr_result result
= string_repr_ok
;
286 gdbpy_ref
<> py_str
= pretty_print_one_value (printer
, &replacement
);
289 if (py_str
== Py_None
)
290 result
= string_repr_none
;
291 else if (gdbpy_is_lazy_string (py_str
.get ()))
296 gdb::unique_xmalloc_ptr
<char> encoding
;
297 struct value_print_options local_opts
= *options
;
299 gdbpy_extract_lazy_string (py_str
.get (), &addr
, &type
,
302 local_opts
.addressprint
= 0;
303 val_print_string (type
, encoding
.get (), addr
, (int) length
,
304 stream
, &local_opts
);
309 = python_string_to_target_python_string (py_str
.get ());
317 output
= PyBytes_AS_STRING (string
.get ());
318 length
= PyBytes_GET_SIZE (string
.get ());
320 output
= PyString_AsString (string
.get ());
321 length
= PyString_Size (string
.get ());
323 type
= builtin_type (gdbarch
)->builtin_char
;
325 if (hint
&& !strcmp (hint
, "string"))
326 LA_PRINT_STRING (stream
, type
, (gdb_byte
*) output
,
327 length
, NULL
, 0, options
);
329 fputs_filtered (output
, stream
);
333 result
= string_repr_error
;
334 print_stack_unless_memory_error (stream
);
338 else if (replacement
)
340 struct value_print_options opts
= *options
;
342 opts
.addressprint
= 0;
343 common_val_print (replacement
, stream
, recurse
, &opts
, language
);
347 result
= string_repr_error
;
348 print_stack_unless_memory_error (stream
);
356 /* Create a dummy PyFrameObject, needed to work around
357 a Python-2.4 bug with generators. */
358 class dummy_python_frame
362 dummy_python_frame ();
364 ~dummy_python_frame ()
367 m_tstate
->frame
= m_saved_frame
;
378 PyFrameObject
*m_saved_frame
;
380 PyThreadState
*m_tstate
;
383 dummy_python_frame::dummy_python_frame ()
385 m_saved_frame (NULL
),
389 PyFrameObject
*frame
;
391 gdbpy_ref
<> empty_string (PyString_FromString (""));
392 if (empty_string
== NULL
)
395 gdbpy_ref
<> null_tuple (PyTuple_New (0));
396 if (null_tuple
== NULL
)
399 code
= PyCode_New (0, /* argcount */
403 empty_string
.get (), /* code */
404 null_tuple
.get (), /* consts */
405 null_tuple
.get (), /* names */
406 null_tuple
.get (), /* varnames */
407 #if PYTHON_API_VERSION >= 1010
408 null_tuple
.get (), /* freevars */
409 null_tuple
.get (), /* cellvars */
411 empty_string
.get (), /* filename */
412 empty_string
.get (), /* name */
414 empty_string
.get () /* lnotab */
418 gdbpy_ref
<> code_holder ((PyObject
*) code
);
420 gdbpy_ref
<> globals (PyDict_New ());
424 m_tstate
= PyThreadState_GET ();
425 frame
= PyFrame_New (m_tstate
, code
, globals
.get (), NULL
);
429 m_frame
.reset ((PyObject
*) frame
);
430 m_tstate
->frame
= frame
;
431 m_saved_frame
= frame
->f_back
;
436 /* Helper for gdbpy_apply_val_pretty_printer that formats children of the
437 printer, if any exist. If is_py_none is true, then nothing has
438 been printed by to_string, and format output accordingly. */
440 print_children (PyObject
*printer
, const char *hint
,
441 struct ui_file
*stream
, int recurse
,
442 const struct value_print_options
*options
,
443 const struct language_defn
*language
,
446 int is_map
, is_array
, done_flag
, pretty
;
449 if (! PyObject_HasAttr (printer
, gdbpy_children_cst
))
452 /* If we are printing a map or an array, we want some special
454 is_map
= hint
&& ! strcmp (hint
, "map");
455 is_array
= hint
&& ! strcmp (hint
, "array");
457 gdbpy_ref
<> children (PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
459 if (children
== NULL
)
461 print_stack_unless_memory_error (stream
);
465 gdbpy_ref
<> iter (PyObject_GetIter (children
.get ()));
468 print_stack_unless_memory_error (stream
);
472 /* Use the prettyformat_arrays option if we are printing an array,
473 and the pretty option otherwise. */
475 pretty
= options
->prettyformat_arrays
;
478 if (options
->prettyformat
== Val_prettyformat
)
481 pretty
= options
->prettyformat_structs
;
484 /* Manufacture a dummy Python frame to work around Python 2.4 bug,
485 where it insists on having a non-NULL tstate->frame when
486 a generator is called. */
488 dummy_python_frame frame
;
491 gdbpy_print_stack ();
497 for (i
= 0; i
< options
->print_max
; ++i
)
502 gdbpy_ref
<> item (PyIter_Next (iter
.get ()));
505 if (PyErr_Occurred ())
506 print_stack_unless_memory_error (stream
);
507 /* Set a flag so we can know whether we printed all the
508 available elements. */
514 if (! PyTuple_Check (item
.get ()) || PyTuple_Size (item
.get ()) != 2)
516 PyErr_SetString (PyExc_TypeError
,
517 _("Result of children iterator not a tuple"
518 " of two elements."));
519 gdbpy_print_stack ();
522 if (! PyArg_ParseTuple (item
.get (), "sO", &name
, &py_v
))
524 /* The user won't necessarily get a stack trace here, so provide
526 if (gdbpy_print_python_errors_p ())
527 fprintf_unfiltered (gdb_stderr
,
528 _("Bad result from children iterator.\n"));
529 gdbpy_print_stack ();
533 /* Print initial "{". For other elements, there are three
535 1. Maps. Print a "," after each value element.
536 2. Arrays. Always print a ",".
537 3. Other. Always print a ",". */
541 fputs_filtered ("{", stream
);
543 fputs_filtered (" = {", stream
);
546 else if (! is_map
|| i
% 2 == 0)
547 fputs_filtered (pretty
? "," : ", ", stream
);
549 /* In summary mode, we just want to print "= {...}" if there is
551 if (options
->summary
)
553 /* This increment tricks the post-loop logic to print what
561 if (! is_map
|| i
% 2 == 0)
565 fputs_filtered ("\n", stream
);
566 print_spaces_filtered (2 + 2 * recurse
, stream
);
569 wrap_here (n_spaces (2 + 2 *recurse
));
572 if (is_map
&& i
% 2 == 0)
573 fputs_filtered ("[", stream
);
576 /* We print the index, not whatever the child method
577 returned as the name. */
578 if (options
->print_array_indexes
)
579 fprintf_filtered (stream
, "[%d] = ", i
);
583 fputs_filtered (name
, stream
);
584 fputs_filtered (" = ", stream
);
587 if (gdbpy_is_lazy_string (py_v
))
592 gdb::unique_xmalloc_ptr
<char> encoding
;
593 struct value_print_options local_opts
= *options
;
595 gdbpy_extract_lazy_string (py_v
, &addr
, &type
, &length
, &encoding
);
597 local_opts
.addressprint
= 0;
598 val_print_string (type
, encoding
.get (), addr
, (int) length
, stream
,
601 else if (gdbpy_is_string (py_v
))
603 gdb::unique_xmalloc_ptr
<char> output
;
605 output
= python_string_to_host_string (py_v
);
607 gdbpy_print_stack ();
609 fputs_filtered (output
.get (), stream
);
613 struct value
*value
= convert_value_from_python (py_v
);
617 gdbpy_print_stack ();
618 error (_("Error while executing Python code."));
621 common_val_print (value
, stream
, recurse
+ 1, options
, language
);
624 if (is_map
&& i
% 2 == 0)
625 fputs_filtered ("] = ", stream
);
634 fputs_filtered ("\n", stream
);
635 print_spaces_filtered (2 + 2 * recurse
, stream
);
637 fputs_filtered ("...", stream
);
641 fputs_filtered ("\n", stream
);
642 print_spaces_filtered (2 * recurse
, stream
);
644 fputs_filtered ("}", stream
);
649 gdbpy_apply_val_pretty_printer (const struct extension_language_defn
*extlang
,
651 LONGEST embedded_offset
, CORE_ADDR address
,
652 struct ui_file
*stream
, int recurse
,
654 const struct value_print_options
*options
,
655 const struct language_defn
*language
)
657 struct gdbarch
*gdbarch
= get_type_arch (type
);
659 enum string_repr_result print_result
;
661 if (value_lazy (val
))
662 value_fetch_lazy (val
);
664 /* No pretty-printer support for unavailable values. */
665 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
666 return EXT_LANG_RC_NOP
;
668 if (!gdb_python_initialized
)
669 return EXT_LANG_RC_NOP
;
671 gdbpy_enter
enter_py (gdbarch
, language
);
673 /* Instantiate the printer. */
674 value
= value_from_component (val
, type
, embedded_offset
);
676 gdbpy_ref
<> val_obj (value_to_value_object (value
));
679 print_stack_unless_memory_error (stream
);
680 return EXT_LANG_RC_ERROR
;
683 /* Find the constructor. */
684 gdbpy_ref
<> printer (find_pretty_printer (val_obj
.get ()));
687 print_stack_unless_memory_error (stream
);
688 return EXT_LANG_RC_ERROR
;
691 if (printer
== Py_None
)
692 return EXT_LANG_RC_NOP
;
694 /* If we are printing a map, we want some special formatting. */
695 gdb::unique_xmalloc_ptr
<char> hint (gdbpy_get_display_hint (printer
.get ()));
697 /* Print the section */
698 print_result
= print_string_repr (printer
.get (), hint
.get (), stream
,
699 recurse
, options
, language
, gdbarch
);
700 if (print_result
!= string_repr_error
)
701 print_children (printer
.get (), hint
.get (), stream
, recurse
, options
,
702 language
, print_result
== string_repr_none
);
704 if (PyErr_Occurred ())
705 print_stack_unless_memory_error (stream
);
706 return EXT_LANG_RC_OK
;
710 /* Apply a pretty-printer for the varobj code. PRINTER_OBJ is the
711 print object. It must have a 'to_string' method (but this is
712 checked by varobj, not here) which takes no arguments and
713 returns a string. The printer will return a value and in the case
714 of a Python string being returned, this function will return a
715 PyObject containing the string. For any other type, *REPLACEMENT is
716 set to the replacement value and this function returns NULL. On
717 error, *REPLACEMENT is set to NULL and this function also returns
720 apply_varobj_pretty_printer (PyObject
*printer_obj
,
721 struct value
**replacement
,
722 struct ui_file
*stream
)
725 gdbpy_ref
<> py_str
= pretty_print_one_value (printer_obj
, replacement
);
727 if (*replacement
== NULL
&& py_str
== NULL
)
728 print_stack_unless_memory_error (stream
);
733 /* Find a pretty-printer object for the varobj module. Returns a new
734 reference to the object if successful; returns NULL if not. VALUE
735 is the value for which a printer tests to determine if it
736 can pretty-print the value. */
738 gdbpy_get_varobj_pretty_printer (struct value
*value
)
742 value
= value_copy (value
);
744 CATCH (except
, RETURN_MASK_ALL
)
746 GDB_PY_HANDLE_EXCEPTION (except
);
750 gdbpy_ref
<> val_obj (value_to_value_object (value
));
754 return find_pretty_printer (val_obj
.get ());
757 /* A Python function which wraps find_pretty_printer and instantiates
758 the resulting class. This accepts a Value argument and returns a
759 pretty printer instance, or None. This function is useful as an
760 argument to the MI command -var-set-visualizer. */
762 gdbpy_default_visualizer (PyObject
*self
, PyObject
*args
)
767 if (! PyArg_ParseTuple (args
, "O", &val_obj
))
769 value
= value_object_to_value (val_obj
);
772 PyErr_SetString (PyExc_TypeError
,
773 _("Argument must be a gdb.Value."));
777 return find_pretty_printer (val_obj
).release ();