[deliverable/binutils-gdb.git] / gdb / python / py-cmd.c

/* gdb commands implemented in Python

   Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

   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 "arch-utils.h"
#include "value.h"
#include "exceptions.h"
#include "python-internal.h"
#include "charset.h"
#include "gdbcmd.h"
#include "cli/cli-decode.h"
#include "completer.h"
#include "language.h"

/* Struct representing built-in completion types.  */
struct cmdpy_completer
{
  /* Python symbol name.  */
  char *name;
  /* Completion function.  */
  char **(*completer) (struct cmd_list_element *, char *, char *);
};

static 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 },
};

#define N_COMPLETERS (sizeof (completers) / sizeof (completers[0]))

/* A gdb command.  For the time being only ordinary commands (not
   set/show commands) are allowed.  */
struct cmdpy_object
{
  PyObject_HEAD

  /* The corresponding gdb command object, or NULL if the command is
     no longer installed.  */
  struct cmd_list_element *command;

  /* A prefix command requires storage for a list of its sub-commands.
     A pointer to this is passed to add_prefix_command, and to add_cmd
     for sub-commands of that prefix.  If this Command is not a prefix
     command, then this field is unused.  */
  struct cmd_list_element *sub_list;
};

typedef struct cmdpy_object cmdpy_object;

static PyTypeObject cmdpy_object_type;


/* Constants used by this module.  */
static PyObject *invoke_cst;
static PyObject *complete_cst;

\f

/* Python function which wraps dont_repeat.  */
static PyObject *
cmdpy_dont_repeat (PyObject *self, PyObject *args)
{
  dont_repeat ();
  Py_RETURN_NONE;
}

\f

/* Called if the gdb cmd_list_element is destroyed.  */

static void
cmdpy_destroyer (struct cmd_list_element *self, void *context)
{
  cmdpy_object *cmd;
  struct cleanup *cleanup;

  cleanup = ensure_python_env (get_current_arch (), current_language);

  /* Release our hold on the command object.  */
  cmd = (cmdpy_object *) context;
  cmd->command = NULL;
  Py_DECREF (cmd);

  /* We allocated the name, doc string, and perhaps the prefix
     name.  */
  xfree (self->name);
  xfree (self->doc);
  xfree (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)
{
  cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
  PyObject *argobj, *ttyobj, *result;
  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, invoke_cst))
    {
      if (obj->command->prefixname)
	{
	  /* A prefix command does not need an invoke method.  */
	  do_cleanups (cleanup);
	  return;
	}
      error (_("Python command object missing 'invoke' method."));
    }

  if (! args)
    args = "";
  argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL);
  if (! argobj)
    {
      gdbpy_print_stack ();
      error (_("Could not convert arguments to Python string."));
    }

  ttyobj = from_tty ? Py_True : Py_False;
  Py_INCREF (ttyobj);
  result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj,
				       ttyobj, NULL);
  Py_DECREF (argobj);
  Py_DECREF (ttyobj);

  if (! result)
    {
      PyObject *ptype, *pvalue, *ptraceback;
      char *msg;

      PyErr_Fetch (&ptype, &pvalue, &ptraceback);

      /* 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)
	{
	  /* 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 ();
	  if (msg != NULL && *msg != '\0')
	    error (_("Error occurred in Python command: %s"), msg);
	  else
	    error (_("Error occurred in Python command."));
	}
      else
	{
	  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)
{
  cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
  PyObject *textobj, *wordobj, *resultobj = NULL;
  char **result = 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;
    }

  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)
    {
      /* Just swallow errors here.  */
      PyErr_Clear ();
      goto done;
    }
  make_cleanup_py_decref (resultobj);

  result = NULL;
  if (PySequence_Check (resultobj))
    {
      Py_ssize_t i, len = PySequence_Size (resultobj);
      Py_ssize_t out;

      if (len < 0)
	goto done;

      result = (char **) xmalloc ((len + 1) * sizeof (char *));
      for (i = out = 0; i < len; ++i)
	{
	  PyObject *elt = PySequence_GetItem (resultobj, i);

	  if (elt == NULL || ! gdbpy_is_string (elt))
	    {
	      /* Skip problem elements.  */
	      PyErr_Clear ();
	      continue;
	    }
	  result[out] = python_string_to_host_string (elt);
	  if (result[out] == NULL)
	    {
	      /* Skip problem elements.  */
	      PyErr_Clear ();
	      continue;
	    }
	  ++out;
	}
      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;

      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);
    }

 done:

  do_cleanups (cleanup);

  return result;
}

