static void print_stack_unless_memory_error (struct ui_file *stream) { if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error)) { PyObject *type, *value, *trace; PyErr_Fetch (&type, &value, &trace); gdbpy_ref<> type_ref (type); gdbpy_ref<> value_ref (value); gdbpy_ref<> trace_ref (trace); gdb::unique_xmalloc_ptr<char> msg (gdbpy_exception_to_string (type, value)); if (msg == NULL || *msg == '\0') fprintf_filtered (stream, _("<error reading variable>")); else fprintf_filtered (stream, _("<error reading variable: %s>"), msg.get ()); } else gdbpy_print_stack (); }
static void print_stack_unless_memory_error (struct ui_file *stream) { if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error)) { struct cleanup *cleanup; PyObject *type, *value, *trace; char *msg; PyErr_Fetch (&type, &value, &trace); cleanup = make_cleanup_py_decref (type); make_cleanup_py_decref (value); make_cleanup_py_decref (trace); msg = gdbpy_exception_to_string (type, value); make_cleanup (xfree, msg); if (msg == NULL || *msg == '\0') fprintf_filtered (stream, _("<error reading variable>")); else fprintf_filtered (stream, _("<error reading variable: %s>"), msg); do_cleanups (cleanup); } else gdbpy_print_stack (); }
static varobj_item * py_varobj_iter_next (struct varobj_iter *self) { struct py_varobj_iter *t = (struct py_varobj_iter *) self; struct cleanup *back_to; PyObject *item; PyObject *py_v; varobj_item *vitem; const char *name = NULL; if (!gdb_python_initialized) return NULL; back_to = varobj_ensure_python_env (self->var); item = PyIter_Next (t->iter); if (item == NULL) { /* Normal end of iteration. */ if (!PyErr_Occurred ()) return NULL; /* If we got a memory error, just use the text as the item. */ if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error)) { PyObject *type, *value, *trace; char *name_str, *value_str; PyErr_Fetch (&type, &value, &trace); value_str = gdbpy_exception_to_string (type, value); Py_XDECREF (type); Py_XDECREF (value); Py_XDECREF (trace); if (value_str == NULL) { gdbpy_print_stack (); return NULL; } name_str = xstrprintf ("<error at %d>", self->next_raw_index++); item = Py_BuildValue ("(ss)", name_str, value_str); xfree (name_str); xfree (value_str); if (item == NULL) { gdbpy_print_stack (); return NULL; } } else { /* Any other kind of error. */ gdbpy_print_stack (); return NULL; } } if (!PyArg_ParseTuple (item, "sO", &name, &py_v)) { gdbpy_print_stack (); error (_("Invalid item from the child list")); } vitem = XNEW (struct varobj_item); vitem->value = convert_value_from_python (py_v); if (vitem->value == NULL) gdbpy_print_stack (); vitem->name = xstrdup (name); self->next_raw_index++; do_cleanups (back_to); return vitem; }
static struct value * fnpy_call (struct gdbarch *gdbarch, const struct language_defn *language, void *cookie, int argc, struct value **argv) { /* The gdbpy_enter object needs to be placed first, so that it's the last to be destroyed. */ gdbpy_enter enter_py (gdbarch, language); struct value *value; gdbpy_ref<> result; gdbpy_ref<> args (convert_values_to_python (argc, argv)); /* convert_values_to_python can return NULL on error. If we encounter this, do not call the function, but allow the Python -> error code conversion below to deal with the Python exception. Note, that this is different if the function simply does not have arguments. */ if (args != NULL) { gdbpy_ref<> callable (PyObject_GetAttrString ((PyObject *) cookie, "invoke")); if (callable == NULL) error (_("No method named 'invoke' in object.")); result.reset (PyObject_Call (callable.get (), args.get (), NULL)); } if (result == NULL) { PyObject *ptype, *pvalue, *ptraceback; PyErr_Fetch (&ptype, &pvalue, &ptraceback); /* Try to fetch an error message contained within ptype, pvalue. When fetching the error message we need to make our own copy, we no longer own ptype, pvalue after the call to PyErr_Restore. */ gdb::unique_xmalloc_ptr<char> msg (gdbpy_exception_to_string (ptype, pvalue)); if (msg == NULL) { /* An error occurred computing the string representation of the error message. This is rare, but we should inform the user. */ printf_filtered (_("An error occurred in a Python " "convenience function\n" "and then another occurred computing the " "error message.\n")); gdbpy_print_stack (); } /* Don't print the stack for gdb.GdbError exceptions. It is generally used to flag user errors. We also don't want to print "Error occurred in Python command" for user errors. However, a missing message for gdb.GdbError exceptions is arguably a bug, so we flag it as such. */ if (!PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc) || msg == NULL || *msg == '\0') { PyErr_Restore (ptype, pvalue, ptraceback); gdbpy_print_stack (); if (msg != NULL && *msg != '\0') error (_("Error occurred in Python convenience function: %s"), msg.get ()); else error (_("Error occurred in Python convenience function.")); } else { Py_XDECREF (ptype); Py_XDECREF (pvalue); Py_XDECREF (ptraceback); error ("%s", msg.get ()); } } value = convert_value_from_python (result.get ()); if (value == NULL) { gdbpy_print_stack (); error (_("Error while executing Python code.")); } return value; }
static struct value * fnpy_call (struct gdbarch *gdbarch, const struct language_defn *language, void *cookie, int argc, struct value **argv) { struct value *value = NULL; /* 'result' must be set to NULL, this initially indicates whether the function was called, or not. */ PyObject *result = NULL; PyObject *callable, *args; struct cleanup *cleanup; cleanup = ensure_python_env (gdbarch, language); args = convert_values_to_python (argc, argv); /* convert_values_to_python can return NULL on error. If we encounter this, do not call the function, but allow the Python -> error code conversion below to deal with the Python exception. Note, that this is different if the function simply does not have arguments. */ if (args) { callable = PyObject_GetAttrString ((PyObject *) cookie, "invoke"); if (! callable) { Py_DECREF (args); error (_("No method named 'invoke' in object.")); } result = PyObject_Call (callable, args, NULL); Py_DECREF (callable); Py_DECREF (args); } if (!result) { PyObject *ptype, *pvalue, *ptraceback; char *msg; PyErr_Fetch (&ptype, &pvalue, &ptraceback); /* Try to fetch an error message contained within ptype, pvalue. When fetching the error message we need to make our own copy, we no longer own ptype, pvalue after the call to PyErr_Restore. */ msg = gdbpy_exception_to_string (ptype, pvalue); make_cleanup (xfree, msg); if (msg == NULL) { /* An error occurred computing the string representation of the error message. This is rare, but we should inform the user. */ printf_filtered (_("An error occurred in a Python " "convenience function\n" "and then another occurred computing the " "error message.\n")); gdbpy_print_stack (); } /* Don't print the stack for gdb.GdbError exceptions. It is generally used to flag user errors. We also don't want to print "Error occurred in Python command" for user errors. However, a missing message for gdb.GdbError exceptions is arguably a bug, so we flag it as such. */ if (!PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc) || msg == NULL || *msg == '\0') { PyErr_Restore (ptype, pvalue, ptraceback); gdbpy_print_stack (); if (msg != NULL && *msg != '\0') error (_("Error occurred in Python convenience function: %s"), msg); else error (_("Error occurred in Python convenience function.")); } else { Py_XDECREF (ptype); Py_XDECREF (pvalue); Py_XDECREF (ptraceback); error ("%s", msg); } } value = convert_value_from_python (result); if (value == NULL) { Py_DECREF (result); gdbpy_print_stack (); error (_("Error while executing Python code.")); } Py_DECREF (result); do_cleanups (cleanup); return value; }