gdb/python/py-cmd.c

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