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