}
}
- /* A class should never have more than one destructor. */
+ /* A class should never have more than one destructor. */
if (current_fns && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
return false;
dtor is handled in finish_struct_1. */
if (!TYPE_POLYMORPHIC_P (basetype))
warning (OPT_Weffc__,
- "base class %q#T has a non-virtual destructor", basetype);
+ "base class %q#T has a non-virtual destructor", basetype);
/* If the base class doesn't have copy constructors or
assignment operators that take const references, then the
if (!has_nonprivate_method)
{
warning (OPT_Wctor_dtor_privacy,
- "all member functions in class %qT are private", t);
+ "all member functions in class %qT are private", t);
return;
}
}
if (fn && TREE_PRIVATE (fn))
{
warning (OPT_Wctor_dtor_privacy,
- "%q#T only defines a private destructor and has no friends",
+ "%q#T only defines a private destructor and has no friends",
t);
return;
}
if (nonprivate_ctor == 0)
{
warning (OPT_Wctor_dtor_privacy,
- "%q#T only defines private constructors and has no friends",
+ "%q#T only defines private constructors and has no friends",
t);
return;
}
/* Extract the declared width of the bitfield, which has been
temporarily stashed in DECL_INITIAL. */
w = DECL_INITIAL (field);
- gcc_assert (w != NULL_TREE);
+ gcc_assert (w != NULL_TREE);
/* Remove the bit-field width indicator so that the rest of the
compiler does not treat that value as an initializer. */
DECL_INITIAL (field) = NULL_TREE;
if (! TYPE_HAS_INIT_REF (t))
{
warning (OPT_Weffc__,
- " but does not override %<%T(const %T&)%>", t, t);
+ " but does not override %<%T(const %T&)%>", t, t);
if (!TYPE_HAS_ASSIGN_REF (t))
warning (OPT_Weffc__, " or %<operator=(const %T&)%>", t);
}
else if (! TYPE_HAS_ASSIGN_REF (t))
warning (OPT_Weffc__,
- " but does not override %<operator=(const %T&)%>", t);
+ " but does not override %<operator=(const %T&)%>", t);
}
if (type == error_mark_node)
return 0;
-
+
if (!TYPE_P (type))
{
if (abi_version_at_least (2))
other empty classes might later be placed) or at the end of the
class (where other objects might then be placed, so other empty
subobjects might later overlap). */
- if (is_data_member
+ if (is_data_member
|| !is_empty_class (BINFO_TYPE (type)))
max_offset = sizeof_biggest_empty_class;
else
(binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo)));
else
warning (OPT_Wabi,
- "offset of empty base %qT may not be ABI-compliant and may"
+ "offset of empty base %qT may not be ABI-compliant and may"
"change in a future version of GCC",
BINFO_TYPE (binfo));
}
CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
else
warning (OPT_Wabi,
- "class %qT will be considered nearly empty in a "
+ "class %qT will be considered nearly empty in a "
"future version of GCC", t);
}
}
bitsize_unit_node),
BINFO_OFFSET (vbase))))
warning (OPT_Wabi,
- "offset of virtual base %qT is not ABI-compliant and "
+ "offset of virtual base %qT is not ABI-compliant and "
"may change in a future version of GCC",
basetype);
/* Versions of G++ before G++ 3.4 did not reset the
DECL_MODE. */
warning (OPT_Wabi,
- "the offset of %qD may not be ABI-compliant and may "
+ "the offset of %qD may not be ABI-compliant and may "
"change in a future version of GCC", field);
}
else
/* The middle end uses the type of expressions to determine the
possible range of expression values. In order to optimize
"x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
- must be made aware of the width of "i", via its type.
+ must be made aware of the width of "i", via its type.
- Because C++ does not have integer types of arbitrary width,
+ Because C++ does not have integer types of arbitrary width,
we must (for the purposes of the front end) convert from the
type assigned here to the declared type of the bitfield
whenever a bitfield expression is used as an rvalue.
ftype = TREE_TYPE (field);
width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
if (width != TYPE_PRECISION (ftype))
- TREE_TYPE (field)
- = c_build_bitfield_integer_type (width,
+ TREE_TYPE (field)
+ = c_build_bitfield_integer_type (width,
TYPE_UNSIGNED (ftype));
}
TYPE_SIZE_UNIT (base_t) = size_zero_node;
if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
warning (OPT_Wabi,
- "layout of classes derived from empty class %qT "
+ "layout of classes derived from empty class %qT "
"may change in a future version of GCC",
t);
}
splay_tree_delete (empty_base_offsets);
if (CLASSTYPE_EMPTY_P (t)
- && tree_int_cst_lt (sizeof_biggest_empty_class,
+ && tree_int_cst_lt (sizeof_biggest_empty_class,
TYPE_SIZE_UNIT (t)))
sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
}
current_class_stack_size *= 2;
current_class_stack
= XRESIZEVEC (struct class_stack_node, current_class_stack,
- current_class_stack_size);
+ current_class_stack_size);
}
/* Insert a new entry on the class stack. */
build_ptrmemfunc_type (build_pointer_type (instantiation_type));
else if (!is_reference)
instantiation_type = build_pointer_type (instantiation_type);
- if (can_convert_arg (target_type, instantiation_type, instantiation,
+ if (can_convert_arg (target_type, instantiation_type, instantiation,
LOOKUP_NORMAL))
matches = tree_cons (instantiation, fn, matches);
}
tree match = most_specialized_instantiation (matches);
if (match != error_mark_node)
- matches = tree_cons (TREE_PURPOSE (match),
- NULL_TREE,
+ matches = tree_cons (TREE_PURPOSE (match),
+ NULL_TREE,
NULL_TREE);
}
}
type = BINFO_TYPE (binfo);
buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
- + TYPE_NAME_LENGTH (type) + 2);
+ + TYPE_NAME_LENGTH (type) + 2);
sprintf (buf, VFIELD_NAME_FORMAT,
IDENTIFIER_POINTER (constructor_name (type)));
return get_identifier (buf);
OSDN Git Service
