This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

more simple warning control patches


More of the simple type of warning fixes: cases where we already test
a warning variable, and we can just move the test inside warning(), or
at least add the OPT* to warning() for diagnostic control.  I'm trying
to at least keep the pace non-zero :-)

89 more down, 582 still to go.

x86_64-linux bootstrapped, no regressions on C/C++

2005-06-28  DJ Delorie  <dj@redhat.com>

	* c-decl.c (pop_scope): Move warning control into warning call.
	(diagnose_mismatched_decls): Likewise.
	(pushdecl): Likewise.
	(start_decl): Likewise.
	(grokparms): Likewise.
	(start_function): Likewise.
	(store_parm_decls_newstyle): Likewise.
	(store_parm_decls_oldstyle): Likewise.
	(finish_function): Likewise.
	(declspecs_add_scspec): Likewise.
	* c-format.c (decode_format_attr): Likewise.
	(maybe_read_dollar_number): Likewise.
	(avoid_dollar_number): Likewise.
	(finish_dollar_format_checking): Likewise.
	(check_format_info): Likewise.
	(check_format_info_main): Likewise.
	(check_format_types): Likewise.
	(format_type_warning): Likewise.
	* c-typeck.c (function_types_compatible_p): Likewise.
	(build_array_ref): Likewise.
	(convert_arguments): Likewise.
	(build_c_cast): Likewise.
	(store_init_value): Likewise.
	(process_init_element): Likewise.
	(c_start_case): Likewise.
	* stor-layout.c (finalize_record_size): Likewise.
	* tree-cfg.c (execute_warn_function_noreturn): Likewise.
	* tree-inline.c (expand_call_inline): Likewise.

Index: c-decl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-decl.c,v
retrieving revision 1.666
diff -p -U3 -r1.666 c-decl.c
--- c-decl.c	26 Jun 2005 21:21:22 -0000	1.666
+++ c-decl.c	28 Jun 2005 17:03:02 -0000
@@ -801,14 +801,13 @@ pop_scope (void)
 
 	case VAR_DECL:
 	  /* Warnings for unused variables.  */
-	  if (warn_unused_variable
-	      && !TREE_USED (p)
+	  if (!TREE_USED (p)
 	      && !DECL_IN_SYSTEM_HEADER (p)
 	      && DECL_NAME (p)
 	      && !DECL_ARTIFICIAL (p)
 	      && scope != file_scope
 	      && scope != external_scope) 
-	    warning (0, "%Junused variable %qD", p, p);
+	    warning (OPT_Wunused_variable, "%Junused variable %qD", p, p);
 
 	  if (b->inner_comp)
 	    {
@@ -1392,8 +1391,8 @@ diagnose_mismatched_decls (tree newdecl,
 	    }
 	  else if (warn_traditional)
 	    {
-	      warning (0, "%Jnon-static declaration of %qD follows "
-		       "static declaration", newdecl, newdecl);
+	      warning (OPT_Wtraditional, "%Jnon-static declaration of %qD "
+		       "follows static declaration", newdecl, newdecl);
 	      warned = true;
 	    }
 	}
@@ -1445,8 +1444,8 @@ diagnose_mismatched_decls (tree newdecl,
 		}
 	      else if (warn_traditional)
 		{
-		  warning (0, "%Jnon-static declaration of %qD follows "
-			   "static declaration", newdecl, newdecl);
+		  warning (OPT_Wtraditional, "%Jnon-static declaration of %qD "
+			   "follows static declaration", newdecl, newdecl);
 		  warned = true;
 		}
 	    }
@@ -1577,7 +1576,8 @@ diagnose_mismatched_decls (tree newdecl,
       && !(TREE_CODE (newdecl) == PARM_DECL
 	   && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)))
     {
-      warning (0, "%Jredundant redeclaration of %qD", newdecl, newdecl);
+      warning (OPT_Wredundant_decls, "%Jredundant redeclaration of %qD",
+	       newdecl, newdecl);
       warned = true;
     }
 
@@ -2121,10 +2121,9 @@ pushdecl (tree x)
 	  visdecl = b->decl;
 	  vistype = TREE_TYPE (visdecl);
 	}
