#include "mi/mi-cmds.h"
#include "python-internal.h"
#include "py-ref.h"
+#include "common/gdb_optional.h"
enum mi_print_types
{
TRY
{
- struct ui_file *stb;
- struct cleanup *cleanup;
-
- stb = mem_fileopen ();
- cleanup = make_cleanup_ui_file_delete (stb);
check_typedef (value_type (val));
- type_print (value_type (val), "", stb, -1);
+
+ string_file stb;
+ type_print (value_type (val), "", &stb, -1);
out->field_stream ("type", stb);
- do_cleanups (cleanup);
}
CATCH (except, RETURN_MASK_ALL)
{
{
TRY
{
- struct ui_file *stb;
- struct cleanup *cleanup;
+ string_file stb;
- stb = mem_fileopen ();
- cleanup = make_cleanup_ui_file_delete (stb);
- common_val_print (val, stb, indent, opts, language);
+ common_val_print (val, &stb, indent, opts, language);
out->field_stream ("value", stb);
- do_cleanups (cleanup);
}
CATCH (except, RETURN_MASK_ALL)
{
TRY
{
- struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
+ gdb::optional<ui_out_emit_tuple> maybe_tuple;
/* MI has varying rules for tuples, but generally if there is only
one element in each item in the list, do not start a tuple. The
if (out->is_mi_like_p ())
{
if (print_args_field || args_type != NO_VALUES)
- make_cleanup_ui_out_tuple_begin_end (out, NULL);
+ maybe_tuple.emplace (out, nullptr);
}
annotate_arg_begin ();
entry value options. */
if (fa != NULL)
{
- struct ui_file *stb;
+ string_file stb;
- stb = mem_fileopen ();
- make_cleanup_ui_file_delete (stb);
- fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (fa->sym),
+ fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (fa->sym),
SYMBOL_LANGUAGE (fa->sym),
DMGL_PARAMS | DMGL_ANSI);
if (fa->entry_kind == print_entry_values_compact)
{
- fputs_filtered ("=", stb);
+ stb.puts ("=");
- fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (fa->sym),
+ fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (fa->sym),
SYMBOL_LANGUAGE (fa->sym),
DMGL_PARAMS | DMGL_ANSI);
}
if (fa->entry_kind == print_entry_values_only
|| fa->entry_kind == print_entry_values_compact)
- {
- fputs_filtered ("@entry", stb);
- }
+ stb.puts ("@entry");
out->field_stream ("name", stb);
}
else
if (args_type == MI_PRINT_SIMPLE_VALUES && val != NULL)
{
if (py_print_type (out, val) == EXT_LANG_BT_ERROR)
- {
- retval = EXT_LANG_BT_ERROR;
- do_cleanups (cleanups);
- }
+ retval = EXT_LANG_BT_ERROR;
}
if (retval != EXT_LANG_BT_ERROR)
retval = EXT_LANG_BT_ERROR;
}
}
-
- do_cleanups (cleanups);
}
}
CATCH (except, RETURN_MASK_ERROR)
int print_args_field,
struct frame_info *frame)
{
- PyObject *item;
struct value_print_options opts;
get_user_print_options (&opts);
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
commas in the argument output is correct. At the end of the
loop block collect another item from the iterator, and, if it is
not null emit a comma. */
- item = PyIter_Next (iter);
+ gdbpy_ref item (PyIter_Next (iter));
if (item == NULL && PyErr_Occurred ())
- goto error;
+ return EXT_LANG_BT_ERROR;
- while (item)
+ while (item != NULL)
{
const struct language_defn *language;
gdb::unique_xmalloc_ptr<char> sym_name;
struct value *val;
enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
- success = extract_sym (item, &sym_name, &sym, &sym_block, &language);
+ success = extract_sym (item.get (), &sym_name, &sym, &sym_block,
+ &language);
if (success == EXT_LANG_BT_ERROR)
- {
- Py_DECREF (item);
- goto error;
- }
+ return EXT_LANG_BT_ERROR;
- success = extract_value (item, &val);
+ success = extract_value (item.get (), &val);
if (success == EXT_LANG_BT_ERROR)
- {
- Py_DECREF (item);
- goto error;
- }
-
- Py_DECREF (item);
- item = NULL;
+ return EXT_LANG_BT_ERROR;
if (sym && out->is_mi_like_p ()
&& ! mi_should_print (sym, MI_PRINT_ARGS))
{
PyErr_SetString (PyExc_RuntimeError,
_("No symbol or value provided."));
- goto error;
+ return EXT_LANG_BT_ERROR;
}
TRY
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
{
xfree (arg.error);
xfree (entryarg.error);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
}
xfree (arg.error);
xfree (entryarg.error);
gdbpy_convert_exception (except);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
}
args_type, print_args_field, NULL)
== EXT_LANG_BT_ERROR)
{
- xfree (arg.error);
- xfree (entryarg.error);
- goto error;
+ xfree (arg.error);
+ xfree (entryarg.error);
+ return EXT_LANG_BT_ERROR;
}
}
if (py_print_single_arg (out, sym_name.get (), NULL, val, &opts,
args_type, print_args_field,
language) == EXT_LANG_BT_ERROR)
- goto error;
+ return EXT_LANG_BT_ERROR;
}
}
/* Collect the next item from the iterator. If
this is the last item, do not print the
comma. */
- item = PyIter_Next (iter);
+ item.reset (PyIter_Next (iter));
if (item != NULL)
{
TRY
}
CATCH (except, RETURN_MASK_ALL)
{
- Py_DECREF (item);
gdbpy_convert_exception (except);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
}
else if (PyErr_Occurred ())
- goto error;
+ return EXT_LANG_BT_ERROR;
TRY
{
}
CATCH (except, RETURN_MASK_ALL)
{
- Py_DECREF (item);
gdbpy_convert_exception (except);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
}
return EXT_LANG_BT_OK;
-
- error:
- return EXT_LANG_BT_ERROR;
}
int print_args_field,
struct frame_info *frame)
{
- PyObject *item;
struct value_print_options opts;
get_user_print_options (&opts);
opts.deref_ref = 1;
- while ((item = PyIter_Next (iter)))
+ while (true)
{
const struct language_defn *language;
gdb::unique_xmalloc_ptr<char> sym_name;
struct symbol *sym;
struct block *sym_block;
int local_indent = 8 + (8 * indent);
- struct cleanup *locals_cleanups;
+ gdb::optional<ui_out_emit_tuple> tuple;
- locals_cleanups = make_cleanup_py_decref (item);
+ gdbpy_ref item (PyIter_Next (iter));
+ if (item == NULL)
+ break;
- success = extract_sym (item, &sym_name, &sym, &sym_block, &language);
+ success = extract_sym (item.get (), &sym_name, &sym, &sym_block,
+ &language);
if (success == EXT_LANG_BT_ERROR)
- {
- do_cleanups (locals_cleanups);
- goto error;
- }
+ return EXT_LANG_BT_ERROR;
- success = extract_value (item, &val);
+ success = extract_value (item.get (), &val);
if (success == EXT_LANG_BT_ERROR)
- {
- do_cleanups (locals_cleanups);
- goto error;
- }
+ return EXT_LANG_BT_ERROR;
if (sym != NULL && out->is_mi_like_p ()
&& ! mi_should_print (sym, MI_PRINT_LOCALS))
- {
- do_cleanups (locals_cleanups);
- continue;
- }
+ continue;
/* If the object did not provide a value, read it. */
if (val == NULL)
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (locals_cleanups);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
}
if (out->is_mi_like_p ())
{
if (print_args_field || args_type != NO_VALUES)
- make_cleanup_ui_out_tuple_begin_end (out, NULL);
+ tuple.emplace (out, nullptr);
}
TRY
{
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (locals_cleanups);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
if (args_type == MI_PRINT_SIMPLE_VALUES)
{
if (py_print_type (out, val) == EXT_LANG_BT_ERROR)
- {
- do_cleanups (locals_cleanups);
- goto error;
- }
+ return EXT_LANG_BT_ERROR;
}
/* CLI always prints values for locals. MI uses the
if (py_print_value (out, val, &opts, val_indent, args_type,
language) == EXT_LANG_BT_ERROR)
- {
- do_cleanups (locals_cleanups);
- goto error;
- }
+ return EXT_LANG_BT_ERROR;
}
else
{
{
if (py_print_value (out, val, &opts, 0, args_type,
language) == EXT_LANG_BT_ERROR)
- {
- do_cleanups (locals_cleanups);
- goto error;
- }
+ return EXT_LANG_BT_ERROR;
}
}
- do_cleanups (locals_cleanups);
-
TRY
{
out->text ("\n");
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- goto error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
}
- if (item == NULL && PyErr_Occurred ())
- goto error;
-
- return EXT_LANG_BT_OK;
+ if (!PyErr_Occurred ())
+ return EXT_LANG_BT_OK;
- error:
return EXT_LANG_BT_ERROR;
}
enum ext_lang_frame_args args_type,
struct frame_info *frame)
{
- struct cleanup *old_chain;
- PyObject *args_iter;
- PyObject *locals_iter;
-
- args_iter = get_py_iter_from_func (filter, "frame_args");
- old_chain = make_cleanup_py_xdecref (args_iter);
+ gdbpy_ref args_iter (get_py_iter_from_func (filter, "frame_args"));
if (args_iter == NULL)
- goto error;
+ return EXT_LANG_BT_ERROR;
- locals_iter = get_py_iter_from_func (filter, "frame_locals");
+ gdbpy_ref locals_iter (get_py_iter_from_func (filter, "frame_locals"));
if (locals_iter == NULL)
- goto error;
+ return EXT_LANG_BT_ERROR;
- make_cleanup_py_decref (locals_iter);
- make_cleanup_ui_out_list_begin_end (out, "variables");
+ ui_out_emit_list list_emitter (out, "variables");
- if (args_iter != Py_None)
- if (enumerate_args (args_iter, out, args_type, 1, frame)
- == EXT_LANG_BT_ERROR)
- goto error;
+ if (args_iter != Py_None
+ && (enumerate_args (args_iter.get (), out, args_type, 1, frame)
+ == EXT_LANG_BT_ERROR))
+ return EXT_LANG_BT_ERROR;
- if (locals_iter != Py_None)
- if (enumerate_locals (locals_iter, out, 1, args_type, 1, frame)
- == EXT_LANG_BT_ERROR)
- goto error;
+ if (locals_iter != Py_None
+ && (enumerate_locals (locals_iter.get (), out, 1, args_type, 1, frame)
+ == EXT_LANG_BT_ERROR))
+ return EXT_LANG_BT_ERROR;
- do_cleanups (old_chain);
return EXT_LANG_BT_OK;
-
- error:
- do_cleanups (old_chain);
- return EXT_LANG_BT_ERROR;
}
/* Helper function for printing locals. This function largely just
int indent,
struct frame_info *frame)
{
- PyObject *locals_iter = get_py_iter_from_func (filter,
- "frame_locals");
- struct cleanup *old_chain = make_cleanup_py_xdecref (locals_iter);
-
+ gdbpy_ref locals_iter (get_py_iter_from_func (filter, "frame_locals"));
if (locals_iter == NULL)
- goto locals_error;
+ return EXT_LANG_BT_ERROR;
- make_cleanup_ui_out_list_begin_end (out, "locals");
+ ui_out_emit_list list_emitter (out, "locals");
- if (locals_iter != Py_None)
- if (enumerate_locals (locals_iter, out, indent, args_type,
- 0, frame) == EXT_LANG_BT_ERROR)
- goto locals_error;
+ if (locals_iter != Py_None
+ && (enumerate_locals (locals_iter.get (), out, indent, args_type,
+ 0, frame) == EXT_LANG_BT_ERROR))
+ return EXT_LANG_BT_ERROR;
- do_cleanups (old_chain);
return EXT_LANG_BT_OK;
-
- locals_error:
- do_cleanups (old_chain);
- return EXT_LANG_BT_ERROR;
}
/* Helper function for printing frame arguments. This function
enum ext_lang_frame_args args_type,
struct frame_info *frame)
{
- PyObject *args_iter = get_py_iter_from_func (filter, "frame_args");
- struct cleanup *old_chain = make_cleanup_py_xdecref (args_iter);
-
+ gdbpy_ref args_iter (get_py_iter_from_func (filter, "frame_args"));
if (args_iter == NULL)
- goto args_error;
+ return EXT_LANG_BT_ERROR;
- make_cleanup_ui_out_list_begin_end (out, "args");
+ ui_out_emit_list list_emitter (out, "args");
TRY
{
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
- goto args_error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
- if (args_iter != Py_None)
- if (enumerate_args (args_iter, out, args_type, 0, frame)
- == EXT_LANG_BT_ERROR)
- goto args_error;
+ if (args_iter != Py_None
+ && (enumerate_args (args_iter.get (), out, args_type, 0, frame)
+ == EXT_LANG_BT_ERROR))
+ return EXT_LANG_BT_ERROR;
TRY
{
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
- goto args_error;
+ return EXT_LANG_BT_ERROR;
}
END_CATCH
- do_cleanups (old_chain);
return EXT_LANG_BT_OK;
-
- args_error:
- do_cleanups (old_chain);
- return EXT_LANG_BT_ERROR;
}
/* Print a single frame to the designated output stream, detecting
CORE_ADDR address = 0;
struct gdbarch *gdbarch = NULL;
struct frame_info *frame = NULL;
- struct cleanup *cleanup_stack;
struct value_print_options opts;
- PyObject *py_inf_frame;
int print_level, print_frame_info, print_args, print_locals;
gdb::unique_xmalloc_ptr<char> function_to_free;
/* Get the underlying frame. This is needed to determine GDB
architecture, and also, in the cases of frame variables/arguments to
read them if they returned filter object requires us to do so. */
- py_inf_frame = PyObject_CallMethod (filter, "inferior_frame", NULL);
+ gdbpy_ref py_inf_frame (PyObject_CallMethod (filter, "inferior_frame", NULL));
if (py_inf_frame == NULL)
return EXT_LANG_BT_ERROR;
- frame = frame_object_to_frame_info (py_inf_frame);;
-
- Py_DECREF (py_inf_frame);
-
+ frame = frame_object_to_frame_info (py_inf_frame.get ());
if (frame == NULL)
return EXT_LANG_BT_ERROR;
return EXT_LANG_BT_COMPLETED;
}
- cleanup_stack = make_cleanup (null_cleanup, NULL);
+ gdb::optional<ui_out_emit_tuple> tuple;
/* -stack-list-locals does not require a
wrapping frame attribute. */
if (print_frame_info || (print_args && ! print_locals))
- make_cleanup_ui_out_tuple_begin_end (out, "frame");
+ tuple.emplace (out, "frame");
if (print_frame_info)
{
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
address printing. */
if (PyObject_HasAttrString (filter, "address"))
{
- PyObject *paddr = PyObject_CallMethod (filter, "address", NULL);
+ gdbpy_ref paddr (PyObject_CallMethod (filter, "address", NULL));
if (paddr == NULL)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
if (paddr != Py_None)
{
- if (get_addr_from_python (paddr, &address) < 0)
- {
- Py_DECREF (paddr);
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ if (get_addr_from_python (paddr.get (), &address) < 0)
+ return EXT_LANG_BT_ERROR;
has_addr = 1;
}
- Py_DECREF (paddr);
}
}
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
const char *function = NULL;
if (py_func == NULL)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
if (gdbpy_is_string (py_func.get ()))
{
function_to_free = python_string_to_host_string (py_func.get ());
if (function_to_free == NULL)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
function = function_to_free.get ();
}
struct bound_minimal_symbol msymbol;
if (get_addr_from_python (py_func.get (), &addr) < 0)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
msymbol = lookup_minimal_symbol_by_pc (addr);
if (msymbol.minsym != NULL)
PyErr_SetString (PyExc_RuntimeError,
_("FrameDecorator.function: expecting a " \
"String, integer or None."));
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
if (print_args)
{
if (py_print_args (filter, out, args_type, frame) == EXT_LANG_BT_ERROR)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
}
/* File name/source/line number information. */
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
gdbpy_ref py_fn (PyObject_CallMethod (filter, "filename", NULL));
if (py_fn == NULL)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
if (py_fn != Py_None)
{
filename (python_string_to_host_string (py_fn.get ()));
if (filename == NULL)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
TRY
{
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
int line;
if (py_line == NULL)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
if (py_line != Py_None)
{
line = PyLong_AsLong (py_line.get ());
if (PyErr_Occurred ())
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
TRY
{
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
CATCH (except, RETURN_MASK_ERROR)
{
gdbpy_convert_exception (except);
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_ERROR;
}
END_CATCH
{
if (py_print_locals (filter, out, args_type, indent,
frame) == EXT_LANG_BT_ERROR)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
}
{
/* Finally recursively print elided frames, if any. */
gdbpy_ref elided (get_py_iter_from_func (filter, "elided"));
if (elided == NULL)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
if (elided != Py_None)
{
PyObject *item;
- make_cleanup_ui_out_list_begin_end (out, "children");
+ ui_out_emit_list inner_list_emiter (out, "children");
if (! out->is_mi_like_p ())
indent++;
levels_printed);
if (success == EXT_LANG_BT_ERROR)
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
}
if (item == NULL && PyErr_Occurred ())
- {
- do_cleanups (cleanup_stack);
- return EXT_LANG_BT_ERROR;
- }
+ return EXT_LANG_BT_ERROR;
}
}
- do_cleanups (cleanup_stack);
return EXT_LANG_BT_COMPLETED;
}