gdb/python/py-value.c

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