typeck.c (composite_pointer_type_r, [...]): Change pedwarn to permerror.

	* typeck.c (composite_pointer_type_r, cxx_sizeof_expr,
	cxx_alignof_expr, check_template_keyword, cp_build_binary_op,
	pointer_diff, cp_build_unary_op, build_x_compound_expr_from_list,
	build_reinterpret_cast_1, cp_build_c_cast, check_return_expr): Change
	pedwarn to permerror.
	* init.c (perform_member_init, build_new_1, build_new): Likewise.
	* decl.c (warn_extern_redeclared_static, duplicate_decls,
	* identify_goto, check_previous_goto_1, check_goto, define_label,
	check_tag_decl, start_decl, check_class_member_definition_namespace,
	grokfndecl, grokdeclarator): Likewise.
	* except.c (check_handlers): Likewise.
	* typeck2.c (digest_init): Likewise.
	* pt.c (check_specialization_namespace,
	check_explicit_instantiation_namespace,
	maybe_process_partial_specialization, check_explicit_specialization,
	convert_template_argument, do_decl_instantiation,
	do_type_instantiation, instantiate_decl): Likewise.
	* semantics.c (finish_template_type_parm): Likewise.
	* name-lookup.c (pushdecl_maybe_friend,
	check_for_out_of_scope_variable): Likewise.
	* decl2.c (finish_static_data_member_decl, build_anon_union_vars,
	coerce_new_type): Likewise.
	* parser.c (cp_parser_nested_name_specifier_opt,
	cp_parser_mem_initializer, cp_parser_elaborated_type_specifier,
	cp_parser_class_head, cp_parser_check_class_key): Likewise.
	(cp_parser_parameter_declaration): Check flag_permissive instead of
	flag_pedantic_errors.
	* call.c (joust): Change pedwarn to warning.
	* friend.c (make_friend_class): Likewise.

From-SVN: r136999

gcc/cp/ChangeLog

+2008-06-21  Jonathan Wakely  <jwakely.gcc@gmail.com>
+
+	* typeck.c (composite_pointer_type_r, cxx_sizeof_expr,
+	cxx_alignof_expr, check_template_keyword, cp_build_binary_op,
+	pointer_diff, cp_build_unary_op, build_x_compound_expr_from_list,
+	build_reinterpret_cast_1, cp_build_c_cast, check_return_expr): Change
+	pedwarn to permerror.
+	* init.c (perform_member_init, build_new_1, build_new): Likewise.
+	* decl.c (warn_extern_redeclared_static, duplicate_decls,
+	* identify_goto, check_previous_goto_1, check_goto, define_label,
+	check_tag_decl, start_decl, check_class_member_definition_namespace,
+	grokfndecl, grokdeclarator): Likewise.
+	* except.c (check_handlers): Likewise.
+	* typeck2.c (digest_init): Likewise.
+	* pt.c (check_specialization_namespace,
+	check_explicit_instantiation_namespace,
+	maybe_process_partial_specialization, check_explicit_specialization,
+	convert_template_argument, do_decl_instantiation,
+	do_type_instantiation, instantiate_decl): Likewise.
+	* semantics.c (finish_template_type_parm): Likewise.
+	* name-lookup.c (pushdecl_maybe_friend,
+	check_for_out_of_scope_variable): Likewise.
+	* decl2.c (finish_static_data_member_decl, build_anon_union_vars,
+	coerce_new_type): Likewise.
+	* parser.c (cp_parser_nested_name_specifier_opt,
+	cp_parser_mem_initializer, cp_parser_elaborated_type_specifier,
+	cp_parser_class_head, cp_parser_check_class_key): Likewise.
+	(cp_parser_parameter_declaration): Check flag_permissive instead of
+	flag_pedantic_errors.
+	* call.c (joust): Change pedwarn to warning.
+	* friend.c (make_friend_class): Likewise.
+
 2008-06-16  Jan Hubicka  <jh@suse.cz>
 
 	* method.c: Include cgraph.h.

gcc/cp/call.c

