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