gdb/python/py-prettyprint.c

   1 /* Python pretty-printing
   2
   3    Copyright (C) 2008, 2009 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
  33 /* Helper function for find_pretty_printer which iterates over a list,
  34    calls each function and inspects output.  This will return a
  35    printer object if one recognizes VALUE.  If no printer is found, it
  36    will return None.  On error, it will set the Python error and
  37    return NULL.  */
  38 static PyObject *
  39 search_pp_list (PyObject *list, PyObject *value)
  40 {
  41   Py_ssize_t pp_list_size, list_index;
  42   PyObject *function, *printer = NULL;
  43
  44   pp_list_size = PyList_Size (list);
  45   for (list_index = 0; list_index < pp_list_size; list_index++)
  46     {
  47       function = PyList_GetItem (list, list_index);
  48       if (! function)
  49         return NULL;
  50
  51       printer = PyObject_CallFunctionObjArgs (function, value, NULL);
  52       if (! printer)
  53         return NULL;
  54       else if (printer != Py_None)
  55         return printer;
  56
  57       Py_DECREF (printer);
  58     }
  59
  60   Py_RETURN_NONE;
  61 }
  62
  63 /* Find the pretty-printing constructor function for VALUE.  If no
  64    pretty-printer exists, return None.  If one exists, return a new
  65    reference.  On error, set the Python error and return NULL.  */
  66 static PyObject *
  67 find_pretty_printer (PyObject *value)
  68 {
  69   PyObject *pp_list = NULL;
  70   PyObject *function = NULL;
  71   struct objfile *obj;
  72   volatile struct gdb_exception except;
  73
  74   /* Look at the pretty-printer dictionary for each objfile.  */
  75   ALL_OBJFILES (obj)
  76   {
  77     PyObject *objf = objfile_to_objfile_object (obj);
  78     if (!objf)
  79       {
  80         /* Ignore the error and continue.  */
  81         PyErr_Clear ();
  82         continue;
  83       }
  84
  85     pp_list = objfpy_get_printers (objf, NULL);
  86     function = search_pp_list (pp_list, value);
  87
  88     /* If there is an error in any objfile list, abort the search and
  89        exit.  */
  90     if (! function)
  91       {
  92         Py_XDECREF (pp_list);
  93         return NULL;
  94       }
  95
  96     if (function != Py_None)
  97       goto done;
  98
  99     Py_DECREF (function);
 100     Py_XDECREF (pp_list);
 101   }
 102
 103   pp_list = NULL;
 104   /* Fetch the global pretty printer dictionary.  */
 105   if (! PyObject_HasAttrString (gdb_module, "pretty_printers"))
 106     {
 107       function = Py_None;
 108       Py_INCREF (function);
 109       goto done;
 110     }
 111   pp_list = PyObject_GetAttrString (gdb_module, "pretty_printers");
 112   if (! pp_list)
 113     goto done;
 114   if (! PyList_Check (pp_list))
 115     goto done;
 116
 117   function = search_pp_list (pp_list, value);
 118
 119  done:
 120   Py_XDECREF (pp_list);
 121
 122   return function;
 123 }
 124 /* Pretty-print a single value, via the printer object PRINTER.
 125    If the function returns a string, a PyObject containing the string
 126    is returned.  Otherwise, if the function returns a value,
 127    *OUT_VALUE is set to the value, and NULL is returned.  On error,
 128    *OUT_VALUE is set to NULL, and NULL is returned.  */
 129 static PyObject *
 130 pretty_print_one_value (PyObject *printer, struct value **out_value)
 131 {
 132   volatile struct gdb_exception except;
 133   PyObject *result = NULL;
 134
 135   *out_value = NULL;
 136   TRY_CATCH (except, RETURN_MASK_ALL)
 137     {
 138       result = PyObject_CallMethodObjArgs (printer, gdbpy_to_string_cst, NULL);
 139       if (result)
 140         {
 141           if (! gdbpy_is_string (result))
 142             {
 143               *out_value = convert_value_from_python (result);
 144               if (PyErr_Occurred ())
 145                 *out_value = NULL;
 146               Py_DECREF (result);
 147               result = NULL;
 148             }
 149         }
 150     }
 151
 152   return result;
 153 }
 154
 155 /* Return the display hint for the object printer, PRINTER.  Return
 156    NULL if there is no display_hint method, or if the method did not
 157    return a string.  On error, print stack trace and return NULL.  On
 158    success, return an xmalloc()d string.  */
 159 char *
 160 gdbpy_get_display_hint (PyObject *printer)
 161 {
 162   PyObject *hint;
 163   char *result = NULL;
 164
 165   if (! PyObject_HasAttr (printer, gdbpy_display_hint_cst))
 166     return NULL;
 167
 168   hint = PyObject_CallMethodObjArgs (printer, gdbpy_display_hint_cst, NULL);
 169   if (gdbpy_is_string (hint))
 170     result = python_string_to_host_string (hint);
 171   if (hint)
 172     Py_DECREF (hint);
 173   else
 174     gdbpy_print_stack ();
 175
 176   return result;
 177 }
 178
 179 /* Helper for apply_val_pretty_printer which calls to_string and
 180    formats the result.  */
 181 static void
 182 print_string_repr (PyObject *printer, const char *hint,
 183                    struct ui_file *stream, int recurse,
 184                    const struct value_print_options *options,
 185                    const struct language_defn *language,
 186                    struct gdbarch *gdbarch)
 187 {
 188   struct value *replacement = NULL;
 189   PyObject *py_str = NULL;
 190
 191   py_str = pretty_print_one_value (printer, &replacement);
 192   if (py_str)
 193     {
 194       PyObject *string = python_string_to_target_python_string (py_str);
 195       if (string)
 196         {
 197           gdb_byte *output = PyString_AsString (string);
 198           int len = PyString_Size (string);
 199
 200           if (hint && !strcmp (hint, "string"))
 201             LA_PRINT_STRING (stream, builtin_type (gdbarch)->builtin_char,
 202                              output, len, 0, options);
 203           else
 204             fputs_filtered (output, stream);
 205           Py_DECREF (string);
 206         }
 207       else
 208         gdbpy_print_stack ();
 209       Py_DECREF (py_str);
 210     }
 211   else if (replacement)
 212     common_val_print (replacement, stream, recurse, options, language);
 213   else
 214     gdbpy_print_stack ();
 215 }
 216
 217 static void
 218 py_restore_tstate (void *p)
 219 {
 220   PyFrameObject *frame = p;
 221   PyThreadState *tstate = PyThreadState_GET ();
 222   tstate->frame = frame;
 223 }
 224
 225 /* Create a dummy PyFrameObject, needed to work around
 226    a Python-2.4 bug with generators.  */
 227 static PyObject *
 228 push_dummy_python_frame ()
 229 {
 230   PyObject *empty_string, *null_tuple, *globals;
 231   PyCodeObject *code;
 232   PyFrameObject *frame;
 233   PyThreadState *tstate;
 234
 235   empty_string = PyString_FromString ("");
 236   if (!empty_string)
 237     return NULL;
 238
 239   null_tuple = PyTuple_New (0);
 240   if (!null_tuple)
 241     {
 242       Py_DECREF (empty_string);
 243       return NULL;
 244     }
 245
 246   code = PyCode_New (0,                 /* argcount */
 247                      0,                 /* nlocals */
 248                      0,                 /* stacksize */
 249                      0,                 /* flags */
 250                      empty_string,      /* code */
 251                      null_tuple,        /* consts */
 252                      null_tuple,        /* names */
 253                      null_tuple,        /* varnames */
 254 #if PYTHON_API_VERSION >= 1010
 255                      null_tuple,        /* freevars */
 256                      null_tuple,        /* cellvars */
 257 #endif
 258                      empty_string,      /* filename */
 259                      empty_string,      /* name */
 260                      1,                 /* firstlineno */
 261                      empty_string       /* lnotab */
 262                     );
 263
 264   Py_DECREF (empty_string);
 265   Py_DECREF (null_tuple);
 266
 267   if (!code)
 268     return NULL;
 269
 270   globals = PyDict_New ();
 271   if (!globals)
 272     {
 273       Py_DECREF (code);
 274       return NULL;
 275     }
 276
 277   tstate = PyThreadState_GET ();
 278
 279   frame = PyFrame_New (tstate, code, globals, NULL);
 280
 281   Py_DECREF (globals);
 282   Py_DECREF (code);
 283
 284   if (!frame)
 285     return NULL;
 286
 287   tstate->frame = frame;
 288   make_cleanup (py_restore_tstate, frame->f_back);
 289   return (PyObject *) frame;
 290 }
 291
 292 /* Helper for apply_val_pretty_printer that formats children of the
 293    printer, if any exist.  */
 294 static void
 295 print_children (PyObject *printer, const char *hint,
 296                 struct ui_file *stream, int recurse,
 297                 const struct value_print_options *options,
 298                 const struct language_defn *language)
 299 {
 300   int is_map, is_array, done_flag, pretty;
 301   unsigned int i;
 302   PyObject *children, *iter, *frame;
 303   struct cleanup *cleanups;
 304
 305   if (! PyObject_HasAttr (printer, gdbpy_children_cst))
 306     return;
 307
 308   /* If we are printing a map or an array, we want some special
 309      formatting.  */
 310   is_map = hint && ! strcmp (hint, "map");
 311   is_array = hint && ! strcmp (hint, "array");
 312
 313   children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
 314                                          NULL);
 315   if (! children)
 316     {
 317       gdbpy_print_stack ();
 318       return;
 319     }
 320
 321   cleanups = make_cleanup_py_decref (children);
 322
 323   iter = PyObject_GetIter (children);
 324   if (!iter)
 325     {
 326       gdbpy_print_stack ();
 327       goto done;
 328     }
 329   make_cleanup_py_decref (iter);
 330
 331   /* Use the prettyprint_arrays option if we are printing an array,
 332      and the pretty option otherwise.  */
 333   pretty = is_array ? options->prettyprint_arrays : options->pretty;
 334
 335   /* Manufacture a dummy Python frame to work around Python 2.4 bug,
 336      where it insists on having a non-NULL tstate->frame when
 337      a generator is called.  */
 338   frame = push_dummy_python_frame ();
 339   if (!frame)
 340     {
 341       gdbpy_print_stack ();
 342       goto done;
 343     }
 344   make_cleanup_py_decref (frame);
 345
 346   done_flag = 0;
 347   for (i = 0; i < options->print_max; ++i)
 348     {
 349       PyObject *py_v, *item = PyIter_Next (iter);
 350       char *name;
 351       struct cleanup *inner_cleanup;
 352
 353       if (! item)
 354         {
 355           if (PyErr_Occurred ())
 356             gdbpy_print_stack ();
 357           /* Set a flag so we can know whether we printed all the
 358              available elements.  */
 359           else
 360             done_flag = 1;
 361           break;
 362         }
 363
 364       if (! PyArg_ParseTuple (item, "sO", &name, &py_v))
 365         {
 366           gdbpy_print_stack ();
 367           Py_DECREF (item);
 368           continue;
 369         }
 370       inner_cleanup = make_cleanup_py_decref (item);
 371
 372       /* Print initial "{".  For other elements, there are three
 373          cases:
 374          1. Maps.  Print a "," after each value element.
 375          2. Arrays.  Always print a ",".
 376          3. Other.  Always print a ",".  */
 377       if (i == 0)
 378         fputs_filtered (" = {", stream);
 379       else if (! is_map || i % 2 == 0)
 380         fputs_filtered (pretty ? "," : ", ", stream);
 381
 382       /* In summary mode, we just want to print "= {...}" if there is
 383          a value.  */
 384       if (options->summary)
 385         {
 386           /* This increment tricks the post-loop logic to print what
 387              we want.  */
 388           ++i;
 389           /* Likewise.  */
 390           pretty = 0;
 391           break;
 392         }
 393
 394       if (! is_map || i % 2 == 0)
 395         {
 396           if (pretty)
 397             {
 398               fputs_filtered ("\n", stream);
 399               print_spaces_filtered (2 + 2 * recurse, stream);
 400             }
 401           else
 402             wrap_here (n_spaces (2 + 2 *recurse));
 403         }
 404
 405       if (is_map && i % 2 == 0)
 406         fputs_filtered ("[", stream);
 407       else if (is_array)
 408         {
 409           /* We print the index, not whatever the child method
 410              returned as the name.  */
 411           if (options->print_array_indexes)
 412             fprintf_filtered (stream, "[%d] = ", i);
 413         }
 414       else if (! is_map)
 415         {
 416           fputs_filtered (name, stream);
 417           fputs_filtered (" = ", stream);
 418         }
 419
 420       if (gdbpy_is_string (py_v))
 421         {
 422           char *text = python_string_to_host_string (py_v);
 423           if (! text)
 424             gdbpy_print_stack ();
 425           else
 426             {
 427               fputs_filtered (text, stream);
 428               xfree (text);
 429             }
 430         }
 431       else
 432         {
 433           struct value *value = convert_value_from_python (py_v);
 434
 435           if (value == NULL)
 436             {
 437               gdbpy_print_stack ();
 438               error (_("Error while executing Python code."));
 439             }
 440           else
 441             common_val_print (value, stream, recurse + 1, options, language);
 442         }
 443
 444       if (is_map && i % 2 == 0)
 445         fputs_filtered ("] = ", stream);
 446
 447       do_cleanups (inner_cleanup);
 448     }
 449
 450   if (i)
 451     {
 452       if (!done_flag)
 453         {
 454           if (pretty)
 455             {
 456               fputs_filtered ("\n", stream);
 457               print_spaces_filtered (2 + 2 * recurse, stream);
 458             }
 459           fputs_filtered ("...", stream);
 460         }
 461       if (pretty)
 462         {
 463           fputs_filtered ("\n", stream);
 464           print_spaces_filtered (2 * recurse, stream);
 465         }
 466       fputs_filtered ("}", stream);
 467     }
 468
 469  done:
 470   do_cleanups (cleanups);
 471 }
 472
 473 int
 474 apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
 475                           int embedded_offset, CORE_ADDR address,
 476                           struct ui_file *stream, int recurse,
 477                           const struct value_print_options *options,
 478                           const struct language_defn *language)
 479 {
 480   struct gdbarch *gdbarch = get_type_arch (type);
 481   PyObject *printer = NULL;
 482   PyObject *val_obj = NULL;
 483   struct value *value;
 484   char *hint = NULL;
 485   struct cleanup *cleanups;
 486   int result = 0;
 487
 488   cleanups = ensure_python_env (gdbarch, language);
 489
 490   /* Instantiate the printer.  */
 491   if (valaddr)
 492     valaddr += embedded_offset;
 493   value = value_from_contents_and_address (type, valaddr, address);
 494
 495   val_obj = value_to_value_object (value);
 496   if (! val_obj)
 497     goto done;
 498
 499   /* Find the constructor.  */
 500   printer = find_pretty_printer (val_obj);
 501   Py_DECREF (val_obj);
 502   make_cleanup_py_decref (printer);
 503   if (! printer || printer == Py_None)
 504     goto done;
 505
 506   /* If we are printing a map, we want some special formatting.  */
 507   hint = gdbpy_get_display_hint (printer);
 508   make_cleanup (free_current_contents, &hint);
 509
 510   /* Print the section */
 511   print_string_repr (printer, hint, stream, recurse, options, language,
 512                      gdbarch);
 513   print_children (printer, hint, stream, recurse, options, language);
 514   result = 1;
 515
 516
 517  done:
 518   if (PyErr_Occurred ())
 519     gdbpy_print_stack ();
 520   do_cleanups (cleanups);
 521   return result;
 522 }
 523
 524
 525 /* Apply a pretty-printer for the varobj code.  PRINTER_OBJ is the
 526    print object.  It must have a 'to_string' method (but this is
 527    checked by varobj, not here) which takes no arguments and
 528    returns a string.  The printer will return a value and in the case
 529    of a Python string being returned, this function will return a
 530    PyObject containing the string.  For any other type, *REPLACEMENT is
 531    set to the replacement value and this function returns NULL.  On
 532    error, *REPLACEMENT is set to NULL and this function also returns
 533    NULL.  */
 534 PyObject *
 535 apply_varobj_pretty_printer (PyObject *printer_obj,
 536                              struct value **replacement)
 537 {
 538   int size = 0;
 539   PyObject *py_str = NULL;
 540
 541   *replacement = NULL;
 542   py_str = pretty_print_one_value (printer_obj, replacement);
 543
 544   if (*replacement == NULL && py_str == NULL)
 545     gdbpy_print_stack ();
 546
 547   return py_str;
 548 }
 549
 550 /* Find a pretty-printer object for the varobj module.  Returns a new
 551    reference to the object if successful; returns NULL if not.  VALUE
 552    is the value for which a printer tests to determine if it
 553    can pretty-print the value.  */
 554 PyObject *
 555 gdbpy_get_varobj_pretty_printer (struct value *value)
 556 {
 557   PyObject *val_obj;
 558   PyObject *pretty_printer = NULL;
 559   volatile struct gdb_exception except;
 560
 561   TRY_CATCH (except, RETURN_MASK_ALL)
 562     {
 563       value = value_copy (value);
 564     }
 565   GDB_PY_HANDLE_EXCEPTION (except);
 566
 567   val_obj = value_to_value_object (value);
 568   if (! val_obj)
 569     return NULL;
 570
 571   pretty_printer = find_pretty_printer (val_obj);
 572   Py_DECREF (val_obj);
 573   return pretty_printer;
 574 }
 575
 576 /* A Python function which wraps find_pretty_printer and instantiates
 577    the resulting class.  This accepts a Value argument and returns a
 578    pretty printer instance, or None.  This function is useful as an
 579    argument to the MI command -var-set-visualizer.  */
 580 PyObject *
 581 gdbpy_default_visualizer (PyObject *self, PyObject *args)
 582 {
 583   PyObject *val_obj;
 584   PyObject *cons, *printer = NULL;
 585   struct value *value;
 586
 587   if (! PyArg_ParseTuple (args, "O", &val_obj))
 588     return NULL;
 589   value = value_object_to_value (val_obj);
 590   if (! value)
 591     {
 592       PyErr_SetString (PyExc_TypeError, "argument must be a gdb.Value");
 593       return NULL;
 594     }
 595
 596   cons = find_pretty_printer (val_obj);
 597   return cons;
 598 }
 599
 600 #else /* HAVE_PYTHON */
 601
 602 int
 603 apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr,
 604                           int embedded_offset, CORE_ADDR address,
 605                           struct ui_file *stream, int recurse,
 606                           const struct value_print_options *options,
 607                           const struct language_defn *language)
 608 {
 609   return 0;
 610 }
 611
 612 #endif /* HAVE_PYTHON */