/* General python/gdb code
- Copyright (C) 2008-2013 Free Software Foundation, Inc.
+ Copyright (C) 2008-2015 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>
/* Declared constants and enum for python stack printing. */
the default. */
static const char *gdbpy_should_print_stack = python_excp_message;
+#ifdef HAVE_PYTHON
+/* Forward decls, these are defined later. */
+static const struct extension_language_script_ops python_extension_script_ops;
+static 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"
+/* True if Python has been successfully initialized, false
+ otherwise. */
+
+int gdb_python_initialized;
+
static PyMethodDef GdbMethods[];
#ifdef IS_PY3K
/* The `gdb.MemoryError' exception. */
PyObject *gdbpy_gdb_memory_error;
+static script_sourcer_func gdbpy_source_script;
+static objfile_script_sourcer_func gdbpy_source_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_clear_quit_flag (const struct extension_language_defn *);
+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. */
+
+static const struct extension_language_script_ops python_extension_script_ops =
+{
+ gdbpy_source_script,
+ gdbpy_source_objfile_script,
+ gdbpy_auto_load_enabled
+};
+
+/* The interface between gdb proper and python extensions. */
+
+static const struct extension_language_ops python_extension_ops =
+{
+ gdbpy_finish_initialization,
+ gdbpy_initialized,
+
+ gdbpy_eval_from_control_command,
+
+ gdbpy_start_type_printers,
+ gdbpy_apply_type_printers,
+ gdbpy_free_type_printers,
+
+ gdbpy_apply_val_pretty_printer,
+
+ gdbpy_apply_frame_filter,
+
+ gdbpy_preserve_values,
+
+ gdbpy_breakpoint_has_cond,
+ gdbpy_breakpoint_cond_says_stop,
+
+ gdbpy_clear_quit_flag,
+ 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_invoke_xmethod
+};
+
/* Architecture and language to be used in callbacks from
the Python interpreter. */
struct gdbarch *python_gdbarch;
struct python_env
{
+ struct active_ext_lang_state *previous_active;
PyGILState_STATE state;
struct gdbarch *gdbarch;
const struct language_defn *language;
PyGILState_Release (env->state);
python_gdbarch = env->gdbarch;
python_language = env->language;
+
+ restore_active_ext_lang (env->previous_active);
+
xfree (env);
}
/* Called before entering the Python interpreter to install the
- current language and architecture to be used for Python values. */
+ current language and architecture to be used for Python values.
+ Also set the active extension language for GDB so that SIGINT's
+ are directed our way, and if necessary install the right SIGINT
+ handler. */
struct cleanup *
ensure_python_env (struct gdbarch *gdbarch,
{
struct python_env *env = xmalloc (sizeof *env);
+ /* We should not ever enter Python unless initialized. */
+ if (!gdb_python_initialized)
+ error (_("Python not initialized"));
+
+ env->previous_active = set_active_ext_lang (&extension_language_python);
+
env->state = PyGILState_Ensure ();
env->gdbarch = python_gdbarch;
env->language = python_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);
}
/* Clear the quit flag. */
-void
-clear_quit_flag (void)
+static void
+gdbpy_clear_quit_flag (const struct extension_language_defn *extlang)
{
/* This clears the flag as a side effect. */
PyOS_InterruptOccurred ();
/* 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 ();
}
cleanup = make_cleanup_restore_integer (&interpreter_async);
interpreter_async = 0;
- while (arg && *arg && isspace (*arg))
- ++arg;
+ arg = skip_spaces (arg);
ensure_python_env (get_current_arch (), current_language);
gdbpy_print_stack ();
error (_("Error while opening file: %s"), full_path);
}
-
+
make_cleanup_py_decref (python_file);
PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
do_cleanups (cleanup);
/* 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;
make_cleanup_restore_integer (&interpreter_async);
interpreter_async = 0;
- while (arg && *arg && isspace (*arg))
- ++arg;
+ arg = skip_spaces (arg);
if (arg && *arg)
{
if (PyRun_SimpleString (arg))
}
}
- return PyErr_Format (PyExc_RuntimeError,
+ return PyErr_Format (PyExc_RuntimeError,
_("Programmer error: unhandled type."));
}
_("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);
}
{
do_cleanups (cleanups);
/* We know this will always throw. */
- GDB_PY_HANDLE_EXCEPTION (except);
+ gdbpy_convert_exception (except);
+ return NULL;
}
if (sals.nelts)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- 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);
{
gdb_py_ulongest pc_llu;
volatile struct gdb_exception except;
- PyObject *result;
+ PyObject *result = NULL; /* init for gcc -Wall */
if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
return NULL;
}
/* 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;
while (gdbpy_event_list)
{
+ PyObject *call_result;
+
/* Dispatching the event might push a new element onto the event
loop, so we update here "atomically enough". */
struct gdbpy_event *item = gdbpy_event_list;
gdbpy_event_list_end = &gdbpy_event_list;
/* Ignore errors. */
- if (PyObject_CallObject (item->event, NULL) == NULL)
+ call_result = PyObject_CallObject (item->event, NULL);
+ if (call_result == NULL)
PyErr_Clear ();
+ Py_XDECREF (call_result);
Py_DECREF (item->event);
xfree (item);
}
if (!PyCallable_Check (func))
{
- PyErr_SetString (PyExc_RuntimeError,
+ PyErr_SetString (PyExc_RuntimeError,
_("Posted event is not callable"));
return NULL;
}
}
/* 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);
}
+
+ 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);
if (gdb_python_module
if (hook == NULL)
goto fail;
+ make_cleanup_py_decref (hook);
+
if (PyCallable_Check (hook))
{
PyObject *result;
set_prompt (prompt);
do_cleanups (cleanup);
- return;
+ return prompt != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_NOP;
fail:
gdbpy_print_stack ();
do_cleanups (cleanup);
- return;
+ return EXT_LANG_RC_ERROR;
}
\f
static 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))
return NULL;
}
}
GDB_PY_HANDLE_EXCEPTION (except);
-
+
Py_RETURN_NONE;
}
{
static char *keywords[] = {"stream", NULL };
int stream_type = 0;
-
+
if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
&stream_type))
return NULL;
default:
gdb_flush (gdb_stdout);
}
-
+
Py_RETURN_NONE;
}
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. */
- begin_line ();
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ begin_line ();
+ }
}
/* Print "message", just error print message. */
else
/* Fetch the error message contained within ptype, pvalue. */
msg = gdbpy_exception_to_string (ptype, pvalue);
type = gdbpy_obj_to_string (ptype);
- if (msg == NULL)
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
{
- /* An error occurred computing the string representation of the
- error message. */
- fprintf_filtered (gdb_stderr,
- _("Error occurred computing Python error" \
- "message.\n"));
+ if (msg == NULL)
+ {
+ /* An error occurred computing the string representation of the
+ error message. */
+ fprintf_filtered (gdb_stderr,
+ _("Error occurred computing Python error" \
+ "message.\n"));
+ }
+ else
+ fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
+ type, msg);
}
- else
- fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
- type, msg);
Py_XDECREF (ptype);
Py_XDECREF (pvalue);
/* 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; 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_current_objfile = objfile;
return list;
}
-/* 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 *type_module, *func = NULL, *printers_obj = NULL;
+
+ if (!gdb_python_initialized)
+ return;
cleanups = ensure_python_env (get_current_arch (), current_language);
gdbpy_print_stack ();
goto done;
}
- make_cleanup_py_decref (type_module);
func = PyObject_GetAttrString (type_module, "get_type_recognizers");
if (func == NULL)
gdbpy_print_stack ();
goto done;
}
- make_cleanup_py_decref (func);
- result_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
- if (result_obj == NULL)
+ printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
+ if (printers_obj == NULL)
gdbpy_print_stack ();
+ else
+ ext_printers->py_type_printers = printers_obj;
done:
+ Py_XDECREF (type_module);
+ Py_XDECREF (func);
do_cleanups (cleanups);
- return result_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;
+ PyObject *type_obj, *type_module = NULL, *func = NULL;
+ PyObject *result_obj = NULL;
+ PyObject *printers_obj = ext_printers->py_type_printers;
char *result = NULL;
if (printers_obj == NULL)
- return NULL;
+ return EXT_LANG_RC_NOP;
+
+ if (!gdb_python_initialized)
+ return EXT_LANG_RC_NOP;
cleanups = ensure_python_env (get_current_arch (), current_language);
gdbpy_print_stack ();
goto done;
}
- make_cleanup_py_decref (type_obj);
type_module = PyImport_ImportModule ("gdb.types");
if (type_module == NULL)
gdbpy_print_stack ();
goto done;
}
- make_cleanup_py_decref (type_module);
func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
if (func == NULL)
gdbpy_print_stack ();
goto done;
}
- make_cleanup_py_decref (func);
result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
type_obj, (char *) NULL);
gdbpy_print_stack ();
goto done;
}
- make_cleanup_py_decref (result_obj);
if (result_obj != Py_None)
{
}
done:
+ Py_XDECREF (type_obj);
+ Py_XDECREF (type_module);
+ Py_XDECREF (func);
+ Py_XDECREF (result_obj);
do_cleanups (cleanups);
- return result;
+ if (result != NULL)
+ *prettied_type = result;
+ return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR;
}
-/* 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 = ext_printers->py_type_printers;
if (printers == NULL)
return;
+ if (!gdb_python_initialized)
+ return;
+
cleanups = ensure_python_env (get_current_arch (), current_language);
Py_DECREF (printers);
do_cleanups (cleanups);
static void
python_interactive_command (char *arg, int from_tty)
{
- while (arg && *arg && isspace (*arg))
- ++arg;
+ arg = skip_spaces (arg);
if (arg && *arg)
error (_("Python scripting is not supported in this copy of GDB."));
else
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
#else
gdb_module = Py_InitModule ("_gdb", GdbMethods);
#endif
+ if (gdb_module == NULL)
+ goto fail;
/* 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);
+ 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)
+ goto fail;
/* Add stream constants. */
- PyModule_AddIntConstant (gdb_module, "STDOUT", 0);
- PyModule_AddIntConstant (gdb_module, "STDERR", 1);
- PyModule_AddIntConstant (gdb_module, "STDLOG", 2);
+ if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
+ || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
+ || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
+ goto fail;
gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
- PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error);
+ if (gdbpy_gdb_error == NULL
+ || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0)
+ goto fail;
gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
gdbpy_gdb_error, NULL);
- PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error);
+ if (gdbpy_gdb_memory_error == NULL
+ || gdb_pymodule_addobject (gdb_module, "MemoryError",
+ gdbpy_gdb_memory_error) < 0)
+ goto fail;
gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
- PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc);
+ if (gdbpy_gdberror_exc == NULL
+ || gdb_pymodule_addobject (gdb_module, "GdbError",
+ gdbpy_gdberror_exc) < 0)
+ goto fail;
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);
+
+ if (gdbpy_initialize_auto_load () < 0
+ || gdbpy_initialize_values () < 0
+ || gdbpy_initialize_frames () < 0
+ || gdbpy_initialize_commands () < 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)
+ goto fail;
gdbpy_to_string_cst = PyString_FromString ("to_string");
+ if (gdbpy_to_string_cst == NULL)
+ goto fail;
gdbpy_children_cst = PyString_FromString ("children");
+ if (gdbpy_children_cst == NULL)
+ goto fail;
gdbpy_display_hint_cst = PyString_FromString ("display_hint");
+ if (gdbpy_display_hint_cst == NULL)
+ goto fail;
gdbpy_doc_cst = PyString_FromString ("__doc__");
+ if (gdbpy_doc_cst == NULL)
+ goto fail;
gdbpy_enabled_cst = PyString_FromString ("enabled");
+ if (gdbpy_enabled_cst == NULL)
+ goto fail;
gdbpy_value_cst = PyString_FromString ("value");
+ if (gdbpy_value_cst == NULL)
+ goto fail;
/* Release the GIL while gdb runs. */
PyThreadState_Swap (NULL);
PyEval_ReleaseLock ();
make_final_cleanup (finalize_python, NULL);
+
+ gdb_python_initialized = 1;
+ return;
+
+ fail:
+ gdbpy_print_stack ();
+ /* Do not set 'gdb_python_initialized'. */
+ return;
+
#endif /* 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. */
+ command installed.
+ This is the extension_language_ops.finish_initialization "method". */
-void
-finish_python_initialization (void)
+static void
+gdbpy_finish_initialization (const struct extension_language_defn *extlang)
{
PyObject *m;
char *gdb_pythondir;
#endif
sys_path = PySys_GetObject ("path");
}
- if (sys_path && PyList_Check (sys_path))
+ if (sys_path && PyList_Check (sys_path))
{
PyObject *pythondir;
int err;
goto fail;
err = PyList_Insert (sys_path, 0, pythondir);
+ Py_DECREF (pythondir);
if (err)
goto fail;
-
- Py_DECREF (pythondir);
}
else
goto fail;
if (gdb_python_module == NULL)
{
gdbpy_print_stack ();
- warning (_("Could not load the Python gdb module from `%s'."),
+ /* 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);
- warning (_("Limited Python support is available from the _gdb module."));
do_cleanups (cleanup);
return;
}
- if (PyModule_AddObject (m, "gdb", gdb_python_module))
+ if (gdb_pymodule_addobject (m, "gdb", gdb_python_module) < 0)
goto fail;
/* Keep the reference to gdb_python_module since it is in a global
do_cleanups (cleanup);
}
+/* 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 */
\f
{ "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" },
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,
PyModuleDef_HEAD_INIT,
"_gdb",
NULL,
- -1,
+ -1,
GdbMethods,
NULL,
NULL,
projects / thirdparty / binutils-gdb.git / blobdiff