/* 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 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.  */
char *
gdbpy_parse_command_name (char *text,
			  struct cmd_list_element ***base_list,
			  struct cmd_list_element **start_list)
{
  struct cmd_list_element *elt;
  int len = strlen (text);
  int i, lastchar;
  char *prefix_text;
  char *result;

  /* Skip trailing whitespace.  */
  for (i = len - 1; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
    ;
  if (i < 0)
    {
      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] == '_');
       --i)
    ;
  result = xmalloc (lastchar - i + 2);
  memcpy (result, &text[i], lastchar - i + 1);
  result[lastchar - i + 1] = '\0';

  /* Skip whitespace again.  */
  for (--i; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
    ;
  if (i < 0)
    {
      *base_list = start_list;
      return result;
    }

  prefix_text = xmalloc (i + 2);
  memcpy (prefix_text, text, i + 1);
  prefix_text[i + 1] = '\0';

  text = prefix_text;
  elt = lookup_cmd_1 (&text, *start_list, NULL, 1);
  if (!elt || elt == (struct cmd_list_element *) -1)
    {
      PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."),
		    prefix_text);
      xfree (prefix_text);
      xfree (result);
      return NULL;
    }

  if (elt->prefixlist)
    {
      xfree (prefix_text);
      *base_list = elt->prefixlist;
      return result;
    }

  PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."),
		prefix_text);
  xfree (prefix_text);
  xfree (result);
  return NULL;
}

/* Object initializer; sets up gdb-side structures for command.

   Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).

   NAME is the name of the command.  It may consist of multiple words,
   in which case the final word is the name of the new command, and
   earlier words must be prefix commands.

   COMMAND_CLASS is the kind of command.  It should be one of the COMMAND_*
   constants defined in the gdb module.

   COMPLETER_CLASS is the kind of completer.  If not given, the
   "complete" method will be used.  Otherwise, it should be one of the
   COMPLETE_* constants defined in the gdb module.

   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.
   
*/
static int
cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
{
  cmdpy_object *obj = (cmdpy_object *) self;
  char *name;
  int cmdtype;
  int completetype = -1;
  char *docstring = NULL;
  volatile struct gdb_exception except;
  struct cmd_list_element **cmd_list;
  char *cmd_name, *pfx_name;
  static char *keywords[] = { "name", "command_class", "completer_class",
			      "prefix", NULL };
  PyObject *is_prefix = NULL;
  int cmp;

  if (obj->command)
    {
      /* Note: this is apparently not documented in Python.  We return
	 0 for success, -1 for failure.  */
      PyErr_Format (PyExc_RuntimeError,
		    _("Command object already initialized."));
      return -1;
    }

  if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO",
				     keywords, &name, &cmdtype,
			  &completetype, &is_prefix))
    return -1;

  if (cmdtype != no_class && cmdtype != class_run
      && cmdtype != class_vars && cmdtype != class_stack
      && cmdtype != class_files && cmdtype != class_support
      && cmdtype != class_info && cmdtype != class_breakpoint
      && cmdtype != class_trace && cmdtype != class_obscure
      && cmdtype != class_maintenance)
    {
      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."));
      return -1;
    }

  cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist);
  if (! cmd_name)
    return -1;

  pfx_name = 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])
	    {
	      /* Skip whitespace.  */
	      while (name[i] == ' ' || name[i] == '\t')
		++i;
	      /* Copy non-whitespace characters.  */
	      while (name[i] && name[i] != ' ' && name[i] != '\t')
		pfx_name[out++] = name[i++];
	      /* Add a single space after each word -- including the final
		 word.  */
	      pfx_name[out++] = ' ';
	    }
	  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);
	  if (docstring == NULL)
	    {
	      xfree (cmd_name);
	      xfree (pfx_name);
	      return -1;
	    }
	}
    }
  if (! docstring)
    docstring = xstrdup (_("This command is not documented."));

  Py_INCREF (self);

  TRY_CATCH (except, RETURN_MASK_ALL)
    {
      struct cmd_list_element *cmd;

      if (pfx_name)
	{
	  int allow_unknown;

	  /* If we have our own "invoke" method, then allow unknown
	     sub-commands.  */
	  allow_unknown = PyObject_HasAttr (self, invoke_cst);
	  cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype,
				NULL, docstring, &obj->sub_list,
				pfx_name, allow_unknown, cmd_list);
	}
      else
	cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL,
		       docstring, cmd_list);

      /* There appears to be no API to set this.  */
      cmd->func = cmdpy_function;
      cmd->destroyer = cmdpy_destroyer;

      obj->command = cmd;
      set_cmd_context (cmd, self);
      set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
			       : completers[completetype].completer));
    }
  if (except.reason < 0)
    {
      xfree (cmd_name);
      xfree (docstring);
      xfree (pfx_name);
      Py_DECREF (self);
      PyErr_Format (except.reason == RETURN_QUIT
		    ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
		    "%s", except.message);
      return -1;
    }
  return 0;
}

