gdb/python/py-cmd.c

   1 /* gdb commands implemented in Python
   2
   3    Copyright (C) 2008-2018 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   char *prefix_text;
 366   const char *prefix_text2;
 367   char *result;
 368
 369   /* Skip trailing whitespace.  */
 370   for (i = len - 1; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
 371     ;
 372   if (i < 0)
 373     {
 374       PyErr_SetString (PyExc_RuntimeError, _("No command name found."));
 375       return NULL;
 376     }
 377   lastchar = i;
 378
 379   /* Find first character of the final word.  */
 380   for (; i > 0 && (isalnum (name[i - 1])
 381                    || name[i - 1] == '-'
 382                    || name[i - 1] == '_');
 383        --i)
 384     ;
 385   result = (char *) xmalloc (lastchar - i + 2);
 386   memcpy (result, &name[i], lastchar - i + 1);
 387   result[lastchar - i + 1] = '\0';
 388
 389   /* Skip whitespace again.  */
 390   for (--i; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
 391     ;
 392   if (i < 0)
 393     {
 394       *base_list = start_list;
 395       return result;
 396     }
 397
 398   prefix_text = (char *) xmalloc (i + 2);
 399   memcpy (prefix_text, name, i + 1);
 400   prefix_text[i + 1] = '\0';
 401
 402   prefix_text2 = prefix_text;
 403   elt = lookup_cmd_1 (&prefix_text2, *start_list, NULL, 1);
 404   if (elt == NULL || elt == CMD_LIST_AMBIGUOUS)
 405     {
 406       PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."),
 407                     prefix_text);
 408       xfree (prefix_text);
 409       xfree (result);
 410       return NULL;
 411     }
 412
 413   if (elt->prefixlist)
 414     {
 415       xfree (prefix_text);
 416       *base_list = elt->prefixlist;
 417       return result;
 418     }
 419
 420   PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."),
 421                 prefix_text);
 422   xfree (prefix_text);
 423   xfree (result);
 424   return NULL;
 425 }
 426
 427 /* Object initializer; sets up gdb-side structures for command.
 428
 429    Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
 430
 431    NAME is the name of the command.  It may consist of multiple words,
 432    in which case the final word is the name of the new command, and
 433    earlier words must be prefix commands.
 434
 435    COMMAND_CLASS is the kind of command.  It should be one of the COMMAND_*
 436    constants defined in the gdb module.
 437
 438    COMPLETER_CLASS is the kind of completer.  If not given, the
 439    "complete" method will be used.  Otherwise, it should be one of the
 440    COMPLETE_* constants defined in the gdb module.
 441
 442    If PREFIX is True, then this command is a prefix command.
 443
 444    The documentation for the command is taken from the doc string for
 445    the python class.  */
 446
 447 static int
 448 cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
 449 {
 450   cmdpy_object *obj = (cmdpy_object *) self;
 451   const char *name;
 452   int cmdtype;
 453   int completetype = -1;
 454   char *docstring = NULL;
 455   struct cmd_list_element **cmd_list;
 456   char *cmd_name, *pfx_name;
 457   static const char *keywords[] = { "name", "command_class", "completer_class",
 458                                     "prefix", NULL };
 459   PyObject *is_prefix = NULL;
 460   int cmp;
 461
 462   if (obj->command)
 463     {
 464       /* Note: this is apparently not documented in Python.  We return
 465          0 for success, -1 for failure.  */
 466       PyErr_Format (PyExc_RuntimeError,
 467                     _("Command object already initialized."));
 468       return -1;
 469     }
 470
 471   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "si|iO",
 472                                         keywords, &name, &cmdtype,
 473                                         &completetype, &is_prefix))
 474     return -1;
 475
 476   if (cmdtype != no_class && cmdtype != class_run
 477       && cmdtype != class_vars && cmdtype != class_stack
 478       && cmdtype != class_files && cmdtype != class_support
 479       && cmdtype != class_info && cmdtype != class_breakpoint
 480       && cmdtype != class_trace && cmdtype != class_obscure
 481       && cmdtype != class_maintenance && cmdtype != class_user)
 482     {
 483       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
 484       return -1;
 485     }
 486
 487   if (completetype < -1 || completetype >= (int) N_COMPLETERS)
 488     {
 489       PyErr_Format (PyExc_RuntimeError,
 490                     _("Invalid completion type argument."));
 491       return -1;
 492     }
 493
 494   cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist);
 495   if (! cmd_name)
 496     return -1;
 497
 498   pfx_name = NULL;
 499   if (is_prefix != NULL)
 500     {
 501       cmp = PyObject_IsTrue (is_prefix);
 502       if (cmp == 1)
 503         {
 504           int i, out;
 505
 506           /* Make a normalized form of the command name.  */
 507           pfx_name = (char *) xmalloc (strlen (name) + 2);
 508
 509           i = 0;
 510           out = 0;
 511           while (name[i])
 512             {
 513               /* Skip whitespace.  */
 514               while (name[i] == ' ' || name[i] == '\t')
 515                 ++i;
 516               /* Copy non-whitespace characters.  */
 517               while (name[i] && name[i] != ' ' && name[i] != '\t')
 518                 pfx_name[out++] = name[i++];
 519               /* Add a single space after each word -- including the final
 520                  word.  */
 521               pfx_name[out++] = ' ';
 522             }
 523           pfx_name[out] = '\0';
 524         }
 525       else if (cmp < 0)
 526         {
 527           xfree (cmd_name);
 528           return -1;
 529         }
 530     }
 531   if (PyObject_HasAttr (self, gdbpy_doc_cst))
 532     {
 533       gdbpy_ref<> ds_obj (PyObject_GetAttr (self, gdbpy_doc_cst));
 534
 535       if (ds_obj != NULL && gdbpy_is_string (ds_obj.get ()))
 536         {
 537           docstring = python_string_to_host_string (ds_obj.get ()).release ();
 538           if (docstring == NULL)
 539             {
 540               xfree (cmd_name);
 541               xfree (pfx_name);
 542               return -1;
 543             }
 544         }
 545     }
 546   if (! docstring)
 547     docstring = xstrdup (_("This command is not documented."));
 548
 549   Py_INCREF (self);
 550
 551   TRY
 552     {
 553       struct cmd_list_element *cmd;
 554
 555       if (pfx_name)
 556         {
 557           int allow_unknown;
 558
 559           /* If we have our own "invoke" method, then allow unknown
 560              sub-commands.  */
 561           allow_unknown = PyObject_HasAttr (self, invoke_cst);
 562           cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype,
 563                                 NULL, docstring, &obj->sub_list,
 564                                 pfx_name, allow_unknown, cmd_list);
 565         }
 566       else
 567         cmd = add_cmd (cmd_name, (enum command_class) cmdtype,
 568                        docstring, cmd_list);
 569
 570       /* There appears to be no API to set this.  */
 571       cmd->func = cmdpy_function;
 572       cmd->destroyer = cmdpy_destroyer;
 573
 574       obj->command = cmd;
 575       set_cmd_context (cmd, self);
 576       set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
 577                                : completers[completetype].completer));
 578       if (completetype == -1)
 579         set_cmd_completer_handle_brkchars (cmd,
 580                                            cmdpy_completer_handle_brkchars);
 581     }
 582   CATCH (except, RETURN_MASK_ALL)
 583     {
 584       xfree (cmd_name);
 585       xfree (docstring);
 586       xfree (pfx_name);
 587       Py_DECREF (self);
 588       PyErr_Format (except.reason == RETURN_QUIT
 589                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 590                     "%s", except.message);
 591       return -1;
 592     }
 593   END_CATCH
 594
 595   return 0;
 596 }
 597
 598 \f
 599
 600 /* Initialize the 'commands' code.  */
 601
 602 int
 603 gdbpy_initialize_commands (void)
 604 {
 605   int i;
 606
 607   cmdpy_object_type.tp_new = PyType_GenericNew;
 608   if (PyType_Ready (&cmdpy_object_type) < 0)
 609     return -1;
 610
 611   /* Note: alias and user are special; pseudo appears to be unused,
 612      and there is no reason to expose tui, I think.  */
 613   if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0
 614       || PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0
 615       || PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0
 616       || PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0
 617       || PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0
 618       || PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT",
 619                                   class_support) < 0
 620       || PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0
 621       || PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS",
 622                                   class_breakpoint) < 0
 623       || PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS",
 624                                   class_trace) < 0
 625       || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
 626                                   class_obscure) < 0
 627       || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
 628                                   class_maintenance) < 0
 629       || PyModule_AddIntConstant (gdb_module, "COMMAND_USER", class_user) < 0)
 630     return -1;
 631
 632   for (i = 0; i < N_COMPLETERS; ++i)
 633     {
 634       if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
 635         return -1;
 636     }
 637
 638   if (gdb_pymodule_addobject (gdb_module, "Command",
 639                               (PyObject *) &cmdpy_object_type) < 0)
 640     return -1;
 641
 642   invoke_cst = PyString_FromString ("invoke");
 643   if (invoke_cst == NULL)
 644     return -1;
 645   complete_cst = PyString_FromString ("complete");
 646   if (complete_cst == NULL)
 647     return -1;
 648
 649   return 0;
 650 }
 651
 652 \f
 653
 654 static PyMethodDef cmdpy_object_methods[] =
 655 {
 656   { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS,
 657     "Prevent command repetition when user enters empty line." },
 658
 659   { 0 }
 660 };
 661
 662 PyTypeObject cmdpy_object_type =
 663 {
 664   PyVarObject_HEAD_INIT (NULL, 0)
 665   "gdb.Command",                  /*tp_name*/
 666   sizeof (cmdpy_object),          /*tp_basicsize*/
 667   0,                              /*tp_itemsize*/
 668   0,                              /*tp_dealloc*/
 669   0,                              /*tp_print*/
 670   0,                              /*tp_getattr*/
 671   0,                              /*tp_setattr*/
 672   0,                              /*tp_compare*/
 673   0,                              /*tp_repr*/
 674   0,                              /*tp_as_number*/
 675   0,                              /*tp_as_sequence*/
 676   0,                              /*tp_as_mapping*/
 677   0,                              /*tp_hash */
 678   0,                              /*tp_call*/
 679   0,                              /*tp_str*/
 680   0,                              /*tp_getattro*/
 681   0,                              /*tp_setattro*/
 682   0,                              /*tp_as_buffer*/
 683   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 684   "GDB command object",           /* tp_doc */
 685   0,                              /* tp_traverse */
 686   0,                              /* tp_clear */
 687   0,                              /* tp_richcompare */
 688   0,                              /* tp_weaklistoffset */
 689   0,                              /* tp_iter */
 690   0,                              /* tp_iternext */
 691   cmdpy_object_methods,           /* tp_methods */
 692   0,                              /* tp_members */
 693   0,                              /* tp_getset */
 694   0,                              /* tp_base */
 695   0,                              /* tp_dict */
 696   0,                              /* tp_descr_get */
 697   0,                              /* tp_descr_set */
 698   0,                              /* tp_dictoffset */
 699   cmdpy_init,                     /* tp_init */
 700   0,                              /* tp_alloc */
 701 };
 702
 703 \f
 704
 705 /* Utility to build a buildargv-like result from ARGS.
 706    This intentionally parses arguments the way libiberty/argv.c:buildargv
 707    does.  It splits up arguments in a reasonable way, and we want a standard
 708    way of parsing arguments.  Several gdb commands use buildargv to parse their
 709    arguments.  Plus we want to be able to write compatible python
 710    implementations of gdb commands.  */
 711
 712 PyObject *
 713 gdbpy_string_to_argv (PyObject *self, PyObject *args)
 714 {
 715   const char *input;
 716
 717   if (!PyArg_ParseTuple (args, "s", &input))
 718     return NULL;
 719
 720   gdbpy_ref<> py_argv (PyList_New (0));
 721   if (py_argv == NULL)
 722     return NULL;
 723
 724   /* buildargv uses NULL to represent an empty argument list, but we can't use
 725      that in Python.  Instead, if ARGS is "" then return an empty list.
 726      This undoes the NULL -> "" conversion that cmdpy_function does.  */
 727
 728   if (*input != '\0')
 729     {
 730       gdb_argv c_argv (input);
 731
 732       for (char *arg : c_argv)
 733         {
 734           gdbpy_ref<> argp (PyString_FromString (arg));
 735
 736           if (argp == NULL
 737               || PyList_Append (py_argv.get (), argp.get ()) < 0)
 738             return NULL;
 739         }
 740     }
 741
 742   return py_argv.release ();
 743 }