gdb/python/py-varobj.c

   1 /* Copyright (C) 2013-2018 Free Software Foundation, Inc.
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; either version 3 of the License, or
   6    (at your option) any later version.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  15
  16 #include "defs.h"
  17 #include "python-internal.h"
  18 #include "varobj.h"
  19 #include "varobj-iter.h"
  20 #include "py-ref.h"
  21
  22 /* A dynamic varobj iterator "class" for python pretty-printed
  23    varobjs.  This inherits struct varobj_iter.  */
  24
  25 struct py_varobj_iter
  26 {
  27   /* The 'base class'.  */
  28   struct varobj_iter base;
  29
  30   /* The python iterator returned by the printer's 'children' method,
  31      or NULL if not available.  */
  32   PyObject *iter;
  33 };
  34
  35 /* Implementation of the 'dtor' method of pretty-printed varobj
  36    iterators.  */
  37
  38 static void
  39 py_varobj_iter_dtor (struct varobj_iter *self)
  40 {
  41   struct py_varobj_iter *dis = (struct py_varobj_iter *) self;
  42   gdbpy_enter_varobj enter_py (self->var);
  43   Py_XDECREF (dis->iter);
  44 }
  45
  46 /* Implementation of the 'next' method of pretty-printed varobj
  47    iterators.  */
  48
  49 static varobj_item *
  50 py_varobj_iter_next (struct varobj_iter *self)
  51 {
  52   struct py_varobj_iter *t = (struct py_varobj_iter *) self;
  53   PyObject *py_v;
  54   varobj_item *vitem;
  55   const char *name = NULL;
  56
  57   if (!gdb_python_initialized)
  58     return NULL;
  59
  60   gdbpy_enter_varobj enter_py (self->var);
  61
  62   gdbpy_ref<> item (PyIter_Next (t->iter));
  63
  64   if (item == NULL)
  65     {
  66       /* Normal end of iteration.  */
  67       if (!PyErr_Occurred ())
  68         return NULL;
  69
  70       /* If we got a memory error, just use the text as the item.  */
  71       if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
  72         {
  73           PyObject *type, *value, *trace;
  74
  75           PyErr_Fetch (&type, &value, &trace);
  76           gdb::unique_xmalloc_ptr<char>
  77             value_str (gdbpy_exception_to_string (type, value));
  78           Py_XDECREF (type);
  79           Py_XDECREF (value);
  80           Py_XDECREF (trace);
  81           if (value_str == NULL)
  82             {
  83               gdbpy_print_stack ();
  84               return NULL;
  85             }
  86
  87           std::string name_str = string_printf ("<error at %d>",
  88                                                 self->next_raw_index++);
  89           item.reset (Py_BuildValue ("(ss)", name_str.c_str (),
  90                                      value_str.get ()));
  91           if (item == NULL)
  92             {
  93               gdbpy_print_stack ();
  94               return NULL;
  95             }
  96         }
  97       else
  98         {
  99           /* Any other kind of error.  */
 100           gdbpy_print_stack ();
 101           return NULL;
 102         }
 103     }
 104
 105   if (!PyArg_ParseTuple (item.get (), "sO", &name, &py_v))
 106     {
 107       gdbpy_print_stack ();
 108       error (_("Invalid item from the child list"));
 109     }
 110
 111   vitem = new varobj_item ();
 112   vitem->value = convert_value_from_python (py_v);
 113   if (vitem->value == NULL)
 114     gdbpy_print_stack ();
 115   vitem->name = name;
 116
 117   self->next_raw_index++;
 118   return vitem;
 119 }
 120
 121 /* The 'vtable' of pretty-printed python varobj iterators.  */
 122
 123 static const struct varobj_iter_ops py_varobj_iter_ops =
 124 {
 125   py_varobj_iter_dtor,
 126   py_varobj_iter_next
 127 };
 128
 129 /* Constructor of pretty-printed varobj iterators.  VAR is the varobj
 130    whose children the iterator will be iterating over.  PYITER is the
 131    python iterator actually responsible for the iteration.  */
 132
 133 static void
 134 py_varobj_iter_ctor (struct py_varobj_iter *self,
 135                      struct varobj *var, gdbpy_ref<> &&pyiter)
 136 {
 137   self->base.var = var;
 138   self->base.ops = &py_varobj_iter_ops;
 139   self->base.next_raw_index = 0;
 140   self->iter = pyiter.release ();
 141 }
 142
 143 /* Allocate and construct a pretty-printed varobj iterator.  VAR is
 144    the varobj whose children the iterator will be iterating over.
 145    PYITER is the python iterator actually responsible for the
 146    iteration.  */
 147
 148 static struct py_varobj_iter *
 149 py_varobj_iter_new (struct varobj *var, gdbpy_ref<> &&pyiter)
 150 {
 151   struct py_varobj_iter *self;
 152
 153   self = XNEW (struct py_varobj_iter);
 154   py_varobj_iter_ctor (self, var, std::move (pyiter));
 155   return self;
 156 }
 157
 158 /* Return a new pretty-printed varobj iterator suitable to iterate
 159    over VAR's children.  */
 160
 161 struct varobj_iter *
 162 py_varobj_get_iterator (struct varobj *var, PyObject *printer)
 163 {
 164   struct py_varobj_iter *py_iter;
 165
 166   gdbpy_enter_varobj enter_py (var);
 167
 168   if (!PyObject_HasAttr (printer, gdbpy_children_cst))
 169     return NULL;
 170
 171   gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
 172                                                     NULL));
 173   if (children == NULL)
 174     {
 175       gdbpy_print_stack ();
 176       error (_("Null value returned for children"));
 177     }
 178
 179   gdbpy_ref<> iter (PyObject_GetIter (children.get ()));
 180   if (iter == NULL)
 181     {
 182       gdbpy_print_stack ();
 183       error (_("Could not get children iterator"));
 184     }
 185
 186   py_iter = py_varobj_iter_new (var, std::move (iter));
 187
 188   return &py_iter->base;
 189 }