Modified Files:

	ChangeLog eval.c valops.c

        * valops.c (typecmp): improve prototype matching when calling
        a method. Make 'p (*(ostream *) &cout) << "lll" ' to work.
        * eval.c(evalute_subexp): fix operator search problem when call
        like  p x.'operator+'(i).

3 files changed, 68 insertions, 21 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 96c9179..2712356 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,10 @@
+Wed Nov 17 09:43:31 1993  Kung Hsu  (kung@cirdan.cygnus.com)
+
+	* valops.c (typecmp): improve prototype matching when calling
+	a method. Make 'p (*(ostream *) &cout) << "lll" ' to work.
+	* eval.c(evalute_subexp): fix operator search problem when call
+	like  p x.'operator+'(i).
+
 Tue Nov 16 17:15:03 1993  Stu Grossman  (grossman at cygnus.com)
 
 	* i386ly-nat.c, i386lynx-nat.c, m68kly-nat.c:  Remove.  Move
diff --git a/gdb/eval.c b/gdb/eval.c
index 4aba99f..a5a8315 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -24,6 +24,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "expression.h"
 #include "target.h"
 #include "frame.h"
+#include "demangle.h"
 #include "language.h"	/* For CAST_IS_CONVERSION */
 
 /* Values of NOSIDE argument to eval_subexp.  */