\f

/* Initialize the 'commands' code.  */
void
gdbpy_initialize_commands (void)
{
  int i;

  if (PyType_Ready (&cmdpy_object_type) < 0)
    return;

  /* Note: alias and user are special; pseudo appears to be unused,
     and there is no reason to expose tui or xdb, I think.  */
  if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT",
				  class_support) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS",
				  class_breakpoint) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS",
				  class_trace) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
				  class_obscure) < 0
      || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
				  class_maintenance) < 0)
    return;

  for (i = 0; i < N_COMPLETERS; ++i)
    {
      if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
	return;
    }

  Py_INCREF (&cmdpy_object_type);
  PyModule_AddObject (gdb_module, "Command",
		      (PyObject *) &cmdpy_object_type);

  invoke_cst = PyString_FromString ("invoke");
  complete_cst = PyString_FromString ("complete");
}

\f

static PyMethodDef cmdpy_object_methods[] =
{
  { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS,
    "Prevent command repetition when user enters empty line." },

  { 0 }
};

static PyTypeObject cmdpy_object_type =
{
  PyObject_HEAD_INIT (NULL)
  0,				  /*ob_size*/
  "gdb.Command",		  /*tp_name*/
  sizeof (cmdpy_object),	  /*tp_basicsize*/
  0,				  /*tp_itemsize*/
  0,				  /*tp_dealloc*/
  0,				  /*tp_print*/
  0,				  /*tp_getattr*/
  0,				  /*tp_setattr*/
  0,				  /*tp_compare*/
  0,				  /*tp_repr*/
  0,				  /*tp_as_number*/
  0,				  /*tp_as_sequence*/
  0,				  /*tp_as_mapping*/
  0,				  /*tp_hash */
  0,				  /*tp_call*/
  0,				  /*tp_str*/
  0,				  /*tp_getattro*/
  0,				  /*tp_setattro*/
  0,				  /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
  "GDB command object",		  /* tp_doc */
  0,				  /* tp_traverse */
  0,				  /* tp_clear */
  0,				  /* tp_richcompare */
  0,				  /* tp_weaklistoffset */
  0,				  /* tp_iter */
  0,				  /* tp_iternext */
  cmdpy_object_methods,		  /* tp_methods */
  0,				  /* tp_members */
  0,				  /* tp_getset */
  0,				  /* tp_base */
  0,				  /* tp_dict */
  0,				  /* tp_descr_get */
  0,				  /* tp_descr_set */
  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;
  char *input;

  if (!PyArg_ParseTuple (args, "s", &input))
    return NULL;

  py_argv = PyList_New (0);

  /* 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)
	    {
	      if (argp != NULL)
		{
		  Py_DECREF (argp);
		}
	      Py_DECREF (py_argv);
	      freeargv (c_argv);
	      return NULL;
	    }
	}

      freeargv (c_argv);
    }

  return py_argv;
}
Commit	Line	Data
d8906c6f TJB	1	/* gdb commands implemented in Python
d8906c6f TJB	2
7b6bb8da	3	Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
d8906c6f TJB	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20
	21	#include "defs.h"
d452c4bc	22	#include "arch-utils.h"
d8906c6f TJB	23	#include "value.h"
	24	#include "exceptions.h"
	25	#include "python-internal.h"
	26	#include "charset.h"
	27	#include "gdbcmd.h"
	28	#include "cli/cli-decode.h"
	29	#include "completer.h"
d452c4bc	30	#include "language.h"
d8906c6f TJB	31
	32	/* Struct representing built-in completion types. */
	33	struct cmdpy_completer
	34	{
	35	/* Python symbol name. */
	36	char *name;
	37	/* Completion function. */
	38	char *(completer) (struct cmd_list_element , char , char *);
	39	};
	40
	41	static struct cmdpy_completer completers[] =
	42	{
	43	{ "COMPLETE_NONE", noop_completer },
	44	{ "COMPLETE_FILENAME", filename_completer },
	45	{ "COMPLETE_LOCATION", location_completer },
	46	{ "COMPLETE_COMMAND", command_completer },
	47	{ "COMPLETE_SYMBOL", make_symbol_completion_list_fn },
	48	};
	49
	50	#define N_COMPLETERS (sizeof (completers) / sizeof (completers[0]))
	51
	52	/* A gdb command. For the time being only ordinary commands (not
	53	set/show commands) are allowed. */
	54	struct cmdpy_object
	55	{
	56	PyObject_HEAD
	57
	58	/* The corresponding gdb command object, or NULL if the command is
	59	no longer installed. */
	60	struct cmd_list_element *command;
	61
	62	/* A prefix command requires storage for a list of its sub-commands.
	63	A pointer to this is passed to add_prefix_command, and to add_cmd
	64	for sub-commands of that prefix. If this Command is not a prefix
	65	command, then this field is unused. */
	66	struct cmd_list_element *sub_list;
	67	};
	68
	69	typedef struct cmdpy_object cmdpy_object;
	70
	71	static PyTypeObject cmdpy_object_type;
	72
	73
	74	/* Constants used by this module. */
	75	static PyObject *invoke_cst;
	76	static PyObject *complete_cst;
	77
	78	\f
	79
	80	/* Python function which wraps dont_repeat. */
	81	static PyObject *
	82	cmdpy_dont_repeat (PyObject self, PyObject args)
	83	{
	84	dont_repeat ();
	85	Py_RETURN_NONE;
	86	}
	87
	88	\f
	89
	90	/* Called if the gdb cmd_list_element is destroyed. */
07ca107c	91
d8906c6f TJB	92	static void
	93	cmdpy_destroyer (struct cmd_list_element self, void context)
	94	{
	95	cmdpy_object *cmd;
d452c4bc	96	struct cleanup *cleanup;
d8906c6f	97
d452c4bc	98	cleanup = ensure_python_env (get_current_arch (), current_language);
d8906c6f TJB	99
	100	/* Release our hold on the command object. */
	101	cmd = (cmdpy_object *) context;
	102	cmd->command = NULL;
	103	Py_DECREF (cmd);
	104
	105	/* We allocated the name, doc string, and perhaps the prefix
	106	name. */
	107	xfree (self->name);
	108	xfree (self->doc);
	109	xfree (self->prefixname);
	110
d452c4bc	111	do_cleanups (cleanup);
d8906c6f TJB	112	}
	113
	114	/* Called by gdb to invoke the command. */
07ca107c	115
d8906c6f TJB	116	static void
	117	cmdpy_function (struct cmd_list_element command, char args, int from_tty)
	118	{
	119	cmdpy_object obj = (cmdpy_object ) get_cmd_context (command);
	120	PyObject argobj, ttyobj, *result;
	121	struct cleanup *cleanup;
d8906c6f	122
d452c4bc	123	cleanup = ensure_python_env (get_current_arch (), current_language);
d8906c6f TJB	124
	125	if (! obj)
	126	error (_("Invalid invocation of Python command object."));
	127	if (! PyObject_HasAttr ((PyObject *) obj, invoke_cst))
	128	{
	129	if (obj->command->prefixname)
	130	{
	131	/* A prefix command does not need an invoke method. */
	132	do_cleanups (cleanup);
	133	return;
	134	}
	135	error (_("Python command object missing 'invoke' method."));
	136	}
	137
	138	if (! args)
	139	args = "";
	140	argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL);
	141	if (! argobj)
8dc78533 JK	142	{
	143	gdbpy_print_stack ();
	144	error (_("Could not convert arguments to Python string."));
	145	}
d8906c6f TJB	146
	147	ttyobj = from_tty ? Py_True : Py_False;
	148	Py_INCREF (ttyobj);
	149	result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj,
	150	ttyobj, NULL);
	151	Py_DECREF (argobj);
	152	Py_DECREF (ttyobj);
