OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

re PR c/44774 (-Werror=edantic) 

2012-04-22  Manuel López-Ibáñez  <manu@gcc.gnu.org>

	PR c/44774
gcc/
	* doc/invoke.texi (pedantic): Rename to Wpedantic.
	* common.opt (Wpedantic): New.
	(pedantic): Alias Wpedantic.
	* diagnostic.c (warning_at): Likewise.
	* c-decl.c (diagnose_mismatched_decls): Likewise.
	(build_array_declarator): Likewise.
	(mark_forward_parm_decls):
	(check_bitfield_type_and_width): Likewise.
	(grokdeclarator): Likewise.
	(grokfield): Likewise.
	(finish_struct): Likewise.
	(build_enumerator): Likewise.
	(store_parm_decls_oldstyle): Likewise.
	(declspecs_add_qual): Likewise.
	(declspecs_add_type): Likewise.
	(finish_declspecs): Likewise.
	* c-typeck.c (composite_type): Likewise.
	(comp_target_types): Likewise.
	(build_array_ref): Likewise.
	(pointer_diff): Likewise.
	(build_unary_op): Likewise.
	(build_conditional_expr): Likewise.
	(build_c_cast): Likewise.
	(convert_for_assignment): Likewise.
	(maybe_warn_string_init): Likewise.
	(digest_init): Likewise.
	(pop_init_level): Likewise.
	(set_init_index): Likewise.
	(c_finish_goto_label): Likewise.
	(c_finish_return): Likewise.
	(do_case): Likewise.
	(build_binary_op): Likewise.
	* c-parser.c (static): Likewise.
	(c_parser_external_declaration): Likewise.
	(c_parser_declaration_or_fndef): Likewise.
	(c_parser_static_assert_declaration_no_se): Likewise.
	(c_parser_enum_specifier): Likewise.
	(c_parser_struct_or_union_specifier): Likewise.
	(c_parser_struct_declaration): Likewise.
	(c_parser_alignas_specifier): Likewise.
	(c_parser_braced_init): Likewise.
	(c_parser_initelt): Likewise.
	(c_parser_compound_statement_nostart): Likewise.
	(c_parser_conditional_expression): Likewise.
	(c_parser_alignof_expression): Likewise.
	(c_parser_postfix_expression): Likewise.
	(c_parser_postfix_expression_after_paren_): Likewise.
	(c_parser_objc_class_instance_variables): Likewise.
	(c_parser_objc_method_definition): Likewise.
	(c_parser_objc_methodprotolist): Likewise.

c-family/
	* c.opt (Wpedantic): New.
	(pedantic): Alias Wpedantic.
	* c-opts.c (c_common_handle_option): Replace -pedantic with -Wpedantic.
	(c_common_post_options): Likewise.
	(sanitize_cpp_opts): Likewise.
	* c-lex.c (interpret_float): Likewise.
	* c-format.c (check_format_types): Likewise.
	* c-common.c (pointer_int_sum): Likewise.
	(c_sizeof_or_alignof_type): Likewise.
	(c_add_case_label): Likewise.
	(c_do_switch_warnings): Likewise.
	* c-pragma.c (handle_pragma_float_const_decimal64): Likewise.
cp/
	* typeck.c (composite_pointer_type): Likewise.
	(cxx_sizeof_or_alignof_type): Likewise.
	(cp_build_array_ref): Likewise.
	(cp_build_function_call_vec): Likewise.
	(cp_build_addr_expr_1): Likewise.
	(convert_member_func_to_ptr): Likewise.
	* decl.c (check_tag_decl): Likewise.
	(check_static_variable_definition): Likewise.
	(compute_array_index_type): Likewise.
	(create_array_type_for_decl): Likewise.
	(grokdeclarator): Likewise.
	(grok_op_properties): Likewise.
	* error.c (maybe_warn_cpp0x): Likewise.
	* pt.c (maybe_process_partial_specialization): Likewise.
	(convert_template_argument): Likewise.
	(do_decl_instantiation): Likewise.
	(do_type_instantiation): Likewise.
	* parser.c (cp_parser_primary_expression): Likewise.
	(cp_parser_postfix_expression): Likewise.
	(cp_parser_unary_expression): Likewise.
	(cp_parser_question_colon_clause): Likewise.
	(cp_parser_lambda_introducer): Likewise.
	(cp_parser_lambda_declarator_opt): Likewise.
	(cp_parser_compound_statement): Likewise.
	(cp_parser_jump_statement): Likewise.
	(cp_parser_declaration_seq_opt): Likewise.
	(cp_parser_enum_specifier): Likewise.
	(cp_parser_enumerator_list): Likewise.
	(cp_parser_initializer_list): Likewise.
	(cp_parser_member_declaration): Likewise.
	* call.c (build_conditional_expr_1): Likewise.
	* friend.c (make_friend_class): Likewise.
	* name-lookup.c (pushdecl_maybe_friend_1): Likewise.

From-SVN: r186681
This commit is contained in:
Manuel López-Ibáñez 2012-04-22 19:17:47 +00:00
parent f12e8bd5c3
commit c1771a200a
23 changed files with 320 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
gcc/ChangeLog
View File

@ -1,3 +1,57 @@
2012-04-22 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR c/44774
* doc/invoke.texi (pedantic): Rename to Wpedantic.
* common.opt (Wpedantic): New.
(pedantic): Alias Wpedantic.
* diagnostic.c (warning_at): Likewise.
* c-decl.c (diagnose_mismatched_decls): Likewise.
(build_array_declarator): Likewise.
(mark_forward_parm_decls):
(check_bitfield_type_and_width): Likewise.
(grokdeclarator): Likewise.
(grokfield): Likewise.
(finish_struct): Likewise.
(build_enumerator): Likewise.
(store_parm_decls_oldstyle): Likewise.
(declspecs_add_qual): Likewise.
(declspecs_add_type): Likewise.
(finish_declspecs): Likewise.
* c-typeck.c (composite_type): Likewise.
(comp_target_types): Likewise.
(build_array_ref): Likewise.
(pointer_diff): Likewise.
(build_unary_op): Likewise.
(build_conditional_expr): Likewise.
(build_c_cast): Likewise.
(convert_for_assignment): Likewise.
(maybe_warn_string_init): Likewise.
(digest_init): Likewise.
(pop_init_level): Likewise.
(set_init_index): Likewise.
(c_finish_goto_label): Likewise.
(c_finish_return): Likewise.
(do_case): Likewise.
(build_binary_op): Likewise.
* c-parser.c (static): Likewise.
(c_parser_external_declaration): Likewise.
(c_parser_declaration_or_fndef): Likewise.
(c_parser_static_assert_declaration_no_se): Likewise.
(c_parser_enum_specifier): Likewise.
(c_parser_struct_or_union_specifier): Likewise.
(c_parser_struct_declaration): Likewise.
(c_parser_alignas_specifier): Likewise.
(c_parser_braced_init): Likewise.
(c_parser_initelt): Likewise.
(c_parser_compound_statement_nostart): Likewise.
(c_parser_conditional_expression): Likewise.
(c_parser_alignof_expression): Likewise.
(c_parser_postfix_expression): Likewise.
(c_parser_postfix_expression_after_paren_): Likewise.
(c_parser_objc_class_instance_variables): Likewise.
(c_parser_objc_method_definition): Likewise.
(c_parser_objc_methodprotolist): Likewise.
2012-04-22 Ian Lance Taylor <iant@google.com> 2012-04-22 Ian Lance Taylor <iant@google.com>
* godump.c (go_output_typedef): Dump size of structs. * godump.c (go_output_typedef): Dump size of structs.

92
gcc/c-decl.c
View File

