contrib/gdb-7/gdb/python/py-value.c

   1 /* Python interface to values.
   2
   3    Copyright (C) 2008-2013 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 #include "defs.h"
  21 #include "gdb_assert.h"
  22 #include "charset.h"
  23 #include "value.h"
  24 #include "exceptions.h"
  25 #include "language.h"
  26 #include "dfp.h"
  27 #include "valprint.h"
  28 #include "infcall.h"
  29 #include "expression.h"
  30 #include "cp-abi.h"
  31 #include "python.h"
  32
  33 #ifdef HAVE_PYTHON
  34
  35 #include "python-internal.h"
  36
  37 /* Even though Python scalar types directly map to host types, we use
  38    target types here to remain consistent with the values system in
  39    GDB (which uses target arithmetic).  */
  40
  41 /* Python's integer type corresponds to C's long type.  */
  42 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
  43
  44 /* Python's float type corresponds to C's double type.  */
  45 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
  46
  47 /* Python's long type corresponds to C's long long type.  */
  48 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
  49
  50 /* Python's long type corresponds to C's long long type.  Unsigned version.  */
  51 #define builtin_type_upylong builtin_type \
  52   (python_gdbarch)->builtin_unsigned_long_long
  53
  54 #define builtin_type_pybool \
  55   language_bool_type (python_language, python_gdbarch)
  56
  57 #define builtin_type_pychar \
  58   language_string_char_type (python_language, python_gdbarch)
  59
  60 typedef struct value_object {
  61   PyObject_HEAD
  62   struct value_object *next;
  63   struct value_object *prev;
  64   struct value *value;
  65   PyObject *address;
  66   PyObject *type;
  67   PyObject *dynamic_type;
  68 } value_object;
  69
  70 /* List of all values which are currently exposed to Python. It is
  71    maintained so that when an objfile is discarded, preserve_values
  72    can copy the values' types if needed.  */
  73 /* This variable is unnecessarily initialized to NULL in order to
  74    work around a linker bug on MacOS.  */
  75 static value_object *values_in_python = NULL;
  76
  77 /* Called by the Python interpreter when deallocating a value object.  */
  78 static void
  79 valpy_dealloc (PyObject *obj)
  80 {
  81   value_object *self = (value_object *) obj;
  82
  83   /* Remove SELF from the global list.  */
  84   if (self->prev)
  85     self->prev->next = self->next;
  86   else
  87     {
  88       gdb_assert (values_in_python == self);
  89       values_in_python = self->next;
  90     }
  91   if (self->next)
  92     self->next->prev = self->prev;
  93
  94   value_free (self->value);
  95
  96   if (self->address)
  97     /* Use braces to appease gcc warning.  *sigh*  */
  98     {
  99       Py_DECREF (self->address);
 100     }
 101
 102   if (self->type)
 103     {
 104       Py_DECREF (self->type);
 105     }
 106
 107   Py_XDECREF (self->dynamic_type);
 108
 109   Py_TYPE (self)->tp_free (self);
 110 }
 111
 112 /* Helper to push a Value object on the global list.  */
 113 static void
 114 note_value (value_object *value_obj)
 115 {
 116   value_obj->next = values_in_python;
 117   if (value_obj->next)
 118     value_obj->next->prev = value_obj;
 119   value_obj->prev = NULL;
 120   values_in_python = value_obj;
 121 }
 122
 123 /* Called when a new gdb.Value object needs to be allocated.  Returns NULL on
 124    error, with a python exception set.  */
 125 static PyObject *
 126 valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords)
 127 {
 128   struct value *value = NULL;   /* Initialize to appease gcc warning.  */
 129   value_object *value_obj;
 130
 131   if (PyTuple_Size (args) != 1)
 132     {
 133       PyErr_SetString (PyExc_TypeError, _("Value object creation takes only "
 134                                           "1 argument"));
 135       return NULL;
 136     }
 137
 138   value_obj = (value_object *) subtype->tp_alloc (subtype, 1);
 139   if (value_obj == NULL)
 140     {
 141       PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to "
 142                                             "create Value object."));
 143       return NULL;
 144     }
 145
 146   value = convert_value_from_python (PyTuple_GetItem (args, 0));
 147   if (value == NULL)
 148     {
 149       subtype->tp_free (value_obj);
 150       return NULL;
 151     }
 152
 153   value_obj->value = value;
 154   release_value_or_incref (value);
 155   value_obj->address = NULL;
 156   value_obj->type = NULL;
 157   value_obj->dynamic_type = NULL;
 158   note_value (value_obj);
 159
 160   return (PyObject *) value_obj;
 161 }
 162
 163 /* Iterate over all the Value objects, calling preserve_one_value on
 164    each.  */
 165 void
 166 preserve_python_values (struct objfile *objfile, htab_t copied_types)
 167 {
 168   value_object *iter;
 169
 170   for (iter = values_in_python; iter; iter = iter->next)
 171     preserve_one_value (iter->value, objfile, copied_types);
 172 }
 173
 174 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 175 static PyObject *
 176 valpy_dereference (PyObject *self, PyObject *args)
 177 {
 178   volatile struct gdb_exception except;
 179   PyObject *result = NULL;
 180
 181   TRY_CATCH (except, RETURN_MASK_ALL)
 182     {
 183       struct value *res_val;
 184       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 185
 186       res_val = value_ind (((value_object *) self)->value);
 187       result = value_to_value_object (res_val);
 188       do_cleanups (cleanup);
 189     }
 190   GDB_PY_HANDLE_EXCEPTION (except);
 191
 192   return result;
 193 }
 194
 195 /* Given a value of a pointer type or a reference type, return the value
 196    referenced. The difference between this function and valpy_dereference is
 197    that the latter applies * unary operator to a value, which need not always
 198    result in the value referenced. For example, for a value which is a reference
 199    to an 'int' pointer ('int *'), valpy_dereference will result in a value of
 200    type 'int' while valpy_referenced_value will result in a value of type
 201    'int *'.  */
 202
 203 static PyObject *
 204 valpy_referenced_value (PyObject *self, PyObject *args)
 205 {
 206   volatile struct gdb_exception except;
 207   PyObject *result = NULL;
 208
 209   TRY_CATCH (except, RETURN_MASK_ALL)
 210     {
 211       struct value *self_val, *res_val;
 212       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 213
 214       self_val = ((value_object *) self)->value;
 215       switch (TYPE_CODE (check_typedef (value_type (self_val))))
 216         {
 217         case TYPE_CODE_PTR:
 218           res_val = value_ind (self_val);
 219           break;
 220         case TYPE_CODE_REF:
 221           res_val = coerce_ref (self_val);
 222           break;
 223         default:
 224           error(_("Trying to get the referenced value from a value which is "
 225                   "neither a pointer nor a reference."));
 226         }
 227
 228       result = value_to_value_object (res_val);
 229       do_cleanups (cleanup);
 230     }
 231   GDB_PY_HANDLE_EXCEPTION (except);
 232
 233   return result;
 234 }
 235
 236 /* Return "&value".  */
 237 static PyObject *
 238 valpy_get_address (PyObject *self, void *closure)
 239 {
 240   value_object *val_obj = (value_object *) self;
 241   volatile struct gdb_exception except;
 242
 243   if (!val_obj->address)
 244     {
 245       TRY_CATCH (except, RETURN_MASK_ALL)
 246         {
 247           struct value *res_val;
 248           struct cleanup *cleanup
 249             = make_cleanup_value_free_to_mark (value_mark ());
 250
 251           res_val = value_addr (val_obj->value);
 252           val_obj->address = value_to_value_object (res_val);
 253           do_cleanups (cleanup);
 254         }
 255       if (except.reason < 0)
 256         {
 257           val_obj->address = Py_None;
 258           Py_INCREF (Py_None);
 259         }
 260     }
 261
 262   Py_XINCREF (val_obj->address);
 263
 264   return val_obj->address;
 265 }
 266
 267 /* Return type of the value.  */
 268 static PyObject *
 269 valpy_get_type (PyObject *self, void *closure)
 270 {
 271   value_object *obj = (value_object *) self;
 272
 273   if (!obj->type)
 274     {
 275       obj->type = type_to_type_object (value_type (obj->value));
 276       if (!obj->type)
 277         return NULL;
 278     }
 279   Py_INCREF (obj->type);
 280   return obj->type;
 281 }
 282
 283 /* Return dynamic type of the value.  */
 284
 285 static PyObject *
 286 valpy_get_dynamic_type (PyObject *self, void *closure)
 287 {
 288   value_object *obj = (value_object *) self;
 289   volatile struct gdb_exception except;
 290   struct type *type = NULL;
 291
 292   if (obj->dynamic_type != NULL)
 293     {
 294       Py_INCREF (obj->dynamic_type);
 295       return obj->dynamic_type;
 296     }
 297
 298   TRY_CATCH (except, RETURN_MASK_ALL)
 299     {
 300       struct value *val = obj->value;
 301       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 302
 303       type = value_type (val);
 304       CHECK_TYPEDEF (type);
 305
 306       if (((TYPE_CODE (type) == TYPE_CODE_PTR)
 307            || (TYPE_CODE (type) == TYPE_CODE_REF))
 308           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 309         {
 310           struct value *target;
 311           int was_pointer = TYPE_CODE (type) == TYPE_CODE_PTR;
 312
 313           target = value_ind (val);
 314           type = value_rtti_type (target, NULL, NULL, NULL);
 315
 316           if (type)
 317             {
 318               if (was_pointer)
 319                 type = lookup_pointer_type (type);
 320               else
 321                 type = lookup_reference_type (type);
 322             }
 323         }
 324       else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
 325         type = value_rtti_type (val, NULL, NULL, NULL);
 326       else
 327         {
 328           /* Re-use object's static type.  */
 329           type = NULL;
 330         }
 331
 332       do_cleanups (cleanup);
 333     }
 334   GDB_PY_HANDLE_EXCEPTION (except);
 335
 336   if (type == NULL)
 337     {
 338       /* Ensure that the TYPE field is ready.  */
 339       if (!valpy_get_type (self, NULL))
 340         return NULL;
 341       /* We don't need to incref here, because valpy_get_type already
 342          did it for us.  */
 343       obj->dynamic_type = obj->type;
 344     }
 345   else
 346     obj->dynamic_type = type_to_type_object (type);
 347
 348   Py_INCREF (obj->dynamic_type);
 349   return obj->dynamic_type;
 350 }
 351
 352 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
 353    string.  Return a PyObject representing a lazy_string_object type.
 354    A lazy string is a pointer to a string with an optional encoding and
 355    length.  If ENCODING is not given, encoding is set to None.  If an
 356    ENCODING is provided the encoding parameter is set to ENCODING, but
 357    the string is not encoded.  If LENGTH is provided then the length
 358    parameter is set to LENGTH, otherwise length will be set to -1 (first
 359    null of appropriate with).  */
 360 static PyObject *
 361 valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
 362 {
 363   gdb_py_longest length = -1;
 364   struct value *value = ((value_object *) self)->value;
 365   const char *user_encoding = NULL;
 366   static char *keywords[] = { "encoding", "length", NULL };
 367   PyObject *str_obj = NULL;
 368   volatile struct gdb_exception except;
 369
 370   if (!PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG, keywords,
 371                                     &user_encoding, &length))
 372     return NULL;
 373
 374   TRY_CATCH (except, RETURN_MASK_ALL)
 375     {
 376       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 377
 378       if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR)
 379         value = value_ind (value);
 380
 381       str_obj = gdbpy_create_lazy_string_object (value_address (value), length,
 382                                                  user_encoding,
 383                                                  value_type (value));
 384
 385       do_cleanups (cleanup);
 386     }
 387   GDB_PY_HANDLE_EXCEPTION (except);
 388
 389   return str_obj;
 390 }
 391
 392 /* Implementation of gdb.Value.string ([encoding] [, errors]
 393    [, length]) -> string.  Return Unicode string with value contents.
 394    If ENCODING is not given, the string is assumed to be encoded in
 395    the target's charset.  If LENGTH is provided, only fetch string to
 396    the length provided.  */
 397
 398 static PyObject *
 399 valpy_string (PyObject *self, PyObject *args, PyObject *kw)
 400 {
 401   int length = -1;
 402   gdb_byte *buffer;
 403   struct value *value = ((value_object *) self)->value;
 404   volatile struct gdb_exception except;
 405   PyObject *unicode;
 406   const char *encoding = NULL;
 407   const char *errors = NULL;
 408   const char *user_encoding = NULL;
 409   const char *la_encoding = NULL;
 410   struct type *char_type;
 411   static char *keywords[] = { "encoding", "errors", "length", NULL };
 412
 413   if (!PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
 414                                     &user_encoding, &errors, &length))
 415     return NULL;
 416
 417   TRY_CATCH (except, RETURN_MASK_ALL)
 418     {
 419       LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
 420     }
 421   GDB_PY_HANDLE_EXCEPTION (except);
 422
 423   encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
 424   unicode = PyUnicode_Decode (buffer, length * TYPE_LENGTH (char_type),
 425                               encoding, errors);
 426   xfree (buffer);
 427
 428   return unicode;
 429 }
 430
 431 /* A helper function that implements the various cast operators.  */
 432
 433 static PyObject *
 434 valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op)
 435 {
 436   PyObject *type_obj, *result = NULL;
 437   struct type *type;
 438   volatile struct gdb_exception except;
 439
 440   if (! PyArg_ParseTuple (args, "O", &type_obj))
 441     return NULL;
 442
 443   type = type_object_to_type (type_obj);
 444   if (! type)
 445     {
 446       PyErr_SetString (PyExc_RuntimeError,
 447                        _("Argument must be a type."));
 448       return NULL;
 449     }
 450
 451   TRY_CATCH (except, RETURN_MASK_ALL)
 452     {
 453       struct value *val = ((value_object *) self)->value;
 454       struct value *res_val;
 455       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 456
 457       if (op == UNOP_DYNAMIC_CAST)
 458         res_val = value_dynamic_cast (type, val);
 459       else if (op == UNOP_REINTERPRET_CAST)
 460         res_val = value_reinterpret_cast (type, val);
 461       else
 462         {
 463           gdb_assert (op == UNOP_CAST);
 464           res_val = value_cast (type, val);
 465         }
 466
 467       result = value_to_value_object (res_val);
 468       do_cleanups (cleanup);
 469     }
 470   GDB_PY_HANDLE_EXCEPTION (except);
 471
 472   return result;
 473 }
 474
 475 /* Implementation of the "cast" method.  */
 476
 477 static PyObject *
 478 valpy_cast (PyObject *self, PyObject *args)
 479 {
 480   return valpy_do_cast (self, args, UNOP_CAST);
 481 }
 482
 483 /* Implementation of the "dynamic_cast" method.  */
 484
 485 static PyObject *
 486 valpy_dynamic_cast (PyObject *self, PyObject *args)
 487 {
 488   return valpy_do_cast (self, args, UNOP_DYNAMIC_CAST);
 489 }
 490
 491 /* Implementation of the "reinterpret_cast" method.  */
 492
 493 static PyObject *
 494 valpy_reinterpret_cast (PyObject *self, PyObject *args)
 495 {
 496   return valpy_do_cast (self, args, UNOP_REINTERPRET_CAST);
 497 }
 498
 499 static Py_ssize_t
 500 valpy_length (PyObject *self)
 501 {
 502   /* We don't support getting the number of elements in a struct / class.  */
 503   PyErr_SetString (PyExc_NotImplementedError,
 504                    _("Invalid operation on gdb.Value."));
 505   return -1;
 506 }
 507
 508 /* Given string name of an element inside structure, return its value
 509    object.  Returns NULL on error, with a python exception set.  */
 510 static PyObject *
 511 valpy_getitem (PyObject *self, PyObject *key)
 512 {
 513   value_object *self_value = (value_object *) self;
 514   char *field = NULL;
 515   volatile struct gdb_exception except;
 516   PyObject *result = NULL;
 517
 518   if (gdbpy_is_string (key))
 519     {
 520       field = python_string_to_host_string (key);
 521       if (field == NULL)
 522         return NULL;
 523     }
 524
 525   TRY_CATCH (except, RETURN_MASK_ALL)
 526     {
 527       struct value *tmp = self_value->value;
 528       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 529       struct value *res_val = NULL;
 530
 531       if (field)
 532         res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
 533       else
 534         {
 535           /* Assume we are attempting an array access, and let the
 536              value code throw an exception if the index has an invalid
 537              type.  */
 538           struct value *idx = convert_value_from_python (key);
 539
 540           if (idx != NULL)
 541             {
 542               /* Check the value's type is something that can be accessed via
 543                  a subscript.  */
 544               struct type *type;
 545
 546               tmp = coerce_ref (tmp);
 547               type = check_typedef (value_type (tmp));
 548               if (TYPE_CODE (type) != TYPE_CODE_ARRAY
 549                   && TYPE_CODE (type) != TYPE_CODE_PTR)
 550                   error (_("Cannot subscript requested type."));
 551               else
 552                 res_val = value_subscript (tmp, value_as_long (idx));
 553             }
 554         }
 555
 556       if (res_val)
 557         result = value_to_value_object (res_val);
 558       do_cleanups (cleanup);
 559     }
 560
 561   xfree (field);
 562   GDB_PY_HANDLE_EXCEPTION (except);
 563
 564   return result;
 565 }
 566
 567 static int
 568 valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
 569 {
 570   PyErr_Format (PyExc_NotImplementedError,
 571                 _("Setting of struct elements is not currently supported."));
 572   return -1;
 573 }
 574
 575 /* Called by the Python interpreter to perform an inferior function
 576    call on the value.  Returns NULL on error, with a python exception set.  */
 577 static PyObject *
 578 valpy_call (PyObject *self, PyObject *args, PyObject *keywords)
 579 {
 580   Py_ssize_t args_count;
 581   volatile struct gdb_exception except;
 582   struct value *function = ((value_object *) self)->value;
 583   struct value **vargs = NULL;
 584   struct type *ftype = NULL;
 585   struct value *mark = value_mark ();
 586   PyObject *result = NULL;
 587
 588   TRY_CATCH (except, RETURN_MASK_ALL)
 589     {
 590       ftype = check_typedef (value_type (function));
 591     }
 592   GDB_PY_HANDLE_EXCEPTION (except);
 593
 594   if (TYPE_CODE (ftype) != TYPE_CODE_FUNC)
 595     {
 596       PyErr_SetString (PyExc_RuntimeError,
 597                        _("Value is not callable (not TYPE_CODE_FUNC)."));
 598       return NULL;
 599     }
 600
 601   if (! PyTuple_Check (args))
 602     {
 603       PyErr_SetString (PyExc_TypeError,
 604                        _("Inferior arguments must be provided in a tuple."));
 605       return NULL;
 606     }
 607
 608   args_count = PyTuple_Size (args);
 609   if (args_count > 0)
 610     {
 611       int i;
 612
 613       vargs = alloca (sizeof (struct value *) * args_count);
 614       for (i = 0; i < args_count; i++)
 615         {
 616           PyObject *item = PyTuple_GetItem (args, i);
 617
 618           if (item == NULL)
 619             return NULL;
 620
 621           vargs[i] = convert_value_from_python (item);
 622           if (vargs[i] == NULL)
 623             return NULL;
 624         }
 625     }
 626
 627   TRY_CATCH (except, RETURN_MASK_ALL)
 628     {
 629       struct cleanup *cleanup = make_cleanup_value_free_to_mark (mark);
 630       struct value *return_value;
 631
 632       return_value = call_function_by_hand (function, args_count, vargs);
 633       result = value_to_value_object (return_value);
 634       do_cleanups (cleanup);
 635     }
 636   GDB_PY_HANDLE_EXCEPTION (except);
 637
 638   return result;
 639 }
 640
 641 /* Called by the Python interpreter to obtain string representation
 642    of the object.  */
 643 static PyObject *
 644 valpy_str (PyObject *self)
 645 {
 646   char *s = NULL;
 647   PyObject *result;
 648   struct value_print_options opts;
 649   volatile struct gdb_exception except;
 650
 651   get_user_print_options (&opts);
 652   opts.deref_ref = 0;
 653
 654   TRY_CATCH (except, RETURN_MASK_ALL)
 655     {
 656       struct ui_file *stb = mem_fileopen ();
 657       struct cleanup *old_chain = make_cleanup_ui_file_delete (stb);
 658
 659       common_val_print (((value_object *) self)->value, stb, 0,
 660                         &opts, python_language);
 661       s = ui_file_xstrdup (stb, NULL);
 662
 663       do_cleanups (old_chain);
 664     }
 665   GDB_PY_HANDLE_EXCEPTION (except);
 666
 667   result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL);
 668   xfree (s);
 669
 670   return result;
 671 }
 672
 673 /* Implements gdb.Value.is_optimized_out.  */
 674 static PyObject *
 675 valpy_get_is_optimized_out (PyObject *self, void *closure)
 676 {
 677   struct value *value = ((value_object *) self)->value;
 678   int opt = 0;
 679   volatile struct gdb_exception except;
 680
 681   TRY_CATCH (except, RETURN_MASK_ALL)
 682     {
 683       opt = value_optimized_out (value);
 684     }
 685   GDB_PY_HANDLE_EXCEPTION (except);
 686
 687   if (opt)
 688     Py_RETURN_TRUE;
 689
 690   Py_RETURN_FALSE;
 691 }
 692
 693 /* Implements gdb.Value.is_lazy.  */
 694 static PyObject *
 695 valpy_get_is_lazy (PyObject *self, void *closure)
 696 {
 697   struct value *value = ((value_object *) self)->value;
 698   int opt = 0;
 699   volatile struct gdb_exception except;
 700
 701   TRY_CATCH (except, RETURN_MASK_ALL)
 702     {
 703       opt = value_lazy (value);
 704     }
 705   GDB_PY_HANDLE_EXCEPTION (except);
 706
 707   if (opt)
 708     Py_RETURN_TRUE;
 709
 710   Py_RETURN_FALSE;
 711 }
 712
 713 /* Implements gdb.Value.fetch_lazy ().  */
 714 static PyObject *
 715 valpy_fetch_lazy (PyObject *self, PyObject *args)
 716 {
 717   struct value *value = ((value_object *) self)->value;
 718   volatile struct gdb_exception except;
 719
 720   TRY_CATCH (except, RETURN_MASK_ALL)
 721     {
 722       if (value_lazy (value))
 723         value_fetch_lazy (value);
 724     }
 725   GDB_PY_HANDLE_EXCEPTION (except);
 726
 727   Py_RETURN_NONE;
 728 }
 729
 730 /* Calculate and return the address of the PyObject as the value of
 731    the builtin __hash__ call.  */
 732 static long
 733 valpy_hash (PyObject *self)
 734 {
 735   return (long) (intptr_t) self;
 736 }
 737
 738 enum valpy_opcode
 739 {
 740   VALPY_ADD,
 741   VALPY_SUB,
 742   VALPY_MUL,
 743   VALPY_DIV,
 744   VALPY_REM,
 745   VALPY_POW,
 746   VALPY_LSH,
 747   VALPY_RSH,
 748   VALPY_BITAND,
 749   VALPY_BITOR,
 750   VALPY_BITXOR
 751 };
 752
 753 /* If TYPE is a reference, return the target; otherwise return TYPE.  */
 754 #define STRIP_REFERENCE(TYPE) \
 755   ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
 756
 757 /* Returns a value object which is the result of applying the operation
 758    specified by OPCODE to the given arguments.  Returns NULL on error, with
 759    a python exception set.  */
 760 static PyObject *
 761 valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
 762 {
 763   volatile struct gdb_exception except;
 764   PyObject *result = NULL;
 765
 766   TRY_CATCH (except, RETURN_MASK_ALL)
 767     {
 768       struct value *arg1, *arg2;
 769       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 770       struct value *res_val = NULL;
 771
 772       /* If the gdb.Value object is the second operand, then it will be passed
 773          to us as the OTHER argument, and SELF will be an entirely different
 774          kind of object, altogether.  Because of this, we can't assume self is
 775          a gdb.Value object and need to convert it from python as well.  */
 776       arg1 = convert_value_from_python (self);
 777       if (arg1 == NULL)
 778         break;
 779
 780       arg2 = convert_value_from_python (other);
 781       if (arg2 == NULL)
 782         break;
 783
 784       switch (opcode)
 785         {
 786         case VALPY_ADD:
 787           {
 788             struct type *ltype = value_type (arg1);
 789             struct type *rtype = value_type (arg2);
 790
 791             CHECK_TYPEDEF (ltype);
 792             ltype = STRIP_REFERENCE (ltype);
 793             CHECK_TYPEDEF (rtype);
 794             rtype = STRIP_REFERENCE (rtype);
 795
 796             if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 797                 && is_integral_type (rtype))
 798               res_val = value_ptradd (arg1, value_as_long (arg2));
 799             else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
 800                      && is_integral_type (ltype))
 801               res_val = value_ptradd (arg2, value_as_long (arg1));
 802             else
 803               res_val = value_binop (arg1, arg2, BINOP_ADD);
 804           }
 805           break;
 806         case VALPY_SUB:
 807           {
 808             struct type *ltype = value_type (arg1);
 809             struct type *rtype = value_type (arg2);
 810
 811             CHECK_TYPEDEF (ltype);
 812             ltype = STRIP_REFERENCE (ltype);
 813             CHECK_TYPEDEF (rtype);
 814             rtype = STRIP_REFERENCE (rtype);
 815
 816             if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 817                 && TYPE_CODE (rtype) == TYPE_CODE_PTR)
 818               /* A ptrdiff_t for the target would be preferable here.  */
 819               res_val = value_from_longest (builtin_type_pyint,
 820                                             value_ptrdiff (arg1, arg2));
 821             else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 822                      && is_integral_type (rtype))
 823               res_val = value_ptradd (arg1, - value_as_long (arg2));
 824             else
 825               res_val = value_binop (arg1, arg2, BINOP_SUB);
 826           }
 827           break;
 828         case VALPY_MUL:
 829           res_val = value_binop (arg1, arg2, BINOP_MUL);
 830           break;
 831         case VALPY_DIV:
 832           res_val = value_binop (arg1, arg2, BINOP_DIV);
 833           break;
 834         case VALPY_REM:
 835           res_val = value_binop (arg1, arg2, BINOP_REM);
 836           break;
 837         case VALPY_POW:
 838           res_val = value_binop (arg1, arg2, BINOP_EXP);
 839           break;
 840         case VALPY_LSH:
 841           res_val = value_binop (arg1, arg2, BINOP_LSH);
 842           break;
 843         case VALPY_RSH:
 844           res_val = value_binop (arg1, arg2, BINOP_RSH);
 845           break;
 846         case VALPY_BITAND:
 847           res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
 848           break;
 849         case VALPY_BITOR:
 850           res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
 851           break;
 852         case VALPY_BITXOR:
 853           res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
 854           break;
 855         }
 856
 857       if (res_val)
 858         result = value_to_value_object (res_val);
 859
 860       do_cleanups (cleanup);
 861     }
 862   GDB_PY_HANDLE_EXCEPTION (except);
 863
 864   return result;
 865 }
 866
 867 static PyObject *
 868 valpy_add (PyObject *self, PyObject *other)
 869 {
 870   return valpy_binop (VALPY_ADD, self, other);
 871 }
 872
 873 static PyObject *
 874 valpy_subtract (PyObject *self, PyObject *other)
 875 {
 876   return valpy_binop (VALPY_SUB, self, other);
 877 }
 878
 879 static PyObject *
 880 valpy_multiply (PyObject *self, PyObject *other)
 881 {
 882   return valpy_binop (VALPY_MUL, self, other);
 883 }
 884
 885 static PyObject *
 886 valpy_divide (PyObject *self, PyObject *other)
 887 {
 888   return valpy_binop (VALPY_DIV, self, other);
 889 }
 890
 891 static PyObject *
 892 valpy_remainder (PyObject *self, PyObject *other)
 893 {
 894   return valpy_binop (VALPY_REM, self, other);
 895 }
 896
 897 static PyObject *
 898 valpy_power (PyObject *self, PyObject *other, PyObject *unused)
 899 {
 900   /* We don't support the ternary form of pow.  I don't know how to express
 901      that, so let's just throw NotImplementedError to at least do something
 902      about it.  */
 903   if (unused != Py_None)
 904     {
 905       PyErr_SetString (PyExc_NotImplementedError,
 906                        "Invalid operation on gdb.Value.");
 907       return NULL;
 908     }
 909
 910   return valpy_binop (VALPY_POW, self, other);
 911 }
 912
 913 static PyObject *
 914 valpy_negative (PyObject *self)
 915 {
 916   volatile struct gdb_exception except;
 917   PyObject *result = NULL;
 918
 919   TRY_CATCH (except, RETURN_MASK_ALL)
 920     {
 921       /* Perhaps overkill, but consistency has some virtue.  */
 922       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 923       struct value *val;
 924
 925       val = value_neg (((value_object *) self)->value);
 926       result = value_to_value_object (val);
 927       do_cleanups (cleanup);
 928     }
 929   GDB_PY_HANDLE_EXCEPTION (except);
 930
 931   return result;
 932 }
 933
 934 static PyObject *
 935 valpy_positive (PyObject *self)
 936 {
 937   return value_to_value_object (((value_object *) self)->value);
 938 }
 939
 940 static PyObject *
 941 valpy_absolute (PyObject *self)
 942 {
 943   struct value *value = ((value_object *) self)->value;
 944   volatile struct gdb_exception except;
 945   int isabs = 1;
 946
 947   TRY_CATCH (except, RETURN_MASK_ALL)
 948     {
 949       struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 950
 951       if (value_less (value, value_zero (value_type (value), not_lval)))
 952         isabs = 0;
 953
 954       do_cleanups (cleanup);
 955     }
 956   GDB_PY_HANDLE_EXCEPTION (except);
 957
 958   if (isabs)
 959     return valpy_positive (self);
 960   else
 961     return valpy_negative (self);
 962 }
 963
 964 /* Implements boolean evaluation of gdb.Value.  */
 965 static int
 966 valpy_nonzero (PyObject *self)
 967 {
 968   volatile struct gdb_exception except;
 969   value_object *self_value = (value_object *) self;
 970   struct type *type;
 971   int nonzero = 0; /* Appease GCC warning.  */
 972
 973   TRY_CATCH (except, RETURN_MASK_ALL)
 974     {
 975       type = check_typedef (value_type (self_value->value));
 976
 977       if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
 978         nonzero = !!value_as_long (self_value->value);
 979       else if (TYPE_CODE (type) == TYPE_CODE_FLT)
 980         nonzero = value_as_double (self_value->value) != 0;
 981       else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
 982         nonzero = !decimal_is_zero (value_contents (self_value->value),
 983                                  TYPE_LENGTH (type),
 984                                  gdbarch_byte_order (get_type_arch (type)));
 985       else
 986         /* All other values are True.  */
 987         nonzero = 1;
 988     }
 989   /* This is not documented in the Python documentation, but if this
 990      function fails, return -1 as slot_nb_nonzero does (the default
 991      Python nonzero function).  */
 992   GDB_PY_SET_HANDLE_EXCEPTION (except);
 993
 994   return nonzero;
 995 }
 996
 997 /* Implements ~ for value objects.  */
 998 static PyObject *
 999 valpy_invert (PyObject *self)
