/* General python/gdb code
- Copyright (C) 2008-2018 Free Software Foundation, Inc.
+ Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "python-internal.h"
#include "linespec.h"
#include "source.h"
-#include "version.h"
+#include "common/version.h"
#include "target.h"
#include "gdbthread.h"
#include "interps.h"
#include "event-top.h"
-#include "py-ref.h"
#include "py-event.h"
/* True if Python has been successfully initialized, false
python_language = language;
/* Save it and ensure ! PyErr_Occurred () afterwards. */
- PyErr_Fetch (&m_error_type, &m_error_value, &m_error_traceback);
+ m_error.emplace ();
}
gdbpy_enter::~gdbpy_enter ()
warning (_("internal error: Unhandled Python exception"));
}
- PyErr_Restore (m_error_type, m_error_value, m_error_traceback);
+ m_error->restore ();
PyGILState_Release (m_state);
python_gdbarch = m_gdbarch;
if (arg && *arg)
{
- int len = strlen (arg);
- char *script = (char *) xmalloc (len + 2);
-
- strcpy (script, arg);
- script[len] = '\n';
- script[len + 1] = '\0';
- err = eval_python_command (script);
- xfree (script);
+ std::string script = std::string (arg) + "\n";
+ err = eval_python_command (script.c_str ());
}
else
{
static PyObject *
gdbpy_parameter (PyObject *self, PyObject *args)
{
- struct gdb_exception except = exception_none;
struct cmd_list_element *alias, *prefix, *cmd;
const char *arg;
- char *newarg;
int found = -1;
if (! PyArg_ParseTuple (args, "s", &arg))
return NULL;
- newarg = concat ("show ", arg, (char *) NULL);
+ std::string newarg = std::string ("show ") + arg;
- TRY
+ try
{
- found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
+ found = lookup_cmd_composition (newarg.c_str (), &alias, &prefix, &cmd);
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
- except = ex;
+ GDB_PY_HANDLE_EXCEPTION (ex);
}
- END_CATCH
- xfree (newarg);
- GDB_PY_HANDLE_EXCEPTION (except);
if (!found)
return PyErr_Format (PyExc_RuntimeError,
_("Could not find parameter `%s'."), arg);
std::string to_string_res;
- TRY
+ scoped_restore preventer = prevent_dont_repeat ();
+
+ try
{
+ gdbpy_allow_threads allow_threads;
+
struct interp *interp;
std::string arg_copy = arg;
interp = interp_lookup (current_ui, "console");
current_uiout = interp->interp_ui_out ();
- scoped_restore preventer = prevent_dont_repeat ();
if (to_string)
to_string_res = execute_control_commands_to_string (lines.get (),
from_tty);
/* Do any commands attached to breakpoint we stopped at. */
bpstat_do_actions ();
}
- CATCH (except, RETURN_MASK_ALL)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
- END_CATCH
if (to_string)
return PyString_FromString (to_string_res.c_str ());
std::vector<symtab_and_line> decoded_sals;
symtab_and_line def_sal;
gdb::array_view<symtab_and_line> sals;
- TRY
+ try
{
if (location != NULL)
{
sals = def_sal;
}
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
/* We know this will always throw. */
gdbpy_convert_exception (ex);
return NULL;
}
- END_CATCH
if (!sals.empty ())
{
if (!PyArg_ParseTuple (args, "s", &expr_str))
return NULL;
- TRY
+ try
{
+ gdbpy_allow_threads allow_threads;
result = parse_and_eval (expr_str);
}
- CATCH (except, RETURN_MASK_ALL)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
- END_CATCH
return value_to_value_object (result);
}
&stream_type))
return NULL;
- TRY
+ try
{
switch (stream_type)
{
fprintf_filtered (gdb_stdout, "%s", arg);
}
}
- CATCH (except, RETURN_MASK_ALL)
+ catch (const gdb_exception &except)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
- END_CATCH
Py_RETURN_NONE;
}
/* PyErr_Print doesn't necessarily end output with a newline.
This works because Python's stdout/stderr is fed through
printf_filtered. */
- TRY
+ try
{
begin_line ();
}
- CATCH (except, RETURN_MASK_ALL)
+ catch (const gdb_exception &except)
{
}
- END_CATCH
}
/* Print "message", just error print message. */
else
{
- PyObject *ptype, *pvalue, *ptraceback;
-
- PyErr_Fetch (&ptype, &pvalue, &ptraceback);
+ gdbpy_err_fetch fetched_error;
- /* Fetch the error message contained within ptype, pvalue. */
- gdb::unique_xmalloc_ptr<char>
- msg (gdbpy_exception_to_string (ptype, pvalue));
- gdb::unique_xmalloc_ptr<char> type (gdbpy_obj_to_string (ptype));
+ gdb::unique_xmalloc_ptr<char> msg = fetched_error.to_string ();
+ gdb::unique_xmalloc_ptr<char> type;
+ /* Don't compute TYPE if MSG already indicates that there is an
+ error. */
+ if (msg != NULL)
+ type = fetched_error.type_to_string ();
- TRY
+ try
{
- if (msg == NULL)
+ if (msg == NULL || type == NULL)
{
/* An error occurred computing the string representation of the
error message. */
fprintf_filtered (gdb_stderr,
_("Error occurred computing Python error" \
"message.\n"));
+ PyErr_Clear ();
}
else
fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
type.get (), msg.get ());
}
- CATCH (except, RETURN_MASK_ALL)
+ catch (const gdb_exception &except)
{
}
- END_CATCH
+ }
+}
- Py_XDECREF (ptype);
- Py_XDECREF (pvalue);
- Py_XDECREF (ptraceback);
+/* Like gdbpy_print_stack, but if the exception is a
+ KeyboardException, throw a gdb "quit" instead. */
+
+void
+gdbpy_print_stack_or_quit ()
+{
+ if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt))
+ {
+ PyErr_Clear ();
+ throw_quit ("Quit");
}
+ gdbpy_print_stack ();
}
\f
if (gdb_module == NULL)
return false;
- /* The casts to (char*) are for python 2.4. */
- if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0
- || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG",
- (char*) host_name) < 0
+ if (PyModule_AddStringConstant (gdb_module, "VERSION", version) < 0
+ || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", host_name) < 0
|| PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
- (char*) target_name) < 0)
+ target_name) < 0)
return false;
/* Add stream constants. */
projects / binutils.git / blobdiff