@@ -163,8 +164,8 @@ evaluate_subexp (expect_type, exp, pos, noside)
 {
   enum exp_opcode op;
   int tem, tem2, tem3;
-  register int pc, pc2, oldpos;
-  register value arg1, arg2, arg3;
+  register int pc, pc2 = 0, oldpos;
+  register value arg1 = NULL, arg2 = NULL, arg3;
   struct type *type;
   int nargs;
   value *argvec;
@@ -202,7 +203,7 @@ evaluate_subexp (expect_type, exp, pos, noside)
 	goto nosideret;
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
-	  struct symbol * sym = exp->elts[pc + 1].symbol;
+	  struct symbol * sym = exp->elts[pc + 2].symbol;
 	  enum lval_type lv;
 
 	  switch (SYMBOL_CLASS (sym))
@@ -416,19 +417,50 @@ evaluate_subexp (expect_type, exp, pos, noside)
 	{
 	  int static_memfuncp;
 	  value temp = arg2;
+	  char tstr[15], mangle_tstr[15], *ptr, *mangle_ptr;
+	  char *pp;
 
 	  argvec[1] = arg2;
-	  argvec[0] =
-	    value_struct_elt (&temp, argvec+1, &exp->elts[pc2 + 2].string,
+	  argvec[0] = 0;
+	  strcpy(tstr, &exp->elts[pc2+2].string);
+	  if (!strncmp(tstr, "operator", 8))
+	    {
+	       ptr = &tstr[8];
+	       strcpy(mangle_tstr, "__");
+	       mangle_ptr = &mangle_tstr[2];
+	       pp = cplus_mangle_opname(ptr, DMGL_ANSI);
+	       if (pp) 
+		 strcpy(mangle_ptr, pp);
+	       else
+	         strcpy(mangle_ptr, ptr);
+	       argvec[0] =
+	         value_struct_elt (&temp, argvec+1, mangle_tstr,
 			      &static_memfuncp,
 			      op == STRUCTOP_STRUCT
 			      ? "structure" : "structure pointer");
-	  if (VALUE_OFFSET (temp))
+	       if (!argvec[0]) 
+		 {
+	            pp = cplus_mangle_opname(ptr, DMGL_NO_OPTS);
+	            if (pp) 
+		      strcpy(mangle_ptr, pp);
+	            else
+	              strcpy(mangle_ptr, ptr);
+		    strcpy(tstr, mangle_tstr);
+	         }
+	    }
+          if (!argvec[0]) 
 	    {
-	      arg2 = value_from_longest (lookup_pointer_type (VALUE_TYPE (temp)),
-					 VALUE_ADDRESS (temp)+VALUE_OFFSET (temp));
-	      argvec[1] = arg2;
+	      temp = arg2;
+	      argvec[0] =
+	      value_struct_elt (&temp, argvec+1, tstr,
+			      &static_memfuncp,
+			      op == STRUCTOP_STRUCT
+			      ? "structure" : "structure pointer");
 	    }
+	  arg2 = value_from_longest (lookup_pointer_type(VALUE_TYPE (temp)),
+			 VALUE_ADDRESS (temp)+VALUE_OFFSET (temp));
+	  argvec[1] = arg2;
+
 	  if (static_memfuncp)
 	    {
 	      argvec[1] = argvec[0];
diff --git a/gdb/valops.c b/gdb/valops.c
index ebddb5b..52f3bc4 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -1278,21 +1278,27 @@ typecmp (staticp, t1, t2)
   if (t1[!staticp] == 0) return 0;
   for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++)
     {
+    struct type *tt1, *tt2;
       if (! t2[i])
 	return i+1;
-      if (TYPE_CODE (t1[i]) == TYPE_CODE_REF
+      tt1 = t1[i];
+      tt2 = VALUE_TYPE(t2[i]);
+      if (TYPE_CODE (tt1) == TYPE_CODE_REF
 	  /* We should be doing hairy argument matching, as below.  */
-	  && (TYPE_CODE (TYPE_TARGET_TYPE (t1[i]))
-	      == TYPE_CODE (VALUE_TYPE (t2[i]))))
+	  && (TYPE_CODE (TYPE_TARGET_TYPE (tt1)) == TYPE_CODE (tt2)))
 	{
 	  t2[i] = value_addr (t2[i]);
 	  continue;
 	}
 
-      if (TYPE_CODE (t1[i]) == TYPE_CODE_PTR
-	  && TYPE_CODE (VALUE_TYPE (t2[i])) == TYPE_CODE_ARRAY)
-	/* Array to pointer is a `trivial conversion' according to the ARM.  */
-	continue;
+      while (TYPE_CODE (tt1) == TYPE_CODE_PTR
+	  && (TYPE_CODE(tt2)==TYPE_CODE_ARRAY || TYPE_CODE(tt2)==TYPE_CODE_PTR))
+	{
+	   tt1 = TYPE_TARGET_TYPE(tt1); 
+	   tt2 = TYPE_TARGET_TYPE(tt2);
+	}
+      if (TYPE_CODE(tt1) == TYPE_CODE(tt2)) continue;
+      /* Array to pointer is a `trivial conversion' according to the ARM.  */
 
       /* We should be doing much hairier argument matching (see section 13.2
 	 of the ARM), but as a quick kludge, just check for the same type
@@ -1400,6 +1406,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
      register struct type *type;
 {
   int i;
+  value v;
   static int name_matched = 0;
 
   check_stub_type (type);
@@ -1425,7 +1432,8 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
 		    return (value)value_virtual_fn_field (arg1p, f, j, type, offset);
 		  if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
 		    *static_memfuncp = 1;
-		  return (value)value_fn_field (arg1p, f, j, type, offset);
+		  v = (value)value_fn_field (arg1p, f, j, type, offset);
+		  if (v != (value)NULL) return v;
 		}
 	      j--;
 	    }
@@ -1434,7 +1442,6 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
 
   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
     {
-      value v;
       int base_offset;
 
       if (BASETYPE_VIA_VIRTUAL (type, i))
@@ -1547,9 +1554,10 @@ value_struct_elt (argp, args, name, static_memfuncp, err)
       if (!args[1])
 	{
 	  /* destructors are a special case.  */
-	  return (value)value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, 0),
-					TYPE_FN_FIELDLIST_LENGTH (t, 0),
-					0, 0);
+	  v = (value)value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, 0),
+				TYPE_FN_FIELDLIST_LENGTH (t, 0), 0, 0);
+	  if (!v) error("could not find destructor function named %s.", name);
+	  else return v;
 	}
       else
 	{