/* General python/gdb code
- Copyright (C) 2008-2013 Free Software Foundation, Inc.
+ Copyright (C) 2008-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "objfiles.h"
#include "value.h"
#include "language.h"
-#include "exceptions.h"
#include "event-loop.h"
#include "serial.h"
#include "readline/tilde.h"
#include "python.h"
+#include "extension-priv.h"
#include "cli/cli-utils.h"
-
#include <ctype.h>
+#include "location.h"
+#include "ser-event.h"
/* Declared constants and enum for python stack printing. */
static const char python_excp_none[] = "none";
the default. */
static const char *gdbpy_should_print_stack = python_excp_message;
+#ifdef HAVE_PYTHON
+/* Forward decls, these are defined later. */
+extern const struct extension_language_script_ops python_extension_script_ops;
+extern const struct extension_language_ops python_extension_ops;
+#endif
+
+/* The main struct describing GDB's interface to the Python
+ extension language. */
+const struct extension_language_defn extension_language_python =
+{
+ EXT_LANG_PYTHON,
+ "python",
+ "Python",
+
+ ".py",
+ "-gdb.py",
+
+ python_control,
+
+#ifdef HAVE_PYTHON
+ &python_extension_script_ops,
+ &python_extension_ops
+#else
+ NULL,
+ NULL
+#endif
+};
+\f
#ifdef HAVE_PYTHON
-#include "libiberty.h"
#include "cli/cli-decode.h"
#include "charset.h"
#include "top.h"
#include "version.h"
#include "target.h"
#include "gdbthread.h"
-#include "observer.h"
#include "interps.h"
#include "event-top.h"
+#include "py-ref.h"
+#include "py-event.h"
+
+/* True if Python has been successfully initialized, false
+ otherwise. */
-static PyMethodDef GdbMethods[];
+int gdb_python_initialized;
+
+extern PyMethodDef python_GdbMethods[];
#ifdef IS_PY3K
-static struct PyModuleDef GdbModuleDef;
+extern struct PyModuleDef python_GdbModuleDef;
#endif
PyObject *gdb_module;
/* The `gdb.MemoryError' exception. */
PyObject *gdbpy_gdb_memory_error;
-/* Architecture and language to be used in callbacks from
- the Python interpreter. */
-struct gdbarch *python_gdbarch;
-const struct language_defn *python_language;
-
-/* Restore global language and architecture and Python GIL state
- when leaving the Python interpreter. */
-
-struct python_env
+static script_sourcer_func gdbpy_source_script;
+static objfile_script_sourcer_func gdbpy_source_objfile_script;
+static objfile_script_executor_func gdbpy_execute_objfile_script;
+static void gdbpy_finish_initialization
+ (const struct extension_language_defn *);
+static int gdbpy_initialized (const struct extension_language_defn *);
+static void gdbpy_eval_from_control_command
+ (const struct extension_language_defn *, struct command_line *cmd);
+static void gdbpy_start_type_printers (const struct extension_language_defn *,
+ struct ext_lang_type_printers *);
+static enum ext_lang_rc gdbpy_apply_type_printers
+ (const struct extension_language_defn *,
+ const struct ext_lang_type_printers *, struct type *, char **);
+static void gdbpy_free_type_printers (const struct extension_language_defn *,
+ struct ext_lang_type_printers *);
+static void gdbpy_set_quit_flag (const struct extension_language_defn *);
+static int gdbpy_check_quit_flag (const struct extension_language_defn *);
+static enum ext_lang_rc gdbpy_before_prompt_hook
+ (const struct extension_language_defn *, const char *current_gdb_prompt);
+
+/* The interface between gdb proper and loading of python scripts. */
+
+const struct extension_language_script_ops python_extension_script_ops =
{
- PyGILState_STATE state;
- struct gdbarch *gdbarch;
- const struct language_defn *language;
- PyObject *error_type, *error_value, *error_traceback;
+ gdbpy_source_script,
+ gdbpy_source_objfile_script,
+ gdbpy_execute_objfile_script,
+ gdbpy_auto_load_enabled
};
-static void
-restore_python_env (void *p)
+/* The interface between gdb proper and python extensions. */
+
+const struct extension_language_ops python_extension_ops =
{
- struct python_env *env = (struct python_env *)p;
+ gdbpy_finish_initialization,
+ gdbpy_initialized,
- /* Leftover Python error is forbidden by Python Exception Handling. */
- if (PyErr_Occurred ())
- {
- /* This order is similar to the one calling error afterwards. */
- gdbpy_print_stack ();
- warning (_("internal error: Unhandled Python exception"));
- }
+ gdbpy_eval_from_control_command,
- PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
+ gdbpy_start_type_printers,
+ gdbpy_apply_type_printers,
+ gdbpy_free_type_printers,
- PyGILState_Release (env->state);
- python_gdbarch = env->gdbarch;
- python_language = env->language;
- xfree (env);
-}
+ gdbpy_apply_val_pretty_printer,
+
+ gdbpy_apply_frame_filter,
-/* Called before entering the Python interpreter to install the
- current language and architecture to be used for Python values. */
+ gdbpy_preserve_values,
-struct cleanup *
-ensure_python_env (struct gdbarch *gdbarch,
- const struct language_defn *language)
+ gdbpy_breakpoint_has_cond,
+ gdbpy_breakpoint_cond_says_stop,
+
+ gdbpy_set_quit_flag,
+ gdbpy_check_quit_flag,
+
+ gdbpy_before_prompt_hook,
+
+ gdbpy_clone_xmethod_worker_data,
+ gdbpy_free_xmethod_worker_data,
+ gdbpy_get_matching_xmethod_workers,
+ gdbpy_get_xmethod_arg_types,
+ gdbpy_get_xmethod_result_type,
+ gdbpy_invoke_xmethod
+};
+
+/* Architecture and language to be used in callbacks from
+ the Python interpreter. */
+struct gdbarch *python_gdbarch;
+const struct language_defn *python_language;
+
+gdbpy_enter::gdbpy_enter (struct gdbarch *gdbarch,
+ const struct language_defn *language)
+: m_gdbarch (python_gdbarch),
+ m_language (python_language)
{
- struct python_env *env = xmalloc (sizeof *env);
+ /* We should not ever enter Python unless initialized. */
+ if (!gdb_python_initialized)
+ error (_("Python not initialized"));
+
+ m_previous_active = set_active_ext_lang (&extension_language_python);
- env->state = PyGILState_Ensure ();
- env->gdbarch = python_gdbarch;
- env->language = python_language;
+ m_state = PyGILState_Ensure ();
python_gdbarch = gdbarch;
python_language = language;
/* Save it and ensure ! PyErr_Occurred () afterwards. */
- PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
-
- return make_cleanup (restore_python_env, env);
+ PyErr_Fetch (&m_error_type, &m_error_value, &m_error_traceback);
}
-/* Clear the quit flag. */
-
-void
-clear_quit_flag (void)
+gdbpy_enter::~gdbpy_enter ()
{
- /* This clears the flag as a side effect. */
- PyOS_InterruptOccurred ();
+ /* Leftover Python error is forbidden by Python Exception Handling. */
+ if (PyErr_Occurred ())
+ {
+ /* This order is similar to the one calling error afterwards. */
+ gdbpy_print_stack ();
+ warning (_("internal error: Unhandled Python exception"));
+ }
+
+ PyErr_Restore (m_error_type, m_error_value, m_error_traceback);
+
+ PyGILState_Release (m_state);
+ python_gdbarch = m_gdbarch;
+ python_language = m_language;
+
+ restore_active_ext_lang (m_previous_active);
}
/* Set the quit flag. */
-void
-set_quit_flag (void)
+static void
+gdbpy_set_quit_flag (const struct extension_language_defn *extlang)
{
PyErr_SetInterrupt ();
}
/* Return true if the quit flag has been set, false otherwise. */
-int
-check_quit_flag (void)
+static int
+gdbpy_check_quit_flag (const struct extension_language_defn *extlang)
{
return PyOS_InterruptOccurred ();
}
static int
eval_python_command (const char *command)
{
- PyObject *m, *d, *v;
+ PyObject *m, *d;
m = PyImport_AddModule ("__main__");
if (m == NULL)
d = PyModule_GetDict (m);
if (d == NULL)
return -1;
- v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
+ gdbpy_ref<> v (PyRun_StringFlags (command, Py_single_input, d, d, NULL));
if (v == NULL)
return -1;
- Py_DECREF (v);
#ifndef IS_PY3K
if (Py_FlushLine ())
PyErr_Clear ();
static void
python_interactive_command (char *arg, int from_tty)
{
- struct cleanup *cleanup;
+ struct ui *ui = current_ui;
int err;
- cleanup = make_cleanup_restore_integer (&interpreter_async);
- interpreter_async = 0;
+ scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
arg = skip_spaces (arg);
- ensure_python_env (get_current_arch (), current_language);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
if (arg && *arg)
{
int len = strlen (arg);
- char *script = xmalloc (len + 2);
+ char *script = (char *) xmalloc (len + 2);
strcpy (script, arg);
script[len] = '\n';
}
else
{
- err = PyRun_InteractiveLoop (instream, "<stdin>");
+ err = PyRun_InteractiveLoop (ui->instream, "<stdin>");
dont_repeat ();
}
gdbpy_print_stack ();
error (_("Error while executing Python code."));
}
-
- do_cleanups (cleanup);
}
/* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
#else /* _WIN32 */
- char *full_path;
- PyObject *python_file;
- struct cleanup *cleanup;
-
/* Because we have a string for a filename, and are using Python to
open the file, we need to expand any tilde in the path first. */
- full_path = tilde_expand (filename);
- cleanup = make_cleanup (xfree, full_path);
- python_file = PyFile_FromString (full_path, "r");
- if (! python_file)
+ gdb::unique_xmalloc_ptr<char> full_path (tilde_expand (filename));
+ gdbpy_ref<> python_file (PyFile_FromString (full_path.get (), (char *) "r"));
+ if (python_file == NULL)
{
- do_cleanups (cleanup);
gdbpy_print_stack ();
- error (_("Error while opening file: %s"), full_path);
+ error (_("Error while opening file: %s"), full_path.get ());
}
-
- make_cleanup_py_decref (python_file);
- PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
- do_cleanups (cleanup);
+
+ PyRun_SimpleFile (PyFile_AsFile (python_file.get ()), filename);
#endif /* _WIN32 */
}
for (iter = l; iter; iter = iter->next)
size += strlen (iter->line) + 1;
- script = xmalloc (size + 1);
+ script = (char *) xmalloc (size + 1);
here = 0;
for (iter = l; iter; iter = iter->next)
{
/* Take a command line structure representing a 'python' command, and
evaluate its body using the Python interpreter. */
-void
-eval_python_from_control_command (struct command_line *cmd)
+static void
+gdbpy_eval_from_control_command (const struct extension_language_defn *extlang,
+ struct command_line *cmd)
{
int ret;
char *script;
- struct cleanup *cleanup;
if (cmd->body_count != 1)
error (_("Invalid \"python\" block structure."));
- cleanup = ensure_python_env (get_current_arch (), current_language);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
script = compute_python_string (cmd->body_list[0]);
ret = PyRun_SimpleString (script);
xfree (script);
if (ret)
error (_("Error while executing Python code."));
-
- do_cleanups (cleanup);
}
/* Implementation of the gdb "python" command. */
static void
python_command (char *arg, int from_tty)
{
- struct cleanup *cleanup;
-
- cleanup = ensure_python_env (get_current_arch (), current_language);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
- make_cleanup_restore_integer (&interpreter_async);
- interpreter_async = 0;
+ scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
arg = skip_spaces (arg);
if (arg && *arg)
}
else
{
- struct command_line *l = get_command_line (python_control, "");
+ command_line_up l = get_command_line (python_control, "");
- make_cleanup_free_command_lines (&l);
- execute_control_command_untraced (l);
+ execute_control_command_untraced (l.get ());
}
-
- do_cleanups (cleanup);
}
\f
case var_filename:
case var_enum:
{
- char *str = * (char **) var;
+ const char *str = *(char **) var;
if (! str)
str = "";
- return PyString_Decode (str, strlen (str), host_charset (), NULL);
+ return host_string_to_python_string (str);
}
case var_boolean:
}
}
- return PyErr_Format (PyExc_RuntimeError,
+ return PyErr_Format (PyExc_RuntimeError,
_("Programmer error: unhandled type."));
}
/* A Python function which returns a gdb parameter's value as a Python
value. */
-PyObject *
+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;
- volatile struct gdb_exception except;
if (! PyArg_ParseTuple (args, "s", &arg))
return NULL;
newarg = concat ("show ", arg, (char *) NULL);
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
}
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ except = ex;
+ }
+ END_CATCH
+
xfree (newarg);
GDB_PY_HANDLE_EXCEPTION (except);
if (!found)
_("Could not find parameter `%s'."), arg);
if (! cmd->var)
- return PyErr_Format (PyExc_RuntimeError,
+ return PyErr_Format (PyExc_RuntimeError,
_("`%s' is not a parameter."), arg);
return gdbpy_parameter_value (cmd->var_type, cmd->var);
}
const char *arg;
PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
int from_tty, to_string;
- volatile struct gdb_exception except;
- static char *keywords[] = {"command", "from_tty", "to_string", NULL };
- char *result = NULL;
+ static const char *keywords[] = { "command", "from_tty", "to_string", NULL };
- if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
- &PyBool_Type, &from_tty_obj,
- &PyBool_Type, &to_string_obj))
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
+ &PyBool_Type, &from_tty_obj,
+ &PyBool_Type, &to_string_obj))
return NULL;
from_tty = 0;
to_string = cmp;
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ std::string to_string_res;
+
+ TRY
{
/* Copy the argument text in case the command modifies it. */
- char *copy = xstrdup (arg);
- struct cleanup *cleanup = make_cleanup (xfree, copy);
+ std::string copy (arg);
+ struct interp *interp;
+
+ scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
+
+ scoped_restore save_uiout = make_scoped_restore (¤t_uiout);
- make_cleanup_restore_integer (&interpreter_async);
- interpreter_async = 0;
+ /* Use the console interpreter uiout to have the same print format
+ for console or MI. */
+ interp = interp_lookup (current_ui, "console");
+ current_uiout = interp_ui_out (interp);
- prevent_dont_repeat ();
+ scoped_restore preventer = prevent_dont_repeat ();
if (to_string)
- result = execute_command_to_string (copy, from_tty);
+ to_string_res = execute_command_to_string (©[0], from_tty);
else
- {
- result = NULL;
- execute_command (copy, from_tty);
- }
-
- do_cleanups (cleanup);
+ execute_command (©[0], from_tty);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
/* Do any commands attached to breakpoint we stopped at. */
bpstat_do_actions ();
- if (result)
- {
- PyObject *r = PyString_FromString (result);
- xfree (result);
- return r;
- }
+ if (to_string)
+ return PyString_FromString (to_string_res.c_str ());
Py_RETURN_NONE;
}
{
char *soname;
PyObject *str_obj;
- gdb_py_longest pc;
+ gdb_py_ulongest pc;
- if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
+ if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
return NULL;
soname = solib_name_from_address (current_program_space, pc);
if (soname)
- str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
+ str_obj = host_string_to_python_string (soname);
else
{
str_obj = Py_None;
static PyObject *
gdbpy_decode_line (PyObject *self, PyObject *args)
{
+ struct gdb_exception except = exception_none;
struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
appease gcc. */
struct symtab_and_line sal;
- const char *arg = NULL;
- char *copy_to_free = NULL, *copy = NULL;
+ char *arg = NULL;
struct cleanup *cleanups;
- PyObject *result = NULL;
- PyObject *return_result = NULL;
- PyObject *unparsed = NULL;
- volatile struct gdb_exception except;
+ gdbpy_ref<> result;
+ gdbpy_ref<> unparsed;
+ event_location_up location;
if (! PyArg_ParseTuple (args, "|s", &arg))
return NULL;
cleanups = make_cleanup (null_cleanup, NULL);
sals.sals = NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+
+ if (arg != NULL)
+ location = string_to_event_location_basic (&arg, python_language);
+
+ TRY
{
- if (arg)
- {
- copy = xstrdup (arg);
- copy_to_free = copy;
- sals = decode_line_1 (©, 0, 0, 0);
- }
+ if (location != NULL)
+ sals = decode_line_1 (location.get (), 0, NULL, NULL, 0);
else
{
set_default_source_symtab_and_line ();
sals.nelts = 1;
}
}
-
- if (sals.sals != NULL && sals.sals != &sal)
+ CATCH (ex, RETURN_MASK_ALL)
{
- make_cleanup (xfree, copy_to_free);
- make_cleanup (xfree, sals.sals);
+ except = ex;
}
+ END_CATCH
+
+ if (sals.sals != NULL && sals.sals != &sal)
+ make_cleanup (xfree, sals.sals);
if (except.reason < 0)
{
do_cleanups (cleanups);
/* We know this will always throw. */
- GDB_PY_HANDLE_EXCEPTION (except);
+ gdbpy_convert_exception (except);
+ return NULL;
}
if (sals.nelts)
{
int i;
- result = PyTuple_New (sals.nelts);
- if (! result)
- goto error;
+ result.reset (PyTuple_New (sals.nelts));
+ if (result == NULL)
+ {
+ do_cleanups (cleanups);
+ return NULL;
+ }
for (i = 0; i < sals.nelts; ++i)
{
PyObject *obj;
obj = symtab_and_line_to_sal_object (sals.sals[i]);
if (! obj)
{
- Py_DECREF (result);
- goto error;
+ do_cleanups (cleanups);
+ return NULL;
}
- PyTuple_SetItem (result, i, obj);
+ PyTuple_SetItem (result.get (), i, obj);
}
}
else
{
- result = Py_None;
+ result.reset (Py_None);
Py_INCREF (Py_None);
}
- return_result = PyTuple_New (2);
- if (! return_result)
+ gdbpy_ref<> return_result (PyTuple_New (2));
+ if (return_result == NULL)
{
- Py_DECREF (result);
- goto error;
+ do_cleanups (cleanups);
+ return NULL;
}
- if (copy && strlen (copy) > 0)
+ if (arg != NULL && strlen (arg) > 0)
{
- unparsed = PyString_FromString (copy);
+ unparsed.reset (PyString_FromString (arg));
if (unparsed == NULL)
{
- Py_DECREF (result);
- Py_DECREF (return_result);
- return_result = NULL;
- goto error;
+ do_cleanups (cleanups);
+ return NULL;
}
}
else
{
- unparsed = Py_None;
+ unparsed.reset (Py_None);
Py_INCREF (Py_None);
}
- PyTuple_SetItem (return_result, 0, unparsed);
- PyTuple_SetItem (return_result, 1, result);
+ PyTuple_SetItem (return_result.get (), 0, unparsed.release ());
+ PyTuple_SetItem (return_result.get (), 1, result.release ());
- error:
do_cleanups (cleanups);
- return return_result;
+ return return_result.release ();
}
/* Parse a string and evaluate it as an expression. */
{
const char *expr_str;
struct value *result = NULL;
- volatile struct gdb_exception except;
if (!PyArg_ParseTuple (args, "s", &expr_str))
return NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
- char *copy = xstrdup (expr_str);
- struct cleanup *cleanup = make_cleanup (xfree, copy);
-
- result = parse_and_eval (copy);
- do_cleanups (cleanup);
+ result = parse_and_eval (expr_str);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return value_to_value_object (result);
}
gdbpy_find_pc_line (PyObject *self, PyObject *args)
{
gdb_py_ulongest pc_llu;
- volatile struct gdb_exception except;
PyObject *result = NULL; /* init for gcc -Wall */
if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
return NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
struct symtab_and_line sal;
CORE_ADDR pc;
sal = find_pc_line (pc, 0);
result = symtab_and_line_to_sal_object (sal);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return result;
}
+/* Implementation of gdb.invalidate_cached_frames. */
+
+static PyObject *
+gdbpy_invalidate_cached_frames (PyObject *self, PyObject *args)
+{
+ reinit_frame_cache ();
+ Py_RETURN_NONE;
+}
+
/* Read a file as Python code.
- FILE is the file to run. FILENAME is name of the file FILE.
+ This is the extension_language_script_ops.script_sourcer "method".
+ FILE is the file to load. FILENAME is name of the file FILE.
This does not throw any errors. If an exception occurs python will print
the traceback and clear the error indicator. */
-void
-source_python_script (FILE *file, const char *filename)
+static void
+gdbpy_source_script (const struct extension_language_defn *extlang,
+ FILE *file, const char *filename)
{
- struct cleanup *cleanup;
-
- cleanup = ensure_python_env (get_current_arch (), current_language);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
python_run_simple_file (file, filename);
- do_cleanups (cleanup);
}
\f
/* The final link of the event list. */
static struct gdbpy_event **gdbpy_event_list_end;
-/* We use a file handler, and not an async handler, so that we can
- wake up the main thread even when it is blocked in poll(). */
-static struct serial *gdbpy_event_fds[2];
+/* So that we can wake up the main thread even when it is blocked in
+ poll(). */
+static struct serial_event *gdbpy_serial_event;
/* The file handler callback. This reads from the internal pipe, and
then processes the Python event queue. This will always be run in
the main gdb thread. */
static void
-gdbpy_run_events (struct serial *scb, void *context)
+gdbpy_run_events (int error, gdb_client_data client_data)
{
- struct cleanup *cleanup;
-
- cleanup = ensure_python_env (get_current_arch (), current_language);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
- /* Flush the fd. Do this before flushing the events list, so that
- any new event post afterwards is sure to re-awake the event
+ /* Clear the event fd. Do this before flushing the events list, so
+ that any new event post afterwards is sure to re-awake the event
loop. */
- while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
- ;
+ serial_event_clear (gdbpy_serial_event);
while (gdbpy_event_list)
{
gdbpy_event_list_end = &gdbpy_event_list;
/* Ignore errors. */
- if (PyObject_CallObject (item->event, NULL) == NULL)
+ gdbpy_ref<> call_result (PyObject_CallObject (item->event, NULL));
+ if (call_result == NULL)
PyErr_Clear ();
Py_DECREF (item->event);
xfree (item);
}
-
- do_cleanups (cleanup);
}
/* Submit an event to the gdb thread. */
if (!PyCallable_Check (func))
{
- PyErr_SetString (PyExc_RuntimeError,
+ PyErr_SetString (PyExc_RuntimeError,
_("Posted event is not callable"));
return NULL;
}
/* Wake up gdb when needed. */
if (wakeup)
- {
- char c = 'q'; /* Anything. */
-
- if (serial_write (gdbpy_event_fds[1], &c, 1))
- return PyErr_SetFromErrno (PyExc_IOError);
- }
+ serial_event_set (gdbpy_serial_event);
Py_RETURN_NONE;
}
/* Initialize the Python event handler. */
-static void
+static int
gdbpy_initialize_events (void)
{
- if (serial_pipe (gdbpy_event_fds) == 0)
- {
- gdbpy_event_list_end = &gdbpy_event_list;
- serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
- }
+ gdbpy_event_list_end = &gdbpy_event_list;
+
+ gdbpy_serial_event = make_serial_event ();
+ add_file_handler (serial_event_fd (gdbpy_serial_event),
+ gdbpy_run_events, NULL);
+
+ return 0;
}
\f
-static void
-before_prompt_hook (const char *current_gdb_prompt)
+/* This is the extension_language_ops.before_prompt "method". */
+
+static enum ext_lang_rc
+gdbpy_before_prompt_hook (const struct extension_language_defn *extlang,
+ const char *current_gdb_prompt)
{
- struct cleanup *cleanup;
- char *prompt = NULL;
+ if (!gdb_python_initialized)
+ return EXT_LANG_RC_NOP;
- cleanup = ensure_python_env (get_current_arch (), current_language);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
+
+ if (!evregpy_no_listeners_p (gdb_py_events.before_prompt)
+ && evpy_emit_event (NULL, gdb_py_events.before_prompt) < 0)
+ return EXT_LANG_RC_ERROR;
if (gdb_python_module
&& PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
{
- PyObject *hook;
-
- hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
+ gdbpy_ref<> hook (PyObject_GetAttrString (gdb_python_module,
+ "prompt_hook"));
if (hook == NULL)
- goto fail;
-
- if (PyCallable_Check (hook))
{
- PyObject *result;
- PyObject *current_prompt;
+ gdbpy_print_stack ();
+ return EXT_LANG_RC_ERROR;
+ }
- current_prompt = PyString_FromString (current_gdb_prompt);
+ if (PyCallable_Check (hook.get ()))
+ {
+ gdbpy_ref<> current_prompt (PyString_FromString (current_gdb_prompt));
if (current_prompt == NULL)
- goto fail;
-
- result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
-
- Py_DECREF (current_prompt);
+ {
+ gdbpy_print_stack ();
+ return EXT_LANG_RC_ERROR;
+ }
+ gdbpy_ref<> result
+ (PyObject_CallFunctionObjArgs (hook.get (), current_prompt.get (),
+ NULL));
if (result == NULL)
- goto fail;
-
- make_cleanup_py_decref (result);
+ {
+ gdbpy_print_stack ();
+ return EXT_LANG_RC_ERROR;
+ }
/* Return type should be None, or a String. If it is None,
fall through, we will not set a prompt. If it is a
string, set PROMPT. Anything else, set an exception. */
- if (result != Py_None && ! PyString_Check (result))
+ if (result != Py_None && ! PyString_Check (result.get ()))
{
PyErr_Format (PyExc_RuntimeError,
_("Return from prompt_hook must " \
"be either a Python string, or None"));
- goto fail;
+ gdbpy_print_stack ();
+ return EXT_LANG_RC_ERROR;
}
if (result != Py_None)
{
- prompt = python_string_to_host_string (result);
+ gdb::unique_xmalloc_ptr<char>
+ prompt (python_string_to_host_string (result.get ()));
if (prompt == NULL)
- goto fail;
- else
- make_cleanup (xfree, prompt);
+ {
+ gdbpy_print_stack ();
+ return EXT_LANG_RC_ERROR;
+ }
+
+ set_prompt (prompt.get ());
+ return EXT_LANG_RC_OK;
}
}
}
- /* If a prompt has been set, PROMPT will not be NULL. If it is
- NULL, do not set the prompt. */
- if (prompt != NULL)
- set_prompt (prompt);
-
- do_cleanups (cleanup);
- return;
-
- fail:
- gdbpy_print_stack ();
- do_cleanups (cleanup);
- return;
+ return EXT_LANG_RC_NOP;
}
\f
gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
{
const char *arg;
- static char *keywords[] = {"text", "stream", NULL };
+ static const char *keywords[] = { "text", "stream", NULL };
int stream_type = 0;
- volatile struct gdb_exception except;
-
- if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
- &stream_type))
+
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
+ &stream_type))
return NULL;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
switch (stream_type)
{
fprintf_filtered (gdb_stdout, "%s", arg);
}
}
- GDB_PY_HANDLE_EXCEPTION (except);
-
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
+
Py_RETURN_NONE;
}
static PyObject *
gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
{
- static char *keywords[] = {"stream", NULL };
+ static const char *keywords[] = { "stream", NULL };
int stream_type = 0;
-
- if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
- &stream_type))
+
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
+ &stream_type))
return NULL;
switch (stream_type)
default:
gdb_flush (gdb_stdout);
}
-
+
Py_RETURN_NONE;
}
+/* Return non-zero if print-stack is not "none". */
+
+int
+gdbpy_print_python_errors_p (void)
+{
+ return gdbpy_should_print_stack != python_excp_none;
+}
+
/* Print a python exception trace, print just a message, or print
nothing and clear the python exception, depending on
gdbpy_should_print_stack. Only call this if a python exception is
void
gdbpy_print_stack (void)
{
- volatile struct gdb_exception except;
/* Print "none", just clear exception. */
if (gdbpy_should_print_stack == python_excp_none)
/* PyErr_Print doesn't necessarily end output with a newline.
This works because Python's stdout/stderr is fed through
printf_filtered. */
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
begin_line ();
}
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ }
+ END_CATCH
}
/* Print "message", just error print message. */
else
{
PyObject *ptype, *pvalue, *ptraceback;
- char *msg = NULL, *type = NULL;
PyErr_Fetch (&ptype, &pvalue, &ptraceback);
/* Fetch the error message contained within ptype, pvalue. */
- msg = gdbpy_exception_to_string (ptype, pvalue);
- type = gdbpy_obj_to_string (ptype);
+ gdb::unique_xmalloc_ptr<char>
+ msg (gdbpy_exception_to_string (ptype, pvalue));
+ gdb::unique_xmalloc_ptr<char> type (gdbpy_obj_to_string (ptype));
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
if (msg == NULL)
{
}
else
fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
- type, msg);
+ type.get (), msg.get ());
}
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ }
+ END_CATCH
Py_XDECREF (ptype);
Py_XDECREF (pvalue);
Py_XDECREF (ptraceback);
- xfree (msg);
}
}
gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
{
struct program_space *ps;
- PyObject *list;
- list = PyList_New (0);
- if (!list)
+ gdbpy_ref<> list (PyList_New (0));
+ if (list == NULL)
return NULL;
ALL_PSPACES (ps)
{
PyObject *item = pspace_to_pspace_object (ps);
- if (!item || PyList_Append (list, item) == -1)
- {
- Py_DECREF (list);
- return NULL;
- }
+ if (!item || PyList_Append (list.get (), item) == -1)
+ return NULL;
}
- return list;
+ return list.release ();
}
\f
/* The "current" objfile. This is set when gdb detects that a new
objfile has been loaded. It is only set for the duration of a call to
- source_python_script_for_objfile; it is NULL at other times. */
+ gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
+ at other times. */
static struct objfile *gdbpy_current_objfile;
/* Set the current objfile to OBJFILE and then read FILE named FILENAME
as Python code. This does not throw any errors. If an exception
- occurs python will print the traceback and clear the error indicator. */
+ occurs python will print the traceback and clear the error indicator.
+ This is the extension_language_script_ops.objfile_script_sourcer
+ "method". */
-void
-source_python_script_for_objfile (struct objfile *objfile, FILE *file,
- const char *filename)
+static void
+gdbpy_source_objfile_script (const struct extension_language_defn *extlang,
+ struct objfile *objfile, FILE *file,
+ const char *filename)
{
- struct cleanup *cleanups;
+ if (!gdb_python_initialized)
+ return;
- cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
+ gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
gdbpy_current_objfile = objfile;
python_run_simple_file (file, filename);
- do_cleanups (cleanups);
+ gdbpy_current_objfile = NULL;
+}
+
+/* Set the current objfile to OBJFILE and then execute SCRIPT
+ as Python code. This does not throw any errors. If an exception
+ occurs python will print the traceback and clear the error indicator.
+ This is the extension_language_script_ops.objfile_script_executor
+ "method". */
+
+static void
+gdbpy_execute_objfile_script (const struct extension_language_defn *extlang,
+ struct objfile *objfile, const char *name,
+ const char *script)
+{
+ if (!gdb_python_initialized)
+ return;
+
+ gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
+ gdbpy_current_objfile = objfile;
+
+ PyRun_SimpleString (script);
+
gdbpy_current_objfile = NULL;
}
gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
{
struct objfile *objf;
- PyObject *list;
- list = PyList_New (0);
- if (!list)
+ gdbpy_ref<> list (PyList_New (0));
+ if (list == NULL)
return NULL;
ALL_OBJFILES (objf)
{
PyObject *item = objfile_to_objfile_object (objf);
- if (!item || PyList_Append (list, item) == -1)
- {
- Py_DECREF (list);
- return NULL;
- }
+ if (!item || PyList_Append (list.get (), item) == -1)
+ return NULL;
}
- return list;
+ return list.release ();
}
-/* Compute the list of active type printers and return it. The result
- of this function can be passed to apply_type_printers, and should
- be freed by free_type_printers. */
+/* Compute the list of active python type printers and store them in
+ EXT_PRINTERS->py_type_printers. The product of this function is used by
+ gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
+ This is the extension_language_ops.start_type_printers "method". */
-void *
-start_type_printers (void)
+static void
+gdbpy_start_type_printers (const struct extension_language_defn *extlang,
+ struct ext_lang_type_printers *ext_printers)
{
- struct cleanup *cleanups;
- PyObject *type_module, *func, *result_obj = NULL;
+ PyObject *printers_obj = NULL;
+
+ if (!gdb_python_initialized)
+ return;
- cleanups = ensure_python_env (get_current_arch (), current_language);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
- type_module = PyImport_ImportModule ("gdb.types");
+ gdbpy_ref<> type_module (PyImport_ImportModule ("gdb.types"));
if (type_module == NULL)
{
gdbpy_print_stack ();
- goto done;
+ return;
}
- make_cleanup_py_decref (type_module);
- func = PyObject_GetAttrString (type_module, "get_type_recognizers");
+ gdbpy_ref<> func (PyObject_GetAttrString (type_module.get (),
+ "get_type_recognizers"));
if (func == NULL)
{
gdbpy_print_stack ();
- goto done;
+ return;
}
- make_cleanup_py_decref (func);
- result_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
- if (result_obj == NULL)
+ printers_obj = PyObject_CallFunctionObjArgs (func.get (), (char *) NULL);
+ if (printers_obj == NULL)
gdbpy_print_stack ();
-
- done:
- do_cleanups (cleanups);
- return result_obj;
+ else
+ ext_printers->py_type_printers = printers_obj;
}
-/* If TYPE is recognized by some type printer, return a newly
- allocated string holding the type's replacement name. The caller
- is responsible for freeing the string. Otherwise, return NULL.
-
- This function has a bit of a funny name, since it actually applies
- recognizers, but this seemed clearer given the start_type_printers
- and free_type_printers functions. */
-
-char *
-apply_type_printers (void *printers, struct type *type)
+/* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
+ a newly allocated string holding the type's replacement name, and return
+ EXT_LANG_RC_OK. The caller is responsible for freeing the string.
+ If there's a Python error return EXT_LANG_RC_ERROR.
+ Otherwise, return EXT_LANG_RC_NOP.
+ This is the extension_language_ops.apply_type_printers "method". */
+
+static enum ext_lang_rc
+gdbpy_apply_type_printers (const struct extension_language_defn *extlang,
+ const struct ext_lang_type_printers *ext_printers,
+ struct type *type, char **prettied_type)
{
- struct cleanup *cleanups;
- PyObject *type_obj, *type_module, *func, *result_obj;
- PyObject *printers_obj = printers;
- char *result = NULL;
+ PyObject *printers_obj = (PyObject *) ext_printers->py_type_printers;
+ gdb::unique_xmalloc_ptr<char> result;
if (printers_obj == NULL)
- return NULL;
+ return EXT_LANG_RC_NOP;
- cleanups = ensure_python_env (get_current_arch (), current_language);
+ if (!gdb_python_initialized)
+ return EXT_LANG_RC_NOP;
- type_obj = type_to_type_object (type);
+ gdbpy_enter enter_py (get_current_arch (), current_language);
+
+ gdbpy_ref<> type_obj (type_to_type_object (type));
if (type_obj == NULL)
{
gdbpy_print_stack ();
- goto done;
+ return EXT_LANG_RC_ERROR;
}
- make_cleanup_py_decref (type_obj);
- type_module = PyImport_ImportModule ("gdb.types");
+ gdbpy_ref<> type_module (PyImport_ImportModule ("gdb.types"));
if (type_module == NULL)
{
gdbpy_print_stack ();
- goto done;
+ return EXT_LANG_RC_ERROR;
}
- make_cleanup_py_decref (type_module);
- func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
+ gdbpy_ref<> func (PyObject_GetAttrString (type_module.get (),
+ "apply_type_recognizers"));
if (func == NULL)
{
gdbpy_print_stack ();
- goto done;
+ return EXT_LANG_RC_ERROR;
}
- make_cleanup_py_decref (func);
- result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
- type_obj, (char *) NULL);
+ gdbpy_ref<> result_obj (PyObject_CallFunctionObjArgs (func.get (),
+ printers_obj,
+ type_obj.get (),
+ (char *) NULL));
if (result_obj == NULL)
{
gdbpy_print_stack ();
- goto done;
+ return EXT_LANG_RC_ERROR;
}
- make_cleanup_py_decref (result_obj);
- if (result_obj != Py_None)
+ if (result_obj == Py_None)
+ return EXT_LANG_RC_NOP;
+
+ result = python_string_to_host_string (result_obj.get ());
+ if (result == NULL)
{
- result = python_string_to_host_string (result_obj);
- if (result == NULL)
- gdbpy_print_stack ();
+ gdbpy_print_stack ();
+ return EXT_LANG_RC_ERROR;
}
- done:
- do_cleanups (cleanups);
- return result;
+ *prettied_type = result.release ();
+ return EXT_LANG_RC_OK;
}
-/* Free the result of start_type_printers. */
+/* Free the result of start_type_printers.
+ This is the extension_language_ops.free_type_printers "method". */
-void
-free_type_printers (void *arg)
+static void
+gdbpy_free_type_printers (const struct extension_language_defn *extlang,
+ struct ext_lang_type_printers *ext_printers)
{
- struct cleanup *cleanups;
- PyObject *printers = arg;
+ PyObject *printers = (PyObject *) ext_printers->py_type_printers;
if (printers == NULL)
return;
- cleanups = ensure_python_env (get_current_arch (), current_language);
+ if (!gdb_python_initialized)
+ return;
+
+ gdbpy_enter enter_py (get_current_arch (), current_language);
Py_DECREF (printers);
- do_cleanups (cleanups);
}
#else /* HAVE_PYTHON */
error (_("Python scripting is not supported in this copy of GDB."));
else
{
- struct command_line *l = get_command_line (python_control, "");
- struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
+ command_line_up l = get_command_line (python_control, "");
- execute_control_command_untraced (l);
- do_cleanups (cleanups);
+ execute_control_command_untraced (l.get ());
}
}
python_interactive_command (arg, from_tty);
}
-void
-eval_python_from_control_command (struct command_line *cmd)
-{
- error (_("Python scripting is not supported in this copy of GDB."));
-}
-
-void
-source_python_script (FILE *file, const char *filename)
-{
- throw_error (UNSUPPORTED_ERROR,
- _("Python scripting is not supported in this copy of GDB."));
-}
-
-int
-gdbpy_should_stop (struct breakpoint_object *bp_obj)
-{
- internal_error (__FILE__, __LINE__,
- _("gdbpy_should_stop called when Python scripting is " \
- "not supported."));
-}
-
-int
-gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj)
-{
- internal_error (__FILE__, __LINE__,
- _("gdbpy_breakpoint_has_py_cond called when Python " \
- "scripting is not supported."));
-}
-
-void *
-start_type_printers (void)
-{
- return NULL;
-}
-
-char *
-apply_type_printers (void *ignore, struct type *type)
-{
- return NULL;
-}
-
-void
-free_type_printers (void *arg)
-{
-}
-
#endif /* HAVE_PYTHON */
\f
static void
finalize_python (void *ignore)
{
+ struct active_ext_lang_state *previous_active;
+
/* We don't use ensure_python_env here because if we ever ran the
cleanup, gdb would crash -- because the cleanup calls into the
Python interpreter, which we are about to destroy. It seems
clearer to make the needed calls explicitly here than to create a
cleanup and then mysteriously discard it. */
+
+ /* This is only called as a final cleanup so we can assume the active
+ SIGINT handler is gdb's. We still need to tell it to notify Python. */
+ previous_active = set_active_ext_lang (&extension_language_python);
+
(void) PyGILState_Ensure ();
python_gdbarch = target_gdbarch ();
python_language = current_language;
Py_Finalize ();
+
+ restore_active_ext_lang (previous_active);
}
#endif
/* Provide a prototype to silence -Wmissing-prototypes. */
extern initialize_file_ftype _initialize_python;
-void
-_initialize_python (void)
+#ifdef HAVE_PYTHON
+
+static bool
+do_start_initialization ()
{
char *progname;
#ifdef IS_PY3K
wchar_t *progname_copy;
#endif
+#ifdef WITH_PYTHON_PATH
+ /* Work around problem where python gets confused about where it is,
+ and then can't find its libraries, etc.
+ NOTE: Python assumes the following layout:
+ /foo/bin/python
+ /foo/lib/pythonX.Y/...
+ This must be done before calling Py_Initialize. */
+ progname = concat (ldirname (python_libdir).c_str (), SLASH_STRING, "bin",
+ SLASH_STRING, "python", (char *) NULL);
+#ifdef IS_PY3K
+ oldloc = xstrdup (setlocale (LC_ALL, NULL));
+ setlocale (LC_ALL, "");
+ progsize = strlen (progname);
+ progname_copy = (wchar_t *) PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
+ if (!progname_copy)
+ {
+ xfree (oldloc);
+ fprintf (stderr, "out of memory\n");
+ return false;
+ }
+ count = mbstowcs (progname_copy, progname, progsize + 1);
+ if (count == (size_t) -1)
+ {
+ xfree (oldloc);
+ fprintf (stderr, "Could not convert python path to string\n");
+ return false;
+ }
+ setlocale (LC_ALL, oldloc);
+ xfree (oldloc);
+
+ /* Note that Py_SetProgramName expects the string it is passed to
+ remain alive for the duration of the program's execution, so
+ it is not freed after this call. */
+ Py_SetProgramName (progname_copy);
+#else
+ Py_SetProgramName (progname);
+#endif
+#endif
+
+ Py_Initialize ();
+ PyEval_InitThreads ();
+
+#ifdef IS_PY3K
+ gdb_module = PyModule_Create (&python_GdbModuleDef);
+ /* Add _gdb module to the list of known built-in modules. */
+ _PyImport_FixupBuiltin (gdb_module, "_gdb");
+#else
+ gdb_module = Py_InitModule ("_gdb", python_GdbMethods);
+#endif
+ 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
+ || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
+ (char*) target_name) < 0)
+ return false;
+
+ /* Add stream constants. */
+ if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
+ || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
+ || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
+ return false;
+
+ gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
+ if (gdbpy_gdb_error == NULL
+ || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0)
+ return false;
+
+ gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
+ gdbpy_gdb_error, NULL);
+ if (gdbpy_gdb_memory_error == NULL
+ || gdb_pymodule_addobject (gdb_module, "MemoryError",
+ gdbpy_gdb_memory_error) < 0)
+ return false;
+
+ gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
+ if (gdbpy_gdberror_exc == NULL
+ || gdb_pymodule_addobject (gdb_module, "GdbError",
+ gdbpy_gdberror_exc) < 0)
+ return false;
+
+ gdbpy_initialize_gdb_readline ();
+
+ if (gdbpy_initialize_auto_load () < 0
+ || gdbpy_initialize_values () < 0
+ || gdbpy_initialize_frames () < 0
+ || gdbpy_initialize_commands () < 0
+ || gdbpy_initialize_record () < 0
+ || gdbpy_initialize_btrace () < 0
+ || gdbpy_initialize_symbols () < 0
+ || gdbpy_initialize_symtabs () < 0
+ || gdbpy_initialize_blocks () < 0
+ || gdbpy_initialize_functions () < 0
+ || gdbpy_initialize_parameters () < 0
+ || gdbpy_initialize_types () < 0
+ || gdbpy_initialize_pspace () < 0
+ || gdbpy_initialize_objfile () < 0
+ || gdbpy_initialize_breakpoints () < 0
+ || gdbpy_initialize_finishbreakpoints () < 0
+ || gdbpy_initialize_lazy_string () < 0
+ || gdbpy_initialize_linetable () < 0
+ || gdbpy_initialize_thread () < 0
+ || gdbpy_initialize_inferior () < 0
+ || gdbpy_initialize_events () < 0
+ || gdbpy_initialize_eventregistry () < 0
+ || gdbpy_initialize_py_events () < 0
+ || gdbpy_initialize_event () < 0
+ || gdbpy_initialize_stop_event () < 0
+ || gdbpy_initialize_signal_event () < 0
+ || gdbpy_initialize_breakpoint_event () < 0
+ || gdbpy_initialize_continue_event () < 0
+ || gdbpy_initialize_inferior_call_pre_event () < 0
+ || gdbpy_initialize_inferior_call_post_event () < 0
+ || gdbpy_initialize_register_changed_event () < 0
+ || gdbpy_initialize_memory_changed_event () < 0
+ || gdbpy_initialize_exited_event () < 0
+ || gdbpy_initialize_thread_event () < 0
+ || gdbpy_initialize_new_objfile_event () < 0
+ || gdbpy_initialize_clear_objfiles_event () < 0
+ || gdbpy_initialize_arch () < 0
+ || gdbpy_initialize_xmethods () < 0
+ || gdbpy_initialize_unwind () < 0)
+ return false;
+
+ gdbpy_to_string_cst = PyString_FromString ("to_string");
+ if (gdbpy_to_string_cst == NULL)
+ return false;
+ gdbpy_children_cst = PyString_FromString ("children");
+ if (gdbpy_children_cst == NULL)
+ return false;
+ gdbpy_display_hint_cst = PyString_FromString ("display_hint");
+ if (gdbpy_display_hint_cst == NULL)
+ return false;
+ gdbpy_doc_cst = PyString_FromString ("__doc__");
+ if (gdbpy_doc_cst == NULL)
+ return false;
+ gdbpy_enabled_cst = PyString_FromString ("enabled");
+ if (gdbpy_enabled_cst == NULL)
+ return false;
+ gdbpy_value_cst = PyString_FromString ("value");
+ if (gdbpy_value_cst == NULL)
+ return false;
+
+ /* Release the GIL while gdb runs. */
+ PyThreadState_Swap (NULL);
+ PyEval_ReleaseLock ();
+
+ make_final_cleanup (finalize_python, NULL);
+
+ /* Only set this when initialization has succeeded. */
+ gdb_python_initialized = 1;
+ return true;
+}
+
+#endif /* HAVE_PYTHON */
+
+void
+_initialize_python (void)
+{
add_com ("python-interactive", class_obscure,
python_interactive_command,
#ifdef HAVE_PYTHON
&user_show_python_list);
#ifdef HAVE_PYTHON
-#ifdef WITH_PYTHON_PATH
- /* Work around problem where python gets confused about where it is,
- and then can't find its libraries, etc.
- NOTE: Python assumes the following layout:
- /foo/bin/python
- /foo/lib/pythonX.Y/...
- This must be done before calling Py_Initialize. */
- progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
- SLASH_STRING, "python", NULL);
-#ifdef IS_PY3K
- oldloc = setlocale (LC_ALL, NULL);
- setlocale (LC_ALL, "");
- progsize = strlen (progname);
- if (progsize == (size_t) -1)
- {
- fprintf (stderr, "Could not convert python path to string\n");
- return;
- }
- progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
- if (!progname_copy)
- {
- fprintf (stderr, "out of memory\n");
- return;
- }
- count = mbstowcs (progname_copy, progname, progsize + 1);
- if (count == (size_t) -1)
- {
- fprintf (stderr, "Could not convert python path to string\n");
- return;
- }
- setlocale (LC_ALL, oldloc);
-
- /* Note that Py_SetProgramName expects the string it is passed to
- remain alive for the duration of the program's execution, so
- it is not freed after this call. */
- Py_SetProgramName (progname_copy);
-#else
- Py_SetProgramName (progname);
-#endif
-#endif
-
- Py_Initialize ();
- PyEval_InitThreads ();
-
-#ifdef IS_PY3K
- gdb_module = PyModule_Create (&GdbModuleDef);
- /* Add _gdb module to the list of known built-in modules. */
- _PyImport_FixupBuiltin (gdb_module, "_gdb");
-#else
- gdb_module = Py_InitModule ("_gdb", GdbMethods);
-#endif
-
- /* The casts to (char*) are for python 2.4. */
- PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
- PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
- PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
- (char*) target_name);
-
- /* Add stream constants. */
- PyModule_AddIntConstant (gdb_module, "STDOUT", 0);
- PyModule_AddIntConstant (gdb_module, "STDERR", 1);
- PyModule_AddIntConstant (gdb_module, "STDLOG", 2);
-
- gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
- PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error);
-
- gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
- gdbpy_gdb_error, NULL);
- PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error);
-
- gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
- PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc);
-
- gdbpy_initialize_gdb_readline ();
- gdbpy_initialize_auto_load ();
- gdbpy_initialize_values ();
- gdbpy_initialize_frames ();
- gdbpy_initialize_commands ();
- gdbpy_initialize_symbols ();
- gdbpy_initialize_symtabs ();
- gdbpy_initialize_blocks ();
- gdbpy_initialize_functions ();
- gdbpy_initialize_parameters ();
- gdbpy_initialize_types ();
- gdbpy_initialize_pspace ();
- gdbpy_initialize_objfile ();
- gdbpy_initialize_breakpoints ();
- gdbpy_initialize_finishbreakpoints ();
- gdbpy_initialize_lazy_string ();
- gdbpy_initialize_thread ();
- gdbpy_initialize_inferior ();
- gdbpy_initialize_events ();
-
- gdbpy_initialize_eventregistry ();
- gdbpy_initialize_py_events ();
- gdbpy_initialize_event ();
- gdbpy_initialize_stop_event ();
- gdbpy_initialize_signal_event ();
- gdbpy_initialize_breakpoint_event ();
- gdbpy_initialize_continue_event ();
- gdbpy_initialize_exited_event ();
- gdbpy_initialize_thread_event ();
- gdbpy_initialize_new_objfile_event () ;
- gdbpy_initialize_arch ();
-
- observer_attach_before_prompt (before_prompt_hook);
-
- gdbpy_to_string_cst = PyString_FromString ("to_string");
- gdbpy_children_cst = PyString_FromString ("children");
- gdbpy_display_hint_cst = PyString_FromString ("display_hint");
- gdbpy_doc_cst = PyString_FromString ("__doc__");
- gdbpy_enabled_cst = PyString_FromString ("enabled");
- gdbpy_value_cst = PyString_FromString ("value");
-
- /* Release the GIL while gdb runs. */
- PyThreadState_Swap (NULL);
- PyEval_ReleaseLock ();
-
- make_final_cleanup (finalize_python, NULL);
+ if (!do_start_initialization () && PyErr_Occurred ())
+ gdbpy_print_stack ();
#endif /* HAVE_PYTHON */
}
#ifdef HAVE_PYTHON
-/* Perform the remaining python initializations.
- These must be done after GDB is at least mostly initialized.
- E.g., The "info pretty-printer" command needs the "info" prefix
- command installed. */
+/* Helper function for gdbpy_finish_initialization. This does the
+ work and then returns false if an error has occurred and must be
+ displayed, or true on success. */
-void
-finish_python_initialization (void)
+static bool
+do_finish_initialization (const struct extension_language_defn *extlang)
{
PyObject *m;
- char *gdb_pythondir;
PyObject *sys_path;
- struct cleanup *cleanup;
-
- cleanup = ensure_python_env (get_current_arch (), current_language);
/* Add the initial data-directory to sys.path. */
- gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
- make_cleanup (xfree, gdb_pythondir);
+ std::string gdb_pythondir = (std::string (gdb_datadir) + SLASH_STRING
+ + "python");
sys_path = PySys_GetObject ("path");
#endif
sys_path = PySys_GetObject ("path");
}
- if (sys_path && PyList_Check (sys_path))
+ if (sys_path && PyList_Check (sys_path))
{
- PyObject *pythondir;
- int err;
-
- pythondir = PyString_FromString (gdb_pythondir);
- if (pythondir == NULL)
- goto fail;
-
- err = PyList_Insert (sys_path, 0, pythondir);
- if (err)
- goto fail;
-
- Py_DECREF (pythondir);
+ gdbpy_ref<> pythondir (PyString_FromString (gdb_pythondir.c_str ()));
+ if (pythondir == NULL || PyList_Insert (sys_path, 0, pythondir.get ()))
+ return false;
}
else
- goto fail;
+ return false;
/* Import the gdb module to finish the initialization, and
add it to __main__ for convenience. */
m = PyImport_AddModule ("__main__");
if (m == NULL)
- goto fail;
+ return false;
+ /* Keep the reference to gdb_python_module since it is in a global
+ variable. */
gdb_python_module = PyImport_ImportModule ("gdb");
if (gdb_python_module == NULL)
{
gdbpy_print_stack ();
- warning (_("Could not load the Python gdb module from `%s'."),
- gdb_pythondir);
- warning (_("Limited Python support is available from the _gdb module."));
- do_cleanups (cleanup);
- return;
+ /* This is passed in one call to warning so that blank lines aren't
+ inserted between each line of text. */
+ warning (_("\n"
+ "Could not load the Python gdb module from `%s'.\n"
+ "Limited Python support is available from the _gdb module.\n"
+ "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
+ gdb_pythondir.c_str ());
+ /* We return "success" here as we've already emitted the
+ warning. */
+ return true;
}
- if (PyModule_AddObject (m, "gdb", gdb_python_module))
- goto fail;
+ return gdb_pymodule_addobject (m, "gdb", gdb_python_module) >= 0;
+}
- /* Keep the reference to gdb_python_module since it is in a global
- variable. */
+/* Perform the remaining python initializations.
+ These must be done after GDB is at least mostly initialized.
+ E.g., The "info pretty-printer" command needs the "info" prefix
+ command installed.
+ This is the extension_language_ops.finish_initialization "method". */
- do_cleanups (cleanup);
- return;
+static void
+gdbpy_finish_initialization (const struct extension_language_defn *extlang)
+{
+ gdbpy_enter enter_py (get_current_arch (), current_language);
- fail:
- gdbpy_print_stack ();
- warning (_("internal error: Unhandled Python exception"));
- do_cleanups (cleanup);
+ if (!do_finish_initialization (extlang))
+ {
+ gdbpy_print_stack ();
+ warning (_("internal error: Unhandled Python exception"));
+ }
+}
+
+/* Return non-zero if Python has successfully initialized.
+ This is the extension_languages_ops.initialized "method". */
+
+static int
+gdbpy_initialized (const struct extension_language_defn *extlang)
+{
+ return gdb_python_initialized;
}
#endif /* HAVE_PYTHON */
#ifdef HAVE_PYTHON
-static PyMethodDef GdbMethods[] =
+PyMethodDef python_GdbMethods[] =
{
{ "history", gdbpy_history, METH_VARARGS,
"Get a value from history" },
{ "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
- "Execute a gdb command" },
+ "execute (command [, from_tty] [, to_string]) -> [String]\n\
+Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
+a Python String containing the output of the command if to_string is\n\
+set to True." },
{ "parameter", gdbpy_parameter, METH_VARARGS,
"Return a gdb parameter's value" },
"stop_reason_string (Integer) -> String.\n\
Return a string explaining unwind stop reason." },
+ { "start_recording", gdbpy_start_recording, METH_VARARGS,
+ "start_recording ([method] [, format]) -> gdb.Record.\n\
+Start recording with the given method. If no method is given, will fall back\n\
+to the system default method. If no format is given, will fall back to the\n\
+default format for the given method."},
+ { "current_recording", gdbpy_current_recording, METH_NOARGS,
+ "current_recording () -> gdb.Record.\n\
+Return current recording object." },
+ { "stop_recording", gdbpy_stop_recording, METH_NOARGS,
+ "stop_recording () -> None.\n\
+Stop current recording." },
+
{ "lookup_type", (PyCFunction) gdbpy_lookup_type,
METH_VARARGS | METH_KEYWORDS,
"lookup_type (name [, block]) -> type\n\
METH_VARARGS | METH_KEYWORDS,
"lookup_global_symbol (name [, domain]) -> symbol\n\
Return the symbol corresponding to the given name (or None)." },
+
+ { "lookup_objfile", (PyCFunction) gdbpy_lookup_objfile,
+ METH_VARARGS | METH_KEYWORDS,
+ "lookup_objfile (name, [by_build_id]) -> objfile\n\
+Look up the specified objfile.\n\
+If by_build_id is True, the objfile is looked up by using name\n\
+as its build id." },
+
{ "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
"Return the block containing the given pc value, or None." },
{ "solib_name", gdbpy_solib_name, METH_VARARGS,
{ "inferiors", gdbpy_inferiors, METH_NOARGS,
"inferiors () -> (gdb.Inferior, ...).\n\
Return a tuple containing all inferiors." },
+
+ { "invalidate_cached_frames", gdbpy_invalidate_cached_frames, METH_NOARGS,
+ "invalidate_cached_frames () -> None.\n\
+Invalidate any cached frame objects in gdb.\n\
+Intended for internal use only." },
+
{NULL, NULL, 0, NULL}
};
#ifdef IS_PY3K
-static struct PyModuleDef GdbModuleDef =
+struct PyModuleDef python_GdbModuleDef =
{
PyModuleDef_HEAD_INIT,
"_gdb",
NULL,
- -1,
- GdbMethods,
+ -1,
+ python_GdbMethods,
NULL,
NULL,
NULL,
projects / deliverable / binutils-gdb.git / blobdiff