+2006-02-03 Lee Millward <lee.millward@gmail.com>
+
+ * typeck.c (string_conv_p): Pass appropiate
+ OPT_Wxxxx values when calling warning().
+ (build_array_ref, cxx_mark_addressable): Likewise.
+ (check_return_expr): Likewise.
+
+ * init.c (perform_member_init): Likewise.
+ (sort_mem_initializers, emit_mem_initializers): Likewise.
+
+ * class.c (check_field_decls): Likewise.
+ (warn_about_ambiguous_bases): Likewise.
+
+ * decl.c (pop_label, poplevel): Likewise.
+ (duplicate_decls, grok_op_properties): Likewise.
+ (start_preparsed_function, finish_function): Likewise.
+
+ * name-lookup.c (pushdecl_maybe_friend): Likewise.
+ (pushdecl_maybe_friend): Likewise.
+
+ * parser.c (cp_parser_warn_min_max): Likewise.
+ (cp_parser_cast_expression): Likewise.
+
+ * method.c (lazily_declare_fn): Likewise.
+ * cvt.c (convert_to_void): Likewise.
+ * mangle.c (finish_mangling): Likewise.
+ * cp-gimplify.c (gimplify_expr_stmt): Likewise.
+
2006-02-03 Mark Mitchell <mark@codesourcery.com>
* name-lookup.c (do_class_using_decl): Use IDENTIFIER_TYPENAME_P,
(cp_parser_asm_definition): Call cgraph_add_asm_node rather than
assemble_asm.
-2006-01-16 Rafael Ávila de Espíndola <rafael.espindola@gmail.com>
+2006-01-16 Rafael �ila de Esp�dola <rafael.espindola@gmail.com>
* g++spec.c (lang_specific_spec_functions): Remove.
* mangle.c (write_bare_function_type): Mangle return type for
methods of Java classes
-2005-12-08 Théodore Papadopoulo <Theodore.Papadopoulo@sophia.inria.fr>
+2005-12-08 Th�dore Papadopoulo <Theodore.Papadopoulo@sophia.inria.fr>
* call.c (build_conditional_expr): Print types in error messages.
* cp-gimplify.c (gimplify_cp_loop): Use fold_build3.
-2005-12-07 Rafael Ávila de Espíndola <rafael.espindola@gmail.com>
+2005-12-07 Rafael �ila de Esp�dola <rafael.espindola@gmail.com>
* Make-lang.in (c++.all.build, c++.install-normal): Remove.
-2005-12-07 Rafael Ávila de Espíndola <rafael.espindola@gmail.com>
+2005-12-07 Rafael �ila de Esp�dola <rafael.espindola@gmail.com>
* Make-lang.in: Remove all dependencies on s-gtype.
members. */
TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
- if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
- && extra_warnings)
- warning (0, "non-static reference %q+#D in class without a constructor", x);
+ if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t))
+ warning (OPT_Wextra, "non-static reference %q+#D in class without a constructor", x);
}
type = strip_array_types (type);
members. */
TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
- if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
- && extra_warnings)
- warning (0, "non-static const member %q+#D in class without a constructor", x);
+ if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t))
+ warning (OPT_Wextra, "non-static const member %q+#D in class without a constructor", x);
}
/* A field that is pseudo-const makes the structure likewise. */
else if (CLASS_TYPE_P (type))
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
&& !(TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
{
- warning (0, "%q#T has pointer data members", t);
+ warning (OPT_Weffc__, "%q#T has pointer data members", t);
if (! TYPE_HAS_INIT_REF (t))
{
basetype = BINFO_TYPE (binfo);
if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
- warning (0, "virtual base %qT inaccessible in %qT due to ambiguity",
+ warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
basetype, t);
}
}
if (!IS_EMPTY_STMT (stmt)
&& !VOID_TYPE_P (TREE_TYPE (stmt))
&& !TREE_NO_WARNING (stmt))
- warning (0, "statement with no effect");
+ warning (OPT_Wextra, "statement with no effect");
}
else if (warn_unused_value)
warn_if_unused_value (stmt, input_location);
/* The middle end does not warn about expressions that have
been explicitly cast to void, so we must do so here. */
if (!TREE_SIDE_EFFECTS (expr))
- warning (0, "%s has no effect", implicit);
+ warning (OPT_Wunused_value, "%s has no effect", implicit);
else
{
tree e;
|| code == PREINCREMENT_EXPR
|| code == POSTDECREMENT_EXPR
|| code == POSTINCREMENT_EXPR)))
- warning (0, "value computed is not used");
+ warning (OPT_Wunused_value, "value computed is not used");
}
}
expr = build1 (CONVERT_EXPR, void_type_node, expr);
/* Avoid crashing later. */
define_label (location, DECL_NAME (label));
}
- else if (warn_unused_label && !TREE_USED (label))
- warning (0, "label %q+D defined but not used", label);
+ else if (!TREE_USED (label))
+ warning (OPT_Wunused_label, "label %q+D defined but not used", label);
}
SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
&& ! TREE_USED (decl)
&& ! DECL_IN_SYSTEM_HEADER (decl)
&& DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
- warning (0, "unused variable %q+D", decl);
+ warning (OPT_Wunused_variable, "unused variable %q+D", decl);
/* Remove declarations for all the DECLs in this level. */
for (link = decls; link; link = TREE_CHAIN (link))
bad choice of name. */
if (! TREE_PUBLIC (newdecl))
{
- if (warn_shadow)
- warning (0, "shadowing %s function %q#D",
- DECL_BUILT_IN (olddecl) ? "built-in" : "library",
- olddecl);
+ warning (OPT_Wshadow, "shadowing %s function %q#D",
+ DECL_BUILT_IN (olddecl) ? "built-in" : "library",
+ olddecl);
/* Discard the old built-in function. */
return NULL_TREE;
}
warning (0, "ambiguates built-in declaration %q#D",
olddecl);
}
- else if (warn_shadow)
- warning (0, "shadowing %s function %q#D",
+ else
+ warning (OPT_Wshadow, "shadowing %s function %q#D",
DECL_BUILT_IN (olddecl) ? "built-in" : "library",
olddecl);
}
/* Don't warn about friends, let add_friend take care of it. */
&& ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
{
- warning (0, "redundant redeclaration of %qD in same scope", newdecl);
- warning (0, "previous declaration of %q+D", olddecl);
+ warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
+ warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
}
}
}
if (what)
- warning (0, "conversion to %s%s will never use a type "
+ warning (OPT_Wconversion, "conversion to %s%s will never use a type "
"conversion operator",
ref ? "a reference to " : "", what);
}
if (TREE_CODE (ret) != REFERENCE_TYPE
|| !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
arg))
- warning (0, "prefix %qD should return %qT", decl,
+ warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
build_reference_type (arg));
}
else
{
if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
- warning (0, "postfix %qD should return %qT", decl, arg);
+ warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
}
}
}
&& (operator_code == TRUTH_ANDIF_EXPR
|| operator_code == TRUTH_ORIF_EXPR
|| operator_code == COMPOUND_EXPR))
- warning (0, "user-defined %qD always evaluates both arguments",
+ warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
decl);
}
|| operator_code == MULT_EXPR
|| operator_code == TRUNC_MOD_EXPR)
&& TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
- warning (0, "%qD should return by value", decl);
+ warning (OPT_Weffc__, "%qD should return by value", decl);
/* [over.oper]/8 */
for (; argtypes && argtypes != void_list_node;
if (warn_ecpp
&& DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
&& TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
- warning (0, "%<operator=%> should return a reference to %<*this%>");
+ warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
/* Make the init_value nonzero so pushdecl knows this is not tentative.
error_mark_node is replaced below (in poplevel) with the BLOCK. */
/* Structor return values (if any) are set by the compiler. */
&& !DECL_CONSTRUCTOR_P (fndecl)
&& !DECL_DESTRUCTOR_P (fndecl))
- warning (0, "no return statement in function returning non-void");
+ warning (OPT_Wreturn_type, "no return statement in function returning non-void");
/* Store the end of the function, so that we get good line number
info for the epilogue. */
/* Effective C++ rule 12 requires that all data members be
initialized. */
if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
- warning (0, "%J%qD should be initialized in the member initialization "
+ warning (OPT_Weffc__, "%J%qD should be initialized in the member initialization "
"list", current_function_decl, member);
if (init == void_type_node)
if (warn_reorder && !subobject_init)
{
if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
- warning (0, "%q+D will be initialized after",
+ warning (OPT_Wreorder, "%q+D will be initialized after",
TREE_PURPOSE (next_subobject));
else
- warning (0, "base %qT will be initialized after",
+ warning (OPT_Wreorder, "base %qT will be initialized after",
TREE_PURPOSE (next_subobject));
if (TREE_CODE (subobject) == FIELD_DECL)
- warning (0, " %q+#D", subobject);
+ warning (OPT_Wreorder, " %q+#D", subobject);
else
- warning (0, " base %qT", subobject);
- warning (0, "%J when initialized here", current_function_decl);
+ warning (OPT_Wreorder, " base %qT", subobject);
+ warning (OPT_Wreorder, "%J when initialized here", current_function_decl);
}
/* Look again, from the beginning of the list. */
if (extra_warnings && !arguments
&& DECL_COPY_CONSTRUCTOR_P (current_function_decl)
&& TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
- warning (0, "%Jbase class %q#T should be explicitly initialized in the "
+ warning (OPT_Wextra, "%Jbase class %q#T should be explicitly initialized in the "
"copy constructor",
current_function_decl, BINFO_TYPE (subobject));
finish_mangling (const bool warn)
{
if (warn_abi && warn && G.need_abi_warning)
- warning (0, "the mangled name of %qD will change in a future "
+ warning (OPT_Wabi, "the mangled name of %qD will change in a future "
"version of GCC",
G.entity);
TYPE_METHODS list, which cause the destructor to be emitted
in an incorrect location in the vtable. */
if (warn_abi && DECL_VIRTUAL_P (fn))
- warning (0, "vtable layout for class %qT may not be ABI-compliant"
+ warning (OPT_Wabi, "vtable layout for class %qT may not be ABI-compliant"
"and may change in a future version of GCC due to "
"implicit virtual destructor",
type);
if (warn_shadow && !err)
{
- warning (0, "declaration of %q#D shadows a parameter", x);
- warning (0, "%Jshadowed declaration is here", oldlocal);
+ warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
+ warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
}
}
if (member && !TREE_STATIC (member))
{
/* Location of previous decl is not useful in this case. */
- warning (0, "declaration of %qD shadows a member of 'this'",
+ warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
x);
}
else if (oldlocal != NULL_TREE
&& TREE_CODE (oldlocal) == VAR_DECL)
{
- warning (0, "declaration of %qD shadows a previous local", x);
- warning (0, "%Jshadowed declaration is here", oldlocal);
+ warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
+ warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
}
else if (oldglobal != NULL_TREE
&& TREE_CODE (oldglobal) == VAR_DECL)
/* XXX shadow warnings in outer-more namespaces */
{
- warning (0, "declaration of %qD shadows a global declaration",
+ warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
x);
- warning (0, "%Jshadowed declaration is here", oldglobal);
+ warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
}
}
}
cp_parser_warn_min_max (void)
{
if (warn_deprecated && !in_system_header)
- warning (0, "minimum/maximum operators are deprecated");
+ warning (OPT_Wdeprecated, "minimum/maximum operators are deprecated");
}
/* If not parsing tentatively, issue a diagnostic of the form
&& !in_system_header
&& !VOID_TYPE_P (type)
&& current_lang_name != lang_name_c)
- warning (0, "use of old-style cast");
+ warning (OPT_Wold_style_cast, "use of old-style cast");
/* Only type conversions to integral or enumeration types
can be used in constant-expressions. */
}
/* This warning is not very useful, as it complains about printf. */
- if (warn && warn_write_strings)
- warning (0, "deprecated conversion from string constant to %qT'", totype);
+ if (warn)
+ warning (OPT_Wwrite_strings, "deprecated conversion from string constant to %qT'", totype);
return 1;
}
while (TREE_CODE (foo) == COMPONENT_REF)
foo = TREE_OPERAND (foo, 0);
if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
- warning (0, "subscripting array declared %<register%>");
+ warning (OPT_Wextra, "subscripting array declared %<register%>");
}
type = TREE_TYPE (TREE_TYPE (array));
("address of explicit register variable %qD requested", x);
return false;
}
- else if (extra_warnings)
+ else
warning
- (0, "address requested for %qD, which is declared %<register%>", x);
+ (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x);
}
TREE_ADDRESSABLE (x) = 1;
return true;
}
if (warn)
- warning (0, "%<operator=%> should return a reference to %<*this%>");
+ warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
}
/* The fabled Named Return Value optimization, as per [class.copy]/15:
projects / thirdparty / gcc.git / commitdiff
