{
if (TREE_CODE (basetype) == FUNCTION_DECL)
basetype = DECL_CONTEXT (basetype);
- error ("type `%T' is not a base type for type `%T'", basetype, type);
+ error ("type %qT is not a base type for type %qT", basetype, type);
return error_mark_node;
}
tree
binfo_or_else (tree base, tree type)
{
- tree binfo = lookup_base (type, base, ba_ignore, NULL);
+ tree binfo = lookup_base (type, base, ba_unique, NULL);
if (binfo == error_mark_node)
return NULL_TREE;
if (TREE_CODE (arg) == COMPONENT_REF)
{
if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
- fmt = "%s of data-member `%D' in read-only structure";
+ fmt = "%s of data-member %qD in read-only structure";
else
- fmt = "%s of read-only data-member `%D'";
+ fmt = "%s of read-only data-member %qD";
(*fn) (fmt, string, TREE_OPERAND (arg, 1));
}
else if (TREE_CODE (arg) == VAR_DECL)
if (DECL_LANG_SPECIFIC (arg)
&& DECL_IN_AGGR_P (arg)
&& !TREE_STATIC (arg))
- fmt = "%s of constant field `%D'";
+ fmt = "%s of constant field %qD";
else
- fmt = "%s of read-only variable `%D'";
+ fmt = "%s of read-only variable %qD";
(*fn) (fmt, string, arg);
}
else if (TREE_CODE (arg) == PARM_DECL)
- (*fn) ("%s of read-only parameter `%D'", string, arg);
+ (*fn) ("%s of read-only parameter %qD", string, arg);
else if (TREE_CODE (arg) == INDIRECT_REF
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
&& (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
|| TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
- (*fn) ("%s of read-only reference `%D'", string, TREE_OPERAND (arg, 0));
+ (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
else if (TREE_CODE (arg) == RESULT_DECL)
- (*fn) ("%s of read-only named return value `%D'", string, arg);
+ (*fn) ("%s of read-only named return value %qD", string, arg);
else if (TREE_CODE (arg) == FUNCTION_DECL)
- (*fn) ("%s of function `%D'", string, arg);
+ (*fn) ("%s of function %qD", string, arg);
else
(*fn) ("%s of read-only location", string);
}
+\f
+/* Structure that holds information about declarations whose type was
+ incomplete and we could not check whether it was abstract or not. */
+
+struct pending_abstract_type GTY((chain_next ("%h.next")))
+{
+ /* Declaration which we are checking for abstractness. It is either
+ a DECL node, or an IDENTIFIER_NODE if we do not have a full
+ declaration available. */
+ tree decl;
+
+ /* Type which will be checked for abstractness. */
+ tree type;
+
+ /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
+ because DECLs already carry locus information. */
+ location_t locus;
+
+ /* Link to the next element in list. */
+ struct pending_abstract_type* next;
+};
+
+
+/* Compute the hash value of the node VAL. This function is used by the
+ hash table abstract_pending_vars. */
+
+static hashval_t
+pat_calc_hash (const void* val)
+{
+ const struct pending_abstract_type* pat = val;
+ return (hashval_t) TYPE_UID (pat->type);
+}
+
+
+/* Compare node VAL1 with the type VAL2. This function is used by the
+ hash table abstract_pending_vars. */
+
+static int
+pat_compare (const void* val1, const void* val2)
+{
+ const struct pending_abstract_type* pat1 = val1;
+ tree type2 = (tree)val2;
+
+ return (pat1->type == type2);
+}
+
+/* Hash table that maintains pending_abstract_type nodes, for which we still
+ need to check for type abstractness. The key of the table is the type
+ of the declaration. */
+static GTY ((param_is (struct pending_abstract_type)))
+htab_t abstract_pending_vars = NULL;
+
+
+/* This function is called after TYPE is completed, and will check if there
+ are pending declarations for which we still need to verify the abstractness
+ of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
+ turned out to be incomplete. */
+
+void
+complete_type_check_abstract (tree type)
+{
+ void **slot;
+ struct pending_abstract_type *pat;
+ location_t cur_loc = input_location;
+
+ gcc_assert (COMPLETE_TYPE_P (type));
+
+ if (!abstract_pending_vars)
+ return;
+
+ /* Retrieve the list of pending declarations for this type. */
+ slot = htab_find_slot_with_hash (abstract_pending_vars, type,
+ (hashval_t)TYPE_UID (type), NO_INSERT);
+ if (!slot)
+ return;
+ pat = (struct pending_abstract_type*)*slot;
+ gcc_assert (pat);
+
+ /* If the type is not abstract, do not do anything. */
+ if (CLASSTYPE_PURE_VIRTUALS (type))
+ {
+ struct pending_abstract_type *prev = 0, *next;
+
+ /* Reverse the list to emit the errors in top-down order. */
+ for (; pat; pat = next)
+ {
+ next = pat->next;
+ pat->next = prev;
+ prev = pat;
+ }
+ pat = prev;
+
+ /* Go through the list, and call abstract_virtuals_error for each
+ element: it will issue a diagnostic if the type is abstract. */
+ while (pat)
+ {
+ gcc_assert (type == pat->type);
+
+ /* Tweak input_location so that the diagnostic appears at the correct
+ location. Notice that this is only needed if the decl is an
+ IDENTIFIER_NODE, otherwise cp_error_at. */
+ input_location = pat->locus;
+ abstract_virtuals_error (pat->decl, pat->type);
+ pat = pat->next;
+ }
+ }
+
+ htab_clear_slot (abstract_pending_vars, slot);
+
+ input_location = cur_loc;
+}
+
+
/* If TYPE has abstract virtual functions, issue an error about trying
to create an object of that type. DECL is the object declared, or
NULL_TREE if the declaration is unavailable. Returns 1 if an error
int
abstract_virtuals_error (tree decl, tree type)
{
- tree u;
- tree tu;
-
- if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type))
+ VEC (tree) *pure;
+
+ /* This function applies only to classes. Any other entity can never
+ be abstract. */
+ if (!CLASS_TYPE_P (type))
return 0;
+ /* If the type is incomplete, we register it within a hash table,
+ so that we can check again once it is completed. This makes sense
+ only for objects for which we have a declaration or at least a
+ name. */
+ if (!COMPLETE_TYPE_P (type))
+ {
+ void **slot;
+ struct pending_abstract_type *pat;
+
+ gcc_assert (!decl || DECL_P (decl)
+ || TREE_CODE (decl) == IDENTIFIER_NODE);
+
+ if (!abstract_pending_vars)
+ abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
+ &pat_compare, NULL);
+
+ slot = htab_find_slot_with_hash (abstract_pending_vars, type,
+ (hashval_t)TYPE_UID (type), INSERT);
+
+ pat = GGC_NEW (struct pending_abstract_type);
+ pat->type = type;
+ pat->decl = decl;
+ pat->locus = ((decl && DECL_P (decl))
+ ? DECL_SOURCE_LOCATION (decl)
+ : input_location);
+
+ pat->next = *slot;
+ *slot = pat;
+
+ return 0;
+ }
+
if (!TYPE_SIZE (type))
/* TYPE is being defined, and during that time
CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
return 0;
- if (dependent_type_p (type))
- /* For a dependent type, we do not yet know which functions are pure
- virtuals. */
+ pure = CLASSTYPE_PURE_VIRTUALS (type);
+ if (!pure)
return 0;
- u = CLASSTYPE_PURE_VIRTUALS (type);
if (decl)
{
if (TREE_CODE (decl) == RESULT_DECL)
return 0;
if (TREE_CODE (decl) == VAR_DECL)
- cp_error_at ("cannot declare variable `%+D' to be of abstract "
- "type `%T'", decl, type);
+ cp_error_at ("cannot declare variable %q+D to be of abstract "
+ "type %qT", decl, type);
else if (TREE_CODE (decl) == PARM_DECL)
- cp_error_at ("cannot declare parameter `%+D' to be of abstract "
- "type `%T'", decl, type);
+ cp_error_at ("cannot declare parameter %q+D to be of abstract "
+ "type %qT", decl, type);
else if (TREE_CODE (decl) == FIELD_DECL)
- cp_error_at ("cannot declare field `%+D' to be of abstract "
- "type `%T'", decl, type);
+ cp_error_at ("cannot declare field %q+D to be of abstract "
+ "type %qT", decl, type);
else if (TREE_CODE (decl) == FUNCTION_DECL
&& TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
- cp_error_at ("invalid abstract return type for member function `%+#D'",
+ cp_error_at ("invalid abstract return type for member function %q+#D",
decl);
else if (TREE_CODE (decl) == FUNCTION_DECL)
- cp_error_at ("invalid abstract return type for function `%+#D'",
+ cp_error_at ("invalid abstract return type for function %q+#D",
decl);
+ else if (TREE_CODE (decl) == IDENTIFIER_NODE)
+ /* Here we do not have location information, so use error instead
+ of cp_error_at. */
+ error ("invalid abstract type %qT for %qE", type, decl);
else
- cp_error_at ("invalid abstract type for `%+D'", decl);
+ cp_error_at ("invalid abstract type for %q+D", decl);
}
else
- error ("cannot allocate an object of abstract type `%T'", type);
+ error ("cannot allocate an object of abstract type %qT", type);
/* Only go through this once. */
- if (TREE_PURPOSE (u) == NULL_TREE)
+ if (VEC_length (tree, pure))
{
- TREE_PURPOSE (u) = error_mark_node;
-
+ unsigned ix;
+ tree fn;
+
inform ("%J because the following virtual functions are pure "
- "within `%T':", TYPE_MAIN_DECL (type), type);
-
- for (tu = u; tu; tu = TREE_CHAIN (tu))
- inform ("%J\t%#D", TREE_VALUE (tu), TREE_VALUE (tu));
+ "within %qT:", TYPE_MAIN_DECL (type), type);
+
+ for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
+ inform ("%J\t%#D", fn, fn);
+ /* Now truncate the vector. This leaves it non-null, so we know
+ there are pure virtuals, but empty so we don't list them out
+ again. */
+ VEC_truncate (tree, pure, 0);
}
else
- inform ("%J since type `%T' has pure virtual functions",
+ inform ("%J since type %qT has pure virtual functions",
TYPE_MAIN_DECL (type), type);
return 1;
|| TREE_CODE (value) == PARM_DECL
|| TREE_CODE (value) == FIELD_DECL))
{
- (*p_msg_at) ("`%D' has incomplete type", value);
+ (*p_msg_at) ("%qD has incomplete type", value);
decl = 1;
}
-retry:
+ retry:
/* We must print an error message. Be clever about what it says. */
switch (TREE_CODE (type))
case UNION_TYPE:
case ENUMERAL_TYPE:
if (!decl)
- (*p_msg) ("invalid use of undefined type `%#T'", type);
+ (*p_msg) ("invalid use of undefined type %q#T", type);
if (!TYPE_TEMPLATE_INFO (type))
- (*p_msg_at) ("forward declaration of `%#T'", type);
+ (*p_msg_at) ("forward declaration of %q#T", type);
else
- (*p_msg_at) ("declaration of `%#T'", type);
+ (*p_msg_at) ("declaration of %q#T", type);
break;
case VOID_TYPE:
- (*p_msg) ("invalid use of `%T'", type);
+ (*p_msg) ("invalid use of %qT", type);
break;
case ARRAY_TYPE:
case OFFSET_TYPE:
bad_member:
- (*p_msg) ("invalid use of member (did you forget the `&' ?)");
+ (*p_msg) ("invalid use of member (did you forget the %<&%> ?)");
break;
case TEMPLATE_TYPE_PARM:
if (value && TREE_CODE (value) == COMPONENT_REF)
goto bad_member;
else if (value && TREE_CODE (value) == ADDR_EXPR)
- (*p_msg) ("address of overloaded function with no contextual type information");
+ (*p_msg) ("address of overloaded function with no contextual "
+ "type information");
else if (value && TREE_CODE (value) == OVERLOAD)
(*p_msg) ("overloaded function with no contextual type information");
else
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
if (TREE_CODE (value) == CONSTRUCTOR)
{
if (array_type_p)
- sub = build (ARRAY_REF, inner_type, dest, field_index,
- NULL_TREE, NULL_TREE);
+ sub = build4 (ARRAY_REF, inner_type, dest, field_index,
+ NULL_TREE, NULL_TREE);
else
- sub = build (COMPONENT_REF, inner_type, dest, field_index,
- NULL_TREE);
+ sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
+ NULL_TREE);
split_nonconstant_init_1 (sub, value);
}
*pelt = TREE_CHAIN (elt);
if (array_type_p)
- sub = build (ARRAY_REF, inner_type, dest, field_index,
- NULL_TREE, NULL_TREE);
+ sub = build4 (ARRAY_REF, inner_type, dest, field_index,
+ NULL_TREE, NULL_TREE);
else
- sub = build (COMPONENT_REF, inner_type, dest, field_index,
- NULL_TREE);
+ sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
+ NULL_TREE);
- code = build (MODIFY_EXPR, inner_type, sub, value);
+ code = build2 (MODIFY_EXPR, inner_type, sub, value);
code = build_stmt (EXPR_STMT, code);
add_stmt (code);
continue;
if (!initializer_constant_valid_p (init, type))
{
CONSTRUCTOR_ELTS (init) = NULL;
- code = build (MODIFY_EXPR, type, dest, init);
+ code = build2 (MODIFY_EXPR, type, dest, init);
code = build_stmt (EXPR_STMT, code);
add_stmt (code);
}
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
TREE_READONLY (dest) = 0;
}
else
- code = build (INIT_EXPR, TREE_TYPE (dest), dest, init);
+ code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
return code;
}
if (IS_AGGR_TYPE (type))
{
- if (! TYPE_HAS_TRIVIAL_INIT_REF (type)
- && TREE_CODE (init) != CONSTRUCTOR)
- abort ();
+ gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
+ || TREE_CODE (init) == CONSTRUCTOR);
if (TREE_CODE (init) == TREE_LIST)
{
- error ("constructor syntax used, but no constructor declared for type `%T'", type);
+ error ("constructor syntax used, but no constructor declared "
+ "for type %qT", type);
init = build_constructor (NULL_TREE, nreverse (init));
}
}
/* Digest the specified initializer into an expression. */
value = digest_init (type, init, (tree *) 0);
-
- /* Store the expression if valid; else report error. */
-
- if (TREE_CODE (value) == ERROR_MARK)
- ;
- /* Other code expects that initializers for objects of types that need
- constructing never make it into DECL_INITIAL, and passes 'init' to
- build_aggr_init without checking DECL_INITIAL. So just return. */
- else if (TYPE_NEEDS_CONSTRUCTING (type))
- return build (INIT_EXPR, type, decl, value);
- else if (TREE_STATIC (decl)
- && (! TREE_CONSTANT (value)
- || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
+ /* If the initializer is not a constant, fill in DECL_INITIAL with
+ the bits that are constant, and then return an expression that
+ will perform the dynamic initialization. */
+ if (value != error_mark_node
+ && (TREE_SIDE_EFFECTS (value)
+ || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
return split_nonconstant_init (decl, value);
-
- /* Store the VALUE in DECL_INITIAL. If we're building a
- statement-tree we will actually expand the initialization later
- when we output this function. */
+ /* If the value is a constant, just put it in DECL_INITIAL. If DECL
+ is an automatic variable, the middle end will turn this into a
+ dynamic initialization later. */
DECL_INITIAL (decl) = value;
return NULL_TREE;
}
}
while (BRACE_ENCLOSED_INITIALIZER_P (init))
{
- pedwarn ("braces around scalar initializer for `%T'", type);
+ pedwarn ("braces around scalar initializer for %qT", type);
init = CONSTRUCTOR_ELTS (init);
if (TREE_CHAIN (init))
- pedwarn ("ignoring extra initializers for `%T'", type);
+ pedwarn ("ignoring extra initializers for %qT", type);
init = TREE_VALUE (init);
}
if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))
{
- error ("variable-sized object of type `%T' may not be initialized",
+ error ("variable-sized object of type %qT may not be initialized",
type);
return error_mark_node;
}
{
if (TYPE_NON_AGGREGATE_CLASS (type))
{
- error ("subobject of type `%T' must be initialized by constructor, not by `%E'",
+ error ("subobject of type %qT must be initialized by "
+ "constructor, not by %qE",
type, init);
return error_mark_node;
}
TREE_VALUE (tail), &tail1);
if (next1 == error_mark_node)
return next1;
- my_friendly_assert
- (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (type), TREE_TYPE (next1)),
- 981123);
- my_friendly_assert (tail1 == 0
- || TREE_CODE (tail1) == TREE_LIST, 319);
+ gcc_assert (same_type_ignoring_top_level_qualifiers_p
+ (TREE_TYPE (type), TREE_TYPE (next1)));
+ gcc_assert (!tail1 || TREE_CODE (tail1) == TREE_LIST);
if (tail == tail1 && len < 0)
{
error ("non-empty initializer for array of empty elements");
if (tail)
{
- if (TYPE_USES_VIRTUAL_BASECLASSES (type))
- {
- sorry ("initializer list for object of class with virtual base classes");
- return error_mark_node;
- }
-
- if (TYPE_BINFO_BASETYPES (type))
- {
- sorry ("initializer list for object of class with base classes");
- return error_mark_node;
- }
-
- if (TYPE_POLYMORPHIC_P (type))
- {
- sorry ("initializer list for object using virtual functions");
- return error_mark_node;
- }
+ gcc_assert (!CLASSTYPE_VBASECLASSES (type));
+ gcc_assert (!TYPE_BINFO (type)
+ || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
+ gcc_assert (!TYPE_POLYMORPHIC_P (type));
}
for (field = TYPE_FIELDS (type); field;
next1 = digest_init (TREE_TYPE (field),
TREE_VALUE (tail), &tail1);
- my_friendly_assert (tail1 == 0
- || TREE_CODE (tail1) == TREE_LIST, 320);
+ gcc_assert (!tail1 || TREE_CODE (tail1) == TREE_LIST);
tail = tail1;
}
else
next1 = digest_init (TREE_TYPE (field), next1, 0);
/* Warn when some struct elements are implicitly initialized. */
- if (extra_warnings
+ if (warn_missing_field_initializers
&& (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
- warning ("missing initializer for member `%D'", field);
+ warning ("missing initializer for member %qD", field);
}
else
{
if (TREE_READONLY (field))
- error ("uninitialized const member `%D'", field);
+ error ("uninitialized const member %qD", field);
else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
- error ("member `%D' with uninitialized const fields",
- field);
+ error ("member %qD with uninitialized const fields", field);
else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
- error ("member `%D' is uninitialized reference", field);
+ error ("member %qD is uninitialized reference", field);
/* Warn when some struct elements are implicitly initialized
to zero. */
- if (extra_warnings
+ if (warn_missing_field_initializers
&& (!init || BRACE_ENCLOSED_INITIALIZER_P (init)))
- warning ("missing initializer for member `%D'", field);
+ warning ("missing initializer for member %qD", field);
if (! zero_init_p (TREE_TYPE (field)))
next1 = build_zero_init (TREE_TYPE (field),
if (temp)
field = temp, win = 1;
else
- error ("no field `%D' in union being initialized",
- TREE_PURPOSE (tail));
+ error ("no field %qD in union being initialized",
+ TREE_PURPOSE (tail));
}
if (!win)
TREE_VALUE (tail) = error_mark_node;
}
else if (field == 0)
{
- error ("union `%T' with no named members cannot be initialized",
- type);
+ error ("union %qT with no named members cannot be initialized",
+ type);
TREE_VALUE (tail) = error_mark_node;
}
next1 = digest_init (TREE_TYPE (field),
TREE_VALUE (tail), &tail1);
- if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
- abort ();
+ gcc_assert (!tail1 || TREE_CODE (tail1) == TREE_LIST);
tail = tail1;
}
else
expr = build_non_dependent_expr (expr);
}
- if (TREE_CODE (type) == REFERENCE_TYPE)
- {
- expr = convert_from_reference (expr);
- type = TREE_TYPE (expr);
- }
-
if (IS_AGGR_TYPE (type))
{
while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
if (last_rval == NULL_TREE)
{
- error ("base operand of `->' has non-pointer type `%T'", type);
+ error ("base operand of %<->%> has non-pointer type %qT", type);
return error_mark_node;
}
}
if (types_memoized)
- error ("result of `operator->()' yields non-pointer result");
+ error ("result of %<operator->()%> yields non-pointer result");
else
- error ("base operand of `->' is not a pointer");
+ error ("base operand of %<->%> is not a pointer");
return error_mark_node;
}
tree objtype;
tree type;
tree binfo;
+ tree ctype;
datum = decay_conversion (datum);
ptrmem_type = TREE_TYPE (component);
if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
{
- error ("`%E' cannot be used as a member pointer, since it is of type `%T'",
+ error ("%qE cannot be used as a member pointer, since it is of "
+ "type %qT",
component, ptrmem_type);
return error_mark_node;
}
objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
if (! IS_AGGR_TYPE (objtype))
{
- error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'",
- component, datum, objtype);
+ error ("cannot apply member pointer %qE to %qE, which is of "
+ "non-aggregate type %qT",
+ component, datum, objtype);
return error_mark_node;
}
type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
- binfo = lookup_base (objtype, TYPE_PTRMEM_CLASS_TYPE (ptrmem_type),
- ba_check, NULL);
- if (!binfo)
+ ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
+
+ if (!COMPLETE_TYPE_P (ctype))
{
- error ("member type `%T::' incompatible with object type `%T'",
- type, objtype);
- return error_mark_node;
+ if (!same_type_p (ctype, objtype))
+ goto mismatch;
+ binfo = NULL;
+ }
+ else
+ {
+ binfo = lookup_base (objtype, ctype, ba_check, NULL);
+
+ if (!binfo)
+ {
+ mismatch:
+ error ("pointer to member type %qT incompatible with object "
+ "type %qT",
+ type, objtype);
+ return error_mark_node;
+ }
+ else if (binfo == error_mark_node)
+ return error_mark_node;
}
- else if (binfo == error_mark_node)
- return error_mark_node;
if (TYPE_PTRMEM_P (ptrmem_type))
{
type = cp_build_qualified_type (type,
(cp_type_quals (type)
| cp_type_quals (TREE_TYPE (datum))));
+
+ datum = build_address (datum);
+
+ /* Convert object to the correct base. */
+ if (binfo)
+ datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
+
/* Build an expression for "object + offset" where offset is the
value stored in the pointer-to-data-member. */
- datum = build (PLUS_EXPR, build_pointer_type (type),
- build_base_path (PLUS_EXPR, build_address (datum),
- binfo, 1),
- build_nop (ptrdiff_type_node, component));
+ datum = build2 (PLUS_EXPR, build_pointer_type (type),
+ datum, build_nop (ptrdiff_type_node, component));
return build_indirect_ref (datum, 0);
}
else
- return build (OFFSET_REF, type, datum, component);
+ return build2 (OFFSET_REF, type, datum, component);
}
/* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
}
exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
- TYPE_BINFO (type), LOOKUP_NORMAL);
+ type, LOOKUP_NORMAL);
if (exp == error_mark_node)
return error_mark_node;
if (spec == error_mark_node)
return list;
- my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317);
+ gcc_assert (spec && (!list || TREE_VALUE (list)));
/* [except.spec] 1, type in an exception specifier shall not be
incomplete, or pointer or ref to incomplete other than pointer
{
if (decl)
error
- ("call to function `%D' which throws incomplete type `%#T'",
+ ("call to function %qD which throws incomplete type %q#T",
decl, type);
else
- error ("call to function which throws incomplete type `%#T'",
+ error ("call to function which throws incomplete type %q#T",
decl);
}
}
}
+
+\f
+#include "gt-cp-typeck2.h"
OSDN Git Service
