gdb/python/py-cmd.c

   1 /* gdb commands implemented in Python
   2
   3    Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
   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"
  22 #include "arch-utils.h"
  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"
  30 #include "language.h"
  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.  */
  91 static void
  92 cmdpy_destroyer (struct cmd_list_element *self, void *context)
  93 {
  94   cmdpy_object *cmd;
  95   struct cleanup *cleanup;
  96
  97   cleanup = ensure_python_env (get_current_arch (), current_language);
  98
  99   /* Release our hold on the command object.  */
 100   cmd = (cmdpy_object *) context;
 101   cmd->command = NULL;
 102   Py_DECREF (cmd);
 103
 104   /* We allocated the name, doc string, and perhaps the prefix
 105      name.  */
 106   xfree (self->name);
 107   xfree (self->doc);
 108   xfree (self->prefixname);
 109
 110   do_cleanups (cleanup);
 111 }
 112
 113 /* Called by gdb to invoke the command.  */
 114 static void
 115 cmdpy_function (struct cmd_list_element *command, char *args, int from_tty)
 116 {
 117   cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
 118   PyObject *argobj, *ttyobj, *result;
 119   struct cleanup *cleanup;
 120
 121   cleanup = ensure_python_env (get_current_arch (), current_language);
 122
 123   if (! obj)
 124     error (_("Invalid invocation of Python command object."));
 125   if (! PyObject_HasAttr ((PyObject *) obj, invoke_cst))
 126     {
 127       if (obj->command->prefixname)
 128         {
 129           /* A prefix command does not need an invoke method.  */
 130           do_cleanups (cleanup);
 131           return;
 132         }
 133       error (_("Python command object missing 'invoke' method."));
 134     }
 135
 136   if (! args)
 137     args = "";
 138   argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL);
 139   if (! argobj)
 140     error (_("Could not convert arguments to Python string."));
 141
 142   ttyobj = from_tty ? Py_True : Py_False;
 143   Py_INCREF (ttyobj);
 144   result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj,
 145                                        ttyobj, NULL);
 146   Py_DECREF (argobj);
 147   Py_DECREF (ttyobj);
 148   if (! result)
 149     {
 150       PyObject *ptype, *pvalue, *ptraceback;
 151       char *s, *str;
 152
 153       PyErr_Fetch (&ptype, &pvalue, &ptraceback);
 154
 155       if (pvalue && PyString_Check (pvalue))
 156         {
 157           /* Make a temporary copy of the string data.  */
 158           char *s = PyString_AsString (pvalue);
 159           char *copy = alloca (strlen (s) + 1);
 160           strcpy (copy, s);
 161
 162           PyErr_Restore (ptype, pvalue, ptraceback);
 163           gdbpy_print_stack ();
 164           error (_("Error occurred in Python command: %s"), copy);
 165         }
 166       else
 167         {
 168           PyErr_Restore (ptype, pvalue, ptraceback);
 169           gdbpy_print_stack ();
 170           error (_("Error occurred in Python command."));
 171         }
 172     }
 173   Py_DECREF (result);
 174   do_cleanups (cleanup);
 175 }
 176
 177 /* Called by gdb for command completion.  */
 178 static char **
 179 cmdpy_completer (struct cmd_list_element *command, char *text, char *word)
 180 {
 181   cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
 182   PyObject *textobj, *wordobj, *resultobj = NULL;
 183   char **result = NULL;
 184   struct cleanup *cleanup;
 185
 186   cleanup = ensure_python_env (get_current_arch (), current_language);
 187
 188   if (! obj)
 189     error (_("Invalid invocation of Python command object."));
 190   if (! PyObject_HasAttr ((PyObject *) obj, complete_cst))
 191     {
 192       /* If there is no complete method, don't error -- instead, just
 193          say that there are no completions.  */
 194       goto done;
 195     }
 196
 197   textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL);
 198   if (! textobj)
 199     error (_("Could not convert argument to Python string."));
 200   wordobj = PyUnicode_Decode (word, strlen (word), host_charset (), NULL);
 201   if (! wordobj)
 202     error (_("Could not convert argument to Python string."));
 203
 204   resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst,
 205                                           textobj, wordobj, NULL);
 206   Py_DECREF (textobj);
 207   Py_DECREF (wordobj);
 208   if (! resultobj)
 209     {
 210       /* Just swallow errors here.  */
 211       PyErr_Clear ();
 212       goto done;
 213     }
 214   make_cleanup_py_decref (resultobj);
 215
 216   result = NULL;
 217   if (PySequence_Check (resultobj))
 218     {
 219       Py_ssize_t i, len = PySequence_Size (resultobj);
 220       Py_ssize_t out;
 221       if (len < 0)
 222         goto done;
 223
 224       result = (char **) xmalloc ((len + 1) * sizeof (char *));
 225       for (i = out = 0; i < len; ++i)
 226         {
 227           int l;
 228           PyObject *elt = PySequence_GetItem (resultobj, i);
 229           if (elt == NULL || ! gdbpy_is_string (elt))
 230             {
 231               /* Skip problem elements.  */
 232               PyErr_Clear ();
 233               continue;
 234             }
 235           result[out] = python_string_to_host_string (elt);
 236           ++out;
 237         }
 238       result[out] = NULL;
 239     }
 240   else if (PyInt_Check (resultobj))
 241     {
 242       /* User code may also return one of the completion constants,
 243          thus requesting that sort of completion.  */
 244       long value = PyInt_AsLong (resultobj);
 245       if (value >= 0 && value < (long) N_COMPLETERS)
 246         result = completers[value].completer (command, text, word);
 247     }
 248
 249  done:
 250
 251   do_cleanups (cleanup);
 252
 253   return result;
 254 }
 255
 256 /* Helper for cmdpy_init which locates the command list to use and
 257    pulls out the command name.
 258
 259    TEXT is the command name list.  The final word in the list is the
 260    name of the new command.  All earlier words must be existing prefix
 261    commands.
 262
 263    *BASE_LIST is set to the final prefix command's list of
 264    *sub-commands.
 265
 266    This function returns the xmalloc()d name of the new command.  On
 267    error sets the Python error and returns NULL.  */
 268 static char *
 269 parse_command_name (char *text, struct cmd_list_element ***base_list)
 270 {
 271   struct cmd_list_element *elt;
 272   int len = strlen (text);
 273   int i, lastchar;
 274   char *prefix_text;
 275   char *result;
 276
 277   /* Skip trailing whitespace.  */
 278   for (i = len - 1; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
 279     ;
 280   if (i < 0)
 281     {
 282       PyErr_SetString (PyExc_RuntimeError, _("no command name found"));
 283       return NULL;
 284     }
 285   lastchar = i;
 286
 287   /* Find first character of the final word.  */
 288   for (; i > 0 && (isalnum (text[i - 1])
 289                    || text[i - 1] == '-'
 290                    || text[i - 1] == '_');
 291        --i)
 292     ;
 293   result = xmalloc (lastchar - i + 2);
 294   memcpy (result, &text[i], lastchar - i + 1);
 295   result[lastchar - i + 1] = '\0';
 296
 297   /* Skip whitespace again.  */
 298   for (--i; i >= 0 && (text[i] == ' ' || text[i] == '\t'); --i)
 299     ;
 300   if (i < 0)
 301     {
 302       *base_list = &cmdlist;
 303       return result;
 304     }
 305
 306   prefix_text = xmalloc (i + 2);
 307   memcpy (prefix_text, text, i + 1);
 308   prefix_text[i + 1] = '\0';
 309
 310   text = prefix_text;
 311   elt = lookup_cmd_1 (&text, cmdlist, NULL, 1);
 312   if (!elt || elt == (struct cmd_list_element *) -1)
 313     {
 314       PyErr_Format (PyExc_RuntimeError, _("could not find command prefix %s"),
 315                     prefix_text);
 316       xfree (prefix_text);
 317       xfree (result);
 318       return NULL;
 319     }
 320
 321   if (elt->prefixlist)
 322     {
 323       xfree (prefix_text);
 324       *base_list = elt->prefixlist;
 325       return result;
 326     }
 327
 328   PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command"),
 329                 prefix_text);
 330   xfree (prefix_text);
 331   xfree (result);
 332   return NULL;
 333 }
 334
 335 /* Object initializer; sets up gdb-side structures for command.
 336
 337    Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
 338
 339    NAME is the name of the command.  It may consist of multiple words,
 340    in which case the final word is the name of the new command, and
 341    earlier words must be prefix commands.
 342
 343    COMMAND_CLASS is the kind of command.  It should be one of the COMMAND_*
 344    constants defined in the gdb module.
 345
 346    COMPLETER_CLASS is the kind of completer.  If not given, the
 347    "complete" method will be used.  Otherwise, it should be one of the
 348    COMPLETE_* constants defined in the gdb module.
 349
 350    If PREFIX is True, then this command is a prefix command.
 351
 352    The documentation for the command is taken from the doc string for
 353    the python class.
 354
 355 */
 356 static int
 357 cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
 358 {
 359   cmdpy_object *obj = (cmdpy_object *) self;
 360   char *name;
 361   int cmdtype;
 362   int completetype = -1;
 363   char *docstring = NULL;
 364   volatile struct gdb_exception except;
 365   struct cmd_list_element **cmd_list;
 366   char *cmd_name, *pfx_name;
 367   static char *keywords[] = { "name", "command_class", "completer_class",
 368                               "prefix", NULL };
 369   PyObject *is_prefix = NULL;
 370   int cmp;
 371
 372   if (obj->command)
 373     {
 374       /* Note: this is apparently not documented in Python.  We return
 375          0 for success, -1 for failure.  */
 376       PyErr_Format (PyExc_RuntimeError,
 377                     _("command object already initialized"));
 378       return -1;
 379     }
 380
 381   if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO", keywords, &name, &cmdtype,
 382                           &completetype, &is_prefix))
 383     return -1;
 384
 385   if (cmdtype != no_class && cmdtype != class_run
 386       && cmdtype != class_vars && cmdtype != class_stack
 387       && cmdtype != class_files && cmdtype != class_support
 388       && cmdtype != class_info && cmdtype != class_breakpoint
 389       && cmdtype != class_trace && cmdtype != class_obscure
 390       && cmdtype != class_maintenance)
 391     {
 392       PyErr_Format (PyExc_RuntimeError, _("invalid command class argument"));
 393       return -1;
 394     }
 395
 396   if (completetype < -1 || completetype >= (int) N_COMPLETERS)
 397     {
 398       PyErr_Format (PyExc_RuntimeError, _("invalid completion type argument"));
 399       return -1;
 400     }
 401
 402   cmd_name = parse_command_name (name, &cmd_list);
 403   if (! cmd_name)
 404     return -1;
 405
 406   pfx_name = NULL;
 407   if (is_prefix != NULL)
 408     {
 409       cmp = PyObject_IsTrue (is_prefix);
 410       if (cmp == 1)
 411         {
 412           int i, out;
 413
 414           /* Make a normalized form of the command name.  */
 415           pfx_name = xmalloc (strlen (name) + 2);
 416
 417           i = 0;
 418           out = 0;
 419           while (name[i])
 420             {
 421               /* Skip whitespace.  */
 422               while (name[i] == ' ' || name[i] == '\t')
 423                 ++i;
 424               /* Copy non-whitespace characters.  */
 425               while (name[i] && name[i] != ' ' && name[i] != '\t')
 426                 pfx_name[out++] = name[i++];
 427               /* Add a single space after each word -- including the final
 428                  word.  */
 429               pfx_name[out++] = ' ';
 430             }
 431           pfx_name[out] = '\0';
 432         }
 433       else if (cmp < 0)
 434           return -1;
 435     }
 436   if (PyObject_HasAttr (self, gdbpy_doc_cst))
 437     {
 438       PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst);
 439       if (ds_obj && gdbpy_is_string (ds_obj))
 440         docstring = python_string_to_host_string (ds_obj);
 441     }
 442   if (! docstring)
 443     docstring = xstrdup (_("This command is not documented."));
 444
 445   Py_INCREF (self);
 446
 447   TRY_CATCH (except, RETURN_MASK_ALL)
 448     {
 449       struct cmd_list_element *cmd;
 450
 451       if (pfx_name)
 452         {
 453           int allow_unknown;
 454
 455           /* If we have our own "invoke" method, then allow unknown
 456              sub-commands.  */
 457           allow_unknown = PyObject_HasAttr (self, invoke_cst);
 458           cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype,
 459                                 NULL, docstring, &obj->sub_list,
 460                                 pfx_name, allow_unknown, cmd_list);
 461         }
 462       else
 463         cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL,
 464                        docstring, cmd_list);
 465
 466       /* There appears to be no API to set this.  */
 467       cmd->func = cmdpy_function;
 468       cmd->destroyer = cmdpy_destroyer;
 469
 470       obj->command = cmd;
 471       set_cmd_context (cmd, self);
 472       set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
 473                                : completers[completetype].completer));
 474     }
 475   if (except.reason < 0)
 476     {
 477       xfree (cmd_name);
 478       xfree (docstring);
 479       xfree (pfx_name);
 480       Py_DECREF (self);
 481       PyErr_Format (except.reason == RETURN_QUIT
 482                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 483                     "%s", except.message);
 484       return -1;
 485     }
 486   return 0;
 487 }
 488
 489 \f
 490
 491 /* Initialize the 'commands' code.  */
 492 void
 493 gdbpy_initialize_commands (void)
 494 {
 495   int i;
 496
 497   if (PyType_Ready (&cmdpy_object_type) < 0)
 498     return;
 499
 500   /* Note: alias and user are special; pseudo appears to be unused,
 501      and there is no reason to expose tui or xdb, I think.  */
 502   if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0
 503       || PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0
 504       || PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0
 505       || PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0
 506       || PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0
 507       || PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT",
 508                                   class_support) < 0
 509       || PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0
 510       || PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS",
 511                                   class_breakpoint) < 0
 512       || PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS",
 513                                   class_trace) < 0
 514       || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
 515                                   class_obscure) < 0
 516       || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
 517                                   class_maintenance) < 0)
 518     return;
 519
 520   for (i = 0; i < N_COMPLETERS; ++i)
 521     {
 522       if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
 523         return;
 524     }
 525
 526   Py_INCREF (&cmdpy_object_type);
 527   PyModule_AddObject (gdb_module, "Command",
 528                       (PyObject *) &cmdpy_object_type);
 529
 530   invoke_cst = PyString_FromString ("invoke");
 531   complete_cst = PyString_FromString ("complete");
 532 }
 533
 534 \f
 535
 536 static PyMethodDef cmdpy_object_methods[] =
 537 {
 538   { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS,
 539     "Prevent command repetition when user enters empty line." },
 540
 541   { 0 }
 542 };
 543
 544 static PyTypeObject cmdpy_object_type =
 545 {
 546   PyObject_HEAD_INIT (NULL)
 547   0,                              /*ob_size*/
 548   "gdb.Command",                  /*tp_name*/
 549   sizeof (cmdpy_object),          /*tp_basicsize*/
 550   0,                              /*tp_itemsize*/
 551   0,                              /*tp_dealloc*/
 552   0,                              /*tp_print*/
 553   0,                              /*tp_getattr*/
 554   0,                              /*tp_setattr*/
 555   0,                              /*tp_compare*/
 556   0,                              /*tp_repr*/
 557   0,                              /*tp_as_number*/
 558   0,                              /*tp_as_sequence*/
 559   0,                              /*tp_as_mapping*/
 560   0,                              /*tp_hash */
 561   0,                              /*tp_call*/
 562   0,                              /*tp_str*/
 563   0,                              /*tp_getattro*/
 564   0,                              /*tp_setattro*/
 565   0,                              /*tp_as_buffer*/
 566   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 567   "GDB command object",           /* tp_doc */
 568   0,                              /* tp_traverse */
 569   0,                              /* tp_clear */
 570   0,                              /* tp_richcompare */
 571   0,                              /* tp_weaklistoffset */
 572   0,                              /* tp_iter */
 573   0,                              /* tp_iternext */
 574   cmdpy_object_methods,           /* tp_methods */
 575   0,                              /* tp_members */
 576   0,                              /* tp_getset */
 577   0,                              /* tp_base */
 578   0,                              /* tp_dict */
 579   0,                              /* tp_descr_get */
 580   0,                              /* tp_descr_set */
 581   0,                              /* tp_dictoffset */
 582   cmdpy_init,                     /* tp_init */
 583   0,                              /* tp_alloc */
 584   PyType_GenericNew               /* tp_new */
 585 };