PR python/18285

[deliverable/binutils-gdb.git] / gdb / valarith.c

diff --git a/gdb/valarith.c b/gdb/valarith.c
index 8e863e37473dfe7560a5ec5467a8fc067a032d21..df1e8c3a17c621a21d2c624e57b70aa425db17e3 100644 (file)
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -1,6 +1,6 @@
 /* Perform arithmetic and other operations on values, for GDB.
 
-   Copyright (C) 1986-2014 Free Software Foundation, Inc.
+   Copyright (C) 1986-2015 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -24,12 +24,10 @@
 #include "expression.h"
 #include "target.h"
 #include "language.h"
-#include <string.h>
 #include "doublest.h"
 #include "dfp.h"
 #include <math.h>
 #include "infcall.h"
-#include "exceptions.h"
 
 /* Define whether or not the C operator '/' truncates towards zero for
    differently signed operands (truncation direction is undefined in C).  */
@@ -286,17 +284,17 @@ unop_user_defined_p (enum exp_opcode op, struct value *arg1)
    situations or combinations thereof.  */
 
 static struct value *
-value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
-                           int *static_memfuncp)
+value_user_defined_cpp_op (struct value **args, int nargs, char *oper,
+                           int *static_memfuncp, enum noside noside)
 {
 
   struct symbol *symp = NULL;
   struct value *valp = NULL;
 
-  find_overload_match (args, nargs, operator, BOTH /* could be method */,
+  find_overload_match (args, nargs, oper, BOTH /* could be method */,
                        &args[0] /* objp */,
                        NULL /* pass NULL symbol since symbol is unknown */,
-                       &valp, &symp, static_memfuncp, 0);
+                       &valp, &symp, static_memfuncp, 0, noside);
 
   if (valp)
     return valp;
@@ -310,7 +308,7 @@ value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
       return value_of_variable (symp, 0);
     }
 
-  error (_("Could not find %s."), operator);
+  error (_("Could not find %s."), oper);
 }
 
 /* Lookup user defined operator NAME.  Return a value representing the
@@ -318,12 +316,15 @@ value_user_defined_cpp_op (struct value **args, int nargs, char *operator,
 
 static struct value *
 value_user_defined_op (struct value **argp, struct value **args, char *name,
-                       int *static_memfuncp, int nargs)
+                       int *static_memfuncp, int nargs, enum noside noside)
 {
   struct value *result = NULL;
 
   if (current_language->la_language == language_cplus)
-    result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp);
+    {
+      result = value_user_defined_cpp_op (args, nargs, name, static_memfuncp,
+                                         noside);
+    }
   else
     result = value_struct_elt (argp, args, name, static_memfuncp,
                                "structure");
@@ -472,7 +473,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
     }
 
   argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
-                                     &static_memfuncp, 2);
+                                     &static_memfuncp, 2, noside);
 
   if (argvec[0])
     {
@@ -481,6 +482,21 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
          argvec[1] = argvec[0];
          argvec++;
        }
+      if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
+       {
+         /* Static xmethods are not supported yet.  */
+         gdb_assert (static_memfuncp == 0);
+         if (noside == EVAL_AVOID_SIDE_EFFECTS)
+           {
+             struct type *return_type
+               = result_type_of_xmethod (argvec[0], 2, argvec + 1);
+
+             if (return_type == NULL)
+               error (_("Xmethod is missing return type."));
+             return value_zero (return_type, VALUE_LVAL (arg1));
+           }
+         return call_xmethod (argvec[0], 2, argvec + 1);
+       }
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *return_type;
@@ -575,7 +591,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
     }
 
   argvec[0] = value_user_defined_op (&arg1, argvec + 1, tstr,
-                                     &static_memfuncp, nargs);
+                                     &static_memfuncp, nargs, noside);
 
   if (argvec[0])
     {
@@ -585,6 +601,21 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
          nargs --;
          argvec++;
        }
+      if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_XMETHOD)
+       {
+         /* Static xmethods are not supported yet.  */
+         gdb_assert (static_memfuncp == 0);
+         if (noside == EVAL_AVOID_SIDE_EFFECTS)
+           {
+             struct type *return_type
+               = result_type_of_xmethod (argvec[0], 1, argvec + 1);
+
+             if (return_type == NULL)
+               error (_("Xmethod is missing return type."));
+             return value_zero (return_type, VALUE_LVAL (arg1));
+           }
+         return call_xmethod (argvec[0], 1, argvec + 1);
+       }
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *return_type;