07ca107c	153
d8906c6f TJB	154	if (! result)
	155	{
	156	PyObject ptype, pvalue, *ptraceback;
07ca107c	157	char *msg;
d8906c6f TJB	158
	159	PyErr_Fetch (&ptype, &pvalue, &ptraceback);
	160
07ca107c DE	161	/* Try to fetch an error message contained within ptype, pvalue.
	162	When fetching the error message we need to make our own copy,
	163	we no longer own ptype, pvalue after the call to PyErr_Restore. */
d8906c6f	164
07ca107c DE	165	msg = gdbpy_exception_to_string (ptype, pvalue);
	166	make_cleanup (xfree, msg);
	167
	168	if (msg == NULL)
	169	{
	170	/* An error occurred computing the string representation of the
	171	error message. This is rare, but we should inform the user. */
	172	printf_filtered (_("An error occurred in a Python command\n"
9a2b4c1b MS	173	"and then another occurred computing the "
9a2b4c1b MS	174	"error message.\n"));
d8906c6f	175	gdbpy_print_stack ();
d8906c6f	176	}
07ca107c DE	177
	178	/* Don't print the stack for gdb.GdbError exceptions.
	179	It is generally used to flag user errors.
	180
	181	We also don't want to print "Error occurred in Python command"
	182	for user errors. However, a missing message for gdb.GdbError
	183	exceptions is arguably a bug, so we flag it as such. */
	184
	185	if (! PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc)
	186	\|\| msg == NULL \|\| *msg == '\0')
