/* General python/gdb code
- Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
#include "exceptions.h"
#include "event-loop.h"
#include "serial.h"
+#include "readline/tilde.h"
+#include "python.h"
#include <ctype.h>
-/* True if we should print the stack when catching a Python error,
- false otherwise. */
-static int gdbpy_should_print_stack = 1;
+/* 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 *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
-#include "python.h"
#include "libiberty.h"
#include "cli/cli-decode.h"
#include "charset.h"
#include "version.h"
#include "target.h"
#include "gdbthread.h"
+#include "observer.h"
+#include "interps.h"
static PyMethodDef GdbMethods[];
PyObject *gdbpy_display_hint_cst;
PyObject *gdbpy_doc_cst;
PyObject *gdbpy_enabled_cst;
+PyObject *gdbpy_value_cst;
/* The GdbError exception. */
PyObject *gdbpy_gdberror_exc;
+/* The `gdb.error' base class. */
+PyObject *gdbpy_gdb_error;
+
+/* 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;
PyGILState_STATE state;
struct gdbarch *gdbarch;
const struct language_defn *language;
+ PyObject *error_type, *error_value, *error_traceback;
};
static void
{
struct python_env *env = (struct python_env *)p;
+ /* 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 (env->error_type, env->error_value, env->error_traceback);
+
PyGILState_Release (env->state);
python_gdbarch = env->gdbarch;
python_language = env->language;
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);
}
+/* 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
+ 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. */
+
+static void
+python_run_simple_file (const char *filename)
+{
+ 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)
+ {
+ do_cleanups (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);
+}
/* Given a command_line, return a command string suitable for passing
to Python. Lines in the string are separated by newlines. The
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);
}
struct cleanup *cleanup;
cleanup = ensure_python_env (get_current_arch (), current_language);
+
+ make_cleanup_restore_integer (&interpreter_async);
+ interpreter_async = 0;
+
while (arg && *arg && isspace (*arg))
++arg;
if (arg && *arg)
{
if (PyRun_SimpleString (arg))
- {
- gdbpy_print_stack ();
- error (_("Error while executing Python code."));
- }
+ error (_("Error while executing Python code."));
}
else
{
gdbpy_parameter (PyObject *self, PyObject *args)
{
struct cmd_list_element *alias, *prefix, *cmd;
- char *arg, *newarg;
+ const char *arg;
+ char *newarg;
int found = -1;
volatile struct gdb_exception except;
static PyObject *
execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
{
- char *arg;
+ const char *arg;
PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
int from_tty, to_string;
volatile struct gdb_exception except;
char *copy = xstrdup (arg);
struct cleanup *cleanup = make_cleanup (xfree, copy);
+ make_cleanup_restore_integer (&interpreter_async);
+ interpreter_async = 0;
+
+ prevent_dont_repeat ();
if (to_string)
result = execute_command_to_string (copy, from_tty);
else
{
char *soname;
PyObject *str_obj;
-#ifdef PY_LONG_LONG
- unsigned PY_LONG_LONG pc;
- /* To be compatible with Python 2.4 the format strings are not const. */
- char *format = "K";
-#else
- unsigned long pc;
- char *format = "k";
-#endif
+ gdb_py_longest pc;
- if (!PyArg_ParseTuple (args, format, &pc))
+ if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
return NULL;
soname = solib_name_from_address (current_program_space, pc);
static PyObject *
gdbpy_decode_line (PyObject *self, PyObject *args)
{
- struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to appease gcc. */
+ struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
+ appease gcc. */
struct symtab_and_line sal;
- char *arg = NULL;
+ const char *arg = NULL;
char *copy = NULL;
struct cleanup *cleanups;
PyObject *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);
TRY_CATCH (except, RETURN_MASK_ALL)
{
if (arg)
{
- arg = xstrdup (arg);
- make_cleanup (xfree, arg);
- copy = arg;
- sals = decode_line_1 (©, 0, 0, 0, 0, 0);
+ copy = xstrdup (arg);
+ make_cleanup (xfree, copy);
+ sals = decode_line_1 (©, 0, 0, 0);
make_cleanup (xfree, sals.sals);
}
else
static PyObject *
gdbpy_parse_and_eval (PyObject *self, PyObject *args)
{
- char *expr_str;
+ const char *expr_str;
struct value *result = NULL;
volatile struct gdb_exception except;
TRY_CATCH (except, RETURN_MASK_ALL)
{
- result = parse_and_eval (expr_str);
+ char *copy = xstrdup (expr_str);
+ struct cleanup *cleanup = make_cleanup (xfree, copy);
+
+ result = parse_and_eval (copy);
+ do_cleanups (cleanup);
}
GDB_PY_HANDLE_EXCEPTION (except);
return value_to_value_object (result);
}
-/* Read a file as Python code. STREAM is the input file; FILE is the
- name of the file.
- STREAM is not closed, that is the caller's responsibility. */
+/* Read a file as Python code.
+ FILE is the name of the 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 *stream, const char *file)
+source_python_script (const char *file)
{
struct cleanup *cleanup;
cleanup = ensure_python_env (get_current_arch (), current_language);
-
- /* Note: If an exception occurs python will print the traceback and
- clear the error indicator. */
- PyRun_SimpleFile (stream, file);
-
+ python_run_simple_file (file);
do_cleanups (cleanup);
}
}
}
+\f
+
+static void
+before_prompt_hook (const char *current_gdb_prompt)
+{
+ struct cleanup *cleanup;
+ char *prompt = NULL;
+
+ cleanup = ensure_python_env (get_current_arch (), current_language);
+
+ if (PyObject_HasAttrString (gdb_module, "prompt_hook"))
+ {
+ PyObject *hook;
+
+ hook = PyObject_GetAttrString (gdb_module, "prompt_hook");
+ if (hook == NULL)
+ goto fail;
+
+ if (PyCallable_Check (hook))
+ {
+ PyObject *result;
+ PyObject *current_prompt;
+
+ current_prompt = PyString_FromString (current_gdb_prompt);
+ if (current_prompt == NULL)
+ goto fail;
+
+ result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
+
+ Py_DECREF (current_prompt);
+
+ if (result == NULL)
+ goto fail;
+
+ make_cleanup_py_decref (result);
+
+ /* 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))
+ {
+ PyErr_Format (PyExc_RuntimeError,
+ _("Return from prompt_hook must " \
+ "be either a Python string, or None"));
+ goto fail;
+ }
+
+ if (result != Py_None)
+ {
+ prompt = python_string_to_host_string (result);
+
+ if (prompt == NULL)
+ goto fail;
+ else
+ make_cleanup (xfree, prompt);
+ }
+ }
+ }
+
+ /* 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;
+}
+
+\f
+
/* Printing. */
/* A python function to write a single string using gdb's filtered
- output stream. */
+ output stream . The optional keyword STREAM can be used to write
+ to a particular stream. The default stream is to gdb_stdout. */
+
static PyObject *
-gdbpy_write (PyObject *self, PyObject *args)
+gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
{
- char *arg;
-
- if (! PyArg_ParseTuple (args, "s", &arg))
+ const char *arg;
+ static char *keywords[] = {"text", "stream", NULL };
+ int stream_type = 0;
+
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
+ &stream_type))
return NULL;
- printf_filtered ("%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);
+ }
+
Py_RETURN_NONE;
}
-/* A python function to flush gdb's filtered output stream. */
+/* A python function to flush a gdb stream. The optional keyword
+ STREAM can be used to flush a particular stream. The default stream
+ is gdb_stdout. */
+
static PyObject *
-gdbpy_flush (PyObject *self, PyObject *args)
+gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
{
- gdb_flush (gdb_stdout);
+ static char *keywords[] = {"stream", NULL };
+ int stream_type = 0;
+
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
+ &stream_type))
+ return NULL;
+
+ switch (stream_type)
+ {
+ case 1:
+ {
+ gdb_flush (gdb_stderr);
+ break;
+ }
+ case 2:
+ {
+ gdb_flush (gdb_stdlog);
+ break;
+ }
+ 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)
+ /* 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.
printf_filtered. */
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);
+ 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
source_python_script_for_objfile; it is NULL at other times. */
static struct objfile *gdbpy_current_objfile;
-/* Set the current objfile to OBJFILE and then read STREAM,FILE as
- Python code. */
+/* 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. */
void
-source_python_script_for_objfile (struct objfile *objfile,
- FILE *stream, const char *file)
+source_python_script_for_objfile (struct objfile *objfile, const char *file)
{
struct cleanup *cleanups;
cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
gdbpy_current_objfile = objfile;
- /* Note: If an exception occurs python will print the traceback and
- clear the error indicator. */
- PyRun_SimpleFile (stream, file);
+ python_run_simple_file (file);
do_cleanups (cleanups);
gdbpy_current_objfile = NULL;
}
void
-source_python_script (FILE *stream, const char *file)
+source_python_script (const char *file)
{
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."));
+}
+
#endif /* HAVE_PYTHON */
\f
-/* Lists for 'maint set python' commands. */
+/* Lists for 'set python' commands. */
-struct cmd_list_element *set_python_list;
-struct cmd_list_element *show_python_list;
+static struct cmd_list_element *user_set_python_list;
+static struct cmd_list_element *user_show_python_list;
-/* Function for use by 'maint set python' prefix command. */
+/* Function for use by 'set python' prefix command. */
static void
-set_python (char *args, int from_tty)
+user_set_python (char *args, int from_tty)
{
- help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);
+ help_list (user_set_python_list, "set python ", all_commands,
+ gdb_stdout);
}
-/* Function for use by 'maint show python' prefix command. */
+/* Function for use by 'show python' prefix command. */
static void
-show_python (char *args, int from_tty)
+user_show_python (char *args, int from_tty)
{
- cmd_show_list (show_python_list, from_tty, "");
+ cmd_show_list (user_show_python_list, from_tty, "");
}
/* Initialize the Python code. */
void
_initialize_python (void)
{
+ char *cmd_name;
+ struct cmd_list_element *cmd;
+
add_com ("python", class_obscure, python_command,
#ifdef HAVE_PYTHON
_("\
#endif /* HAVE_PYTHON */
);
- add_prefix_cmd ("python", no_class, show_python,
- _("Prefix command for python maintenance settings."),
- &show_python_list, "maintenance show python ", 0,
- &maintenance_show_cmdlist);
- add_prefix_cmd ("python", no_class, set_python,
- _("Prefix command for python maintenance settings."),
- &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,
- &set_python_list,
- &show_python_list);
+ /* Add set/show python print-stack. */
+ add_prefix_cmd ("python", no_class, user_show_python,
+ _("Prefix command for python preference settings."),
+ &user_show_python_list, "show python ", 0,
+ &showlist);
+
+ add_prefix_cmd ("python", no_class, user_set_python,
+ _("Prefix command for python preference settings."),
+ &user_set_python_list, "set python ", 0,
+ &setlist);
+
+ 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
/* 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);
+ 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);
+
+ /* 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;
xfree (gdb_pythondir);
}
+ 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_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 () ;
+
+ observer_attach_before_prompt (before_prompt_hook);
+
PyRun_SimpleString ("import gdb");
PyRun_SimpleString ("gdb.pretty_printers = []");
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 ();
+
+#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. */
+
+void
+finish_python_initialization (void)
+{
+ struct cleanup *cleanup;
+
+ cleanup = ensure_python_env (get_current_arch (), current_language);
- /* Create a couple objects which are used for Python's stdout and
- stderr. */
PyRun_SimpleString ("\
+import os\n\
import sys\n\
+\n\
class GdbOutputFile:\n\
def close(self):\n\
# Do nothing.\n\
return False\n\
\n\
def write(self, s):\n\
- gdb.write(s)\n\
+ gdb.write(s, stream=gdb.STDOUT)\n \
\n\
def writelines(self, iterable):\n\
for line in iterable:\n\
def flush(self):\n\
gdb.flush()\n\
\n\
-sys.stderr = GdbOutputFile()\n\
sys.stdout = GdbOutputFile()\n\
\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\
-sys.path.insert(0, gdb.PYTHONDIR)\n\
+class GdbOutputErrorFile:\n\
+ def close(self):\n\
+ # Do nothing.\n\
+ return None\n\
+\n\
+ def isatty(self):\n\
+ return False\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 exists.\n\
-gdb.__path__ = [gdb.PYTHONDIR + '/gdb']\n\
-from os.path import exists\n\
-ipy = gdb.PYTHONDIR + '/gdb/__init__.py'\n\
-if exists (ipy):\n\
- execfile (ipy)\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\
");
- /* Release the GIL while gdb runs. */
- PyThreadState_Swap (NULL);
- PyEval_ReleaseLock ();
+ do_cleanups (cleanup);
+}
#endif /* HAVE_PYTHON */
-}
\f
-#if HAVE_PYTHON
+#ifdef HAVE_PYTHON
static PyMethodDef GdbMethods[] =
{
{ "objfiles", gdbpy_objfiles, METH_NOARGS,
"Return a sequence of all loaded objfiles." },
+ { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
+ "newest_frame () -> gdb.Frame.\n\
+Return the newest frame object." },
{ "selected_frame", gdbpy_selected_frame, METH_NOARGS,
"selected_frame () -> gdb.Frame.\n\
Return the selected frame object." },
Return a tuple with the symbol corresponding to the given name (or None) and\n\
a boolean indicating if name is a field of the current implied argument\n\
`this' (when the current language is object-oriented)." },
+ { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
+ METH_VARARGS | METH_KEYWORDS,
+ "lookup_global_symbol (name [, domain]) -> symbol\n\
+Return the symbol corresponding to the given name (or None)." },
{ "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,
Parse String and return an argv-like array.\n\
Arguments are separate by spaces and may be quoted."
},
-
- { "write", gdbpy_write, METH_VARARGS,
+ { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
"Write a string using gdb's filtered stream." },
- { "flush", gdbpy_flush, METH_NOARGS,
+ { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
"Flush gdb's filtered stdout stream." },
{ "selected_thread", gdbpy_selected_thread, METH_NOARGS,
"selected_thread () -> gdb.InferiorThread.\n\
Return the selected thread object." },
+ { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
+ "selected_inferior () -> gdb.Inferior.\n\
+Return the selected inferior object." },
{ "inferiors", gdbpy_inferiors, METH_NOARGS,
"inferiors () -> (gdb.Inferior, ...).\n\
Return a tuple containing all inferiors." },