gdb/python/py-cmd.c

   1 /* gdb commands implemented in Python
   2
   3    Copyright (C) 2008-2015 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      This isn't a const char * for Python 2.4's sake.
  36      PyModule_AddIntConstant only takes a char *, sigh.  */
  37   char *name;
  38   /* Completion function.  */
  39   completer_ftype *completer;
  40 };
  41
  42 static const struct cmdpy_completer completers[] =
  43 {
  44   { "COMPLETE_NONE", noop_completer },
  45   { "COMPLETE_FILENAME", filename_completer },
  46   { "COMPLETE_LOCATION", location_completer },
  47   { "COMPLETE_COMMAND", command_completer },
  48   { "COMPLETE_SYMBOL", make_symbol_completion_list_fn },
  49   { "COMPLETE_EXPRESSION", expression_completer },
  50 };
  51
  52 #define N_COMPLETERS (sizeof (completers) / sizeof (completers[0]))
  53
  54 /* A gdb command.  For the time being only ordinary commands (not
  55    set/show commands) are allowed.  */
  56 struct cmdpy_object
  57 {
  58   PyObject_HEAD
  59
  60   /* The corresponding gdb command object, or NULL if the command is
  61      no longer installed.  */
  62   struct cmd_list_element *command;
  63
  64   /* A prefix command requires storage for a list of its sub-commands.
  65      A pointer to this is passed to add_prefix_command, and to add_cmd
  66      for sub-commands of that prefix.  If this Command is not a prefix
  67      command, then this field is unused.  */
  68   struct cmd_list_element *sub_list;
  69 };
  70
  71 typedef struct cmdpy_object cmdpy_object;
  72
  73 static PyTypeObject cmdpy_object_type
  74     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("cmdpy_object");
  75
  76 /* Constants used by this module.  */
  77 static PyObject *invoke_cst;
  78 static PyObject *complete_cst;
  79
  80 \f
  81
  82 /* Python function which wraps dont_repeat.  */
  83 static PyObject *
  84 cmdpy_dont_repeat (PyObject *self, PyObject *args)
  85 {
  86   dont_repeat ();
  87   Py_RETURN_NONE;
  88 }
  89
  90 \f
  91
  92 /* Called if the gdb cmd_list_element is destroyed.  */
  93
  94 static void
  95 cmdpy_destroyer (struct cmd_list_element *self, void *context)
  96 {
  97   cmdpy_object *cmd;
  98   struct cleanup *cleanup;
  99
 100   cleanup = ensure_python_env (get_current_arch (), current_language);
 101
 102   /* Release our hold on the command object.  */
 103   cmd = (cmdpy_object *) context;
 104   cmd->command = NULL;
 105   Py_DECREF (cmd);
 106
 107   /* We allocated the name, doc string, and perhaps the prefix
 108      name.  */
 109   xfree ((char *) self->name);
 110   xfree ((char *) self->doc);
 111   xfree ((char *) self->prefixname);
 112
 113   do_cleanups (cleanup);
 114 }
 115
 116 /* Called by gdb to invoke the command.  */
 117
 118 static void
 119 cmdpy_function (struct cmd_list_element *command, char *args, int from_tty)
 120 {
 121   cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
 122   PyObject *argobj, *ttyobj, *result;
 123   struct cleanup *cleanup;
 124
 125   cleanup = ensure_python_env (get_current_arch (), current_language);
 126
 127   if (! obj)
 128     error (_("Invalid invocation of Python command object."));
 129   if (! PyObject_HasAttr ((PyObject *) obj, invoke_cst))
 130     {
 131       if (obj->command->prefixname)
 132         {
 133           /* A prefix command does not need an invoke method.  */
 134           do_cleanups (cleanup);
 135           return;
 136         }
 137       error (_("Python command object missing 'invoke' method."));
 138     }
 139
 140   if (! args)
 141     args = "";
 142   argobj = PyUnicode_Decode (args, strlen (args), host_charset (), NULL);
 143   if (! argobj)
 144     {
 145       gdbpy_print_stack ();
 146       error (_("Could not convert arguments to Python string."));
 147     }
 148
 149   ttyobj = from_tty ? Py_True : Py_False;
 150   Py_INCREF (ttyobj);
 151   result = PyObject_CallMethodObjArgs ((PyObject *) obj, invoke_cst, argobj,
 152                                        ttyobj, NULL);
 153   Py_DECREF (argobj);
 154   Py_DECREF (ttyobj);
 155
 156   if (! result)
 157     {
 158       PyObject *ptype, *pvalue, *ptraceback;
 159       char *msg;
 160
 161       PyErr_Fetch (&ptype, &pvalue, &ptraceback);
 162
 163       /* Try to fetch an error message contained within ptype, pvalue.
 164          When fetching the error message we need to make our own copy,
 165          we no longer own ptype, pvalue after the call to PyErr_Restore.  */
 166
 167       msg = gdbpy_exception_to_string (ptype, pvalue);
 168       make_cleanup (xfree, msg);
 169
 170       if (msg == NULL)
 171         {
 172           /* An error occurred computing the string representation of the
 173              error message.  This is rare, but we should inform the user.  */
 174           printf_filtered (_("An error occurred in a Python command\n"
 175                              "and then another occurred computing the "
 176                              "error message.\n"));
 177           gdbpy_print_stack ();
 178         }
 179
 180       /* Don't print the stack for gdb.GdbError exceptions.
 181          It is generally used to flag user errors.
 182
 183          We also don't want to print "Error occurred in Python command"
 184          for user errors.  However, a missing message for gdb.GdbError
 185          exceptions is arguably a bug, so we flag it as such.  */
 186
 187       if (! PyErr_GivenExceptionMatches (ptype, gdbpy_gdberror_exc)
 188           || msg == NULL || *msg == '\0')
 189         {
 190           PyErr_Restore (ptype, pvalue, ptraceback);
 191           gdbpy_print_stack ();
 192           if (msg != NULL && *msg != '\0')
 193             error (_("Error occurred in Python command: %s"), msg);
 194           else
 195             error (_("Error occurred in Python command."));
 196         }
 197       else
 198         {
 199           Py_XDECREF (ptype);
 200           Py_XDECREF (pvalue);
 201           Py_XDECREF (ptraceback);
 202           error ("%s", msg);
 203         }
 204     }
 205
 206   Py_DECREF (result);
 207   do_cleanups (cleanup);
 208 }
 209
 210 /* Helper function for the Python command completers (both "pure"
 211    completer and brkchar handler).  This function takes COMMAND, TEXT
 212    and WORD and tries to call the Python method for completion with
 213    these arguments.  It also takes HANDLE_BRKCHARS_P, an argument to
 214    identify whether it is being called from the brkchar handler or
 215    from the "pure" completer.  In the first case, it effectively calls
 216    the Python method for completion, and records the PyObject in a
 217    static variable (used as a "cache").  In the second case, it just
 218    returns that variable, without actually calling the Python method
 219    again.  This saves us one Python method call.
 220
 221    The reason for this two step dance is that we need to know the set
 222    of "brkchars" to use early on, before we actually try to perform
 223    the completion.  But if a Python command supplies a "complete"
 224    method then we have to call that method first: it may return as its
 225    result the kind of completion to perform and that will in turn
 226    specify which brkchars to use.  IOW, we need the result of the
 227    "complete" method before we actually perform the completion.
 228
 229    It is important to mention that this function is built on the
 230    assumption that the calls to cmdpy_completer_handle_brkchars and
 231    cmdpy_completer will be subsequent with nothing intervening.  This
 232    is true for our completer mechanism.
 233
 234    This function returns the PyObject representing the Python method
 235    call.  */
 236
 237 static PyObject *
 238 cmdpy_completer_helper (struct cmd_list_element *command,
 239                         const char *text, const char *word,
 240                         int handle_brkchars_p)
 241 {
 242   cmdpy_object *obj = (cmdpy_object *) get_cmd_context (command);
 243   PyObject *textobj, *wordobj;
 244   /* This static variable will server as a "cache" for us, in order to
 245      store the PyObject that results from calling the Python
 246      function.  */
 247   static PyObject *resultobj = NULL;
 248
 249   if (handle_brkchars_p)
 250     {
 251       /* If we were called to handle brkchars, it means this is the
 252          first function call of two that will happen in a row.
 253          Therefore, we need to call the completer ourselves, and cache
 254          the return value in the static variable RESULTOBJ.  Then, in
 255          the second call, we can just use the value of RESULTOBJ to do
 256          our job.  */
 257       if (resultobj != NULL)
 258         Py_DECREF (resultobj);
 259
 260       resultobj = NULL;
 261       if (obj == NULL)
 262         error (_("Invalid invocation of Python command object."));
 263       if (!PyObject_HasAttr ((PyObject *) obj, complete_cst))
 264         {
 265           /* If there is no complete method, don't error.  */
 266           return NULL;
 267         }
 268
 269       textobj = PyUnicode_Decode (text, strlen (text), host_charset (), NULL);
 270       if (textobj == NULL)
 271         error (_("Could not convert argument to Python string."));
 272       wordobj = PyUnicode_Decode (word, sizeof (word), host_charset (), NULL);
 273       if (wordobj == NULL)
 274         {
 275           Py_DECREF (textobj);
 276           error (_("Could not convert argument to Python string."));
 277         }
 278
 279       resultobj = PyObject_CallMethodObjArgs ((PyObject *) obj, complete_cst,
 280                                               textobj, wordobj, NULL);
 281       Py_DECREF (textobj);
 282       Py_DECREF (wordobj);
 283       if (!resultobj)
 284         {
 285           /* Just swallow errors here.  */
 286           PyErr_Clear ();
 287         }
 288
 289       Py_XINCREF (resultobj);
 290     }
 291
 292   return resultobj;
 293 }
 294
 295 /* Python function called to determine the break characters of a
 296    certain completer.  We are only interested in knowing if the
 297    completer registered by the user will return one of the integer
 298    codes (see COMPLETER_* symbols).  */
 299
 300 static void
 301 cmdpy_completer_handle_brkchars (struct cmd_list_element *command,
 302                                  const char *text, const char *word)
 303 {
 304   PyObject *resultobj = NULL;
 305   struct cleanup *cleanup;
 306
 307   cleanup = ensure_python_env (get_current_arch (), current_language);
 308
 309   /* Calling our helper to obtain the PyObject of the Python
 310      function.  */
 311   resultobj = cmdpy_completer_helper (command, text, word, 1);
 312
 313   /* Check if there was an error.  */
 314   if (resultobj == NULL)
 315     goto done;
 316
 317   if (PyInt_Check (resultobj))
 318     {
 319       /* User code may also return one of the completion constants,
 320          thus requesting that sort of completion.  We are only
 321          interested in this kind of return.  */
 322       long value;
 323
 324       if (!gdb_py_int_as_long (resultobj, &value))
 325         {
 326           /* Ignore.  */
 327           PyErr_Clear ();
 328         }
 329       else if (value >= 0 && value < (long) N_COMPLETERS)
 330         {
 331           /* This is the core of this function.  Depending on which
 332              completer type the Python function returns, we have to
 333              adjust the break characters accordingly.  */
 334           set_gdb_completion_word_break_characters
 335             (completers[value].completer);
 336         }
 337     }
 338
 339  done:
 340
 341   /* We do not call Py_XDECREF here because RESULTOBJ will be used in
 342      the subsequent call to cmdpy_completer function.  */
 343   do_cleanups (cleanup);
 344 }
 345
 346 /* Called by gdb for command completion.  */
 347
 348 static VEC (char_ptr) *
 349 cmdpy_completer (struct cmd_list_element *command,
 350                  const char *text, const char *word)
 351 {
 352   PyObject *resultobj = NULL;
 353   VEC (char_ptr) *result = NULL;
 354   struct cleanup *cleanup;
 355
 356   cleanup = ensure_python_env (get_current_arch (), current_language);
 357
 358   /* Calling our helper to obtain the PyObject of the Python
 359      function.  */
 360   resultobj = cmdpy_completer_helper (command, text, word, 0);
 361
 362   /* If the result object of calling the Python function is NULL, it
 363      means that there was an error.  In this case, just give up and
 364      return NULL.  */
 365   if (resultobj == NULL)
 366     goto done;
 367
 368   result = NULL;
 369   if (PyInt_Check (resultobj))
 370     {
 371       /* User code may also return one of the completion constants,
 372          thus requesting that sort of completion.  */
 373       long value;
 374
 375       if (! gdb_py_int_as_long (resultobj, &value))
 376         {
 377           /* Ignore.  */
 378           PyErr_Clear ();
 379         }
 380       else if (value >= 0 && value < (long) N_COMPLETERS)
 381         result = completers[value].completer (command, text, word);
 382     }
 383   else
 384     {
 385       PyObject *iter = PyObject_GetIter (resultobj);
 386       PyObject *elt;
 387
 388       if (iter == NULL)
 389         goto done;
 390
 391       while ((elt = PyIter_Next (iter)) != NULL)
 392         {
 393           char *item;
 394
 395           if (! gdbpy_is_string (elt))
 396             {
 397               /* Skip problem elements.  */
 398               Py_DECREF (elt);
 399               continue;
 400             }
 401           item = python_string_to_host_string (elt);
 402           Py_DECREF (elt);
 403           if (item == NULL)
 404             {
 405               /* Skip problem elements.  */
 406               PyErr_Clear ();
 407               continue;
 408             }
 409           VEC_safe_push (char_ptr, result, item);
 410         }
 411
 412       Py_DECREF (iter);
 413
 414       /* If we got some results, ignore problems.  Otherwise, report
 415          the problem.  */
 416       if (result != NULL && PyErr_Occurred ())
 417         PyErr_Clear ();
 418     }
 419
 420  done:
 421
 422   do_cleanups (cleanup);
 423
 424   return result;
 425 }
 426
 427 /* Helper for cmdpy_init which locates the command list to use and
 428    pulls out the command name.
 429
 430    NAME is the command name list.  The final word in the list is the
 431    name of the new command.  All earlier words must be existing prefix
 432    commands.
 433
 434    *BASE_LIST is set to the final prefix command's list of
 435    *sub-commands.
 436
 437    START_LIST is the list in which the search starts.
 438
 439    This function returns the xmalloc()d name of the new command.  On
 440    error sets the Python error and returns NULL.  */
 441
 442 char *
 443 gdbpy_parse_command_name (const char *name,
 444                           struct cmd_list_element ***base_list,
 445                           struct cmd_list_element **start_list)
 446 {
 447   struct cmd_list_element *elt;
 448   int len = strlen (name);
 449   int i, lastchar;
 450   char *prefix_text;
 451   const char *prefix_text2;
 452   char *result;
 453
 454   /* Skip trailing whitespace.  */
 455   for (i = len - 1; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
 456     ;
 457   if (i < 0)
 458     {
 459       PyErr_SetString (PyExc_RuntimeError, _("No command name found."));
 460       return NULL;
 461     }
 462   lastchar = i;
 463
 464   /* Find first character of the final word.  */
 465   for (; i > 0 && (isalnum (name[i - 1])
 466                    || name[i - 1] == '-'
 467                    || name[i - 1] == '_');
 468        --i)
 469     ;
 470   result = xmalloc (lastchar - i + 2);
 471   memcpy (result, &name[i], lastchar - i + 1);
 472   result[lastchar - i + 1] = '\0';
 473
 474   /* Skip whitespace again.  */
 475   for (--i; i >= 0 && (name[i] == ' ' || name[i] == '\t'); --i)
 476     ;
 477   if (i < 0)
 478     {
 479       *base_list = start_list;
 480       return result;
 481     }
 482
 483   prefix_text = xmalloc (i + 2);
 484   memcpy (prefix_text, name, i + 1);
 485   prefix_text[i + 1] = '\0';
 486
 487   prefix_text2 = prefix_text;
 488   elt = lookup_cmd_1 (&prefix_text2, *start_list, NULL, 1);
 489   if (elt == NULL || elt == CMD_LIST_AMBIGUOUS)
 490     {
 491       PyErr_Format (PyExc_RuntimeError, _("Could not find command prefix %s."),
 492                     prefix_text);
 493       xfree (prefix_text);
 494       xfree (result);
 495       return NULL;
 496     }
 497
 498   if (elt->prefixlist)
 499     {
 500       xfree (prefix_text);
 501       *base_list = elt->prefixlist;
 502       return result;
 503     }
 504
 505   PyErr_Format (PyExc_RuntimeError, _("'%s' is not a prefix command."),
 506                 prefix_text);
 507   xfree (prefix_text);
 508   xfree (result);
 509   return NULL;
 510 }
 511
 512 /* Object initializer; sets up gdb-side structures for command.
 513
 514    Use: __init__(NAME, COMMAND_CLASS [, COMPLETER_CLASS][, PREFIX]]).
 515
 516    NAME is the name of the command.  It may consist of multiple words,
 517    in which case the final word is the name of the new command, and
 518    earlier words must be prefix commands.
 519
 520    COMMAND_CLASS is the kind of command.  It should be one of the COMMAND_*
 521    constants defined in the gdb module.
 522
 523    COMPLETER_CLASS is the kind of completer.  If not given, the
 524    "complete" method will be used.  Otherwise, it should be one of the
 525    COMPLETE_* constants defined in the gdb module.
 526
 527    If PREFIX is True, then this command is a prefix command.
 528
 529    The documentation for the command is taken from the doc string for
 530    the python class.  */
 531
 532 static int
 533 cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
 534 {
 535   cmdpy_object *obj = (cmdpy_object *) self;
 536   const char *name;
 537   int cmdtype;
 538   int completetype = -1;
 539   char *docstring = NULL;
 540   volatile struct gdb_exception except;
 541   struct cmd_list_element **cmd_list;
 542   char *cmd_name, *pfx_name;
 543   static char *keywords[] = { "name", "command_class", "completer_class",
 544                               "prefix", NULL };
 545   PyObject *is_prefix = NULL;
 546   int cmp;
 547
 548   if (obj->command)
 549     {
 550       /* Note: this is apparently not documented in Python.  We return
 551          0 for success, -1 for failure.  */
 552       PyErr_Format (PyExc_RuntimeError,
 553                     _("Command object already initialized."));
 554       return -1;
 555     }
 556
 557   if (! PyArg_ParseTupleAndKeywords (args, kw, "si|iO",
 558                                      keywords, &name, &cmdtype,
 559                           &completetype, &is_prefix))
 560     return -1;
 561
 562   if (cmdtype != no_class && cmdtype != class_run
 563       && cmdtype != class_vars && cmdtype != class_stack
 564       && cmdtype != class_files && cmdtype != class_support
 565       && cmdtype != class_info && cmdtype != class_breakpoint
 566       && cmdtype != class_trace && cmdtype != class_obscure
 567       && cmdtype != class_maintenance && cmdtype != class_user)
 568     {
 569       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
 570       return -1;
 571     }
 572
 573   if (completetype < -1 || completetype >= (int) N_COMPLETERS)
 574     {
 575       PyErr_Format (PyExc_RuntimeError,
 576                     _("Invalid completion type argument."));
 577       return -1;
 578     }
 579
 580   cmd_name = gdbpy_parse_command_name (name, &cmd_list, &cmdlist);
 581   if (! cmd_name)
 582     return -1;
 583
 584   pfx_name = NULL;
 585   if (is_prefix != NULL)
 586     {
 587       cmp = PyObject_IsTrue (is_prefix);
 588       if (cmp == 1)
 589         {
 590           int i, out;
 591
 592           /* Make a normalized form of the command name.  */
 593           pfx_name = xmalloc (strlen (name) + 2);
 594
 595           i = 0;
 596           out = 0;
 597           while (name[i])
 598             {
 599               /* Skip whitespace.  */
 600               while (name[i] == ' ' || name[i] == '\t')
 601                 ++i;
 602               /* Copy non-whitespace characters.  */
 603               while (name[i] && name[i] != ' ' && name[i] != '\t')
 604                 pfx_name[out++] = name[i++];
 605               /* Add a single space after each word -- including the final
 606                  word.  */
 607               pfx_name[out++] = ' ';
 608             }
 609           pfx_name[out] = '\0';
 610         }
 611       else if (cmp < 0)
 612         {
 613           xfree (cmd_name);
 614           return -1;
 615         }
 616     }
 617   if (PyObject_HasAttr (self, gdbpy_doc_cst))
 618     {
 619       PyObject *ds_obj = PyObject_GetAttr (self, gdbpy_doc_cst);
 620
 621       if (ds_obj && gdbpy_is_string (ds_obj))
 622         {
 623           docstring = python_string_to_host_string (ds_obj);
 624           if (docstring == NULL)
 625             {
 626               xfree (cmd_name);
 627               xfree (pfx_name);
 628               Py_DECREF (ds_obj);
 629               return -1;
 630             }
 631         }
 632
 633       Py_XDECREF (ds_obj);
 634     }
 635   if (! docstring)
 636     docstring = xstrdup (_("This command is not documented."));
 637
 638   Py_INCREF (self);
 639
 640   TRY_CATCH (except, RETURN_MASK_ALL)
 641     {
 642       struct cmd_list_element *cmd;
 643
 644       if (pfx_name)
 645         {
 646           int allow_unknown;
 647
 648           /* If we have our own "invoke" method, then allow unknown
 649              sub-commands.  */
 650           allow_unknown = PyObject_HasAttr (self, invoke_cst);
 651           cmd = add_prefix_cmd (cmd_name, (enum command_class) cmdtype,
 652                                 NULL, docstring, &obj->sub_list,
 653                                 pfx_name, allow_unknown, cmd_list);
 654         }
 655       else
 656         cmd = add_cmd (cmd_name, (enum command_class) cmdtype, NULL,
 657                        docstring, cmd_list);
 658
 659       /* There appears to be no API to set this.  */
 660       cmd->func = cmdpy_function;
 661       cmd->destroyer = cmdpy_destroyer;
 662
 663       obj->command = cmd;
 664       set_cmd_context (cmd, self);
 665       set_cmd_completer (cmd, ((completetype == -1) ? cmdpy_completer
 666                                : completers[completetype].completer));
 667       if (completetype == -1)
 668         set_cmd_completer_handle_brkchars (cmd,
 669                                            cmdpy_completer_handle_brkchars);
 670     }
 671   if (except.reason < 0)
 672     {
 673       xfree (cmd_name);
 674       xfree (docstring);
 675       xfree (pfx_name);
 676       Py_DECREF (self);
 677       PyErr_Format (except.reason == RETURN_QUIT
 678                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 679                     "%s", except.message);
 680       return -1;
 681     }
 682   return 0;
 683 }
 684
 685 \f
 686
 687 /* Initialize the 'commands' code.  */
 688
 689 int
 690 gdbpy_initialize_commands (void)
 691 {
 692   int i;
 693
 694   cmdpy_object_type.tp_new = PyType_GenericNew;
 695   if (PyType_Ready (&cmdpy_object_type) < 0)
 696     return -1;
 697
 698   /* Note: alias and user are special; pseudo appears to be unused,
 699      and there is no reason to expose tui or xdb, I think.  */
 700   if (PyModule_AddIntConstant (gdb_module, "COMMAND_NONE", no_class) < 0
 701       || PyModule_AddIntConstant (gdb_module, "COMMAND_RUNNING", class_run) < 0
 702       || PyModule_AddIntConstant (gdb_module, "COMMAND_DATA", class_vars) < 0
 703       || PyModule_AddIntConstant (gdb_module, "COMMAND_STACK", class_stack) < 0
 704       || PyModule_AddIntConstant (gdb_module, "COMMAND_FILES", class_files) < 0
 705       || PyModule_AddIntConstant (gdb_module, "COMMAND_SUPPORT",
 706                                   class_support) < 0
 707       || PyModule_AddIntConstant (gdb_module, "COMMAND_STATUS", class_info) < 0
 708       || PyModule_AddIntConstant (gdb_module, "COMMAND_BREAKPOINTS",
 709                                   class_breakpoint) < 0
 710       || PyModule_AddIntConstant (gdb_module, "COMMAND_TRACEPOINTS",
 711                                   class_trace) < 0
 712       || PyModule_AddIntConstant (gdb_module, "COMMAND_OBSCURE",
 713                                   class_obscure) < 0
 714       || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
 715                                   class_maintenance) < 0
 716       || PyModule_AddIntConstant (gdb_module, "COMMAND_USER", class_user) < 0)
 717     return -1;
 718
 719   for (i = 0; i < N_COMPLETERS; ++i)
 720     {
 721       if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
 722         return -1;
 723     }
 724
 725   if (gdb_pymodule_addobject (gdb_module, "Command",
 726                               (PyObject *) &cmdpy_object_type) < 0)
 727     return -1;
 728
 729   invoke_cst = PyString_FromString ("invoke");
 730   if (invoke_cst == NULL)
 731     return -1;
 732   complete_cst = PyString_FromString ("complete");
 733   if (complete_cst == NULL)
 734     return -1;
 735
 736   return 0;
 737 }
 738
 739 \f
 740
 741 static PyMethodDef cmdpy_object_methods[] =
 742 {
 743   { "dont_repeat", cmdpy_dont_repeat, METH_NOARGS,
 744     "Prevent command repetition when user enters empty line." },
 745
 746   { 0 }
 747 };
 748
 749 static PyTypeObject cmdpy_object_type =
 750 {
 751   PyVarObject_HEAD_INIT (NULL, 0)
 752   "gdb.Command",                  /*tp_name*/
 753   sizeof (cmdpy_object),          /*tp_basicsize*/
 754   0,                              /*tp_itemsize*/
 755   0,                              /*tp_dealloc*/
 756   0,                              /*tp_print*/
 757   0,                              /*tp_getattr*/
 758   0,                              /*tp_setattr*/
 759   0,                              /*tp_compare*/
 760   0,                              /*tp_repr*/
 761   0,                              /*tp_as_number*/
 762   0,                              /*tp_as_sequence*/
 763   0,                              /*tp_as_mapping*/
 764   0,                              /*tp_hash */
 765   0,                              /*tp_call*/
 766   0,                              /*tp_str*/
 767   0,                              /*tp_getattro*/
 768   0,                              /*tp_setattro*/
 769   0,                              /*tp_as_buffer*/
 770   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 771   "GDB command object",           /* tp_doc */
 772   0,                              /* tp_traverse */
 773   0,                              /* tp_clear */
 774   0,                              /* tp_richcompare */
 775   0,                              /* tp_weaklistoffset */
 776   0,                              /* tp_iter */
 777   0,                              /* tp_iternext */
 778   cmdpy_object_methods,           /* tp_methods */
 779   0,                              /* tp_members */
 780   0,                              /* tp_getset */
 781   0,                              /* tp_base */
 782   0,                              /* tp_dict */
 783   0,                              /* tp_descr_get */
 784   0,                              /* tp_descr_set */
 785   0,                              /* tp_dictoffset */
 786   cmdpy_init,                     /* tp_init */
 787   0,                              /* tp_alloc */
 788 };
 789
 790 \f
 791
 792 /* Utility to build a buildargv-like result from ARGS.
 793    This intentionally parses arguments the way libiberty/argv.c:buildargv
 794    does.  It splits up arguments in a reasonable way, and we want a standard
 795    way of parsing arguments.  Several gdb commands use buildargv to parse their
 796    arguments.  Plus we want to be able to write compatible python
 797    implementations of gdb commands.  */
 798
 799 PyObject *
 800 gdbpy_string_to_argv (PyObject *self, PyObject *args)
 801 {
 802   PyObject *py_argv;
 803   const char *input;
 804
 805   if (!PyArg_ParseTuple (args, "s", &input))
 806     return NULL;
 807
 808   py_argv = PyList_New (0);
 809   if (py_argv == NULL)
 810     return NULL;
 811
 812   /* buildargv uses NULL to represent an empty argument list, but we can't use
 813      that in Python.  Instead, if ARGS is "" then return an empty list.
 814      This undoes the NULL -> "" conversion that cmdpy_function does.  */
 815
 816   if (*input != '\0')
 817     {
 818       char **c_argv = gdb_buildargv (input);
 819       int i;
 820
 821       for (i = 0; c_argv[i] != NULL; ++i)
 822         {
 823           PyObject *argp = PyString_FromString (c_argv[i]);
 824
 825           if (argp == NULL
 826               || PyList_Append (py_argv, argp) < 0)
 827             {
 828               Py_XDECREF (argp);
 829               Py_DECREF (py_argv);
 830               freeargv (c_argv);
 831               return NULL;
 832             }
 833           Py_DECREF (argp);
 834         }
 835
 836       freeargv (c_argv);
 837     }
 838
 839   return py_argv;
 840 }