]> Git Repo - binutils.git/blob - gdb/python/py-param.c
d80b731860c056a54d1737869654ac93dcd454e7
[binutils.git] / gdb / python / py-param.c
1 /* GDB parameters implemented in Python
2
3    Copyright (C) 2008-2017 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20
21 #include "defs.h"
22 #include "value.h"
23 #include "python-internal.h"
24 #include "charset.h"
25 #include "gdbcmd.h"
26 #include "cli/cli-decode.h"
27 #include "completer.h"
28 #include "language.h"
29 #include "arch-utils.h"
30 #include "py-ref.h"
31
32 /* Parameter constants and their values.  */
33 struct parm_constant
34 {
35   char *name;
36   int value;
37 };
38
39 struct parm_constant parm_constants[] =
40 {
41   { "PARAM_BOOLEAN", var_boolean }, /* ARI: var_boolean */
42   { "PARAM_AUTO_BOOLEAN", var_auto_boolean },
43   { "PARAM_UINTEGER", var_uinteger },
44   { "PARAM_INTEGER", var_integer },
45   { "PARAM_STRING", var_string },
46   { "PARAM_STRING_NOESCAPE", var_string_noescape },
47   { "PARAM_OPTIONAL_FILENAME", var_optional_filename },
48   { "PARAM_FILENAME", var_filename },
49   { "PARAM_ZINTEGER", var_zinteger },
50   { "PARAM_ENUM", var_enum },
51   { NULL, 0 }
52 };
53
54 /* A union that can hold anything described by enum var_types.  */
55 union parmpy_variable
56 {
57   /* Hold an integer value, for boolean and integer types.  */
58   int intval;
59
60   /* Hold an auto_boolean.  */
61   enum auto_boolean autoboolval;
62
63   /* Hold an unsigned integer value, for uinteger.  */
64   unsigned int uintval;
65
66   /* Hold a string, for the various string types.  */
67   char *stringval;
68
69   /* Hold a string, for enums.  */
70   const char *cstringval;
71 };
72
73 /* A GDB parameter.  */
74 struct parmpy_object
75 {
76   PyObject_HEAD
77
78   /* The type of the parameter.  */
79   enum var_types type;
80
81   /* The value of the parameter.  */
82   union parmpy_variable value;
83
84   /* For an enum command, the possible values.  The vector is
85      allocated with xmalloc, as is each element.  It is
86      NULL-terminated.  */
87   const char **enumeration;
88 };
89
90 typedef struct parmpy_object parmpy_object;
91
92 extern PyTypeObject parmpy_object_type
93     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("parmpy_object");
94
95 /* Some handy string constants.  */
96 static PyObject *set_doc_cst;
97 static PyObject *show_doc_cst;
98
99 \f
100
101 /* Get an attribute.  */
102 static PyObject *
103 get_attr (PyObject *obj, PyObject *attr_name)
104 {
105   if (PyString_Check (attr_name)
106 #ifdef IS_PY3K
107       && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
108 #else
109       && ! strcmp (PyString_AsString (attr_name), "value"))
110 #endif
111     {
112       parmpy_object *self = (parmpy_object *) obj;
113
114       return gdbpy_parameter_value (self->type, &self->value);
115     }
116
117   return PyObject_GenericGetAttr (obj, attr_name);
118 }
119
120 /* Set a parameter value from a Python value.  Return 0 on success.  Returns
121    -1 on error, with a python exception set.  */
122 static int
123 set_parameter_value (parmpy_object *self, PyObject *value)
124 {
125   int cmp;
126
127   switch (self->type)
128     {
129     case var_string:
130     case var_string_noescape:
131     case var_optional_filename:
132     case var_filename:
133       if (! gdbpy_is_string (value)
134           && (self->type == var_filename
135               || value != Py_None))
136         {
137           PyErr_SetString (PyExc_RuntimeError,
138                            _("String required for filename."));
139
140           return -1;
141         }
142       if (value == Py_None)
143         {
144           xfree (self->value.stringval);
145           if (self->type == var_optional_filename)
146             self->value.stringval = xstrdup ("");
147           else
148             self->value.stringval = NULL;
149         }
150       else
151         {
152           gdb::unique_xmalloc_ptr<char>
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.release ();
159         }
160       break;
161
162     case var_enum:
163       {
164         int i;
165
166         if (! gdbpy_is_string (value))
167           {
168             PyErr_SetString (PyExc_RuntimeError,
169                              _("ENUM arguments must be a string."));
170             return -1;
171           }
172
173         gdb::unique_xmalloc_ptr<char>
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.get ()))
179             break;
180         if (! self->enumeration[i])
181           {
182             PyErr_SetString (PyExc_RuntimeError,
183                              _("The value must be member of an enumeration."));
184             return -1;
185           }
186         self->value.cstringval = self->enumeration[i];
187         break;
188       }
189
190     case var_boolean:
191       if (! PyBool_Check (value))
192         {
193           PyErr_SetString (PyExc_RuntimeError,
194                            _("A boolean argument is required."));
195           return -1;
196         }
197       cmp = PyObject_IsTrue (value);
198       if (cmp < 0)
199           return -1;
200       self->value.intval = cmp;
201       break;
202
203     case var_auto_boolean:
204       if (! PyBool_Check (value) && value != Py_None)
205         {
206           PyErr_SetString (PyExc_RuntimeError,
207                            _("A boolean or None is required"));
208           return -1;
209         }
210
211       if (value == Py_None)
212         self->value.autoboolval = AUTO_BOOLEAN_AUTO;
213       else
214         {
215           cmp = PyObject_IsTrue (value);
216           if (cmp < 0 )
217             return -1;  
218           if (cmp == 1)
219             self->value.autoboolval = AUTO_BOOLEAN_TRUE;
220           else
221             self->value.autoboolval = AUTO_BOOLEAN_FALSE;
222         }
223       break;
224
225     case var_integer:
226     case var_zinteger:
227     case var_uinteger:
228       {
229         long l;
230         int ok;
231
232         if (! PyInt_Check (value))
233           {
234             PyErr_SetString (PyExc_RuntimeError,
235                              _("The value must be integer."));
236             return -1;
237           }
238
239         if (! gdb_py_int_as_long (value, &l))
240           return -1;
241
242         if (self->type == var_uinteger)
243           {
244             ok = (l >= 0 && l <= UINT_MAX);
245             if (l == 0)
246               l = UINT_MAX;
247           }
248         else if (self->type == var_integer)
249           {
250             ok = (l >= INT_MIN && l <= INT_MAX);
251             if (l == 0)
252               l = INT_MAX;
253           }
254         else
255           ok = (l >= INT_MIN && l <= INT_MAX);
256
257         if (! ok)
258           {
259             PyErr_SetString (PyExc_RuntimeError,
260                              _("Range exceeded."));
261             return -1;
262           }
263
264         self->value.intval = (int) l;
265         break;
266       }
267
268     default:
269       PyErr_SetString (PyExc_RuntimeError,
270                        _("Unhandled type in parameter value."));
271       return -1;
272     }
273
274   return 0;
275 }
276
277 /* Set an attribute.  Returns -1 on error, with a python exception set.  */
278 static int
279 set_attr (PyObject *obj, PyObject *attr_name, PyObject *val)
280 {
281   if (PyString_Check (attr_name)
282 #ifdef IS_PY3K
283       && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
284 #else
285       && ! strcmp (PyString_AsString (attr_name), "value"))
286 #endif
287     {
288       if (!val)
289         {
290           PyErr_SetString (PyExc_RuntimeError,
291                            _("Cannot delete a parameter's value."));
292           return -1;
293         }
294       return set_parameter_value ((parmpy_object *) obj, val);
295     }
296
297   return PyObject_GenericSetAttr (obj, attr_name, val);
298 }
299
300 /* A helper function which returns a documentation string for an
301    object. */
302
303 static gdb::unique_xmalloc_ptr<char>
304 get_doc_string (PyObject *object, PyObject *attr)
305 {
306   gdb::unique_xmalloc_ptr<char> result;
307
308   if (PyObject_HasAttr (object, attr))
309     {
310       gdbpy_ref<> ds_obj (PyObject_GetAttr (object, attr));
311
312       if (ds_obj != NULL && gdbpy_is_string (ds_obj.get ()))
313         {
314           result = python_string_to_host_string (ds_obj.get ());
315           if (result == NULL)
316             gdbpy_print_stack ();
317         }
318     }
319   if (! result)
320     result.reset (xstrdup (_("This command is not documented.")));
321   return result;
322 }
323
324 /* Helper function which will execute a METHOD in OBJ passing the
325    argument ARG.  ARG can be NULL.  METHOD should return a Python
326    string.  If this function returns NULL, there has been an error and
327    the appropriate exception set.  */
328 static gdb::unique_xmalloc_ptr<char>
329 call_doc_function (PyObject *obj, PyObject *method, PyObject *arg)
330 {
331   gdb::unique_xmalloc_ptr<char> data;
332   gdbpy_ref<> result (PyObject_CallMethodObjArgs (obj, method, arg, NULL));
333
334   if (result == NULL)
335     return NULL;
336
337   if (gdbpy_is_string (result.get ()))
338     {
339       data = python_string_to_host_string (result.get ());
340       if (! data)
341         return NULL;
342     }
343   else
344     {
345       PyErr_SetString (PyExc_RuntimeError,
346                        _("Parameter must return a string value."));
347       return NULL;
348     }
349
350   return data;
351 }
352
353 /* A callback function that is registered against the respective
354    add_setshow_* set_doc prototype.  This function will either call
355    the Python function "get_set_string" or extract the Python
356    attribute "set_doc" and return the contents as a string.  If
357    neither exist, insert a string indicating the Parameter is not
358    documented.  */
359 static void
360 get_set_value (char *args, int from_tty,
361                struct cmd_list_element *c)
362 {
363   PyObject *obj = (PyObject *) get_cmd_context (c);
364   gdb::unique_xmalloc_ptr<char> set_doc_string;
365
366   gdbpy_enter enter_py (get_current_arch (), current_language);
367   gdbpy_ref<> set_doc_func (PyString_FromString ("get_set_string"));
368
369   if (set_doc_func == NULL)
370     {
371       gdbpy_print_stack ();
372       return;
373     }
374
375   if (PyObject_HasAttr (obj, set_doc_func.get ()))
376     {
377       set_doc_string = call_doc_function (obj, set_doc_func.get (), NULL);
378       if (! set_doc_string)
379         {
380           gdbpy_print_stack ();
381           return;
382         }
383     }
384   else
385     {
386       /* We have to preserve the existing < GDB 7.3 API.  If a
387          callback function does not exist, then attempt to read the
388          set_doc attribute.  */
389       set_doc_string  = get_doc_string (obj, set_doc_cst);
390     }
391
392   fprintf_filtered (gdb_stdout, "%s\n", set_doc_string.get ());
393 }
394
395 /* A callback function that is registered against the respective
396    add_setshow_* show_doc prototype.  This function will either call
397    the Python function "get_show_string" or extract the Python
398    attribute "show_doc" and return the contents as a string.  If
399    neither exist, insert a string indicating the Parameter is not
400    documented.  */
401 static void
402 get_show_value (struct ui_file *file, int from_tty,
403                 struct cmd_list_element *c,
404                 const char *value)
405 {
406   PyObject *obj = (PyObject *) get_cmd_context (c);
407   gdb::unique_xmalloc_ptr<char> show_doc_string;
408
409   gdbpy_enter enter_py (get_current_arch (), current_language);
410   gdbpy_ref<> show_doc_func (PyString_FromString ("get_show_string"));
411
412   if (show_doc_func == NULL)
413     {
414       gdbpy_print_stack ();
415       return;
416     }
417
418   if (PyObject_HasAttr (obj, show_doc_func.get ()))
419     {
420       gdbpy_ref<> val_obj (PyString_FromString (value));
421
422       if (val_obj == NULL)
423         {
424           gdbpy_print_stack ();
425           return;
426         }
427
428       show_doc_string = call_doc_function (obj, show_doc_func.get (),
429                                            val_obj.get ());
430       if (! show_doc_string)
431         {
432           gdbpy_print_stack ();
433           return;
434         }
435
436       fprintf_filtered (file, "%s\n", show_doc_string.get ());
437     }
438   else
439     {
440       /* We have to preserve the existing < GDB 7.3 API.  If a
441          callback function does not exist, then attempt to read the
442          show_doc attribute.  */
443       show_doc_string  = get_doc_string (obj, show_doc_cst);
444       fprintf_filtered (file, "%s %s\n", show_doc_string.get (), value);
445     }
446 }
447 \f
448
449 /* A helper function that dispatches to the appropriate add_setshow
450    function.  */
451 static void
452 add_setshow_generic (int parmclass, enum command_class cmdclass,
453                      char *cmd_name, parmpy_object *self,
454                      char *set_doc, char *show_doc, char *help_doc,
455                      struct cmd_list_element **set_list,
456                      struct cmd_list_element **show_list)
457 {
458   struct cmd_list_element *param = NULL;
459   const char *tmp_name = NULL;
460
461   switch (parmclass)
462     {
463     case var_boolean:
464
465       add_setshow_boolean_cmd (cmd_name, cmdclass,
466                                &self->value.intval, set_doc, show_doc,
467                                help_doc, get_set_value, get_show_value,
468                                set_list, show_list);
469
470       break;
471
472     case var_auto_boolean:
473       add_setshow_auto_boolean_cmd (cmd_name, cmdclass,
474                                     &self->value.autoboolval,
475                                     set_doc, show_doc, help_doc,
476                                     get_set_value, get_show_value,
477                                     set_list, show_list);
478       break;
479
480     case var_uinteger:
481       add_setshow_uinteger_cmd (cmd_name, cmdclass,
482                                 &self->value.uintval, set_doc, show_doc,
483                                 help_doc, get_set_value, get_show_value,
484                                 set_list, show_list);
485       break;
486
487     case var_integer:
488       add_setshow_integer_cmd (cmd_name, cmdclass,
489                                &self->value.intval, set_doc, show_doc,
490                                help_doc, get_set_value, get_show_value,
491                                set_list, show_list); break;
492
493     case var_string:
494       add_setshow_string_cmd (cmd_name, cmdclass,
495                               &self->value.stringval, set_doc, show_doc,
496                               help_doc, get_set_value, get_show_value,
497                               set_list, show_list); break;
498
499     case var_string_noescape:
500       add_setshow_string_noescape_cmd (cmd_name, cmdclass,
501                                        &self->value.stringval,
502                                        set_doc, show_doc, help_doc,
503                                        get_set_value, get_show_value,
504                                        set_list, show_list);
505
506       break;
507
508     case var_optional_filename:
509       add_setshow_optional_filename_cmd (cmd_name, cmdclass,
510                                          &self->value.stringval, set_doc,
511                                          show_doc, help_doc, get_set_value,
512                                          get_show_value, set_list,
513                                          show_list);
514       break;
515
516     case var_filename:
517       add_setshow_filename_cmd (cmd_name, cmdclass,
518                                 &self->value.stringval, set_doc, show_doc,
519                                 help_doc, get_set_value, get_show_value,
520                                 set_list, show_list); break;
521
522     case var_zinteger:
523       add_setshow_zinteger_cmd (cmd_name, cmdclass,
524                                 &self->value.intval, set_doc, show_doc,
525                                 help_doc, get_set_value, get_show_value,
526                                 set_list, show_list);
527       break;
528
529     case var_enum:
530       add_setshow_enum_cmd (cmd_name, cmdclass, self->enumeration,
531                             &self->value.cstringval, set_doc, show_doc,
532                             help_doc, get_set_value, get_show_value,
533                             set_list, show_list);
534       /* Initialize the value, just in case.  */
535       self->value.cstringval = self->enumeration[0];
536       break;
537     }
538
539   /* Lookup created parameter, and register Python object against the
540      parameter context.  Perform this task against both lists.  */
541   tmp_name = cmd_name;
542   param = lookup_cmd (&tmp_name, *show_list, "", 0, 1);
543   if (param)
544     set_cmd_context (param, self);
545
546   tmp_name = cmd_name;
547   param = lookup_cmd (&tmp_name, *set_list, "", 0, 1);
548   if (param)
549     set_cmd_context (param, self);
550 }
551
552 /* A helper which computes enum values.  Returns 1 on success.  Returns 0 on
553    error, with a python exception set.  */
554 static int
555 compute_enum_values (parmpy_object *self, PyObject *enum_values)
556 {
557   Py_ssize_t size, i;
558   struct cleanup *back_to;
559
560   if (! enum_values)
561     {
562       PyErr_SetString (PyExc_RuntimeError,
563                        _("An enumeration is required for PARAM_ENUM."));
564       return 0;
565     }
566
567   if (! PySequence_Check (enum_values))
568     {
569       PyErr_SetString (PyExc_RuntimeError,
570                        _("The enumeration is not a sequence."));
571       return 0;
572     }
573
574   size = PySequence_Size (enum_values);
575   if (size < 0)
576     return 0;
577   if (size == 0)
578     {
579       PyErr_SetString (PyExc_RuntimeError,
580                        _("The enumeration is empty."));
581       return 0;
582     }
583
584   self->enumeration = XCNEWVEC (const char *, size + 1);
585   back_to = make_cleanup (free_current_contents, &self->enumeration);
586
587   for (i = 0; i < size; ++i)
588     {
589       gdbpy_ref<> item (PySequence_GetItem (enum_values, i));
590
591       if (item == NULL)
592         {
593           do_cleanups (back_to);
594           return 0;
595         }
596       if (! gdbpy_is_string (item.get ()))
597         {
598           do_cleanups (back_to);
599           PyErr_SetString (PyExc_RuntimeError,
600                            _("The enumeration item not a string."));
601           return 0;
602         }
603       self->enumeration[i]
604         = python_string_to_host_string (item.get ()).release ();
605       if (self->enumeration[i] == NULL)
606         {
607           do_cleanups (back_to);
608           return 0;
609         }
610       make_cleanup (xfree, (char *) self->enumeration[i]);
611     }
612
613   discard_cleanups (back_to);
614   return 1;
615 }
616
617 /* Object initializer; sets up gdb-side structures for command.
618
619    Use: __init__(NAME, CMDCLASS, PARMCLASS, [ENUM])
620
621    NAME is the name of the parameter.  It may consist of multiple
622    words, in which case the final word is the name of the new command,
623    and earlier words must be prefix commands.
624
625    CMDCLASS is the kind of command.  It should be one of the COMMAND_*
626    constants defined in the gdb module.
627
628    PARMCLASS is the type of the parameter.  It should be one of the
629    PARAM_* constants defined in the gdb module.
630
631    If PARMCLASS is PARAM_ENUM, then the final argument should be a
632    collection of strings.  These strings are the valid values for this
633    parameter.
634
635    The documentation for the parameter is taken from the doc string
636    for the python class.
637
638    Returns -1 on error, with a python exception set.  */
639
640 static int
641 parmpy_init (PyObject *self, PyObject *args, PyObject *kwds)
642 {
643   parmpy_object *obj = (parmpy_object *) self;
644   const char *name;
645   char *set_doc, *show_doc, *doc;
646   char *cmd_name;
647   int parmclass, cmdtype;
648   PyObject *enum_values = NULL;
649   struct cmd_list_element **set_list, **show_list;
650
651   if (! PyArg_ParseTuple (args, "sii|O", &name, &cmdtype, &parmclass,
652                           &enum_values))
653     return -1;
654
655   if (cmdtype != no_class && cmdtype != class_run
656       && cmdtype != class_vars && cmdtype != class_stack
657       && cmdtype != class_files && cmdtype != class_support
658       && cmdtype != class_info && cmdtype != class_breakpoint
659       && cmdtype != class_trace && cmdtype != class_obscure
660       && cmdtype != class_maintenance)
661     {
662       PyErr_Format (PyExc_RuntimeError, _("Invalid command class argument."));
663       return -1;
664     }
665
666   if (parmclass != var_boolean /* ARI: var_boolean */
667       && parmclass != var_auto_boolean
668       && parmclass != var_uinteger && parmclass != var_integer
669       && parmclass != var_string && parmclass != var_string_noescape
670       && parmclass != var_optional_filename && parmclass != var_filename
671       && parmclass != var_zinteger && parmclass != var_enum)
672     {
673       PyErr_SetString (PyExc_RuntimeError,
674                        _("Invalid parameter class argument."));
675       return -1;
676     }
677
678   if (enum_values && parmclass != var_enum)
679     {
680       PyErr_SetString (PyExc_RuntimeError,
681                        _("Only PARAM_ENUM accepts a fourth argument."));
682       return -1;
683     }
684   if (parmclass == var_enum)
685     {
686       if (! compute_enum_values (obj, enum_values))
687         return -1;
688     }
689   else
690     obj->enumeration = NULL;
691   obj->type = (enum var_types) parmclass;
692   memset (&obj->value, 0, sizeof (obj->value));
693
694   cmd_name = gdbpy_parse_command_name (name, &set_list,
695                                        &setlist);
696
697   if (! cmd_name)
698     return -1;
699   xfree (cmd_name);
700   cmd_name = gdbpy_parse_command_name (name, &show_list,
701                                        &showlist);
702   if (! cmd_name)
703     return -1;
704
705   set_doc = get_doc_string (self, set_doc_cst).release ();
706   show_doc = get_doc_string (self, show_doc_cst).release ();
707   doc = get_doc_string (self, gdbpy_doc_cst).release ();
708
709   Py_INCREF (self);
710
711   TRY
712     {
713       add_setshow_generic (parmclass, (enum command_class) cmdtype,
714                            cmd_name, obj,
715                            set_doc, show_doc,
716                            doc, set_list, show_list);
717     }
718   CATCH (except, RETURN_MASK_ALL)
719     {
720       xfree (cmd_name);
721       xfree (set_doc);
722       xfree (show_doc);
723       xfree (doc);
724       Py_DECREF (self);
725       PyErr_Format (except.reason == RETURN_QUIT
726                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
727                     "%s", except.message);
728       return -1;
729     }
730   END_CATCH
731
732   return 0;
733 }
734
735 \f
736
737 /* Initialize the 'parameters' module.  */
738 int
739 gdbpy_initialize_parameters (void)
740 {
741   int i;
742
743   parmpy_object_type.tp_new = PyType_GenericNew;
744   if (PyType_Ready (&parmpy_object_type) < 0)
745     return -1;
746
747   set_doc_cst = PyString_FromString ("set_doc");
748   if (! set_doc_cst)
749     return -1;
750   show_doc_cst = PyString_FromString ("show_doc");
751   if (! show_doc_cst)
752     return -1;
753
754   for (i = 0; parm_constants[i].name; ++i)
755     {
756       if (PyModule_AddIntConstant (gdb_module,
757                                    parm_constants[i].name,
758                                    parm_constants[i].value) < 0)
759         return -1;
760     }
761
762   return gdb_pymodule_addobject (gdb_module, "Parameter",
763                                  (PyObject *) &parmpy_object_type);
764 }
765
766 \f
767
768 PyTypeObject parmpy_object_type =
769 {
770   PyVarObject_HEAD_INIT (NULL, 0)
771   "gdb.Parameter",                /*tp_name*/
772   sizeof (parmpy_object),         /*tp_basicsize*/
773   0,                              /*tp_itemsize*/
774   0,                              /*tp_dealloc*/
775   0,                              /*tp_print*/
776   0,                              /*tp_getattr*/
777   0,                              /*tp_setattr*/
778   0,                              /*tp_compare*/
779   0,                              /*tp_repr*/
780   0,                              /*tp_as_number*/
781   0,                              /*tp_as_sequence*/
782   0,                              /*tp_as_mapping*/
783   0,                              /*tp_hash */
784   0,                              /*tp_call*/
785   0,                              /*tp_str*/
786   get_attr,                       /*tp_getattro*/
787   set_attr,                       /*tp_setattro*/
788   0,                              /*tp_as_buffer*/
789   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
790   "GDB parameter object",         /* tp_doc */
791   0,                              /* tp_traverse */
792   0,                              /* tp_clear */
793   0,                              /* tp_richcompare */
794   0,                              /* tp_weaklistoffset */
795   0,                              /* tp_iter */
796   0,                              /* tp_iternext */
797   0,                              /* tp_methods */
798   0,                              /* tp_members */
799   0,                              /* tp_getset */
800   0,                              /* tp_base */
801   0,                              /* tp_dict */
802   0,                              /* tp_descr_get */
803   0,                              /* tp_descr_set */
804   0,                              /* tp_dictoffset */
805   parmpy_init,                    /* tp_init */
806   0,                              /* tp_alloc */
807 };
This page took 0.064701 seconds and 2 git commands to generate.