86th Cygnus<->FSF quick merge

From-SVN: r12008

gcc/cp/ChangeLog

@@ -3,6 +3,31 @@ Sat May 11 04:33:50 1996  Doug Evans  <dje@canuck.cygnus.com>
 	* decl2.c (finish_vtable_vardecl): Surround DECL_ONE_ONLY with ifdef.
 	(finish_file): Likewise.
 
+Thu May 16 15:29:33 1996  Bob Manson  <manson@charmed.cygnus.com>
+
+	* expr.c (do_case): Don't try to dereference null TREE_TYPEs
+	when checking for pointer types.
+
+Thu May 16 13:38:58 1996  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* pt.c (instantiate_class_template): Remove obsolete check for
+ 	access declarations.
+
+Thu May 16 13:34:15 1996  Mike Stump  <mrs@cygnus.com>
+
+	* call.c (build_overload_call): Simplify calls to
+	build_overload_call by removing last parameter.
+	(build_method_call): Ditto.
+	* cp-tree.h: Ditto.
+	* method.c (build_opfncall): Ditto.
+	* typeck.c (build_x_function_call): Ditto.
+
+Thu May 16 13:15:43 1996  Mike Stump  <mrs@cygnus.com>
+
+	* call.c (default_parm_conversions): Factor out common code.
+	(build_method_call): Use it.
+	(build_overload_call_real): Use it.
+
 Wed May 15 14:46:14 1996  Mike Stump  <mrs@cygnus.com>
 
 	* call.c (build_method_call): Allow implicit & on METHOD_TYPEs,

gcc/cp/call.c

@@ -1584,6 +1584,36 @@ build_call (function, result_type, parms)
   return function;
 }
 
+static tree
+default_parm_conversions (parms, last)
+     tree parms, *last;
+{
+  tree parm, parmtypes = NULL_TREE;
+
+  *last = NULL_TREE;
+
+  for (parm = parms; parm; parm = TREE_CHAIN (parm))
+    {
+      tree t = TREE_TYPE (TREE_VALUE (parm));
+
+      if (TREE_CODE (t) == OFFSET_TYPE
+	  || TREE_CODE (t) == METHOD_TYPE
+	  || TREE_CODE (t) == FUNCTION_TYPE)
+	{
+	  TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
+	  t = TREE_TYPE (TREE_VALUE (parm));
+	}
+
+      if (t == error_mark_node)
+	  return error_mark_node;
+
+      *last = build_tree_list (NULL_TREE, t);
+      parmtypes = chainon (parmtypes, *last);
+    }
+
+  return parmtypes;
+}
+
 
 /* Build something of the form ptr->method (args)
    or object.method (args).  This can also build
@@ -1988,35 +2018,10 @@ build_method_call (instance, name, parms, basetype_path, flags)
 
   save_basetype = TYPE_MAIN_VARIANT (basetype);
 
-  last = NULL_TREE;
-  for (parmtypes = NULL_TREE, parm = parms; parm; parm = TREE_CHAIN (parm))
+  parmtypes = default_parm_conversions (parms, &last);
+  if (parmtypes == error_mark_node)
     {
-      tree t = TREE_TYPE (TREE_VALUE (parm));
-      if (TREE_CODE (t) == OFFSET_TYPE)
-	{
-	  /* Convert OFFSET_TYPE entities to their normal selves.  */
-	  TREE_VALUE (parm) = resolve_offset_ref (TREE_VALUE (parm));
-	  t = TREE_TYPE (TREE_VALUE (parm));
-	}
-      if (TREE_CODE (t) == METHOD_TYPE)
-	{
-	  cp_pedwarn ("assuming & on `%E'", TREE_VALUE (parm));
-	  TREE_VALUE (parm) = build_unary_op (ADDR_EXPR, TREE_VALUE (parm), 0);
-	}
-#if 0
-      /* This breaks reference-to-array parameters.  */
-      if (TREE_CODE (t) == ARRAY_TYPE)
-	{
-	  /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
-	     This eliminates needless calls to `compute_conversion_costs'.  */
-	  TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
-	  t = TREE_TYPE (TREE_VALUE (parm));
-	}
-#endif
-      if (t == error_mark_node)
-	return error_mark_node;
-      last = build_tree_list (NULL_TREE, t);
-      parmtypes = chainon (parmtypes, last);
+      return error_mark_node;
     }
 
   if (instance && IS_SIGNATURE (basetype))
@@ -2146,7 +2151,7 @@ build_method_call (instance, name, parms, basetype_path, flags)
 	      cp->harshness = (struct harshness_code *)
 		alloca ((len + 1) * sizeof (struct harshness_code));
 
-	      result = build_overload_call (name, friend_parms, 0, cp);
+	      result = build_overload_call_real (name, friend_parms, 0, cp, 1);
 
 	      /* If it turns out to be the one we were actually looking for
 		 (it was probably a friend function), the return the
@@ -2429,14 +2434,16 @@ build_method_call (instance, name, parms, basetype_path, flags)
       && value_member (function, get_abstract_virtuals (basetype)))
     cp_error ("abstract virtual `%#D' called from constructor", function);
 
-  if (IS_SIGNATURE (basetype) && static_call_context)
+  if (IS_SIGNATURE (basetype))
     {
-      cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
-		basetype, save_name);
-      return error_mark_node;
+      if (static_call_context)
+	{
+	  cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference",
+		    basetype, save_name);
+	  return error_mark_node;
 	}
