gdb/python/py-param.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* GDB parameters implemented in Python

  3.    Copyright (C) 2008-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */


  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"

  31. /* Parameter constants and their values.  */
  32. ‌struct parm_constant
  33. {
  34.   char *name;
  35.   int value;
  36. };

  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. };

  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;

  59.   /* Hold an auto_boolean.  */
  60.   enum auto_boolean autoboolval;

  62.   /* Hold an unsigned integer value, for uinteger.  */
  63.   unsigned int uintval;

  65.   /* Hold a string, for the various string types.  */
  66.   char *stringval;

  68.   /* Hold a string, for enums.  */
  69.   const char *cstringval;
  70. };

  72. /* A GDB parameter.  */
  73. ‌struct parmpy_object
  74. {
  75.   PyObject_HEAD

  77.   /* The type of the parameter.  */
  78.   enum var_types type;

  80.   /* The value of the parameter.  */
  81.   union parmpy_variable value;

  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. };

  89. ‌typedef struct parmpy_object parmpy_object;

  91. static PyTypeObject parmpy_object_type
  92.     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("parmpy_object");

  94. /* Some handy string constants.  */
  95. ‌static PyObject *set_doc_cst;
  96. ‌static PyObject *show_doc_cst;



  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;

  113.       return gdbpy_parameter_value (self->type, &self->value);
  114.     }

  116.   return PyObject_GenericGetAttr (obj, attr_name);
  117. }

  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;

  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."));

  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;

  153.           string = python_string_to_host_string (value);
  154.           if (string == NULL)
  155.             return -1;

  157.           xfree (self->value.stringval);
  158.           self->value.stringval = string;
  159.         }
  160.       break;

  162.     case var_enum:
  163.       {
  164.         int i;
  165.         char *str;

  167.         if (! gdbpy_is_string (value))
  168.           {
  169.             PyErr_SetString (PyExc_RuntimeError,
  170.                              _("ENUM arguments must be a string."));
  171.             return -1;
  172.           }

  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.       }

  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;

  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.         }

  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;

  226.     case var_integer:
  227.     case var_zinteger:
  228.     case var_uinteger:
  229.       {
  230.         long l;
  231.         int ok;

  233.         if (! PyInt_Check (value))
  234.           {
  235.             PyErr_SetString (PyExc_RuntimeError,
  236.                              _("The value must be integer."));
  237.             return -1;
  238.           }

  240.         if (! gdb_py_int_as_long (value, &l))
  241.           return -1;

  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);

  258.         if (! ok)
  259.           {
  260.             PyErr_SetString (PyExc_RuntimeError,
  261.                              _("Range exceeded."));
  262.             return -1;
  263.           }

  265.         self->value.intval = (int) l;
  266.         break;
  267.       }

  269.     default:
  270.       PyErr_SetString (PyExc_RuntimeError,
  271.                        _("Unhandled type in parameter value."));
  272.       return -1;
  273.     }

  275.   return 0;
  276. }

  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.     }

  298.   return PyObject_GenericSetAttr (obj, attr_name, val);
  299. }

  301. /* A helper function which returns a documentation string for an
  302.    object. */

  304. static char *
  305. ‌get_doc_string (PyObject *object, PyObject *attr)
  306. {
  307.   char *result = NULL;

  309.   if (PyObject_HasAttr (object, attr))
  310.     {
  311.       PyObject *ds_obj = PyObject_GetAttr (object, attr);

  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. }

  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);

  336.   if (! result)
  337.     return NULL;

  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.     }

  354.   return data;
  355. }

  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");

  373.   if (! set_doc_func)
  374.     goto error;

  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.     }

  390.   make_cleanup (xfree, set_doc_string);
  391.   fprintf_filtered (gdb_stdout, "%s\n", set_doc_string);

  393.   Py_XDECREF (set_doc_func);
  394.   do_cleanups (cleanup);
  395.   return;

  397. error:
  398.   Py_XDECREF (set_doc_func);
  399.   gdbpy_print_stack ();
  400.   do_cleanups (cleanup);
  401.   return;
  402. }

  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");

  421.   if (! show_doc_func)
  422.     goto error;

  424.   if (PyObject_HasAttr (obj, show_doc_func))
  425.     {
  426.       PyObject *val_obj = PyString_FromString (value);

  428.       if (! val_obj)
  429.         goto error;

  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;

  436.       make_cleanup (xfree, show_doc_string);

  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.     }

  450.   Py_XDECREF (show_doc_func);
  451.   do_cleanups (cleanup);
  452.   return;

  454. error:
  455.   Py_XDECREF (show_doc_func);
  456.   gdbpy_print_stack ();
  457.   do_cleanups (cleanup);
  458.   return;
  459. }


  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;

  474.   switch (parmclass)
  475.     {
  476.     case var_boolean:

  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);

  483.       break;

  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;

  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;

  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;

  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;

  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);

  519.       break;

  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;

  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;

  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;

  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.     }

  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);

  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. }

  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;

  573.   if (! enum_values)
  574.     {
  575.       PyErr_SetString (PyExc_RuntimeError,
  576.                        _("An enumeration is required for PARAM_ENUM."));
  577.       return 0;
  578.     }

  580.   if (! PySequence_Check (enum_values))
  581.     {
  582.       PyErr_SetString (PyExc_RuntimeError,
  583.                        _("The enumeration is not a sequence."));
  584.       return 0;
  585.     }

  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.     }

  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 *));

  601.   for (i = 0; i < size; ++i)
  602.     {
  603.       PyObject *item = PySequence_GetItem (enum_values, i);

  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.     }

  628.   discard_cleanups (back_to);
  629.   return 1;
  630. }

  632. /* Object initializer; sets up gdb-side structures for command.

  634.    Use: __init__(NAME, CMDCLASS, PARMCLASS, [ENUM])

  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.

  640.    CMDCLASS is the kind of command.  It should be one of the COMMAND_*
  641.    constants defined in the gdb module.

  643.    PARMCLASS is the type of the parameter.  It should be one of the
  644.    PARAM_* constants defined in the gdb module.

  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.

  650.    The documentation for the parameter is taken from the doc string
  651.    for the python class.

  653.    Returns -1 on error, with a python exception set.  */

  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;

  667.   if (! PyArg_ParseTuple (args, "sii|O", &name, &cmdtype, &parmclass,
  668.                           &enum_values))
  669.     return -1;

  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.     }

  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.     }

  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));

  710.   cmd_name = gdbpy_parse_command_name (name, &set_list,
  711.                                        &setlist);

  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;

  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);

  725.   Py_INCREF (self);

  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. }



  751. /* Initialize the 'parameters' module.  */
  752. int
  753. ‌gdbpy_initialize_parameters (void)
  754. {
  755.   int i;

  757.   parmpy_object_type.tp_new = PyType_GenericNew;
  758.   if (PyType_Ready (&parmpy_object_type) < 0)
  759.     return -1;

  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;

  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.     }

  776.   return gdb_pymodule_addobject (gdb_module, "Parameter",
  777.                                  (PyObject *) &parmpy_object_type);
  778. }



  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. };