gdb/python/py-param.c

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