1 /* Copyright (C) 2013-2016 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 struct cleanup *back_to = varobj_ensure_python_env (self->var); 42 43 Py_XDECREF (dis->iter); 44 45 do_cleanups (back_to); 46 } 47 48 /* Implementation of the 'next' method of pretty-printed varobj 49 iterators. */ 50 51 static varobj_item * 52 py_varobj_iter_next (struct varobj_iter *self) 53 { 54 struct py_varobj_iter *t = (struct py_varobj_iter *) self; 55 struct cleanup *back_to; 56 PyObject *item; 57 PyObject *py_v; 58 varobj_item *vitem; 59 const char *name = NULL; 60 61 if (!gdb_python_initialized) 62 return NULL; 63 64 back_to = varobj_ensure_python_env (self->var); 65 66 item = PyIter_Next (t->iter); 67 68 if (item == NULL) 69 { 70 /* Normal end of iteration. */ 71 if (!PyErr_Occurred ()) 72 return NULL; 73 74 /* If we got a memory error, just use the text as the item. */ 75 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error)) 76 { 77 PyObject *type, *value, *trace; 78 char *name_str, *value_str; 79 80 PyErr_Fetch (&type, &value, &trace); 81 value_str = gdbpy_exception_to_string (type, value); 82 Py_XDECREF (type); 83 Py_XDECREF (value); 84 Py_XDECREF (trace); 85 if (value_str == NULL) 86 { 87 gdbpy_print_stack (); 88 return NULL; 89 } 90 91 name_str = xstrprintf ("<error at %d>", 92 self->next_raw_index++); 93 item = Py_BuildValue ("(ss)", name_str, value_str); 94 xfree (name_str); 95 xfree (value_str); 96 if (item == NULL) 97 { 98 gdbpy_print_stack (); 99 return NULL; 100 } 101 } 102 else 103 { 104 /* Any other kind of error. */ 105 gdbpy_print_stack (); 106 return NULL; 107 } 108 } 109 110 if (!PyArg_ParseTuple (item, "sO", &name, &py_v)) 111 { 112 gdbpy_print_stack (); 113 error (_("Invalid item from the child list")); 114 } 115 116 vitem = XNEW (struct varobj_item); 117 vitem->value = convert_value_from_python (py_v); 118 if (vitem->value == NULL) 119 gdbpy_print_stack (); 120 vitem->name = xstrdup (name); 121 122 self->next_raw_index++; 123 do_cleanups (back_to); 124 return vitem; 125 } 126 127 /* The 'vtable' of pretty-printed python varobj iterators. */ 128 129 static const struct varobj_iter_ops py_varobj_iter_ops = 130 { 131 py_varobj_iter_dtor, 132 py_varobj_iter_next 133 }; 134 135 /* Constructor of pretty-printed varobj iterators. VAR is the varobj 136 whose children the iterator will be iterating over. PYITER is the 137 python iterator actually responsible for the iteration. */ 138 139 static void CPYCHECKER_STEALS_REFERENCE_TO_ARG (3) 140 py_varobj_iter_ctor (struct py_varobj_iter *self, 141 struct varobj *var, PyObject *pyiter) 142 { 143 self->base.var = var; 144 self->base.ops = &py_varobj_iter_ops; 145 self->base.next_raw_index = 0; 146 self->iter = pyiter; 147 } 148 149 /* Allocate and construct a pretty-printed varobj iterator. VAR is 150 the varobj whose children the iterator will be iterating over. 151 PYITER is the python iterator actually responsible for the 152 iteration. */ 153 154 static struct py_varobj_iter * CPYCHECKER_STEALS_REFERENCE_TO_ARG (2) 155 py_varobj_iter_new (struct varobj *var, PyObject *pyiter) 156 { 157 struct py_varobj_iter *self; 158 159 self = XNEW (struct py_varobj_iter); 160 py_varobj_iter_ctor (self, var, pyiter); 161 return self; 162 } 163 164 /* Return a new pretty-printed varobj iterator suitable to iterate 165 over VAR's children. */ 166 167 struct varobj_iter * 168 py_varobj_get_iterator (struct varobj *var, PyObject *printer) 169 { 170 PyObject *children; 171 PyObject *iter; 172 struct py_varobj_iter *py_iter; 173 struct cleanup *back_to = varobj_ensure_python_env (var); 174 175 if (!PyObject_HasAttr (printer, gdbpy_children_cst)) 176 { 177 do_cleanups (back_to); 178 return NULL; 179 } 180 181 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst, 182 NULL); 183 if (children == NULL) 184 { 185 gdbpy_print_stack (); 186 error (_("Null value returned for children")); 187 } 188 189 make_cleanup_py_decref (children); 190 191 iter = PyObject_GetIter (children); 192 if (iter == NULL) 193 { 194 gdbpy_print_stack (); 195 error (_("Could not get children iterator")); 196 } 197 198 py_iter = py_varobj_iter_new (var, iter); 199 200 do_cleanups (back_to); 201 202 return &py_iter->base; 203 } 204