gdb/python/py-cmd.c

   1 /* gdb commands implemented in Python
   2
   3    Copyright (C) 2008-2016 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 "python-internal.h"
  25 #include "charset.h"
  26 #include "gdbcmd.h"
  27 #include "cli/cli-decode.h"
  28 #include "completer.h"
  29 #include "language.h"
  30
  31 /* Struct representing built-in completion types.  */
  32 struct cmdpy_completer
  33 {
  34   /* Python symbol name.
  35      This isn't a const char * for Python 2.4's sake.
  36      PyModule_AddIntConstant only takes a char *, sigh.  */
  37   char *name;
  38   /* Completion function.  */
  39   completer_ftype *completer;
  40 };
  41
  42 static const struct cmdpy_completer completers[] =
  43 {
  44   { "COMPLETE_NONE", noop_completer },
  45   { "COMPLETE_FILENAME", filename_completer },
  46   { "COMPLETE_LOCATION", location_completer },
  47   { "COMPLETE_COMMAND", command_completer },
  48   { "COMPLETE_SYMBOL", make_symbol_completion_list_fn },
  49   { "COMPLETE_EXPRESSION", expression_completer },
  50 };
  51
  52 #define N_COMPLETERS (sizeof (completers) / sizeof (completers[0]))
  53
  54 /* A gdb command.  For the time being only ordinary commands (not
  55    set/show commands) are allowed.  */
  56 struct cmdpy_object
  57 {
  58   PyObject_HEAD
  59
  60   /* The corresponding gdb command object, or NULL if the command is
  61      no longer installed.  */
  62   struct cmd_list_element *command;
  63
  64   /* A prefix command requires storage for a list of its sub-commands.
  65      A pointer to this is passed to add_prefix_command, and to add_cmd
  66      for sub-commands of that prefix.  If this Command is not a prefix
  67      command, then this field is unused.  */
  68   struct cmd_list_element *sub_list;
  69 };
  70
  71 typedef struct cmdpy_object cmdpy_object;
  72
  73 extern PyTypeObject cmdpy_object_type
  74     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("cmdpy_object");
  75
  76 /* Constants used by this module.  */
  77 static PyObject *invoke_cst;
  78 static PyObject *complete_cst;
  79
  80 \f
  81
  82 /* Python function which wraps dont_repeat.  */
  83 static PyObject *
  84 cmdpy_dont_repeat (PyObject *self, PyObject *args)
  85 {
  86   dont_repeat ();
  87   Py_RETURN_NONE;
  88 }
  89
  90 \f
  91
  92 /* Called if the gdb cmd_list_element is destroyed.  */
  93
  94 static void
  95 cmdpy_destroyer (struct cmd_list_element *self, void *context)
  96 {
  97   cmdpy_object *cmd;
  98   struct cleanup *cleanup;
  99
 100   cleanup = ensure_python_env (get_current_arch (), current_language);
 101
 102   /* Release our hold on the command object.  */
 103   cmd = (cmdpy_object *) context;
 104   cmd->command = NULL;
 105   Py_DECREF (cmd);
 106
 107   /* We allocated the name, doc string, and perhaps the prefix
 108      name.  */
 109   xfree ((char *) self->name);
 110   xfree ((char *) self->doc);
 111   xfree ((char *) self->prefixname);
 112
 113   do_cleanups (cleanup);
 114 }
 115
 116 /* Called by gdb to invoke the command.  */
 117
 118 static void
 119 cmdpy_function (struct cmd_list_element *command, char *args, int from_tty)
 120 {
 121   cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
 122   PyObject *argobj, *ttyobj, *result;
 123   struct cleanup *cleanup;
 124
 125   cleanup = ensure_python_env (get_current_arch (), current_language);
 126
 127   if (! obj)
 128     error (_("Invalid invocation of Python command object."));
 129   if (! PyObject_HasAttr ((PyObject *) obj, invoke_cst))
 130     {
 131       if (obj->command->prefixname)
 132         {
 133           /* A prefix command does not need an invoke method.  */
 134           do_cleanups (cleanup);
 135           return;
 136         }
 137       error (_("Python command object missing 'invoke' method."));
 138     }
 139
 140   if (! args)
 141     args = "";
 142   argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL);
 143   if (! argobj)
 144     {
 145       gdbpy_print_stack ();
 146       error (_("Could not convert arguments to Python string."));
 147     }
 148
 149   ttyobj = from_tty ? Py_True : Py_False;
 150   Py_INCREF (ttyobj);
 151   result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj,
 152                                        ttyobj, NULL);
 153   Py_DECREF (argobj);
 154   Py_DECREF (ttyobj);
 155
 156   if (! result)
 157     {
 158       PyObject *ptype, *pvalue, *ptraceback;
 159
 160       PyErr_Fetch (&ptype, &pvalue, &ptraceback);
 161
 162       /* Try to fetch an error message contained within ptype, pvalue.
 163          When fetching the error message we need to make our own copy,
 164          we no longer own ptype, pvalue after the call to PyErr_Restore.  */
 165
 166       gdb::unique_xmalloc_ptr<char>
 167         msg (gdbpy_exception_to_string (ptype, pvalue));
 168
 169       if (msg == NULL)
 170         {
 171           /* An error occurred computing the string representation of the
 172              error message.  This is rare, but we should inform the user.  */
 173           printf_filtered (_("An error occurred in a Python command\n"
 174                              "and then another occurred computing the "
 175                              "error message.\n"));
 176           gdbpy_print_stack ();
 177         }
 178
 179       /* Don't print the stack for gdb.GdbError exceptions.
 180          It is generally used to flag user errors.
 181
 182          We also don't want to print "Error occurred in Python command"
 183          for user errors.  However, a missing message for gdb.GdbError
 184          exceptions is arguably a bug, so we flag it as such.  */
 185
 186       if (! PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc)
 187           || msg == NULL || *msg == '\0')
 188         {
 189           PyErr_Restore (ptype, pvalue, ptraceback);
 190           gdbpy_print_stack ();
 191           if (msg != NULL && *msg != '\0')
 192             error (_("Error occurred in Python command: %s"), msg.get ());
 193           else
 194             error (_("Error occurred in Python command."));
 195         }
 196       else
 197         {
 198           Py_XDECREF (ptype);
 199           Py_XDECREF (pvalue);
 200           Py_XDECREF (ptraceback);
 201           error ("%s", msg.get ());
 202         }
 203     }
 204
 205   Py_DECREF (result);
 206   do_cleanups (cleanup);
 207 }
 208
 209 /* Helper function for the Python command completers (both "pure"
 210    completer and brkchar handler).  This function takes COMMAND, TEXT
 211    and WORD and tries to call the Python method for completion with
 212    these arguments.
 213
 214    This function is usually called twice: once when we are figuring out
 215    the break characters to be used, and another to perform the real
 216    completion itself.  The reason for this two step dance is that we
 217    need to know the set of "brkchars" to use early on, before we
 218    actually try to perform the completion.  But if a Python command
 219    supplies a "complete" method then we have to call that method
 220    first: it may return as its result the kind of completion to
 221    perform and that will in turn specify which brkchars to use.  IOW,
 222    we need the result of the "complete" method before we actually
 223    perform the completion.  The only situation when this function is
 224    not called twice is when the user uses the "complete" command: in
 225    this scenario, there is no call to determine the "brkchars".
 226
 227    Ideally, it would be nice to cache the result of the first call (to
 228    determine the "brkchars") and return this value directly in the
 229    second call (to perform the actual completion).  However, due to
 230    the peculiarity of the "complete" command mentioned above, it is
 231    possible to put GDB in a bad state if you perform a TAB-completion
 232    and then a "complete"-completion sequentially.  Therefore, we just
 233    recalculate everything twice for TAB-completions.
 234
 235    This function returns the PyObject representing the Python method
 236    call.  */
 237
 238 static PyObject *
 239 cmdpy_completer_helper (struct cmd_list_element *command,
 240                         const char *text, const char *word)
 241 {
 242   cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
 243   PyObject *textobj, *wordobj;
 244   PyObject *resultobj;
 245
 246   if (obj == NULL)
 247     error (_("Invalid invocation of Python command object."));
 248   if (!PyObject_HasAttr ((PyObject *) obj, complete_cst))
 249     {
 250       /* If there is no complete method, don't error.  */
 251       return NULL;
 252     }
 253
 254   textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL);
 255   if (textobj == NULL)
 256     error (_("Could not convert argument to Python string."));
 257   wordobj = PyUnicode_Decode (word, strlen (word), host_charset (), NULL);
 258   if (wordobj == NULL)
 259     {
 260       Py_DECREF (textobj);
 261       error (_("Could not convert argument to Python string."));
 262     }
 263
 264   resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst,
 265                                           textobj, wordobj, NULL);
 266   Py_DECREF (textobj);
 267   Py_DECREF (wordobj);
 268   if (!resultobj)
 269     {
 270       /* Just swallow errors here.  */
 271       PyErr_Clear ();
 272     }
 273
 274   Py_XINCREF (resultobj);
 275
 276   return resultobj;
 277 }
 278
 279 /* Python function called to determine the break characters of a
 280    certain completer.  We are only interested in knowing if the
 281    completer registered by the user will return one of the integer
 282    codes (see COMPLETER_* symbols).  */
 283
 284 static void
 285 cmdpy_completer_handle_brkchars (struct cmd_list_element *command,
 286                                  const char *text, const char *word)
 287 {
 288   PyObject *resultobj = NULL;
 289   struct cleanup *cleanup;
 290
 291   cleanup = ensure_python_env (get_current_arch (), current_language);
 292
 293   /* Calling our helper to obtain the PyObject of the Python
 294      function.  */
 295   resultobj = cmdpy_completer_helper (command, text, word);
 296
 297   /* Check if there was an error.  */
 298   if (resultobj == NULL)
 299     goto done;
 300
 301   if (PyInt_Check (resultobj))
 302     {
 303       /* User code may also return one of the completion constants,
 304          thus requesting that sort of completion.  We are only
 305          interested in this kind of return.  */
 306       long value;
 307
 308       if (!gdb_py_int_as_long (resultobj, &value))
 309         {
 310           /* Ignore.  */
 311           PyErr_Clear ();
 312         }
 313       else if (value >= 0 && value < (long) N_COMPLETERS)
 314         {
 315           /* This is the core of this function.  Depending on which
 316              completer type the Python function returns, we have to
 317              adjust the break characters accordingly.  */
 318           set_gdb_completion_word_break_characters
 319             (completers[value].completer);
 320         }
 321     }
 322
 323  done:
 324
 325   Py_XDECREF (resultobj);
 326   do_cleanups (cleanup);
 327 }
 328
 329 /* Called by gdb for command completion.  */
 330
 331 static VEC (char_ptr) *
 332 cmdpy_completer (struct cmd_list_element *command,
 333                  const char *text, const char *word)
 334 {
 335   PyObject *resultobj = NULL;
 336   VEC (char_ptr) *result = NULL;
 337   struct cleanup *cleanup;
 338
 339   cleanup = ensure_python_env (get_current_arch (), current_language);
 340
 341   /* Calling our helper to obtain the PyObject of the Python
 342      function.  */
 343   resultobj = cmdpy_completer_helper (command, text, word);
 344
 345   /* If the result object of calling the Python function is NULL, it
 346      means that there was an error.  In this case, just give up and
 347      return NULL.  */
 348   if (resultobj == NULL)
 349     goto done;
 350
 351   result = NULL;
 352   if (PyInt_Check (resultobj))
 353     {
 354       /* User code may also return one of the completion constants,
 355          thus requesting that sort of completion.  */
 356       long value;
 357
 358       if (! gdb_py_int_as_long (resultobj, &value))
 359         {
 360           /* Ignore.  */
 361           PyErr_Clear ();
 362         }
 363       else if (value >= 0 && value < (long) N_COMPLETERS)
 364         result = completers[value].completer (command, text, word);
 365     }
 366   else
 367     {
 368       PyObject *iter = PyObject_GetIter (resultobj);
 369       PyObject *elt;
 370
 371       if (iter == NULL)
 372         goto done;
 373
 374       while ((elt = PyIter_Next (iter)) != NULL)
 375         {
 376
 377           if (! gdbpy_is_string (elt))
 378             {
 379               /* Skip problem elements.  */
 380               Py_DECREF (elt);
 381               continue;
 382             }
 383           gdb::unique_xmalloc_ptr<char>
 384             item (python_string_to_host_string (elt));
 385           Py_DECREF (elt);
 386           if (item == NULL)
 387             {
 388               /* Skip problem elements.  */
 389               PyErr_Clear ();
 390               continue;
 391             }
 392           VEC_safe_push (char_ptr, result, item.release ());
 393         }
 394
 395       Py_DECREF (iter);
 396
 397       /* If we got some results, ignore problems.  Otherwise, report
 398          the problem.  */
 399       if (result != NULL && PyErr_Occurred ())
 400         PyErr_Clear ();
 401     }
 402
 403  done:
 404
 405   Py_XDECREF (resultobj);
 406   do_cleanups (cleanup);
 407
 408   return result;
 409 }
 410
 411 /* Helper for cmdpy_init which locates the command list to use and
 412    pulls out the command name.
 413
 414    NAME is the command name list.  The final word in the list is the
 415    name of the new command.  All earlier words must be existing prefix
 416    commands.
 417
 418    *BASE_LIST is set to the final prefix command's list of
 419    *sub-commands.
 420
 421    START_LIST is the list in which the search starts.
 422
 423    This function returns the xmalloc()d name of the new command.  On
 424    error sets the Python error and returns NULL.  */
 425
 426 char *
 427 gdbpy_parse_command_name (const char *name,
 428                           struct cmd_list_element ***base_list,
 429                           struct cmd_list_element **start_list)
 430 {
 431   struct cmd_list_element *elt;
 432   int len = strlen (name);
 433   int i, lastchar;
 434   char *prefix_text;
 435   const char *prefix_text2;
 436   char *result;
 437
 438   /* Skip trailing whitespace.  */
 439   for (i = len - 1; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
 440     ;
 441   if (i < 0)
 442     {
 443       PyErr_SetString (PyExc_RuntimeError, _("No command name found."));
 444       return NULL;
 445     }
 446   lastchar = i;
 447
 448   /* Find first character of the final word.  */
 449   for (; i > 0 && (isalnum (name[i - 1])
 450                    || name[i - 1] == '-'
 451                    || name[i - 1] == '_');
 452        --i)
 453     ;
 454   result = (char *) xmalloc (lastchar - i + 2);
 455   memcpy (result, &name[i], lastchar - i + 1);
 456   result[lastchar - i + 1] = '\0';
 457
 458   /* Skip whitespace again.  */
 459   for (--i; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
 460     ;
 461   if (i < 0)
 462     {
 463       *base_list = start_list;
 464       return result;
 465     }
 466
 467   prefix_text = (char *) xmalloc (i + 2);
 468   memcpy (prefix_text, name, i + 1);
 469   prefix_text[i + 1] = '\0';
 470
 471   prefix_text2 = prefix_text;
 472   elt = lookup_cmd_1 (&prefix_text2, *start_list, NULL, 1);
 473   if (elt == NULL || elt == CMD_LIST_AMBIGUOUS)
 474     {
 475       PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."),
 476                     prefix_text);
 477       xfree (prefix_text);
 478       xfree (result);
 479       return NULL;
 480     }
 481
 482   if (elt->prefixlist)
 483     {
 484       xfree (prefix_text);
 485       *base_list = elt->prefixlist;
 486       return result;
 487     }
 488
 489   PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."),
 490                 prefix_text);
 491   xfree (prefix_text);
 492   xfree (result);
 493   return NULL;
 494 }
 495
 496 /* Object initializer; sets up gdb-side structures for command.
 497
 498    Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
 499
 500    NAME is the name of the command.  It may consist of multiple words,
 501    in which case the final word is the name of the new command, and
 502    earlier words must be prefix commands.
 503
 504    COMMAND_CLASS is the kind of command.  It should be one of the COMMAND_*
 505    constants defined in the gdb module.
 506
 507    COMPLETER_CLASS is the kind of completer.  If not given, the
 508    "complete" method will be used.  Otherwise, it should be one of the
 509    COMPLETE_* constants defined in the gdb module.
 510
 511    If PREFIX is True, then this command is a prefix command.
 512
 513    The documentation for the command is taken from the doc string for
 514    the python class.  */
 515
 516 static int
 517 cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
 518 {
 519   cmdpy_object *obj = (cmdpy_object *) self;
 520   const char *name;
 521   int cmdtype;
 522   int completetype = -1;
 523   char *docstring = NULL;
 524   struct cmd_list_element **cmd_list;
 525   char *cmd_name, *pfx_name;
 526   static char *keywords[] = { "name", "command_class", "completer_class",
 527                               "prefix", NULL };
 528   PyObject *is_prefix = NULL;
 529   int cmp;
 530
 531   if (obj->command)
 532     {
 533       /* Note: this is apparently not documented in Python.  We return
 534          0 for success, -1 for failure.  */
 535       PyErr_Format (PyExc_RuntimeError,
 536                     _("Command object already initialized."));
 537       return -1;
 538     }
 539
 540   if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO",
 541                                      keywords, &name, &cmdtype,
 542                           &completetype, &is_prefix))
 543     return -1;
 544
 545   if (cmdtype != no_class && cmdtype != class_run
 546       && cmdtype != class_vars && cmdtype != class_stack
 547       && cmdtype != class_files && cmdtype != class_support
 548       && cmdtype != class_info && cmdtype != class_breakpoint
 549       && cmdtype != class_trace && cmdtype != class_obscure
 550       && cmdtype != class_maintenance && cmdtype != class_user)
 551     {
 552       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
 553       return -1;
 554     }
 555
 556   if (completetype < -1 || completetype >= (int) N_COMPLETERS)
 557     {
 558       PyErr_Format (PyExc_RuntimeError,
 559                     _("Invalid completion type argument."));
 560       return -1;
 561     }
 562
 563   cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist);
 564   if (! cmd_name)
 565     return -1;
 566
 567   pfx_name = NULL;
 568   if (is_prefix != NULL)
 569     {
 570       cmp = PyObject_IsTrue (is_prefix);
 571       if (cmp == 1)
 572         {
 573           int i, out;
 574
 575           /* Make a normalized form of the command name.  */
 576           pfx_name = (char *) xmalloc (strlen (name) + 2);
 577
 578           i = 0;
 579           out = 0;
 580           while (name[i])
 581             {
 582               /* Skip whitespace.  */
 583               while (name[i] == ' ' || name[i] == '\t')
 584                 ++i;
 585               /* Copy non-whitespace characters.  */
 586               while (name[i] && name[i] != ' ' && name[i] != '\t')
 587                 pfx_name[out++] = name[i++];
 588               /* Add a single space after each word -- including the final
 589                  word.  */
 590               pfx_name[out++] = ' ';
 591             }
 592           pfx_name[out] = '\0';
 593         }
 594       else if (cmp < 0)
 595         {
 596           xfree (cmd_name);
 597           return -1;
 598         }
 599     }
 600   if (PyObject_HasAttr (self, gdbpy_doc_cst))
 601     {
 602       PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst);
 603
 604       if (ds_obj && gdbpy_is_string (ds_obj))
 605         {
 606           docstring = python_string_to_host_string (ds_obj).release ();
 607           if (docstring == NULL)
 608             {
 609               xfree (cmd_name);
 610               xfree (pfx_name);
 611               Py_DECREF (ds_obj);
 612               return -1;
 613             }
 614         }
 615
 616       Py_XDECREF (ds_obj);
 617     }
 618   if (! docstring)
 619     docstring = xstrdup (_("This command is not documented."));
 620
 621   Py_INCREF (self);
 622
 623   TRY
 624     {
 625       struct cmd_list_element *cmd;
 626
 627       if (pfx_name)
 628         {
 629           int allow_unknown;
 630
 631           /* If we have our own "invoke" method, then allow unknown
 632              sub-commands.  */
 633           allow_unknown = PyObject_HasAttr (self, invoke_cst);
 634           cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype,
 635                                 NULL, docstring, &obj->sub_list,
 636                                 pfx_name, allow_unknown, cmd_list);
 637         }
 638       else
 639         cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL,
 640                        docstring, cmd_list);
 641
 642       /* There appears to be no API to set this.  */
 643       cmd->func = cmdpy_function;
 644       cmd->destroyer = cmdpy_destroyer;
 645
 646       obj->command = cmd;
 647       set_cmd_context (cmd, self);
 648       set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
 649                                : completers[completetype].completer));
 650       if (completetype == -1)
 651         set_cmd_completer_handle_brkchars (cmd,
 652                                            cmdpy_completer_handle_brkchars);
 653     }
 654   CATCH (except, RETURN_MASK_ALL)
 655     {
 656       xfree (cmd_name);
 657       xfree (docstring);
 658       xfree (pfx_name);
 659       Py_DECREF (self);
 660       PyErr_Format (except.reason == RETURN_QUIT
 661                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 662                     "%s", except.message);
 663       return -1;
 664     }
 665   END_CATCH
 666
 667   return 0;
 668 }
 669
 670 \f
 671
 672 /* Initialize the 'commands' code.  */
 673
 674 int
 675 gdbpy_initialize_commands (void)
 676 {
 677   int i;
 678
 679   cmdpy_object_type.tp_new = PyType_GenericNew;
 680   if (PyType_Ready (&cmdpy_object_type) < 0)
 681     return -1;
 682
 683   /* Note: alias and user are special; pseudo appears to be unused,
 684      and there is no reason to expose tui, I think.  */
 685   if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0
 686       || PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0
 687       || PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0
 688       || PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0
 689       || PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0
 690       || PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT",
 691                                   class_support) < 0
 692       || PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0
 693       || PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS",
 694                                   class_breakpoint) < 0
 695       || PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS",
 696                                   class_trace) < 0
 697       || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
 698                                   class_obscure) < 0
 699       || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
 700                                   class_maintenance) < 0
 701       || PyModule_AddIntConstant (gdb_module, "COMMAND_USER", class_user) < 0)
 702     return -1;
 703
 704   for (i = 0; i < N_COMPLETERS; ++i)
 705     {
 706       if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
 707         return -1;
 708     }
 709
 710   if (gdb_pymodule_addobject (gdb_module, "Command",
 711                               (PyObject *) &cmdpy_object_type) < 0)
 712     return -1;
 713
 714   invoke_cst = PyString_FromString ("invoke");
 715   if (invoke_cst == NULL)
 716     return -1;
 717   complete_cst = PyString_FromString ("complete");
 718   if (complete_cst == NULL)
 719     return -1;
 720
 721   return 0;
 722 }
 723
 724 \f
 725
 726 static PyMethodDef cmdpy_object_methods[] =
 727 {
 728   { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS,
 729     "Prevent command repetition when user enters empty line." },
 730
 731   { 0 }
 732 };
 733
 734 PyTypeObject cmdpy_object_type =
 735 {
 736   PyVarObject_HEAD_INIT (NULL, 0)
 737   "gdb.Command",                  /*tp_name*/
 738   sizeof (cmdpy_object),          /*tp_basicsize*/
 739   0,                              /*tp_itemsize*/
 740   0,                              /*tp_dealloc*/
 741   0,                              /*tp_print*/
 742   0,                              /*tp_getattr*/
 743   0,                              /*tp_setattr*/
 744   0,                              /*tp_compare*/
 745   0,                              /*tp_repr*/
 746   0,                              /*tp_as_number*/
 747   0,                              /*tp_as_sequence*/
 748   0,                              /*tp_as_mapping*/
 749   0,                              /*tp_hash */
 750   0,                              /*tp_call*/
 751   0,                              /*tp_str*/
 752   0,                              /*tp_getattro*/
 753   0,                              /*tp_setattro*/
 754   0,                              /*tp_as_buffer*/
 755   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 756   "GDB command object",           /* tp_doc */
 757   0,                              /* tp_traverse */
 758   0,                              /* tp_clear */
 759   0,                              /* tp_richcompare */
 760   0,                              /* tp_weaklistoffset */
 761   0,                              /* tp_iter */
 762   0,                              /* tp_iternext */
 763   cmdpy_object_methods,           /* tp_methods */
 764   0,                              /* tp_members */
 765   0,                              /* tp_getset */
 766   0,                              /* tp_base */
 767   0,                              /* tp_dict */
 768   0,                              /* tp_descr_get */
 769   0,                              /* tp_descr_set */
 770   0,                              /* tp_dictoffset */
 771   cmdpy_init,                     /* tp_init */
 772   0,                              /* tp_alloc */
 773 };
 774
 775 \f
 776
 777 /* Utility to build a buildargv-like result from ARGS.
 778    This intentionally parses arguments the way libiberty/argv.c:buildargv
 779    does.  It splits up arguments in a reasonable way, and we want a standard
 780    way of parsing arguments.  Several gdb commands use buildargv to parse their
 781    arguments.  Plus we want to be able to write compatible python
 782    implementations of gdb commands.  */
 783
 784 PyObject *
 785 gdbpy_string_to_argv (PyObject *self, PyObject *args)
 786 {
 787   PyObject *py_argv;
 788   const char *input;
 789
 790   if (!PyArg_ParseTuple (args, "s", &input))
 791     return NULL;
 792
 793   py_argv = PyList_New (0);
 794   if (py_argv == NULL)
 795     return NULL;
 796
 797   /* buildargv uses NULL to represent an empty argument list, but we can't use
 798      that in Python.  Instead, if ARGS is "" then return an empty list.
 799      This undoes the NULL -> "" conversion that cmdpy_function does.  */
 800
 801   if (*input != '\0')
 802     {
 803       char **c_argv = gdb_buildargv (input);
 804       int i;
 805
 806       for (i = 0; c_argv[i] != NULL; ++i)
 807         {
 808           PyObject *argp = PyString_FromString (c_argv[i]);
 809
 810           if (argp == NULL
 811               || PyList_Append (py_argv, argp) < 0)
 812             {
 813               Py_XDECREF (argp);
 814               Py_DECREF (py_argv);
 815               freeargv (c_argv);
 816               return NULL;
 817             }
 818           Py_DECREF (argp);
 819         }
 820
 821       freeargv (c_argv);
 822     }
 823
 824   return py_argv;
 825 }