gdb/python/py-param.c

   1 /* GDB parameters implemented in Python
   2
   3    Copyright (C) 2008-2014 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 static 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 = xmalloc ((size + 1) * sizeof (char *));
 598   back_to = make_cleanup (free_current_contents, &self->enumeration);
 599   memset (self->enumeration, 0, (size + 1) * sizeof (char *));
 600
 601   for (i = 0; i < size; ++i)
 602     {
 603       PyObject *item = PySequence_GetItem (enum_values, i);
 604
 605       if (! item)
 606         {
 607           do_cleanups (back_to);
 608           return 0;
 609         }
 610       if (! gdbpy_is_string (item))
 611         {
 612           Py_DECREF (item);
 613           do_cleanups (back_to);
 614           PyErr_SetString (PyExc_RuntimeError,
 615                            _("The enumeration item not a string."));
 616           return 0;
 617         }
 618       self->enumeration[i] = python_string_to_host_string (item);
 619       Py_DECREF (item);
 620       if (self->enumeration[i] == NULL)
 621         {
 622           do_cleanups (back_to);
 623           return 0;
 624         }
 625       make_cleanup (xfree, (char *) self->enumeration[i]);
 626     }
 627
 628   discard_cleanups (back_to);
 629   return 1;
 630 }
 631
 632 /* Object initializer; sets up gdb-side structures for command.
 633
 634    Use: __init__(NAME, CMDCLASS, PARMCLASS, [ENUM])
 635
 636    NAME is the name of the parameter.  It may consist of multiple
 637    words, in which case the final word is the name of the new command,
 638    and earlier words must be prefix commands.
 639
 640    CMDCLASS is the kind of command.  It should be one of the COMMAND_*
 641    constants defined in the gdb module.
 642
 643    PARMCLASS is the type of the parameter.  It should be one of the
 644    PARAM_* constants defined in the gdb module.
 645
 646    If PARMCLASS is PARAM_ENUM, then the final argument should be a
 647    collection of strings.  These strings are the valid values for this
 648    parameter.
 649
 650    The documentation for the parameter is taken from the doc string
 651    for the python class.
 652
 653    Returns -1 on error, with a python exception set.  */
 654
 655 static int
 656 parmpy_init (PyObject *self, PyObject *args, PyObject *kwds)
 657 {
 658   parmpy_object *obj = (parmpy_object *) self;
 659   const char *name;
 660   char *set_doc, *show_doc, *doc;
 661   char *cmd_name;
 662   int parmclass, cmdtype;
 663   PyObject *enum_values = NULL;
 664   struct cmd_list_element **set_list, **show_list;
 665   volatile struct gdb_exception except;
 666
 667   if (! PyArg_ParseTuple (args, "sii|O", &name, &cmdtype, &parmclass,
 668                           &enum_values))
 669     return -1;
 670
 671   if (cmdtype != no_class && cmdtype != class_run
 672       && cmdtype != class_vars && cmdtype != class_stack
 673       && cmdtype != class_files && cmdtype != class_support
 674       && cmdtype != class_info && cmdtype != class_breakpoint
 675       && cmdtype != class_trace && cmdtype != class_obscure
 676       && cmdtype != class_maintenance)
 677     {
 678       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
 679       return -1;
 680     }
 681
 682   if (parmclass != var_boolean /* ARI: var_boolean */
 683       && parmclass != var_auto_boolean
 684       && parmclass != var_uinteger && parmclass != var_integer
 685       && parmclass != var_string && parmclass != var_string_noescape
 686       && parmclass != var_optional_filename && parmclass != var_filename
 687       && parmclass != var_zinteger && parmclass != var_enum)
 688     {
 689       PyErr_SetString (PyExc_RuntimeError,
 690                        _("Invalid parameter class argument."));
 691       return -1;
 692     }
 693
 694   if (enum_values && parmclass != var_enum)
 695     {
 696       PyErr_SetString (PyExc_RuntimeError,
 697                        _("Only PARAM_ENUM accepts a fourth argument."));
 698       return -1;
 699     }
 700   if (parmclass == var_enum)
 701     {
 702       if (! compute_enum_values (obj, enum_values))
 703         return -1;
 704     }
 705   else
 706     obj->enumeration = NULL;
 707   obj->type = (enum var_types) parmclass;
 708   memset (&obj->value, 0, sizeof (obj->value));
 709
 710   cmd_name = gdbpy_parse_command_name (name, &set_list,
 711                                        &setlist);
 712
 713   if (! cmd_name)
 714     return -1;
 715   xfree (cmd_name);
 716   cmd_name = gdbpy_parse_command_name (name, &show_list,
 717                                        &showlist);
 718   if (! cmd_name)
 719     return -1;
 720
 721   set_doc = get_doc_string (self, set_doc_cst);
 722   show_doc = get_doc_string (self, show_doc_cst);
 723   doc = get_doc_string (self, gdbpy_doc_cst);
 724
 725   Py_INCREF (self);
 726
 727   TRY_CATCH (except, RETURN_MASK_ALL)
 728     {
 729       add_setshow_generic (parmclass, (enum command_class) cmdtype,
 730                            cmd_name, obj,
 731                            set_doc, show_doc,
 732                            doc, set_list, show_list);
 733     }
 734   if (except.reason < 0)
 735     {
 736       xfree (cmd_name);
 737       xfree (set_doc);
 738       xfree (show_doc);
 739       xfree (doc);
 740       Py_DECREF (self);
 741       PyErr_Format (except.reason == RETURN_QUIT
 742                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 743                     "%s", except.message);
 744       return -1;
 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 static 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 };