d8906c6f TJB	187	{
	188	PyErr_Restore (ptype, pvalue, ptraceback);
	189	gdbpy_print_stack ();
07ca107c DE	190	if (msg != NULL && *msg != '\0')
	191	error (_("Error occurred in Python command: %s"), msg);
	192	else
	193	error (_("Error occurred in Python command."));
d8906c6f	194	}
07ca107c	195	else
cca56ac7 TT	196	{
	197	Py_XDECREF (ptype);
	198	Py_XDECREF (pvalue);
	199	Py_XDECREF (ptraceback);
	200	error ("%s", msg);
	201	}
d8906c6f	202	}
07ca107c	203
d8906c6f TJB	204	Py_DECREF (result);
	205	do_cleanups (cleanup);
	206	}
	207
	208	/* Called by gdb for command completion. */
	209	static char **
	210	cmdpy_completer (struct cmd_list_element command, char text, char *word)
	211	{
	212	cmdpy_object obj = (cmdpy_object ) get_cmd_context (command);
	213	PyObject textobj, wordobj, *resultobj = NULL;
	214	char **result = NULL;
	215	struct cleanup *cleanup;
d8906c6f	216
d452c4bc	217	cleanup = ensure_python_env (get_current_arch (), current_language);
d8906c6f TJB	218
	219	if (! obj)
	220	error (_("Invalid invocation of Python command object."));
	221	if (! PyObject_HasAttr ((PyObject *) obj, complete_cst))
	222	{
	223	/* If there is no complete method, don't error -- instead, just
	224	say that there are no completions. */
	225	goto done;
	226	}
	227
	228	textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL);
	229	if (! textobj)
	230	error (_("Could not convert argument to Python string."));
	231	wordobj = PyUnicode_Decode (word, strlen (word), host_charset (), NULL);
	232	if (! wordobj)
	233	error (_("Could not convert argument to Python string."));
	234
	235	resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst,
	236	textobj, wordobj, NULL);
	237	Py_DECREF (textobj);
	238	Py_DECREF (wordobj);
	239	if (! resultobj)
	240	{
	241	/* Just swallow errors here. */
	242	PyErr_Clear ();
	243	goto done;
	244	}
	245	make_cleanup_py_decref (resultobj);
	246
	247	result = NULL;
	248	if (PySequence_Check (resultobj))
	249	{
	250	Py_ssize_t i, len = PySequence_Size (resultobj);
	251	Py_ssize_t out;
d59b6f6c	252
d8906c6f TJB	253	if (len < 0)
	254	goto done;
	255
	256	result = (char *) xmalloc ((len + 1) sizeof (char *));
	257	for (i = out = 0; i < len; ++i)
	258	{
d8906c6f	259	PyObject *elt = PySequence_GetItem (resultobj, i);
d59b6f6c	260
d8906c6f TJB	261	if (elt == NULL \|\| ! gdbpy_is_string (elt))
	262	{
	263	/* Skip problem elements. */
	264	PyErr_Clear ();
	265	continue;
	266	}
	267	result[out] = python_string_to_host_string (elt);
8dc78533 JK	268	if (result[out] == NULL)
	269	{
	270	/* Skip problem elements. */
	271	PyErr_Clear ();
	272	continue;
	273	}
d8906c6f TJB	274	++out;
	275	}
	276	result[out] = NULL;
	277	}
	278	else if (PyInt_Check (resultobj))
	279	{
	280	/* User code may also return one of the completion constants,
	281	thus requesting that sort of completion. */
74aedc46	282	long value;
d59b6f6c	283
74aedc46 TT	284	if (! gdb_py_int_as_long (resultobj, &value))
	285	{
	286	/* Ignore. */
	287	PyErr_Clear ();
	288	}
	289	else if (value >= 0 && value < (long) N_COMPLETERS)
d8906c6f TJB	290	result = completers[value].completer (command, text, word);
	291	}
	292
	293	done:
	294
	295	do_cleanups (cleanup);
	296
	297	return result;
	298	}
	299
	300	/* Helper for cmdpy_init which locates the command list to use and
	301	pulls out the command name.
	302
	303	TEXT is the command name list. The final word in the list is the
	304	name of the new command. All earlier words must be existing prefix
	305	commands.
	306
	307	*BASE_LIST is set to the final prefix command's list of
	308	*sub-commands.
	309
d7b32ed3 PM	310	START_LIST is the list in which the search starts.
d7b32ed3 PM	311
d8906c6f TJB	312	This function returns the xmalloc()d name of the new command. On
d8906c6f TJB	313	error sets the Python error and returns NULL. */
d7b32ed3 PM	314	char *
	315	gdbpy_parse_command_name (char *text,
	316	struct cmd_list_element ***base_list,
	317	struct cmd_list_element **start_list)