@ -1837,7 +1837,7 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
} }
else if (pedantic && !flag_isoc11) else if (pedantic && !flag_isoc11)
{ {
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"redefinition of typedef %q+D", newdecl); "redefinition of typedef %q+D", newdecl);
locate_old_decl (olddecl); locate_old_decl (olddecl);
} }
@ -3897,11 +3897,11 @@ build_array_declarator (location_t loc,
if (!flag_isoc99) if (!flag_isoc99)
{ {
if (static_p || quals != NULL) if (static_p || quals != NULL)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support %<static%> or type " "ISO C90 does not support %<static%> or type "
"qualifiers in parameter array declarators"); "qualifiers in parameter array declarators");
if (vla_unspec_p) if (vla_unspec_p)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support %<[*]%> array declarators"); "ISO C90 does not support %<[*]%> array declarators");
} }
if (vla_unspec_p) if (vla_unspec_p)
@ -4594,7 +4594,7 @@ mark_forward_parm_decls (void)
if (pedantic && !current_scope->warned_forward_parm_decls) if (pedantic && !current_scope->warned_forward_parm_decls)
{ {
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C forbids forward parameter declarations"); "ISO C forbids forward parameter declarations");
current_scope->warned_forward_parm_decls = true; current_scope->warned_forward_parm_decls = true;
} }
@ -4746,7 +4746,7 @@ check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
{ {
*width = c_fully_fold (*width, false, NULL); *width = c_fully_fold (*width, false, NULL);
if (TREE_CODE (*width) == INTEGER_CST) if (TREE_CODE (*width) == INTEGER_CST)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"bit-field %qs width not an integer constant expression", "bit-field %qs width not an integer constant expression",
name); name);
} }
@ -4782,7 +4782,7 @@ check_bitfield_type_and_width (tree *type, tree *width, tree orig_name)
&& type_mv != integer_type_node && type_mv != integer_type_node
&& type_mv != unsigned_type_node && type_mv != unsigned_type_node
&& type_mv != boolean_type_node) && type_mv != boolean_type_node)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"type of bit-field %qs is a GCC extension", name); "type of bit-field %qs is a GCC extension", name);
max_width = TYPE_PRECISION (*type); max_width = TYPE_PRECISION (*type);
@ -5076,11 +5076,11 @@ grokdeclarator (const struct c_declarator *declarator,
if (pedantic && !flag_isoc99) if (pedantic && !flag_isoc99)
{ {
if (constp > 1) if (constp > 1)
pedwarn (loc, OPT_pedantic, "duplicate %<const%>"); pedwarn (loc, OPT_Wpedantic, "duplicate %<const%>");
if (restrictp > 1) if (restrictp > 1)
pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>"); pedwarn (loc, OPT_Wpedantic, "duplicate %<restrict%>");
if (volatilep > 1) if (volatilep > 1)
pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>"); pedwarn (loc, OPT_Wpedantic, "duplicate %<volatile%>");
} }
if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2) if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2)
@ -5107,7 +5107,7 @@ grokdeclarator (const struct c_declarator *declarator,
{ {
if (storage_class == csc_auto) if (storage_class == csc_auto)
pedwarn (loc, pedwarn (loc,
(current_scope == file_scope) ? 0 : OPT_pedantic, (current_scope == file_scope) ? 0 : OPT_Wpedantic,
"function definition declared %<auto%>"); "function definition declared %<auto%>");
if (storage_class == csc_register) if (storage_class == csc_register)
error_at (loc, "function definition declared %<register%>"); error_at (loc, "function definition declared %<register%>");
@ -5173,7 +5173,7 @@ grokdeclarator (const struct c_declarator *declarator,
error_at (loc, "file-scope declaration of %qE specifies %<auto%>", error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
name); name);
if (pedantic && storage_class == csc_register) if (pedantic && storage_class == csc_register)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"file-scope declaration of %qE specifies %<register%>", name); "file-scope declaration of %qE specifies %<register%>", name);
} }
else else
@ -5295,7 +5295,7 @@ grokdeclarator (const struct c_declarator *declarator,
} }
if (pedantic && !in_system_header && flexible_array_type_p (type)) if (pedantic && !in_system_header && flexible_array_type_p (type))
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"invalid use of structure with flexible array member"); "invalid use of structure with flexible array member");
if (size == error_mark_node) if (size == error_mark_node)
@ -5335,10 +5335,10 @@ grokdeclarator (const struct c_declarator *declarator,
if (pedantic && size_maybe_const && integer_zerop (size)) if (pedantic && size_maybe_const && integer_zerop (size))
{ {
if (name) if (name)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids zero-size array %qE", name); "ISO C forbids zero-size array %qE", name);
else else
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids zero-size array"); "ISO C forbids zero-size array");
} }
@ -5463,7 +5463,7 @@ grokdeclarator (const struct c_declarator *declarator,
} }
if (flexible_array_member if (flexible_array_member
&& pedantic && !flag_isoc99 && !in_system_header) && pedantic && !flag_isoc99 && !in_system_header)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support flexible array members"); "ISO C90 does not support flexible array members");
/* ISO C99 Flexible array members are effectively /* ISO C99 Flexible array members are effectively
@ -5664,7 +5664,7 @@ grokdeclarator (const struct c_declarator *declarator,
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
&& type_quals) && type_quals)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids qualified function types"); "ISO C forbids qualified function types");
if (type_quals) if (type_quals)
type = c_build_qualified_type (type, type_quals); type = c_build_qualified_type (type, type_quals);
@ -5842,7 +5842,7 @@ grokdeclarator (const struct c_declarator *declarator,
tree decl; tree decl;
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
&& type_quals) && type_quals)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids qualified function types"); "ISO C forbids qualified function types");
if (type_quals) if (type_quals)
type = c_build_qualified_type (type, type_quals); type = c_build_qualified_type (type, type_quals);
@ -5888,7 +5888,7 @@ grokdeclarator (const struct c_declarator *declarator,
&& !declspecs->inline_p && !declspecs->noreturn_p); && !declspecs->inline_p && !declspecs->noreturn_p);
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
&& type_quals) && type_quals)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids const or volatile function types"); "ISO C forbids const or volatile function types");
if (type_quals) if (type_quals)
type = c_build_qualified_type (type, type_quals); type = c_build_qualified_type (type, type_quals);
@ -5899,7 +5899,7 @@ grokdeclarator (const struct c_declarator *declarator,
&& variably_modified_type_p (type, NULL_TREE)) && variably_modified_type_p (type, NULL_TREE))
{ {
/* C99 6.7.2.1p8 */ /* C99 6.7.2.1p8 */
pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot " pedwarn (loc, OPT_Wpedantic, "a member of a structure or union cannot "
"have a variably modified type"); "have a variably modified type");
} }
@ -5954,7 +5954,7 @@ grokdeclarator (const struct c_declarator *declarator,
else if (TREE_CODE (type) == FUNCTION_TYPE) else if (TREE_CODE (type) == FUNCTION_TYPE)
{ {
if (type_quals) if (type_quals)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids qualified function types"); "ISO C forbids qualified function types");
if (type_quals) if (type_quals)
type = c_build_qualified_type (type, type_quals); type = c_build_qualified_type (type, type_quals);
@ -6032,7 +6032,7 @@ grokdeclarator (const struct c_declarator *declarator,
GCC allows 'auto', perhaps with 'inline', to support GCC allows 'auto', perhaps with 'inline', to support
nested functions. */ nested functions. */
if (storage_class == csc_auto) if (storage_class == csc_auto)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"invalid storage class for function %qE", name); "invalid storage class for function %qE", name);
else if (storage_class == csc_static) else if (storage_class == csc_static)
{ {
@ -6049,7 +6049,7 @@ grokdeclarator (const struct c_declarator *declarator,
decl = build_decl_attribute_variant (decl, decl_attr); decl = build_decl_attribute_variant (decl, decl_attr);
if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl)) if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids qualified function types"); "ISO C forbids qualified function types");
/* Every function declaration is an external reference /* Every function declaration is an external reference
@ -6101,10 +6101,10 @@ grokdeclarator (const struct c_declarator *declarator,
if (!flag_isoc11) if (!flag_isoc11)
{ {
if (flag_isoc99) if (flag_isoc99)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C99 does not support %<_Noreturn%>"); "ISO C99 does not support %<_Noreturn%>");
else else
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support %<_Noreturn%>"); "ISO C90 does not support %<_Noreturn%>");
} }
TREE_THIS_VOLATILE (decl) = 1; TREE_THIS_VOLATILE (decl) = 1;
@ -6816,10 +6816,10 @@ grokfield (location_t loc,
if (!flag_isoc11) if (!flag_isoc11)
{ {
if (flag_isoc99) if (flag_isoc99)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C99 doesn%'t support unnamed structs/unions"); "ISO C99 doesn%'t support unnamed structs/unions");
else else
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 doesn%'t support unnamed structs/unions"); "ISO C90 doesn%'t support unnamed structs/unions");
} }
} }
@ -7104,16 +7104,16 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
if (TREE_CODE (t) == UNION_TYPE) if (TREE_CODE (t) == UNION_TYPE)
{ {
if (fieldlist) if (fieldlist)
pedwarn (loc, OPT_pedantic, "union has no named members"); pedwarn (loc, OPT_Wpedantic, "union has no named members");
else else
pedwarn (loc, OPT_pedantic, "union has no members"); pedwarn (loc, OPT_Wpedantic, "union has no members");
} }
else else
{ {
if (fieldlist) if (fieldlist)
pedwarn (loc, OPT_pedantic, "struct has no named members"); pedwarn (loc, OPT_Wpedantic, "struct has no named members");
else else
pedwarn (loc, OPT_pedantic, "struct has no members"); pedwarn (loc, OPT_Wpedantic, "struct has no members");
} }
} }
} }
@ -7195,7 +7195,7 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
if (pedantic && TREE_CODE (t) == RECORD_TYPE if (pedantic && TREE_CODE (t) == RECORD_TYPE
&& flexible_array_type_p (TREE_TYPE (x))) && flexible_array_type_p (TREE_TYPE (x)))
pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic, pedwarn (DECL_SOURCE_LOCATION (x), OPT_Wpedantic,
"invalid use of structure with flexible array member"); "invalid use of structure with flexible array member");
if (DECL_NAME (x) if (DECL_NAME (x)
@ -7617,7 +7617,7 @@ build_enumerator (location_t decl_loc, location_t loc,
{ {
value = c_fully_fold (value, false, NULL); value = c_fully_fold (value, false, NULL);
if (TREE_CODE (value) == INTEGER_CST) if (TREE_CODE (value) == INTEGER_CST)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"enumerator value for %qE is not an integer " "enumerator value for %qE is not an integer "
"constant expression", name); "constant expression", name);
} }
@ -7649,7 +7649,7 @@ build_enumerator (location_t decl_loc, location_t loc,
(6.4.4.3/2 in the C99 Standard). GCC allows any integer type as (6.4.4.3/2 in the C99 Standard). GCC allows any integer type as
an extension. */ an extension. */
else if (!int_fits_type_p (value, integer_type_node)) else if (!int_fits_type_p (value, integer_type_node))
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C restricts enumerator values to range of %<int%>"); "ISO C restricts enumerator values to range of %<int%>");
/* The ISO C Standard mandates enumerators to have type int, even /* The ISO C Standard mandates enumerators to have type int, even
@ -8195,14 +8195,14 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
old-style definition and discarded? */ old-style definition and discarded? */
if (current_function_prototype_built_in) if (current_function_prototype_built_in)
warning_at (DECL_SOURCE_LOCATION (parm), warning_at (DECL_SOURCE_LOCATION (parm),
OPT_pedantic, "promoted argument %qD " OPT_Wpedantic, "promoted argument %qD "
"doesn%'t match built-in prototype", parm); "doesn%'t match built-in prototype", parm);
else else
{ {
pedwarn (DECL_SOURCE_LOCATION (parm), pedwarn (DECL_SOURCE_LOCATION (parm),
OPT_pedantic, "promoted argument %qD " OPT_Wpedantic, "promoted argument %qD "
"doesn%'t match prototype", parm); "doesn%'t match prototype", parm);
pedwarn (current_function_prototype_locus, OPT_pedantic, pedwarn (current_function_prototype_locus, OPT_Wpedantic,
"prototype declaration"); "prototype declaration");
} }
} }
@ -8878,7 +8878,7 @@ declspecs_add_qual (struct c_declspecs *specs, tree qual)
gcc_unreachable (); gcc_unreachable ();
} }
if (dupe && !flag_isoc99) if (dupe && !flag_isoc99)
pedwarn (input_location, OPT_pedantic, "duplicate %qE", qual); pedwarn (input_location, OPT_Wpedantic, "duplicate %qE", qual);
return specs; return specs;
} }
@ -9094,7 +9094,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
case RID_COMPLEX: case RID_COMPLEX:
dupe = specs->complex_p; dupe = specs->complex_p;
if (!flag_isoc99 && !in_system_header) if (!flag_isoc99 && !in_system_header)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support complex types"); "ISO C90 does not support complex types");
if (specs->typespec_word == cts_void) if (specs->typespec_word == cts_void)
error_at (loc, error_at (loc,
@ -9133,7 +9133,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
break; break;
case RID_SAT: case RID_SAT:
dupe = specs->saturating_p; dupe = specs->saturating_p;
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C does not support saturating types"); "ISO C does not support saturating types");
if (specs->typespec_word == cts_int128) if (specs->typespec_word == cts_int128)
{ {
@ -9212,7 +9212,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
return specs; return specs;
} }
if (!in_system_header) if (!in_system_header)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C does not support %<__int128%> type"); "ISO C does not support %<__int128%> type");
if (specs->long_p) if (specs->long_p)
@ -9415,7 +9415,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
error_at (loc, error_at (loc,
("decimal floating point not supported " ("decimal floating point not supported "
"for this target")); "for this target"));
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C does not support decimal floating point"); "ISO C does not support decimal floating point");
return specs; return specs;
case RID_FRACT: case RID_FRACT:
@ -9439,7 +9439,7 @@ declspecs_add_type (location_t loc, struct c_declspecs *specs,
if (!targetm.fixed_point_supported_p ()) if (!targetm.fixed_point_supported_p ())
error_at (loc, error_at (loc,
"fixed-point types not supported for this target"); "fixed-point types not supported for this target");
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C does not support fixed-point types"); "ISO C does not support fixed-point types");
return specs; return specs;
default: default:
@ -9675,7 +9675,7 @@ finish_declspecs (struct c_declspecs *specs)
else if (specs->complex_p) else if (specs->complex_p)
{ {
specs->typespec_word = cts_double; specs->typespec_word = cts_double;
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C does not support plain %<complex%> meaning " "ISO C does not support plain %<complex%> meaning "
"%<double complex%>"); "%<double complex%>");
} }
@ -9720,7 +9720,7 @@ finish_declspecs (struct c_declspecs *specs)
specs->type = char_type_node; specs->type = char_type_node;
if (specs->complex_p) if (specs->complex_p)
{ {
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C does not support complex integer types"); "ISO C does not support complex integer types");
specs->type = build_complex_type (specs->type); specs->type = build_complex_type (specs->type);
} }
@ -9733,7 +9733,7 @@ finish_declspecs (struct c_declspecs *specs)
: int128_integer_type_node); : int128_integer_type_node);
if (specs->complex_p) if (specs->complex_p)
{ {
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C does not support complex integer types"); "ISO C does not support complex integer types");
specs->type = build_complex_type (specs->type); specs->type = build_complex_type (specs->type);
} }
@ -9759,7 +9759,7 @@ finish_declspecs (struct c_declspecs *specs)
: integer_type_node); : integer_type_node);
if (specs->complex_p) if (specs->complex_p)
{ {
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C does not support complex integer types"); "ISO C does not support complex integer types");
specs->type = build_complex_type (specs->type); specs->type = build_complex_type (specs->type);
} }

16
gcc/c-family/ChangeLog
View File

@ -1,3 +1,19 @@
2012-04-22 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR c/44774
* c.opt (Wpedantic): New.
(pedantic): Alias Wpedantic.
* c-opts.c (c_common_handle_option): Replace -pedantic with -Wpedantic.
(c_common_post_options): Likewise.
(sanitize_cpp_opts): Likewise.
* c-lex.c (interpret_float): Likewise.
* c-format.c (check_format_types): Likewise.
* c-common.c (pointer_int_sum): Likewise.
(c_sizeof_or_alignof_type): Likewise.
(c_add_case_label): Likewise.
(c_do_switch_warnings): Likewise.
* c-pragma.c (handle_pragma_float_const_decimal64): Likewise.
2012-04-15 Jason Merrill <jason@redhat.com> 2012-04-15 Jason Merrill <jason@redhat.com>
PR c++/52818 PR c++/52818

18
gcc/c-family/c-common.c
View File

