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