d8906c6f TJB	318	{
	319	struct cmd_list_element *elt;
	320	int len = strlen (text);
	321	int i, lastchar;
	322	char *prefix_text;
	323	char *result;
	324
	325	/* Skip trailing whitespace. */
	326	for (i = len - 1; i >= 0 && (text[i] == ' ' \|\| text[i] == '\t'); --i)
	327	;
	328	if (i < 0)
	329	{
044c0f87	330	PyErr_SetString (PyExc_RuntimeError, _("No command name found."));
d8906c6f TJB	331	return NULL;
	332	}
	333	lastchar = i;
	334
	335	/* Find first character of the final word. */
	336	for (; i > 0 && (isalnum (text[i - 1])
	337	\|\| text[i - 1] == '-'
	338	\|\| text[i - 1] == '_');
	339	--i)
	340	;
	341	result = xmalloc (lastchar - i + 2);
	342	memcpy (result, &text[i], lastchar - i + 1);
	343	result[lastchar - i + 1] = '\0';
	344
	345	/* Skip whitespace again. */
	346	for (--i; i >= 0 && (text[i] == ' ' \|\| text[i] == '\t'); --i)
	347	;
	348	if (i < 0)
	349	{
d7b32ed3	350	*base_list = start_list;
d8906c6f TJB	351	return result;
	352	}
	353
	354	prefix_text = xmalloc (i + 2);
	355	memcpy (prefix_text, text, i + 1);
	356	prefix_text[i + 1] = '\0';
	357
	358	text = prefix_text;
d7b32ed3	359	elt = lookup_cmd_1 (&text, *start_list, NULL, 1);
d8906c6f TJB	360	if (!elt \|\| elt == (struct cmd_list_element *) -1)
d8906c6f TJB	361	{
044c0f87	362	PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."),
d8906c6f TJB	363	prefix_text);
	364	xfree (prefix_text);
	365	xfree (result);
	366	return NULL;
	367	}
	368
	369	if (elt->prefixlist)
	370	{
	371	xfree (prefix_text);
	372	*base_list = elt->prefixlist;
	373	return result;
	374	}
	375
044c0f87	376	PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."),
d8906c6f TJB	377	prefix_text);
	378	xfree (prefix_text);
	379	xfree (result);
	380	return NULL;
	381	}
	382
	383	/* Object initializer; sets up gdb-side structures for command.
	384
cc924cad	385	Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
d8906c6f TJB	386
	387	NAME is the name of the command. It may consist of multiple words,
	388	in which case the final word is the name of the new command, and
	389	earlier words must be prefix commands.
	390
cc924cad	391	COMMAND_CLASS is the kind of command. It should be one of the COMMAND_*
d8906c6f TJB	392	constants defined in the gdb module.
d8906c6f TJB	393
cc924cad	394	COMPLETER_CLASS is the kind of completer. If not given, the
d8906c6f TJB	395	"complete" method will be used. Otherwise, it should be one of the
	396	COMPLETE_* constants defined in the gdb module.
	397
	398	If PREFIX is True, then this command is a prefix command.
	399
	400	The documentation for the command is taken from the doc string for
	401	the python class.
	402
	403	*/
	404	static int
