diff options
Diffstat (limited to 'contrib/gcc/cp/pt.c')
| -rw-r--r-- | contrib/gcc/cp/pt.c | 9876 |
1 files changed, 0 insertions, 9876 deletions
diff --git a/contrib/gcc/cp/pt.c b/contrib/gcc/cp/pt.c deleted file mode 100644 index 28c295695e44..000000000000 --- a/contrib/gcc/cp/pt.c +++ /dev/null @@ -1,9876 +0,0 @@ -/* Handle parameterized types (templates) for GNU C++. - Copyright (C) 1992, 93-97, 1998, 1999 Free Software Foundation, Inc. - Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing. - Rewritten by Jason Merrill (jason@cygnus.com). - -This file is part of GNU CC. - -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ - -/* Known bugs or deficiencies include: - - all methods must be provided in header files; can't use a source - file that contains only the method templates and "just win". */ - -#include "config.h" -#include "system.h" -#include "obstack.h" - -#include "tree.h" -#include "flags.h" -#include "cp-tree.h" -#include "decl.h" -#include "parse.h" -#include "lex.h" -#include "output.h" -#include "defaults.h" -#include "except.h" -#include "toplev.h" -#include "rtl.h" -#include "varray.h" - -/* The type of functions taking a tree, and some additional data, and - returning an int. */ -typedef int (*tree_fn_t) PROTO((tree, void*)); - -extern struct obstack permanent_obstack; - -extern int lineno; -extern char *input_filename; - -tree current_template_parms; -HOST_WIDE_INT processing_template_decl; - -/* The PENDING_TEMPLATES is a TREE_LIST of templates whose - instantiations have been deferred, either because their definitions - were not yet available, or because we were putting off doing the - work. The TREE_PURPOSE of each entry is a SRCLOC indicating where - the instantiate request occurred; the TREE_VALUE is a either a DECL - (for a function or static data member), or a TYPE (for a class) - indicating what we are hoping to instantiate. */ -static tree pending_templates; -static tree *template_tail = &pending_templates; - -static tree maybe_templates; -static tree *maybe_template_tail = &maybe_templates; - -int minimal_parse_mode; - -int processing_specialization; -int processing_explicit_instantiation; -int processing_template_parmlist; -static int template_header_count; - -static tree saved_trees; -static varray_type inline_parm_levels; -static size_t inline_parm_levels_used; - -#define obstack_chunk_alloc xmalloc -#define obstack_chunk_free free - -#define UNIFY_ALLOW_NONE 0 -#define UNIFY_ALLOW_MORE_CV_QUAL 1 -#define UNIFY_ALLOW_LESS_CV_QUAL 2 -#define UNIFY_ALLOW_DERIVED 4 -#define UNIFY_ALLOW_INTEGER 8 - -#define GTB_VIA_VIRTUAL 1 /* The base class we are examining is - virtual, or a base class of a virtual - base. */ -#define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current - type with the desired type. */ - -static int resolve_overloaded_unification PROTO((tree, tree, tree, tree, - unification_kind_t, int)); -static int try_one_overload PROTO((tree, tree, tree, tree, tree, - unification_kind_t, int)); -static int unify PROTO((tree, tree, tree, tree, int)); -static void add_pending_template PROTO((tree)); -static int push_tinst_level PROTO((tree)); -static tree classtype_mangled_name PROTO((tree)); -static char *mangle_class_name_for_template PROTO((char *, tree, tree)); -static tree tsubst_expr_values PROTO((tree, tree)); -static int list_eq PROTO((tree, tree)); -static tree get_class_bindings PROTO((tree, tree, tree)); -static tree coerce_template_parms PROTO((tree, tree, tree, int, int)); -static void tsubst_enum PROTO((tree, tree, tree)); -static tree add_to_template_args PROTO((tree, tree)); -static tree add_outermost_template_args PROTO((tree, tree)); -static void maybe_adjust_types_for_deduction PROTO((unification_kind_t, tree*, - tree*)); -static int type_unification_real PROTO((tree, tree, tree, tree, - int, unification_kind_t, int)); -static void note_template_header PROTO((int)); -static tree maybe_fold_nontype_arg PROTO((tree)); -static tree convert_nontype_argument PROTO((tree, tree)); -static tree convert_template_argument PROTO ((tree, tree, tree, int, - int , tree)); -static tree get_bindings_overload PROTO((tree, tree, tree)); -static int for_each_template_parm PROTO((tree, tree_fn_t, void*)); -static tree build_template_parm_index PROTO((int, int, int, tree, tree)); -static int inline_needs_template_parms PROTO((tree)); -static void push_inline_template_parms_recursive PROTO((tree, int)); -static tree retrieve_specialization PROTO((tree, tree)); -static tree register_specialization PROTO((tree, tree, tree)); -static int unregister_specialization PROTO((tree, tree)); -static tree reduce_template_parm_level PROTO((tree, tree, int)); -static tree build_template_decl PROTO((tree, tree)); -static int mark_template_parm PROTO((tree, void *)); -static tree tsubst_friend_function PROTO((tree, tree)); -static tree tsubst_friend_class PROTO((tree, tree)); -static tree get_bindings_real PROTO((tree, tree, tree, int)); -static int template_decl_level PROTO((tree)); -static tree maybe_get_template_decl_from_type_decl PROTO((tree)); -static int check_cv_quals_for_unify PROTO((int, tree, tree)); -static tree tsubst_template_arg_vector PROTO((tree, tree, int)); -static tree tsubst_template_parms PROTO((tree, tree, int)); -static void regenerate_decl_from_template PROTO((tree, tree)); -static tree most_specialized PROTO((tree, tree, tree)); -static tree most_specialized_class PROTO((tree, tree)); -static tree most_general_template PROTO((tree)); -static void set_mangled_name_for_template_decl PROTO((tree)); -static int template_class_depth_real PROTO((tree, int)); -static tree tsubst_aggr_type PROTO((tree, tree, int, tree, int)); -static tree tsubst_decl PROTO((tree, tree, tree, tree)); -static tree tsubst_arg_types PROTO((tree, tree, int, tree)); -static tree tsubst_function_type PROTO((tree, tree, int, tree)); -static void check_specialization_scope PROTO((void)); -static tree process_partial_specialization PROTO((tree)); -static void set_current_access_from_decl PROTO((tree)); -static void check_default_tmpl_args PROTO((tree, tree, int, int)); -static tree tsubst_call_declarator_parms PROTO((tree, tree, int, tree)); -static tree get_template_base_recursive PROTO((tree, tree, - tree, tree, tree, int)); -static tree get_template_base PROTO((tree, tree, tree, tree)); -static tree try_class_unification PROTO((tree, tree, tree, tree)); -static int coerce_template_template_parms PROTO((tree, tree, int, - tree, tree)); -static tree determine_specialization PROTO((tree, tree, tree *, int)); -static int template_args_equal PROTO((tree, tree)); -static void print_template_context PROTO((int)); -static int has_pvbases_p PROTO((tree, tree)); - -/* We use TREE_VECs to hold template arguments. If there is only one - level of template arguments, then the TREE_VEC contains the - arguments directly. If there is more than one level of template - arguments, then each entry in the TREE_VEC is itself a TREE_VEC, - containing the template arguments for a single level. The first - entry in the outer TREE_VEC is the outermost level of template - parameters; the last is the innermost. - - It is incorrect to ever form a template argument vector containing - only one level of arguments, but which is a TREE_VEC containing as - its only entry the TREE_VEC for that level. */ - -/* Non-zero if the template arguments is actually a vector of vectors, - rather than just a vector. */ -#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ - (NODE != NULL_TREE \ - && TREE_CODE (NODE) == TREE_VEC \ - && TREE_VEC_LENGTH (NODE) > 0 \ - && TREE_VEC_ELT (NODE, 0) != NULL_TREE \ - && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) - -/* The depth of a template argument vector. When called directly by - the parser, we use a TREE_LIST rather than a TREE_VEC to represent - template arguments. In fact, we may even see NULL_TREE if there - are no template arguments. In both of those cases, there is only - one level of template arguments. */ -#define TMPL_ARGS_DEPTH(NODE) \ - (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1) - -/* The LEVELth level of the template ARGS. Note that template - parameter levels are indexed from 1, not from 0. */ -#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \ - (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \ - ? TREE_VEC_ELT ((ARGS), (LEVEL) - 1) : ARGS) - -/* Set the LEVELth level of the template ARGS to VAL. This macro does - not work with single-level argument vectors. */ -#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \ - (TREE_VEC_ELT ((ARGS), (LEVEL) - 1) = (VAL)) - -/* Accesses the IDXth parameter in the LEVELth level of the ARGS. */ -#define TMPL_ARG(ARGS, LEVEL, IDX) \ - (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX)) - -/* Set the IDXth element in the LEVELth level of ARGS to VAL. This - macro does not work with single-level argument vectors. */ -#define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \ - (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL)) - -/* Given a single level of template arguments in NODE, return the - number of arguments. */ -#define NUM_TMPL_ARGS(NODE) \ - ((NODE) == NULL_TREE ? 0 \ - : (TREE_CODE (NODE) == TREE_VEC \ - ? TREE_VEC_LENGTH (NODE) : list_length (NODE))) - -/* The number of levels of template parameters given by NODE. */ -#define TMPL_PARMS_DEPTH(NODE) \ - (TREE_INT_CST_HIGH (TREE_PURPOSE (NODE))) - -/* Do any processing required when DECL (a member template declaration - using TEMPLATE_PARAMETERS as its innermost parameter list) is - finished. Returns the TEMPLATE_DECL corresponding to DECL, unless - it is a specialization, in which case the DECL itself is returned. */ - -tree -finish_member_template_decl (decl) - tree decl; -{ - if (decl == NULL_TREE || decl == void_type_node) - return NULL_TREE; - else if (decl == error_mark_node) - /* By returning NULL_TREE, the parser will just ignore this - declaration. We have already issued the error. */ - return NULL_TREE; - else if (TREE_CODE (decl) == TREE_LIST) - { - /* Assume that the class is the only declspec. */ - decl = TREE_VALUE (decl); - if (IS_AGGR_TYPE (decl) && CLASSTYPE_TEMPLATE_INFO (decl) - && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl)) - { - tree tmpl = CLASSTYPE_TI_TEMPLATE (decl); - check_member_template (tmpl); - return tmpl; - } - return NULL_TREE; - } - else if (DECL_TEMPLATE_INFO (decl)) - { - if (!DECL_TEMPLATE_SPECIALIZATION (decl)) - { - check_member_template (DECL_TI_TEMPLATE (decl)); - return DECL_TI_TEMPLATE (decl); - } - else - return decl; - } - else - cp_error ("invalid member template declaration `%D'", decl); - - return error_mark_node; -} - -/* Returns the template nesting level of the indicated class TYPE. - - For example, in: - template <class T> - struct A - { - template <class U> - struct B {}; - }; - - A<T>::B<U> has depth two, while A<T> has depth one. - Both A<T>::B<int> and A<int>::B<U> have depth one, if - COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not - specializations. - - This function is guaranteed to return 0 if passed NULL_TREE so - that, for example, `template_class_depth (current_class_type)' is - always safe. */ - -static int -template_class_depth_real (type, count_specializations) - tree type; - int count_specializations; -{ - int depth; - - for (depth = 0; - type && TREE_CODE (type) != NAMESPACE_DECL; - type = (TREE_CODE (type) == FUNCTION_DECL) - ? DECL_REAL_CONTEXT (type) : TYPE_CONTEXT (type)) - { - if (TREE_CODE (type) != FUNCTION_DECL) - { - if (CLASSTYPE_TEMPLATE_INFO (type) - && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)) - && ((count_specializations - && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)) - || uses_template_parms (CLASSTYPE_TI_ARGS (type)))) - ++depth; - } - else - { - if (DECL_TEMPLATE_INFO (type) - && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type)) - && ((count_specializations - && DECL_TEMPLATE_SPECIALIZATION (type)) - || uses_template_parms (DECL_TI_ARGS (type)))) - ++depth; - } - } - - return depth; -} - -/* Returns the template nesting level of the indicated class TYPE. - Like template_class_depth_real, but instantiations do not count in - the depth. */ - -int -template_class_depth (type) - tree type; -{ - return template_class_depth_real (type, /*count_specializations=*/0); -} - -/* Returns 1 if processing DECL as part of do_pending_inlines - needs us to push template parms. */ - -static int -inline_needs_template_parms (decl) - tree decl; -{ - if (! DECL_TEMPLATE_INFO (decl)) - return 0; - - return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl))) - > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl))); -} - -/* Subroutine of maybe_begin_member_template_processing. - Push the template parms in PARMS, starting from LEVELS steps into the - chain, and ending at the beginning, since template parms are listed - innermost first. */ - -static void -push_inline_template_parms_recursive (parmlist, levels) - tree parmlist; - int levels; -{ - tree parms = TREE_VALUE (parmlist); - int i; - - if (levels > 1) - push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1); - - ++processing_template_decl; - current_template_parms - = tree_cons (build_int_2 (0, processing_template_decl), - parms, current_template_parms); - TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1; - - pushlevel (0); - for (i = 0; i < TREE_VEC_LENGTH (parms); ++i) - { - tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); - my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm)) == 'd', 0); - - switch (TREE_CODE (parm)) - { - case TYPE_DECL: - case TEMPLATE_DECL: - pushdecl (parm); - break; - - case PARM_DECL: - { - /* Make a CONST_DECL as is done in process_template_parm. - It is ugly that we recreate this here; the original - version built in process_template_parm is no longer - available. */ - tree decl = build_decl (CONST_DECL, DECL_NAME (parm), - TREE_TYPE (parm)); - SET_DECL_ARTIFICIAL (decl); - DECL_INITIAL (decl) = DECL_INITIAL (parm); - DECL_TEMPLATE_PARM_P (decl) = 1; - pushdecl (decl); - } - break; - - default: - my_friendly_abort (0); - } - } -} - -/* Restore the template parameter context for a member template or - a friend template defined in a class definition. */ - -void -maybe_begin_member_template_processing (decl) - tree decl; -{ - tree parms; - int levels = 0; - - if (inline_needs_template_parms (decl)) - { - parms = DECL_TEMPLATE_PARMS (most_general_template (decl)); - levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl; - - if (DECL_TEMPLATE_SPECIALIZATION (decl)) - { - --levels; - parms = TREE_CHAIN (parms); - } - - push_inline_template_parms_recursive (parms, levels); - } - - /* Remember how many levels of template parameters we pushed so that - we can pop them later. */ - if (!inline_parm_levels) - VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels"); - if (inline_parm_levels_used == inline_parm_levels->num_elements) - VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used); - VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels; - ++inline_parm_levels_used; -} - -/* Undo the effects of begin_member_template_processing. */ - -void -maybe_end_member_template_processing () -{ - int i; - - if (!inline_parm_levels_used) - return; - - --inline_parm_levels_used; - for (i = 0; - i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used); - ++i) - { - --processing_template_decl; - current_template_parms = TREE_CHAIN (current_template_parms); - poplevel (0, 0, 0); - } -} - -/* Returns non-zero iff T is a member template function. We must be - careful as in - - template <class T> class C { void f(); } - - Here, f is a template function, and a member, but not a member - template. This function does not concern itself with the origin of - T, only its present state. So if we have - - template <class T> class C { template <class U> void f(U); } - - then neither C<int>::f<char> nor C<T>::f<double> is considered - to be a member template. But, `template <class U> void - C<int>::f(U)' is considered a member template. */ - -int -is_member_template (t) - tree t; -{ - if (!DECL_FUNCTION_TEMPLATE_P (t)) - /* Anything that isn't a function or a template function is - certainly not a member template. */ - return 0; - - /* A local class can't have member templates. */ - if (hack_decl_function_context (t)) - return 0; - - return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t)) - /* If there are more levels of template parameters than - there are template classes surrounding the declaration, - then we have a member template. */ - && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) > - template_class_depth (DECL_CLASS_CONTEXT (t)))); -} - -#if 0 /* UNUSED */ -/* Returns non-zero iff T is a member template class. See - is_member_template for a description of what precisely constitutes - a member template. */ - -int -is_member_template_class (t) - tree t; -{ - if (!DECL_CLASS_TEMPLATE_P (t)) - /* Anything that isn't a class template, is certainly not a member - template. */ - return 0; - - if (!DECL_CLASS_SCOPE_P (t)) - /* Anything whose context isn't a class type is surely not a - member template. */ - return 0; - - /* If there are more levels of template parameters than there are - template classes surrounding the declaration, then we have a - member template. */ - return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) > - template_class_depth (DECL_CONTEXT (t))); -} -#endif - -/* Return a new template argument vector which contains all of ARGS, - but has as its innermost set of arguments the EXTRA_ARGS. The - resulting vector will be built on a temporary obstack, and so must - be explicitly copied to the permanent obstack, if required. */ - -static tree -add_to_template_args (args, extra_args) - tree args; - tree extra_args; -{ - tree new_args; - int extra_depth; - int i; - int j; - - extra_depth = TMPL_ARGS_DEPTH (extra_args); - new_args = make_temp_vec (TMPL_ARGS_DEPTH (args) + extra_depth); - - for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i) - SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i)); - - for (j = 1; j <= extra_depth; ++j, ++i) - SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j)); - - return new_args; -} - -/* Like add_to_template_args, but only the outermost ARGS are added to - the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH - (EXTRA_ARGS) levels are added. This function is used to combine - the template arguments from a partial instantiation with the - template arguments used to attain the full instantiation from the - partial instantiation. */ - -static tree -add_outermost_template_args (args, extra_args) - tree args; - tree extra_args; -{ - tree new_args; - - /* If there are more levels of EXTRA_ARGS than there are ARGS, - something very fishy is going on. */ - my_friendly_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args), - 0); - - /* If *all* the new arguments will be the EXTRA_ARGS, just return - them. */ - if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args)) - return extra_args; - - /* For the moment, we make ARGS look like it contains fewer levels. */ - TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args); - - new_args = add_to_template_args (args, extra_args); - - /* Now, we restore ARGS to its full dimensions. */ - TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args); - - return new_args; -} - -/* We've got a template header coming up; push to a new level for storing - the parms. */ - -void -begin_template_parm_list () -{ - /* We use a non-tag-transparent scope here, which causes pushtag to - put tags in this scope, rather than in the enclosing class or - namespace scope. This is the right thing, since we want - TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a - global template class, push_template_decl handles putting the - TEMPLATE_DECL into top-level scope. For a nested template class, - e.g.: - - template <class T> struct S1 { - template <class T> struct S2 {}; - }; - - pushtag contains special code to call pushdecl_with_scope on the - TEMPLATE_DECL for S2. */ - pushlevel (0); - declare_pseudo_global_level (); - ++processing_template_decl; - ++processing_template_parmlist; - note_template_header (0); -} - -/* This routine is called when a specialization is declared. If it is - illegal to declare a specialization here, an error is reported. */ - -static void -check_specialization_scope () -{ - tree scope = current_scope (); - - /* [temp.expl.spec] - - An explicit specialization shall be declared in the namespace of - which the template is a member, or, for member templates, in the - namespace of which the enclosing class or enclosing class - template is a member. An explicit specialization of a member - function, member class or static data member of a class template - shall be declared in the namespace of which the class template - is a member. */ - if (scope && TREE_CODE (scope) != NAMESPACE_DECL) - cp_error ("explicit specialization in non-namespace scope `%D'", - scope); - - /* [temp.expl.spec] - - In an explicit specialization declaration for a member of a class - template or a member template that appears in namespace scope, - the member template and some of its enclosing class templates may - remain unspecialized, except that the declaration shall not - explicitly specialize a class member template if its enclosing - class templates are not explicitly specialized as well. */ - if (current_template_parms) - cp_error ("enclosing class templates are not explicitly specialized"); -} - -/* We've just seen template <>. */ - -void -begin_specialization () -{ - note_template_header (1); - check_specialization_scope (); -} - -/* Called at then end of processing a declaration preceeded by - template<>. */ - -void -end_specialization () -{ - reset_specialization (); -} - -/* Any template <>'s that we have seen thus far are not referring to a - function specialization. */ - -void -reset_specialization () -{ - processing_specialization = 0; - template_header_count = 0; -} - -/* We've just seen a template header. If SPECIALIZATION is non-zero, - it was of the form template <>. */ - -static void -note_template_header (specialization) - int specialization; -{ - processing_specialization = specialization; - template_header_count++; -} - -/* We're beginning an explicit instantiation. */ - -void -begin_explicit_instantiation () -{ - ++processing_explicit_instantiation; -} - - -void -end_explicit_instantiation () -{ - my_friendly_assert(processing_explicit_instantiation > 0, 0); - --processing_explicit_instantiation; -} - -/* The TYPE is being declared. If it is a template type, that means it - is a partial specialization. Do appropriate error-checking. */ - -void -maybe_process_partial_specialization (type) - tree type; -{ - if (IS_AGGR_TYPE (type) && CLASSTYPE_USE_TEMPLATE (type)) - { - if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) - && TYPE_SIZE (type) == NULL_TREE) - { - if (current_namespace - != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type))) - { - cp_pedwarn ("specializing `%#T' in different namespace", type); - cp_pedwarn_at (" from definition of `%#D'", - CLASSTYPE_TI_TEMPLATE (type)); - } - SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type); - if (processing_template_decl) - push_template_decl (TYPE_MAIN_DECL (type)); - } - else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)) - cp_error ("specialization of `%T' after instantiation", type); - } - else if (processing_specialization) - cp_error ("explicit specialization of non-template `%T'", type); -} - -/* Retrieve the specialization (in the sense of [temp.spec] - a - specialization is either an instantiation or an explicit - specialization) of TMPL for the given template ARGS. If there is - no such specialization, return NULL_TREE. The ARGS are a vector of - arguments, or a vector of vectors of arguments, in the case of - templates with more than one level of parameters. */ - -static tree -retrieve_specialization (tmpl, args) - tree tmpl; - tree args; -{ - tree s; - - my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); - - /* There should be as many levels of arguments as there are - levels of parameters. */ - my_friendly_assert (TMPL_ARGS_DEPTH (args) - == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)), - 0); - - for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); - s != NULL_TREE; - s = TREE_CHAIN (s)) - if (comp_template_args (TREE_PURPOSE (s), args)) - return TREE_VALUE (s); - - return NULL_TREE; -} - -/* Returns non-zero iff DECL is a specialization of TMPL. */ - -int -is_specialization_of (decl, tmpl) - tree decl; - tree tmpl; -{ - tree t; - - if (TREE_CODE (decl) == FUNCTION_DECL) - { - for (t = decl; - t != NULL_TREE; - t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE) - if (t == tmpl) - return 1; - } - else - { - my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 0); - - for (t = TREE_TYPE (decl); - t != NULL_TREE; - t = CLASSTYPE_USE_TEMPLATE (t) - ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE) - if (same_type_p (TYPE_MAIN_VARIANT (t), - TYPE_MAIN_VARIANT (TREE_TYPE (tmpl)))) - return 1; - } - - return 0; -} - -/* Register the specialization SPEC as a specialization of TMPL with - the indicated ARGS. Returns SPEC, or an equivalent prior - declaration, if available. */ - -static tree -register_specialization (spec, tmpl, args) - tree spec; - tree tmpl; - tree args; -{ - tree s; - - my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); - - if (TREE_CODE (spec) == FUNCTION_DECL - && uses_template_parms (DECL_TI_ARGS (spec))) - /* This is the FUNCTION_DECL for a partial instantiation. Don't - register it; we want the corresponding TEMPLATE_DECL instead. - We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than - the more obvious `uses_template_parms (spec)' to avoid problems - with default function arguments. In particular, given - something like this: - - template <class T> void f(T t1, T t = T()) - - the default argument expression is not substituted for in an - instantiation unless and until it is actually needed. */ - return spec; - - /* There should be as many levels of arguments as there are - levels of parameters. */ - my_friendly_assert (TMPL_ARGS_DEPTH (args) - == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)), - 0); - - for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); - s != NULL_TREE; - s = TREE_CHAIN (s)) - if (comp_template_args (TREE_PURPOSE (s), args)) - { - tree fn = TREE_VALUE (s); - - if (DECL_TEMPLATE_SPECIALIZATION (spec)) - { - if (DECL_TEMPLATE_INSTANTIATION (fn)) - { - if (TREE_USED (fn) - || DECL_EXPLICIT_INSTANTIATION (fn)) - { - cp_error ("specialization of %D after instantiation", - fn); - return spec; - } - else - { - /* This situation should occur only if the first - specialization is an implicit instantiation, - the second is an explicit specialization, and - the implicit instantiation has not yet been - used. That situation can occur if we have - implicitly instantiated a member function and - then specialized it later. - - We can also wind up here if a friend - declaration that looked like an instantiation - turns out to be a specialization: - - template <class T> void foo(T); - class S { friend void foo<>(int) }; - template <> void foo(int); - - We transform the existing DECL in place so that - any pointers to it become pointers to the - updated declaration. - - If there was a definition for the template, but - not for the specialization, we want this to - look as if there is no definition, and vice - versa. */ - DECL_INITIAL (fn) = NULL_TREE; - duplicate_decls (spec, fn); - - return fn; - } - } - else if (DECL_TEMPLATE_SPECIALIZATION (fn)) - { - duplicate_decls (spec, fn); - return fn; - } - } - } - - DECL_TEMPLATE_SPECIALIZATIONS (tmpl) - = perm_tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl)); - - return spec; -} - -/* Unregister the specialization SPEC as a specialization of TMPL. - Returns nonzero if the SPEC was listed as a specialization of - TMPL. */ - -static int -unregister_specialization (spec, tmpl) - tree spec; - tree tmpl; -{ - tree* s; - - for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl); - *s != NULL_TREE; - s = &TREE_CHAIN (*s)) - if (TREE_VALUE (*s) == spec) - { - *s = TREE_CHAIN (*s); - return 1; - } - - return 0; -} - -/* Print the list of candidate FNS in an error message. */ - -void -print_candidates (fns) - tree fns; -{ - tree fn; - - const char *str = "candidates are:"; - - for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn)) - { - tree f; - - for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f)) - cp_error_at ("%s %+#D", str, OVL_CURRENT (f)); - str = " "; - } -} - -/* Returns the template (one of the functions given by TEMPLATE_ID) - which can be specialized to match the indicated DECL with the - explicit template args given in TEMPLATE_ID. The DECL may be - NULL_TREE if none is available. In that case, the functions in - TEMPLATE_ID are non-members. - - If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a - specialization of a member template. - - The template args (those explicitly specified and those deduced) - are output in a newly created vector *TARGS_OUT. - - If it is impossible to determine the result, an error message is - issued. The error_mark_node is returned to indicate failure. */ - -static tree -determine_specialization (template_id, decl, targs_out, - need_member_template) - tree template_id; - tree decl; - tree* targs_out; - int need_member_template; -{ - tree fn; - tree fns; - tree targs; - tree explicit_targs; - tree candidates = NULL_TREE; - tree templates = NULL_TREE; - - *targs_out = NULL_TREE; - - if (template_id == error_mark_node) - return error_mark_node; - - fns = TREE_OPERAND (template_id, 0); - explicit_targs = TREE_OPERAND (template_id, 1); - - if (fns == error_mark_node) - return error_mark_node; - - /* Check for baselinks. */ - if (TREE_CODE (fns) == TREE_LIST) - fns = TREE_VALUE (fns); - - for (; fns; fns = OVL_NEXT (fns)) - { - tree tmpl; - - fn = OVL_CURRENT (fns); - - if (TREE_CODE (fn) == TEMPLATE_DECL) - /* DECL might be a specialization of FN. */ - tmpl = fn; - else if (need_member_template) - /* FN is an ordinary member function, and we need a - specialization of a member template. */ - continue; - else if (TREE_CODE (fn) != FUNCTION_DECL) - /* We can get IDENTIFIER_NODEs here in certain erroneous - cases. */ - continue; - else if (!DECL_FUNCTION_MEMBER_P (fn)) - /* This is just an ordinary non-member function. Nothing can - be a specialization of that. */ - continue; - else - { - tree decl_arg_types; - - /* This is an ordinary member function. However, since - we're here, we can assume it's enclosing class is a - template class. For example, - - template <typename T> struct S { void f(); }; - template <> void S<int>::f() {} - - Here, S<int>::f is a non-template, but S<int> is a - template class. If FN has the same type as DECL, we - might be in business. */ - if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)), - TREE_TYPE (TREE_TYPE (fn)))) - /* The return types differ. */ - continue; - - /* Adjust the type of DECL in case FN is a static member. */ - decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); - if (DECL_STATIC_FUNCTION_P (fn) - && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) - decl_arg_types = TREE_CHAIN (decl_arg_types); - - if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)), - decl_arg_types)) - /* They match! */ - candidates = tree_cons (NULL_TREE, fn, candidates); - - continue; - } - - /* See whether this function might be a specialization of this - template. */ - targs = get_bindings (tmpl, decl, explicit_targs); - - if (!targs) - /* We cannot deduce template arguments that when used to - specialize TMPL will produce DECL. */ - continue; - - /* Save this template, and the arguments deduced. */ - templates = scratch_tree_cons (targs, tmpl, templates); - } - - if (templates && TREE_CHAIN (templates)) - { - /* We have: - - [temp.expl.spec] - - It is possible for a specialization with a given function - signature to be instantiated from more than one function - template. In such cases, explicit specification of the - template arguments must be used to uniquely identify the - function template specialization being specialized. - - Note that here, there's no suggestion that we're supposed to - determine which of the candidate templates is most - specialized. However, we, also have: - - [temp.func.order] - - Partial ordering of overloaded function template - declarations is used in the following contexts to select - the function template to which a function template - specialization refers: - - -- when an explicit specialization refers to a function - template. - - So, we do use the partial ordering rules, at least for now. - This extension can only serve to make illegal programs legal, - so it's safe. And, there is strong anecdotal evidence that - the committee intended the partial ordering rules to apply; - the EDG front-end has that behavior, and John Spicer claims - that the committee simply forgot to delete the wording in - [temp.expl.spec]. */ - tree tmpl = most_specialized (templates, decl, explicit_targs); - if (tmpl && tmpl != error_mark_node) - { - targs = get_bindings (tmpl, decl, explicit_targs); - templates = scratch_tree_cons (targs, tmpl, NULL_TREE); - } - } - - if (templates == NULL_TREE && candidates == NULL_TREE) - { - cp_error_at ("template-id `%D' for `%+D' does not match any template declaration", - template_id, decl); - return error_mark_node; - } - else if ((templates && TREE_CHAIN (templates)) - || (candidates && TREE_CHAIN (candidates)) - || (templates && candidates)) - { - cp_error_at ("ambiguous template specialization `%D' for `%+D'", - template_id, decl); - chainon (candidates, templates); - print_candidates (candidates); - return error_mark_node; - } - - /* We have one, and exactly one, match. */ - if (candidates) - { - /* It was a specialization of an ordinary member function in a - template class. */ - *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates))); - return DECL_TI_TEMPLATE (TREE_VALUE (candidates)); - } - - /* It was a specialization of a template. */ - targs = DECL_TI_ARGS (DECL_RESULT (TREE_VALUE (templates))); - if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs)) - { - *targs_out = copy_node (targs); - SET_TMPL_ARGS_LEVEL (*targs_out, - TMPL_ARGS_DEPTH (*targs_out), - TREE_PURPOSE (templates)); - } - else - *targs_out = TREE_PURPOSE (templates); - return TREE_VALUE (templates); -} - -/* Check to see if the function just declared, as indicated in - DECLARATOR, and in DECL, is a specialization of a function - template. We may also discover that the declaration is an explicit - instantiation at this point. - - Returns DECL, or an equivalent declaration that should be used - instead if all goes well. Issues an error message if something is - amiss. Returns error_mark_node if the error is not easily - recoverable. - - FLAGS is a bitmask consisting of the following flags: - - 2: The function has a definition. - 4: The function is a friend. - - The TEMPLATE_COUNT is the number of references to qualifying - template classes that appeared in the name of the function. For - example, in - - template <class T> struct S { void f(); }; - void S<int>::f(); - - the TEMPLATE_COUNT would be 1. However, explicitly specialized - classes are not counted in the TEMPLATE_COUNT, so that in - - template <class T> struct S {}; - template <> struct S<int> { void f(); } - template <> void S<int>::f(); - - the TEMPLATE_COUNT would be 0. (Note that this declaration is - illegal; there should be no template <>.) - - If the function is a specialization, it is marked as such via - DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO - is set up correctly, and it is added to the list of specializations - for that template. */ - -tree -check_explicit_specialization (declarator, decl, template_count, flags) - tree declarator; - tree decl; - int template_count; - int flags; -{ - int have_def = flags & 2; - int is_friend = flags & 4; - int specialization = 0; - int explicit_instantiation = 0; - int member_specialization = 0; - - tree ctype = DECL_CLASS_CONTEXT (decl); - tree dname = DECL_NAME (decl); - - if (processing_specialization) - { - /* The last template header was of the form template <>. */ - - if (template_header_count > template_count) - { - /* There were more template headers than qualifying template - classes. */ - if (template_header_count - template_count > 1) - /* There shouldn't be that many template parameter lists. - There can be at most one parameter list for every - qualifying class, plus one for the function itself. */ - cp_error ("too many template parameter lists in declaration of `%D'", decl); - - SET_DECL_TEMPLATE_SPECIALIZATION (decl); - if (ctype) - member_specialization = 1; - else - specialization = 1; - } - else if (template_header_count == template_count) - { - /* The counts are equal. So, this might be a - specialization, but it is not a specialization of a - member template. It might be something like - - template <class T> struct S { - void f(int i); - }; - template <> - void S<int>::f(int i) {} */ - specialization = 1; - SET_DECL_TEMPLATE_SPECIALIZATION (decl); - } - else - { - /* This cannot be an explicit specialization. There are not - enough headers for all of the qualifying classes. For - example, we might have: - - template <> - void S<int>::T<char>::f(); - - But, we're missing another template <>. */ - cp_error("too few template parameter lists in declaration of `%D'", decl); - return decl; - } - } - else if (processing_explicit_instantiation) - { - if (template_header_count) - cp_error ("template parameter list used in explicit instantiation"); - - if (have_def) - cp_error ("definition provided for explicit instantiation"); - - explicit_instantiation = 1; - } - else if (ctype != NULL_TREE - && !TYPE_BEING_DEFINED (ctype) - && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype) - && !is_friend) - { - /* This case catches outdated code that looks like this: - - template <class T> struct S { void f(); }; - void S<int>::f() {} // Missing template <> - - We disable this check when the type is being defined to - avoid complaining about default compiler-generated - constructors, destructors, and assignment operators. - Since the type is an instantiation, not a specialization, - these are the only functions that can be defined before - the class is complete. */ - - /* If they said - template <class T> void S<int>::f() {} - that's bogus. */ - if (template_header_count) - { - cp_error ("template parameters specified in specialization"); - return decl; - } - - if (pedantic) - cp_pedwarn - ("explicit specialization not preceded by `template <>'"); - specialization = 1; - SET_DECL_TEMPLATE_SPECIALIZATION (decl); - } - else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) - { - if (is_friend) - /* This could be something like: - - template <class T> void f(T); - class S { friend void f<>(int); } */ - specialization = 1; - else - { - /* This case handles bogus declarations like template <> - template <class T> void f<int>(); */ - - cp_error ("template-id `%D' in declaration of primary template", - declarator); - return decl; - } - } - - if (specialization || member_specialization) - { - tree t = TYPE_ARG_TYPES (TREE_TYPE (decl)); - for (; t; t = TREE_CHAIN (t)) - if (TREE_PURPOSE (t)) - { - cp_pedwarn - ("default argument specified in explicit specialization"); - break; - } - if (current_lang_name == lang_name_c) - cp_error ("template specialization with C linkage"); - } - - if (specialization || member_specialization || explicit_instantiation) - { - tree tmpl = NULL_TREE; - tree targs = NULL_TREE; - - /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */ - if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR) - { - tree fns; - - my_friendly_assert (TREE_CODE (declarator) == IDENTIFIER_NODE, - 0); - if (!ctype) - fns = IDENTIFIER_NAMESPACE_VALUE (dname); - else - fns = dname; - - declarator = - lookup_template_function (fns, NULL_TREE); - } - - if (declarator == error_mark_node) - return error_mark_node; - - if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype)) - { - if (!explicit_instantiation) - /* A specialization in class scope. This is illegal, - but the error will already have been flagged by - check_specialization_scope. */ - return error_mark_node; - else - { - /* It's not legal to write an explicit instantiation in - class scope, e.g.: - - class C { template void f(); } - - This case is caught by the parser. However, on - something like: - - template class C { void f(); }; - - (which is illegal) we can get here. The error will be - issued later. */ - ; - } - - return decl; - } - else if (TREE_CODE (TREE_OPERAND (declarator, 0)) == LOOKUP_EXPR) - { - /* A friend declaration. We can't do much, because we don't - know what this resolves to, yet. */ - my_friendly_assert (is_friend != 0, 0); - my_friendly_assert (!explicit_instantiation, 0); - SET_DECL_IMPLICIT_INSTANTIATION (decl); - return decl; - } - else if (ctype != NULL_TREE - && (TREE_CODE (TREE_OPERAND (declarator, 0)) == - IDENTIFIER_NODE)) - { - /* Find the list of functions in ctype that have the same - name as the declared function. */ - tree name = TREE_OPERAND (declarator, 0); - tree fns = NULL_TREE; - int idx; - - if (name == constructor_name (ctype) - || name == constructor_name_full (ctype)) - { - int is_constructor = DECL_CONSTRUCTOR_P (decl); - - if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype) - : !TYPE_HAS_DESTRUCTOR (ctype)) - { - /* From [temp.expl.spec]: - - If such an explicit specialization for the member - of a class template names an implicitly-declared - special member function (clause _special_), the - program is ill-formed. - - Similar language is found in [temp.explicit]. */ - cp_error ("specialization of implicitly-declared special member function"); - return error_mark_node; - } - - name = is_constructor ? ctor_identifier : dtor_identifier; - } - - if (!IDENTIFIER_TYPENAME_P (name)) - { - idx = lookup_fnfields_1 (ctype, name); - if (idx >= 0) - fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), idx); - } - else - { - tree methods; - - /* For a type-conversion operator, we cannot do a - name-based lookup. We might be looking for `operator - int' which will be a specialization of `operator T'. - So, we find *all* the conversion operators, and then - select from them. */ - fns = NULL_TREE; - - methods = CLASSTYPE_METHOD_VEC (ctype); - if (methods) - for (idx = 2; idx < TREE_VEC_LENGTH (methods); ++idx) - { - tree ovl = TREE_VEC_ELT (methods, idx); - - if (!ovl || !DECL_CONV_FN_P (OVL_CURRENT (ovl))) - /* There are no more conversion functions. */ - break; - - /* Glue all these conversion functions together - with those we already have. */ - for (; ovl; ovl = OVL_NEXT (ovl)) - fns = ovl_cons (OVL_CURRENT (ovl), fns); - } - } - - if (fns == NULL_TREE) - { - cp_error ("no member function `%D' declared in `%T'", - name, ctype); - return error_mark_node; - } - else - TREE_OPERAND (declarator, 0) = fns; - } - - /* Figure out what exactly is being specialized at this point. - Note that for an explicit instantiation, even one for a - member function, we cannot tell apriori whether the - instantiation is for a member template, or just a member - function of a template class. Even if a member template is - being instantiated, the member template arguments may be - elided if they can be deduced from the rest of the - declaration. */ - tmpl = determine_specialization (declarator, decl, - &targs, - member_specialization); - - if (!tmpl || tmpl == error_mark_node) - /* We couldn't figure out what this declaration was - specializing. */ - return error_mark_node; - else - { - tree gen_tmpl = most_general_template (tmpl); - - if (explicit_instantiation) - { - /* We don't set DECL_EXPLICIT_INSTANTIATION here; that - is done by do_decl_instantiation later. */ - - int arg_depth = TMPL_ARGS_DEPTH (targs); - int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)); - - if (arg_depth > parm_depth) - { - /* If TMPL is not the most general template (for - example, if TMPL is a friend template that is - injected into namespace scope), then there will - be too many levels fo TARGS. Remove some of them - here. */ - int i; - tree new_targs; - - new_targs = make_temp_vec (parm_depth); - for (i = arg_depth - parm_depth; i < arg_depth; ++i) - TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth)) - = TREE_VEC_ELT (targs, i); - targs = new_targs; - } - - decl = instantiate_template (tmpl, targs); - return decl; - } - - /* If we though that the DECL was a member function, but it - turns out to be specializing a static member function, - make DECL a static member function as well. */ - if (DECL_STATIC_FUNCTION_P (tmpl) - && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) - { - revert_static_member_fn (&decl, 0, 0); - last_function_parms = TREE_CHAIN (last_function_parms); - } - - /* Set up the DECL_TEMPLATE_INFO for DECL. */ - DECL_TEMPLATE_INFO (decl) - = perm_tree_cons (tmpl, targs, NULL_TREE); - - /* Mangle the function name appropriately. Note that we do - not mangle specializations of non-template member - functions of template classes, e.g. with - - template <class T> struct S { void f(); } - - and given the specialization - - template <> void S<int>::f() {} - - we do not mangle S<int>::f() here. That's because it's - just an ordinary member function and doesn't need special - treatment. We do this here so that the ordinary, - non-template, name-mangling algorith will not be used - later. */ - if ((is_member_template (tmpl) || ctype == NULL_TREE) - && name_mangling_version >= 1) - set_mangled_name_for_template_decl (decl); - - if (is_friend && !have_def) - /* This is not really a declaration of a specialization. - It's just the name of an instantiation. But, it's not - a request for an instantiation, either. */ - SET_DECL_IMPLICIT_INSTANTIATION (decl); - - /* Register this specialization so that we can find it - again. */ - decl = register_specialization (decl, gen_tmpl, targs); - } - } - - return decl; -} - -/* TYPE is being declared. Verify that the use of template headers - and such is reasonable. Issue error messages if not. */ - -void -maybe_check_template_type (type) - tree type; -{ - if (template_header_count) - { - /* We are in the scope of some `template <...>' header. */ - - int context_depth - = template_class_depth_real (TYPE_CONTEXT (type), - /*count_specializations=*/1); - - if (template_header_count <= context_depth) - /* This is OK; the template headers are for the context. We - are actually too lenient here; like - check_explicit_specialization we should consider the number - of template types included in the actual declaration. For - example, - - template <class T> struct S { - template <class U> template <class V> - struct I {}; - }; - - is illegal, but: - - template <class T> struct S { - template <class U> struct I; - }; - - template <class T> template <class U. - struct S<T>::I {}; - - is not. */ - ; - else if (template_header_count > context_depth + 1) - /* There are two many template parameter lists. */ - cp_error ("too many template parameter lists in declaration of `%T'", type); - } -} - -/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template - parameters. These are represented in the same format used for - DECL_TEMPLATE_PARMS. */ - -int comp_template_parms (parms1, parms2) - tree parms1; - tree parms2; -{ - tree p1; - tree p2; - - if (parms1 == parms2) - return 1; - - for (p1 = parms1, p2 = parms2; - p1 != NULL_TREE && p2 != NULL_TREE; - p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2)) - { - tree t1 = TREE_VALUE (p1); - tree t2 = TREE_VALUE (p2); - int i; - - my_friendly_assert (TREE_CODE (t1) == TREE_VEC, 0); - my_friendly_assert (TREE_CODE (t2) == TREE_VEC, 0); - - if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2)) - return 0; - - for (i = 0; i < TREE_VEC_LENGTH (t2); ++i) - { - tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i)); - tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i)); - - if (TREE_CODE (parm1) != TREE_CODE (parm2)) - return 0; - - if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM) - continue; - else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2))) - return 0; - } - } - - if ((p1 != NULL_TREE) != (p2 != NULL_TREE)) - /* One set of parameters has more parameters lists than the - other. */ - return 0; - - return 1; -} - -/* Complain if DECL shadows a template parameter. - - [temp.local]: A template-parameter shall not be redeclared within its - scope (including nested scopes). */ - -void -check_template_shadow (decl) - tree decl; -{ - tree olddecl; - - /* If we're not in a template, we can't possibly shadow a template - parameter. */ - if (!current_template_parms) - return; - - /* Figure out what we're shadowing. */ - if (TREE_CODE (decl) == OVERLOAD) - decl = OVL_CURRENT (decl); - olddecl = IDENTIFIER_VALUE (DECL_NAME (decl)); - - /* If there's no previous binding for this name, we're not shadowing - anything, let alone a template parameter. */ - if (!olddecl) - return; - - /* If we're not shadowing a template parameter, we're done. Note - that OLDDECL might be an OVERLOAD (or perhaps even an - ERROR_MARK), so we can't just blithely assume it to be a _DECL - node. */ - if (TREE_CODE_CLASS (TREE_CODE (olddecl)) != 'd' - || !DECL_TEMPLATE_PARM_P (olddecl)) - return; - - /* We check for decl != olddecl to avoid bogus errors for using a - name inside a class. We check TPFI to avoid duplicate errors for - inline member templates. */ - if (decl == olddecl - || TEMPLATE_PARMS_FOR_INLINE (current_template_parms)) - return; - - cp_error_at ("declaration of `%#D'", decl); - cp_error_at (" shadows template parm `%#D'", olddecl); -} - -/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL, - ORIG_LEVEL, DECL, and TYPE. */ - -static tree -build_template_parm_index (index, level, orig_level, decl, type) - int index; - int level; - int orig_level; - tree decl; - tree type; -{ - tree t = make_node (TEMPLATE_PARM_INDEX); - TEMPLATE_PARM_IDX (t) = index; - TEMPLATE_PARM_LEVEL (t) = level; - TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level; - TEMPLATE_PARM_DECL (t) = decl; - TREE_TYPE (t) = type; - - return t; -} - -/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose - TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a - TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a - new one is created. */ - -static tree -reduce_template_parm_level (index, type, levels) - tree index; - tree type; - int levels; -{ - if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE - || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index)) - != TEMPLATE_PARM_LEVEL (index) - levels)) - { - tree decl - = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index)), - DECL_NAME (TEMPLATE_PARM_DECL (index)), - type); - tree t - = build_template_parm_index (TEMPLATE_PARM_IDX (index), - TEMPLATE_PARM_LEVEL (index) - levels, - TEMPLATE_PARM_ORIG_LEVEL (index), - decl, type); - TEMPLATE_PARM_DESCENDANTS (index) = t; - - /* Template template parameters need this. */ - DECL_TEMPLATE_PARMS (decl) - = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)); - } - - return TEMPLATE_PARM_DESCENDANTS (index); -} - -/* Process information from new template parameter NEXT and append it to the - LIST being built. */ - -tree -process_template_parm (list, next) - tree list, next; -{ - tree parm; - tree decl = 0; - tree defval; - int is_type, idx; - - parm = next; - my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259); - defval = TREE_PURPOSE (parm); - parm = TREE_VALUE (parm); - is_type = TREE_PURPOSE (parm) == class_type_node; - - if (list) - { - tree p = TREE_VALUE (tree_last (list)); - - if (TREE_CODE (p) == TYPE_DECL) - idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p)); - else if (TREE_CODE (p) == TEMPLATE_DECL) - idx = TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p))); - else - idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p)); - ++idx; - } - else - idx = 0; - - if (!is_type) - { - my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260); - /* is a const-param */ - parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), - PARM, 0, NULL_TREE); - - /* [temp.param] - - The top-level cv-qualifiers on the template-parameter are - ignored when determining its type. */ - TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm)); - - /* A template parameter is not modifiable. */ - TREE_READONLY (parm) = 1; - if (IS_AGGR_TYPE (TREE_TYPE (parm)) - && TREE_CODE (TREE_TYPE (parm)) != TEMPLATE_TYPE_PARM - && TREE_CODE (TREE_TYPE (parm)) != TYPENAME_TYPE) - { - cp_error ("`%#T' is not a valid type for a template constant parameter", - TREE_TYPE (parm)); - if (DECL_NAME (parm) == NULL_TREE) - error (" a template type parameter must begin with `class' or `typename'"); - TREE_TYPE (parm) = void_type_node; - } - else if (pedantic - && (TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE - || TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE)) - cp_pedwarn ("`%T' is not a valid type for a template constant parameter", - TREE_TYPE (parm)); - if (TREE_PERMANENT (parm) == 0) - { - parm = copy_node (parm); - TREE_PERMANENT (parm) = 1; - } - decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm)); - DECL_INITIAL (parm) = DECL_INITIAL (decl) - = build_template_parm_index (idx, processing_template_decl, - processing_template_decl, - decl, TREE_TYPE (parm)); - } - else - { - tree t; - parm = TREE_VALUE (parm); - - if (parm && TREE_CODE (parm) == TEMPLATE_DECL) - { - t = make_lang_type (TEMPLATE_TEMPLATE_PARM); - /* This is for distinguishing between real templates and template - template parameters */ - TREE_TYPE (parm) = t; - TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t; - decl = parm; - } - else - { - t = make_lang_type (TEMPLATE_TYPE_PARM); - /* parm is either IDENTIFIER_NODE or NULL_TREE */ - decl = build_decl (TYPE_DECL, parm, t); - } - - TYPE_NAME (t) = decl; - TYPE_STUB_DECL (t) = decl; - parm = decl; - TEMPLATE_TYPE_PARM_INDEX (t) - = build_template_parm_index (idx, processing_template_decl, - processing_template_decl, - decl, TREE_TYPE (parm)); - } - SET_DECL_ARTIFICIAL (decl); - DECL_TEMPLATE_PARM_P (decl) = 1; - pushdecl (decl); - parm = build_tree_list (defval, parm); - return chainon (list, parm); -} - -/* The end of a template parameter list has been reached. Process the - tree list into a parameter vector, converting each parameter into a more - useful form. Type parameters are saved as IDENTIFIER_NODEs, and others - as PARM_DECLs. */ - -tree -end_template_parm_list (parms) - tree parms; -{ - int nparms; - tree parm; - tree saved_parmlist = make_tree_vec (list_length (parms)); - - current_template_parms - = tree_cons (build_int_2 (0, processing_template_decl), - saved_parmlist, current_template_parms); - - for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++) - TREE_VEC_ELT (saved_parmlist, nparms) = parm; - - --processing_template_parmlist; - - return saved_parmlist; -} - -/* end_template_decl is called after a template declaration is seen. */ - -void -end_template_decl () -{ - reset_specialization (); - - if (! processing_template_decl) - return; - - /* This matches the pushlevel in begin_template_parm_list. */ - poplevel (0, 0, 0); - - --processing_template_decl; - current_template_parms = TREE_CHAIN (current_template_parms); - (void) get_pending_sizes (); /* Why? */ -} - -/* Given a template argument vector containing the template PARMS. - The innermost PARMS are given first. */ - -tree -current_template_args () -{ - tree header; - tree args = NULL_TREE; - int length = TMPL_PARMS_DEPTH (current_template_parms); - int l = length; - - /* If there is only one level of template parameters, we do not - create a TREE_VEC of TREE_VECs. Instead, we return a single - TREE_VEC containing the arguments. */ - if (length > 1) - args = make_tree_vec (length); - - for (header = current_template_parms; header; header = TREE_CHAIN (header)) - { - tree a = copy_node (TREE_VALUE (header)); - int i; - - TREE_TYPE (a) = NULL_TREE; - for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i) - { - tree t = TREE_VEC_ELT (a, i); - - /* T will be a list if we are called from within a - begin/end_template_parm_list pair, but a vector directly - if within a begin/end_member_template_processing pair. */ - if (TREE_CODE (t) == TREE_LIST) - { - t = TREE_VALUE (t); - - if (TREE_CODE (t) == TYPE_DECL - || TREE_CODE (t) == TEMPLATE_DECL) - t = TREE_TYPE (t); - else - t = DECL_INITIAL (t); - TREE_VEC_ELT (a, i) = t; - } - } - - if (length > 1) - TREE_VEC_ELT (args, --l) = a; - else - args = a; - } - - return args; -} - -/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated - template PARMS. Used by push_template_decl below. */ - -static tree -build_template_decl (decl, parms) - tree decl; - tree parms; -{ - tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE); - DECL_TEMPLATE_PARMS (tmpl) = parms; - DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl); - if (DECL_LANG_SPECIFIC (decl)) - { - DECL_CLASS_CONTEXT (tmpl) = DECL_CLASS_CONTEXT (decl); - DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl); - DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl); - } - - return tmpl; -} - -struct template_parm_data -{ - /* The level of the template parameters we are currently - processing. */ - int level; - - /* The index of the specialization argument we are currently - processing. */ - int current_arg; - - /* An array whose size is the number of template parameters. The - elements are non-zero if the parameter has been used in any one - of the arguments processed so far. */ - int* parms; - - /* An array whose size is the number of template arguments. The - elements are non-zero if the argument makes use of template - parameters of this level. */ - int* arg_uses_template_parms; -}; - -/* Subroutine of push_template_decl used to see if each template - parameter in a partial specialization is used in the explicit - argument list. If T is of the LEVEL given in DATA (which is - treated as a template_parm_data*), then DATA->PARMS is marked - appropriately. */ - -static int -mark_template_parm (t, data) - tree t; - void* data; -{ - int level; - int idx; - struct template_parm_data* tpd = (struct template_parm_data*) data; - - if (TREE_CODE (t) == TEMPLATE_PARM_INDEX) - { - level = TEMPLATE_PARM_LEVEL (t); - idx = TEMPLATE_PARM_IDX (t); - } - else - { - level = TEMPLATE_TYPE_LEVEL (t); - idx = TEMPLATE_TYPE_IDX (t); - } - - if (level == tpd->level) - { - tpd->parms[idx] = 1; - tpd->arg_uses_template_parms[tpd->current_arg] = 1; - } - - /* Return zero so that for_each_template_parm will continue the - traversal of the tree; we want to mark *every* template parm. */ - return 0; -} - -/* Process the partial specialization DECL. */ - -static tree -process_partial_specialization (decl) - tree decl; -{ - tree type = TREE_TYPE (decl); - tree maintmpl = CLASSTYPE_TI_TEMPLATE (type); - tree specargs = CLASSTYPE_TI_ARGS (type); - tree inner_args = innermost_args (specargs); - tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms); - tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl); - int nargs = TREE_VEC_LENGTH (inner_args); - int ntparms = TREE_VEC_LENGTH (inner_parms); - int i; - int did_error_intro = 0; - struct template_parm_data tpd; - struct template_parm_data tpd2; - - /* We check that each of the template parameters given in the - partial specialization is used in the argument list to the - specialization. For example: - - template <class T> struct S; - template <class T> struct S<T*>; - - The second declaration is OK because `T*' uses the template - parameter T, whereas - - template <class T> struct S<int>; - - is no good. Even trickier is: - - template <class T> - struct S1 - { - template <class U> - struct S2; - template <class U> - struct S2<T>; - }; - - The S2<T> declaration is actually illegal; it is a - full-specialization. Of course, - - template <class U> - struct S2<T (*)(U)>; - - or some such would have been OK. */ - tpd.level = TMPL_PARMS_DEPTH (current_template_parms); - tpd.parms = alloca (sizeof (int) * ntparms); - bzero ((PTR) tpd.parms, sizeof (int) * ntparms); - - tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs); - bzero ((PTR) tpd.arg_uses_template_parms, sizeof (int) * nargs); - for (i = 0; i < nargs; ++i) - { - tpd.current_arg = i; - for_each_template_parm (TREE_VEC_ELT (inner_args, i), - &mark_template_parm, - &tpd); - } - for (i = 0; i < ntparms; ++i) - if (tpd.parms[i] == 0) - { - /* One of the template parms was not used in the - specialization. */ - if (!did_error_intro) - { - cp_error ("template parameters not used in partial specialization:"); - did_error_intro = 1; - } - - cp_error (" `%D'", - TREE_VALUE (TREE_VEC_ELT (inner_parms, i))); - } - - /* [temp.class.spec] - - The argument list of the specialization shall not be identical to - the implicit argument list of the primary template. */ - if (comp_template_args (inner_args, - innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE - (maintmpl))))) - cp_error ("partial specialization `%T' does not specialize any template arguments", type); - - /* [temp.class.spec] - - A partially specialized non-type argument expression shall not - involve template parameters of the partial specialization except - when the argument expression is a simple identifier. - - The type of a template parameter corresponding to a specialized - non-type argument shall not be dependent on a parameter of the - specialization. */ - my_friendly_assert (nargs == DECL_NTPARMS (maintmpl), 0); - tpd2.parms = 0; - for (i = 0; i < nargs; ++i) - { - tree arg = TREE_VEC_ELT (inner_args, i); - if (/* These first two lines are the `non-type' bit. */ - TREE_CODE_CLASS (TREE_CODE (arg)) != 't' - && TREE_CODE (arg) != TEMPLATE_DECL - /* This next line is the `argument expression is not just a - simple identifier' condition and also the `specialized - non-type argument' bit. */ - && TREE_CODE (arg) != TEMPLATE_PARM_INDEX) - { - if (tpd.arg_uses_template_parms[i]) - cp_error ("template argument `%E' involves template parameter(s)", arg); - else - { - /* Look at the corresponding template parameter, - marking which template parameters its type depends - upon. */ - tree type = - TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms, - i))); - - if (!tpd2.parms) - { - /* We haven't yet initialized TPD2. Do so now. */ - tpd2.arg_uses_template_parms - = (int*) alloca (sizeof (int) * nargs); - /* The number of parameters here is the number in the - main template, which, as checked in the assertion - above, is NARGS. */ - tpd2.parms = (int*) alloca (sizeof (int) * nargs); - tpd2.level = - TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl)); - } - - /* Mark the template parameters. But this time, we're - looking for the template parameters of the main - template, not in the specialization. */ - tpd2.current_arg = i; - tpd2.arg_uses_template_parms[i] = 0; - bzero ((PTR) tpd2.parms, sizeof (int) * nargs); - for_each_template_parm (type, - &mark_template_parm, - &tpd2); - - if (tpd2.arg_uses_template_parms [i]) - { - /* The type depended on some template parameters. - If they are fully specialized in the - specialization, that's OK. */ - int j; - for (j = 0; j < nargs; ++j) - if (tpd2.parms[j] != 0 - && tpd.arg_uses_template_parms [j]) - { - cp_error ("type `%T' of template argument `%E' depends on template parameter(s)", - type, - arg); - break; - } - } - } - } - } - - if (retrieve_specialization (maintmpl, specargs)) - /* We've already got this specialization. */ - return decl; - - DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) = CLASSTYPE_TI_SPEC_INFO (type) - = perm_tree_cons (inner_args, inner_parms, - DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)); - TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type; - return decl; -} - -/* Check that a template declaration's use of default arguments is not - invalid. Here, PARMS are the template parameters. IS_PRIMARY is - non-zero if DECL is the thing declared by a primary template. - IS_PARTIAL is non-zero if DECL is a partial specialization. */ - -static void -check_default_tmpl_args (decl, parms, is_primary, is_partial) - tree decl; - tree parms; - int is_primary; - int is_partial; -{ - const char *msg; - int last_level_to_check; - - /* [temp.param] - - A default template-argument shall not be specified in a - function template declaration or a function template definition, nor - in the template-parameter-list of the definition of a member of a - class template. */ - - if (current_class_type - && !TYPE_BEING_DEFINED (current_class_type) - && DECL_LANG_SPECIFIC (decl) - /* If this is either a friend defined in the scope of the class - or a member function. */ - && DECL_CLASS_CONTEXT (decl) == current_class_type - /* And, if it was a member function, it really was defined in - the scope of the class. */ - && (!DECL_FUNCTION_MEMBER_P (decl) || DECL_DEFINED_IN_CLASS_P (decl))) - /* We already checked these parameters when the template was - declared, so there's no need to do it again now. This function - was defined in class scope, but we're processing it's body now - that the class is complete. */ - return; - - if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary) - /* For an ordinary class template, default template arguments are - allowed at the innermost level, e.g.: - template <class T = int> - struct S {}; - but, in a partial specialization, they're not allowed even - there, as we have in [temp.class.spec]: - - The template parameter list of a specialization shall not - contain default template argument values. - - So, for a partial specialization, or for a function template, - we look at all of them. */ - ; - else - /* But, for a primary class template that is not a partial - specialization we look at all template parameters except the - innermost ones. */ - parms = TREE_CHAIN (parms); - - /* Figure out what error message to issue. */ - if (TREE_CODE (decl) == FUNCTION_DECL) - msg = "default argument for template parameter in function template `%D'"; - else if (is_partial) - msg = "default argument in partial specialization `%D'"; - else - msg = "default argument for template parameter for class enclosing `%D'"; - - if (current_class_type && TYPE_BEING_DEFINED (current_class_type)) - /* If we're inside a class definition, there's no need to - examine the parameters to the class itself. On the one - hand, they will be checked when the class is defined, and, - on the other, default arguments are legal in things like: - template <class T = double> - struct S { template <class U> void f(U); }; - Here the default argument for `S' has no bearing on the - declaration of `f'. */ - last_level_to_check = template_class_depth (current_class_type) + 1; - else - /* Check everything. */ - last_level_to_check = 0; - - for (; parms && TMPL_PARMS_DEPTH (parms) >= last_level_to_check; - parms = TREE_CHAIN (parms)) - { - tree inner_parms = TREE_VALUE (parms); - int i, ntparms; - - ntparms = TREE_VEC_LENGTH (inner_parms); - for (i = 0; i < ntparms; ++i) - if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i))) - { - if (msg) - { - cp_error (msg, decl); - msg = 0; - } - - /* Clear out the default argument so that we are not - confused later. */ - TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE; - } - - /* At this point, if we're still interested in issuing messages, - they must apply to classes surrounding the object declared. */ - if (msg) - msg = "default argument for template parameter for class enclosing `%D'"; - } -} - -/* Creates a TEMPLATE_DECL for the indicated DECL using the template - parameters given by current_template_args, or reuses a - previously existing one, if appropriate. Returns the DECL, or an - equivalent one, if it is replaced via a call to duplicate_decls. - - If IS_FRIEND is non-zero, DECL is a friend declaration. */ - -tree -push_template_decl_real (decl, is_friend) - tree decl; - int is_friend; -{ - tree tmpl; - tree args; - tree info; - tree ctx; - int primary; - int is_partial; - - /* See if this is a partial specialization. */ - is_partial = (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl) - && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE - && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl))); - - is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl)); - - if (is_friend) - /* For a friend, we want the context of the friend function, not - the type of which it is a friend. */ - ctx = DECL_CONTEXT (decl); - else if (DECL_REAL_CONTEXT (decl) - && TREE_CODE (DECL_REAL_CONTEXT (decl)) != NAMESPACE_DECL) - /* In the case of a virtual function, we want the class in which - it is defined. */ - ctx = DECL_REAL_CONTEXT (decl); - else - /* Otherwise, if we're currently definining some class, the DECL - is assumed to be a member of the class. */ - ctx = current_class_type; - - if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL) - ctx = NULL_TREE; - - if (!DECL_CONTEXT (decl)) - DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); - - /* For determining whether this is a primary template or not, we're really - interested in the lexical context, not the true context. */ - if (is_friend) - info = current_class_type; - else - info = ctx; - - /* See if this is a primary template. */ - if (info && TREE_CODE (info) == FUNCTION_DECL) - primary = 0; - /* Note that template_class_depth returns 0 if given NULL_TREE, so - this next line works even when we are at global scope. */ - else if (processing_template_decl > template_class_depth (info)) - primary = 1; - else - primary = 0; - - if (primary) - { - if (current_lang_name == lang_name_c) - cp_error ("template with C linkage"); - if (TREE_CODE (decl) == TYPE_DECL && ANON_AGGRNAME_P (DECL_NAME (decl))) - cp_error ("template class without a name"); - if (TREE_CODE (decl) == TYPE_DECL - && TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) - cp_error ("template declaration of `%#T'", TREE_TYPE (decl)); - } - - /* Check to see that the rules regarding the use of default - arguments are not being violated. */ - check_default_tmpl_args (decl, current_template_parms, - primary, is_partial); - - if (is_partial) - return process_partial_specialization (decl); - - args = current_template_args (); - - if (!ctx - || TREE_CODE (ctx) == FUNCTION_DECL - || TYPE_BEING_DEFINED (ctx) - || (is_friend && !DECL_TEMPLATE_INFO (decl))) - { - if (DECL_LANG_SPECIFIC (decl) - && DECL_TEMPLATE_INFO (decl) - && DECL_TI_TEMPLATE (decl)) - tmpl = DECL_TI_TEMPLATE (decl); - else - { - tmpl = build_template_decl (decl, current_template_parms); - - if (DECL_LANG_SPECIFIC (decl) - && DECL_TEMPLATE_SPECIALIZATION (decl)) - { - /* A specialization of a member template of a template - class. */ - SET_DECL_TEMPLATE_SPECIALIZATION (tmpl); - DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl); - DECL_TEMPLATE_INFO (decl) = NULL_TREE; - } - } - } - else - { - tree a, t, current, parms; - int i; - - if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx)) - cp_error ("must specialize `%#T' before defining member `%#D'", - ctx, decl); - if (TREE_CODE (decl) == TYPE_DECL) - { - if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl))) - || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) - && TYPE_TEMPLATE_INFO (TREE_TYPE (decl)) - && TYPE_TI_TEMPLATE (TREE_TYPE (decl))) - tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl)); - else - { - cp_error ("`%D' does not declare a template type", decl); - return decl; - } - } - else if (! DECL_TEMPLATE_INFO (decl)) - { - cp_error ("template definition of non-template `%#D'", decl); - return decl; - } - else - tmpl = DECL_TI_TEMPLATE (decl); - - if (is_member_template (tmpl) - && DECL_FUNCTION_TEMPLATE_P (tmpl) - && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl) - && DECL_TEMPLATE_SPECIALIZATION (decl)) - { - tree new_tmpl; - - /* The declaration is a specialization of a member - template, declared outside the class. Therefore, the - innermost template arguments will be NULL, so we - replace them with the arguments determined by the - earlier call to check_explicit_specialization. */ - args = DECL_TI_ARGS (decl); - - new_tmpl - = build_template_decl (decl, current_template_parms); - DECL_TEMPLATE_RESULT (new_tmpl) = decl; - TREE_TYPE (new_tmpl) = TREE_TYPE (decl); - DECL_TI_TEMPLATE (decl) = new_tmpl; - SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl); - DECL_TEMPLATE_INFO (new_tmpl) = - perm_tree_cons (tmpl, args, NULL_TREE); - - register_specialization (new_tmpl, tmpl, args); - return decl; - } - - /* Make sure the template headers we got make sense. */ - - parms = DECL_TEMPLATE_PARMS (tmpl); - i = TMPL_PARMS_DEPTH (parms); - if (TMPL_ARGS_DEPTH (args) != i) - { - cp_error ("expected %d levels of template parms for `%#D', got %d", - i, decl, TMPL_ARGS_DEPTH (args)); - } - else - for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms)) - { - a = TMPL_ARGS_LEVEL (args, i); - t = INNERMOST_TEMPLATE_PARMS (parms); - - if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a)) - { - if (current == decl) - cp_error ("got %d template parameters for `%#D'", - TREE_VEC_LENGTH (a), decl); - else - cp_error ("got %d template parameters for `%#T'", - TREE_VEC_LENGTH (a), current); - cp_error (" but %d required", TREE_VEC_LENGTH (t)); - } - - /* Perhaps we should also check that the parms are used in the - appropriate qualifying scopes in the declarator? */ - - if (current == decl) - current = ctx; - else - current = TYPE_CONTEXT (current); - } - } - - DECL_TEMPLATE_RESULT (tmpl) = decl; - TREE_TYPE (tmpl) = TREE_TYPE (decl); - - /* Push template declarations for global functions and types. Note - that we do not try to push a global template friend declared in a - template class; such a thing may well depend on the template - parameters of the class. */ - if (! ctx - && !(is_friend && template_class_depth (current_class_type) > 0)) - tmpl = pushdecl_namespace_level (tmpl); - - if (primary) - DECL_PRIMARY_TEMPLATE (tmpl) = tmpl; - - info = perm_tree_cons (tmpl, args, NULL_TREE); - - if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl)) - { - SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info); - if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL) - && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE) - DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl)); - } - else if (! DECL_LANG_SPECIFIC (decl)) - cp_error ("template declaration of `%#D'", decl); - else - DECL_TEMPLATE_INFO (decl) = info; - - return DECL_TEMPLATE_RESULT (tmpl); -} - -tree -push_template_decl (decl) - tree decl; -{ - return push_template_decl_real (decl, 0); -} - -/* Called when a class template TYPE is redeclared with the indicated - template PARMS, e.g.: - - template <class T> struct S; - template <class T> struct S {}; */ - -void -redeclare_class_template (type, parms) - tree type; - tree parms; -{ - tree tmpl; - tree tmpl_parms; - int i; - - if (!TYPE_TEMPLATE_INFO (type)) - { - cp_error ("`%T' is not a template type", type); - return; - } - - tmpl = TYPE_TI_TEMPLATE (type); - if (!PRIMARY_TEMPLATE_P (tmpl)) - /* The type is nested in some template class. Nothing to worry - about here; there are no new template parameters for the nested - type. */ - return; - - parms = INNERMOST_TEMPLATE_PARMS (parms); - tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); - - if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms)) - { - cp_error_at ("previous declaration `%D'", tmpl); - cp_error ("used %d template parameter%s instead of %d", - TREE_VEC_LENGTH (tmpl_parms), - TREE_VEC_LENGTH (tmpl_parms) == 1 ? "" : "s", - TREE_VEC_LENGTH (parms)); - return; - } - - for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i) - { - tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i)); - tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); - tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)); - tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i)); - - if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)) - { - cp_error_at ("template parameter `%#D'", tmpl_parm); - cp_error ("redeclared here as `%#D'", parm); - return; - } - - if (tmpl_default != NULL_TREE && parm_default != NULL_TREE) - { - /* We have in [temp.param]: - - A template-parameter may not be given default arguments - by two different declarations in the same scope. */ - cp_error ("redefinition of default argument for `%#D'", parm); - cp_error_at (" original definition appeared here", tmpl_parm); - return; - } - - if (parm_default != NULL_TREE) - /* Update the previous template parameters (which are the ones - that will really count) with the new default value. */ - TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default; - } -} - -/* Attempt to convert the non-type template parameter EXPR to the - indicated TYPE. If the conversion is successful, return the - converted value. If the conversion is unsuccesful, return - NULL_TREE if we issued an error message, or error_mark_node if we - did not. We issue error messages for out-and-out bad template - parameters, but not simply because the conversion failed, since we - might be just trying to do argument deduction. By the time this - function is called, neither TYPE nor EXPR may make use of template - parameters. */ - -static tree -convert_nontype_argument (type, expr) - tree type; - tree expr; -{ - tree expr_type = TREE_TYPE (expr); - - /* A template-argument for a non-type, non-template - template-parameter shall be one of: - - --an integral constant-expression of integral or enumeration - type; or - - --the name of a non-type template-parameter; or - - --the name of an object or function with external linkage, - including function templates and function template-ids but - excluding non-static class members, expressed as id-expression; - or - - --the address of an object or function with external linkage, - including function templates and function template-ids but - excluding non-static class members, expressed as & id-expression - where the & is optional if the name refers to a function or - array; or - - --a pointer to member expressed as described in _expr.unary.op_. */ - - /* An integral constant-expression can include const variables - or enumerators. */ - if (INTEGRAL_TYPE_P (expr_type) && TREE_READONLY_DECL_P (expr)) - expr = decl_constant_value (expr); - - if (is_overloaded_fn (expr)) - /* OK for now. We'll check that it has external linkage later. - Check this first since if expr_type is the unknown_type_node - we would otherwise complain below. */ - ; - else if (TYPE_PTRMEM_P (expr_type) - || TYPE_PTRMEMFUNC_P (expr_type)) - { - if (TREE_CODE (expr) != PTRMEM_CST) - goto bad_argument; - } - else if (TYPE_PTR_P (expr_type) - || TYPE_PTRMEM_P (expr_type) - || TREE_CODE (expr_type) == ARRAY_TYPE - || TREE_CODE (type) == REFERENCE_TYPE - /* If expr is the address of an overloaded function, we - will get the unknown_type_node at this point. */ - || expr_type == unknown_type_node) - { - tree referent; - tree e = expr; - STRIP_NOPS (e); - - if (TREE_CODE (type) == REFERENCE_TYPE - || TREE_CODE (expr_type) == ARRAY_TYPE) - referent = e; - else - { - if (TREE_CODE (e) != ADDR_EXPR) - { - bad_argument: - cp_error ("`%E' is not a valid template argument", expr); - if (TYPE_PTR_P (expr_type)) - { - if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE) - cp_error ("it must be the address of a function with external linkage"); - else - cp_error ("it must be the address of an object with external linkage"); - } - else if (TYPE_PTRMEM_P (expr_type) - || TYPE_PTRMEMFUNC_P (expr_type)) - cp_error ("it must be a pointer-to-member of the form `&X::Y'"); - - return NULL_TREE; - } - - referent = TREE_OPERAND (e, 0); - STRIP_NOPS (referent); - } - - if (TREE_CODE (referent) == STRING_CST) - { - cp_error ("string literal %E is not a valid template argument", - referent); - error ("because it is the address of an object with static linkage"); - return NULL_TREE; - } - - if (is_overloaded_fn (referent)) - /* We'll check that it has external linkage later. */ - ; - else if (TREE_CODE (referent) != VAR_DECL) - goto bad_argument; - else if (!TREE_PUBLIC (referent)) - { - cp_error ("address of non-extern `%E' cannot be used as template argument", referent); - return error_mark_node; - } - } - else if (INTEGRAL_TYPE_P (expr_type) - || TYPE_PTRMEM_P (expr_type) - || TYPE_PTRMEMFUNC_P (expr_type) - /* The next two are g++ extensions. */ - || TREE_CODE (expr_type) == REAL_TYPE - || TREE_CODE (expr_type) == COMPLEX_TYPE) - { - if (! TREE_CONSTANT (expr)) - { - non_constant: - cp_error ("non-constant `%E' cannot be used as template argument", - expr); - return NULL_TREE; - } - } - else - { - cp_error ("object `%E' cannot be used as template argument", expr); - return NULL_TREE; - } - - switch (TREE_CODE (type)) - { - case INTEGER_TYPE: - case BOOLEAN_TYPE: - case ENUMERAL_TYPE: - /* For a non-type template-parameter of integral or enumeration - type, integral promotions (_conv.prom_) and integral - conversions (_conv.integral_) are applied. */ - if (!INTEGRAL_TYPE_P (expr_type)) - return error_mark_node; - - /* It's safe to call digest_init in this case; we know we're - just converting one integral constant expression to another. */ - expr = digest_init (type, expr, (tree*) 0); - - if (TREE_CODE (expr) != INTEGER_CST) - /* Curiously, some TREE_CONSTANT integral expressions do not - simplify to integer constants. For example, `3 % 0', - remains a TRUNC_MOD_EXPR. */ - goto non_constant; - - return expr; - - case REAL_TYPE: - case COMPLEX_TYPE: - /* These are g++ extensions. */ - if (TREE_CODE (expr_type) != TREE_CODE (type)) - return error_mark_node; - - expr = digest_init (type, expr, (tree*) 0); - - if (TREE_CODE (expr) != REAL_CST) - goto non_constant; - - return expr; - - case POINTER_TYPE: - { - tree type_pointed_to = TREE_TYPE (type); - - if (TYPE_PTRMEM_P (type)) - { - tree e; - - /* For a non-type template-parameter of type pointer to data - member, qualification conversions (_conv.qual_) are - applied. */ - e = perform_qualification_conversions (type, expr); - if (TREE_CODE (e) == NOP_EXPR) - /* The call to perform_qualification_conversions will - insert a NOP_EXPR over EXPR to do express conversion, - if necessary. But, that will confuse us if we use - this (converted) template parameter to instantiate - another template; then the thing will not look like a - valid template argument. So, just make a new - constant, of the appropriate type. */ - e = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr)); - return e; - } - else if (TREE_CODE (type_pointed_to) == FUNCTION_TYPE) - { - /* For a non-type template-parameter of type pointer to - function, only the function-to-pointer conversion - (_conv.func_) is applied. If the template-argument - represents a set of overloaded functions (or a pointer to - such), the matching function is selected from the set - (_over.over_). */ - tree fns; - tree fn; - - if (TREE_CODE (expr) == ADDR_EXPR) - fns = TREE_OPERAND (expr, 0); - else - fns = expr; - - fn = instantiate_type (type_pointed_to, fns, 0); - - if (fn == error_mark_node) - return error_mark_node; - - if (!TREE_PUBLIC (fn)) - { - if (really_overloaded_fn (fns)) - return error_mark_node; - else - goto bad_argument; - } - - expr = build_unary_op (ADDR_EXPR, fn, 0); - - my_friendly_assert (same_type_p (type, TREE_TYPE (expr)), - 0); - return expr; - } - else - { - /* For a non-type template-parameter of type pointer to - object, qualification conversions (_conv.qual_) and the - array-to-pointer conversion (_conv.array_) are applied. - [Note: In particular, neither the null pointer conversion - (_conv.ptr_) nor the derived-to-base conversion - (_conv.ptr_) are applied. Although 0 is a valid - template-argument for a non-type template-parameter of - integral type, it is not a valid template-argument for a - non-type template-parameter of pointer type.] - - The call to decay_conversion performs the - array-to-pointer conversion, if appropriate. */ - expr = decay_conversion (expr); - - if (expr == error_mark_node) - return error_mark_node; - else - return perform_qualification_conversions (type, expr); - } - } - break; - - case REFERENCE_TYPE: - { - tree type_referred_to = TREE_TYPE (type); - - if (TREE_CODE (type_referred_to) == FUNCTION_TYPE) - { - /* For a non-type template-parameter of type reference to - function, no conversions apply. If the - template-argument represents a set of overloaded - functions, the matching function is selected from the - set (_over.over_). */ - tree fns = expr; - tree fn; - - fn = instantiate_type (type_referred_to, fns, 0); - - if (fn == error_mark_node) - return error_mark_node; - - if (!TREE_PUBLIC (fn)) - { - if (really_overloaded_fn (fns)) - /* Don't issue an error here; we might get a different - function if the overloading had worked out - differently. */ - return error_mark_node; - else - goto bad_argument; - } - - my_friendly_assert (same_type_p (type_referred_to, - TREE_TYPE (fn)), - 0); - - return fn; - } - else - { - /* For a non-type template-parameter of type reference to - object, no conversions apply. The type referred to by the - reference may be more cv-qualified than the (otherwise - identical) type of the template-argument. The - template-parameter is bound directly to the - template-argument, which must be an lvalue. */ - if ((TYPE_MAIN_VARIANT (expr_type) - != TYPE_MAIN_VARIANT (type_referred_to)) - || !at_least_as_qualified_p (type_referred_to, - expr_type) - || !real_lvalue_p (expr)) - return error_mark_node; - else - return expr; - } - } - break; - - case RECORD_TYPE: - { - if (!TYPE_PTRMEMFUNC_P (type)) - /* This handles templates like - template<class T, T t> void f(); - when T is substituted with any class. The second template - parameter becomes invalid and the template candidate is - rejected. */ - return error_mark_node; - - /* For a non-type template-parameter of type pointer to member - function, no conversions apply. If the template-argument - represents a set of overloaded member functions, the - matching member function is selected from the set - (_over.over_). */ - - if (!TYPE_PTRMEMFUNC_P (expr_type) && - expr_type != unknown_type_node) - return error_mark_node; - - if (TREE_CODE (expr) == PTRMEM_CST) - { - /* A ptr-to-member constant. */ - if (!same_type_p (type, expr_type)) - return error_mark_node; - else - return expr; - } - - if (TREE_CODE (expr) != ADDR_EXPR) - return error_mark_node; - - expr = instantiate_type (type, expr, 0); - - if (expr == error_mark_node) - return error_mark_node; - - my_friendly_assert (same_type_p (type, TREE_TYPE (expr)), - 0); - return expr; - } - break; - - default: - /* All non-type parameters must have one of these types. */ - my_friendly_abort (0); - break; - } - - return error_mark_node; -} - -/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for - template template parameters. Both PARM_PARMS and ARG_PARMS are - vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL - or PARM_DECL. - - ARG_PARMS may contain more parameters than PARM_PARMS. If this is - the case, then extra parameters must have default arguments. - - Consider the example: - template <class T, class Allocator = allocator> class vector; - template<template <class U> class TT> class C; - - C<vector> is a valid instantiation. PARM_PARMS for the above code - contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for - T and Allocator) and OUTER_ARGS contains the argument that is used to - substitute the TT parameter. */ - -static int -coerce_template_template_parms (parm_parms, arg_parms, complain, - in_decl, outer_args) - tree parm_parms, arg_parms; - int complain; - tree in_decl, outer_args; -{ - int nparms, nargs, i; - tree parm, arg; - - my_friendly_assert (TREE_CODE (parm_parms) == TREE_VEC, 0); - my_friendly_assert (TREE_CODE (arg_parms) == TREE_VEC, 0); - - nparms = TREE_VEC_LENGTH (parm_parms); - nargs = TREE_VEC_LENGTH (arg_parms); - - /* The rule here is opposite of coerce_template_parms. */ - if (nargs < nparms - || (nargs > nparms - && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE)) - return 0; - - for (i = 0; i < nparms; ++i) - { - parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i)); - arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i)); - - if (arg == NULL_TREE || arg == error_mark_node - || parm == NULL_TREE || parm == error_mark_node) - return 0; - - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 0; - - switch (TREE_CODE (parm)) - { - case TYPE_DECL: - break; - - case TEMPLATE_DECL: - /* We encounter instantiations of templates like - template <template <template <class> class> class TT> - class C; */ - { - tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); - tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); - - if (!coerce_template_template_parms (parmparm, argparm, - complain, in_decl, - outer_args)) - return 0; - } - break; - - case PARM_DECL: - /* The tsubst call is used to handle cases such as - template <class T, template <T> class TT> class D; - i.e. the parameter list of TT depends on earlier parameters. */ - if (!same_type_p (tsubst (TREE_TYPE (parm), outer_args, - complain, in_decl), - TREE_TYPE (arg))) - return 0; - break; - - default: - my_friendly_abort (0); - } - } - return 1; -} - -/* 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. */ - -static tree -convert_template_argument (parm, arg, args, complain, i, in_decl) - tree parm; - tree arg; - tree args; - int complain; - int i; - tree in_decl; -{ - tree val; - tree inner_args; - int is_type, requires_type, is_tmpl_type, requires_tmpl_type; - - inner_args = innermost_args (args); - - if (TREE_CODE (arg) == TREE_LIST - && TREE_TYPE (arg) != NULL_TREE - && TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE) - { - /* The template argument was the name of some - member function. That's usually - illegal, but static members are OK. In any - case, grab the underlying fields/functions - and issue an error later if required. */ - arg = TREE_VALUE (arg); - TREE_TYPE (arg) = unknown_type_node; - } - - requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL; - requires_type = (TREE_CODE (parm) == TYPE_DECL - || requires_tmpl_type); - - /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true, - we also accept implicitly created TYPE_DECL as a valid argument. - This is necessary to handle the case where we pass a template name - to a template template parameter in a scope where we've derived from - in instantiation of that template, so the template name refers to that - instantiation. We really ought to handle this better. */ - is_tmpl_type - = ((TREE_CODE (arg) == TEMPLATE_DECL - && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL) - || (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM - && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg)) - || (TREE_CODE (arg) == RECORD_TYPE - && CLASSTYPE_TEMPLATE_INFO (arg) - && TREE_CODE (TYPE_NAME (arg)) == TYPE_DECL - && DECL_ARTIFICIAL (TYPE_NAME (arg)) - && requires_tmpl_type - && is_base_of_enclosing_class (arg, current_class_type))); - if (is_tmpl_type && TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) - arg = TYPE_STUB_DECL (arg); - else if (is_tmpl_type && TREE_CODE (arg) == RECORD_TYPE) - arg = CLASSTYPE_TI_TEMPLATE (arg); - - is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't' || is_tmpl_type; - - if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF - && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM) - { - cp_pedwarn ("to refer to a type member of a template parameter,"); - cp_pedwarn (" use `typename %E'", arg); - - arg = make_typename_type (TREE_OPERAND (arg, 0), - TREE_OPERAND (arg, 1)); - is_type = 1; - } - if (is_type != requires_type) - { - if (in_decl) - { - if (complain) - { - cp_error ("type/value mismatch at argument %d in template parameter list for `%D'", - i + 1, in_decl); - if (is_type) - cp_error (" expected a constant of type `%T', got `%T'", - TREE_TYPE (parm), - (is_tmpl_type ? DECL_NAME (arg) : arg)); - else - cp_error (" expected a type, got `%E'", arg); - } - } - return error_mark_node; - } - if (is_tmpl_type ^ requires_tmpl_type) - { - if (in_decl && complain) - { - cp_error ("type/value mismatch at argument %d in template parameter list for `%D'", - i + 1, in_decl); - if (is_tmpl_type) - cp_error (" expected a type, got `%T'", DECL_NAME (arg)); - else - cp_error (" expected a class template, got `%T'", arg); - } - return error_mark_node; - } - - if (is_type) - { - if (requires_tmpl_type) - { - tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); - tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); - - if (coerce_template_template_parms (parmparm, argparm, complain, - in_decl, inner_args)) - { - val = arg; - - /* TEMPLATE_TEMPLATE_PARM node is preferred over - TEMPLATE_DECL. */ - if (val != error_mark_node - && DECL_TEMPLATE_TEMPLATE_PARM_P (val)) - val = TREE_TYPE (val); - } - else - { - if (in_decl && complain) - { - cp_error ("type/value mismatch at argument %d in template parameter list for `%D'", - i + 1, in_decl); - cp_error (" expected a template of type `%D', got `%D'", parm, arg); - } - - val = error_mark_node; - } - } - else - { - val = groktypename (arg); - if (! processing_template_decl) - { - /* [basic.link]: A name with no linkage (notably, the - name of a class or enumeration declared in a local - scope) shall not be used to declare an entity with - linkage. This implies that names with no linkage - cannot be used as template arguments. */ - tree t = no_linkage_check (val); - if (t) - { - if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))) - cp_pedwarn - ("template-argument `%T' uses anonymous type", val); - else - cp_error - ("template-argument `%T' uses local type `%T'", - val, t); - return error_mark_node; - } - } - } - } - else - { - tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl); - - if (processing_template_decl) - arg = maybe_fold_nontype_arg (arg); - - if (!uses_template_parms (arg) && !uses_template_parms (t)) - /* We used to call digest_init here. However, digest_init - will report errors, which we don't want when complain - is zero. More importantly, digest_init will try too - hard to convert things: for example, `0' should not be - converted to pointer type at this point according to - the standard. Accepting this is not merely an - extension, since deciding whether or not these - conversions can occur is part of determining which - function template to call, or whether a given epxlicit - argument specification is legal. */ - val = convert_nontype_argument (t, arg); - else - val = arg; - - if (val == NULL_TREE) - val = error_mark_node; - else if (val == error_mark_node && complain) - cp_error ("could not convert template argument `%E' to `%T'", - arg, t); - } - - return val; -} - -/* 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. - - If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be - provided in ARGLIST, or else trailing parameters must have default - values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument - deduction for any unspecified trailing arguments. - - The resulting TREE_VEC is allocated on a temporary obstack, and - must be explicitly copied if it will be permanent. */ - -static tree -coerce_template_parms (parms, args, in_decl, - complain, - require_all_arguments) - tree parms, args; - tree in_decl; - int complain; - int require_all_arguments; -{ - int nparms, nargs, i, lost = 0; - tree inner_args; - tree new_args; - tree new_inner_args; - - inner_args = innermost_args (args); - nargs = NUM_TMPL_ARGS (inner_args); - nparms = TREE_VEC_LENGTH (parms); - - if (nargs > nparms - || (nargs < nparms - && require_all_arguments - && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE)) - { - if (complain) - { - cp_error ("wrong number of template arguments (%d, should be %d)", - nargs, nparms); - - if (in_decl) - cp_error_at ("provided for `%D'", in_decl); - } - - return error_mark_node; - } - - new_inner_args = make_temp_vec (nparms); - new_args = add_outermost_template_args (args, new_inner_args); - for (i = 0; i < nparms; i++) - { - tree arg; - tree parm; - - /* Get the Ith template parameter. */ - parm = TREE_VEC_ELT (parms, i); - - /* Calculate the Ith argument. */ - if (inner_args && TREE_CODE (inner_args) == TREE_LIST) - { - arg = TREE_VALUE (inner_args); - inner_args = TREE_CHAIN (inner_args); - } - else if (i < nargs) - arg = TREE_VEC_ELT (inner_args, i); - /* If no template argument was supplied, look for a default - value. */ - else if (TREE_PURPOSE (parm) == NULL_TREE) - { - /* There was no default value. */ - my_friendly_assert (!require_all_arguments, 0); - break; - } - else if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL) - arg = tsubst (TREE_PURPOSE (parm), new_args, complain, in_decl); - else - arg = tsubst_expr (TREE_PURPOSE (parm), new_args, complain, - in_decl); - - /* Now, convert the Ith argument, as necessary. */ - if (arg == NULL_TREE) - /* We're out of arguments. */ - { - my_friendly_assert (!require_all_arguments, 0); - break; - } - else if (arg == error_mark_node) - { - cp_error ("template argument %d is invalid", i + 1); - arg = error_mark_node; - } - else - arg = convert_template_argument (TREE_VALUE (parm), - arg, new_args, complain, i, - in_decl); - - if (arg == error_mark_node) - lost++; - TREE_VEC_ELT (new_inner_args, i) = arg; - } - - if (lost) - return error_mark_node; - - return new_inner_args; -} - -/* Returns 1 if template args OT and NT are equivalent. */ - -static int -template_args_equal (ot, nt) - tree ot, nt; -{ - if (nt == ot) - return 1; - if (TREE_CODE (nt) != TREE_CODE (ot)) - return 0; - if (TREE_CODE (nt) == TREE_VEC) - /* For member templates */ - return comp_template_args (ot, nt); - else if (TREE_CODE_CLASS (TREE_CODE (ot)) == 't') - return same_type_p (ot, nt); - else - return (cp_tree_equal (ot, nt) > 0); -} - -/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets - of template arguments. Returns 0 otherwise. */ - -int -comp_template_args (oldargs, newargs) - tree oldargs, newargs; -{ - int i; - - if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs)) - return 0; - - for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i) - { - tree nt = TREE_VEC_ELT (newargs, i); - tree ot = TREE_VEC_ELT (oldargs, i); - - if (! template_args_equal (ot, nt)) - return 0; - } - return 1; -} - -/* Given class template name and parameter list, produce a user-friendly name - for the instantiation. */ - -static char * -mangle_class_name_for_template (name, parms, arglist) - char *name; - tree parms, arglist; -{ - static struct obstack scratch_obstack; - static char *scratch_firstobj; - int i, nparms; - - if (!scratch_firstobj) - gcc_obstack_init (&scratch_obstack); - else - obstack_free (&scratch_obstack, scratch_firstobj); - scratch_firstobj = obstack_alloc (&scratch_obstack, 1); - -#define ccat(c) obstack_1grow (&scratch_obstack, (c)); -#define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s)) - - cat (name); - ccat ('<'); - nparms = TREE_VEC_LENGTH (parms); - arglist = innermost_args (arglist); - my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268); - for (i = 0; i < nparms; i++) - { - tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); - tree arg = TREE_VEC_ELT (arglist, i); - - if (i) - ccat (','); - - if (TREE_CODE (parm) == TYPE_DECL) - { - cat (type_as_string_real (arg, 0, 1)); - continue; - } - else if (TREE_CODE (parm) == TEMPLATE_DECL) - { - if (TREE_CODE (arg) == TEMPLATE_DECL) - { - /* Already substituted with real template. Just output - the template name here */ - tree context = DECL_CONTEXT (arg); - if (context) - { - my_friendly_assert (TREE_CODE (context) == NAMESPACE_DECL, 980422); - cat(decl_as_string (DECL_CONTEXT (arg), 0)); - cat("::"); - } - cat (IDENTIFIER_POINTER (DECL_NAME (arg))); - } - else - /* Output the parameter declaration */ - cat (type_as_string_real (arg, 0, 1)); - continue; - } - else - my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269); - - if (TREE_CODE (arg) == TREE_LIST) - { - /* New list cell was built because old chain link was in - use. */ - my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270); - arg = TREE_VALUE (arg); - } - /* No need to check arglist against parmlist here; we did that - in coerce_template_parms, called from lookup_template_class. */ - cat (expr_as_string (arg, 0)); - } - { - char *bufp = obstack_next_free (&scratch_obstack); - int offset = 0; - while (bufp[offset - 1] == ' ') - offset--; - obstack_blank_fast (&scratch_obstack, offset); - - /* B<C<char> >, not B<C<char>> */ - if (bufp[offset - 1] == '>') - ccat (' '); - } - ccat ('>'); - ccat ('\0'); - return (char *) obstack_base (&scratch_obstack); -} - -static tree -classtype_mangled_name (t) - tree t; -{ - if (CLASSTYPE_TEMPLATE_INFO (t) - /* Specializations have already had their names set up in - lookup_template_class. */ - && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) - { - tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t)); - - /* For non-primary templates, the template parameters are - implicit from their surrounding context. */ - if (PRIMARY_TEMPLATE_P (tmpl)) - { - tree name = DECL_NAME (tmpl); - char *mangled_name = mangle_class_name_for_template - (IDENTIFIER_POINTER (name), - DECL_INNERMOST_TEMPLATE_PARMS (tmpl), - CLASSTYPE_TI_ARGS (t)); - tree id = get_identifier (mangled_name); - IDENTIFIER_TEMPLATE (id) = name; - return id; - } - } - - return TYPE_IDENTIFIER (t); -} - -static void -add_pending_template (d) - tree d; -{ - tree ti; - - if (TREE_CODE_CLASS (TREE_CODE (d)) == 't') - ti = CLASSTYPE_TEMPLATE_INFO (d); - else - ti = DECL_TEMPLATE_INFO (d); - - if (TI_PENDING_TEMPLATE_FLAG (ti)) - return; - - *template_tail = perm_tree_cons - (build_srcloc_here (), d, NULL_TREE); - template_tail = &TREE_CHAIN (*template_tail); - TI_PENDING_TEMPLATE_FLAG (ti) = 1; -} - - -/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which - may be either a _DECL or an overloaded function or an - IDENTIFIER_NODE), and ARGLIST. */ - -tree -lookup_template_function (fns, arglist) - tree fns, arglist; -{ - tree type; - - if (fns == NULL_TREE) - { - cp_error ("non-template used as template"); - return error_mark_node; - } - - type = TREE_TYPE (fns); - if (TREE_CODE (fns) == OVERLOAD || !type) - type = unknown_type_node; - - if (processing_template_decl) - return build_min (TEMPLATE_ID_EXPR, type, fns, arglist); - else - return build (TEMPLATE_ID_EXPR, type, fns, arglist); -} - -/* Within the scope of a template class S<T>, the name S gets bound - (in build_self_reference) to a TYPE_DECL for the class, not a - TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type, - or one of its enclosing classes, and that type is a template, - return the associated TEMPLATE_DECL. Otherwise, the original - DECL is returned. */ - -static tree -maybe_get_template_decl_from_type_decl (decl) - tree decl; -{ - return (decl != NULL_TREE - && TREE_CODE (decl) == TYPE_DECL - && DECL_ARTIFICIAL (decl) - && CLASS_TYPE_P (TREE_TYPE (decl)) - && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl))) - ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl; -} - -/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of - parameters, find the desired type. - - D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments. - (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will - be a TREE_LIST if called directly from the parser, and a TREE_VEC - otherwise.) Since ARGLIST is build on the decl_obstack, we must - copy it here to keep it from being reclaimed when the decl storage - is reclaimed. - - IN_DECL, if non-NULL, is the template declaration we are trying to - instantiate. - - If ENTERING_SCOPE is non-zero, we are about to enter the scope of - the class we are looking up. - - If the template class is really a local class in a template - function, then the FUNCTION_CONTEXT is the function in which it is - being instantiated. */ - -tree -lookup_template_class (d1, arglist, in_decl, context, entering_scope) - tree d1, arglist; - tree in_decl; - tree context; - int entering_scope; -{ - tree template = NULL_TREE, parmlist; - tree t; - - if (TREE_CODE (d1) == IDENTIFIER_NODE) - { - if (IDENTIFIER_VALUE (d1) - && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1))) - template = IDENTIFIER_VALUE (d1); - else - { - if (context) - push_decl_namespace (context); - if (current_class_type != NULL_TREE) - template = - maybe_get_template_decl_from_type_decl - (IDENTIFIER_CLASS_VALUE (d1)); - if (template == NULL_TREE) - template = lookup_name_nonclass (d1); - if (context) - pop_decl_namespace (); - } - if (template) - context = DECL_CONTEXT (template); - } - else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1))) - { - tree type = TREE_TYPE (d1); - - /* If we are declaring a constructor, say A<T>::A<T>, we will get - an implicit typename for the second A. Deal with it. */ - if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type)) - type = TREE_TYPE (type); - - if (CLASSTYPE_TEMPLATE_INFO (type)) - { - template = CLASSTYPE_TI_TEMPLATE (type); - d1 = DECL_NAME (template); - } - } - else if (TREE_CODE (d1) == ENUMERAL_TYPE - || (TREE_CODE_CLASS (TREE_CODE (d1)) == 't' - && IS_AGGR_TYPE (d1))) - { - template = TYPE_TI_TEMPLATE (d1); - d1 = DECL_NAME (template); - } - else if (TREE_CODE (d1) == TEMPLATE_DECL - && TREE_CODE (DECL_RESULT (d1)) == TYPE_DECL) - { - template = d1; - d1 = DECL_NAME (template); - context = DECL_CONTEXT (template); - } - else - my_friendly_abort (272); - - /* With something like `template <class T> class X class X { ... };' - we could end up with D1 having nothing but an IDENTIFIER_VALUE. - We don't want to do that, but we have to deal with the situation, - so let's give them some syntax errors to chew on instead of a - crash. */ - if (! template) - { - cp_error ("`%T' is not a template", d1); - return error_mark_node; - } - - if (context == NULL_TREE) - context = global_namespace; - - if (TREE_CODE (template) != TEMPLATE_DECL) - { - cp_error ("non-template type `%T' used as a template", d1); - if (in_decl) - cp_error_at ("for template declaration `%D'", in_decl); - return error_mark_node; - } - - if (DECL_TEMPLATE_TEMPLATE_PARM_P (template)) - { - /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store - template arguments */ - - tree parm = copy_template_template_parm (TREE_TYPE (template)); - tree template2 = TYPE_STUB_DECL (parm); - tree arglist2; - - parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template); - - arglist2 = coerce_template_parms (parmlist, arglist, template, 1, 1); - if (arglist2 == error_mark_node) - return error_mark_node; - - arglist2 = copy_to_permanent (arglist2); - TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm) - = perm_tree_cons (template2, arglist2, NULL_TREE); - TYPE_SIZE (parm) = 0; - return parm; - } - else - { - tree template_type = TREE_TYPE (template); - tree gen_tmpl; - tree type_decl; - tree found = NULL_TREE; - int arg_depth; - int parm_depth; - int is_partial_instantiation; - - gen_tmpl = most_general_template (template); - parmlist = DECL_TEMPLATE_PARMS (gen_tmpl); - parm_depth = TMPL_PARMS_DEPTH (parmlist); - arg_depth = TMPL_ARGS_DEPTH (arglist); - - /* We build up the coerced arguments and such on the - momentary_obstack. */ - push_momentary (); - - if (arg_depth == 1 && parm_depth > 1) - { - /* We've been given an incomplete set of template arguments. - For example, given: - - template <class T> struct S1 { - template <class U> struct S2 {}; - template <class U> struct S2<U*> {}; - }; - - we will be called with an ARGLIST of `U*', but the - TEMPLATE will be `template <class T> template - <class U> struct S1<T>::S2'. We must fill in the missing - arguments. */ - arglist - = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)), - arglist); - arg_depth = TMPL_ARGS_DEPTH (arglist); - } - - /* Now we should enough arguments. */ - my_friendly_assert (parm_depth == arg_depth, 0); - - /* From here on, we're only interested in the most general - template. */ - template = gen_tmpl; - - /* Calculate the BOUND_ARGS. These will be the args that are - actually tsubst'd into the definition to create the - instantiation. */ - if (parm_depth > 1) - { - /* We have multiple levels of arguments to coerce, at once. */ - int i; - int saved_depth = TMPL_ARGS_DEPTH (arglist); - - tree bound_args = make_temp_vec (parm_depth); - - for (i = saved_depth, - t = DECL_TEMPLATE_PARMS (template); - i > 0 && t != NULL_TREE; - --i, t = TREE_CHAIN (t)) - { - tree a = coerce_template_parms (TREE_VALUE (t), - arglist, template, 1, 1); - SET_TMPL_ARGS_LEVEL (bound_args, i, a); - - /* We temporarily reduce the length of the ARGLIST so - that coerce_template_parms will see only the arguments - corresponding to the template parameters it is - examining. */ - TREE_VEC_LENGTH (arglist)--; - } - - /* Restore the ARGLIST to its full size. */ - TREE_VEC_LENGTH (arglist) = saved_depth; - - arglist = bound_args; - } - else - arglist - = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist), - innermost_args (arglist), - template, 1, 1); - - if (arglist == error_mark_node) - /* We were unable to bind the arguments. */ - return error_mark_node; - - /* In the scope of a template class, explicit references to the - template class refer to the type of the template, not any - instantiation of it. For example, in: - - template <class T> class C { void f(C<T>); } - - the `C<T>' is just the same as `C'. Outside of the - class, however, such a reference is an instantiation. */ - if (comp_template_args (TYPE_TI_ARGS (template_type), - arglist)) - { - found = template_type; - - if (!entering_scope && PRIMARY_TEMPLATE_P (template)) - { - tree ctx; - - /* Note that we use DECL_CONTEXT, rather than - CP_DECL_CONTEXT, so that the termination test is - always just `ctx'. We're not interested in namepace - scopes. */ - for (ctx = current_class_type; - ctx; - ctx = (TREE_CODE_CLASS (TREE_CODE (ctx)) == 't') - ? TYPE_CONTEXT (ctx) : DECL_CONTEXT (ctx)) - if (same_type_p (ctx, template_type)) - break; - - if (!ctx) - /* We're not in the scope of the class, so the - TEMPLATE_TYPE is not the type we want after - all. */ - found = NULL_TREE; - } - } - - if (!found) - { - for (found = DECL_TEMPLATE_INSTANTIATIONS (template); - found; found = TREE_CHAIN (found)) - if (comp_template_args (TREE_PURPOSE (found), arglist)) - break; - - if (found) - found = TREE_VALUE (found); - } - - if (found) - { - pop_momentary (); - return found; - } - - /* Since we didn't find the type, we'll have to create it. - Since we'll be saving this type on the - DECL_TEMPLATE_INSTANTIATIONS list, it must be permanent. */ - push_obstacks (&permanent_obstack, &permanent_obstack); - - /* This type is a "partial instantiation" if any of the template - arguments still inolve template parameters. Note that we set - IS_PARTIAL_INSTANTIATION for partial specializations as - well. */ - is_partial_instantiation = uses_template_parms (arglist); - - /* Create the type. */ - if (TREE_CODE (template_type) == ENUMERAL_TYPE) - { - if (!is_partial_instantiation) - t = start_enum (TYPE_IDENTIFIER (template_type)); - else - /* We don't want to call start_enum for this type, since - the values for the enumeration constants may involve - template parameters. And, no one should be interested - in the enumeration constants for such a type. */ - t = make_node (ENUMERAL_TYPE); - } - else - { - t = make_lang_type (TREE_CODE (template_type)); - CLASSTYPE_DECLARED_CLASS (t) - = CLASSTYPE_DECLARED_CLASS (template_type); - CLASSTYPE_GOT_SEMICOLON (t) = 1; - SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t); - TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type); - } - - /* If we called start_enum above, this information will already - be set up. */ - if (!TYPE_NAME (t)) - { - TYPE_CONTEXT (t) = FROB_CONTEXT (context); - - /* Create a stub TYPE_DECL for it. */ - type_decl = build_decl (TYPE_DECL, DECL_NAME (template), t); - SET_DECL_ARTIFICIAL (type_decl); - DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t); - DECL_SOURCE_FILE (type_decl) - = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type)); - DECL_SOURCE_LINE (type_decl) - = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type)); - TYPE_STUB_DECL (t) = TYPE_NAME (t) = type_decl; - } - else - type_decl = TYPE_NAME (t); - - /* Set up the template information. We have to figure out which - template is the immediate parent if this is a full - instantiation. */ - if (parm_depth == 1 || is_partial_instantiation - || !PRIMARY_TEMPLATE_P (template)) - /* This case is easy; there are no member templates involved. */ - found = template; - else - { - /* This is a full instantiation of a member template. There - should be some partial instantiation of which this is an - instance. */ - - for (found = DECL_TEMPLATE_INSTANTIATIONS (template); - found; found = TREE_CHAIN (found)) - { - int success; - tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found)); - - /* We only want partial instantiations, here, not - specializations or full instantiations. */ - if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found)) - || !uses_template_parms (TREE_VALUE (found))) - continue; - - /* Temporarily reduce by one the number of levels in the - ARGLIST and in FOUND so as to avoid comparing the - last set of arguments. */ - TREE_VEC_LENGTH (arglist)--; - TREE_VEC_LENGTH (TREE_PURPOSE (found)) --; - - /* See if the arguments match. If they do, then TMPL is - the partial instantiation we want. */ - success = comp_template_args (TREE_PURPOSE (found), arglist); - - /* Restore the argument vectors to their full size. */ - TREE_VEC_LENGTH (arglist)++; - TREE_VEC_LENGTH (TREE_PURPOSE (found))++; - - if (success) - { - found = tmpl; - break; - } - } - - if (!found) - my_friendly_abort (0); - } - - arglist = copy_to_permanent (arglist); - SET_TYPE_TEMPLATE_INFO (t, - tree_cons (found, arglist, NULL_TREE)); - DECL_TEMPLATE_INSTANTIATIONS (template) - = tree_cons (arglist, t, - DECL_TEMPLATE_INSTANTIATIONS (template)); - - if (TREE_CODE (t) == ENUMERAL_TYPE - && !is_partial_instantiation) - /* Now that the type has been registered on the instantiations - list, we set up the enumerators. Because the enumeration - constants may involve the enumeration type itself, we make - sure to register the type first, and then create the - constants. That way, doing tsubst_expr for the enumeration - constants won't result in recursive calls here; we'll find - the instantiation and exit above. */ - tsubst_enum (template_type, t, arglist); - - /* We're done with the permanent obstack, now. */ - pop_obstacks (); - /* We're also done with the momentary allocation we started - above. */ - pop_momentary (); - - /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO - is set up. */ - if (TREE_CODE (t) != ENUMERAL_TYPE) - DECL_NAME (type_decl) = classtype_mangled_name (t); - DECL_ASSEMBLER_NAME (type_decl) = DECL_NAME (type_decl); - if (!is_partial_instantiation) - { - DECL_ASSEMBLER_NAME (type_decl) - = get_identifier (build_overload_name (t, 1, 1)); - - /* For backwards compatibility; code that uses - -fexternal-templates expects looking up a template to - instantiate it. I think DDD still relies on this. - (jason 8/20/1998) */ - if (TREE_CODE (t) != ENUMERAL_TYPE - && flag_external_templates - && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template)) - && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template))) - add_pending_template (t); - } - else - /* If the type makes use of template parameters, the - code that generates debugging information will crash. */ - DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1; - - return t; - } -} - -/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or - TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA. - If FN returns non-zero, the iteration is terminated, and - for_each_template_parm returns 1. Otherwise, the iteration - continues. If FN never returns a non-zero value, the value - returned by for_each_template_parm is 0. If FN is NULL, it is - considered to be the function which always returns 1. */ - -static int -for_each_template_parm (t, fn, data) - tree t; - tree_fn_t fn; - void* data; -{ - if (!t) - return 0; - - if (TREE_CODE_CLASS (TREE_CODE (t)) == 't' - && for_each_template_parm (TYPE_CONTEXT (t), fn, data)) - return 1; - - switch (TREE_CODE (t)) - { - case INDIRECT_REF: - case COMPONENT_REF: - /* We assume that the object must be instantiated in order to build - the COMPONENT_REF, so we test only whether the type of the - COMPONENT_REF uses template parms. */ - return for_each_template_parm (TREE_TYPE (t), fn, data); - - case ARRAY_REF: - case OFFSET_REF: - return (for_each_template_parm (TREE_OPERAND (t, 0), fn, data) - || for_each_template_parm (TREE_OPERAND (t, 1), fn, data)); - - case IDENTIFIER_NODE: - if (!IDENTIFIER_TEMPLATE (t)) - return 0; - my_friendly_abort (42); - - /* aggregates of tree nodes */ - case TREE_VEC: - { - int i = TREE_VEC_LENGTH (t); - while (i--) - if (for_each_template_parm (TREE_VEC_ELT (t, i), fn, data)) - return 1; - return 0; - } - case TREE_LIST: - if (for_each_template_parm (TREE_PURPOSE (t), fn, data) - || for_each_template_parm (TREE_VALUE (t), fn, data)) - return 1; - return for_each_template_parm (TREE_CHAIN (t), fn, data); - - case OVERLOAD: - if (for_each_template_parm (OVL_FUNCTION (t), fn, data)) - return 1; - return for_each_template_parm (OVL_CHAIN (t), fn, data); - - /* constructed type nodes */ - case POINTER_TYPE: - case REFERENCE_TYPE: - return for_each_template_parm (TREE_TYPE (t), fn, data); - - case RECORD_TYPE: - if (TYPE_PTRMEMFUNC_FLAG (t)) - return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE (t), - fn, data); - /* Fall through. */ - - case UNION_TYPE: - case ENUMERAL_TYPE: - if (! TYPE_TEMPLATE_INFO (t)) - return 0; - return for_each_template_parm (TREE_VALUE - (TYPE_TEMPLATE_INFO (t)), - fn, data); - case METHOD_TYPE: - if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data)) - return 1; - /* Fall through. */ - - case FUNCTION_TYPE: - /* Check the parameter types. Since default arguments are not - instantiated until they are needed, the TYPE_ARG_TYPES may - contain expressions that involve template parameters. But, - no-one should be looking at them yet. And, once they're - instantiated, they don't contain template parameters, so - there's no point in looking at them then, either. */ - { - tree parm; - - for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm)) - if (for_each_template_parm (TREE_VALUE (parm), fn, data)) - return 1; - } - - /* Check the return type, too. */ - return for_each_template_parm (TREE_TYPE (t), fn, data); - - case ARRAY_TYPE: - if (for_each_template_parm (TYPE_DOMAIN (t), fn, data)) - return 1; - return for_each_template_parm (TREE_TYPE (t), fn, data); - case OFFSET_TYPE: - if (for_each_template_parm (TYPE_OFFSET_BASETYPE (t), fn, data)) - return 1; - return for_each_template_parm (TREE_TYPE (t), fn, data); - - /* decl nodes */ - case TYPE_DECL: - return for_each_template_parm (TREE_TYPE (t), fn, data); - - case TEMPLATE_DECL: - /* A template template parameter is encountered */ - if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) - return for_each_template_parm (TREE_TYPE (t), fn, data); - /* Already substituted template template parameter */ - return 0; - - case CONST_DECL: - if (for_each_template_parm (DECL_INITIAL (t), fn, data)) - return 1; - goto check_type_and_context; - - case FUNCTION_DECL: - case VAR_DECL: - /* ??? What about FIELD_DECLs? */ - if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t) - && for_each_template_parm (DECL_TI_ARGS (t), fn, data)) - return 1; - /* fall through */ - case PARM_DECL: - check_type_and_context: - if (for_each_template_parm (TREE_TYPE (t), fn, data)) - return 1; - if (DECL_CONTEXT (t) - && for_each_template_parm (DECL_CONTEXT (t), fn, data)) - return 1; - return 0; - - case CALL_EXPR: - return (for_each_template_parm (TREE_OPERAND (t, 0), fn, data) - || for_each_template_parm (TREE_OPERAND (t, 1), fn, data)); - - case ADDR_EXPR: - return for_each_template_parm (TREE_OPERAND (t, 0), fn, data); - - /* template parm nodes */ - case TEMPLATE_TEMPLATE_PARM: - /* Record template parameters such as `T' inside `TT<T>'. */ - if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t) - && for_each_template_parm (TYPE_TI_ARGS (t), fn, data)) - return 1; - case TEMPLATE_TYPE_PARM: - case TEMPLATE_PARM_INDEX: - if (fn) - return (*fn)(t, data); - else - return 1; - - /* simple type nodes */ - case INTEGER_TYPE: - if (for_each_template_parm (TYPE_MIN_VALUE (t), fn, data)) - return 1; - return for_each_template_parm (TYPE_MAX_VALUE (t), fn, data); - - case REAL_TYPE: - case COMPLEX_TYPE: - case VOID_TYPE: - case BOOLEAN_TYPE: - case NAMESPACE_DECL: - return 0; - - /* constants */ - case INTEGER_CST: - case REAL_CST: - case STRING_CST: - return 0; - - case ERROR_MARK: - /* Non-error_mark_node ERROR_MARKs are bad things. */ - my_friendly_assert (t == error_mark_node, 274); - /* NOTREACHED */ - return 0; - - case LOOKUP_EXPR: - case TYPENAME_TYPE: - return 1; - - case PTRMEM_CST: - return for_each_template_parm (TREE_TYPE (t), fn, data); - - case SCOPE_REF: - return for_each_template_parm (TREE_OPERAND (t, 0), fn, data); - - case CONSTRUCTOR: - if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) - return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE - (TREE_TYPE (t)), fn, data); - return for_each_template_parm (TREE_OPERAND (t, 1), fn, data); - - case MODOP_EXPR: - case CAST_EXPR: - case REINTERPRET_CAST_EXPR: - case CONST_CAST_EXPR: - case STATIC_CAST_EXPR: - case DYNAMIC_CAST_EXPR: - case ARROW_EXPR: - case DOTSTAR_EXPR: - case TYPEID_EXPR: - return 1; - - case SIZEOF_EXPR: - case ALIGNOF_EXPR: - return for_each_template_parm (TREE_OPERAND (t, 0), fn, data); - - default: - switch (TREE_CODE_CLASS (TREE_CODE (t))) - { - case '1': - case '2': - case 'e': - case '<': - { - int i; - for (i = first_rtl_op (TREE_CODE (t)); --i >= 0;) - if (for_each_template_parm (TREE_OPERAND (t, i), fn, data)) - return 1; - return 0; - } - default: - break; - } - sorry ("testing %s for template parms", - tree_code_name [(int) TREE_CODE (t)]); - my_friendly_abort (82); - /* NOTREACHED */ - return 0; - } -} - -int -uses_template_parms (t) - tree t; -{ - return for_each_template_parm (t, 0, 0); -} - -static struct tinst_level *current_tinst_level; -static struct tinst_level *free_tinst_level; -static int tinst_depth; -extern int max_tinst_depth; -#ifdef GATHER_STATISTICS -int depth_reached; -#endif -int tinst_level_tick; -int last_template_error_tick; - -/* Print out all the template instantiations that we are currently - working on. If ERR, we are being called from cp_thing, so do - the right thing for an error message. */ - -static void -print_template_context (err) - int err; -{ - struct tinst_level *p = current_tinst_level; - int line = lineno; - char *file = input_filename; - - if (err && p) - { - if (current_function_decl != p->decl - && current_function_decl != NULL_TREE) - /* We can get here during the processing of some synthesized - method. Then, p->decl will be the function that's causing - the synthesis. */ - ; - else - { - if (current_function_decl == p->decl) - /* Avoid redundancy with the the "In function" line. */; - else - fprintf (stderr, "%s: In instantiation of `%s':\n", - file, decl_as_string (p->decl, 0)); - - line = p->line; - file = p->file; - p = p->next; - } - } - - for (; p; p = p->next) - { - fprintf (stderr, "%s:%d: instantiated from `%s'\n", file, line, - decl_as_string (p->decl, 0)); - line = p->line; - file = p->file; - } - fprintf (stderr, "%s:%d: instantiated from here\n", file, line); -} - -/* Called from cp_thing to print the template context for an error. */ - -void -maybe_print_template_context () -{ - if (last_template_error_tick == tinst_level_tick - || current_tinst_level == 0) - return; - - last_template_error_tick = tinst_level_tick; - print_template_context (1); -} - -static int -push_tinst_level (d) - tree d; -{ - struct tinst_level *new; - - if (tinst_depth >= max_tinst_depth) - { - /* If the instantiation in question still has unbound template parms, - we don't really care if we can't instantiate it, so just return. - This happens with base instantiation for implicit `typename'. */ - if (uses_template_parms (d)) - return 0; - - last_template_error_tick = tinst_level_tick; - error ("template instantiation depth exceeds maximum of %d", - max_tinst_depth); - error (" (use -ftemplate-depth-NN to increase the maximum)"); - cp_error (" instantiating `%D'", d); - - print_template_context (0); - - return 0; - } - - if (free_tinst_level) - { - new = free_tinst_level; - free_tinst_level = new->next; - } - else - new = (struct tinst_level *) xmalloc (sizeof (struct tinst_level)); - - new->decl = d; - new->line = lineno; - new->file = input_filename; - new->next = current_tinst_level; - current_tinst_level = new; - - ++tinst_depth; -#ifdef GATHER_STATISTICS - if (tinst_depth > depth_reached) - depth_reached = tinst_depth; -#endif - - ++tinst_level_tick; - return 1; -} - -void -pop_tinst_level () -{ - struct tinst_level *old = current_tinst_level; - - /* Restore the filename and line number stashed away when we started - this instantiation. */ - lineno = old->line; - input_filename = old->file; - extract_interface_info (); - - current_tinst_level = old->next; - old->next = free_tinst_level; - free_tinst_level = old; - --tinst_depth; - ++tinst_level_tick; -} - -struct tinst_level * -tinst_for_decl () -{ - struct tinst_level *p = current_tinst_level; - - if (p) - for (; p->next ; p = p->next ) - ; - return p; -} - -/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the - vector of template arguments, as for tsubst. - - Returns an appropriate tsbust'd friend declaration. */ - -static tree -tsubst_friend_function (decl, args) - tree decl; - tree args; -{ - tree new_friend; - int line = lineno; - char *file = input_filename; - - lineno = DECL_SOURCE_LINE (decl); - input_filename = DECL_SOURCE_FILE (decl); - - if (TREE_CODE (decl) == FUNCTION_DECL - && DECL_TEMPLATE_INSTANTIATION (decl) - && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL) - /* This was a friend declared with an explicit template - argument list, e.g.: - - friend void f<>(T); - - to indicate that f was a template instantiation, not a new - function declaration. Now, we have to figure out what - instantiation of what template. */ - { - tree template_id; - tree new_args; - tree tmpl; - - template_id - = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl), - args, /*complain=*/1, - NULL_TREE), - tsubst (DECL_TI_ARGS (decl), - args, /*complain=*/1, - NULL_TREE)); - /* FIXME: The decl we create via the next tsubst could be - created on a temporary obstack. */ - new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE); - tmpl = determine_specialization (template_id, new_friend, - &new_args, - /*need_member_template=*/0); - new_friend = instantiate_template (tmpl, new_args); - goto done; - } - - new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE); - - /* The NEW_FRIEND will look like an instantiation, to the - compiler, but is not an instantiation from the point of view of - the language. For example, we might have had: - - template <class T> struct S { - template <class U> friend void f(T, U); - }; - - Then, in S<int>, template <class U> void f(int, U) is not an - instantiation of anything. */ - DECL_USE_TEMPLATE (new_friend) = 0; - if (TREE_CODE (decl) == TEMPLATE_DECL) - DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0; - - /* The mangled name for the NEW_FRIEND is incorrect. The call to - tsubst will have resulted in a call to - set_mangled_name_for_template_decl. But, the function is not a - template instantiation and should not be mangled like one. - Therefore, we remangle the function name. We don't have to do - this if the NEW_FRIEND is a template since - set_mangled_name_for_template_decl doesn't do anything if the - function declaration still uses template arguments. */ - if (TREE_CODE (new_friend) != TEMPLATE_DECL) - { - set_mangled_name_for_decl (new_friend); - DECL_RTL (new_friend) = 0; - make_decl_rtl (new_friend, NULL_PTR, 1); - } - - if (DECL_NAMESPACE_SCOPE_P (new_friend)) - { - tree old_decl; - tree new_friend_template_info; - tree new_friend_result_template_info; - int new_friend_is_defn; - - /* We must save some information from NEW_FRIEND before calling - duplicate decls since that function will free NEW_FRIEND if - possible. */ - new_friend_template_info = DECL_TEMPLATE_INFO (new_friend); - if (TREE_CODE (new_friend) == TEMPLATE_DECL) - { - /* This declaration is a `primary' template. */ - DECL_PRIMARY_TEMPLATE (new_friend) = new_friend; - - new_friend_is_defn - = DECL_INITIAL (DECL_RESULT (new_friend)) != NULL_TREE; - new_friend_result_template_info - = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend)); - } - else - { - new_friend_is_defn = DECL_INITIAL (new_friend) != NULL_TREE; - new_friend_result_template_info = NULL_TREE; - } - - old_decl = pushdecl_namespace_level (new_friend); - - if (old_decl != new_friend) - { - /* This new friend declaration matched an existing - declaration. For example, given: - - template <class T> void f(T); - template <class U> class C { - template <class T> friend void f(T) {} - }; - - the friend declaration actually provides the definition - of `f', once C has been instantiated for some type. So, - old_decl will be the out-of-class template declaration, - while new_friend is the in-class definition. - - But, if `f' was called before this point, the - instantiation of `f' will have DECL_TI_ARGS corresponding - to `T' but not to `U', references to which might appear - in the definition of `f'. Previously, the most general - template for an instantiation of `f' was the out-of-class - version; now it is the in-class version. Therefore, we - run through all specialization of `f', adding to their - DECL_TI_ARGS appropriately. In particular, they need a - new set of outer arguments, corresponding to the - arguments for this class instantiation. - - The same situation can arise with something like this: - - friend void f(int); - template <class T> class C { - friend void f(T) {} - }; - - when `C<int>' is instantiated. Now, `f(int)' is defined - in the class. */ - - if (!new_friend_is_defn) - /* On the other hand, if the in-class declaration does - *not* provide a definition, then we don't want to alter - existing definitions. We can just leave everything - alone. */ - ; - else - { - /* Overwrite whatever template info was there before, if - any, with the new template information pertaining to - the declaration. */ - DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info; - - if (TREE_CODE (old_decl) != TEMPLATE_DECL) - /* duplicate_decls will take care of this case. */ - ; - else - { - tree t; - tree new_friend_args; - - DECL_TEMPLATE_INFO (DECL_RESULT (old_decl)) - = new_friend_result_template_info; - - new_friend_args = TI_ARGS (new_friend_template_info); - for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl); - t != NULL_TREE; - t = TREE_CHAIN (t)) - { - tree spec = TREE_VALUE (t); - - DECL_TI_ARGS (spec) - = add_outermost_template_args (new_friend_args, - DECL_TI_ARGS (spec)); - DECL_TI_ARGS (spec) - = copy_to_permanent (DECL_TI_ARGS (spec)); - } - - /* Now, since specializations are always supposed to - hang off of the most general template, we must move - them. */ - t = most_general_template (old_decl); - if (t != old_decl) - { - DECL_TEMPLATE_SPECIALIZATIONS (t) - = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t), - DECL_TEMPLATE_SPECIALIZATIONS (old_decl)); - DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE; - } - } - } - - /* The information from NEW_FRIEND has been merged into OLD_DECL - by duplicate_decls. */ - new_friend = old_decl; - } - } - else if (TYPE_SIZE (DECL_CONTEXT (new_friend))) - { - /* Check to see that the declaration is really present, and, - possibly obtain an improved declaration. */ - tree fn = check_classfn (DECL_CONTEXT (new_friend), - new_friend); - - if (fn) - new_friend = fn; - } - - done: - lineno = line; - input_filename = file; - return new_friend; -} - -/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of - template arguments, as for tsubst. - - Returns an appropriate tsbust'd friend type. */ - -static tree -tsubst_friend_class (friend_tmpl, args) - tree friend_tmpl; - tree args; -{ - tree friend_type; - tree tmpl; - - /* First, we look for a class template. */ - tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0); - - /* But, if we don't find one, it might be because we're in a - situation like this: - - template <class T> - struct S { - template <class U> - friend struct S; - }; - - Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL - for `S<int>', not the TEMPLATE_DECL. */ - if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) - { - tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1); - tmpl = maybe_get_template_decl_from_type_decl (tmpl); - } - - if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl)) - { - /* The friend template has already been declared. Just - check to see that the declarations match, and install any new - default parameters. We must tsubst the default parameters, - of course. We only need the innermost template parameters - because that is all that redeclare_class_template will look - at. */ - tree parms - = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl), - args, /*complain=*/1); - redeclare_class_template (TREE_TYPE (tmpl), parms); - friend_type = TREE_TYPE (tmpl); - } - else - { - /* 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); - - /* The new TMPL is not an instantiation of anything, so we - forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for - the new type because that is supposed to be the corresponding - template decl, i.e., TMPL. */ - DECL_USE_TEMPLATE (tmpl) = 0; - DECL_TEMPLATE_INFO (tmpl) = NULL_TREE; - CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0; - - /* Inject this template into the global scope. */ - friend_type = TREE_TYPE (pushdecl_top_level (tmpl)); - } - - return friend_type; -} - -static int -has_pvbases_p (t, pattern) - tree t, pattern; -{ - if (!TYPE_USES_VIRTUAL_BASECLASSES (t)) - return 0; - - if (TYPE_USES_PVBASES (pattern)) - return 1; - - for (t = CLASSTYPE_VBASECLASSES (t); t; t = TREE_CHAIN (t)) - if (TYPE_VIRTUAL_P (BINFO_TYPE (t))) - return 1; - - return 0; -} - -tree -instantiate_class_template (type) - tree type; -{ - tree template, args, pattern, t; - tree typedecl; - - if (type == error_mark_node) - return error_mark_node; - - if (TYPE_BEING_DEFINED (type) || TYPE_SIZE (type)) - return type; - - /* We want to allocate temporary vectors of template arguments and - template argument expressions on the momentary obstack, not on - the expression obstack. Otherwise, all the space allocated in - argument coercion and such is simply lost. */ - push_momentary (); - - /* Figure out which template is being instantiated. */ - template = most_general_template (CLASSTYPE_TI_TEMPLATE (type)); - my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279); - - /* Figure out which arguments are being used to do the - instantiation. */ - args = CLASSTYPE_TI_ARGS (type); - PARTIAL_INSTANTIATION_P (type) = uses_template_parms (args); - - if (pedantic && PARTIAL_INSTANTIATION_P (type)) - /* If this is a partial instantiation, then we can't instantiate - the type; there's no telling whether or not one of the - template parameters might eventually be instantiated to some - value that results in a specialization being used. For - example, consider: - - template <class T> - struct S {}; - - template <class U> - void f(S<U>); - - template <> - struct S<int> {}; - - Now, the `S<U>' in `f<int>' is the specialization, not an - instantiation of the original template. */ - goto end; - - /* Determine what specialization of the original template to - instantiate. */ - if (PARTIAL_INSTANTIATION_P (type)) - /* There's no telling which specialization is appropriate at this - point. Since all peeking at the innards of this partial - instantiation are extensions (like the "implicit typename" - extension, which allows users to omit the keyword `typename' on - names that are declared as types in template base classes), we - are free to do what we please. - - Trying to figure out which partial instantiation to use can - cause a crash. (Some of the template arguments don't even have - types.) So, we just use the most general version. */ - t = NULL_TREE; - else - { - t = most_specialized_class (template, args); - - if (t == error_mark_node) - { - const char *str = "candidates are:"; - cp_error ("ambiguous class template instantiation for `%#T'", type); - for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t; - t = TREE_CHAIN (t)) - { - if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), - args)) - { - cp_error_at ("%s %+#T", str, TREE_TYPE (t)); - str = " "; - } - } - TYPE_BEING_DEFINED (type) = 1; - type = error_mark_node; - goto end; - } - } - - if (t) - pattern = TREE_TYPE (t); - else - pattern = TREE_TYPE (template); - - /* If the template we're instantiating is incomplete, then clearly - there's nothing we can do. */ - if (TYPE_SIZE (pattern) == NULL_TREE) - goto end; - - /* If this is a partial instantiation, don't tsubst anything. We will - only use this type for implicit typename, so the actual contents don't - matter. All that matters is whether a particular name is a type. */ - if (PARTIAL_INSTANTIATION_P (type)) - { - /* The fields set here must be kept in sync with those cleared - in begin_class_definition. */ - TYPE_BINFO_BASETYPES (type) = TYPE_BINFO_BASETYPES (pattern); - TYPE_FIELDS (type) = TYPE_FIELDS (pattern); - TYPE_METHODS (type) = TYPE_METHODS (pattern); - CLASSTYPE_TAGS (type) = CLASSTYPE_TAGS (pattern); - /* Pretend that the type is complete, so that we will look - inside it during name lookup and such. */ - TYPE_SIZE (type) = integer_zero_node; - goto end; - } - - /* If we've recursively instantiated too many templates, stop. */ - if (! push_tinst_level (type)) - goto end; - - /* Now we're really doing the instantiation. Mark the type as in - the process of being defined. */ - TYPE_BEING_DEFINED (type) = 1; - - maybe_push_to_top_level (uses_template_parms (type)); - - if (t) - { - /* This TYPE is actually a instantiation of of a partial - specialization. We replace the innermost set of ARGS with - the arguments appropriate for substitution. For example, - given: - - template <class T> struct S {}; - template <class T> struct S<T*> {}; - - and supposing that we are instantiating S<int*>, ARGS will - present be {int*} but we need {int}. */ - tree inner_args - = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), - args); - - /* If there were multiple levels in ARGS, replacing the - innermost level would alter CLASSTYPE_TI_ARGS, which we don't - want, so we make a copy first. */ - if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) - { - args = copy_node (args); - SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args); - } - else - args = inner_args; - } - - if (flag_external_templates) - { - if (flag_alt_external_templates) - { - CLASSTYPE_INTERFACE_ONLY (type) = interface_only; - SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type, interface_unknown); - CLASSTYPE_VTABLE_NEEDS_WRITING (type) - = (! CLASSTYPE_INTERFACE_ONLY (type) - && CLASSTYPE_INTERFACE_KNOWN (type)); - } - else - { - CLASSTYPE_INTERFACE_ONLY (type) = CLASSTYPE_INTERFACE_ONLY (pattern); - SET_CLASSTYPE_INTERFACE_UNKNOWN_X - (type, CLASSTYPE_INTERFACE_UNKNOWN (pattern)); - CLASSTYPE_VTABLE_NEEDS_WRITING (type) - = (! CLASSTYPE_INTERFACE_ONLY (type) - && CLASSTYPE_INTERFACE_KNOWN (type)); - } - } - else - { - SET_CLASSTYPE_INTERFACE_UNKNOWN (type); - CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1; - } - - TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern); - TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern); - TYPE_OVERLOADS_CALL_EXPR (type) = TYPE_OVERLOADS_CALL_EXPR (pattern); - TYPE_OVERLOADS_ARRAY_REF (type) = TYPE_OVERLOADS_ARRAY_REF (pattern); - TYPE_OVERLOADS_ARROW (type) = TYPE_OVERLOADS_ARROW (pattern); - TYPE_GETS_NEW (type) = TYPE_GETS_NEW (pattern); - TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern); - TYPE_VEC_DELETE_TAKES_SIZE (type) = TYPE_VEC_DELETE_TAKES_SIZE (pattern); - TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern); - TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern); - TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern); - TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern); - TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern); - TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern); - TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern); - TYPE_USES_COMPLEX_INHERITANCE (type) - = TYPE_USES_COMPLEX_INHERITANCE (pattern); - TYPE_USES_MULTIPLE_INHERITANCE (type) - = TYPE_USES_MULTIPLE_INHERITANCE (pattern); - TYPE_USES_VIRTUAL_BASECLASSES (type) - = TYPE_USES_VIRTUAL_BASECLASSES (pattern); - TYPE_PACKED (type) = TYPE_PACKED (pattern); - TYPE_ALIGN (type) = TYPE_ALIGN (pattern); - TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */ - if (ANON_UNION_TYPE_P (pattern)) - SET_ANON_UNION_TYPE_P (type); - - /* We must copy the arguments to the permanent obstack since - during the tsubst'ing below they may wind up in the - DECL_TI_ARGS of some instantiated member template. */ - args = copy_to_permanent (args); - - if (TYPE_BINFO_BASETYPES (pattern)) - { - tree base_list = NULL_TREE; - tree pbases = TYPE_BINFO_BASETYPES (pattern); - int i; - - /* Substitute into each of the bases to determine the actual - basetypes. */ - for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i) - { - tree base; - tree access; - tree pbase; - - pbase = TREE_VEC_ELT (pbases, i); - - /* Substitue to figure out the base class. */ - base = tsubst (BINFO_TYPE (pbase), args, - /*complain=*/1, NULL_TREE); - if (base == error_mark_node) - continue; - - /* Calculate the correct access node. */ - if (TREE_VIA_VIRTUAL (pbase)) - { - if (TREE_VIA_PUBLIC (pbase)) - access = access_public_virtual_node; - else if (TREE_VIA_PROTECTED (pbase)) - access = access_protected_virtual_node; - else - access = access_private_virtual_node; - } - else - { - if (TREE_VIA_PUBLIC (pbase)) - access = access_public_node; - else if (TREE_VIA_PROTECTED (pbase)) - access = access_protected_node; - else - access = access_private_node; - } - - base_list = tree_cons (access, base, base_list); - } - - /* The list is now in reverse order; correct that. */ - base_list = nreverse (base_list); - - /* Now call xref_basetypes to set up all the base-class - information. */ - xref_basetypes (TREE_CODE (pattern) == RECORD_TYPE - ? (CLASSTYPE_DECLARED_CLASS (pattern) - ? class_type_node : record_type_node) - : union_type_node, - DECL_NAME (TYPE_NAME (pattern)), - type, - base_list); - } - - /* Now that our base classes are set up, enter the scope of the - class, so that name lookups into base classes, etc. will work - corectly. This is precisely analagous to what we do in - begin_class_definition when defining an ordinary non-template - class. */ - pushclass (type, 1); - - for (t = CLASSTYPE_TAGS (pattern); t; t = TREE_CHAIN (t)) - { - tree tag = TREE_VALUE (t); - tree name = TYPE_IDENTIFIER (tag); - tree newtag; - - newtag = tsubst (tag, args, /*complain=*/1, NULL_TREE); - if (TREE_CODE (newtag) != ENUMERAL_TYPE) - { - if (TYPE_LANG_SPECIFIC (tag) && CLASSTYPE_IS_TEMPLATE (tag)) - /* Unfortunately, lookup_template_class sets - CLASSTYPE_IMPLICIT_INSTANTIATION for a partial - instantiation (i.e., for the type of a member template - class nested within a template class.) This behavior is - required for maybe_process_partial_specialization to work - correctly, but is not accurate in this case; the TAG is not - an instantiation of anything. (The corresponding - TEMPLATE_DECL is an instantiation, but the TYPE is not.) */ - CLASSTYPE_USE_TEMPLATE (newtag) = 0; - - /* Now, we call pushtag to put this NEWTAG into the scope of - TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid - pushtag calling push_template_decl. We don't have to do - this for enums because it will already have been done in - tsubst_enum. */ - if (name) - SET_IDENTIFIER_TYPE_VALUE (name, newtag); - pushtag (name, newtag, /*globalize=*/0); - } - } - - /* Don't replace enum constants here. */ - for (t = TYPE_FIELDS (pattern); t; t = TREE_CHAIN (t)) - if (TREE_CODE (t) != CONST_DECL) - { - tree r; - - /* The the file and line for this declaration, to assist in - error message reporting. Since we called push_tinst_level - above, we don't need to restore these. */ - lineno = DECL_SOURCE_LINE (t); - input_filename = DECL_SOURCE_FILE (t); - - r = tsubst (t, args, /*complain=*/1, NULL_TREE); - if (TREE_CODE (r) == VAR_DECL) - { - tree init; - - if (DECL_DEFINED_IN_CLASS_P (r)) - init = tsubst_expr (DECL_INITIAL (t), args, - /*complain=*/1, NULL_TREE); - else - init = NULL_TREE; - - finish_static_data_member_decl (r, init, - /*asmspec_tree=*/NULL_TREE, - /*need_pop=*/0, - /*flags=*/0); - - if (DECL_DEFINED_IN_CLASS_P (r)) - check_static_variable_definition (r, TREE_TYPE (r)); - } - - /* R will have a TREE_CHAIN if and only if it has already been - processed by finish_member_declaration. This can happen - if, for example, it is a TYPE_DECL for a class-scoped - ENUMERAL_TYPE; such a thing will already have been added to - the field list by tsubst_enum above. */ - if (!TREE_CHAIN (r)) - { - set_current_access_from_decl (r); - finish_member_declaration (r); - } - } - - /* After we have calculated the bases, we can now compute whether we - have polymorphic vbases. This needs to happen before we - instantiate the methods, because the constructors may take - additional arguments. */ - if (flag_vtable_thunks >= 2) - TYPE_USES_PVBASES (type) = has_pvbases_p (type, pattern); - - /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC) - for this instantiation. */ - for (t = TYPE_METHODS (pattern); t; t = TREE_CHAIN (t)) - { - tree r = tsubst (t, args, /*complain=*/1, NULL_TREE); - set_current_access_from_decl (r); - finish_member_declaration (r); - } - - /* Construct the DECL_FRIENDLIST for the new class type. */ - typedecl = TYPE_MAIN_DECL (type); - for (t = DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern)); - t != NULL_TREE; - t = TREE_CHAIN (t)) - { - tree friends; - - for (friends = TREE_VALUE (t); - friends != NULL_TREE; - friends = TREE_CHAIN (friends)) - if (TREE_PURPOSE (friends) == error_mark_node) - add_friend (type, - tsubst_friend_function (TREE_VALUE (friends), - args)); - else - add_friends (type, - tsubst_copy (TREE_PURPOSE (t), args, - /*complain=*/1, NULL_TREE), - tsubst (TREE_PURPOSE (friends), args, - /*complain=*/1, NULL_TREE)); - } - - for (t = CLASSTYPE_FRIEND_CLASSES (pattern); - t != NULL_TREE; - t = TREE_CHAIN (t)) - { - tree friend_type = TREE_VALUE (t); - tree new_friend_type; - - 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); - else - /* The call to xref_tag_from_type does injection for friend - classes. */ - new_friend_type = - xref_tag_from_type (friend_type, NULL_TREE, 1); - - - if (TREE_CODE (friend_type) == TEMPLATE_DECL) - /* Trick make_friend_class into realizing that the friend - we're adding is a template, not an ordinary class. It's - important that we use make_friend_class since it will - perform some error-checking and output cross-reference - information. */ - ++processing_template_decl; - - make_friend_class (type, new_friend_type); - - if (TREE_CODE (friend_type) == TEMPLATE_DECL) - --processing_template_decl; - } - - /* This does injection for friend functions. */ - if (!processing_template_decl) - { - t = tsubst (DECL_TEMPLATE_INJECT (template), args, - /*complain=*/1, NULL_TREE); - - for (; t; t = TREE_CHAIN (t)) - { - tree d = TREE_VALUE (t); - - if (TREE_CODE (d) == TYPE_DECL) - /* Already injected. */; - else - pushdecl (d); - } - } - - for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t)) - if (TREE_CODE (t) == FIELD_DECL) - { - TREE_TYPE (t) = complete_type (TREE_TYPE (t)); - require_complete_type (t); - } - - /* Set the file and line number information to whatever is given for - the class itself. This puts error messages involving generated - implicit functions at a predictable point, and the same point - that would be used for non-template classes. */ - lineno = DECL_SOURCE_LINE (typedecl); - input_filename = DECL_SOURCE_FILE (typedecl); - - unreverse_member_declarations (type); - finish_struct_1 (type, 0); - CLASSTYPE_GOT_SEMICOLON (type) = 1; - - /* Clear this now so repo_template_used is happy. */ - TYPE_BEING_DEFINED (type) = 0; - repo_template_used (type); - - popclass (); - pop_from_top_level (); - pop_tinst_level (); - - end: - pop_momentary (); - - return type; -} - -static int -list_eq (t1, t2) - tree t1, t2; -{ - if (t1 == NULL_TREE) - return t2 == NULL_TREE; - if (t2 == NULL_TREE) - return 0; - /* Don't care if one declares its arg const and the other doesn't -- the - main variant of the arg type is all that matters. */ - if (TYPE_MAIN_VARIANT (TREE_VALUE (t1)) - != TYPE_MAIN_VARIANT (TREE_VALUE (t2))) - return 0; - return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2)); -} - -/* If arg is a non-type template parameter that does not depend on template - arguments, fold it like we weren't in the body of a template. */ - -static tree -maybe_fold_nontype_arg (arg) - tree arg; -{ - if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't' - && !uses_template_parms (arg)) - { - /* Sometimes, one of the args was an expression involving a - template constant parameter, like N - 1. Now that we've - tsubst'd, we might have something like 2 - 1. This will - confuse lookup_template_class, so we do constant folding - here. We have to unset processing_template_decl, to - fool build_expr_from_tree() into building an actual - tree. */ - - int saved_processing_template_decl = processing_template_decl; - processing_template_decl = 0; - arg = fold (build_expr_from_tree (arg)); - processing_template_decl = saved_processing_template_decl; - } - return arg; -} - -/* Return the TREE_VEC with the arguments for the innermost template header, - where ARGS is either that or the VEC of VECs for all the - arguments. */ - -tree -innermost_args (args) - tree args; -{ - return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args)); -} - -/* Substitute ARGS into the vector of template arguments T. */ - -static tree -tsubst_template_arg_vector (t, args, complain) - tree t; - tree args; - int complain; -{ - int len = TREE_VEC_LENGTH (t), need_new = 0, i; - tree *elts = (tree *) alloca (len * sizeof (tree)); - - bzero ((char *) elts, len * sizeof (tree)); - - for (i = 0; i < len; i++) - { - if (TREE_VEC_ELT (t, i) != NULL_TREE - && TREE_CODE (TREE_VEC_ELT (t, i)) == TREE_VEC) - elts[i] = tsubst_template_arg_vector (TREE_VEC_ELT (t, i), - args, complain); - else - elts[i] = maybe_fold_nontype_arg - (tsubst_expr (TREE_VEC_ELT (t, i), args, complain, - NULL_TREE)); - - if (elts[i] != TREE_VEC_ELT (t, i)) - need_new = 1; - } - - if (!need_new) - return t; - - t = make_temp_vec (len); - for (i = 0; i < len; i++) - TREE_VEC_ELT (t, i) = elts[i]; - - return t; -} - -/* Return the result of substituting ARGS into the template parameters - given by PARMS. If there are m levels of ARGS and m + n levels of - PARMS, then the result will contain n levels of PARMS. For - example, if PARMS is `template <class T> template <class U> - template <T*, U, class V>' and ARGS is {{int}, {double}} then the - result will be `template <int*, double, class V>'. */ - -static tree -tsubst_template_parms (parms, args, complain) - tree parms; - tree args; - int complain; -{ - tree r; - tree* new_parms = &r; - - for (new_parms = &r; - TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args); - new_parms = &(TREE_CHAIN (*new_parms)), - parms = TREE_CHAIN (parms)) - { - tree new_vec = - make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms))); - int i; - - for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i) - { - tree default_value = - TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms), i)); - tree parm_decl = - TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms), i)); - - TREE_VEC_ELT (new_vec, i) - = build_tree_list (tsubst (default_value, args, complain, - NULL_TREE), - tsubst (parm_decl, args, complain, - NULL_TREE)); - } - - *new_parms = - tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms) - - TMPL_ARGS_DEPTH (args))), - new_vec, NULL_TREE); - } - - return r; -} - -/* Substitute the ARGS into the indicated aggregate (or enumeration) - type T. If T is not an aggregate or enumeration type, it is - handled as if by tsubst. IN_DECL is as for tsubst. If - ENTERING_SCOPE is non-zero, T is the context for a template which - we are presently tsubst'ing. Return the subsituted value. */ - -static tree -tsubst_aggr_type (t, args, complain, in_decl, entering_scope) - tree t; - tree args; - int complain; - tree in_decl; - int entering_scope; -{ - if (t == NULL_TREE) - return NULL_TREE; - - switch (TREE_CODE (t)) - { - case RECORD_TYPE: - if (TYPE_PTRMEMFUNC_P (t)) - { - tree r = build_ptrmemfunc_type - (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl)); - return cp_build_qualified_type (r, TYPE_QUALS (t)); - } - - /* else fall through */ - case ENUMERAL_TYPE: - case UNION_TYPE: - if (TYPE_TEMPLATE_INFO (t)) - { - tree argvec; - tree context; - tree r; - - /* First, determine the context for the type we are looking - up. */ - if (TYPE_CONTEXT (t) != NULL_TREE) - context = tsubst_aggr_type (TYPE_CONTEXT (t), args, - complain, - in_decl, /*entering_scope=*/1); - else - context = NULL_TREE; - - /* Then, figure out what arguments are appropriate for the - type we are trying to find. For example, given: - - template <class T> struct S; - template <class T, class U> void f(T, U) { S<U> su; } - - and supposing that we are instantiating f<int, double>, - then our ARGS will be {int, double}, but, when looking up - S we only want {double}. */ - push_momentary (); - argvec = tsubst_template_arg_vector (TYPE_TI_ARGS (t), args, - complain); - - r = lookup_template_class (t, argvec, in_decl, context, - entering_scope); - pop_momentary (); - - return cp_build_qualified_type (r, TYPE_QUALS (t)); - } - else - /* This is not a template type, so there's nothing to do. */ - return t; - - default: - return tsubst (t, args, complain, in_decl); - } -} - -/* 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. IN_DECL is as - for tsubst. */ - -static tree -tsubst_decl (t, args, type, in_decl) - tree t; - tree args; - tree type; - tree in_decl; -{ - int saved_lineno; - char* saved_filename; - tree r = NULL_TREE; - - /* Set the filename and linenumber to improve error-reporting. */ - saved_lineno = lineno; - saved_filename = input_filename; - lineno = DECL_SOURCE_LINE (t); - input_filename = DECL_SOURCE_FILE (t); - - switch (TREE_CODE (t)) - { - case TEMPLATE_DECL: - { - /* We can get here when processing a member template function - of a template class. */ - tree decl = DECL_TEMPLATE_RESULT (t); - tree spec; - int is_template_template_parm = DECL_TEMPLATE_TEMPLATE_PARM_P (t); - - if (!is_template_template_parm) - { - /* We might already have an instance of this template. - The ARGS are for the surrounding class type, so the - full args contain the tsubst'd args for the context, - plus the innermost args from the template decl. */ - tree tmpl_args = DECL_CLASS_TEMPLATE_P (t) - ? CLASSTYPE_TI_ARGS (TREE_TYPE (t)) - : DECL_TI_ARGS (DECL_RESULT (t)); - tree full_args; - - push_momentary (); - full_args = tsubst_template_arg_vector (tmpl_args, args, - /*complain=*/1); - - /* tsubst_template_arg_vector doesn't copy the vector if - nothing changed. But, *something* should have - changed. */ - my_friendly_assert (full_args != tmpl_args, 0); - - spec = retrieve_specialization (t, full_args); - pop_momentary (); - if (spec != NULL_TREE) - { - r = spec; - break; - } - } - - /* Make a new template decl. It will be similar to the - original, but will record the current template arguments. - We also create a new function declaration, which is just - like the old one, but points to this new template, rather - than the old one. */ - r = copy_node (t); - copy_lang_decl (r); - my_friendly_assert (DECL_LANG_SPECIFIC (r) != 0, 0); - TREE_CHAIN (r) = NULL_TREE; - - if (is_template_template_parm) - { - tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl); - DECL_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, /*entering_scope=*/1); - DECL_CLASS_CONTEXT (r) - = tsubst_aggr_type (DECL_CLASS_CONTEXT (t), args, - /*complain=*/1, 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_TYPE (r) = new_type; - CLASSTYPE_TI_TEMPLATE (new_type) = r; - DECL_RESULT (r) = TYPE_MAIN_DECL (new_type); - DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type); - } - else - { - tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl); - DECL_RESULT (r) = new_decl; - DECL_TI_TEMPLATE (new_decl) = r; - TREE_TYPE (r) = TREE_TYPE (new_decl); - DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl); - } - - SET_DECL_IMPLICIT_INSTANTIATION (r); - DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE; - DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE; - - /* The template parameters for this new template are all the - template parameters for the old template, except the - outermost level of parameters. */ - DECL_TEMPLATE_PARMS (r) - = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args, - /*complain=*/1); - - if (PRIMARY_TEMPLATE_P (t)) - DECL_PRIMARY_TEMPLATE (r) = r; - - /* We don't partially instantiate partial specializations. */ - if (TREE_CODE (decl) == TYPE_DECL) - break; - - for (spec = DECL_TEMPLATE_SPECIALIZATIONS (t); - spec != NULL_TREE; - spec = TREE_CHAIN (spec)) - { - /* It helps to consider example here. Consider: - - template <class T> - struct S { - template <class U> - void f(U u); - - template <> - void f(T* t) {} - }; - - Now, for example, we are instantiating S<int>::f(U u). - We want to make a template: - - template <class U> - void S<int>::f(U); - - It will have a specialization, for the case U = int*, of - the form: - - template <> - void S<int>::f<int*>(int*); - - This specialization will be an instantiation of - the specialization given in the declaration of S, with - argument list int*. */ - - tree fn = TREE_VALUE (spec); - tree spec_args; - tree new_fn; - - if (!DECL_TEMPLATE_SPECIALIZATION (fn)) - /* Instantiations are on the same list, but they're of - no concern to us. */ - continue; - - if (TREE_CODE (fn) != TEMPLATE_DECL) - /* A full specialization. There's no need to record - that here. */ - continue; - - spec_args = tsubst (DECL_TI_ARGS (fn), args, - /*complain=*/1, in_decl); - new_fn = tsubst (DECL_RESULT (most_general_template (fn)), - spec_args, /*complain=*/1, in_decl); - DECL_TI_TEMPLATE (new_fn) = fn; - register_specialization (new_fn, r, - innermost_args (spec_args)); - } - - /* Record this partial instantiation. */ - register_specialization (r, t, - DECL_TI_ARGS (DECL_RESULT (r))); - - } - break; - - case FUNCTION_DECL: - { - tree ctx; - tree argvec = NULL_TREE; - tree *friends; - tree gen_tmpl; - int member; - int args_depth; - int parms_depth; - - /* Nobody should be tsubst'ing into non-template functions. */ - my_friendly_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE, 0); - - if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL) - { - tree spec; - - /* Allocate template arguments on the momentary obstack, - in case we don't need to keep them. */ - push_momentary (); - - /* Calculate the most general template of which R is a - specialization, and the complete set of arguments used to - specialize R. */ - gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t)); - argvec - = tsubst_template_arg_vector (DECL_TI_ARGS - (DECL_TEMPLATE_RESULT (gen_tmpl)), - args, /*complain=*/1); - - /* Check to see if we already have this specialization. */ - spec = retrieve_specialization (gen_tmpl, argvec); - - if (spec) - { - r = spec; - pop_momentary (); - break; - } - - /* We're going to need to keep the ARGVEC, so we copy it - here. */ - argvec = copy_to_permanent (argvec); - pop_momentary (); - - /* Here, we deal with the peculiar case: - - template <class T> struct S { - template <class U> friend void f(); - }; - template <class U> friend void f() {} - template S<int>; - template void f<double>(); - - Here, the ARGS for the instantiation of will be {int, - double}. But, we only need as many ARGS as there are - levels of template parameters in CODE_PATTERN. We are - careful not to get fooled into reducing the ARGS in - situations like: - - template <class T> struct S { template <class U> void f(U); } - template <class T> template <> void S<T>::f(int) {} - - which we can spot because the pattern will be a - specialization in this case. */ - args_depth = TMPL_ARGS_DEPTH (args); - parms_depth = - TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t))); - if (args_depth > parms_depth - && !DECL_TEMPLATE_SPECIALIZATION (t)) - { - my_friendly_assert (DECL_FRIEND_P (t), 0); - - if (parms_depth > 1) - { - int i; - - args = make_temp_vec (parms_depth); - for (i = 0; i < parms_depth; ++i) - TREE_VEC_ELT (args, i) = - TREE_VEC_ELT (args, i + (args_depth - parms_depth)); - } - else - args = TREE_VEC_ELT (args, args_depth - parms_depth); - } - } - else - { - /* This special case arises when we have something like this: - - template <class T> struct S { - friend void f<int>(int, double); - }; - - Here, the DECL_TI_TEMPLATE for the friend declaration - will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are - being called from tsubst_friend_function, and we want - only to create a new decl (R) with appropriate types so - that we can call determine_specialization. */ - my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t)) - == LOOKUP_EXPR) - || (TREE_CODE (DECL_TI_TEMPLATE (t)) - == IDENTIFIER_NODE), 0); - gen_tmpl = NULL_TREE; - } - - if (DECL_CLASS_SCOPE_P (t)) - { - if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t))) - member = 2; - else - member = 1; - ctx = tsubst_aggr_type (DECL_CLASS_CONTEXT (t), args, - /*complain=*/1, t, - /*entering_scope=*/1); - } - else - { - member = 0; - ctx = NULL_TREE; - } - type = tsubst (type, args, /*complain=*/1, in_decl); - - /* We do NOT check for matching decls pushed separately at this - point, as they may not represent instantiations of this - template, and in any case are considered separate under the - discrete model. Instead, see add_maybe_template. */ - - r = copy_node (t); - copy_lang_decl (r); - DECL_USE_TEMPLATE (r) = 0; - TREE_TYPE (r) = type; - - DECL_CONTEXT (r) - = tsubst_aggr_type (DECL_CONTEXT (t), args, /*complain=*/1, t, - /*entering_scope=*/1); - DECL_CLASS_CONTEXT (r) = ctx; - - if (member && IDENTIFIER_TYPENAME_P (DECL_NAME (r))) - /* Type-conversion operator. Reconstruct the name, in - case it's the name of one of the template's parameters. */ - DECL_NAME (r) = build_typename_overload (TREE_TYPE (type)); - - DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, - /*complain=*/1, t); - DECL_MAIN_VARIANT (r) = r; - DECL_RESULT (r) = NULL_TREE; - - TREE_STATIC (r) = 0; - TREE_PUBLIC (r) = TREE_PUBLIC (t); - DECL_EXTERNAL (r) = 1; - DECL_INTERFACE_KNOWN (r) = 0; - DECL_DEFER_OUTPUT (r) = 0; - TREE_CHAIN (r) = NULL_TREE; - DECL_PENDING_INLINE_INFO (r) = 0; - TREE_USED (r) = 0; - - /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled - name. There's no need to do this in the special friend - case mentioned above where GEN_TMPL is NULL. */ - if (gen_tmpl) - { - /* The ARGVEC was built on the momentary obstack. Make it - permanent now. */ - argvec = copy_to_permanent (argvec); - DECL_TEMPLATE_INFO (r) - = perm_tree_cons (gen_tmpl, argvec, NULL_TREE); - SET_DECL_IMPLICIT_INSTANTIATION (r); - register_specialization (r, gen_tmpl, argvec); - - - if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r)) - { - maybe_retrofit_in_chrg (r); - grok_ctor_properties (ctx, r); - } - - /* Set the mangled name for R. */ - if (DECL_DESTRUCTOR_P (t)) - DECL_ASSEMBLER_NAME (r) = - build_destructor_name (ctx, DECL_DESTRUCTOR_FOR_PVBASE_P (r)); - else - { - /* Instantiations of template functions must be mangled - specially, in order to conform to 14.5.5.1 - [temp.over.link]. */ - tree tmpl = DECL_TI_TEMPLATE (t); - - /* TMPL will be NULL if this is a specialization of a - member function of a template class. */ - if (name_mangling_version < 1 - || tmpl == NULL_TREE - || (member && !is_member_template (tmpl) - && !DECL_TEMPLATE_INFO (tmpl))) - set_mangled_name_for_decl (r); - else - set_mangled_name_for_template_decl (r); - } - - DECL_RTL (r) = 0; - make_decl_rtl (r, NULL_PTR, 1); - - /* Like grokfndecl. If we don't do this, pushdecl will - mess up our TREE_CHAIN because it doesn't find a - previous decl. Sigh. */ - if (member - && ! uses_template_parms (r) - && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r)) - == NULL_TREE)) - SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r), r); - } - - /* Copy the list of befriending classes. */ - for (friends = &DECL_BEFRIENDING_CLASSES (r); - *friends; - friends = &TREE_CHAIN (*friends)) - { - *friends = copy_node (*friends); - TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends), - args, /*complain=*/1, - in_decl); - } - -#if 0 - /* This has now moved further up. */ - if (DECL_CONSTRUCTOR_P (r)) - { - maybe_retrofit_in_chrg (r); - grok_ctor_properties (ctx, r); - } -#endif - if (IDENTIFIER_OPNAME_P (DECL_NAME (r))) - grok_op_properties (r, DECL_VIRTUAL_P (r), DECL_FRIEND_P (r)); - } - break; - - case PARM_DECL: - { - r = copy_node (t); - TREE_TYPE (r) = type; - c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r); - - if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX) - DECL_INITIAL (r) = TREE_TYPE (r); - else - DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args, - /*complain=*/1, in_decl); - - DECL_CONTEXT (r) = NULL_TREE; -#ifdef PROMOTE_PROTOTYPES - if ((TREE_CODE (type) == INTEGER_TYPE - || TREE_CODE (type) == ENUMERAL_TYPE) - && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) - DECL_ARG_TYPE (r) = integer_type_node; -#endif - if (TREE_CHAIN (t)) - TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, - /*complain=*/1, TREE_CHAIN (t)); - } - break; - - case FIELD_DECL: - { - r = copy_node (t); - copy_lang_decl (r); - TREE_TYPE (r) = type; - c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r); - - /* 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); - TREE_CHAIN (r) = NULL_TREE; - if (TREE_CODE (type) == VOID_TYPE) - cp_error_at ("instantiation of `%D' as type void", r); - } - break; - - case USING_DECL: - { - r = copy_node (t); - DECL_INITIAL (r) - = tsubst_copy (DECL_INITIAL (t), args, /*complain=*/1, in_decl); - TREE_CHAIN (r) = NULL_TREE; - } - break; - - case VAR_DECL: - { - tree argvec; - tree gen_tmpl; - tree spec; - tree tmpl; - tree ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, - /*complain=*/1, - in_decl, /*entering_scope=*/1); - - /* Nobody should be tsubst'ing into non-template variables. */ - my_friendly_assert (DECL_LANG_SPECIFIC (t) - && DECL_TEMPLATE_INFO (t) != NULL_TREE, 0); - - /* Check to see if we already have this specialization. */ - tmpl = DECL_TI_TEMPLATE (t); - gen_tmpl = most_general_template (tmpl); - argvec = tsubst (DECL_TI_ARGS (t), args, /*complain=*/1, in_decl); - spec = retrieve_specialization (gen_tmpl, argvec); - - if (spec) - { - r = spec; - break; - } - - r = copy_node (t); - TREE_TYPE (r) = type; - c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r); - DECL_CONTEXT (r) = ctx; - - /* Don't try to expand the initializer until someone tries to use - this variable; otherwise we run into circular dependencies. */ - DECL_INITIAL (r) = NULL_TREE; - DECL_RTL (r) = 0; - DECL_SIZE (r) = 0; - copy_lang_decl (r); - DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r); - - /* A static data member declaration is always marked external - when it is declared in-class, even if an initializer is - present. We mimic the non-template processing here. */ - DECL_EXTERNAL (r) = 1; - - DECL_TEMPLATE_INFO (r) = perm_tree_cons (tmpl, argvec, NULL_TREE); - SET_DECL_IMPLICIT_INSTANTIATION (r); - register_specialization (r, gen_tmpl, argvec); - - TREE_CHAIN (r) = NULL_TREE; - if (TREE_CODE (type) == VOID_TYPE) - cp_error_at ("instantiation of `%D' as type void", r); - } - break; - - case TYPE_DECL: - if (t == TYPE_NAME (TREE_TYPE (t))) - r = TYPE_NAME (type); - else - { - r = copy_node (t); - TREE_TYPE (r) = type; - DECL_CONTEXT (r) = current_class_type; - TREE_CHAIN (r) = NULL_TREE; - } - break; - - default: - my_friendly_abort (0); - } - - /* Restore the file and line information. */ - lineno = saved_lineno; - input_filename = saved_filename; - - return r; -} - -/* Substitue into the ARG_TYPES of a function type. */ - -static tree -tsubst_arg_types (arg_types, args, complain, in_decl) - tree arg_types; - tree args; - int complain; - tree in_decl; -{ - tree remaining_arg_types; - tree type; - - if (!arg_types || arg_types == void_list_node) - return arg_types; - - remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types), - args, complain, in_decl); - if (remaining_arg_types == error_mark_node) - return error_mark_node; - - type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl); - if (type == error_mark_node) - return error_mark_node; - - /* Do array-to-pointer, function-to-pointer conversion, and ignore - top-level qualifiers as required. */ - type = TYPE_MAIN_VARIANT (type_decays_to (type)); - - /* Note that we do not substitute into default arguments here. The - standard mandates that they be instantiated only when needed, - which is done in build_over_call. */ - return hash_tree_cons (TREE_PURPOSE (arg_types), type, - remaining_arg_types); - -} - -/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does - *not* handle the exception-specification for FNTYPE, because the - initial substitution of explicitly provided template parameters - during argument deduction forbids substitution into the - exception-specification: - - [temp.deduct] - - All references in the function type of the function template to the - corresponding template parameters are replaced by the specified tem- - plate argument values. If a substitution in a template parameter or - in the function type of the function template results in an invalid - type, type deduction fails. [Note: The equivalent substitution in - exception specifications is done only when the function is instanti- - ated, at which point a program is ill-formed if the substitution - results in an invalid type.] */ - -static tree -tsubst_function_type (t, args, complain, in_decl) - tree t; - tree args; - int complain; - tree in_decl; -{ - tree return_type; - tree arg_types; - tree fntype; - - /* The TYPE_CONTEXT is not used for function/method types. */ - my_friendly_assert (TYPE_CONTEXT (t) == NULL_TREE, 0); - - /* Substitue the return type. */ - return_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (return_type == error_mark_node) - return error_mark_node; - - /* Substitue the argument types. */ - arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, - complain, in_decl); - if (arg_types == error_mark_node) - return error_mark_node; - - /* Construct a new type node and return it. */ - if (TREE_CODE (t) == FUNCTION_TYPE) - fntype = build_function_type (return_type, arg_types); - else - { - tree r = TREE_TYPE (TREE_VALUE (arg_types)); - if (! IS_AGGR_TYPE (r)) - { - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - -- Attempting to create "pointer to member of T" when T - is not a class type. */ - if (complain) - cp_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 = build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t)); - - return fntype; -} - -/* Substitute into the PARMS of a call-declarator. */ - -static tree -tsubst_call_declarator_parms (parms, args, complain, in_decl) - tree parms; - tree args; - int complain; - tree in_decl; -{ - tree new_parms; - tree type; - tree defarg; - - if (!parms || parms == void_list_node) - return parms; - - new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms), - args, complain, in_decl); - - /* Figure out the type of this parameter. */ - type = tsubst (TREE_VALUE (parms), args, complain, in_decl); - - /* Figure out the default argument as well. Note that we use - tsubst_expr since the default argument is really an expression. */ - defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl); - - /* Chain this parameter on to the front of those we have already - processed. We don't use hash_tree_cons because that function - doesn't check TREE_PARMLIST. */ - new_parms = tree_cons (defarg, type, new_parms); - - /* And note that these are parameters. */ - TREE_PARMLIST (new_parms) = 1; - - return 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. - - 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; - tree in_decl; -{ - tree type, r; - - if (t == NULL_TREE || t == error_mark_node - || t == integer_type_node - || t == void_type_node - || t == char_type_node - || TREE_CODE (t) == NAMESPACE_DECL) - return t; - - if (TREE_CODE (t) == IDENTIFIER_NODE) - type = IDENTIFIER_TYPE_VALUE (t); - else - type = TREE_TYPE (t); - if (type == unknown_type_node) - my_friendly_abort (42); - - if (type && TREE_CODE (t) != FUNCTION_DECL - && TREE_CODE (t) != TYPENAME_TYPE - && TREE_CODE (t) != TEMPLATE_DECL - && TREE_CODE (t) != IDENTIFIER_NODE - && TREE_CODE (t) != FUNCTION_TYPE - && TREE_CODE (t) != METHOD_TYPE) - type = tsubst (type, args, complain, in_decl); - if (type == error_mark_node) - return error_mark_node; - - if (TREE_CODE_CLASS (TREE_CODE (t)) == 'd') - return tsubst_decl (t, args, type, in_decl); - - switch (TREE_CODE (t)) - { - case RECORD_TYPE: - case UNION_TYPE: - case ENUMERAL_TYPE: - return tsubst_aggr_type (t, args, complain, in_decl, - /*entering_scope=*/0); - - case ERROR_MARK: - case IDENTIFIER_NODE: - case OP_IDENTIFIER: - case VOID_TYPE: - case REAL_TYPE: - case COMPLEX_TYPE: - case BOOLEAN_TYPE: - case INTEGER_CST: - case REAL_CST: - case STRING_CST: - return t; - - case INTEGER_TYPE: - if (t == integer_type_node) - return t; - - if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST - && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST) - return t; - - { - tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0); - - max = tsubst_expr (omax, args, complain, in_decl); - if (max == error_mark_node) - return error_mark_node; - - /* See if we can reduce this expression to something simpler. */ - max = maybe_fold_nontype_arg (max); - if (!processing_template_decl && TREE_READONLY_DECL_P (max)) - max = decl_constant_value (max); - - if (processing_template_decl - /* When providing explicit arguments to a template - function, but leaving some arguments for subsequent - deduction, MAX may be template-dependent even if we're - not PROCESSING_TEMPLATE_DECL. */ - || TREE_CODE (max) != INTEGER_CST) - { - tree itype = make_node (INTEGER_TYPE); - TYPE_MIN_VALUE (itype) = size_zero_node; - TYPE_MAX_VALUE (itype) = build_min (MINUS_EXPR, sizetype, max, - integer_one_node); - return itype; - } - - if (integer_zerop (omax)) - { - /* Still allow an explicit array of size zero. */ - if (pedantic) - pedwarn ("creating array with size zero"); - } - else if (integer_zerop (max) || INT_CST_LT (max, integer_zero_node)) - { - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - Attempting to create an array with a size that is - zero or negative. */ - if (complain) - cp_error ("creating array with size `%E'", max); - - return error_mark_node; - } - - max = fold (build_binary_op (MINUS_EXPR, max, integer_one_node)); - if (!TREE_PERMANENT (max) && !allocation_temporary_p ()) - max = copy_to_permanent (max); - return build_index_type (max); - } - - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - case TEMPLATE_PARM_INDEX: - { - int idx; - int level; - int levels; - - r = NULL_TREE; - - if (TREE_CODE (t) == TEMPLATE_TYPE_PARM - || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM) - { - idx = TEMPLATE_TYPE_IDX (t); - level = TEMPLATE_TYPE_LEVEL (t); - } - else - { - idx = TEMPLATE_PARM_IDX (t); - level = TEMPLATE_PARM_LEVEL (t); - } - - if (TREE_VEC_LENGTH (args) > 0) - { - tree arg = NULL_TREE; - - levels = TMPL_ARGS_DEPTH (args); - if (level <= levels) - arg = TMPL_ARG (args, level, idx); - - if (arg == error_mark_node) - return error_mark_node; - else if (arg != NULL_TREE) - { - if (TREE_CODE (t) == TEMPLATE_TYPE_PARM) - { - my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg)) - == 't', 0); - return cp_build_qualified_type - (arg, CP_TYPE_QUALS (arg) | CP_TYPE_QUALS (t)); - } - else if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM) - { - if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t)) - { - /* We are processing a type constructed from - a template template parameter */ - tree argvec = tsubst (TYPE_TI_ARGS (t), - args, complain, in_decl); - if (argvec == error_mark_node) - return error_mark_node; - - /* We can get a TEMPLATE_TEMPLATE_PARM here when - we are resolving nested-types in the signature of - a member function templates. - Otherwise ARG is a TEMPLATE_DECL and is the real - template to be instantiated. */ - if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) - arg = TYPE_NAME (arg); - - r = lookup_template_class (DECL_NAME (arg), - argvec, in_decl, - DECL_CONTEXT (arg), - /*entering_scope=*/0); - return cp_build_qualified_type (r, TYPE_QUALS (t)); - } - else - /* We are processing a template argument list. */ - return arg; - } - else - return arg; - } - } - else - my_friendly_abort (981018); - - if (level == 1) - /* This can happen during the attempted tsubst'ing in - unify. This means that we don't yet have any information - about the template parameter in question. */ - return t; - - /* If we get here, we must have been looking at a parm for a - more deeply nested template. Make a new version of this - template parameter, but with a lower level. */ - switch (TREE_CODE (t)) - { - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - r = copy_node (t); - TEMPLATE_TYPE_PARM_INDEX (r) - = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t), - r, levels); - TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r); - TYPE_MAIN_VARIANT (r) = r; - TYPE_POINTER_TO (r) = NULL_TREE; - TYPE_REFERENCE_TO (r) = NULL_TREE; - - if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM - && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t)) - { - tree argvec = tsubst (TYPE_TI_ARGS (t), args, - complain, in_decl); - if (argvec == error_mark_node) - return error_mark_node; - - TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r) - = perm_tree_cons (TYPE_NAME (t), argvec, NULL_TREE); - } - break; - - case TEMPLATE_PARM_INDEX: - r = reduce_template_parm_level (t, type, levels); - break; - - default: - my_friendly_abort (0); - } - - return r; - } - - case TREE_LIST: - { - tree purpose, value, chain, result; - - if (t == void_list_node) - return t; - - purpose = TREE_PURPOSE (t); - if (purpose) - { - purpose = tsubst (purpose, args, complain, in_decl); - if (purpose == error_mark_node) - return error_mark_node; - } - value = TREE_VALUE (t); - if (value) - { - value = tsubst (value, args, complain, in_decl); - if (value == error_mark_node) - return error_mark_node; - } - chain = TREE_CHAIN (t); - if (chain && chain != void_type_node) - { - chain = tsubst (chain, args, complain, in_decl); - if (chain == error_mark_node) - return error_mark_node; - } - if (purpose == TREE_PURPOSE (t) - && value == TREE_VALUE (t) - && chain == TREE_CHAIN (t)) - return t; - result = hash_tree_cons (purpose, value, chain); - TREE_PARMLIST (result) = TREE_PARMLIST (t); - return result; - } - case TREE_VEC: - if (type != NULL_TREE) - { - /* A binfo node. We always need to make a copy, of the node - itself and of its BINFO_BASETYPES. */ - - t = copy_node (t); - - /* Make sure type isn't a typedef copy. */ - type = BINFO_TYPE (TYPE_BINFO (type)); - - TREE_TYPE (t) = complete_type (type); - if (IS_AGGR_TYPE (type)) - { - BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type); - BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type); - if (TYPE_BINFO_BASETYPES (type) != NULL_TREE) - BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type)); - } - return t; - } - - /* Otherwise, a vector of template arguments. */ - return tsubst_template_arg_vector (t, args, complain); - - case POINTER_TYPE: - case REFERENCE_TYPE: - { - enum tree_code code; - - if (type == TREE_TYPE (t)) - return t; - - code = TREE_CODE (t); - - - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - -- Attempting to create a pointer to reference type. - -- Attempting to create a reference to a reference type or - a reference to void. */ - if (TREE_CODE (type) == REFERENCE_TYPE - || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE)) - { - static int last_line = 0; - static char* last_file = 0; - - /* 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 (TREE_CODE (type) == VOID_TYPE) - cp_error ("forming reference to void"); - else - cp_error ("forming %s to reference type `%T'", - (code == POINTER_TYPE) ? "pointer" : "reference", - type); - last_line = lineno; - last_file = input_filename; - } - - return error_mark_node; - } - else if (code == POINTER_TYPE) - r = build_pointer_type (type); - else - r = build_reference_type (type); - r = cp_build_qualified_type (r, TYPE_QUALS (t)); - - /* Will this ever be needed for TYPE_..._TO values? */ - layout_type (r); - return r; - } - case OFFSET_TYPE: - { - r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl); - if (r == error_mark_node || !IS_AGGR_TYPE (r)) - { - /* [temp.deduct] - - Type deduction may fail for any of the following - reasons: - - -- Attempting to create "pointer to member of T" when T - is not a class type. */ - if (complain) - cp_error ("creating pointer to member of non-class type `%T'", - r); - return error_mark_node; - } - return build_offset_type (r, type); - } - case FUNCTION_TYPE: - case METHOD_TYPE: - { - tree fntype; - tree raises; - - fntype = tsubst_function_type (t, args, complain, in_decl); - if (fntype == error_mark_node) - return error_mark_node; - - /* Substitue the exception specification. */ - raises = TYPE_RAISES_EXCEPTIONS (t); - if (raises) - { - raises = tsubst (raises, args, complain, in_decl); - if (raises == error_mark_node) - return raises; - fntype = build_exception_variant (fntype, raises); - } - return fntype; - } - case ARRAY_TYPE: - { - tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl); - if (domain == error_mark_node) - return error_mark_node; - - /* As an optimization, we avoid regenerating the array type if - it will obviously be the same as T. */ - if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t)) - return t; - - /* These checks should match the ones in grokdeclarator. - - [temp.deduct] - - The deduction may fail for any of the following reasons: - - -- Attempting to create an array with an element type that - is void, a function type, or a reference type. */ - if (TREE_CODE (type) == VOID_TYPE - || TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == REFERENCE_TYPE) - { - if (complain) - cp_error ("creating array of `%T'", type); - return error_mark_node; - } - - r = build_cplus_array_type (type, domain); - return r; - } - - 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); - - if (e1 == error_mark_node || e2 == error_mark_node) - return error_mark_node; - - return fold (build (TREE_CODE (t), TREE_TYPE (t), e1, e2)); - } - - case NEGATE_EXPR: - case NOP_EXPR: - { - tree e = tsubst (TREE_OPERAND (t, 0), args, complain, - in_decl); - if (e == error_mark_node) - return error_mark_node; - - return fold (build (TREE_CODE (t), TREE_TYPE (t), e)); - } - - case TYPENAME_TYPE: - { - tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain, - in_decl, /*entering_scope=*/1); - tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args, - complain, in_decl); - - if (ctx == error_mark_node || f == error_mark_node) - return error_mark_node; - - if (!IS_AGGR_TYPE (ctx)) - { - if (complain) - cp_error ("`%T' is not a class, struct, or union type", - ctx); - return error_mark_node; - } - else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx)) - { - /* Normally, make_typename_type does not require that the CTX - have complete type in order to allow things like: - - template <class T> struct S { typename S<T>::X Y; }; - - But, such constructs have already been resolved by this - point, so here CTX really should have complete type, unless - it's a partial instantiation. */ - ctx = complete_type (ctx); - if (!TYPE_SIZE (ctx)) - { - if (complain) - incomplete_type_error (NULL_TREE, ctx); - return error_mark_node; - } - } - - f = make_typename_type (ctx, f); - if (f == error_mark_node) - return f; - return cp_build_qualified_type (f, - CP_TYPE_QUALS (f) - | CP_TYPE_QUALS (t)); - } - - case INDIRECT_REF: - { - 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); - 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); - if (e1 == error_mark_node || e2 == error_mark_node) - return error_mark_node; - - return build_parse_node (ARRAY_REF, e1, e2, tsubst_expr); - } - - case CALL_EXPR: - { - tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, - in_decl); - tree e2 = tsubst_call_declarator_parms (TREE_OPERAND (t, 1), args, - complain, in_decl); - tree e3 = tsubst (TREE_TYPE (t), args, complain, in_decl); - - if (e1 == error_mark_node || e2 == error_mark_node - || e3 == error_mark_node) - return error_mark_node; - - return make_call_declarator (e1, e2, TREE_OPERAND (t, 2), e3); - } - - case SCOPE_REF: - { - 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; - - return build_parse_node (TREE_CODE (t), e1, e2); - } - - case TYPEOF_TYPE: - { - tree e1 = tsubst_expr (TYPE_FIELDS (t), args, complain, - in_decl); - if (e1 == error_mark_node) - return error_mark_node; - - return TREE_TYPE (e1); - } - - default: - sorry ("use of `%s' in template", - tree_code_name [(int) TREE_CODE (t)]); - return error_mark_node; - } -} - -void -do_pushlevel () -{ - emit_line_note (input_filename, lineno); - pushlevel (0); - clear_last_expr (); - push_momentary (); - expand_start_bindings (0); -} - -tree -do_poplevel () -{ - tree t; - int saved_warn_unused = 0; - - if (processing_template_decl) - { - saved_warn_unused = warn_unused; - warn_unused = 0; - } - expand_end_bindings (getdecls (), kept_level_p (), 0); - if (processing_template_decl) - warn_unused = saved_warn_unused; - t = poplevel (kept_level_p (), 1, 0); - pop_momentary (); - return t; -} - -/* Like tsubst, but deals with expressions. This function just replaces - template parms; to finish processing the resultant expression, use - tsubst_expr. */ - -tree -tsubst_copy (t, args, complain, in_decl) - tree t, args; - int complain; - tree in_decl; -{ - enum tree_code code; - tree r; - - if (t == NULL_TREE || t == error_mark_node) - return t; - - code = TREE_CODE (t); - - switch (code) - { - case PARM_DECL: - return do_identifier (DECL_NAME (t), 0, NULL_TREE); - - case CONST_DECL: - { - tree enum_type; - tree v; - - if (!DECL_CONTEXT (t)) - /* This is a global enumeration constant. */ - return t; - - /* Unfortunately, we cannot just call lookup_name here. - Consider: - - template <int I> int f() { - enum E { a = I }; - struct S { void g() { E e = a; } }; - }; - - When we instantiate f<7>::S::g(), say, lookup_name is not - clever enough to find f<7>::a. */ - enum_type - = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl, - /*entering_scope=*/0); - - for (v = TYPE_VALUES (enum_type); - v != NULL_TREE; - v = TREE_CHAIN (v)) - if (TREE_PURPOSE (v) == DECL_NAME (t)) - return TREE_VALUE (v); - - /* We didn't find the name. That should never happen; if - name-lookup found it during preliminary parsing, we - should find it again here during instantiation. */ - my_friendly_abort (0); - } - return t; - - case FIELD_DECL: - if (DECL_CONTEXT (t)) - { - tree ctx; - - ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl, - /*entering_scope=*/1); - if (ctx != DECL_CONTEXT (t)) - return lookup_field (ctx, DECL_NAME (t), 0, 0); - } - return t; - - case VAR_DECL: - case FUNCTION_DECL: - if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)) - t = tsubst (t, args, complain, in_decl); - mark_used (t); - return t; - - case TEMPLATE_DECL: - if (is_member_template (t)) - return tsubst (t, args, complain, in_decl); - else - return t; - - case LOOKUP_EXPR: - { - /* We must tsbust into a LOOKUP_EXPR in case the names to - which it refers is a conversion operator; in that case the - name will change. We avoid making unnecessary copies, - however. */ - - tree id = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl); - - if (id != TREE_OPERAND (t, 0)) - { - r = build_nt (LOOKUP_EXPR, id); - LOOKUP_EXPR_GLOBAL (r) = LOOKUP_EXPR_GLOBAL (t); - t = r; - } - - return t; - } - - case CAST_EXPR: - case REINTERPRET_CAST_EXPR: - case CONST_CAST_EXPR: - case STATIC_CAST_EXPR: - case DYNAMIC_CAST_EXPR: - case NOP_EXPR: - return build1 - (code, tsubst (TREE_TYPE (t), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); - - case INDIRECT_REF: - case PREDECREMENT_EXPR: - case PREINCREMENT_EXPR: - case POSTDECREMENT_EXPR: - case POSTINCREMENT_EXPR: - case NEGATE_EXPR: - case TRUTH_NOT_EXPR: - case BIT_NOT_EXPR: - case ADDR_EXPR: - case CONVERT_EXPR: /* Unary + */ - case SIZEOF_EXPR: - case ALIGNOF_EXPR: - case ARROW_EXPR: - case THROW_EXPR: - case TYPEID_EXPR: - return build1 - (code, tsubst (TREE_TYPE (t), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); - - case PLUS_EXPR: - case MINUS_EXPR: - case MULT_EXPR: - case TRUNC_DIV_EXPR: - case CEIL_DIV_EXPR: - case FLOOR_DIV_EXPR: - case ROUND_DIV_EXPR: - case EXACT_DIV_EXPR: - case BIT_AND_EXPR: - case BIT_ANDTC_EXPR: - case BIT_IOR_EXPR: - case BIT_XOR_EXPR: - case TRUNC_MOD_EXPR: - case FLOOR_MOD_EXPR: - case TRUTH_ANDIF_EXPR: - case TRUTH_ORIF_EXPR: - case TRUTH_AND_EXPR: - case TRUTH_OR_EXPR: - case RSHIFT_EXPR: - case LSHIFT_EXPR: - case RROTATE_EXPR: - case LROTATE_EXPR: - case EQ_EXPR: - case NE_EXPR: - case MAX_EXPR: - case MIN_EXPR: - case LE_EXPR: - case GE_EXPR: - case LT_EXPR: - case GT_EXPR: - case COMPONENT_REF: - case ARRAY_REF: - case COMPOUND_EXPR: - case SCOPE_REF: - case DOTSTAR_EXPR: - case MEMBER_REF: - return build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); - - case CALL_EXPR: - { - tree fn = TREE_OPERAND (t, 0); - if (is_overloaded_fn (fn)) - fn = tsubst_copy (get_first_fn (fn), args, complain, in_decl); - else - /* Sometimes FN is a LOOKUP_EXPR. */ - fn = tsubst_copy (fn, args, complain, in_decl); - return build_nt - (code, fn, tsubst_copy (TREE_OPERAND (t, 1), args, complain, - in_decl), - NULL_TREE); - } - - case METHOD_CALL_EXPR: - { - tree name = TREE_OPERAND (t, 0); - if (TREE_CODE (name) == BIT_NOT_EXPR) - { - name = tsubst_copy (TREE_OPERAND (name, 0), args, - complain, in_decl); - name = build1 (BIT_NOT_EXPR, NULL_TREE, name); - } - else if (TREE_CODE (name) == SCOPE_REF - && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR) - { - tree base = tsubst_copy (TREE_OPERAND (name, 0), args, - complain, in_decl); - name = TREE_OPERAND (name, 1); - name = tsubst_copy (TREE_OPERAND (name, 0), args, - complain, in_decl); - name = build1 (BIT_NOT_EXPR, NULL_TREE, name); - name = build_nt (SCOPE_REF, base, name); - } - else - name = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl); - return build_nt - (code, name, tsubst_copy (TREE_OPERAND (t, 1), args, - complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl), - NULL_TREE); - } - - case BIND_EXPR: - case COND_EXPR: - case MODOP_EXPR: - { - r = build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); - - if (code == BIND_EXPR && !processing_template_decl) - { - /* This processing should really occur in tsubst_expr, - However, tsubst_expr does not recurse into expressions, - since it assumes that there aren't any statements - inside them. Instead, it simply calls - build_expr_from_tree. So, we need to expand the - BIND_EXPR here. */ - tree rtl_expr = begin_stmt_expr (); - tree block = tsubst_expr (TREE_OPERAND (r, 1), args, - complain, in_decl); - r = finish_stmt_expr (rtl_expr, block); - } - - return r; - } - - case NEW_EXPR: - { - r = build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); - NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t); - return r; - } - - case DELETE_EXPR: - { - r = build_nt - (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); - DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t); - DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t); - return r; - } - - case TEMPLATE_ID_EXPR: - { - /* Substituted template arguments */ - tree targs = tsubst_copy (TREE_OPERAND (t, 1), args, complain, - in_decl); - - if (targs && TREE_CODE (targs) == TREE_LIST) - { - tree chain; - for (chain = targs; chain; chain = TREE_CHAIN (chain)) - TREE_VALUE (chain) = maybe_fold_nontype_arg (TREE_VALUE (chain)); - } - else if (targs) - { - int i; - for (i = 0; i < TREE_VEC_LENGTH (targs); ++i) - TREE_VEC_ELT (targs, i) - = maybe_fold_nontype_arg (TREE_VEC_ELT (targs, i)); - } - - return lookup_template_function - (tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), targs); - } - - case TREE_LIST: - { - tree purpose, value, chain; - - if (t == void_list_node) - return t; - - purpose = TREE_PURPOSE (t); - if (purpose) - purpose = tsubst_copy (purpose, args, complain, in_decl); - value = TREE_VALUE (t); - if (value) - value = tsubst_copy (value, args, complain, in_decl); - chain = TREE_CHAIN (t); - if (chain && chain != void_type_node) - chain = tsubst_copy (chain, args, complain, in_decl); - if (purpose == TREE_PURPOSE (t) - && value == TREE_VALUE (t) - && chain == TREE_CHAIN (t)) - return t; - return tree_cons (purpose, value, chain); - } - - case RECORD_TYPE: - case UNION_TYPE: - case ENUMERAL_TYPE: - case INTEGER_TYPE: - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - case TEMPLATE_PARM_INDEX: - case POINTER_TYPE: - case REFERENCE_TYPE: - case OFFSET_TYPE: - case FUNCTION_TYPE: - case METHOD_TYPE: - case ARRAY_TYPE: - case TYPENAME_TYPE: - case TYPE_DECL: - return tsubst (t, args, complain, in_decl); - - case IDENTIFIER_NODE: - if (IDENTIFIER_TYPENAME_P (t) - /* Make sure it's not just a variable named `__opr', for instance, - which can occur in some existing code. */ - && TREE_TYPE (t)) - return build_typename_overload - (tsubst (TREE_TYPE (t), args, complain, in_decl)); - else - return t; - - case CONSTRUCTOR: - { - r = build - (CONSTRUCTOR, tsubst (TREE_TYPE (t), args, complain, in_decl), - NULL_TREE, tsubst_copy (CONSTRUCTOR_ELTS (t), args, - complain, in_decl)); - TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t); - return r; - } - - default: - return t; - } -} - -/* Like tsubst_copy, but also does semantic processing and RTL expansion. */ - -tree -tsubst_expr (t, args, complain, in_decl) - tree t, args; - int complain; - tree in_decl; -{ - if (t == NULL_TREE || t == error_mark_node) - return t; - - if (processing_template_decl) - return tsubst_copy (t, args, complain, in_decl); - - switch (TREE_CODE (t)) - { - case RETURN_STMT: - lineno = TREE_COMPLEXITY (t); - finish_return_stmt (tsubst_expr (RETURN_EXPR (t), - args, complain, in_decl)); - break; - - case EXPR_STMT: - lineno = TREE_COMPLEXITY (t); - finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t), - args, complain, in_decl)); - break; - - case DECL_STMT: - { - int i = suspend_momentary (); - tree dcl, init; - - lineno = TREE_COMPLEXITY (t); - emit_line_note (input_filename, lineno); - dcl = start_decl - (tsubst (TREE_OPERAND (t, 0), args, complain, in_decl), - tsubst (TREE_OPERAND (t, 1), args, complain, in_decl), - TREE_OPERAND (t, 2) != 0, NULL_TREE, NULL_TREE); - init = tsubst_expr (TREE_OPERAND (t, 2), args, complain, in_decl); - cp_finish_decl - (dcl, init, NULL_TREE, 1, /*init ? LOOKUP_ONLYCONVERTING :*/ 0); - resume_momentary (i); - return dcl; - } - - case FOR_STMT: - { - tree tmp; - lineno = TREE_COMPLEXITY (t); - - begin_for_stmt (); - for (tmp = FOR_INIT_STMT (t); tmp; tmp = TREE_CHAIN (tmp)) - tsubst_expr (tmp, args, complain, in_decl); - finish_for_init_stmt (NULL_TREE); - finish_for_cond (tsubst_expr (FOR_COND (t), args, - complain, in_decl), - NULL_TREE); - tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl); - finish_for_expr (tmp, NULL_TREE); - tsubst_expr (FOR_BODY (t), args, complain, in_decl); - finish_for_stmt (tmp, NULL_TREE); - } - break; - - case WHILE_STMT: - { - lineno = TREE_COMPLEXITY (t); - begin_while_stmt (); - finish_while_stmt_cond (tsubst_expr (WHILE_COND (t), - args, complain, in_decl), - NULL_TREE); - tsubst_expr (WHILE_BODY (t), args, complain, in_decl); - finish_while_stmt (NULL_TREE); - } - break; - - case DO_STMT: - { - lineno = TREE_COMPLEXITY (t); - begin_do_stmt (); - tsubst_expr (DO_BODY (t), args, complain, in_decl); - finish_do_body (NULL_TREE); - finish_do_stmt (tsubst_expr (DO_COND (t), args, - complain, in_decl), - NULL_TREE); - } - break; - - case IF_STMT: - { - tree tmp; - - lineno = TREE_COMPLEXITY (t); - begin_if_stmt (); - finish_if_stmt_cond (tsubst_expr (IF_COND (t), - args, complain, in_decl), - NULL_TREE); - - if (tmp = THEN_CLAUSE (t), tmp) - { - tsubst_expr (tmp, args, complain, in_decl); - finish_then_clause (NULL_TREE); - } - - if (tmp = ELSE_CLAUSE (t), tmp) - { - begin_else_clause (); - tsubst_expr (tmp, args, complain, in_decl); - finish_else_clause (NULL_TREE); - } - - finish_if_stmt (); - } - break; - - case COMPOUND_STMT: - { - tree substmt; - - lineno = TREE_COMPLEXITY (t); - begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t)); - for (substmt = COMPOUND_BODY (t); - substmt != NULL_TREE; - substmt = TREE_CHAIN (substmt)) - tsubst_expr (substmt, args, complain, in_decl); - return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t), - NULL_TREE); - } - break; - - case BREAK_STMT: - lineno = TREE_COMPLEXITY (t); - finish_break_stmt (); - break; - - case CONTINUE_STMT: - lineno = TREE_COMPLEXITY (t); - finish_continue_stmt (); - break; - - case SWITCH_STMT: - { - tree val, tmp; - - lineno = TREE_COMPLEXITY (t); - begin_switch_stmt (); - val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl); - finish_switch_cond (val); - - if (tmp = TREE_OPERAND (t, 1), tmp) - tsubst_expr (tmp, args, complain, in_decl); - - finish_switch_stmt (val, NULL_TREE); - } - break; - - case CASE_LABEL: - finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl), - tsubst_expr (CASE_HIGH (t), args, complain, in_decl)); - break; - - case LABEL_DECL: - t = define_label (DECL_SOURCE_FILE (t), DECL_SOURCE_LINE (t), - DECL_NAME (t)); - if (t) - expand_label (t); - break; - - case GOTO_STMT: - lineno = TREE_COMPLEXITY (t); - t = GOTO_DESTINATION (t); - if (TREE_CODE (t) != IDENTIFIER_NODE) - /* Computed goto's must be tsubst'd into. On the other hand, - non-computed gotos must not be; the identifier in question - will have no binding. */ - t = tsubst_expr (t, args, complain, in_decl); - finish_goto_stmt (t); - break; - - case ASM_STMT: - lineno = TREE_COMPLEXITY (t); - finish_asm_stmt (tsubst_expr (ASM_CV_QUAL (t), args, complain, in_decl), - tsubst_expr (ASM_STRING (t), args, complain, in_decl), - tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl), - tsubst_expr (ASM_INPUTS (t), args, complain, in_decl), - tsubst_expr (ASM_CLOBBERS (t), args, complain, - in_decl)); - break; - - case TRY_BLOCK: - lineno = TREE_COMPLEXITY (t); - begin_try_block (); - tsubst_expr (TRY_STMTS (t), args, complain, in_decl); - finish_try_block (NULL_TREE); - { - tree handler = TRY_HANDLERS (t); - for (; handler; handler = TREE_CHAIN (handler)) - tsubst_expr (handler, args, complain, in_decl); - } - finish_handler_sequence (NULL_TREE); - break; - - case HANDLER: - lineno = TREE_COMPLEXITY (t); - begin_handler (); - if (HANDLER_PARMS (t)) - { - tree d = HANDLER_PARMS (t); - expand_start_catch_block - (tsubst (TREE_OPERAND (d, 1), args, complain, in_decl), - tsubst (TREE_OPERAND (d, 0), args, complain, in_decl)); - } - else - expand_start_catch_block (NULL_TREE, NULL_TREE); - finish_handler_parms (NULL_TREE); - tsubst_expr (HANDLER_BODY (t), args, complain, in_decl); - finish_handler (NULL_TREE); - break; - - case TAG_DEFN: - lineno = TREE_COMPLEXITY (t); - t = TREE_TYPE (t); - if (TREE_CODE (t) == ENUMERAL_TYPE) - tsubst (t, args, complain, NULL_TREE); - break; - - default: - return build_expr_from_tree (tsubst_copy (t, args, complain, in_decl)); - } - return NULL_TREE; -} - -/* Instantiate the indicated variable or function template TMPL with - the template arguments in TARG_PTR. */ - -tree -instantiate_template (tmpl, targ_ptr) - tree tmpl, targ_ptr; -{ - tree fndecl; - tree gen_tmpl; - tree spec; - int i, len; - struct obstack *old_fmp_obstack; - extern struct obstack *function_maybepermanent_obstack; - tree inner_args; - - if (tmpl == error_mark_node) - return error_mark_node; - - my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283); - - /* Check to see if we already have this specialization. */ - spec = retrieve_specialization (tmpl, targ_ptr); - if (spec != NULL_TREE) - return spec; - - if (DECL_TEMPLATE_INFO (tmpl)) - { - /* The TMPL is a partial instantiation. To get a full set of - arguments we must add the arguments used to perform the - partial instantiation. */ - targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl), - targ_ptr); - gen_tmpl = most_general_template (tmpl); - - /* Check to see if we already have this specialization. */ - spec = retrieve_specialization (gen_tmpl, targ_ptr); - if (spec != NULL_TREE) - return spec; - } - else - gen_tmpl = tmpl; - - push_obstacks (&permanent_obstack, &permanent_obstack); - old_fmp_obstack = function_maybepermanent_obstack; - function_maybepermanent_obstack = &permanent_obstack; - - len = DECL_NTPARMS (gen_tmpl); - inner_args = innermost_args (targ_ptr); - i = len; - while (i--) - { - tree t = TREE_VEC_ELT (inner_args, i); - if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') - { - tree nt = target_type (t); - if (IS_AGGR_TYPE (nt) && decl_function_context (TYPE_MAIN_DECL (nt))) - { - cp_error ("type `%T' composed from a local class is not a valid template-argument", t); - cp_error (" trying to instantiate `%D'", gen_tmpl); - fndecl = error_mark_node; - goto out; - } - } - } - targ_ptr = copy_to_permanent (targ_ptr); - - /* substitute template parameters */ - fndecl = tsubst (DECL_RESULT (gen_tmpl), targ_ptr, /*complain=*/1, gen_tmpl); - /* The DECL_TI_TEMPLATE should always be the immediate parent - template, not the most general template. */ - DECL_TI_TEMPLATE (fndecl) = tmpl; - - if (flag_external_templates) - add_pending_template (fndecl); - - out: - function_maybepermanent_obstack = old_fmp_obstack; - pop_obstacks (); - - return fndecl; -} - -/* Push the name of the class template into the scope of the instantiation. */ - -void -overload_template_name (type) - tree type; -{ - tree id = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)); - tree decl; - - if (IDENTIFIER_CLASS_VALUE (id) - && TREE_TYPE (IDENTIFIER_CLASS_VALUE (id)) == type) - return; - - decl = build_decl (TYPE_DECL, id, type); - SET_DECL_ARTIFICIAL (decl); - pushdecl_class_level (decl); -} - -/* The FN is a TEMPLATE_DECL for a function. The ARGS are the - arguments that are being used when calling it. TARGS is a vector - into which the deduced template arguments are placed. - - Return zero for success, 2 for an incomplete match that doesn't resolve - all the types, and 1 for complete failure. An error message will be - printed only for an incomplete match. - - If FN is a conversion operator, RETURN_TYPE is the type desired as - the result of the conversion operator. - - TPARMS is a vector of template parameters. - - The EXPLICIT_TARGS are explicit template arguments provided via a - template-id. - - The parameter STRICT is one of: - - DEDUCE_CALL: - We are deducing arguments for a function call, as in - [temp.deduct.call]. - - DEDUCE_CONV: - We are deducing arguments for a conversion function, as in - [temp.deduct.conv]. - - DEDUCE_EXACT: - We are deducing arguments when calculating the partial - ordering between specializations of function or class - templates, as in [temp.func.order] and [temp.class.order], - when doing an explicit instantiation as in [temp.explicit], - when determining an explicit specialization as in - [temp.expl.spec], or when taking the address of a function - template, as in [temp.deduct.funcaddr]. - - The other arguments are as for type_unification. */ - -int -fn_type_unification (fn, explicit_targs, targs, args, return_type, - strict) - tree fn, explicit_targs, targs, args, return_type; - unification_kind_t strict; -{ - tree parms; - tree fntype; - - my_friendly_assert (TREE_CODE (fn) == TEMPLATE_DECL, 0); - - fntype = TREE_TYPE (fn); - if (explicit_targs) - { - /* [temp.deduct] - - The specified template arguments must match the template - parameters in kind (i.e., type, nontype, template), and there - must not be more arguments than there are parameters; - otherwise type deduction fails. - - Nontype arguments must match the types of the corresponding - nontype template parameters, or must be convertible to the - types of the corresponding nontype parameters as specified in - _temp.arg.nontype_, otherwise type deduction fails. - - All references in the function type of the function template - to the corresponding template parameters are replaced by the - specified template argument values. If a substitution in a - template parameter or in the function type of the function - template results in an invalid type, type deduction fails. */ - int i; - tree converted_args; - - converted_args - = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn), - explicit_targs, NULL_TREE, /*complain=*/0, - /*require_all_arguments=*/0)); - if (converted_args == error_mark_node) - return 1; - - fntype = tsubst (fntype, converted_args, /*complain=*/0, NULL_TREE); - if (fntype == error_mark_node) - return 1; - - /* Place the explicitly specified arguments in TARGS. */ - for (i = 0; i < TREE_VEC_LENGTH (targs); i++) - TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i); - } - - parms = TYPE_ARG_TYPES (fntype); - - if (DECL_CONV_FN_P (fn)) - { - /* This is a template conversion operator. Use the return types - as well as the argument types. We use it instead of 'this', since - we could be comparing conversions from different classes. */ - parms = scratch_tree_cons (NULL_TREE, TREE_TYPE (fntype), - TREE_CHAIN (parms)); - args = scratch_tree_cons (NULL_TREE, return_type, TREE_CHAIN (args)); - } - - /* We allow incomplete unification without an error message here - because the standard doesn't seem to explicitly prohibit it. Our - callers must be ready to deal with unification failures in any - event. */ - return type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn), - targs, parms, args, /*subr=*/0, - strict, /*allow_incomplete*/1); -} - -/* Adjust types before performing type deduction, as described in - [temp.deduct.call] and [temp.deduct.conv]. The rules in these two - sections are symmetric. PARM is the type of a function parameter - or the return type of the conversion function. ARG is the type of - the argument passed to the call, or the type of the value - intialized with the result of the conversion function. */ - -static void -maybe_adjust_types_for_deduction (strict, parm, arg) - unification_kind_t strict; - tree* parm; - tree* arg; -{ - switch (strict) - { - case DEDUCE_CALL: - break; - - case DEDUCE_CONV: - { - /* Swap PARM and ARG throughout the remainder of this - function; the handling is precisely symmetric since PARM - will initialize ARG rather than vice versa. */ - tree* temp = parm; - parm = arg; - arg = temp; - break; - } - - case DEDUCE_EXACT: - /* There is nothing to do in this case. */ - return; - - default: - my_friendly_abort (0); - } - - if (TREE_CODE (*parm) != REFERENCE_TYPE) - { - /* [temp.deduct.call] - - If P is not a reference type: - - --If A is an array type, the pointer type produced by the - array-to-pointer standard conversion (_conv.array_) is - used in place of A for type deduction; otherwise, - - --If A is a function type, the pointer type produced by - the function-to-pointer standard conversion - (_conv.func_) is used in place of A for type deduction; - otherwise, - - --If A is a cv-qualified type, the top level - cv-qualifiers of A's type are ignored for type - deduction. */ - if (TREE_CODE (*arg) == ARRAY_TYPE) - *arg = build_pointer_type (TREE_TYPE (*arg)); - else if (TREE_CODE (*arg) == FUNCTION_TYPE) - *arg = build_pointer_type (*arg); - else - *arg = TYPE_MAIN_VARIANT (*arg); - } - - /* [temp.deduct.call] - - If P is a cv-qualified type, the top level cv-qualifiers - of P's type are ignored for type deduction. If P is a - reference type, the type referred to by P is used for - type deduction. */ - *parm = TYPE_MAIN_VARIANT (*parm); - if (TREE_CODE (*parm) == REFERENCE_TYPE) - *parm = TREE_TYPE (*parm); -} - -/* Like type_unfication. - - If SUBR is 1, we're being called recursively (to unify the - arguments of a function or method parameter of a function - template). */ - -static int -type_unification_real (tparms, targs, parms, args, subr, - strict, allow_incomplete) - tree tparms, targs, parms, args; - int subr; - unification_kind_t strict; - int allow_incomplete; -{ - tree parm, arg; - int i; - int ntparms = TREE_VEC_LENGTH (tparms); - int sub_strict; - - my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289); - my_friendly_assert (parms == NULL_TREE - || TREE_CODE (parms) == TREE_LIST, 290); - /* ARGS could be NULL (via a call from parse.y to - build_x_function_call). */ - if (args) - my_friendly_assert (TREE_CODE (args) == TREE_LIST, 291); - my_friendly_assert (ntparms > 0, 292); - - switch (strict) - { - case DEDUCE_CALL: - sub_strict = UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_DERIVED; - break; - - case DEDUCE_CONV: - sub_strict = UNIFY_ALLOW_LESS_CV_QUAL; - break; - - case DEDUCE_EXACT: - sub_strict = UNIFY_ALLOW_NONE; - break; - - default: - my_friendly_abort (0); - } - - while (parms - && parms != void_list_node - && args - && args != void_list_node) - { - parm = TREE_VALUE (parms); - parms = TREE_CHAIN (parms); - arg = TREE_VALUE (args); - args = TREE_CHAIN (args); - - if (arg == error_mark_node) - return 1; - if (arg == unknown_type_node) - /* We can't deduce anything from this, but we might get all the - template args from other function args. */ - continue; - - /* Conversions will be performed on a function argument that - corresponds with a function parameter that contains only - non-deducible template parameters and explicitly specified - template parameters. */ - if (! uses_template_parms (parm)) - { - tree type; - - if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't') - type = TREE_TYPE (arg); - else - { - type = arg; - arg = NULL_TREE; - } - - if (strict == DEDUCE_EXACT) - { - if (same_type_p (parm, type)) - continue; - } - else - /* It might work; we shouldn't check now, because we might - get into infinite recursion. Overload resolution will - handle it. */ - continue; - - return 1; - } - - if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't') - { - my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293); - if (type_unknown_p (arg)) - { - /* [temp.deduct.type] A template-argument can be deduced from - a pointer to function or pointer to member function - argument if the set of overloaded functions does not - contain function templates and at most one of a set of - overloaded functions provides a unique match. */ - - if (resolve_overloaded_unification - (tparms, targs, parm, arg, strict, sub_strict) - != 0) - return 1; - continue; - } - arg = TREE_TYPE (arg); - } - - if (!subr) - maybe_adjust_types_for_deduction (strict, &parm, &arg); - - switch (unify (tparms, targs, parm, arg, sub_strict)) - { - case 0: - break; - case 1: - return 1; - } - } - /* Fail if we've reached the end of the parm list, and more args - are present, and the parm list isn't variadic. */ - if (args && args != void_list_node && parms == void_list_node) - return 1; - /* Fail if parms are left and they don't have default values. */ - if (parms - && parms != void_list_node - && TREE_PURPOSE (parms) == NULL_TREE) - return 1; - if (!subr) - for (i = 0; i < ntparms; i++) - if (TREE_VEC_ELT (targs, i) == NULL_TREE) - { - if (!allow_incomplete) - error ("incomplete type unification"); - return 2; - } - return 0; -} - -/* Subroutine of type_unification_real. Args are like the variables at the - call site. ARG is an overloaded function (or template-id); we try - deducing template args from each of the overloads, and if only one - succeeds, we go with that. Modifies TARGS and returns 0 on success. */ - -static int -resolve_overloaded_unification (tparms, targs, parm, arg, strict, - sub_strict) - tree tparms, targs, parm, arg; - unification_kind_t strict; - int sub_strict; -{ - tree tempargs = copy_node (targs); - int good = 0; - - if (TREE_CODE (arg) == ADDR_EXPR) - arg = TREE_OPERAND (arg, 0); - - if (TREE_CODE (arg) == COMPONENT_REF) - /* Handle `&x' where `x' is some static or non-static member - function name. */ - arg = TREE_OPERAND (arg, 1); - - if (TREE_CODE (arg) == OFFSET_REF) - arg = TREE_OPERAND (arg, 1); - - /* Strip baselink information. */ - while (TREE_CODE (arg) == TREE_LIST) - arg = TREE_VALUE (arg); - - if (TREE_CODE (arg) == TEMPLATE_ID_EXPR) - { - /* If we got some explicit template args, we need to plug them into - the affected templates before we try to unify, in case the - explicit args will completely resolve the templates in question. */ - - tree expl_subargs = TREE_OPERAND (arg, 1); - arg = TREE_OPERAND (arg, 0); - - for (; arg; arg = OVL_NEXT (arg)) - { - tree fn = OVL_CURRENT (arg); - tree subargs, elem; - - if (TREE_CODE (fn) != TEMPLATE_DECL) - continue; - - subargs = get_bindings_overload (fn, DECL_RESULT (fn), expl_subargs); - if (subargs) - { - elem = tsubst (TREE_TYPE (fn), subargs, /*complain=*/0, - 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, - strict, sub_strict); - } - } - } - else if (TREE_CODE (arg) == OVERLOAD) - { - for (; arg; arg = OVL_NEXT (arg)) - { - tree type = TREE_TYPE (OVL_CURRENT (arg)); - if (TREE_CODE (type) == METHOD_TYPE) - type = build_ptrmemfunc_type (build_pointer_type (type)); - good += try_one_overload (tparms, targs, tempargs, parm, - type, - strict, sub_strict); - } - } - else - my_friendly_abort (981006); - - /* [temp.deduct.type] A template-argument can be deduced from a pointer - to function or pointer to member function argument if the set of - overloaded functions does not contain function templates and at most - one of a set of overloaded functions provides a unique match. - - So if we found multiple possibilities, we return success but don't - deduce anything. */ - - if (good == 1) - { - int i = TREE_VEC_LENGTH (targs); - for (; i--; ) - if (TREE_VEC_ELT (tempargs, i)) - TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i); - } - if (good) - return 0; - - return 1; -} - -/* Subroutine of resolve_overloaded_unification; does deduction for a single - overload. Fills TARGS with any deduced arguments, or error_mark_node if - different overloads deduce different arguments for a given parm. - Returns 1 on success. */ - -static int -try_one_overload (tparms, orig_targs, targs, parm, arg, strict, - sub_strict) - tree tparms, orig_targs, targs, parm, arg; - unification_kind_t strict; - int sub_strict; -{ - int nargs; - tree tempargs; - int i; - - /* [temp.deduct.type] A template-argument can be deduced from a pointer - to function or pointer to member function argument if the set of - overloaded functions does not contain function templates and at most - one of a set of overloaded functions provides a unique match. - - So if this is a template, just return success. */ - - if (uses_template_parms (arg)) - return 1; - - maybe_adjust_types_for_deduction (strict, &parm, &arg); - - /* We don't copy orig_targs for this because if we have already deduced - some template args from previous args, unify would complain when we - try to deduce a template parameter for the same argument, even though - there isn't really a conflict. */ - nargs = TREE_VEC_LENGTH (targs); - tempargs = make_scratch_vec (nargs); - - if (unify (tparms, tempargs, parm, arg, sub_strict) != 0) - return 0; - - /* First make sure we didn't deduce anything that conflicts with - explicitly specified args. */ - for (i = nargs; i--; ) - { - tree elt = TREE_VEC_ELT (tempargs, i); - tree oldelt = TREE_VEC_ELT (orig_targs, i); - - if (elt == NULL_TREE) - continue; - else if (uses_template_parms (elt)) - { - /* Since we're unifying against ourselves, we will fill in template - args used in the function parm list with our own template parms. - Discard them. */ - TREE_VEC_ELT (tempargs, i) = NULL_TREE; - continue; - } - else if (oldelt && ! template_args_equal (oldelt, elt)) - return 0; - } - - for (i = nargs; i--; ) - { - tree elt = TREE_VEC_ELT (tempargs, i); - - if (elt) - TREE_VEC_ELT (targs, i) = elt; - } - - return 1; -} - -/* PARM is a template class (perhaps with unbound template - parameters). ARG is a fully instantiated type. If ARG can be - bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and - TARGS are as for unify. */ - -static tree -try_class_unification (tparms, targs, parm, arg) - tree tparms; - tree targs; - tree parm; - tree arg; -{ - int i; - tree copy_of_targs; - - if (!CLASSTYPE_TEMPLATE_INFO (arg) - || CLASSTYPE_TI_TEMPLATE (arg) != CLASSTYPE_TI_TEMPLATE (parm)) - return NULL_TREE; - - /* We need to make a new template argument vector for the call to - unify. If we used TARGS, we'd clutter it up with the result of - the attempted unification, even if this class didn't work out. - We also don't want to commit ourselves to all the unifications - we've already done, since unification is supposed to be done on - an argument-by-argument basis. In other words, consider the - following pathological case: - - template <int I, int J, int K> - struct S {}; - - template <int I, int J> - struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {}; - - template <int I, int J, int K> - void f(S<I, J, K>, S<I, I, I>); - - void g() { - S<0, 0, 0> s0; - S<0, 1, 2> s2; - - f(s0, s2); - } - - Now, by the time we consider the unification involving `s2', we - already know that we must have `f<0, 0, 0>'. But, even though - `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal - because there are two ways to unify base classes of S<0, 1, 2> - with S<I, I, I>. If we kept the already deduced knowledge, we - would reject the possibility I=1. */ - push_momentary (); - copy_of_targs = make_temp_vec (TREE_VEC_LENGTH (targs)); - i = unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm), - CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE); - pop_momentary (); - - /* If unification failed, we're done. */ - if (i != 0) - return NULL_TREE; - else - return arg; -} - -/* Subroutine of get_template_base. RVAL, if non-NULL, is a base we - have alreay discovered to be satisfactory. ARG_BINFO is the binfo - for the base class of ARG that we are currently examining. */ - -static tree -get_template_base_recursive (tparms, targs, parm, - arg_binfo, rval, flags) - tree tparms; - tree targs; - tree arg_binfo; - tree rval; - tree parm; - int flags; -{ - tree binfos; - int i, n_baselinks; - tree arg = BINFO_TYPE (arg_binfo); - - if (!(flags & GTB_IGNORE_TYPE)) - { - tree r = try_class_unification (tparms, targs, - parm, arg); - - /* If there is more than one satisfactory baseclass, then: - - [temp.deduct.call] - - If they yield more than one possible deduced A, the type - deduction fails. - - applies. */ - if (r && rval && !same_type_p (r, rval)) - return error_mark_node; - else if (r) - rval = r; - } - - binfos = BINFO_BASETYPES (arg_binfo); - n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - /* Process base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - int this_virtual; - - /* Skip this base, if we've already seen it. */ - if (BINFO_MARKED (base_binfo)) - continue; - - this_virtual = - (flags & GTB_VIA_VIRTUAL) || TREE_VIA_VIRTUAL (base_binfo); - - /* When searching for a non-virtual, we cannot mark virtually - found binfos. */ - if (! this_virtual) - SET_BINFO_MARKED (base_binfo); - - rval = get_template_base_recursive (tparms, targs, - parm, - base_binfo, - rval, - GTB_VIA_VIRTUAL * this_virtual); - - /* If we discovered more than one matching base class, we can - stop now. */ - if (rval == error_mark_node) - return error_mark_node; - } - - return rval; -} - -/* Given a template type PARM and a class type ARG, find the unique - base type in ARG that is an instance of PARM. We do not examine - ARG itself; only its base-classes. If there is no appropriate base - class, return NULL_TREE. If there is more than one, return - error_mark_node. PARM may be the type of a partial specialization, - as well as a plain template type. Used by unify. */ - -static tree -get_template_base (tparms, targs, parm, arg) - tree tparms; - tree targs; - tree parm; - tree arg; -{ - tree rval; - tree arg_binfo; - - my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)), 92); - - arg_binfo = TYPE_BINFO (complete_type (arg)); - rval = get_template_base_recursive (tparms, targs, - parm, arg_binfo, - NULL_TREE, - GTB_IGNORE_TYPE); - - /* Since get_template_base_recursive marks the bases classes, we - must unmark them here. */ - dfs_walk (arg_binfo, dfs_unmark, markedp, 0); - - return rval; -} - -/* Returns the level of DECL, which declares a template parameter. */ - -static int -template_decl_level (decl) - tree decl; -{ - switch (TREE_CODE (decl)) - { - case TYPE_DECL: - case TEMPLATE_DECL: - return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl)); - - case PARM_DECL: - return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl)); - - default: - my_friendly_abort (0); - return 0; - } -} - -/* Decide whether ARG can be unified with PARM, considering only the - cv-qualifiers of each type, given STRICT as documented for unify. - Returns non-zero iff the unification is OK on that basis.*/ - -static int -check_cv_quals_for_unify (strict, arg, parm) - int strict; - tree arg; - tree parm; -{ - return !((!(strict & UNIFY_ALLOW_MORE_CV_QUAL) - && !at_least_as_qualified_p (arg, parm)) - || (!(strict & UNIFY_ALLOW_LESS_CV_QUAL) - && (!at_least_as_qualified_p (parm, arg)))); -} - -/* Takes parameters as for type_unification. Returns 0 if the - type deduction suceeds, 1 otherwise. The parameter STRICT is a - bitwise or of the following flags: - - UNIFY_ALLOW_NONE: - Require an exact match between PARM and ARG. - UNIFY_ALLOW_MORE_CV_QUAL: - Allow the deduced ARG to be more cv-qualified than ARG. - UNIFY_ALLOW_LESS_CV_QUAL: - Allow the deduced ARG to be less cv-qualified than ARG. - UNIFY_ALLOW_DERIVED: - Allow the deduced ARG to be a template base class of ARG, - or a pointer to a template base class of the type pointed to by - ARG. - UNIFY_ALLOW_INTEGER: - Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX - case for more information. */ - -static int -unify (tparms, targs, parm, arg, strict) - tree tparms, targs, parm, arg; - int strict; -{ - int idx; - tree targ; - tree tparm; - - /* I don't think this will do the right thing with respect to types. - But the only case I've seen it in so far has been array bounds, where - signedness is the only information lost, and I think that will be - okay. */ - while (TREE_CODE (parm) == NOP_EXPR) - parm = TREE_OPERAND (parm, 0); - - if (arg == error_mark_node) - return 1; - if (arg == unknown_type_node) - /* We can't deduce anything from this, but we might get all the - template args from other function args. */ - return 0; - - /* If PARM uses template parameters, then we can't bail out here, - even if ARG == PARM, since we won't record unifications for the - template parameters. We might need them if we're trying to - figure out which of two things is more specialized. */ - if (arg == parm && !uses_template_parms (parm)) - return 0; - - /* Immediately reject some pairs that won't unify because of - cv-qualification mismatches. */ - if (TREE_CODE (arg) == TREE_CODE (parm) - && TREE_CODE_CLASS (TREE_CODE (arg)) == 't' - /* We check the cv-qualifiers when unifying with template type - parameters below. We want to allow ARG `const T' to unify with - PARM `T' for example, when computing which of two templates - is more specialized, for example. */ - && TREE_CODE (arg) != TEMPLATE_TYPE_PARM - && !check_cv_quals_for_unify (strict, arg, parm)) - return 1; - - switch (TREE_CODE (parm)) - { - case TYPENAME_TYPE: - /* In a type which contains a nested-name-specifier, template - argument values cannot be deduced for template parameters used - within the nested-name-specifier. */ - return 0; - - case TEMPLATE_TYPE_PARM: - case TEMPLATE_TEMPLATE_PARM: - tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); - - if (TEMPLATE_TYPE_LEVEL (parm) - != template_decl_level (tparm)) - /* The PARM is not one we're trying to unify. Just check - to see if it matches ARG. */ - return (TREE_CODE (arg) == TREE_CODE (parm) - && same_type_p (parm, arg)) ? 0 : 1; - idx = TEMPLATE_TYPE_IDX (parm); - targ = TREE_VEC_ELT (targs, idx); - tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx)); - - /* Check for mixed types and values. */ - if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM - && TREE_CODE (tparm) != TYPE_DECL) - || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM - && TREE_CODE (tparm) != TEMPLATE_DECL)) - return 1; - - if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM) - { - if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm)) - { - /* We arrive here when PARM does not involve template - specialization. */ - - /* ARG must be constructed from a template class. */ - if (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)) - return 1; - - { - tree parmtmpl = TYPE_TI_TEMPLATE (parm); - tree parmvec = TYPE_TI_ARGS (parm); - tree argvec = CLASSTYPE_TI_ARGS (arg); - tree argtmplvec - = DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg)); - int i; - - /* The parameter and argument roles have to be switched here - in order to handle default arguments properly. For example, - template<template <class> class TT> void f(TT<int>) - should be able to accept vector<int> which comes from - template <class T, class Allocator = allocator> - class vector. */ - - if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1) - == error_mark_node) - return 1; - - /* Deduce arguments T, i from TT<T> or TT<i>. - We check each element of PARMVEC and ARGVEC individually - rather than the whole TREE_VEC since they can have - different number of elements. */ - - for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i) - { - tree t = TREE_VEC_ELT (parmvec, i); - - if (unify (tparms, targs, t, - TREE_VEC_ELT (argvec, i), - UNIFY_ALLOW_NONE)) - return 1; - } - } - arg = CLASSTYPE_TI_TEMPLATE (arg); - } - } - else - { - /* If PARM is `const T' and ARG is only `int', we don't have - a match unless we are allowing additional qualification. - If ARG is `const int' and PARM is just `T' that's OK; - that binds `const int' to `T'. */ - if (!check_cv_quals_for_unify (strict | UNIFY_ALLOW_LESS_CV_QUAL, - arg, parm)) - 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 (arg, - CP_TYPE_QUALS (arg) - & ~CP_TYPE_QUALS (parm)); - } - - /* Simple cases: Value already set, does match or doesn't. */ - if (targ != NULL_TREE && same_type_p (targ, arg)) - return 0; - else if (targ) - return 1; - - /* Make sure that ARG is not a variable-sized array. (Note that - were talking about variable-sized arrays (like `int[n]'), - rather than arrays of unknown size (like `int[]').) We'll - get very confused by such a type since the bound of the array - will not be computable in an instantiation. Besides, such - types are not allowed in ISO C++, so we can do as we please - here. */ - if (TREE_CODE (arg) == ARRAY_TYPE - && !uses_template_parms (arg) - && (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (arg))) - != INTEGER_CST)) - return 1; - - TREE_VEC_ELT (targs, idx) = arg; - return 0; - - case TEMPLATE_PARM_INDEX: - tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); - - if (TEMPLATE_PARM_LEVEL (parm) - != template_decl_level (tparm)) - /* The PARM is not one we're trying to unify. Just check - to see if it matches ARG. */ - return (TREE_CODE (arg) == TREE_CODE (parm) - && cp_tree_equal (parm, arg) > 0) ? 0 : 1; - - idx = TEMPLATE_PARM_IDX (parm); - targ = TREE_VEC_ELT (targs, idx); - - if (targ) - { - int i = (cp_tree_equal (targ, arg) > 0); - if (i == 1) - return 0; - else if (i == 0) - return 1; - else - my_friendly_abort (42); - } - - /* [temp.deduct.type] If, in the declaration of a function template - with a non-type template-parameter, the non-type - template-parameter is used in an expression in the function - parameter-list and, if the corresponding template-argument is - deduced, the template-argument type shall match the type of the - template-parameter exactly, except that a template-argument - deduced from an array bound may be of any integral type. */ - if (same_type_p (TREE_TYPE (arg), TREE_TYPE (parm))) - /* OK */; - else if ((strict & UNIFY_ALLOW_INTEGER) - && (TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE - || TREE_CODE (TREE_TYPE (parm)) == BOOLEAN_TYPE)) - /* OK */; - else - return 1; - - TREE_VEC_ELT (targs, idx) = copy_to_permanent (arg); - return 0; - - case POINTER_TYPE: - { - int sub_strict; - - if (TREE_CODE (arg) == RECORD_TYPE && TYPE_PTRMEMFUNC_FLAG (arg)) - return (unify (tparms, targs, parm, - TYPE_PTRMEMFUNC_FN_TYPE (arg), strict)); - - if (TREE_CODE (arg) != POINTER_TYPE) - return 1; - - /* [temp.deduct.call] - - A can be another pointer or pointer to member type that can - be converted to the deduced A via a qualification - conversion (_conv.qual_). - - We pass down STRICT here rather than UNIFY_ALLOW_NONE. - This will allow for additional cv-qualification of the - pointed-to types if appropriate. In general, this is a bit - too generous; we are only supposed to allow qualification - conversions and this method will allow an ARG of char** and - a deduced ARG of const char**. However, overload - resolution will subsequently invalidate the candidate, so - this is probably OK. */ - sub_strict = strict; - - if (TREE_CODE (TREE_TYPE (arg)) != RECORD_TYPE - || TYPE_PTRMEMFUNC_FLAG (TREE_TYPE (arg))) - /* The derived-to-base conversion only persists through one - level of pointers. */ - sub_strict &= ~UNIFY_ALLOW_DERIVED; - - return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE - (arg), sub_strict); - } - - case REFERENCE_TYPE: - if (TREE_CODE (arg) != REFERENCE_TYPE) - return 1; - return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), - UNIFY_ALLOW_NONE); - - case ARRAY_TYPE: - if (TREE_CODE (arg) != ARRAY_TYPE) - return 1; - if ((TYPE_DOMAIN (parm) == NULL_TREE) - != (TYPE_DOMAIN (arg) == NULL_TREE)) - return 1; - if (TYPE_DOMAIN (parm) != NULL_TREE - && unify (tparms, targs, TYPE_DOMAIN (parm), - TYPE_DOMAIN (arg), UNIFY_ALLOW_NONE) != 0) - return 1; - return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), - UNIFY_ALLOW_NONE); - - case REAL_TYPE: - case COMPLEX_TYPE: - case INTEGER_TYPE: - case BOOLEAN_TYPE: - case VOID_TYPE: - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 1; - - if (TREE_CODE (parm) == INTEGER_TYPE - && TREE_CODE (TYPE_MAX_VALUE (parm)) != INTEGER_CST) - { - if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg) - && unify (tparms, targs, TYPE_MIN_VALUE (parm), - TYPE_MIN_VALUE (arg), UNIFY_ALLOW_INTEGER)) - return 1; - if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg) - && unify (tparms, targs, TYPE_MAX_VALUE (parm), - TYPE_MAX_VALUE (arg), UNIFY_ALLOW_INTEGER)) - return 1; - } - /* We use the TYPE_MAIN_VARIANT since we have already - checked cv-qualification at the top of the - function. */ - else if (!same_type_p (TYPE_MAIN_VARIANT (arg), - TYPE_MAIN_VARIANT (parm))) - return 1; - - /* As far as unification is concerned, this wins. Later checks - will invalidate it if necessary. */ - return 0; - - /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */ - /* Type INTEGER_CST can come from ordinary constant template args. */ - case INTEGER_CST: - while (TREE_CODE (arg) == NOP_EXPR) - arg = TREE_OPERAND (arg, 0); - - if (TREE_CODE (arg) != INTEGER_CST) - return 1; - return !tree_int_cst_equal (parm, arg); - - case TREE_VEC: - { - int i; - if (TREE_CODE (arg) != TREE_VEC) - return 1; - if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg)) - return 1; - for (i = TREE_VEC_LENGTH (parm) - 1; i >= 0; i--) - if (unify (tparms, targs, - TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i), - UNIFY_ALLOW_NONE)) - return 1; - return 0; - } - - case RECORD_TYPE: - case UNION_TYPE: - if (TYPE_PTRMEMFUNC_FLAG (parm)) - return unify (tparms, targs, TYPE_PTRMEMFUNC_FN_TYPE (parm), - arg, strict); - - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 1; - - if (CLASSTYPE_TEMPLATE_INFO (parm)) - { - tree t = NULL_TREE; - - if (strict & UNIFY_ALLOW_DERIVED) - { - /* First, we try to unify the PARM and ARG directly. */ - t = try_class_unification (tparms, targs, - parm, arg); - - if (!t) - { - /* Fallback to the special case allowed in - [temp.deduct.call]: - - If P is a class, and P has the form - template-id, then A can be a derived class of - the deduced A. Likewise, if P is a pointer to - a class of the form template-id, A can be a - pointer to a derived class pointed to by the - deduced A. */ - t = get_template_base (tparms, targs, - parm, arg); - - if (! t || t == error_mark_node) - return 1; - } - } - else if (CLASSTYPE_TEMPLATE_INFO (arg) - && (CLASSTYPE_TI_TEMPLATE (parm) - == CLASSTYPE_TI_TEMPLATE (arg))) - /* Perhaps PARM is something like S<U> and ARG is S<int>. - Then, we should unify `int' and `U'. */ - t = arg; - else - /* There's no chance of unication succeeding. */ - return 1; - - return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm), - CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE); - } - else if (!same_type_p (TYPE_MAIN_VARIANT (parm), - TYPE_MAIN_VARIANT (arg))) - return 1; - return 0; - - case METHOD_TYPE: - case FUNCTION_TYPE: - if (TREE_CODE (arg) != TREE_CODE (parm)) - return 1; - - if (unify (tparms, targs, TREE_TYPE (parm), - TREE_TYPE (arg), UNIFY_ALLOW_NONE)) - return 1; - return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm), - TYPE_ARG_TYPES (arg), 1, - DEDUCE_EXACT, 0); - - case OFFSET_TYPE: - if (TREE_CODE (arg) != OFFSET_TYPE) - return 1; - if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm), - TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE)) - return 1; - return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), - strict); - - case CONST_DECL: - if (arg != decl_constant_value (parm)) - return 1; - return 0; - - case TEMPLATE_DECL: - /* Matched cases are handled by the ARG == PARM test above. */ - return 1; - - case MINUS_EXPR: - if (TREE_CODE (TREE_OPERAND (parm, 1)) == INTEGER_CST) - { - /* We handle this case specially, since it comes up with - arrays. In particular, something like: - - template <int N> void f(int (&x)[N]); - - Here, we are trying to unify the range type, which - looks like [0 ... (N - 1)]. */ - tree t, t1, t2; - t1 = TREE_OPERAND (parm, 0); - t2 = TREE_OPERAND (parm, 1); - - /* Should this be a regular fold? */ - t = maybe_fold_nontype_arg (build (PLUS_EXPR, - integer_type_node, - arg, t2)); - - return unify (tparms, targs, t1, t, strict); - } - /* else fall through */ - - default: - if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm)))) - /* We're looking at an expression. This can happen with - something like: - - template <int I> - void foo(S<I>, S<I + 2>); - - This is a "nondeduced context": - - [deduct.type] - - The nondeduced contexts are: - - --A type that is a template-id in which one or more of - the template-arguments is an expression that references - a template-parameter. - - In these cases, we assume deduction succeeded, but don't - actually infer any unifications. */ - return 0; - else - sorry ("use of `%s' in template type unification", - tree_code_name [(int) TREE_CODE (parm)]); - - return 1; - } -} - -/* Called if RESULT is explicitly instantiated, or is a member of an - explicitly instantiated class, or if using -frepo and the - instantiation of RESULT has been assigned to this file. */ - -void -mark_decl_instantiated (result, extern_p) - tree result; - int extern_p; -{ - if (TREE_CODE (result) != FUNCTION_DECL) - /* The TREE_PUBLIC flag for function declarations will have been - set correctly by tsubst. */ - TREE_PUBLIC (result) = 1; - - if (! extern_p) - { - DECL_INTERFACE_KNOWN (result) = 1; - DECL_NOT_REALLY_EXTERN (result) = 1; - - /* Always make artificials weak. */ - if (DECL_ARTIFICIAL (result) && flag_weak) - comdat_linkage (result); - /* For WIN32 we also want to put explicit instantiations in - linkonce sections. */ - else if (TREE_PUBLIC (result)) - maybe_make_one_only (result); - } - else if (TREE_CODE (result) == FUNCTION_DECL) - mark_inline_for_output (result); -} - -/* Given two function templates PAT1 and PAT2, and explicit template - arguments EXPLICIT_ARGS return: - - 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order]. - -1 if PAT2 is more specialized than PAT1. - 0 if neither is more specialized. */ - -int -more_specialized (pat1, pat2, explicit_args) - tree pat1, pat2, explicit_args; -{ - tree targs; - int winner = 0; - - targs = get_bindings_overload (pat1, DECL_RESULT (pat2), explicit_args); - if (targs) - --winner; - - targs = get_bindings_overload (pat2, DECL_RESULT (pat1), explicit_args); - if (targs) - ++winner; - - return winner; -} - -/* Given two class template specialization list nodes PAT1 and PAT2, return: - - 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order]. - -1 if PAT2 is more specialized than PAT1. - 0 if neither is more specialized. */ - -int -more_specialized_class (pat1, pat2) - tree pat1, pat2; -{ - tree targs; - int winner = 0; - - targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1), - TREE_PURPOSE (pat2)); - if (targs) - --winner; - - targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2), - TREE_PURPOSE (pat1)); - if (targs) - ++winner; - - return winner; -} - -/* Return the template arguments that will produce the function signature - DECL from the function template FN, with the explicit template - arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must - also match. Return NULL_TREE if no satisfactory arguments could be - found. */ - -static tree -get_bindings_real (fn, decl, explicit_args, check_rettype) - tree fn, decl, explicit_args; - int check_rettype; -{ - int ntparms = DECL_NTPARMS (fn); - tree targs = make_scratch_vec (ntparms); - tree decl_type; - tree decl_arg_types; - int i; - - /* Substitute the explicit template arguments into the type of DECL. - The call to fn_type_unification will handle substitution into the - FN. */ - decl_type = TREE_TYPE (decl); - if (explicit_args && uses_template_parms (decl_type)) - { - tree tmpl; - tree converted_args; - - if (DECL_TEMPLATE_INFO (decl)) - tmpl = DECL_TI_TEMPLATE (decl); - else - /* We can get here for some illegal specializations. */ - return NULL_TREE; - - converted_args - = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl), - explicit_args, NULL_TREE, - /*complain=*/0, - /*require_all_arguments=*/0)); - if (converted_args == error_mark_node) - return NULL_TREE; - - decl_type = tsubst (decl_type, converted_args, /*complain=*/0, - NULL_TREE); - if (decl_type == error_mark_node) - return NULL_TREE; - } - - /* If FN is a static member function, adjust the type of DECL - appropriately. */ - decl_arg_types = TYPE_ARG_TYPES (decl_type); - if (DECL_STATIC_FUNCTION_P (fn) - && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) - decl_arg_types = TREE_CHAIN (decl_arg_types); - - i = fn_type_unification (fn, explicit_args, targs, - decl_arg_types, - TREE_TYPE (decl_type), - DEDUCE_EXACT); - - if (i != 0) - return NULL_TREE; - - if (check_rettype) - { - /* Check to see that the resulting return type is also OK. */ - tree t = tsubst (TREE_TYPE (TREE_TYPE (fn)), targs, - /*complain=*/0, NULL_TREE); - - if (!same_type_p (t, TREE_TYPE (TREE_TYPE (decl)))) - return NULL_TREE; - } - - return targs; -} - -/* For most uses, we want to check the return type. */ - -tree -get_bindings (fn, decl, explicit_args) - tree fn, decl, explicit_args; -{ - return get_bindings_real (fn, decl, explicit_args, 1); -} - -/* But for more_specialized, we only care about the parameter types. */ - -static tree -get_bindings_overload (fn, decl, explicit_args) - tree fn, decl, explicit_args; -{ - return get_bindings_real (fn, decl, explicit_args, 0); -} - -/* Return the innermost template arguments that, when applied to a - template specialization whose innermost template parameters are - TPARMS, and whose specialization arguments are ARGS, yield the - ARGS. - - For example, suppose we have: - - template <class T, class U> struct S {}; - template <class T> struct S<T*, int> {}; - - Then, suppose we want to get `S<double*, int>'. The TPARMS will be - {T}, the PARMS will be {T*, int} and the ARGS will be {double*, - int}. The resulting vector will be {double}, indicating that `T' - is bound to `double'. */ - -static tree -get_class_bindings (tparms, parms, args) - tree tparms, parms, args; -{ - int i, ntparms = TREE_VEC_LENGTH (tparms); - tree vec = make_temp_vec (ntparms); - - args = innermost_args (args); - - if (unify (tparms, vec, parms, args, UNIFY_ALLOW_NONE)) - return NULL_TREE; - - for (i = 0; i < ntparms; ++i) - if (! TREE_VEC_ELT (vec, i)) - return NULL_TREE; - - return vec; -} - -/* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs. - Pick the most specialized template, and return the corresponding - instantiation, or if there is no corresponding instantiation, the - template itself. EXPLICIT_ARGS is any template arguments explicity - mentioned in a template-id. If there is no most specialized - tempalte, error_mark_node is returned. If there are no templates - at all, NULL_TREE is returned. */ - -tree -most_specialized_instantiation (instantiations, explicit_args) - tree instantiations; - tree explicit_args; -{ - tree fn, champ; - int fate; - - if (!instantiations) - return NULL_TREE; - - champ = instantiations; - for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn)) - { - fate = more_specialized (TREE_VALUE (champ), - TREE_VALUE (fn), explicit_args); - if (fate == 1) - ; - else - { - if (fate == 0) - { - fn = TREE_CHAIN (fn); - if (! fn) - return error_mark_node; - } - champ = fn; - } - } - - for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn)) - { - fate = more_specialized (TREE_VALUE (champ), - TREE_VALUE (fn), explicit_args); - if (fate != 1) - return error_mark_node; - } - - return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ); -} - -/* Return the most specialized of the list of templates in FNS that can - produce an instantiation matching DECL, given the explicit template - arguments EXPLICIT_ARGS. */ - -static tree -most_specialized (fns, decl, explicit_args) - tree fns, decl, explicit_args; -{ - tree candidates = NULL_TREE; - tree fn, args; - - for (fn = fns; fn; fn = TREE_CHAIN (fn)) - { - tree candidate = TREE_VALUE (fn); - - args = get_bindings (candidate, decl, explicit_args); - if (args) - candidates = scratch_tree_cons (NULL_TREE, candidate, - candidates); - } - - return most_specialized_instantiation (candidates, explicit_args); -} - -/* If DECL is a specialization of some template, return the most - general such template. For example, given: - - template <class T> struct S { template <class U> void f(U); }; - - if TMPL is `template <class U> void S<int>::f(U)' this will return - the full template. This function will not trace past partial - specializations, however. For example, given in addition: - - template <class T> struct S<T*> { template <class U> void f(U); }; - - if TMPL is `template <class U> void S<int*>::f(U)' this will return - `template <class T> template <class U> S<T*>::f(U)'. */ - -static tree -most_general_template (decl) - tree decl; -{ - while (DECL_TEMPLATE_INFO (decl)) - decl = DECL_TI_TEMPLATE (decl); - - return decl; -} - -/* Return the most specialized of the class template specializations - of TMPL which can produce an instantiation matching ARGS, or - error_mark_node if the choice is ambiguous. */ - -static tree -most_specialized_class (tmpl, args) - tree tmpl; - tree args; -{ - tree list = NULL_TREE; - tree t; - tree champ; - int fate; - - tmpl = most_general_template (tmpl); - for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t)) - { - tree spec_args - = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args); - if (spec_args) - { - list = decl_tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list); - TREE_TYPE (list) = TREE_TYPE (t); - } - } - - if (! list) - return NULL_TREE; - - t = list; - champ = t; - t = TREE_CHAIN (t); - for (; t; t = TREE_CHAIN (t)) - { - fate = more_specialized_class (champ, t); - if (fate == 1) - ; - else - { - if (fate == 0) - { - t = TREE_CHAIN (t); - if (! t) - return error_mark_node; - } - champ = t; - } - } - - for (t = list; t && t != champ; t = TREE_CHAIN (t)) - { - fate = more_specialized_class (champ, t); - if (fate != 1) - return error_mark_node; - } - - return champ; -} - -/* called from the parser. */ - -void -do_decl_instantiation (declspecs, declarator, storage) - tree declspecs, declarator, storage; -{ - tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, NULL_TREE); - tree result = NULL_TREE; - int extern_p = 0; - - if (! DECL_LANG_SPECIFIC (decl)) - { - cp_error ("explicit instantiation of non-template `%#D'", decl); - return; - } - else if (TREE_CODE (decl) == VAR_DECL) - { - /* There is an asymmetry here in the way VAR_DECLs and - FUNCTION_DECLs are handled by grokdeclarator. In the case of - the latter, the DECL we get back will be marked as a - template instantiation, and the appropriate - DECL_TEMPLATE_INFO will be set up. This does not happen for - VAR_DECLs so we do the lookup here. Probably, grokdeclarator - should handle VAR_DECLs as it currently handles - FUNCTION_DECLs. */ - result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, 0); - if (result && TREE_CODE (result) != VAR_DECL) - { - cp_error ("no matching template for `%D' found", result); - return; - } - } - else if (TREE_CODE (decl) != FUNCTION_DECL) - { - cp_error ("explicit instantiation of `%#D'", decl); - return; - } - else - result = decl; - - /* Check for various error cases. Note that if the explicit - instantiation is legal the RESULT will currently be marked as an - *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set - until we get here. */ - - if (DECL_TEMPLATE_SPECIALIZATION (result)) - { - /* [temp.spec] - - No program shall both explicitly instantiate and explicitly - specialize a template. */ - cp_pedwarn ("explicit instantiation of `%#D' after", result); - cp_pedwarn_at ("explicit specialization here", result); - return; - } - else if (DECL_EXPLICIT_INSTANTIATION (result)) - { - /* [temp.spec] - - No program shall explicitly instantiate any template more - than once. - - We check DECL_INTERFACE_KNOWN so as not to complain when the - first instantiation was `extern' and the second is not, and - EXTERN_P for the opposite case. */ - if (DECL_INTERFACE_KNOWN (result) && !extern_p && !flag_use_repository) - cp_pedwarn ("duplicate explicit instantiation of `%#D'", result); - - /* If we've already instantiated the template, just return now. */ - if (DECL_INTERFACE_KNOWN (result)) - return; - } - else if (!DECL_IMPLICIT_INSTANTIATION (result)) - { - cp_error ("no matching template for `%D' found", result); - return; - } - else if (!DECL_TEMPLATE_INFO (result)) - { - cp_pedwarn ("explicit instantiation of non-template `%#D'", result); - return; - } - - if (flag_external_templates) - return; - - if (storage == NULL_TREE) - ; - else if (storage == ridpointers[(int) RID_EXTERN]) - { - if (pedantic) - cp_pedwarn ("ANSI C++ forbids the use of `extern' on explicit instantiations"); - extern_p = 1; - } - else - cp_error ("storage class `%D' applied to template instantiation", - storage); - - SET_DECL_EXPLICIT_INSTANTIATION (result); - mark_decl_instantiated (result, extern_p); - repo_template_instantiated (result, extern_p); - if (! extern_p) - instantiate_decl (result); -} - -void -mark_class_instantiated (t, extern_p) - tree t; - int extern_p; -{ - SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t); - SET_CLASSTYPE_INTERFACE_KNOWN (t); - CLASSTYPE_INTERFACE_ONLY (t) = extern_p; - CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p; - TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p; - if (! extern_p) - { - CLASSTYPE_DEBUG_REQUESTED (t) = 1; - rest_of_type_compilation (t, 1); - } -} - -void -do_type_instantiation (t, storage) - tree t, storage; -{ - int extern_p = 0; - int nomem_p = 0; - int static_p = 0; - - if (TREE_CODE (t) == TYPE_DECL) - t = TREE_TYPE (t); - - if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t)) - { - cp_error ("explicit instantiation of non-template type `%T'", t); - return; - } - - complete_type (t); - - /* With -fexternal-templates, explicit instantiations are treated the same - as implicit ones. */ - if (flag_external_templates) - return; - - if (TYPE_SIZE (t) == NULL_TREE) - { - cp_error ("explicit instantiation of `%#T' before definition of template", - t); - return; - } - - if (storage != NULL_TREE) - { - if (pedantic) - cp_pedwarn("ANSI C++ forbids the use of `%s' on explicit instantiations", - IDENTIFIER_POINTER (storage)); - - if (storage == ridpointers[(int) RID_INLINE]) - nomem_p = 1; - else if (storage == ridpointers[(int) RID_EXTERN]) - extern_p = 1; - else if (storage == ridpointers[(int) RID_STATIC]) - static_p = 1; - else - { - cp_error ("storage class `%D' applied to template instantiation", - storage); - extern_p = 0; - } - } - - if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) - { - /* [temp.spec] - - No program shall both explicitly instantiate and explicitly - specialize a template. */ - cp_error ("explicit instantiation of `%#T' after", t); - cp_error_at ("explicit specialization here", t); - return; - } - else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t)) - { - /* [temp.spec] - - No program shall explicitly instantiate any template more - than once. - - If CLASSTYPE_INTERFACE_ONLY, then the first explicit - instantiation was `extern', and if EXTERN_P then the second - is. Both cases are OK. */ - if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository) - cp_pedwarn ("duplicate explicit instantiation of `%#T'", t); - - /* If we've already instantiated the template, just return now. */ - if (!CLASSTYPE_INTERFACE_ONLY (t)) - return; - } - - mark_class_instantiated (t, extern_p); - repo_template_instantiated (t, extern_p); - - if (nomem_p) - return; - - { - tree tmp; - - /* In contrast to implicit instantiation, where only the - declarations, and not the definitions, of members are - instantiated, we have here: - - [temp.explicit] - - The explicit instantiation of a class template specialization - implies the instantiation of all of its members not - previously explicitly specialized in the translation unit - containing the explicit instantiation. - - Of course, we can't instantiate member template classes, since - we don't have any arguments for them. Note that the standard - is unclear on whether the instatiation of the members are - *explicit* instantiations or not. We choose to be generous, - and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow - the explicit instantiation of a class where some of the members - have no definition in the current translation unit. */ - - if (! static_p) - for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp)) - if (TREE_CODE (tmp) == FUNCTION_DECL - && DECL_TEMPLATE_INSTANTIATION (tmp)) - { - mark_decl_instantiated (tmp, extern_p); - repo_template_instantiated (tmp, extern_p); - if (! extern_p) - instantiate_decl (tmp); - } - - for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp)) - if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp)) - { - mark_decl_instantiated (tmp, extern_p); - repo_template_instantiated (tmp, extern_p); - if (! extern_p) - instantiate_decl (tmp); - } - - for (tmp = CLASSTYPE_TAGS (t); tmp; tmp = TREE_CHAIN (tmp)) - if (IS_AGGR_TYPE (TREE_VALUE (tmp)) - && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp)))) - do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp)), storage); - } -} - -/* Given a function DECL, which is a specialization of TMPL, modify - DECL to be a re-instantiation of TMPL with the same template - arguments. TMPL should be the template into which tsubst'ing - should occur for DECL, not the most general template. - - One reason for doing this is a scenario like this: - - template <class T> - void f(const T&, int i); - - void g() { f(3, 7); } - - template <class T> - void f(const T& t, const int i) { } - - Note that when the template is first instantiated, with - instantiate_template, the resulting DECL will have no name for the - first parameter, and the wrong type for the second. So, when we go - to instantiate the DECL, we regenerate it. */ - -static void -regenerate_decl_from_template (decl, tmpl) - tree decl; - tree tmpl; -{ - tree args; - tree code_pattern; - tree new_decl; - tree gen_tmpl; - int unregistered; - - args = DECL_TI_ARGS (decl); - code_pattern = DECL_TEMPLATE_RESULT (tmpl); - - /* Unregister the specialization so that when we tsubst we will not - just return DECL. We don't have to unregister DECL from TMPL - because if would only be registered there if it were a partial - instantiation of a specialization, which it isn't: it's a full - instantiation. */ - gen_tmpl = most_general_template (tmpl); - unregistered = unregister_specialization (decl, gen_tmpl); - - /* If the DECL was not unregistered then something peculiar is - happening: we created a specialization but did not call - register_specialization for it. */ - my_friendly_assert (unregistered, 0); - - if (TREE_CODE (decl) == VAR_DECL) - /* Make sure that we can see identifiers, and compute access - correctly, for the class members used in the declaration of - this static variable. */ - pushclass (DECL_CONTEXT (decl), 2); - - /* Do the substitution to get the new declaration. */ - new_decl = tsubst (code_pattern, args, /*complain=*/1, 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)); - /* Pop the class context we pushed above. */ - popclass (); - } - else if (TREE_CODE (decl) == FUNCTION_DECL) - { - /* Convince duplicate_decls to use the DECL_ARGUMENTS from the - new decl. */ - DECL_INITIAL (new_decl) = error_mark_node; - /* And don't complain about a duplicate definition. */ - DECL_INITIAL (decl) = NULL_TREE; - } - - /* The immediate parent of the new template is still whatever it was - before, even though tsubst sets DECL_TI_TEMPLATE up as the most - general template. We also reset the DECL_ASSEMBLER_NAME since - tsubst always calculates the name as if the function in question - were really a template instance, and sometimes, with friend - functions, this is not so. See tsubst_friend_function for - details. */ - DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl); - DECL_ASSEMBLER_NAME (new_decl) = DECL_ASSEMBLER_NAME (decl); - DECL_RTL (new_decl) = DECL_RTL (decl); - - /* Call duplicate decls to merge the old and new declarations. */ - duplicate_decls (new_decl, decl); - - /* Now, re-register the specialization. */ - register_specialization (decl, gen_tmpl, args); -} - -/* Produce the definition of D, a _DECL generated from a template. */ - -tree -instantiate_decl (d) - tree d; -{ - tree tmpl = DECL_TI_TEMPLATE (d); - tree args = DECL_TI_ARGS (d); - tree td; - tree code_pattern; - tree spec; - tree gen_tmpl; - int nested = in_function_p (); - int pattern_defined; - int line = lineno; - char *file = input_filename; - - /* This function should only be used to instantiate templates for - functions and static member variables. */ - my_friendly_assert (TREE_CODE (d) == FUNCTION_DECL - || TREE_CODE (d) == VAR_DECL, 0); - - if (DECL_TEMPLATE_INSTANTIATED (d)) - /* D has already been instantiated. It might seem reasonable to - check whether or not D is an explict instantiation, and, if so, - stop here. But when an explicit instantiation is deferred - until the end of the compilation, DECL_EXPLICIT_INSTANTIATION - is set, even though we still need to do the instantiation. */ - return d; - - /* If we already have a specialization of this declaration, then - there's no reason to instantiate it. Note that - retrieve_specialization gives us both instantiations and - specializations, so we must explicitly check - DECL_TEMPLATE_SPECIALIZATION. */ - gen_tmpl = most_general_template (tmpl); - spec = retrieve_specialization (gen_tmpl, args); - if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec)) - return spec; - - /* This needs to happen before any tsubsting. */ - if (! push_tinst_level (d)) - return d; - - /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern - for the instantiation. This is not always the most general - template. Consider, for example: - - template <class T> - struct S { template <class U> void f(); - template <> void f<int>(); }; - - and an instantiation of S<double>::f<int>. We want TD to be the - specialization S<T>::f<int>, not the more general S<T>::f<U>. */ - td = tmpl; - for (td = tmpl; - /* An instantiation cannot have a definition, so we need a - more general template. */ - DECL_TEMPLATE_INSTANTIATION (td) - /* We must also deal with friend templates. Given: - - template <class T> struct S { - template <class U> friend void f() {}; - }; - - S<int>::f<U> say, is not an instantiation of S<T>::f<U>, - so far as the language is concerned, but that's still - where we get the pattern for the instantiation from. On - ther hand, if the definition comes outside the class, say: - - template <class T> struct S { - template <class U> friend void f(); - }; - template <class U> friend void f() {} - - we don't need to look any further. That's what the check for - DECL_INITIAL is for. */ - || (TREE_CODE (d) == FUNCTION_DECL - && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td) - && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td))); - ) - { - /* The present template, TD, should not be a definition. If it - were a definition, we should be using it! Note that we - cannot restructure the loop to just keep going until we find - a template with a definition, since that might go too far if - a specialization was declared, but not defined. */ - my_friendly_assert (!(TREE_CODE (d) == VAR_DECL - && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td))), - 0); - - /* Fetch the more general template. */ - td = DECL_TI_TEMPLATE (td); - } - - code_pattern = DECL_TEMPLATE_RESULT (td); - - if (TREE_CODE (d) == FUNCTION_DECL) - pattern_defined = (DECL_INITIAL (code_pattern) != NULL_TREE); - else - pattern_defined = ! DECL_IN_AGGR_P (code_pattern); - - push_to_top_level (); - lineno = DECL_SOURCE_LINE (d); - input_filename = DECL_SOURCE_FILE (d); - - if (pattern_defined) - { - repo_template_used (d); - - if (flag_external_templates && ! DECL_INTERFACE_KNOWN (d)) - { - if (flag_alt_external_templates) - { - if (interface_unknown) - warn_if_unknown_interface (d); - } - else if (DECL_INTERFACE_KNOWN (code_pattern)) - { - DECL_INTERFACE_KNOWN (d) = 1; - DECL_NOT_REALLY_EXTERN (d) = ! DECL_EXTERNAL (code_pattern); - } - else - warn_if_unknown_interface (code_pattern); - } - - if (at_eof) - import_export_decl (d); - } - - /* Reject all external templates except inline functions. */ - if (DECL_INTERFACE_KNOWN (d) - && ! DECL_NOT_REALLY_EXTERN (d) - && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))) - goto out; - - if (TREE_CODE (d) == VAR_DECL - && TREE_READONLY (d) - && DECL_INITIAL (d) == NULL_TREE - && DECL_INITIAL (code_pattern) != NULL_TREE) - /* We need to set up DECL_INITIAL regardless of pattern_defined if - the variable is a static const initialized in the class body. */; - else if (! pattern_defined - || (! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d) && nested) - && ! at_eof)) - { - /* Defer all templates except inline functions used in another - function. We restore the source position here because it's used - by add_pending_template. */ - lineno = line; - input_filename = file; - - if (at_eof && !pattern_defined - && DECL_EXPLICIT_INSTANTIATION (d)) - /* [temp.explicit] - - The definition of a non-exported function template, a - non-exported member function template, or a non-exported - member function or static data member of a class template - shall be present in every translation unit in which it is - explicitly instantiated. */ - cp_error ("explicit instantiation of `%D' but no definition available", - d); - - add_pending_template (d); - goto out; - } - - /* We're now committed to instantiating this template. Mark it as - instantiated so that recursive calls to instantiate_decl do not - try to instantiate it again. */ - DECL_TEMPLATE_INSTANTIATED (d) = 1; - - /* Regenerate the declaration in case the template has been modified - by a subsequent redeclaration. */ - regenerate_decl_from_template (d, td); - - /* We already set the file and line above. Reset them now in case - they changed as a result of calling regenerate_decl_from_template. */ - lineno = DECL_SOURCE_LINE (d); - input_filename = DECL_SOURCE_FILE (d); - - if (TREE_CODE (d) == VAR_DECL) - { - DECL_IN_AGGR_P (d) = 0; - if (DECL_INTERFACE_KNOWN (d)) - DECL_EXTERNAL (d) = ! DECL_NOT_REALLY_EXTERN (d); - else - { - DECL_EXTERNAL (d) = 1; - DECL_NOT_REALLY_EXTERN (d) = 1; - } - cp_finish_decl (d, DECL_INITIAL (d), NULL_TREE, 0, 0); - } - else if (TREE_CODE (d) == FUNCTION_DECL) - { - tree t = DECL_SAVED_TREE (code_pattern); - - start_function (NULL_TREE, d, NULL_TREE, 1); - store_parm_decls (); - - if (t && TREE_CODE (t) == RETURN_INIT) - { - store_return_init - (TREE_OPERAND (t, 0), - tsubst_expr (TREE_OPERAND (t, 1), args, /*complain=*/1, tmpl)); - t = TREE_CHAIN (t); - } - - if (t && TREE_CODE (t) == CTOR_INITIALIZER) - { - current_member_init_list - = tsubst_expr_values (TREE_OPERAND (t, 0), args); - current_base_init_list - = tsubst_expr_values (TREE_OPERAND (t, 1), args); - t = TREE_CHAIN (t); - } - - setup_vtbl_ptr (); - /* Always keep the BLOCK node associated with the outermost - pair of curly braces of a function. These are needed - for correct operation of dwarfout.c. */ - keep_next_level (); - - my_friendly_assert (TREE_CODE (t) == COMPOUND_STMT, 42); - tsubst_expr (t, args, /*complain=*/1, tmpl); - - finish_function (lineno, 0, nested); - } - -out: - lineno = line; - input_filename = file; - - pop_from_top_level (); - pop_tinst_level (); - - return d; -} - -/* Run through the list of templates that we wish we could - instantiate, and instantiate any we can. */ - -int -instantiate_pending_templates () -{ - tree *t; - int instantiated_something = 0; - int reconsider; - - do - { - reconsider = 0; - - t = &pending_templates; - while (*t) - { - tree srcloc = TREE_PURPOSE (*t); - tree instantiation = TREE_VALUE (*t); - - input_filename = SRCLOC_FILE (srcloc); - lineno = SRCLOC_LINE (srcloc); - - if (TREE_CODE_CLASS (TREE_CODE (instantiation)) == 't') - { - tree fn; - - if (!TYPE_SIZE (instantiation)) - { - instantiate_class_template (instantiation); - if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation)) - for (fn = TYPE_METHODS (instantiation); - fn; - fn = TREE_CHAIN (fn)) - if (! DECL_ARTIFICIAL (fn)) - instantiate_decl (fn); - if (TYPE_SIZE (instantiation)) - { - instantiated_something = 1; - reconsider = 1; - } - } - - if (TYPE_SIZE (instantiation)) - /* If INSTANTIATION has been instantiated, then we don't - need to consider it again in the future. */ - *t = TREE_CHAIN (*t); - else - t = &TREE_CHAIN (*t); - } - else - { - if (DECL_TEMPLATE_INSTANTIATION (instantiation) - && !DECL_TEMPLATE_INSTANTIATED (instantiation)) - { - instantiation = instantiate_decl (instantiation); - if (DECL_TEMPLATE_INSTANTIATED (instantiation)) - { - instantiated_something = 1; - reconsider = 1; - } - } - - if (!DECL_TEMPLATE_INSTANTIATION (instantiation) - || DECL_TEMPLATE_INSTANTIATED (instantiation)) - /* If INSTANTIATION has been instantiated, then we don't - need to consider it again in the future. */ - *t = TREE_CHAIN (*t); - else - t = &TREE_CHAIN (*t); - } - } - template_tail = t; - - /* Go through the things that are template instantiations if we are - using guiding declarations. */ - t = &maybe_templates; - while (*t) - { - tree template; - tree fn; - tree args; - - fn = TREE_VALUE (*t); - - if (DECL_INITIAL (fn)) - /* If the FN is already defined, then it was either already - instantiated or, even though guiding declarations were - allowed, a non-template definition was provided. */ - ; - else - { - template = TREE_PURPOSE (*t); - args = get_bindings (template, fn, NULL_TREE); - fn = instantiate_template (template, args); - instantiate_decl (fn); - reconsider = 1; - } - - /* Remove this entry from the chain. */ - *t = TREE_CHAIN (*t); - } - maybe_template_tail = t; - } - while (reconsider); - - return instantiated_something; -} - -/* Substitute ARGVEC into T, which is a TREE_LIST. In particular, it - is an initializer list: the TREE_PURPOSEs are DECLs, and the - TREE_VALUEs are initializer values. Used by instantiate_decl. */ - -static tree -tsubst_expr_values (t, argvec) - tree t, argvec; -{ - tree first = NULL_TREE; - tree *p = &first; - - for (; t; t = TREE_CHAIN (t)) - { - tree pur = tsubst_copy (TREE_PURPOSE (t), argvec, - /*complain=*/1, NULL_TREE); - tree val = tsubst_expr (TREE_VALUE (t), argvec, /*complain=*/1, - NULL_TREE); - *p = build_tree_list (pur, val); - p = &TREE_CHAIN (*p); - } - return first; -} - -tree last_tree; - -void -add_tree (t) - tree t; -{ - last_tree = TREE_CHAIN (last_tree) = t; -} - - -void -begin_tree () -{ - saved_trees = tree_cons (NULL_TREE, last_tree, saved_trees); - last_tree = NULL_TREE; -} - - -void -end_tree () -{ - my_friendly_assert (saved_trees != NULL_TREE, 0); - - last_tree = TREE_VALUE (saved_trees); - saved_trees = TREE_CHAIN (saved_trees); -} - -/* D is an undefined function declaration in the presence of templates with - the same name, listed in FNS. If one of them can produce D as an - instantiation, remember this so we can instantiate it at EOF if D has - not been defined by that time. */ - -void -add_maybe_template (d, fns) - tree d, fns; -{ - tree t; - - if (DECL_MAYBE_TEMPLATE (d)) - return; - - t = most_specialized (fns, d, NULL_TREE); - if (! t) - return; - if (t == error_mark_node) - { - cp_error ("ambiguous template instantiation for `%D'", d); - return; - } - - *maybe_template_tail = perm_tree_cons (t, d, NULL_TREE); - maybe_template_tail = &TREE_CHAIN (*maybe_template_tail); - DECL_MAYBE_TEMPLATE (d) = 1; -} - -/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */ - -static void -set_current_access_from_decl (decl) - tree decl; -{ - if (TREE_PRIVATE (decl)) - current_access_specifier = access_private_node; - else if (TREE_PROTECTED (decl)) - current_access_specifier = access_protected_node; - else - current_access_specifier = access_public_node; -} - -/* Instantiate an enumerated type. TAG is the template type, NEWTAG - is the instantiation (which should have been created with - start_enum) and ARGS are the template arguments to use. */ - -static void -tsubst_enum (tag, newtag, args) - tree tag; - tree newtag; - tree args; -{ - tree e; - - for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e)) - { - tree value; - tree elt; - - /* 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, - NULL_TREE); - - /* Give this enumeration constant the correct access. */ - set_current_access_from_decl (TREE_VALUE (e)); - - /* Actually build the enumerator itself. */ - elt = build_enumerator (TREE_PURPOSE (e), value, newtag); - - /* We save the enumerators we have built so far in the - TYPE_VALUES so that if the enumeration constants for - subsequent enumerators involve those for previous ones, - tsubst_copy will be able to find them. */ - TREE_CHAIN (elt) = TYPE_VALUES (newtag); - TYPE_VALUES (newtag) = elt; - } - - finish_enum (newtag); -} - -/* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that - is either an instantiation or specialization of a template - function. */ - -static void -set_mangled_name_for_template_decl (decl) - tree decl; -{ - tree saved_namespace; - tree context = NULL_TREE; - tree fn_type; - tree ret_type; - tree parm_types; - tree tparms; - tree targs; - tree tmpl; - int parm_depth; - - my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0); - my_friendly_assert (DECL_TEMPLATE_INFO (decl) != NULL_TREE, 0); - - /* The names of template functions must be mangled so as to indicate - what template is being specialized with what template arguments. - For example, each of the following three functions must get - different mangled names: - - void f(int); - template <> void f<7>(int); - template <> void f<8>(int); */ - - targs = DECL_TI_ARGS (decl); - if (uses_template_parms (targs)) - /* This DECL is for a partial instantiation. There's no need to - mangle the name of such an entity. */ - return; - - tmpl = most_general_template (DECL_TI_TEMPLATE (decl)); - tparms = DECL_TEMPLATE_PARMS (tmpl); - parm_depth = TMPL_PARMS_DEPTH (tparms); - - /* There should be as many levels of arguments as there are levels - of parameters. */ - my_friendly_assert (parm_depth == TMPL_ARGS_DEPTH (targs), 0); - - /* We now compute the PARMS and RET_TYPE to give to - build_decl_overload_real. The PARMS and RET_TYPE are the - parameter and return types of the template, after all but the - innermost template arguments have been substituted, not the - parameter and return types of the function DECL. For example, - given: - - template <class T> T f(T); - - both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'. - A more subtle example is: - - template <class T> struct S { template <class U> void f(T, U); } - - Here, if DECL is `void S<int>::f(int, double)', PARMS should be - {int, U}. Thus, the args that we want to subsitute into the - return and parameter type for the function are those in TARGS, - with the innermost level omitted. */ - fn_type = TREE_TYPE (tmpl); - if (DECL_STATIC_FUNCTION_P (decl)) - context = DECL_CLASS_CONTEXT (decl); - - if (parm_depth == 1) - /* No substitution is necessary. */ - ; - else - { - int i; - tree partial_args; - - /* Replace the innermost level of the TARGS with NULL_TREEs to - let tsubst know not to subsitute for those parameters. */ - partial_args = make_temp_vec (TREE_VEC_LENGTH (targs)); - for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i) - SET_TMPL_ARGS_LEVEL (partial_args, i, - TMPL_ARGS_LEVEL (targs, i)); - SET_TMPL_ARGS_LEVEL (partial_args, - TMPL_ARGS_DEPTH (targs), - make_temp_vec (DECL_NTPARMS (tmpl))); - - /* Now, do the (partial) substitution to figure out the - appropriate function type. */ - fn_type = tsubst (fn_type, partial_args, /*complain=*/1, NULL_TREE); - if (DECL_STATIC_FUNCTION_P (decl)) - context = tsubst (context, partial_args, /*complain=*/1, 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); - } - - /* Now, get the innermost parameters and arguments, and figure out - the parameter and return types. */ - tparms = INNERMOST_TEMPLATE_PARMS (tparms); - targs = innermost_args (targs); - ret_type = TREE_TYPE (fn_type); - parm_types = TYPE_ARG_TYPES (fn_type); - - /* For a static member function, we generate a fake `this' pointer, - for the purposes of mangling. This indicates of which class the - function is a member. Because of: - - [class.static] - - There shall not be a static and a nonstatic member function - with the same name and the same parameter types - - we don't have to worry that this will result in a clash with a - non-static member function. */ - if (DECL_STATIC_FUNCTION_P (decl)) - parm_types = hash_tree_chain (build_pointer_type (context), parm_types); - - /* There should be the same number of template parameters as - template arguments. */ - my_friendly_assert (TREE_VEC_LENGTH (tparms) == TREE_VEC_LENGTH (targs), - 0); - - /* If the template is in a namespace, we need to put that into the - mangled name. Unfortunately, build_decl_overload_real does not - get the decl to mangle, so it relies on the current - namespace. Therefore, we set that here temporarily. */ - my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd', 980702); - saved_namespace = current_namespace; - current_namespace = CP_DECL_CONTEXT (decl); - - /* Actually set the DCL_ASSEMBLER_NAME. */ - DECL_ASSEMBLER_NAME (decl) - = build_decl_overload_real (DECL_NAME (decl), parm_types, ret_type, - tparms, targs, - DECL_FUNCTION_MEMBER_P (decl) - + DECL_CONSTRUCTOR_P (decl)); - - /* Restore the previously active namespace. */ - current_namespace = saved_namespace; -} |