1 /* Python interface to values.
3 Copyright (C) 2008, 2009 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 "gdb_assert.h"
24 #include "exceptions.h"
31 #include "python-internal.h"
33 /* Even though Python scalar types directly map to host types, we use
34 target types here to remain consistent with the the values system in
35 GDB (which uses target arithmetic). */
37 /* Python's integer type corresponds to C's long type. */
38 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
40 /* Python's float type corresponds to C's double type. */
41 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
43 /* Python's long type corresponds to C's long long type. */
44 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
46 #define builtin_type_pybool \
47 language_bool_type (python_language, python_gdbarch)
49 #define builtin_type_pychar \
50 language_string_char_type (python_language, python_gdbarch)
52 typedef struct value_object {
54 struct value_object *next;
55 struct value_object *prev;
61 /* List of all values which are currently exposed to Python. It is
62 maintained so that when an objfile is discarded, preserve_values
63 can copy the values' types if needed. */
64 /* This variable is unnecessarily initialized to NULL in order to
65 work around a linker bug on MacOS. */
66 static value_object *values_in_python = NULL;
68 /* Called by the Python interpreter when deallocating a value object. */
70 valpy_dealloc (PyObject *obj)
72 value_object *self = (value_object *) obj;
74 /* Remove SELF from the global list. */
76 self->prev->next = self->next;
79 gdb_assert (values_in_python == self);
80 values_in_python = self->next;
83 self->next->prev = self->prev;
85 value_free (self->value);
88 /* Use braces to appease gcc warning. *sigh* */
90 Py_DECREF (self->address);
95 Py_DECREF (self->type);
98 self->ob_type->tp_free (self);
101 /* Helper to push a Value object on the global list. */
103 note_value (value_object *value_obj)
105 value_obj->next = values_in_python;
107 value_obj->next->prev = value_obj;
108 value_obj->prev = NULL;
109 values_in_python = value_obj;
112 /* Called when a new gdb.Value object needs to be allocated. */
114 valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords)
116 struct value *value = NULL; /* Initialize to appease gcc warning. */
117 value_object *value_obj;
119 if (PyTuple_Size (args) != 1)
121 PyErr_SetString (PyExc_TypeError, _("Value object creation takes only "
126 value_obj = (value_object *) subtype->tp_alloc (subtype, 1);
127 if (value_obj == NULL)
129 PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to "
130 "create Value object."));
134 value = convert_value_from_python (PyTuple_GetItem (args, 0));
137 subtype->tp_free (value_obj);
141 value_obj->value = value;
142 value_incref (value);
143 value_obj->address = NULL;
144 value_obj->type = NULL;
145 note_value (value_obj);
147 return (PyObject *) value_obj;
150 /* Iterate over all the Value objects, calling preserve_one_value on
153 preserve_python_values (struct objfile *objfile, htab_t copied_types)
157 for (iter = values_in_python; iter; iter = iter->next)
158 preserve_one_value (iter->value, objfile, copied_types);
161 /* Given a value of a pointer type, apply the C unary * operator to it. */
163 valpy_dereference (PyObject *self, PyObject *args)
165 struct value *res_val = NULL; /* Initialize to appease gcc warning. */
166 volatile struct gdb_exception except;
168 TRY_CATCH (except, RETURN_MASK_ALL)
170 res_val = value_ind (((value_object *) self)->value);
172 GDB_PY_HANDLE_EXCEPTION (except);
174 return value_to_value_object (res_val);
177 /* Return "&value". */
179 valpy_get_address (PyObject *self, void *closure)
181 struct value *res_val = NULL; /* Initialize to appease gcc warning. */
182 value_object *val_obj = (value_object *) self;
183 volatile struct gdb_exception except;
185 if (!val_obj->address)
187 TRY_CATCH (except, RETURN_MASK_ALL)
189 res_val = value_addr (val_obj->value);
191 if (except.reason < 0)
193 val_obj->address = Py_None;
197 val_obj->address = value_to_value_object (res_val);
200 Py_INCREF (val_obj->address);
202 return val_obj->address;
205 /* Return type of the value. */
207 valpy_get_type (PyObject *self, void *closure)
209 value_object *obj = (value_object *) self;
212 obj->type = type_to_type_object (value_type (obj->value));
216 Py_INCREF (obj->type);
219 Py_INCREF (obj->type);
223 /* Implementation of gdb.Value.string ([encoding] [, errors]
224 [, length]) -> string. Return Unicode string with value contents.
225 If ENCODING is not given, the string is assumed to be encoded in
226 the target's charset. If LENGTH is provided, only fetch string to
227 the length provided. */
230 valpy_string (PyObject *self, PyObject *args, PyObject *kw)
232 int length = -1, ret = 0;
234 struct value *value = ((value_object *) self)->value;
235 volatile struct gdb_exception except;
237 const char *encoding = NULL;
238 const char *errors = NULL;
239 const char *user_encoding = NULL;
240 const char *la_encoding = NULL;
241 static char *keywords[] = { "encoding", "errors", "length", NULL };
243 if (!PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
244 &user_encoding, &errors, &length))
247 TRY_CATCH (except, RETURN_MASK_ALL)
249 LA_GET_STRING (value, &buffer, &length, &la_encoding);
251 GDB_PY_HANDLE_EXCEPTION (except);
253 encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
254 unicode = PyUnicode_Decode (buffer, length, encoding, errors);
260 /* Cast a value to a given type. */
262 valpy_cast (PyObject *self, PyObject *args)
266 struct value *res_val = NULL; /* Initialize to appease gcc warning. */
267 volatile struct gdb_exception except;
269 if (! PyArg_ParseTuple (args, "O", &type_obj))
272 type = type_object_to_type (type_obj);
275 PyErr_SetString (PyExc_RuntimeError, "argument must be a Type");
279 TRY_CATCH (except, RETURN_MASK_ALL)
281 res_val = value_cast (type, ((value_object *) self)->value);
283 GDB_PY_HANDLE_EXCEPTION (except);
285 return value_to_value_object (res_val);
289 valpy_length (PyObject *self)
291 /* We don't support getting the number of elements in a struct / class. */
292 PyErr_SetString (PyExc_NotImplementedError,
293 "Invalid operation on gdb.Value.");
297 /* Given string name of an element inside structure, return its value
300 valpy_getitem (PyObject *self, PyObject *key)
302 value_object *self_value = (value_object *) self;
304 struct value *res_val = NULL;
305 volatile struct gdb_exception except;
307 if (gdbpy_is_string (key))
309 field = python_string_to_host_string (key);
314 TRY_CATCH (except, RETURN_MASK_ALL)
316 struct value *tmp = self_value->value;
319 res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
322 /* Assume we are attempting an array access, and let the
323 value code throw an exception if the index has an invalid
325 struct value *idx = convert_value_from_python (key);
328 /* Check the value's type is something that can be accessed via
331 tmp = coerce_ref (tmp);
332 type = check_typedef (value_type (tmp));
333 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
334 && TYPE_CODE (type) != TYPE_CODE_PTR)
335 error( _("Cannot subscript requested type"));
337 res_val = value_subscript (tmp, value_as_long (idx));
343 GDB_PY_HANDLE_EXCEPTION (except);
345 return res_val ? value_to_value_object (res_val) : NULL;
349 valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
351 PyErr_Format (PyExc_NotImplementedError,
352 _("Setting of struct elements is not currently supported."));
356 /* Called by the Python interpreter to obtain string representation
359 valpy_str (PyObject *self)
363 struct cleanup *old_chain;
365 struct value_print_options opts;
366 volatile struct gdb_exception except;
368 get_user_print_options (&opts);
371 stb = mem_fileopen ();
372 old_chain = make_cleanup_ui_file_delete (stb);
374 TRY_CATCH (except, RETURN_MASK_ALL)
376 common_val_print (((value_object *) self)->value, stb, 0,
377 &opts, python_language);
378 s = ui_file_xstrdup (stb, NULL);
380 GDB_PY_HANDLE_EXCEPTION (except);
382 do_cleanups (old_chain);
384 result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL);
390 /* Implements gdb.Value.is_optimized_out. */
392 valpy_get_is_optimized_out (PyObject *self, void *closure)
394 struct value *value = ((value_object *) self)->value;
396 if (value_optimized_out (value))
417 /* If TYPE is a reference, return the target; otherwise return TYPE. */
418 #define STRIP_REFERENCE(TYPE) \
419 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
421 /* Returns a value object which is the result of applying the operation
422 specified by OPCODE to the given arguments. */
424 valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
426 struct value *res_val = NULL; /* Initialize to appease gcc warning. */
427 volatile struct gdb_exception except;
429 TRY_CATCH (except, RETURN_MASK_ALL)
431 struct value *arg1, *arg2;
433 /* If the gdb.Value object is the second operand, then it will be passed
434 to us as the OTHER argument, and SELF will be an entirely different
435 kind of object, altogether. Because of this, we can't assume self is
436 a gdb.Value object and need to convert it from python as well. */
437 arg1 = convert_value_from_python (self);
441 arg2 = convert_value_from_python (other);
449 struct type *ltype = value_type (arg1);
450 struct type *rtype = value_type (arg2);
452 CHECK_TYPEDEF (ltype);
453 ltype = STRIP_REFERENCE (ltype);
454 CHECK_TYPEDEF (rtype);
455 rtype = STRIP_REFERENCE (rtype);
457 if (TYPE_CODE (ltype) == TYPE_CODE_PTR
458 && is_integral_type (rtype))
459 res_val = value_ptradd (arg1, value_as_long (arg2));
460 else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
461 && is_integral_type (ltype))
462 res_val = value_ptradd (arg2, value_as_long (arg1));
464 res_val = value_binop (arg1, arg2, BINOP_ADD);
469 struct type *ltype = value_type (arg1);
470 struct type *rtype = value_type (arg2);
472 CHECK_TYPEDEF (ltype);
473 ltype = STRIP_REFERENCE (ltype);
474 CHECK_TYPEDEF (rtype);
475 rtype = STRIP_REFERENCE (rtype);
477 if (TYPE_CODE (ltype) == TYPE_CODE_PTR
478 && TYPE_CODE (rtype) == TYPE_CODE_PTR)
479 /* A ptrdiff_t for the target would be preferable here. */
480 res_val = value_from_longest (builtin_type_pyint,
481 value_ptrdiff (arg1, arg2));
482 else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
483 && is_integral_type (rtype))
484 res_val = value_ptradd (arg1, - value_as_long (arg2));
486 res_val = value_binop (arg1, arg2, BINOP_SUB);
490 res_val = value_binop (arg1, arg2, BINOP_MUL);
493 res_val = value_binop (arg1, arg2, BINOP_DIV);
496 res_val = value_binop (arg1, arg2, BINOP_REM);
499 res_val = value_binop (arg1, arg2, BINOP_EXP);
502 res_val = value_binop (arg1, arg2, BINOP_LSH);
505 res_val = value_binop (arg1, arg2, BINOP_RSH);
508 res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
511 res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
514 res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
518 GDB_PY_HANDLE_EXCEPTION (except);
520 return res_val ? value_to_value_object (res_val) : NULL;
524 valpy_add (PyObject *self, PyObject *other)
526 return valpy_binop (VALPY_ADD, self, other);
530 valpy_subtract (PyObject *self, PyObject *other)
532 return valpy_binop (VALPY_SUB, self, other);
536 valpy_multiply (PyObject *self, PyObject *other)
538 return valpy_binop (VALPY_MUL, self, other);
542 valpy_divide (PyObject *self, PyObject *other)
544 return valpy_binop (VALPY_DIV, self, other);
548 valpy_remainder (PyObject *self, PyObject *other)
550 return valpy_binop (VALPY_REM, self, other);
554 valpy_power (PyObject *self, PyObject *other, PyObject *unused)
556 /* We don't support the ternary form of pow. I don't know how to express
557 that, so let's just throw NotImplementedError to at least do something
559 if (unused != Py_None)
561 PyErr_SetString (PyExc_NotImplementedError,
562 "Invalid operation on gdb.Value.");
566 return valpy_binop (VALPY_POW, self, other);
570 valpy_negative (PyObject *self)
572 struct value *val = NULL;
573 volatile struct gdb_exception except;
575 TRY_CATCH (except, RETURN_MASK_ALL)
577 val = value_neg (((value_object *) self)->value);
579 GDB_PY_HANDLE_EXCEPTION (except);
581 return value_to_value_object (val);
585 valpy_positive (PyObject *self)
587 return value_to_value_object (((value_object *) self)->value);
591 valpy_absolute (PyObject *self)
593 struct value *value = ((value_object *) self)->value;
594 if (value_less (value, value_zero (value_type (value), not_lval)))
595 return valpy_negative (self);
597 return valpy_positive (self);
600 /* Implements boolean evaluation of gdb.Value. */
602 valpy_nonzero (PyObject *self)
604 value_object *self_value = (value_object *) self;
607 type = check_typedef (value_type (self_value->value));
609 if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
610 return !!value_as_long (self_value->value);
611 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
612 return value_as_double (self_value->value) != 0;
613 else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
614 return !decimal_is_zero (value_contents (self_value->value),
616 gdbarch_byte_order (get_type_arch (type)));
619 PyErr_SetString (PyExc_TypeError, _("Attempted truth testing on invalid "
625 /* Implements ~ for value objects. */
627 valpy_invert (PyObject *self)
629 struct value *val = NULL;
630 volatile struct gdb_exception except;
632 TRY_CATCH (except, RETURN_MASK_ALL)
634 val = value_complement (((value_object *) self)->value);
636 GDB_PY_HANDLE_EXCEPTION (except);
638 return value_to_value_object (val);
641 /* Implements left shift for value objects. */
643 valpy_lsh (PyObject *self, PyObject *other)
645 return valpy_binop (VALPY_LSH, self, other);
648 /* Implements right shift for value objects. */
650 valpy_rsh (PyObject *self, PyObject *other)
652 return valpy_binop (VALPY_RSH, self, other);
655 /* Implements bitwise and for value objects. */
657 valpy_and (PyObject *self, PyObject *other)
659 return valpy_binop (VALPY_BITAND, self, other);
662 /* Implements bitwise or for value objects. */
664 valpy_or (PyObject *self, PyObject *other)
666 return valpy_binop (VALPY_BITOR, self, other);
669 /* Implements bitwise xor for value objects. */
671 valpy_xor (PyObject *self, PyObject *other)
673 return valpy_binop (VALPY_BITXOR, self, other);
676 /* Implements comparison operations for value objects. */
678 valpy_richcompare (PyObject *self, PyObject *other, int op)
681 struct value *value_other;
682 volatile struct gdb_exception except;
684 if (other == Py_None)
685 /* Comparing with None is special. From what I can tell, in Python
686 None is smaller than anything else. */
698 PyErr_SetString (PyExc_NotImplementedError,
699 "Invalid operation on gdb.Value.");
703 TRY_CATCH (except, RETURN_MASK_ALL)
705 value_other = convert_value_from_python (other);
706 if (value_other == NULL)
714 result = value_less (((value_object *) self)->value, value_other);
717 result = value_less (((value_object *) self)->value, value_other)
718 || value_equal (((value_object *) self)->value, value_other);
721 result = value_equal (((value_object *) self)->value, value_other);
724 result = !value_equal (((value_object *) self)->value, value_other);
727 result = value_less (value_other, ((value_object *) self)->value);
730 result = value_less (value_other, ((value_object *) self)->value)
731 || value_equal (((value_object *) self)->value, value_other);
735 PyErr_SetString (PyExc_NotImplementedError,
736 "Invalid operation on gdb.Value.");
741 GDB_PY_HANDLE_EXCEPTION (except);
743 /* In this case, the Python exception has already been set. */
753 /* Helper function to determine if a type is "int-like". */
755 is_intlike (struct type *type, int ptr_ok)
757 CHECK_TYPEDEF (type);
758 return (TYPE_CODE (type) == TYPE_CODE_INT
759 || TYPE_CODE (type) == TYPE_CODE_ENUM
760 || TYPE_CODE (type) == TYPE_CODE_BOOL
761 || TYPE_CODE (type) == TYPE_CODE_CHAR
762 || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR));
765 /* Implements conversion to int. */
767 valpy_int (PyObject *self)
769 struct value *value = ((value_object *) self)->value;
770 struct type *type = value_type (value);
772 volatile struct gdb_exception except;
774 CHECK_TYPEDEF (type);
775 if (!is_intlike (type, 0))
777 PyErr_SetString (PyExc_RuntimeError, "cannot convert value to int");
781 TRY_CATCH (except, RETURN_MASK_ALL)
783 l = value_as_long (value);
785 GDB_PY_HANDLE_EXCEPTION (except);
787 #ifdef HAVE_LONG_LONG /* Defined by Python. */
788 /* If we have 'long long', and the value overflows a 'long', use a
789 Python Long; otherwise use a Python Int. */
790 if (sizeof (l) > sizeof (long) && (l > PyInt_GetMax ()
791 || l < (- (LONGEST) PyInt_GetMax ()) - 1))
792 return PyLong_FromLongLong (l);
794 return PyInt_FromLong (l);
797 /* Implements conversion to long. */
799 valpy_long (PyObject *self)
801 struct value *value = ((value_object *) self)->value;
802 struct type *type = value_type (value);
804 volatile struct gdb_exception except;
806 if (!is_intlike (type, 1))
808 PyErr_SetString (PyExc_RuntimeError, "cannot convert value to long");
812 TRY_CATCH (except, RETURN_MASK_ALL)
814 l = value_as_long (value);
816 GDB_PY_HANDLE_EXCEPTION (except);
818 #ifdef HAVE_LONG_LONG /* Defined by Python. */
819 return PyLong_FromLongLong (l);
821 return PyLong_FromLong (l);
825 /* Implements conversion to float. */
827 valpy_float (PyObject *self)
829 struct value *value = ((value_object *) self)->value;
830 struct type *type = value_type (value);
832 volatile struct gdb_exception except;
834 CHECK_TYPEDEF (type);
835 if (TYPE_CODE (type) != TYPE_CODE_FLT)
837 PyErr_SetString (PyExc_RuntimeError, "cannot convert value to float");
841 TRY_CATCH (except, RETURN_MASK_ALL)
843 d = value_as_double (value);
845 GDB_PY_HANDLE_EXCEPTION (except);
847 return PyFloat_FromDouble (d);
850 /* Returns an object for a value which is released from the all_values chain,
851 so its lifetime is not bound to the execution of a command. */
853 value_to_value_object (struct value *val)
855 value_object *val_obj;
857 val_obj = PyObject_New (value_object, &value_object_type);
860 val_obj->value = val;
862 val_obj->address = NULL;
863 val_obj->type = NULL;
864 note_value (val_obj);
867 return (PyObject *) val_obj;
870 /* Returns a borrowed reference to the struct value corresponding to
871 the given value object. */
873 value_object_to_value (PyObject *self)
876 if (! PyObject_TypeCheck (self, &value_object_type))
878 real = (value_object *) self;
882 /* Try to convert a Python value to a gdb value. If the value cannot
883 be converted, set a Python exception and return NULL. Returns a
884 reference to a new value on the all_values chain. */
887 convert_value_from_python (PyObject *obj)
889 struct value *value = NULL; /* -Wall */
890 PyObject *target_str, *unicode_str;
892 volatile struct gdb_exception except;
895 gdb_assert (obj != NULL);
897 TRY_CATCH (except, RETURN_MASK_ALL)
899 if (PyBool_Check (obj))
901 cmp = PyObject_IsTrue (obj);
903 value = value_from_longest (builtin_type_pybool, cmp);
905 else if (PyInt_Check (obj))
907 long l = PyInt_AsLong (obj);
909 if (! PyErr_Occurred ())
910 value = value_from_longest (builtin_type_pyint, l);
912 else if (PyLong_Check (obj))
914 LONGEST l = PyLong_AsLongLong (obj);
916 if (! PyErr_Occurred ())
917 value = value_from_longest (builtin_type_pylong, l);
919 else if (PyFloat_Check (obj))
921 double d = PyFloat_AsDouble (obj);
923 if (! PyErr_Occurred ())
924 value = value_from_double (builtin_type_pyfloat, d);
926 else if (gdbpy_is_string (obj))
930 s = python_string_to_target_string (obj);
933 old = make_cleanup (xfree, s);
934 value = value_cstring (s, strlen (s), builtin_type_pychar);
938 else if (PyObject_TypeCheck (obj, &value_object_type))
939 value = value_copy (((value_object *) obj)->value);
941 PyErr_Format (PyExc_TypeError, _("Could not convert Python object: %s"),
942 PyString_AsString (PyObject_Str (obj)));
944 if (except.reason < 0)
946 PyErr_Format (except.reason == RETURN_QUIT
947 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
948 "%s", except.message);
955 /* Returns value object in the ARGth position in GDB's history. */
957 gdbpy_history (PyObject *self, PyObject *args)
960 struct value *res_val = NULL; /* Initialize to appease gcc warning. */
961 volatile struct gdb_exception except;
963 if (!PyArg_ParseTuple (args, "i", &i))
966 TRY_CATCH (except, RETURN_MASK_ALL)
968 res_val = access_value_history (i);
970 GDB_PY_HANDLE_EXCEPTION (except);
972 return value_to_value_object (res_val);
976 gdbpy_initialize_values (void)
978 if (PyType_Ready (&value_object_type) < 0)
981 Py_INCREF (&value_object_type);
982 PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type);
984 values_in_python = NULL;
989 static PyGetSetDef value_object_getset[] = {
990 { "address", valpy_get_address, NULL, "The address of the value.",
992 { "is_optimized_out", valpy_get_is_optimized_out, NULL,
993 "Boolean telling whether the value is optimized out (i.e., not available).",
995 { "type", valpy_get_type, NULL, "Type of the value.", NULL },
996 {NULL} /* Sentinel */
999 static PyMethodDef value_object_methods[] = {
1000 { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." },
1001 { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
1002 { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
1003 "string ([encoding] [, errors] [, length]) -> string\n\
1004 Return Unicode string representation of the value." },
1005 {NULL} /* Sentinel */
1008 static PyNumberMethods value_object_as_number = {
1014 NULL, /* nb_divmod */
1015 valpy_power, /* nb_power */
1016 valpy_negative, /* nb_negative */
1017 valpy_positive, /* nb_positive */
1018 valpy_absolute, /* nb_absolute */
1019 valpy_nonzero, /* nb_nonzero */
1020 valpy_invert, /* nb_invert */
1021 valpy_lsh, /* nb_lshift */
1022 valpy_rsh, /* nb_rshift */
1023 valpy_and, /* nb_and */
1024 valpy_xor, /* nb_xor */
1025 valpy_or, /* nb_or */
1026 NULL, /* nb_coerce */
1027 valpy_int, /* nb_int */
1028 valpy_long, /* nb_long */
1029 valpy_float, /* nb_float */
1034 static PyMappingMethods value_object_as_mapping = {
1040 PyTypeObject value_object_type = {
1041 PyObject_HEAD_INIT (NULL)
1043 "gdb.Value", /*tp_name*/
1044 sizeof (value_object), /*tp_basicsize*/
1046 valpy_dealloc, /*tp_dealloc*/
1052 &value_object_as_number, /*tp_as_number*/
1053 0, /*tp_as_sequence*/
1054 &value_object_as_mapping, /*tp_as_mapping*/
1057 valpy_str, /*tp_str*/
1061 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
1062 "GDB value object", /* tp_doc */
1063 0, /* tp_traverse */
1065 valpy_richcompare, /* tp_richcompare */
1066 0, /* tp_weaklistoffset */
1068 0, /* tp_iternext */
1069 value_object_methods, /* tp_methods */
1071 value_object_getset, /* tp_getset */
1074 0, /* tp_descr_get */
1075 0, /* tp_descr_set */
1076 0, /* tp_dictoffset */
1079 valpy_new /* tp_new */
1085 preserve_python_values (struct objfile *objfile, htab_t copied_types)
1090 #endif /* HAVE_PYTHON */