static int
fnpy_init (PyObject *self, PyObject *args, PyObject *kwds)
{
const char *name;
char *docstring = NULL;
if (! PyArg_ParseTuple (args, "s", &name))
return -1;
Py_INCREF (self);
if (PyObject_HasAttrString (self, "__doc__"))
{
PyObject *ds_obj = PyObject_GetAttrString (self, "__doc__");
if (ds_obj != NULL)
{
if (gdbpy_is_string (ds_obj))
{
docstring = python_string_to_host_string (ds_obj);
if (docstring == NULL)
{
Py_DECREF (self);
Py_DECREF (ds_obj);
return -1;
}
}
Py_DECREF (ds_obj);
}
}
if (! docstring)
docstring = xstrdup (_("This function is not documented."));
add_internal_function (name, docstring, fnpy_call, self);
return 0;
}
static int
fnpy_init (PyObject *self, PyObject *args, PyObject *kwds)
{
const char *name;
gdb::unique_xmalloc_ptr<char> docstring;
if (! PyArg_ParseTuple (args, "s", &name))
return -1;
Py_INCREF (self);
if (PyObject_HasAttrString (self, "__doc__"))
{
gdbpy_ref<> ds_obj (PyObject_GetAttrString (self, "__doc__"));
if (ds_obj != NULL)
{
if (gdbpy_is_string (ds_obj.get ()))
{
docstring = python_string_to_host_string (ds_obj.get ());
if (docstring == NULL)
{
Py_DECREF (self);
return -1;
}
}
}
}
if (! docstring)
docstring.reset (xstrdup (_("This function is not documented.")));
add_internal_function (name, docstring.release (), fnpy_call, self);
return 0;
}
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 ();
}
/* Return the display hint for the object printer, PRINTER. Return
NULL if there is no display_hint method, or if the method did not
return a string. On error, print stack trace and return NULL. On
success, return an xmalloc()d string. */
char *
gdbpy_get_display_hint (PyObject *printer)
{
PyObject *hint;
char *result = NULL;
if (! PyObject_HasAttr (printer, gdbpy_display_hint_cst))
return NULL;
hint = PyObject_CallMethodObjArgs (printer, gdbpy_display_hint_cst, NULL);
if (hint)
{
if (gdbpy_is_string (hint))
{
result = python_string_to_host_string (hint);
if (result == NULL)
gdbpy_print_stack ();
}
Py_DECREF (hint);
}
else
gdbpy_print_stack ();
return result;
}
/* 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;
}
}
}
static int
thpy_set_name (PyObject *self, PyObject *newvalue, void *ignore)
{
thread_object *thread_obj = (thread_object *) self;
char *name;
if (! thread_obj->thread)
{
PyErr_SetString (PyExc_RuntimeError, _("Thread no longer exists."));
return -1;
}
if (newvalue == NULL)
{
PyErr_SetString (PyExc_TypeError,
_("Cannot delete `name' attribute."));
return -1;
}
else if (newvalue == Py_None)
name = NULL;
else if (! gdbpy_is_string (newvalue))
{
PyErr_SetString (PyExc_TypeError,
_("The value of `name' must be a string."));
return -1;
}
else
{
name = python_string_to_host_string (newvalue);
if (! name)
return -1;
}
xfree (thread_obj->thread->name);
thread_obj->thread->name = name;
return 0;
}
/* Return the display hint for the object printer, PRINTER. Return
NULL if there is no display_hint method, or if the method did not
return a string. On error, print stack trace and return NULL. On
success, return an xmalloc()d string. */
gdb::unique_xmalloc_ptr<char>
gdbpy_get_display_hint (PyObject *printer)
{
gdb::unique_xmalloc_ptr<char> result;
if (! PyObject_HasAttr (printer, gdbpy_display_hint_cst))
return NULL;
gdbpy_ref<> hint (PyObject_CallMethodObjArgs (printer, gdbpy_display_hint_cst,
NULL));
if (hint != NULL)
{
if (gdbpy_is_string (hint.get ()))
{
result = python_string_to_host_string (hint.get ());
if (result == NULL)
gdbpy_print_stack ();
}
}
else
gdbpy_print_stack ();
return result;
}
/* 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);
}
}
static enum ext_lang_bt_status
extract_sym (PyObject *obj, gdb::unique_xmalloc_ptr<char> *name,
struct symbol **sym, struct block **sym_block,
const struct language_defn **language)
{
PyObject *result = PyObject_CallMethod (obj, "symbol", NULL);
if (result == NULL)
return EXT_LANG_BT_ERROR;
/* For 'symbol' callback, the function can return a symbol or a
string. */
if (gdbpy_is_string (result))
{
*name = python_string_to_host_string (result);
Py_DECREF (result);
if (*name == NULL)
return EXT_LANG_BT_ERROR;
/* If the API returns a string (and not a symbol), then there is
no symbol derived language available and the frame filter has
either overridden the symbol with a string, or supplied a
entirely synthetic symbol/value pairing. In that case, use
python_language. */
*language = python_language;
*sym = NULL;
*sym_block = NULL;
}
else
{
/* This type checks 'result' during the conversion so we
just call it unconditionally and check the return. */
*sym = symbol_object_to_symbol (result);
/* TODO: currently, we have no way to recover the block in which SYMBOL
was found, so we have no block to return. Trying to evaluate SYMBOL
will yield an incorrect value when it's located in a FRAME and
evaluated from another frame (as permitted in nested functions). */
*sym_block = NULL;
Py_DECREF (result);
if (*sym == NULL)
{
PyErr_SetString (PyExc_RuntimeError,
_("Unexpected value. Expecting a "
"gdb.Symbol or a Python string."));
return EXT_LANG_BT_ERROR;
}
/* Duplicate the symbol name, so the caller has consistency
in garbage collection. */
name->reset (xstrdup (SYMBOL_PRINT_NAME (*sym)));
/* If a symbol is specified attempt to determine the language
from the symbol. If mode is not "auto", then the language
has been explicitly set, use that. */
if (language_mode == language_mode_auto)
*language = language_def (SYMBOL_LANGUAGE (*sym));
else
*language = current_language;
}
return EXT_LANG_BT_OK;
}