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
~py_varobj_iter()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>
next()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
py_varobj_iter(struct varobj * var,gdbpy_ref<> && pyiter,const value_print_options * opts)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>
py_varobj_get_iterator(struct varobj * var,PyObject * printer,const value_print_options * opts)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 }
174