@ -3858,19 +3858,19 @@ pointer_int_sum (location_t loc, enum tree_code resultcode,
if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE) if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
{ {
pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (loc, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"pointer of type %<void *%> used in arithmetic"); "pointer of type %<void *%> used in arithmetic");
size_exp = integer_one_node; size_exp = integer_one_node;
} }
else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE) else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
{ {
pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (loc, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"pointer to a function used in arithmetic"); "pointer to a function used in arithmetic");
size_exp = integer_one_node; size_exp = integer_one_node;
} }
else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE) else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
{ {
pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (loc, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"pointer to member function used in arithmetic"); "pointer to member function used in arithmetic");
size_exp = integer_one_node; size_exp = integer_one_node;
} }
@ -4449,7 +4449,7 @@ c_sizeof_or_alignof_type (location_t loc,
if (is_sizeof) if (is_sizeof)
{ {
if (complain && (pedantic || warn_pointer_arith)) if (complain && (pedantic || warn_pointer_arith))
pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (loc, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"invalid application of %<sizeof%> to a function type"); "invalid application of %<sizeof%> to a function type");
else if (!complain) else if (!complain)
return error_mark_node; return error_mark_node;
@ -4460,10 +4460,10 @@ c_sizeof_or_alignof_type (location_t loc,
if (complain) if (complain)
{ {
if (c_dialect_cxx ()) if (c_dialect_cxx ())
pedwarn (loc, OPT_pedantic, "ISO C++ does not permit " pedwarn (loc, OPT_Wpedantic, "ISO C++ does not permit "
"%<alignof%> applied to a function type"); "%<alignof%> applied to a function type");
else else
pedwarn (loc, OPT_pedantic, "ISO C does not permit " pedwarn (loc, OPT_Wpedantic, "ISO C does not permit "
"%<_Alignof%> applied to a function type"); "%<_Alignof%> applied to a function type");
} }
value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT); value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
@ -4473,7 +4473,7 @@ c_sizeof_or_alignof_type (location_t loc,
{ {
if (type_code == VOID_TYPE if (type_code == VOID_TYPE
&& complain && (pedantic || warn_pointer_arith)) && complain && (pedantic || warn_pointer_arith))
pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (loc, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"invalid application of %qs to a void type", op_name); "invalid application of %qs to a void type", op_name);
else if (!complain) else if (!complain)
return error_mark_node; return error_mark_node;
@ -5441,7 +5441,7 @@ c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
/* Case ranges are a GNU extension. */ /* Case ranges are a GNU extension. */
if (high_value) if (high_value)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"range expressions in switch statements are non-standard"); "range expressions in switch statements are non-standard");
type = TREE_TYPE (cond); type = TREE_TYPE (cond);
@ -5755,7 +5755,7 @@ finish_label_address_expr (tree label, location_t loc)
{ {
tree result; tree result;
pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard"); pedwarn (input_location, OPT_Wpedantic, "taking the address of a label is non-standard");
if (label == error_mark_node) if (label == error_mark_node)
return error_mark_node; return error_mark_node;

4
gcc/c-family/c-format.c
View File

@ -2424,13 +2424,13 @@ check_format_types (format_wanted_type *types)
continue; continue;
/* If we want 'void *', allow any pointer type. /* If we want 'void *', allow any pointer type.
(Anything else would already have got a warning.) (Anything else would already have got a warning.)
With -pedantic, only allow pointers to void and to character With -Wpedantic, only allow pointers to void and to character
types. */ types. */
if (wanted_type == void_type_node if (wanted_type == void_type_node
&& (!pedantic || (i == 1 && char_type_flag))) && (!pedantic || (i == 1 && char_type_flag)))
continue; continue;
/* Don't warn about differences merely in signedness, unless /* Don't warn about differences merely in signedness, unless
-pedantic. With -pedantic, warn if the type is a pointer -Wpedantic. With -Wpedantic, warn if the type is a pointer
target and not a character type, and for character types at target and not a character type, and for character types at
a second level of indirection. */ a second level of indirection. */
if (TREE_CODE (wanted_type) == INTEGER_TYPE if (TREE_CODE (wanted_type) == INTEGER_TYPE

2
gcc/c-family/c-lex.c
View File

@ -734,7 +734,7 @@ interpret_float (const cpp_token *token, unsigned int flags,
return error_mark_node; return error_mark_node;
} }
else else
pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant"); pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
type = c_common_type_for_mode (mode, 0); type = c_common_type_for_mode (mode, 0);
gcc_assert (type); gcc_assert (type);

12
gcc/c-family/c-opts.c
View File

@ -740,11 +740,11 @@ c_common_handle_option (size_t scode, const char *arg, int value,
error ("output filename specified twice"); error ("output filename specified twice");
break; break;
/* We need to handle the -pedantic switches here, rather than in /* We need to handle the -Wpedantic switches here, rather than in
c_common_post_options, so that a subsequent -Wno-endif-labels c_common_post_options, so that a subsequent -Wno-endif-labels
is not overridden. */ is not overridden. */
case OPT_pedantic_errors: case OPT_pedantic_errors:
case OPT_pedantic: case OPT_Wpedantic:
cpp_opts->cpp_pedantic = 1; cpp_opts->cpp_pedantic = 1;
cpp_opts->warn_endif_labels = 1; cpp_opts->warn_endif_labels = 1;
if (warn_pointer_sign == -1) if (warn_pointer_sign == -1)
@ -925,7 +925,7 @@ c_common_post_options (const char **pfilename)
warn_ignored_qualifiers = extra_warnings; warn_ignored_qualifiers = extra_warnings;
/* -Wpointer-sign is disabled by default, but it is enabled if any /* -Wpointer-sign is disabled by default, but it is enabled if any
of -Wall or -pedantic are given. */ of -Wall or -Wpedantic are given. */
if (warn_pointer_sign == -1) if (warn_pointer_sign == -1)
warn_pointer_sign = 0; warn_pointer_sign = 0;
@ -936,7 +936,7 @@ c_common_post_options (const char **pfilename)
if (warn_jump_misses_init == -1) if (warn_jump_misses_init == -1)
warn_jump_misses_init = 0; warn_jump_misses_init = 0;
/* -Woverlength-strings is off by default, but is enabled by -pedantic. /* -Woverlength-strings is off by default, but is enabled by -Wpedantic.
It is never enabled in C++, as the minimum limit is not normative It is never enabled in C++, as the minimum limit is not normative
in that standard. */ in that standard. */
if (warn_overlength_strings == -1 || c_dialect_cxx ()) if (warn_overlength_strings == -1 || c_dialect_cxx ())
@ -1278,8 +1278,8 @@ sanitize_cpp_opts (void)
cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
/* Wlong-long is disabled by default. It is enabled by: /* Wlong-long is disabled by default. It is enabled by:
[-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or
[-pedantic | -Wtraditional] -std=non-c99 . [-Wpedantic | -Wtraditional] -std=non-c99 .
Either -Wlong-long or -Wno-long-long override any other settings. */ Either -Wlong-long or -Wno-long-long override any other settings. */
if (warn_long_long == -1) if (warn_long_long == -1)

2
gcc/c-family/c-pragma.c
View File

@ -1127,7 +1127,7 @@ handle_pragma_float_const_decimal64 (cpp_reader *ARG_UNUSED (dummy))
return; return;
} }
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>"); "ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>");
switch (handle_stdc_pragma ("STDC FLOAT_CONST_DECIMAL64")) switch (handle_stdc_pragma ("STDC FLOAT_CONST_DECIMAL64"))

6
gcc/c-family/c.opt
View File

@ -557,6 +557,10 @@ Wparentheses
C ObjC C++ ObjC++ Var(warn_parentheses) Warning C ObjC C++ ObjC++ Var(warn_parentheses) Warning
Warn about possibly missing parentheses Warn about possibly missing parentheses
Wpedantic
C ObjC C++ ObjC++ Warning
; Documented in common.opt
Wpmf-conversions Wpmf-conversions
C++ ObjC++ Var(warn_pmf2ptr) Init(1) Warning C++ ObjC++ Var(warn_pmf2ptr) Init(1) Warning
Warn when converting the type of pointers to member functions Warn when converting the type of pointers to member functions
@ -1184,7 +1188,7 @@ C ObjC C++ ObjC++ Joined Separate
; Documented in common.opt ; Documented in common.opt
pedantic pedantic
C ObjC C++ ObjC++ C ObjC C++ ObjC++ Alias(Wpedantic)
; Documented in common.opt ; Documented in common.opt
pedantic-errors pedantic-errors

60
gcc/c-parser.c
View File

@ -1238,7 +1238,7 @@ c_parser_translation_unit (c_parser *parser)
{ {
if (c_parser_next_token_is (parser, CPP_EOF)) if (c_parser_next_token_is (parser, CPP_EOF))
{ {
pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"ISO C forbids an empty translation unit"); "ISO C forbids an empty translation unit");
} }
else else
@ -1336,7 +1336,7 @@ c_parser_external_declaration (c_parser *parser)
} }
break; break;
case CPP_SEMICOLON: case CPP_SEMICOLON:
pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"ISO C does not allow extra %<;%> outside of a function"); "ISO C does not allow extra %<;%> outside of a function");
c_parser_consume_token (parser); c_parser_consume_token (parser);
break; break;
@ -1715,7 +1715,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
/* Function definition (nested or otherwise). */ /* Function definition (nested or otherwise). */
if (nested) if (nested)
{ {
pedwarn (here, OPT_pedantic, "ISO C forbids nested functions"); pedwarn (here, OPT_Wpedantic, "ISO C forbids nested functions");
c_push_function_context (); c_push_function_context ();
} }
if (!start_function (specs, declarator, all_prefix_attrs)) if (!start_function (specs, declarator, all_prefix_attrs))
@ -1830,10 +1830,10 @@ c_parser_static_assert_declaration_no_semi (c_parser *parser)
if (!flag_isoc11) if (!flag_isoc11)
{ {
if (flag_isoc99) if (flag_isoc99)
pedwarn (assert_loc, OPT_pedantic, pedwarn (assert_loc, OPT_Wpedantic,
"ISO C99 does not support %<_Static_assert%>"); "ISO C99 does not support %<_Static_assert%>");
else else
pedwarn (assert_loc, OPT_pedantic, pedwarn (assert_loc, OPT_Wpedantic,
"ISO C90 does not support %<_Static_assert%>"); "ISO C90 does not support %<_Static_assert%>");
} }
c_parser_consume_token (parser); c_parser_consume_token (parser);
@ -1874,7 +1874,7 @@ c_parser_static_assert_declaration_no_semi (c_parser *parser)
{ {
value = c_fully_fold (value, false, NULL); value = c_fully_fold (value, false, NULL);
if (TREE_CODE (value) == INTEGER_CST) if (TREE_CODE (value) == INTEGER_CST)
pedwarn (value_loc, OPT_pedantic, "expression in static assertion " pedwarn (value_loc, OPT_Wpedantic, "expression in static assertion "
"is not an integer constant expression"); "is not an integer constant expression");
} }
if (TREE_CODE (value) != INTEGER_CST) if (TREE_CODE (value) != INTEGER_CST)
@ -2292,7 +2292,7 @@ c_parser_enum_specifier (c_parser *parser)
if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
{ {
if (seen_comma && !flag_isoc99) if (seen_comma && !flag_isoc99)
pedwarn (comma_loc, OPT_pedantic, "comma at end of enumerator list"); pedwarn (comma_loc, OPT_Wpedantic, "comma at end of enumerator list");
c_parser_consume_token (parser); c_parser_consume_token (parser);
break; break;
} }
@ -2328,7 +2328,7 @@ c_parser_enum_specifier (c_parser *parser)
if (pedantic && !COMPLETE_TYPE_P (ret.spec)) if (pedantic && !COMPLETE_TYPE_P (ret.spec))
{ {
gcc_assert (ident); gcc_assert (ident);
pedwarn (enum_loc, OPT_pedantic, pedwarn (enum_loc, OPT_Wpedantic,
"ISO C forbids forward references to %<enum%> types"); "ISO C forbids forward references to %<enum%> types");
} }
return ret; return ret;
@ -2463,7 +2463,7 @@ c_parser_struct_or_union_specifier (c_parser *parser)
/* Parse any stray semicolon. */ /* Parse any stray semicolon. */
if (c_parser_next_token_is (parser, CPP_SEMICOLON)) if (c_parser_next_token_is (parser, CPP_SEMICOLON))
{ {
pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"extra semicolon in struct or union specified"); "extra semicolon in struct or union specified");
c_parser_consume_token (parser); c_parser_consume_token (parser);
continue; continue;
@ -2601,7 +2601,7 @@ c_parser_struct_declaration (c_parser *parser)
tree ret; tree ret;
if (specs->typespec_kind == ctsk_none) if (specs->typespec_kind == ctsk_none)
{ {
pedwarn (decl_loc, OPT_pedantic, pedwarn (decl_loc, OPT_Wpedantic,
"ISO C forbids member declarations with no members"); "ISO C forbids member declarations with no members");
shadow_tag_warned (specs, pedantic); shadow_tag_warned (specs, pedantic);
ret = NULL_TREE; ret = NULL_TREE;
@ -2785,10 +2785,10 @@ c_parser_alignas_specifier (c_parser * parser)
if (!flag_isoc11) if (!flag_isoc11)
{ {
if (flag_isoc99) if (flag_isoc99)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C99 does not support %<_Alignas%>"); "ISO C99 does not support %<_Alignas%>");
else else
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support %<_Alignas%>"); "ISO C90 does not support %<_Alignas%>");
} }
if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
@ -3745,7 +3745,7 @@ c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
really_start_incremental_init (type); really_start_incremental_init (type);
if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
{ {
pedwarn (brace_loc, OPT_pedantic, "ISO C forbids empty initializer braces"); pedwarn (brace_loc, OPT_Wpedantic, "ISO C forbids empty initializer braces");
} }
else else
{ {
@ -3795,7 +3795,7 @@ c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
set_init_label (c_parser_peek_token (parser)->value, set_init_label (c_parser_peek_token (parser)->value,
braced_init_obstack); braced_init_obstack);
/* Use the colon as the error location. */ /* Use the colon as the error location. */
pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_Wpedantic,
"obsolete use of designated initializer with %<:%>"); "obsolete use of designated initializer with %<:%>");
c_parser_consume_token (parser); c_parser_consume_token (parser);
c_parser_consume_token (parser); c_parser_consume_token (parser);
@ -3935,7 +3935,7 @@ c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
c_parser_consume_token (parser); c_parser_consume_token (parser);
set_init_index (first, second, braced_init_obstack); set_init_index (first, second, braced_init_obstack);
if (second) if (second)
pedwarn (ellipsis_loc, OPT_pedantic, pedwarn (ellipsis_loc, OPT_Wpedantic,
"ISO C forbids specifying range of elements to initialize"); "ISO C forbids specifying range of elements to initialize");
} }
else else
@ -3948,14 +3948,14 @@ c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
if (c_parser_next_token_is (parser, CPP_EQ)) if (c_parser_next_token_is (parser, CPP_EQ))
{ {
if (!flag_isoc99) if (!flag_isoc99)
pedwarn (des_loc, OPT_pedantic, pedwarn (des_loc, OPT_Wpedantic,
"ISO C90 forbids specifying subobject to initialize"); "ISO C90 forbids specifying subobject to initialize");
c_parser_consume_token (parser); c_parser_consume_token (parser);
} }
else else
{ {
if (des_seen == 1) if (des_seen == 1)
pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"obsolete use of designated initializer without %<=%>"); "obsolete use of designated initializer without %<=%>");
else else
{ {
@ -4120,7 +4120,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
} }
c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
} }
pedwarn (label_loc, OPT_pedantic, "ISO C forbids label declarations"); pedwarn (label_loc, OPT_Wpedantic, "ISO C forbids label declarations");
} }
/* We must now have at least one statement, label or declaration. */ /* We must now have at least one statement, label or declaration. */
if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
@ -4156,7 +4156,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
if (last_stmt) if (last_stmt)
pedwarn_c90 (loc, pedwarn_c90 (loc,
(pedantic && !flag_isoc99) (pedantic && !flag_isoc99)
? OPT_pedantic ? OPT_Wpedantic
: OPT_Wdeclaration_after_statement, : OPT_Wdeclaration_after_statement,
"ISO C90 forbids mixed declarations and code"); "ISO C90 forbids mixed declarations and code");
last_stmt = false; last_stmt = false;
@ -4186,7 +4186,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
restore_extension_diagnostics (ext); restore_extension_diagnostics (ext);
if (last_stmt) if (last_stmt)
pedwarn_c90 (loc, (pedantic && !flag_isoc99) pedwarn_c90 (loc, (pedantic && !flag_isoc99)
? OPT_pedantic ? OPT_Wpedantic
: OPT_Wdeclaration_after_statement, : OPT_Wdeclaration_after_statement,
"ISO C90 forbids mixed declarations and code"); "ISO C90 forbids mixed declarations and code");
last_stmt = false; last_stmt = false;
@ -5441,7 +5441,7 @@ c_parser_conditional_expression (c_parser *parser, struct c_expr *after)
tree eptype = NULL_TREE; tree eptype = NULL_TREE;
middle_loc = c_parser_peek_token (parser)->location; middle_loc = c_parser_peek_token (parser)->location;
pedwarn (middle_loc, OPT_pedantic, pedwarn (middle_loc, OPT_Wpedantic,
"ISO C forbids omitting the middle term of a ?: expression"); "ISO C forbids omitting the middle term of a ?: expression");
warn_for_omitted_condop (middle_loc, cond.value); warn_for_omitted_condop (middle_loc, cond.value);
if (TREE_CODE (cond.value) == EXCESS_PRECISION_EXPR) if (TREE_CODE (cond.value) == EXCESS_PRECISION_EXPR)
@ -6049,10 +6049,10 @@ c_parser_alignof_expression (c_parser *parser)
&& strcmp (IDENTIFIER_POINTER (alignof_spelling), "_Alignof") == 0) && strcmp (IDENTIFIER_POINTER (alignof_spelling), "_Alignof") == 0)
{ {
if (flag_isoc99) if (flag_isoc99)
pedwarn (loc, OPT_pedantic, "ISO C99 does not support %qE", pedwarn (loc, OPT_Wpedantic, "ISO C99 does not support %qE",
alignof_spelling); alignof_spelling);
else else
pedwarn (loc, OPT_pedantic, "ISO C90 does not support %qE", pedwarn (loc, OPT_Wpedantic, "ISO C90 does not support %qE",
alignof_spelling); alignof_spelling);
} }
c_parser_consume_token (parser); c_parser_consume_token (parser);
@ -6103,7 +6103,7 @@ c_parser_alignof_expression (c_parser *parser)
mark_exp_read (expr.value); mark_exp_read (expr.value);
c_inhibit_evaluation_warnings--; c_inhibit_evaluation_warnings--;
in_alignof--; in_alignof--;
pedwarn (loc, OPT_pedantic, "ISO C does not allow %<%E (expression)%>", pedwarn (loc, OPT_Wpedantic, "ISO C does not allow %<%E (expression)%>",
alignof_spelling); alignof_spelling);
ret.value = c_alignof_expr (loc, expr.value); ret.value = c_alignof_expr (loc, expr.value);
ret.original_code = ERROR_MARK; ret.original_code = ERROR_MARK;
@ -6329,7 +6329,7 @@ c_parser_postfix_expression (c_parser *parser)
c_parser_compound_statement_nostart (parser); c_parser_compound_statement_nostart (parser);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
"expected %<)%>"); "expected %<)%>");
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids braced-groups within expressions"); "ISO C forbids braced-groups within expressions");
expr.value = c_finish_stmt_expr (brace_loc, stmt); expr.value = c_finish_stmt_expr (brace_loc, stmt);
mark_exp_read (expr.value); mark_exp_read (expr.value);
@ -6640,7 +6640,7 @@ c_parser_postfix_expression (c_parser *parser)
break; break;
} }
if (!flag_isoc99) if (!flag_isoc99)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 does not support complex types"); "ISO C90 does not support complex types");
expr.value = build2 (COMPLEX_EXPR, expr.value = build2 (COMPLEX_EXPR,
build_complex_type build_complex_type
@ -6819,7 +6819,7 @@ c_parser_postfix_expression_after_paren_type (c_parser *parser,
} }
if (!flag_isoc99) if (!flag_isoc99)
pedwarn (start_loc, OPT_pedantic, "ISO C90 forbids compound literals"); pedwarn (start_loc, OPT_Wpedantic, "ISO C90 forbids compound literals");
non_const = ((init.value && TREE_CODE (init.value) == CONSTRUCTOR) non_const = ((init.value && TREE_CODE (init.value) == CONSTRUCTOR)
? CONSTRUCTOR_NON_CONST (init.value) ? CONSTRUCTOR_NON_CONST (init.value)
: init.original_code == C_MAYBE_CONST_EXPR); : init.original_code == C_MAYBE_CONST_EXPR);
@ -7238,7 +7238,7 @@ c_parser_objc_class_instance_variables (c_parser *parser)
/* Parse any stray semicolon. */ /* Parse any stray semicolon. */
if (c_parser_next_token_is (parser, CPP_SEMICOLON)) if (c_parser_next_token_is (parser, CPP_SEMICOLON))
{ {
pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"extra semicolon"); "extra semicolon");
c_parser_consume_token (parser); c_parser_consume_token (parser);
continue; continue;
@ -7486,7 +7486,7 @@ c_parser_objc_method_definition (c_parser *parser)
if (c_parser_next_token_is (parser, CPP_SEMICOLON)) if (c_parser_next_token_is (parser, CPP_SEMICOLON))
{ {
c_parser_consume_token (parser); c_parser_consume_token (parser);
pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"extra semicolon in method definition specified"); "extra semicolon in method definition specified");
} }
@ -7538,7 +7538,7 @@ c_parser_objc_methodprotolist (c_parser *parser)
switch (c_parser_peek_token (parser)->type) switch (c_parser_peek_token (parser)->type)
{ {
case CPP_SEMICOLON: case CPP_SEMICOLON:
pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic, pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
"ISO C does not allow extra %<;%> outside of a function"); "ISO C does not allow extra %<;%> outside of a function");
c_parser_consume_token (parser); c_parser_consume_token (parser);
break; break;

