static PyObject * pretty_print_one_value (PyObject *printer, struct value **out_value) { gdbpy_ref<> result; *out_value = NULL; TRY { result.reset (PyObject_CallMethodObjArgs (printer, gdbpy_to_string_cst, NULL)); if (result != NULL) { if (! gdbpy_is_string (result.get ()) && ! gdbpy_is_lazy_string (result.get ()) && result != Py_None) { *out_value = convert_value_from_python (result.get ()); if (PyErr_Occurred ()) *out_value = NULL; result = NULL; } } } CATCH (except, RETURN_MASK_ALL) { } END_CATCH return result.release (); }
static enum ext_lang_bt_status extract_value (PyObject *obj, struct value **value) { if (PyObject_HasAttrString (obj, "value")) { PyObject *vresult = PyObject_CallMethod (obj, "value", NULL); if (vresult == NULL) return EXT_LANG_BT_ERROR; /* The Python code has returned 'None' for a value, so we set value to NULL. This flags that GDB should read the value. */ if (vresult == Py_None) { Py_DECREF (vresult); *value = NULL; return EXT_LANG_BT_OK; } else { *value = convert_value_from_python (vresult); Py_DECREF (vresult); if (*value == NULL) return EXT_LANG_BT_ERROR; return EXT_LANG_BT_OK; } } else *value = NULL; return EXT_LANG_BT_OK; }
static struct value * fnpy_call (struct gdbarch *gdbarch, const struct language_defn *language, void *cookie, int argc, struct value **argv) { struct value *value = NULL; PyObject *result, *callable, *args; struct cleanup *cleanup; cleanup = ensure_python_env (gdbarch, language); args = convert_values_to_python (argc, argv); 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) { gdbpy_print_stack (); error (_("Error while executing Python code.")); } 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; }
/* Pretty-print a single value, via the printer object PRINTER. If the function returns a string, a PyObject containing the string is returned. Otherwise, if the function returns a value, *OUT_VALUE is set to the value, and NULL is returned. On error, *OUT_VALUE is set to NULL, and NULL is returned. */ static PyObject * pretty_print_one_value (PyObject *printer, struct value **out_value) { volatile struct gdb_exception except; PyObject *result = NULL; *out_value = NULL; TRY_CATCH (except, RETURN_MASK_ALL) { result = PyObject_CallMethodObjArgs (printer, gdbpy_to_string_cst, NULL); if (result) { if (! gdbpy_is_string (result)) { *out_value = convert_value_from_python (result); if (PyErr_Occurred ()) *out_value = NULL; Py_DECREF (result); result = NULL; } } }
/* Called when a new gdb.Value object needs to be allocated. Returns NULL on error, with a python exception set. */ static PyObject * valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) { struct value *value = NULL; /* Initialize to appease gcc warning. */ value_object *value_obj; if (PyTuple_Size (args) != 1) { PyErr_SetString (PyExc_TypeError, _("Value object creation takes only " "1 argument")); return NULL; } value_obj = (value_object *) subtype->tp_alloc (subtype, 1); if (value_obj == NULL) { PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to " "create Value object.")); return NULL; } value = convert_value_from_python (PyTuple_GetItem (args, 0)); if (value == NULL) { subtype->tp_free (value_obj); return NULL; } value_obj->value = value; release_value_or_incref (value); value_obj->address = NULL; value_obj->type = NULL; value_obj->dynamic_type = NULL; note_value (value_obj); return (PyObject *) value_obj; }
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; }
/* Helper for gdbpy_apply_val_pretty_printer that formats children of the printer, if any exist. If is_py_none is true, then nothing has been printed by to_string, and format output accordingly. */ static void print_children (PyObject *printer, const char *hint, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language, int is_py_none) { int is_map, is_array, done_flag, pretty; unsigned int i; if (! PyObject_HasAttr (printer, gdbpy_children_cst)) return; /* If we are printing a map or an array, we want some special formatting. */ is_map = hint && ! strcmp (hint, "map"); is_array = hint && ! strcmp (hint, "array"); gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst, NULL)); if (children == NULL) { print_stack_unless_memory_error (stream); return; } gdbpy_ref<> iter (PyObject_GetIter (children.get ())); if (iter == NULL) { print_stack_unless_memory_error (stream); return; } /* Use the prettyformat_arrays option if we are printing an array, and the pretty option otherwise. */ if (is_array) pretty = options->prettyformat_arrays; else { if (options->prettyformat == Val_prettyformat) pretty = 1; else pretty = options->prettyformat_structs; } /* Manufacture a dummy Python frame to work around Python 2.4 bug, where it insists on having a non-NULL tstate->frame when a generator is called. */ #ifndef IS_PY3K dummy_python_frame frame; if (frame.failed ()) { gdbpy_print_stack (); return; } #endif done_flag = 0; for (i = 0; i < options->print_max; ++i) { PyObject *py_v; const char *name; gdbpy_ref<> item (PyIter_Next (iter.get ())); if (item == NULL) { if (PyErr_Occurred ()) print_stack_unless_memory_error (stream); /* Set a flag so we can know whether we printed all the available elements. */ else done_flag = 1; break; } if (! PyTuple_Check (item.get ()) || PyTuple_Size (item.get ()) != 2) { PyErr_SetString (PyExc_TypeError, _("Result of children iterator not a tuple" " of two elements.")); gdbpy_print_stack (); continue; } if (! PyArg_ParseTuple (item.get (), "sO", &name, &py_v)) { /* The user won't necessarily get a stack trace here, so provide more context. */ if (gdbpy_print_python_errors_p ()) fprintf_unfiltered (gdb_stderr, _("Bad result from children iterator.\n")); gdbpy_print_stack (); continue; } /* Print initial "{". For other elements, there are three cases: 1. Maps. Print a "," after each value element. 2. Arrays. Always print a ",". 3. Other. Always print a ",". */ if (i == 0) { if (is_py_none) fputs_filtered ("{", stream); else fputs_filtered (" = {", stream); } else if (! is_map || i % 2 == 0) fputs_filtered (pretty ? "," : ", ", stream); /* In summary mode, we just want to print "= {...}" if there is a value. */ if (options->summary) { /* This increment tricks the post-loop logic to print what we want. */ ++i; /* Likewise. */ pretty = 0; break; } if (! is_map || i % 2 == 0) { if (pretty) { fputs_filtered ("\n", stream); print_spaces_filtered (2 + 2 * recurse, stream); } else wrap_here (n_spaces (2 + 2 *recurse)); } if (is_map && i % 2 == 0) fputs_filtered ("[", stream); else if (is_array) { /* We print the index, not whatever the child method returned as the name. */ if (options->print_array_indexes) fprintf_filtered (stream, "[%d] = ", i); } else if (! is_map) { fputs_filtered (name, stream); fputs_filtered (" = ", stream); } if (gdbpy_is_lazy_string (py_v)) { CORE_ADDR addr; struct type *type; long length; gdb::unique_xmalloc_ptr<char> encoding; struct value_print_options local_opts = *options; gdbpy_extract_lazy_string (py_v, &addr, &type, &length, &encoding); local_opts.addressprint = 0; val_print_string (type, encoding.get (), addr, (int) length, stream, &local_opts); } else if (gdbpy_is_string (py_v)) { gdb::unique_xmalloc_ptr<char> output; output = python_string_to_host_string (py_v); if (!output) gdbpy_print_stack (); else fputs_filtered (output.get (), stream); } else { struct value *value = convert_value_from_python (py_v); if (value == NULL) { gdbpy_print_stack (); error (_("Error while executing Python code.")); } else common_val_print (value, stream, recurse + 1, options, language); } if (is_map && i % 2 == 0) fputs_filtered ("] = ", stream); } if (i) { if (!done_flag) { if (pretty) { fputs_filtered ("\n", stream); print_spaces_filtered (2 + 2 * recurse, stream); } fputs_filtered ("...", stream); } if (pretty) { fputs_filtered ("\n", stream); print_spaces_filtered (2 * recurse, stream); } fputs_filtered ("}", stream); } }