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
  21 /* A dynamic varobj iterator "class" for python pretty-printed
  22    varobjs.  This inherits struct varobj_iter.  */
  23
  24 struct py_varobj_iter
  25 {
  26   /* The 'base class'.  */
  27   struct varobj_iter base;
  28
  29   /* The python iterator returned by the printer's 'children' method,
  30      or NULL if not available.  */
  31   PyObject *iter;
  32 };
  33
  34 /* Implementation of the 'dtor' method of pretty-printed varobj
  35    iterators.  */
  36
  37 static void
  38 py_varobj_iter_dtor (struct varobj_iter *self)
  39 {
  40   struct py_varobj_iter *dis = (struct py_varobj_iter *) self;
  41   gdbpy_enter_varobj enter_py (self->var);
  42   Py_XDECREF (dis->iter);
  43 }
  44
  45 /* Implementation of the 'next' method of pretty-printed varobj
  46    iterators.  */
  47
  48 static varobj_item *
  49 py_varobj_iter_next (struct varobj_iter *self)
  50 {
  51   struct py_varobj_iter *t = (struct py_varobj_iter *) self;
  52   PyObject *py_v;
  53   varobj_item *vitem;
  54   const char *name = NULL;
  55
  56   if (!gdb_python_initialized)
  57     return NULL;
  58
  59   gdbpy_enter_varobj enter_py (self->var);
  60
  61   gdbpy_ref<> item (PyIter_Next (t->iter));
  62
  63   if (item == NULL)
  64     {
  65       /* Normal end of iteration.  */
  66       if (!PyErr_Occurred ())
  67         return NULL;
  68
  69       /* If we got a memory error, just use the text as the item.  */
  70       if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
  71         {
  72           gdbpy_err_fetch fetched_error;
  73           gdb::unique_xmalloc_ptr<char> value_str = fetched_error.to_string ();
  74           if (value_str == NULL)
  75             {
  76               gdbpy_print_stack ();
  77               return NULL;
  78             }
  79
  80           std::string name_str = string_printf ("<error at %d>",
  81                                                 self->next_raw_index++);
  82           item.reset (Py_BuildValue ("(ss)", name_str.c_str (),
  83                                      value_str.get ()));
  84           if (item == NULL)
  85             {
  86               gdbpy_print_stack ();
  87               return NULL;
  88             }
  89         }
  90       else
  91         {
  92           /* Any other kind of error.  */
  93           gdbpy_print_stack ();
  94           return NULL;
  95         }
  96     }
  97
  98   if (!PyArg_ParseTuple (item.get (), "sO", &name, &py_v))
  99     {
 100       gdbpy_print_stack ();
 101       error (_("Invalid item from the child list"));
 102     }
 103
 104   vitem = new varobj_item ();
 105   vitem->value = convert_value_from_python (py_v);
 106   if (vitem->value == NULL)
 107     gdbpy_print_stack ();
 108   vitem->name = name;
 109
 110   self->next_raw_index++;
 111   return vitem;
 112 }
 113
 114 /* The 'vtable' of pretty-printed python varobj iterators.  */
 115
 116 static const struct varobj_iter_ops py_varobj_iter_ops =
 117 {
 118   py_varobj_iter_dtor,
 119   py_varobj_iter_next
 120 };
 121
 122 /* Constructor of pretty-printed varobj iterators.  VAR is the varobj
 123    whose children the iterator will be iterating over.  PYITER is the
 124    python iterator actually responsible for the iteration.  */
 125
 126 static void
 127 py_varobj_iter_ctor (struct py_varobj_iter *self,
 128                      struct varobj *var, gdbpy_ref<> &&pyiter)
 129 {
 130   self->base.var = var;
 131   self->base.ops = &py_varobj_iter_ops;
 132   self->base.next_raw_index = 0;
 133   self->iter = pyiter.release ();
 134 }
 135
 136 /* Allocate and construct a pretty-printed varobj iterator.  VAR is
 137    the varobj whose children the iterator will be iterating over.
 138    PYITER is the python iterator actually responsible for the
 139    iteration.  */
 140
 141 static struct py_varobj_iter *
 142 py_varobj_iter_new (struct varobj *var, gdbpy_ref<> &&pyiter)
 143 {
 144   struct py_varobj_iter *self;
 145
 146   self = XNEW (struct py_varobj_iter);
 147   py_varobj_iter_ctor (self, var, std::move (pyiter));
 148   return self;
 149 }
 150
 151 /* Return a new pretty-printed varobj iterator suitable to iterate
 152    over VAR's children.  */
 153
 154 struct varobj_iter *
 155 py_varobj_get_iterator (struct varobj *var, PyObject *printer)
 156 {
 157   struct py_varobj_iter *py_iter;
 158
 159   gdbpy_enter_varobj enter_py (var);
 160
 161   if (!PyObject_HasAttr (printer, gdbpy_children_cst))
 162     return NULL;
 163
 164   gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
 165                                                     NULL));
 166   if (children == NULL)
 167     {
 168       gdbpy_print_stack ();
 169       error (_("Null value returned for children"));
 170     }
 171
 172   gdbpy_ref<> iter (PyObject_GetIter (children.get ()));
 173   if (iter == NULL)
 174     {
 175       gdbpy_print_stack ();
 176       error (_("Could not get children iterator"));
 177     }
 178
 179   py_iter = py_varobj_iter_new (var, std::move (iter));
 180
 181   return &py_iter->base;
 182 }