gdb/python/py-cmd.c

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