gdb/python/py-cmd.c

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