gdb/python/py-varobj.c

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