gdb/python/py-value.c

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