* gdbtypes.c (is_ancestor): Infer type equivalence from name

	equivalence.
	(rank_one_type): Use strcmp instead of == to compare type names.
	Don't swap parm with arg when checking TYPE_CODE_REF types.
	* valops.c (find_overload_match): Fix indentation.  Compare
	parameter rankings to 0..9, 10..99, and 100+ instead of 0, 10,
	and 100.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 88c921a..2e3060b 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,13 @@
+2000-07-09  Nick Duffek  <nsd@redhat.com>
+
+       * gdbtypes.c (is_ancestor): Infer type equivalence from name
+       equivalence.
+       (rank_one_type): Use strcmp instead of == to compare type names.
+       Don't swap parm with arg when checking TYPE_CODE_REF types.
+       * valops.c (find_overload_match): Fix indentation.  Compare
+       parameter rankings to 0..9, 10..99, and 100+ instead of 0, 10,
+       and 100.
+
 2000-07-07  David Edelsohn  <edelsohn@gnu.org>
 
        * xcoffread.c (read_symbol_nvalue): Return CORE_ADDR.

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 0f6eef9..3ca1b33 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1736,6 +1736,9 @@ is_ancestor (base, dclass)
 
   if (base == dclass)
     return 1;
+  if (TYPE_NAME (base) && TYPE_NAME (dclass) &&
+      !strcmp (TYPE_NAME (base), TYPE_NAME (dclass)))
+    return 1;
 
   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
     if (is_ancestor (base, TYPE_BASECLASS (dclass, i)))
@@ -2206,7 +2209,8 @@ rank_one_type (parm, arg)
      really are the same.
   */
 
-  if (TYPE_NAME (parm) == TYPE_NAME (arg))
+  if (TYPE_NAME (parm) && TYPE_NAME (arg) &&
+      !strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
       return 0;
 
   /* Check if identical after resolving typedefs */
@@ -2216,10 +2220,10 @@ rank_one_type (parm, arg)
   /* See through references, since we can almost make non-references
      references. */
   if (TYPE_CODE (arg) == TYPE_CODE_REF)
-    return (rank_one_type (TYPE_TARGET_TYPE (arg), parm)
+    return (rank_one_type (parm, TYPE_TARGET_TYPE (arg))
            + REFERENCE_CONVERSION_BADNESS);
   if (TYPE_CODE (parm) == TYPE_CODE_REF)
-    return (rank_one_type (arg, TYPE_TARGET_TYPE (parm))
+    return (rank_one_type (TYPE_TARGET_TYPE (parm), arg)
            + REFERENCE_CONVERSION_BADNESS);
   if (overload_debug)
   /* Debugging only. */

diff --git a/gdb/valops.c b/gdb/valops.c
index d5171a6..114a035 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -2858,16 +2858,16 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp,
            break;
          }
       free (parm_types);
-if (overload_debug)
-{
-      if (method)
-       fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
-      else
-       fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
-      for (jj = 0; jj < nargs; jj++)
-       fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
-      fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
-}
+      if (overload_debug)
+       {
+         if (method)
+           fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
+         else
+           fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
+         for (jj = 0; jj < nargs; jj++)
+           fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
+         fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
+       }
     }                          /* end loop over all candidates */
   /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
      if they have the exact same goodness. This is because there is no
@@ -2890,15 +2890,11 @@ if (overload_debug)
   /* Check how bad the best match is */
   for (ix = 1; ix <= nargs; ix++)
     {
-      switch (oload_champ_bv->rank[ix])
-       {
-       case 10:
-         oload_non_standard = 1;       /* non-standard type conversions needed */
-         break;
-       case 100:
-         oload_incompatible = 1;       /* truly mismatched types */
-         break;
-       }
+      if (oload_champ_bv->rank[ix] >= 100)
+       oload_incompatible = 1; /* truly mismatched types */
+
+      else if (oload_champ_bv->rank[ix] >= 10)
+       oload_non_standard = 1; /* non-standard type conversions needed */
     }
   if (oload_incompatible)
     {