* defs.h (extract_signed_integer, extract_unsigned_integer,

[deliverable/binutils-gdb.git] / gdb / python / python-value.c

diff --git a/gdb/python/python-value.c b/gdb/python/python-value.c
index 76f5cde000b9eba032cb7819aab322ad9ef7ed46..5304cafa2a6c561881db255edb3dc754f2ee8766 100644 (file)
--- a/gdb/python/python-value.c
+++ b/gdb/python/python-value.c
@@ -44,16 +44,19 @@ struct value *values_in_python = NULL;
    GDB (which uses target arithmetic).  */
 
 /* Python's integer type corresponds to C's long type.  */
-#define builtin_type_pyint builtin_type (current_gdbarch)->builtin_long
+#define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
 
 /* Python's float type corresponds to C's double type.  */
-#define builtin_type_pyfloat builtin_type (current_gdbarch)->builtin_double
+#define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
 
 /* Python's long type corresponds to C's long long type.  */
-#define builtin_type_pylong builtin_type (current_gdbarch)->builtin_long_long
+#define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
 
 #define builtin_type_pybool \
-  language_bool_type (current_language, current_gdbarch)
+  language_bool_type (python_language, python_gdbarch)
+
+#define builtin_type_pychar \
+  language_string_char_type (python_language, python_gdbarch)
 
 typedef struct {
   PyObject_HEAD
@@ -290,7 +293,7 @@ valpy_getitem (PyObject *self, PyObject *key)
          if (idx == NULL)
            return NULL;
 
-         res_val = value_subscript (tmp, idx);
+         res_val = value_subscript (tmp, value_as_long (idx));
        }
     }
   if (field)
@@ -330,7 +333,7 @@ valpy_str (PyObject *self)
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       common_val_print (((value_object *) self)->value, stb, 0,
-                       &opts, current_language);
+                       &opts, python_language);
       s = ui_file_xstrdup (stb, &dummy);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
@@ -410,10 +413,12 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
            CHECK_TYPEDEF (rtype);
            rtype = STRIP_REFERENCE (rtype);
 
-           if (TYPE_CODE (ltype) == TYPE_CODE_PTR)
-             res_val = value_ptradd (arg1, arg2);
-           else if (TYPE_CODE (rtype) == TYPE_CODE_PTR)
-             res_val = value_ptradd (arg2, arg1);
+           if (TYPE_CODE (ltype) == TYPE_CODE_PTR
+               && is_integral_type (rtype))
+             res_val = value_ptradd (arg1, value_as_long (arg2));
+           else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
+                    && is_integral_type (ltype))
+             res_val = value_ptradd (arg2, value_as_long (arg1));
            else
              res_val = value_binop (arg1, arg2, BINOP_ADD);
          }
@@ -428,16 +433,14 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
            CHECK_TYPEDEF (rtype);
            rtype = STRIP_REFERENCE (rtype);
 
-           if (TYPE_CODE (ltype) == TYPE_CODE_PTR)
-             {
-               if (TYPE_CODE (rtype) == TYPE_CODE_PTR)
-                   /* A ptrdiff_t for the target would be preferable
-                      here.  */
-                   res_val = value_from_longest (builtin_type_pyint,
-                                                 value_ptrdiff (arg1, arg2));
-               else
-                 res_val = value_ptrsub (arg1, arg2);
-             }
+           if (TYPE_CODE (ltype) == TYPE_CODE_PTR
+               && TYPE_CODE (rtype) == TYPE_CODE_PTR)
+             /* A ptrdiff_t for the target would be preferable here.  */
+             res_val = value_from_longest (builtin_type_pyint,
+                                           value_ptrdiff (arg1, arg2));
+           else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
+                    && is_integral_type (rtype))
+             res_val = value_ptradd (arg1, - value_as_long (arg2));
            else
              res_val = value_binop (arg1, arg2, BINOP_SUB);
          }
@@ -548,8 +551,8 @@ valpy_positive (PyObject *self)
 static PyObject *
 valpy_absolute (PyObject *self)
 {
-  if (value_less (((value_object *) self)->value,
-                 value_from_longest (builtin_type_int8, 0)))
+  struct value *value = ((value_object *) self)->value;
+  if (value_less (value, value_zero (value_type (value), not_lval)))
     return valpy_negative (self);
   else
     return valpy_positive (self);
@@ -570,7 +573,8 @@ valpy_nonzero (PyObject *self)
     return value_as_double (self_value->value) != 0;
   else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
     return !decimal_is_zero (value_contents (self_value->value),
-                            TYPE_LENGTH (type));
+                            TYPE_LENGTH (type),
+                            gdbarch_byte_order (get_type_arch (type)));
   else
     {
       PyErr_SetString (PyExc_TypeError, _("Attempted truth testing on invalid "
@@ -805,6 +809,17 @@ value_to_value_object (struct value *val)
   return (PyObject *) val_obj;
 }
 
+/* Returns value structure corresponding to the given value object.  */
+struct value *
+value_object_to_value (PyObject *self)
+{
+  value_object *real;
+  if (! PyObject_TypeCheck (self, &value_object_type))
+    return NULL;
+  real = (value_object *) self;
+  return real->value;
+}
+
 /* Try to convert a Python value to a gdb value.  If the value cannot
    be converted, set a Python exception and return NULL.  */
 
@@ -856,7 +871,7 @@ convert_value_from_python (PyObject *obj)
          if (s != NULL)
            {
              old = make_cleanup (xfree, s);
-             value = value_from_string (s);
+             value = value_cstring (s, strlen (s), builtin_type_pychar);
              do_cleanups (old);
            }
        }