gdb/python/py-value.c

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