gdb/python/py-varobj.c

   1 /* Copyright (C) 2013-2017 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           char *name_str;
  75
  76           PyErr_Fetch (&type, &value, &trace);
  77           gdb::unique_xmalloc_ptr<char>
  78             value_str (gdbpy_exception_to_string (type, value));
  79           Py_XDECREF (type);
  80           Py_XDECREF (value);
  81           Py_XDECREF (trace);
  82           if (value_str == NULL)
  83             {
  84               gdbpy_print_stack ();
  85               return NULL;
  86             }
  87
  88           name_str = xstrprintf ("<error at %d>",
  89                                  self->next_raw_index++);
  90           item.reset (Py_BuildValue ("(ss)", name_str, value_str.get ()));
  91           xfree (name_str);
  92           if (item == NULL)
  93             {
  94               gdbpy_print_stack ();
  95               return NULL;
  96             }
  97         }
  98       else
  99         {
 100           /* Any other kind of error.  */
 101           gdbpy_print_stack ();
 102           return NULL;
 103         }
 104     }
 105
 106   if (!PyArg_ParseTuple (item.get (), "sO", &name, &py_v))
 107     {
 108       gdbpy_print_stack ();
 109       error (_("Invalid item from the child list"));
 110     }
 111
 112   vitem = new varobj_item ();
 113   vitem->value = convert_value_from_python (py_v);
 114   if (vitem->value == NULL)
 115     gdbpy_print_stack ();
 116   vitem->name = name;
 117
 118   self->next_raw_index++;
 119   return vitem;
 120 }
 121
 122 /* The 'vtable' of pretty-printed python varobj iterators.  */
 123
 124 static const struct varobj_iter_ops py_varobj_iter_ops =
 125 {
 126   py_varobj_iter_dtor,
 127   py_varobj_iter_next
 128 };
 129
 130 /* Constructor of pretty-printed varobj iterators.  VAR is the varobj
 131    whose children the iterator will be iterating over.  PYITER is the
 132    python iterator actually responsible for the iteration.  */
 133
 134 static void CPYCHECKER_STEALS_REFERENCE_TO_ARG (3)
 135 py_varobj_iter_ctor (struct py_varobj_iter *self,
 136                       struct varobj *var, PyObject *pyiter)
 137 {
 138   self->base.var = var;
 139   self->base.ops = &py_varobj_iter_ops;
 140   self->base.next_raw_index = 0;
 141   self->iter = pyiter;
 142 }
 143
 144 /* Allocate and construct a pretty-printed varobj iterator.  VAR is
 145    the varobj whose children the iterator will be iterating over.
 146    PYITER is the python iterator actually responsible for the
 147    iteration.  */
 148
 149 static struct py_varobj_iter * CPYCHECKER_STEALS_REFERENCE_TO_ARG (2)
 150 py_varobj_iter_new (struct varobj *var, PyObject *pyiter)
 151 {
 152   struct py_varobj_iter *self;
 153
 154   self = XNEW (struct py_varobj_iter);
 155   py_varobj_iter_ctor (self, var, pyiter);
 156   return self;
 157 }
 158
 159 /* Return a new pretty-printed varobj iterator suitable to iterate
 160    over VAR's children.  */
 161
 162 struct varobj_iter *
 163 py_varobj_get_iterator (struct varobj *var, PyObject *printer)
 164 {
 165   PyObject *iter;
 166   struct py_varobj_iter *py_iter;
 167
 168   gdbpy_enter_varobj enter_py (var);
 169
 170   if (!PyObject_HasAttr (printer, gdbpy_children_cst))
 171     return NULL;
 172
 173   gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
 174                                                     NULL));
 175   if (children == NULL)
 176     {
 177       gdbpy_print_stack ();
 178       error (_("Null value returned for children"));
 179     }
 180
 181   iter = PyObject_GetIter (children.get ());
 182   if (iter == NULL)
 183     {
 184       gdbpy_print_stack ();
 185       error (_("Could not get children iterator"));
 186     }
 187
 188   py_iter = py_varobj_iter_new (var, iter);
 189
 190   return &py_iter->base;
 191 }