/* General python/gdb code
- Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2008-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include "serial.h"
#include "readline/tilde.h"
#include "python.h"
-
+#include "extension-priv.h"
+#include "cli/cli-utils.h"
#include <ctype.h>
-/* True if we should print the stack when catching a Python error,
- false otherwise. */
-static int gdbpy_should_print_stack = 0;
+/* Declared constants and enum for python stack printing. */
+static const char python_excp_none[] = "none";
+static const char python_excp_full[] = "full";
+static const char python_excp_message[] = "message";
+
+/* "set python print-stack" choices. */
+static const char *const python_excp_enums[] =
+ {
+ python_excp_none,
+ python_excp_full,
+ python_excp_message,
+ NULL
+ };
+
+/* The exception printing variable. 'full' if we want to print the
+ error message and stack, 'none' if we want to print nothing, and
+ 'message' if we only want to print the error message. 'message' is
+ 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 "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
+static struct PyModuleDef GdbModuleDef;
+#endif
+
PyObject *gdb_module;
+PyObject *gdb_python_module;
/* Some string constants we may wish to use. */
PyObject *gdbpy_to_string_cst;
/* 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);
}
-/* A wrapper around PyRun_SimpleFile. FILENAME is the name of
- the Python script to run.
-
- One of the parameters of PyRun_SimpleFile is a FILE *.
- The problem is that type FILE is extremely system and compiler
- dependent. So, unless the Python library has been compiled using
- the same build environment as GDB, we run the risk of getting
- a crash due to inconsistencies between the definition used by GDB,
- and the definition used by Python. A mismatch can very likely
- lead to a crash.
-
- There is also the situation where the Python library and GDB
- are using two different versions of the C runtime library.
- This is particularly visible on Windows, where few users would
- build Python themselves (this is no trivial task on this platform),
- and thus use binaries built by someone else instead. Python,
- being built with VC, would use one version of the msvcr DLL
- (Eg. msvcr100.dll), while MinGW uses msvcrt.dll. A FILE *
- from one runtime does not necessarily operate correctly in
+/* Clear the quit flag. */
+
+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. */
+
+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. */
+
+static int
+gdbpy_check_quit_flag (const struct extension_language_defn *extlang)
+{
+ return PyOS_InterruptOccurred ();
+}
+
+/* Evaluate a Python command like PyRun_SimpleString, but uses
+ Py_single_input which prints the result of expressions, and does
+ not automatically print the stack on errors. */
+
+static int
+eval_python_command (const char *command)
+{
+ PyObject *m, *d, *v;
+
+ m = PyImport_AddModule ("__main__");
+ if (m == NULL)
+ return -1;
+
+ d = PyModule_GetDict (m);
+ if (d == NULL)
+ return -1;
+ 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 ();
+#endif
+
+ return 0;
+}
+
+/* Implementation of the gdb "python-interactive" command. */
+
+static void
+python_interactive_command (char *arg, int from_tty)
+{
+ struct cleanup *cleanup;
+ int err;
+
+ cleanup = make_cleanup_restore_integer (&interpreter_async);
+ interpreter_async = 0;
+
+ arg = skip_spaces (arg);
+
+ ensure_python_env (get_current_arch (), current_language);
+
+ if (arg && *arg)
+ {
+ int len = strlen (arg);
+ char *script = xmalloc (len + 2);
+
+ strcpy (script, arg);
+ script[len] = '\n';
+ script[len + 1] = '\0';
+ err = eval_python_command (script);
+ xfree (script);
+ }
+ else
+ {
+ err = PyRun_InteractiveLoop (instream, "<stdin>");
+ dont_repeat ();
+ }
+
+ if (err)
+ {
+ gdbpy_print_stack ();
+ error (_("Error while executing Python code."));
+ }
+
+ do_cleanups (cleanup);
+}
+
+/* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
+ named FILENAME.
+
+ On Windows hosts few users would build Python themselves (this is no
+ trivial task on this platform), and thus use binaries built by
+ someone else instead. There may happen situation where the Python
+ library and GDB are using two different versions of the C runtime
+ library. Python, being built with VC, would use one version of the
+ msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
+ A FILE * from one runtime does not necessarily operate correctly in
the other runtime.
- To work around this potential issue, we create the FILE object
- using Python routines, thus making sure that it is compatible
- with the Python library. */
+ To work around this potential issue, we create on Windows hosts the
+ FILE object using Python routines, thus making sure that it is
+ compatible with the Python library. */
static void
-python_run_simple_file (const char *filename)
+python_run_simple_file (FILE *file, const char *filename)
{
+#ifndef _WIN32
+
+ PyRun_SimpleFile (file, filename);
+
+#else /* _WIN32 */
+
char *full_path;
PyObject *python_file;
struct cleanup *cleanup;
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);
+
+#endif /* _WIN32 */
}
/* Given a command_line, return a command string suitable for passing
/* 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;
ret = PyRun_SimpleString (script);
xfree (script);
if (ret)
- {
- gdbpy_print_stack ();
- error (_("Error while executing Python code."));
- }
+ error (_("Error while executing Python code."));
do_cleanups (cleanup);
}
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))
- {
- gdbpy_print_stack ();
- error (_("Error while executing Python code."));
- }
+ error (_("Error while executing Python code."));
}
else
{
}
}
- 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);
}
appease gcc. */
struct symtab_and_line sal;
const char *arg = NULL;
- char *copy = NULL;
+ char *copy_to_free = NULL, *copy = NULL;
struct cleanup *cleanups;
PyObject *result = NULL;
PyObject *return_result = NULL;
if (! PyArg_ParseTuple (args, "|s", &arg))
return NULL;
- cleanups = ensure_python_env (get_current_arch (), current_language);
+ cleanups = make_cleanup (null_cleanup, NULL);
+ sals.sals = NULL;
TRY_CATCH (except, RETURN_MASK_ALL)
{
if (arg)
{
copy = xstrdup (arg);
- make_cleanup (xfree, copy);
- sals = decode_line_1 (©, 0, 0, 0, 0);
- make_cleanup (xfree, sals.sals);
+ copy_to_free = copy;
+ sals = decode_line_1 (©, 0, 0, 0);
}
else
{
sals.nelts = 1;
}
}
+
+ if (sals.sals != NULL && sals.sals != &sal)
+ {
+ make_cleanup (xfree, copy_to_free);
+ 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)
for (i = 0; i < sals.nelts; ++i)
{
PyObject *obj;
- char *str;
obj = symtab_and_line_to_sal_object (sals.sals[i]);
if (! obj)
}
if (copy && strlen (copy) > 0)
- unparsed = PyString_FromString (copy);
+ {
+ unparsed = PyString_FromString (copy);
+ if (unparsed == NULL)
+ {
+ Py_DECREF (result);
+ Py_DECREF (return_result);
+ return_result = NULL;
+ goto error;
+ }
+ }
else
{
unparsed = Py_None;
PyTuple_SetItem (return_result, 0, unparsed);
PyTuple_SetItem (return_result, 1, result);
+ error:
do_cleanups (cleanups);
return return_result;
-
- error:
- do_cleanups (cleanups);
- return NULL;
}
/* Parse a string and evaluate it as an expression. */
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);
return value_to_value_object (result);
}
+/* Implementation of gdb.find_pc_line function.
+ Returns the gdb.Symtab_and_line object corresponding to a PC value. */
+
+static PyObject *
+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)
+ {
+ struct symtab_and_line sal;
+ CORE_ADDR pc;
+
+ pc = (CORE_ADDR) pc_llu;
+ sal = find_pc_line (pc, 0);
+ result = symtab_and_line_to_sal_object (sal);
+ }
+ GDB_PY_HANDLE_EXCEPTION (except);
+
+ return result;
+}
+
/* Read a file as Python code.
- FILE is the name of the 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 (const char *file)
+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);
- python_run_simple_file (file);
+ python_run_simple_file (file, filename);
do_cleanups (cleanup);
}
gdbpy_run_events (struct serial *scb, void *context)
{
struct cleanup *cleanup;
- int r;
cleanup = ensure_python_env (get_current_arch (), current_language);
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 (PyObject_HasAttrString (gdb_module, "prompt_hook"))
+ if (gdb_python_module
+ && PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
{
PyObject *hook;
- hook = PyObject_GetAttrString (gdb_module, "prompt_hook");
+ hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
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
const char *arg;
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;
- switch (stream_type)
+ TRY_CATCH (except, RETURN_MASK_ALL)
{
- case 1:
- {
- fprintf_filtered (gdb_stderr, "%s", arg);
- break;
- }
- case 2:
- {
- fprintf_filtered (gdb_stdlog, "%s", arg);
- break;
- }
- default:
- fprintf_filtered (gdb_stdout, "%s", arg);
+ switch (stream_type)
+ {
+ case 1:
+ {
+ fprintf_filtered (gdb_stderr, "%s", arg);
+ break;
+ }
+ case 2:
+ {
+ fprintf_filtered (gdb_stdlog, "%s", arg);
+ break;
+ }
+ default:
+ fprintf_filtered (gdb_stdout, "%s", arg);
+ }
}
-
+ 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;
}
-/* Print a python exception trace, or print nothing and clear the
- python exception, depending on gdbpy_should_print_stack. Only call
- this if a python exception is set. */
+/* 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
+ set. */
void
gdbpy_print_stack (void)
{
- if (gdbpy_should_print_stack)
+ volatile struct gdb_exception except;
+
+ /* Print "none", just clear exception. */
+ if (gdbpy_should_print_stack == python_excp_none)
+ {
+ PyErr_Clear ();
+ }
+ /* Print "full" message and backtrace. */
+ else if (gdbpy_should_print_stack == python_excp_full)
{
PyErr_Print ();
/* 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
- PyErr_Clear ();
+ {
+ 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);
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ 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);
+ }
+
+ Py_XDECREF (ptype);
+ Py_XDECREF (pvalue);
+ Py_XDECREF (ptraceback);
+ xfree (msg);
+ }
}
\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; it is NULL at other times. */
static struct objfile *gdbpy_current_objfile;
-/* Set the current objfile to OBJFILE and then read FILE as Python code.
- This does not throw any errors. If an exception occurs python will print
- the traceback and clear the error indicator. */
+/* 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.
+ This is the extension_language_script_ops.objfile_script_sourcer
+ "method". */
-void
-source_python_script_for_objfile (struct objfile *objfile, const char *file)
+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;
- python_run_simple_file (file);
+ python_run_simple_file (file, filename);
do_cleanups (cleanups);
gdbpy_current_objfile = NULL;
return list;
}
-#else /* HAVE_PYTHON */
-
-/* Dummy implementation of the gdb "python" command. */
+/* 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". */
static void
-python_command (char *arg, int from_tty)
+gdbpy_start_type_printers (const struct extension_language_defn *extlang,
+ struct ext_lang_type_printers *ext_printers)
{
- while (arg && *arg && isspace (*arg))
- ++arg;
- if (arg && *arg)
- error (_("Python scripting is not supported in this copy of GDB."));
- else
+ struct cleanup *cleanups;
+ PyObject *type_module, *func = NULL, *printers_obj = NULL;
+
+ if (!gdb_python_initialized)
+ return;
+
+ cleanups = ensure_python_env (get_current_arch (), current_language);
+
+ type_module = PyImport_ImportModule ("gdb.types");
+ if (type_module == NULL)
{
- struct command_line *l = get_command_line (python_control, "");
- struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
+ gdbpy_print_stack ();
+ goto done;
+ }
- execute_control_command_untraced (l);
- do_cleanups (cleanups);
+ func = PyObject_GetAttrString (type_module, "get_type_recognizers");
+ if (func == NULL)
+ {
+ gdbpy_print_stack ();
+ goto done;
}
-}
-void
-eval_python_from_control_command (struct command_line *cmd)
-{
- error (_("Python scripting is not supported in this copy of GDB."));
-}
+ printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
+ if (printers_obj == NULL)
+ gdbpy_print_stack ();
+ else
+ ext_printers->py_type_printers = printers_obj;
-void
-source_python_script (const char *file)
-{
- throw_error (UNSUPPORTED_ERROR,
- _("Python scripting is not supported in this copy of GDB."));
+ done:
+ Py_XDECREF (type_module);
+ Py_XDECREF (func);
+ do_cleanups (cleanups);
}
-int
-gdbpy_should_stop (struct breakpoint_object *bp_obj)
+/* 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)
{
- internal_error (__FILE__, __LINE__,
- _("gdbpy_should_stop called when Python scripting is " \
- "not supported."));
-}
+ struct cleanup *cleanups;
+ PyObject *type_obj, *type_module = NULL, *func = NULL;
+ PyObject *result_obj = NULL;
+ PyObject *printers_obj = ext_printers->py_type_printers;
+ char *result = NULL;
-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."));
-}
+ if (printers_obj == NULL)
+ return EXT_LANG_RC_NOP;
-#endif /* HAVE_PYTHON */
+ if (!gdb_python_initialized)
+ return EXT_LANG_RC_NOP;
-\f
+ cleanups = ensure_python_env (get_current_arch (), current_language);
-/* Lists for 'maint set python' commands. */
+ type_obj = type_to_type_object (type);
+ if (type_obj == NULL)
+ {
+ gdbpy_print_stack ();
+ goto done;
+ }
-static struct cmd_list_element *maint_set_python_list;
-static struct cmd_list_element *maint_show_python_list;
+ type_module = PyImport_ImportModule ("gdb.types");
+ if (type_module == NULL)
+ {
+ gdbpy_print_stack ();
+ goto done;
+ }
-/* Lists for 'set python' commands. */
+ func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
+ if (func == NULL)
+ {
+ gdbpy_print_stack ();
+ goto done;
+ }
-static struct cmd_list_element *user_set_python_list;
-static struct cmd_list_element *user_show_python_list;
+ result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
+ type_obj, (char *) NULL);
+ if (result_obj == NULL)
+ {
+ gdbpy_print_stack ();
+ goto done;
+ }
+
+ if (result_obj != Py_None)
+ {
+ result = python_string_to_host_string (result_obj);
+ if (result == NULL)
+ gdbpy_print_stack ();
+ }
+
+ done:
+ Py_XDECREF (type_obj);
+ Py_XDECREF (type_module);
+ Py_XDECREF (func);
+ Py_XDECREF (result_obj);
+ do_cleanups (cleanups);
+ if (result != NULL)
+ *prettied_type = result;
+ return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR;
+}
-/* Function for use by 'maint set python' prefix command. */
+/* Free the result of start_type_printers.
+ This is the extension_language_ops.free_type_printers "method". */
static void
-maint_set_python (char *args, int from_tty)
+gdbpy_free_type_printers (const struct extension_language_defn *extlang,
+ struct ext_lang_type_printers *ext_printers)
{
- help_list (maint_set_python_list, "maintenance set python ",
- class_deprecated, gdb_stdout);
+ struct cleanup *cleanups;
+ 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);
}
-/* Function for use by 'maint show python' prefix command. */
+#else /* HAVE_PYTHON */
+
+/* Dummy implementation of the gdb "python-interactive" and "python"
+ command. */
+
+static void
+python_interactive_command (char *arg, int from_tty)
+{
+ arg = skip_spaces (arg);
+ if (arg && *arg)
+ 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);
+
+ execute_control_command_untraced (l);
+ do_cleanups (cleanups);
+ }
+}
static void
-maint_show_python (char *args, int from_tty)
+python_command (char *arg, int from_tty)
{
- cmd_show_list (maint_show_python_list, from_tty, "");
+ python_interactive_command (arg, from_tty);
}
+#endif /* HAVE_PYTHON */
+
+\f
+
+/* Lists for 'set python' commands. */
+
+static struct cmd_list_element *user_set_python_list;
+static struct cmd_list_element *user_show_python_list;
+
/* Function for use by 'set python' prefix command. */
static void
/* Initialize the Python code. */
+#ifdef HAVE_PYTHON
+
+/* This is installed as a final cleanup and cleans up the
+ interpreter. This lets Python's 'atexit' work. */
+
+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)
{
- char *cmd_name;
- struct cmd_list_element *cmd;
+ char *progname;
+#ifdef IS_PY3K
+ int i;
+ size_t progsize, count;
+ char *oldloc;
+ wchar_t *progname_copy;
+#endif
+
+ add_com ("python-interactive", class_obscure,
+ python_interactive_command,
+#ifdef HAVE_PYTHON
+ _("\
+Start an interactive Python prompt.\n\
+\n\
+To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
+prompt).\n\
+\n\
+Alternatively, a single-line Python command can be given as an\n\
+argument, and if the command is an expression, the result will be\n\
+printed. For example:\n\
+\n\
+ (gdb) python-interactive 2 + 3\n\
+ 5\n\
+")
+#else /* HAVE_PYTHON */
+ _("\
+Start a Python interactive prompt.\n\
+\n\
+Python scripting is not supported in this copy of GDB.\n\
+This command is only a placeholder.")
+#endif /* HAVE_PYTHON */
+ );
+ add_com_alias ("pi", "python-interactive", class_obscure, 1);
add_com ("python", class_obscure, python_command,
#ifdef HAVE_PYTHON
This command is only a placeholder.")
#endif /* HAVE_PYTHON */
);
-
- add_prefix_cmd ("python", no_class, maint_show_python,
- _("Prefix command for python maintenance settings."),
- &maint_show_python_list, "maintenance show python ", 0,
- &maintenance_show_cmdlist);
- add_prefix_cmd ("python", no_class, maint_set_python,
- _("Prefix command for python maintenance settings."),
- &maint_set_python_list, "maintenance set python ", 0,
- &maintenance_set_cmdlist);
-
- add_setshow_boolean_cmd ("print-stack", class_maintenance,
- &gdbpy_should_print_stack, _("\
-Enable or disable printing of Python stack dump on error."), _("\
-Show whether Python stack will be printed on error."), _("\
-Enables or disables printing of Python stack traces."),
- NULL, NULL,
- &maint_set_python_list,
- &maint_show_python_list);
-
- /* Deprecate maint set/show python print-stack in favour of
- non-maintenance alternatives. */
- cmd_name = "print-stack";
- cmd = lookup_cmd (&cmd_name, maint_set_python_list, "", -1, 0);
- deprecate_cmd (cmd, "set python print-stack");
- cmd_name = "print-stack"; /* Reset name. */
- cmd = lookup_cmd (&cmd_name, maint_show_python_list, "", -1, 0);
- deprecate_cmd (cmd, "show python print-stack");
+ add_com_alias ("py", "python", class_obscure, 1);
/* Add set/show python print-stack. */
add_prefix_cmd ("python", no_class, user_show_python,
&user_set_python_list, "set python ", 0,
&setlist);
- add_setshow_boolean_cmd ("print-stack", no_class,
- &gdbpy_should_print_stack, _("\
-Enable or disable printing of Python stack dump on error."), _("\
-Show whether Python stack will be printed on error."), _("\
-Enables or disables printing of Python stack traces."),
- NULL, NULL,
- &user_set_python_list,
- &user_show_python_list);
+ add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
+ &gdbpy_should_print_stack, _("\
+Set mode for Python stack dump on error."), _("\
+Show the mode of Python stack printing on error."), _("\
+none == no stack or message will be printed.\n\
+full == a message and a stack will be printed.\n\
+message == an error message without a stack will be printed."),
+ NULL, NULL,
+ &user_set_python_list,
+ &user_show_python_list);
#ifdef HAVE_PYTHON
#ifdef WITH_PYTHON_PATH
/foo/bin/python
/foo/lib/pythonX.Y/...
This must be done before calling Py_Initialize. */
- Py_SetProgramName (concat (ldirname (python_libdir), SLASH_STRING, "bin",
- SLASH_STRING, "python", NULL));
+ 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 ();
- gdb_module = Py_InitModule ("gdb", GdbMethods);
+#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
+ 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);
-
- /* gdb.parameter ("data-directory") doesn't necessarily exist when the python
- script below is run (depending on order of _initialize_* functions).
- Define the initial value of gdb.PYTHONDIR here. */
- {
- char *gdb_pythondir;
-
- gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
- PyModule_AddStringConstant (gdb_module, "PYTHONDIR", gdb_pythondir);
- xfree (gdb_pythondir);
- }
+ 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);
-
- 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_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 () ;
-
- observer_attach_before_prompt (before_prompt_hook);
-
- PyRun_SimpleString ("import gdb");
- PyRun_SimpleString ("gdb.pretty_printers = []");
+ if (gdbpy_gdberror_exc == NULL
+ || gdb_pymodule_addobject (gdb_module, "GdbError",
+ gdbpy_gdberror_exc) < 0)
+ goto fail;
+
+ gdbpy_initialize_gdb_readline ();
+
+ 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_exited_event () < 0
+ || gdbpy_initialize_thread_event () < 0
+ || gdbpy_initialize_new_objfile_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;
+ PyObject *sys_path;
struct cleanup *cleanup;
cleanup = ensure_python_env (get_current_arch (), current_language);
- PyRun_SimpleString ("\
-import os\n\
-import sys\n\
-\n\
-class GdbOutputFile:\n\
- def close(self):\n\
- # Do nothing.\n\
- return None\n\
-\n\
- def isatty(self):\n\
- return False\n\
-\n\
- def write(self, s):\n\
- gdb.write(s, stream=gdb.STDOUT)\n \
-\n\
- def writelines(self, iterable):\n\
- for line in iterable:\n\
- self.write(line)\n\
-\n\
- def flush(self):\n\
- gdb.flush()\n\
-\n\
-sys.stdout = GdbOutputFile()\n\
-\n\
-class GdbOutputErrorFile:\n\
- def close(self):\n\
- # Do nothing.\n\
- return None\n\
-\n\
- def isatty(self):\n\
- return False\n\
-\n\
- def write(self, s):\n\
- gdb.write(s, stream=gdb.STDERR)\n \
-\n\
- def writelines(self, iterable):\n\
- for line in iterable:\n\
- self.write(line)\n \
-\n\
- def flush(self):\n\
- gdb.flush()\n\
-\n\
-sys.stderr = GdbOutputErrorFile()\n\
-\n\
-# Ideally this would live in the gdb module, but it's intentionally written\n\
-# in python, and we need this to bootstrap the gdb module.\n\
-\n\
-def GdbSetPythonDirectory (dir):\n\
- \"Set gdb.PYTHONDIR and update sys.path,etc.\"\n\
- old_dir = gdb.PYTHONDIR\n\
- gdb.PYTHONDIR = dir\n\
- # GDB's python scripts are stored inside gdb.PYTHONDIR. So insert\n\
- # that directory name at the start of sys.path to allow the Python\n\
- # interpreter to find them.\n\
- if old_dir in sys.path:\n\
- sys.path.remove (old_dir)\n\
- sys.path.insert (0, gdb.PYTHONDIR)\n\
-\n\
- # Tell python where to find submodules of gdb.\n\
- gdb.__path__ = [os.path.join (gdb.PYTHONDIR, 'gdb')]\n\
-\n\
- # The gdb module is implemented in C rather than in Python. As a result,\n\
- # the associated __init.py__ script is not not executed by default when\n\
- # the gdb module gets imported. Execute that script manually if it\n\
- # exists.\n\
- ipy = os.path.join (gdb.PYTHONDIR, 'gdb', '__init__.py')\n\
- if os.path.exists (ipy):\n\
- execfile (ipy)\n\
-\n\
-# Install the default gdb.PYTHONDIR.\n\
-GdbSetPythonDirectory (gdb.PYTHONDIR)\n\
-# Default prompt hook does nothing.\n\
-prompt_hook = None\n\
-");
+ /* Add the initial data-directory to sys.path. */
+
+ gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
+ make_cleanup (xfree, gdb_pythondir);
+
+ sys_path = PySys_GetObject ("path");
+
+ /* If sys.path is not defined yet, define it first. */
+ if (!(sys_path && PyList_Check (sys_path)))
+ {
+#ifdef IS_PY3K
+ PySys_SetPath (L"");
+#else
+ PySys_SetPath ("");
+#endif
+ sys_path = PySys_GetObject ("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);
+ Py_DECREF (pythondir);
+ if (err)
+ goto fail;
+ }
+ else
+ goto fail;
+
+ /* Import the gdb module to finish the initialization, and
+ add it to __main__ for convenience. */
+ m = PyImport_AddModule ("__main__");
+ if (m == NULL)
+ goto fail;
+
+ gdb_python_module = PyImport_ImportModule ("gdb");
+ if (gdb_python_module == NULL)
+ {
+ gdbpy_print_stack ();
+ /* 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);
+ do_cleanups (cleanup);
+ return;
+ }
+
+ 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
+ variable. */
do_cleanups (cleanup);
+ return;
+
+ fail:
+ gdbpy_print_stack ();
+ warning (_("internal error: Unhandled Python exception"));
+ 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 */
{ "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" },
"parse_and_eval (String) -> Value.\n\
Parse String as an expression, evaluate it, and return the result as a Value."
},
+ { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
+ "find_pc_line (pc) -> Symtab_and_line.\n\
+Return the gdb.Symtab_and_line object corresponding to the pc value." },
{ "post_event", gdbpy_post_event, METH_VARARGS,
"Post an event into gdb's event loop." },
{NULL, NULL, 0, NULL}
};
+#ifdef IS_PY3K
+static struct PyModuleDef GdbModuleDef =
+{
+ PyModuleDef_HEAD_INIT,
+ "_gdb",
+ NULL,
+ -1,
+ GdbMethods,
+ NULL,
+ NULL,
+ NULL,
+ NULL
+};
+#endif
#endif /* HAVE_PYTHON */
projects / deliverable / binutils-gdb.git / blobdiff