1000 {
1001   struct value *val = NULL;
1002   volatile struct gdb_exception except;
1003
1004   TRY_CATCH (except, RETURN_MASK_ALL)
1005     {
1006       val = value_complement (((value_object *) self)->value);
1007     }
1008   GDB_PY_HANDLE_EXCEPTION (except);
1009
1010   return value_to_value_object (val);
1011 }
1012
1013 /* Implements left shift for value objects.  */
1014 static PyObject *
1015 valpy_lsh (PyObject *self, PyObject *other)
1016 {
1017   return valpy_binop (VALPY_LSH, self, other);
1018 }
1019
1020 /* Implements right shift for value objects.  */
1021 static PyObject *
1022 valpy_rsh (PyObject *self, PyObject *other)
1023 {
1024   return valpy_binop (VALPY_RSH, self, other);
1025 }
1026
1027 /* Implements bitwise and for value objects.  */
1028 static PyObject *
1029 valpy_and (PyObject *self, PyObject *other)
1030 {
1031   return valpy_binop (VALPY_BITAND, self, other);
1032 }
1033
1034 /* Implements bitwise or for value objects.  */
1035 static PyObject *
1036 valpy_or (PyObject *self, PyObject *other)
1037 {
1038   return valpy_binop (VALPY_BITOR, self, other);
1039 }
1040
1041 /* Implements bitwise xor for value objects.  */
1042 static PyObject *
1043 valpy_xor (PyObject *self, PyObject *other)
1044 {
1045   return valpy_binop (VALPY_BITXOR, self, other);
1046 }
1047
1048 /* Implements comparison operations for value objects.  Returns NULL on error,
1049    with a python exception set.  */
1050 static PyObject *
1051 valpy_richcompare (PyObject *self, PyObject *other, int op)
1052 {
1053   int result = 0;
1054   volatile struct gdb_exception except;
1055
1056   if (other == Py_None)
1057     /* Comparing with None is special.  From what I can tell, in Python
1058        None is smaller than anything else.  */
1059     switch (op) {
1060       case Py_LT:
1061       case Py_LE:
1062       case Py_EQ:
1063         Py_RETURN_FALSE;
1064       case Py_NE:
1065       case Py_GT:
1066       case Py_GE:
1067         Py_RETURN_TRUE;
1068       default:
1069         /* Can't happen.  */
1070         PyErr_SetString (PyExc_NotImplementedError,
1071                          _("Invalid operation on gdb.Value."));
1072         return NULL;
1073     }
1074
1075   TRY_CATCH (except, RETURN_MASK_ALL)
1076     {
1077       struct value *value_other, *mark = value_mark ();
1078       struct cleanup *cleanup;
1079
1080       value_other = convert_value_from_python (other);
1081       if (value_other == NULL)
1082         {
1083           result = -1;
1084           break;
1085         }
1086
1087       cleanup = make_cleanup_value_free_to_mark (mark);
1088
1089       switch (op) {
1090         case Py_LT:
1091           result = value_less (((value_object *) self)->value, value_other);
1092           break;
1093         case Py_LE:
1094           result = value_less (((value_object *) self)->value, value_other)
1095             || value_equal (((value_object *) self)->value, value_other);
1096           break;
1097         case Py_EQ:
1098           result = value_equal (((value_object *) self)->value, value_other);
1099           break;
1100         case Py_NE:
1101           result = !value_equal (((value_object *) self)->value, value_other);
1102           break;
1103         case Py_GT:
1104           result = value_less (value_other, ((value_object *) self)->value);
1105           break;
1106         case Py_GE:
1107           result = value_less (value_other, ((value_object *) self)->value)
1108             || value_equal (((value_object *) self)->value, value_other);
1109           break;
1110         default:
1111           /* Can't happen.  */
1112           PyErr_SetString (PyExc_NotImplementedError,
1113                            _("Invalid operation on gdb.Value."));
1114           result = -1;
1115           break;
1116       }
1117
1118       do_cleanups (cleanup);
1119     }
1120   GDB_PY_HANDLE_EXCEPTION (except);
1121
1122   /* In this case, the Python exception has already been set.  */
1123   if (result < 0)
1124     return NULL;
1125
1126   if (result == 1)
1127     Py_RETURN_TRUE;
1128
1129   Py_RETURN_FALSE;
1130 }
1131
1132 /* Helper function to determine if a type is "int-like".  */
1133 static int
1134 is_intlike (struct type *type, int ptr_ok)
1135 {
1136   return (TYPE_CODE (type) == TYPE_CODE_INT
1137           || TYPE_CODE (type) == TYPE_CODE_ENUM
1138           || TYPE_CODE (type) == TYPE_CODE_BOOL
1139           || TYPE_CODE (type) == TYPE_CODE_CHAR
1140           || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR));
1141 }
1142
1143 #ifndef IS_PY3K
1144 /* Implements conversion to int.  */
1145 static PyObject *
1146 valpy_int (PyObject *self)
1147 {
1148   struct value *value = ((value_object *) self)->value;
1149   struct type *type = value_type (value);
1150   LONGEST l = 0;
1151   volatile struct gdb_exception except;
1152
1153   TRY_CATCH (except, RETURN_MASK_ALL)
1154     {
1155       CHECK_TYPEDEF (type);
1156       if (!is_intlike (type, 0))
1157         error (_("Cannot convert value to int."));
1158
1159       l = value_as_long (value);
1160     }
1161   GDB_PY_HANDLE_EXCEPTION (except);
1162
1163   return gdb_py_object_from_longest (l);
1164 }
1165 #endif
1166
1167 /* Implements conversion to long.  */
1168 static PyObject *
1169 valpy_long (PyObject *self)
1170 {
1171   struct value *value = ((value_object *) self)->value;
1172   struct type *type = value_type (value);
1173   LONGEST l = 0;
1174   volatile struct gdb_exception except;
1175
1176   TRY_CATCH (except, RETURN_MASK_ALL)
1177     {
1178       CHECK_TYPEDEF (type);
1179
1180       if (!is_intlike (type, 1))
1181         error (_("Cannot convert value to long."));
1182
1183       l = value_as_long (value);
1184     }
1185   GDB_PY_HANDLE_EXCEPTION (except);
1186
1187   return gdb_py_long_from_longest (l);
1188 }
1189
1190 /* Implements conversion to float.  */
1191 static PyObject *
1192 valpy_float (PyObject *self)
1193 {
1194   struct value *value = ((value_object *) self)->value;
1195   struct type *type = value_type (value);
1196   double d = 0;
1197   volatile struct gdb_exception except;
1198
1199   TRY_CATCH (except, RETURN_MASK_ALL)
1200     {
1201       CHECK_TYPEDEF (type);
1202
1203       if (TYPE_CODE (type) != TYPE_CODE_FLT)
1204         error (_("Cannot convert value to float."));
1205
1206       d = value_as_double (value);
1207     }
1208   GDB_PY_HANDLE_EXCEPTION (except);
1209
1210   return PyFloat_FromDouble (d);
1211 }
1212
1213 /* Returns an object for a value which is released from the all_values chain,
1214    so its lifetime is not bound to the execution of a command.  */
1215 PyObject *
1216 value_to_value_object (struct value *val)
1217 {
1218   value_object *val_obj;
1219
1220   val_obj = PyObject_New (value_object, &value_object_type);
1221   if (val_obj != NULL)
1222     {
1223       val_obj->value = val;
1224       release_value_or_incref (val);
1225       val_obj->address = NULL;
1226       val_obj->type = NULL;
1227       val_obj->dynamic_type = NULL;
1228       note_value (val_obj);
1229     }
1230
1231   return (PyObject *) val_obj;
1232 }
1233
1234 /* Returns a borrowed reference to the struct value corresponding to
1235    the given value object.  */
1236 struct value *
1237 value_object_to_value (PyObject *self)
1238 {
1239   value_object *real;
1240
1241   if (! PyObject_TypeCheck (self, &value_object_type))
1242     return NULL;
1243   real = (value_object *) self;
1244   return real->value;
1245 }
1246
1247 /* Try to convert a Python value to a gdb value.  If the value cannot
1248    be converted, set a Python exception and return NULL.  Returns a
1249    reference to a new value on the all_values chain.  */
1250
1251 struct value *
1252 convert_value_from_python (PyObject *obj)
1253 {
1254   struct value *value = NULL; /* -Wall */
1255   volatile struct gdb_exception except;
1256   int cmp;
1257
1258   gdb_assert (obj != NULL);
1259
1260   TRY_CATCH (except, RETURN_MASK_ALL)
1261     {
1262       if (PyBool_Check (obj))
1263         {
1264           cmp = PyObject_IsTrue (obj);
1265           if (cmp >= 0)
1266             value = value_from_longest (builtin_type_pybool, cmp);
1267         }
1268       else if (PyInt_Check (obj))
1269         {
1270           long l = PyInt_AsLong (obj);
1271
1272           if (! PyErr_Occurred ())
1273             value = value_from_longest (builtin_type_pyint, l);
1274         }
1275       else if (PyLong_Check (obj))
1276         {
1277           LONGEST l = PyLong_AsLongLong (obj);
1278
1279           if (PyErr_Occurred ())
1280             {
1281               /* If the error was an overflow, we can try converting to
1282                  ULONGEST instead.  */
1283               if (PyErr_ExceptionMatches (PyExc_OverflowError))
1284                 {
1285                   PyObject *etype, *evalue, *etraceback, *zero;
1286
1287                   PyErr_Fetch (&etype, &evalue, &etraceback);
1288                   zero = PyInt_FromLong (0);
1289
1290                   /* Check whether obj is positive.  */
1291                   if (PyObject_RichCompareBool (obj, zero, Py_GT) > 0)
1292                     {
1293                       ULONGEST ul;
1294
1295                       ul = PyLong_AsUnsignedLongLong (obj);
1296                       if (! PyErr_Occurred ())
1297                         value = value_from_ulongest (builtin_type_upylong, ul);
1298                     }
1299                   else
1300                     /* There's nothing we can do.  */
1301                     PyErr_Restore (etype, evalue, etraceback);
1302
1303                   Py_DECREF (zero);
1304                 }
1305             }
1306           else
1307             value = value_from_longest (builtin_type_pylong, l);
1308         }
1309       else if (PyFloat_Check (obj))
1310         {
1311           double d = PyFloat_AsDouble (obj);
1312
1313           if (! PyErr_Occurred ())
1314             value = value_from_double (builtin_type_pyfloat, d);
1315         }
1316       else if (gdbpy_is_string (obj))
1317         {
1318           char *s;
1319
1320           s = python_string_to_target_string (obj);
1321           if (s != NULL)
1322             {
1323               struct cleanup *old;
1324
1325               old = make_cleanup (xfree, s);
1326               value = value_cstring (s, strlen (s), builtin_type_pychar);
1327               do_cleanups (old);
1328             }
1329         }
1330       else if (PyObject_TypeCheck (obj, &value_object_type))
1331         value = value_copy (((value_object *) obj)->value);
1332       else if (gdbpy_is_lazy_string (obj))
1333         {
1334           PyObject *result;
1335
1336           result = PyObject_CallMethodObjArgs (obj, gdbpy_value_cst,  NULL);
1337           value = value_copy (((value_object *) result)->value);
1338         }
1339       else
1340 #ifdef IS_PY3K
1341         PyErr_Format (PyExc_TypeError,
1342                       _("Could not convert Python object: %S."), obj);
1343 #else
1344         PyErr_Format (PyExc_TypeError,
1345                       _("Could not convert Python object: %s."),
1346                       PyString_AsString (PyObject_Str (obj)));
1347 #endif
1348     }
1349   if (except.reason < 0)
1350     {
1351       PyErr_Format (except.reason == RETURN_QUIT
1352                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
1353                     "%s", except.message);
1354       return NULL;
1355     }
1356
1357   return value;
1358 }
1359
1360 /* Returns value object in the ARGth position in GDB's history.  */
1361 PyObject *
1362 gdbpy_history (PyObject *self, PyObject *args)
1363 {
1364   int i;
1365   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
1366   volatile struct gdb_exception except;
1367
1368   if (!PyArg_ParseTuple (args, "i", &i))
1369     return NULL;
1370
1371   TRY_CATCH (except, RETURN_MASK_ALL)
1372     {
1373       res_val = access_value_history (i);
1374     }
1375   GDB_PY_HANDLE_EXCEPTION (except);
1376
1377   return value_to_value_object (res_val);
1378 }
1379
1380 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise.  */
1381
1382 int
1383 gdbpy_is_value_object (PyObject *obj)
1384 {
1385   return PyObject_TypeCheck (obj, &value_object_type);
1386 }
1387
1388 void
1389 gdbpy_initialize_values (void)
1390 {
1391   if (PyType_Ready (&value_object_type) < 0)
1392     return;
1393
1394   Py_INCREF (&value_object_type);
1395   PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type);
1396
1397   values_in_python = NULL;
1398 }
1399
1400 \f
1401
1402 static PyGetSetDef value_object_getset[] = {
1403   { "address", valpy_get_address, NULL, "The address of the value.",
1404     NULL },
1405   { "is_optimized_out", valpy_get_is_optimized_out, NULL,
1406     "Boolean telling whether the value is optimized "
1407     "out (i.e., not available).",
1408     NULL },
1409   { "type", valpy_get_type, NULL, "Type of the value.", NULL },
1410   { "dynamic_type", valpy_get_dynamic_type, NULL,
1411     "Dynamic type of the value.", NULL },
1412   { "is_lazy", valpy_get_is_lazy, NULL,
1413     "Boolean telling whether the value is lazy (not fetched yet\n\
1414 from the inferior).  A lazy value is fetched when needed, or when\n\
1415 the \"fetch_lazy()\" method is called.", NULL },
1416   {NULL}  /* Sentinel */
1417 };
1418
1419 static PyMethodDef value_object_methods[] = {
1420   { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." },
1421   { "dynamic_cast", valpy_dynamic_cast, METH_VARARGS,
1422     "dynamic_cast (gdb.Type) -> gdb.Value\n\
1423 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1424   },
1425   { "reinterpret_cast", valpy_reinterpret_cast, METH_VARARGS,
1426     "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1427 Cast the value to the supplied type, as if by the C++\n\
1428 reinterpret_cast operator."
1429   },
1430   { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
1431   { "referenced_value", valpy_referenced_value, METH_NOARGS,
1432     "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1433   { "lazy_string", (PyCFunction) valpy_lazy_string,
1434     METH_VARARGS | METH_KEYWORDS,
1435     "lazy_string ([encoding]  [, length]) -> lazy_string\n\
1436 Return a lazy string representation of the value." },
1437   { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
1438     "string ([encoding] [, errors] [, length]) -> string\n\
1439 Return Unicode string representation of the value." },
1440   { "fetch_lazy", valpy_fetch_lazy, METH_NOARGS,
1441     "Fetches the value from the inferior, if it was lazy." },
1442   {NULL}  /* Sentinel */
1443 };
1444
1445 static PyNumberMethods value_object_as_number = {
1446   valpy_add,
1447   valpy_subtract,
1448   valpy_multiply,
1449 #ifndef IS_PY3K
1450   valpy_divide,
1451 #endif
1452   valpy_remainder,
1453   NULL,                       /* nb_divmod */
1454   valpy_power,                /* nb_power */
1455   valpy_negative,             /* nb_negative */
1456   valpy_positive,             /* nb_positive */
1457   valpy_absolute,             /* nb_absolute */
1458   valpy_nonzero,              /* nb_nonzero */
1459   valpy_invert,               /* nb_invert */
1460   valpy_lsh,                  /* nb_lshift */
1461   valpy_rsh,                  /* nb_rshift */
1462   valpy_and,                  /* nb_and */
1463   valpy_xor,                  /* nb_xor */
1464   valpy_or,                   /* nb_or */
1465 #ifdef IS_PY3K
1466   valpy_long,                 /* nb_int */
1467   NULL,                       /* reserved */
1468 #else
1469   NULL,                       /* nb_coerce */
1470   valpy_int,                  /* nb_int */
1471   valpy_long,                 /* nb_long */
1472 #endif
1473   valpy_float,                /* nb_float */
1474 #ifndef IS_PY3K
1475   NULL,                       /* nb_oct */
1476   NULL,                       /* nb_hex */
1477 #endif
1478   NULL,                       /* nb_inplace_add */
1479   NULL,                       /* nb_inplace_subtract */
1480   NULL,                       /* nb_inplace_multiply */
1481   NULL,                       /* nb_inplace_remainder */
1482   NULL,                       /* nb_inplace_power */
1483   NULL,                       /* nb_inplace_lshift */
1484   NULL,                       /* nb_inplace_rshift */
1485   NULL,                       /* nb_inplace_and */
1486   NULL,                       /* nb_inplace_xor */
1487   NULL,                       /* nb_inplace_or */
1488   NULL,                       /* nb_floor_divide */
1489   valpy_divide                /* nb_true_divide */
1490 };
1491
1492 static PyMappingMethods value_object_as_mapping = {
1493   valpy_length,
1494   valpy_getitem,
1495   valpy_setitem
1496 };
1497
1498 PyTypeObject value_object_type = {
1499   PyVarObject_HEAD_INIT (NULL, 0)
1500   "gdb.Value",                    /*tp_name*/
1501   sizeof (value_object),          /*tp_basicsize*/
1502   0,                              /*tp_itemsize*/
1503   valpy_dealloc,                  /*tp_dealloc*/
1504   0,                              /*tp_print*/
1505   0,                              /*tp_getattr*/
1506   0,                              /*tp_setattr*/
1507   0,                              /*tp_compare*/
1508   0,                              /*tp_repr*/
1509   &value_object_as_number,        /*tp_as_number*/
1510   0,                              /*tp_as_sequence*/
1511   &value_object_as_mapping,       /*tp_as_mapping*/
1512   valpy_hash,                     /*tp_hash*/
1513   valpy_call,                     /*tp_call*/
1514   valpy_str,                      /*tp_str*/
1515   0,                              /*tp_getattro*/
1516   0,                              /*tp_setattro*/
1517   0,                              /*tp_as_buffer*/
1518   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES
1519   | Py_TPFLAGS_BASETYPE,          /*tp_flags*/
1520   "GDB value object",             /* tp_doc */
1521   0,                              /* tp_traverse */
1522   0,                              /* tp_clear */
1523   valpy_richcompare,              /* tp_richcompare */
1524   0,                              /* tp_weaklistoffset */
1525   0,                              /* tp_iter */
1526   0,                              /* tp_iternext */
1527   value_object_methods,           /* tp_methods */
1528   0,                              /* tp_members */
1529   value_object_getset,            /* tp_getset */
1530   0,                              /* tp_base */
1531   0,                              /* tp_dict */
1532   0,                              /* tp_descr_get */
1533   0,                              /* tp_descr_set */
1534   0,                              /* tp_dictoffset */
1535   0,                              /* tp_init */
1536   0,                              /* tp_alloc */
1537   valpy_new                       /* tp_new */
1538 };
1539
1540 #else
1541
1542 void
1543 preserve_python_values (struct objfile *objfile, htab_t copied_types)
1544 {
1545   /* Nothing.  */
1546 }
1547
1548 #endif /* HAVE_PYTHON */