GDB (xrefs)

py-prettyprint.c
Go to the documentation of this file.
1 /* Python pretty-printing
2
3 Copyright (C) 2008-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "objfiles.h"
22 #include "symtab.h"
23 #include "language.h"
24 #include "valprint.h"
25 #include "extension-priv.h"
26 #include "python.h"
27 #include "python-internal.h"
28 #include "py-ref.h"
29
30 /* Return type of print_string_repr. */
31
32 enum string_repr_result
33 {
34 /* The string method returned None. */
35 string_repr_none,
36 /* The string method had an error. */
37 string_repr_error,
38 /* Everything ok. */
39 string_repr_ok
40 };
41
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
46 return NULL. */
47
48 static PyObject *
49 search_pp_list (PyObject *list, PyObject *value)
50 {
51 Py_ssize_t pp_list_size, list_index;
52
53 pp_list_size = PyList_Size (list);
54 for (list_index = 0; list_index < pp_list_size; list_index++)
55 {
56 PyObject *function = PyList_GetItem (list, list_index);
57 if (! function)
58 return NULL;
59
60 /* Skip if disabled. */
61 if (PyObject_HasAttr (function, gdbpy_enabled_cst))
62 {
63 gdbpy_ref<> attr (PyObject_GetAttr (function, gdbpy_enabled_cst));
64 int cmp;
65
66 if (attr == NULL)
67 return NULL;
68 cmp = PyObject_IsTrue (attr.get ());
69 if (cmp == -1)
70 return NULL;
71
72 if (!cmp)
73 continue;
74 }
75
76 gdbpy_ref<> printer (PyObject_CallFunctionObjArgs (function, value,
77 NULL));
78 if (printer == NULL)
79 return NULL;
80 else if (printer != Py_None)
81 return printer.release ();
82 }
83
84 Py_RETURN_NONE;
85 }
86
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. */
92
93 static PyObject *
94 find_pretty_printer_from_objfiles (PyObject *value)
95 {
96 struct objfile *obj;
97
98 ALL_OBJFILES (obj)
99 {
100 PyObject *objf = objfile_to_objfile_object (obj);
101 if (!objf)
102 {
103 /* Ignore the error and continue. */
104 PyErr_Clear ();
105 continue;
106 }
107
108 gdbpy_ref<> pp_list (objfpy_get_printers (objf, NULL));
109 gdbpy_ref<> function (search_pp_list (pp_list.get (), value));
110
111 /* If there is an error in any objfile list, abort the search and exit. */
112 if (function == NULL)
113 return NULL;
114
115 if (function != Py_None)
116 return function.release ();
117 }
118
119 Py_RETURN_NONE;
120 }
121
122 /* Subroutine of find_pretty_printer to simplify it.
123 Look for a pretty-printer to print VALUE in the current program space.
124 The result is NULL if there's an error and the search should be terminated.
125 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
126 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
127
128 static PyObject *
129 find_pretty_printer_from_progspace (PyObject *value)
130 {
131 PyObject *obj = pspace_to_pspace_object (current_program_space);
132
133 if (!obj)
134 return NULL;
135 gdbpy_ref<> pp_list (pspy_get_printers (obj, NULL));
136 return search_pp_list (pp_list.get (), value);
137 }
138
139 /* Subroutine of find_pretty_printer to simplify it.
140 Look for a pretty-printer to print VALUE in the gdb module.
141 The result is NULL if there's an error and the search should be terminated.
142 The result is Py_None, suitably inc-ref'd, if no pretty-printer was found.
143 Otherwise the result is the pretty-printer function, suitably inc-ref'd. */
144
145 static PyObject *
146 find_pretty_printer_from_gdb (PyObject *value)
147 {
148 /* Fetch the global pretty printer list. */
149 if (gdb_python_module == NULL
150 || ! PyObject_HasAttrString (gdb_python_module, "pretty_printers"))
151 Py_RETURN_NONE;
152 gdbpy_ref<> pp_list (PyObject_GetAttrString (gdb_python_module,
153 "pretty_printers"));
154 if (pp_list == NULL || ! PyList_Check (pp_list.get ()))
155 Py_RETURN_NONE;
156
157 return search_pp_list (pp_list.get (), value);
158 }
159
160 /* Find the pretty-printing constructor function for VALUE. If no
161 pretty-printer exists, return None. If one exists, return a new
162 reference. On error, set the Python error and return NULL. */
163
164 static PyObject *
165 find_pretty_printer (PyObject *value)
166 {
167 /* Look at the pretty-printer list for each objfile
168 in the current program-space. */
169 gdbpy_ref<> function (find_pretty_printer_from_objfiles (value));
170 if (function == NULL || function != Py_None)
171 return function.release ();
172
173 /* Look at the pretty-printer list for the current program-space. */
174 function.reset (find_pretty_printer_from_progspace (value));
175 if (function == NULL || function != Py_None)
176 return function.release ();
177
178 /* Look at the pretty-printer list in the gdb module. */
179 return find_pretty_printer_from_gdb (value);
180 }
181
182 /* Pretty-print a single value, via the printer object PRINTER.
183 If the function returns a string, a PyObject containing the string
184 is returned. If the function returns Py_NONE that means the pretty
185 printer returned the Python None as a value. Otherwise, if the
186 function returns a value, *OUT_VALUE is set to the value, and NULL
187 is returned. On error, *OUT_VALUE is set to NULL, NULL is
188 returned, with a python exception set. */
189
190 static PyObject *
191 pretty_print_one_value (PyObject *printer, struct value **out_value)
192 {
193 gdbpy_ref<> result;
194
195 *out_value = NULL;
196 TRY
197 {
198 result.reset (PyObject_CallMethodObjArgs (printer, gdbpy_to_string_cst,
199 NULL));
200 if (result != NULL)
201 {
202 if (! gdbpy_is_string (result.get ())
203 && ! gdbpy_is_lazy_string (result.get ())
204 && result != Py_None)
205 {
206 *out_value = convert_value_from_python (result.get ());
207 if (PyErr_Occurred ())
208 *out_value = NULL;
209 result = NULL;
210 }
211 }
212 }
213 CATCH (except, RETURN_MASK_ALL)
214 {
215 }
216 END_CATCH
217
218 return result.release ();
219 }
220
221 /* Return the display hint for the object printer, PRINTER. Return
222 NULL if there is no display_hint method, or if the method did not
223 return a string. On error, print stack trace and return NULL. On
224 success, return an xmalloc()d string. */
225 gdb::unique_xmalloc_ptr<char>
226 gdbpy_get_display_hint (PyObject *printer)
227 {
228 gdb::unique_xmalloc_ptr<char> result;
229
230 if (! PyObject_HasAttr (printer, gdbpy_display_hint_cst))
231 return NULL;
232
233 gdbpy_ref<> hint (PyObject_CallMethodObjArgs (printer, gdbpy_display_hint_cst,
234 NULL));
235 if (hint != NULL)
236 {
237 if (gdbpy_is_string (hint.get ()))
238 {
239 result = python_string_to_host_string (hint.get ());
240 if (result == NULL)
241 gdbpy_print_stack ();
242 }
243 }
244 else
245 gdbpy_print_stack ();
246
247 return result;
248 }
249
250 /* A wrapper for gdbpy_print_stack that ignores MemoryError. */
251
252 static void
253 print_stack_unless_memory_error (struct ui_file *stream)
254 {
255 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
256 {
257 PyObject *type, *value, *trace;
258
259 PyErr_Fetch (&type, &value, &trace);
260
261 gdbpy_ref<> type_ref (type);
262 gdbpy_ref<> value_ref (value);
263 gdbpy_ref<> trace_ref (trace);
264
265 gdb::unique_xmalloc_ptr<char>
266 msg (gdbpy_exception_to_string (type, value));
267
268 if (msg == NULL || *msg == '\0')
269 fprintf_filtered (stream, _("<error reading variable>"));
270 else
271 fprintf_filtered (stream, _("<error reading variable: %s>"),
272 msg.get ());
273 }
274 else
275 gdbpy_print_stack ();
276 }
277
278 /* Helper for gdbpy_apply_val_pretty_printer which calls to_string and
279 formats the result. */
280
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)
287 {
288 struct value *replacement = NULL;
289 enum string_repr_result result = string_repr_ok;
290
291 gdbpy_ref<> py_str (pretty_print_one_value (printer, &replacement));
292 if (py_str != NULL)
293 {
294 if (py_str == Py_None)
295 result = string_repr_none;
296 else if (gdbpy_is_lazy_string (py_str.get ()))
297 {
298 CORE_ADDR addr;
299 long length;
300 struct type *type;
301 gdb::unique_xmalloc_ptr<char> encoding;
302 struct value_print_options local_opts = *options;
303
304 gdbpy_extract_lazy_string (py_str.get (), &addr, &type,
305 &length, &encoding);
306
307 local_opts.addressprint = 0;
308 val_print_string (type, encoding.get (), addr, (int) length,
309 stream, &local_opts);
310 }
311 else
312 {
313 gdbpy_ref<> string
314 (python_string_to_target_python_string (py_str.get ()));
315 if (string != NULL)
316 {
317 char *output;
318 long length;
319 struct type *type;
320
321 #ifdef IS_PY3K
322 output = PyBytes_AS_STRING (string.get ());
323 length = PyBytes_GET_SIZE (string.get ());
324 #else
325 output = PyString_AsString (string.get ());
326 length = PyString_Size (string.get ());
327 #endif
328 type = builtin_type (gdbarch)->builtin_char;
329
330 if (hint && !strcmp (hint, "string"))
331 LA_PRINT_STRING (stream, type, (gdb_byte *) output,
332 length, NULL, 0, options);
333 else
334 fputs_filtered (output, stream);
335 }
336 else
337 {
338 result = string_repr_error;
339 print_stack_unless_memory_error (stream);
340 }
341 }
342 }
343 else if (replacement)
344 {
345 struct value_print_options opts = *options;
346
347 opts.addressprint = 0;
348 common_val_print (replacement, stream, recurse, &opts, language);
349 }
350 else
351 {
352 result = string_repr_error;
353 print_stack_unless_memory_error (stream);
354 }
355
356 return result;
357 }
358
359 #ifndef IS_PY3K
360
361 /* Create a dummy PyFrameObject, needed to work around
362 a Python-2.4 bug with generators. */
363 class dummy_python_frame
364 {
365 public:
366
367 dummy_python_frame ();
368
369 ~dummy_python_frame ()
370 {
371 if (m_valid)
372 m_tstate->frame = m_saved_frame;
373 }
374
375 bool failed () const
376 {
377 return !m_valid;
378 }
379
380 private:
381
382 bool m_valid;
383 PyFrameObject *m_saved_frame;
384 gdbpy_ref<> m_frame;
385 PyThreadState *m_tstate;
386 };
387
388 dummy_python_frame::dummy_python_frame ()
389 : m_valid (false),
390 m_saved_frame (NULL),
391 m_tstate (NULL)
392 {
393 PyCodeObject *code;
394 PyFrameObject *frame;
395
396 gdbpy_ref<> empty_string (PyString_FromString (""));
397 if (empty_string == NULL)
398 return;
399
400 gdbpy_ref<> null_tuple (PyTuple_New (0));
401 if (null_tuple == NULL)
402 return;
403
404 code = PyCode_New (0, /* argcount */
405 0, /* locals */
406 0, /* stacksize */
407 0, /* flags */
408 empty_string.get (), /* code */
409 null_tuple.get (), /* consts */
410 null_tuple.get (), /* names */
411 null_tuple.get (), /* varnames */
412 #if PYTHON_API_VERSION >= 1010
413 null_tuple.get (), /* freevars */
414 null_tuple.get (), /* cellvars */
415 #endif
416 empty_string.get (), /* filename */
417 empty_string.get (), /* name */
418 1, /* firstlineno */
419 empty_string.get () /* lnotab */
420 );
421 if (code == NULL)
422 return;
423 gdbpy_ref<> code_holder ((PyObject *) code);
424
425 gdbpy_ref<> globals (PyDict_New ());
426 if (globals == NULL)
427 return;
428
429 m_tstate = PyThreadState_GET ();
430 frame = PyFrame_New (m_tstate, code, globals.get (), NULL);
431 if (frame == NULL)
432 return;
433
434 m_frame.reset ((PyObject *) frame);
435 m_tstate->frame = frame;
436 m_saved_frame = frame->f_back;
437 m_valid = true;
438 }
439 #endif
440
441 /* Helper for gdbpy_apply_val_pretty_printer that formats children of the
442 printer, if any exist. If is_py_none is true, then nothing has
443 been printed by to_string, and format output accordingly. */
444 static void
445 print_children (PyObject *printer, const char *hint,
446 struct ui_file *stream, int recurse,
447 const struct value_print_options *options,
448 const struct language_defn *language,
449 int is_py_none)
450 {
451 int is_map, is_array, done_flag, pretty;
452 unsigned int i;
453
454 if (! PyObject_HasAttr (printer, gdbpy_children_cst))
455 return;
456
457 /* If we are printing a map or an array, we want some special
458 formatting. */
459 is_map = hint && ! strcmp (hint, "map");
460 is_array = hint && ! strcmp (hint, "array");
461
462 gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
463 NULL));
464 if (children == NULL)
465 {
466 print_stack_unless_memory_error (stream);
467 return;
468 }
469
470 gdbpy_ref<> iter (PyObject_GetIter (children.get ()));
471 if (iter == NULL)
472 {
473 print_stack_unless_memory_error (stream);
474 return;
475 }
476
477 /* Use the prettyformat_arrays option if we are printing an array,
478 and the pretty option otherwise. */
479 if (is_array)
480 pretty = options->prettyformat_arrays;
481 else
482 {
483 if (options->prettyformat == Val_prettyformat)
484 pretty = 1;
485 else
486 pretty = options->prettyformat_structs;
487 }
488
489 /* Manufacture a dummy Python frame to work around Python 2.4 bug,
490 where it insists on having a non-NULL tstate->frame when
491 a generator is called. */
492 #ifndef IS_PY3K
493 dummy_python_frame frame;
494 if (frame.failed ())
495 {
496 gdbpy_print_stack ();
497 return;
498 }
499 #endif
500
501 done_flag = 0;
502 for (i = 0; i < options->print_max; ++i)
503 {
504 PyObject *py_v;
505 const char *name;
506
507 gdbpy_ref<> item (PyIter_Next (iter.get ()));
508 if (item == NULL)
509 {
510 if (PyErr_Occurred ())
511 print_stack_unless_memory_error (stream);
512 /* Set a flag so we can know whether we printed all the
513 available elements. */
514 else
515 done_flag = 1;
516 break;
517 }
518
519 if (! PyTuple_Check (item.get ()) || PyTuple_Size (item.get ()) != 2)
520 {
521 PyErr_SetString (PyExc_TypeError,
522 _("Result of children iterator not a tuple"
523 " of two elements."));
524 gdbpy_print_stack ();
525 continue;
526 }
527 if (! PyArg_ParseTuple (item.get (), "sO", &name, &py_v))
528 {
529 /* The user won't necessarily get a stack trace here, so provide
530 more context. */
531 if (gdbpy_print_python_errors_p ())
532 fprintf_unfiltered (gdb_stderr,
533 _("Bad result from children iterator.\n"));
534 gdbpy_print_stack ();
535 continue;
536 }
537
538 /* Print initial "{". For other elements, there are three
539 cases:
540 1. Maps. Print a "," after each value element.
541 2. Arrays. Always print a ",".
542 3. Other. Always print a ",". */
543 if (i == 0)
544 {
545 if (is_py_none)
546 fputs_filtered ("{", stream);
547 else
548 fputs_filtered (" = {", stream);
549 }
550
551 else if (! is_map || i % 2 == 0)
552 fputs_filtered (pretty ? "," : ", ", stream);
553
554 /* In summary mode, we just want to print "= {...}" if there is
555 a value. */
556 if (options->summary)
557 {
558 /* This increment tricks the post-loop logic to print what
559 we want. */
560 ++i;
561 /* Likewise. */
562 pretty = 0;
563 break;
564 }
565
566 if (! is_map || i % 2 == 0)
567 {
568 if (pretty)
569 {
570 fputs_filtered ("\n", stream);
571 print_spaces_filtered (2 + 2 * recurse, stream);
572 }
573 else
574 wrap_here (n_spaces (2 + 2 *recurse));
575 }
576
577 if (is_map && i % 2 == 0)
578 fputs_filtered ("[", stream);
579 else if (is_array)
580 {
581 /* We print the index, not whatever the child method
582 returned as the name. */
583 if (options->print_array_indexes)
584 fprintf_filtered (stream, "[%d] = ", i);
585 }
586 else if (! is_map)
587 {
588 fputs_filtered (name, stream);
589 fputs_filtered (" = ", stream);
590 }
591
592 if (gdbpy_is_lazy_string (py_v))
593 {
594 CORE_ADDR addr;
595 struct type *type;
596 long length;
597 gdb::unique_xmalloc_ptr<char> encoding;
598 struct value_print_options local_opts = *options;
599
600 gdbpy_extract_lazy_string (py_v, &addr, &type, &length, &encoding);
601
602 local_opts.addressprint = 0;
603 val_print_string (type, encoding.get (), addr, (int) length, stream,
604 &local_opts);
605 }
606 else if (gdbpy_is_string (py_v))
607 {
608 gdb::unique_xmalloc_ptr<char> output;
609
610 output = python_string_to_host_string (py_v);
611 if (!output)
612 gdbpy_print_stack ();
613 else
614 fputs_filtered (output.get (), stream);
615 }
616 else
617 {
618 struct value *value = convert_value_from_python (py_v);
619
620 if (value == NULL)
621 {
622 gdbpy_print_stack ();
623 error (_("Error while executing Python code."));
624 }
625 else
626 common_val_print (value, stream, recurse + 1, options, language);
627 }
628
629 if (is_map && i % 2 == 0)
630 fputs_filtered ("] = ", stream);
631 }
632
633 if (i)
634 {
635 if (!done_flag)
636 {
637 if (pretty)
638 {
639 fputs_filtered ("\n", stream);
640 print_spaces_filtered (2 + 2 * recurse, stream);
641 }
642 fputs_filtered ("...", stream);
643 }
644 if (pretty)
645 {
646 fputs_filtered ("\n", stream);
647 print_spaces_filtered (2 * recurse, stream);
648 }
649 fputs_filtered ("}", stream);
650 }
651 }
652
653 enum ext_lang_rc
654 gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang,
655 struct type *type,
656 LONGEST embedded_offset, CORE_ADDR address,
657 struct ui_file *stream, int recurse,
658 struct value *val,
659 const struct value_print_options *options,
660 const struct language_defn *language)
661 {
662 struct gdbarch *gdbarch = get_type_arch (type);
663 struct value *value;
664 enum string_repr_result print_result;
665 const gdb_byte *valaddr = value_contents_for_printing (val);
666
667 /* No pretty-printer support for unavailable values. */
668 if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
669 return EXT_LANG_RC_NOP;
670
671 if (!gdb_python_initialized)
672 return EXT_LANG_RC_NOP;
673
674 gdbpy_enter enter_py (gdbarch, language);
675
676 /* Instantiate the printer. */
677 value = value_from_component (val, type, embedded_offset);
678
679 gdbpy_ref<> val_obj (value_to_value_object (value));
680 if (val_obj == NULL)
681 {
682 print_stack_unless_memory_error (stream);
683 return EXT_LANG_RC_ERROR;
684 }
685
686 /* Find the constructor. */
687 gdbpy_ref<> printer (find_pretty_printer (val_obj.get ()));
688 if (printer == NULL)
689 {
690 print_stack_unless_memory_error (stream);
691 return EXT_LANG_RC_ERROR;
692 }
693
694 if (printer == Py_None)
695 return EXT_LANG_RC_NOP;
696
697 /* If we are printing a map, we want some special formatting. */
698 gdb::unique_xmalloc_ptr<char> hint (gdbpy_get_display_hint (printer.get ()));
699
700 /* Print the section */
701 print_result = print_string_repr (printer.get (), hint.get (), stream,
702 recurse, options, language, gdbarch);
703 if (print_result != string_repr_error)
704 print_children (printer.get (), hint.get (), stream, recurse, options,
705 language, print_result == string_repr_none);
706
707 if (PyErr_Occurred ())
708 print_stack_unless_memory_error (stream);
709 return EXT_LANG_RC_OK;
710 }
711
712
713 /* Apply a pretty-printer for the varobj code. PRINTER_OBJ is the
714 print object. It must have a 'to_string' method (but this is
715 checked by varobj, not here) which takes no arguments and
716 returns a string. The printer will return a value and in the case
717 of a Python string being returned, this function will return a
718 PyObject containing the string. For any other type, *REPLACEMENT is
719 set to the replacement value and this function returns NULL. On
720 error, *REPLACEMENT is set to NULL and this function also returns
721 NULL. */
722 PyObject *
723 apply_varobj_pretty_printer (PyObject *printer_obj,
724 struct value **replacement,
725 struct ui_file *stream)
726 {
727 PyObject *py_str = NULL;
728
729 *replacement = NULL;
730 py_str = pretty_print_one_value (printer_obj, replacement);
731
732 if (*replacement == NULL && py_str == NULL)
733 print_stack_unless_memory_error (stream);
734
735 return py_str;
736 }
737
738 /* Find a pretty-printer object for the varobj module. Returns a new
739 reference to the object if successful; returns NULL if not. VALUE
740 is the value for which a printer tests to determine if it
741 can pretty-print the value. */
742 PyObject *
743 gdbpy_get_varobj_pretty_printer (struct value *value)
744 {
745 TRY
746 {
747 value = value_copy (value);
748 }
749 CATCH (except, RETURN_MASK_ALL)
750 {
751 GDB_PY_HANDLE_EXCEPTION (except);
752 }
753 END_CATCH
754
755 gdbpy_ref<> val_obj (value_to_value_object (value));
756 if (val_obj == NULL)
757 return NULL;
758
759 return find_pretty_printer (val_obj.get ());
760 }
761
762 /* A Python function which wraps find_pretty_printer and instantiates
763 the resulting class. This accepts a Value argument and returns a
764 pretty printer instance, or None. This function is useful as an
765 argument to the MI command -var-set-visualizer. */
766 PyObject *
767 gdbpy_default_visualizer (PyObject *self, PyObject *args)
768 {
769 PyObject *val_obj;
770 PyObject *cons;
771 struct value *value;
772
773 if (! PyArg_ParseTuple (args, "O", &val_obj))
774 return NULL;
775 value = value_object_to_value (val_obj);
776 if (! value)
777 {
778 PyErr_SetString (PyExc_TypeError,
779 _("Argument must be a gdb.Value."));
780 return NULL;
781 }
782
783 cons = find_pretty_printer (val_obj);
784 return cons;
785 }
gdbarch
Definition: gdbarch.c:127
type::length
unsigned int length
Definition: gdbtypes.h:803
string
const char * string
Definition: signals.c:50
find_pretty_printer_from_gdb
static PyObject * find_pretty_printer_from_gdb(PyObject *value)
Definition: py-prettyprint.c:146
PyObject_GetAttrString
#define PyObject_GetAttrString(obj, attr)
Definition: python-internal.h:217
gdb_python_module
PyObject * gdb_python_module
Definition: python.c:117
Val_prettyformat
Definition: defs.h:443
dummy_python_frame::m_tstate
PyThreadState * m_tstate
Definition: py-prettyprint.c:385
print_stack_unless_memory_error
static void print_stack_unless_memory_error(struct ui_file *stream)
Definition: py-prettyprint.c:253
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
RETURN_MASK_ALL
Definition: common-exceptions.h:44
find_pretty_printer_from_progspace
static PyObject * find_pretty_printer_from_progspace(PyObject *value)
Definition: py-prettyprint.c:129
string_repr_error
Definition: py-prettyprint.c:37
ext_lang_rc
ext_lang_rc
Definition: extension-priv.h:30
value::embedded_offset
LONGEST embedded_offset
Definition: value.c:309
gdbpy_is_string
int gdbpy_is_string(PyObject *obj)
Definition: py-utils.c:173
dummy_python_frame::dummy_python_frame
dummy_python_frame()
Definition: py-prettyprint.c:388
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
common_val_print
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1136
gdbpy_to_string_cst
PyObject * gdbpy_to_string_cst
Definition: python.c:120
gdbpy_enter
Definition: python-internal.h:627
apply_varobj_pretty_printer
PyObject * apply_varobj_pretty_printer(PyObject *printer_obj, struct value **replacement, struct ui_file *stream)
Definition: py-prettyprint.c:723
value_print_options::print_array_indexes
int print_array_indexes
Definition: valprint.h:71
python_string_to_target_python_string
PyObject * python_string_to_target_python_string(PyObject *obj)
Definition: py-utils.c:139
value_copy
struct value * value_copy(struct value *arg)
Definition: value.c:1757
_
#define _(String)
Definition: gdb_locale.h:35
value_contents_for_printing
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1250
ui_file
Definition: ui-file.h:26
gdbpy_display_hint_cst
PyObject * gdbpy_display_hint_cst
Definition: python.c:122
value_bytes_available
int value_bytes_available(const struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:357
defs.h
dummy_python_frame::m_frame
gdbpy_ref m_frame
Definition: py-prettyprint.c:384
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
value_print_options::prettyformat
enum val_prettyformat prettyformat
Definition: valprint.h:28
objfiles.h
language_defn
Definition: language.h:132
gdb::ref_ptr::reset
void reset(T *obj)
Definition: gdb_ref_ptr.h:121
GDB_PY_HANDLE_EXCEPTION
#define GDB_PY_HANDLE_EXCEPTION(Exception)
Definition: python-internal.h:663
TRY
#define TRY
Definition: common-exceptions.h:246
symtab.h
name
const char *const name
Definition: aarch64-tdep.c:76
gdb::ref_ptr< T, gdbpy_ref_policy< T > >
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
value_print_options
Definition: valprint.h:25
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
gdbpy_enabled_cst
PyObject * gdbpy_enabled_cst
Definition: python.c:124
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
dummy_python_frame::m_valid
bool m_valid
Definition: py-prettyprint.c:382
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
dummy_python_frame
Definition: py-prettyprint.c:363
value_print_options::prettyformat_structs
int prettyformat_structs
Definition: valprint.h:34
gdbpy_print_python_errors_p
int gdbpy_print_python_errors_p(void)
Definition: python.c:1252
type
Definition: gdbtypes.h:749
language.h
objfile_to_objfile_object
PyObject * objfile_to_objfile_object(struct objfile *objfile)
Definition: py-objfile.c:624
get_type_arch
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:234
value_print_options::summary
int summary
Definition: valprint.h:90
n_spaces
char * n_spaces(int n)
Definition: utils.c:2099
type
static const char * type
Definition: language.c:113
string_repr_ok
Definition: py-prettyprint.c:39
value_to_value_object
PyObject * value_to_value_object(struct value *val)
Definition: py-value.c:1579
python.h
gdb_python_initialized
int gdb_python_initialized
Definition: python.c:108
python-internal.h
python_string_to_host_string
gdb::unique_xmalloc_ptr< char > python_string_to_host_string(PyObject *obj)
Definition: py-utils.c:152
string_repr_none
Definition: py-prettyprint.c:35
dummy_python_frame::m_saved_frame
PyFrameObject * m_saved_frame
Definition: py-prettyprint.c:383
extension_language_defn
Definition: extension-priv.h:53
value_print_options::addressprint
int addressprint
Definition: valprint.h:43
value
Definition: value.c:169
wrap_here
void wrap_here(const char *indent)
Definition: utils.c:1596
value_ref
struct value * value_ref(struct value *arg1, enum type_code refcode)
Definition: valops.c:1521
objfile
Definition: objfiles.h:286
print_spaces_filtered
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2121
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
gdbpy_extract_lazy_string
void gdbpy_extract_lazy_string(PyObject *string, CORE_ADDR *addr, struct type **str_elt_type, long *length, gdb::unique_xmalloc_ptr< char > *encoding)
Definition: py-lazy-string.c:277
builtin_type::builtin_char
struct type * builtin_char
Definition: gdbtypes.h:1501
gdbpy_children_cst
PyObject * gdbpy_children_cst
Definition: python.c:121
gdbpy_apply_val_pretty_printer
enum ext_lang_rc gdbpy_apply_val_pretty_printer(const struct extension_language_defn *extlang, struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: py-prettyprint.c:654
print_children
static void print_children(PyObject *printer, const char *hint, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language, int is_py_none)
Definition: py-prettyprint.c:445
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
value_print_options::prettyformat_arrays
int prettyformat_arrays
Definition: valprint.h:31
find_pretty_printer
static PyObject * find_pretty_printer(PyObject *value)
Definition: py-prettyprint.c:165
gdbpy_default_visualizer
PyObject * gdbpy_default_visualizer(PyObject *self, PyObject *args)
Definition: py-prettyprint.c:767
gdbpy_get_display_hint
gdb::unique_xmalloc_ptr< char > gdbpy_get_display_hint(PyObject *printer)
Definition: py-prettyprint.c:226
pretty_print_one_value
static PyObject * pretty_print_one_value(PyObject *printer, struct value **out_value)
Definition: py-prettyprint.c:191
gdb::ref_ptr::release
T * release()
Definition: gdb_ref_ptr.h:138
objfpy_get_printers
PyObject * objfpy_get_printers(PyObject *o, void *ignore)
Definition: py-objfile.c:243
gdbpy_print_stack
void gdbpy_print_stack(void)
Definition: python.c:1262
code
int code
Definition: ser-unix.c:239
convert_value_from_python
struct value * convert_value_from_python(PyObject *obj)
Definition: py-value.c:1615
gdbpy_is_lazy_string
int gdbpy_is_lazy_string(PyObject *result)
Definition: py-lazy-string.c:245
dummy_python_frame::~dummy_python_frame
~dummy_python_frame()
Definition: py-prettyprint.c:369
gdb::ref_ptr::get
T * get() const
Definition: gdb_ref_ptr.h:130
gdbpy_gdb_memory_error
PyObject * gdbpy_gdb_memory_error
Definition: python.c:134
extension-priv.h
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
language
language
Definition: defs.h:203
print_string_repr
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, const struct language_defn *language, struct gdbarch *gdbarch)
Definition: py-prettyprint.c:282
value_print_options::print_max
unsigned int print_max
Definition: valprint.h:53
EXT_LANG_RC_NOP
Definition: extension-priv.h:36
dummy_python_frame::failed
bool failed() const
Definition: py-prettyprint.c:375
gdbpy_exception_to_string
gdb::unique_xmalloc_ptr< char > gdbpy_exception_to_string(PyObject *ptype, PyObject *pvalue)
Definition: py-utils.c:212
LA_PRINT_STRING
#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options)
Definition: language.h:529
value_object_to_value
struct value * value_object_to_value(PyObject *self)
Definition: py-value.c:1600
search_pp_list
static PyObject * search_pp_list(PyObject *list, PyObject *value)
Definition: py-prettyprint.c:49
EXT_LANG_RC_OK
Definition: extension-priv.h:33
string_repr_result
string_repr_result
Definition: scm-pretty-print.c:34
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
val_print_string
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:2795
value::address
CORE_ADDR address
Definition: value.c:208
ALL_OBJFILES
#define ALL_OBJFILES(obj)
Definition: objfiles.h:582
valprint.h
gdbpy_get_varobj_pretty_printer
PyObject * gdbpy_get_varobj_pretty_printer(struct value *value)
Definition: py-prettyprint.c:743
py-ref.h
value_from_component
struct value * value_from_component(struct value *whole, struct type *type, LONGEST offset)
Definition: value.c:3699
find_pretty_printer_from_objfiles
static PyObject * find_pretty_printer_from_objfiles(PyObject *value)
Definition: py-prettyprint.c:94
error
void error(const char *fmt,...)
Definition: errors.c:38
pspace_to_pspace_object
PyObject * pspace_to_pspace_object(struct program_space *pspace)
Definition: py-progspace.c:346
PyObject_HasAttrString
#define PyObject_HasAttrString(obj, attr)
Definition: python-internal.h:230
EXT_LANG_RC_ERROR
Definition: extension-priv.h:45
pspy_get_printers
PyObject * pspy_get_printers(PyObject *o, void *ignore)
Definition: py-progspace.c:144
LONGEST
long long LONGEST
Definition: common-types.h:52