@@ -6563,10 +6563,10 @@ tweak:
 	{
 	  if (warn)
 	    {
-	      pedwarn ("\
-ISO C++ says that these are ambiguous, even \
-though the worst conversion for the first is better than \
-the worst conversion for the second:");
+	      warning (0,
+	      "ISO C++ says that these are ambiguous, even "
+	      "though the worst conversion for the first is better than "
+	      "the worst conversion for the second:");
 	      print_z_candidate (_("candidate 1:"), w);
 	      print_z_candidate (_("candidate 2:"), l);
 	    }

gcc/cp/decl2.c

@@ -716,8 +716,8 @@ finish_static_data_member_decl (tree decl,
     VEC_safe_push (tree, gc, pending_statics, decl);
 
   if (LOCAL_CLASS_P (current_class_type))
-    pedwarn ("local class %q#T shall not have static data member %q#D",
-	     current_class_type, decl);
+    permerror ("local class %q#T shall not have static data member %q#D",
+	       current_class_type, decl);
 
   /* Static consts need not be initialized in the class definition.  */
   if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
@@ -1233,15 +1233,15 @@ build_anon_union_vars (tree type, tree object)
 	continue;
       if (TREE_CODE (field) != FIELD_DECL)
 	{
-	  pedwarn ("%q+#D invalid; an anonymous union can only "
-		   "have non-static data members", field);
+	  permerror ("%q+#D invalid; an anonymous union can only "
+		     "have non-static data members", field);
 	  continue;
 	}
 
       if (TREE_PRIVATE (field))
-	pedwarn ("private member %q+#D in anonymous union", field);
+	permerror ("private member %q+#D in anonymous union", field);
       else if (TREE_PROTECTED (field))
-	pedwarn ("protected member %q+#D in anonymous union", field);
+	permerror ("protected member %q+#D in anonymous union", field);
 
       if (processing_template_decl)
 	ref = build_min_nt (COMPONENT_REF, object,
@@ -1376,8 +1376,8 @@ coerce_new_type (tree type)
     e = 2;
 
   if (e == 2)
-    pedwarn ("%<operator new%> takes type %<size_t%> (%qT) "
-	     "as first parameter", size_type_node);
+    permerror ("%<operator new%> takes type %<size_t%> (%qT) "
+	       "as first parameter", size_type_node);
 
   switch (e)
   {

gcc/cp/except.c

@@ -1015,8 +1015,8 @@ check_handlers (tree handlers)
 	if (tsi_end_p (i))
 	  break;
 	if (TREE_TYPE (handler) == NULL_TREE)
-	  pedwarn ("%H%<...%> handler must be the last handler for"
-		   " its try block", EXPR_LOCUS (handler));
+	  permerror ("%H%<...%> handler must be the last handler for"
+		     " its try block", EXPR_LOCUS (handler));
 	else
 	  check_handlers_1 (handler, i);
       }

gcc/cp/friend.c

@@ -253,7 +253,7 @@ make_friend_class (tree type, tree friend_type, bool complain)
   else if (same_type_p (type, friend_type))
     {
       if (complain)
-	pedwarn ("class %qT is implicitly friends with itself",
+	warning (0, "class %qT is implicitly friends with itself",
 		 type);
       return;
     }

gcc/cp/init.c

@@ -533,11 +533,11 @@ perform_member_init (tree member, tree init)
 	    }
 	  /* member traversal: note it leaves init NULL */
 	  else if (TREE_CODE (type) == REFERENCE_TYPE)
-	    pedwarn ("%Juninitialized reference member %qD",
-		     current_function_decl, member);
+	    permerror ("%Juninitialized reference member %qD",
+		       current_function_decl, member);
 	  else if (CP_TYPE_CONST_P (type))
-	    pedwarn ("%Juninitialized member %qD with %<const%> type %qT",
-		     current_function_decl, member, type);
+	    permerror ("%Juninitialized member %qD with %<const%> type %qT",
+		       current_function_decl, member, type);
 	}
       else if (TREE_CODE (init) == TREE_LIST)
 	/* There was an explicit member initialization.  Do some work
@@ -2158,7 +2158,7 @@ build_new_1 (tree placement, tree type, tree nelts, tree init,
 	  else if (init)
             {
               if (complain & tf_error)
-                pedwarn ("ISO C++ forbids initialization in array new");
+                permerror ("ISO C++ forbids initialization in array new");
               else
                 return error_mark_node;
             }
@@ -2370,7 +2370,7 @@ build_new (tree placement, tree type, tree nelts, tree init,
       if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
         {
           if (complain & tf_error)
-            pedwarn ("size in array new must have integral type");
+            permerror ("size in array new must have integral type");
           else
             return error_mark_node;
         }

gcc/cp/name-lookup.c

@@ -846,8 +846,8 @@ pushdecl_maybe_friend (tree x, bool is_friend)
 	      && TREE_CODE (decl) == TREE_CODE (x)
 	      && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
 	    {
-	      pedwarn ("type mismatch with previous external decl of %q#D", x);
-	      pedwarn ("previous external decl of %q+#D", decl);
+	      permerror ("type mismatch with previous external decl of %q#D", x);
+	      permerror ("previous external decl of %q+#D", decl);
 	    }
 	}
 
@@ -1165,7 +1165,7 @@ check_for_out_of_scope_variable (tree decl)
 
   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
     {
-      error ("name lookup of %qD changed for new ISO %<for%> scoping",
+      error ("name lookup of %qD changed for ISO %<for%> scoping",
 	     DECL_NAME (decl));
       error ("  cannot use obsolete binding at %q+D because "
 	     "it has a destructor", decl);
@@ -1173,9 +1173,19 @@ check_for_out_of_scope_variable (tree decl)
     }
   else
     {
-      pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
-	       DECL_NAME (decl));
-      pedwarn ("  using obsolete binding at %q+D", decl);
+      permerror ("name lookup of %qD changed for ISO %<for%> scoping",
+	         DECL_NAME (decl));
+      if (flag_permissive)
+        permerror ("  using obsolete binding at %q+D", decl);
+      else
+	{
+	  static bool hint;
+	  if (!hint)
+	    {
+	      inform ("(if you use %<-fpermissive%> G++ will accept your code)");
+	      hint = true;
+	    }
+	}
     }
 
   return decl;

gcc/cp/parser.c

@@ -4111,10 +4111,10 @@ cp_parser_nested_name_specifier_opt (cp_parser *parser,
 	  && !(TREE_CODE (new_scope) == TYPENAME_TYPE
 	       && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
 		   == TEMPLATE_ID_EXPR)))
-	pedwarn (TYPE_P (new_scope)
-		 ? "%qT is not a template"
-		 : "%qD is not a template",
-		 new_scope);
+	permerror (TYPE_P (new_scope)
+		   ? "%qT is not a template"
+		   : "%qD is not a template",
+		   new_scope);
       /* If it is a class scope, try to complete it; we are about to
 	 be looking up names inside the class.  */
       if (TYPE_P (new_scope)
@@ -8928,7 +8928,7 @@ cp_parser_mem_initializer (cp_parser* parser)
   /* Find out what is being initialized.  */
   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
     {
-      pedwarn ("anachronistic old-style base class initializer");
+      permerror ("anachronistic old-style base class initializer");
       mem_initializer_id = NULL_TREE;
     }
   else
@@ -9845,7 +9845,7 @@ cp_parser_template_id (cp_parser *parser,
 	  static bool hint;
 	  if (!hint)
 	    {
-	      inform ("(if you use -fpermissive G++ will accept your code)");
+	      inform ("(if you use %<-fpermissive%> G++ will accept your code)");
 	      hint = true;
 	    }
 	}
@@ -11186,7 +11186,7 @@ cp_parser_elaborated_type_specifier (cp_parser* parser,
       tag_type = typename_type;
       /* The `typename' keyword is only allowed in templates.  */
       if (!processing_template_decl)
-	pedwarn ("using %<typename%> outside of template");
+	permerror ("using %<typename%> outside of template");
     }
   /* Otherwise it must be a class-key.  */
   else
@@ -13865,7 +13865,7 @@ cp_parser_parameter_declaration (cp_parser *parser,
 
       if (!parser->default_arg_ok_p)
 	{
-	  if (!flag_pedantic_errors)
+	  if (flag_permissive)
 	    warning (0, "deprecated use of default argument for parameter of non-function");
 	  else
 	    {
@@ -14758,7 +14758,7 @@ cp_parser_class_head (cp_parser* parser,
 	 class member of a namespace outside of its namespace.  */
       if (scope == nested_name_specifier)
 	{
-	  pedwarn ("extra qualification ignored");
+	  permerror ("extra qualification not allowed");
 	  nested_name_specifier = NULL_TREE;
 	  num_templates = 0;
 	}
@@ -18121,7 +18121,7 @@ static void
 cp_parser_check_class_key (enum tag_types class_key, tree type)
 {
   if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
-    pedwarn ("%qs tag used in naming %q#T",
+    permerror ("%qs tag used in naming %q#T",
 	    class_key == union_type ? "union"
 	     : class_key == record_type ? "struct" : "class",
 	     type);

gcc/cp/pt.c

@@ -710,8 +710,8 @@ check_specialization_namespace (tree tmpl)
     return true;
   else
     {
-      pedwarn ("specialization of %qD in different namespace", tmpl);
-      pedwarn ("  from definition of %q+#D", tmpl);
+      permerror ("specialization of %qD in different namespace", tmpl);
+      permerror ("  from definition of %q+#D", tmpl);
       return false;
     }
 }
@@ -728,9 +728,9 @@ check_explicit_instantiation_namespace (tree spec)
      namespace of its template.  */
   ns = decl_namespace_context (spec);
   if (!is_ancestor (current_namespace, ns))
-    pedwarn ("explicit instantiation of %qD in namespace %qD "
-	     "(which does not enclose namespace %qD)",
-	     spec, current_namespace, ns);
+    permerror ("explicit instantiation of %qD in namespace %qD "
+	       "(which does not enclose namespace %qD)",
+	       spec, current_namespace, ns);
 }
 
 /* The TYPE is being declared.  If it is a template type, that means it
@@ -811,9 +811,9 @@ maybe_process_partial_specialization (tree type)
 	  if (current_namespace
 	      != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
 	    {
-	      pedwarn ("specializing %q#T in different namespace", type);
-	      pedwarn ("  from definition of %q+#D",
-		       CLASSTYPE_TI_TEMPLATE (type));
+	      permerror ("specializing %q#T in different namespace", type);
+	      permerror ("  from definition of %q+#D",
+		         CLASSTYPE_TI_TEMPLATE (type));
 	    }
 
 	  /* Check for invalid specialization after instantiation:
@@ -2006,7 +2006,7 @@ check_explicit_specialization (tree declarator,
       for (; t; t = TREE_CHAIN (t))
 	if (TREE_PURPOSE (t))
 	  {
-	    pedwarn
+	    permerror
 	      ("default argument specified in explicit specialization");
 	    break;
 	  }
@@ -4942,8 +4942,8 @@ convert_template_argument (tree parm,
   if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
       && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
     {
-      pedwarn ("to refer to a type member of a template parameter, "
-	       "use %<typename %E%>", orig_arg);
+      permerror ("to refer to a type member of a template parameter, "
+	         "use %<typename %E%>", orig_arg);
 
       orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
 				     TREE_OPERAND (arg, 1),
@@ -14567,7 +14567,7 @@ do_decl_instantiation (tree decl, tree storage)
 	 the first instantiation was `extern' and the second is not,
 	 and EXTERN_P for the opposite case.  */
       if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
-	pedwarn ("duplicate explicit instantiation of %q#D", result);
+	permerror ("duplicate explicit instantiation of %q#D", result);
       /* If an "extern" explicit instantiation follows an ordinary
 	 explicit instantiation, the template is instantiated.  */
       if (extern_p)
@@ -14580,7 +14580,7 @@ do_decl_instantiation (tree decl, tree storage)
     }
   else if (!DECL_TEMPLATE_INFO (result))
     {
-      pedwarn ("explicit instantiation of non-template %q#D", result);
+      permerror ("explicit instantiation of non-template %q#D", result);
       return;
     }
 
@@ -14721,7 +14721,7 @@ do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
 
       if (!previous_instantiation_extern_p && !extern_p
 	  && (complain & tf_error))
-	pedwarn ("duplicate explicit instantiation of %q#T", t);
+	permerror ("duplicate explicit instantiation of %q#T", t);
 
       /* If we've already instantiated the template, just return now.  */
       if (!CLASSTYPE_INTERFACE_ONLY (t))
@@ -15168,7 +15168,7 @@ instantiate_decl (tree d, int defer_ok,
 	   member function or static data member of a class template
 	   shall be present in every translation unit in which it is
 	   explicitly instantiated.  */
-	pedwarn
+	permerror
 	  ("explicit instantiation of %qD but no definition available", d);
 
       /* ??? Historically, we have instantiated inline functions, even

gcc/cp/semantics.c

@@ -2170,7 +2170,7 @@ finish_template_type_parm (tree aggr, tree identifier)
 {
   if (aggr != class_type_node)
     {
-      pedwarn ("template type parameters must use the keyword %<class%> or %<typename%>");
+      permerror ("template type parameters must use the keyword %<class%> or %<typename%>");
       aggr = class_type_node;
     }
 

gcc/cp/typeck2.c

@@ -694,7 +694,7 @@ digest_init (tree type, tree init)
 		 counted in the length of the constant, but in C++ this would
 		 be invalid.  */
 	      if (size < TREE_STRING_LENGTH (init))
-		pedwarn ("initializer-string for array of chars is too long");
+		permerror ("initializer-string for array of chars is too long");
 	    }
 	  return init;
 	}