gdb/python/python-value.c

   1 /* Python interface to values.
   2
   3    Copyright (C) 2008, 2009 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
  29 /* List of all values which are currently exposed to Python. It is
  30    maintained so that when an objfile is discarded, preserve_values
  31    can copy the values' types if needed.  This is declared
  32    unconditionally to reduce the number of uses of HAVE_PYTHON in the
  33    generic code.  */
  34 /* This variable is unnecessarily initialized to NULL in order to
  35    work around a linker bug on MacOS.  */
  36 struct value *values_in_python = NULL;
  37
  38 #ifdef HAVE_PYTHON
  39
  40 #include "python-internal.h"
  41
  42 /* Even though Python scalar types directly map to host types, we use
  43    target types here to remain consistent with the the values system in
  44    GDB (which uses target arithmetic).  */
  45
  46 /* Python's integer type corresponds to C's long type.  */
  47 #define builtin_type_pyint builtin_type (current_gdbarch)->builtin_long
  48
  49 /* Python's float type corresponds to C's double type.  */
  50 #define builtin_type_pyfloat builtin_type (current_gdbarch)->builtin_double
  51
  52 /* Python's long type corresponds to C's long long type.  */
  53 #define builtin_type_pylong builtin_type (current_gdbarch)->builtin_long_long
  54
  55 #define builtin_type_pybool \
  56   language_bool_type (current_language, current_gdbarch)
  57
  58 #define builtin_type_pychar \
  59   language_string_char_type (current_language, current_gdbarch)
  60
  61 typedef struct {
  62   PyObject_HEAD
  63   struct value *value;
  64   PyObject *address;
  65   PyObject *type;
  66 } value_object;
  67
  68 /* Called by the Python interpreter when deallocating a value object.  */
  69 static void
  70 valpy_dealloc (PyObject *obj)
  71 {
  72   value_object *self = (value_object *) obj;
  73
  74   value_remove_from_list (&values_in_python, self->value);
  75
  76   value_free (self->value);
  77
  78   if (self->address)
  79     /* Use braces to appease gcc warning.  *sigh*  */
  80     {
  81       Py_DECREF (self->address);
  82     }
  83
  84   if (self->type)
  85     {
  86       Py_DECREF (self->type);
  87     }
  88
  89   self->ob_type->tp_free (self);
  90 }
  91
  92 /* Called when a new gdb.Value object needs to be allocated.  */
  93 static PyObject *
  94 valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords)
  95 {
  96   struct value *value = NULL;   /* Initialize to appease gcc warning.  */
  97   value_object *value_obj;
  98
  99   if (PyTuple_Size (args) != 1)
 100     {
 101       PyErr_SetString (PyExc_TypeError, _("Value object creation takes only "
 102                                           "1 argument"));
 103       return NULL;
 104     }
 105
 106   value_obj = (value_object *) subtype->tp_alloc (subtype, 1);
 107   if (value_obj == NULL)
 108     {
 109       PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to "
 110                                             "create Value object."));
 111       return NULL;
 112     }
 113
 114   value = convert_value_from_python (PyTuple_GetItem (args, 0));
 115   if (value == NULL)
 116     {
 117       subtype->tp_free (value_obj);
 118       return NULL;
 119     }
 120
 121   value_obj->value = value;
 122   value_obj->address = NULL;
 123   value_obj->type = NULL;
 124   release_value (value);
 125   value_prepend_to_list (&values_in_python, value);
 126
 127   return (PyObject *) value_obj;
 128 }
 129
 130 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 131 static PyObject *
 132 valpy_dereference (PyObject *self, PyObject *args)
 133 {
 134   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 135   volatile struct gdb_exception except;
 136
 137   TRY_CATCH (except, RETURN_MASK_ALL)
 138     {
 139       res_val = value_ind (((value_object *) self)->value);
 140     }
 141   GDB_PY_HANDLE_EXCEPTION (except);
 142
 143   return value_to_value_object (res_val);
 144 }
 145
 146 /* Return "&value".  */
 147 static PyObject *
 148 valpy_get_address (PyObject *self, void *closure)
 149 {
 150   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 151   value_object *val_obj = (value_object *) self;
 152   volatile struct gdb_exception except;
 153
 154   if (!val_obj->address)
 155     {
 156       TRY_CATCH (except, RETURN_MASK_ALL)
 157         {
 158           res_val = value_addr (val_obj->value);
 159         }
 160       if (except.reason < 0)
 161         {
 162           val_obj->address = Py_None;
 163           Py_INCREF (Py_None);
 164         }
 165       else
 166         val_obj->address = value_to_value_object (res_val);
 167     }
 168
 169   Py_INCREF (val_obj->address);
 170
 171   return val_obj->address;
 172 }
 173
 174 /* Return type of the value.  */
 175 static PyObject *
 176 valpy_get_type (PyObject *self, void *closure)
 177 {
 178   value_object *obj = (value_object *) self;
 179   if (!obj->type)
 180     {
 181       obj->type = type_to_type_object (value_type (obj->value));
 182       if (!obj->type)
 183         {
 184           obj->type = Py_None;
 185           Py_INCREF (obj->type);
 186         }
 187     }
 188   Py_INCREF (obj->type);
 189   return obj->type;
 190 }
 191
 192 /* Implementation of gdb.Value.string ([encoding] [, errors]) -> string
 193    Return Unicode string with value contents.  If ENCODING is not given,
 194    the string is assumed to be encoded in the target's charset.  */
 195 static PyObject *
 196 valpy_string (PyObject *self, PyObject *args, PyObject *kw)
 197 {
 198   int length, ret = 0;
 199   gdb_byte *buffer;
 200   struct value *value = ((value_object *) self)->value;
 201   volatile struct gdb_exception except;
 202   PyObject *unicode;
 203   const char *encoding = NULL;
 204   const char *errors = NULL;
 205   const char *user_encoding = NULL;
 206   const char *la_encoding = NULL;
 207   static char *keywords[] = { "encoding", "errors" };
 208
 209   if (!PyArg_ParseTupleAndKeywords (args, kw, "|ss", keywords,
 210                                     &user_encoding, &errors))
 211     return NULL;
 212
 213   TRY_CATCH (except, RETURN_MASK_ALL)
 214     {
 215       LA_GET_STRING (value, &buffer, &length, &la_encoding);
 216     }
 217   GDB_PY_HANDLE_EXCEPTION (except);
 218
 219   encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
 220   unicode = PyUnicode_Decode (buffer, length, encoding, errors);
 221   xfree (buffer);
 222
 223   return unicode;
 224 }
 225
 226 /* Cast a value to a given type.  */
 227 static PyObject *
 228 valpy_cast (PyObject *self, PyObject *args)
 229 {
 230   PyObject *type_obj;
 231   struct type *type;
 232   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 233   volatile struct gdb_exception except;
 234
 235   if (! PyArg_ParseTuple (args, "O", &type_obj))
 236     return NULL;
 237
 238   type = type_object_to_type (type_obj);
 239   if (! type)
 240     {
 241       PyErr_SetString (PyExc_RuntimeError, "argument must be a Type");
 242       return NULL;
 243     }
 244
 245   TRY_CATCH (except, RETURN_MASK_ALL)
 246     {
 247       res_val = value_cast (type, ((value_object *) self)->value);
 248     }
 249   GDB_PY_HANDLE_EXCEPTION (except);
 250
 251   return value_to_value_object (res_val);
 252 }
 253
 254 static Py_ssize_t
 255 valpy_length (PyObject *self)
 256 {
 257   /* We don't support getting the number of elements in a struct / class.  */
 258   PyErr_SetString (PyExc_NotImplementedError,
 259                    "Invalid operation on gdb.Value.");
 260   return -1;
 261 }
 262
 263 /* Given string name of an element inside structure, return its value
 264    object.  */
 265 static PyObject *
 266 valpy_getitem (PyObject *self, PyObject *key)
 267 {
 268   value_object *self_value = (value_object *) self;
 269   char *field = NULL;
 270   struct value *idx = NULL;
 271   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 272   volatile struct gdb_exception except;
 273
 274   if (gdbpy_is_string (key))
 275     {
 276       field = python_string_to_host_string (key);
 277       if (field == NULL)
 278         return NULL;
 279     }
 280
 281   TRY_CATCH (except, RETURN_MASK_ALL)
 282     {
 283       struct value *tmp = self_value->value;
 284
 285       if (field)
 286         res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
 287       else
 288         {
 289           /* Assume we are attempting an array access, and let the
 290              value code throw an exception if the index has an invalid
 291              type.  */
 292           struct value *idx = convert_value_from_python (key);
 293           if (idx == NULL)
 294             return NULL;
 295
 296           res_val = value_subscript (tmp, value_as_long (idx));
 297         }
 298     }
 299   if (field)
 300     xfree (field);
 301   GDB_PY_HANDLE_EXCEPTION (except);
 302
 303   return value_to_value_object (res_val);
 304 }
 305
 306 static int
 307 valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
 308 {
 309   PyErr_Format (PyExc_NotImplementedError,
 310                 _("Setting of struct elements is not currently supported."));
 311   return -1;
 312 }
 313
 314 /* Called by the Python interpreter to obtain string representation
 315    of the object.  */
 316 static PyObject *
 317 valpy_str (PyObject *self)
 318 {
 319   char *s = NULL;
 320   long dummy;
 321   struct ui_file *stb;
 322   struct cleanup *old_chain;
 323   PyObject *result;
 324   struct value_print_options opts;
 325   volatile struct gdb_exception except;
 326
 327   get_user_print_options (&opts);
 328   opts.deref_ref = 0;
 329
 330   stb = mem_fileopen ();
 331   old_chain = make_cleanup_ui_file_delete (stb);
 332
 333   TRY_CATCH (except, RETURN_MASK_ALL)
 334     {
 335       common_val_print (((value_object *) self)->value, stb, 0,
 336                         &opts, current_language);
 337       s = ui_file_xstrdup (stb, &dummy);
 338     }
 339   GDB_PY_HANDLE_EXCEPTION (except);
 340
 341   do_cleanups (old_chain);
 342
 343   result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL);
 344   xfree (s);
 345
 346   return result;
 347 }
 348
 349 /* Implements gdb.Value.is_optimized_out.  */
 350 static PyObject *
 351 valpy_get_is_optimized_out (PyObject *self, void *closure)
 352 {
 353   struct value *value = ((value_object *) self)->value;
 354
 355   if (value_optimized_out (value))
 356     Py_RETURN_TRUE;
 357
 358   Py_RETURN_FALSE;
 359 }
 360
 361 enum valpy_opcode
 362 {
 363   VALPY_ADD,
 364   VALPY_SUB,
 365   VALPY_MUL,
 366   VALPY_DIV,
 367   VALPY_REM,
 368   VALPY_POW,
 369   VALPY_LSH,
 370   VALPY_RSH,
 371   VALPY_BITAND,
 372   VALPY_BITOR,
 373   VALPY_BITXOR
 374 };
 375
 376 /* If TYPE is a reference, return the target; otherwise return TYPE.  */
 377 #define STRIP_REFERENCE(TYPE) \
 378   ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
 379
 380 /* Returns a value object which is the result of applying the operation
 381    specified by OPCODE to the given arguments.  */
 382 static PyObject *
 383 valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
 384 {
 385   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 386   volatile struct gdb_exception except;
 387
 388   TRY_CATCH (except, RETURN_MASK_ALL)
 389     {
 390       struct value *arg1, *arg2;
 391
 392       /* If the gdb.Value object is the second operand, then it will be passed
 393          to us as the OTHER argument, and SELF will be an entirely different
 394          kind of object, altogether.  Because of this, we can't assume self is
 395          a gdb.Value object and need to convert it from python as well.  */
 396       arg1 = convert_value_from_python (self);
 397       if (arg1 == NULL)
 398         break;
 399
 400       arg2 = convert_value_from_python (other);
 401       if (arg2 == NULL)
 402         break;
 403
 404       switch (opcode)
 405         {
 406         case VALPY_ADD:
 407           {
 408             struct type *ltype = value_type (arg1);
 409             struct type *rtype = value_type (arg2);
 410
 411             CHECK_TYPEDEF (ltype);
 412             ltype = STRIP_REFERENCE (ltype);
 413             CHECK_TYPEDEF (rtype);
 414             rtype = STRIP_REFERENCE (rtype);
 415
 416             if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 417                 && is_integral_type (rtype))
 418               res_val = value_ptradd (arg1, value_as_long (arg2));
 419             else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
 420                      && is_integral_type (ltype))
 421               res_val = value_ptradd (arg2, value_as_long (arg1));
 422             else
 423               res_val = value_binop (arg1, arg2, BINOP_ADD);
 424           }
 425           break;
 426         case VALPY_SUB:
 427           {
 428             struct type *ltype = value_type (arg1);
 429             struct type *rtype = value_type (arg2);
 430
 431             CHECK_TYPEDEF (ltype);
 432             ltype = STRIP_REFERENCE (ltype);
 433             CHECK_TYPEDEF (rtype);
 434             rtype = STRIP_REFERENCE (rtype);
 435
 436             if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 437                 && TYPE_CODE (rtype) == TYPE_CODE_PTR)
 438               /* A ptrdiff_t for the target would be preferable here.  */
 439               res_val = value_from_longest (builtin_type_pyint,
 440                                             value_ptrdiff (arg1, arg2));
 441             else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
 442                      && is_integral_type (rtype))
 443               res_val = value_ptradd (arg1, - value_as_long (arg2));
 444             else
 445               res_val = value_binop (arg1, arg2, BINOP_SUB);
 446           }
 447           break;
 448         case VALPY_MUL:
 449           res_val = value_binop (arg1, arg2, BINOP_MUL);
 450           break;
 451         case VALPY_DIV:
 452           res_val = value_binop (arg1, arg2, BINOP_DIV);
 453           break;
 454         case VALPY_REM:
 455           res_val = value_binop (arg1, arg2, BINOP_REM);
 456           break;
 457         case VALPY_POW:
 458           res_val = value_binop (arg1, arg2, BINOP_EXP);
 459           break;
 460         case VALPY_LSH:
 461           res_val = value_binop (arg1, arg2, BINOP_LSH);
 462           break;
 463         case VALPY_RSH:
 464           res_val = value_binop (arg1, arg2, BINOP_RSH);
 465           break;
 466         case VALPY_BITAND:
 467           res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
 468           break;
 469         case VALPY_BITOR:
 470           res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
 471           break;
 472         case VALPY_BITXOR:
 473           res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
 474           break;
 475         }
 476     }
 477   GDB_PY_HANDLE_EXCEPTION (except);
 478
 479   return res_val ? value_to_value_object (res_val) : NULL;
 480 }
 481
 482 static PyObject *
 483 valpy_add (PyObject *self, PyObject *other)
 484 {
 485   return valpy_binop (VALPY_ADD, self, other);
 486 }
 487
 488 static PyObject *
 489 valpy_subtract (PyObject *self, PyObject *other)
 490 {
 491   return valpy_binop (VALPY_SUB, self, other);
 492 }
 493
 494 static PyObject *
 495 valpy_multiply (PyObject *self, PyObject *other)
 496 {
 497   return valpy_binop (VALPY_MUL, self, other);
 498 }
 499
 500 static PyObject *
 501 valpy_divide (PyObject *self, PyObject *other)
 502 {
 503   return valpy_binop (VALPY_DIV, self, other);
 504 }
 505
 506 static PyObject *
 507 valpy_remainder (PyObject *self, PyObject *other)
 508 {
 509   return valpy_binop (VALPY_REM, self, other);
 510 }
 511
 512 static PyObject *
 513 valpy_power (PyObject *self, PyObject *other, PyObject *unused)
 514 {
 515   /* We don't support the ternary form of pow.  I don't know how to express
 516      that, so let's just throw NotImplementedError to at least do something
 517      about it.  */
 518   if (unused != Py_None)
 519     {
 520       PyErr_SetString (PyExc_NotImplementedError,
 521                        "Invalid operation on gdb.Value.");
 522       return NULL;
 523     }
 524
 525   return valpy_binop (VALPY_POW, self, other);
 526 }
 527
 528 static PyObject *
 529 valpy_negative (PyObject *self)
 530 {
 531   struct value *val = NULL;
 532   volatile struct gdb_exception except;
 533
 534   TRY_CATCH (except, RETURN_MASK_ALL)
 535     {
 536       val = value_neg (((value_object *) self)->value);
 537     }
 538   GDB_PY_HANDLE_EXCEPTION (except);
 539
 540   return value_to_value_object (val);
 541 }
 542
 543 static PyObject *
 544 valpy_positive (PyObject *self)
 545 {
 546   struct value *copy = value_copy (((value_object *) self)->value);
 547
 548   return value_to_value_object (copy);
 549 }
 550
 551 static PyObject *
 552 valpy_absolute (PyObject *self)
 553 {
 554   if (value_less (((value_object *) self)->value,
 555                   value_from_longest (builtin_type_int8, 0)))
 556     return valpy_negative (self);
 557   else
 558     return valpy_positive (self);
 559 }
 560
 561 /* Implements boolean evaluation of gdb.Value.  */
 562 static int
 563 valpy_nonzero (PyObject *self)
 564 {
 565   value_object *self_value = (value_object *) self;
 566   struct type *type;
 567
 568   type = check_typedef (value_type (self_value->value));
 569
 570   if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
 571     return !!value_as_long (self_value->value);
 572   else if (TYPE_CODE (type) == TYPE_CODE_FLT)
 573     return value_as_double (self_value->value) != 0;
 574   else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
 575     return !decimal_is_zero (value_contents (self_value->value),
 576                              TYPE_LENGTH (type));
 577   else
 578     {
 579       PyErr_SetString (PyExc_TypeError, _("Attempted truth testing on invalid "
 580                                           "gdb.Value type."));
 581       return 0;
 582     }
 583 }
 584
 585 /* Implements ~ for value objects.  */
 586 static PyObject *
 587 valpy_invert (PyObject *self)
 588 {
 589   struct value *val = NULL;
 590   volatile struct gdb_exception except;
 591
 592   TRY_CATCH (except, RETURN_MASK_ALL)
 593     {
 594       val = value_complement (((value_object *) self)->value);
 595     }
 596   GDB_PY_HANDLE_EXCEPTION (except);
 597
 598   return value_to_value_object (val);
 599 }
 600
 601 /* Implements left shift for value objects.  */
 602 static PyObject *
 603 valpy_lsh (PyObject *self, PyObject *other)
 604 {
 605   return valpy_binop (VALPY_LSH, self, other);
 606 }
 607
 608 /* Implements right shift for value objects.  */
 609 static PyObject *
 610 valpy_rsh (PyObject *self, PyObject *other)
 611 {
 612   return valpy_binop (VALPY_RSH, self, other);
 613 }
 614
 615 /* Implements bitwise and for value objects.  */
 616 static PyObject *
 617 valpy_and (PyObject *self, PyObject *other)
 618 {
 619   return valpy_binop (VALPY_BITAND, self, other);
 620 }
 621
 622 /* Implements bitwise or for value objects.  */
 623 static PyObject *
 624 valpy_or (PyObject *self, PyObject *other)
 625 {
 626   return valpy_binop (VALPY_BITOR, self, other);
 627 }
 628
 629 /* Implements bitwise xor for value objects.  */
 630 static PyObject *
 631 valpy_xor (PyObject *self, PyObject *other)
 632 {
 633   return valpy_binop (VALPY_BITXOR, self, other);
 634 }
 635
 636 /* Implements comparison operations for value objects.  */
 637 static PyObject *
 638 valpy_richcompare (PyObject *self, PyObject *other, int op)
 639 {
 640   int result = 0;
 641   struct value *value_other;
 642   volatile struct gdb_exception except;
 643
 644   if (other == Py_None)
 645     /* Comparing with None is special.  From what I can tell, in Python
 646        None is smaller than anything else.  */
 647     switch (op) {
 648       case Py_LT:
 649       case Py_LE:
 650       case Py_EQ:
 651         Py_RETURN_FALSE;
 652       case Py_NE:
 653       case Py_GT:
 654       case Py_GE:
 655         Py_RETURN_TRUE;
 656       default:
 657         /* Can't happen.  */
 658         PyErr_SetString (PyExc_NotImplementedError,
 659                          "Invalid operation on gdb.Value.");
 660         return NULL;
 661     }
 662
 663   TRY_CATCH (except, RETURN_MASK_ALL)
 664     {
 665       value_other = convert_value_from_python (other);
 666       if (value_other == NULL)
 667         return NULL;
 668
 669       switch (op) {
 670         case Py_LT:
 671           result = value_less (((value_object *) self)->value, value_other);
 672           break;
 673         case Py_LE:
 674           result = value_less (((value_object *) self)->value, value_other)
 675             || value_equal (((value_object *) self)->value, value_other);
 676           break;
 677         case Py_EQ:
 678           result = value_equal (((value_object *) self)->value, value_other);
 679           break;
 680         case Py_NE:
 681           result = !value_equal (((value_object *) self)->value, value_other);
 682           break;
 683         case Py_GT:
 684           result = value_less (value_other, ((value_object *) self)->value);
 685           break;
 686         case Py_GE:
 687           result = value_less (value_other, ((value_object *) self)->value)
 688             || value_equal (((value_object *) self)->value, value_other);
 689           break;
 690         default:
 691           /* Can't happen.  */
 692           PyErr_SetString (PyExc_NotImplementedError,
 693                            "Invalid operation on gdb.Value.");
 694           return NULL;
 695       }
 696     }
 697   GDB_PY_HANDLE_EXCEPTION (except);
 698
 699   if (result == 1)
 700     Py_RETURN_TRUE;
 701
 702   Py_RETURN_FALSE;
 703 }
 704
 705 /* Helper function to determine if a type is "int-like".  */
 706 static int
 707 is_intlike (struct type *type, int ptr_ok)
 708 {
 709   CHECK_TYPEDEF (type);
 710   return (TYPE_CODE (type) == TYPE_CODE_INT
 711           || TYPE_CODE (type) == TYPE_CODE_ENUM
 712           || TYPE_CODE (type) == TYPE_CODE_BOOL
 713           || TYPE_CODE (type) == TYPE_CODE_CHAR
 714           || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR));
 715 }
 716
 717 /* Implements conversion to int.  */
 718 static PyObject *
 719 valpy_int (PyObject *self)
 720 {
 721   struct value *value = ((value_object *) self)->value;
 722   struct type *type = value_type (value);
 723   LONGEST l = 0;
 724   volatile struct gdb_exception except;
 725
 726   CHECK_TYPEDEF (type);
 727   if (!is_intlike (type, 0))
 728     {
 729       PyErr_SetString (PyExc_RuntimeError, "cannot convert value to int");
 730       return NULL;
 731     }
 732
 733   TRY_CATCH (except, RETURN_MASK_ALL)
 734     {
 735       l = value_as_long (value);
 736     }
 737   GDB_PY_HANDLE_EXCEPTION (except);
 738
 739   return PyInt_FromLong (l);
 740 }
 741
 742 /* Implements conversion to long.  */
 743 static PyObject *
 744 valpy_long (PyObject *self)
 745 {
 746   struct value *value = ((value_object *) self)->value;
 747   struct type *type = value_type (value);
 748   LONGEST l = 0;
 749   volatile struct gdb_exception except;
 750
 751   if (!is_intlike (type, 1))
 752     {
 753       PyErr_SetString (PyExc_RuntimeError, "cannot convert value to long");
 754       return NULL;
 755     }
 756
 757   TRY_CATCH (except, RETURN_MASK_ALL)
 758     {
 759       l = value_as_long (value);
 760     }
 761   GDB_PY_HANDLE_EXCEPTION (except);
 762
 763   return PyLong_FromLong (l);
 764 }
 765
 766 /* Implements conversion to float.  */
 767 static PyObject *
 768 valpy_float (PyObject *self)
 769 {
 770   struct value *value = ((value_object *) self)->value;
 771   struct type *type = value_type (value);
 772   double d = 0;
 773   volatile struct gdb_exception except;
 774
 775   CHECK_TYPEDEF (type);
 776   if (TYPE_CODE (type) != TYPE_CODE_FLT)
 777     {
 778       PyErr_SetString (PyExc_RuntimeError, "cannot convert value to float");
 779       return NULL;
 780     }
 781
 782   TRY_CATCH (except, RETURN_MASK_ALL)
 783     {
 784       d = value_as_double (value);
 785     }
 786   GDB_PY_HANDLE_EXCEPTION (except);
 787
 788   return PyFloat_FromDouble (d);
 789 }
 790
 791 /* Returns an object for a value which is released from the all_values chain,
 792    so its lifetime is not bound to the execution of a command.  */
 793 PyObject *
 794 value_to_value_object (struct value *val)
 795 {
 796   value_object *val_obj;
 797
 798   val_obj = PyObject_New (value_object, &value_object_type);
 799   if (val_obj != NULL)
 800     {
 801       val_obj->value = val;
 802       val_obj->address = NULL;
 803       val_obj->type = NULL;
 804       release_value (val);
 805       value_prepend_to_list (&values_in_python, val);
 806     }
 807
 808   return (PyObject *) val_obj;
 809 }
 810
 811 /* Returns value structure corresponding to the given value object.  */
 812 struct value *
 813 value_object_to_value (PyObject *self)
 814 {
 815   value_object *real;
 816   if (! PyObject_TypeCheck (self, &value_object_type))
 817     return NULL;
 818   real = (value_object *) self;
 819   return real->value;
 820 }
 821
 822 /* Try to convert a Python value to a gdb value.  If the value cannot
 823    be converted, set a Python exception and return NULL.  */
 824
 825 struct value *
 826 convert_value_from_python (PyObject *obj)
 827 {
 828   struct value *value = NULL; /* -Wall */
 829   PyObject *target_str, *unicode_str;
 830   struct cleanup *old;
 831   volatile struct gdb_exception except;
 832   int cmp;
 833
 834   gdb_assert (obj != NULL);
 835
 836   TRY_CATCH (except, RETURN_MASK_ALL)
 837     {
 838       if (PyBool_Check (obj))
 839         {
 840           cmp = PyObject_IsTrue (obj);
 841           if (cmp >= 0)
 842             value = value_from_longest (builtin_type_pybool, cmp);
 843         }
 844       else if (PyInt_Check (obj))
 845         {
 846           long l = PyInt_AsLong (obj);
 847
 848           if (! PyErr_Occurred ())
 849             value = value_from_longest (builtin_type_pyint, l);
 850         }
 851       else if (PyLong_Check (obj))
 852         {
 853           LONGEST l = PyLong_AsLongLong (obj);
 854
 855           if (! PyErr_Occurred ())
 856             value = value_from_longest (builtin_type_pylong, l);
 857         }
 858       else if (PyFloat_Check (obj))
 859         {
 860           double d = PyFloat_AsDouble (obj);
 861
 862           if (! PyErr_Occurred ())
 863             value = value_from_double (builtin_type_pyfloat, d);
 864         }
 865       else if (gdbpy_is_string (obj))
 866         {
 867           char *s;
 868
 869           s = python_string_to_target_string (obj);
 870           if (s != NULL)
 871             {
 872               old = make_cleanup (xfree, s);
 873               value = value_cstring (s, strlen (s), builtin_type_pychar);
 874               do_cleanups (old);
 875             }
 876         }
 877       else if (PyObject_TypeCheck (obj, &value_object_type))
 878         value = value_copy (((value_object *) obj)->value);
 879       else
 880         PyErr_Format (PyExc_TypeError, _("Could not convert Python object: %s"),
 881                       PyString_AsString (PyObject_Str (obj)));
 882     }
 883   if (except.reason < 0)
 884     {
 885       PyErr_Format (except.reason == RETURN_QUIT
 886                     ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
 887                     "%s", except.message);
 888       return NULL;
 889     }
 890
 891   return value;
 892 }
 893
 894 /* Returns value object in the ARGth position in GDB's history.  */
 895 PyObject *
 896 gdbpy_history (PyObject *self, PyObject *args)
 897 {
 898   int i;
 899   struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
 900   volatile struct gdb_exception except;
 901
 902   if (!PyArg_ParseTuple (args, "i", &i))
 903     return NULL;
 904
 905   TRY_CATCH (except, RETURN_MASK_ALL)
 906     {
 907       res_val = access_value_history (i);
 908     }
 909   GDB_PY_HANDLE_EXCEPTION (except);
 910
 911   return value_to_value_object (res_val);
 912 }
 913
 914 void
 915 gdbpy_initialize_values (void)
 916 {
 917   if (PyType_Ready (&value_object_type) < 0)
 918     return;
 919
 920   Py_INCREF (&value_object_type);
 921   PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type);
 922
 923   values_in_python = NULL;
 924 }
 925
 926 \f
 927
 928 static PyGetSetDef value_object_getset[] = {
 929   { "address", valpy_get_address, NULL, "The address of the value.",
 930     NULL },
 931   { "is_optimized_out", valpy_get_is_optimized_out, NULL,
 932     "Boolean telling whether the value is optimized out (i.e., not available).",
 933     NULL },
 934   { "type", valpy_get_type, NULL, "Type of the value.", NULL },
 935   {NULL}  /* Sentinel */
 936 };
 937
 938 static PyMethodDef value_object_methods[] = {
 939   { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." },
 940   { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
 941   { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
 942     "string ([encoding] [, errors]) -> string\n\
 943 Return Unicode string representation of the value." },
 944   {NULL}  /* Sentinel */
 945 };
 946
 947 static PyNumberMethods value_object_as_number = {
 948   valpy_add,
 949   valpy_subtract,
 950   valpy_multiply,
 951   valpy_divide,
 952   valpy_remainder,
 953   NULL,                       /* nb_divmod */
 954   valpy_power,                /* nb_power */
 955   valpy_negative,             /* nb_negative */
 956   valpy_positive,             /* nb_positive */
 957   valpy_absolute,             /* nb_absolute */
 958   valpy_nonzero,              /* nb_nonzero */
 959   valpy_invert,               /* nb_invert */
 960   valpy_lsh,                  /* nb_lshift */
 961   valpy_rsh,                  /* nb_rshift */
 962   valpy_and,                  /* nb_and */
 963   valpy_xor,                  /* nb_xor */
 964   valpy_or,                   /* nb_or */
 965   NULL,                       /* nb_coerce */
 966   valpy_int,                  /* nb_int */
 967   valpy_long,                 /* nb_long */
 968   valpy_float,                /* nb_float */
 969   NULL,                       /* nb_oct */
 970   NULL                        /* nb_hex */
 971 };
 972
 973 static PyMappingMethods value_object_as_mapping = {
 974   valpy_length,
 975   valpy_getitem,
 976   valpy_setitem
 977 };
 978
 979 PyTypeObject value_object_type = {
 980   PyObject_HEAD_INIT (NULL)
 981   0,                              /*ob_size*/
 982   "gdb.Value",                    /*tp_name*/
 983   sizeof (value_object),          /*tp_basicsize*/
 984   0,                              /*tp_itemsize*/
 985   valpy_dealloc,                  /*tp_dealloc*/
 986   0,                              /*tp_print*/
 987   0,                              /*tp_getattr*/
 988   0,                              /*tp_setattr*/
 989   0,                              /*tp_compare*/
 990   0,                              /*tp_repr*/
 991   &value_object_as_number,        /*tp_as_number*/
 992   0,                              /*tp_as_sequence*/
 993   &value_object_as_mapping,       /*tp_as_mapping*/
 994   0,                              /*tp_hash */
 995   0,                              /*tp_call*/
 996   valpy_str,                      /*tp_str*/
 997   0,                              /*tp_getattro*/
 998   0,                              /*tp_setattro*/
 999   0,                              /*tp_as_buffer*/
1000   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,   /*tp_flags*/
1001   "GDB value object",             /* tp_doc */
1002   0,                              /* tp_traverse */
1003   0,                              /* tp_clear */
1004   valpy_richcompare,              /* tp_richcompare */
1005   0,                              /* tp_weaklistoffset */
1006   0,                              /* tp_iter */
1007   0,                              /* tp_iternext */
1008   value_object_methods,           /* tp_methods */
1009   0,                              /* tp_members */
1010   value_object_getset,            /* tp_getset */
1011   0,                              /* tp_base */
1012   0,                              /* tp_dict */
1013   0,                              /* tp_descr_get */
1014   0,                              /* tp_descr_set */
1015   0,                              /* tp_dictoffset */
1016   0,                              /* tp_init */
1017   0,                              /* tp_alloc */
1018   valpy_new                       /* tp_new */
1019 };
1020
1021 #endif /* HAVE_PYTHON */