1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Known bugs or deficiencies include:
22 * templates for class static data don't work (methods only)
23 * duplicated method templates can crash the compiler
24 * interface/impl data is taken from file defining the template
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"
27 * method templates must be seen before the expansion of the
28 class template is done
42 extern struct obstack permanent_obstack;
43 extern tree grokdeclarator ();
46 extern char *input_filename;
47 struct pending_inline *pending_template_expansions;
49 int processing_template_decl;
50 int processing_template_defn;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
56 static void add_pending_template ();
58 void overload_template_name (), pop_template_decls ();
60 /* We've got a template header coming up; set obstacks up to save the
61 nodes created permanently. (There might be cases with nested templates
62 where we don't have to do this, but they aren't implemented, and it
63 probably wouldn't be worth the effort.) */
65 begin_template_parm_list ()
68 push_obstacks (&permanent_obstack, &permanent_obstack);
72 /* Process information from new template parameter NEXT and append it to the
73 LIST being built. The rules for use of a template parameter type name
74 by later parameters are not well-defined for us just yet. However, the
75 only way to avoid having to parse expressions of unknown complexity (and
76 with tokens of unknown types) is to disallow it completely. So for now,
77 that is what is assumed. */
79 process_template_parm (list, next)
87 my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);
88 defval = TREE_PURPOSE (parm);
89 parm = TREE_VALUE (parm);
90 is_type = TREE_PURPOSE (parm) == class_type_node;
94 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260);
95 /* is a const-param */
96 parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm),
98 /* A template parameter is not modifiable. */
99 TREE_READONLY (parm) = 1;
100 if (IS_AGGR_TYPE (TREE_TYPE (parm)))
102 sorry ("aggregate template parameter types");
103 TREE_TYPE (parm) = void_type_node;
105 tinfo = make_node (TEMPLATE_CONST_PARM);
106 my_friendly_assert (TREE_PERMANENT (tinfo), 260.5);
107 if (TREE_PERMANENT (parm) == 0)
109 parm = copy_node (parm);
110 TREE_PERMANENT (parm) = 1;
112 TREE_TYPE (tinfo) = TREE_TYPE (parm);
113 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
114 DECL_INITIAL (decl) = tinfo;
115 DECL_INITIAL (parm) = tinfo;
119 tree t = make_node (TEMPLATE_TYPE_PARM);
120 decl = build_decl (TYPE_DECL, TREE_VALUE (parm), t);
121 TYPE_MAIN_DECL (t) = decl;
125 if (IDENTIFIER_HAS_TYPE_VALUE (defval))
126 defval = IDENTIFIER_TYPE_VALUE (defval);
128 defval = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (defval));
131 SET_DECL_ARTIFICIAL (decl);
133 parm = build_tree_list (defval, parm);
134 return chainon (list, parm);
137 /* The end of a template parameter list has been reached. Process the
138 tree list into a parameter vector, converting each parameter into a more
139 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
143 end_template_parm_list (parms)
150 for (parm = parms; parm; parm = TREE_CHAIN (parm))
152 saved_parmlist = make_tree_vec (nparms);
154 for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++)
156 tree p = TREE_VALUE (parm);
157 if (TREE_PURPOSE (parm))
159 else if (saw_default)
161 error ("if a default argument is given for one template parameter");
162 error ("default arguments must be given for all subsequent");
163 error ("parameters as well");
166 if (TREE_CODE (p) == TYPE_DECL)
168 tree t = TREE_TYPE (p);
169 TEMPLATE_TYPE_SET_INFO (t, saved_parmlist, nparms);
173 tree tinfo = DECL_INITIAL (p);
174 DECL_INITIAL (p) = NULL_TREE;
175 TEMPLATE_CONST_SET_INFO (tinfo, saved_parmlist, nparms);
177 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
179 set_current_level_tags_transparency (1);
180 processing_template_decl++;
181 return saved_parmlist;
184 /* end_template_decl is called after a template declaration is seen.
185 D1 is template header; D2 is class_head_sans_basetype or a
186 TEMPLATE_DECL with its DECL_RESULT field set. */
188 end_template_decl (d1, d2, is_class, defn)
189 tree d1, d2, is_class;
193 struct template_info *tmpl;
195 tmpl = (struct template_info *) obstack_alloc (&permanent_obstack,
196 sizeof (struct template_info));
199 tmpl->aggr = is_class;
201 /* cloned from reinit_parse_for_template */
202 tmpl->filename = input_filename;
203 tmpl->lineno = lineno;
204 tmpl->parm_vec = d1; /* [eichin:19911015.2306EST] */
206 if (d2 == NULL_TREE || d2 == error_mark_node)
214 decl = build_lang_decl (TEMPLATE_DECL, d2, NULL_TREE);
215 GNU_xref_decl (current_function_decl, decl);
219 if (TREE_CODE (d2) == TEMPLATE_DECL)
223 /* Class destructor templates and operator templates are
224 slipping past as non-template nodes. Process them here, since
225 I haven't figured out where to catch them earlier. I could
226 go do that, but it's a choice between getting that done and
227 staying only N months behind schedule. Sorry.... */
229 my_friendly_assert (TREE_CODE (d2) == CALL_EXPR, 263);
230 code = TREE_CODE (TREE_OPERAND (d2, 0));
231 my_friendly_assert (code == BIT_NOT_EXPR
232 || code == OP_IDENTIFIER
233 || code == SCOPE_REF, 264);
234 d2 = grokdeclarator (d2, NULL_TREE, MEMFUNCDEF, 0, NULL_TREE);
235 decl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (d2),
237 DECL_TEMPLATE_RESULT (decl) = d2;
238 DECL_CONTEXT (decl) = DECL_CONTEXT (d2);
239 DECL_CLASS_CONTEXT (decl) = DECL_CLASS_CONTEXT (d2);
240 DECL_NAME (decl) = DECL_NAME (d2);
241 TREE_TYPE (decl) = TREE_TYPE (d2);
242 if (interface_unknown && flag_external_templates
243 && ! flag_alt_external_templates
244 && ! DECL_IN_SYSTEM_HEADER (decl))
245 warn_if_unknown_interface (decl);
246 TREE_PUBLIC (decl) = TREE_PUBLIC (d2) = flag_external_templates && !interface_unknown;
247 DECL_EXTERNAL (decl) = (DECL_EXTERNAL (d2)
248 && !(DECL_CLASS_CONTEXT (d2)
249 && !DECL_THIS_EXTERN (d2)));
252 /* All routines creating TEMPLATE_DECL nodes should now be using
253 build_lang_decl, which will have set this up already. */
254 my_friendly_assert (DECL_LANG_SPECIFIC (decl) != 0, 265);
256 /* @@ Somewhere, permanent allocation isn't being used. */
257 if (! DECL_TEMPLATE_IS_CLASS (decl)
258 && TREE_CODE (DECL_TEMPLATE_RESULT (decl)) == FUNCTION_DECL)
260 tree result = DECL_TEMPLATE_RESULT (decl);
261 /* Will do nothing if allocation was already permanent. */
262 DECL_ARGUMENTS (result) = copy_to_permanent (DECL_ARGUMENTS (result));
265 /* If this is for a method, there's an extra binding level here. */
266 if (DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
268 /* @@ Find out where this should be getting set! */
269 tree r = DECL_TEMPLATE_RESULT (decl);
270 if (DECL_LANG_SPECIFIC (r) && DECL_CLASS_CONTEXT (r) == NULL_TREE)
271 DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r);
274 DECL_TEMPLATE_INFO (decl) = tmpl;
275 DECL_TEMPLATE_PARMS (decl) = d1;
277 /* So that duplicate_decls can do the right thing. */
279 DECL_INITIAL (decl) = error_mark_node;
281 /* If context of decl is non-null (i.e., method template), add it
282 to the appropriate class template, and pop the binding levels. */
283 if (! is_class && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
285 tree ctx = DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl));
287 my_friendly_assert (TREE_CODE (ctx) == UNINSTANTIATED_P_TYPE, 266);
288 tmpl = UPT_TEMPLATE (ctx);
289 for (t = DECL_TEMPLATE_MEMBERS (tmpl); t; t = TREE_CHAIN (t))
290 if (TREE_PURPOSE (t) == DECL_NAME (decl)
291 && duplicate_decls (decl, TREE_VALUE (t)))
293 DECL_TEMPLATE_MEMBERS (tmpl) =
294 perm_tree_cons (DECL_NAME (decl), decl, DECL_TEMPLATE_MEMBERS (tmpl));
299 /* Otherwise, go back to top level first, and push the template decl
308 #if 0 /* It happens sometimes, with syntactic or semantic errors.
311 template <class A, int X, int Y> class Foo { ... };
312 template <class A, int X, int y> Foo<X,Y>::method (Foo& x) { ... }
313 Note the missing "A" in the class containing "method". */
314 my_friendly_assert (global_bindings_p (), 267);
316 while (! global_bindings_p ())
320 processing_template_decl--;
321 (void) get_pending_sizes ();
324 /* If TYPE contains a template parm type, then substitute that type
325 with its actual type that is found in TVEC. */
327 grok_template_type (tvec, type)
331 switch (TREE_CODE (*type))
333 case TEMPLATE_TYPE_PARM:
334 if (*type != TYPE_MAIN_VARIANT (*type))
336 /* we are here for cases like const T* etc. */
337 grok_template_type (tvec, &TYPE_MAIN_VARIANT (*type));
338 *type = cp_build_type_variant (TYPE_MAIN_VARIANT (*type),
339 TYPE_READONLY (*type),
340 TYPE_VOLATILE (*type));
343 *type = TREE_VEC_ELT (tvec, TEMPLATE_TYPE_IDX (*type));
347 grok_template_type (tvec, &TREE_TYPE (*type));
353 /* take care of function's return type first */
354 grok_template_type (tvec, &TREE_TYPE (*type));
356 /* take care of function's arguments */
357 for (p = TYPE_ARG_TYPES (*type); p; p = TREE_CHAIN (p))
358 grok_template_type (tvec, &TREE_VALUE (p));
367 /* Convert all template arguments to their appropriate types, and return
368 a vector containing the resulting values. If any error occurs, return
371 coerce_template_parms (parms, arglist, in_decl)
375 int nparms, nargs, i, lost = 0;
378 if (arglist == NULL_TREE)
380 else if (TREE_CODE (arglist) == TREE_VEC)
381 nargs = TREE_VEC_LENGTH (arglist);
383 nargs = list_length (arglist);
385 nparms = TREE_VEC_LENGTH (parms);
389 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
391 error ("incorrect number of parameters (%d, should be %d)",
394 cp_error_at ("in template expansion for decl `%D'", in_decl);
395 return error_mark_node;
398 if (arglist && TREE_CODE (arglist) == TREE_VEC)
399 vec = copy_node (arglist);
402 vec = make_tree_vec (nparms);
403 for (i = 0; i < nparms; i++)
410 arglist = TREE_CHAIN (arglist);
412 if (arg == error_mark_node)
415 arg = TREE_VALUE (arg);
418 arg = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
420 TREE_VEC_ELT (vec, i) = arg;
423 for (i = 0; i < nparms; i++)
425 tree arg = TREE_VEC_ELT (vec, i);
426 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
428 int is_type, requires_type;
430 is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't';
431 requires_type = TREE_CODE (parm) == TYPE_DECL;
432 if (is_type != requires_type)
435 cp_error ("type/value mismatch in template parameter list for `%D'",
438 TREE_VEC_ELT (vec, i) = error_mark_node;
442 val = groktypename (arg);
443 else if (TREE_CODE (arg) == STRING_CST)
445 cp_error ("string literal %E is not a valid template argument", arg);
446 error ("because it is the address of an object with static linkage");
447 val = error_mark_node;
451 grok_template_type (vec, &TREE_TYPE (parm));
452 val = digest_init (TREE_TYPE (parm), arg, (tree *) 0);
454 if (val == error_mark_node)
457 /* 14.2: Other template-arguments must be constant-expressions,
458 addresses of objects or functions with external linkage, or of
459 static class members. */
460 else if (!TREE_CONSTANT (val))
462 cp_error ("non-const `%E' cannot be used as template argument",
464 val = error_mark_node;
466 else if (TREE_CODE (val) == ADDR_EXPR)
468 tree a = TREE_OPERAND (val, 0);
469 if ((TREE_CODE (a) == VAR_DECL
470 || TREE_CODE (a) == FUNCTION_DECL)
471 && ! DECL_PUBLIC (a))
473 cp_error ("address of non-extern `%E' cannot be used as template argument", a);
474 val = error_mark_node;
479 if (val == error_mark_node)
482 TREE_VEC_ELT (vec, i) = val;
485 return error_mark_node;
489 /* Given class template name and parameter list, produce a user-friendly name
490 for the instantiation. */
492 mangle_class_name_for_template (name, parms, arglist)
496 static struct obstack scratch_obstack;
497 static char *scratch_firstobj;
500 if (!scratch_firstobj)
502 gcc_obstack_init (&scratch_obstack);
503 scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
506 obstack_free (&scratch_obstack, scratch_firstobj);
509 #define buflen sizeof(buf)
510 #define check if (bufp >= buf+buflen-1) goto too_long
511 #define ccat(c) *bufp++=(c); check
512 #define advance bufp+=strlen(bufp); check
513 #define cat(s) strncpy(bufp, s, buf+buflen-bufp-1); advance
516 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
518 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
523 nparms = TREE_VEC_LENGTH (parms);
524 my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268);
525 for (i = 0; i < nparms; i++)
527 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
528 tree arg = TREE_VEC_ELT (arglist, i);
533 if (TREE_CODE (parm) == TYPE_DECL)
535 cat (type_as_string (arg, 0));
539 my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
541 if (TREE_CODE (arg) == TREE_LIST)
543 /* New list cell was built because old chain link was in
545 my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270);
546 arg = TREE_VALUE (arg);
548 /* No need to check arglist against parmlist here; we did that
549 in coerce_template_parms, called from lookup_template_class. */
550 cat (expr_as_string (arg, 0));
553 char *bufp = obstack_next_free (&scratch_obstack);
555 while (bufp[offset - 1] == ' ')
557 obstack_blank_fast (&scratch_obstack, offset);
559 /* B<C<char> >, not B<C<char>> */
560 if (bufp[offset - 1] == '>')
565 return (char *) obstack_base (&scratch_obstack);
570 fatal ("out of (preallocated) string space creating template instantiation name");
575 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
576 parameters, find the desired type.
578 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
579 Since ARGLIST is build on the decl_obstack, we must copy it here
580 to keep it from being reclaimed when the decl storage is reclaimed.
582 IN_DECL, if non-NULL, is the template declaration we are trying to
585 lookup_template_class (d1, arglist, in_decl)
589 tree template, parmlist;
593 my_friendly_assert (TREE_CODE (d1) == IDENTIFIER_NODE, 272);
594 template = IDENTIFIER_GLOBAL_VALUE (d1); /* XXX */
596 template = IDENTIFIER_CLASS_VALUE (d1);
597 /* With something like `template <class T> class X class X { ... };'
598 we could end up with D1 having nothing but an IDENTIFIER_LOCAL_VALUE.
599 We don't want to do that, but we have to deal with the situation, so
600 let's give them some syntax errors to chew on instead of a crash. */
602 return error_mark_node;
603 if (TREE_CODE (template) != TEMPLATE_DECL)
605 cp_error ("non-template type `%T' used as a template", d1);
607 cp_error_at ("for template declaration `%D'", in_decl);
608 return error_mark_node;
610 parmlist = DECL_TEMPLATE_PARMS (template);
612 arglist = coerce_template_parms (parmlist, arglist, template);
613 if (arglist == error_mark_node)
614 return error_mark_node;
615 if (uses_template_parms (arglist))
617 tree t = make_lang_type (UNINSTANTIATED_P_TYPE);
619 id = make_anon_name ();
620 d = build_decl (TYPE_DECL, id, t);
622 TYPE_VALUES (t) = build_tree_list (template, arglist);
623 pushdecl_top_level (d);
627 mangled_name = mangle_class_name_for_template (IDENTIFIER_POINTER (d1),
629 id = get_identifier (mangled_name);
631 if (!IDENTIFIER_TEMPLATE (id))
633 arglist = copy_to_permanent (arglist);
634 IDENTIFIER_TEMPLATE (id) = perm_tree_cons (template, arglist, NULL_TREE);
640 push_template_decls (parmlist, arglist, class_level)
641 tree parmlist, arglist;
646 /* Don't want to push values into global context. */
650 declare_pseudo_global_level ();
653 nparms = TREE_VEC_LENGTH (parmlist);
655 for (i = 0; i < nparms; i++)
657 int requires_type, is_type;
658 tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i));
659 tree arg = TREE_VEC_ELT (arglist, i);
662 requires_type = TREE_CODE (parm) == TYPE_DECL;
663 is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't';
666 /* add typename to namespace */
669 error ("template use error: type provided where value needed");
673 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 't', 273);
674 decl = build_decl (TYPE_DECL, DECL_NAME (parm), decl);
678 /* add const decl to namespace */
682 error ("template use error: value provided where type needed");
685 val = digest_init (TREE_TYPE (parm), arg, (tree *) 0);
686 if (val != error_mark_node)
688 decl = build_decl (CONST_DECL, DECL_NAME (parm),
690 DECL_INITIAL (decl) = val;
691 TREE_READONLY (decl) = 1;
696 SET_DECL_ARTIFICIAL (decl);
697 layout_decl (decl, 0);
699 pushdecl_class_level (decl);
707 pop_template_decls (parmlist, arglist, class_level)
708 tree parmlist, arglist;
715 /* Should be defined in parse.h. */
719 uses_template_parms (t)
724 switch (TREE_CODE (t))
728 /* We assume that the object must be instantiated in order to build
729 the COMPONENT_REF, so we test only whether the type of the
730 COMPONENT_REF uses template parms. */
731 return uses_template_parms (TREE_TYPE (t));
733 case IDENTIFIER_NODE:
734 if (!IDENTIFIER_TEMPLATE (t))
736 return uses_template_parms (TREE_VALUE (IDENTIFIER_TEMPLATE (t)));
738 /* aggregates of tree nodes */
741 int i = TREE_VEC_LENGTH (t);
743 if (uses_template_parms (TREE_VEC_ELT (t, i)))
748 if (uses_template_parms (TREE_PURPOSE (t))
749 || uses_template_parms (TREE_VALUE (t)))
751 return uses_template_parms (TREE_CHAIN (t));
753 /* constructed type nodes */
756 return uses_template_parms (TREE_TYPE (t));
758 if (TYPE_PTRMEMFUNC_FLAG (t))
759 return uses_template_parms (TYPE_PTRMEMFUNC_FN_TYPE (t));
763 if (!TYPE_IDENTIFIER (t))
765 return uses_template_parms (TYPE_IDENTIFIER (t));
767 if (uses_template_parms (TYPE_ARG_TYPES (t)))
769 return uses_template_parms (TREE_TYPE (t));
771 if (uses_template_parms (TYPE_DOMAIN (t)))
773 return uses_template_parms (TREE_TYPE (t));
775 if (uses_template_parms (TYPE_OFFSET_BASETYPE (t)))
777 return uses_template_parms (TREE_TYPE (t));
779 if (uses_template_parms (TYPE_OFFSET_BASETYPE (t)))
781 if (uses_template_parms (TYPE_ARG_TYPES (t)))
783 return uses_template_parms (TREE_TYPE (t));
787 return uses_template_parms (DECL_NAME (t));
789 if (uses_template_parms (TREE_TYPE (t)))
794 /* ??? What about FIELD_DECLs? */
795 /* The type of a decl can't use template parms if the name of the
796 variable doesn't, because it's impossible to resolve them. So
797 ignore the type field for now. */
798 if (DECL_CONTEXT (t) && uses_template_parms (DECL_CONTEXT (t)))
800 if (uses_template_parms (TREE_TYPE (t)))
802 error ("template parms used where they can't be resolved");
807 return uses_template_parms (TREE_TYPE (t));
809 return uses_template_parms (TREE_OPERAND (t, 0));
811 /* template parm nodes */
812 case TEMPLATE_TYPE_PARM:
813 case TEMPLATE_CONST_PARM:
816 /* simple type nodes */
818 if (uses_template_parms (TYPE_MIN_VALUE (t)))
820 return uses_template_parms (TYPE_MAX_VALUE (t));
835 /* Non-error_mark_node ERROR_MARKs are bad things. */
836 my_friendly_assert (t == error_mark_node, 274);
840 case UNINSTANTIATED_P_TYPE:
844 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
845 return uses_template_parms (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
846 /* else fall through */
849 switch (TREE_CODE_CLASS (TREE_CODE (t)))
857 for (i = tree_code_length[(int) TREE_CODE (t)]; --i >= 0;)
858 if (uses_template_parms (TREE_OPERAND (t, i)))
865 sorry ("testing %s for template parms",
866 tree_code_name [(int) TREE_CODE (t)]);
867 my_friendly_abort (82);
874 instantiate_member_templates (classname)
879 tree members = DECL_TEMPLATE_MEMBERS (TREE_PURPOSE (IDENTIFIER_TEMPLATE (id)));
881 for (t = members; t; t = TREE_CHAIN (t))
883 tree parmvec, type, classparms, tdecl, t2;
884 int nparms, xxx = 0, i;
886 my_friendly_assert (TREE_VALUE (t) != NULL_TREE, 275);
887 my_friendly_assert (TREE_CODE (TREE_VALUE (t)) == TEMPLATE_DECL, 276);
888 /* @@ Should verify that class parm list is a list of
889 distinct template parameters, and covers all the template
891 tdecl = TREE_VALUE (t);
892 type = DECL_CONTEXT (DECL_TEMPLATE_RESULT (tdecl));
893 classparms = UPT_PARMS (type);
894 nparms = TREE_VEC_LENGTH (classparms);
895 parmvec = make_tree_vec (nparms);
896 for (i = 0; i < nparms; i++)
897 TREE_VEC_ELT (parmvec, i) = NULL_TREE;
898 switch (unify (DECL_TEMPLATE_PARMS (tdecl),
899 &TREE_VEC_ELT (parmvec, 0), nparms,
900 type, IDENTIFIER_TYPE_VALUE (classname),
904 /* Success -- well, no inconsistency, at least. */
905 for (i = 0; i < nparms; i++)
906 if (TREE_VEC_ELT (parmvec, i) == NULL_TREE)
908 t2 = instantiate_template (tdecl,
909 &TREE_VEC_ELT (parmvec, 0));
910 type = IDENTIFIER_TYPE_VALUE (id);
911 my_friendly_assert (type != 0, 277);
916 cp_error_at ("type unification error instantiating `%D'", tdecl);
917 cp_error ("while instantiating members of `%T'", classname);
919 continue /* loop of members */;
922 my_friendly_abort (83);
927 struct tinst_level *current_tinst_level = 0;
928 struct tinst_level *free_tinst_level = 0;
931 push_tinst_level (name)
934 struct tinst_level *new;
935 tree global = IDENTIFIER_GLOBAL_VALUE (name);
937 if (free_tinst_level)
939 new = free_tinst_level;
940 free_tinst_level = new->next;
943 new = (struct tinst_level *) xmalloc (sizeof (struct tinst_level));
945 new->classname = name;
948 new->line = DECL_SOURCE_LINE (global);
949 new->file = DECL_SOURCE_FILE (global);
954 new->file = input_filename;
956 new->next = current_tinst_level;
957 current_tinst_level = new;
963 struct tinst_level *old = current_tinst_level;
965 current_tinst_level = old->next;
966 old->next = free_tinst_level;
967 free_tinst_level = old;
973 struct tinst_level *p = current_tinst_level;
976 for (; p->next ; p = p->next )
982 instantiate_class_template (classname, setup_parse)
986 struct template_info *template_info;
989 if (classname == error_mark_node)
990 return error_mark_node;
992 my_friendly_assert (TREE_CODE (classname) == IDENTIFIER_NODE, 278);
993 template = IDENTIFIER_TEMPLATE (classname);
995 if (IDENTIFIER_HAS_TYPE_VALUE (classname))
997 tree type = IDENTIFIER_TYPE_VALUE (classname);
998 if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
1000 if (TYPE_BEING_DEFINED (type)
1002 || CLASSTYPE_USE_TEMPLATE (type) != 0)
1006 /* If IDENTIFIER_LOCAL_VALUE is already set on this template classname
1007 (it's something like `foo<int>'), that means we're already working on
1008 the instantiation for it. Normally, a classname comes in with nothing
1009 but its IDENTIFIER_TEMPLATE slot set. If we were to try to instantiate
1010 this again, we'd get a redeclaration error. Since we're already working
1011 on it, we'll pass back this classname's TYPE_DECL (it's the value of
1012 the classname's IDENTIFIER_LOCAL_VALUE). Only do this if we're setting
1013 things up for the parser, though---if we're just trying to instantiate
1014 it (e.g., via tsubst) we can trip up cuz it may not have an
1015 IDENTIFIER_TYPE_VALUE when it will need one. */
1016 if (setup_parse && IDENTIFIER_LOCAL_VALUE (classname))
1017 return IDENTIFIER_LOCAL_VALUE (classname);
1019 if (uses_template_parms (classname))
1021 if (!TREE_TYPE (classname))
1023 tree t = make_lang_type (RECORD_TYPE);
1024 tree d = build_decl (TYPE_DECL, classname, t);
1025 DECL_NAME (d) = classname;
1032 t1 = TREE_PURPOSE (template);
1033 my_friendly_assert (TREE_CODE (t1) == TEMPLATE_DECL, 279);
1035 /* If a template is declared but not defined, accept it; don't crash.
1036 Later uses requiring the definition will be flagged as errors by
1037 other code. Thanks to niklas@appli.se for this bug fix. */
1038 if (DECL_TEMPLATE_INFO (t1)->text == 0)
1041 push_to_top_level ();
1042 template_info = DECL_TEMPLATE_INFO (t1);
1045 push_tinst_level (classname);
1046 push_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (template)),
1047 TREE_VALUE (template), 0);
1048 set_current_level_tags_transparency (1);
1049 feed_input (template_info->text, template_info->length, (struct obstack *)0);
1050 lineno = template_info->lineno;
1051 input_filename = template_info->filename;
1052 /* Get interface/implementation back in sync. */
1053 extract_interface_info ();
1054 overload_template_name (classname, 0);
1055 /* Kludge so that we don't get screwed by our own base classes. */
1056 TYPE_BEING_DEFINED (TREE_TYPE (classname)) = 1;
1057 yychar = PRE_PARSED_CLASS_DECL;
1058 yylval.ttype = classname;
1059 processing_template_defn++;
1060 if (!flag_external_templates)
1061 interface_unknown++;
1065 tree t, decl, id, tmpl;
1068 tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE (id));
1069 t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, id, NULL_TREE, 0);
1070 my_friendly_assert (TREE_CODE (t) == RECORD_TYPE
1071 || TREE_CODE (t) == UNION_TYPE, 280);
1073 /* Now, put a copy of the decl in global scope, to avoid
1074 * recursive expansion. */
1075 decl = IDENTIFIER_LOCAL_VALUE (id);
1077 decl = IDENTIFIER_CLASS_VALUE (id);
1080 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 281);
1081 /* We'd better make sure we're on the permanent obstack or else
1082 * we'll get a "friendly" abort 124 in pushdecl. Perhaps a
1083 * copy_to_permanent would be sufficient here, but then a
1084 * sharing problem might occur. I don't know -- niklas@appli.se */
1085 push_obstacks (&permanent_obstack, &permanent_obstack);
1086 pushdecl_top_level (copy_node (decl));
1089 pop_from_top_level ();
1099 if (t1 == NULL_TREE)
1100 return t2 == NULL_TREE;
1101 if (t2 == NULL_TREE)
1103 /* Don't care if one declares its arg const and the other doesn't -- the
1104 main variant of the arg type is all that matters. */
1105 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1))
1106 != TYPE_MAIN_VARIANT (TREE_VALUE (t2)))
1108 return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2));
1112 lookup_nested_type_by_name (ctype, name)
1117 for (t = CLASSTYPE_TAGS (ctype); t; t = TREE_CHAIN (t))
1119 if (name == TREE_PURPOSE (t))
1120 return TREE_VALUE (t);
1126 search_nested_type_in_tmpl (tmpl, type)
1131 if (tmpl == NULL || TYPE_CONTEXT(type) == NULL)
1133 t = search_nested_type_in_tmpl (tmpl, TYPE_CONTEXT(type));
1134 if (t == NULL) return t;
1135 t = lookup_nested_type_by_name(t, DECL_NAME(TYPE_NAME(type)));
1140 tsubst (t, args, nargs, in_decl)
1147 if (t == NULL_TREE || t == error_mark_node)
1150 type = TREE_TYPE (t);
1152 /* Minor optimization.
1153 ?? Are these really the most frequent cases? Is the savings
1155 && type != integer_type_node
1156 && type != void_type_node
1157 && type != char_type_node)
1158 type = tsubst (type, args, nargs, in_decl);
1160 switch (TREE_CODE (t))
1163 if (TYPE_PTRMEMFUNC_P (t))
1164 return build_ptrmemfunc_type
1165 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, nargs, in_decl));
1167 /* else fall through */
1170 case IDENTIFIER_NODE:
1183 if (t == integer_type_node)
1186 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
1187 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
1189 return build_index_2_type
1190 (tsubst (TYPE_MIN_VALUE (t), args, nargs, in_decl),
1191 tsubst (TYPE_MAX_VALUE (t), args, nargs, in_decl));
1193 case TEMPLATE_TYPE_PARM:
1195 tree arg = args[TEMPLATE_TYPE_IDX (t)];
1196 return cp_build_type_variant
1197 (arg, TYPE_READONLY (arg) || TYPE_READONLY (t),
1198 TYPE_VOLATILE (arg) || TYPE_VOLATILE (t));
1201 case TEMPLATE_CONST_PARM:
1202 return args[TEMPLATE_CONST_IDX (t)];
1207 tree fnargs, result;
1209 if (type == TREE_TYPE (t)
1210 && (DECL_CONTEXT (t) == NULL_TREE
1211 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) != 't'))
1213 fnargs = tsubst (DECL_ARGUMENTS (t), args, nargs, t);
1214 result = tsubst (DECL_RESULT (t), args, nargs, t);
1215 if (DECL_CONTEXT (t) != NULL_TREE
1216 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't')
1218 /* Look it up in that class, and return the decl node there,
1219 instead of creating a new one. */
1220 tree ctx, methods, name, method;
1224 name = DECL_NAME (t);
1225 ctx = tsubst (DECL_CONTEXT (t), args, nargs, t);
1226 methods = CLASSTYPE_METHOD_VEC (ctx);
1227 if (methods == NULL_TREE)
1228 /* No methods at all -- no way this one can match. */
1230 n_methods = TREE_VEC_LENGTH (methods);
1234 if (!strncmp (OPERATOR_TYPENAME_FORMAT,
1235 IDENTIFIER_POINTER (name),
1236 sizeof (OPERATOR_TYPENAME_FORMAT) - 1))
1238 /* Type-conversion operator. Reconstruct the name, in
1239 case it's the name of one of the template's parameters. */
1240 name = build_typename_overload (TREE_TYPE (type));
1243 if (DECL_CONTEXT (t) != NULL_TREE
1244 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't'
1245 && constructor_name (DECL_CONTEXT (t)) == DECL_NAME (t))
1246 name = constructor_name (ctx);
1248 if (DECL_CONSTRUCTOR_P (t) && TYPE_USES_VIRTUAL_BASECLASSES (ctx))
1250 /* Since we didn't know that this class had virtual bases until after
1251 we instantiated it, we have to recreate the arguments to this
1252 constructor, as otherwise it would miss the __in_chrg parameter. */
1254 tree parms = TREE_CHAIN (TYPE_ARG_TYPES (type));
1255 parms = hash_tree_chain (integer_type_node, parms);
1256 newtype = build_cplus_method_type (ctx,
1259 newtype = build_type_variant (newtype,
1260 TYPE_READONLY (type),
1261 TYPE_VOLATILE (type));
1264 fnargs = copy_node (DECL_ARGUMENTS (t));
1265 TREE_CHAIN (fnargs) = TREE_CHAIN (DECL_ARGUMENTS (t));
1267 /* In this case we need "in-charge" flag saying whether
1268 this constructor is responsible for initialization
1269 of virtual baseclasses or not. */
1270 parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node);
1271 /* Mark the artificial `__in_chrg' parameter as "artificial". */
1272 SET_DECL_ARTIFICIAL (parm);
1273 DECL_ARG_TYPE (parm) = integer_type_node;
1274 DECL_REGISTER (parm) = 1;
1275 TREE_CHAIN (parm) = TREE_CHAIN (fnargs);
1276 TREE_CHAIN (fnargs) = parm;
1278 fnargs = tsubst (fnargs, args, nargs, t);
1281 fprintf (stderr, "\nfor function %s in class %s:\n",
1282 IDENTIFIER_POINTER (name),
1283 IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx)));
1285 for (i = 0; i < n_methods; i++)
1289 method = TREE_VEC_ELT (methods, i);
1290 if (method == NULL_TREE || DECL_NAME (method) != name)
1295 for (; method; method = DECL_CHAIN (method))
1297 my_friendly_assert (TREE_CODE (method) == FUNCTION_DECL,
1299 if (! comptypes (type, TREE_TYPE (method), 1))
1301 tree mtype = TREE_TYPE (method);
1304 /* Keep looking for a method that matches
1305 perfectly. This takes care of the problem
1306 where destructors (which have implicit int args)
1307 look like constructors which have an int arg. */
1311 t1 = TYPE_ARG_TYPES (mtype);
1312 t2 = TYPE_ARG_TYPES (type);
1313 if (TREE_CODE (mtype) == FUNCTION_TYPE)
1314 t2 = TREE_CHAIN (t2);
1316 if (list_eq (t1, t2))
1318 if (TREE_CODE (mtype) == FUNCTION_TYPE)
1321 newtype = build_function_type (TREE_TYPE (type),
1322 TYPE_ARG_TYPES (type));
1323 newtype = build_type_variant (newtype,
1324 TYPE_READONLY (type),
1325 TYPE_VOLATILE (type));
1327 if (TREE_TYPE (type) != TREE_TYPE (mtype))
1328 goto maybe_bad_return_type;
1330 else if (TYPE_METHOD_BASETYPE (mtype)
1331 == TYPE_METHOD_BASETYPE (type))
1333 /* Types didn't match, but arg types and
1334 `this' do match, so the return type is
1335 all that should be messing it up. */
1336 maybe_bad_return_type:
1337 if (TREE_TYPE (type) != TREE_TYPE (mtype))
1338 error ("inconsistent return types for method `%s' in class `%s'",
1339 IDENTIFIER_POINTER (name),
1340 IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx)));
1349 fprintf (stderr, "\tfound %s\n\n",
1350 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method)));
1352 if (DECL_ARTIFICIAL (method))
1354 cp_error ("template for method `%D' which has default implementation in class `%T'", name, ctx);
1356 cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl);
1357 return error_mark_node;
1360 if (DECL_ARGUMENTS (method)
1361 && ! TREE_PERMANENT (DECL_ARGUMENTS (method)))
1362 /* @@ Is this early enough? Might we want to do
1363 this instead while processing the expansion? */
1364 DECL_ARGUMENTS (method)
1365 = tsubst (DECL_ARGUMENTS (t), args, nargs, t);
1369 if (r == NULL_TREE && pass == 0)
1372 method = TREE_VEC_ELT (methods, i);
1381 ? "template for method `%D' doesn't match any in class `%T'"
1382 : "method `%D' not found in class `%T'", name, ctx);
1384 cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl);
1385 return error_mark_node;
1395 decls = lookup_name_nonclass (r);
1396 if (decls == NULL_TREE)
1398 else if (TREE_CODE (decls) == TREE_LIST)
1399 for (decls = TREE_VALUE (decls); decls ;
1400 decls = DECL_CHAIN (decls))
1402 if (TREE_CODE (decls) == FUNCTION_DECL
1403 && TREE_TYPE (decls) == type)
1414 if (TREE_CODE (val) == FUNCTION_DECL
1415 && TREE_TYPE (val) == type)
1424 tree a = build_decl_overload (r, TYPE_VALUES (type),
1425 DECL_CONTEXT (t) != NULL_TREE);
1426 r = build_lang_decl (FUNCTION_DECL, r, type);
1427 DECL_ASSEMBLER_NAME (r) = a;
1429 else if (TREE_STATIC (r))
1431 /* This overrides the template version, use it. */
1436 TREE_PUBLIC (r) = 1;
1437 DECL_EXTERNAL (r) = 1;
1438 TREE_STATIC (r) = 0;
1439 DECL_INTERFACE_KNOWN (r) = 0;
1440 DECL_INLINE (r) = DECL_INLINE (t);
1442 #if 0 /* Maybe later. -jason */
1443 struct tinst_level *til = tinst_for_decl();
1445 /* should always be true under new approach */
1448 DECL_SOURCE_FILE (r) = til->file;
1449 DECL_SOURCE_LINE (r) = til->line;
1454 DECL_SOURCE_FILE (r) = DECL_SOURCE_FILE (t);
1455 DECL_SOURCE_LINE (r) = DECL_SOURCE_LINE (t);
1458 DECL_CLASS_CONTEXT (r) = tsubst (DECL_CLASS_CONTEXT (t), args, nargs, t);
1459 make_decl_rtl (r, NULL_PTR, 1);
1460 DECL_ARGUMENTS (r) = fnargs;
1461 DECL_RESULT (r) = result;
1463 if (DECL_CONTEXT (t) == NULL_TREE
1464 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) != 't')
1465 push_overloaded_decl_top_level (r, 0);
1473 r = build_decl (PARM_DECL, DECL_NAME (t), type);
1474 DECL_INITIAL (r) = TREE_TYPE (r);
1476 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, nargs, TREE_CHAIN (t));
1482 tree purpose, value, chain, result;
1483 int via_public, via_virtual, via_protected;
1485 if (t == void_list_node)
1488 via_public = TREE_VIA_PUBLIC (t);
1489 via_protected = TREE_VIA_PROTECTED (t);
1490 via_virtual = TREE_VIA_VIRTUAL (t);
1492 purpose = TREE_PURPOSE (t);
1494 purpose = tsubst (purpose, args, nargs, in_decl);
1495 value = TREE_VALUE (t);
1497 value = tsubst (value, args, nargs, in_decl);
1498 chain = TREE_CHAIN (t);
1499 if (chain && chain != void_type_node)
1500 chain = tsubst (chain, args, nargs, in_decl);
1501 if (purpose == TREE_PURPOSE (t)
1502 && value == TREE_VALUE (t)
1503 && chain == TREE_CHAIN (t))
1505 result = hash_tree_cons (via_public, via_virtual, via_protected,
1506 purpose, value, chain);
1507 TREE_PARMLIST (result) = TREE_PARMLIST (t);
1512 int len = TREE_VEC_LENGTH (t), need_new = 0, i;
1513 tree *elts = (tree *) alloca (len * sizeof (tree));
1514 bzero ((char *) elts, len * sizeof (tree));
1516 for (i = 0; i < len; i++)
1518 elts[i] = tsubst (TREE_VEC_ELT (t, i), args, nargs, in_decl);
1519 if (elts[i] != TREE_VEC_ELT (t, i))
1526 t = make_tree_vec (len);
1527 for (i = 0; i < len; i++)
1528 TREE_VEC_ELT (t, i) = elts[i];
1532 case REFERENCE_TYPE:
1535 enum tree_code code;
1536 if (type == TREE_TYPE (t))
1539 code = TREE_CODE (t);
1540 if (code == POINTER_TYPE)
1541 r = build_pointer_type (type);
1543 r = build_reference_type (type);
1544 r = cp_build_type_variant (r, TYPE_READONLY (t), TYPE_VOLATILE (t));
1545 /* Will this ever be needed for TYPE_..._TO values? */
1550 return build_offset_type
1551 (tsubst (TYPE_OFFSET_BASETYPE (t), args, nargs, in_decl), type);
1555 tree values = TYPE_VALUES (t); /* same as TYPE_ARG_TYPES */
1556 tree context = TYPE_CONTEXT (t);
1559 /* Don't bother recursing if we know it won't change anything. */
1560 if (values != void_list_node)
1561 values = tsubst (values, args, nargs, in_decl);
1563 context = tsubst (context, args, nargs, in_decl);
1564 /* Could also optimize cases where return value and
1565 values have common elements (e.g., T min(const &T, const T&). */
1567 /* If the above parameters haven't changed, just return the type. */
1568 if (type == TREE_TYPE (t)
1569 && values == TYPE_VALUES (t)
1570 && context == TYPE_CONTEXT (t))
1573 /* Construct a new type node and return it. */
1574 if (TREE_CODE (t) == FUNCTION_TYPE
1575 && context == NULL_TREE)
1577 new_value = build_function_type (type, values);
1579 else if (context == NULL_TREE)
1581 tree base = tsubst (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))),
1582 args, nargs, in_decl);
1583 new_value = build_cplus_method_type (base, type,
1584 TREE_CHAIN (values));
1588 new_value = make_node (TREE_CODE (t));
1589 TREE_TYPE (new_value) = type;
1590 TYPE_CONTEXT (new_value) = context;
1591 TYPE_VALUES (new_value) = values;
1592 TYPE_SIZE (new_value) = TYPE_SIZE (t);
1593 TYPE_ALIGN (new_value) = TYPE_ALIGN (t);
1594 TYPE_MODE (new_value) = TYPE_MODE (t);
1595 if (TYPE_METHOD_BASETYPE (t))
1596 TYPE_METHOD_BASETYPE (new_value) = tsubst (TYPE_METHOD_BASETYPE (t),
1597 args, nargs, in_decl);
1598 /* Need to generate hash value. */
1599 my_friendly_abort (84);
1601 new_value = build_type_variant (new_value,
1608 tree domain = tsubst (TYPE_DOMAIN (t), args, nargs, in_decl);
1610 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
1612 r = build_cplus_array_type (type, domain);
1616 case UNINSTANTIATED_P_TYPE:
1618 int nparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (UPT_TEMPLATE (t)));
1619 tree argvec = make_tree_vec (nparms);
1620 tree parmvec = UPT_PARMS (t);
1623 for (i = 0; i < nparms; i++)
1624 TREE_VEC_ELT (argvec, i) = tsubst (TREE_VEC_ELT (parmvec, i),
1625 args, nargs, in_decl);
1626 id = lookup_template_class (DECL_NAME (UPT_TEMPLATE (t)), argvec, NULL_TREE);
1627 if (! IDENTIFIER_HAS_TYPE_VALUE (id)) {
1628 instantiate_class_template(id, 0);
1629 /* set up pending_classes */
1630 add_pending_template (id);
1632 TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (id)) =
1633 IDENTIFIER_TYPE_VALUE (id);
1635 rt = IDENTIFIER_TYPE_VALUE (id);
1637 /* kung: this part handles nested type in template definition */
1639 if ( !ANON_AGGRNAME_P (DECL_NAME(TYPE_NAME(t))))
1641 rt = search_nested_type_in_tmpl (rt, t);
1644 return build_type_variant (rt, TYPE_READONLY (t), TYPE_VOLATILE (t));
1649 return fold (build (TREE_CODE (t), TREE_TYPE (t),
1650 tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl),
1651 tsubst (TREE_OPERAND (t, 1), args, nargs, in_decl)));
1655 return fold (build1 (TREE_CODE (t), TREE_TYPE (t),
1656 tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl)));
1659 sorry ("use of `%s' in function template",
1660 tree_code_name [(int) TREE_CODE (t)]);
1661 return error_mark_node;
1666 instantiate_template (tmpl, targ_ptr)
1667 tree tmpl, *targ_ptr;
1671 struct pending_inline *p;
1672 struct template_info *t;
1673 struct obstack *old_fmp_obstack;
1674 extern struct obstack *function_maybepermanent_obstack;
1676 push_obstacks (&permanent_obstack, &permanent_obstack);
1677 old_fmp_obstack = function_maybepermanent_obstack;
1678 function_maybepermanent_obstack = &permanent_obstack;
1680 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283);
1681 len = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl));
1685 targ_ptr[i] = copy_to_permanent (targ_ptr[i]);
1687 for (fndecl = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
1688 fndecl; fndecl = TREE_CHAIN (fndecl))
1690 tree *t1 = &TREE_VEC_ELT (TREE_PURPOSE (fndecl), 0);
1691 for (i = len - 1; i >= 0; i--)
1692 if (simple_cst_equal (t1[i], targ_ptr[i]) <= 0)
1695 /* Here, we have a match. */
1696 fndecl = TREE_VALUE (fndecl);
1703 targs = make_tree_vec (len);
1706 TREE_VEC_ELT (targs, i) = targ_ptr[i];
1708 /* substitute template parameters */
1709 fndecl = tsubst (DECL_RESULT (tmpl), targ_ptr,
1710 TREE_VEC_LENGTH (targs), tmpl);
1712 if (fndecl == error_mark_node)
1715 /* If it's a static member fn in the template, we need to change it
1716 into a FUNCTION_TYPE and chop off its this pointer. */
1717 if (TREE_CODE (TREE_TYPE (DECL_RESULT (tmpl))) == METHOD_TYPE
1718 && DECL_STATIC_FUNCTION_P (fndecl))
1720 tree olddecl = DECL_RESULT (tmpl);
1721 revert_static_member_fn (&DECL_RESULT (tmpl), NULL, NULL);
1722 /* Chop off the this pointer that grokclassfn so kindly added
1723 for us (it didn't know yet if the fn was static or not). */
1724 DECL_ARGUMENTS (olddecl) = TREE_CHAIN (DECL_ARGUMENTS (olddecl));
1725 DECL_ARGUMENTS (fndecl) = TREE_CHAIN (DECL_ARGUMENTS (fndecl));
1728 t = DECL_TEMPLATE_INFO (tmpl);
1730 /* If we have a preexisting version of this function, don't expand
1731 the template version, use the other instead. */
1732 if (TREE_STATIC (fndecl))
1734 SET_DECL_TEMPLATE_SPECIALIZATION (fndecl);
1735 p = (struct pending_inline *)0;
1739 SET_DECL_IMPLICIT_INSTANTIATION (fndecl);
1740 p = (struct pending_inline *) permalloc (sizeof (struct pending_inline));
1741 p->parm_vec = t->parm_vec;
1742 p->bindings = targs;
1750 char * f = input_filename;
1752 lineno = p->lineno = t->lineno;
1753 input_filename = p->filename = t->filename;
1755 extract_interface_info ();
1757 if (interface_unknown && flag_external_templates)
1759 if (DECL_CLASS_CONTEXT (fndecl)
1760 && CLASSTYPE_INTERFACE_KNOWN (DECL_CLASS_CONTEXT (fndecl)))
1762 interface_unknown = 0;
1764 = CLASSTYPE_INTERFACE_ONLY (DECL_CLASS_CONTEXT (fndecl));
1766 else if (! DECL_IN_SYSTEM_HEADER (tmpl))
1767 warn_if_unknown_interface (tmpl);
1770 if (interface_unknown || ! flag_external_templates)
1771 p->interface = 1; /* unknown */
1773 p->interface = interface_only ? 0 : 2;
1778 extract_interface_info ();
1782 p = (struct pending_inline *)0;
1784 DECL_TEMPLATE_INSTANTIATIONS (tmpl) =
1785 tree_cons (targs, fndecl, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1787 if (p == (struct pending_inline *)0)
1791 else if (DECL_INLINE (fndecl))
1793 DECL_PENDING_INLINE_INFO (fndecl) = p;
1794 p->next = pending_inlines;
1795 pending_inlines = p;
1799 p->next = pending_template_expansions;
1800 pending_template_expansions = p;
1803 function_maybepermanent_obstack = old_fmp_obstack;
1809 /* classlevel should now never be true. jason 4/12/94 */
1811 undo_template_name_overload (id, classlevel)
1817 template = IDENTIFIER_TEMPLATE (id);
1821 #if 0 /* not yet, should get fixed properly later */
1825 /* This was a botch... See `overload_template_name' just below. */
1831 /* classlevel should now never be true. jason 4/12/94 */
1833 overload_template_name (id, classlevel)
1837 tree template, t, decl;
1838 struct template_info *tinfo;
1840 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 284);
1841 template = IDENTIFIER_TEMPLATE (id);
1845 template = TREE_PURPOSE (template);
1846 tinfo = DECL_TEMPLATE_INFO (template);
1847 template = DECL_NAME (template);
1848 my_friendly_assert (template != NULL_TREE, 285);
1851 /* This was a botch... names of templates do not get their own private
1852 scopes. Rather, they should go into the binding level already created
1853 by push_template_decls. Except that there isn't one of those for
1858 declare_pseudo_global_level ();
1862 t = xref_tag (tinfo->aggr, id, NULL_TREE, 1);
1863 my_friendly_assert (TREE_CODE (t) == RECORD_TYPE
1864 || TREE_CODE (t) == UNION_TYPE
1865 || TREE_CODE (t) == UNINSTANTIATED_P_TYPE, 286);
1867 decl = build_decl (TYPE_DECL, template, t);
1868 SET_DECL_ARTIFICIAL (decl);
1870 #if 0 /* fix this later */
1871 /* We don't want to call here if the work has already been done. */
1873 ? IDENTIFIER_CLASS_VALUE (template)
1874 : IDENTIFIER_LOCAL_VALUE (template));
1876 && TREE_CODE (t) == TYPE_DECL
1877 && TREE_TYPE (t) == t)
1878 my_friendly_abort (85);
1882 pushdecl_class_level (decl);
1886 #if 0 /* This seems bogus to me; if it isn't, explain why. (jason) */
1887 /* Fake this for now, just to make dwarfout.c happy. It will have to
1888 be done in a proper way later on. */
1889 DECL_CONTEXT (decl) = t;
1893 /* NAME is the IDENTIFIER value of a PRE_PARSED_CLASS_DECL. */
1895 end_template_instantiation (name)
1898 extern struct pending_input *to_be_restored;
1901 processing_template_defn--;
1902 if (!flag_external_templates)
1903 interface_unknown--;
1905 /* Restore the old parser input state. */
1906 if (yychar == YYEMPTY)
1908 if (yychar != END_OF_SAVED_INPUT)
1909 error ("parse error at end of class template");
1912 restore_pending_input (to_be_restored);
1916 /* Our declarations didn't get stored in the global slot, since
1917 there was a (supposedly tags-transparent) scope in between. */
1918 t = IDENTIFIER_TYPE_VALUE (name);
1919 my_friendly_assert (t != NULL_TREE
1920 && TREE_CODE_CLASS (TREE_CODE (t)) == 't',
1922 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
1923 /* Make methods of template classes static, unless
1924 -fexternal-templates is given. */
1925 if (!flag_external_templates)
1926 SET_CLASSTYPE_INTERFACE_UNKNOWN (t);
1927 decl = IDENTIFIER_GLOBAL_VALUE (name);
1928 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 288);
1930 undo_template_name_overload (name, 0);
1931 t = IDENTIFIER_TEMPLATE (name);
1932 pop_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (t)), TREE_VALUE (t),
1934 /* This will fix up the type-value field. */
1936 pop_from_top_level ();
1938 #ifdef DWARF_DEBUGGING_INFO
1939 if (write_symbols == DWARF_DEBUG && TREE_CODE (decl) == TYPE_DECL)
1941 /* We just completed the definition of a new file-scope type,
1942 so we can go ahead and output debug-info for it now. */
1943 TYPE_STUB_DECL (TREE_TYPE (decl)) = decl;
1944 rest_of_type_compilation (TREE_TYPE (decl), 1);
1946 #endif /* DWARF_DEBUGGING_INFO */
1948 /* Restore interface/implementation settings. */
1949 extract_interface_info ();
1952 /* Store away the text of an template. */
1955 reinit_parse_for_template (yychar, d1, d2)
1959 struct template_info *template_info;
1960 extern struct obstack inline_text_obstack; /* see comment in lex.c */
1962 if (d2 == NULL_TREE || d2 == error_mark_node)
1965 /* @@ Should use temp obstack, and discard results. */
1966 reinit_parse_for_block (yychar, &inline_text_obstack, 1);
1970 if (TREE_CODE (d2) == IDENTIFIER_NODE)
1971 d2 = IDENTIFIER_GLOBAL_VALUE (d2);
1974 template_info = DECL_TEMPLATE_INFO (d2);
1977 template_info = (struct template_info *) permalloc (sizeof (struct template_info));
1978 bzero ((char *) template_info, sizeof (struct template_info));
1979 DECL_TEMPLATE_INFO (d2) = template_info;
1981 template_info->filename = input_filename;
1982 template_info->lineno = lineno;
1983 reinit_parse_for_block (yychar, &inline_text_obstack, 1);
1984 template_info->text = obstack_base (&inline_text_obstack);
1985 template_info->length = obstack_object_size (&inline_text_obstack);
1986 obstack_finish (&inline_text_obstack);
1987 template_info->parm_vec = d1;
1990 /* Type unification.
1992 We have a function template signature with one or more references to
1993 template parameters, and a parameter list we wish to fit to this
1994 template. If possible, produce a list of parameters for the template
1995 which will cause it to fit the supplied parameter list.
1997 Return zero for success, 2 for an incomplete match that doesn't resolve
1998 all the types, and 1 for complete failure. An error message will be
1999 printed only for an incomplete match.
2001 TPARMS[NTPARMS] is an array of template parameter types;
2002 TARGS[NTPARMS] is the array of template parameter values. PARMS is
2003 the function template's signature (using TEMPLATE_PARM_IDX nodes),
2004 and ARGS is the argument list we're trying to match against it.
2006 If SUBR is 1, we're being called recursively (to unify the arguments of
2007 a function or method parameter of a function template), so don't zero
2008 out targs and don't fail on an incomplete match. */
2011 type_unification (tparms, targs, parms, args, nsubsts, subr)
2012 tree tparms, *targs, parms, args;
2017 int ntparms = TREE_VEC_LENGTH (tparms);
2019 my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289);
2020 my_friendly_assert (TREE_CODE (parms) == TREE_LIST, 290);
2021 /* ARGS could be NULL (via a call from parse.y to
2022 build_x_function_call). */
2024 my_friendly_assert (TREE_CODE (args) == TREE_LIST, 291);
2025 my_friendly_assert (ntparms > 0, 292);
2028 bzero ((char *) targs, sizeof (tree) * ntparms);
2031 && parms != void_list_node
2033 && args != void_list_node)
2035 parm = TREE_VALUE (parms);
2036 parms = TREE_CHAIN (parms);
2037 arg = TREE_VALUE (args);
2038 args = TREE_CHAIN (args);
2040 if (arg == error_mark_node)
2042 if (arg == unknown_type_node)
2045 if (! uses_template_parms (parm)
2046 && TREE_CODE_CLASS (TREE_CODE (arg)) != 't')
2048 if (can_convert_arg (parm, TREE_TYPE (arg), arg))
2054 if (TREE_CODE (arg) == VAR_DECL)
2055 arg = TREE_TYPE (arg);
2056 else if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'e')
2057 arg = TREE_TYPE (arg);
2059 if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't')
2061 my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293);
2062 arg = TREE_TYPE (arg);
2065 if (TREE_CODE (arg) == REFERENCE_TYPE)
2066 arg = TREE_TYPE (arg);
2068 if (TREE_CODE (parm) != REFERENCE_TYPE)
2070 if (TREE_CODE (arg) == FUNCTION_TYPE
2071 || TREE_CODE (arg) == METHOD_TYPE)
2072 arg = build_pointer_type (arg);
2073 else if (TREE_CODE (arg) == ARRAY_TYPE)
2074 arg = build_pointer_type (TREE_TYPE (arg));
2076 arg = TYPE_MAIN_VARIANT (arg);
2079 switch (unify (tparms, targs, ntparms, parm, arg, nsubsts))
2087 /* Fail if we've reached the end of the parm list, and more args
2088 are present, and the parm list isn't variadic. */
2089 if (args && args != void_list_node && parms == void_list_node)
2091 /* Fail if parms are left and they don't have default values. */
2093 && parms != void_list_node
2094 && TREE_PURPOSE (parms) == NULL_TREE)
2097 for (i = 0; i < ntparms; i++)
2100 error ("incomplete type unification");
2106 /* Tail recursion is your friend. */
2108 unify (tparms, targs, ntparms, parm, arg, nsubsts)
2109 tree tparms, *targs, parm, arg;
2110 int *nsubsts, ntparms;
2114 /* I don't think this will do the right thing with respect to types.
2115 But the only case I've seen it in so far has been array bounds, where
2116 signedness is the only information lost, and I think that will be
2118 while (TREE_CODE (parm) == NOP_EXPR)
2119 parm = TREE_OPERAND (parm, 0);
2121 if (arg == error_mark_node)
2123 if (arg == unknown_type_node)
2128 switch (TREE_CODE (parm))
2130 case TEMPLATE_TYPE_PARM:
2132 if (TEMPLATE_TYPE_TPARMLIST (parm) != tparms)
2134 error ("mixed template headers?!");
2135 my_friendly_abort (86);
2138 idx = TEMPLATE_TYPE_IDX (parm);
2140 /* Template type parameters cannot contain cv-quals; i.e.
2141 template <class T> void f (T& a, T& b) will not generate
2142 void f (const int& a, const int& b). */
2143 if (TYPE_READONLY (arg) > TYPE_READONLY (parm)
2144 || TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm))
2146 arg = TYPE_MAIN_VARIANT (arg);
2149 int constp = TYPE_READONLY (arg) > TYPE_READONLY (parm);
2150 int volatilep = TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm);
2151 arg = cp_build_type_variant (arg, constp, volatilep);
2154 /* Simple cases: Value already set, does match or doesn't. */
2155 if (targs[idx] == arg)
2157 else if (targs[idx])
2159 /* Check for mixed types and values. */
2160 if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (tparms, idx))) != TYPE_DECL)
2164 case TEMPLATE_CONST_PARM:
2166 idx = TEMPLATE_CONST_IDX (parm);
2167 if (targs[idx] == arg)
2169 else if (targs[idx])
2171 tree t = targs[idx];
2172 if (TREE_CODE (t) == TREE_CODE (arg))
2173 switch (TREE_CODE (arg))
2176 if (tree_int_cst_equal (t, arg))
2180 if (REAL_VALUES_EQUAL (TREE_REAL_CST (t), TREE_REAL_CST (arg)))
2183 /* STRING_CST values are not valid template const parms. */
2187 my_friendly_abort (87);
2190 /* else if (typeof arg != tparms[idx])
2193 targs[idx] = copy_to_permanent (arg);
2197 if (TREE_CODE (arg) != POINTER_TYPE)
2199 return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg),
2202 case REFERENCE_TYPE:
2203 return unify (tparms, targs, ntparms, TREE_TYPE (parm), arg, nsubsts);
2206 if (TREE_CODE (arg) != ARRAY_TYPE)
2208 if (unify (tparms, targs, ntparms, TYPE_DOMAIN (parm), TYPE_DOMAIN (arg),
2211 return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg),
2216 if (TREE_CODE (arg) != TREE_CODE (parm))
2219 if (TREE_CODE (parm) == INTEGER_TYPE)
2221 if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg)
2222 && unify (tparms, targs, ntparms,
2223 TYPE_MIN_VALUE (parm), TYPE_MIN_VALUE (arg), nsubsts))
2225 if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg)
2226 && unify (tparms, targs, ntparms,
2227 TYPE_MAX_VALUE (parm), TYPE_MAX_VALUE (arg), nsubsts))
2230 /* As far as unification is concerned, this wins. Later checks
2231 will invalidate it if necessary. */
2234 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
2236 if (TREE_CODE (arg) != INTEGER_CST)
2238 return !tree_int_cst_equal (parm, arg);
2243 t1 = TREE_OPERAND (parm, 0);
2244 t2 = TREE_OPERAND (parm, 1);
2245 if (TREE_CODE (t1) != TEMPLATE_CONST_PARM)
2247 return unify (tparms, targs, ntparms, t1,
2248 fold (build (PLUS_EXPR, integer_type_node, arg, t2)),
2255 if (TREE_CODE (arg) != TREE_VEC)
2257 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
2259 for (i = TREE_VEC_LENGTH (parm) - 1; i >= 0; i--)
2260 if (unify (tparms, targs, ntparms,
2261 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
2267 case UNINSTANTIATED_P_TYPE:
2270 /* Unification of something that is not a class fails. */
2271 if (! IS_AGGR_TYPE (arg))
2273 a = IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (arg));
2274 if (a && UPT_TEMPLATE (parm) == TREE_PURPOSE (a))
2275 return unify (tparms, targs, ntparms, UPT_PARMS (parm),
2276 TREE_VALUE (a), nsubsts);
2277 /* FIXME: Should check base conversions here. */
2282 if (TYPE_PTRMEMFUNC_FLAG (parm))
2283 return unify (tparms, targs, ntparms, TYPE_PTRMEMFUNC_FN_TYPE (parm),
2286 /* Allow trivial conversions. */
2287 if (TYPE_MAIN_VARIANT (parm) != TYPE_MAIN_VARIANT (arg)
2288 || TYPE_READONLY (parm) < TYPE_READONLY (arg)
2289 || TYPE_VOLATILE (parm) < TYPE_VOLATILE (arg))
2294 if (TREE_CODE (arg) != METHOD_TYPE)
2299 if (TREE_CODE (arg) != FUNCTION_TYPE)
2302 return type_unification (tparms, targs, TYPE_ARG_TYPES (parm),
2303 TYPE_ARG_TYPES (arg), nsubsts, 1);
2306 if (TREE_CODE (arg) != OFFSET_TYPE)
2308 if (unify (tparms, targs, ntparms, TYPE_OFFSET_BASETYPE (parm),
2309 TYPE_OFFSET_BASETYPE (arg), nsubsts))
2311 return unify (tparms, targs, ntparms, TREE_TYPE (parm),
2312 TREE_TYPE (arg), nsubsts);
2315 sorry ("use of `%s' in template type unification",
2316 tree_code_name [(int) TREE_CODE (parm)]);
2325 do_pending_expansions ()
2327 struct pending_inline *i, *new_list = 0;
2329 if (!pending_template_expansions)
2333 fprintf (stderr, "\n\n\t\t IN DO_PENDING_EXPANSIONS\n\n");
2336 i = pending_template_expansions;
2341 struct pending_inline *next = i->next;
2345 #define DECIDE(N) do {decision=(N); goto decided;} while(0)
2347 my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL
2348 || TREE_CODE (t) == VAR_DECL, 294);
2349 if (TREE_ASM_WRITTEN (t))
2352 if (DECL_EXPLICIT_INSTANTIATION (t))
2353 DECIDE (! DECL_EXTERNAL (t));
2354 else if (! flag_implicit_templates)
2357 if (i->interface == 1)
2358 /* OK, it was an implicit instantiation. */
2359 TREE_PUBLIC (t) = 0;
2361 /* If it's a method, let the class type decide it.
2362 @@ What if the method template is in a separate file?
2363 Maybe both file contexts should be taken into account?
2364 Maybe only do this if i->interface == 1 (unknown)? */
2365 context = DECL_CONTEXT (t);
2366 if (context != NULL_TREE
2367 && TREE_CODE_CLASS (TREE_CODE (context)) == 't')
2369 /* I'm interested in the context of this version of the function,
2370 not the original virtual declaration. */
2371 context = DECL_CLASS_CONTEXT (t);
2373 /* If `unknown', we might want a static copy.
2374 If `implementation', we want a global one.
2375 If `interface', ext ref. */
2376 if (CLASSTYPE_INTERFACE_KNOWN (context))
2377 DECIDE (!CLASSTYPE_INTERFACE_ONLY (context));
2378 #if 0 /* This doesn't get us stuff needed only by the file initializer. */
2379 DECIDE (TREE_USED (t));
2380 #else /* This compiles too much stuff, but that's probably better in
2381 most cases than never compiling the stuff we need. */
2386 if (i->interface == 1)
2387 DECIDE (TREE_USED (t));
2389 DECIDE (i->interface);
2393 print_node_brief (stderr, decision ? "yes: " : "no: ", t, 0);
2394 fprintf (stderr, "\t%s\n",
2395 (DECL_ASSEMBLER_NAME (t)
2396 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t))
2401 i->next = pending_inlines;
2402 pending_inlines = i;
2411 pending_template_expansions = new_list;
2412 if (!pending_inlines)
2414 do_pending_inlines ();
2419 struct pending_template {
2420 struct pending_template *next;
2424 static struct pending_template* pending_templates;
2427 do_pending_templates ()
2429 struct pending_template* t;
2431 for ( t = pending_templates; t; t = t->next)
2433 instantiate_class_template (t->id, 1);
2436 for ( t = pending_templates; t; t = pending_templates)
2438 pending_templates = t->next;
2444 add_pending_template (pt)
2447 struct pending_template *p;
2449 p = (struct pending_template *) malloc (sizeof (struct pending_template));
2450 p->next = pending_templates;
2451 pending_templates = p;
2455 /* called from the parser. */
2457 do_function_instantiation (declspecs, declarator, storage)
2458 tree declspecs, declarator, storage;
2460 tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, 0);
2461 tree name = DECL_NAME (decl);
2462 tree fn = IDENTIFIER_GLOBAL_VALUE (name);
2463 tree result = NULL_TREE;
2466 for (fn = get_first_fn (fn); fn; fn = DECL_CHAIN (fn))
2467 if (TREE_CODE (fn) == TEMPLATE_DECL)
2469 int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (fn));
2470 tree *targs = (tree *) malloc (sizeof (tree) * ntparms);
2472 i = type_unification (DECL_TEMPLATE_PARMS (fn), targs,
2473 TYPE_ARG_TYPES (TREE_TYPE (fn)),
2474 TYPE_ARG_TYPES (TREE_TYPE (decl)),
2479 cp_error ("ambiguous template instantiation for `%D' requested", decl);
2481 result = instantiate_template (fn, targs);
2487 cp_error ("no matching template for `%D' found", decl);
2489 if (flag_external_templates)
2492 SET_DECL_EXPLICIT_INSTANTIATION (result);
2493 TREE_PUBLIC (result) = 1;
2495 if (storage == NULL_TREE)
2497 DECL_INTERFACE_KNOWN (result) = 1;
2498 DECL_EXTERNAL (result) = 0;
2499 TREE_STATIC (result) = 1;
2501 else if (storage == ridpointers[(int) RID_EXTERN])
2504 cp_error ("storage class `%D' applied to template instantiation",
2509 do_type_instantiation (name, storage)
2512 tree t = TREE_TYPE (name);
2515 /* With -fexternal-templates, explicit instantiations are treated the same
2516 as implicit ones. */
2517 if (flag_external_templates)
2520 if (TYPE_SIZE (t) == NULL_TREE)
2522 cp_error ("explicit instantiation of `%#T' before definition of template",
2527 if (storage == NULL_TREE)
2529 else if (storage == ridpointers[(int) RID_EXTERN])
2533 cp_error ("storage class `%D' applied to template instantiation",
2538 /* We've already instantiated this. */
2539 if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && ! CLASSTYPE_INTERFACE_ONLY (t))
2542 cp_pedwarn ("multiple explicit instantiation of `%#T'", t);
2546 if (! CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
2548 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
2549 SET_CLASSTYPE_INTERFACE_KNOWN (t);
2550 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
2551 CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p;
2552 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
2555 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
2556 rest_of_type_compilation (t, 1);
2562 /* Classes nested in template classes currently don't have an
2563 IDENTIFIER_TEMPLATE--their out-of-line members are handled
2564 by the enclosing template class. Note that there are name
2565 conflict bugs with this approach. */
2566 tmp = TYPE_IDENTIFIER (t);
2567 if (IDENTIFIER_TEMPLATE (tmp))
2568 instantiate_member_templates (tmp);
2570 /* this should really be done by instantiate_member_templates */
2571 tmp = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0);
2572 for (; tmp; tmp = TREE_CHAIN (tmp))
2574 if (DECL_TEMPLATE_SPECIALIZATION (tmp)
2575 || (DECL_USE_TEMPLATE (tmp) == 0
2576 && CLASSTYPE_TEMPLATE_SPECIALIZATION (t)))
2579 SET_DECL_EXPLICIT_INSTANTIATION (tmp);
2580 TREE_PUBLIC (tmp) = 1;
2583 DECL_INTERFACE_KNOWN (tmp) = 1;
2584 DECL_EXTERNAL (tmp) = 0;
2585 TREE_STATIC (tmp) = 1;
2590 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
2592 if (TREE_CODE (tmp) == VAR_DECL)
2593 /* eventually do something */;
2597 for (tmp = CLASSTYPE_TAGS (t); tmp; tmp = TREE_CHAIN (tmp))
2598 if (IS_AGGR_TYPE (TREE_VALUE (tmp)))
2599 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp)), storage);
2604 create_nested_upt (scope, name)
2607 tree t = make_lang_type (UNINSTANTIATED_P_TYPE);
2608 tree d = build_decl (TYPE_DECL, name, t);
2611 TYPE_VALUES (t) = TYPE_VALUES (scope);
2612 TYPE_CONTEXT (t) = scope;