gdb/python/py-param.c

   1 /* GDB parameters implemented in Python
   2
   3    Copyright (C) 2008-2016 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   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_ENUM", var_enum },
  50   { NULL, 0 }
  51 };
  52
  53 /* A union that can hold anything described by enum var_types.  */
  54 union parmpy_variable
  55 {
  56   /* Hold an integer value, for boolean and integer types.  */
  57   int intval;
  58
  59   /* Hold an auto_boolean.  */
  60   enum auto_boolean autoboolval;
  61
  62   /* Hold an unsigned integer value, for uinteger.  */
  63   unsigned int uintval;
  64
  65   /* Hold a string, for the various string types.  */
  66   char *stringval;
  67
  68   /* Hold a string, for enums.  */
  69   const char *cstringval;
  70 };
  71
  72 /* A GDB parameter.  */
  73 struct parmpy_object
  74 {
  75   PyObject_HEAD
  76
  77   /* The type of the parameter.  */
  78   enum var_types type;
  79
  80   /* The value of the parameter.  */
  81   union parmpy_variable value;
  82
  83   /* For an enum command, the possible values.  The vector is
  84      allocated with xmalloc, as is each element.  It is
  85      NULL-terminated.  */
  86   const char **enumeration;
  87 };
  88
  89 typedef struct parmpy_object parmpy_object;
  90
  91 extern PyTypeObject parmpy_object_type
  92     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("parmpy_object");
  93
  94 /* Some handy string constants.  */
  95 static PyObject *set_doc_cst;
  96 static PyObject *show_doc_cst;
  97
  98 \f
  99
 100 /* Get an attribute.  */
 101 static PyObject *
 102 get_attr (PyObject *obj, PyObject *attr_name)
 103 {
 104   if (PyString_Check (attr_name)
 105 #ifdef IS_PY3K
 106       && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
 107 #else
 108       && ! strcmp (PyString_AsString (attr_name), "value"))
 109 #endif
 110     {
 111       parmpy_object *self = (parmpy_object *) obj;
 112
 113       return gdbpy_parameter_value (self->type, &self->value);
 114     }
 115
 116   return PyObject_GenericGetAttr (obj, attr_name);
 117 }
 118
 119 /* Set a parameter value from a Python value.  Return 0 on success.  Returns
 120    -1 on error, with a python exception set.  */
 121 static int
 122 set_parameter_value (parmpy_object *self, PyObject *value)
 123 {
 124   int cmp;
 125
 126   switch (self->type)
 127     {
 128     case var_string:
 129     case var_string_noescape:
 130     case var_optional_filename:
 131     case var_filename:
 132       if (! gdbpy_is_string (value)
 133           && (self->type == var_filename
 134               || value != Py_None))
 135         {
 136           PyErr_SetString (PyExc_RuntimeError,
 137                            _("String required for filename."));
 138
 139           return -1;
 140         }
 141       if (value == Py_None)
 142         {
 143           xfree (self->value.stringval);
 144           if (self->type == var_optional_filename)
 145             self->value.stringval = xstrdup ("");
 146           else
 147             self->value.stringval = NULL;
 148         }
 149       else
 150         {
 151           char *string;
 152
 153           string = python_string_to_host_string (value);
 154           if (string == NULL)
 155             return -1;
 156
 157           xfree (self->value.stringval);
 158           self->value.stringval = string;
 159         }
 160       break;
 161
 162     case var_enum:
 163       {
 164         int i;
 165         char *str;
 166
 167         if (! gdbpy_is_string (value))
 168           {
 169             PyErr_SetString (PyExc_RuntimeError,
 170                              _("ENUM arguments must be a string."));
 171             return -1;
 172           }
 173
 174         str = python_string_to_host_string (value);
 175         if (str == NULL)
 176           return -1;
 177         for (i = 0; self->enumeration[i]; ++i)
 178           if (! strcmp (self->enumeration[i], str))
 179             break;
 180         xfree (str);
 181         if (! self->enumeration[i])
 182           {
 183             PyErr_SetString (PyExc_RuntimeError,
 184                              _("The value must be member of an enumeration."));
 185             return -1;
 186           }
 187         self->value.cstringval = self->enumeration[i];
 188         break;
 189       }
 190
 191     case var_boolean:
 192       if (! PyBool_Check (value))
 193         {
 194           PyErr_SetString (PyExc_RuntimeError,
 195                            _("A boolean argument is required."));
 196           return -1;
 197         }
 198       cmp = PyObject_IsTrue (value);
 199       if (cmp < 0)
 200           return -1;
 201       self->value.intval = cmp;
 202       break;
 203
 204     case var_auto_boolean:
 205       if (! PyBool_Check (value) && value != Py_None)
 206         {
 207           PyErr_SetString (PyExc_RuntimeError,
 208                            _("A boolean or None is required"));
 209           return -1;
 210         }
 211
 212       if (value == Py_None)
 213         self->value.autoboolval = AUTO_BOOLEAN_AUTO;
 214       else
 215         {
 216           cmp = PyObject_IsTrue (value);
 217           if (cmp < 0 )
 218             return -1;
 219           if (cmp == 1)
 220             self->value.autoboolval = AUTO_BOOLEAN_TRUE;
 221           else
 222             self->value.autoboolval = AUTO_BOOLEAN_FALSE;
 223         }
 224       break;
 225
 226     case var_integer:
 227     case var_zinteger:
 228     case var_uinteger:
 229       {
 230         long l;
 231         int ok;
 232
 233         if (! PyInt_Check (value))
 234           {
 235             PyErr_SetString (PyExc_RuntimeError,
 236                              _("The value must be integer."));
 237             return -1;
 238           }
 239
 240         if (! gdb_py_int_as_long (value, &l))
 241           return -1;
 242
 243         if (self->type == var_uinteger)
 244           {
 245             ok = (l >= 0 && l <= UINT_MAX);
 246             if (l == 0)
 247               l = UINT_MAX;
 248           }
 249         else if (self->type == var_integer)
 250           {
 251             ok = (l >= INT_MIN && l <= INT_MAX);
 252             if (l == 0)
 253               l = INT_MAX;
 254           }
 255         else
 256           ok = (l >= INT_MIN && l <= INT_MAX);
 257
 258         if (! ok)
 259           {
 260             PyErr_SetString (PyExc_RuntimeError,
 261                              _("Range exceeded."));
 262             return -1;
 263           }
 264
 265         self->value.intval = (int) l;
 266         break;
 267       }
 268
 269     default:
 270       PyErr_SetString (PyExc_RuntimeError,
 271                        _("Unhandled type in parameter value."));
 272       return -1;
 273     }
 274
 275   return 0;
 276 }
 277
 278 /* Set an attribute.  Returns -1 on error, with a python exception set.  */
 279 static int
 280 set_attr (PyObject *obj, PyObject *attr_name, PyObject *val)
 281 {
 282   if (PyString_Check (attr_name)
 283 #ifdef IS_PY3K
 284       && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
 285 #else
 286       && ! strcmp (PyString_AsString (attr_name), "value"))
 287 #endif
 288     {
 289       if (!val)
 290         {
 291           PyErr_SetString (PyExc_RuntimeError,
 292                            _("Cannot delete a parameter's value."));
 293           return -1;
 294         }
 295       return set_parameter_value ((parmpy_object *) obj, val);
 296     }
 297
 298   return PyObject_GenericSetAttr (obj, attr_name, val);
 299 }
 300
 301 /* A helper function which returns a documentation string for an
 302    object. */
 303
 304 static char *
 305 get_doc_string (PyObject *object, PyObject *attr)
 306 {
 307   char *result = NULL;
 308
 309   if (PyObject_HasAttr (object, attr))
 310     {
 311       PyObject *ds_obj = PyObject_GetAttr (object, attr);
 312
 313       if (ds_obj && gdbpy_is_string (ds_obj))
 314         {
 315           result = python_string_to_host_string (ds_obj);
 316           if (result == NULL)
 317             gdbpy_print_stack ();
 318         }
 319       Py_XDECREF (ds_obj);
 320     }
 321   if (! result)
 322     result = xstrdup (_("This command is not documented."));
 323   return result;
 324 }
 325
 326 /* Helper function which will execute a METHOD in OBJ passing the
 327    argument ARG.  ARG can be NULL.  METHOD should return a Python
 328    string.  If this function returns NULL, there has been an error and
 329    the appropriate exception set.  */
 330 static char *
 331 call_doc_function (PyObject *obj, PyObject *method, PyObject *arg)
 332 {
 333   char *data = NULL;
 334   PyObject *result = PyObject_CallMethodObjArgs (obj, method, arg, NULL);
 335
 336   if (! result)
 337     return NULL;
 338
 339   if (gdbpy_is_string (result))
 340     {
 341       data = python_string_to_host_string (result);
 342       Py_DECREF (result);
 343       if (! data)
 344         return NULL;
 345     }
 346   else
 347     {
 348       PyErr_SetString (PyExc_RuntimeError,
 349                        _("Parameter must return a string value."));
 350       Py_DECREF (result);
 351       return NULL;
 352     }
 353
 354   return data;
 355 }
 356
 357 /* A callback function that is registered against the respective
 358    add_setshow_* set_doc prototype.  This function will either call
 359    the Python function "get_set_string" or extract the Python
 360    attribute "set_doc" and return the contents as a string.  If
 361    neither exist, insert a string indicating the Parameter is not
 362    documented.  */
 363 static void
 364 get_set_value (char *args, int from_tty,
 365                struct cmd_list_element *c)
 366 {
 367   PyObject *obj = (PyObject *) get_cmd_context (c);
 368   char *set_doc_string;
 369   struct cleanup *cleanup = ensure_python_env (get_current_arch (),
 370                                                current_language);
 371   PyObject *set_doc_func = PyString_FromString ("get_set_string");
 372
 373   if (! set_doc_func)
 374     goto error;
 375
 376   if (PyObject_HasAttr (obj, set_doc_func))
 377     {
 378       set_doc_string = call_doc_function (obj, set_doc_func, NULL);
 379       if (! set_doc_string)
 380         goto error;
 381     }
 382   else
 383     {
 384       /* We have to preserve the existing < GDB 7.3 API.  If a
 385          callback function does not exist, then attempt to read the
 386          set_doc attribute.  */
 387       set_doc_string  = get_doc_string (obj, set_doc_cst);
 388     }
 389
 390   make_cleanup (xfree, set_doc_string);
 391   fprintf_filtered (gdb_stdout, "%s\n", set_doc_string);
 392
 393   Py_XDECREF (set_doc_func);
 394   do_cleanups (cleanup);
 395   return;
 396
 397  error:
 398   Py_XDECREF (set_doc_func);
 399   gdbpy_print_stack ();
 400   do_cleanups (cleanup);
 401   return;
 402 }
 403
 404 /* A callback function that is registered against the respective
 405    add_setshow_* show_doc prototype.  This function will either call
 406    the Python function "get_show_string" or extract the Python
 407    attribute "show_doc" and return the contents as a string.  If
 408    neither exist, insert a string indicating the Parameter is not
 409    documented.  */
 410 static void
 411 get_show_value (struct ui_file *file, int from_tty,
 412                 struct cmd_list_element *c,
 413                 const char *value)
 414 {
 415   PyObject *obj = (PyObject *) get_cmd_context (c);
 416   char *show_doc_string = NULL;
 417   struct cleanup *cleanup = ensure_python_env (get_current_arch (),
 418                                                current_language);
 419   PyObject *show_doc_func = PyString_FromString ("get_show_string");
 420
 421   if (! show_doc_func)
 422     goto error;
 423
 424   if (PyObject_HasAttr (obj, show_doc_func))
 425     {
 426       PyObject *val_obj = PyString_FromString (value);
 427
 428       if (! val_obj)
 429         goto error;
 430
 431       show_doc_string = call_doc_function (obj, show_doc_func, val_obj);
 432       Py_DECREF (val_obj);
 433       if (! show_doc_string)
 434         goto error;
 435
 436       make_cleanup (xfree, show_doc_string);
 437
 438       fprintf_filtered (file, "%s\n", show_doc_string);
 439     }
 440   else
 441     {
 442       /* We have to preserve the existing < GDB 7.3 API.  If a
 443          callback function does not exist, then attempt to read the
 444          show_doc attribute.  */
 445       show_doc_string  = get_doc_string (obj, show_doc_cst);
 446       make_cleanup (xfree, show_doc_string);
 447       fprintf_filtered (file, "%s %s\n", show_doc_string, value);
 448     }
 449
 450   Py_XDECREF (show_doc_func);
 451   do_cleanups (cleanup);
 452   return;
 453
 454  error:
 455   Py_XDECREF (show_doc_func);
 456   gdbpy_print_stack ();
 457   do_cleanups (cleanup);
 458   return;
 459 }
 460 \f
 461
 462 /* A helper function that dispatches to the appropriate add_setshow
 463    function.  */
 464 static void
 465 add_setshow_generic (int parmclass, enum command_class cmdclass,
 466                      char *cmd_name, parmpy_object *self,
 467                      char *set_doc, char *show_doc, 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_enum:
 543       add_setshow_enum_cmd (cmd_name, cmdclass, self->enumeration,
 544                             &self->value.cstringval, set_doc, show_doc,
 545                             help_doc, get_set_value, get_show_value,
 546                             set_list, show_list);
 547       /* Initialize the value, just in case.  */
 548       self->value.cstringval = self->enumeration[0];
 549       break;
 550     }
 551
 552   /* Lookup created parameter, and register Python object against the
 553      parameter context.  Perform this task against both lists.  */
 554   tmp_name = cmd_name;
 555   param = lookup_cmd (&tmp_name, *show_list, "", 0, 1);
 556   if (param)
 557     set_cmd_context (param, self);
 558
 559   tmp_name = cmd_name;
 560   param = lookup_cmd (&tmp_name, *set_list, "", 0, 1);
 561   if (param)
 562     set_cmd_context (param, self);
 563 }
 564
 565 /* A helper which computes enum values.  Returns 1 on success.  Returns 0 on
 566    error, with a python exception set.  */
 567 static int
 568 compute_enum_values (parmpy_object *self, PyObject *enum_values)
 569 {
 570   Py_ssize_t size, i;
 571   struct cleanup *back_to;
 572
 573   if (! enum_values)
 574     {
 575       PyErr_SetString (PyExc_RuntimeError,
 576                        _("An enumeration is required for PARAM_ENUM."));
 577       return 0;
 578     }
 579
 580   if (! PySequence_Check (enum_values))
 581     {
 582       PyErr_SetString (PyExc_RuntimeError,
 583                        _("The enumeration is not a sequence."));
 584       return 0;
 585     }
 586
 587   size = PySequence_Size (enum_values);
 588   if (size < 0)
 589     return 0;
 590   if (size == 0)
 591     {
 592       PyErr_SetString (PyExc_RuntimeError,
 593                        _("The enumeration is empty."));
 594       return 0;
 595     }
 596
 597   self->enumeration = XCNEWVEC (const char *, size + 1);
 598   back_to = make_cleanup (free_current_contents, &self->enumeration);
 599
 600   for (i = 0; i < size; ++i)
 601     {
 602       PyObject *item = PySequence_GetItem (enum_values, i);
 603
 604       if (! item)
 605         {
 606           do_cleanups (back_to);
 607           return 0;
 608         }
 609       if (! gdbpy_is_string (item))
 610         {
 611           Py_DECREF (item);
 612           do_cleanups (back_to);
 613           PyErr_SetString (PyExc_RuntimeError,
 614                            _("The enumeration item not a string."));
 615           return 0;
 616         }
 617       self->enumeration[i] = python_string_to_host_string (item);
 618       Py_DECREF (item);
 619       if (self->enumeration[i] == NULL)
 620         {
 621           do_cleanups (back_to);
 622           return 0;
 623         }
 624       make_cleanup (xfree, (char *) self->enumeration[i]);
 625     }
 626
 627   discard_cleanups (back_to);
 628   return 1;
 629 }
 630
 631 /* Object initializer; sets up gdb-side structures for command.
 632
 633    Use: __init__(NAME, CMDCLASS, PARMCLASS, [ENUM])
 634
 635    NAME is the name of the parameter.  It may consist of multiple
 636    words, in which case the final word is the name of the new command,
 637    and earlier words must be prefix commands.
 638
 639    CMDCLASS is the kind of command.  It should be one of the COMMAND_*
 640    constants defined in the gdb module.
 641
 642    PARMCLASS is the type of the parameter.  It should be one of the
 643    PARAM_* constants defined in the gdb module.
 644
 645    If PARMCLASS is PARAM_ENUM, then the final argument should be a
 646    collection of strings.  These strings are the valid values for this
 647    parameter.
 648
 649    The documentation for the parameter is taken from the doc string
 650    for the python class.
 651
 652    Returns -1 on error, with a python exception set.  */
 653
 654 static int
 655 parmpy_init (PyObject *self, PyObject *args, PyObject *kwds)
 656 {
 657   parmpy_object *obj = (parmpy_object *) self;
 658   const char *name;
 659   char *set_doc, *show_doc, *doc;
 660   char *cmd_name;
 661   int parmclass, cmdtype;
 662   PyObject *enum_values = NULL;
 663   struct cmd_list_element **set_list, **show_list;
 664
 665   if (! PyArg_ParseTuple (args, "sii|O", &name, &cmdtype, &parmclass,
 666                           &enum_values))
 667     return -1;
 668
 669   if (cmdtype != no_class && cmdtype != class_run
 670       && cmdtype != class_vars && cmdtype != class_stack
 671       && cmdtype != class_files && cmdtype != class_support
 672       && cmdtype != class_info && cmdtype != class_breakpoint
 673       && cmdtype != class_trace && cmdtype != class_obscure
 674       && cmdtype != class_maintenance)
 675     {
 676       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
 677       return -1;
 678     }
 679
 680   if (parmclass != var_boolean /* ARI: var_boolean */
 681       && parmclass != var_auto_boolean
 682       && parmclass != var_uinteger && parmclass != var_integer
 683       && parmclass != var_string && parmclass != var_string_noescape
 684       && parmclass != var_optional_filename && parmclass != var_filename
 685       && parmclass != var_zinteger && parmclass != var_enum)
 686     {
 687       PyErr_SetString (PyExc_RuntimeError,
 688                        _("Invalid parameter class argument."));
 689       return -1;
 690     }
 691
 692   if (enum_values && parmclass != var_enum)
 693     {
 694       PyErr_SetString (PyExc_RuntimeError,
 695                        _("Only PARAM_ENUM accepts a fourth argument."));
 696       return -1;
 697     }
 698   if (parmclass == var_enum)
 699     {
 700       if (! compute_enum_values (obj, enum_values))
 701         return -1;
 702     }
 703   else
 704     obj->enumeration = NULL;
 705   obj->type = (enum var_types) parmclass;
 706   memset (&obj->value, 0, sizeof (obj->value));
 707
 708   cmd_name = gdbpy_parse_command_name (name, &set_list,
 709                                        &setlist);
 710
 711   if (! cmd_name)
 712     return -1;
 713   xfree (cmd_name);
 714   cmd_name = gdbpy_parse_command_name (name, &show_list,
 715                                        &showlist);
 716   if (! cmd_name)
 717     return -1;
 718
 719   set_doc = get_doc_string (self, set_doc_cst);
 720   show_doc = get_doc_string (self, show_doc_cst);
 721   doc = get_doc_string (self, gdbpy_doc_cst);
 722
 723   Py_INCREF (self);
 724
 725   TRY
 726     {
 727       add_setshow_generic (parmclass, (enum command_class) cmdtype,
 728                            cmd_name, obj,
 729                            set_doc, show_doc,
 730                            doc, set_list, show_list);
 731     }
 732   CATCH (except, RETURN_MASK_ALL)
 733     {
 734       xfree (cmd_name);
 735       xfree (set_doc);
 736       xfree (show_doc);
 737       xfree (doc);
 738       Py_DECREF (self);
 739       PyErr_Format (except.reason == RETURN_QUIT
 740                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 741                     "%s", except.message);
 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 };