cc924cad	405	cmdpy_init (PyObject self, PyObject args, PyObject *kw)
d8906c6f TJB	406	{
	407	cmdpy_object obj = (cmdpy_object ) self;
	408	char *name;
	409	int cmdtype;
	410	int completetype = -1;
	411	char *docstring = NULL;
	412	volatile struct gdb_exception except;
	413	struct cmd_list_element **cmd_list;
	414	char cmd_name, pfx_name;
cc924cad TJB	415	static char *keywords[] = { "name", "command_class", "completer_class",
cc924cad TJB	416	"prefix", NULL };
d8906c6f TJB	417	PyObject *is_prefix = NULL;
	418	int cmp;
	419
	420	if (obj->command)
	421	{
	422	/* Note: this is apparently not documented in Python. We return
	423	0 for success, -1 for failure. */
	424	PyErr_Format (PyExc_RuntimeError,
044c0f87	425	_("Command object already initialized."));
d8906c6f TJB	426	return -1;
	427	}
	428
9a2b4c1b MS	429	if (! PyArg_ParseTupleAndKeywords (args, kw, "si\|iO",
9a2b4c1b MS	430	keywords, &name, &cmdtype,
d8906c6f TJB	431	&completetype, &is_prefix))
	432	return -1;
	433
	434	if (cmdtype != no_class && cmdtype != class_run
	435	&& cmdtype != class_vars && cmdtype != class_stack
	436	&& cmdtype != class_files && cmdtype != class_support
	437	&& cmdtype != class_info && cmdtype != class_breakpoint
	438	&& cmdtype != class_trace && cmdtype != class_obscure
	439	&& cmdtype != class_maintenance)
	440	{
044c0f87	441	PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
d8906c6f TJB	442	return -1;
	443	}
	444
	445	if (completetype < -1 \|\| completetype >= (int) N_COMPLETERS)
	446	{
9a2b4c1b MS	447	PyErr_Format (PyExc_RuntimeError,
9a2b4c1b MS	448	_("Invalid completion type argument."));
d8906c6f TJB	449	return -1;
	450	}
	451
d7b32ed3	452	cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist);
d8906c6f TJB	453	if (! cmd_name)
	454	return -1;
	455
	456	pfx_name = NULL;
	457	if (is_prefix != NULL)
	458	{
	459	cmp = PyObject_IsTrue (is_prefix);
	460	if (cmp == 1)
	461	{
	462	int i, out;
	463
	464	/* Make a normalized form of the command name. */
	465	pfx_name = xmalloc (strlen (name) + 2);
	466
	467	i = 0;
	468	out = 0;
	469	while (name[i])
	470	{
	471	/* Skip whitespace. */
	472	while (name[i] == ' ' \|\| name[i] == '\t')
	473	++i;
	474	/* Copy non-whitespace characters. */
	475	while (name[i] && name[i] != ' ' && name[i] != '\t')
	476	pfx_name[out++] = name[i++];
	477	/* Add a single space after each word -- including the final
	478	word. */
	479	pfx_name[out++] = ' ';
	480	}
	481	pfx_name[out] = '\0';
	482	}
	483	else if (cmp < 0)
e463f587 MS	484	{
e463f587 MS	485	xfree (cmd_name);
d8906c6f	486	return -1;
e463f587	487	}
d8906c6f TJB	488	}
	489	if (PyObject_HasAttr (self, gdbpy_doc_cst))
	490	{
	491	PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst);
d59b6f6c	492
d8906c6f	493	if (ds_obj && gdbpy_is_string (ds_obj))
8dc78533 JK	494	{
	495	docstring = python_string_to_host_string (ds_obj);
	496	if (docstring == NULL)
	497	{
	498	xfree (cmd_name);
	499	xfree (pfx_name);
	500	return -1;
	501	}
	502	}
