gdb/python/py-cmd.c

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