type with the desired type. */
static int resolve_overloaded_unification PARAMS ((tree, tree, tree, tree,
- unification_kind_t, int));
+ unification_kind_t, int));
static int try_one_overload PARAMS ((tree, tree, tree, tree, tree,
- unification_kind_t, int));
+ unification_kind_t, int));
static int unify PARAMS ((tree, tree, tree, tree, int));
static void add_pending_template PARAMS ((tree));
static void reopen_tinst_level PARAMS ((tree));
static tree classtype_mangled_name PARAMS ((tree));
-static char *mangle_class_name_for_template PARAMS ((const char *, tree, tree));
+static char *mangle_class_name_for_template PARAMS ((const char *,
+ tree, tree));
static tree tsubst_initializer_list PARAMS ((tree, tree));
static int list_eq PARAMS ((tree, tree));
static tree get_class_bindings PARAMS ((tree, tree, tree));
-static tree coerce_template_parms PARAMS ((tree, tree, tree, int, int));
+static tree coerce_template_parms PARAMS ((tree, tree, tree,
+ tsubst_flags_t, int));
static void tsubst_enum PARAMS ((tree, tree, tree));
static tree add_to_template_args PARAMS ((tree, tree));
static tree add_outermost_template_args PARAMS ((tree, tree));
static int maybe_adjust_types_for_deduction PARAMS ((unification_kind_t, tree*,
- tree*));
+ tree*));
static int type_unification_real PARAMS ((tree, tree, tree, tree,
- int, unification_kind_t, int, int));
+ int, unification_kind_t, int, int));
static void note_template_header PARAMS ((int));
static tree maybe_fold_nontype_arg PARAMS ((tree));
static tree convert_nontype_argument PARAMS ((tree, tree));
-static tree convert_template_argument PARAMS ((tree, tree, tree, int,
- int , tree));
+static tree convert_template_argument PARAMS ((tree, tree, tree,
+ tsubst_flags_t, int, tree));
static tree get_bindings_overload PARAMS ((tree, tree, tree));
static int for_each_template_parm PARAMS ((tree, tree_fn_t, void*));
static tree build_template_parm_index PARAMS ((int, int, int, tree, tree));
static int template_decl_level PARAMS ((tree));
static tree maybe_get_template_decl_from_type_decl PARAMS ((tree));
static int check_cv_quals_for_unify PARAMS ((int, tree, tree));
-static tree tsubst_template_arg_vector PARAMS ((tree, tree, int));
-static tree tsubst_template_parms PARAMS ((tree, tree, int));
+static tree tsubst_template_arg_vector PARAMS ((tree, tree, tsubst_flags_t));
+static tree tsubst_template_parms PARAMS ((tree, tree, tsubst_flags_t));
static void regenerate_decl_from_template PARAMS ((tree, tree));
static tree most_specialized PARAMS ((tree, tree, tree));
static tree most_specialized_class PARAMS ((tree, tree));
static int template_class_depth_real PARAMS ((tree, int));
-static tree tsubst_aggr_type PARAMS ((tree, tree, int, tree, int));
-static tree tsubst_decl PARAMS ((tree, tree, tree));
-static tree tsubst_arg_types PARAMS ((tree, tree, int, tree));
-static tree tsubst_function_type PARAMS ((tree, tree, int, tree));
+static tree tsubst_aggr_type PARAMS ((tree, tree, tsubst_flags_t, tree, int));
+static tree tsubst_decl PARAMS ((tree, tree, tree, tsubst_flags_t));
+static tree tsubst_arg_types PARAMS ((tree, tree, tsubst_flags_t, tree));
+static tree tsubst_function_type PARAMS ((tree, tree, tsubst_flags_t, tree));
static void check_specialization_scope PARAMS ((void));
static tree process_partial_specialization PARAMS ((tree));
static void set_current_access_from_decl PARAMS ((tree));
static void check_default_tmpl_args PARAMS ((tree, tree, int, int));
-static tree tsubst_call_declarator_parms PARAMS ((tree, tree, int, tree));
+static tree tsubst_call_declarator_parms PARAMS ((tree, tree,
+ tsubst_flags_t, tree));
static tree get_template_base_recursive PARAMS ((tree, tree,
- tree, tree, tree, int));
+ tree, tree, tree, int));
static tree get_template_base PARAMS ((tree, tree, tree, tree));
static int verify_class_unification PARAMS ((tree, tree, tree));
static tree try_class_unification PARAMS ((tree, tree, tree, tree));
-static int coerce_template_template_parms PARAMS ((tree, tree, int,
- tree, tree));
+static int coerce_template_template_parms PARAMS ((tree, tree, tsubst_flags_t,
+ tree, tree));
static tree determine_specialization PARAMS ((tree, tree, tree *, int));
static int template_args_equal PARAMS ((tree, tree));
static void tsubst_default_arguments PARAMS ((tree));
static tree for_each_template_parm_r PARAMS ((tree *, int *, void *));
static tree copy_default_args_to_explicit_spec_1 PARAMS ((tree, tree));
static void copy_default_args_to_explicit_spec PARAMS ((tree));
-static int invalid_nontype_parm_type_p PARAMS ((tree, int));
+static int invalid_nontype_parm_type_p PARAMS ((tree, tsubst_flags_t));
/* Called once to initialize pt.c. */
else
fns = expr;
- fn = instantiate_type (type_pointed_to, fns, itf_none);
+ fn = instantiate_type (type_pointed_to, fns, tf_none);
if (fn == error_mark_node)
return error_mark_node;
set (_over.over_). */
tree fn;
- fn = instantiate_type (type_referred_to, expr, itf_none);
+ fn = instantiate_type (type_referred_to, expr, tf_none);
if (fn == error_mark_node)
return error_mark_node;
if (TREE_CODE (expr) != ADDR_EXPR)
return error_mark_node;
- expr = instantiate_type (type, expr, itf_none);
+ expr = instantiate_type (type, expr, tf_none);
if (expr == error_mark_node)
return error_mark_node;
coerce_template_template_parms (parm_parms, arg_parms, complain,
in_decl, outer_args)
tree parm_parms, arg_parms;
- int complain;
+ tsubst_flags_t complain;
tree in_decl, outer_args;
{
int nparms, nargs, i;
/* Convert the indicated template ARG as necessary to match the
indicated template PARM. Returns the converted ARG, or
- error_mark_node if the conversion was unsuccessful. Error messages
- are issued if COMPLAIN is non-zero. This conversion is for the Ith
- parameter in the parameter list. ARGS is the full set of template
- arguments deduced so far. */
+ error_mark_node if the conversion was unsuccessful. Error and
+ warning messages are issued under control of COMPLAIN. This
+ conversion is for the Ith parameter in the parameter list. ARGS is
+ the full set of template arguments deduced so far. */
static tree
convert_template_argument (parm, arg, args, complain, i, in_decl)
tree parm;
tree arg;
tree args;
- int complain;
+ tsubst_flags_t complain;
int i;
tree in_decl;
{
arg = make_typename_type (TREE_OPERAND (arg, 0),
TREE_OPERAND (arg, 1),
- complain);
+ complain & tf_error);
+ if (TREE_CODE (arg) == TYPE_DECL)
+ arg = TREE_TYPE (arg);
is_type = 1;
}
if (is_type != requires_type)
{
if (in_decl)
{
- if (complain)
+ if (complain & tf_error)
{
error ("type/value mismatch at argument %d in template parameter list for `%D'",
i + 1, in_decl);
}
if (is_tmpl_type ^ requires_tmpl_type)
{
- if (in_decl && complain)
+ if (in_decl && (complain & tf_error))
{
error ("type/value mismatch at argument %d in template parameter list for `%D'",
i + 1, in_decl);
}
else
{
- if (in_decl && complain)
+ if (in_decl && (complain & tf_error))
{
error ("type/value mismatch at argument %d in template parameter list for `%D'",
i + 1, in_decl);
if (val == NULL_TREE)
val = error_mark_node;
- else if (val == error_mark_node && complain)
+ else if (val == error_mark_node && (complain & tf_error))
error ("could not convert template argument `%E' to `%T'",
arg, t);
}
/* Convert all template arguments to their appropriate types, and
return a vector containing the innermost resulting template
- arguments. If any error occurs, return error_mark_node, and, if
- COMPLAIN is non-zero, issue an error message. Some error messages
- are issued even if COMPLAIN is zero; for instance, if a template
- argument is composed from a local class.
+ arguments. If any error occurs, return error_mark_node. Error and
+ warning messages are issued under control of COMPLAIN. Some error
+ messages are issued even if COMPLAIN is zero; for instance, if a
+ template argument is composed from a local class.
If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
provided in ARGLIST, or else trailing parameters must have default
require_all_arguments)
tree parms, args;
tree in_decl;
- int complain;
+ tsubst_flags_t complain;
int require_all_arguments;
{
int nparms, nargs, i, lost = 0;
&& require_all_arguments
&& TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
{
- if (complain)
+ if (complain & tf_error)
{
error ("wrong number of template arguments (%d, should be %d)",
nargs, nparms);
If ENTERING_SCOPE is non-zero, we are about to enter the scope of
the class we are looking up.
- If COMPLAIN is non-zero, issue error messages.
+ Issue error and warning messages under control of COMPLAIN.
If the template class is really a local class in a template
function, then the FUNCTION_CONTEXT is the function in which it is
tree in_decl;
tree context;
int entering_scope;
- int complain;
+ tsubst_flags_t complain;
{
tree template = NULL_TREE, parmlist;
tree t;
crash. Alternatively D1 might not be a template type at all. */
if (! template)
{
- if (complain)
+ if (complain & tf_error)
error ("`%T' is not a template", d1);
return error_mark_node;
}
&& !DECL_TEMPLATE_PARM_P (template)
&& !PRIMARY_TEMPLATE_P (template)))
{
- if (complain)
+ if (complain & tf_error)
{
error ("non-template type `%T' used as a template", d1);
if (in_decl)
}
context = tsubst (DECL_CONTEXT (template), arglist,
- /*complain=*/0, in_decl);
+ complain, in_decl);
if (!context)
context = global_namespace;
Create the partial instantiation.
*/
TREE_VEC_LENGTH (arglist)--;
- found = tsubst (template, arglist, /*complain=*/0, NULL_TREE);
+ found = tsubst (template, arglist, complain, NULL_TREE);
TREE_VEC_LENGTH (arglist)++;
}
}
current cless with same name. */
push_nested_namespace (ns);
fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
- /*complain=*/1, NULL_TREE);
+ tf_error | tf_warning, NULL_TREE);
pop_nested_namespace (ns);
arglist = tsubst (DECL_TI_ARGS (decl), args,
- /*complain=*/1, NULL_TREE);
+ tf_error | tf_warning, NULL_TREE);
template_id = lookup_template_function (fns, arglist);
- new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE);
+ new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
tmpl = determine_specialization (template_id, new_friend,
&new_args,
/*need_member_template=*/0);
goto done;
}
- new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE);
+ new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
/* The NEW_FRIEND will look like an instantiation, to the
compiler, but is not an instantiation from the point of view of
at. */
tree parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
- args, /*complain=*/1);
+ args, tf_error | tf_warning);
if (!parms)
return error_mark_node;
redeclare_class_template (TREE_TYPE (tmpl), parms);
/* The friend template has not already been declared. In this
case, the instantiation of the template class will cause the
injection of this template into the global scope. */
- tmpl = tsubst (friend_tmpl, args, /*complain=*/1, NULL_TREE);
+ tmpl = tsubst (friend_tmpl, args, tf_error | tf_warning, NULL_TREE);
/* The new TMPL is not an instantiation of anything, so we
forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
pbase = TREE_VEC_ELT (pbases, i);
/* Substitute to figure out the base class. */
- base = tsubst (BINFO_TYPE (pbase), args,
- /*complain=*/1, NULL_TREE);
+ base = tsubst (BINFO_TYPE (pbase), args, tf_error, NULL_TREE);
if (base == error_mark_node)
continue;
tree name = TYPE_IDENTIFIER (tag);
tree newtag;
- newtag = tsubst (tag, args, /*complain=*/1, NULL_TREE);
+ newtag = tsubst (tag, args, tf_error, NULL_TREE);
my_friendly_assert (newtag != error_mark_node, 20010206);
if (TREE_CODE (newtag) != ENUMERAL_TYPE)
{
lineno = DECL_SOURCE_LINE (t);
input_filename = DECL_SOURCE_FILE (t);
- r = tsubst (t, args, /*complain=*/1, NULL_TREE);
+ r = tsubst (t, args, tf_error | tf_warning, NULL_TREE);
if (TREE_CODE (r) == VAR_DECL)
{
tree init;
if (DECL_INITIALIZED_IN_CLASS_P (r))
init = tsubst_expr (DECL_INITIAL (t), args,
- /*complain=*/1, NULL_TREE);
+ tf_error | tf_warning, NULL_TREE);
else
init = NULL_TREE;
for this instantiation. */
for (t = TYPE_METHODS (pattern); t; t = TREE_CHAIN (t))
{
- tree r = tsubst (t, args, /*complain=*/1, NULL_TREE);
+ tree r = tsubst (t, args, tf_error, NULL_TREE);
set_current_access_from_decl (r);
grok_special_member_properties (r);
finish_member_declaration (r);
if (TREE_CODE (friend_type) == TEMPLATE_DECL)
new_friend_type = tsubst_friend_class (friend_type, args);
else if (uses_template_parms (friend_type))
- new_friend_type = tsubst (friend_type, args, /*complain=*/1,
- NULL_TREE);
+ new_friend_type = tsubst (friend_type, args,
+ tf_error | tf_warning, NULL_TREE);
else
{
tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
tsubst_template_arg_vector (t, args, complain)
tree t;
tree args;
- int complain;
+ tsubst_flags_t complain;
{
int len = TREE_VEC_LENGTH (t), need_new = 0, i;
tree *elts = (tree *) alloca (len * sizeof (tree));
tsubst_template_parms (parms, args, complain)
tree parms;
tree args;
- int complain;
+ tsubst_flags_t complain;
{
tree r = NULL_TREE;
tree* new_parms;
tsubst_aggr_type (t, args, complain, in_decl, entering_scope)
tree t;
tree args;
- int complain;
+ tsubst_flags_t complain;
tree in_decl;
int entering_scope;
{
r = lookup_template_class (t, argvec, in_decl, context,
entering_scope, complain);
- return cp_build_qualified_type_real (r, TYPE_QUALS (t),
- complain);
+ return cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
}
else
/* This is not a template type, so there's nothing to do. */
if (DECL_CLASS_SCOPE_P (fn))
pushclass (DECL_CONTEXT (fn), 2);
- arg = tsubst_expr (arg, DECL_TI_ARGS (fn), /*complain=*/1, NULL_TREE);
+ arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
+ tf_error | tf_warning, NULL_TREE);
if (DECL_CLASS_SCOPE_P (fn))
popclass ();
/* Substitute the ARGS into the T, which is a _DECL. TYPE is the
(already computed) substitution of ARGS into TREE_TYPE (T), if
- appropriate. Return the result of the substitution. */
+ appropriate. Return the result of the substitution. Issue error
+ and warning messages under control of COMPLAIN. */
static tree
-tsubst_decl (t, args, type)
+tsubst_decl (t, args, type, complain)
tree t;
tree args;
tree type;
+ tsubst_flags_t complain;
{
int saved_lineno;
const char *saved_filename;
tree r = NULL_TREE;
tree in_decl = t;
+ my_friendly_assert (complain & tf_error, 20011214);
+
/* Set the filename and linenumber to improve error-reporting. */
saved_lineno = lineno;
saved_filename = input_filename;
tree full_args;
full_args = tsubst_template_arg_vector (tmpl_args, args,
- /*complain=*/1);
+ complain);
/* tsubst_template_arg_vector doesn't copy the vector if
nothing changed. But, *something* should have
if (is_template_template_parm)
{
- tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl);
+ tree new_decl = tsubst (decl, args, complain, in_decl);
DECL_TEMPLATE_RESULT (r) = new_decl;
TREE_TYPE (r) = TREE_TYPE (new_decl);
break;
DECL_CONTEXT (r)
= tsubst_aggr_type (DECL_CONTEXT (t), args,
- /*complain=*/1, in_decl,
+ complain, in_decl,
/*entering_scope=*/1);
DECL_VIRTUAL_CONTEXT (r)
= tsubst_aggr_type (DECL_VIRTUAL_CONTEXT (t), args,
- /*complain=*/1, in_decl,
+ complain, in_decl,
/*entering_scope=*/1);
DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
if (TREE_CODE (decl) == TYPE_DECL)
{
- tree new_type = tsubst (TREE_TYPE (t), args,
- /*complain=*/1, in_decl);
+ tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
TREE_TYPE (r) = new_type;
CLASSTYPE_TI_TEMPLATE (new_type) = r;
DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
}
else
{
- tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl);
+ tree new_decl = tsubst (decl, args, complain, in_decl);
DECL_TEMPLATE_RESULT (r) = new_decl;
DECL_TI_TEMPLATE (new_decl) = r;
outermost level of parameters. */
DECL_TEMPLATE_PARMS (r)
= tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
- /*complain=*/1);
+ complain);
if (PRIMARY_TEMPLATE_P (t))
DECL_PRIMARY_TEMPLATE (r) = r;
argvec
= tsubst_template_arg_vector (DECL_TI_ARGS
(DECL_TEMPLATE_RESULT (gen_tmpl)),
- args, /*complain=*/1);
+ args, complain);
/* Check to see if we already have this specialization. */
spec = retrieve_specialization (gen_tmpl, argvec);
else
member = 1;
ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
- /*complain=*/1, t,
+ complain, t,
/*entering_scope=*/1);
}
else
member = 0;
ctx = DECL_CONTEXT (t);
}
- type = tsubst (type, args, /*complain=*/1, in_decl);
+ type = tsubst (type, args, complain, in_decl);
if (type == error_mark_node)
return error_mark_node;
DECL_CONTEXT (r) = ctx;
DECL_VIRTUAL_CONTEXT (r)
= tsubst_aggr_type (DECL_VIRTUAL_CONTEXT (t), args,
- /*complain=*/1, t,
+ complain, t,
/*entering_scope=*/1);
if (member && DECL_CONV_FN_P (r))
DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
- /*complain=*/1, t);
+ complain, t);
DECL_RESULT (r) = NULL_TREE;
TREE_STATIC (r) = 0;
if (DECL_CLONED_FUNCTION (r))
{
DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
- args, /*complain=*/1, t);
+ args, complain, t);
TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
}
{
*friends = copy_node (*friends);
TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
- args, /*complain=*/1,
+ args, complain,
in_decl);
}
DECL_INITIAL (r) = TREE_TYPE (r);
else
DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
- /*complain=*/1, in_decl);
+ complain, in_decl);
DECL_CONTEXT (r) = NULL_TREE;
if (!DECL_TEMPLATE_PARM_P (r) && PROMOTE_PROTOTYPES
DECL_ARG_TYPE (r) = integer_type_node;
if (TREE_CHAIN (t))
TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
- /*complain=*/1, TREE_CHAIN (t));
+ complain, TREE_CHAIN (t));
}
break;
/* We don't have to set DECL_CONTEXT here; it is set by
finish_member_declaration. */
DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
- /*complain=*/1, in_decl);
+ complain, in_decl);
TREE_CHAIN (r) = NULL_TREE;
if (VOID_TYPE_P (type))
cp_error_at ("instantiation of `%D' as type `%T'", r, type);
{
r = copy_node (t);
DECL_INITIAL (r)
- = tsubst_copy (DECL_INITIAL (t), args, /*complain=*/1, in_decl);
+ = tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
TREE_CHAIN (r) = NULL_TREE;
}
break;
if (TYPE_P (CP_DECL_CONTEXT (t)))
ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
- /*complain=*/1,
+ complain,
in_decl, /*entering_scope=*/1);
else if (DECL_NAMESPACE_SCOPE_P (t))
ctx = DECL_CONTEXT (t);
{
tmpl = DECL_TI_TEMPLATE (t);
gen_tmpl = most_general_template (tmpl);
- argvec = tsubst (DECL_TI_ARGS (t), args, /*complain=*/1, in_decl);
+ argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
spec = retrieve_specialization (gen_tmpl, argvec);
}
else
tsubst_arg_types (arg_types, args, complain, in_decl)
tree arg_types;
tree args;
- int complain;
+ tsubst_flags_t complain;
tree in_decl;
{
tree remaining_arg_types;
return error_mark_node;
if (VOID_TYPE_P (type))
{
- if (complain)
+ if (complain & tf_error)
{
error ("invalid parameter type `%T'", type);
if (in_decl)
tsubst_function_type (t, args, complain, in_decl)
tree t;
tree args;
- int complain;
+ tsubst_flags_t complain;
tree in_decl;
{
tree return_type;
-- Attempting to create "pointer to member of T" when T
is not a class type. */
- if (complain)
+ if (complain & tf_error)
error ("creating pointer to member function of non-class type `%T'",
r);
return error_mark_node;
fntype = build_cplus_method_type (r, return_type, TREE_CHAIN
(arg_types));
}
- fntype = build_qualified_type (fntype, TYPE_QUALS (t));
+ fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
fntype = build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
return fntype;
tsubst_call_declarator_parms (parms, args, complain, in_decl)
tree parms;
tree args;
- int complain;
+ tsubst_flags_t complain;
tree in_decl;
{
tree new_parms;
/* Take the tree structure T and replace template parameters used
therein with the argument vector ARGS. IN_DECL is an associated
decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
- An appropriate error message is issued only if COMPLAIN is
- non-zero. Note that we must be relatively non-tolerant of
- extensions here, in order to preserve conformance; if we allow
- substitutions that should not be allowed, we may allow argument
- deductions that should not succeed, and therefore report ambiguous
- overload situations where there are none. In theory, we could
- allow the substitution, but indicate that it should have failed,
- and allow our caller to make sure that the right thing happens, but
- we don't try to do this yet.
+ Issue error and warning messages under control of COMPLAIN. Note
+ that we must be relatively non-tolerant of extensions here, in
+ order to preserve conformance; if we allow substitutions that
+ should not be allowed, we may allow argument deductions that should
+ not succeed, and therefore report ambiguous overload situations
+ where there are none. In theory, we could allow the substitution,
+ but indicate that it should have failed, and allow our caller to
+ make sure that the right thing happens, but we don't try to do this
+ yet.
This function is used for dealing with types, decls and the like;
for expressions, use tsubst_expr or tsubst_copy. */
tree
tsubst (t, args, complain, in_decl)
tree t, args;
- int complain;
+ tsubst_flags_t complain;
tree in_decl;
{
tree type, r;
return error_mark_node;
if (DECL_P (t))
- return tsubst_decl (t, args, type);
+ return tsubst_decl (t, args, type, complain);
switch (TREE_CODE (t))
{
Attempting to create an array with a size that is
zero or negative. */
- if (complain)
+ if (complain & tf_error)
error ("creating array with size zero (`%E')", max);
return error_mark_node;
DECL_CONTEXT (arg),
/*entering_scope=*/0,
complain);
- return cp_build_qualified_type_real (r,
- TYPE_QUALS (t),
- complain);
+ return cp_build_qualified_type_real
+ (r, TYPE_QUALS (t), complain);
}
else
/* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
if (cp_type_quals (t))
{
r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
- r = cp_build_qualified_type_real (r, cp_type_quals (t),
- complain);
+ r = cp_build_qualified_type_real
+ (r, cp_type_quals (t), complain);
}
else
{
/* We keep track of the last time we issued this error
message to avoid spewing a ton of messages during a
single bad template instantiation. */
- if (complain && (last_line != lineno ||
- last_file != input_filename))
+ if (complain & tf_error
+ && (last_line != lineno || last_file != input_filename))
{
if (TREE_CODE (type) == VOID_TYPE)
error ("forming reference to void");
-- Attempting to create "pointer to member of T" when T
is not a class type. */
- if (complain)
- error ("creating pointer to member of non-class type `%T'",
- r);
+ if (complain & tf_error)
+ error ("creating pointer to member of non-class type `%T'", r);
return error_mark_node;
}
if (TREE_CODE (type) == REFERENCE_TYPE)
|| TREE_CODE (type) == FUNCTION_TYPE
|| TREE_CODE (type) == REFERENCE_TYPE)
{
- if (complain)
+ if (complain & tf_error)
error ("creating array of `%T'", type);
return error_mark_node;
}
case PLUS_EXPR:
case MINUS_EXPR:
{
- tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
- in_decl);
- tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain,
- in_decl);
+ tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
+ tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
if (e1 == error_mark_node || e2 == error_mark_node)
return error_mark_node;
case NEGATE_EXPR:
case NOP_EXPR:
{
- tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
- in_decl);
+ tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
if (e == error_mark_node)
return error_mark_node;
if (!IS_AGGR_TYPE (ctx))
{
- if (complain)
+ if (complain & tf_error)
error ("`%T' is not a class, struct, or union type",
ctx);
return error_mark_node;
ctx = complete_type (ctx);
if (!COMPLETE_TYPE_P (ctx))
{
- if (complain)
+ if (complain & tf_error)
incomplete_type_error (NULL_TREE, ctx);
return error_mark_node;
}
}
- f = make_typename_type (ctx, f, complain);
+ f = make_typename_type (ctx, f, complain & tf_error);
if (f == error_mark_node)
return f;
- return cp_build_qualified_type_real (f,
- cp_type_quals (f)
- | cp_type_quals (t),
- complain);
+ return cp_build_qualified_type_real
+ (f, cp_type_quals (f) | cp_type_quals (t), complain);
}
-
+
case UNBOUND_CLASS_TEMPLATE:
{
tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
case INDIRECT_REF:
{
- tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
- in_decl);
+ tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
if (e == error_mark_node)
return error_mark_node;
return make_pointer_declarator (type, e);
case ADDR_EXPR:
{
- tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
- in_decl);
+ tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
if (e == error_mark_node)
return error_mark_node;
return make_reference_declarator (type, e);
case ARRAY_REF:
{
- tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
- in_decl);
- tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain,
- in_decl);
+ tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
+ tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
if (e1 == error_mark_node || e2 == error_mark_node)
return error_mark_node;
case CALL_EXPR:
{
- tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
- in_decl);
+ tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
tree e2 = (tsubst_call_declarator_parms
(CALL_DECLARATOR_PARMS (t), args, complain, in_decl));
tree e3 = tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t), args,
case SCOPE_REF:
{
- tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
- in_decl);
+ tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
if (e1 == error_mark_node || e2 == error_mark_node)
return error_mark_node;
case TYPEOF_TYPE:
{
- tree e1 = tsubst_expr (TYPE_FIELDS (t), args, complain,
- in_decl);
+ tree e1 = tsubst_expr (TYPE_FIELDS (t), args, complain, in_decl);
if (e1 == error_mark_node)
return error_mark_node;
tree
tsubst_copy (t, args, complain, in_decl)
tree t, args;
- int complain;
+ tsubst_flags_t complain;
tree in_decl;
{
enum tree_code code;
if (!processing_template_decl)
{
tree stmt_expr = begin_stmt_expr ();
- tsubst_expr (STMT_EXPR_STMT (t), args,
- complain, in_decl);
+ tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl);
return finish_stmt_expr (stmt_expr);
}
case VA_ARG_EXPR:
return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
- in_decl),
- tsubst (TREE_TYPE (t), args, complain, in_decl));
+ in_decl),
+ tsubst (TREE_TYPE (t), args, complain, in_decl));
default:
return t;
tree
tsubst_expr (t, args, complain, in_decl)
tree t, args;
- int complain;
+ tsubst_flags_t complain;
tree in_decl;
{
tree stmt, tmp;
prep_stmt (t);
finish_named_return_value
(TREE_OPERAND (t, 0),
- tsubst_expr (TREE_OPERAND (t, 1), args, /*complain=*/1, in_decl));
+ tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl));
break;
case CTOR_INITIALIZER:
stmt = begin_for_stmt ();
tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
finish_for_init_stmt (stmt);
- finish_for_cond (tsubst_expr (FOR_COND (t), args,
- complain, in_decl),
+ finish_for_cond (tsubst_expr (FOR_COND (t),
+ args, complain, in_decl),
stmt);
tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
finish_for_expr (tmp, stmt);
stmt = begin_do_stmt ();
tsubst_expr (DO_BODY (t), args, complain, in_decl);
finish_do_body (stmt);
- finish_do_stmt (tsubst_expr (DO_COND (t), args,
- complain, in_decl),
+ finish_do_stmt (tsubst_expr (DO_COND (t),
+ args, complain, in_decl),
stmt);
}
break;
/* substitute template parameters */
fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
- targ_ptr, /*complain=*/1, gen_tmpl);
+ targ_ptr, tf_error, gen_tmpl);
/* The DECL_TI_TEMPLATE should always be the immediate parent
template, not the most general template. */
DECL_TI_TEMPLATE (fndecl) = tmpl;
converted_args
= (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
- explicit_targs, NULL_TREE, /*complain=*/0,
+ explicit_targs, NULL_TREE, tf_none,
/*require_all_arguments=*/0));
if (converted_args == error_mark_node)
return 1;
- fntype = tsubst (fntype, converted_args, /*complain=*/0, NULL_TREE);
+ fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
if (fntype == error_mark_node)
return 1;
the corresponding deduced argument values. If the
substitution results in an invalid type, as described above,
type deduction fails. */
- if (tsubst (TREE_TYPE (fn), targs, /*complain=*/0, NULL_TREE)
+ if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
== error_mark_node)
return 1;
expl_subargs);
if (subargs)
{
- elem = tsubst (TREE_TYPE (fn), subargs, /*complain=*/0,
- NULL_TREE);
+ elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
if (TREE_CODE (elem) == METHOD_TYPE)
elem = build_ptrmemfunc_type (build_pointer_type (elem));
good += try_one_overload (tparms, targs, tempargs, parm, elem,
int i;
int nparms = TREE_VEC_LENGTH (parms);
tree new_parms = tsubst (parms, add_outermost_template_args (args, targs),
- /*complain=*/0, NULL_TREE);
+ tf_none, NULL_TREE);
if (new_parms == error_mark_node)
return 1;
/* Consider the case where ARG is `const volatile int' and
PARM is `const T'. Then, T should be `volatile int'. */
- arg =
- cp_build_qualified_type_real (arg,
- cp_type_quals (arg)
- & ~cp_type_quals (parm),
- /*complain=*/0);
+ arg = cp_build_qualified_type_real
+ (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
if (arg == error_mark_node)
return 1;
converted_args
= (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
explicit_args, NULL_TREE,
- /*complain=*/0,
- /*require_all_arguments=*/0));
+ tf_none, /*require_all_arguments=*/0));
if (converted_args == error_mark_node)
return NULL_TREE;
- decl_type = tsubst (decl_type, converted_args, /*complain=*/0,
- NULL_TREE);
+ decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
if (decl_type == error_mark_node)
return NULL_TREE;
}
void
do_type_instantiation (t, storage, complain)
tree t, storage;
- int complain;
+ tsubst_flags_t complain;
{
int extern_p = 0;
int nomem_p = 0;
if (!COMPLETE_TYPE_P (t))
{
- if (complain)
+ if (complain & tf_error)
error ("explicit instantiation of `%#T' before definition of template",
t);
return;
No program shall both explicitly instantiate and explicitly
specialize a template. */
- if (complain)
+ if (complain & tf_error)
{
error ("explicit instantiation of `%#T' after", t);
cp_error_at ("explicit specialization here", t);
are we already got marked as an explicit instantiation because of the
repo file. All these cases are OK. */
if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository
- && complain)
+ && (complain & tf_error))
pedwarn ("duplicate explicit instantiation of `%#T'", t);
/* If we've already instantiated the template, just return now. */
pushclass (DECL_CONTEXT (decl), 2);
/* Do the substitution to get the new declaration. */
- new_decl = tsubst (code_pattern, args, /*complain=*/1, NULL_TREE);
+ new_decl = tsubst (code_pattern, args, tf_error, NULL_TREE);
if (TREE_CODE (decl) == VAR_DECL)
{
/* Set up DECL_INITIAL, since tsubst doesn't. */
DECL_INITIAL (new_decl) =
tsubst_expr (DECL_INITIAL (code_pattern), args,
- /*complain=*/1, DECL_TI_TEMPLATE (decl));
+ tf_error, DECL_TI_TEMPLATE (decl));
/* Pop the class context we pushed above. */
popclass ();
}
/* Substitute into the body of the function. */
tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
- /*complain=*/1, tmpl);
+ tf_error | tf_warning, tmpl);
/* We don't need the local specializations any more. */
htab_delete (local_specializations);
tree init;
tree val;
- decl = tsubst_copy (TREE_PURPOSE (t), argvec, /*complain=*/1,
+ decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_error | tf_warning,
NULL_TREE);
- init = tsubst_expr (TREE_VALUE (t), argvec, /*complain=*/1,
+ init = tsubst_expr (TREE_VALUE (t), argvec, tf_error | tf_warning,
NULL_TREE);
if (!init)
/* Note that in a template enum, the TREE_VALUE is the
CONST_DECL, not the corresponding INTEGER_CST. */
value = tsubst_expr (DECL_INITIAL (TREE_VALUE (e)),
- args, /*complain=*/1,
+ args, tf_error | tf_warning,
NULL_TREE);
/* Give this enumeration constant the correct access. */
/* Now, do the (partial) substitution to figure out the
appropriate function type. */
- fn_type = tsubst (fn_type, partial_args, /*complain=*/1, NULL_TREE);
+ fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
if (DECL_STATIC_FUNCTION_P (decl))
- context = tsubst (context, partial_args, /*complain=*/1, NULL_TREE);
+ context = tsubst (context, partial_args, tf_error, NULL_TREE);
/* Substitute into the template parameters to obtain the real
innermost set of parameters. This step is important if the
innermost set of template parameters contains value
parameters whose types depend on outer template parameters. */
TREE_VEC_LENGTH (partial_args)--;
- tparms = tsubst_template_parms (tparms, partial_args, /*complain=*/1);
+ tparms = tsubst_template_parms (tparms, partial_args, tf_error);
}
if (contextp)
}
/* [temp.param] Check that template non-type parm TYPE is of an allowable
- type. Return zero for ok, non-zero for disallowed. If COMPLAIN is
- non-zero, then complain. */
+ type. Return zero for ok, non-zero for disallowed. Issue error and
+ warning messages under control of COMPLAIN. */
static int
invalid_nontype_parm_type_p (type, complain)
tree type;
- int complain;
+ tsubst_flags_t complain;
{
if (INTEGRAL_TYPE_P (type))
return 0;
else if (TREE_CODE (type) == TYPENAME_TYPE)
return 0;
- if (complain)
+ if (complain & tf_error)
error ("`%#T' is not a valid type for a template constant parameter",
type);
return 1;
OSDN Git Service