-  else if (IS_SIGNATURE (basetype))
-    return build_signature_method_call (basetype, instance, function, parms);
+      return build_signature_method_call (basetype, instance, function, parms);
+    }
 
   function = DECL_MAIN_VARIANT (function);
   mark_used (function);
@@ -2632,7 +2639,7 @@ build_overload_call_real (fnname, parms, flags, final_cp, require_complete)
 {
   /* must check for overloading here */
   tree functions, function, parm;
-  tree parmtypes = NULL_TREE, last = NULL_TREE;
+  tree parmtypes, last;
   register tree outer;
   int length;
   int parmlength = list_length (parms);
@@ -2648,31 +2655,14 @@ build_overload_call_real (fnname, parms, flags, final_cp, require_complete)
       final_cp[1].h.code = EVIL_CODE;
     }
 
-  for (parm = parms; parm; parm = TREE_CHAIN (parm))
+  parmtypes = default_parm_conversions (parms, &last);
+  if (parmtypes == error_mark_node)
     {
-      register tree t = TREE_TYPE (TREE_VALUE (parm));
-
-      if (t == error_mark_node)
-	{
-	  if (final_cp)
-	    final_cp->h.code = EVIL_CODE;
-	  return error_mark_node;
-	}
-      if (TREE_CODE (t) == OFFSET_TYPE)
-#if 0
-      /* This breaks reference-to-array parameters.  */
-	  || TREE_CODE (t) == ARRAY_TYPE
-#endif
-	{
-	  /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
-	     Also convert OFFSET_TYPE entities to their normal selves.
-	     This eliminates needless calls to `compute_conversion_costs'.  */
-	  TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
-	  t = TREE_TYPE (TREE_VALUE (parm));
-	}
-      last = build_tree_list (NULL_TREE, t);
-      parmtypes = chainon (parmtypes, last);
+      if (final_cp)
+	final_cp->h.code = EVIL_CODE;
+      return error_mark_node;
     }
+
   if (last)
     TREE_CHAIN (last) = void_list_node;
   else
@@ -2891,10 +2881,9 @@ build_overload_call_real (fnname, parms, flags, final_cp, require_complete)
 
 /* This requires a complete type on the result of the call.  */
 tree
-build_overload_call (fnname, parms, flags, final_cp)
+build_overload_call (fnname, parms, flags)
      tree fnname, parms;
      int flags;
-     struct candidate *final_cp;
 {
-  return build_overload_call_real (fnname, parms, flags, final_cp, 1);
+  return build_overload_call_real (fnname, parms, flags, (struct candidate *)0, 1);
 }

gcc/cp/cp-tree.h

@@ -1944,7 +1944,7 @@ extern tree build_addr_func			PROTO((tree));
 extern tree build_scoped_method_call		PROTO((tree, tree, tree, tree));
 extern tree build_method_call			PROTO((tree, tree, tree, tree, int));
 extern tree build_overload_call_real		PROTO((tree, tree, int, struct candidate *, int));
-extern tree build_overload_call			PROTO((tree, tree, int, struct candidate *));
+extern tree build_overload_call			PROTO((tree, tree, int));
 
 /* in class.c */
 extern tree build_vbase_pointer			PROTO((tree, tree));

gcc/cp/expr.c

@@ -374,7 +374,8 @@ do_case (start, end)
 {
   tree value1 = NULL_TREE, value2 = NULL_TREE, label;
 
-  if (start && POINTER_TYPE_P (TREE_TYPE (start)))
+  if (start != NULL_TREE && TREE_TYPE (start) != NULL_TREE 
+      && POINTER_TYPE_P (TREE_TYPE (start)))
     error ("pointers are not permitted as case values");
 
   if (end && pedantic)

gcc/cp/method.c

@@ -1233,8 +1233,7 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
 	tree args = tree_cons (NULL_TREE, xarg2, arg3);
 	fnname = ansi_opname[(int) code];
 	if (flags & LOOKUP_GLOBAL)
-	  return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN,
-				      (struct candidate *)0);
+	  return build_overload_call (fnname, args, flags & LOOKUP_COMPLAIN);
 
 	rval = build_method_call
 	  (build_indirect_ref (build1 (NOP_EXPR, xarg1, error_mark_node),
@@ -1258,8 +1257,7 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
 	if (flags & LOOKUP_GLOBAL)
 	  return build_overload_call (fnname,
 				      build_tree_list (NULL_TREE, xarg1),
-				      flags & LOOKUP_COMPLAIN,
-				      (struct candidate *)0);
+				      flags & LOOKUP_COMPLAIN);
 	arg1 = TREE_TYPE (xarg1);
 
 	/* This handles the case where we're trying to delete
@@ -1481,8 +1479,7 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
     {
       parms = tree_cons (NULL_TREE, xarg1,
 			 build_tree_list (NULL_TREE, xarg2));
-      rval = build_overload_call (fnname, parms, flags,
-				  (struct candidate *)0);
+      rval = build_overload_call (fnname, parms, flags);
     }
 
   return rval;

gcc/cp/pt.c

@@ -1182,8 +1182,7 @@ instantiate_class_template (type)
     {
       tree tmp;
       for (tmp = TYPE_FIELDS (type); tmp; tmp = TREE_CHAIN (tmp))
-	if (TREE_CODE (tmp) == FIELD_DECL
-	    && TREE_CODE (DECL_NAME (tmp)) != SCOPE_REF)
+	if (TREE_CODE (tmp) == FIELD_DECL)
 	  require_complete_type (tmp);
 
       /* XXX handle attributes */

gcc/cp/typeck.c

@@ -1430,7 +1430,7 @@ decay_conversion (exp)
   register tree type = TREE_TYPE (exp);
   register enum tree_code code = TREE_CODE (type);
 
-  if (code == OFFSET_TYPE /* || TREE_CODE (exp) == OFFSET_REF */ )
+  if (code == OFFSET_TYPE)
     {
       if (TREE_CODE (exp) == OFFSET_REF)
 	return decay_conversion (resolve_offset_ref (exp));
@@ -2370,7 +2370,7 @@ build_x_function_call (function, params, decl)
 	      (function, params, LOOKUP_COMPLAIN, (struct candidate *)0, 0);
 	  else if (DECL_CHAIN (val) != NULL_TREE)
 	    return build_overload_call
-	      (function, params, LOOKUP_COMPLAIN, (struct candidate *)0);
+	      (function, params, LOOKUP_COMPLAIN);
 	  else
 	    my_friendly_abort (360);
 	}