else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
{
tree t = complete_type (TREE_TYPE (type));
+ unsigned int needs_constructing, has_nontrivial_dtor;
if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))
layout_type (type);
- TYPE_NEEDS_CONSTRUCTING (type)
+ needs_constructing
= TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
- TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
+ has_nontrivial_dtor
= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
+ for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
+ {
+ TYPE_NEEDS_CONSTRUCTING (t) = needs_constructing;
+ TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = has_nontrivial_dtor;
+ }
}
else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
instantiate_class_template (TYPE_MAIN_VARIANT (type));
return expr;
}
+/* An expression of the form "A::template B" has been resolved to
+ DECL. Issue a diagnostic if B is not a template or template
+ specialization. */
+
+void
+check_template_keyword (tree decl)
+{
+ /* The standard says:
+
+ [temp.names]
+
+ If a name prefixed by the keyword template is not a member
+ template, the program is ill-formed.
+
+ DR 228 removed the restriction that the template be a member
+ template.
+
+ DR 96, if accepted would add the further restriction that explicit
+ template arguments must be provided if the template keyword is
+ used, but, as of 2005-10-16, that DR is still in "drafting". If
+ this DR is accepted, then the semantic checks here can be
+ simplified, as the entity named must in fact be a template
+ specialization, rather than, as at present, a set of overloaded
+ functions containing at least one template function. */
+ if (TREE_CODE (decl) != TEMPLATE_DECL
+ && TREE_CODE (decl) != TEMPLATE_ID_EXPR)
+ {
+ if (!is_overloaded_fn (decl))
+ pedwarn ("%qD is not a template", decl);
+ else
+ {
+ tree fns;
+ fns = decl;
+ if (BASELINK_P (fns))
+ fns = BASELINK_FUNCTIONS (fns);
+ while (fns)
+ {
+ tree fn = OVL_CURRENT (fns);
+ if (TREE_CODE (fn) == TEMPLATE_DECL
+ || TREE_CODE (fn) == TEMPLATE_ID_EXPR)
+ break;
+ if (TREE_CODE (fn) == FUNCTION_DECL
+ && DECL_USE_TEMPLATE (fn)
+ && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
+ break;
+ fns = OVL_NEXT (fns);
+ }
+ if (!fns)
+ pedwarn ("%qD is not a template", decl);
+ }
+ }
+}
+
/* This function is called by the parser to process a class member
access expression of the form OBJECT.NAME. NAME is a node used by
the parser to represent a name; it is not yet a DECL. It may,
however, be a BASELINK where the BASELINK_FUNCTIONS is a
TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
there is no reason to do the lookup twice, so the parser keeps the
- BASELINK. */
+ BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
+ be a template via the use of the "A::template B" syntax. */
tree
-finish_class_member_access_expr (tree object, tree name)
+finish_class_member_access_expr (tree object, tree name, bool template_p)
{
tree expr;
tree object_type;
}
if (BASELINK_P (name))
- {
- /* A member function that has already been looked up. */
- gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name)) == TEMPLATE_ID_EXPR);
- member = name;
- }
+ /* A member function that has already been looked up. */
+ member = name;
else
{
bool is_template_id = false;
if (TREE_DEPRECATED (member))
warn_deprecated_use (member);
+ if (template_p)
+ check_template_keyword (member);
+
expr = build_class_member_access_expr (object, member, access_path,
/*preserve_reference=*/false);
if (processing_template_decl && expr != error_mark_node)
- return build_min_non_dep (COMPONENT_REF, expr,
- orig_object, orig_name, NULL_TREE);
+ {
+ if (BASELINK_P (member))
+ {
+ if (TREE_CODE (orig_name) == SCOPE_REF)
+ BASELINK_QUALIFIED_P (member) = 1;
+ orig_name = member;
+ }
+ return build_min_non_dep (COMPONENT_REF, expr,
+ orig_object, orig_name,
+ NULL_TREE);
+ }
+
return expr;
}
{
tree rval, type;
- /* Subscripting with type char is likely to lose
- on a machine where chars are signed.
- So warn on any machine, but optionally.
- Don't warn for unsigned char since that type is safe.
- Don't warn for signed char because anyone who uses that
- must have done so deliberately. */
- if (warn_char_subscripts
- && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
- warning (0, "array subscript has type %<char%>");
+ warn_array_subscript_with_type_char (idx);
if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
{
case NE_EXPR:
if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
warning (0, "comparing floating point with == or != is unsafe");
+ if ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
+ || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0)))
+ warning (OPT_Wstring_literal_comparison,
+ "comparison with string literal");
build_type = boolean_type_node;
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
case GE_EXPR:
case LT_EXPR:
case GT_EXPR:
+ if (TREE_CODE (orig_op0) == STRING_CST
+ || TREE_CODE (orig_op1) == STRING_CST)
+ warning (OPT_Wstring_literal_comparison,
+ "comparison with string literal");
+
build_type = boolean_type_node;
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
}
else
{
- error ("parenthesis around %qE cannot be used to form a"
+ error ("parentheses around %qE cannot be used to form a"
" pointer-to-member-function",
xarg);
PTRMEM_OK_P (xarg) = 1;
const char *description)
{
if (diag_fn && casts_away_constness (src_type, dest_type))
- error ("%s from type %qT to type %qT casts away constness",
- description, src_type, dest_type);
+ diag_fn ("%s from type %qT to type %qT casts away constness",
+ description, src_type, dest_type);
}
/* Convert EXPR (an expression with pointer-to-member type) to TYPE
else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
|| (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
{
+ tree sexpr = expr;
+
if (!c_cast_p)
check_for_casting_away_constness (intype, type, error,
"reinterpret_cast");
"target type",
intype, type);
+ /* We need to strip nops here, because the frontend likes to
+ create (int *)&a for array-to-pointer decay, instead of &a[0]. */
+ STRIP_NOPS (sexpr);
+ strict_aliasing_warning (intype, type, sexpr);
+
return fold_if_not_in_template (build_nop (type, expr));
}
else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
/* Perform a const_cast from EXPR to TYPE. If the cast is valid,
return an appropriate expression. Otherwise, return
error_mark_node. If the cast is not valid, and COMPLAIN is true,
- then a diagnostic will be issued. If VALID_P is non-NULL, its
- value upon return will indicate whether or not the conversion
- succeeded. */
+ then a diagnostic will be issued. If VALID_P is non-NULL, we are
+ performing a C-style cast, its value upon return will indicate
+ whether or not the conversion succeeded. */
static tree
build_const_cast_1 (tree dst_type, tree expr, bool complain,
&& comp_ptr_ttypes_const (dst_type, src_type))
{
if (valid_p)
- *valid_p = true;
+ {
+ *valid_p = true;
+ /* This cast is actually a C-style cast. Issue a warning if
+ the user is making a potentially unsafe cast. */
+ if (warn_cast_qual)
+ check_for_casting_away_constness (src_type, dst_type,
+ warning0,
+ "cast");
+ }
if (reference_type)
{
expr = build_unary_op (ADDR_EXPR, expr, 0);
/* The type the function is declared to return. */
tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
+ /* The functype's return type will have been set to void, if it
+ was an incomplete type. Just treat this as 'return;' */
+ if (VOID_TYPE_P (functype))
+ return error_mark_node;
+
/* First convert the value to the function's return type, then
to the type of return value's location to handle the
case that functype is smaller than the valtype. */
OSDN Git Service
