gdb/python/py-cmd.c

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