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