gdb/python/py-cmd.c

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