72
gcc/c-typeck.c
View File

@ -562,7 +562,7 @@ composite_type (tree t1, tree t2)
{ {
TREE_VALUE (n) = composite_type (TREE_TYPE (memb), TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
TREE_VALUE (p2)); TREE_VALUE (p2));
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"function types not truly compatible in ISO C"); "function types not truly compatible in ISO C");
goto parm_done; goto parm_done;
} }
@ -587,7 +587,7 @@ composite_type (tree t1, tree t2)
{ {
TREE_VALUE (n) = composite_type (TREE_TYPE (memb), TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
TREE_VALUE (p1)); TREE_VALUE (p1));
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"function types not truly compatible in ISO C"); "function types not truly compatible in ISO C");
goto parm_done; goto parm_done;
} }
@ -1217,7 +1217,7 @@ comp_target_types (location_t location, tree ttl, tree ttr)
val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p); val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
if (val == 2) if (val == 2)
pedwarn (location, OPT_pedantic, "types are not quite compatible"); pedwarn (location, OPT_Wpedantic, "types are not quite compatible");
if (val == 1 && enum_and_int_p && warn_cxx_compat) if (val == 1 && enum_and_int_p && warn_cxx_compat)
warning_at (location, OPT_Wc___compat, warning_at (location, OPT_Wc___compat,
@ -2394,10 +2394,10 @@ build_array_ref (location_t loc, tree array, tree index)
while (TREE_CODE (foo) == COMPONENT_REF) while (TREE_CODE (foo) == COMPONENT_REF)
foo = TREE_OPERAND (foo, 0); foo = TREE_OPERAND (foo, 0);
if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo)) if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids subscripting %<register%> array"); "ISO C forbids subscripting %<register%> array");
else if (!flag_isoc99 && !lvalue_p (foo)) else if (!flag_isoc99 && !lvalue_p (foo))
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C90 forbids subscripting non-lvalue array"); "ISO C90 forbids subscripting non-lvalue array");
} }
@ -3437,10 +3437,10 @@ pointer_diff (location_t loc, tree op0, tree op1)
if (TREE_CODE (target_type) == VOID_TYPE) if (TREE_CODE (target_type) == VOID_TYPE)
pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (loc, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"pointer of type %<void *%> used in subtraction"); "pointer of type %<void *%> used in subtraction");
if (TREE_CODE (target_type) == FUNCTION_TYPE) if (TREE_CODE (target_type) == FUNCTION_TYPE)
pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (loc, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"pointer to a function used in subtraction"); "pointer to a function used in subtraction");
/* If the conversion to ptrdiff_type does anything like widening or /* If the conversion to ptrdiff_type does anything like widening or
@ -3604,7 +3604,7 @@ build_unary_op (location_t location,
else if (typecode == COMPLEX_TYPE) else if (typecode == COMPLEX_TYPE)
{ {
code = CONJ_EXPR; code = CONJ_EXPR;
pedwarn (location, OPT_pedantic, pedwarn (location, OPT_Wpedantic,
"ISO C does not support %<~%> for complex conjugation"); "ISO C does not support %<~%> for complex conjugation");
if (!noconvert) if (!noconvert)
arg = default_conversion (arg); arg = default_conversion (arg);
@ -3710,7 +3710,7 @@ build_unary_op (location_t location,
{ {
tree real, imag; tree real, imag;
pedwarn (location, OPT_pedantic, pedwarn (location, OPT_Wpedantic,
"ISO C does not support %<++%> and %<--%> on complex types"); "ISO C does not support %<++%> and %<--%> on complex types");
arg = stabilize_reference (arg); arg = stabilize_reference (arg);
@ -3761,10 +3761,10 @@ build_unary_op (location_t location,
|| TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE) || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
{ {
if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (location, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"wrong type argument to increment"); "wrong type argument to increment");
else else
pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (location, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"wrong type argument to decrement"); "wrong type argument to decrement");
} }
@ -4305,7 +4305,7 @@ build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
else if (code1 == VOID_TYPE || code2 == VOID_TYPE) else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
{ {
if (code1 != VOID_TYPE || code2 != VOID_TYPE) if (code1 != VOID_TYPE || code2 != VOID_TYPE)
pedwarn (colon_loc, OPT_pedantic, pedwarn (colon_loc, OPT_Wpedantic,
"ISO C forbids conditional expr with only one void side"); "ISO C forbids conditional expr with only one void side");
result_type = void_type_node; result_type = void_type_node;
} }
@ -4330,7 +4330,7 @@ build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
else if (VOID_TYPE_P (TREE_TYPE (type1))) else if (VOID_TYPE_P (TREE_TYPE (type1)))
{ {
if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
pedwarn (colon_loc, OPT_pedantic, pedwarn (colon_loc, OPT_Wpedantic,
"ISO C forbids conditional expr between " "ISO C forbids conditional expr between "
"%<void *%> and function pointer"); "%<void *%> and function pointer");
result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
@ -4339,7 +4339,7 @@ build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
else if (VOID_TYPE_P (TREE_TYPE (type2))) else if (VOID_TYPE_P (TREE_TYPE (type2)))
{ {
if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
pedwarn (colon_loc, OPT_pedantic, pedwarn (colon_loc, OPT_Wpedantic,
"ISO C forbids conditional expr between " "ISO C forbids conditional expr between "
"%<void *%> and function pointer"); "%<void *%> and function pointer");
result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
@ -4650,7 +4650,7 @@ build_c_cast (location_t loc, tree type, tree expr)
{ {
if (TREE_CODE (type) == RECORD_TYPE if (TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE) || TREE_CODE (type) == UNION_TYPE)
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C forbids casting nonscalar to the same type"); "ISO C forbids casting nonscalar to the same type");
} }
else if (TREE_CODE (type) == UNION_TYPE) else if (TREE_CODE (type) == UNION_TYPE)
@ -4668,7 +4668,7 @@ build_c_cast (location_t loc, tree type, tree expr)
tree t; tree t;
bool maybe_const = true; bool maybe_const = true;
pedwarn (loc, OPT_pedantic, "ISO C forbids casts to union type"); pedwarn (loc, OPT_Wpedantic, "ISO C forbids casts to union type");
t = c_fully_fold (value, false, &maybe_const); t = c_fully_fold (value, false, &maybe_const);
t = build_constructor_single (type, field, t); t = build_constructor_single (type, field, t);
if (!maybe_const) if (!maybe_const)
@ -4782,7 +4782,7 @@ build_c_cast (location_t loc, tree type, tree expr)
&& TREE_CODE (otype) == POINTER_TYPE && TREE_CODE (otype) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
&& TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE) && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
pedwarn (loc, OPT_pedantic, "ISO C forbids " pedwarn (loc, OPT_Wpedantic, "ISO C forbids "
"conversion of function pointer to object pointer type"); "conversion of function pointer to object pointer type");
if (pedantic if (pedantic
@ -4791,7 +4791,7 @@ build_c_cast (location_t loc, tree type, tree expr)
&& TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
&& TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
&& !null_pointer_constant_p (value)) && !null_pointer_constant_p (value))
pedwarn (loc, OPT_pedantic, "ISO C forbids " pedwarn (loc, OPT_Wpedantic, "ISO C forbids "
"conversion of object pointer to function pointer type"); "conversion of object pointer to function pointer type");
ovalue = value; ovalue = value;
@ -5503,7 +5503,7 @@ convert_for_assignment (location_t location, tree type, tree rhs,
} }
if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl)) if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
pedwarn (location, OPT_pedantic, pedwarn (location, OPT_Wpedantic,
"ISO C prohibits argument conversion to union type"); "ISO C prohibits argument conversion to union type");
rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs); rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
@ -5640,7 +5640,7 @@ convert_for_assignment (location_t location, tree type, tree rhs,
(VOID_TYPE_P (ttr) (VOID_TYPE_P (ttr)
&& !null_pointer_constant && !null_pointer_constant
&& TREE_CODE (ttl) == FUNCTION_TYPE))) && TREE_CODE (ttl) == FUNCTION_TYPE)))
WARN_FOR_ASSIGNMENT (location, OPT_pedantic, WARN_FOR_ASSIGNMENT (location, OPT_Wpedantic,
G_("ISO C forbids passing argument %d of " G_("ISO C forbids passing argument %d of "
"%qE between function pointer " "%qE between function pointer "
"and %<void *%>"), "and %<void *%>"),
@ -6077,7 +6077,7 @@ maybe_warn_string_init (tree type, struct c_expr expr)
&& TREE_CODE (type) == ARRAY_TYPE && TREE_CODE (type) == ARRAY_TYPE
&& TREE_CODE (expr.value) == STRING_CST && TREE_CODE (expr.value) == STRING_CST
&& expr.original_code != STRING_CST) && expr.original_code != STRING_CST)
pedwarn_init (input_location, OPT_pedantic, pedwarn_init (input_location, OPT_Wpedantic,
"array initialized from parenthesized string constant"); "array initialized from parenthesized string constant");
} }
@ -6150,7 +6150,7 @@ digest_init (location_t init_loc, tree type, tree init, tree origtype,
maybe_warn_string_init (type, expr); maybe_warn_string_init (type, expr);
if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type))) if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
pedwarn_init (init_loc, OPT_pedantic, pedwarn_init (init_loc, OPT_Wpedantic,
"initialization of a flexible array member"); "initialization of a flexible array member");
if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
@ -6307,7 +6307,7 @@ digest_init (location_t init_loc, tree type, tree init, tree origtype,
return error_mark_node; return error_mark_node;
} }
/* Compound expressions can only occur here if -pedantic or /* Compound expressions can only occur here if -Wpedantic or
-pedantic-errors is specified. In the later case, we always want -pedantic-errors is specified. In the later case, we always want
an error. In the former case, we simply want a warning. */ an error. In the former case, we simply want a warning. */
if (require_constant && pedantic if (require_constant && pedantic
@ -6319,7 +6319,7 @@ digest_init (location_t init_loc, tree type, tree init, tree origtype,
if (inside_init == error_mark_node) if (inside_init == error_mark_node)
error_init ("initializer element is not constant"); error_init ("initializer element is not constant");
else else
pedwarn_init (init_loc, OPT_pedantic, pedwarn_init (init_loc, OPT_Wpedantic,
"initializer element is not constant"); "initializer element is not constant");
if (flag_pedantic_errors) if (flag_pedantic_errors)
inside_init = error_mark_node; inside_init = error_mark_node;
@ -7025,7 +7025,7 @@ pop_init_level (int implicit, struct obstack * braced_init_obstack)
if (constructor_depth > 2) if (constructor_depth > 2)
error_init ("initialization of flexible array member in a nested context"); error_init ("initialization of flexible array member in a nested context");
else else
pedwarn_init (input_location, OPT_pedantic, pedwarn_init (input_location, OPT_Wpedantic,
"initialization of a flexible array member"); "initialization of a flexible array member");
/* We have already issued an error message for the existence /* We have already issued an error message for the existence
@ -7262,7 +7262,7 @@ set_init_index (tree first, tree last,
{ {
first = c_fully_fold (first, false, NULL); first = c_fully_fold (first, false, NULL);
if (TREE_CODE (first) == INTEGER_CST) if (TREE_CODE (first) == INTEGER_CST)
pedwarn_init (input_location, OPT_pedantic, pedwarn_init (input_location, OPT_Wpedantic,
"array index in initializer is not " "array index in initializer is not "
"an integer constant expression"); "an integer constant expression");
} }
@ -7271,7 +7271,7 @@ set_init_index (tree first, tree last,
{ {
last = c_fully_fold (last, false, NULL); last = c_fully_fold (last, false, NULL);
if (TREE_CODE (last) == INTEGER_CST) if (TREE_CODE (last) == INTEGER_CST)
pedwarn_init (input_location, OPT_pedantic, pedwarn_init (input_location, OPT_Wpedantic,
"array index in initializer is not " "array index in initializer is not "
"an integer constant expression"); "an integer constant expression");
} }
@ -8704,7 +8704,7 @@ tree
c_finish_goto_ptr (location_t loc, tree expr) c_finish_goto_ptr (location_t loc, tree expr)
{ {
tree t; tree t;
pedwarn (loc, OPT_pedantic, "ISO C forbids %<goto *expr;%>"); pedwarn (loc, OPT_Wpedantic, "ISO C forbids %<goto *expr;%>");
expr = c_fully_fold (expr, false, NULL); expr = c_fully_fold (expr, false, NULL);
expr = convert (ptr_type_node, expr); expr = convert (ptr_type_node, expr);
t = build1 (GOTO_EXPR, void_type_node, expr); t = build1 (GOTO_EXPR, void_type_node, expr);
@ -8761,7 +8761,7 @@ c_finish_return (location_t loc, tree retval, tree origtype)
pedwarn (loc, 0, pedwarn (loc, 0,
"%<return%> with a value, in function returning void"); "%<return%> with a value, in function returning void");
else else
pedwarn (loc, OPT_pedantic, "ISO C forbids " pedwarn (loc, OPT_Wpedantic, "ISO C forbids "
"%<return%> with expression, in function returning void"); "%<return%> with expression, in function returning void");
} }
else else
@ -8943,7 +8943,7 @@ do_case (location_t loc, tree low_value, tree high_value)
{ {
low_value = c_fully_fold (low_value, false, NULL); low_value = c_fully_fold (low_value, false, NULL);
if (TREE_CODE (low_value) == INTEGER_CST) if (TREE_CODE (low_value) == INTEGER_CST)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"case label is not an integer constant expression"); "case label is not an integer constant expression");
} }
@ -8951,7 +8951,7 @@ do_case (location_t loc, tree low_value, tree high_value)
{ {
high_value = c_fully_fold (high_value, false, NULL); high_value = c_fully_fold (high_value, false, NULL);
if (TREE_CODE (high_value) == INTEGER_CST) if (TREE_CODE (high_value) == INTEGER_CST)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"case label is not an integer constant expression"); "case label is not an integer constant expression");
} }
@ -10123,13 +10123,13 @@ build_binary_op (location_t location, enum tree_code code,
else if (VOID_TYPE_P (tt0)) else if (VOID_TYPE_P (tt0))
{ {
if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE) if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
pedwarn (location, OPT_pedantic, "ISO C forbids " pedwarn (location, OPT_Wpedantic, "ISO C forbids "
"comparison of %<void *%> with function pointer"); "comparison of %<void *%> with function pointer");
} }
else if (VOID_TYPE_P (tt1)) else if (VOID_TYPE_P (tt1))
{ {
if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE) if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
pedwarn (location, OPT_pedantic, "ISO C forbids " pedwarn (location, OPT_Wpedantic, "ISO C forbids "
"comparison of %<void *%> with function pointer"); "comparison of %<void *%> with function pointer");
} }
else else
@ -10206,7 +10206,7 @@ build_binary_op (location_t location, enum tree_code code,
pedwarn (location, 0, pedwarn (location, 0,
"comparison of complete and incomplete pointers"); "comparison of complete and incomplete pointers");
else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
pedwarn (location, OPT_pedantic, "ISO C forbids " pedwarn (location, OPT_Wpedantic, "ISO C forbids "
"ordered comparisons of pointers to functions"); "ordered comparisons of pointers to functions");
else if (null_pointer_constant_p (orig_op0) else if (null_pointer_constant_p (orig_op0)
|| null_pointer_constant_p (orig_op1)) || null_pointer_constant_p (orig_op1))
@ -10233,7 +10233,7 @@ build_binary_op (location_t location, enum tree_code code,
{ {
result_type = type0; result_type = type0;
if (pedantic) if (pedantic)
pedwarn (location, OPT_pedantic, pedwarn (location, OPT_Wpedantic,
"ordered comparison of pointer with integer zero"); "ordered comparison of pointer with integer zero");
else if (extra_warnings) else if (extra_warnings)
warning_at (location, OPT_Wextra, warning_at (location, OPT_Wextra,
@ -10243,7 +10243,7 @@ build_binary_op (location_t location, enum tree_code code,
{ {
result_type = type1; result_type = type1;
if (pedantic) if (pedantic)
pedwarn (location, OPT_pedantic, pedwarn (location, OPT_Wpedantic,
"ordered comparison of pointer with integer zero"); "ordered comparison of pointer with integer zero");
else if (extra_warnings) else if (extra_warnings)
warning_at (location, OPT_Wextra, warning_at (location, OPT_Wextra,

9
gcc/common.opt
View File

@ -307,7 +307,7 @@ Common Driver Joined Alias(o) MissingArgError(missing filename after %qs)
Driver Alias(pass-exit-codes) Driver Alias(pass-exit-codes)
-pedantic -pedantic
Common Alias(pedantic) Common Alias(Wpedantic)
-pedantic-errors -pedantic-errors
Common Alias(pedantic-errors) Common Alias(pedantic-errors)
@ -582,6 +582,10 @@ Wpadded
Common Var(warn_padded) Warning Common Var(warn_padded) Warning
Warn when padding is required to align structure members Warn when padding is required to align structure members
Wpedantic
Common Var(pedantic) Warning
Issue warnings needed for strict compliance to the standard
Wshadow Wshadow
Common Var(warn_shadow) Warning Common Var(warn_shadow) Warning
Warn when one local variable shadows another Warn when one local variable shadows another
@ -2292,8 +2296,7 @@ pass-exit-codes
Driver Var(pass_exit_codes) Driver Var(pass_exit_codes)
pedantic pedantic
Common Var(pedantic) Common Alias(Wpedantic)
Issue warnings needed for strict compliance to the standard
pedantic-errors pedantic-errors
Common Var(flag_pedantic_errors) Common Var(flag_pedantic_errors)

37
gcc/cp/ChangeLog
View File

@ -1,3 +1,40 @@
2012-04-22 Manuel López-Ibáñez <manu@gcc.gnu.org>
PR c/44774
* typeck.c (composite_pointer_type): Likewise.
(cxx_sizeof_or_alignof_type): Likewise.
(cp_build_array_ref): Likewise.
(cp_build_function_call_vec): Likewise.
(cp_build_addr_expr_1): Likewise.
(convert_member_func_to_ptr): Likewise.
* decl.c (check_tag_decl): Likewise.
(check_static_variable_definition): Likewise.
(compute_array_index_type): Likewise.
(create_array_type_for_decl): Likewise.
(grokdeclarator): Likewise.
(grok_op_properties): Likewise.
* error.c (maybe_warn_cpp0x): Likewise.
* pt.c (maybe_process_partial_specialization): Likewise.
(convert_template_argument): Likewise.
(do_decl_instantiation): Likewise.
(do_type_instantiation): Likewise.
* parser.c (cp_parser_primary_expression): Likewise.
(cp_parser_postfix_expression): Likewise.
(cp_parser_unary_expression): Likewise.
(cp_parser_question_colon_clause): Likewise.
(cp_parser_lambda_introducer): Likewise.
(cp_parser_lambda_declarator_opt): Likewise.
(cp_parser_compound_statement): Likewise.
(cp_parser_jump_statement): Likewise.
(cp_parser_declaration_seq_opt): Likewise.
(cp_parser_enum_specifier): Likewise.
(cp_parser_enumerator_list): Likewise.
(cp_parser_initializer_list): Likewise.
(cp_parser_member_declaration): Likewise.
* call.c (build_conditional_expr_1): Likewise.
* friend.c (make_friend_class): Likewise.
* name-lookup.c (pushdecl_maybe_friend_1): Likewise.
2012-04-21 Jan Hubicka <jh@suse.cz> 2012-04-21 Jan Hubicka <jh@suse.cz>
* method.c (make_alias_for): Do not set TREE_SYMBOL_REFERENCED. * method.c (make_alias_for): Do not set TREE_SYMBOL_REFERENCED.

2
gcc/cp/call.c
View File

@ -4335,7 +4335,7 @@ build_conditional_expr_1 (tree arg1, tree arg2, tree arg3,
if (!arg2) if (!arg2)
{ {
if (complain & tf_error) if (complain & tf_error)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids omitting the middle term of a ?: expression"); "ISO C++ forbids omitting the middle term of a ?: expression");
/* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */ /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */

24
gcc/cp/decl.c
View File

@ -4193,7 +4193,7 @@ check_tag_decl (cp_decl_specifier_seq *declspecs)
SET_ANON_AGGR_TYPE_P (declared_type); SET_ANON_AGGR_TYPE_P (declared_type);
if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header) if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
pedwarn (input_location, OPT_pedantic, "ISO C++ prohibits anonymous structs"); pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
} }
else else
@ -7877,7 +7877,7 @@ check_static_variable_definition (tree decl, tree type)
"static member %qD", "static member %qD",
decl); decl);
else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type)) else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
pedwarn (input_location, OPT_pedantic, "ISO C++ forbids initialization of member constant " pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids initialization of member constant "
"%qD of non-integral type %qT", decl, type); "%qD of non-integral type %qT", decl, type);
return 0; return 0;
@ -8050,9 +8050,9 @@ compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
else if (in_system_header) else if (in_system_header)
/* Allow them in system headers because glibc uses them. */; /* Allow them in system headers because glibc uses them. */;
else if (name) else if (name)
pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array %qD", name); pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
else else
pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array"); pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array");
} }
} }
else if (TREE_CONSTANT (size) else if (TREE_CONSTANT (size)
@ -8178,7 +8178,7 @@ create_array_type_for_decl (tree name, tree type, tree size)
/* 8.3.4/1: If the type of the identifier of D contains the auto /* 8.3.4/1: If the type of the identifier of D contains the auto
type-specifier, the program is ill-formed. */ type-specifier, the program is ill-formed. */
if (pedantic && type_uses_auto (type)) if (pedantic && type_uses_auto (type))
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"declaration of %qD as array of %<auto%>", name); "declaration of %qD as array of %<auto%>", name);
/* If there are some types which cannot be array elements, /* If there are some types which cannot be array elements,
@ -8773,7 +8773,7 @@ grokdeclarator (const cp_declarator *declarator,
else if (! is_main) else if (! is_main)
permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name); permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
else if (pedantic) else if (pedantic)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids declaration of %qs with no type", name); "ISO C++ forbids declaration of %qs with no type", name);
else else
warning (OPT_Wreturn_type, warning (OPT_Wreturn_type,
@ -8792,7 +8792,7 @@ grokdeclarator (const cp_declarator *declarator,
explicit_int128 = false; explicit_int128 = false;
} }
else if (pedantic && ! in_system_header) else if (pedantic && ! in_system_header)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ does not support %<__int128%> for %qs", name); "ISO C++ does not support %<__int128%> for %qs", name);
} }
@ -8843,7 +8843,7 @@ grokdeclarator (const cp_declarator *declarator,
ok = 1; ok = 1;
if (!explicit_int && !defaulted_int && !explicit_char && !explicit_int128 && pedantic) if (!explicit_int && !defaulted_int && !explicit_char && !explicit_int128 && pedantic)
{ {
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"long, short, signed or unsigned used invalidly for %qs", "long, short, signed or unsigned used invalidly for %qs",
name); name);
if (flag_pedantic_errors) if (flag_pedantic_errors)
@ -10354,11 +10354,11 @@ grokdeclarator (const cp_declarator *declarator,
&& pedantic) && pedantic)
{ {
if (storage_class == sc_static) if (storage_class == sc_static)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"%<static%> specified invalid for function %qs " "%<static%> specified invalid for function %qs "
"declared out of global scope", name); "declared out of global scope", name);
else else
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"%<inline%> specifier invalid for function %qs " "%<inline%> specifier invalid for function %qs "
"declared out of global scope", name); "declared out of global scope", name);
} }
@ -10452,7 +10452,7 @@ grokdeclarator (const cp_declarator *declarator,
} }
if (storage_class == sc_extern && pedantic) if (storage_class == sc_extern && pedantic)
{ {
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"cannot explicitly declare member %q#D to have " "cannot explicitly declare member %q#D to have "
"extern linkage", decl); "extern linkage", decl);
storage_class = sc_none; storage_class = sc_none;
@ -11418,7 +11418,7 @@ grok_op_properties (tree decl, bool complain)
if (operator_code == POSTINCREMENT_EXPR if (operator_code == POSTINCREMENT_EXPR
|| operator_code == POSTDECREMENT_EXPR) || operator_code == POSTDECREMENT_EXPR)
{ {
pedwarn (input_location, OPT_pedantic, "%qD cannot have default arguments", pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments",
decl); decl);
} }
else else

2
gcc/cp/error.c
View File

@ -3306,7 +3306,7 @@ maybe_warn_cpp0x (cpp0x_warn_str str)
"only available with -std=c++11 or -std=gnu++11"); "only available with -std=c++11 or -std=gnu++11");
break; break;
case CPP0X_INLINE_NAMESPACES: case CPP0X_INLINE_NAMESPACES:
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"inline namespaces " "inline namespaces "
"only available with -std=c++11 or -std=gnu++11"); "only available with -std=c++11 or -std=gnu++11");
break; break;

2
gcc/cp/friend.c
View File

@ -232,7 +232,7 @@ make_friend_class (tree type, tree friend_type, bool complain)
So don't complain in C++0x mode. */ So don't complain in C++0x mode. */
if (cxx_dialect < cxx0x) if (cxx_dialect < cxx0x)
pedwarn (input_location, complain ? 0 : OPT_pedantic, pedwarn (input_location, complain ? 0 : OPT_Wpedantic,
"invalid type %qT declared %<friend%>", friend_type); "invalid type %qT declared %<friend%>", friend_type);
return; return;
} }

