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