-      if (warn_nested_externs
-	  && scope != file_scope
+      if (scope != file_scope
 	  && !DECL_IN_SYSTEM_HEADER (x))
-	warning (0, "nested extern declaration of %qD", x);
+	warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
 
       while (b && !B_IN_EXTERNAL_SCOPE (b))
 	{
@@ -3102,7 +3101,7 @@ start_decl (struct c_declarator *declara
 
   if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
       && MAIN_NAME_P (DECL_NAME (decl)))
-    warning (0, "%J%qD is usually a function", decl, decl);
+    warning (OPT_Wmain, "%J%qD is usually a function", decl, decl);
 
   if (initialized)
     /* Is it valid for this decl to have an initializer at all?
@@ -4742,9 +4741,9 @@ grokparms (struct c_arg_info *arg_info, 
 {
   tree arg_types = arg_info->types;
 
-  if (warn_strict_prototypes && arg_types == 0 && !funcdef_flag
-      && !in_system_header)
-    warning (0, "function declaration isn%'t a prototype");
+  if (arg_types == 0 && !funcdef_flag && !in_system_header)
+    warning (OPT_Wstrict_prototypes,
+	     "function declaration isn%'t a prototype");
 
   if (arg_types == error_mark_node)
     return 0;  /* don't set TYPE_ARG_TYPES in this case */
@@ -5893,14 +5892,16 @@ start_function (struct c_declspecs *decl
       && old_decl != error_mark_node
       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
       && C_DECL_ISNT_PROTOTYPE (old_decl))
-    warning (0, "function declaration isn%'t a prototype");
+    warning (OPT_Wstrict_prototypes,
+	     "function declaration isn%'t a prototype");
   /* Optionally warn of any global def with no previous prototype.  */
   else if (warn_missing_prototypes
 	   && old_decl != error_mark_node
 	   && TREE_PUBLIC (decl1)
 	   && !MAIN_NAME_P (DECL_NAME (decl1))
 	   && C_DECL_ISNT_PROTOTYPE (old_decl))
-    warning (0, "%Jno previous prototype for %qD", decl1, decl1);
+    warning (OPT_Wmissing_prototypes, "%Jno previous prototype for %qD",
+	     decl1, decl1);
   /* Optionally warn of any def with no previous prototype
      if the function has already been used.  */
   else if (warn_missing_prototypes
@@ -5908,14 +5909,16 @@ start_function (struct c_declspecs *decl
 	   && old_decl != error_mark_node
 	   && TREE_USED (old_decl)
 	   && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
-    warning (0, "%J%qD was used with no prototype before its definition",
+    warning (OPT_Wmissing_prototypes,
+	     "%J%qD was used with no prototype before its definition",
 	     decl1, decl1);
   /* Optionally warn of any global def with no previous declaration.  */
   else if (warn_missing_declarations
 	   && TREE_PUBLIC (decl1)
 	   && old_decl == 0
 	   && !MAIN_NAME_P (DECL_NAME (decl1)))
-    warning (0, "%Jno previous declaration for %qD", decl1, decl1);
+    warning (OPT_Wmissing_declarations, "%Jno previous declaration for %qD",
+	     decl1, decl1);
   /* Optionally warn of any def with no previous declaration
      if the function has already been used.  */
   else if (warn_missing_declarations
@@ -5923,7 +5926,8 @@ start_function (struct c_declspecs *decl
 	   && old_decl != error_mark_node
 	   && TREE_USED (old_decl)
 	   && C_DECL_IMPLICIT (old_decl))
-    warning (0, "%J%qD was used with no declaration before its definition",
+    warning (OPT_Wmissing_declarations,
+	     "%J%qD was used with no declaration before its definition",
 	     decl1, decl1);
 
   /* This is a definition, not a reference.
@@ -6059,9 +6063,10 @@ store_parm_decls_newstyle (tree fndecl, 
      warning if we got here because ARG_INFO_TYPES was error_mark_node
      (this happens when a function definition has just an ellipsis in
      its parameter list).  */
-  else if (warn_traditional && !in_system_header && !current_function_scope
+  else if (!in_system_header && !current_function_scope
 	   && arg_info->types != error_mark_node)
-    warning (0, "%Jtraditional C rejects ISO C style function definitions",
+    warning (OPT_Wtraditional,
+	     "%Jtraditional C rejects ISO C style function definitions",
 	     fndecl);
 
   /* Now make all the parameter declarations visible in the function body.
@@ -6163,7 +6168,8 @@ store_parm_decls_oldstyle (tree fndecl, 
 	  if (flag_isoc99)
 	    pedwarn ("%Jtype of %qD defaults to %<int%>", decl, decl);
 	  else if (extra_warnings)
-	    warning (0, "%Jtype of %qD defaults to %<int%>", decl, decl);
+	    warning (OPT_Wextra, "%Jtype of %qD defaults to %<int%>",
+		     decl, decl);
 	}
 
       TREE_PURPOSE (parm) = decl;
@@ -6518,7 +6524,8 @@ finish_function (void)
 	 inline function, as we might never be compiled separately.  */
       && DECL_INLINE (fndecl))
     {
-      warning (0, "no return statement in function returning non-void");
+      warning (OPT_Wreturn_type,
+	       "no return statement in function returning non-void");
       TREE_NO_WARNING (fndecl) = 1;
     }
 
@@ -6527,7 +6534,7 @@ finish_function (void)
   if (extra_warnings
       && current_function_returns_value
       && current_function_returns_null)
-    warning (0, "this function may return with or without a value");
+    warning (OPT_Wextra, "this function may return with or without a value");
 
   /* Store the end of the function, so that we get good line number
      info for the epilogue.  */
@@ -7265,7 +7272,7 @@ declspecs_add_scspec (struct c_declspecs
 	      && C_IS_RESERVED_WORD (scspec));
   i = C_RID_CODE (scspec);
   if (extra_warnings && specs->non_sc_seen_p)
-    warning (0, "%qE is not at beginning of declaration", scspec);
+    warning (OPT_Wextra, "%qE is not at beginning of declaration", scspec);
   switch (i)
     {
     case RID_INLINE:
Index: c-format.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-format.c,v
retrieving revision 1.78
diff -p -U3 -r1.78 c-format.c
--- c-format.c	25 Jun 2005 01:59:19 -0000	1.78
+++ c-format.c	28 Jun 2005 17:03:02 -0000
@@ -194,7 +194,7 @@ decode_format_attr (tree args, function_
       if (info->format_type == format_type_error)
 	{
 	  gcc_assert (!validated_p);
-	  warning (0, "%qE is an unrecognized format function type",
+	  warning (OPT_Wformat, "%qE is an unrecognized format function type",
 		   format_type_id);
 	  return false;
 	}
@@ -925,7 +925,7 @@ maybe_read_dollar_number (const char **f
     {
       if (dollar_needed)
 	{
-	  warning (0, "missing $ operand number in format");
+	  warning (OPT_Wformat, "missing $ operand number in format");
 	  return -1;
 	}
       else
@@ -946,7 +946,7 @@ maybe_read_dollar_number (const char **f
     {
       if (dollar_needed)
 	{
-	  warning (0, "missing $ operand number in format");
+	  warning (OPT_Wformat, "missing $ operand number in format");
 	  return -1;
 	}
       else
@@ -955,14 +955,14 @@ maybe_read_dollar_number (const char **f
   *format = fcp + 1;
   if (pedantic && !dollar_format_warned)
     {
-      warning (0, "%s does not support %%n$ operand number formats",
+      warning (OPT_Wformat, "%s does not support %%n$ operand number formats",
 	       C_STD_NAME (STD_EXT));
       dollar_format_warned = 1;
     }
   if (overflow_flag || argnum == 0
       || (dollar_first_arg_num && argnum > dollar_arguments_count))
     {
-      warning (0, "operand number out of range in format");
+      warning (OPT_Wformat, "operand number out of range in format");
       return -1;
     }
   if (argnum > dollar_max_arg_used)
@@ -985,7 +985,7 @@ maybe_read_dollar_number (const char **f
       && dollar_arguments_used[argnum - 1] == 1)
     {
       dollar_arguments_used[argnum - 1] = 2;
-      warning (0, "format argument %d used more than once in %s format",
+      warning (OPT_Wformat, "format argument %d used more than once in %s format",
 	       argnum, fki->name);
     }
   else
@@ -1017,7 +1017,7 @@ avoid_dollar_number (const char *format)
     format++;
   if (*format == '$')
     {
-      warning (0, "$ operand number used after format without operand number");
+      warning (OPT_Wformat, "$ operand number used after format without operand number");
       return true;
     }
   return false;
@@ -1047,7 +1047,8 @@ finish_dollar_format_checking (format_ch
 				 || dollar_arguments_pointer_p[i]))
 	    found_pointer_gap = true;
 	  else
-	    warning (0, "format argument %d unused before used argument %d in $-style format",
+	    warning (OPT_Wformat,
+		     "format argument %d unused before used argument %d in $-style format",
 		     i + 1, dollar_max_arg_used);
 	}
     }
@@ -1175,21 +1176,21 @@ check_format_info (function_format_info 
      If the format is an empty string, this should be counted similarly to the
      case of extra format arguments.  */
   if (res.number_extra_args > 0 && res.number_non_literal == 0
-      && res.number_other == 0 && warn_format_extra_args)
-    warning (0, "too many arguments for format");
+      && res.number_other == 0)
+    warning (OPT_Wformat_extra_args, "too many arguments for format");
   if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
-      && res.number_other == 0 && warn_format_extra_args)
-    warning (0, "unused arguments in $-style format");
+      && res.number_other == 0)
+    warning (OPT_Wformat_extra_args, "unused arguments in $-style format");
   if (res.number_empty > 0 && res.number_non_literal == 0
-      && res.number_other == 0 && warn_format_zero_length)
-    warning (0, "zero-length %s format string",
+      && res.number_other == 0)
+    warning (OPT_Wformat_zero_length, "zero-length %s format string",
 	     format_types[info->format_type].name);
 
   if (res.number_wide > 0)
-    warning (0, "format is a wide character string");
+    warning (OPT_Wformat, "format is a wide character string");
 
   if (res.number_unterminated > 0)
-    warning (0, "unterminated format string");
+    warning (OPT_Wformat, "unterminated format string");
 }
 
 /* Callback from check_function_arguments_recurse to check a
@@ -1403,7 +1404,7 @@ check_format_info_main (format_check_res
       if (*format_chars == 0)
 	{
 	  if (format_chars - orig_format_chars != format_length)
-	    warning (0, "embedded %<\\0%> in format");
+	    warning (OPT_Wformat, "embedded %<\\0%> in format");
 	  if (info->first_arg_num != 0 && params != 0
 	      && has_operand_number <= 0)
 	    {
@@ -1418,7 +1419,7 @@ check_format_info_main (format_check_res
 	continue;
       if (*format_chars == 0)
 	{
-	  warning (0, "spurious trailing %<%%%> in format");
+	  warning (OPT_Wformat, "spurious trailing %<%%%> in format");
 	  continue;
 	}
       if (*format_chars == '%')
@@ -1462,7 +1463,7 @@ check_format_info_main (format_check_res
 						     *format_chars, NULL);
 	  if (strchr (flag_chars, *format_chars) != 0)
 	    {
-	      warning (0, "repeated %s in format", _(s->name));
+	      warning (OPT_Wformat, "repeated %s in format", _(s->name));
 	    }
 	  else
 	    {
@@ -1475,7 +1476,7 @@ check_format_info_main (format_check_res
 	      ++format_chars;
 	      if (*format_chars == 0)
 		{
-		  warning (0, "missing fill character at end of strfmon format");
+		  warning (OPT_Wformat, "missing fill character at end of strfmon format");
 		  return;
 		}
 	    }
@@ -1519,7 +1520,7 @@ check_format_info_main (format_check_res
 		{
 		  if (params == 0)
 		    {
-		      warning (0, "too few arguments for format");
+		      warning (OPT_Wformat, "too few arguments for format");
 		      return;
 		    }
 		  cur_param = TREE_VALUE (params);
@@ -1560,7 +1561,7 @@ check_format_info_main (format_check_res
 		}
 	      if (found_width && !non_zero_width_char &&
 		  (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
-		warning (0, "zero width in %s format", fki->name);
+		warning (OPT_Wformat, "zero width in %s format", fki->name);
 	      if (found_width)
 		{
 		  i = strlen (flag_chars);
@@ -1578,7 +1579,7 @@ check_format_info_main (format_check_res
 	  flag_chars[i++] = fki->left_precision_char;
 	  flag_chars[i] = 0;
 	  if (!ISDIGIT (*format_chars))
-	    warning (0, "empty left precision in %s format", fki->name);
+	    warning (OPT_Wformat, "empty left precision in %s format", fki->name);
 	  while (ISDIGIT (*format_chars))
 	    ++format_chars;
 	}
@@ -1621,7 +1622,7 @@ check_format_info_main (format_check_res
 		{
 		  if (params == 0)
 		    {
-		      warning (0, "too few arguments for format");
+		      warning (OPT_Wformat, "too few arguments for format");
 		      return;
 		    }
 		  cur_param = TREE_VALUE (params);
@@ -1651,7 +1652,7 @@ check_format_info_main (format_check_res
 	    {
 	      if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
 		  && !ISDIGIT (*format_chars))
-		warning (0, "empty precision in %s format", fki->name);
+		warning (OPT_Wformat, "empty precision in %s format", fki->name);
 	      while (ISDIGIT (*format_chars))
 		++format_chars;
 	    }
@@ -1690,7 +1691,8 @@ check_format_info_main (format_check_res
 	    {
 	      /* Warn if the length modifier is non-standard.  */
 	      if (ADJ_STD (length_chars_std) > C_STD_VER)
-		warning (0, "%s does not support the %qs %s length modifier",
+		warning (OPT_Wformat,
+			 "%s does not support the %qs %s length modifier",
 			 C_STD_NAME (length_chars_std), length_chars,
 			 fki->name);
 	    }
@@ -1706,7 +1708,7 @@ check_format_info_main (format_check_res
 		{
 		  const format_flag_spec *s = get_flag_spec (flag_specs,
 							     *format_chars, NULL);
-		  warning (0, "repeated %s in format", _(s->name));
+		  warning (OPT_Wformat, "repeated %s in format", _(s->name));
 		}
 	      else
 		{
@@ -1740,7 +1742,7 @@ check_format_info_main (format_check_res
 	  || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
 	      && format_char == '%'))
 	{
-	  warning (0, "conversion lacks type at end of format");
+	  warning (OPT_Wformat, "conversion lacks type at end of format");
 	  continue;
 	}
       format_chars++;
@@ -1751,17 +1753,17 @@ check_format_info_main (format_check_res
       if (fci->format_chars == 0)
 	{
           if (ISGRAPH (format_char))
-	    warning (0, "unknown conversion type character %qc in format",
+	    warning (OPT_Wformat, "unknown conversion type character %qc in format",
 		     format_char);
 	  else
-	    warning (0, "unknown conversion type character 0x%x in format",
+	    warning (OPT_Wformat, "unknown conversion type character 0x%x in format",
 		     format_char);
 	  continue;
 	}
       if (pedantic)
 	{
 	  if (ADJ_STD (fci->std) > C_STD_VER)
-	    warning (0, "%s does not support the %<%%%c%> %s format",
+	    warning (OPT_Wformat, "%s does not support the %<%%%c%> %s format",
 		     C_STD_NAME (fci->std), format_char, fki->name);
 	}
 
@@ -1777,7 +1779,7 @@ check_format_info_main (format_check_res
 	      continue;
 	    if (strchr (fci->flag_chars, flag_chars[i]) == 0)
 	      {
-		warning (0, "%s used with %<%%%c%> %s format",
+		warning (OPT_Wformat, "%s used with %<%%%c%> %s format",
 			 _(s->name), format_char, fki->name);
 		d++;
 		continue;
@@ -1786,7 +1788,7 @@ check_format_info_main (format_check_res
 	      {
 		const format_flag_spec *t;
 		if (ADJ_STD (s->std) > C_STD_VER)
-		  warning (0, "%s does not support %s",
+		  warning (OPT_Wformat, "%s does not support %s",
 			   C_STD_NAME (s->std), _(s->long_name));
 		t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
 		if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
@@ -1795,7 +1797,8 @@ check_format_info_main (format_check_res
 					     ? t->long_name
 					     : s->long_name);
 		    if (ADJ_STD (t->std) > C_STD_VER)
-		      warning (0, "%s does not support %s with the %<%%%c%> %s format",
+		      warning (OPT_Wformat,
+			       "%s does not support %s with the %<%%%c%> %s format",
 			       C_STD_NAME (t->std), _(long_name),
 			       format_char, fki->name);
 		  }
@@ -1828,21 +1831,23 @@ check_format_info_main (format_check_res
 	  if (bad_flag_pairs[i].ignored)
 	    {
 	      if (bad_flag_pairs[i].predicate != 0)
-		warning (0, "%s ignored with %s and %<%%%c%> %s format",
+		warning (OPT_Wformat,
+			 "%s ignored with %s and %<%%%c%> %s format",
 			 _(s->name), _(t->name), format_char,
 			 fki->name);
 	      else
-		warning (0, "%s ignored with %s in %s format",
+		warning (OPT_Wformat, "%s ignored with %s in %s format",
 			 _(s->name), _(t->name), fki->name);
 	    }
 	  else
 	    {
 	      if (bad_flag_pairs[i].predicate != 0)
-		warning (0, "use of %s and %s together with %<%%%c%> %s format",
+		warning (OPT_Wformat,
+			 "use of %s and %s together with %<%%%c%> %s format",
 			 _(s->name), _(t->name), format_char,
 			 fki->name);
 	      else
-		warning (0, "use of %s and %s together in %s format",
+		warning (OPT_Wformat, "use of %s and %s together in %s format",
 			 _(s->name), _(t->name), fki->name);
 	    }
 	}
@@ -1861,10 +1866,11 @@ check_format_info_main (format_check_res
 	  else if (strchr (fci->flags2, '2') != 0)
 	    y2k_level = 2;
 	  if (y2k_level == 3)
-	    warning (0, "%<%%%c%> yields only last 2 digits of year in some locales",
-		     format_char);
+	    warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
+		     "year in some locales", format_char);
 	  else if (y2k_level == 2)
-	    warning (0, "%<%%%c%> yields only last 2 digits of year", format_char);
+	    warning (OPT_Wformat_y2k, "%<%%%c%> yields only last 2 digits of "
+		     "year", format_char);
 	}
 
       if (strchr (fci->flags2, '[') != 0)
@@ -1880,7 +1886,7 @@ check_format_info_main (format_check_res
 	    ++format_chars;
 	  if (*format_chars != ']')
 	    /* The end of the format string was reached.  */
-	    warning (0, "no closing %<]%> for %<%%[%> format");
+	    warning (OPT_Wformat, "no closing %<]%> for %<%%[%> format");
 	}
 
       wanted_type = 0;
@@ -1893,14 +1899,15 @@ check_format_info_main (format_check_res
 	  wanted_type_std = fci->types[length_chars_val].std;
 	  if (wanted_type == 0)
 	    {
-	      warning (0, "use of %qs length modifier with %qc type character",
+	      warning (OPT_Wformat,
+		       "use of %qs length modifier with %qc type character",
 		       length_chars, format_char);
 	      /* Heuristic: skip one argument when an invalid length/type
 		 combination is encountered.  */
 	      arg_num++;
 	      if (params == 0)
 		{
-		  warning (0, "too few arguments for format");
+		  warning (OPT_Wformat, "too few arguments for format");
 		  return;
 		}
 	      params = TREE_CHAIN (params);
@@ -1914,7 +1921,8 @@ check_format_info_main (format_check_res
 		   && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
 	    {
 	      if (ADJ_STD (wanted_type_std) > C_STD_VER)
-		warning (0, "%s does not support the %<%%%s%c%> %s format",
+		warning (OPT_Wformat,
+			 "%s does not support the %<%%%s%c%> %s format",
 			 C_STD_NAME (wanted_type_std), length_chars,
 			 format_char, fki->name);
 	    }
@@ -1931,9 +1939,11 @@ check_format_info_main (format_check_res
 	  if (main_arg_num != 0)
 	    {
 	      if (suppressed)
-		warning (0, "operand number specified with suppressed assignment");
+		warning (OPT_Wformat, "operand number specified with "
+			 "suppressed assignment");
 	      else
-		warning (0, "operand number specified for format taking no argument");
+		warning (OPT_Wformat, "operand number specified for format "
+			 "taking no argument");
 	    }
 	}
       else
@@ -1950,7 +1960,7 @@ check_format_info_main (format_check_res
 	      ++arg_num;
 	      if (has_operand_number > 0)
 		{
-		  warning (0, "missing $ operand number in format");
+		  warning (OPT_Wformat, "missing $ operand number in format");
 		  return;
 		}
 	      else
@@ -1962,7 +1972,7 @@ check_format_info_main (format_check_res
 	    {
 	      if (params == 0)
 		{
-		  warning (0, "too few arguments for format");
+		  warning (OPT_Wformat, "too few arguments for format");
 		  return;
 		}
 
@@ -2075,16 +2085,16 @@ check_format_types (format_wanted_type *
 		  && i == 0
 		  && cur_param != 0
 		  && integer_zerop (cur_param))
-		warning (0, "writing through null pointer (argument %d)",
-			 arg_num);
+		warning (OPT_Wformat, "writing through null pointer "
+			 "(argument %d)", arg_num);
 
 	      /* Check for reading through a NULL pointer.  */
 	      if (types->reading_from_flag
 		  && i == 0
 		  && cur_param != 0
 		  && integer_zerop (cur_param))
-		warning (0, "reading through null pointer (argument %d)",
-			 arg_num);
+		warning (OPT_Wformat, "reading through null pointer "
+			 "(argument %d)", arg_num);
 
 	      if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
 		cur_param = TREE_OPERAND (cur_param, 0);
@@ -2103,8 +2113,8 @@ check_format_types (format_wanted_type *
 			  && (CONSTANT_CLASS_P (cur_param)
 			      || (DECL_P (cur_param)
 				  && TREE_READONLY (cur_param))))))
-		warning (0, "writing into constant object (argument %d)",
-			 arg_num);
+		warning (OPT_Wformat, "writing into constant object "
+			 "(argument %d)", arg_num);
 
 	      /* If there are extra type qualifiers beyond the first
 		 indirection, then this makes the types technically
@@ -2114,8 +2124,8 @@ check_format_types (format_wanted_type *
 		  && (TYPE_READONLY (cur_type)
 		      || TYPE_VOLATILE (cur_type)
 		      || TYPE_RESTRICT (cur_type)))
-		warning (0, "extra type qualifiers in format argument "
-			 "(argument %d)",
+		warning (OPT_Wformat, "extra type qualifiers in format "
+			 "argument (argument %d)",
 			 arg_num);
 
 	    }
@@ -2225,20 +2235,24 @@ format_type_warning (const char *descr, 
   if (wanted_type_name)
     {
       if (descr)
-	warning (0, "%s should have type %<%s%s%>, but argument %d has type %qT",
+	warning (OPT_Wformat, "%s should have type %<%s%s%>, "
+		 "but argument %d has type %qT",
 		 descr, wanted_type_name, p, arg_num, arg_type);
       else
-	warning (0, "format %q.*s expects type %<%s%s%>, but argument %d has type %qT",
+	warning (OPT_Wformat, "format %q.*s expects type %<%s%s%>, "
+		 "but argument %d has type %qT",
 		 format_length, format_start, wanted_type_name, p,
 		 arg_num, arg_type);
     }
   else
     {
       if (descr)
-	warning (0, "%s should have type %<%T%s%>, but argument %d has type %qT",
+	warning (OPT_Wformat, "%s should have type %<%T%s%>, "
+		 "but argument %d has type %qT",
 		 descr, wanted_type, p, arg_num, arg_type);
       else
-	warning (0, "format %q.*s expects type %<%T%s%>, but argument %d has type %qT",
+	warning (OPT_Wformat, "format %q.*s expects type %<%T%s%>, "
+		 "but argument %d has type %qT",
 		 format_length, format_start, wanted_type, p, arg_num, arg_type);
     }
 }
Index: c-typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v
retrieving revision 1.460
diff -p -U3 -r1.460 c-typeck.c
--- c-typeck.c	26 Jun 2005 21:54:14 -0000	1.460
+++ c-typeck.c	28 Jun 2005 17:03:04 -0000
@@ -1064,7 +1064,7 @@ function_types_compatible_p (tree f1, tr
 	return 0;
       /* If one of these types comes from a non-prototype fn definition,
 	 compare that with the other type's arglist.
-	 If they don't match, ask for a warning (0, but no error).  */
+	 If they don't match, ask for a warning (but no error).  */
       if (TYPE_ACTUAL_ARG_TYPES (f1)
 	  && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
 	val = 2;
@@ -1721,9 +1721,9 @@ build_array_ref (tree array, tree index)
      deliberately.  ??? Existing practice has also been to warn only
      when the char index is syntactically the index, not for
      char[array].  */
-  if (warn_char_subscripts && !swapped
+  if (!swapped
       && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
-    warning (0, "array subscript has type %<char%>");
+    warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
 
   /* Apply default promotions *after* noticing character types.  */
   index = default_conversion (index);
@@ -2234,8 +2234,9 @@ convert_arguments (tree typelist, tree v
 			   and the actual arg is that enum type.  */
 			;
 		      else if (formal_prec != TYPE_PRECISION (type1))
-			warning (0, "passing argument %d of %qE with different "
-				 "width due to prototype", argnum, rname);
+			warning (OPT_Wconversion, "passing argument %d of %qE "
+				 "with different width due to prototype",
+				 argnum, rname);
 		      else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
 			;
 		      /* Don't complain if the formal parameter type
@@ -2256,11 +2257,12 @@ convert_arguments (tree typelist, tree v
 			       && TYPE_UNSIGNED (TREE_TYPE (val)))
 			;
 		      else if (TYPE_UNSIGNED (type))
-			warning (0, "passing argument %d of %qE as unsigned "
-				 "due to prototype", argnum, rname);
+			warning (OPT_Wconversion, "passing argument %d of %qE "
+				 "as unsigned due to prototype",
+				 argnum, rname);
 		      else
-			warning (0, "passing argument %d of %qE as signed "
-				 "due to prototype", argnum, rname);
+			warning (OPT_Wconversion, "passing argument %d of %qE "
+				 "as signed due to prototype", argnum, rname);
 		    }
 		}
 
@@ -3249,7 +3251,7 @@ build_c_cast (tree type, tree expr)
 	}
 
       /* Warn about possible alignment problems.  */
-      if (STRICT_ALIGNMENT && warn_cast_align
+      if (STRICT_ALIGNMENT
 	  && TREE_CODE (type) == POINTER_TYPE
 	  && TREE_CODE (otype) == POINTER_TYPE
 	  && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
@@ -3260,28 +3262,28 @@ build_c_cast (tree type, tree expr)
 		|| TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
 	       && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
 	  && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
-	warning (0, "cast increases required alignment of target type");
+	warning (OPT_Wcast_align,
+		 "cast increases required alignment of target type");
 
-      if (warn_pointer_to_int_cast
-	  && TREE_CODE (type) == INTEGER_TYPE
+      if (TREE_CODE (type) == INTEGER_TYPE
 	  && TREE_CODE (otype) == POINTER_TYPE
 	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
 	  && !TREE_CONSTANT (value))
-	warning (0, "cast from pointer to integer of different size");
+	warning (OPT_Wpointer_to_int_cast,
+		 "cast from pointer to integer of different size");
 
-      if (warn_bad_function_cast
-	  && TREE_CODE (value) == CALL_EXPR
+      if (TREE_CODE (value) == CALL_EXPR
 	  && TREE_CODE (type) != TREE_CODE (otype))
-	warning (0, "cast from function call of type %qT to non-matching "
-		 "type %qT", otype, type);
+	warning (OPT_Wbad_function_cast, "cast from function call of type %qT "
+		 "to non-matching type %qT", otype, type);
 
-      if (warn_int_to_pointer_cast
-	  && TREE_CODE (type) == POINTER_TYPE
+      if (TREE_CODE (type) == POINTER_TYPE
 	  && TREE_CODE (otype) == INTEGER_TYPE
 	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
 	  /* Don't warn about converting any constant.  */
 	  && !TREE_CONSTANT (value))
-	warning (0, "cast to pointer from integer of different size");
+	warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer "
+		 "of different size");
 
       if (flag_strict_aliasing && warn_strict_aliasing
 	  && TREE_CODE (type) == POINTER_TYPE
@@ -3294,17 +3296,20 @@ build_c_cast (tree type, tree expr)
 	  /* Casting the address of an object to non void pointer. Warn
 	     if the cast breaks type based aliasing.  */
 	  if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
-	    warning (0, "type-punning to incomplete type might break strict-aliasing rules");
+	    warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
+		     "might break strict-aliasing rules");
 	  else
 	    {
 	      HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
 	      HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
 
 	      if (!alias_sets_conflict_p (set1, set2))
-		warning (0, "dereferencing type-punned pointer will break strict-aliasing rules");
+		warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
+			 "pointer will break strict-aliasing rules");
 	      else if (warn_strict_aliasing > 1
 		       && !alias_sets_might_conflict_p (set1, set2))
-		warning (0, "dereferencing type-punned pointer might break strict-aliasing rules");
+		warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
+			 "pointer might break strict-aliasing rules");
 	    }
 	}
 
@@ -3998,9 +4003,10 @@ store_init_value (tree decl, tree init)
 
   /* Store the expression if valid; else report error.  */
 
-  if (warn_traditional && !in_system_header
+  if (!in_system_header
       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
-    warning (0, "traditional C rejects automatic aggregate initialization");
+    warning (OPT_Wtraditional, "traditional C rejects automatic "
+	     "aggregate initialization");
 
   DECL_INITIAL (decl) = value;
 
@@ -6240,10 +6246,11 @@ process_init_element (struct c_expr valu
 	     again on the assumption that this must be conditional on
 	     __STDC__ anyway (and we've already complained about the
 	     member-designator already).  */
-	  if (warn_traditional && !in_system_header && !constructor_designated
+	  if (!in_system_header && !constructor_designated
 	      && !(value.value && (integer_zerop (value.value)
 				   || real_zerop (value.value))))
-	    warning (0, "traditional C rejects initialization of unions");
+	    warning (OPT_Wtraditional, "traditional C rejects initialization "
+		     "of unions");
 
 	  /* Accept a string constant to initialize a subarray.  */
 	  if (value.value != 0
@@ -6751,11 +6758,11 @@ c_start_case (tree exp)
 	{
 	  type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
 
-	  if (warn_traditional && !in_system_header
+	  if (!in_system_header
 	      && (type == long_integer_type_node
 		  || type == long_unsigned_type_node))
-	    warning (0, "%<long%> switch expression not converted to "
-		     "%<int%> in ISO C");
+	    warning (OPT_Wtraditional, "%<long%> switch expression not "
+		     "converted to %<int%> in ISO C");
 
 	  exp = default_conversion (exp);
 	  type = TREE_TYPE (exp);
Index: stor-layout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/stor-layout.c,v
retrieving revision 1.234
diff -p -U3 -r1.234 stor-layout.c
--- stor-layout.c	25 Jun 2005 02:01:06 -0000	1.234
+++ stor-layout.c	28 Jun 2005 17:03:05 -0000
@@ -1266,9 +1266,9 @@ finalize_record_size (record_layout_info
   TYPE_SIZE_UNIT (rli->t)
     = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
 
-  if (warn_padded && TREE_CONSTANT (unpadded_size)
+  if (TREE_CONSTANT (unpadded_size)
       && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
-    warning (0, "padding struct size to alignment boundary");
+    warning (OPT_Wpadded, "padding struct size to alignment boundary");
 
   if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
       && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
@@ -1298,19 +1298,19 @@ finalize_record_size (record_layout_info
 		name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
 
 	      if (STRICT_ALIGNMENT)
-		warning (OPT_Wattributes, "packed attribute causes inefficient "
+		warning (OPT_Wpacked, "packed attribute causes inefficient "
 			 "alignment for %qs", name);
 	      else
-		warning (OPT_Wattributes,
+		warning (OPT_Wpacked,
 			 "packed attribute is unnecessary for %qs", name);
 	    }
 	  else
 	    {
 	      if (STRICT_ALIGNMENT)
-		warning (OPT_Wattributes,
+		warning (OPT_Wpacked,
 			 "packed attribute causes inefficient alignment");
 	      else
-		warning (OPT_Wattributes, "packed attribute is unnecessary");
+		warning (OPT_Wpacked, "packed attribute is unnecessary");
 	    }
 	}
     }
Index: tree-cfg.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-cfg.c,v
retrieving revision 2.206
diff -p -U3 -r2.206 tree-cfg.c
--- tree-cfg.c	26 Jun 2005 21:21:27 -0000	2.206
+++ tree-cfg.c	28 Jun 2005 17:03:05 -0000
@@ -5130,8 +5130,8 @@ execute_warn_function_noreturn (void)
       && !TREE_THIS_VOLATILE (cfun->decl)
       && EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 0
       && !lang_hooks.function.missing_noreturn_ok_p (cfun->decl))
-    warning (0, "%Jfunction might be possible candidate for "
-	     "attribute %<noreturn%>",
+    warning (OPT_Wmissing_noreturn, "%Jfunction might be possible candidate "
+	     "for attribute %<noreturn%>",
 	     cfun->decl);
 }
 
Index: tree-inline.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-inline.c,v
retrieving revision 1.198
diff -p -U3 -r1.198 tree-inline.c
--- tree-inline.c	25 Jun 2005 02:01:22 -0000	1.198
+++ tree-inline.c	28 Jun 2005 17:03:05 -0000
@@ -1971,8 +1971,9 @@ expand_call_inline (basic_block bb, tree
 	       && strlen (reason)
 	       && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn)))
 	{
-	  warning (0, "%Jinlining failed in call to %qF: %s", fn, fn, reason);
-	  warning (0, "called from here");
+	  warning (OPT_Winline, "%Jinlining failed in call to %qF: %s",
+		   fn, fn, reason);
+	  warning (OPT_Winline, "called from here");
 	}
       goto egress;
     }


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]