gdb/python/py-varobj.c

   1 /* Copyright (C) 2013-2024 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 "python-internal.h"
  17 #include "varobj.h"
  18 #include "varobj-iter.h"
  19 #include "valprint.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 : public varobj_iter
  25 {
  26   py_varobj_iter (struct varobj *var, gdbpy_ref<> &&pyiter,
  27                   const value_print_options *opts);
  28   ~py_varobj_iter () override;
  29
  30   std::unique_ptr<varobj_item> next () override;
  31
  32 private:
  33
  34   /* The varobj this iterator is listing children for.  */
  35   struct varobj *m_var;
  36
  37   /* The next raw index we will try to check is available.  If it is
  38      equal to number_of_children, then we've already iterated the
  39      whole set.  */
  40   int m_next_raw_index = 0;
  41
  42   /* The python iterator returned by the printer's 'children' method,
  43      or NULL if not available.  */
  44   PyObject *m_iter;
  45
  46   /* The print options to use.  */
  47   value_print_options m_opts;
  48 };
  49
  50 /* Implementation of the 'dtor' method of pretty-printed varobj
  51    iterators.  */
  52
  53 py_varobj_iter::~py_varobj_iter ()
  54 {
  55   gdbpy_enter_varobj enter_py (m_var);
  56   Py_XDECREF (m_iter);
  57 }
  58
  59 /* Implementation of the 'next' method of pretty-printed varobj
  60    iterators.  */
  61
  62 std::unique_ptr<varobj_item>
  63 py_varobj_iter::next ()
  64 {
  65   PyObject *py_v;
  66   varobj_item *vitem;
  67   const char *name = NULL;
  68
  69   if (!gdb_python_initialized)
  70     return NULL;
  71
  72   gdbpy_enter_varobj enter_py (m_var);
  73
  74   scoped_restore set_options = make_scoped_restore (&gdbpy_current_print_options,
  75                                                     &m_opts);
  76
  77   gdbpy_ref<> item (PyIter_Next (m_iter));
  78
  79   if (item == NULL)
  80     {
  81       /* Normal end of iteration.  */
  82       if (!PyErr_Occurred ())
  83         return NULL;
  84
  85       /* If we got a memory error, just use the text as the item.  */
  86       if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
  87         {
  88           gdbpy_err_fetch fetched_error;
  89           gdb::unique_xmalloc_ptr<char> value_str = fetched_error.to_string ();
  90           if (value_str == NULL)
  91             {
  92               gdbpy_print_stack ();
  93               return NULL;
  94             }
  95
  96           std::string name_str = string_printf ("<error at %d>",
  97                                                 m_next_raw_index++);
  98           item.reset (Py_BuildValue ("(ss)", name_str.c_str (),
  99                                      value_str.get ()));
 100           if (item == NULL)
 101             {
 102               gdbpy_print_stack ();
 103               return NULL;
 104             }
 105         }
 106       else
 107         {
 108           /* Any other kind of error.  */
 109           gdbpy_print_stack ();
 110           return NULL;
 111         }
 112     }
 113
 114   if (!PyArg_ParseTuple (item.get (), "sO", &name, &py_v))
 115     {
 116       gdbpy_print_stack ();
 117       error (_("Invalid item from the child list"));
 118     }
 119
 120   vitem = new varobj_item ();
 121   vitem->value = release_value (convert_value_from_python (py_v));
 122   if (vitem->value == NULL)
 123     gdbpy_print_stack ();
 124   vitem->name = name;
 125
 126   m_next_raw_index++;
 127   return std::unique_ptr<varobj_item> (vitem);
 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 py_varobj_iter::py_varobj_iter (struct varobj *var, gdbpy_ref<> &&pyiter,
 135                                 const value_print_options *opts)
 136   : m_var (var),
 137     m_iter (pyiter.release ()),
 138     m_opts (*opts)
 139 {
 140 }
 141
 142 /* Return a new pretty-printed varobj iterator suitable to iterate
 143    over VAR's children.  */
 144
 145 std::unique_ptr<varobj_iter>
 146 py_varobj_get_iterator (struct varobj *var, PyObject *printer,
 147                         const value_print_options *opts)
 148 {
 149   gdbpy_enter_varobj enter_py (var);
 150
 151   if (!PyObject_HasAttr (printer, gdbpy_children_cst))
 152     return NULL;
 153
 154   scoped_restore set_options = make_scoped_restore (&gdbpy_current_print_options,
 155                                                     opts);
 156
 157   gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
 158                                                     NULL));
 159   if (children == NULL)
 160     {
 161       gdbpy_print_stack ();
 162       error (_("Null value returned for children"));
 163     }
 164
 165   gdbpy_ref<> iter (PyObject_GetIter (children.get ()));
 166   if (iter == NULL)
 167     {
 168       gdbpy_print_stack ();
 169       error (_("Could not get children iterator"));
 170     }
 171
 172   return std::make_unique<py_varobj_iter> (var, std::move (iter), opts);
 173 }