2008-08-06 21:41:33 +02:00
|
|
|
|
/* General python/gdb code
|
|
|
|
|
|
2009-01-03 06:58:08 +01:00
|
|
|
|
Copyright (C) 2008, 2009 Free Software Foundation, Inc.
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "command.h"
|
|
|
|
|
#include "ui-out.h"
|
|
|
|
|
#include "cli/cli-script.h"
|
|
|
|
|
#include "gdbcmd.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;
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_PYTHON
|
|
|
|
|
|
|
|
|
|
#include "python.h"
|
|
|
|
|
#include "libiberty.h"
|
|
|
|
|
#include "cli/cli-decode.h"
|
|
|
|
|
#include "charset.h"
|
|
|
|
|
#include "top.h"
|
|
|
|
|
#include "exceptions.h"
|
|
|
|
|
#include "python-internal.h"
|
|
|
|
|
#include "version.h"
|
|
|
|
|
#include "target.h"
|
|
|
|
|
#include "gdbthread.h"
|
|
|
|
|
|
2009-02-05 17:40:34 +01:00
|
|
|
|
static PyMethodDef GdbMethods[];
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
PyObject *gdb_module;
|
|
|
|
|
|
2009-02-06 22:33:59 +01:00
|
|
|
|
PyObject *gdbpy_doc_cst;
|
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
/* Given a command_line, return a command string suitable for passing
|
|
|
|
|
to Python. Lines in the string are separated by newlines. The
|
|
|
|
|
return value is allocated using xmalloc and the caller is
|
|
|
|
|
responsible for freeing it. */
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
compute_python_string (struct command_line *l)
|
|
|
|
|
{
|
|
|
|
|
struct command_line *iter;
|
|
|
|
|
char *script = NULL;
|
|
|
|
|
int size = 0;
|
|
|
|
|
int here;
|
|
|
|
|
|
|
|
|
|
for (iter = l; iter; iter = iter->next)
|
|
|
|
|
size += strlen (iter->line) + 1;
|
|
|
|
|
|
|
|
|
|
script = xmalloc (size + 1);
|
|
|
|
|
here = 0;
|
|
|
|
|
for (iter = l; iter; iter = iter->next)
|
|
|
|
|
{
|
|
|
|
|
int len = strlen (iter->line);
|
|
|
|
|
strcpy (&script[here], iter->line);
|
|
|
|
|
here += len;
|
|
|
|
|
script[here++] = '\n';
|
|
|
|
|
}
|
|
|
|
|
script[here] = '\0';
|
|
|
|
|
return script;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
{
|
2009-02-05 17:40:34 +01:00
|
|
|
|
int ret;
|
2008-08-06 21:41:33 +02:00
|
|
|
|
char *script;
|
2008-11-21 15:59:56 +01:00
|
|
|
|
struct cleanup *cleanup;
|
|
|
|
|
PyGILState_STATE state;
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
if (cmd->body_count != 1)
|
|
|
|
|
error (_("Invalid \"python\" block structure."));
|
|
|
|
|
|
2008-11-21 15:59:56 +01:00
|
|
|
|
state = PyGILState_Ensure ();
|
|
|
|
|
cleanup = make_cleanup_py_restore_gil (&state);
|
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
script = compute_python_string (cmd->body_list[0]);
|
2009-02-05 17:40:34 +01:00
|
|
|
|
ret = PyRun_SimpleString (script);
|
2008-08-06 21:41:33 +02:00
|
|
|
|
xfree (script);
|
2009-02-05 17:40:34 +01:00
|
|
|
|
if (ret)
|
2008-08-06 21:41:33 +02:00
|
|
|
|
{
|
|
|
|
|
gdbpy_print_stack ();
|
2009-02-05 17:40:34 +01:00
|
|
|
|
error (_("Error while executing Python code."));
|
2008-08-06 21:41:33 +02:00
|
|
|
|
}
|
2008-11-21 15:59:56 +01:00
|
|
|
|
|
|
|
|
|
do_cleanups (cleanup);
|
2008-08-06 21:41:33 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implementation of the gdb "python" command. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
python_command (char *arg, int from_tty)
|
|
|
|
|
{
|
2008-11-21 15:59:56 +01:00
|
|
|
|
struct cleanup *cleanup;
|
|
|
|
|
PyGILState_STATE state;
|
|
|
|
|
|
|
|
|
|
state = PyGILState_Ensure ();
|
|
|
|
|
cleanup = make_cleanup_py_restore_gil (&state);
|
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
while (arg && *arg && isspace (*arg))
|
|
|
|
|
++arg;
|
|
|
|
|
if (arg && *arg)
|
|
|
|
|
{
|
2009-02-05 17:40:34 +01:00
|
|
|
|
if (PyRun_SimpleString (arg))
|
2008-08-06 21:41:33 +02:00
|
|
|
|
{
|
|
|
|
|
gdbpy_print_stack ();
|
2009-02-05 17:40:34 +01:00
|
|
|
|
error (_("Error while executing Python code."));
|
2008-08-06 21:41:33 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
struct command_line *l = get_command_line (python_control, "");
|
2008-11-21 15:59:56 +01:00
|
|
|
|
make_cleanup_free_command_lines (&l);
|
2008-08-06 21:41:33 +02:00
|
|
|
|
execute_control_command_untraced (l);
|
|
|
|
|
}
|
2008-11-21 15:59:56 +01:00
|
|
|
|
|
|
|
|
|
do_cleanups (cleanup);
|
2008-08-06 21:41:33 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Transform a gdb parameters's value into a Python value. May return
|
|
|
|
|
NULL (and set a Python exception) on error. Helper function for
|
|
|
|
|
get_parameter. */
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
parameter_to_python (struct cmd_list_element *cmd)
|
|
|
|
|
{
|
|
|
|
|
switch (cmd->var_type)
|
|
|
|
|
{
|
|
|
|
|
case var_string:
|
|
|
|
|
case var_string_noescape:
|
|
|
|
|
case var_optional_filename:
|
|
|
|
|
case var_filename:
|
|
|
|
|
case var_enum:
|
|
|
|
|
{
|
|
|
|
|
char *str = * (char **) cmd->var;
|
|
|
|
|
if (! str)
|
|
|
|
|
str = "";
|
|
|
|
|
return PyString_Decode (str, strlen (str), host_charset (), NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case var_boolean:
|
|
|
|
|
{
|
|
|
|
|
if (* (int *) cmd->var)
|
|
|
|
|
Py_RETURN_TRUE;
|
|
|
|
|
else
|
|
|
|
|
Py_RETURN_FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case var_auto_boolean:
|
|
|
|
|
{
|
|
|
|
|
enum auto_boolean ab = * (enum auto_boolean *) cmd->var;
|
|
|
|
|
if (ab == AUTO_BOOLEAN_TRUE)
|
|
|
|
|
Py_RETURN_TRUE;
|
|
|
|
|
else if (ab == AUTO_BOOLEAN_FALSE)
|
|
|
|
|
Py_RETURN_FALSE;
|
|
|
|
|
else
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case var_integer:
|
|
|
|
|
if ((* (int *) cmd->var) == INT_MAX)
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
case var_zinteger:
|
|
|
|
|
return PyLong_FromLong (* (int *) cmd->var);
|
|
|
|
|
|
|
|
|
|
case var_uinteger:
|
|
|
|
|
{
|
|
|
|
|
unsigned int val = * (unsigned int *) cmd->var;
|
|
|
|
|
if (val == UINT_MAX)
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
|
return PyLong_FromUnsignedLong (val);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A Python function which returns a gdb parameter's value as a Python
|
|
|
|
|
value. */
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
get_parameter (PyObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
struct cmd_list_element *alias, *prefix, *cmd;
|
|
|
|
|
char *arg, *newarg;
|
|
|
|
|
volatile struct gdb_exception except;
|
|
|
|
|
|
|
|
|
|
if (! PyArg_ParseTuple (args, "s", &arg))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
newarg = concat ("show ", arg, (char *) NULL);
|
|
|
|
|
|
|
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
|
|
|
|
{
|
|
|
|
|
if (! lookup_cmd_composition (newarg, &alias, &prefix, &cmd))
|
|
|
|
|
{
|
|
|
|
|
xfree (newarg);
|
|
|
|
|
return PyErr_Format (PyExc_RuntimeError,
|
|
|
|
|
"could not find variable `%s'", arg);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
xfree (newarg);
|
|
|
|
|
GDB_PY_HANDLE_EXCEPTION (except);
|
|
|
|
|
|
|
|
|
|
if (! cmd->var)
|
|
|
|
|
return PyErr_Format (PyExc_RuntimeError, "`%s' is not a variable", arg);
|
|
|
|
|
return parameter_to_python (cmd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A Python function which evaluates a string using the gdb CLI. */
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
|
execute_gdb_command (PyObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
struct cmd_list_element *alias, *prefix, *cmd;
|
|
|
|
|
char *arg, *newarg;
|
2009-02-05 17:40:34 +01:00
|
|
|
|
PyObject *from_tty_obj = NULL;
|
|
|
|
|
int from_tty;
|
|
|
|
|
int cmp;
|
2008-08-06 21:41:33 +02:00
|
|
|
|
volatile struct gdb_exception except;
|
|
|
|
|
|
2009-02-05 17:40:34 +01:00
|
|
|
|
if (! PyArg_ParseTuple (args, "s|O!", &arg, &PyBool_Type, &from_tty_obj))
|
2008-08-06 21:41:33 +02:00
|
|
|
|
return NULL;
|
|
|
|
|
|
2009-02-05 17:40:34 +01:00
|
|
|
|
from_tty = 0;
|
|
|
|
|
if (from_tty_obj)
|
|
|
|
|
{
|
|
|
|
|
cmp = PyObject_IsTrue (from_tty_obj);
|
|
|
|
|
if (cmp < 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
from_tty = cmp;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
|
|
|
|
{
|
2009-02-05 17:40:34 +01:00
|
|
|
|
execute_command (arg, from_tty);
|
2008-08-06 21:41:33 +02:00
|
|
|
|
}
|
|
|
|
|
GDB_PY_HANDLE_EXCEPTION (except);
|
|
|
|
|
|
2008-09-08 23:46:21 +02:00
|
|
|
|
/* Do any commands attached to breakpoint we stopped at. */
|
|
|
|
|
bpstat_do_actions ();
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Printing. */
|
|
|
|
|
|
|
|
|
|
/* A python function to write a single string using gdb's filtered
|
|
|
|
|
output stream. */
|
|
|
|
|
static PyObject *
|
|
|
|
|
gdbpy_write (PyObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
char *arg;
|
|
|
|
|
if (! PyArg_ParseTuple (args, "s", &arg))
|
|
|
|
|
return NULL;
|
|
|
|
|
printf_filtered ("%s", arg);
|
|
|
|
|
Py_RETURN_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A python function to flush gdb's filtered output stream. */
|
|
|
|
|
static PyObject *
|
|
|
|
|
gdbpy_flush (PyObject *self, PyObject *args)
|
|
|
|
|
{
|
|
|
|
|
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. */
|
|
|
|
|
void
|
|
|
|
|
gdbpy_print_stack (void)
|
|
|
|
|
{
|
|
|
|
|
if (gdbpy_should_print_stack)
|
|
|
|
|
PyErr_Print ();
|
|
|
|
|
else
|
|
|
|
|
PyErr_Clear ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else /* HAVE_PYTHON */
|
|
|
|
|
|
|
|
|
|
/* Dummy implementation of the gdb "python" command. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
python_command (char *arg, int from_tty)
|
|
|
|
|
{
|
|
|
|
|
while (arg && *arg && isspace (*arg))
|
|
|
|
|
++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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
eval_python_from_control_command (struct command_line *cmd)
|
|
|
|
|
{
|
|
|
|
|
error (_("Python scripting is not supported in this copy of GDB."));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* HAVE_PYTHON */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Lists for 'maint set python' commands. */
|
|
|
|
|
|
|
|
|
|
static struct cmd_list_element *set_python_list;
|
|
|
|
|
static struct cmd_list_element *show_python_list;
|
|
|
|
|
|
|
|
|
|
/* Function for use by 'maint set python' prefix command. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
set_python (char *args, int from_tty)
|
|
|
|
|
{
|
|
|
|
|
help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Function for use by 'maint show python' prefix command. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
show_python (char *args, int from_tty)
|
|
|
|
|
{
|
|
|
|
|
cmd_show_list (show_python_list, from_tty, "");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Initialize the Python code. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_initialize_python (void)
|
|
|
|
|
{
|
|
|
|
|
add_com ("python", class_obscure, python_command,
|
|
|
|
|
#ifdef HAVE_PYTHON
|
|
|
|
|
_("\
|
|
|
|
|
Evaluate a Python command.\n\
|
|
|
|
|
\n\
|
|
|
|
|
The command can be given as an argument, for instance:\n\
|
|
|
|
|
\n\
|
|
|
|
|
python print 23\n\
|
|
|
|
|
\n\
|
|
|
|
|
If no argument is given, the following lines are read and used\n\
|
|
|
|
|
as the Python commands. Type a line containing \"end\" to indicate\n\
|
|
|
|
|
the end of the command.")
|
|
|
|
|
#else /* HAVE_PYTHON */
|
|
|
|
|
_("\
|
|
|
|
|
Evaluate a Python command.\n\
|
|
|
|
|
\n\
|
|
|
|
|
Python scripting is not supported in this copy of GDB.\n\
|
|
|
|
|
This command is only a placeholder.")
|
|
|
|
|
#endif /* HAVE_PYTHON */
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
add_prefix_cmd ("python", no_class, show_python,
|
|
|
|
|
_("Prefix command for python maintenance settings."),
|
2008-08-09 21:17:03 +02:00
|
|
|
|
&show_python_list, "maintenance show python ", 0,
|
2008-08-06 21:41:33 +02:00
|
|
|
|
&maintenance_show_cmdlist);
|
|
|
|
|
add_prefix_cmd ("python", no_class, set_python,
|
|
|
|
|
_("Prefix command for python maintenance settings."),
|
2008-08-09 21:17:03 +02:00
|
|
|
|
&set_python_list, "maintenance set python ", 0,
|
2008-08-06 21:41:33 +02:00
|
|
|
|
&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);
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_PYTHON
|
|
|
|
|
Py_Initialize ();
|
2008-11-21 15:59:56 +01:00
|
|
|
|
PyEval_InitThreads ();
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
gdb_module = Py_InitModule ("gdb", GdbMethods);
|
|
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
|
2008-10-16 05:54:00 +02:00
|
|
|
|
gdbpy_initialize_values ();
|
2009-02-06 22:33:59 +01:00
|
|
|
|
gdbpy_initialize_commands ();
|
2008-10-16 05:54:00 +02:00
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
PyRun_SimpleString ("import gdb");
|
|
|
|
|
|
2009-02-06 22:33:59 +01:00
|
|
|
|
gdbpy_doc_cst = PyString_FromString ("__doc__");
|
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
/* Create a couple objects which are used for Python's stdout and
|
|
|
|
|
stderr. */
|
|
|
|
|
PyRun_SimpleString ("\
|
|
|
|
|
import sys\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)\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 = GdbOutputFile()\n\
|
|
|
|
|
sys.stdout = GdbOutputFile()\n\
|
|
|
|
|
");
|
2008-11-21 15:59:56 +01:00
|
|
|
|
|
|
|
|
|
/* Release the GIL while gdb runs. */
|
|
|
|
|
PyThreadState_Swap (NULL);
|
|
|
|
|
PyEval_ReleaseLock ();
|
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
#endif /* HAVE_PYTHON */
|
|
|
|
|
}
|
2009-02-05 17:40:34 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if HAVE_PYTHON
|
|
|
|
|
|
|
|
|
|
static PyMethodDef GdbMethods[] =
|
|
|
|
|
{
|
|
|
|
|
{ "history", gdbpy_history, METH_VARARGS,
|
|
|
|
|
"Get a value from history" },
|
|
|
|
|
{ "execute", execute_gdb_command, METH_VARARGS,
|
|
|
|
|
"Execute a gdb command" },
|
|
|
|
|
{ "get_parameter", get_parameter, METH_VARARGS,
|
|
|
|
|
"Return a gdb parameter's value" },
|
|
|
|
|
|
|
|
|
|
{ "write", gdbpy_write, METH_VARARGS,
|
|
|
|
|
"Write a string using gdb's filtered stream." },
|
|
|
|
|
{ "flush", gdbpy_flush, METH_NOARGS,
|
|
|
|
|
"Flush gdb's filtered stdout stream." },
|
|
|
|
|
|
|
|
|
|
{NULL, NULL, 0, NULL}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#endif /* HAVE_PYTHON */
|