xref: /netbsd-src/external/gpl3/gdb.old/dist/gdb/python/py-varobj.c (revision 404ee5b9334f618040b6cdef96a0ff35a6fc4636)
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 }
192