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