/* gdb commands implemented in Python
- Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2008-2015 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "arch-utils.h"
#include "value.h"
-#include "exceptions.h"
#include "python-internal.h"
#include "charset.h"
#include "gdbcmd.h"
/* Struct representing built-in completion types. */
struct cmdpy_completer
{
- /* Python symbol name. */
+ /* Python symbol name.
+ This isn't a const char * for Python 2.4's sake.
+ PyModule_AddIntConstant only takes a char *, sigh. */
char *name;
/* Completion function. */
- char **(*completer) (struct cmd_list_element *, char *, char *);
+ completer_ftype *completer;
};
-static struct cmdpy_completer completers[] =
+static const struct cmdpy_completer completers[] =
{
{ "COMPLETE_NONE", noop_completer },
{ "COMPLETE_FILENAME", filename_completer },
{ "COMPLETE_LOCATION", location_completer },
{ "COMPLETE_COMMAND", command_completer },
{ "COMPLETE_SYMBOL", make_symbol_completion_list_fn },
+ { "COMPLETE_EXPRESSION", expression_completer },
};
#define N_COMPLETERS (sizeof (completers) / sizeof (completers[0]))
typedef struct cmdpy_object cmdpy_object;
-static PyTypeObject cmdpy_object_type;
-
+extern PyTypeObject cmdpy_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("cmdpy_object");
/* Constants used by this module. */
static PyObject *invoke_cst;
\f
/* Called if the gdb cmd_list_element is destroyed. */
+
static void
cmdpy_destroyer (struct cmd_list_element *self, void *context)
{
/* We allocated the name, doc string, and perhaps the prefix
name. */
- xfree (self->name);
- xfree (self->doc);
- xfree (self->prefixname);
+ xfree ((char *) self->name);
+ xfree ((char *) self->doc);
+ xfree ((char *) self->prefixname);
do_cleanups (cleanup);
}
/* Called by gdb to invoke the command. */
+
static void
cmdpy_function (struct cmd_list_element *command, char *args, int from_tty)
{
args = "";
argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL);
if (! argobj)
- error (_("Could not convert arguments to Python string."));
+ {
+ gdbpy_print_stack ();
+ error (_("Could not convert arguments to Python string."));
+ }
ttyobj = from_tty ? Py_True : Py_False;
Py_INCREF (ttyobj);
ttyobj, NULL);
Py_DECREF (argobj);
Py_DECREF (ttyobj);
+
if (! result)
{
PyObject *ptype, *pvalue, *ptraceback;
- char *s, *str;
+ char *msg;
PyErr_Fetch (&ptype, &pvalue, &ptraceback);
- if (pvalue && PyString_Check (pvalue))
+ /* Try to fetch an error message contained within ptype, pvalue.
+ When fetching the error message we need to make our own copy,
+ we no longer own ptype, pvalue after the call to PyErr_Restore. */
+
+ msg = gdbpy_exception_to_string (ptype, pvalue);
+ make_cleanup (xfree, msg);
+
+ if (msg == NULL)
{
- /* Make a temporary copy of the string data. */
- char *s = PyString_AsString (pvalue);
- char *copy = alloca (strlen (s) + 1);
- strcpy (copy, s);
+ /* An error occurred computing the string representation of the
+ error message. This is rare, but we should inform the user. */
+ printf_filtered (_("An error occurred in a Python command\n"
+ "and then another occurred computing the "
+ "error message.\n"));
+ gdbpy_print_stack ();
+ }
+
+ /* Don't print the stack for gdb.GdbError exceptions.
+ It is generally used to flag user errors.
+
+ We also don't want to print "Error occurred in Python command"
+ for user errors. However, a missing message for gdb.GdbError
+ exceptions is arguably a bug, so we flag it as such. */
+ if (! PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc)
+ || msg == NULL || *msg == '\0')
+ {
PyErr_Restore (ptype, pvalue, ptraceback);
gdbpy_print_stack ();
- error (_("Error occurred in Python command: %s"), copy);
+ if (msg != NULL && *msg != '\0')
+ error (_("Error occurred in Python command: %s"), msg);
+ else
+ error (_("Error occurred in Python command."));
}
else
{
- PyErr_Restore (ptype, pvalue, ptraceback);
- gdbpy_print_stack ();
- error (_("Error occurred in Python command."));
+ Py_XDECREF (ptype);
+ Py_XDECREF (pvalue);
+ Py_XDECREF (ptraceback);
+ error ("%s", msg);
}
}
+
Py_DECREF (result);
do_cleanups (cleanup);
}
-/* Called by gdb for command completion. */
-static char **
-cmdpy_completer (struct cmd_list_element *command, char *text, char *word)
+/* Helper function for the Python command completers (both "pure"
+ completer and brkchar handler). This function takes COMMAND, TEXT
+ and WORD and tries to call the Python method for completion with
+ these arguments. It also takes HANDLE_BRKCHARS_P, an argument to
+ identify whether it is being called from the brkchar handler or
+ from the "pure" completer. In the first case, it effectively calls
+ the Python method for completion, and records the PyObject in a
+ static variable (used as a "cache"). In the second case, it just
+ returns that variable, without actually calling the Python method
+ again. This saves us one Python method call.
+
+ The reason for this two step dance is that we need to know the set
+ of "brkchars" to use early on, before we actually try to perform
+ the completion. But if a Python command supplies a "complete"
+ method then we have to call that method first: it may return as its
+ result the kind of completion to perform and that will in turn
+ specify which brkchars to use. IOW, we need the result of the
+ "complete" method before we actually perform the completion.
+
+ It is important to mention that this function is built on the
+ assumption that the calls to cmdpy_completer_handle_brkchars and
+ cmdpy_completer will be subsequent with nothing intervening. This
+ is true for our completer mechanism.
+
+ This function returns the PyObject representing the Python method
+ call. */
+
+static PyObject *
+cmdpy_completer_helper (struct cmd_list_element *command,
+ const char *text, const char *word,
+ int handle_brkchars_p)
{
cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
- PyObject *textobj, *wordobj, *resultobj = NULL;
- char **result = NULL;
+ PyObject *textobj, *wordobj;
+ /* This static variable will server as a "cache" for us, in order to
+ store the PyObject that results from calling the Python
+ function. */
+ static PyObject *resultobj = NULL;
+
+ if (handle_brkchars_p)
+ {
+ /* If we were called to handle brkchars, it means this is the
+ first function call of two that will happen in a row.
+ Therefore, we need to call the completer ourselves, and cache
+ the return value in the static variable RESULTOBJ. Then, in
+ the second call, we can just use the value of RESULTOBJ to do
+ our job. */
+ if (resultobj != NULL)
+ Py_DECREF (resultobj);
+
+ resultobj = NULL;
+ if (obj == NULL)
+ error (_("Invalid invocation of Python command object."));
+ if (!PyObject_HasAttr ((PyObject *) obj, complete_cst))
+ {
+ /* If there is no complete method, don't error. */
+ return NULL;
+ }
+
+ textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL);
+ if (textobj == NULL)
+ error (_("Could not convert argument to Python string."));
+ wordobj = PyUnicode_Decode (word, sizeof (word), host_charset (), NULL);
+ if (wordobj == NULL)
+ {
+ Py_DECREF (textobj);
+ error (_("Could not convert argument to Python string."));
+ }
+
+ resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst,
+ textobj, wordobj, NULL);
+ Py_DECREF (textobj);
+ Py_DECREF (wordobj);
+ if (!resultobj)
+ {
+ /* Just swallow errors here. */
+ PyErr_Clear ();
+ }
+
+ Py_XINCREF (resultobj);
+ }
+
+ return resultobj;
+}
+
+/* Python function called to determine the break characters of a
+ certain completer. We are only interested in knowing if the
+ completer registered by the user will return one of the integer
+ codes (see COMPLETER_* symbols). */
+
+static void
+cmdpy_completer_handle_brkchars (struct cmd_list_element *command,
+ const char *text, const char *word)
+{
+ PyObject *resultobj = NULL;
struct cleanup *cleanup;
cleanup = ensure_python_env (get_current_arch (), current_language);
- if (! obj)
- error (_("Invalid invocation of Python command object."));
- if (! PyObject_HasAttr ((PyObject *) obj, complete_cst))
- {
- /* If there is no complete method, don't error -- instead, just
- say that there are no completions. */
- goto done;
- }
+ /* Calling our helper to obtain the PyObject of the Python
+ function. */
+ resultobj = cmdpy_completer_helper (command, text, word, 1);
+
+ /* Check if there was an error. */
+ if (resultobj == NULL)
+ goto done;
- textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL);
- if (! textobj)
- error (_("Could not convert argument to Python string."));
- wordobj = PyUnicode_Decode (word, strlen (word), host_charset (), NULL);
- if (! wordobj)
- error (_("Could not convert argument to Python string."));
-
- resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst,
- textobj, wordobj, NULL);
- Py_DECREF (textobj);
- Py_DECREF (wordobj);
- if (! resultobj)
+ if (PyInt_Check (resultobj))
{
- /* Just swallow errors here. */
- PyErr_Clear ();
- goto done;
+ /* User code may also return one of the completion constants,
+ thus requesting that sort of completion. We are only
+ interested in this kind of return. */
+ long value;
+
+ if (!gdb_py_int_as_long (resultobj, &value))
+ {
+ /* Ignore. */
+ PyErr_Clear ();
+ }
+ else if (value >= 0 && value < (long) N_COMPLETERS)
+ {
+ /* This is the core of this function. Depending on which
+ completer type the Python function returns, we have to
+ adjust the break characters accordingly. */
+ set_gdb_completion_word_break_characters
+ (completers[value].completer);
+ }
}
- make_cleanup_py_decref (resultobj);
+
+ done:
+
+ /* We do not call Py_XDECREF here because RESULTOBJ will be used in
+ the subsequent call to cmdpy_completer function. */
+ do_cleanups (cleanup);
+}
+
+/* Called by gdb for command completion. */
+
+static VEC (char_ptr) *
+cmdpy_completer (struct cmd_list_element *command,
+ const char *text, const char *word)
+{
+ PyObject *resultobj = NULL;
+ VEC (char_ptr) *result = NULL;
+ struct cleanup *cleanup;
+
+ cleanup = ensure_python_env (get_current_arch (), current_language);
+
+ /* Calling our helper to obtain the PyObject of the Python
+ function. */
+ resultobj = cmdpy_completer_helper (command, text, word, 0);
+
+ /* If the result object of calling the Python function is NULL, it
+ means that there was an error. In this case, just give up and
+ return NULL. */
+ if (resultobj == NULL)
+ goto done;
result = NULL;
- if (PySequence_Check (resultobj))
+ if (PyInt_Check (resultobj))
+ {
+ /* User code may also return one of the completion constants,
+ thus requesting that sort of completion. */
+ long value;
+
+ if (! gdb_py_int_as_long (resultobj, &value))
+ {
+ /* Ignore. */
+ PyErr_Clear ();
+ }
+ else if (value >= 0 && value < (long) N_COMPLETERS)
+ result = completers[value].completer (command, text, word);
+ }
+ else
{
- Py_ssize_t i, len = PySequence_Size (resultobj);
- Py_ssize_t out;
- if (len < 0)
+ PyObject *iter = PyObject_GetIter (resultobj);
+ PyObject *elt;
+
+ if (iter == NULL)
goto done;
- result = (char **) xmalloc ((len + 1) * sizeof (char *));
- for (i = out = 0; i < len; ++i)
+ while ((elt = PyIter_Next (iter)) != NULL)
{
- int l;
- PyObject *elt = PySequence_GetItem (resultobj, i);
- if (elt == NULL || ! gdbpy_is_string (elt))
+ char *item;
+
+ if (! gdbpy_is_string (elt))
+ {
+ /* Skip problem elements. */
+ Py_DECREF (elt);
+ continue;
+ }
+ item = python_string_to_host_string (elt);
+ Py_DECREF (elt);
+ if (item == NULL)
{
/* Skip problem elements. */
PyErr_Clear ();
continue;
}
- result[out] = python_string_to_host_string (elt);
- ++out;
+ VEC_safe_push (char_ptr, result, item);
}
- result[out] = NULL;
- }
- else if (PyInt_Check (resultobj))
- {
- /* User code may also return one of the completion constants,
- thus requesting that sort of completion. */
- long value = PyInt_AsLong (resultobj);
- if (value >= 0 && value < (long) N_COMPLETERS)
- result = completers[value].completer (command, text, word);
+
+ Py_DECREF (iter);
+
+ /* If we got some results, ignore problems. Otherwise, report
+ the problem. */
+ if (result != NULL && PyErr_Occurred ())
+ PyErr_Clear ();
}
done:
/* Helper for cmdpy_init which locates the command list to use and
pulls out the command name.
-
- TEXT is the command name list. The final word in the list is the
+
+ NAME is the command name list. The final word in the list is the
name of the new command. All earlier words must be existing prefix
commands.
*BASE_LIST is set to the final prefix command's list of
*sub-commands.
-
+
+ START_LIST is the list in which the search starts.
+
This function returns the xmalloc()d name of the new command. On
error sets the Python error and returns NULL. */
-static char *
-parse_command_name (char *text, struct cmd_list_element ***base_list)
+
+char *
+gdbpy_parse_command_name (const char *name,
+ struct cmd_list_element ***base_list,
+ struct cmd_list_element **start_list)
{
struct cmd_list_element *elt;
- int len = strlen (text);
+ int len = strlen (name);
int i, lastchar;
char *prefix_text;
+ const char *prefix_text2;
char *result;
/* Skip trailing whitespace. */
- for (i = len - 1; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
+ for (i = len - 1; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
;
if (i < 0)
{
- PyErr_SetString (PyExc_RuntimeError, _("no command name found"));
+ PyErr_SetString (PyExc_RuntimeError, _("No command name found."));
return NULL;
}
lastchar = i;
/* Find first character of the final word. */
- for (; i > 0 && (isalnum (text[i - 1])
- || text[i - 1] == '-'
- || text[i - 1] == '_');
+ for (; i > 0 && (isalnum (name[i - 1])
+ || name[i - 1] == '-'
+ || name[i - 1] == '_');
--i)
;
result = xmalloc (lastchar - i + 2);
- memcpy (result, &text[i], lastchar - i + 1);
+ memcpy (result, &name[i], lastchar - i + 1);
result[lastchar - i + 1] = '\0';
/* Skip whitespace again. */
- for (--i; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
+ for (--i; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
;
if (i < 0)
{
- *base_list = &cmdlist;
+ *base_list = start_list;
return result;
}
prefix_text = xmalloc (i + 2);
- memcpy (prefix_text, text, i + 1);
+ memcpy (prefix_text, name, i + 1);
prefix_text[i + 1] = '\0';
- text = prefix_text;
- elt = lookup_cmd_1 (&text, cmdlist, NULL, 1);
- if (!elt || elt == (struct cmd_list_element *) -1)
+ prefix_text2 = prefix_text;
+ elt = lookup_cmd_1 (&prefix_text2, *start_list, NULL, 1);
+ if (elt == NULL || elt == CMD_LIST_AMBIGUOUS)
{
- PyErr_Format (PyExc_RuntimeError, _("could not find command prefix %s"),
+ PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."),
prefix_text);
xfree (prefix_text);
xfree (result);
return result;
}
- PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command"),
+ PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."),
prefix_text);
xfree (prefix_text);
xfree (result);
If PREFIX is True, then this command is a prefix command.
The documentation for the command is taken from the doc string for
- the python class.
-
-*/
+ the python class. */
+
static int
cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
{
cmdpy_object *obj = (cmdpy_object *) self;
- char *name;
+ const char *name;
int cmdtype;
int completetype = -1;
char *docstring = NULL;
/* Note: this is apparently not documented in Python. We return
0 for success, -1 for failure. */
PyErr_Format (PyExc_RuntimeError,
- _("command object already initialized"));
+ _("Command object already initialized."));
return -1;
}
- if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO", keywords, &name, &cmdtype,
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO",
+ keywords, &name, &cmdtype,
&completetype, &is_prefix))
return -1;
&& cmdtype != class_files && cmdtype != class_support
&& cmdtype != class_info && cmdtype != class_breakpoint
&& cmdtype != class_trace && cmdtype != class_obscure
- && cmdtype != class_maintenance)
+ && cmdtype != class_maintenance && cmdtype != class_user)
{
- PyErr_Format (PyExc_RuntimeError, _("invalid command class argument"));
+ PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
return -1;
}
if (completetype < -1 || completetype >= (int) N_COMPLETERS)
{
- PyErr_Format (PyExc_RuntimeError, _("invalid completion type argument"));
+ PyErr_Format (PyExc_RuntimeError,
+ _("Invalid completion type argument."));
return -1;
}
- cmd_name = parse_command_name (name, &cmd_list);
+ cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist);
if (! cmd_name)
return -1;
pfx_name = NULL;
- if (is_prefix != NULL)
+ if (is_prefix != NULL)
{
cmp = PyObject_IsTrue (is_prefix);
if (cmp == 1)
{
int i, out;
-
+
/* Make a normalized form of the command name. */
pfx_name = xmalloc (strlen (name) + 2);
-
+
i = 0;
out = 0;
while (name[i])
pfx_name[out] = '\0';
}
else if (cmp < 0)
+ {
+ xfree (cmd_name);
return -1;
+ }
}
if (PyObject_HasAttr (self, gdbpy_doc_cst))
{
PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst);
+
if (ds_obj && gdbpy_is_string (ds_obj))
- docstring = python_string_to_host_string (ds_obj);
+ {
+ docstring = python_string_to_host_string (ds_obj);
+ if (docstring == NULL)
+ {
+ xfree (cmd_name);
+ xfree (pfx_name);
+ Py_DECREF (ds_obj);
+ return -1;
+ }
+ }
+
+ Py_XDECREF (ds_obj);
}
if (! docstring)
docstring = xstrdup (_("This command is not documented."));
set_cmd_context (cmd, self);
set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
: completers[completetype].completer));
+ if (completetype == -1)
+ set_cmd_completer_handle_brkchars (cmd,
+ cmdpy_completer_handle_brkchars);
}
if (except.reason < 0)
{
\f
/* Initialize the 'commands' code. */
-void
+
+int
gdbpy_initialize_commands (void)
{
int i;
+ cmdpy_object_type.tp_new = PyType_GenericNew;
if (PyType_Ready (&cmdpy_object_type) < 0)
- return;
+ return -1;
/* Note: alias and user are special; pseudo appears to be unused,
and there is no reason to expose tui or xdb, I think. */
|| PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
class_obscure) < 0
|| PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
- class_maintenance) < 0)
- return;
+ class_maintenance) < 0
+ || PyModule_AddIntConstant (gdb_module, "COMMAND_USER", class_user) < 0)
+ return -1;
for (i = 0; i < N_COMPLETERS; ++i)
{
if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
- return;
+ return -1;
}
- Py_INCREF (&cmdpy_object_type);
- PyModule_AddObject (gdb_module, "Command",
- (PyObject *) &cmdpy_object_type);
+ if (gdb_pymodule_addobject (gdb_module, "Command",
+ (PyObject *) &cmdpy_object_type) < 0)
+ return -1;
invoke_cst = PyString_FromString ("invoke");
+ if (invoke_cst == NULL)
+ return -1;
complete_cst = PyString_FromString ("complete");
+ if (complete_cst == NULL)
+ return -1;
+
+ return 0;
}
\f
{ 0 }
};
-static PyTypeObject cmdpy_object_type =
+PyTypeObject cmdpy_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Command", /*tp_name*/
sizeof (cmdpy_object), /*tp_basicsize*/
0, /*tp_itemsize*/
0, /* tp_dictoffset */
cmdpy_init, /* tp_init */
0, /* tp_alloc */
- PyType_GenericNew /* tp_new */
};
+
+\f
+
+/* Utility to build a buildargv-like result from ARGS.
+ This intentionally parses arguments the way libiberty/argv.c:buildargv
+ does. It splits up arguments in a reasonable way, and we want a standard
+ way of parsing arguments. Several gdb commands use buildargv to parse their
+ arguments. Plus we want to be able to write compatible python
+ implementations of gdb commands. */
+
+PyObject *
+gdbpy_string_to_argv (PyObject *self, PyObject *args)
+{
+ PyObject *py_argv;
+ const char *input;
+
+ if (!PyArg_ParseTuple (args, "s", &input))
+ return NULL;
+
+ py_argv = PyList_New (0);
+ if (py_argv == NULL)
+ return NULL;
+
+ /* buildargv uses NULL to represent an empty argument list, but we can't use
+ that in Python. Instead, if ARGS is "" then return an empty list.
+ This undoes the NULL -> "" conversion that cmdpy_function does. */
+
+ if (*input != '\0')
+ {
+ char **c_argv = gdb_buildargv (input);
+ int i;
+
+ for (i = 0; c_argv[i] != NULL; ++i)
+ {
+ PyObject *argp = PyString_FromString (c_argv[i]);
+
+ if (argp == NULL
+ || PyList_Append (py_argv, argp) < 0)
+ {
+ Py_XDECREF (argp);
+ Py_DECREF (py_argv);
+ freeargv (c_argv);
+ return NULL;
+ }
+ Py_DECREF (argp);
+ }
+
+ freeargv (c_argv);
+ }
+
+ return py_argv;
+}