gdb/python/py-param.c

   1 /* GDB parameters implemented in Python
   2
   3    Copyright (C) 2008-2019 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 "value.h"
  23 #include "python-internal.h"
  24 #include "charset.h"
  25 #include "gdbcmd.h"
  26 #include "cli/cli-decode.h"
  27 #include "completer.h"
  28 #include "language.h"
  29 #include "arch-utils.h"
  30 #include "py-ref.h"
  31
  32 /* Parameter constants and their values.  */
  33 struct parm_constant
  34 {
  35   const char *name;
  36   int value;
  37 };
  38
  39 struct parm_constant parm_constants[] =
  40 {
  41   { "PARAM_BOOLEAN", var_boolean }, /* ARI: var_boolean */
  42   { "PARAM_AUTO_BOOLEAN", var_auto_boolean },
  43   { "PARAM_UINTEGER", var_uinteger },
  44   { "PARAM_INTEGER", var_integer },
  45   { "PARAM_STRING", var_string },
  46   { "PARAM_STRING_NOESCAPE", var_string_noescape },
  47   { "PARAM_OPTIONAL_FILENAME", var_optional_filename },
  48   { "PARAM_FILENAME", var_filename },
  49   { "PARAM_ZINTEGER", var_zinteger },
  50   { "PARAM_ZUINTEGER", var_zuinteger },
  51   { "PARAM_ZUINTEGER_UNLIMITED", var_zuinteger_unlimited },
  52   { "PARAM_ENUM", var_enum },
  53   { NULL, 0 }
  54 };
  55
  56 /* A union that can hold anything described by enum var_types.  */
  57 union parmpy_variable
  58 {
  59   /* Hold an integer value, for boolean and integer types.  */
  60   int intval;
  61
  62   /* Hold an auto_boolean.  */
  63   enum auto_boolean autoboolval;
  64
  65   /* Hold an unsigned integer value, for uinteger.  */
  66   unsigned int uintval;
  67
  68   /* Hold a string, for the various string types.  */
  69   char *stringval;
  70
  71   /* Hold a string, for enums.  */
  72   const char *cstringval;
  73 };
  74
  75 /* A GDB parameter.  */
  76 struct parmpy_object
  77 {
  78   PyObject_HEAD
  79
  80   /* The type of the parameter.  */
  81   enum var_types type;
  82
  83   /* The value of the parameter.  */
  84   union parmpy_variable value;
  85
  86   /* For an enum command, the possible values.  The vector is
  87      allocated with xmalloc, as is each element.  It is
  88      NULL-terminated.  */
  89   const char **enumeration;
  90 };
  91
  92 typedef struct parmpy_object parmpy_object;
  93
  94 extern PyTypeObject parmpy_object_type
  95     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("parmpy_object");
  96
  97 /* Some handy string constants.  */
  98 static PyObject *set_doc_cst;
  99 static PyObject *show_doc_cst;
 100
 101 \f
 102
 103 /* Get an attribute.  */
 104 static PyObject *
 105 get_attr (PyObject *obj, PyObject *attr_name)
 106 {
 107   if (PyString_Check (attr_name)
 108 #ifdef IS_PY3K
 109       && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
 110 #else
 111       && ! strcmp (PyString_AsString (attr_name), "value"))
 112 #endif
 113     {
 114       parmpy_object *self = (parmpy_object *) obj;
 115
 116       return gdbpy_parameter_value (self->type, &self->value);
 117     }
 118
 119   return PyObject_GenericGetAttr (obj, attr_name);
 120 }
 121
 122 /* Set a parameter value from a Python value.  Return 0 on success.  Returns
 123    -1 on error, with a python exception set.  */
 124 static int
 125 set_parameter_value (parmpy_object *self, PyObject *value)
 126 {
 127   int cmp;
 128
 129   switch (self->type)
 130     {
 131     case var_string:
 132     case var_string_noescape:
 133     case var_optional_filename:
 134     case var_filename:
 135       if (! gdbpy_is_string (value)
 136           && (self->type == var_filename
 137               || value != Py_None))
 138         {
 139           PyErr_SetString (PyExc_RuntimeError,
 140                            _("String required for filename."));
 141
 142           return -1;
 143         }
 144       if (value == Py_None)
 145         {
 146           xfree (self->value.stringval);
 147           if (self->type == var_optional_filename)
 148             self->value.stringval = xstrdup ("");
 149           else
 150             self->value.stringval = NULL;
 151         }
 152       else
 153         {
 154           gdb::unique_xmalloc_ptr<char>
 155             string (python_string_to_host_string (value));
 156           if (string == NULL)
 157             return -1;
 158
 159           xfree (self->value.stringval);
 160           self->value.stringval = string.release ();
 161         }
 162       break;
 163
 164     case var_enum:
 165       {
 166         int i;
 167
 168         if (! gdbpy_is_string (value))
 169           {
 170             PyErr_SetString (PyExc_RuntimeError,
 171                              _("ENUM arguments must be a string."));
 172             return -1;
 173           }
 174
 175         gdb::unique_xmalloc_ptr<char>
 176           str (python_string_to_host_string (value));
 177         if (str == NULL)
 178           return -1;
 179         for (i = 0; self->enumeration[i]; ++i)
 180           if (! strcmp (self->enumeration[i], str.get ()))
 181             break;
 182         if (! self->enumeration[i])
 183           {
 184             PyErr_SetString (PyExc_RuntimeError,
 185                              _("The value must be member of an enumeration."));
 186             return -1;
 187           }
 188         self->value.cstringval = self->enumeration[i];
 189         break;
 190       }
 191
 192     case var_boolean:
 193       if (! PyBool_Check (value))
 194         {
 195           PyErr_SetString (PyExc_RuntimeError,
 196                            _("A boolean argument is required."));
 197           return -1;
 198         }
 199       cmp = PyObject_IsTrue (value);
 200       if (cmp < 0)
 201           return -1;
 202       self->value.intval = cmp;
 203       break;
 204
 205     case var_auto_boolean:
 206       if (! PyBool_Check (value) && value != Py_None)
 207         {
 208           PyErr_SetString (PyExc_RuntimeError,
 209                            _("A boolean or None is required"));
 210           return -1;
 211         }
 212
 213       if (value == Py_None)
 214         self->value.autoboolval = AUTO_BOOLEAN_AUTO;
 215       else
 216         {
 217           cmp = PyObject_IsTrue (value);
 218           if (cmp < 0 )
 219             return -1;
 220           if (cmp == 1)
 221             self->value.autoboolval = AUTO_BOOLEAN_TRUE;
 222           else
 223             self->value.autoboolval = AUTO_BOOLEAN_FALSE;
 224         }
 225       break;
 226
 227     case var_integer:
 228     case var_zinteger:
 229     case var_uinteger:
 230     case var_zuinteger:
 231     case var_zuinteger_unlimited:
 232       {
 233         long l;
 234         int ok;
 235
 236         if (! PyInt_Check (value))
 237           {
 238             PyErr_SetString (PyExc_RuntimeError,
 239                              _("The value must be integer."));
 240             return -1;
 241           }
 242
 243         if (! gdb_py_int_as_long (value, &l))
 244           return -1;
 245
 246         switch (self->type)
 247           {
 248           case var_uinteger:
 249             if (l == 0)
 250               l = UINT_MAX;
 251             /* Fall through.  */
 252           case var_zuinteger:
 253             ok = (l >= 0 && l <= UINT_MAX);
 254             break;
 255
 256           case var_zuinteger_unlimited:
 257             ok = (l >= -1 && l <= INT_MAX);
 258             break;
 259
 260           case var_integer:
 261             ok = (l >= INT_MIN && l <= INT_MAX);
 262             if (l == 0)
 263               l = INT_MAX;
 264             break;
 265
 266           case var_zinteger:
 267             ok = (l >= INT_MIN && l <= INT_MAX);
 268             break;
 269
 270           default:
 271             gdb_assert_not_reached ("unknown var_ constant");
 272           }
 273
 274         if (! ok)
 275           {
 276             PyErr_SetString (PyExc_RuntimeError,
 277                              _("Range exceeded."));
 278             return -1;
 279           }
 280
 281         if (self->type == var_uinteger || self->type == var_zuinteger)
 282           self->value.uintval = (unsigned) l;
 283         else
 284           self->value.intval = (int) l;
 285         break;
 286       }
 287
 288     default:
 289       PyErr_SetString (PyExc_RuntimeError,
 290                        _("Unhandled type in parameter value."));
 291       return -1;
 292     }
 293
 294   return 0;
 295 }
 296
 297 /* Set an attribute.  Returns -1 on error, with a python exception set.  */
 298 static int
 299 set_attr (PyObject *obj, PyObject *attr_name, PyObject *val)
 300 {
 301   if (PyString_Check (attr_name)
 302 #ifdef IS_PY3K
 303       && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
 304 #else
 305       && ! strcmp (PyString_AsString (attr_name), "value"))
 306 #endif
 307     {
 308       if (!val)
 309         {
 310           PyErr_SetString (PyExc_RuntimeError,
 311                            _("Cannot delete a parameter's value."));
 312           return -1;
 313         }
 314       return set_parameter_value ((parmpy_object *) obj, val);
 315     }
 316
 317   return PyObject_GenericSetAttr (obj, attr_name, val);
 318 }
 319
 320 /* A helper function which returns a documentation string for an
 321    object. */
 322
 323 static gdb::unique_xmalloc_ptr<char>
 324 get_doc_string (PyObject *object, PyObject *attr)
 325 {
 326   gdb::unique_xmalloc_ptr<char> result;
 327
 328   if (PyObject_HasAttr (object, attr))
 329     {
 330       gdbpy_ref<> ds_obj (PyObject_GetAttr (object, attr));
 331
 332       if (ds_obj != NULL && gdbpy_is_string (ds_obj.get ()))
 333         {
 334           result = python_string_to_host_string (ds_obj.get ());
 335           if (result == NULL)
 336             gdbpy_print_stack ();
 337         }
 338     }
 339   if (! result)
 340     result.reset (xstrdup (_("This command is not documented.")));
 341   return result;
 342 }
 343
 344 /* Helper function which will execute a METHOD in OBJ passing the
 345    argument ARG.  ARG can be NULL.  METHOD should return a Python
 346    string.  If this function returns NULL, there has been an error and
 347    the appropriate exception set.  */
 348 static gdb::unique_xmalloc_ptr<char>
 349 call_doc_function (PyObject *obj, PyObject *method, PyObject *arg)
 350 {
 351   gdb::unique_xmalloc_ptr<char> data;
 352   gdbpy_ref<> result (PyObject_CallMethodObjArgs (obj, method, arg, NULL));
 353
 354   if (result == NULL)
 355     return NULL;
 356
 357   if (gdbpy_is_string (result.get ()))
 358     {
 359       data = python_string_to_host_string (result.get ());
 360       if (! data)
 361         return NULL;
 362     }
 363   else
 364     {
 365       PyErr_SetString (PyExc_RuntimeError,
 366                        _("Parameter must return a string value."));
 367       return NULL;
 368     }
 369
 370   return data;
 371 }
 372
 373 /* A callback function that is registered against the respective
 374    add_setshow_* set_doc prototype.  This function will either call
 375    the Python function "get_set_string" or extract the Python
 376    attribute "set_doc" and return the contents as a string.  If
 377    neither exist, insert a string indicating the Parameter is not
 378    documented.  */
 379 static void
 380 get_set_value (const char *args, int from_tty,
 381                struct cmd_list_element *c)
 382 {
 383   PyObject *obj = (PyObject *) get_cmd_context (c);
 384   gdb::unique_xmalloc_ptr<char> set_doc_string;
 385
 386   gdbpy_enter enter_py (get_current_arch (), current_language);
 387   gdbpy_ref<> set_doc_func (PyString_FromString ("get_set_string"));
 388
 389   if (set_doc_func == NULL)
 390     {
 391       gdbpy_print_stack ();
 392       return;
 393     }
 394
 395   if (PyObject_HasAttr (obj, set_doc_func.get ()))
 396     {
 397       set_doc_string = call_doc_function (obj, set_doc_func.get (), NULL);
 398       if (! set_doc_string)
 399         gdbpy_handle_exception ();
 400     }
 401
 402   const char *str = set_doc_string.get ();
 403   if (str != nullptr && str[0] != '\0')
 404     fprintf_filtered (gdb_stdout, "%s\n", str);
 405 }
 406
 407 /* A callback function that is registered against the respective
 408    add_setshow_* show_doc prototype.  This function will either call
 409    the Python function "get_show_string" or extract the Python
 410    attribute "show_doc" and return the contents as a string.  If
 411    neither exist, insert a string indicating the Parameter is not
 412    documented.  */
 413 static void
 414 get_show_value (struct ui_file *file, int from_tty,
 415                 struct cmd_list_element *c,
 416                 const char *value)
 417 {
 418   PyObject *obj = (PyObject *) get_cmd_context (c);
 419   gdb::unique_xmalloc_ptr<char> show_doc_string;
 420
 421   gdbpy_enter enter_py (get_current_arch (), current_language);
 422   gdbpy_ref<> show_doc_func (PyString_FromString ("get_show_string"));
 423
 424   if (show_doc_func == NULL)
 425     {
 426       gdbpy_print_stack ();
 427       return;
 428     }
 429
 430   if (PyObject_HasAttr (obj, show_doc_func.get ()))
 431     {
 432       gdbpy_ref<> val_obj (PyString_FromString (value));
 433
 434       if (val_obj == NULL)
 435         {
 436           gdbpy_print_stack ();
 437           return;
 438         }
 439
 440       show_doc_string = call_doc_function (obj, show_doc_func.get (),
 441                                            val_obj.get ());
 442       if (! show_doc_string)
 443         {
 444           gdbpy_print_stack ();
 445           return;
 446         }
 447
 448       fprintf_filtered (file, "%s\n", show_doc_string.get ());
 449     }
 450   else
 451     {
 452       /* We have to preserve the existing < GDB 7.3 API.  If a
 453          callback function does not exist, then attempt to read the
 454          show_doc attribute.  */
 455       show_doc_string  = get_doc_string (obj, show_doc_cst);
 456       fprintf_filtered (file, "%s %s\n", show_doc_string.get (), value);
 457     }
 458 }
 459 \f
 460
 461 /* A helper function that dispatches to the appropriate add_setshow
 462    function.  */
 463 static void
 464 add_setshow_generic (int parmclass, enum command_class cmdclass,
 465                      const char *cmd_name, parmpy_object *self,
 466                      const char *set_doc, const char *show_doc,
 467                      const char *help_doc,
 468                      struct cmd_list_element **set_list,
 469                      struct cmd_list_element **show_list)
 470 {
 471   struct cmd_list_element *param = NULL;
 472   const char *tmp_name = NULL;
 473
 474   switch (parmclass)
 475     {
 476     case var_boolean:
 477
 478       add_setshow_boolean_cmd (cmd_name, cmdclass,
 479                                &self->value.intval, set_doc, show_doc,
 480                                help_doc, get_set_value, get_show_value,
 481                                set_list, show_list);
 482
 483       break;
 484
 485     case var_auto_boolean:
 486       add_setshow_auto_boolean_cmd (cmd_name, cmdclass,
 487                                     &self->value.autoboolval,
 488                                     set_doc, show_doc, help_doc,
 489                                     get_set_value, get_show_value,
 490                                     set_list, show_list);
 491       break;
 492
 493     case var_uinteger:
 494       add_setshow_uinteger_cmd (cmd_name, cmdclass,
 495                                 &self->value.uintval, set_doc, show_doc,
 496                                 help_doc, get_set_value, get_show_value,
 497                                 set_list, show_list);
 498       break;
 499
 500     case var_integer:
 501       add_setshow_integer_cmd (cmd_name, cmdclass,
 502                                &self->value.intval, set_doc, show_doc,
 503                                help_doc, get_set_value, get_show_value,
 504                                set_list, show_list); break;
 505
 506     case var_string:
 507       add_setshow_string_cmd (cmd_name, cmdclass,
 508                               &self->value.stringval, set_doc, show_doc,
 509                               help_doc, get_set_value, get_show_value,
 510                               set_list, show_list); break;
 511
 512     case var_string_noescape:
 513       add_setshow_string_noescape_cmd (cmd_name, cmdclass,
 514                                        &self->value.stringval,
 515                                        set_doc, show_doc, help_doc,
 516                                        get_set_value, get_show_value,
 517                                        set_list, show_list);
 518
 519       break;
 520
 521     case var_optional_filename:
 522       add_setshow_optional_filename_cmd (cmd_name, cmdclass,
 523                                          &self->value.stringval, set_doc,
 524                                          show_doc, help_doc, get_set_value,
 525                                          get_show_value, set_list,
 526                                          show_list);
 527       break;
 528
 529     case var_filename:
 530       add_setshow_filename_cmd (cmd_name, cmdclass,
 531                                 &self->value.stringval, set_doc, show_doc,
 532                                 help_doc, get_set_value, get_show_value,
 533                                 set_list, show_list); break;
 534
 535     case var_zinteger:
 536       add_setshow_zinteger_cmd (cmd_name, cmdclass,
 537                                 &self->value.intval, set_doc, show_doc,
 538                                 help_doc, get_set_value, get_show_value,
 539                                 set_list, show_list);
 540       break;
 541
 542     case var_zuinteger:
 543       add_setshow_zuinteger_cmd (cmd_name, cmdclass,
 544                                 &self->value.uintval, set_doc, show_doc,
 545                                 help_doc, get_set_value, get_show_value,
 546                                 set_list, show_list);
 547       break;
 548
 549     case var_zuinteger_unlimited:
 550       add_setshow_zuinteger_unlimited_cmd (cmd_name, cmdclass,
 551                                            &self->value.intval, set_doc,
 552                                            show_doc, help_doc, get_set_value,
 553                                            get_show_value,
 554                                            set_list, show_list);
 555       break;
 556
 557     case var_enum:
 558       add_setshow_enum_cmd (cmd_name, cmdclass, self->enumeration,
 559                             &self->value.cstringval, set_doc, show_doc,
 560                             help_doc, get_set_value, get_show_value,
 561                             set_list, show_list);
 562       /* Initialize the value, just in case.  */
 563       self->value.cstringval = self->enumeration[0];
 564       break;
 565     }
 566
 567   /* Lookup created parameter, and register Python object against the
 568      parameter context.  Perform this task against both lists.  */
 569   tmp_name = cmd_name;
 570   param = lookup_cmd (&tmp_name, *show_list, "", 0, 1);
 571   if (param)
 572     set_cmd_context (param, self);
 573
 574   tmp_name = cmd_name;
 575   param = lookup_cmd (&tmp_name, *set_list, "", 0, 1);
 576   if (param)
 577     set_cmd_context (param, self);
 578 }
 579
 580 /* A helper which computes enum values.  Returns 1 on success.  Returns 0 on
 581    error, with a python exception set.  */
 582 static int
 583 compute_enum_values (parmpy_object *self, PyObject *enum_values)
 584 {
 585   Py_ssize_t size, i;
 586
 587   if (! enum_values)
 588     {
 589       PyErr_SetString (PyExc_RuntimeError,
 590                        _("An enumeration is required for PARAM_ENUM."));
 591       return 0;
 592     }
 593
 594   if (! PySequence_Check (enum_values))
 595     {
 596       PyErr_SetString (PyExc_RuntimeError,
 597                        _("The enumeration is not a sequence."));
 598       return 0;
 599     }
 600
 601   size = PySequence_Size (enum_values);
 602   if (size < 0)
 603     return 0;
 604   if (size == 0)
 605     {
 606       PyErr_SetString (PyExc_RuntimeError,
 607                        _("The enumeration is empty."));
 608       return 0;
 609     }
 610
 611   gdb_argv holder (XCNEWVEC (char *, size + 1));
 612   char **enumeration = holder.get ();
 613
 614   for (i = 0; i < size; ++i)
 615     {
 616       gdbpy_ref<> item (PySequence_GetItem (enum_values, i));
 617
 618       if (item == NULL)
 619         return 0;
 620       if (! gdbpy_is_string (item.get ()))
 621         {
 622           PyErr_SetString (PyExc_RuntimeError,
 623                            _("The enumeration item not a string."));
 624           return 0;
 625         }
 626       enumeration[i] = python_string_to_host_string (item.get ()).release ();
 627       if (enumeration[i] == NULL)
 628         return 0;
 629     }
 630
 631   self->enumeration = const_cast<const char**> (holder.release ());
 632   return 1;
 633 }
 634
 635 /* Object initializer; sets up gdb-side structures for command.
 636
 637    Use: __init__(NAME, CMDCLASS, PARMCLASS, [ENUM])
 638
 639    NAME is the name of the parameter.  It may consist of multiple
 640    words, in which case the final word is the name of the new command,
 641    and earlier words must be prefix commands.
 642
 643    CMDCLASS is the kind of command.  It should be one of the COMMAND_*
 644    constants defined in the gdb module.
 645
 646    PARMCLASS is the type of the parameter.  It should be one of the
 647    PARAM_* constants defined in the gdb module.
 648
 649    If PARMCLASS is PARAM_ENUM, then the final argument should be a
 650    collection of strings.  These strings are the valid values for this
 651    parameter.
 652
 653    The documentation for the parameter is taken from the doc string
 654    for the python class.
 655
 656    Returns -1 on error, with a python exception set.  */
 657
 658 static int
 659 parmpy_init (PyObject *self, PyObject *args, PyObject *kwds)
 660 {
 661   parmpy_object *obj = (parmpy_object *) self;
 662   const char *name;
 663   gdb::unique_xmalloc_ptr<char> set_doc, show_doc, doc;
 664   char *cmd_name;
 665   int parmclass, cmdtype;
 666   PyObject *enum_values = NULL;
 667   struct cmd_list_element **set_list, **show_list;
 668
 669   if (! PyArg_ParseTuple (args, "sii|O", &name, &cmdtype, &parmclass,
 670                           &enum_values))
 671     return -1;
 672
 673   if (cmdtype != no_class && cmdtype != class_run
 674       && cmdtype != class_vars && cmdtype != class_stack
 675       && cmdtype != class_files && cmdtype != class_support
 676       && cmdtype != class_info && cmdtype != class_breakpoint
 677       && cmdtype != class_trace && cmdtype != class_obscure
 678       && cmdtype != class_maintenance)
 679     {
 680       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
 681       return -1;
 682     }
 683
 684   if (parmclass != var_boolean /* ARI: var_boolean */
 685       && parmclass != var_auto_boolean
 686       && parmclass != var_uinteger && parmclass != var_integer
 687       && parmclass != var_string && parmclass != var_string_noescape
 688       && parmclass != var_optional_filename && parmclass != var_filename
 689       && parmclass != var_zinteger && parmclass != var_zuinteger
 690       && parmclass != var_zuinteger_unlimited && parmclass != var_enum)
 691     {
 692       PyErr_SetString (PyExc_RuntimeError,
 693                        _("Invalid parameter class argument."));
 694       return -1;
 695     }
 696
 697   if (enum_values && parmclass != var_enum)
 698     {
 699       PyErr_SetString (PyExc_RuntimeError,
 700                        _("Only PARAM_ENUM accepts a fourth argument."));
 701       return -1;
 702     }
 703   if (parmclass == var_enum)
 704     {
 705       if (! compute_enum_values (obj, enum_values))
 706         return -1;
 707     }
 708   else
 709     obj->enumeration = NULL;
 710   obj->type = (enum var_types) parmclass;
 711   memset (&obj->value, 0, sizeof (obj->value));
 712
 713   cmd_name = gdbpy_parse_command_name (name, &set_list,
 714                                        &setlist);
 715
 716   if (! cmd_name)
 717     return -1;
 718   xfree (cmd_name);
 719   cmd_name = gdbpy_parse_command_name (name, &show_list,
 720                                        &showlist);
 721   if (! cmd_name)
 722     return -1;
 723
 724   set_doc = get_doc_string (self, set_doc_cst);
 725   show_doc = get_doc_string (self, show_doc_cst);
 726   doc = get_doc_string (self, gdbpy_doc_cst);
 727
 728   Py_INCREF (self);
 729
 730   TRY
 731     {
 732       add_setshow_generic (parmclass, (enum command_class) cmdtype,
 733                            cmd_name, obj,
 734                            set_doc.get (), show_doc.get (),
 735                            doc.get (), set_list, show_list);
 736     }
 737   CATCH (except, RETURN_MASK_ALL)
 738     {
 739       xfree (cmd_name);
 740       Py_DECREF (self);
 741       gdbpy_convert_exception (except);
 742       return -1;
 743     }
 744   END_CATCH
 745
 746   return 0;
 747 }
 748
 749 \f
 750
 751 /* Initialize the 'parameters' module.  */
 752 int
 753 gdbpy_initialize_parameters (void)
 754 {
 755   int i;
 756
 757   parmpy_object_type.tp_new = PyType_GenericNew;
 758   if (PyType_Ready (&parmpy_object_type) < 0)
 759     return -1;
 760
 761   set_doc_cst = PyString_FromString ("set_doc");
 762   if (! set_doc_cst)
 763     return -1;
 764   show_doc_cst = PyString_FromString ("show_doc");
 765   if (! show_doc_cst)
 766     return -1;
 767
 768   for (i = 0; parm_constants[i].name; ++i)
 769     {
 770       if (PyModule_AddIntConstant (gdb_module,
 771                                    parm_constants[i].name,
 772                                    parm_constants[i].value) < 0)
 773         return -1;
 774     }
 775
 776   return gdb_pymodule_addobject (gdb_module, "Parameter",
 777                                  (PyObject *) &parmpy_object_type);
 778 }
 779
 780 \f
 781
 782 PyTypeObject parmpy_object_type =
 783 {
 784   PyVarObject_HEAD_INIT (NULL, 0)
 785   "gdb.Parameter",                /*tp_name*/
 786   sizeof (parmpy_object),         /*tp_basicsize*/
 787   0,                              /*tp_itemsize*/
 788   0,                              /*tp_dealloc*/
 789   0,                              /*tp_print*/
 790   0,                              /*tp_getattr*/
 791   0,                              /*tp_setattr*/
 792   0,                              /*tp_compare*/
 793   0,                              /*tp_repr*/
 794   0,                              /*tp_as_number*/
 795   0,                              /*tp_as_sequence*/
 796   0,                              /*tp_as_mapping*/
 797   0,                              /*tp_hash */
 798   0,                              /*tp_call*/
 799   0,                              /*tp_str*/
 800   get_attr,                       /*tp_getattro*/
 801   set_attr,                       /*tp_setattro*/
 802   0,                              /*tp_as_buffer*/
 803   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 804   "GDB parameter object",         /* tp_doc */
 805   0,                              /* tp_traverse */
 806   0,                              /* tp_clear */
 807   0,                              /* tp_richcompare */
 808   0,                              /* tp_weaklistoffset */
 809   0,                              /* tp_iter */
 810   0,                              /* tp_iternext */
 811   0,                              /* tp_methods */
 812   0,                              /* tp_members */
 813   0,                              /* tp_getset */
 814   0,                              /* tp_base */
 815   0,                              /* tp_dict */
 816   0,                              /* tp_descr_get */
 817   0,                              /* tp_descr_set */
 818   0,                              /* tp_dictoffset */
 819   parmpy_init,                    /* tp_init */
 820   0,                              /* tp_alloc */
 821 };