1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 93-97, 1998, 1999 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Known bugs or deficiencies include:
25 all methods must be provided in header files; can't use a source
26 file that contains only the method templates and "just win". */
43 /* The type of functions taking a tree, and some additional data, and
45 typedef int (*tree_fn_t
) PROTO((tree
, void*));
47 extern struct obstack permanent_obstack
;
50 extern char *input_filename
;
51 struct pending_inline
*pending_template_expansions
;
53 tree current_template_parms
;
54 HOST_WIDE_INT processing_template_decl
;
56 tree pending_templates
;
57 static tree
*template_tail
= &pending_templates
;
60 static tree
*maybe_template_tail
= &maybe_templates
;
62 int minimal_parse_mode
;
64 int processing_specialization
;
65 int processing_explicit_instantiation
;
66 int processing_template_parmlist
;
67 static int template_header_count
;
69 static tree saved_trees
;
71 #define obstack_chunk_alloc xmalloc
72 #define obstack_chunk_free free
74 #define UNIFY_ALLOW_NONE 0
75 #define UNIFY_ALLOW_MORE_CV_QUAL 1
76 #define UNIFY_ALLOW_LESS_CV_QUAL 2
77 #define UNIFY_ALLOW_DERIVED 4
78 #define UNIFY_ALLOW_INTEGER 8
80 #define GTB_VIA_VIRTUAL 1 /* The base class we are examining is
81 virtual, or a base class of a virtual
83 #define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current
84 type with the desired type. */
86 static int resolve_overloaded_unification
PROTO((tree
, tree
, tree
, tree
,
87 unification_kind_t
, int));
88 static int try_one_overload
PROTO((tree
, tree
, tree
, tree
, tree
,
89 unification_kind_t
, int));
90 static int unify
PROTO((tree
, tree
, tree
, tree
, int));
91 static void add_pending_template
PROTO((tree
));
92 static int push_tinst_level
PROTO((tree
));
93 static tree classtype_mangled_name
PROTO((tree
));
94 static char *mangle_class_name_for_template
PROTO((char *, tree
, tree
));
95 static tree tsubst_expr_values
PROTO((tree
, tree
));
96 static int list_eq
PROTO((tree
, tree
));
97 static tree get_class_bindings
PROTO((tree
, tree
, tree
));
98 static tree coerce_template_parms
PROTO((tree
, tree
, tree
, int, int));
99 static void tsubst_enum
PROTO((tree
, tree
, tree
));
100 static tree add_to_template_args
PROTO((tree
, tree
));
101 static tree add_outermost_template_args
PROTO((tree
, tree
));
102 static void maybe_adjust_types_for_deduction
PROTO((unification_kind_t
, tree
*,
104 static int type_unification_real
PROTO((tree
, tree
, tree
, tree
,
105 int, unification_kind_t
, int));
106 static void note_template_header
PROTO((int));
107 static tree maybe_fold_nontype_arg
PROTO((tree
));
108 static tree convert_nontype_argument
PROTO((tree
, tree
));
109 static tree convert_template_argument
PROTO ((tree
, tree
, tree
, int,
111 static tree get_bindings_overload
PROTO((tree
, tree
, tree
));
112 static int for_each_template_parm
PROTO((tree
, tree_fn_t
, void*));
113 static tree build_template_parm_index
PROTO((int, int, int, tree
, tree
));
114 static int inline_needs_template_parms
PROTO((tree
));
115 static void push_inline_template_parms_recursive
PROTO((tree
, int));
116 static tree retrieve_specialization
PROTO((tree
, tree
));
117 static tree register_specialization
PROTO((tree
, tree
, tree
));
118 static int unregister_specialization
PROTO((tree
, tree
));
119 static tree reduce_template_parm_level
PROTO((tree
, tree
, int));
120 static tree build_template_decl
PROTO((tree
, tree
));
121 static int mark_template_parm
PROTO((tree
, void *));
122 static tree tsubst_friend_function
PROTO((tree
, tree
));
123 static tree tsubst_friend_class
PROTO((tree
, tree
));
124 static tree get_bindings_real
PROTO((tree
, tree
, tree
, int));
125 static int template_decl_level
PROTO((tree
));
126 static tree maybe_get_template_decl_from_type_decl
PROTO((tree
));
127 static int check_cv_quals_for_unify
PROTO((int, tree
, tree
));
128 static tree tsubst_template_arg_vector
PROTO((tree
, tree
, int));
129 static tree tsubst_template_parms
PROTO((tree
, tree
, int));
130 static void regenerate_decl_from_template
PROTO((tree
, tree
));
131 static tree most_specialized
PROTO((tree
, tree
, tree
));
132 static tree most_specialized_class
PROTO((tree
, tree
));
133 static tree most_general_template
PROTO((tree
));
134 static void set_mangled_name_for_template_decl
PROTO((tree
));
135 static int template_class_depth_real
PROTO((tree
, int));
136 static tree tsubst_aggr_type
PROTO((tree
, tree
, int, tree
, int));
137 static tree tsubst_decl
PROTO((tree
, tree
, tree
, tree
));
138 static tree tsubst_arg_types
PROTO((tree
, tree
, int, tree
));
139 static tree tsubst_function_type
PROTO((tree
, tree
, int, tree
));
140 static void check_specialization_scope
PROTO((void));
141 static tree process_partial_specialization
PROTO((tree
));
142 static void set_current_access_from_decl
PROTO((tree
));
143 static void check_default_tmpl_args
PROTO((tree
, tree
, int, int));
144 static tree tsubst_call_declarator_parms
PROTO((tree
, tree
, int, tree
));
145 static tree get_template_base_recursive
PROTO((tree
, tree
,
146 tree
, tree
, tree
, int));
147 static tree get_template_base
PROTO((tree
, tree
, tree
, tree
));
148 static tree try_class_unification
PROTO((tree
, tree
, tree
, tree
));
149 static int coerce_template_template_parms
PROTO((tree
, tree
, int,
151 static tree determine_specialization
PROTO((tree
, tree
, tree
*, int));
153 /* We use TREE_VECs to hold template arguments. If there is only one
154 level of template arguments, then the TREE_VEC contains the
155 arguments directly. If there is more than one level of template
156 arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
157 containing the template arguments for a single level. The first
158 entry in the outer TREE_VEC is the outermost level of template
159 parameters; the last is the innermost.
161 It is incorrect to ever form a template argument vector containing
162 only one level of arguments, but which is a TREE_VEC containing as
163 its only entry the TREE_VEC for that level. */
165 /* Non-zero if the template arguments is actually a vector of vectors,
166 rather than just a vector. */
167 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
169 && TREE_CODE (NODE) == TREE_VEC \
170 && TREE_VEC_LENGTH (NODE) > 0 \
171 && TREE_VEC_ELT (NODE, 0) != NULL_TREE \
172 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
174 /* The depth of a template argument vector. When called directly by
175 the parser, we use a TREE_LIST rather than a TREE_VEC to represent
176 template arguments. In fact, we may even see NULL_TREE if there
177 are no template arguments. In both of those cases, there is only
178 one level of template arguments. */
179 #define TMPL_ARGS_DEPTH(NODE) \
180 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
182 /* The LEVELth level of the template ARGS. Note that template
183 parameter levels are indexed from 1, not from 0. */
184 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
185 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
186 ? TREE_VEC_ELT ((ARGS), (LEVEL) - 1) : ARGS)
188 /* Set the LEVELth level of the template ARGS to VAL. This macro does
189 not work with single-level argument vectors. */
190 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
191 (TREE_VEC_ELT ((ARGS), (LEVEL) - 1) = (VAL))
193 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */
194 #define TMPL_ARG(ARGS, LEVEL, IDX) \
195 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
197 /* Set the IDXth element in the LEVELth level of ARGS to VAL. This
198 macro does not work with single-level argument vectors. */
199 #define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \
200 (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL))
202 /* Given a single level of template arguments in NODE, return the
203 number of arguments. */
204 #define NUM_TMPL_ARGS(NODE) \
205 ((NODE) == NULL_TREE ? 0 \
206 : (TREE_CODE (NODE) == TREE_VEC \
207 ? TREE_VEC_LENGTH (NODE) : list_length (NODE)))
209 /* The number of levels of template parameters given by NODE. */
210 #define TMPL_PARMS_DEPTH(NODE) \
211 (TREE_INT_CST_HIGH (TREE_PURPOSE (NODE)))
213 /* Do any processing required when DECL (a member template declaration
214 using TEMPLATE_PARAMETERS as its innermost parameter list) is
215 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
216 it is a specialization, in which case the DECL itself is returned. */
219 finish_member_template_decl (decl
)
222 if (decl
== NULL_TREE
|| decl
== void_type_node
)
224 else if (decl
== error_mark_node
)
225 /* By returning NULL_TREE, the parser will just ignore this
226 declaration. We have already issued the error. */
228 else if (TREE_CODE (decl
) == TREE_LIST
)
230 /* Assume that the class is the only declspec. */
231 decl
= TREE_VALUE (decl
);
232 if (IS_AGGR_TYPE (decl
) && CLASSTYPE_TEMPLATE_INFO (decl
)
233 && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl
))
235 tree tmpl
= CLASSTYPE_TI_TEMPLATE (decl
);
236 check_member_template (tmpl
);
241 else if (DECL_TEMPLATE_INFO (decl
))
243 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
245 check_member_template (DECL_TI_TEMPLATE (decl
));
246 return DECL_TI_TEMPLATE (decl
);
252 cp_error ("invalid member template declaration `%D'", decl
);
254 return error_mark_node
;
257 /* Returns the template nesting level of the indicated class TYPE.
267 A<T>::B<U> has depth two, while A<T> has depth one.
268 Both A<T>::B<int> and A<int>::B<U> have depth one, if
269 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
272 This function is guaranteed to return 0 if passed NULL_TREE so
273 that, for example, `template_class_depth (current_class_type)' is
277 template_class_depth_real (type
, count_specializations
)
279 int count_specializations
;
284 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
285 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
286 ? DECL_REAL_CONTEXT (type
) : TYPE_CONTEXT (type
))
288 if (TREE_CODE (type
) != FUNCTION_DECL
)
290 if (CLASSTYPE_TEMPLATE_INFO (type
)
291 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
))
292 && ((count_specializations
293 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
294 || uses_template_parms (CLASSTYPE_TI_ARGS (type
))))
299 if (DECL_TEMPLATE_INFO (type
)
300 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type
))
301 && ((count_specializations
302 && DECL_TEMPLATE_SPECIALIZATION (type
))
303 || uses_template_parms (DECL_TI_ARGS (type
))))
311 /* Returns the template nesting level of the indicated class TYPE.
312 Like template_class_depth_real, but instantiations do not count in
316 template_class_depth (type
)
319 return template_class_depth_real (type
, /*count_specializations=*/0);
322 /* Returns 1 if processing DECL as part of do_pending_inlines
323 needs us to push template parms. */
326 inline_needs_template_parms (decl
)
329 if (! DECL_TEMPLATE_INFO (decl
))
332 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
333 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
336 /* Subroutine of maybe_begin_member_template_processing.
337 Push the template parms in PARMS, starting from LEVELS steps into the
338 chain, and ending at the beginning, since template parms are listed
342 push_inline_template_parms_recursive (parmlist
, levels
)
346 tree parms
= TREE_VALUE (parmlist
);
350 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
352 ++processing_template_decl
;
353 current_template_parms
354 = tree_cons (build_int_2 (0, processing_template_decl
),
355 parms
, current_template_parms
);
356 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
359 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
361 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
362 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm
)) == 'd', 0);
364 switch (TREE_CODE (parm
))
373 /* Make a CONST_DECL as is done in process_template_parm.
374 It is ugly that we recreate this here; the original
375 version built in process_template_parm is no longer
377 tree decl
= build_decl (CONST_DECL
, DECL_NAME (parm
),
379 SET_DECL_ARTIFICIAL (decl
);
380 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
381 DECL_TEMPLATE_PARM_P (decl
) = 1;
387 my_friendly_abort (0);
392 /* Restore the template parameter context for a member template or
393 a friend template defined in a class definition. */
396 maybe_begin_member_template_processing (decl
)
402 if (! inline_needs_template_parms (decl
))
405 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
407 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
409 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
412 parms
= TREE_CHAIN (parms
);
415 push_inline_template_parms_recursive (parms
, levels
);
418 /* Undo the effects of begin_member_template_processing. */
421 maybe_end_member_template_processing ()
423 if (! processing_template_decl
)
426 while (current_template_parms
427 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
429 --processing_template_decl
;
430 current_template_parms
= TREE_CHAIN (current_template_parms
);
435 /* Returns non-zero iff T is a member template function. We must be
438 template <class T> class C { void f(); }
440 Here, f is a template function, and a member, but not a member
441 template. This function does not concern itself with the origin of
442 T, only its present state. So if we have
444 template <class T> class C { template <class U> void f(U); }
446 then neither C<int>::f<char> nor C<T>::f<double> is considered
447 to be a member template. But, `template <class U> void
448 C<int>::f(U)' is considered a member template. */
451 is_member_template (t
)
454 if (!DECL_FUNCTION_TEMPLATE_P (t
))
455 /* Anything that isn't a function or a template function is
456 certainly not a member template. */
459 /* A local class can't have member templates. */
460 if (hack_decl_function_context (t
))
463 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t
))
464 /* If there are more levels of template parameters than
465 there are template classes surrounding the declaration,
466 then we have a member template. */
467 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
468 template_class_depth (DECL_CLASS_CONTEXT (t
))));
472 /* Returns non-zero iff T is a member template class. See
473 is_member_template for a description of what precisely constitutes
474 a member template. */
477 is_member_template_class (t
)
480 if (!DECL_CLASS_TEMPLATE_P (t
))
481 /* Anything that isn't a class template, is certainly not a member
485 if (!DECL_CLASS_SCOPE_P (t
))
486 /* Anything whose context isn't a class type is surely not a
490 /* If there are more levels of template parameters than there are
491 template classes surrounding the declaration, then we have a
493 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
494 template_class_depth (DECL_CONTEXT (t
)));
498 /* Return a new template argument vector which contains all of ARGS,
499 but has as its innermost set of arguments the EXTRA_ARGS. The
500 resulting vector will be built on a temporary obstack, and so must
501 be explicitly copied to the permanent obstack, if required. */
504 add_to_template_args (args
, extra_args
)
513 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
514 new_args
= make_temp_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
516 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
517 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
519 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
520 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
525 /* Like add_to_template_args, but only the outermost ARGS are added to
526 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
527 (EXTRA_ARGS) levels are added. This function is used to combine
528 the template arguments from a partial instantiation with the
529 template arguments used to attain the full instantiation from the
530 partial instantiation. */
533 add_outermost_template_args (args
, extra_args
)
539 /* If there are more levels of EXTRA_ARGS than there are ARGS,
540 something very fishy is going on. */
541 my_friendly_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
),
544 /* If *all* the new arguments will be the EXTRA_ARGS, just return
546 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
549 /* For the moment, we make ARGS look like it contains fewer levels. */
550 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
552 new_args
= add_to_template_args (args
, extra_args
);
554 /* Now, we restore ARGS to its full dimensions. */
555 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
560 /* We've got a template header coming up; push to a new level for storing
564 begin_template_parm_list ()
566 /* We use a non-tag-transparent scope here, which causes pushtag to
567 put tags in this scope, rather than in the enclosing class or
568 namespace scope. This is the right thing, since we want
569 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
570 global template class, push_template_decl handles putting the
571 TEMPLATE_DECL into top-level scope. For a nested template class,
574 template <class T> struct S1 {
575 template <class T> struct S2 {};
578 pushtag contains special code to call pushdecl_with_scope on the
579 TEMPLATE_DECL for S2. */
581 declare_pseudo_global_level ();
582 ++processing_template_decl
;
583 ++processing_template_parmlist
;
584 note_template_header (0);
587 /* This routine is called when a specialization is declared. If it is
588 illegal to declare a specialization here, an error is reported. */
591 check_specialization_scope ()
593 tree scope
= current_scope ();
597 An explicit specialization shall be declared in the namespace of
598 which the template is a member, or, for member templates, in the
599 namespace of which the enclosing class or enclosing class
600 template is a member. An explicit specialization of a member
601 function, member class or static data member of a class template
602 shall be declared in the namespace of which the class template
604 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
605 cp_error ("explicit specialization in non-namespace scope `%D'",
610 In an explicit specialization declaration for a member of a class
611 template or a member template that appears in namespace scope,
612 the member template and some of its enclosing class templates may
613 remain unspecialized, except that the declaration shall not
614 explicitly specialize a class member template if its enclosing
615 class templates are not explicitly specialized as well. */
616 if (current_template_parms
)
617 cp_error ("enclosing class templates are not explicitly specialized");
620 /* We've just seen template <>. */
623 begin_specialization ()
625 note_template_header (1);
626 check_specialization_scope ();
629 /* Called at then end of processing a declaration preceeded by
633 end_specialization ()
635 reset_specialization ();
638 /* Any template <>'s that we have seen thus far are not referring to a
639 function specialization. */
642 reset_specialization ()
644 processing_specialization
= 0;
645 template_header_count
= 0;
648 /* We've just seen a template header. If SPECIALIZATION is non-zero,
649 it was of the form template <>. */
652 note_template_header (specialization
)
655 processing_specialization
= specialization
;
656 template_header_count
++;
659 /* We're beginning an explicit instantiation. */
662 begin_explicit_instantiation ()
664 ++processing_explicit_instantiation
;
669 end_explicit_instantiation ()
671 my_friendly_assert(processing_explicit_instantiation
> 0, 0);
672 --processing_explicit_instantiation
;
675 /* The TYPE is being declared. If it is a template type, that means it
676 is a partial specialization. Do appropriate error-checking. */
679 maybe_process_partial_specialization (type
)
682 if (IS_AGGR_TYPE (type
) && CLASSTYPE_USE_TEMPLATE (type
))
684 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
685 && TYPE_SIZE (type
) == NULL_TREE
)
687 if (current_namespace
688 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type
)))
690 cp_pedwarn ("specializing `%#T' in different namespace", type
);
691 cp_pedwarn_at (" from definition of `%#D'",
692 CLASSTYPE_TI_TEMPLATE (type
));
694 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
695 if (processing_template_decl
)
696 push_template_decl (TYPE_MAIN_DECL (type
));
698 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
699 cp_error ("specialization of `%T' after instantiation", type
);
701 else if (processing_specialization
)
702 cp_error ("explicit specialization of non-template `%T'", type
);
705 /* Retrieve the specialization (in the sense of [temp.spec] - a
706 specialization is either an instantiation or an explicit
707 specialization) of TMPL for the given template ARGS. If there is
708 no such specialization, return NULL_TREE. The ARGS are a vector of
709 arguments, or a vector of vectors of arguments, in the case of
710 templates with more than one level of parameters. */
713 retrieve_specialization (tmpl
, args
)
719 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
721 /* There should be as many levels of arguments as there are
722 levels of parameters. */
723 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
724 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
727 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
730 if (comp_template_args (TREE_PURPOSE (s
), args
))
731 return TREE_VALUE (s
);
736 /* Returns non-zero iff DECL is a specialization of TMPL. */
739 is_specialization_of (decl
, tmpl
)
745 if (TREE_CODE (decl
) == FUNCTION_DECL
)
749 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
755 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 0);
757 for (t
= TREE_TYPE (decl
);
759 t
= CLASSTYPE_USE_TEMPLATE (t
)
760 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
761 if (same_type_p (TYPE_MAIN_VARIANT (t
),
762 TYPE_MAIN_VARIANT (TREE_TYPE (tmpl
))))
769 /* Register the specialization SPEC as a specialization of TMPL with
770 the indicated ARGS. Returns SPEC, or an equivalent prior
771 declaration, if available. */
774 register_specialization (spec
, tmpl
, args
)
781 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
783 if (TREE_CODE (spec
) == FUNCTION_DECL
784 && uses_template_parms (DECL_TI_ARGS (spec
)))
785 /* This is the FUNCTION_DECL for a partial instantiation. Don't
786 register it; we want the corresponding TEMPLATE_DECL instead.
787 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
788 the more obvious `uses_template_parms (spec)' to avoid problems
789 with default function arguments. In particular, given
792 template <class T> void f(T t1, T t = T())
794 the default argument expression is not substituted for in an
795 instantiation unless and until it is actually needed. */
798 /* There should be as many levels of arguments as there are
799 levels of parameters. */
800 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
801 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
804 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
807 if (comp_template_args (TREE_PURPOSE (s
), args
))
809 tree fn
= TREE_VALUE (s
);
811 if (DECL_TEMPLATE_SPECIALIZATION (spec
))
813 if (DECL_TEMPLATE_INSTANTIATION (fn
))
816 || DECL_EXPLICIT_INSTANTIATION (fn
))
818 cp_error ("specialization of %D after instantiation",
824 /* This situation should occur only if the first
825 specialization is an implicit instantiation,
826 the second is an explicit specialization, and
827 the implicit instantiation has not yet been
828 used. That situation can occur if we have
829 implicitly instantiated a member function and
830 then specialized it later.
832 We can also wind up here if a friend
833 declaration that looked like an instantiation
834 turns out to be a specialization:
836 template <class T> void foo(T);
837 class S { friend void foo<>(int) };
838 template <> void foo(int);
840 We transform the existing DECL in place so that
841 any pointers to it become pointers to the
844 If there was a definition for the template, but
845 not for the specialization, we want this to
846 look as if there is no definition, and vice
848 DECL_INITIAL (fn
) = NULL_TREE
;
849 duplicate_decls (spec
, fn
);
854 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
856 duplicate_decls (spec
, fn
);
862 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
863 = perm_tree_cons (args
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
868 /* Unregister the specialization SPEC as a specialization of TMPL.
869 Returns nonzero if the SPEC was listed as a specialization of
873 unregister_specialization (spec
, tmpl
)
879 for (s
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
881 s
= &TREE_CHAIN (*s
))
882 if (TREE_VALUE (*s
) == spec
)
884 *s
= TREE_CHAIN (*s
);
891 /* Print the list of candidate FNS in an error message. */
894 print_candidates (fns
)
899 char* str
= "candidates are:";
901 for (fn
= fns
; fn
!= NULL_TREE
; fn
= TREE_CHAIN (fn
))
905 for (f
= TREE_VALUE (fn
); f
; f
= OVL_NEXT (f
))
906 cp_error_at ("%s %+#D", str
, OVL_CURRENT (f
));
911 /* Returns the template (one of the functions given by TEMPLATE_ID)
912 which can be specialized to match the indicated DECL with the
913 explicit template args given in TEMPLATE_ID. The DECL may be
914 NULL_TREE if none is available. In that case, the functions in
915 TEMPLATE_ID are non-members.
917 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
918 specialization of a member template.
920 The template args (those explicitly specified and those deduced)
921 are output in a newly created vector *TARGS_OUT.
923 If it is impossible to determine the result, an error message is
924 issued. The error_mark_node is returned to indicate failure. */
927 determine_specialization (template_id
, decl
, targs_out
,
928 need_member_template
)
932 int need_member_template
;
938 tree candidates
= NULL_TREE
;
939 tree templates
= NULL_TREE
;
941 *targs_out
= NULL_TREE
;
943 if (template_id
== error_mark_node
)
944 return error_mark_node
;
946 fns
= TREE_OPERAND (template_id
, 0);
947 explicit_targs
= TREE_OPERAND (template_id
, 1);
949 if (fns
== error_mark_node
)
950 return error_mark_node
;
952 /* Check for baselinks. */
953 if (TREE_CODE (fns
) == TREE_LIST
)
954 fns
= TREE_VALUE (fns
);
956 for (; fns
; fns
= OVL_NEXT (fns
))
960 fn
= OVL_CURRENT (fns
);
962 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
963 /* DECL might be a specialization of FN. */
965 else if (need_member_template
)
966 /* FN is an ordinary member function, and we need a
967 specialization of a member template. */
969 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
970 /* We can get IDENTIFIER_NODEs here in certain erroneous
973 else if (!DECL_FUNCTION_MEMBER_P (fn
))
974 /* This is just an ordinary non-member function. Nothing can
975 be a specialization of that. */
981 /* This is an ordinary member function. However, since
982 we're here, we can assume it's enclosing class is a
983 template class. For example,
985 template <typename T> struct S { void f(); };
986 template <> void S<int>::f() {}
988 Here, S<int>::f is a non-template, but S<int> is a
989 template class. If FN has the same type as DECL, we
990 might be in business. */
991 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
992 TREE_TYPE (TREE_TYPE (fn
))))
993 /* The return types differ. */
996 /* Adjust the type of DECL in case FN is a static member. */
997 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
998 if (DECL_STATIC_FUNCTION_P (fn
)
999 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1000 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
1002 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1005 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1010 /* See whether this function might be a specialization of this
1012 targs
= get_bindings (tmpl
, decl
, explicit_targs
);
1015 /* We cannot deduce template arguments that when used to
1016 specialize TMPL will produce DECL. */
1019 /* Save this template, and the arguments deduced. */
1020 templates
= scratch_tree_cons (targs
, tmpl
, templates
);
1023 if (templates
&& TREE_CHAIN (templates
))
1029 It is possible for a specialization with a given function
1030 signature to be instantiated from more than one function
1031 template. In such cases, explicit specification of the
1032 template arguments must be used to uniquely identify the
1033 function template specialization being specialized.
1035 Note that here, there's no suggestion that we're supposed to
1036 determine which of the candidate templates is most
1037 specialized. However, we, also have:
1041 Partial ordering of overloaded function template
1042 declarations is used in the following contexts to select
1043 the function template to which a function template
1044 specialization refers:
1046 -- when an explicit specialization refers to a function
1049 So, we do use the partial ordering rules, at least for now.
1050 This extension can only serve to make illegal programs legal,
1051 so it's safe. And, there is strong anecdotal evidence that
1052 the committee intended the partial ordering rules to apply;
1053 the EDG front-end has that behavior, and John Spicer claims
1054 that the committee simply forgot to delete the wording in
1055 [temp.expl.spec]. */
1056 tree tmpl
= most_specialized (templates
, decl
, explicit_targs
);
1057 if (tmpl
&& tmpl
!= error_mark_node
)
1059 targs
= get_bindings (tmpl
, decl
, explicit_targs
);
1060 templates
= scratch_tree_cons (targs
, tmpl
, NULL_TREE
);
1064 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
1066 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1068 return error_mark_node
;
1070 else if ((templates
&& TREE_CHAIN (templates
))
1071 || (candidates
&& TREE_CHAIN (candidates
))
1072 || (templates
&& candidates
))
1074 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1076 chainon (candidates
, templates
);
1077 print_candidates (candidates
);
1078 return error_mark_node
;
1081 /* We have one, and exactly one, match. */
1084 /* It was a specialization of an ordinary member function in a
1086 *targs_out
= copy_node (DECL_TI_ARGS (TREE_VALUE (candidates
)));
1087 return DECL_TI_TEMPLATE (TREE_VALUE (candidates
));
1090 /* It was a specialization of a template. */
1091 targs
= DECL_TI_ARGS (DECL_RESULT (TREE_VALUE (templates
)));
1092 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
1094 *targs_out
= copy_node (targs
);
1095 SET_TMPL_ARGS_LEVEL (*targs_out
,
1096 TMPL_ARGS_DEPTH (*targs_out
),
1097 TREE_PURPOSE (templates
));
1100 *targs_out
= TREE_PURPOSE (templates
);
1101 return TREE_VALUE (templates
);
1104 /* Check to see if the function just declared, as indicated in
1105 DECLARATOR, and in DECL, is a specialization of a function
1106 template. We may also discover that the declaration is an explicit
1107 instantiation at this point.
1109 Returns DECL, or an equivalent declaration that should be used
1110 instead if all goes well. Issues an error message if something is
1111 amiss. Returns error_mark_node if the error is not easily
1114 FLAGS is a bitmask consisting of the following flags:
1116 2: The function has a definition.
1117 4: The function is a friend.
1119 The TEMPLATE_COUNT is the number of references to qualifying
1120 template classes that appeared in the name of the function. For
1123 template <class T> struct S { void f(); };
1126 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1127 classes are not counted in the TEMPLATE_COUNT, so that in
1129 template <class T> struct S {};
1130 template <> struct S<int> { void f(); }
1131 template <> void S<int>::f();
1133 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1134 illegal; there should be no template <>.)
1136 If the function is a specialization, it is marked as such via
1137 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1138 is set up correctly, and it is added to the list of specializations
1139 for that template. */
1142 check_explicit_specialization (declarator
, decl
, template_count
, flags
)
1148 int have_def
= flags
& 2;
1149 int is_friend
= flags
& 4;
1150 int specialization
= 0;
1151 int explicit_instantiation
= 0;
1152 int member_specialization
= 0;
1154 tree ctype
= DECL_CLASS_CONTEXT (decl
);
1155 tree dname
= DECL_NAME (decl
);
1157 if (processing_specialization
)
1159 /* The last template header was of the form template <>. */
1161 if (template_header_count
> template_count
)
1163 /* There were more template headers than qualifying template
1165 if (template_header_count
- template_count
> 1)
1166 /* There shouldn't be that many template parameter lists.
1167 There can be at most one parameter list for every
1168 qualifying class, plus one for the function itself. */
1169 cp_error ("too many template parameter lists in declaration of `%D'", decl
);
1171 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1173 member_specialization
= 1;
1177 else if (template_header_count
== template_count
)
1179 /* The counts are equal. So, this might be a
1180 specialization, but it is not a specialization of a
1181 member template. It might be something like
1183 template <class T> struct S {
1187 void S<int>::f(int i) {} */
1189 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1193 /* This cannot be an explicit specialization. There are not
1194 enough headers for all of the qualifying classes. For
1195 example, we might have:
1198 void S<int>::T<char>::f();
1200 But, we're missing another template <>. */
1201 cp_error("too few template parameter lists in declaration of `%D'", decl
);
1205 else if (processing_explicit_instantiation
)
1207 if (template_header_count
)
1208 cp_error ("template parameter list used in explicit instantiation");
1211 cp_error ("definition provided for explicit instantiation");
1213 explicit_instantiation
= 1;
1215 else if (ctype
!= NULL_TREE
1216 && !TYPE_BEING_DEFINED (ctype
)
1217 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
)
1220 /* This case catches outdated code that looks like this:
1222 template <class T> struct S { void f(); };
1223 void S<int>::f() {} // Missing template <>
1225 We disable this check when the type is being defined to
1226 avoid complaining about default compiler-generated
1227 constructors, destructors, and assignment operators.
1228 Since the type is an instantiation, not a specialization,
1229 these are the only functions that can be defined before
1230 the class is complete. */
1233 template <class T> void S<int>::f() {}
1235 if (template_header_count
)
1237 cp_error ("template parameters specified in specialization");
1243 ("explicit specialization not preceded by `template <>'");
1245 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1247 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1250 /* This could be something like:
1252 template <class T> void f(T);
1253 class S { friend void f<>(int); } */
1257 /* This case handles bogus declarations like template <>
1258 template <class T> void f<int>(); */
1260 cp_error ("template-id `%D' in declaration of primary template",
1266 if (specialization
|| member_specialization
)
1268 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1269 for (; t
; t
= TREE_CHAIN (t
))
1270 if (TREE_PURPOSE (t
))
1273 ("default argument specified in explicit specialization");
1276 if (current_lang_name
== lang_name_c
)
1277 cp_error ("template specialization with C linkage");
1280 if (specialization
|| member_specialization
|| explicit_instantiation
)
1283 tree tmpl
= NULL_TREE
;
1284 tree targs
= NULL_TREE
;
1286 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1287 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
1291 my_friendly_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
,
1294 fns
= IDENTIFIER_NAMESPACE_VALUE (dname
);
1299 lookup_template_function (fns
, NULL_TREE
);
1302 if (declarator
== error_mark_node
)
1303 return error_mark_node
;
1305 if (TREE_CODE (TREE_OPERAND (declarator
, 0)) == LOOKUP_EXPR
)
1307 /* A friend declaration. We can't do much, because we don't
1308 know what this resolves to, yet. */
1309 my_friendly_assert (is_friend
!= 0, 0);
1310 my_friendly_assert (!explicit_instantiation
, 0);
1311 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1315 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
1317 if (!explicit_instantiation
)
1318 /* A specialization in class scope. This is illegal,
1319 but the error will already have been flagged by
1320 check_specialization_scope. */
1321 return error_mark_node
;
1324 /* It's not legal to write an explicit instantiation in
1327 class C { template void f(); }
1329 This case is caught by the parser. However, on
1332 template class C { void f(); };
1334 (which is illegal) we can get here. The error will be
1341 else if (ctype
!= NULL_TREE
1342 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
1345 /* Find the list of functions in ctype that have the same
1346 name as the declared function. */
1347 tree name
= TREE_OPERAND (declarator
, 0);
1348 tree fns
= NULL_TREE
;
1351 if (name
== constructor_name (ctype
)
1352 || name
== constructor_name_full (ctype
))
1354 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
1356 if (is_constructor
? !TYPE_HAS_CONSTRUCTOR (ctype
)
1357 : !TYPE_HAS_DESTRUCTOR (ctype
))
1359 /* From [temp.expl.spec]:
1361 If such an explicit specialization for the member
1362 of a class template names an implicitly-declared
1363 special member function (clause _special_), the
1364 program is ill-formed.
1366 Similar language is found in [temp.explicit]. */
1367 cp_error ("specialization of implicitly-declared special member function");
1368 return error_mark_node
;
1371 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
1374 if (!IDENTIFIER_TYPENAME_P (name
))
1376 idx
= lookup_fnfields_1 (ctype
, name
);
1378 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype
), idx
);
1384 /* For a type-conversion operator, we cannot do a
1385 name-based lookup. We might be looking for `operator
1386 int' which will be a specialization of `operator T'.
1387 So, we find *all* the conversion operators, and then
1388 select from them. */
1391 methods
= CLASSTYPE_METHOD_VEC (ctype
);
1393 for (idx
= 2; idx
< TREE_VEC_LENGTH (methods
); ++idx
)
1395 tree ovl
= TREE_VEC_ELT (methods
, idx
);
1397 if (!ovl
|| !DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
1398 /* There are no more conversion functions. */
1401 /* Glue all these conversion functions together
1402 with those we already have. */
1403 for (; ovl
; ovl
= OVL_NEXT (ovl
))
1404 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
1408 if (fns
== NULL_TREE
)
1410 cp_error ("no member function `%s' declared in `%T'",
1411 IDENTIFIER_POINTER (name
),
1413 return error_mark_node
;
1416 TREE_OPERAND (declarator
, 0) = fns
;
1419 /* Figure out what exactly is being specialized at this point.
1420 Note that for an explicit instantiation, even one for a
1421 member function, we cannot tell apriori whether the
1422 instantiation is for a member template, or just a member
1423 function of a template class. Even if a member template is
1424 being instantiated, the member template arguments may be
1425 elided if they can be deduced from the rest of the
1427 tmpl
= determine_specialization (declarator
, decl
,
1429 member_specialization
);
1431 if (!tmpl
|| tmpl
== error_mark_node
)
1432 /* We couldn't figure out what this declaration was
1434 return error_mark_node
;
1437 gen_tmpl
= most_general_template (tmpl
);
1439 if (explicit_instantiation
)
1441 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1442 is done by do_decl_instantiation later. */
1443 decl
= instantiate_template (tmpl
, innermost_args (targs
));
1447 /* If we though that the DECL was a member function, but it
1448 turns out to be specializing a static member function,
1449 make DECL a static member function as well. */
1450 if (DECL_STATIC_FUNCTION_P (tmpl
)
1451 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1453 revert_static_member_fn (&decl
, 0, 0);
1454 last_function_parms
= TREE_CHAIN (last_function_parms
);
1457 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1458 DECL_TEMPLATE_INFO (decl
)
1459 = perm_tree_cons (tmpl
, targs
, NULL_TREE
);
1461 /* Mangle the function name appropriately. Note that we do
1462 not mangle specializations of non-template member
1463 functions of template classes, e.g. with
1465 template <class T> struct S { void f(); }
1467 and given the specialization
1469 template <> void S<int>::f() {}
1471 we do not mangle S<int>::f() here. That's because it's
1472 just an ordinary member function and doesn't need special
1473 treatment. We do this here so that the ordinary,
1474 non-template, name-mangling algorith will not be used
1476 if ((is_member_template (tmpl
) || ctype
== NULL_TREE
)
1477 && name_mangling_version
>= 1)
1478 set_mangled_name_for_template_decl (decl
);
1480 if (is_friend
&& !have_def
)
1481 /* This is not really a declaration of a specialization.
1482 It's just the name of an instantiation. But, it's not
1483 a request for an instantiation, either. */
1484 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1486 /* Register this specialization so that we can find it
1488 decl
= register_specialization (decl
, gen_tmpl
, targs
);
1495 /* TYPE is being declared. Verify that the use of template headers
1496 and such is reasonable. Issue error messages if not. */
1499 maybe_check_template_type (type
)
1502 if (template_header_count
)
1504 /* We are in the scope of some `template <...>' header. */
1507 = template_class_depth_real (TYPE_CONTEXT (type
),
1508 /*count_specializations=*/1);
1510 if (template_header_count
<= context_depth
)
1511 /* This is OK; the template headers are for the context. We
1512 are actually too lenient here; like
1513 check_explicit_specialization we should consider the number
1514 of template types included in the actual declaration. For
1517 template <class T> struct S {
1518 template <class U> template <class V>
1524 template <class T> struct S {
1525 template <class U> struct I;
1528 template <class T> template <class U.
1533 else if (template_header_count
> context_depth
+ 1)
1534 /* There are two many template parameter lists. */
1535 cp_error ("too many template parameter lists in declaration of `%T'", type
);
1539 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1540 parameters. These are represented in the same format used for
1541 DECL_TEMPLATE_PARMS. */
1543 int comp_template_parms (parms1
, parms2
)
1550 if (parms1
== parms2
)
1553 for (p1
= parms1
, p2
= parms2
;
1554 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
1555 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
1557 tree t1
= TREE_VALUE (p1
);
1558 tree t2
= TREE_VALUE (p2
);
1561 my_friendly_assert (TREE_CODE (t1
) == TREE_VEC
, 0);
1562 my_friendly_assert (TREE_CODE (t2
) == TREE_VEC
, 0);
1564 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
1567 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
1569 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
1570 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
1572 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
1575 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
)
1577 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
1582 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
1583 /* One set of parameters has more parameters lists than the
1590 /* Complain if DECL shadows a template parameter.
1592 [temp.local]: A template-parameter shall not be redeclared within its
1593 scope (including nested scopes). */
1596 check_template_shadow (decl
)
1599 tree olddecl
= IDENTIFIER_VALUE (DECL_NAME (decl
));
1601 if (current_template_parms
&& olddecl
)
1603 /* We check for decl != olddecl to avoid bogus errors for using a
1604 name inside a class. We check TPFI to avoid duplicate errors for
1605 inline member templates. */
1606 if (decl
!= olddecl
&& DECL_TEMPLATE_PARM_P (olddecl
)
1607 && ! TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
1609 cp_error_at ("declaration of `%#D'", decl
);
1610 cp_error_at (" shadows template parm `%#D'", olddecl
);
1615 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1616 ORIG_LEVEL, DECL, and TYPE. */
1619 build_template_parm_index (index
, level
, orig_level
, decl
, type
)
1626 tree t
= make_node (TEMPLATE_PARM_INDEX
);
1627 TEMPLATE_PARM_IDX (t
) = index
;
1628 TEMPLATE_PARM_LEVEL (t
) = level
;
1629 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
1630 TEMPLATE_PARM_DECL (t
) = decl
;
1631 TREE_TYPE (t
) = type
;
1636 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1637 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1638 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1639 new one is created. */
1642 reduce_template_parm_level (index
, type
, levels
)
1647 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
1648 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
1649 != TEMPLATE_PARM_LEVEL (index
) - levels
))
1652 = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index
)),
1653 DECL_NAME (TEMPLATE_PARM_DECL (index
)),
1656 = build_template_parm_index (TEMPLATE_PARM_IDX (index
),
1657 TEMPLATE_PARM_LEVEL (index
) - levels
,
1658 TEMPLATE_PARM_ORIG_LEVEL (index
),
1660 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
1662 /* Template template parameters need this. */
1663 DECL_TEMPLATE_PARMS (decl
)
1664 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
));
1667 return TEMPLATE_PARM_DESCENDANTS (index
);
1670 /* Process information from new template parameter NEXT and append it to the
1671 LIST being built. */
1674 process_template_parm (list
, next
)
1683 my_friendly_assert (TREE_CODE (parm
) == TREE_LIST
, 259);
1684 defval
= TREE_PURPOSE (parm
);
1685 parm
= TREE_VALUE (parm
);
1686 is_type
= TREE_PURPOSE (parm
) == class_type_node
;
1690 tree p
= TREE_VALUE (tree_last (list
));
1692 if (TREE_CODE (p
) == TYPE_DECL
)
1693 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
1694 else if (TREE_CODE (p
) == TEMPLATE_DECL
)
1695 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p
)));
1697 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
1705 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm
)) == TREE_LIST
, 260);
1706 /* is a const-param */
1707 parm
= grokdeclarator (TREE_VALUE (parm
), TREE_PURPOSE (parm
),
1708 PARM
, 0, NULL_TREE
);
1712 The top-level cv-qualifiers on the template-parameter are
1713 ignored when determining its type. */
1714 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
1716 /* A template parameter is not modifiable. */
1717 TREE_READONLY (parm
) = 1;
1718 if (IS_AGGR_TYPE (TREE_TYPE (parm
))
1719 && TREE_CODE (TREE_TYPE (parm
)) != TEMPLATE_TYPE_PARM
1720 && TREE_CODE (TREE_TYPE (parm
)) != TYPENAME_TYPE
)
1722 cp_error ("`%#T' is not a valid type for a template constant parameter",
1724 if (DECL_NAME (parm
) == NULL_TREE
)
1725 error (" a template type parameter must begin with `class' or `typename'");
1726 TREE_TYPE (parm
) = void_type_node
;
1729 && (TREE_CODE (TREE_TYPE (parm
)) == REAL_TYPE
1730 || TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
))
1731 cp_pedwarn ("`%T' is not a valid type for a template constant parameter",
1733 if (TREE_PERMANENT (parm
) == 0)
1735 parm
= copy_node (parm
);
1736 TREE_PERMANENT (parm
) = 1;
1738 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
1739 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
1740 = build_template_parm_index (idx
, processing_template_decl
,
1741 processing_template_decl
,
1742 decl
, TREE_TYPE (parm
));
1747 parm
= TREE_VALUE (parm
);
1749 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
1751 t
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1752 /* This is for distinguishing between real templates and template
1753 template parameters */
1754 TREE_TYPE (parm
) = t
;
1755 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
1760 t
= make_lang_type (TEMPLATE_TYPE_PARM
);
1761 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1762 decl
= build_decl (TYPE_DECL
, parm
, t
);
1765 TYPE_NAME (t
) = decl
;
1766 TYPE_STUB_DECL (t
) = decl
;
1768 TEMPLATE_TYPE_PARM_INDEX (t
)
1769 = build_template_parm_index (idx
, processing_template_decl
,
1770 processing_template_decl
,
1771 decl
, TREE_TYPE (parm
));
1773 SET_DECL_ARTIFICIAL (decl
);
1774 DECL_TEMPLATE_PARM_P (decl
) = 1;
1776 parm
= build_tree_list (defval
, parm
);
1777 return chainon (list
, parm
);
1780 /* The end of a template parameter list has been reached. Process the
1781 tree list into a parameter vector, converting each parameter into a more
1782 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1786 end_template_parm_list (parms
)
1791 tree saved_parmlist
= make_tree_vec (list_length (parms
));
1793 current_template_parms
1794 = tree_cons (build_int_2 (0, processing_template_decl
),
1795 saved_parmlist
, current_template_parms
);
1797 for (parm
= parms
, nparms
= 0; parm
; parm
= TREE_CHAIN (parm
), nparms
++)
1798 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
1800 --processing_template_parmlist
;
1802 return saved_parmlist
;
1805 /* end_template_decl is called after a template declaration is seen. */
1808 end_template_decl ()
1810 reset_specialization ();
1812 if (! processing_template_decl
)
1815 /* This matches the pushlevel in begin_template_parm_list. */
1818 --processing_template_decl
;
1819 current_template_parms
= TREE_CHAIN (current_template_parms
);
1820 (void) get_pending_sizes (); /* Why? */
1823 /* Given a template argument vector containing the template PARMS.
1824 The innermost PARMS are given first. */
1827 current_template_args ()
1830 tree args
= NULL_TREE
;
1831 int length
= TMPL_PARMS_DEPTH (current_template_parms
);
1834 /* If there is only one level of template parameters, we do not
1835 create a TREE_VEC of TREE_VECs. Instead, we return a single
1836 TREE_VEC containing the arguments. */
1838 args
= make_tree_vec (length
);
1840 for (header
= current_template_parms
; header
; header
= TREE_CHAIN (header
))
1842 tree a
= copy_node (TREE_VALUE (header
));
1845 TREE_TYPE (a
) = NULL_TREE
;
1846 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
1848 tree t
= TREE_VEC_ELT (a
, i
);
1850 /* T will be a list if we are called from within a
1851 begin/end_template_parm_list pair, but a vector directly
1852 if within a begin/end_member_template_processing pair. */
1853 if (TREE_CODE (t
) == TREE_LIST
)
1857 if (TREE_CODE (t
) == TYPE_DECL
1858 || TREE_CODE (t
) == TEMPLATE_DECL
)
1861 t
= DECL_INITIAL (t
);
1862 TREE_VEC_ELT (a
, i
) = t
;
1867 TREE_VEC_ELT (args
, --l
) = a
;
1875 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
1876 template PARMS. Used by push_template_decl below. */
1879 build_template_decl (decl
, parms
)
1883 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1884 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
1885 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
1886 if (DECL_LANG_SPECIFIC (decl
))
1888 DECL_CLASS_CONTEXT (tmpl
) = DECL_CLASS_CONTEXT (decl
);
1889 DECL_STATIC_FUNCTION_P (tmpl
) =
1890 DECL_STATIC_FUNCTION_P (decl
);
1896 struct template_parm_data
1898 /* The level of the template parameters we are currently
1902 /* The index of the specialization argument we are currently
1906 /* An array whose size is the number of template parameters. The
1907 elements are non-zero if the parameter has been used in any one
1908 of the arguments processed so far. */
1911 /* An array whose size is the number of template arguments. The
1912 elements are non-zero if the argument makes use of template
1913 parameters of this level. */
1914 int* arg_uses_template_parms
;
1917 /* Subroutine of push_template_decl used to see if each template
1918 parameter in a partial specialization is used in the explicit
1919 argument list. If T is of the LEVEL given in DATA (which is
1920 treated as a template_parm_data*), then DATA->PARMS is marked
1924 mark_template_parm (t
, data
)
1930 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
1932 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
1934 level
= TEMPLATE_PARM_LEVEL (t
);
1935 idx
= TEMPLATE_PARM_IDX (t
);
1939 level
= TEMPLATE_TYPE_LEVEL (t
);
1940 idx
= TEMPLATE_TYPE_IDX (t
);
1943 if (level
== tpd
->level
)
1945 tpd
->parms
[idx
] = 1;
1946 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
1949 /* Return zero so that for_each_template_parm will continue the
1950 traversal of the tree; we want to mark *every* template parm. */
1954 /* Process the partial specialization DECL. */
1957 process_partial_specialization (decl
)
1960 tree type
= TREE_TYPE (decl
);
1961 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1962 tree specargs
= CLASSTYPE_TI_ARGS (type
);
1963 tree inner_args
= innermost_args (specargs
);
1964 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
1965 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
1966 int nargs
= TREE_VEC_LENGTH (inner_args
);
1967 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
1969 int did_error_intro
= 0;
1970 struct template_parm_data tpd
;
1971 struct template_parm_data tpd2
;
1973 /* We check that each of the template parameters given in the
1974 partial specialization is used in the argument list to the
1975 specialization. For example:
1977 template <class T> struct S;
1978 template <class T> struct S<T*>;
1980 The second declaration is OK because `T*' uses the template
1981 parameter T, whereas
1983 template <class T> struct S<int>;
1985 is no good. Even trickier is:
1996 The S2<T> declaration is actually illegal; it is a
1997 full-specialization. Of course,
2000 struct S2<T (*)(U)>;
2002 or some such would have been OK. */
2003 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
2004 tpd
.parms
= alloca (sizeof (int) * ntparms
);
2005 bzero ((PTR
) tpd
.parms
, sizeof (int) * ntparms
);
2007 tpd
.arg_uses_template_parms
= alloca (sizeof (int) * nargs
);
2008 bzero ((PTR
) tpd
.arg_uses_template_parms
, sizeof (int) * nargs
);
2009 for (i
= 0; i
< nargs
; ++i
)
2011 tpd
.current_arg
= i
;
2012 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
2013 &mark_template_parm
,
2016 for (i
= 0; i
< ntparms
; ++i
)
2017 if (tpd
.parms
[i
] == 0)
2019 /* One of the template parms was not used in the
2021 if (!did_error_intro
)
2023 cp_error ("template parameters not used in partial specialization:");
2024 did_error_intro
= 1;
2028 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
2031 /* [temp.class.spec]
2033 The argument list of the specialization shall not be identical to
2034 the implicit argument list of the primary template. */
2035 if (comp_template_args (inner_args
,
2036 innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE
2038 cp_error ("partial specialization `%T' does not specialize any template arguments", type
);
2040 /* [temp.class.spec]
2042 A partially specialized non-type argument expression shall not
2043 involve template parameters of the partial specialization except
2044 when the argument expression is a simple identifier.
2046 The type of a template parameter corresponding to a specialized
2047 non-type argument shall not be dependent on a parameter of the
2049 my_friendly_assert (nargs
== DECL_NTPARMS (maintmpl
), 0);
2051 for (i
= 0; i
< nargs
; ++i
)
2053 tree arg
= TREE_VEC_ELT (inner_args
, i
);
2054 if (/* These first two lines are the `non-type' bit. */
2055 TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
2056 && TREE_CODE (arg
) != TEMPLATE_DECL
2057 /* This next line is the `argument expression is not just a
2058 simple identifier' condition and also the `specialized
2059 non-type argument' bit. */
2060 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
2062 if (tpd
.arg_uses_template_parms
[i
])
2063 cp_error ("template argument `%E' involves template parameter(s)", arg
);
2066 /* Look at the corresponding template parameter,
2067 marking which template parameters its type depends
2070 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms
,
2075 /* We haven't yet initialized TPD2. Do so now. */
2076 tpd2
.arg_uses_template_parms
2077 = (int*) alloca (sizeof (int) * nargs
);
2078 /* The number of parameters here is the number in the
2079 main template, which, as checked in the assertion
2081 tpd2
.parms
= (int*) alloca (sizeof (int) * nargs
);
2083 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
2086 /* Mark the template parameters. But this time, we're
2087 looking for the template parameters of the main
2088 template, not in the specialization. */
2089 tpd2
.current_arg
= i
;
2090 tpd2
.arg_uses_template_parms
[i
] = 0;
2091 bzero ((PTR
) tpd2
.parms
, sizeof (int) * nargs
);
2092 for_each_template_parm (type
,
2093 &mark_template_parm
,
2096 if (tpd2
.arg_uses_template_parms
[i
])
2098 /* The type depended on some template parameters.
2099 If they are fully specialized in the
2100 specialization, that's OK. */
2102 for (j
= 0; j
< nargs
; ++j
)
2103 if (tpd2
.parms
[j
] != 0
2104 && tpd
.arg_uses_template_parms
[j
])
2106 cp_error ("type `%T' of template argument `%E' depends on template parameter(s)",
2116 if (retrieve_specialization (maintmpl
, specargs
))
2117 /* We've already got this specialization. */
2120 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
) = CLASSTYPE_TI_SPEC_INFO (type
)
2121 = perm_tree_cons (inner_args
, inner_parms
,
2122 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
2123 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
2127 /* Check that a template declaration's use of default arguments is not
2128 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2129 non-zero if DECL is the thing declared by a primary template.
2130 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2133 check_default_tmpl_args (decl
, parms
, is_primary
, is_partial
)
2140 int last_level_to_check
;
2144 A default template-argument shall not be specified in a
2145 function template declaration or a function template definition, nor
2146 in the template-parameter-list of the definition of a member of a
2149 if (current_class_type
2150 && !TYPE_BEING_DEFINED (current_class_type
)
2151 && DECL_REAL_CONTEXT (decl
) == current_class_type
2152 && DECL_DEFINED_IN_CLASS_P (decl
))
2153 /* We already checked these parameters when the template was
2154 declared, so there's no need to do it again now. This is an
2155 inline member function definition. */
2158 if (TREE_CODE (decl
) != TYPE_DECL
|| is_partial
|| !is_primary
)
2159 /* For an ordinary class template, default template arguments are
2160 allowed at the innermost level, e.g.:
2161 template <class T = int>
2163 but, in a partial specialization, they're not allowed even
2164 there, as we have in [temp.class.spec]:
2166 The template parameter list of a specialization shall not
2167 contain default template argument values.
2169 So, for a partial specialization, or for a function template,
2170 we look at all of them. */
2173 /* But, for a primary class template that is not a partial
2174 specialization we look at all template parameters except the
2176 parms
= TREE_CHAIN (parms
);
2178 /* Figure out what error message to issue. */
2179 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2180 msg
= "default argument for template parameter in function template `%D'";
2181 else if (is_partial
)
2182 msg
= "default argument in partial specialization `%D'";
2184 msg
= "default argument for template parameter for class enclosing `%D'";
2186 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
2187 /* If we're inside a class definition, there's no need to
2188 examine the parameters to the class itself. On the one
2189 hand, they will be checked when the class is defined, and,
2190 on the other, default arguments are legal in things like:
2191 template <class T = double>
2192 struct S { template <class U> void f(U); };
2193 Here the default argument for `S' has no bearing on the
2194 declaration of `f'. */
2195 last_level_to_check
= template_class_depth (current_class_type
) + 1;
2197 /* Check everything. */
2198 last_level_to_check
= 0;
2200 for (; parms
&& TMPL_PARMS_DEPTH (parms
) >= last_level_to_check
;
2201 parms
= TREE_CHAIN (parms
))
2203 tree inner_parms
= TREE_VALUE (parms
);
2206 ntparms
= TREE_VEC_LENGTH (inner_parms
);
2207 for (i
= 0; i
< ntparms
; ++i
)
2208 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
2212 cp_error (msg
, decl
);
2216 /* Clear out the default argument so that we are not
2218 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
2221 /* At this point, if we're still interested in issuing messages,
2222 they must apply to classes surrounding the object declared. */
2224 msg
= "default argument for template parameter for class enclosing `%D'";
2228 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2229 parameters given by current_template_args, or reuses a
2230 previously existing one, if appropriate. Returns the DECL, or an
2231 equivalent one, if it is replaced via a call to duplicate_decls.
2233 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2236 push_template_decl_real (decl
, is_friend
)
2247 /* See if this is a partial specialization. */
2248 is_partial
= (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
)
2249 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
2250 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
2252 is_friend
|= (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
));
2255 /* For a friend, we want the context of the friend function, not
2256 the type of which it is a friend. */
2257 ctx
= DECL_CONTEXT (decl
);
2258 else if (DECL_REAL_CONTEXT (decl
)
2259 && TREE_CODE (DECL_REAL_CONTEXT (decl
)) != NAMESPACE_DECL
)
2260 /* In the case of a virtual function, we want the class in which
2262 ctx
= DECL_REAL_CONTEXT (decl
);
2264 /* Otherwise, if we're currently definining some class, the DECL
2265 is assumed to be a member of the class. */
2266 ctx
= current_class_type
;
2268 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
2271 if (!DECL_CONTEXT (decl
))
2272 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
2274 /* For determining whether this is a primary template or not, we're really
2275 interested in the lexical context, not the true context. */
2277 info
= current_class_type
;
2281 /* See if this is a primary template. */
2282 if (info
&& TREE_CODE (info
) == FUNCTION_DECL
)
2284 /* Note that template_class_depth returns 0 if given NULL_TREE, so
2285 this next line works even when we are at global scope. */
2286 else if (processing_template_decl
> template_class_depth (info
))
2293 if (current_lang_name
== lang_name_c
)
2294 cp_error ("template with C linkage");
2295 if (TREE_CODE (decl
) == TYPE_DECL
&& ANON_AGGRNAME_P (DECL_NAME (decl
)))
2296 cp_error ("template class without a name");
2297 if (TREE_CODE (decl
) == TYPE_DECL
2298 && TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2299 cp_error ("template declaration of `%#T'", TREE_TYPE (decl
));
2302 /* Check to see that the rules regarding the use of default
2303 arguments are not being violated. */
2304 check_default_tmpl_args (decl
, current_template_parms
,
2305 primary
, is_partial
);
2308 return process_partial_specialization (decl
);
2310 args
= current_template_args ();
2313 || TREE_CODE (ctx
) == FUNCTION_DECL
2314 || TYPE_BEING_DEFINED (ctx
)
2315 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
2317 if (DECL_LANG_SPECIFIC (decl
)
2318 && DECL_TEMPLATE_INFO (decl
)
2319 && DECL_TI_TEMPLATE (decl
))
2320 tmpl
= DECL_TI_TEMPLATE (decl
);
2323 tmpl
= build_template_decl (decl
, current_template_parms
);
2325 if (DECL_LANG_SPECIFIC (decl
)
2326 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2328 /* A specialization of a member template of a template
2330 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2331 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
2332 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
2338 tree a
, t
, current
, parms
;
2341 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
2342 cp_error ("must specialize `%#T' before defining member `%#D'",
2344 if (TREE_CODE (decl
) == TYPE_DECL
)
2346 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl
)))
2347 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2348 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2349 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
2350 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
2353 cp_error ("`%D' does not declare a template type", decl
);
2357 else if (! DECL_TEMPLATE_INFO (decl
))
2359 cp_error ("template definition of non-template `%#D'", decl
);
2363 tmpl
= DECL_TI_TEMPLATE (decl
);
2365 if (is_member_template (tmpl
)
2366 && DECL_FUNCTION_TEMPLATE_P (tmpl
)
2367 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
2368 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2372 /* The declaration is a specialization of a member
2373 template, declared outside the class. Therefore, the
2374 innermost template arguments will be NULL, so we
2375 replace them with the arguments determined by the
2376 earlier call to check_explicit_specialization. */
2377 args
= DECL_TI_ARGS (decl
);
2380 = build_template_decl (decl
, current_template_parms
);
2381 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
2382 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
2383 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
2384 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
2385 DECL_TEMPLATE_INFO (new_tmpl
) =
2386 perm_tree_cons (tmpl
, args
, NULL_TREE
);
2388 register_specialization (new_tmpl
, tmpl
, args
);
2392 /* Make sure the template headers we got make sense. */
2394 parms
= DECL_TEMPLATE_PARMS (tmpl
);
2395 i
= TMPL_PARMS_DEPTH (parms
);
2396 if (TMPL_ARGS_DEPTH (args
) != i
)
2398 cp_error ("expected %d levels of template parms for `%#D', got %d",
2399 i
, decl
, TMPL_ARGS_DEPTH (args
));
2402 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
2404 a
= TMPL_ARGS_LEVEL (args
, i
);
2405 t
= INNERMOST_TEMPLATE_PARMS (parms
);
2407 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
2409 if (current
== decl
)
2410 cp_error ("got %d template parameters for `%#D'",
2411 TREE_VEC_LENGTH (a
), decl
);
2413 cp_error ("got %d template parameters for `%#T'",
2414 TREE_VEC_LENGTH (a
), current
);
2415 cp_error (" but %d required", TREE_VEC_LENGTH (t
));
2418 /* Perhaps we should also check that the parms are used in the
2419 appropriate qualifying scopes in the declarator? */
2421 if (current
== decl
)
2424 current
= TYPE_CONTEXT (current
);
2428 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2429 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
2431 /* Push template declarations for global functions and types. Note
2432 that we do not try to push a global template friend declared in a
2433 template class; such a thing may well depend on the template
2434 parameters of the class. */
2436 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
2437 tmpl
= pushdecl_namespace_level (tmpl
);
2440 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
2442 info
= perm_tree_cons (tmpl
, args
, NULL_TREE
);
2444 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
2446 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
2447 if ((!ctx
|| TREE_CODE (ctx
) != FUNCTION_DECL
)
2448 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
)
2449 DECL_NAME (decl
) = classtype_mangled_name (TREE_TYPE (decl
));
2451 else if (! DECL_LANG_SPECIFIC (decl
))
2452 cp_error ("template declaration of `%#D'", decl
);
2454 DECL_TEMPLATE_INFO (decl
) = info
;
2456 return DECL_TEMPLATE_RESULT (tmpl
);
2460 push_template_decl (decl
)
2463 return push_template_decl_real (decl
, 0);
2466 /* Called when a class template TYPE is redeclared with the indicated
2467 template PARMS, e.g.:
2469 template <class T> struct S;
2470 template <class T> struct S {}; */
2473 redeclare_class_template (type
, parms
)
2477 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
2481 if (!PRIMARY_TEMPLATE_P (tmpl
))
2482 /* The type is nested in some template class. Nothing to worry
2483 about here; there are no new template parameters for the nested
2487 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
2488 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
2490 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
2492 cp_error_at ("previous declaration `%D'", tmpl
);
2493 cp_error ("used %d template parameter%s instead of %d",
2494 TREE_VEC_LENGTH (tmpl_parms
),
2495 TREE_VEC_LENGTH (tmpl_parms
) == 1 ? "" : "s",
2496 TREE_VEC_LENGTH (parms
));
2500 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
2502 tree tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
2503 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
2504 tree tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
2505 tree parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
2507 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
))
2509 cp_error_at ("template parameter `%#D'", tmpl_parm
);
2510 cp_error ("redeclared here as `%#D'", parm
);
2514 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
2516 /* We have in [temp.param]:
2518 A template-parameter may not be given default arguments
2519 by two different declarations in the same scope. */
2520 cp_error ("redefinition of default argument for `%#D'", parm
);
2521 cp_error_at (" original definition appeared here", tmpl_parm
);
2525 if (parm_default
!= NULL_TREE
)
2526 /* Update the previous template parameters (which are the ones
2527 that will really count) with the new default value. */
2528 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
2532 /* Attempt to convert the non-type template parameter EXPR to the
2533 indicated TYPE. If the conversion is successful, return the
2534 converted value. If the conversion is unsuccesful, return
2535 NULL_TREE if we issued an error message, or error_mark_node if we
2536 did not. We issue error messages for out-and-out bad template
2537 parameters, but not simply because the conversion failed, since we
2538 might be just trying to do argument deduction. By the time this
2539 function is called, neither TYPE nor EXPR may make use of template
2543 convert_nontype_argument (type
, expr
)
2547 tree expr_type
= TREE_TYPE (expr
);
2549 /* A template-argument for a non-type, non-template
2550 template-parameter shall be one of:
2552 --an integral constant-expression of integral or enumeration
2555 --the name of a non-type template-parameter; or
2557 --the name of an object or function with external linkage,
2558 including function templates and function template-ids but
2559 excluding non-static class members, expressed as id-expression;
2562 --the address of an object or function with external linkage,
2563 including function templates and function template-ids but
2564 excluding non-static class members, expressed as & id-expression
2565 where the & is optional if the name refers to a function or
2568 --a pointer to member expressed as described in _expr.unary.op_. */
2570 /* An integral constant-expression can include const variables
2572 if (INTEGRAL_TYPE_P (expr_type
) && TREE_READONLY_DECL_P (expr
))
2573 expr
= decl_constant_value (expr
);
2575 if (is_overloaded_fn (expr
))
2576 /* OK for now. We'll check that it has external linkage later.
2577 Check this first since if expr_type is the unknown_type_node
2578 we would otherwise complain below. */
2580 else if (TYPE_PTR_P (expr_type
)
2581 || TREE_CODE (expr_type
) == ARRAY_TYPE
2582 || TREE_CODE (type
) == REFERENCE_TYPE
2583 /* If expr is the address of an overloaded function, we
2584 will get the unknown_type_node at this point. */
2585 || expr_type
== unknown_type_node
)
2591 if (TREE_CODE (type
) == REFERENCE_TYPE
2592 || TREE_CODE (expr_type
) == ARRAY_TYPE
)
2596 if (TREE_CODE (e
) != ADDR_EXPR
)
2599 cp_error ("`%E' is not a valid template argument", expr
);
2600 error ("it must be %s%s with external linkage",
2601 TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
2602 ? "a pointer to " : "",
2603 TREE_CODE (TREE_TYPE (TREE_TYPE (expr
))) == FUNCTION_TYPE
2604 ? "a function" : "an object");
2608 referent
= TREE_OPERAND (e
, 0);
2609 STRIP_NOPS (referent
);
2612 if (TREE_CODE (referent
) == STRING_CST
)
2614 cp_error ("string literal %E is not a valid template argument",
2616 error ("because it is the address of an object with static linkage");
2620 if (is_overloaded_fn (referent
))
2621 /* We'll check that it has external linkage later. */
2623 else if (TREE_CODE (referent
) != VAR_DECL
)
2625 else if (!TREE_PUBLIC (referent
))
2627 cp_error ("address of non-extern `%E' cannot be used as template argument", referent
);
2628 return error_mark_node
;
2631 else if (INTEGRAL_TYPE_P (expr_type
)
2632 || TYPE_PTRMEM_P (expr_type
)
2633 || TYPE_PTRMEMFUNC_P (expr_type
)
2634 /* The next two are g++ extensions. */
2635 || TREE_CODE (expr_type
) == REAL_TYPE
2636 || TREE_CODE (expr_type
) == COMPLEX_TYPE
)
2638 if (! TREE_CONSTANT (expr
))
2641 cp_error ("non-constant `%E' cannot be used as template argument",
2648 cp_error ("object `%E' cannot be used as template argument", expr
);
2652 switch (TREE_CODE (type
))
2657 /* For a non-type template-parameter of integral or enumeration
2658 type, integral promotions (_conv.prom_) and integral
2659 conversions (_conv.integral_) are applied. */
2660 if (!INTEGRAL_TYPE_P (expr_type
))
2661 return error_mark_node
;
2663 /* It's safe to call digest_init in this case; we know we're
2664 just converting one integral constant expression to another. */
2665 expr
= digest_init (type
, expr
, (tree
*) 0);
2667 if (TREE_CODE (expr
) != INTEGER_CST
)
2668 /* Curiously, some TREE_CONSTANT integral expressions do not
2669 simplify to integer constants. For example, `3 % 0',
2670 remains a TRUNC_MOD_EXPR. */
2677 /* These are g++ extensions. */
2678 if (TREE_CODE (expr_type
) != TREE_CODE (type
))
2679 return error_mark_node
;
2681 expr
= digest_init (type
, expr
, (tree
*) 0);
2683 if (TREE_CODE (expr
) != REAL_CST
)
2690 tree type_pointed_to
= TREE_TYPE (type
);
2692 if (TYPE_PTRMEM_P (type
))
2693 /* For a non-type template-parameter of type pointer to data
2694 member, qualification conversions (_conv.qual_) are
2696 return perform_qualification_conversions (type
, expr
);
2697 else if (TREE_CODE (type_pointed_to
) == FUNCTION_TYPE
)
2699 /* For a non-type template-parameter of type pointer to
2700 function, only the function-to-pointer conversion
2701 (_conv.func_) is applied. If the template-argument
2702 represents a set of overloaded functions (or a pointer to
2703 such), the matching function is selected from the set
2708 if (TREE_CODE (expr
) == ADDR_EXPR
)
2709 fns
= TREE_OPERAND (expr
, 0);
2713 fn
= instantiate_type (type_pointed_to
, fns
, 0);
2715 if (fn
== error_mark_node
)
2716 return error_mark_node
;
2718 if (!TREE_PUBLIC (fn
))
2720 if (really_overloaded_fn (fns
))
2721 return error_mark_node
;
2726 expr
= build_unary_op (ADDR_EXPR
, fn
, 0);
2728 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2734 /* For a non-type template-parameter of type pointer to
2735 object, qualification conversions (_conv.qual_) and the
2736 array-to-pointer conversion (_conv.array_) are applied.
2737 [Note: In particular, neither the null pointer conversion
2738 (_conv.ptr_) nor the derived-to-base conversion
2739 (_conv.ptr_) are applied. Although 0 is a valid
2740 template-argument for a non-type template-parameter of
2741 integral type, it is not a valid template-argument for a
2742 non-type template-parameter of pointer type.]
2744 The call to decay_conversion performs the
2745 array-to-pointer conversion, if appropriate. */
2746 expr
= decay_conversion (expr
);
2748 if (expr
== error_mark_node
)
2749 return error_mark_node
;
2751 return perform_qualification_conversions (type
, expr
);
2756 case REFERENCE_TYPE
:
2758 tree type_referred_to
= TREE_TYPE (type
);
2760 if (TREE_CODE (type_referred_to
) == FUNCTION_TYPE
)
2762 /* For a non-type template-parameter of type reference to
2763 function, no conversions apply. If the
2764 template-argument represents a set of overloaded
2765 functions, the matching function is selected from the
2766 set (_over.over_). */
2770 fn
= instantiate_type (type_referred_to
, fns
, 0);
2772 if (fn
== error_mark_node
)
2773 return error_mark_node
;
2775 if (!TREE_PUBLIC (fn
))
2777 if (really_overloaded_fn (fns
))
2778 /* Don't issue an error here; we might get a different
2779 function if the overloading had worked out
2781 return error_mark_node
;
2786 my_friendly_assert (same_type_p (type_referred_to
,
2794 /* For a non-type template-parameter of type reference to
2795 object, no conversions apply. The type referred to by the
2796 reference may be more cv-qualified than the (otherwise
2797 identical) type of the template-argument. The
2798 template-parameter is bound directly to the
2799 template-argument, which must be an lvalue. */
2800 if ((TYPE_MAIN_VARIANT (expr_type
)
2801 != TYPE_MAIN_VARIANT (type_referred_to
))
2802 || !at_least_as_qualified_p (type_referred_to
,
2804 || !real_lvalue_p (expr
))
2805 return error_mark_node
;
2814 if (!TYPE_PTRMEMFUNC_P (type
))
2815 /* This handles templates like
2816 template<class T, T t> void f();
2817 when T is substituted with any class. The second template
2818 parameter becomes invalid and the template candidate is
2820 return error_mark_node
;
2822 /* For a non-type template-parameter of type pointer to member
2823 function, no conversions apply. If the template-argument
2824 represents a set of overloaded member functions, the
2825 matching member function is selected from the set
2828 if (!TYPE_PTRMEMFUNC_P (expr_type
) &&
2829 expr_type
!= unknown_type_node
)
2830 return error_mark_node
;
2832 if (TREE_CODE (expr
) == CONSTRUCTOR
)
2834 /* A ptr-to-member constant. */
2835 if (!same_type_p (type
, expr_type
))
2836 return error_mark_node
;
2841 if (TREE_CODE (expr
) != ADDR_EXPR
)
2842 return error_mark_node
;
2844 expr
= instantiate_type (type
, expr
, 0);
2846 if (expr
== error_mark_node
)
2847 return error_mark_node
;
2849 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2856 /* All non-type parameters must have one of these types. */
2857 my_friendly_abort (0);
2861 return error_mark_node
;
2864 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
2865 template template parameters. Both PARM_PARMS and ARG_PARMS are
2866 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
2869 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
2870 the case, then extra parameters must have default arguments.
2872 Consider the example:
2873 template <class T, class Allocator = allocator> class vector;
2874 template<template <class U> class TT> class C;
2876 C<vector> is a valid instantiation. PARM_PARMS for the above code
2877 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
2878 T and Allocator) and OUTER_ARGS contains the argument that is used to
2879 substitute the TT parameter. */
2882 coerce_template_template_parms (parm_parms
, arg_parms
, complain
,
2883 in_decl
, outer_args
)
2884 tree parm_parms
, arg_parms
;
2886 tree in_decl
, outer_args
;
2888 int nparms
, nargs
, i
;
2891 my_friendly_assert (TREE_CODE (parm_parms
) == TREE_VEC
, 0);
2892 my_friendly_assert (TREE_CODE (arg_parms
) == TREE_VEC
, 0);
2894 nparms
= TREE_VEC_LENGTH (parm_parms
);
2895 nargs
= TREE_VEC_LENGTH (arg_parms
);
2897 /* The rule here is opposite of coerce_template_parms. */
2900 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms
, nparms
)) == NULL_TREE
))
2903 for (i
= 0; i
< nparms
; ++i
)
2905 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
2906 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
2908 if (arg
== NULL_TREE
|| arg
== error_mark_node
2909 || parm
== NULL_TREE
|| parm
== error_mark_node
)
2912 if (TREE_CODE (arg
) != TREE_CODE (parm
))
2915 switch (TREE_CODE (parm
))
2921 /* We encounter instantiations of templates like
2922 template <template <template <class> class> class TT>
2925 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
2926 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
2928 if (!coerce_template_template_parms (parmparm
, argparm
,
2936 /* The tsubst call is used to handle cases such as
2937 template <class T, template <T> class TT> class D;
2938 i.e. the parameter list of TT depends on earlier parameters. */
2939 if (!same_type_p (tsubst (TREE_TYPE (parm
), outer_args
,
2946 my_friendly_abort (0);
2952 /* Convert the indicated template ARG as necessary to match the
2953 indicated template PARM. Returns the converted ARG, or
2954 error_mark_node if the conversion was unsuccessful. Error messages
2955 are issued if COMPLAIN is non-zero. This conversion is for the Ith
2956 parameter in the parameter list. ARGS is the full set of template
2957 arguments deduced so far. */
2960 convert_template_argument (parm
, arg
, args
, complain
, i
, in_decl
)
2970 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
2972 inner_args
= innermost_args (args
);
2974 if (TREE_CODE (arg
) == TREE_LIST
2975 && TREE_TYPE (arg
) != NULL_TREE
2976 && TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
2978 /* The template argument was the name of some
2979 member function. That's usually
2980 illegal, but static members are OK. In any
2981 case, grab the underlying fields/functions
2982 and issue an error later if required. */
2983 arg
= TREE_VALUE (arg
);
2984 TREE_TYPE (arg
) = unknown_type_node
;
2987 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
2988 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
2989 || requires_tmpl_type
);
2991 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true,
2992 we also accept implicitly created TYPE_DECL as a valid argument.
2993 This is necessary to handle the case where we pass a template name
2994 to a template template parameter in a scope where we've derived from
2995 in instantiation of that template, so the template name refers to that
2996 instantiation. We really ought to handle this better. */
2998 = ((TREE_CODE (arg
) == TEMPLATE_DECL
2999 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
3000 || (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
3001 && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg
))
3002 || (TREE_CODE (arg
) == RECORD_TYPE
3003 && CLASSTYPE_TEMPLATE_INFO (arg
)
3004 && TREE_CODE (TYPE_NAME (arg
)) == TYPE_DECL
3005 && DECL_ARTIFICIAL (TYPE_NAME (arg
))
3006 && requires_tmpl_type
3007 && is_base_of_enclosing_class (arg
, current_class_type
)));
3008 if (is_tmpl_type
&& TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
3009 arg
= TYPE_STUB_DECL (arg
);
3010 else if (is_tmpl_type
&& TREE_CODE (arg
) == RECORD_TYPE
)
3011 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
3013 is_type
= TREE_CODE_CLASS (TREE_CODE (arg
)) == 't' || is_tmpl_type
;
3015 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
3016 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
3018 cp_pedwarn ("to refer to a type member of a template parameter,");
3019 cp_pedwarn (" use `typename %E'", arg
);
3021 arg
= make_typename_type (TREE_OPERAND (arg
, 0),
3022 TREE_OPERAND (arg
, 1));
3025 if (is_type
!= requires_type
)
3031 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3034 cp_error (" expected a constant of type `%T', got `%T'",
3036 (is_tmpl_type
? DECL_NAME (arg
) : arg
));
3038 cp_error (" expected a type, got `%E'", arg
);
3041 return error_mark_node
;
3043 if (is_tmpl_type
^ requires_tmpl_type
)
3045 if (in_decl
&& complain
)
3047 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3050 cp_error (" expected a type, got `%T'", DECL_NAME (arg
));
3052 cp_error (" expected a class template, got `%T'", arg
);
3054 return error_mark_node
;
3059 if (requires_tmpl_type
)
3061 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
3062 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
3064 if (coerce_template_template_parms (parmparm
, argparm
, complain
,
3065 in_decl
, inner_args
))
3069 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3071 if (val
!= error_mark_node
3072 && DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
3073 val
= TREE_TYPE (val
);
3077 if (in_decl
&& complain
)
3079 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3081 cp_error (" expected a template of type `%D', got `%D'", parm
, arg
);
3084 val
= error_mark_node
;
3089 val
= groktypename (arg
);
3090 if (! processing_template_decl
)
3092 /* [basic.link]: A name with no linkage (notably, the
3093 name of a class or enumeration declared in a local
3094 scope) shall not be used to declare an entity with
3095 linkage. This implies that names with no linkage
3096 cannot be used as template arguments. */
3097 tree t
= no_linkage_check (val
);
3100 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
3102 ("template-argument `%T' uses anonymous type", val
);
3105 ("template-argument `%T' uses local type `%T'",
3107 return error_mark_node
;
3114 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
3116 if (processing_template_decl
)
3117 arg
= maybe_fold_nontype_arg (arg
);
3119 if (!uses_template_parms (arg
) && !uses_template_parms (t
))
3120 /* We used to call digest_init here. However, digest_init
3121 will report errors, which we don't want when complain
3122 is zero. More importantly, digest_init will try too
3123 hard to convert things: for example, `0' should not be
3124 converted to pointer type at this point according to
3125 the standard. Accepting this is not merely an
3126 extension, since deciding whether or not these
3127 conversions can occur is part of determining which
3128 function template to call, or whether a given epxlicit
3129 argument specification is legal. */
3130 val
= convert_nontype_argument (t
, arg
);
3134 if (val
== NULL_TREE
)
3135 val
= error_mark_node
;
3136 else if (val
== error_mark_node
&& complain
)
3137 cp_error ("could not convert template argument `%E' to `%T'",
3144 /* Convert all template arguments to their appropriate types, and
3145 return a vector containing the innermost resulting template
3146 arguments. If any error occurs, return error_mark_node, and, if
3147 COMPLAIN is non-zero, issue an error message. Some error messages
3148 are issued even if COMPLAIN is zero; for instance, if a template
3149 argument is composed from a local class.
3151 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3152 provided in ARGLIST, or else trailing parameters must have default
3153 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3154 deduction for any unspecified trailing arguments.
3156 The resulting TREE_VEC is allocated on a temporary obstack, and
3157 must be explicitly copied if it will be permanent. */
3160 coerce_template_parms (parms
, args
, in_decl
,
3162 require_all_arguments
)
3166 int require_all_arguments
;
3168 int nparms
, nargs
, i
, lost
= 0;
3171 tree new_inner_args
;
3173 inner_args
= innermost_args (args
);
3174 nargs
= NUM_TMPL_ARGS (inner_args
);
3175 nparms
= TREE_VEC_LENGTH (parms
);
3179 && require_all_arguments
3180 && TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
)) == NULL_TREE
))
3184 cp_error ("wrong number of template arguments (%d, should be %d)",
3188 cp_error_at ("provided for `%D'", in_decl
);
3191 return error_mark_node
;
3194 new_inner_args
= make_temp_vec (nparms
);
3195 new_args
= add_outermost_template_args (args
, new_inner_args
);
3196 for (i
= 0; i
< nparms
; i
++)
3201 /* Get the Ith template parameter. */
3202 parm
= TREE_VEC_ELT (parms
, i
);
3204 /* Calculate the Ith argument. */
3205 if (inner_args
&& TREE_CODE (inner_args
) == TREE_LIST
)
3207 arg
= TREE_VALUE (inner_args
);
3208 inner_args
= TREE_CHAIN (inner_args
);
3211 arg
= TREE_VEC_ELT (inner_args
, i
);
3212 /* If no template argument was supplied, look for a default
3214 else if (TREE_PURPOSE (parm
) == NULL_TREE
)
3216 /* There was no default value. */
3217 my_friendly_assert (!require_all_arguments
, 0);
3220 else if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
)
3221 arg
= tsubst (TREE_PURPOSE (parm
), new_args
, complain
, in_decl
);
3223 arg
= tsubst_expr (TREE_PURPOSE (parm
), new_args
, complain
,
3226 /* Now, convert the Ith argument, as necessary. */
3227 if (arg
== NULL_TREE
)
3228 /* We're out of arguments. */
3230 my_friendly_assert (!require_all_arguments
, 0);
3233 else if (arg
== error_mark_node
)
3235 cp_error ("template argument %d is invalid", i
+ 1);
3236 arg
= error_mark_node
;
3239 arg
= convert_template_argument (TREE_VALUE (parm
),
3240 arg
, new_args
, complain
, i
,
3243 if (arg
== error_mark_node
)
3245 TREE_VEC_ELT (new_inner_args
, i
) = arg
;
3249 return error_mark_node
;
3251 return new_inner_args
;
3254 /* Returns 1 if template args OT and NT are equivalent. */
3257 template_args_equal (ot
, nt
)
3262 if (TREE_CODE (nt
) != TREE_CODE (ot
))
3264 if (TREE_CODE (nt
) == TREE_VEC
)
3265 /* For member templates */
3266 return comp_template_args (ot
, nt
);
3267 else if (TREE_CODE_CLASS (TREE_CODE (ot
)) == 't')
3268 return same_type_p (ot
, nt
);
3270 return (cp_tree_equal (ot
, nt
) > 0);
3273 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3274 of template arguments. Returns 0 otherwise. */
3277 comp_template_args (oldargs
, newargs
)
3278 tree oldargs
, newargs
;
3282 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
3285 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
3287 tree nt
= TREE_VEC_ELT (newargs
, i
);
3288 tree ot
= TREE_VEC_ELT (oldargs
, i
);
3290 if (! template_args_equal (ot
, nt
))
3296 /* Given class template name and parameter list, produce a user-friendly name
3297 for the instantiation. */
3300 mangle_class_name_for_template (name
, parms
, arglist
)
3302 tree parms
, arglist
;
3304 static struct obstack scratch_obstack
;
3305 static char *scratch_firstobj
;
3308 if (!scratch_firstobj
)
3309 gcc_obstack_init (&scratch_obstack
);
3311 obstack_free (&scratch_obstack
, scratch_firstobj
);
3312 scratch_firstobj
= obstack_alloc (&scratch_obstack
, 1);
3314 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3315 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
3319 nparms
= TREE_VEC_LENGTH (parms
);
3320 arglist
= innermost_args (arglist
);
3321 my_friendly_assert (nparms
== TREE_VEC_LENGTH (arglist
), 268);
3322 for (i
= 0; i
< nparms
; i
++)
3324 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
3325 tree arg
= TREE_VEC_ELT (arglist
, i
);
3330 if (TREE_CODE (parm
) == TYPE_DECL
)
3332 cat (type_as_string_real (arg
, 0, 1));
3335 else if (TREE_CODE (parm
) == TEMPLATE_DECL
)
3337 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
3339 /* Already substituted with real template. Just output
3340 the template name here */
3341 tree context
= DECL_CONTEXT (arg
);
3344 my_friendly_assert (TREE_CODE (context
) == NAMESPACE_DECL
, 980422);
3345 cat(decl_as_string (DECL_CONTEXT (arg
), 0));
3348 cat (IDENTIFIER_POINTER (DECL_NAME (arg
)));
3351 /* Output the parameter declaration */
3352 cat (type_as_string_real (arg
, 0, 1));
3356 my_friendly_assert (TREE_CODE (parm
) == PARM_DECL
, 269);
3358 if (TREE_CODE (arg
) == TREE_LIST
)
3360 /* New list cell was built because old chain link was in
3362 my_friendly_assert (TREE_PURPOSE (arg
) == NULL_TREE
, 270);
3363 arg
= TREE_VALUE (arg
);
3365 /* No need to check arglist against parmlist here; we did that
3366 in coerce_template_parms, called from lookup_template_class. */
3367 cat (expr_as_string (arg
, 0));
3370 char *bufp
= obstack_next_free (&scratch_obstack
);
3372 while (bufp
[offset
- 1] == ' ')
3374 obstack_blank_fast (&scratch_obstack
, offset
);
3376 /* B<C<char> >, not B<C<char>> */
3377 if (bufp
[offset
- 1] == '>')
3382 return (char *) obstack_base (&scratch_obstack
);
3386 classtype_mangled_name (t
)
3389 if (CLASSTYPE_TEMPLATE_INFO (t
)
3390 /* Specializations have already had their names set up in
3391 lookup_template_class. */
3392 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
3394 tree tmpl
= most_general_template (CLASSTYPE_TI_TEMPLATE (t
));
3396 /* For non-primary templates, the template parameters are
3397 implicit from their surrounding context. */
3398 if (PRIMARY_TEMPLATE_P (tmpl
))
3400 tree name
= DECL_NAME (tmpl
);
3401 char *mangled_name
= mangle_class_name_for_template
3402 (IDENTIFIER_POINTER (name
),
3403 DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
3404 CLASSTYPE_TI_ARGS (t
));
3405 tree id
= get_identifier (mangled_name
);
3406 IDENTIFIER_TEMPLATE (id
) = name
;
3411 return TYPE_IDENTIFIER (t
);
3415 add_pending_template (d
)
3420 if (TREE_CODE_CLASS (TREE_CODE (d
)) == 't')
3421 ti
= CLASSTYPE_TEMPLATE_INFO (d
);
3423 ti
= DECL_TEMPLATE_INFO (d
);
3425 if (TI_PENDING_TEMPLATE_FLAG (ti
))
3428 *template_tail
= perm_tree_cons
3429 (build_srcloc_here (), d
, NULL_TREE
);
3430 template_tail
= &TREE_CHAIN (*template_tail
);
3431 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
3435 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3436 may be either a _DECL or an overloaded function or an
3437 IDENTIFIER_NODE), and ARGLIST. */
3440 lookup_template_function (fns
, arglist
)
3445 if (fns
== NULL_TREE
)
3447 cp_error ("non-template used as template");
3448 return error_mark_node
;
3451 type
= TREE_TYPE (fns
);
3452 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
3453 type
= unknown_type_node
;
3455 if (processing_template_decl
)
3456 return build_min (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3458 return build (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3461 /* Within the scope of a template class S<T>, the name S gets bound
3462 (in build_self_reference) to a TYPE_DECL for the class, not a
3463 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3464 or one of its enclosing classes, and that type is a template,
3465 return the associated TEMPLATE_DECL. Otherwise, the original
3466 DECL is returned. */
3469 maybe_get_template_decl_from_type_decl (decl
)
3472 return (decl
!= NULL_TREE
3473 && TREE_CODE (decl
) == TYPE_DECL
3474 && DECL_ARTIFICIAL (decl
)
3475 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
3476 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
3479 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3480 parameters, find the desired type.
3482 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3483 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3484 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3485 otherwise.) Since ARGLIST is build on the decl_obstack, we must
3486 copy it here to keep it from being reclaimed when the decl storage
3489 IN_DECL, if non-NULL, is the template declaration we are trying to
3492 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3493 the class we are looking up.
3495 If the template class is really a local class in a template
3496 function, then the FUNCTION_CONTEXT is the function in which it is
3497 being instantiated. */
3500 lookup_template_class (d1
, arglist
, in_decl
, context
, entering_scope
)
3506 tree
template = NULL_TREE
, parmlist
;
3509 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
3511 if (IDENTIFIER_VALUE (d1
)
3512 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1
)))
3513 template = IDENTIFIER_VALUE (d1
);
3517 push_decl_namespace (context
);
3518 if (current_class_type
!= NULL_TREE
)
3520 maybe_get_template_decl_from_type_decl
3521 (IDENTIFIER_CLASS_VALUE (d1
));
3522 if (template == NULL_TREE
)
3523 template = lookup_name_nonclass (d1
);
3525 pop_decl_namespace ();
3528 context
= DECL_CONTEXT (template);
3530 else if (TREE_CODE (d1
) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1
)))
3532 if (CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (d1
)))
3534 template = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (d1
));
3535 d1
= DECL_NAME (template);
3538 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
3539 || (TREE_CODE_CLASS (TREE_CODE (d1
)) == 't'
3540 && IS_AGGR_TYPE (d1
)))
3542 template = TYPE_TI_TEMPLATE (d1
);
3543 d1
= DECL_NAME (template);
3545 else if (TREE_CODE (d1
) == TEMPLATE_DECL
3546 && TREE_CODE (DECL_RESULT (d1
)) == TYPE_DECL
)
3549 d1
= DECL_NAME (template);
3550 context
= DECL_CONTEXT (template);
3553 my_friendly_abort (272);
3555 /* With something like `template <class T> class X class X { ... };'
3556 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3557 We don't want to do that, but we have to deal with the situation,
3558 so let's give them some syntax errors to chew on instead of a
3562 cp_error ("`%T' is not a template", d1
);
3563 return error_mark_node
;
3566 if (context
== NULL_TREE
)
3567 context
= global_namespace
;
3569 if (TREE_CODE (template) != TEMPLATE_DECL
)
3571 cp_error ("non-template type `%T' used as a template", d1
);
3573 cp_error_at ("for template declaration `%D'", in_decl
);
3574 return error_mark_node
;
3577 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
3579 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3580 template arguments */
3582 tree parm
= copy_template_template_parm (TREE_TYPE (template));
3583 tree template2
= TYPE_STUB_DECL (parm
);
3586 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
3588 arglist2
= coerce_template_parms (parmlist
, arglist
, template, 1, 1);
3589 if (arglist2
== error_mark_node
)
3590 return error_mark_node
;
3592 arglist2
= copy_to_permanent (arglist2
);
3593 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
)
3594 = perm_tree_cons (template2
, arglist2
, NULL_TREE
);
3595 TYPE_SIZE (parm
) = 0;
3600 tree template_type
= TREE_TYPE (template);
3602 tree found
= NULL_TREE
;
3605 int is_partial_instantiation
;
3607 template = most_general_template (template);
3608 parmlist
= DECL_TEMPLATE_PARMS (template);
3609 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
3610 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3612 /* We build up the coerced arguments and such on the
3613 momentary_obstack. */
3616 if (arg_depth
== 1 && parm_depth
> 1)
3618 /* We've been given an incomplete set of template arguments.
3621 template <class T> struct S1 {
3622 template <class U> struct S2 {};
3623 template <class U> struct S2<U*> {};
3626 we will be called with an ARGLIST of `U*', but the
3627 TEMPLATE will be `template <class T> template
3628 <class U> struct S1<T>::S2'. We must fill in the missing
3630 my_friendly_assert (context
!= NULL_TREE
, 0);
3631 while (!IS_AGGR_TYPE_CODE (TREE_CODE (context
))
3632 && context
!= global_namespace
)
3633 context
= DECL_REAL_CONTEXT (context
);
3635 if (context
== global_namespace
)
3636 /* This is bad. We cannot get enough arguments, even from
3637 the surrounding context, to resolve this class. One
3638 case where this might happen is (illegal) code like:
3646 We should catch this error sooner (at the opening curly
3647 for `S', but it is better to be safe than sorry here. */
3649 cp_error ("invalid use of `%D'", template);
3650 return error_mark_node
;
3653 arglist
= add_to_template_args (TYPE_TI_ARGS (context
),
3655 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3658 my_friendly_assert (parm_depth
== arg_depth
, 0);
3660 /* Calculate the BOUND_ARGS. These will be the args that are
3661 actually tsubst'd into the definition to create the
3665 /* We have multiple levels of arguments to coerce, at once. */
3667 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
3669 tree bound_args
= make_temp_vec (parm_depth
);
3671 for (i
= saved_depth
,
3672 t
= DECL_TEMPLATE_PARMS (template);
3673 i
> 0 && t
!= NULL_TREE
;
3674 --i
, t
= TREE_CHAIN (t
))
3676 tree a
= coerce_template_parms (TREE_VALUE (t
),
3677 arglist
, template, 1, 1);
3678 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
3680 /* We temporarily reduce the length of the ARGLIST so
3681 that coerce_template_parms will see only the arguments
3682 corresponding to the template parameters it is
3684 TREE_VEC_LENGTH (arglist
)--;
3687 /* Restore the ARGLIST to its full size. */
3688 TREE_VEC_LENGTH (arglist
) = saved_depth
;
3690 arglist
= bound_args
;
3694 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
3695 innermost_args (arglist
),
3698 if (arglist
== error_mark_node
)
3699 /* We were unable to bind the arguments. */
3700 return error_mark_node
;
3702 /* In the scope of a template class, explicit references to the
3703 template class refer to the type of the template, not any
3704 instantiation of it. For example, in:
3706 template <class T> class C { void f(C<T>); }
3708 the `C<T>' is just the same as `C'. Outside of the
3709 class, however, such a reference is an instantiation. */
3710 if (comp_template_args (TYPE_TI_ARGS (template_type
),
3713 found
= template_type
;
3715 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
3719 /* Note that we use DECL_CONTEXT, rather than
3720 CP_DECL_CONTEXT, so that the termination test is
3721 always just `ctx'. We're not interested in namepace
3723 for (ctx
= current_class_type
;
3725 ctx
= (TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't')
3726 ? TYPE_CONTEXT (ctx
) : DECL_CONTEXT (ctx
))
3727 if (same_type_p (ctx
, template_type
))
3731 /* We're not in the scope of the class, so the
3732 TEMPLATE_TYPE is not the type we want after
3740 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3741 found
; found
= TREE_CHAIN (found
))
3742 if (comp_template_args (TREE_PURPOSE (found
), arglist
))
3746 found
= TREE_VALUE (found
);
3755 /* Since we didn't find the type, we'll have to create it.
3756 Since we'll be saving this type on the
3757 DECL_TEMPLATE_INSTANTIATIONS list, it must be permanent. */
3758 push_obstacks (&permanent_obstack
, &permanent_obstack
);
3760 /* This type is a "partial instantiation" if any of the template
3761 arguments still inolve template parameters. Note that we set
3762 IS_PARTIAL_INSTANTIATION for partial specializations as
3764 is_partial_instantiation
= uses_template_parms (arglist
);
3766 /* Create the type. */
3767 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
3769 if (!is_partial_instantiation
)
3770 t
= start_enum (TYPE_IDENTIFIER (template_type
));
3772 /* We don't want to call start_enum for this type, since
3773 the values for the enumeration constants may involve
3774 template parameters. And, no one should be interested
3775 in the enumeration constants for such a type. */
3776 t
= make_node (ENUMERAL_TYPE
);
3780 t
= make_lang_type (TREE_CODE (template_type
));
3781 CLASSTYPE_DECLARED_CLASS (t
)
3782 = CLASSTYPE_DECLARED_CLASS (template_type
);
3783 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
3784 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
3785 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
3788 /* If we called start_enum above, this information will already
3792 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3794 /* Create a stub TYPE_DECL for it. */
3795 type_decl
= build_decl (TYPE_DECL
, DECL_NAME (template), t
);
3796 SET_DECL_ARTIFICIAL (type_decl
);
3797 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
3798 DECL_SOURCE_FILE (type_decl
)
3799 = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type
));
3800 DECL_SOURCE_LINE (type_decl
)
3801 = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type
));
3802 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = type_decl
;
3805 type_decl
= TYPE_NAME (t
);
3807 /* Set up the template information. We have to figure out which
3808 template is the immediate parent if this is a full
3810 if (parm_depth
== 1 || is_partial_instantiation
3811 || !PRIMARY_TEMPLATE_P (template))
3812 /* This case is easy; there are no member templates involved. */
3816 /* This is a full instantiation of a member template. There
3817 should be some partial instantiation of which this is an
3820 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3821 found
; found
= TREE_CHAIN (found
))
3824 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
3826 /* We only want partial instantiations, here, not
3827 specializations or full instantiations. */
3828 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
3829 || !uses_template_parms (TREE_VALUE (found
)))
3832 /* Temporarily reduce by one the number of levels in the
3833 ARGLIST and in FOUND so as to avoid comparing the
3834 last set of arguments. */
3835 TREE_VEC_LENGTH (arglist
)--;
3836 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
3838 /* See if the arguments match. If they do, then TMPL is
3839 the partial instantiation we want. */
3840 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
3842 /* Restore the argument vectors to their full size. */
3843 TREE_VEC_LENGTH (arglist
)++;
3844 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
3854 my_friendly_abort (0);
3857 arglist
= copy_to_permanent (arglist
);
3858 SET_TYPE_TEMPLATE_INFO (t
,
3859 tree_cons (found
, arglist
, NULL_TREE
));
3860 DECL_TEMPLATE_INSTANTIATIONS (template)
3861 = tree_cons (arglist
, t
,
3862 DECL_TEMPLATE_INSTANTIATIONS (template));
3864 if (TREE_CODE (t
) == ENUMERAL_TYPE
3865 && !is_partial_instantiation
)
3866 /* Now that the type has been registered on the instantiations
3867 list, we set up the enumerators. Because the enumeration
3868 constants may involve the enumeration type itself, we make
3869 sure to register the type first, and then create the
3870 constants. That way, doing tsubst_expr for the enumeration
3871 constants won't result in recursive calls here; we'll find
3872 the instantiation and exit above. */
3873 tsubst_enum (template_type
, t
, arglist
);
3875 /* We're done with the permanent obstack, now. */
3877 /* We're also done with the momentary allocation we started
3881 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
3883 if (TREE_CODE (t
) != ENUMERAL_TYPE
)
3884 DECL_NAME (type_decl
) = classtype_mangled_name (t
);
3885 DECL_ASSEMBLER_NAME (type_decl
) = DECL_NAME (type_decl
);
3886 if (!is_partial_instantiation
)
3888 DECL_ASSEMBLER_NAME (type_decl
)
3889 = get_identifier (build_overload_name (t
, 1, 1));
3891 /* For backwards compatibility; code that uses
3892 -fexternal-templates expects looking up a template to
3893 instantiate it. I think DDD still relies on this.
3894 (jason 8/20/1998) */
3895 if (TREE_CODE (t
) != ENUMERAL_TYPE
3896 && flag_external_templates
3897 && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
3898 && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
3899 add_pending_template (t
);
3902 /* If the type makes use of template parameters, the
3903 code that generates debugging information will crash. */
3904 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
3910 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or
3911 TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA.
3912 If FN returns non-zero, the iteration is terminated, and
3913 for_each_template_parm returns 1. Otherwise, the iteration
3914 continues. If FN never returns a non-zero value, the value
3915 returned by for_each_template_parm is 0. If FN is NULL, it is
3916 considered to be the function which always returns 1. */
3919 for_each_template_parm (t
, fn
, data
)
3927 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't'
3928 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
))
3931 switch (TREE_CODE (t
))
3935 /* We assume that the object must be instantiated in order to build
3936 the COMPONENT_REF, so we test only whether the type of the
3937 COMPONENT_REF uses template parms. */
3938 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3941 return (for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
)
3942 || for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
));
3944 case IDENTIFIER_NODE
:
3945 if (!IDENTIFIER_TEMPLATE (t
))
3947 my_friendly_abort (42);
3949 /* aggregates of tree nodes */
3952 int i
= TREE_VEC_LENGTH (t
);
3954 if (for_each_template_parm (TREE_VEC_ELT (t
, i
), fn
, data
))
3959 if (for_each_template_parm (TREE_PURPOSE (t
), fn
, data
)
3960 || for_each_template_parm (TREE_VALUE (t
), fn
, data
))
3962 return for_each_template_parm (TREE_CHAIN (t
), fn
, data
);
3965 if (for_each_template_parm (OVL_FUNCTION (t
), fn
, data
))
3967 return for_each_template_parm (OVL_CHAIN (t
), fn
, data
);
3969 /* constructed type nodes */
3971 case REFERENCE_TYPE
:
3972 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
3975 if (TYPE_PTRMEMFUNC_FLAG (t
))
3976 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE (t
),
3982 if (! TYPE_TEMPLATE_INFO (t
))
3984 return for_each_template_parm (TREE_VALUE
3985 (TYPE_TEMPLATE_INFO (t
)),
3988 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
))
3993 /* Check the parameter types. Since default arguments are not
3994 instantiated until they are needed, the TYPE_ARG_TYPES may
3995 contain expressions that involve template parameters. But,
3996 no-one should be looking at them yet. And, once they're
3997 instantiated, they don't contain template parameters, so
3998 there's no point in looking at them then, either. */
4002 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
4003 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
))
4007 /* Check the return type, too. */
4008 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4011 if (for_each_template_parm (TYPE_DOMAIN (t
), fn
, data
))
4013 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4015 if (for_each_template_parm (TYPE_OFFSET_BASETYPE (t
), fn
, data
))
4017 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4021 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4024 /* A template template parameter is encountered */
4025 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
4026 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4027 /* Already substituted template template parameter */
4031 if (for_each_template_parm (DECL_INITIAL (t
), fn
, data
))
4033 goto check_type_and_context
;
4037 /* ??? What about FIELD_DECLs? */
4038 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
4039 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
))
4043 check_type_and_context
:
4044 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
))
4046 if (DECL_CONTEXT (t
)
4047 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
))
4052 return (for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
)
4053 || for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
));
4056 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4058 /* template parm nodes */
4059 case TEMPLATE_TEMPLATE_PARM
:
4060 /* Record template parameters such as `T' inside `TT<T>'. */
4061 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
)
4062 && for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
))
4064 case TEMPLATE_TYPE_PARM
:
4065 case TEMPLATE_PARM_INDEX
:
4067 return (*fn
)(t
, data
);
4071 /* simple type nodes */
4073 if (for_each_template_parm (TYPE_MIN_VALUE (t
), fn
, data
))
4075 return for_each_template_parm (TYPE_MAX_VALUE (t
), fn
, data
);
4081 case NAMESPACE_DECL
:
4091 /* Non-error_mark_node ERROR_MARKs are bad things. */
4092 my_friendly_assert (t
== error_mark_node
, 274);
4101 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4104 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4107 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
4108 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4109 (TREE_TYPE (t
)), fn
, data
);
4110 return for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
);
4114 case REINTERPRET_CAST_EXPR
:
4115 case CONST_CAST_EXPR
:
4116 case STATIC_CAST_EXPR
:
4117 case DYNAMIC_CAST_EXPR
:
4125 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4128 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
4136 for (i
= first_rtl_op (TREE_CODE (t
)); --i
>= 0;)
4137 if (for_each_template_parm (TREE_OPERAND (t
, i
), fn
, data
))
4144 sorry ("testing %s for template parms",
4145 tree_code_name
[(int) TREE_CODE (t
)]);
4146 my_friendly_abort (82);
4153 uses_template_parms (t
)
4156 return for_each_template_parm (t
, 0, 0);
4159 static struct tinst_level
*current_tinst_level
;
4160 static struct tinst_level
*free_tinst_level
;
4161 static int tinst_depth
;
4162 extern int max_tinst_depth
;
4163 #ifdef GATHER_STATISTICS
4166 int tinst_level_tick
;
4167 int last_template_error_tick
;
4169 /* Print out all the template instantiations that we are currently
4170 working on. If ERR, we are being called from cp_thing, so do
4171 the right thing for an error message. */
4174 print_template_context (err
)
4177 struct tinst_level
*p
= current_tinst_level
;
4179 char *file
= input_filename
;
4183 if (current_function_decl
!= p
->decl
4184 && current_function_decl
!= NULL_TREE
)
4185 /* We can get here during the processing of some synthesized
4186 method. Then, p->decl will be the function that's causing
4191 if (current_function_decl
== p
->decl
)
4192 /* Avoid redundancy with the the "In function" line. */;
4194 fprintf (stderr
, "%s: In instantiation of `%s':\n",
4195 file
, decl_as_string (p
->decl
, 0));
4203 for (; p
; p
= p
->next
)
4205 fprintf (stderr
, "%s:%d: instantiated from `%s'\n", file
, line
,
4206 decl_as_string (p
->decl
, 0));
4210 fprintf (stderr
, "%s:%d: instantiated from here\n", file
, line
);
4213 /* Called from cp_thing to print the template context for an error. */
4216 maybe_print_template_context ()
4218 if (last_template_error_tick
== tinst_level_tick
4219 || current_tinst_level
== 0)
4222 last_template_error_tick
= tinst_level_tick
;
4223 print_template_context (1);
4227 push_tinst_level (d
)
4230 struct tinst_level
*new;
4232 if (tinst_depth
>= max_tinst_depth
)
4234 /* If the instantiation in question still has unbound template parms,
4235 we don't really care if we can't instantiate it, so just return.
4236 This happens with base instantiation for implicit `typename'. */
4237 if (uses_template_parms (d
))
4240 last_template_error_tick
= tinst_level_tick
;
4241 error ("template instantiation depth exceeds maximum of %d",
4243 error (" (use -ftemplate-depth-NN to increase the maximum)");
4244 cp_error (" instantiating `%D'", d
);
4246 print_template_context (0);
4251 if (free_tinst_level
)
4253 new = free_tinst_level
;
4254 free_tinst_level
= new->next
;
4257 new = (struct tinst_level
*) xmalloc (sizeof (struct tinst_level
));
4261 new->file
= input_filename
;
4262 new->next
= current_tinst_level
;
4263 current_tinst_level
= new;
4266 #ifdef GATHER_STATISTICS
4267 if (tinst_depth
> depth_reached
)
4268 depth_reached
= tinst_depth
;
4278 struct tinst_level
*old
= current_tinst_level
;
4280 /* Restore the filename and line number stashed away when we started
4281 this instantiation. */
4283 input_filename
= old
->file
;
4284 extract_interface_info ();
4286 current_tinst_level
= old
->next
;
4287 old
->next
= free_tinst_level
;
4288 free_tinst_level
= old
;
4293 struct tinst_level
*
4296 struct tinst_level
*p
= current_tinst_level
;
4299 for (; p
->next
; p
= p
->next
)
4304 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4305 vector of template arguments, as for tsubst.
4307 Returns an appropriate tsbust'd friend declaration. */
4310 tsubst_friend_function (decl
, args
)
4316 char *file
= input_filename
;
4318 lineno
= DECL_SOURCE_LINE (decl
);
4319 input_filename
= DECL_SOURCE_FILE (decl
);
4321 if (TREE_CODE (decl
) == FUNCTION_DECL
4322 && DECL_TEMPLATE_INSTANTIATION (decl
)
4323 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
4324 /* This was a friend declared with an explicit template
4325 argument list, e.g.:
4329 to indicate that f was a template instantiation, not a new
4330 function declaration. Now, we have to figure out what
4331 instantiation of what template. */
4338 = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl
),
4339 args
, /*complain=*/1,
4341 tsubst (DECL_TI_ARGS (decl
),
4342 args
, /*complain=*/1,
4344 /* FIXME: The decl we create via the next tsubst could be
4345 created on a temporary obstack. */
4346 new_friend
= tsubst (decl
, args
, /*complain=*/1, NULL_TREE
);
4347 tmpl
= determine_specialization (template_id
, new_friend
,
4349 /*need_member_template=*/0);
4350 new_friend
= instantiate_template (tmpl
, new_args
);
4354 new_friend
= tsubst (decl
, args
, /*complain=*/1, NULL_TREE
);
4356 /* The NEW_FRIEND will look like an instantiation, to the
4357 compiler, but is not an instantiation from the point of view of
4358 the language. For example, we might have had:
4360 template <class T> struct S {
4361 template <class U> friend void f(T, U);
4364 Then, in S<int>, template <class U> void f(int, U) is not an
4365 instantiation of anything. */
4366 DECL_USE_TEMPLATE (new_friend
) = 0;
4367 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4368 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
4370 /* The mangled name for the NEW_FRIEND is incorrect. The call to
4371 tsubst will have resulted in a call to
4372 set_mangled_name_for_template_decl. But, the function is not a
4373 template instantiation and should not be mangled like one.
4374 Therefore, we remangle the function name. We don't have to do
4375 this if the NEW_FRIEND is a template since
4376 set_mangled_name_for_template_decl doesn't do anything if the
4377 function declaration still uses template arguments. */
4378 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
4380 set_mangled_name_for_decl (new_friend
);
4381 DECL_RTL (new_friend
) = 0;
4382 make_decl_rtl (new_friend
, NULL_PTR
, 1);
4385 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
4388 tree new_friend_template_info
;
4389 tree new_friend_result_template_info
;
4390 int new_friend_is_defn
;
4392 /* We must save some information from NEW_FRIEND before calling
4393 duplicate decls since that function will free NEW_FRIEND if
4395 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
4396 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
4398 /* This declaration is a `primary' template. */
4399 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
4402 = DECL_INITIAL (DECL_RESULT (new_friend
)) != NULL_TREE
;
4403 new_friend_result_template_info
4404 = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend
));
4408 new_friend_is_defn
= DECL_INITIAL (new_friend
) != NULL_TREE
;
4409 new_friend_result_template_info
= NULL_TREE
;
4412 old_decl
= pushdecl_namespace_level (new_friend
);
4414 if (old_decl
!= new_friend
)
4416 /* This new friend declaration matched an existing
4417 declaration. For example, given:
4419 template <class T> void f(T);
4420 template <class U> class C {
4421 template <class T> friend void f(T) {}
4424 the friend declaration actually provides the definition
4425 of `f', once C has been instantiated for some type. So,
4426 old_decl will be the out-of-class template declaration,
4427 while new_friend is the in-class definition.
4429 But, if `f' was called before this point, the
4430 instantiation of `f' will have DECL_TI_ARGS corresponding
4431 to `T' but not to `U', references to which might appear
4432 in the definition of `f'. Previously, the most general
4433 template for an instantiation of `f' was the out-of-class
4434 version; now it is the in-class version. Therefore, we
4435 run through all specialization of `f', adding to their
4436 DECL_TI_ARGS appropriately. In particular, they need a
4437 new set of outer arguments, corresponding to the
4438 arguments for this class instantiation.
4440 The same situation can arise with something like this:
4443 template <class T> class C {
4447 when `C<int>' is instantiated. Now, `f(int)' is defined
4450 if (!new_friend_is_defn
)
4451 /* On the other hand, if the in-class declaration does
4452 *not* provide a definition, then we don't want to alter
4453 existing definitions. We can just leave everything
4458 /* Overwrite whatever template info was there before, if
4459 any, with the new template information pertaining to
4461 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
4463 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
4464 /* duplicate_decls will take care of this case. */
4469 tree new_friend_args
;
4471 DECL_TEMPLATE_INFO (DECL_RESULT (old_decl
))
4472 = new_friend_result_template_info
;
4474 new_friend_args
= TI_ARGS (new_friend_template_info
);
4475 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
4479 tree spec
= TREE_VALUE (t
);
4482 = add_outermost_template_args (new_friend_args
,
4483 DECL_TI_ARGS (spec
));
4485 = copy_to_permanent (DECL_TI_ARGS (spec
));
4488 /* Now, since specializations are always supposed to
4489 hang off of the most general template, we must move
4491 t
= most_general_template (old_decl
);
4494 DECL_TEMPLATE_SPECIALIZATIONS (t
)
4495 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
4496 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
4497 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
4502 /* The information from NEW_FRIEND has been merged into OLD_DECL
4503 by duplicate_decls. */
4504 new_friend
= old_decl
;
4507 else if (TYPE_SIZE (DECL_CONTEXT (new_friend
)))
4509 /* Check to see that the declaration is really present, and,
4510 possibly obtain an improved declaration. */
4511 tree fn
= check_classfn (DECL_CONTEXT (new_friend
),
4520 input_filename
= file
;
4524 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4525 template arguments, as for tsubst.
4527 Returns an appropriate tsbust'd friend type. */
4530 tsubst_friend_class (friend_tmpl
, args
)
4535 tree tmpl
= lookup_name (DECL_NAME (friend_tmpl
), 1);
4537 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
4539 if (tmpl
!= NULL_TREE
&& DECL_CLASS_TEMPLATE_P (tmpl
))
4541 /* The friend template has already been declared. Just
4542 check to see that the declarations match, and install any new
4543 default parameters. We must tsubst the default parameters,
4544 of course. We only need the innermost template parameters
4545 because that is all that redeclare_class_template will look
4548 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
4549 args
, /*complain=*/1);
4550 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
4551 friend_type
= TREE_TYPE (tmpl
);
4555 /* The friend template has not already been declared. In this
4556 case, the instantiation of the template class will cause the
4557 injection of this template into the global scope. */
4558 tmpl
= tsubst (friend_tmpl
, args
, /*complain=*/1, NULL_TREE
);
4560 /* The new TMPL is not an instantiation of anything, so we
4561 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4562 the new type because that is supposed to be the corresponding
4563 template decl, i.e., TMPL. */
4564 DECL_USE_TEMPLATE (tmpl
) = 0;
4565 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
4566 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
4568 /* Inject this template into the global scope. */
4569 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
));
4576 instantiate_class_template (type
)
4579 tree
template, args
, pattern
, t
;
4582 if (type
== error_mark_node
)
4583 return error_mark_node
;
4585 if (TYPE_BEING_DEFINED (type
) || TYPE_SIZE (type
))
4588 /* We want to allocate temporary vectors of template arguments and
4589 template argument expressions on the momentary obstack, not on
4590 the expression obstack. Otherwise, all the space allocated in
4591 argument coercion and such is simply lost. */
4594 /* Figure out which template is being instantiated. */
4595 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
4596 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL
, 279);
4598 /* Figure out which arguments are being used to do the
4600 args
= CLASSTYPE_TI_ARGS (type
);
4601 PARTIAL_INSTANTIATION_P (type
) = uses_template_parms (args
);
4603 if (pedantic
&& PARTIAL_INSTANTIATION_P (type
))
4604 /* If this is a partial instantiation, then we can't instantiate
4605 the type; there's no telling whether or not one of the
4606 template parameters might eventually be instantiated to some
4607 value that results in a specialization being used. For
4619 Now, the `S<U>' in `f<int>' is the specialization, not an
4620 instantiation of the original template. */
4623 /* Determine what specialization of the original template to
4625 if (PARTIAL_INSTANTIATION_P (type
))
4626 /* There's no telling which specialization is appropriate at this
4627 point. Since all peeking at the innards of this partial
4628 instantiation are extensions (like the "implicit typename"
4629 extension, which allows users to omit the keyword `typename' on
4630 names that are declared as types in template base classes), we
4631 are free to do what we please.
4633 Trying to figure out which partial instantiation to use can
4634 cause a crash. (Some of the template arguments don't even have
4635 types.) So, we just use the most general version. */
4639 t
= most_specialized_class (template, args
);
4641 if (t
== error_mark_node
)
4643 char *str
= "candidates are:";
4644 cp_error ("ambiguous class template instantiation for `%#T'", type
);
4645 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (template); t
;
4648 if (get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4651 cp_error_at ("%s %+#T", str
, TREE_TYPE (t
));
4655 TYPE_BEING_DEFINED (type
) = 1;
4656 type
= error_mark_node
;
4662 pattern
= TREE_TYPE (t
);
4664 pattern
= TREE_TYPE (template);
4666 /* If the template we're instantiating is incomplete, then clearly
4667 there's nothing we can do. */
4668 if (TYPE_SIZE (pattern
) == NULL_TREE
)
4671 /* If this is a partial instantiation, don't tsubst anything. We will
4672 only use this type for implicit typename, so the actual contents don't
4673 matter. All that matters is whether a particular name is a type. */
4674 if (PARTIAL_INSTANTIATION_P (type
))
4676 /* The fields set here must be kept in sync with those cleared
4677 in begin_class_definition. */
4678 TYPE_BINFO_BASETYPES (type
) = TYPE_BINFO_BASETYPES (pattern
);
4679 TYPE_FIELDS (type
) = TYPE_FIELDS (pattern
);
4680 TYPE_METHODS (type
) = TYPE_METHODS (pattern
);
4681 CLASSTYPE_TAGS (type
) = CLASSTYPE_TAGS (pattern
);
4682 /* Pretend that the type is complete, so that we will look
4683 inside it during name lookup and such. */
4684 TYPE_SIZE (type
) = integer_zero_node
;
4688 /* If we've recursively instantiated too many templates, stop. */
4689 if (! push_tinst_level (type
))
4692 /* Now we're really doing the instantiation. Mark the type as in
4693 the process of being defined. */
4694 TYPE_BEING_DEFINED (type
) = 1;
4696 maybe_push_to_top_level (uses_template_parms (type
));
4697 pushclass (type
, 0);
4701 /* This TYPE is actually a instantiation of of a partial
4702 specialization. We replace the innermost set of ARGS with
4703 the arguments appropriate for substitution. For example,
4706 template <class T> struct S {};
4707 template <class T> struct S<T*> {};
4709 and supposing that we are instantiating S<int*>, ARGS will
4710 present be {int*} but we need {int}. */
4712 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4715 /* If there were multiple levels in ARGS, replacing the
4716 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4717 want, so we make a copy first. */
4718 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
4720 args
= copy_node (args
);
4721 SET_TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
), inner_args
);
4727 if (flag_external_templates
)
4729 if (flag_alt_external_templates
)
4731 CLASSTYPE_INTERFACE_ONLY (type
) = interface_only
;
4732 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type
, interface_unknown
);
4733 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4734 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4735 && CLASSTYPE_INTERFACE_KNOWN (type
));
4739 CLASSTYPE_INTERFACE_ONLY (type
) = CLASSTYPE_INTERFACE_ONLY (pattern
);
4740 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
4741 (type
, CLASSTYPE_INTERFACE_UNKNOWN (pattern
));
4742 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4743 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4744 && CLASSTYPE_INTERFACE_KNOWN (type
));
4749 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
4750 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
4753 TYPE_HAS_CONSTRUCTOR (type
) = TYPE_HAS_CONSTRUCTOR (pattern
);
4754 TYPE_HAS_DESTRUCTOR (type
) = TYPE_HAS_DESTRUCTOR (pattern
);
4755 TYPE_HAS_ASSIGNMENT (type
) = TYPE_HAS_ASSIGNMENT (pattern
);
4756 TYPE_OVERLOADS_CALL_EXPR (type
) = TYPE_OVERLOADS_CALL_EXPR (pattern
);
4757 TYPE_OVERLOADS_ARRAY_REF (type
) = TYPE_OVERLOADS_ARRAY_REF (pattern
);
4758 TYPE_OVERLOADS_ARROW (type
) = TYPE_OVERLOADS_ARROW (pattern
);
4759 TYPE_GETS_NEW (type
) = TYPE_GETS_NEW (pattern
);
4760 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
4761 TYPE_VEC_DELETE_TAKES_SIZE (type
) = TYPE_VEC_DELETE_TAKES_SIZE (pattern
);
4762 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
4763 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
4764 TYPE_HAS_ABSTRACT_ASSIGN_REF (type
) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern
);
4765 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
4766 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
4767 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
4768 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
4769 TYPE_USES_COMPLEX_INHERITANCE (type
)
4770 = TYPE_USES_COMPLEX_INHERITANCE (pattern
);
4771 TYPE_USES_MULTIPLE_INHERITANCE (type
)
4772 = TYPE_USES_MULTIPLE_INHERITANCE (pattern
);
4773 TYPE_USES_VIRTUAL_BASECLASSES (type
)
4774 = TYPE_USES_VIRTUAL_BASECLASSES (pattern
);
4775 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
4776 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
4777 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
4779 /* We must copy the arguments to the permanent obstack since
4780 during the tsubst'ing below they may wind up in the
4781 DECL_TI_ARGS of some instantiated member template. */
4782 args
= copy_to_permanent (args
);
4784 if (TYPE_BINFO_BASETYPES (pattern
))
4786 tree base_list
= NULL_TREE
;
4787 tree pbases
= TYPE_BINFO_BASETYPES (pattern
);
4790 /* Substitute into each of the bases to determine the actual
4792 for (i
= 0; i
< TREE_VEC_LENGTH (pbases
); ++i
)
4798 pbase
= TREE_VEC_ELT (pbases
, i
);
4800 /* Substitue to figure out the base class. */
4801 base
= tsubst (BINFO_TYPE (pbase
), args
,
4802 /*complain=*/1, NULL_TREE
);
4803 if (base
== error_mark_node
)
4806 /* Calculate the correct access node. */
4807 if (TREE_VIA_VIRTUAL (pbase
))
4809 if (TREE_VIA_PUBLIC (pbase
))
4810 access
= access_public_virtual_node
;
4811 else if (TREE_VIA_PROTECTED (pbase
))
4812 access
= access_protected_virtual_node
;
4814 access
= access_private_virtual_node
;
4818 if (TREE_VIA_PUBLIC (pbase
))
4819 access
= access_public_node
;
4820 else if (TREE_VIA_PROTECTED (pbase
))
4821 access
= access_protected_node
;
4823 access
= access_private_node
;
4826 base_list
= tree_cons (access
, base
, base_list
);
4829 /* The list is now in reverse order; correct that. */
4830 base_list
= nreverse (base_list
);
4832 /* Now call xref_basetypes to set up all the base-class
4834 xref_basetypes (TREE_CODE (pattern
) == RECORD_TYPE
4835 ? (CLASSTYPE_DECLARED_CLASS (pattern
)
4836 ? class_type_node
: record_type_node
)
4838 DECL_NAME (TYPE_NAME (pattern
)),
4843 for (t
= CLASSTYPE_TAGS (pattern
); t
; t
= TREE_CHAIN (t
))
4845 tree tag
= TREE_VALUE (t
);
4846 tree name
= TYPE_IDENTIFIER (tag
);
4849 newtag
= tsubst (tag
, args
, /*complain=*/1, NULL_TREE
);
4850 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
4852 if (TYPE_LANG_SPECIFIC (tag
) && CLASSTYPE_IS_TEMPLATE (tag
))
4853 /* Unfortunately, lookup_template_class sets
4854 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
4855 instantiation (i.e., for the type of a member template
4856 class nested within a template class.) This behavior is
4857 required for maybe_process_partial_specialization to work
4858 correctly, but is not accurate in this case; the TAG is not
4859 an instantiation of anything. (The corresponding
4860 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
4861 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
4863 /* Now, we call pushtag to put this NEWTAG into the scope of
4864 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
4865 pushtag calling push_template_decl. We don't have to do
4866 this for enums because it will already have been done in
4869 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
4870 pushtag (name
, newtag
, /*globalize=*/0);
4874 /* Don't replace enum constants here. */
4875 for (t
= TYPE_FIELDS (pattern
); t
; t
= TREE_CHAIN (t
))
4876 if (TREE_CODE (t
) != CONST_DECL
)
4880 /* The the file and line for this declaration, to assist in
4881 error message reporting. Since we called push_tinst_level
4882 above, we don't need to restore these. */
4883 lineno
= DECL_SOURCE_LINE (t
);
4884 input_filename
= DECL_SOURCE_FILE (t
);
4886 r
= tsubst (t
, args
, /*complain=*/1, NULL_TREE
);
4887 if (TREE_CODE (r
) == VAR_DECL
)
4889 pending_statics
= perm_tree_cons (NULL_TREE
, r
, pending_statics
);
4890 /* Perhaps we should do more of grokfield here. */
4891 if (DECL_DEFINED_IN_CLASS_P (r
))
4892 /* Set up DECL_INITIAL, since tsubst doesn't. */
4893 DECL_INITIAL (r
) = tsubst_expr (DECL_INITIAL (t
), args
,
4894 /*complain=*/1, NULL_TREE
);
4896 DECL_IN_AGGR_P (r
) = 1;
4897 DECL_EXTERNAL (r
) = 1;
4898 cp_finish_decl (r
, DECL_INITIAL (r
), NULL_TREE
, 0, 0);
4899 if (DECL_DEFINED_IN_CLASS_P (r
))
4900 check_static_variable_definition (r
, TREE_TYPE (r
));
4903 /* R will have a TREE_CHAIN if and only if it has already been
4904 processed by finish_member_declaration. This can happen
4905 if, for example, it is a TYPE_DECL for a class-scoped
4906 ENUMERAL_TYPE; such a thing will already have been added to
4907 the field list by tsubst_enum above. */
4908 if (!TREE_CHAIN (r
))
4910 set_current_access_from_decl (r
);
4911 finish_member_declaration (r
);
4915 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
4916 for this instantiation. */
4917 for (t
= TYPE_METHODS (pattern
); t
; t
= TREE_CHAIN (t
))
4919 tree r
= tsubst (t
, args
, /*complain=*/1, NULL_TREE
);
4920 set_current_access_from_decl (r
);
4921 finish_member_declaration (r
);
4924 /* Construct the DECL_FRIENDLIST for the new class type. */
4925 typedecl
= TYPE_MAIN_DECL (type
);
4926 for (t
= DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern
));
4932 DECL_FRIENDLIST (typedecl
)
4933 = tree_cons (TREE_PURPOSE (t
), NULL_TREE
,
4934 DECL_FRIENDLIST (typedecl
));
4936 for (friends
= TREE_VALUE (t
);
4937 friends
!= NULL_TREE
;
4938 friends
= TREE_CHAIN (friends
))
4940 if (TREE_PURPOSE (friends
) == error_mark_node
)
4942 TREE_VALUE (DECL_FRIENDLIST (typedecl
))
4943 = tree_cons (error_mark_node
,
4944 tsubst_friend_function (TREE_VALUE (friends
),
4946 TREE_VALUE (DECL_FRIENDLIST (typedecl
)));
4950 TREE_VALUE (DECL_FRIENDLIST (typedecl
))
4951 = tree_cons (tsubst (TREE_PURPOSE (friends
), args
,
4952 /*complain=*/1, NULL_TREE
),
4954 TREE_VALUE (DECL_FRIENDLIST (typedecl
)));
4960 for (t
= CLASSTYPE_FRIEND_CLASSES (pattern
);
4964 tree friend_type
= TREE_VALUE (t
);
4965 tree new_friend_type
;
4967 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4968 new_friend_type
= tsubst_friend_class (friend_type
, args
);
4969 else if (uses_template_parms (friend_type
))
4970 new_friend_type
= tsubst (friend_type
, args
, /*complain=*/1,
4973 /* The call to xref_tag_from_type does injection for friend
4976 xref_tag_from_type (friend_type
, NULL_TREE
, 1);
4979 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4980 /* Trick make_friend_class into realizing that the friend
4981 we're adding is a template, not an ordinary class. It's
4982 important that we use make_friend_class since it will
4983 perform some error-checking and output cross-reference
4985 ++processing_template_decl
;
4987 make_friend_class (type
, new_friend_type
);
4989 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
4990 --processing_template_decl
;
4993 /* This does injection for friend functions. */
4994 if (!processing_template_decl
)
4996 t
= tsubst (DECL_TEMPLATE_INJECT (template), args
,
4997 /*complain=*/1, NULL_TREE
);
4999 for (; t
; t
= TREE_CHAIN (t
))
5001 tree d
= TREE_VALUE (t
);
5003 if (TREE_CODE (d
) == TYPE_DECL
)
5004 /* Already injected. */;
5010 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
5011 if (TREE_CODE (t
) == FIELD_DECL
)
5013 TREE_TYPE (t
) = complete_type (TREE_TYPE (t
));
5014 require_complete_type (t
);
5017 /* Set the file and line number information to whatever is given for
5018 the class itself. This puts error messages involving generated
5019 implicit functions at a predictable point, and the same point
5020 that would be used for non-template classes. */
5021 lineno
= DECL_SOURCE_LINE (typedecl
);
5022 input_filename
= DECL_SOURCE_FILE (typedecl
);
5024 unreverse_member_declarations (type
);
5025 type
= finish_struct_1 (type
, 0);
5026 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
5028 /* Clear this now so repo_template_used is happy. */
5029 TYPE_BEING_DEFINED (type
) = 0;
5030 repo_template_used (type
);
5033 pop_from_top_level ();
5046 if (t1
== NULL_TREE
)
5047 return t2
== NULL_TREE
;
5048 if (t2
== NULL_TREE
)
5050 /* Don't care if one declares its arg const and the other doesn't -- the
5051 main variant of the arg type is all that matters. */
5052 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1
))
5053 != TYPE_MAIN_VARIANT (TREE_VALUE (t2
)))
5055 return list_eq (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
5058 /* If arg is a non-type template parameter that does not depend on template
5059 arguments, fold it like we weren't in the body of a template. */
5062 maybe_fold_nontype_arg (arg
)
5065 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
5066 && !uses_template_parms (arg
))
5068 /* Sometimes, one of the args was an expression involving a
5069 template constant parameter, like N - 1. Now that we've
5070 tsubst'd, we might have something like 2 - 1. This will
5071 confuse lookup_template_class, so we do constant folding
5072 here. We have to unset processing_template_decl, to
5073 fool build_expr_from_tree() into building an actual
5076 int saved_processing_template_decl
= processing_template_decl
;
5077 processing_template_decl
= 0;
5078 arg
= fold (build_expr_from_tree (arg
));
5079 processing_template_decl
= saved_processing_template_decl
;
5084 /* Return the TREE_VEC with the arguments for the innermost template header,
5085 where ARGS is either that or the VEC of VECs for all the
5089 innermost_args (args
)
5092 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
5095 /* Substitute ARGS into the vector of template arguments T. */
5098 tsubst_template_arg_vector (t
, args
, complain
)
5103 int len
= TREE_VEC_LENGTH (t
), need_new
= 0, i
;
5104 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
5106 bzero ((char *) elts
, len
* sizeof (tree
));
5108 for (i
= 0; i
< len
; i
++)
5110 if (TREE_VEC_ELT (t
, i
) != NULL_TREE
5111 && TREE_CODE (TREE_VEC_ELT (t
, i
)) == TREE_VEC
)
5112 elts
[i
] = tsubst_template_arg_vector (TREE_VEC_ELT (t
, i
),
5115 elts
[i
] = maybe_fold_nontype_arg
5116 (tsubst_expr (TREE_VEC_ELT (t
, i
), args
, complain
,
5119 if (elts
[i
] != TREE_VEC_ELT (t
, i
))
5126 t
= make_temp_vec (len
);
5127 for (i
= 0; i
< len
; i
++)
5128 TREE_VEC_ELT (t
, i
) = elts
[i
];
5133 /* Return the result of substituting ARGS into the template parameters
5134 given by PARMS. If there are m levels of ARGS and m + n levels of
5135 PARMS, then the result will contain n levels of PARMS. For
5136 example, if PARMS is `template <class T> template <class U>
5137 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5138 result will be `template <int*, double, class V>'. */
5141 tsubst_template_parms (parms
, args
, complain
)
5147 tree
* new_parms
= &r
;
5149 for (new_parms
= &r
;
5150 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
5151 new_parms
= &(TREE_CHAIN (*new_parms
)),
5152 parms
= TREE_CHAIN (parms
))
5155 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
5158 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
5160 tree default_value
=
5161 TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5163 TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5165 TREE_VEC_ELT (new_vec
, i
)
5166 = build_tree_list (tsubst (default_value
, args
, complain
,
5168 tsubst (parm_decl
, args
, complain
,
5173 tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms
)
5174 - TMPL_ARGS_DEPTH (args
))),
5175 new_vec
, NULL_TREE
);
5181 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5182 type T. If T is not an aggregate or enumeration type, it is
5183 handled as if by tsubst. IN_DECL is as for tsubst. If
5184 ENTERING_SCOPE is non-zero, T is the context for a template which
5185 we are presently tsubst'ing. Return the subsituted value. */
5188 tsubst_aggr_type (t
, args
, complain
, in_decl
, entering_scope
)
5198 switch (TREE_CODE (t
))
5201 if (TYPE_PTRMEMFUNC_P (t
))
5203 tree r
= build_ptrmemfunc_type
5204 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
));
5205 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5208 /* else fall through */
5211 if (TYPE_TEMPLATE_INFO (t
))
5217 /* First, determine the context for the type we are looking
5219 if (TYPE_CONTEXT (t
) != NULL_TREE
)
5220 context
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
,
5222 in_decl
, /*entering_scope=*/1);
5224 context
= NULL_TREE
;
5226 /* Then, figure out what arguments are appropriate for the
5227 type we are trying to find. For example, given:
5229 template <class T> struct S;
5230 template <class T, class U> void f(T, U) { S<U> su; }
5232 and supposing that we are instantiating f<int, double>,
5233 then our ARGS will be {int, double}, but, when looking up
5234 S we only want {double}. */
5236 argvec
= tsubst_template_arg_vector (TYPE_TI_ARGS (t
), args
,
5239 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
5243 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
5246 /* This is not a template type, so there's nothing to do. */
5250 return tsubst (t
, args
, complain
, in_decl
);
5254 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5255 (already computed) substitution of ARGS into TREE_TYPE (T), if
5256 appropriate. Return the result of the substitution. IN_DECL is as
5260 tsubst_decl (t
, args
, type
, in_decl
)
5267 char* saved_filename
;
5270 /* Set the filename and linenumber to improve error-reporting. */
5271 saved_lineno
= lineno
;
5272 saved_filename
= input_filename
;
5273 lineno
= DECL_SOURCE_LINE (t
);
5274 input_filename
= DECL_SOURCE_FILE (t
);
5276 switch (TREE_CODE (t
))
5280 /* We can get here when processing a member template function
5281 of a template class. */
5282 tree decl
= DECL_TEMPLATE_RESULT (t
);
5284 int is_template_template_parm
= DECL_TEMPLATE_TEMPLATE_PARM_P (t
);
5286 if (!is_template_template_parm
)
5288 /* We might already have an instance of this template.
5289 The ARGS are for the surrounding class type, so the
5290 full args contain the tsubst'd args for the context,
5291 plus the innermost args from the template decl. */
5292 tree tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
5293 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
5294 : DECL_TI_ARGS (DECL_RESULT (t
));
5298 full_args
= tsubst_template_arg_vector (tmpl_args
, args
,
5301 /* tsubst_template_arg_vector doesn't copy the vector if
5302 nothing changed. But, *something* should have
5304 my_friendly_assert (full_args
!= tmpl_args
, 0);
5306 spec
= retrieve_specialization (t
, full_args
);
5308 if (spec
!= NULL_TREE
)
5315 /* Make a new template decl. It will be similar to the
5316 original, but will record the current template arguments.
5317 We also create a new function declaration, which is just
5318 like the old one, but points to this new template, rather
5319 than the old one. */
5322 my_friendly_assert (DECL_LANG_SPECIFIC (r
) != 0, 0);
5323 TREE_CHAIN (r
) = NULL_TREE
;
5325 if (is_template_template_parm
)
5327 tree new_decl
= tsubst (decl
, args
, /*complain=*/1, in_decl
);
5328 DECL_RESULT (r
) = new_decl
;
5329 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5334 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, /*complain=*/1,
5335 in_decl
, /*entering_scope=*/1);
5336 DECL_CLASS_CONTEXT (r
)
5337 = tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
,
5338 /*complain=*/1, in_decl
,
5339 /*entering_scope=*/1);
5340 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
5342 if (TREE_CODE (decl
) == TYPE_DECL
)
5344 tree new_type
= tsubst (TREE_TYPE (t
), args
,
5345 /*complain=*/1, in_decl
);
5346 TREE_TYPE (r
) = new_type
;
5347 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
5348 DECL_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
5349 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
5353 tree new_decl
= tsubst (decl
, args
, /*complain=*/1, in_decl
);
5354 DECL_RESULT (r
) = new_decl
;
5355 DECL_TI_TEMPLATE (new_decl
) = r
;
5356 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5357 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
5360 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5361 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
5362 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
5364 /* The template parameters for this new template are all the
5365 template parameters for the old template, except the
5366 outermost level of parameters. */
5367 DECL_TEMPLATE_PARMS (r
)
5368 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
5371 if (PRIMARY_TEMPLATE_P (t
))
5372 DECL_PRIMARY_TEMPLATE (r
) = r
;
5374 /* We don't partially instantiate partial specializations. */
5375 if (TREE_CODE (decl
) == TYPE_DECL
)
5378 for (spec
= DECL_TEMPLATE_SPECIALIZATIONS (t
);
5380 spec
= TREE_CHAIN (spec
))
5382 /* It helps to consider example here. Consider:
5393 Now, for example, we are instantiating S<int>::f(U u).
5394 We want to make a template:
5399 It will have a specialization, for the case U = int*, of
5403 void S<int>::f<int*>(int*);
5405 This specialization will be an instantiation of
5406 the specialization given in the declaration of S, with
5407 argument list int*. */
5409 tree fn
= TREE_VALUE (spec
);
5413 if (!DECL_TEMPLATE_SPECIALIZATION (fn
))
5414 /* Instantiations are on the same list, but they're of
5415 no concern to us. */
5418 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
5419 /* A full specialization. There's no need to record
5423 spec_args
= tsubst (DECL_TI_ARGS (fn
), args
,
5424 /*complain=*/1, in_decl
);
5425 new_fn
= tsubst (DECL_RESULT (most_general_template (fn
)),
5426 spec_args
, /*complain=*/1, in_decl
);
5427 DECL_TI_TEMPLATE (new_fn
) = fn
;
5428 register_specialization (new_fn
, r
,
5429 innermost_args (spec_args
));
5432 /* Record this partial instantiation. */
5433 register_specialization (r
, t
,
5434 DECL_TI_ARGS (DECL_RESULT (r
)));
5442 tree argvec
= NULL_TREE
;
5448 /* Nobody should be tsubst'ing into non-template functions. */
5449 my_friendly_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5451 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
5455 /* Allocate template arguments on the momentary obstack,
5456 in case we don't need to keep them. */
5459 /* Calculate the most general template of which R is a
5460 specialization, and the complete set of arguments used to
5462 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
5464 = tsubst_template_arg_vector (DECL_TI_ARGS
5465 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
5466 args
, /*complain=*/1);
5468 /* Check to see if we already have this specialization. */
5469 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5478 /* We're going to need to keep the ARGVEC, so we copy it
5480 argvec
= copy_to_permanent (argvec
);
5483 /* Here, we deal with the peculiar case:
5485 template <class T> struct S {
5486 template <class U> friend void f();
5488 template <class U> friend void f() {}
5490 template void f<double>();
5492 Here, the ARGS for the instantiation of will be {int,
5493 double}. But, we only need as many ARGS as there are
5494 levels of template parameters in CODE_PATTERN. We are
5495 careful not to get fooled into reducing the ARGS in
5498 template <class T> struct S { template <class U> void f(U); }
5499 template <class T> template <> void S<T>::f(int) {}
5501 which we can spot because the pattern will be a
5502 specialization in this case. */
5503 args_depth
= TMPL_ARGS_DEPTH (args
);
5505 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
5506 if (args_depth
> parms_depth
5507 && !DECL_TEMPLATE_SPECIALIZATION (t
))
5509 my_friendly_assert (DECL_FRIEND_P (t
), 0);
5511 if (parms_depth
> 1)
5515 args
= make_temp_vec (parms_depth
);
5516 for (i
= 0; i
< parms_depth
; ++i
)
5517 TREE_VEC_ELT (args
, i
) =
5518 TREE_VEC_ELT (args
, i
+ (args_depth
- parms_depth
));
5521 args
= TREE_VEC_ELT (args
, args_depth
- parms_depth
);
5526 /* This special case arises when we have something like this:
5528 template <class T> struct S {
5529 friend void f<int>(int, double);
5532 Here, the DECL_TI_TEMPLATE for the friend declaration
5533 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5534 being called from tsubst_friend_function, and we want
5535 only to create a new decl (R) with appropriate types so
5536 that we can call determine_specialization. */
5537 my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t
))
5539 || (TREE_CODE (DECL_TI_TEMPLATE (t
))
5540 == IDENTIFIER_NODE
), 0);
5541 gen_tmpl
= NULL_TREE
;
5544 if (DECL_CLASS_SCOPE_P (t
))
5546 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
5550 ctx
= tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
,
5552 /*entering_scope=*/1);
5559 type
= tsubst (type
, args
, /*complain=*/1, in_decl
);
5561 /* We do NOT check for matching decls pushed separately at this
5562 point, as they may not represent instantiations of this
5563 template, and in any case are considered separate under the
5564 discrete model. Instead, see add_maybe_template. */
5568 DECL_USE_TEMPLATE (r
) = 0;
5569 TREE_TYPE (r
) = type
;
5572 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, /*complain=*/1, t
,
5573 /*entering_scope=*/1);
5574 DECL_CLASS_CONTEXT (r
) = ctx
;
5576 if (member
&& IDENTIFIER_TYPENAME_P (DECL_NAME (r
)))
5577 /* Type-conversion operator. Reconstruct the name, in
5578 case it's the name of one of the template's parameters. */
5579 DECL_NAME (r
) = build_typename_overload (TREE_TYPE (type
));
5581 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
5583 DECL_MAIN_VARIANT (r
) = r
;
5584 DECL_RESULT (r
) = NULL_TREE
;
5586 TREE_STATIC (r
) = 0;
5587 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
5588 DECL_EXTERNAL (r
) = 1;
5589 DECL_INTERFACE_KNOWN (r
) = 0;
5590 DECL_DEFER_OUTPUT (r
) = 0;
5591 TREE_CHAIN (r
) = NULL_TREE
;
5592 DECL_PENDING_INLINE_INFO (r
) = 0;
5595 /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
5596 name. There's no need to do this in the special friend
5597 case mentioned above where GEN_TMPL is NULL. */
5600 /* The ARGVEC was built on the momentary obstack. Make it
5602 argvec
= copy_to_permanent (argvec
);
5603 DECL_TEMPLATE_INFO (r
)
5604 = perm_tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
5605 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5606 register_specialization (r
, gen_tmpl
, argvec
);
5608 /* Set the mangled name for R. */
5609 if (DECL_DESTRUCTOR_P (t
))
5610 DECL_ASSEMBLER_NAME (r
) = build_destructor_name (ctx
);
5613 /* Instantiations of template functions must be mangled
5614 specially, in order to conform to 14.5.5.1
5615 [temp.over.link]. */
5616 tree tmpl
= DECL_TI_TEMPLATE (t
);
5618 /* TMPL will be NULL if this is a specialization of a
5619 member function of a template class. */
5620 if (name_mangling_version
< 1
5621 || tmpl
== NULL_TREE
5622 || (member
&& !is_member_template (tmpl
)
5623 && !DECL_TEMPLATE_INFO (tmpl
)))
5624 set_mangled_name_for_decl (r
);
5626 set_mangled_name_for_template_decl (r
);
5630 make_decl_rtl (r
, NULL_PTR
, 1);
5632 /* Like grokfndecl. If we don't do this, pushdecl will
5633 mess up our TREE_CHAIN because it doesn't find a
5634 previous decl. Sigh. */
5636 && ! uses_template_parms (r
)
5637 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
))
5639 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
), r
);
5642 if (DECL_CONSTRUCTOR_P (r
))
5644 maybe_retrofit_in_chrg (r
);
5645 grok_ctor_properties (ctx
, r
);
5647 if (IDENTIFIER_OPNAME_P (DECL_NAME (r
)))
5648 grok_op_properties (r
, DECL_VIRTUAL_P (r
), DECL_FRIEND_P (r
));
5655 TREE_TYPE (r
) = type
;
5656 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
5657 DECL_INITIAL (r
) = TREE_TYPE (r
);
5659 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
5660 /*complain=*/1, in_decl
);
5662 DECL_CONTEXT (r
) = NULL_TREE
;
5663 #ifdef PROMOTE_PROTOTYPES
5664 if ((TREE_CODE (type
) == INTEGER_TYPE
5665 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5666 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
5667 DECL_ARG_TYPE (r
) = integer_type_node
;
5670 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
,
5671 /*complain=*/1, TREE_CHAIN (t
));
5678 TREE_TYPE (r
) = type
;
5681 DECL_FIELD_CONTEXT (r
) = tsubst (DECL_FIELD_CONTEXT (t
), args
,
5682 /*complain=*/1, in_decl
);
5684 DECL_INITIAL (r
) = tsubst_expr (DECL_INITIAL (t
), args
,
5685 /*complain=*/1, in_decl
);
5686 TREE_CHAIN (r
) = NULL_TREE
;
5687 if (TREE_CODE (type
) == VOID_TYPE
)
5688 cp_error_at ("instantiation of `%D' as type void", r
);
5696 = tsubst_copy (DECL_INITIAL (t
), args
, /*complain=*/1, in_decl
);
5697 TREE_CHAIN (r
) = NULL_TREE
;
5707 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
5709 in_decl
, /*entering_scope=*/1);
5711 /* Nobody should be tsubst'ing into non-template variables. */
5712 my_friendly_assert (DECL_LANG_SPECIFIC (t
)
5713 && DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5715 /* Check to see if we already have this specialization. */
5716 tmpl
= DECL_TI_TEMPLATE (t
);
5717 gen_tmpl
= most_general_template (tmpl
);
5718 argvec
= tsubst (DECL_TI_ARGS (t
), args
, /*complain=*/1, in_decl
);
5719 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5728 TREE_TYPE (r
) = type
;
5729 DECL_CONTEXT (r
) = ctx
;
5730 if (TREE_STATIC (r
))
5731 DECL_ASSEMBLER_NAME (r
)
5732 = build_static_name (DECL_CONTEXT (r
), DECL_NAME (r
));
5734 /* Don't try to expand the initializer until someone tries to use
5735 this variable; otherwise we run into circular dependencies. */
5736 DECL_INITIAL (r
) = NULL_TREE
;
5740 DECL_CLASS_CONTEXT (r
) = DECL_CONTEXT (r
);
5742 DECL_TEMPLATE_INFO (r
) = perm_tree_cons (tmpl
, argvec
, NULL_TREE
);
5743 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5744 register_specialization (r
, gen_tmpl
, argvec
);
5746 TREE_CHAIN (r
) = NULL_TREE
;
5747 if (TREE_CODE (type
) == VOID_TYPE
)
5748 cp_error_at ("instantiation of `%D' as type void", r
);
5753 if (t
== TYPE_NAME (TREE_TYPE (t
)))
5754 r
= TYPE_NAME (type
);
5758 TREE_TYPE (r
) = type
;
5759 DECL_CONTEXT (r
) = current_class_type
;
5760 TREE_CHAIN (r
) = NULL_TREE
;
5765 my_friendly_abort (0);
5768 /* Restore the file and line information. */
5769 lineno
= saved_lineno
;
5770 input_filename
= saved_filename
;
5775 /* Substitue into the ARG_TYPES of a function type. */
5778 tsubst_arg_types (arg_types
, args
, complain
, in_decl
)
5784 tree remaining_arg_types
;
5787 if (!arg_types
|| arg_types
== void_list_node
)
5790 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
5791 args
, complain
, in_decl
);
5792 if (remaining_arg_types
== error_mark_node
)
5793 return error_mark_node
;
5795 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
5796 if (type
== error_mark_node
)
5797 return error_mark_node
;
5799 /* Do array-to-pointer, function-to-pointer conversion, and ignore
5800 top-level qualifiers as required. */
5801 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
5803 /* Note that we do not substitute into default arguments here. The
5804 standard mandates that they be instantiated only when needed,
5805 which is done in build_over_call. */
5806 return hash_tree_cons_simple (TREE_PURPOSE (arg_types
), type
,
5807 remaining_arg_types
);
5811 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
5812 *not* handle the exception-specification for FNTYPE, because the
5813 initial substitution of explicitly provided template parameters
5814 during argument deduction forbids substitution into the
5815 exception-specification:
5819 All references in the function type of the function template to the
5820 corresponding template parameters are replaced by the specified tem-
5821 plate argument values. If a substitution in a template parameter or
5822 in the function type of the function template results in an invalid
5823 type, type deduction fails. [Note: The equivalent substitution in
5824 exception specifications is done only when the function is instanti-
5825 ated, at which point a program is ill-formed if the substitution
5826 results in an invalid type.] */
5829 tsubst_function_type (t
, args
, complain
, in_decl
)
5839 /* The TYPE_CONTEXT is not used for function/method types. */
5840 my_friendly_assert (TYPE_CONTEXT (t
) == NULL_TREE
, 0);
5842 /* Substitue the return type. */
5843 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
5844 if (return_type
== error_mark_node
)
5845 return error_mark_node
;
5847 /* Substitue the argument types. */
5848 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
,
5850 if (arg_types
== error_mark_node
)
5851 return error_mark_node
;
5853 /* Construct a new type node and return it. */
5854 if (TREE_CODE (t
) == FUNCTION_TYPE
)
5855 fntype
= build_function_type (return_type
, arg_types
);
5858 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
5859 if (! IS_AGGR_TYPE (r
))
5863 Type deduction may fail for any of the following
5866 -- Attempting to create "pointer to member of T" when T
5867 is not a class type. */
5869 cp_error ("creating pointer to member function of non-class type `%T'",
5871 return error_mark_node
;
5874 fntype
= build_cplus_method_type (r
, return_type
, TREE_CHAIN
5877 fntype
= build_qualified_type (fntype
, TYPE_QUALS (t
));
5882 /* Substitute into the PARMS of a call-declarator. */
5885 tsubst_call_declarator_parms (parms
, args
, complain
, in_decl
)
5895 if (!parms
|| parms
== void_list_node
)
5898 new_parms
= tsubst_call_declarator_parms (TREE_CHAIN (parms
),
5899 args
, complain
, in_decl
);
5901 /* Figure out the type of this parameter. */
5902 type
= tsubst (TREE_VALUE (parms
), args
, complain
, in_decl
);
5904 /* Figure out the default argument as well. Note that we use
5905 tsubst_expr since the default argument is really an expression. */
5906 defarg
= tsubst_expr (TREE_PURPOSE (parms
), args
, complain
, in_decl
);
5908 /* Chain this parameter on to the front of those we have already
5909 processed. We don't use hash_tree_cons because that function
5910 doesn't check TREE_PARMLIST. */
5911 new_parms
= tree_cons (defarg
, type
, new_parms
);
5913 /* And note that these are parameters. */
5914 TREE_PARMLIST (new_parms
) = 1;
5919 /* Take the tree structure T and replace template parameters used
5920 therein with the argument vector ARGS. IN_DECL is an associated
5921 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
5922 An appropriate error message is issued only if COMPLAIN is
5923 non-zero. Note that we must be relatively non-tolerant of
5924 extensions here, in order to preserve conformance; if we allow
5925 substitutions that should not be allowed, we may allow argument
5926 deductions that should not succeed, and therefore report ambiguous
5927 overload situations where there are none. In theory, we could
5928 allow the substitution, but indicate that it should have failed,
5929 and allow our caller to make sure that the right thing happens, but
5930 we don't try to do this yet.
5932 This function is used for dealing with types, decls and the like;
5933 for expressions, use tsubst_expr or tsubst_copy. */
5936 tsubst (t
, args
, complain
, in_decl
)
5943 if (t
== NULL_TREE
|| t
== error_mark_node
5944 || t
== integer_type_node
5945 || t
== void_type_node
5946 || t
== char_type_node
5947 || TREE_CODE (t
) == NAMESPACE_DECL
)
5950 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
5951 type
= IDENTIFIER_TYPE_VALUE (t
);
5953 type
= TREE_TYPE (t
);
5954 if (type
== unknown_type_node
)
5955 my_friendly_abort (42);
5957 if (type
&& TREE_CODE (t
) != FUNCTION_DECL
5958 && TREE_CODE (t
) != TYPENAME_TYPE
5959 && TREE_CODE (t
) != TEMPLATE_DECL
5960 && TREE_CODE (t
) != IDENTIFIER_NODE
5961 && TREE_CODE (t
) != FUNCTION_TYPE
5962 && TREE_CODE (t
) != METHOD_TYPE
)
5963 type
= tsubst (type
, args
, complain
, in_decl
);
5964 if (type
== error_mark_node
)
5965 return error_mark_node
;
5967 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'd')
5968 return tsubst_decl (t
, args
, type
, in_decl
);
5970 switch (TREE_CODE (t
))
5975 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
5976 /*entering_scope=*/0);
5979 case IDENTIFIER_NODE
:
5991 if (t
== integer_type_node
)
5994 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
5995 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
5999 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
6001 max
= tsubst_expr (omax
, args
, complain
, in_decl
);
6002 if (max
== error_mark_node
)
6003 return error_mark_node
;
6005 if (processing_template_decl
)
6007 tree itype
= make_node (INTEGER_TYPE
);
6008 TYPE_MIN_VALUE (itype
) = size_zero_node
;
6009 TYPE_MAX_VALUE (itype
) = build_min (MINUS_EXPR
, sizetype
, max
,
6014 if (integer_zerop (omax
))
6016 /* Still allow an explicit array of size zero. */
6018 pedwarn ("creating array with size zero");
6020 else if (integer_zerop (max
) || INT_CST_LT (max
, integer_zero_node
))
6024 Type deduction may fail for any of the following
6027 Attempting to create an array with a size that is
6028 zero or negative. */
6030 cp_error ("creating array with size `%E'", max
);
6032 return error_mark_node
;
6035 max
= fold (build_binary_op (MINUS_EXPR
, max
, integer_one_node
, 1));
6036 if (!TREE_PERMANENT (max
) && !allocation_temporary_p ())
6037 max
= copy_to_permanent (max
);
6038 return build_index_type (max
);
6041 case TEMPLATE_TYPE_PARM
:
6042 case TEMPLATE_TEMPLATE_PARM
:
6043 case TEMPLATE_PARM_INDEX
:
6051 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
6052 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
6054 idx
= TEMPLATE_TYPE_IDX (t
);
6055 level
= TEMPLATE_TYPE_LEVEL (t
);
6059 idx
= TEMPLATE_PARM_IDX (t
);
6060 level
= TEMPLATE_PARM_LEVEL (t
);
6063 if (TREE_VEC_LENGTH (args
) > 0)
6065 tree arg
= NULL_TREE
;
6067 levels
= TMPL_ARGS_DEPTH (args
);
6068 if (level
<= levels
)
6069 arg
= TMPL_ARG (args
, level
, idx
);
6071 if (arg
== error_mark_node
)
6072 return error_mark_node
;
6073 else if (arg
!= NULL_TREE
)
6075 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
6077 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg
))
6079 return cp_build_qualified_type
6080 (arg
, CP_TYPE_QUALS (arg
) | CP_TYPE_QUALS (t
));
6082 else if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
6084 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
6086 /* We are processing a type constructed from
6087 a template template parameter */
6088 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
6089 args
, complain
, in_decl
);
6090 if (argvec
== error_mark_node
)
6091 return error_mark_node
;
6093 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6094 we are resolving nested-types in the signature of
6095 a member function templates.
6096 Otherwise ARG is a TEMPLATE_DECL and is the real
6097 template to be instantiated. */
6098 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
6099 arg
= TYPE_NAME (arg
);
6101 r
= lookup_template_class (DECL_NAME (arg
),
6104 /*entering_scope=*/0);
6105 return cp_build_qualified_type (r
, TYPE_QUALS (t
));
6108 /* We are processing a template argument list. */
6116 my_friendly_abort (981018);
6119 /* This can happen during the attempted tsubst'ing in
6120 unify. This means that we don't yet have any information
6121 about the template parameter in question. */
6124 /* If we get here, we must have been looking at a parm for a
6125 more deeply nested template. Make a new version of this
6126 template parameter, but with a lower level. */
6127 switch (TREE_CODE (t
))
6129 case TEMPLATE_TYPE_PARM
:
6130 case TEMPLATE_TEMPLATE_PARM
:
6132 TEMPLATE_TYPE_PARM_INDEX (r
)
6133 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
6135 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
6136 TYPE_MAIN_VARIANT (r
) = r
;
6137 TYPE_POINTER_TO (r
) = NULL_TREE
;
6138 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
6140 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
6141 && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
6143 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
6145 if (argvec
== error_mark_node
)
6146 return error_mark_node
;
6148 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
6149 = perm_tree_cons (TYPE_NAME (t
), argvec
, NULL_TREE
);
6153 case TEMPLATE_PARM_INDEX
:
6154 r
= reduce_template_parm_level (t
, type
, levels
);
6158 my_friendly_abort (0);
6166 tree purpose
, value
, chain
, result
;
6167 int via_public
, via_virtual
, via_protected
;
6169 if (t
== void_list_node
)
6172 via_public
= TREE_VIA_PUBLIC (t
);
6173 via_protected
= TREE_VIA_PROTECTED (t
);
6174 via_virtual
= TREE_VIA_VIRTUAL (t
);
6176 purpose
= TREE_PURPOSE (t
);
6179 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
6180 if (purpose
== error_mark_node
)
6181 return error_mark_node
;
6183 value
= TREE_VALUE (t
);
6186 value
= tsubst (value
, args
, complain
, in_decl
);
6187 if (value
== error_mark_node
)
6188 return error_mark_node
;
6190 chain
= TREE_CHAIN (t
);
6191 if (chain
&& chain
!= void_type_node
)
6193 chain
= tsubst (chain
, args
, complain
, in_decl
);
6194 if (chain
== error_mark_node
)
6195 return error_mark_node
;
6197 if (purpose
== TREE_PURPOSE (t
)
6198 && value
== TREE_VALUE (t
)
6199 && chain
== TREE_CHAIN (t
))
6201 result
= hash_tree_cons (via_public
, via_virtual
, via_protected
,
6202 purpose
, value
, chain
);
6203 TREE_PARMLIST (result
) = TREE_PARMLIST (t
);
6207 if (type
!= NULL_TREE
)
6209 /* A binfo node. We always need to make a copy, of the node
6210 itself and of its BINFO_BASETYPES. */
6214 /* Make sure type isn't a typedef copy. */
6215 type
= BINFO_TYPE (TYPE_BINFO (type
));
6217 TREE_TYPE (t
) = complete_type (type
);
6218 if (IS_AGGR_TYPE (type
))
6220 BINFO_VTABLE (t
) = TYPE_BINFO_VTABLE (type
);
6221 BINFO_VIRTUALS (t
) = TYPE_BINFO_VIRTUALS (type
);
6222 if (TYPE_BINFO_BASETYPES (type
) != NULL_TREE
)
6223 BINFO_BASETYPES (t
) = copy_node (TYPE_BINFO_BASETYPES (type
));
6228 /* Otherwise, a vector of template arguments. */
6229 return tsubst_template_arg_vector (t
, args
, complain
);
6232 case REFERENCE_TYPE
:
6234 enum tree_code code
;
6236 if (type
== TREE_TYPE (t
))
6239 code
= TREE_CODE (t
);
6244 Type deduction may fail for any of the following
6247 -- Attempting to create a pointer to reference type.
6248 -- Attempting to create a reference to a reference type or
6249 a reference to void. */
6250 if (TREE_CODE (type
) == REFERENCE_TYPE
6251 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
6253 static int last_line
= 0;
6254 static char* last_file
= 0;
6256 /* We keep track of the last time we issued this error
6257 message to avoid spewing a ton of messages during a
6258 single bad template instantiation. */
6259 if (complain
&& (last_line
!= lineno
||
6260 last_file
!= input_filename
))
6262 if (TREE_CODE (type
) == VOID_TYPE
)
6263 cp_error ("forming reference to void");
6265 cp_error ("forming %s to reference type `%T'",
6266 (code
== POINTER_TYPE
) ? "pointer" : "reference",
6269 last_file
= input_filename
;
6272 return error_mark_node
;
6274 else if (code
== POINTER_TYPE
)
6275 r
= build_pointer_type (type
);
6277 r
= build_reference_type (type
);
6278 r
= cp_build_qualified_type (r
, TYPE_QUALS (t
));
6280 /* Will this ever be needed for TYPE_..._TO values? */
6286 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
6287 if (r
== error_mark_node
|| !IS_AGGR_TYPE (r
))
6291 Type deduction may fail for any of the following
6294 -- Attempting to create "pointer to member of T" when T
6295 is not a class type. */
6297 cp_error ("creating pointer to member of non-class type `%T'",
6299 return error_mark_node
;
6301 return build_offset_type (r
, type
);
6309 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
6310 if (fntype
== error_mark_node
)
6311 return error_mark_node
;
6313 /* Substitue the exception specification. */
6314 raises
= TYPE_RAISES_EXCEPTIONS (t
);
6317 raises
= tsubst (raises
, args
, complain
, in_decl
);
6318 if (raises
== error_mark_node
)
6320 fntype
= build_exception_variant (fntype
, raises
);
6326 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
6327 if (domain
== error_mark_node
)
6328 return error_mark_node
;
6330 /* As an optimization, we avoid regenerating the array type if
6331 it will obviously be the same as T. */
6332 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
6335 /* These checks should match the ones in grokdeclarator.
6339 The deduction may fail for any of the following reasons:
6341 -- Attempting to create an array with an element type that
6342 is void, a function type, or a reference type. */
6343 if (TREE_CODE (type
) == VOID_TYPE
6344 || TREE_CODE (type
) == FUNCTION_TYPE
6345 || TREE_CODE (type
) == REFERENCE_TYPE
)
6348 cp_error ("creating array of `%T'", type
);
6349 return error_mark_node
;
6352 r
= build_cplus_array_type (type
, domain
);
6359 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6361 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
,
6364 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6365 return error_mark_node
;
6367 return fold (build (TREE_CODE (t
), TREE_TYPE (t
), e1
, e2
));
6373 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6375 if (e
== error_mark_node
)
6376 return error_mark_node
;
6378 return fold (build (TREE_CODE (t
), TREE_TYPE (t
), e
));
6383 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
6384 in_decl
, /*entering_scope=*/1);
6385 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
6388 if (ctx
== error_mark_node
|| f
== error_mark_node
)
6389 return error_mark_node
;
6391 if (!IS_AGGR_TYPE (ctx
))
6394 cp_error ("`%T' is not a class, struct, or union type",
6396 return error_mark_node
;
6398 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
6400 /* Normally, make_typename_type does not require that the CTX
6401 have complete type in order to allow things like:
6403 template <class T> struct S { typename S<T>::X Y; };
6405 But, such constructs have already been resolved by this
6406 point, so here CTX really should have complete type, unless
6407 it's a partial instantiation. */
6408 ctx
= complete_type (ctx
);
6409 if (!TYPE_SIZE (ctx
))
6412 incomplete_type_error (NULL_TREE
, ctx
);
6413 return error_mark_node
;
6417 f
= make_typename_type (ctx
, f
);
6418 return cp_build_qualified_type (f
,
6420 | CP_TYPE_QUALS (t
));
6425 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6427 if (e
== error_mark_node
)
6428 return error_mark_node
;
6429 return make_pointer_declarator (type
, e
);
6434 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6436 if (e
== error_mark_node
)
6437 return error_mark_node
;
6438 return make_reference_declarator (type
, e
);
6443 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6445 tree e2
= tsubst_expr (TREE_OPERAND (t
, 1), args
, complain
,
6447 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6448 return error_mark_node
;
6450 return build_parse_node (ARRAY_REF
, e1
, e2
, tsubst_expr
);
6455 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6457 tree e2
= tsubst_call_declarator_parms (TREE_OPERAND (t
, 1), args
,
6459 tree e3
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
6461 if (e1
== error_mark_node
|| e2
== error_mark_node
6462 || e3
== error_mark_node
)
6463 return error_mark_node
;
6465 return make_call_declarator (e1
, e2
, TREE_OPERAND (t
, 2), e3
);
6470 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6472 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
6473 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6474 return error_mark_node
;
6476 return build_parse_node (TREE_CODE (t
), e1
, e2
);
6481 tree e1
= tsubst_expr (TYPE_FIELDS (t
), args
, complain
,
6483 if (e1
== error_mark_node
)
6484 return error_mark_node
;
6486 return TREE_TYPE (e1
);
6490 sorry ("use of `%s' in template",
6491 tree_code_name
[(int) TREE_CODE (t
)]);
6492 return error_mark_node
;
6499 emit_line_note (input_filename
, lineno
);
6503 expand_start_bindings (0);
6510 int saved_warn_unused
= 0;
6512 if (processing_template_decl
)
6514 saved_warn_unused
= warn_unused
;
6517 expand_end_bindings (getdecls (), kept_level_p (), 0);
6518 if (processing_template_decl
)
6519 warn_unused
= saved_warn_unused
;
6520 t
= poplevel (kept_level_p (), 1, 0);
6525 /* Like tsubst, but deals with expressions. This function just replaces
6526 template parms; to finish processing the resultant expression, use
6530 tsubst_copy (t
, args
, complain
, in_decl
)
6535 enum tree_code code
;
6538 if (t
== NULL_TREE
|| t
== error_mark_node
)
6541 code
= TREE_CODE (t
);
6546 return do_identifier (DECL_NAME (t
), 0, NULL_TREE
);
6553 if (!DECL_CONTEXT (t
))
6554 /* This is a global enumeration constant. */
6557 /* Unfortunately, we cannot just call lookup_name here.
6560 template <int I> int f() {
6562 struct S { void g() { E e = a; } };
6565 When we instantiate f<7>::S::g(), say, lookup_name is not
6566 clever enough to find f<7>::a. */
6568 = tsubst_aggr_type (TREE_TYPE (t
), args
, complain
, in_decl
,
6569 /*entering_scope=*/0);
6571 for (v
= TYPE_VALUES (enum_type
);
6574 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
6575 return TREE_VALUE (v
);
6577 /* We didn't find the name. That should never happen; if
6578 name-lookup found it during preliminary parsing, we
6579 should find it again here during instantiation. */
6580 my_friendly_abort (0);
6585 if (DECL_CONTEXT (t
))
6589 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
6590 /*entering_scope=*/1);
6591 if (ctx
!= DECL_CONTEXT (t
))
6592 return lookup_field (ctx
, DECL_NAME (t
), 0, 0);
6598 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
6599 t
= tsubst (t
, args
, complain
, in_decl
);
6604 if (is_member_template (t
))
6605 return tsubst (t
, args
, complain
, in_decl
);
6611 /* We must tsbust into a LOOKUP_EXPR in case the names to
6612 which it refers is a conversion operator; in that case the
6613 name will change. We avoid making unnecessary copies,
6616 tree id
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
6618 if (id
!= TREE_OPERAND (t
, 0))
6620 r
= build_nt (LOOKUP_EXPR
, id
);
6621 LOOKUP_EXPR_GLOBAL (r
) = LOOKUP_EXPR_GLOBAL (t
);
6629 case REINTERPRET_CAST_EXPR
:
6630 case CONST_CAST_EXPR
:
6631 case STATIC_CAST_EXPR
:
6632 case DYNAMIC_CAST_EXPR
:
6635 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
6636 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
6639 case PREDECREMENT_EXPR
:
6640 case PREINCREMENT_EXPR
:
6641 case POSTDECREMENT_EXPR
:
6642 case POSTINCREMENT_EXPR
:
6644 case TRUTH_NOT_EXPR
:
6647 case CONVERT_EXPR
: /* Unary + */
6655 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
6660 case TRUNC_DIV_EXPR
:
6662 case FLOOR_DIV_EXPR
:
6663 case ROUND_DIV_EXPR
:
6664 case EXACT_DIV_EXPR
:
6666 case BIT_ANDTC_EXPR
:
6669 case TRUNC_MOD_EXPR
:
6670 case FLOOR_MOD_EXPR
:
6671 case TRUTH_ANDIF_EXPR
:
6672 case TRUTH_ORIF_EXPR
:
6673 case TRUTH_AND_EXPR
:
6694 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6695 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
6699 tree fn
= TREE_OPERAND (t
, 0);
6700 if (is_overloaded_fn (fn
))
6701 fn
= tsubst_copy (get_first_fn (fn
), args
, complain
, in_decl
);
6703 /* Sometimes FN is a LOOKUP_EXPR. */
6704 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
6706 (code
, fn
, tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
,
6711 case METHOD_CALL_EXPR
:
6713 tree name
= TREE_OPERAND (t
, 0);
6714 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
6716 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
6718 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6720 else if (TREE_CODE (name
) == SCOPE_REF
6721 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
6723 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
6725 name
= TREE_OPERAND (name
, 1);
6726 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
6728 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6729 name
= build_nt (SCOPE_REF
, base
, name
);
6732 name
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
6734 (code
, name
, tsubst_copy (TREE_OPERAND (t
, 1), args
,
6736 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
),
6745 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6746 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
6747 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
6749 if (code
== BIND_EXPR
&& !processing_template_decl
)
6751 /* This processing should really occur in tsubst_expr,
6752 However, tsubst_expr does not recurse into expressions,
6753 since it assumes that there aren't any statements
6754 inside them. Instead, it simply calls
6755 build_expr_from_tree. So, we need to expand the
6757 tree rtl_expr
= begin_stmt_expr ();
6758 tree block
= tsubst_expr (TREE_OPERAND (r
, 1), args
,
6760 r
= finish_stmt_expr (rtl_expr
, block
);
6769 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6770 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
6771 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
6772 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
6779 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6780 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
6781 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
6782 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
6786 case TEMPLATE_ID_EXPR
:
6788 /* Substituted template arguments */
6789 tree targs
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
,
6792 for (chain
= targs
; chain
; chain
= TREE_CHAIN (chain
))
6793 TREE_VALUE (chain
) = maybe_fold_nontype_arg (TREE_VALUE (chain
));
6795 return lookup_template_function
6796 (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
), targs
);
6801 tree purpose
, value
, chain
;
6803 if (t
== void_list_node
)
6806 purpose
= TREE_PURPOSE (t
);
6808 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
6809 value
= TREE_VALUE (t
);
6811 value
= tsubst_copy (value
, args
, complain
, in_decl
);
6812 chain
= TREE_CHAIN (t
);
6813 if (chain
&& chain
!= void_type_node
)
6814 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
6815 if (purpose
== TREE_PURPOSE (t
)
6816 && value
== TREE_VALUE (t
)
6817 && chain
== TREE_CHAIN (t
))
6819 return tree_cons (purpose
, value
, chain
);
6826 case TEMPLATE_TYPE_PARM
:
6827 case TEMPLATE_TEMPLATE_PARM
:
6828 case TEMPLATE_PARM_INDEX
:
6830 case REFERENCE_TYPE
:
6837 return tsubst (t
, args
, complain
, in_decl
);
6839 case IDENTIFIER_NODE
:
6840 if (IDENTIFIER_TYPENAME_P (t
)
6841 /* Make sure it's not just a variable named `__opr', for instance,
6842 which can occur in some existing code. */
6844 return build_typename_overload
6845 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
6852 (CONSTRUCTOR
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
6853 NULL_TREE
, tsubst_copy (CONSTRUCTOR_ELTS (t
), args
,
6854 complain
, in_decl
));
6855 TREE_HAS_CONSTRUCTOR (r
) = TREE_HAS_CONSTRUCTOR (t
);
6864 /* Like tsubst_copy, but also does semantic processing and RTL expansion. */
6867 tsubst_expr (t
, args
, complain
, in_decl
)
6872 if (t
== NULL_TREE
|| t
== error_mark_node
)
6875 if (processing_template_decl
)
6876 return tsubst_copy (t
, args
, complain
, in_decl
);
6878 switch (TREE_CODE (t
))
6881 lineno
= TREE_COMPLEXITY (t
);
6882 finish_return_stmt (tsubst_expr (RETURN_EXPR (t
),
6883 args
, complain
, in_decl
));
6887 lineno
= TREE_COMPLEXITY (t
);
6888 finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t
),
6889 args
, complain
, in_decl
));
6894 int i
= suspend_momentary ();
6897 lineno
= TREE_COMPLEXITY (t
);
6898 emit_line_note (input_filename
, lineno
);
6900 (tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6901 tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
6902 TREE_OPERAND (t
, 2) != 0, NULL_TREE
, NULL_TREE
);
6903 init
= tsubst_expr (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
6905 (dcl
, init
, NULL_TREE
, 1, /*init ? LOOKUP_ONLYCONVERTING :*/ 0);
6906 resume_momentary (i
);
6913 lineno
= TREE_COMPLEXITY (t
);
6916 for (tmp
= FOR_INIT_STMT (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
6917 tsubst_expr (tmp
, args
, complain
, in_decl
);
6918 finish_for_init_stmt (NULL_TREE
);
6919 finish_for_cond (tsubst_expr (FOR_COND (t
), args
,
6922 tmp
= tsubst_expr (FOR_EXPR (t
), args
, complain
, in_decl
);
6923 finish_for_expr (tmp
, NULL_TREE
);
6924 tsubst_expr (FOR_BODY (t
), args
, complain
, in_decl
);
6925 finish_for_stmt (tmp
, NULL_TREE
);
6931 lineno
= TREE_COMPLEXITY (t
);
6932 begin_while_stmt ();
6933 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t
),
6934 args
, complain
, in_decl
),
6936 tsubst_expr (WHILE_BODY (t
), args
, complain
, in_decl
);
6937 finish_while_stmt (NULL_TREE
);
6943 lineno
= TREE_COMPLEXITY (t
);
6945 tsubst_expr (DO_BODY (t
), args
, complain
, in_decl
);
6946 finish_do_body (NULL_TREE
);
6947 finish_do_stmt (tsubst_expr (DO_COND (t
), args
,
6957 lineno
= TREE_COMPLEXITY (t
);
6959 finish_if_stmt_cond (tsubst_expr (IF_COND (t
),
6960 args
, complain
, in_decl
),
6963 if (tmp
= THEN_CLAUSE (t
), tmp
)
6965 tsubst_expr (tmp
, args
, complain
, in_decl
);
6966 finish_then_clause (NULL_TREE
);
6969 if (tmp
= ELSE_CLAUSE (t
), tmp
)
6971 begin_else_clause ();
6972 tsubst_expr (tmp
, args
, complain
, in_decl
);
6973 finish_else_clause (NULL_TREE
);
6984 lineno
= TREE_COMPLEXITY (t
);
6985 begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
));
6986 for (substmt
= COMPOUND_BODY (t
);
6987 substmt
!= NULL_TREE
;
6988 substmt
= TREE_CHAIN (substmt
))
6989 tsubst_expr (substmt
, args
, complain
, in_decl
);
6990 return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
),
6996 lineno
= TREE_COMPLEXITY (t
);
6997 finish_break_stmt ();
7001 lineno
= TREE_COMPLEXITY (t
);
7002 finish_continue_stmt ();
7009 lineno
= TREE_COMPLEXITY (t
);
7010 begin_switch_stmt ();
7011 val
= tsubst_expr (SWITCH_COND (t
), args
, complain
, in_decl
);
7012 finish_switch_cond (val
);
7014 if (tmp
= TREE_OPERAND (t
, 1), tmp
)
7015 tsubst_expr (tmp
, args
, complain
, in_decl
);
7017 finish_switch_stmt (val
, NULL_TREE
);
7022 finish_case_label (tsubst_expr (CASE_LOW (t
), args
, complain
, in_decl
),
7023 tsubst_expr (CASE_HIGH (t
), args
, complain
, in_decl
));
7027 t
= define_label (DECL_SOURCE_FILE (t
), DECL_SOURCE_LINE (t
),
7034 lineno
= TREE_COMPLEXITY (t
);
7035 t
= GOTO_DESTINATION (t
);
7036 if (TREE_CODE (t
) != IDENTIFIER_NODE
)
7037 /* Computed goto's must be tsubst'd into. On the other hand,
7038 non-computed gotos must not be; the identifier in question
7039 will have no binding. */
7040 t
= tsubst_expr (t
, args
, complain
, in_decl
);
7041 finish_goto_stmt (t
);
7045 lineno
= TREE_COMPLEXITY (t
);
7046 finish_asm_stmt (tsubst_expr (ASM_CV_QUAL (t
), args
, complain
, in_decl
),
7047 tsubst_expr (ASM_STRING (t
), args
, complain
, in_decl
),
7048 tsubst_expr (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
7049 tsubst_expr (ASM_INPUTS (t
), args
, complain
, in_decl
),
7050 tsubst_expr (ASM_CLOBBERS (t
), args
, complain
,
7055 lineno
= TREE_COMPLEXITY (t
);
7057 tsubst_expr (TRY_STMTS (t
), args
, complain
, in_decl
);
7058 finish_try_block (NULL_TREE
);
7060 tree handler
= TRY_HANDLERS (t
);
7061 for (; handler
; handler
= TREE_CHAIN (handler
))
7062 tsubst_expr (handler
, args
, complain
, in_decl
);
7064 finish_handler_sequence (NULL_TREE
);
7068 lineno
= TREE_COMPLEXITY (t
);
7070 if (HANDLER_PARMS (t
))
7072 tree d
= HANDLER_PARMS (t
);
7073 expand_start_catch_block
7074 (tsubst (TREE_OPERAND (d
, 1), args
, complain
, in_decl
),
7075 tsubst (TREE_OPERAND (d
, 0), args
, complain
, in_decl
));
7078 expand_start_catch_block (NULL_TREE
, NULL_TREE
);
7079 finish_handler_parms (NULL_TREE
);
7080 tsubst_expr (HANDLER_BODY (t
), args
, complain
, in_decl
);
7081 finish_handler (NULL_TREE
);
7085 lineno
= TREE_COMPLEXITY (t
);
7087 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
7088 tsubst (t
, args
, complain
, NULL_TREE
);
7092 return build_expr_from_tree (tsubst_copy (t
, args
, complain
, in_decl
));
7097 /* Instantiate the indicated variable or function template TMPL with
7098 the template arguments in TARG_PTR. */
7101 instantiate_template (tmpl
, targ_ptr
)
7102 tree tmpl
, targ_ptr
;
7108 struct obstack
*old_fmp_obstack
;
7109 extern struct obstack
*function_maybepermanent_obstack
;
7112 if (tmpl
== error_mark_node
)
7113 return error_mark_node
;
7115 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 283);
7117 /* Check to see if we already have this specialization. */
7118 spec
= retrieve_specialization (tmpl
, targ_ptr
);
7119 if (spec
!= NULL_TREE
)
7122 if (DECL_TEMPLATE_INFO (tmpl
))
7124 /* The TMPL is a partial instantiation. To get a full set of
7125 arguments we must add the arguments used to perform the
7126 partial instantiation. */
7127 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
7129 gen_tmpl
= most_general_template (tmpl
);
7131 /* Check to see if we already have this specialization. */
7132 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
);
7133 if (spec
!= NULL_TREE
)
7139 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7140 old_fmp_obstack
= function_maybepermanent_obstack
;
7141 function_maybepermanent_obstack
= &permanent_obstack
;
7143 len
= DECL_NTPARMS (gen_tmpl
);
7144 inner_args
= innermost_args (targ_ptr
);
7148 tree t
= TREE_VEC_ELT (inner_args
, i
);
7149 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
7151 tree nt
= target_type (t
);
7152 if (IS_AGGR_TYPE (nt
) && decl_function_context (TYPE_MAIN_DECL (nt
)))
7154 cp_error ("type `%T' composed from a local class is not a valid template-argument", t
);
7155 cp_error (" trying to instantiate `%D'", gen_tmpl
);
7156 fndecl
= error_mark_node
;
7161 targ_ptr
= copy_to_permanent (targ_ptr
);
7163 /* substitute template parameters */
7164 fndecl
= tsubst (DECL_RESULT (gen_tmpl
), targ_ptr
, /*complain=*/1, gen_tmpl
);
7165 /* The DECL_TI_TEMPLATE should always be the immediate parent
7166 template, not the most general template. */
7167 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
7169 if (flag_external_templates
)
7170 add_pending_template (fndecl
);
7173 function_maybepermanent_obstack
= old_fmp_obstack
;
7179 /* Push the name of the class template into the scope of the instantiation. */
7182 overload_template_name (type
)
7185 tree id
= DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
));
7188 if (IDENTIFIER_CLASS_VALUE (id
)
7189 && TREE_TYPE (IDENTIFIER_CLASS_VALUE (id
)) == type
)
7192 decl
= build_decl (TYPE_DECL
, id
, type
);
7193 SET_DECL_ARTIFICIAL (decl
);
7194 pushdecl_class_level (decl
);
7197 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
7198 arguments that are being used when calling it. TARGS is a vector
7199 into which the deduced template arguments are placed.
7201 Return zero for success, 2 for an incomplete match that doesn't resolve
7202 all the types, and 1 for complete failure. An error message will be
7203 printed only for an incomplete match.
7205 If FN is a conversion operator, RETURN_TYPE is the type desired as
7206 the result of the conversion operator.
7208 TPARMS is a vector of template parameters.
7210 The EXPLICIT_TARGS are explicit template arguments provided via a
7213 The parameter STRICT is one of:
7216 We are deducing arguments for a function call, as in
7220 We are deducing arguments for a conversion function, as in
7224 We are deducing arguments when calculating the partial
7225 ordering between specializations of function or class
7226 templates, as in [temp.func.order] and [temp.class.order],
7227 when doing an explicit instantiation as in [temp.explicit],
7228 when determining an explicit specialization as in
7229 [temp.expl.spec], or when taking the address of a function
7230 template, as in [temp.deduct.funcaddr].
7232 The other arguments are as for type_unification. */
7235 fn_type_unification (fn
, explicit_targs
, targs
, args
, return_type
,
7237 tree fn
, explicit_targs
, targs
, args
, return_type
;
7238 unification_kind_t strict
;
7243 my_friendly_assert (TREE_CODE (fn
) == TEMPLATE_DECL
, 0);
7245 fntype
= TREE_TYPE (fn
);
7250 The specified template arguments must match the template
7251 parameters in kind (i.e., type, nontype, template), and there
7252 must not be more arguments than there are parameters;
7253 otherwise type deduction fails.
7255 Nontype arguments must match the types of the corresponding
7256 nontype template parameters, or must be convertible to the
7257 types of the corresponding nontype parameters as specified in
7258 _temp.arg.nontype_, otherwise type deduction fails.
7260 All references in the function type of the function template
7261 to the corresponding template parameters are replaced by the
7262 specified template argument values. If a substitution in a
7263 template parameter or in the function type of the function
7264 template results in an invalid type, type deduction fails. */
7266 tree converted_args
;
7269 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
7270 explicit_targs
, NULL_TREE
, /*complain=*/0,
7271 /*require_all_arguments=*/0));
7272 if (converted_args
== error_mark_node
)
7275 fntype
= tsubst (fntype
, converted_args
, /*complain=*/0, NULL_TREE
);
7276 if (fntype
== error_mark_node
)
7279 /* Place the explicitly specified arguments in TARGS. */
7280 for (i
= 0; i
< TREE_VEC_LENGTH (targs
); i
++)
7281 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (converted_args
, i
);
7284 parms
= TYPE_ARG_TYPES (fntype
);
7286 if (DECL_CONV_FN_P (fn
))
7288 /* This is a template conversion operator. Use the return types
7289 as well as the argument types. */
7290 parms
= scratch_tree_cons (NULL_TREE
, TREE_TYPE (fntype
),
7292 args
= scratch_tree_cons (NULL_TREE
, return_type
, args
);
7295 /* We allow incomplete unification without an error message here
7296 because the standard doesn't seem to explicitly prohibit it. Our
7297 callers must be ready to deal with unification failures in any
7299 return type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
7300 targs
, parms
, args
, /*subr=*/0,
7301 strict
, /*allow_incomplete*/1);
7304 /* Adjust types before performing type deduction, as described in
7305 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
7306 sections are symmetric. PARM is the type of a function parameter
7307 or the return type of the conversion function. ARG is the type of
7308 the argument passed to the call, or the type of the value
7309 intialized with the result of the conversion function. */
7312 maybe_adjust_types_for_deduction (strict
, parm
, arg
)
7313 unification_kind_t strict
;
7324 /* Swap PARM and ARG throughout the remainder of this
7325 function; the handling is precisely symmetric since PARM
7326 will initialize ARG rather than vice versa. */
7334 /* There is nothing to do in this case. */
7338 my_friendly_abort (0);
7341 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
7343 /* [temp.deduct.call]
7345 If P is not a reference type:
7347 --If A is an array type, the pointer type produced by the
7348 array-to-pointer standard conversion (_conv.array_) is
7349 used in place of A for type deduction; otherwise,
7351 --If A is a function type, the pointer type produced by
7352 the function-to-pointer standard conversion
7353 (_conv.func_) is used in place of A for type deduction;
7356 --If A is a cv-qualified type, the top level
7357 cv-qualifiers of A's type are ignored for type
7359 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
7360 *arg
= build_pointer_type (TREE_TYPE (*arg
));
7361 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
7362 *arg
= build_pointer_type (*arg
);
7364 *arg
= TYPE_MAIN_VARIANT (*arg
);
7367 /* [temp.deduct.call]
7369 If P is a cv-qualified type, the top level cv-qualifiers
7370 of P's type are ignored for type deduction. If P is a
7371 reference type, the type referred to by P is used for
7373 *parm
= TYPE_MAIN_VARIANT (*parm
);
7374 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
7375 *parm
= TREE_TYPE (*parm
);
7378 /* Like type_unfication.
7380 If SUBR is 1, we're being called recursively (to unify the
7381 arguments of a function or method parameter of a function
7385 type_unification_real (tparms
, targs
, parms
, args
, subr
,
7386 strict
, allow_incomplete
)
7387 tree tparms
, targs
, parms
, args
;
7389 unification_kind_t strict
;
7390 int allow_incomplete
;
7394 int ntparms
= TREE_VEC_LENGTH (tparms
);
7397 my_friendly_assert (TREE_CODE (tparms
) == TREE_VEC
, 289);
7398 my_friendly_assert (parms
== NULL_TREE
7399 || TREE_CODE (parms
) == TREE_LIST
, 290);
7400 /* ARGS could be NULL (via a call from parse.y to
7401 build_x_function_call). */
7403 my_friendly_assert (TREE_CODE (args
) == TREE_LIST
, 291);
7404 my_friendly_assert (ntparms
> 0, 292);
7409 sub_strict
= UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_DERIVED
;
7413 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
7417 sub_strict
= UNIFY_ALLOW_NONE
;
7421 my_friendly_abort (0);
7425 && parms
!= void_list_node
7427 && args
!= void_list_node
)
7429 parm
= TREE_VALUE (parms
);
7430 parms
= TREE_CHAIN (parms
);
7431 arg
= TREE_VALUE (args
);
7432 args
= TREE_CHAIN (args
);
7434 if (arg
== error_mark_node
)
7436 if (arg
== unknown_type_node
)
7437 /* We can't deduce anything from this, but we might get all the
7438 template args from other function args. */
7441 /* Conversions will be performed on a function argument that
7442 corresponds with a function parameter that contains only
7443 non-deducible template parameters and explicitly specified
7444 template parameters. */
7445 if (! uses_template_parms (parm
))
7449 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7450 type
= TREE_TYPE (arg
);
7457 if (strict
== DEDUCE_EXACT
)
7459 if (same_type_p (parm
, type
))
7463 /* It might work; we shouldn't check now, because we might
7464 get into infinite recursion. Overload resolution will
7471 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7473 my_friendly_assert (TREE_TYPE (arg
) != NULL_TREE
, 293);
7474 if (type_unknown_p (arg
))
7476 /* [temp.deduct.type] A template-argument can be deduced from
7477 a pointer to function or pointer to member function
7478 argument if the set of overloaded functions does not
7479 contain function templates and at most one of a set of
7480 overloaded functions provides a unique match. */
7482 if (resolve_overloaded_unification
7483 (tparms
, targs
, parm
, arg
, strict
, sub_strict
)
7488 arg
= TREE_TYPE (arg
);
7492 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7494 switch (unify (tparms
, targs
, parm
, arg
, sub_strict
))
7502 /* Fail if we've reached the end of the parm list, and more args
7503 are present, and the parm list isn't variadic. */
7504 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
7506 /* Fail if parms are left and they don't have default values. */
7508 && parms
!= void_list_node
7509 && TREE_PURPOSE (parms
) == NULL_TREE
)
7512 for (i
= 0; i
< ntparms
; i
++)
7513 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
7515 if (!allow_incomplete
)
7516 error ("incomplete type unification");
7522 /* Subroutine of type_unification_real. Args are like the variables at the
7523 call site. ARG is an overloaded function (or template-id); we try
7524 deducing template args from each of the overloads, and if only one
7525 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
7528 resolve_overloaded_unification (tparms
, targs
, parm
, arg
, strict
,
7530 tree tparms
, targs
, parm
, arg
;
7531 unification_kind_t strict
;
7534 tree tempargs
= copy_node (targs
);
7537 if (TREE_CODE (arg
) == ADDR_EXPR
)
7538 arg
= TREE_OPERAND (arg
, 0);
7540 if (TREE_CODE (arg
) == COMPONENT_REF
)
7541 /* Handle `&x' where `x' is some static or non-static member
7543 arg
= TREE_OPERAND (arg
, 1);
7545 /* Strip baselink information. */
7546 while (TREE_CODE (arg
) == TREE_LIST
)
7547 arg
= TREE_VALUE (arg
);
7549 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
7551 /* If we got some explicit template args, we need to plug them into
7552 the affected templates before we try to unify, in case the
7553 explicit args will completely resolve the templates in question. */
7555 tree expl_subargs
= TREE_OPERAND (arg
, 1);
7556 arg
= TREE_OPERAND (arg
, 0);
7558 for (; arg
; arg
= OVL_NEXT (arg
))
7560 tree fn
= OVL_CURRENT (arg
);
7563 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7566 subargs
= get_bindings_overload (fn
, DECL_RESULT (fn
), expl_subargs
);
7569 elem
= tsubst (TREE_TYPE (fn
), subargs
, /*complain=*/0,
7571 if (TREE_CODE (elem
) == METHOD_TYPE
)
7572 elem
= build_ptrmemfunc_type (build_pointer_type (elem
));
7573 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
, elem
,
7574 strict
, sub_strict
);
7578 else if (TREE_CODE (arg
) == OVERLOAD
)
7580 for (; arg
; arg
= OVL_NEXT (arg
))
7582 tree type
= TREE_TYPE (OVL_CURRENT (arg
));
7583 if (TREE_CODE (type
) == METHOD_TYPE
)
7584 type
= build_ptrmemfunc_type (build_pointer_type (type
));
7585 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
7587 strict
, sub_strict
);
7591 my_friendly_abort (981006);
7593 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7594 to function or pointer to member function argument if the set of
7595 overloaded functions does not contain function templates and at most
7596 one of a set of overloaded functions provides a unique match.
7598 So if we found multiple possibilities, we return success but don't
7603 int i
= TREE_VEC_LENGTH (targs
);
7605 if (TREE_VEC_ELT (tempargs
, i
))
7606 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
7614 /* Subroutine of resolve_overloaded_unification; does deduction for a single
7615 overload. Fills TARGS with any deduced arguments, or error_mark_node if
7616 different overloads deduce different arguments for a given parm.
7617 Returns 1 on success. */
7620 try_one_overload (tparms
, orig_targs
, targs
, parm
, arg
, strict
,
7622 tree tparms
, orig_targs
, targs
, parm
, arg
;
7623 unification_kind_t strict
;
7630 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7631 to function or pointer to member function argument if the set of
7632 overloaded functions does not contain function templates and at most
7633 one of a set of overloaded functions provides a unique match.
7635 So if this is a template, just return success. */
7637 if (uses_template_parms (arg
))
7640 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7642 /* We don't copy orig_targs for this because if we have already deduced
7643 some template args from previous args, unify would complain when we
7644 try to deduce a template parameter for the same argument, even though
7645 there isn't really a conflict. */
7646 nargs
= TREE_VEC_LENGTH (targs
);
7647 tempargs
= make_scratch_vec (nargs
);
7649 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
) != 0)
7652 /* First make sure we didn't deduce anything that conflicts with
7653 explicitly specified args. */
7654 for (i
= nargs
; i
--; )
7656 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7657 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
7659 if (elt
== NULL_TREE
)
7661 else if (uses_template_parms (elt
))
7663 /* Since we're unifying against ourselves, we will fill in template
7664 args used in the function parm list with our own template parms.
7666 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
7669 else if (oldelt
&& ! template_args_equal (oldelt
, elt
))
7673 for (i
= nargs
; i
--; )
7675 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7678 TREE_VEC_ELT (targs
, i
) = elt
;
7684 /* PARM is a template class (perhaps with unbound template
7685 parameters). ARG is a fully instantiated type. If ARG can be
7686 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
7687 TARGS are as for unify. */
7690 try_class_unification (tparms
, targs
, parm
, arg
)
7699 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
7700 || CLASSTYPE_TI_TEMPLATE (arg
) != CLASSTYPE_TI_TEMPLATE (parm
))
7703 /* We need to make a new template argument vector for the call to
7704 unify. If we used TARGS, we'd clutter it up with the result of
7705 the attempted unification, even if this class didn't work out.
7706 We also don't want to commit ourselves to all the unifications
7707 we've already done, since unification is supposed to be done on
7708 an argument-by-argument basis. In other words, consider the
7709 following pathological case:
7711 template <int I, int J, int K>
7714 template <int I, int J>
7715 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
7717 template <int I, int J, int K>
7718 void f(S<I, J, K>, S<I, I, I>);
7727 Now, by the time we consider the unification involving `s2', we
7728 already know that we must have `f<0, 0, 0>'. But, even though
7729 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal
7730 because there are two ways to unify base classes of S<0, 1, 2>
7731 with S<I, I, I>. If we kept the already deduced knowledge, we
7732 would reject the possibility I=1. */
7734 copy_of_targs
= make_temp_vec (TREE_VEC_LENGTH (targs
));
7735 i
= unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
7736 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
);
7739 /* If unification failed, we're done. */
7746 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
7747 have alreay discovered to be satisfactory. ARG_BINFO is the binfo
7748 for the base class of ARG that we are currently examining. */
7751 get_template_base_recursive (tparms
, targs
, parm
,
7752 arg_binfo
, rval
, flags
)
7762 tree arg
= BINFO_TYPE (arg_binfo
);
7764 if (!(flags
& GTB_IGNORE_TYPE
))
7766 tree r
= try_class_unification (tparms
, targs
,
7769 /* If there is more than one satisfactory baseclass, then:
7773 If they yield more than one possible deduced A, the type
7777 if (r
&& rval
&& !same_type_p (r
, rval
))
7778 return error_mark_node
;
7783 binfos
= BINFO_BASETYPES (arg_binfo
);
7784 n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
7786 /* Process base types. */
7787 for (i
= 0; i
< n_baselinks
; i
++)
7789 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
7792 /* Skip this base, if we've already seen it. */
7793 if (BINFO_MARKED (base_binfo
))
7797 (flags
& GTB_VIA_VIRTUAL
) || TREE_VIA_VIRTUAL (base_binfo
);
7799 /* When searching for a non-virtual, we cannot mark virtually
7802 SET_BINFO_MARKED (base_binfo
);
7804 rval
= get_template_base_recursive (tparms
, targs
,
7808 GTB_VIA_VIRTUAL
* this_virtual
);
7810 /* If we discovered more than one matching base class, we can
7812 if (rval
== error_mark_node
)
7813 return error_mark_node
;
7819 /* Given a template type PARM and a class type ARG, find the unique
7820 base type in ARG that is an instance of PARM. We do not examine
7821 ARG itself; only its base-classes. If there is no appropriate base
7822 class, return NULL_TREE. If there is more than one, return
7823 error_mark_node. PARM may be the type of a partial specialization,
7824 as well as a plain template type. Used by unify. */
7827 get_template_base (tparms
, targs
, parm
, arg
)
7836 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg
)), 92);
7838 arg_binfo
= TYPE_BINFO (complete_type (arg
));
7839 rval
= get_template_base_recursive (tparms
, targs
,
7844 /* Since get_template_base_recursive marks the bases classes, we
7845 must unmark them here. */
7846 dfs_walk (arg_binfo
, dfs_unmark
, markedp
, 0);
7851 /* Returns the level of DECL, which declares a template parameter. */
7854 template_decl_level (decl
)
7857 switch (TREE_CODE (decl
))
7861 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
7864 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
7867 my_friendly_abort (0);
7872 /* Decide whether ARG can be unified with PARM, considering only the
7873 cv-qualifiers of each type, given STRICT as documented for unify.
7874 Returns non-zero iff the unification is OK on that basis.*/
7877 check_cv_quals_for_unify (strict
, arg
, parm
)
7882 return !((!(strict
& UNIFY_ALLOW_MORE_CV_QUAL
)
7883 && !at_least_as_qualified_p (arg
, parm
))
7884 || (!(strict
& UNIFY_ALLOW_LESS_CV_QUAL
)
7885 && (!at_least_as_qualified_p (parm
, arg
))));
7888 /* Takes parameters as for type_unification. Returns 0 if the
7889 type deduction suceeds, 1 otherwise. The parameter STRICT is a
7890 bitwise or of the following flags:
7893 Require an exact match between PARM and ARG.
7894 UNIFY_ALLOW_MORE_CV_QUAL:
7895 Allow the deduced ARG to be more cv-qualified than ARG.
7896 UNIFY_ALLOW_LESS_CV_QUAL:
7897 Allow the deduced ARG to be less cv-qualified than ARG.
7898 UNIFY_ALLOW_DERIVED:
7899 Allow the deduced ARG to be a template base class of ARG,
7900 or a pointer to a template base class of the type pointed to by
7902 UNIFY_ALLOW_INTEGER:
7903 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
7904 case for more information. */
7907 unify (tparms
, targs
, parm
, arg
, strict
)
7908 tree tparms
, targs
, parm
, arg
;
7915 /* I don't think this will do the right thing with respect to types.
7916 But the only case I've seen it in so far has been array bounds, where
7917 signedness is the only information lost, and I think that will be
7919 while (TREE_CODE (parm
) == NOP_EXPR
)
7920 parm
= TREE_OPERAND (parm
, 0);
7922 if (arg
== error_mark_node
)
7924 if (arg
== unknown_type_node
)
7925 /* We can't deduce anything from this, but we might get all the
7926 template args from other function args. */
7929 /* If PARM uses template parameters, then we can't bail out here,
7930 even if ARG == PARM, since we won't record unifications for the
7931 template parameters. We might need them if we're trying to
7932 figure out which of two things is more specialized. */
7933 if (arg
== parm
&& !uses_template_parms (parm
))
7936 /* Immediately reject some pairs that won't unify because of
7937 cv-qualification mismatches. */
7938 if (TREE_CODE (arg
) == TREE_CODE (parm
)
7939 && TREE_CODE_CLASS (TREE_CODE (arg
)) == 't'
7940 /* We check the cv-qualifiers when unifying with template type
7941 parameters below. We want to allow ARG `const T' to unify with
7942 PARM `T' for example, when computing which of two templates
7943 is more specialized, for example. */
7944 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
7945 && !check_cv_quals_for_unify (strict
, arg
, parm
))
7948 switch (TREE_CODE (parm
))
7951 /* In a type which contains a nested-name-specifier, template
7952 argument values cannot be deduced for template parameters used
7953 within the nested-name-specifier. */
7956 case TEMPLATE_TYPE_PARM
:
7957 case TEMPLATE_TEMPLATE_PARM
:
7958 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
7960 if (TEMPLATE_TYPE_LEVEL (parm
)
7961 != template_decl_level (tparm
))
7962 /* The PARM is not one we're trying to unify. Just check
7963 to see if it matches ARG. */
7964 return (TREE_CODE (arg
) == TREE_CODE (parm
)
7965 && same_type_p (parm
, arg
)) ? 0 : 1;
7966 idx
= TEMPLATE_TYPE_IDX (parm
);
7967 targ
= TREE_VEC_ELT (targs
, idx
);
7968 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
7970 /* Check for mixed types and values. */
7971 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
7972 && TREE_CODE (tparm
) != TYPE_DECL
)
7973 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
7974 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
7977 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
7979 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
))
7981 /* We arrive here when PARM does not involve template
7984 /* ARG must be constructed from a template class. */
7985 if (TREE_CODE (arg
) != RECORD_TYPE
|| !CLASSTYPE_TEMPLATE_INFO (arg
))
7989 tree parmtmpl
= TYPE_TI_TEMPLATE (parm
);
7990 tree parmvec
= TYPE_TI_ARGS (parm
);
7991 tree argvec
= CLASSTYPE_TI_ARGS (arg
);
7993 = DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg
));
7996 /* The parameter and argument roles have to be switched here
7997 in order to handle default arguments properly. For example,
7998 template<template <class> class TT> void f(TT<int>)
7999 should be able to accept vector<int> which comes from
8000 template <class T, class Allocator = allocator>
8003 if (coerce_template_parms (argtmplvec
, parmvec
, parmtmpl
, 0, 1)
8007 /* Deduce arguments T, i from TT<T> or TT<i>.
8008 We check each element of PARMVEC and ARGVEC individually
8009 rather than the whole TREE_VEC since they can have
8010 different number of elements. */
8012 for (i
= 0; i
< TREE_VEC_LENGTH (parmvec
); ++i
)
8014 tree t
= TREE_VEC_ELT (parmvec
, i
);
8016 if (unify (tparms
, targs
, t
,
8017 TREE_VEC_ELT (argvec
, i
),
8022 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
8027 /* If PARM is `const T' and ARG is only `int', we don't have
8028 a match unless we are allowing additional qualification.
8029 If ARG is `const int' and PARM is just `T' that's OK;
8030 that binds `const int' to `T'. */
8031 if (!check_cv_quals_for_unify (strict
| UNIFY_ALLOW_LESS_CV_QUAL
,
8035 /* Consider the case where ARG is `const volatile int' and
8036 PARM is `const T'. Then, T should be `volatile int'. */
8038 cp_build_qualified_type (arg
,
8040 & ~CP_TYPE_QUALS (parm
));
8043 /* Simple cases: Value already set, does match or doesn't. */
8044 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
8049 /* Make sure that ARG is not a variable-sized array. (Note that
8050 were talking about variable-sized arrays (like `int[n]'),
8051 rather than arrays of unknown size (like `int[]').) We'll
8052 get very confused by such a type since the bound of the array
8053 will not be computable in an instantiation. Besides, such
8054 types are not allowed in ISO C++, so we can do as we please
8056 if (TREE_CODE (arg
) == ARRAY_TYPE
8057 && !uses_template_parms (arg
)
8058 && (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (arg
)))
8062 TREE_VEC_ELT (targs
, idx
) = arg
;
8065 case TEMPLATE_PARM_INDEX
:
8066 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
8068 if (TEMPLATE_PARM_LEVEL (parm
)
8069 != template_decl_level (tparm
))
8070 /* The PARM is not one we're trying to unify. Just check
8071 to see if it matches ARG. */
8072 return (TREE_CODE (arg
) == TREE_CODE (parm
)
8073 && cp_tree_equal (parm
, arg
) > 0) ? 0 : 1;
8075 idx
= TEMPLATE_PARM_IDX (parm
);
8076 targ
= TREE_VEC_ELT (targs
, idx
);
8080 int i
= (cp_tree_equal (targ
, arg
) > 0);
8086 my_friendly_abort (42);
8089 /* [temp.deduct.type] If, in the declaration of a function template
8090 with a non-type template-parameter, the non-type
8091 template-parameter is used in an expression in the function
8092 parameter-list and, if the corresponding template-argument is
8093 deduced, the template-argument type shall match the type of the
8094 template-parameter exactly, except that a template-argument
8095 deduced from an array bound may be of any integral type. */
8096 if (same_type_p (TREE_TYPE (arg
), TREE_TYPE (parm
)))
8098 else if ((strict
& UNIFY_ALLOW_INTEGER
)
8099 && (TREE_CODE (TREE_TYPE (parm
)) == INTEGER_TYPE
8100 || TREE_CODE (TREE_TYPE (parm
)) == BOOLEAN_TYPE
))
8105 TREE_VEC_ELT (targs
, idx
) = copy_to_permanent (arg
);
8112 if (TREE_CODE (arg
) == RECORD_TYPE
&& TYPE_PTRMEMFUNC_FLAG (arg
))
8113 return (unify (tparms
, targs
, parm
,
8114 TYPE_PTRMEMFUNC_FN_TYPE (arg
), strict
));
8116 if (TREE_CODE (arg
) != POINTER_TYPE
)
8119 /* [temp.deduct.call]
8121 A can be another pointer or pointer to member type that can
8122 be converted to the deduced A via a qualification
8123 conversion (_conv.qual_).
8125 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
8126 This will allow for additional cv-qualification of the
8127 pointed-to types if appropriate. In general, this is a bit
8128 too generous; we are only supposed to allow qualification
8129 conversions and this method will allow an ARG of char** and
8130 a deduced ARG of const char**. However, overload
8131 resolution will subsequently invalidate the candidate, so
8132 this is probably OK. */
8133 sub_strict
= strict
;
8135 if (TREE_CODE (TREE_TYPE (arg
)) != RECORD_TYPE
8136 || TYPE_PTRMEMFUNC_FLAG (TREE_TYPE (arg
)))
8137 /* The derived-to-base conversion only persists through one
8138 level of pointers. */
8139 sub_strict
&= ~UNIFY_ALLOW_DERIVED
;
8141 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE
8145 case REFERENCE_TYPE
:
8146 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
8148 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8152 if (TREE_CODE (arg
) != ARRAY_TYPE
)
8154 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
8155 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
8157 if (TYPE_DOMAIN (parm
) != NULL_TREE
8158 && unify (tparms
, targs
, TYPE_DOMAIN (parm
),
8159 TYPE_DOMAIN (arg
), UNIFY_ALLOW_NONE
) != 0)
8161 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8169 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8172 if (TREE_CODE (parm
) == INTEGER_TYPE
8173 && TREE_CODE (TYPE_MAX_VALUE (parm
)) != INTEGER_CST
)
8175 if (TYPE_MIN_VALUE (parm
) && TYPE_MIN_VALUE (arg
)
8176 && unify (tparms
, targs
, TYPE_MIN_VALUE (parm
),
8177 TYPE_MIN_VALUE (arg
), UNIFY_ALLOW_INTEGER
))
8179 if (TYPE_MAX_VALUE (parm
) && TYPE_MAX_VALUE (arg
)
8180 && unify (tparms
, targs
, TYPE_MAX_VALUE (parm
),
8181 TYPE_MAX_VALUE (arg
), UNIFY_ALLOW_INTEGER
))
8184 /* We use the TYPE_MAIN_VARIANT since we have already
8185 checked cv-qualification at the top of the
8187 else if (!same_type_p (TYPE_MAIN_VARIANT (arg
),
8188 TYPE_MAIN_VARIANT (parm
)))
8191 /* As far as unification is concerned, this wins. Later checks
8192 will invalidate it if necessary. */
8195 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
8196 /* Type INTEGER_CST can come from ordinary constant template args. */
8198 while (TREE_CODE (arg
) == NOP_EXPR
)
8199 arg
= TREE_OPERAND (arg
, 0);
8201 if (TREE_CODE (arg
) != INTEGER_CST
)
8203 return !tree_int_cst_equal (parm
, arg
);
8208 if (TREE_CODE (arg
) != TREE_VEC
)
8210 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
8212 for (i
= TREE_VEC_LENGTH (parm
) - 1; i
>= 0; i
--)
8213 if (unify (tparms
, targs
,
8214 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
8222 if (TYPE_PTRMEMFUNC_FLAG (parm
))
8223 return unify (tparms
, targs
, TYPE_PTRMEMFUNC_FN_TYPE (parm
),
8226 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8229 if (CLASSTYPE_TEMPLATE_INFO (parm
))
8233 if (strict
& UNIFY_ALLOW_DERIVED
)
8235 /* First, we try to unify the PARM and ARG directly. */
8236 t
= try_class_unification (tparms
, targs
,
8241 /* Fallback to the special case allowed in
8244 If P is a class, and P has the form
8245 template-id, then A can be a derived class of
8246 the deduced A. Likewise, if P is a pointer to
8247 a class of the form template-id, A can be a
8248 pointer to a derived class pointed to by the
8250 t
= get_template_base (tparms
, targs
,
8253 if (! t
|| t
== error_mark_node
)
8257 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
8258 && (CLASSTYPE_TI_TEMPLATE (parm
)
8259 == CLASSTYPE_TI_TEMPLATE (arg
)))
8260 /* Perhaps PARM is something like S<U> and ARG is S<int>.
8261 Then, we should unify `int' and `U'. */
8264 /* There's no chance of unication succeeding. */
8267 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
8268 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
);
8270 else if (!same_type_p (TYPE_MAIN_VARIANT (parm
),
8271 TYPE_MAIN_VARIANT (arg
)))
8277 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8280 if (unify (tparms
, targs
, TREE_TYPE (parm
),
8281 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
))
8283 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
8284 TYPE_ARG_TYPES (arg
), 1,
8288 if (TREE_CODE (arg
) != OFFSET_TYPE
)
8290 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
8291 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
))
8293 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8297 if (arg
!= decl_constant_value (parm
))
8302 /* Matched cases are handled by the ARG == PARM test above. */
8306 if (TREE_CODE (TREE_OPERAND (parm
, 1)) == INTEGER_CST
)
8308 /* We handle this case specially, since it comes up with
8309 arrays. In particular, something like:
8311 template <int N> void f(int (&x)[N]);
8313 Here, we are trying to unify the range type, which
8314 looks like [0 ... (N - 1)]. */
8316 t1
= TREE_OPERAND (parm
, 0);
8317 t2
= TREE_OPERAND (parm
, 1);
8319 /* Should this be a regular fold? */
8320 t
= maybe_fold_nontype_arg (build (PLUS_EXPR
,
8324 return unify (tparms
, targs
, t1
, t
, strict
);
8326 /* else fall through */
8329 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm
))))
8330 /* We're looking at an expression. This can happen with
8334 void foo(S<I>, S<I + 2>);
8336 This is a "nondeduced context":
8340 The nondeduced contexts are:
8342 --A type that is a template-id in which one or more of
8343 the template-arguments is an expression that references
8344 a template-parameter.
8346 In these cases, we assume deduction succeeded, but don't
8347 actually infer any unifications. */
8350 sorry ("use of `%s' in template type unification",
8351 tree_code_name
[(int) TREE_CODE (parm
)]);
8357 /* Called if RESULT is explicitly instantiated, or is a member of an
8358 explicitly instantiated class, or if using -frepo and the
8359 instantiation of RESULT has been assigned to this file. */
8362 mark_decl_instantiated (result
, extern_p
)
8366 if (TREE_CODE (result
) != FUNCTION_DECL
)
8367 /* The TREE_PUBLIC flag for function declarations will have been
8368 set correctly by tsubst. */
8369 TREE_PUBLIC (result
) = 1;
8373 DECL_INTERFACE_KNOWN (result
) = 1;
8374 DECL_NOT_REALLY_EXTERN (result
) = 1;
8376 /* Always make artificials weak. */
8377 if (DECL_ARTIFICIAL (result
) && flag_weak
)
8378 comdat_linkage (result
);
8379 /* For WIN32 we also want to put explicit instantiations in
8380 linkonce sections. */
8381 else if (TREE_PUBLIC (result
))
8382 maybe_make_one_only (result
);
8384 else if (TREE_CODE (result
) == FUNCTION_DECL
)
8385 mark_inline_for_output (result
);
8388 /* Given two function templates PAT1 and PAT2, and explicit template
8389 arguments EXPLICIT_ARGS return:
8391 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
8392 -1 if PAT2 is more specialized than PAT1.
8393 0 if neither is more specialized. */
8396 more_specialized (pat1
, pat2
, explicit_args
)
8397 tree pat1
, pat2
, explicit_args
;
8402 targs
= get_bindings_overload (pat1
, DECL_RESULT (pat2
), explicit_args
);
8406 targs
= get_bindings_overload (pat2
, DECL_RESULT (pat1
), explicit_args
);
8413 /* Given two class template specialization list nodes PAT1 and PAT2, return:
8415 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
8416 -1 if PAT2 is more specialized than PAT1.
8417 0 if neither is more specialized. */
8420 more_specialized_class (pat1
, pat2
)
8426 targs
= get_class_bindings (TREE_VALUE (pat1
), TREE_PURPOSE (pat1
),
8427 TREE_PURPOSE (pat2
));
8431 targs
= get_class_bindings (TREE_VALUE (pat2
), TREE_PURPOSE (pat2
),
8432 TREE_PURPOSE (pat1
));
8439 /* Return the template arguments that will produce the function signature
8440 DECL from the function template FN, with the explicit template
8441 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
8442 also match. Return NULL_TREE if no satisfactory arguments could be
8446 get_bindings_real (fn
, decl
, explicit_args
, check_rettype
)
8447 tree fn
, decl
, explicit_args
;
8450 int ntparms
= DECL_NTPARMS (fn
);
8451 tree targs
= make_scratch_vec (ntparms
);
8453 tree decl_arg_types
;
8456 /* Substitute the explicit template arguments into the type of DECL.
8457 The call to fn_type_unification will handle substitution into the
8459 decl_type
= TREE_TYPE (decl
);
8460 if (explicit_args
&& uses_template_parms (decl_type
))
8463 tree converted_args
;
8465 if (DECL_TEMPLATE_INFO (decl
))
8466 tmpl
= DECL_TI_TEMPLATE (decl
);
8468 /* We can get here for some illegal specializations. */
8472 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
8473 explicit_args
, NULL_TREE
,
8475 /*require_all_arguments=*/0));
8476 if (converted_args
== error_mark_node
)
8479 decl_type
= tsubst (decl_type
, converted_args
, /*complain=*/0,
8481 if (decl_type
== error_mark_node
)
8485 /* If FN is a static member function, adjust the type of DECL
8487 decl_arg_types
= TYPE_ARG_TYPES (decl_type
);
8488 if (DECL_STATIC_FUNCTION_P (fn
)
8489 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
8490 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
8492 i
= fn_type_unification (fn
, explicit_args
, targs
,
8494 TREE_TYPE (decl_type
),
8502 /* Check to see that the resulting return type is also OK. */
8503 tree t
= tsubst (TREE_TYPE (TREE_TYPE (fn
)), targs
,
8504 /*complain=*/0, NULL_TREE
);
8506 if (!same_type_p (t
, TREE_TYPE (TREE_TYPE (decl
))))
8513 /* For most uses, we want to check the return type. */
8516 get_bindings (fn
, decl
, explicit_args
)
8517 tree fn
, decl
, explicit_args
;
8519 return get_bindings_real (fn
, decl
, explicit_args
, 1);
8522 /* But for more_specialized, we only care about the parameter types. */
8525 get_bindings_overload (fn
, decl
, explicit_args
)
8526 tree fn
, decl
, explicit_args
;
8528 return get_bindings_real (fn
, decl
, explicit_args
, 0);
8531 /* Return the innermost template arguments that, when applied to a
8532 template specialization whose innermost template parameters are
8533 TPARMS, and whose specialization arguments are ARGS, yield the
8536 For example, suppose we have:
8538 template <class T, class U> struct S {};
8539 template <class T> struct S<T*, int> {};
8541 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
8542 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
8543 int}. The resulting vector will be {double}, indicating that `T'
8544 is bound to `double'. */
8547 get_class_bindings (tparms
, parms
, args
)
8548 tree tparms
, parms
, args
;
8550 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
8551 tree vec
= make_temp_vec (ntparms
);
8553 args
= innermost_args (args
);
8555 if (unify (tparms
, vec
, parms
, args
, UNIFY_ALLOW_NONE
))
8558 for (i
= 0; i
< ntparms
; ++i
)
8559 if (! TREE_VEC_ELT (vec
, i
))
8565 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
8566 Pick the most specialized template, and return the corresponding
8567 instantiation, or if there is no corresponding instantiation, the
8568 template itself. EXPLICIT_ARGS is any template arguments explicity
8569 mentioned in a template-id. If there is no most specialized
8570 tempalte, error_mark_node is returned. If there are no templates
8571 at all, NULL_TREE is returned. */
8574 most_specialized_instantiation (instantiations
, explicit_args
)
8575 tree instantiations
;
8581 if (!instantiations
)
8584 champ
= instantiations
;
8585 for (fn
= TREE_CHAIN (instantiations
); fn
; fn
= TREE_CHAIN (fn
))
8587 fate
= more_specialized (TREE_VALUE (champ
),
8588 TREE_VALUE (fn
), explicit_args
);
8595 fn
= TREE_CHAIN (fn
);
8597 return error_mark_node
;
8603 for (fn
= instantiations
; fn
&& fn
!= champ
; fn
= TREE_CHAIN (fn
))
8605 fate
= more_specialized (TREE_VALUE (champ
),
8606 TREE_VALUE (fn
), explicit_args
);
8608 return error_mark_node
;
8611 return TREE_PURPOSE (champ
) ? TREE_PURPOSE (champ
) : TREE_VALUE (champ
);
8614 /* Return the most specialized of the list of templates in FNS that can
8615 produce an instantiation matching DECL, given the explicit template
8616 arguments EXPLICIT_ARGS. */
8619 most_specialized (fns
, decl
, explicit_args
)
8620 tree fns
, decl
, explicit_args
;
8622 tree candidates
= NULL_TREE
;
8625 for (fn
= fns
; fn
; fn
= TREE_CHAIN (fn
))
8627 tree candidate
= TREE_VALUE (fn
);
8629 args
= get_bindings (candidate
, decl
, explicit_args
);
8631 candidates
= scratch_tree_cons (NULL_TREE
, candidate
,
8635 return most_specialized_instantiation (candidates
, explicit_args
);
8638 /* If DECL is a specialization of some template, return the most
8639 general such template. For example, given:
8641 template <class T> struct S { template <class U> void f(U); };
8643 if TMPL is `template <class U> void S<int>::f(U)' this will return
8644 the full template. This function will not trace past partial
8645 specializations, however. For example, given in addition:
8647 template <class T> struct S<T*> { template <class U> void f(U); };
8649 if TMPL is `template <class U> void S<int*>::f(U)' this will return
8650 `template <class T> template <class U> S<T*>::f(U)'. */
8653 most_general_template (decl
)
8656 while (DECL_TEMPLATE_INFO (decl
))
8657 decl
= DECL_TI_TEMPLATE (decl
);
8662 /* Return the most specialized of the class template specializations
8663 of TMPL which can produce an instantiation matching ARGS, or
8664 error_mark_node if the choice is ambiguous. */
8667 most_specialized_class (tmpl
, args
)
8671 tree list
= NULL_TREE
;
8676 tmpl
= most_general_template (tmpl
);
8677 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
8680 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
), args
);
8683 list
= decl_tree_cons (TREE_PURPOSE (t
), TREE_VALUE (t
), list
);
8684 TREE_TYPE (list
) = TREE_TYPE (t
);
8694 for (; t
; t
= TREE_CHAIN (t
))
8696 fate
= more_specialized_class (champ
, t
);
8705 return error_mark_node
;
8711 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
8713 fate
= more_specialized_class (champ
, t
);
8715 return error_mark_node
;
8721 /* called from the parser. */
8724 do_decl_instantiation (declspecs
, declarator
, storage
)
8725 tree declspecs
, declarator
, storage
;
8727 tree decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, 0, NULL_TREE
);
8728 tree result
= NULL_TREE
;
8731 if (! DECL_LANG_SPECIFIC (decl
))
8733 cp_error ("explicit instantiation of non-template `%#D'", decl
);
8736 else if (TREE_CODE (decl
) == VAR_DECL
)
8738 /* There is an asymmetry here in the way VAR_DECLs and
8739 FUNCTION_DECLs are handled by grokdeclarator. In the case of
8740 the latter, the DECL we get back will be marked as a
8741 template instantiation, and the appropriate
8742 DECL_TEMPLATE_INFO will be set up. This does not happen for
8743 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
8744 should handle VAR_DECLs as it currently handles
8746 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, 0);
8747 if (result
&& TREE_CODE (result
) != VAR_DECL
)
8749 cp_error ("no matching template for `%D' found", result
);
8753 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
8755 cp_error ("explicit instantiation of `%#D'", decl
);
8761 /* Check for various error cases. Note that if the explicit
8762 instantiation is legal the RESULT will currently be marked as an
8763 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
8764 until we get here. */
8766 if (DECL_TEMPLATE_SPECIALIZATION (result
))
8770 No program shall both explicitly instantiate and explicitly
8771 specialize a template. */
8772 cp_error ("explicit instantiation of `%#D' after", result
);
8773 cp_error_at ("explicit specialization here", result
);
8776 else if (DECL_EXPLICIT_INSTANTIATION (result
))
8780 No program shall explicitly instantiate any template more
8783 We check DECL_INTERFACE_KNOWN so as not to complain when the
8784 first instantiation was `extern' and the second is not, and
8785 EXTERN_P for the opposite case. */
8786 if (DECL_INTERFACE_KNOWN (result
) && !extern_p
)
8787 cp_error ("duplicate explicit instantiation of `%#D'", result
);
8789 /* If we've already instantiated the template, just return now. */
8790 if (DECL_INTERFACE_KNOWN (result
))
8793 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
8795 cp_error ("no matching template for `%D' found", result
);
8798 else if (!DECL_TEMPLATE_INFO (result
))
8800 cp_pedwarn ("explicit instantiation of non-template `%#D'", result
);
8804 if (flag_external_templates
)
8807 if (storage
== NULL_TREE
)
8809 else if (storage
== ridpointers
[(int) RID_EXTERN
])
8812 cp_pedwarn ("ANSI C++ forbids the use of `extern' on explicit instantiations");
8816 cp_error ("storage class `%D' applied to template instantiation",
8819 SET_DECL_EXPLICIT_INSTANTIATION (result
);
8820 mark_decl_instantiated (result
, extern_p
);
8821 repo_template_instantiated (result
, extern_p
);
8823 instantiate_decl (result
);
8827 mark_class_instantiated (t
, extern_p
)
8831 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
8832 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
8833 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
8834 CLASSTYPE_VTABLE_NEEDS_WRITING (t
) = ! extern_p
;
8835 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
8838 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
8839 rest_of_type_compilation (t
, 1);
8844 do_type_instantiation (t
, storage
)
8851 if (TREE_CODE (t
) == TYPE_DECL
)
8854 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
8856 cp_error ("explicit instantiation of non-template type `%T'", t
);
8862 /* With -fexternal-templates, explicit instantiations are treated the same
8863 as implicit ones. */
8864 if (flag_external_templates
)
8867 if (TYPE_SIZE (t
) == NULL_TREE
)
8869 cp_error ("explicit instantiation of `%#T' before definition of template",
8874 if (storage
!= NULL_TREE
)
8877 cp_pedwarn("ANSI C++ forbids the use of `%s' on explicit instantiations",
8878 IDENTIFIER_POINTER (storage
));
8880 if (storage
== ridpointers
[(int) RID_INLINE
])
8882 else if (storage
== ridpointers
[(int) RID_EXTERN
])
8884 else if (storage
== ridpointers
[(int) RID_STATIC
])
8888 cp_error ("storage class `%D' applied to template instantiation",
8894 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
8898 No program shall both explicitly instantiate and explicitly
8899 specialize a template. */
8900 cp_error ("explicit instantiation of `%#T' after", t
);
8901 cp_error_at ("explicit specialization here", t
);
8904 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
8908 No program shall explicitly instantiate any template more
8911 If CLASSTYPE_INTERFACE_ONLY, then the first explicit
8912 instantiation was `extern', and if EXTERN_P then the second
8913 is. Both cases are OK. */
8914 if (!CLASSTYPE_INTERFACE_ONLY (t
) && !extern_p
)
8915 cp_error ("duplicate explicit instantiation of `%#T'", t
);
8917 /* If we've already instantiated the template, just return now. */
8918 if (!CLASSTYPE_INTERFACE_ONLY (t
))
8922 mark_class_instantiated (t
, extern_p
);
8923 repo_template_instantiated (t
, extern_p
);
8931 /* In contrast to implicit instantiation, where only the
8932 declarations, and not the definitions, of members are
8933 instantiated, we have here:
8937 The explicit instantiation of a class template specialization
8938 implies the instantiation of all of its members not
8939 previously explicitly specialized in the translation unit
8940 containing the explicit instantiation.
8942 Of course, we can't instantiate member template classes, since
8943 we don't have any arguments for them. Note that the standard
8944 is unclear on whether the instatiation of the members are
8945 *explicit* instantiations or not. We choose to be generous,
8946 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
8947 the explicit instantiation of a class where some of the members
8948 have no definition in the current translation unit. */
8951 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8952 if (TREE_CODE (tmp
) == FUNCTION_DECL
8953 && DECL_TEMPLATE_INSTANTIATION (tmp
))
8955 mark_decl_instantiated (tmp
, extern_p
);
8956 repo_template_instantiated (tmp
, extern_p
);
8958 instantiate_decl (tmp
);
8961 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8962 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
8964 mark_decl_instantiated (tmp
, extern_p
);
8965 repo_template_instantiated (tmp
, extern_p
);
8967 instantiate_decl (tmp
);
8970 for (tmp
= CLASSTYPE_TAGS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
8971 if (IS_AGGR_TYPE (TREE_VALUE (tmp
))
8972 && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp
))))
8973 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp
)), storage
);
8977 /* Given a function DECL, which is a specialization of TMPL, modify
8978 DECL to be a re-instantiation of TMPL with the same template
8979 arguments. TMPL should be the template into which tsubst'ing
8980 should occur for DECL, not the most general template.
8982 One reason for doing this is a scenario like this:
8985 void f(const T&, int i);
8987 void g() { f(3, 7); }
8990 void f(const T& t, const int i) { }
8992 Note that when the template is first instantiated, with
8993 instantiate_template, the resulting DECL will have no name for the
8994 first parameter, and the wrong type for the second. So, when we go
8995 to instantiate the DECL, we regenerate it. */
8998 regenerate_decl_from_template (decl
, tmpl
)
9008 args
= DECL_TI_ARGS (decl
);
9009 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9011 /* Unregister the specialization so that when we tsubst we will not
9012 just return DECL. We don't have to unregister DECL from TMPL
9013 because if would only be registered there if it were a partial
9014 instantiation of a specialization, which it isn't: it's a full
9016 gen_tmpl
= most_general_template (tmpl
);
9017 unregistered
= unregister_specialization (decl
, gen_tmpl
);
9019 /* If the DECL was not unregistered then something peculiar is
9020 happening: we created a specialization but did not call
9021 register_specialization for it. */
9022 my_friendly_assert (unregistered
, 0);
9024 if (TREE_CODE (decl
) == VAR_DECL
)
9025 /* Make sure that we can see identifiers, and compute access
9026 correctly, for the class members used in the declaration of
9027 this static variable. */
9028 pushclass (DECL_CONTEXT (decl
), 2);
9030 /* Do the substitution to get the new declaration. */
9031 new_decl
= tsubst (code_pattern
, args
, /*complain=*/1, NULL_TREE
);
9033 if (TREE_CODE (decl
) == VAR_DECL
)
9035 /* Set up DECL_INITIAL, since tsubst doesn't. */
9036 DECL_INITIAL (new_decl
) =
9037 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
9038 /*complain=*/1, DECL_TI_TEMPLATE (decl
));
9039 /* Pop the class context we pushed above. */
9042 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
9044 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
9046 DECL_INITIAL (new_decl
) = error_mark_node
;
9047 /* And don't complain about a duplicate definition. */
9048 DECL_INITIAL (decl
) = NULL_TREE
;
9051 /* The immediate parent of the new template is still whatever it was
9052 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
9053 general template. We also reset the DECL_ASSEMBLER_NAME since
9054 tsubst always calculates the name as if the function in question
9055 were really a template instance, and sometimes, with friend
9056 functions, this is not so. See tsubst_friend_function for
9058 DECL_TI_TEMPLATE (new_decl
) = DECL_TI_TEMPLATE (decl
);
9059 DECL_ASSEMBLER_NAME (new_decl
) = DECL_ASSEMBLER_NAME (decl
);
9060 DECL_RTL (new_decl
) = DECL_RTL (decl
);
9062 /* Call duplicate decls to merge the old and new declarations. */
9063 duplicate_decls (new_decl
, decl
);
9065 /* Now, re-register the specialization. */
9066 register_specialization (decl
, gen_tmpl
, args
);
9069 /* Produce the definition of D, a _DECL generated from a template. */
9072 instantiate_decl (d
)
9075 tree tmpl
= DECL_TI_TEMPLATE (d
);
9076 tree args
= DECL_TI_ARGS (d
);
9081 int nested
= in_function_p ();
9082 int pattern_defined
;
9084 char *file
= input_filename
;
9086 /* This function should only be used to instantiate templates for
9087 functions and static member variables. */
9088 my_friendly_assert (TREE_CODE (d
) == FUNCTION_DECL
9089 || TREE_CODE (d
) == VAR_DECL
, 0);
9091 if (DECL_TEMPLATE_INSTANTIATED (d
))
9092 /* D has already been instantiated. It might seem reasonable to
9093 check whether or not D is an explict instantiation, and, if so,
9094 stop here. But when an explicit instantiation is deferred
9095 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
9096 is set, even though we still need to do the instantiation. */
9099 /* If we already have a specialization of this declaration, then
9100 there's no reason to instantiate it. Note that
9101 retrieve_specialization gives us both instantiations and
9102 specializations, so we must explicitly check
9103 DECL_TEMPLATE_SPECIALIZATION. */
9104 gen_tmpl
= most_general_template (tmpl
);
9105 spec
= retrieve_specialization (gen_tmpl
, args
);
9106 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
9109 /* This needs to happen before any tsubsting. */
9110 if (! push_tinst_level (d
))
9113 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
9114 for the instantiation. This is not always the most general
9115 template. Consider, for example:
9118 struct S { template <class U> void f();
9119 template <> void f<int>(); };
9121 and an instantiation of S<double>::f<int>. We want TD to be the
9122 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
9125 /* An instantiation cannot have a definition, so we need a
9126 more general template. */
9127 DECL_TEMPLATE_INSTANTIATION (td
)
9128 /* We must also deal with friend templates. Given:
9130 template <class T> struct S {
9131 template <class U> friend void f() {};
9134 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
9135 so far as the language is concerned, but that's still
9136 where we get the pattern for the instantiation from. On
9137 ther hand, if the definition comes outside the class, say:
9139 template <class T> struct S {
9140 template <class U> friend void f();
9142 template <class U> friend void f() {}
9144 we don't need to look any further. That's what the check for
9145 DECL_INITIAL is for. */
9146 || (TREE_CODE (d
) == FUNCTION_DECL
9147 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td
)
9148 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td
)));
9151 /* The present template, TD, should not be a definition. If it
9152 were a definition, we should be using it! Note that we
9153 cannot restructure the loop to just keep going until we find
9154 a template with a definition, since that might go too far if
9155 a specialization was declared, but not defined. */
9156 my_friendly_assert (!(TREE_CODE (d
) == VAR_DECL
9157 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td
))),
9160 /* Fetch the more general template. */
9161 td
= DECL_TI_TEMPLATE (td
);
9164 code_pattern
= DECL_TEMPLATE_RESULT (td
);
9166 if (TREE_CODE (d
) == FUNCTION_DECL
)
9167 pattern_defined
= (DECL_INITIAL (code_pattern
) != NULL_TREE
);
9169 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
9171 push_to_top_level ();
9172 lineno
= DECL_SOURCE_LINE (d
);
9173 input_filename
= DECL_SOURCE_FILE (d
);
9175 if (pattern_defined
)
9177 repo_template_used (d
);
9179 if (flag_external_templates
&& ! DECL_INTERFACE_KNOWN (d
))
9181 if (flag_alt_external_templates
)
9183 if (interface_unknown
)
9184 warn_if_unknown_interface (d
);
9186 else if (DECL_INTERFACE_KNOWN (code_pattern
))
9188 DECL_INTERFACE_KNOWN (d
) = 1;
9189 DECL_NOT_REALLY_EXTERN (d
) = ! DECL_EXTERNAL (code_pattern
);
9192 warn_if_unknown_interface (code_pattern
);
9196 import_export_decl (d
);
9199 /* Reject all external templates except inline functions. */
9200 if (DECL_INTERFACE_KNOWN (d
)
9201 && ! DECL_NOT_REALLY_EXTERN (d
)
9202 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
)))
9205 if (TREE_CODE (d
) == VAR_DECL
9206 && TREE_READONLY (d
)
9207 && DECL_INITIAL (d
) == NULL_TREE
9208 && DECL_INITIAL (code_pattern
) != NULL_TREE
)
9209 /* We need to set up DECL_INITIAL regardless of pattern_defined if
9210 the variable is a static const initialized in the class body. */;
9211 else if (! pattern_defined
9212 || (! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
) && nested
)
9215 /* Defer all templates except inline functions used in another
9216 function. We restore the source position here because it's used
9217 by add_pending_template. */
9219 input_filename
= file
;
9221 if (at_eof
&& !pattern_defined
9222 && DECL_EXPLICIT_INSTANTIATION (d
))
9225 The definition of a non-exported function template, a
9226 non-exported member function template, or a non-exported
9227 member function or static data member of a class template
9228 shall be present in every translation unit in which it is
9229 explicitly instantiated. */
9230 cp_error ("explicit instantiation of `%D' but no definition available",
9233 add_pending_template (d
);
9237 /* We're now committed to instantiating this template. Mark it as
9238 instantiated so that recursive calls to instantiate_decl do not
9239 try to instantiate it again. */
9240 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
9242 /* Regenerate the declaration in case the template has been modified
9243 by a subsequent redeclaration. */
9244 regenerate_decl_from_template (d
, td
);
9246 /* We already set the file and line above. Reset them now in case
9247 they changed as a result of calling regenerate_decl_from_template. */
9248 lineno
= DECL_SOURCE_LINE (d
);
9249 input_filename
= DECL_SOURCE_FILE (d
);
9251 if (TREE_CODE (d
) == VAR_DECL
)
9253 DECL_IN_AGGR_P (d
) = 0;
9254 if (DECL_INTERFACE_KNOWN (d
))
9255 DECL_EXTERNAL (d
) = ! DECL_NOT_REALLY_EXTERN (d
);
9258 DECL_EXTERNAL (d
) = 1;
9259 DECL_NOT_REALLY_EXTERN (d
) = 1;
9261 cp_finish_decl (d
, DECL_INITIAL (d
), NULL_TREE
, 0, 0);
9263 else if (TREE_CODE (d
) == FUNCTION_DECL
)
9265 tree t
= DECL_SAVED_TREE (code_pattern
);
9267 start_function (NULL_TREE
, d
, NULL_TREE
, 1);
9268 store_parm_decls ();
9270 if (t
&& TREE_CODE (t
) == RETURN_INIT
)
9273 (TREE_OPERAND (t
, 0),
9274 tsubst_expr (TREE_OPERAND (t
, 1), args
, /*complain=*/1, tmpl
));
9278 if (t
&& TREE_CODE (t
) == CTOR_INITIALIZER
)
9280 current_member_init_list
9281 = tsubst_expr_values (TREE_OPERAND (t
, 0), args
);
9282 current_base_init_list
9283 = tsubst_expr_values (TREE_OPERAND (t
, 1), args
);
9288 /* Always keep the BLOCK node associated with the outermost
9289 pair of curly braces of a function. These are needed
9290 for correct operation of dwarfout.c. */
9293 my_friendly_assert (TREE_CODE (t
) == COMPOUND_STMT
, 42);
9294 tsubst_expr (t
, args
, /*complain=*/1, tmpl
);
9296 finish_function (lineno
, 0, nested
);
9301 input_filename
= file
;
9303 pop_from_top_level ();
9309 /* Substitute ARGVEC into T, which is a TREE_LIST. In particular, it
9310 is an initializer list: the TREE_PURPOSEs are DECLs, and the
9311 TREE_VALUEs are initializer values. Used by instantiate_decl. */
9314 tsubst_expr_values (t
, argvec
)
9317 tree first
= NULL_TREE
;
9320 for (; t
; t
= TREE_CHAIN (t
))
9322 tree pur
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
9323 /*complain=*/1, NULL_TREE
);
9324 tree val
= tsubst_expr (TREE_VALUE (t
), argvec
, /*complain=*/1,
9326 *p
= build_tree_list (pur
, val
);
9327 p
= &TREE_CHAIN (*p
);
9338 last_tree
= TREE_CHAIN (last_tree
) = t
;
9345 saved_trees
= tree_cons (NULL_TREE
, last_tree
, saved_trees
);
9346 last_tree
= NULL_TREE
;
9353 my_friendly_assert (saved_trees
!= NULL_TREE
, 0);
9355 last_tree
= TREE_VALUE (saved_trees
);
9356 saved_trees
= TREE_CHAIN (saved_trees
);
9359 /* D is an undefined function declaration in the presence of templates with
9360 the same name, listed in FNS. If one of them can produce D as an
9361 instantiation, remember this so we can instantiate it at EOF if D has
9362 not been defined by that time. */
9365 add_maybe_template (d
, fns
)
9370 if (DECL_MAYBE_TEMPLATE (d
))
9373 t
= most_specialized (fns
, d
, NULL_TREE
);
9376 if (t
== error_mark_node
)
9378 cp_error ("ambiguous template instantiation for `%D'", d
);
9382 *maybe_template_tail
= perm_tree_cons (t
, d
, NULL_TREE
);
9383 maybe_template_tail
= &TREE_CHAIN (*maybe_template_tail
);
9384 DECL_MAYBE_TEMPLATE (d
) = 1;
9387 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
9390 set_current_access_from_decl (decl
)
9393 if (TREE_PRIVATE (decl
))
9394 current_access_specifier
= access_private_node
;
9395 else if (TREE_PROTECTED (decl
))
9396 current_access_specifier
= access_protected_node
;
9398 current_access_specifier
= access_public_node
;
9401 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
9402 is the instantiation (which should have been created with
9403 start_enum) and ARGS are the template arguments to use. */
9406 tsubst_enum (tag
, newtag
, args
)
9413 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
9418 /* Note that in a template enum, the TREE_VALUE is the
9419 CONST_DECL, not the corresponding INTEGER_CST. */
9420 value
= tsubst_expr (DECL_INITIAL (TREE_VALUE (e
)),
9421 args
, /*complain=*/1,
9424 /* Give this enumeration constant the correct access. */
9425 set_current_access_from_decl (TREE_VALUE (e
));
9427 /* Actually build the enumerator itself. */
9428 elt
= build_enumerator (TREE_PURPOSE (e
), value
, newtag
);
9430 /* We save the enumerators we have built so far in the
9431 TYPE_VALUES so that if the enumeration constants for
9432 subsequent enumerators involve those for previous ones,
9433 tsubst_copy will be able to find them. */
9434 TREE_CHAIN (elt
) = TYPE_VALUES (newtag
);
9435 TYPE_VALUES (newtag
) = elt
;
9438 finish_enum (newtag
);
9441 /* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
9442 is either an instantiation or specialization of a template
9446 set_mangled_name_for_template_decl (decl
)
9449 tree saved_namespace
;
9450 tree context
= NULL_TREE
;
9459 my_friendly_assert (TREE_CODE (decl
) == FUNCTION_DECL
, 0);
9460 my_friendly_assert (DECL_TEMPLATE_INFO (decl
) != NULL_TREE
, 0);
9462 /* The names of template functions must be mangled so as to indicate
9463 what template is being specialized with what template arguments.
9464 For example, each of the following three functions must get
9465 different mangled names:
9468 template <> void f<7>(int);
9469 template <> void f<8>(int); */
9471 targs
= DECL_TI_ARGS (decl
);
9472 if (uses_template_parms (targs
))
9473 /* This DECL is for a partial instantiation. There's no need to
9474 mangle the name of such an entity. */
9477 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
9478 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
9479 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
9481 /* There should be as many levels of arguments as there are levels
9483 my_friendly_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
), 0);
9485 /* We now compute the PARMS and RET_TYPE to give to
9486 build_decl_overload_real. The PARMS and RET_TYPE are the
9487 parameter and return types of the template, after all but the
9488 innermost template arguments have been substituted, not the
9489 parameter and return types of the function DECL. For example,
9492 template <class T> T f(T);
9494 both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'.
9495 A more subtle example is:
9497 template <class T> struct S { template <class U> void f(T, U); }
9499 Here, if DECL is `void S<int>::f(int, double)', PARMS should be
9500 {int, U}. Thus, the args that we want to subsitute into the
9501 return and parameter type for the function are those in TARGS,
9502 with the innermost level omitted. */
9503 fn_type
= TREE_TYPE (tmpl
);
9504 if (DECL_STATIC_FUNCTION_P (decl
))
9505 context
= DECL_CLASS_CONTEXT (decl
);
9507 if (parm_depth
== 1)
9508 /* No substitution is necessary. */
9515 /* Replace the innermost level of the TARGS with NULL_TREEs to
9516 let tsubst know not to subsitute for those parameters. */
9517 partial_args
= make_temp_vec (TREE_VEC_LENGTH (targs
));
9518 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
9519 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
9520 TMPL_ARGS_LEVEL (targs
, i
));
9521 SET_TMPL_ARGS_LEVEL (partial_args
,
9522 TMPL_ARGS_DEPTH (targs
),
9523 make_temp_vec (DECL_NTPARMS (tmpl
)));
9525 /* Now, do the (partial) substitution to figure out the
9526 appropriate function type. */
9527 fn_type
= tsubst (fn_type
, partial_args
, /*complain=*/1, NULL_TREE
);
9528 if (DECL_STATIC_FUNCTION_P (decl
))
9529 context
= tsubst (context
, partial_args
, /*complain=*/1, NULL_TREE
);
9531 /* Substitute into the template parameters to obtain the real
9532 innermost set of parameters. This step is important if the
9533 innermost set of template parameters contains value
9534 parameters whose types depend on outer template parameters. */
9535 TREE_VEC_LENGTH (partial_args
)--;
9536 tparms
= tsubst_template_parms (tparms
, partial_args
, /*complain=*/1);
9539 /* Now, get the innermost parameters and arguments, and figure out
9540 the parameter and return types. */
9541 tparms
= INNERMOST_TEMPLATE_PARMS (tparms
);
9542 targs
= innermost_args (targs
);
9543 ret_type
= TREE_TYPE (fn_type
);
9544 parm_types
= TYPE_ARG_TYPES (fn_type
);
9546 /* For a static member function, we generate a fake `this' pointer,
9547 for the purposes of mangling. This indicates of which class the
9548 function is a member. Because of:
9552 There shall not be a static and a nonstatic member function
9553 with the same name and the same parameter types
9555 we don't have to worry that this will result in a clash with a
9556 non-static member function. */
9557 if (DECL_STATIC_FUNCTION_P (decl
))
9558 parm_types
= hash_tree_chain (build_pointer_type (context
), parm_types
);
9560 /* There should be the same number of template parameters as
9561 template arguments. */
9562 my_friendly_assert (TREE_VEC_LENGTH (tparms
) == TREE_VEC_LENGTH (targs
),
9565 /* If the template is in a namespace, we need to put that into the
9566 mangled name. Unfortunately, build_decl_overload_real does not
9567 get the decl to mangle, so it relies on the current
9568 namespace. Therefore, we set that here temporarily. */
9569 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd', 980702);
9570 saved_namespace
= current_namespace
;
9571 current_namespace
= CP_DECL_CONTEXT (decl
);
9573 /* Actually set the DCL_ASSEMBLER_NAME. */
9574 DECL_ASSEMBLER_NAME (decl
)
9575 = build_decl_overload_real (DECL_NAME (decl
), parm_types
, ret_type
,
9577 DECL_FUNCTION_MEMBER_P (decl
)
9578 + DECL_CONSTRUCTOR_P (decl
));
9580 /* Restore the previously active namespace. */
9581 current_namespace
= saved_namespace
;