gdb/python/py-param.c

   1 /* GDB parameters implemented in Python
   2
   3    Copyright (C) 2008-2018 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         {
 400           gdbpy_print_stack ();
 401           return;
 402         }
 403     }
 404   else
 405     {
 406       /* We have to preserve the existing < GDB 7.3 API.  If a
 407          callback function does not exist, then attempt to read the
 408          set_doc attribute.  */
 409       set_doc_string  = get_doc_string (obj, set_doc_cst);
 410     }
 411
 412   fprintf_filtered (gdb_stdout, "%s\n", set_doc_string.get ());
 413 }
 414
 415 /* A callback function that is registered against the respective
 416    add_setshow_* show_doc prototype.  This function will either call
 417    the Python function "get_show_string" or extract the Python
 418    attribute "show_doc" and return the contents as a string.  If
 419    neither exist, insert a string indicating the Parameter is not
 420    documented.  */
 421 static void
 422 get_show_value (struct ui_file *file, int from_tty,
 423                 struct cmd_list_element *c,
 424                 const char *value)
 425 {
 426   PyObject *obj = (PyObject *) get_cmd_context (c);
 427   gdb::unique_xmalloc_ptr<char> show_doc_string;
 428
 429   gdbpy_enter enter_py (get_current_arch (), current_language);
 430   gdbpy_ref<> show_doc_func (PyString_FromString ("get_show_string"));
 431
 432   if (show_doc_func == NULL)
 433     {
 434       gdbpy_print_stack ();
 435       return;
 436     }
 437
 438   if (PyObject_HasAttr (obj, show_doc_func.get ()))
 439     {
 440       gdbpy_ref<> val_obj (PyString_FromString (value));
 441
 442       if (val_obj == NULL)
 443         {
 444           gdbpy_print_stack ();
 445           return;
 446         }
 447
 448       show_doc_string = call_doc_function (obj, show_doc_func.get (),
 449                                            val_obj.get ());
 450       if (! show_doc_string)
 451         {
 452           gdbpy_print_stack ();
 453           return;
 454         }
 455
 456       fprintf_filtered (file, "%s\n", show_doc_string.get ());
 457     }
 458   else
 459     {
 460       /* We have to preserve the existing < GDB 7.3 API.  If a
 461          callback function does not exist, then attempt to read the
 462          show_doc attribute.  */
 463       show_doc_string  = get_doc_string (obj, show_doc_cst);
 464       fprintf_filtered (file, "%s %s\n", show_doc_string.get (), value);
 465     }
 466 }
 467 \f
 468
 469 /* A helper function that dispatches to the appropriate add_setshow
 470    function.  */
 471 static void
 472 add_setshow_generic (int parmclass, enum command_class cmdclass,
 473                      char *cmd_name, parmpy_object *self,
 474                      char *set_doc, char *show_doc, char *help_doc,
 475                      struct cmd_list_element **set_list,
 476                      struct cmd_list_element **show_list)
 477 {
 478   struct cmd_list_element *param = NULL;
 479   const char *tmp_name = NULL;
 480
 481   switch (parmclass)
 482     {
 483     case var_boolean:
 484
 485       add_setshow_boolean_cmd (cmd_name, cmdclass,
 486                                &self->value.intval, set_doc, show_doc,
 487                                help_doc, get_set_value, get_show_value,
 488                                set_list, show_list);
 489
 490       break;
 491
 492     case var_auto_boolean:
 493       add_setshow_auto_boolean_cmd (cmd_name, cmdclass,
 494                                     &self->value.autoboolval,
 495                                     set_doc, show_doc, help_doc,
 496                                     get_set_value, get_show_value,
 497                                     set_list, show_list);
 498       break;
 499
 500     case var_uinteger:
 501       add_setshow_uinteger_cmd (cmd_name, cmdclass,
 502                                 &self->value.uintval, set_doc, show_doc,
 503                                 help_doc, get_set_value, get_show_value,
 504                                 set_list, show_list);
 505       break;
 506
 507     case var_integer:
 508       add_setshow_integer_cmd (cmd_name, cmdclass,
 509                                &self->value.intval, set_doc, show_doc,
 510                                help_doc, get_set_value, get_show_value,
 511                                set_list, show_list); break;
 512
 513     case var_string:
 514       add_setshow_string_cmd (cmd_name, cmdclass,
 515                               &self->value.stringval, set_doc, show_doc,
 516                               help_doc, get_set_value, get_show_value,
 517                               set_list, show_list); break;
 518
 519     case var_string_noescape:
 520       add_setshow_string_noescape_cmd (cmd_name, cmdclass,
 521                                        &self->value.stringval,
 522                                        set_doc, show_doc, help_doc,
 523                                        get_set_value, get_show_value,
 524                                        set_list, show_list);
 525
 526       break;
 527
 528     case var_optional_filename:
 529       add_setshow_optional_filename_cmd (cmd_name, cmdclass,
 530                                          &self->value.stringval, set_doc,
 531                                          show_doc, help_doc, get_set_value,
 532                                          get_show_value, set_list,
 533                                          show_list);
 534       break;
 535
 536     case var_filename:
 537       add_setshow_filename_cmd (cmd_name, cmdclass,
 538                                 &self->value.stringval, set_doc, show_doc,
 539                                 help_doc, get_set_value, get_show_value,
 540                                 set_list, show_list); break;
 541
 542     case var_zinteger:
 543       add_setshow_zinteger_cmd (cmd_name, cmdclass,
 544                                 &self->value.intval, 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:
 550       add_setshow_zuinteger_cmd (cmd_name, cmdclass,
 551                                 &self->value.uintval, set_doc, show_doc,
 552                                 help_doc, get_set_value, get_show_value,
 553                                 set_list, show_list);
 554       break;
 555
 556     case var_zuinteger_unlimited:
 557       add_setshow_zuinteger_unlimited_cmd (cmd_name, cmdclass,
 558                                            &self->value.intval, set_doc,
 559                                            show_doc, help_doc, get_set_value,
 560                                            get_show_value,
 561                                            set_list, show_list);
 562       break;
 563
 564     case var_enum:
 565       add_setshow_enum_cmd (cmd_name, cmdclass, self->enumeration,
 566                             &self->value.cstringval, set_doc, show_doc,
 567                             help_doc, get_set_value, get_show_value,
 568                             set_list, show_list);
 569       /* Initialize the value, just in case.  */
 570       self->value.cstringval = self->enumeration[0];
 571       break;
 572     }
 573
 574   /* Lookup created parameter, and register Python object against the
 575      parameter context.  Perform this task against both lists.  */
 576   tmp_name = cmd_name;
 577   param = lookup_cmd (&tmp_name, *show_list, "", 0, 1);
 578   if (param)
 579     set_cmd_context (param, self);
 580
 581   tmp_name = cmd_name;
 582   param = lookup_cmd (&tmp_name, *set_list, "", 0, 1);
 583   if (param)
 584     set_cmd_context (param, self);
 585 }
 586
 587 /* A helper which computes enum values.  Returns 1 on success.  Returns 0 on
 588    error, with a python exception set.  */
 589 static int
 590 compute_enum_values (parmpy_object *self, PyObject *enum_values)
 591 {
 592   Py_ssize_t size, i;
 593
 594   if (! enum_values)
 595     {
 596       PyErr_SetString (PyExc_RuntimeError,
 597                        _("An enumeration is required for PARAM_ENUM."));
 598       return 0;
 599     }
 600
 601   if (! PySequence_Check (enum_values))
 602     {
 603       PyErr_SetString (PyExc_RuntimeError,
 604                        _("The enumeration is not a sequence."));
 605       return 0;
 606     }
 607
 608   size = PySequence_Size (enum_values);
 609   if (size < 0)
 610     return 0;
 611   if (size == 0)
 612     {
 613       PyErr_SetString (PyExc_RuntimeError,
 614                        _("The enumeration is empty."));
 615       return 0;
 616     }
 617
 618   gdb_argv holder (XCNEWVEC (char *, size + 1));
 619   char **enumeration = holder.get ();
 620
 621   for (i = 0; i < size; ++i)
 622     {
 623       gdbpy_ref<> item (PySequence_GetItem (enum_values, i));
 624
 625       if (item == NULL)
 626         return 0;
 627       if (! gdbpy_is_string (item.get ()))
 628         {
 629           PyErr_SetString (PyExc_RuntimeError,
 630                            _("The enumeration item not a string."));
 631           return 0;
 632         }
 633       enumeration[i] = python_string_to_host_string (item.get ()).release ();
 634       if (enumeration[i] == NULL)
 635         return 0;
 636     }
 637
 638   self->enumeration = const_cast<const char**> (holder.release ());
 639   return 1;
 640 }
 641
 642 /* Object initializer; sets up gdb-side structures for command.
 643
 644    Use: __init__(NAME, CMDCLASS, PARMCLASS, [ENUM])
 645
 646    NAME is the name of the parameter.  It may consist of multiple
 647    words, in which case the final word is the name of the new command,
 648    and earlier words must be prefix commands.
 649
 650    CMDCLASS is the kind of command.  It should be one of the COMMAND_*
 651    constants defined in the gdb module.
 652
 653    PARMCLASS is the type of the parameter.  It should be one of the
 654    PARAM_* constants defined in the gdb module.
 655
 656    If PARMCLASS is PARAM_ENUM, then the final argument should be a
 657    collection of strings.  These strings are the valid values for this
 658    parameter.
 659
 660    The documentation for the parameter is taken from the doc string
 661    for the python class.
 662
 663    Returns -1 on error, with a python exception set.  */
 664
 665 static int
 666 parmpy_init (PyObject *self, PyObject *args, PyObject *kwds)
 667 {
 668   parmpy_object *obj = (parmpy_object *) self;
 669   const char *name;
 670   char *set_doc, *show_doc, *doc;
 671   char *cmd_name;
 672   int parmclass, cmdtype;
 673   PyObject *enum_values = NULL;
 674   struct cmd_list_element **set_list, **show_list;
 675
 676   if (! PyArg_ParseTuple (args, "sii|O", &name, &cmdtype, &parmclass,
 677                           &enum_values))
 678     return -1;
 679
 680   if (cmdtype != no_class && cmdtype != class_run
 681       && cmdtype != class_vars && cmdtype != class_stack
 682       && cmdtype != class_files && cmdtype != class_support
 683       && cmdtype != class_info && cmdtype != class_breakpoint
 684       && cmdtype != class_trace && cmdtype != class_obscure
 685       && cmdtype != class_maintenance)
 686     {
 687       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
 688       return -1;
 689     }
 690
 691   if (parmclass != var_boolean /* ARI: var_boolean */
 692       && parmclass != var_auto_boolean
 693       && parmclass != var_uinteger && parmclass != var_integer
 694       && parmclass != var_string && parmclass != var_string_noescape
 695       && parmclass != var_optional_filename && parmclass != var_filename
 696       && parmclass != var_zinteger && parmclass != var_zuinteger
 697       && parmclass != var_zuinteger_unlimited && parmclass != var_enum)
 698     {
 699       PyErr_SetString (PyExc_RuntimeError,
 700                        _("Invalid parameter class argument."));
 701       return -1;
 702     }
 703
 704   if (enum_values && parmclass != var_enum)
 705     {
 706       PyErr_SetString (PyExc_RuntimeError,
 707                        _("Only PARAM_ENUM accepts a fourth argument."));
 708       return -1;
 709     }
 710   if (parmclass == var_enum)
 711     {
 712       if (! compute_enum_values (obj, enum_values))
 713         return -1;
 714     }
 715   else
 716     obj->enumeration = NULL;
 717   obj->type = (enum var_types) parmclass;
 718   memset (&obj->value, 0, sizeof (obj->value));
 719
 720   cmd_name = gdbpy_parse_command_name (name, &set_list,
 721                                        &setlist);
 722
 723   if (! cmd_name)
 724     return -1;
 725   xfree (cmd_name);
 726   cmd_name = gdbpy_parse_command_name (name, &show_list,
 727                                        &showlist);
 728   if (! cmd_name)
 729     return -1;
 730
 731   set_doc = get_doc_string (self, set_doc_cst).release ();
 732   show_doc = get_doc_string (self, show_doc_cst).release ();
 733   doc = get_doc_string (self, gdbpy_doc_cst).release ();
 734
 735   Py_INCREF (self);
 736
 737   TRY
 738     {
 739       add_setshow_generic (parmclass, (enum command_class) cmdtype,
 740                            cmd_name, obj,
 741                            set_doc, show_doc,
 742                            doc, set_list, show_list);
 743     }
 744   CATCH (except, RETURN_MASK_ALL)
 745     {
 746       xfree (cmd_name);
 747       xfree (set_doc);
 748       xfree (show_doc);
 749       xfree (doc);
 750       Py_DECREF (self);
 751       PyErr_Format (except.reason == RETURN_QUIT
 752                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 753                     "%s", except.message);
 754       return -1;
 755     }
 756   END_CATCH
 757
 758   return 0;
 759 }
 760
 761 \f
 762
 763 /* Initialize the 'parameters' module.  */
 764 int
 765 gdbpy_initialize_parameters (void)
 766 {
 767   int i;
 768
 769   parmpy_object_type.tp_new = PyType_GenericNew;
 770   if (PyType_Ready (&parmpy_object_type) < 0)
 771     return -1;
 772
 773   set_doc_cst = PyString_FromString ("set_doc");
 774   if (! set_doc_cst)
 775     return -1;
 776   show_doc_cst = PyString_FromString ("show_doc");
 777   if (! show_doc_cst)
 778     return -1;
 779
 780   for (i = 0; parm_constants[i].name; ++i)
 781     {
 782       if (PyModule_AddIntConstant (gdb_module,
 783                                    parm_constants[i].name,
 784                                    parm_constants[i].value) < 0)
 785         return -1;
 786     }
 787
 788   return gdb_pymodule_addobject (gdb_module, "Parameter",
 789                                  (PyObject *) &parmpy_object_type);
 790 }
 791
 792 \f
 793
 794 PyTypeObject parmpy_object_type =
 795 {
 796   PyVarObject_HEAD_INIT (NULL, 0)
 797   "gdb.Parameter",                /*tp_name*/
 798   sizeof (parmpy_object),         /*tp_basicsize*/
 799   0,                              /*tp_itemsize*/
 800   0,                              /*tp_dealloc*/
 801   0,                              /*tp_print*/
 802   0,                              /*tp_getattr*/
 803   0,                              /*tp_setattr*/
 804   0,                              /*tp_compare*/
 805   0,                              /*tp_repr*/
 806   0,                              /*tp_as_number*/
 807   0,                              /*tp_as_sequence*/
 808   0,                              /*tp_as_mapping*/
 809   0,                              /*tp_hash */
 810   0,                              /*tp_call*/
 811   0,                              /*tp_str*/
 812   get_attr,                       /*tp_getattro*/
 813   set_attr,                       /*tp_setattro*/
 814   0,                              /*tp_as_buffer*/
 815   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 816   "GDB parameter object",         /* tp_doc */
 817   0,                              /* tp_traverse */
 818   0,                              /* tp_clear */
 819   0,                              /* tp_richcompare */
 820   0,                              /* tp_weaklistoffset */
 821   0,                              /* tp_iter */
 822   0,                              /* tp_iternext */
 823   0,                              /* tp_methods */
 824   0,                              /* tp_members */
 825   0,                              /* tp_getset */
 826   0,                              /* tp_base */
 827   0,                              /* tp_dict */
 828   0,                              /* tp_descr_get */
 829   0,                              /* tp_descr_set */
 830   0,                              /* tp_dictoffset */
 831   parmpy_init,                    /* tp_init */
 832   0,                              /* tp_alloc */
 833 };