1 /* Convenience functions implemented in Python. 2 3 Copyright (C) 2008-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 21 #include "defs.h" 22 #include "value.h" 23 #include "exceptions.h" 24 #include "python-internal.h" 25 #include "charset.h" 26 #include "gdbcmd.h" 27 #include "cli/cli-decode.h" 28 #include "completer.h" 29 #include "expression.h" 30 #include "language.h" 31 32 static PyTypeObject fnpy_object_type; 33 34 35 36 static PyObject * 37 convert_values_to_python (int argc, struct value **argv) 38 { 39 int i; 40 PyObject *result = PyTuple_New (argc); 41 42 if (! result) 43 return NULL; 44 45 for (i = 0; i < argc; ++i) 46 { 47 PyObject *elt = value_to_value_object (argv[i]); 48 if (! elt) 49 { 50 Py_DECREF (result); 51 return NULL; 52 } 53 PyTuple_SetItem (result, i, elt); 54 } 55 return result; 56 } 57 58 /* Call a Python function object's invoke method. */ 59 60 static struct value * 61 fnpy_call (struct gdbarch *gdbarch, const struct language_defn *language, 62 void *cookie, int argc, struct value **argv) 63 { 64 struct value *value = NULL; 65 /* 'result' must be set to NULL, this initially indicates whether 66 the function was called, or not. */ 67 PyObject *result = NULL; 68 PyObject *callable, *args; 69 struct cleanup *cleanup; 70 71 cleanup = ensure_python_env (gdbarch, language); 72 73 args = convert_values_to_python (argc, argv); 74 /* convert_values_to_python can return NULL on error. If we 75 encounter this, do not call the function, but allow the Python -> 76 error code conversion below to deal with the Python exception. 77 Note, that this is different if the function simply does not 78 have arguments. */ 79 80 if (args) 81 { 82 callable = PyObject_GetAttrString ((PyObject *) cookie, "invoke"); 83 if (! callable) 84 { 85 Py_DECREF (args); 86 error (_("No method named 'invoke' in object.")); 87 } 88 89 result = PyObject_Call (callable, args, NULL); 90 Py_DECREF (callable); 91 Py_DECREF (args); 92 } 93 94 if (!result) 95 { 96 PyObject *ptype, *pvalue, *ptraceback; 97 char *msg; 98 99 PyErr_Fetch (&ptype, &pvalue, &ptraceback); 100 101 /* Try to fetch an error message contained within ptype, pvalue. 102 When fetching the error message we need to make our own copy, 103 we no longer own ptype, pvalue after the call to PyErr_Restore. */ 104 105 msg = gdbpy_exception_to_string (ptype, pvalue); 106 make_cleanup (xfree, msg); 107 108 if (msg == NULL) 109 { 110 /* An error occurred computing the string representation of the 111 error message. This is rare, but we should inform the user. */ 112 113 printf_filtered (_("An error occurred in a Python " 114 "convenience function\n" 115 "and then another occurred computing the " 116 "error message.\n")); 117 gdbpy_print_stack (); 118 } 119 120 /* Don't print the stack for gdb.GdbError exceptions. 121 It is generally used to flag user errors. 122 123 We also don't want to print "Error occurred in Python command" 124 for user errors. However, a missing message for gdb.GdbError 125 exceptions is arguably a bug, so we flag it as such. */ 126 127 if (!PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc) 128 || msg == NULL || *msg == '\0') 129 { 130 PyErr_Restore (ptype, pvalue, ptraceback); 131 gdbpy_print_stack (); 132 if (msg != NULL && *msg != '\0') 133 error (_("Error occurred in Python convenience function: %s"), 134 msg); 135 else 136 error (_("Error occurred in Python convenience function.")); 137 } 138 else 139 { 140 Py_XDECREF (ptype); 141 Py_XDECREF (pvalue); 142 Py_XDECREF (ptraceback); 143 error ("%s", msg); 144 } 145 } 146 147 value = convert_value_from_python (result); 148 if (value == NULL) 149 { 150 Py_DECREF (result); 151 gdbpy_print_stack (); 152 error (_("Error while executing Python code.")); 153 } 154 155 Py_DECREF (result); 156 do_cleanups (cleanup); 157 158 return value; 159 } 160 161 /* Initializer for a Function object. It takes one argument, the name 162 of the function. */ 163 164 static int 165 fnpy_init (PyObject *self, PyObject *args, PyObject *kwds) 166 { 167 const char *name; 168 char *docstring = NULL; 169 170 if (! PyArg_ParseTuple (args, "s", &name)) 171 return -1; 172 Py_INCREF (self); 173 174 if (PyObject_HasAttrString (self, "__doc__")) 175 { 176 PyObject *ds_obj = PyObject_GetAttrString (self, "__doc__"); 177 if (ds_obj && gdbpy_is_string (ds_obj)) 178 { 179 docstring = python_string_to_host_string (ds_obj); 180 if (docstring == NULL) 181 { 182 Py_DECREF (self); 183 return -1; 184 } 185 } 186 } 187 if (! docstring) 188 docstring = xstrdup (_("This function is not documented.")); 189 190 add_internal_function (name, docstring, fnpy_call, self); 191 return 0; 192 } 193 194 /* Initialize internal function support. */ 195 196 void 197 gdbpy_initialize_functions (void) 198 { 199 fnpy_object_type.tp_new = PyType_GenericNew; 200 if (PyType_Ready (&fnpy_object_type) < 0) 201 return; 202 203 Py_INCREF (&fnpy_object_type); 204 PyModule_AddObject (gdb_module, "Function", (PyObject *) &fnpy_object_type); 205 } 206 207 208 209 static PyTypeObject fnpy_object_type = 210 { 211 PyVarObject_HEAD_INIT (NULL, 0) 212 "gdb.Function", /*tp_name*/ 213 sizeof (PyObject), /*tp_basicsize*/ 214 0, /*tp_itemsize*/ 215 0, /*tp_dealloc*/ 216 0, /*tp_print*/ 217 0, /*tp_getattr*/ 218 0, /*tp_setattr*/ 219 0, /*tp_compare*/ 220 0, /*tp_repr*/ 221 0, /*tp_as_number*/ 222 0, /*tp_as_sequence*/ 223 0, /*tp_as_mapping*/ 224 0, /*tp_hash */ 225 0, /*tp_call*/ 226 0, /*tp_str*/ 227 0, /*tp_getattro*/ 228 0, /*tp_setattro*/ 229 0, /*tp_as_buffer*/ 230 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 231 "GDB function object", /* tp_doc */ 232 0, /* tp_traverse */ 233 0, /* tp_clear */ 234 0, /* tp_richcompare */ 235 0, /* tp_weaklistoffset */ 236 0, /* tp_iter */ 237 0, /* tp_iternext */ 238 0, /* tp_methods */ 239 0, /* tp_members */ 240 0, /* tp_getset */ 241 0, /* tp_base */ 242 0, /* tp_dict */ 243 0, /* tp_descr_get */ 244 0, /* tp_descr_set */ 245 0, /* tp_dictoffset */ 246 fnpy_init, /* tp_init */ 247 0, /* tp_alloc */ 248 }; 249