2
gcc/cp/name-lookup.c
View File

@ -766,7 +766,7 @@ pushdecl_maybe_friend_1 (tree x, bool is_friend)
else if (t == wchar_decl_node) else if (t == wchar_decl_node)
{ {
if (! DECL_IN_SYSTEM_HEADER (x)) if (! DECL_IN_SYSTEM_HEADER (x))
pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT", pedwarn (input_location, OPT_Wpedantic, "redeclaration of %<wchar_t%> as %qT",
TREE_TYPE (x)); TREE_TYPE (x));
/* Throw away the redeclaration. */ /* Throw away the redeclaration. */

30
gcc/cp/parser.c
View File

@ -4011,7 +4011,7 @@ cp_parser_primary_expression (cp_parser *parser,
&& cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
{ {
/* Statement-expressions are not allowed by the standard. */ /* Statement-expressions are not allowed by the standard. */
pedwarn (token->location, OPT_pedantic, pedwarn (token->location, OPT_Wpedantic,
"ISO C++ forbids braced-groups within expressions"); "ISO C++ forbids braced-groups within expressions");
/* And they're not allowed outside of a function-body; you /* And they're not allowed outside of a function-body; you
@ -5550,7 +5550,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
{ {
/* Warn the user that a compound literal is not /* Warn the user that a compound literal is not
allowed in standard C++. */ allowed in standard C++. */
pedwarn (input_location, OPT_pedantic, "ISO C++ forbids compound-literals"); pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids compound-literals");
/* For simplicity, we disallow compound literals in /* For simplicity, we disallow compound literals in
constant-expressions. We could constant-expressions. We could
allow compound literals of integer type, whose allow compound literals of integer type, whose
@ -6393,7 +6393,7 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p,
expressions. So pedwarn if alignof is used with a non- expressions. So pedwarn if alignof is used with a non-
type expression. However, __alignof__ is ok. */ type expression. However, __alignof__ is ok. */
if (!strcmp (IDENTIFIER_POINTER (token->u.value), "alignof")) if (!strcmp (IDENTIFIER_POINTER (token->u.value), "alignof"))
pedwarn (token->location, OPT_pedantic, pedwarn (token->location, OPT_Wpedantic,
"ISO C++ does not allow %<alignof%> " "ISO C++ does not allow %<alignof%> "
"with a non-type"); "with a non-type");
@ -7434,7 +7434,7 @@ cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
if (cp_parser_allow_gnu_extensions_p (parser) if (cp_parser_allow_gnu_extensions_p (parser)
&& token->type == CPP_COLON) && token->type == CPP_COLON)
{ {
pedwarn (token->location, OPT_pedantic, pedwarn (token->location, OPT_Wpedantic,
"ISO C++ does not allow ?: with omitted middle operand"); "ISO C++ does not allow ?: with omitted middle operand");
/* Implicit true clause. */ /* Implicit true clause. */
expr = NULL_TREE; expr = NULL_TREE;
@ -8238,7 +8238,7 @@ cp_parser_lambda_introducer (cp_parser* parser, tree lambda_expr)
{ {
/* An explicit expression exists. */ /* An explicit expression exists. */
cp_lexer_consume_token (parser->lexer); cp_lexer_consume_token (parser->lexer);
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ does not allow initializers " "ISO C++ does not allow initializers "
"in lambda expression capture lists"); "in lambda expression capture lists");
capture_init_expr = cp_parser_assignment_expression (parser, capture_init_expr = cp_parser_assignment_expression (parser,
@ -8368,7 +8368,7 @@ cp_parser_lambda_declarator_opt (cp_parser* parser, tree lambda_expr)
parameter-declaration-clause of a lambda-declarator. */ parameter-declaration-clause of a lambda-declarator. */
for (t = param_list; t; t = TREE_CHAIN (t)) for (t = param_list; t; t = TREE_CHAIN (t))
if (TREE_PURPOSE (t)) if (TREE_PURPOSE (t))
pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t)), OPT_pedantic, pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t)), OPT_Wpedantic,
"default argument specified for lambda parameter"); "default argument specified for lambda parameter");
cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN); cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
@ -8939,7 +8939,7 @@ cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
return error_mark_node; return error_mark_node;
if (DECL_DECLARED_CONSTEXPR_P (current_function_decl) if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
&& !function_body) && !function_body)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"compound-statement in constexpr function"); "compound-statement in constexpr function");
/* Begin the compound-statement. */ /* Begin the compound-statement. */
compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0); compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
@ -9910,7 +9910,7 @@ cp_parser_jump_statement (cp_parser* parser)
if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)) if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
{ {
/* Issue a warning about this use of a GNU extension. */ /* Issue a warning about this use of a GNU extension. */
pedwarn (token->location, OPT_pedantic, "ISO C++ forbids computed gotos"); pedwarn (token->location, OPT_Wpedantic, "ISO C++ forbids computed gotos");
/* Consume the '*' token. */ /* Consume the '*' token. */
cp_lexer_consume_token (parser->lexer); cp_lexer_consume_token (parser->lexer);
/* Parse the dependent expression. */ /* Parse the dependent expression. */
@ -10055,7 +10055,7 @@ cp_parser_declaration_seq_opt (cp_parser* parser)
invalid. Allow it unless we're being pedantic. */ invalid. Allow it unless we're being pedantic. */
cp_lexer_consume_token (parser->lexer); cp_lexer_consume_token (parser->lexer);
if (!in_system_header) if (!in_system_header)
pedwarn (input_location, OPT_pedantic, "extra %<;%>"); pedwarn (input_location, OPT_Wpedantic, "extra %<;%>");
continue; continue;
} }
@ -14362,7 +14362,7 @@ cp_parser_enum_specifier (cp_parser* parser)
{ {
/* Are template enums allowed in ISO? */ /* Are template enums allowed in ISO? */
if (template_parm_scope_p ()) if (template_parm_scope_p ())
pedwarn (type_start_token->location, OPT_pedantic, pedwarn (type_start_token->location, OPT_Wpedantic,
"%qD is an enumeration template", name); "%qD is an enumeration template", name);
/* ignore a typename reference, for it will be solved by name /* ignore a typename reference, for it will be solved by name
in start_enum. */ in start_enum. */
@ -14615,7 +14615,7 @@ cp_parser_enumerator_list (cp_parser* parser, tree type)
if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE)) if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
{ {
if (cxx_dialect < cxx0x && !in_system_header) if (cxx_dialect < cxx0x && !in_system_header)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"comma at end of enumerator list"); "comma at end of enumerator list");
break; break;
} }
@ -17634,7 +17634,7 @@ cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
&& cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON) && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
{ {
/* Warn the user that they are using an extension. */ /* Warn the user that they are using an extension. */
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ does not allow designated initializers"); "ISO C++ does not allow designated initializers");
/* Consume the identifier. */ /* Consume the identifier. */
designator = cp_lexer_consume_token (parser->lexer)->u.value; designator = cp_lexer_consume_token (parser->lexer)->u.value;
@ -17648,7 +17648,7 @@ cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
&& cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ) && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ)
{ {
/* Warn the user that they are using an extension. */ /* Warn the user that they are using an extension. */
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ does not allow C99 designated initializers"); "ISO C++ does not allow C99 designated initializers");
/* Consume the `.'. */ /* Consume the `.'. */
cp_lexer_consume_token (parser->lexer); cp_lexer_consume_token (parser->lexer);
@ -18864,7 +18864,7 @@ cp_parser_member_declaration (cp_parser* parser)
{ {
cp_token *token = cp_lexer_peek_token (parser->lexer); cp_token *token = cp_lexer_peek_token (parser->lexer);
if (!in_system_header_at (token->location)) if (!in_system_header_at (token->location))
pedwarn (token->location, OPT_pedantic, "extra %<;%>"); pedwarn (token->location, OPT_Wpedantic, "extra %<;%>");
} }
else else
{ {
@ -18882,7 +18882,7 @@ cp_parser_member_declaration (cp_parser* parser)
/* If the `friend' keyword was present, the friend must /* If the `friend' keyword was present, the friend must
be introduced with a class-key. */ be introduced with a class-key. */
if (!declares_class_or_enum && cxx_dialect < cxx0x) if (!declares_class_or_enum && cxx_dialect < cxx0x)
pedwarn (decl_spec_token_start->location, OPT_pedantic, pedwarn (decl_spec_token_start->location, OPT_Wpedantic,
"in C++03 a class-key must be used " "in C++03 a class-key must be used "
"when declaring a friend"); "when declaring a friend");
/* In this case: /* In this case:

10
gcc/cp/pt.c
View File

@ -943,7 +943,7 @@ maybe_process_partial_specialization (tree type)
/* Someday C++0x may allow for enum template specialization. */ /* Someday C++0x may allow for enum template specialization. */
if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE
&& CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context)) && CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context))
pedwarn (input_location, OPT_pedantic, "template specialization " pedwarn (input_location, OPT_Wpedantic, "template specialization "
"of %qD not allowed by ISO C++", type); "of %qD not allowed by ISO C++", type);
else else
{ {
@ -6433,7 +6433,7 @@ convert_template_argument (tree parm,
if (cxx_dialect >= cxx0x) if (cxx_dialect >= cxx0x)
/* OK under DR 1004. */; /* OK under DR 1004. */;
else if (complain & tf_warning_or_error) else if (complain & tf_warning_or_error)
pedwarn (input_location, OPT_pedantic, "injected-class-name %qD" pedwarn (input_location, OPT_Wpedantic, "injected-class-name %qD"
" used as template template argument", TYPE_NAME (arg)); " used as template template argument", TYPE_NAME (arg));
else if (flag_pedantic_errors) else if (flag_pedantic_errors)
t = arg; t = arg;
@ -17909,7 +17909,7 @@ do_decl_instantiation (tree decl, tree storage)
else if (storage == ridpointers[(int) RID_EXTERN]) else if (storage == ridpointers[(int) RID_EXTERN])
{ {
if (!in_system_header && (cxx_dialect == cxx98)) if (!in_system_header && (cxx_dialect == cxx98))
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ 1998 forbids the use of %<extern%> on explicit " "ISO C++ 1998 forbids the use of %<extern%> on explicit "
"instantiations"); "instantiations");
extern_p = 1; extern_p = 1;
@ -18006,12 +18006,12 @@ do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
if (storage == ridpointers[(int) RID_EXTERN]) if (storage == ridpointers[(int) RID_EXTERN])
{ {
if (cxx_dialect == cxx98) if (cxx_dialect == cxx98)
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ 1998 forbids the use of %<extern%> on " "ISO C++ 1998 forbids the use of %<extern%> on "
"explicit instantiations"); "explicit instantiations");
} }
else else
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids the use of %qE" "ISO C++ forbids the use of %qE"
" on explicit instantiations", storage); " on explicit instantiations", storage);
} }

