gdb/python/py-value.c

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