d8906c6f TJB	503	}
	504	if (! docstring)
	505	docstring = xstrdup (_("This command is not documented."));
	506
	507	Py_INCREF (self);
	508
	509	TRY_CATCH (except, RETURN_MASK_ALL)
	510	{
	511	struct cmd_list_element *cmd;
	512
	513	if (pfx_name)
	514	{
	515	int allow_unknown;
	516
	517	/* If we have our own "invoke" method, then allow unknown
	518	sub-commands. */
	519	allow_unknown = PyObject_HasAttr (self, invoke_cst);
	520	cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype,
	521	NULL, docstring, &obj->sub_list,
	522	pfx_name, allow_unknown, cmd_list);
	523	}
	524	else
	525	cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL,
	526	docstring, cmd_list);
	527
	528	/* There appears to be no API to set this. */
	529	cmd->func = cmdpy_function;
	530	cmd->destroyer = cmdpy_destroyer;
	531
	532	obj->command = cmd;
	533	set_cmd_context (cmd, self);
	534	set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
	535	: completers[completetype].completer));
	536	}
	537	if (except.reason < 0)
	538	{
	539	xfree (cmd_name);
	540	xfree (docstring);
	541	xfree (pfx_name);
	542	Py_DECREF (self);
	543	PyErr_Format (except.reason == RETURN_QUIT
	544	? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
	545	"%s", except.message);
	546	return -1;
	547	}
	548	return 0;
	549	}
	550
	551	\f
	552
	553	/* Initialize the 'commands' code. */
	554	void
	555	gdbpy_initialize_commands (void)
	556	{
	557	int i;
	558
	559	if (PyType_Ready (&cmdpy_object_type) < 0)
	560	return;
	561
	562	/* Note: alias and user are special; pseudo appears to be unused,
	563	and there is no reason to expose tui or xdb, I think. */
	564	if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0
	565	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0
	566	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0
567	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0
568	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0
569	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT",
570	class_support) < 0
571	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0
572	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS",
573	class_breakpoint) < 0
574	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS",
575	class_trace) < 0
576	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
577	class_obscure) < 0
578	\|\| PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
579	class_maintenance) < 0)
580	return;
581
582	for (i = 0; i < N_COMPLETERS; ++i)
583	{
584	if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
585	return;
586	}
587
588	Py_INCREF (&cmdpy_object_type);
589	PyModule_AddObject (gdb_module, "Command",
590	(PyObject *) &cmdpy_object_type);
591
592	invoke_cst = PyString_FromString ("invoke");
593	complete_cst = PyString_FromString ("complete");
594	}
595
596	\f
597
598	static PyMethodDef cmdpy_object_methods[] =
599	{
600	{ "dont_repeat", cmdpy_dont_repeat, METH_NOARGS,
601	"Prevent command repetition when user enters empty line." },
602
603	{ 0 }
604	};
605
606	static PyTypeObject cmdpy_object_type =
607	{
608	PyObject_HEAD_INIT (NULL)
609	0, /ob_size/
610	"gdb.Command", /tp_name/
611	sizeof (cmdpy_object), /tp_basicsize/
612	0, /tp_itemsize/
613	0, /tp_dealloc/
614	0, /tp_print/
615	0, /tp_getattr/
616	0, /tp_setattr/
617	0, /tp_compare/
618	0, /tp_repr/
619	0, /tp_as_number/
620	0, /tp_as_sequence/
621	0, /tp_as_mapping/
622	0, /tp_hash /
623	0, /tp_call/
624	0, /tp_str/
625	0, /tp_getattro/
626	0, /tp_setattro/
627	0, /tp_as_buffer/
628	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /tp_flags/
629	"GDB command object", /* tp_doc */
630	0, /* tp_traverse */
631	0, /* tp_clear */
632	0, /* tp_richcompare */
633	0, /* tp_weaklistoffset */
634	0, /* tp_iter */
635	0, /* tp_iternext */
636	cmdpy_object_methods, /* tp_methods */
637	0, /* tp_members */
638	0, /* tp_getset */
639	0, /* tp_base */
640	0, /* tp_dict */
641	0, /* tp_descr_get */
642	0, /* tp_descr_set */
643	0, /* tp_dictoffset */
644	cmdpy_init, /* tp_init */
645	0, /* tp_alloc */
646	PyType_GenericNew /* tp_new */
647	};
07ca107c DE	648
	649	\f
	650
	651	/* Utility to build a buildargv-like result from ARGS.
	652	This intentionally parses arguments the way libiberty/argv.c:buildargv
	653	does. It splits up arguments in a reasonable way, and we want a standard
	654	way of parsing arguments. Several gdb commands use buildargv to parse their
	655	arguments. Plus we want to be able to write compatible python
	656	implementations of gdb commands. */
	657
	658	PyObject *
	659	gdbpy_string_to_argv (PyObject self, PyObject args)
	660	{
	661	PyObject *py_argv;
	662	char *input;
	663
	664	if (!PyArg_ParseTuple (args, "s", &input))
	665	return NULL;
	666
	667	py_argv = PyList_New (0);
	668
	669	/* buildargv uses NULL to represent an empty argument list, but we can't use
	670	that in Python. Instead, if ARGS is "" then return an empty list.
	671	This undoes the NULL -> "" conversion that cmdpy_function does. */
	672
	673	if (*input != '\0')
	674	{
	675	char **c_argv = gdb_buildargv (input);
	676	int i;
	677
	678	for (i = 0; c_argv[i] != NULL; ++i)
	679	{
	680	PyObject *argp = PyString_FromString (c_argv[i]);
	681
	682	if (argp == NULL
	683	\|\| PyList_Append (py_argv, argp) < 0)
	684	{
	685	if (argp != NULL)
	686	{
	687	Py_DECREF (argp);
	688	}
	689	Py_DECREF (py_argv);
	690	freeargv (c_argv);
	691	return NULL;
	692	}
	693	}
	694
	695	freeargv (c_argv);
	696	}
	697
	698	return py_argv;
	699	}