18
gcc/cp/typeck.c
View File

@ -605,17 +605,17 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2,
switch (operation) switch (operation)
{ {
case CPO_COMPARISON: case CPO_COMPARISON:
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids comparison between " "ISO C++ forbids comparison between "
"pointer of type %<void *%> and pointer-to-function"); "pointer of type %<void *%> and pointer-to-function");
break; break;
case CPO_CONVERSION: case CPO_CONVERSION:
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids conversion between " "ISO C++ forbids conversion between "
"pointer of type %<void *%> and pointer-to-function"); "pointer of type %<void *%> and pointer-to-function");
break; break;
case CPO_CONDITIONAL_EXPR: case CPO_CONDITIONAL_EXPR:
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids conditional expression between " "ISO C++ forbids conditional expression between "
"pointer of type %<void *%> and pointer-to-function"); "pointer of type %<void *%> and pointer-to-function");
break; break;
@ -1526,7 +1526,7 @@ cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain)
if (TREE_CODE (type) == METHOD_TYPE) if (TREE_CODE (type) == METHOD_TYPE)
{ {
if (complain) if (complain)
pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, pedwarn (input_location, pedantic ? OPT_Wpedantic : OPT_Wpointer_arith,
"invalid application of %qs to a member function", "invalid application of %qs to a member function",
operator_name_info[(int) op].name); operator_name_info[(int) op].name);
value = size_one_node; value = size_one_node;
@ -2961,7 +2961,7 @@ cp_build_array_ref (location_t loc, tree array, tree idx,
} }
if (!lvalue_p (array) && (complain & tf_error)) if (!lvalue_p (array) && (complain & tf_error))
pedwarn (loc, OPT_pedantic, pedwarn (loc, OPT_Wpedantic,
"ISO C++ forbids subscripting non-lvalue array"); "ISO C++ forbids subscripting non-lvalue array");
/* Note in C++ it is valid to subscript a `register' array, since /* Note in C++ it is valid to subscript a `register' array, since
@ -3287,7 +3287,7 @@ cp_build_function_call_vec (tree function, VEC(tree,gc) **params,
/* Convert anything with function type to a pointer-to-function. */ /* Convert anything with function type to a pointer-to-function. */
if (DECL_MAIN_P (function) && (complain & tf_error)) if (DECL_MAIN_P (function) && (complain & tf_error))
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids calling %<::main%> from within program"); "ISO C++ forbids calling %<::main%> from within program");
function = build_addr_func (function, complain); function = build_addr_func (function, complain);
@ -4935,9 +4935,9 @@ cp_build_addr_expr_1 (tree arg, bool strict_lvalue, tsubst_flags_t complain)
{ {
/* ARM $3.4 */ /* ARM $3.4 */
/* Apparently a lot of autoconf scripts for C++ packages do this, /* Apparently a lot of autoconf scripts for C++ packages do this,
so only complain if -pedantic. */ so only complain if -Wpedantic. */
if (complain & (flag_pedantic_errors ? tf_error : tf_warning)) if (complain & (flag_pedantic_errors ? tf_error : tf_warning))
pedwarn (input_location, OPT_pedantic, pedwarn (input_location, OPT_Wpedantic,
"ISO C++ forbids taking address of function %<::main%>"); "ISO C++ forbids taking address of function %<::main%>");
else if (flag_pedantic_errors) else if (flag_pedantic_errors)
return error_mark_node; return error_mark_node;
@ -6194,7 +6194,7 @@ convert_member_func_to_ptr (tree type, tree expr, tsubst_flags_t complain)
return error_mark_node; return error_mark_node;
if (pedantic || warn_pmf2ptr) if (pedantic || warn_pmf2ptr)
pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpmf_conversions, pedwarn (input_location, pedantic ? OPT_Wpedantic : OPT_Wpmf_conversions,
"converting from %qT to %qT", intype, type); "converting from %qT to %qT", intype, type);
if (TREE_CODE (intype) == METHOD_TYPE) if (TREE_CODE (intype) == METHOD_TYPE)

6
gcc/diagnostic.c
View File

@ -809,10 +809,10 @@ warning_at (location_t location, int opt, const char *gmsgid, ...)
language standard, if you have chosen not to make them errors. language standard, if you have chosen not to make them errors.
Note that these diagnostics are issued independent of the setting Note that these diagnostics are issued independent of the setting
of the -pedantic command-line switch. To get a warning enabled of the -Wpedantic command-line switch. To get a warning enabled
only with that switch, use either "if (pedantic) pedwarn only with that switch, use either "if (pedantic) pedwarn
(OPT_pedantic,...)" or just "pedwarn (OPT_pedantic,..)". To get a (OPT_Wpedantic,...)" or just "pedwarn (OPT_Wpedantic,..)". To get a
pedwarn independently of the -pedantic switch use "pedwarn (0,...)". pedwarn independently of the -Wpedantic switch use "pedwarn (0,...)".
Returns true if the warning was printed, false if it was inhibited. */ Returns true if the warning was printed, false if it was inhibited. */

44
gcc/doc/invoke.texi
View File

@ -39,7 +39,7 @@ included in the gfdl(7) man page.
@c man begin SYNOPSIS @c man begin SYNOPSIS
gcc [@option{-c}|@option{-S}|@option{-E}] [@option{-std=}@var{standard}] gcc [@option{-c}|@option{-S}|@option{-E}] [@option{-std=}@var{standard}]
[@option{-g}] [@option{-pg}] [@option{-O}@var{level}] [@option{-g}] [@option{-pg}] [@option{-O}@var{level}]
[@option{-W}@var{warn}@dots{}] [@option{-pedantic}] [@option{-W}@var{warn}@dots{}] [@option{-Wpedantic}]
[@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}] [@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}]
[@option{-D}@var{macro}[=@var{defn}]@dots{}] [@option{-U}@var{macro}] [@option{-D}@var{macro}[=@var{defn}]@dots{}] [@option{-U}@var{macro}]
[@option{-f}@var{option}@dots{}] [@option{-m}@var{machine-option}@dots{}] [@option{-f}@var{option}@dots{}] [@option{-m}@var{machine-option}@dots{}]
@ -234,7 +234,7 @@ Objective-C and Objective-C++ Dialects}.
@item Warning Options @item Warning Options
@xref{Warning Options,,Options to Request or Suppress Warnings}. @xref{Warning Options,,Options to Request or Suppress Warnings}.
@gccoptlist{-fsyntax-only -fmax-errors=@var{n} -pedantic @gol @gccoptlist{-fsyntax-only -fmax-errors=@var{n} -Wpedantic @gol
-pedantic-errors @gol -pedantic-errors @gol
-w -Wextra -Wall -Waddress -Waggregate-return -Warray-bounds @gol -w -Wextra -Wall -Waddress -Waggregate-return -Warray-bounds @gol
-Wno-attributes -Wno-builtin-macro-redefined @gol -Wno-attributes -Wno-builtin-macro-redefined @gol
@ -1516,7 +1516,7 @@ such as @code{__unix__} and @code{__vax__} are also available, with or
without @option{-ansi}. without @option{-ansi}.
The @option{-ansi} option does not cause non-ISO programs to be The @option{-ansi} option does not cause non-ISO programs to be
rejected gratuitously. For that, @option{-pedantic} is required in rejected gratuitously. For that, @option{-Wpedantic} is required in
addition to @option{-ansi}. @xref{Warning Options}. addition to @option{-ansi}. @xref{Warning Options}.
The macro @code{__STRICT_ANSI__} is predefined when the @option{-ansi} The macro @code{__STRICT_ANSI__} is predefined when the @option{-ansi}
@ -1550,10 +1550,10 @@ expression. On the other hand, by specifying a GNU dialect of a
standard, all features the compiler support are enabled, even when standard, all features the compiler support are enabled, even when
those features change the meaning of the base standard and some those features change the meaning of the base standard and some
strict-conforming programs may be rejected. The particular standard strict-conforming programs may be rejected. The particular standard
is used by @option{-pedantic} to identify which features are GNU is used by @option{-Wpedantic} to identify which features are GNU
extensions given that version of the standard. For example extensions given that version of the standard. For example
@option{-std=gnu90 -pedantic} warns about C++ style @samp{//} @option{-std=gnu90 -Wpedantic} warns about C++ style @samp{//}
comments, while @option{-std=gnu99 -pedantic} does not. comments, while @option{-std=gnu99 -Wpedantic} does not.
A value for this option must be provided; possible values are A value for this option must be provided; possible values are
@ -2059,7 +2059,7 @@ errors if these functions are not inlined everywhere they are called.
@item -fms-extensions @item -fms-extensions
@opindex fms-extensions @opindex fms-extensions
Disable pedantic warnings about constructs used in MFC, such as implicit Disable Wpedantic warnings about constructs used in MFC, such as implicit
int and getting a pointer to member function via non-standard syntax. int and getting a pointer to member function via non-standard syntax.
@item -fno-nonansi-builtins @item -fno-nonansi-builtins
@ -2994,8 +2994,10 @@ with old compilers, but if something goes wrong, the compiler
warns that an unrecognized option is present. warns that an unrecognized option is present.
@table @gcctabopt @table @gcctabopt
@item -pedantic @item -Wpedantic
@itemx -pedantic
@opindex pedantic @opindex pedantic
@opindex Wpedantic
Issue all the warnings demanded by strict ISO C and ISO C++; Issue all the warnings demanded by strict ISO C and ISO C++;
reject all programs that use forbidden extensions, and some other reject all programs that use forbidden extensions, and some other
programs that do not follow ISO C and ISO C++. For ISO C, follows the programs that do not follow ISO C and ISO C++. For ISO C, follows the
@ -3007,14 +3009,14 @@ this option (though a rare few require @option{-ansi} or a
without this option, certain GNU extensions and traditional C and C++ without this option, certain GNU extensions and traditional C and C++
features are supported as well. With this option, they are rejected. features are supported as well. With this option, they are rejected.
@option{-pedantic} does not cause warning messages for use of the @option{-Wpedantic} does not cause warning messages for use of the
alternate keywords whose names begin and end with @samp{__}. Pedantic alternate keywords whose names begin and end with @samp{__}. Pedantic
warnings are also disabled in the expression that follows warnings are also disabled in the expression that follows
@code{__extension__}. However, only system header files should use @code{__extension__}. However, only system header files should use
these escape routes; application programs should avoid them. these escape routes; application programs should avoid them.
@xref{Alternate Keywords}. @xref{Alternate Keywords}.
Some users try to use @option{-pedantic} to check programs for strict ISO Some users try to use @option{-Wpedantic} to check programs for strict ISO
C conformance. They soon find that it does not do quite what they want: C conformance. They soon find that it does not do quite what they want:
it finds some non-ISO practices, but not all---only those for which it finds some non-ISO practices, but not all---only those for which
ISO C @emph{requires} a diagnostic, and some others for which ISO C @emph{requires} a diagnostic, and some others for which
@ -3022,13 +3024,13 @@ diagnostics have been added.
A feature to report any failure to conform to ISO C might be useful in A feature to report any failure to conform to ISO C might be useful in
some instances, but would require considerable additional work and would some instances, but would require considerable additional work and would
be quite different from @option{-pedantic}. We don't have plans to be quite different from @option{-Wpedantic}. We don't have plans to
support such a feature in the near future. support such a feature in the near future.
Where the standard specified with @option{-std} represents a GNU Where the standard specified with @option{-std} represents a GNU
extended dialect of C, such as @samp{gnu90} or @samp{gnu99}, there is a extended dialect of C, such as @samp{gnu90} or @samp{gnu99}, there is a
corresponding @dfn{base standard}, the version of ISO C on which the GNU corresponding @dfn{base standard}, the version of ISO C on which the GNU
extended dialect is based. Warnings from @option{-pedantic} are given extended dialect is based. Warnings from @option{-Wpedantic} are given
where they are required by the base standard. (It does not make sense where they are required by the base standard. (It does not make sense
for such warnings to be given only for features not in the specified GNU for such warnings to be given only for features not in the specified GNU
C dialect, since by definition the GNU dialects of C include all C dialect, since by definition the GNU dialects of C include all
@ -3037,7 +3039,7 @@ nothing to warn about.)
@item -pedantic-errors @item -pedantic-errors
@opindex pedantic-errors @opindex pedantic-errors
Like @option{-pedantic}, except that errors are produced rather than Like @option{-Wpedantic}, except that errors are produced rather than
warnings. warnings.
@item -Wall @item -Wall
@ -3223,7 +3225,7 @@ libc version 2.2. These include all ISO C90 and C99 features, as well
as features from the Single Unix Specification and some BSD and GNU as features from the Single Unix Specification and some BSD and GNU
extensions. Other library implementations may not support all these extensions. Other library implementations may not support all these
features; GCC does not support warning about features that go beyond a features; GCC does not support warning about features that go beyond a
particular library's limitations. However, if @option{-pedantic} is used particular library's limitations. However, if @option{-Wpedantic} is used
with @option{-Wformat}, warnings are given about format features not with @option{-Wformat}, warnings are given about format features not
in the selected standard version (but not for @code{strfmon} formats, in the selected standard version (but not for @code{strfmon} formats,
since those are not in any version of the C standard). @xref{C Dialect since those are not in any version of the C standard). @xref{C Dialect
@ -3366,7 +3368,7 @@ Warn if the type of @samp{main} is suspicious. @samp{main} should be
a function with external linkage, returning int, taking either zero a function with external linkage, returning int, taking either zero
arguments, two, or three arguments of appropriate types. This warning arguments, two, or three arguments of appropriate types. This warning
is enabled by default in C++ and is enabled by either @option{-Wall} is enabled by default in C++ and is enabled by either @option{-Wall}
or @option{-pedantic}. or @option{-Wpedantic}.
@item -Wmissing-braces @item -Wmissing-braces
@opindex Wmissing-braces @opindex Wmissing-braces
@ -4107,7 +4109,7 @@ such assumptions.
Disables the warnings about non-ISO @code{printf} / @code{scanf} format Disables the warnings about non-ISO @code{printf} / @code{scanf} format
width specifiers @code{I32}, @code{I64}, and @code{I} used on Windows targets width specifiers @code{I32}, @code{I64}, and @code{I} used on Windows targets
depending on the MS runtime, when you are using the options @option{-Wformat} depending on the MS runtime, when you are using the options @option{-Wformat}
and @option{-pedantic} without gnu-extensions. and @option{-Wpedantic} without gnu-extensions.
@item -Wpointer-arith @item -Wpointer-arith
@opindex Wpointer-arith @opindex Wpointer-arith
@ -4116,7 +4118,7 @@ Warn about anything that depends on the ``size of'' a function type or
of @code{void}. GNU C assigns these types a size of 1, for of @code{void}. GNU C assigns these types a size of 1, for
convenience in calculations with @code{void *} pointers and pointers convenience in calculations with @code{void *} pointers and pointers
to functions. In C++, warn also when an arithmetic operation involves to functions. In C++, warn also when an arithmetic operation involves
@code{NULL}. This warning is also enabled by @option{-pedantic}. @code{NULL}. This warning is also enabled by @option{-Wpedantic}.
@item -Wtype-limits @item -Wtype-limits
@opindex Wtype-limits @opindex Wtype-limits
@ -4621,7 +4623,7 @@ the search path but can't be used.
@opindex Wlong-long @opindex Wlong-long
@opindex Wno-long-long @opindex Wno-long-long
Warn if @samp{long long} type is used. This is enabled by either Warn if @samp{long long} type is used. This is enabled by either
@option{-pedantic} or @option{-Wtraditional} in ISO C90 and C++98 @option{-Wpedantic} or @option{-Wtraditional} in ISO C90 and C++98
modes. To inhibit the warning messages, use @option{-Wno-long-long}. modes. To inhibit the warning messages, use @option{-Wno-long-long}.
@item -Wvariadic-macros @item -Wvariadic-macros
@ -4647,7 +4649,7 @@ scalar type.
@opindex Wvla @opindex Wvla
@opindex Wno-vla @opindex Wno-vla
Warn if variable length array is used in the code. Warn if variable length array is used in the code.
@option{-Wno-vla} prevents the @option{-pedantic} warning of @option{-Wno-vla} prevents the @option{-Wpedantic} warning of
the variable length array. the variable length array.
@item -Wvolatile-register-var @item -Wvolatile-register-var
@ -4673,7 +4675,7 @@ itself is likely to take inordinate amounts of time.
@opindex Wno-pointer-sign @opindex Wno-pointer-sign
Warn for pointer argument passing or assignment with different signedness. Warn for pointer argument passing or assignment with different signedness.
This option is only supported for C and Objective-C@. It is implied by This option is only supported for C and Objective-C@. It is implied by
@option{-Wall} and by @option{-pedantic}, which can be disabled with @option{-Wall} and by @option{-Wpedantic}, which can be disabled with
@option{-Wno-pointer-sign}. @option{-Wno-pointer-sign}.
@item -Wstack-protector @item -Wstack-protector
@ -4701,7 +4703,7 @@ not count the trailing NUL@. In C90, the limit was 509 characters; in
C99, it was raised to 4095. C++98 does not specify a normative C99, it was raised to 4095. C++98 does not specify a normative
minimum maximum, so we do not diagnose overlength strings in C++@. minimum maximum, so we do not diagnose overlength strings in C++@.
This option is implied by @option{-pedantic}, and can be disabled with This option is implied by @option{-Wpedantic}, and can be disabled with
@option{-Wno-overlength-strings}. @option{-Wno-overlength-strings}.
@item -Wunsuffixed-float-constants @r{(C and Objective-C only)} @item -Wunsuffixed-float-constants @r{(C and Objective-C only)}