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 static struct tinst_level
*current_tinst_level
= 0;
928 static struct tinst_level
*free_tinst_level
= 0;
929 static int tinst_depth
= 0;
930 int max_tinst_depth
= 17;
933 push_tinst_level (name
)
936 struct tinst_level
*new;
937 tree global
= IDENTIFIER_GLOBAL_VALUE (name
);
939 if (tinst_depth
>= max_tinst_depth
)
941 error ("template instantiation depth exceeds maximum of %d",
943 cp_error (" instantiating `%D'", name
);
947 if (free_tinst_level
)
949 new = free_tinst_level
;
950 free_tinst_level
= new->next
;
953 new = (struct tinst_level
*) xmalloc (sizeof (struct tinst_level
));
955 new->classname
= name
;
958 new->line
= DECL_SOURCE_LINE (global
);
959 new->file
= DECL_SOURCE_FILE (global
);
964 new->file
= input_filename
;
966 new->next
= current_tinst_level
;
967 current_tinst_level
= new;
975 struct tinst_level
*old
= current_tinst_level
;
977 current_tinst_level
= old
->next
;
978 old
->next
= free_tinst_level
;
979 free_tinst_level
= old
;
986 struct tinst_level
*p
= current_tinst_level
;
989 for (; p
->next
; p
= p
->next
)
995 instantiate_class_template (classname
, setup_parse
)
999 struct template_info
*template_info
;
1002 if (classname
== error_mark_node
)
1003 return error_mark_node
;
1005 my_friendly_assert (TREE_CODE (classname
) == IDENTIFIER_NODE
, 278);
1006 template = IDENTIFIER_TEMPLATE (classname
);
1008 if (IDENTIFIER_HAS_TYPE_VALUE (classname
))
1010 tree type
= IDENTIFIER_TYPE_VALUE (classname
);
1011 if (TREE_CODE (type
) == UNINSTANTIATED_P_TYPE
)
1013 if (TYPE_BEING_DEFINED (type
)
1015 || CLASSTYPE_USE_TEMPLATE (type
) != 0)
1019 /* If IDENTIFIER_LOCAL_VALUE is already set on this template classname
1020 (it's something like `foo<int>'), that means we're already working on
1021 the instantiation for it. Normally, a classname comes in with nothing
1022 but its IDENTIFIER_TEMPLATE slot set. If we were to try to instantiate
1023 this again, we'd get a redeclaration error. Since we're already working
1024 on it, we'll pass back this classname's TYPE_DECL (it's the value of
1025 the classname's IDENTIFIER_LOCAL_VALUE). Only do this if we're setting
1026 things up for the parser, though---if we're just trying to instantiate
1027 it (e.g., via tsubst) we can trip up cuz it may not have an
1028 IDENTIFIER_TYPE_VALUE when it will need one. */
1029 if (setup_parse
&& IDENTIFIER_LOCAL_VALUE (classname
))
1030 return IDENTIFIER_LOCAL_VALUE (classname
);
1032 if (uses_template_parms (classname
))
1034 if (!TREE_TYPE (classname
))
1036 tree t
= make_lang_type (RECORD_TYPE
);
1037 tree d
= build_decl (TYPE_DECL
, classname
, t
);
1038 DECL_NAME (d
) = classname
;
1045 t1
= TREE_PURPOSE (template);
1046 my_friendly_assert (TREE_CODE (t1
) == TEMPLATE_DECL
, 279);
1048 /* If a template is declared but not defined, accept it; don't crash.
1049 Later uses requiring the definition will be flagged as errors by
1050 other code. Thanks to niklas@appli.se for this bug fix. */
1051 if (DECL_TEMPLATE_INFO (t1
)->text
== 0)
1054 push_to_top_level ();
1055 template_info
= DECL_TEMPLATE_INFO (t1
);
1056 if (setup_parse
&& push_tinst_level (classname
))
1058 push_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (template)),
1059 TREE_VALUE (template), 0);
1060 set_current_level_tags_transparency (1);
1061 feed_input (template_info
->text
, template_info
->length
, (struct obstack
*)0);
1062 lineno
= template_info
->lineno
;
1063 input_filename
= template_info
->filename
;
1064 /* Get interface/implementation back in sync. */
1065 extract_interface_info ();
1066 overload_template_name (classname
, 0);
1067 /* Kludge so that we don't get screwed by our own base classes. */
1068 TYPE_BEING_DEFINED (TREE_TYPE (classname
)) = 1;
1069 yychar
= PRE_PARSED_CLASS_DECL
;
1070 yylval
.ttype
= classname
;
1071 processing_template_defn
++;
1072 if (!flag_external_templates
)
1073 interface_unknown
++;
1077 tree t
, decl
, id
, tmpl
;
1080 tmpl
= TREE_PURPOSE (IDENTIFIER_TEMPLATE (id
));
1081 t
= xref_tag (DECL_TEMPLATE_INFO (tmpl
)->aggr
, id
, NULL_TREE
, 0);
1082 my_friendly_assert (TREE_CODE (t
) == RECORD_TYPE
1083 || TREE_CODE (t
) == UNION_TYPE
, 280);
1085 /* Now, put a copy of the decl in global scope, to avoid
1086 * recursive expansion. */
1087 decl
= IDENTIFIER_LOCAL_VALUE (id
);
1089 decl
= IDENTIFIER_CLASS_VALUE (id
);
1092 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 281);
1093 /* We'd better make sure we're on the permanent obstack or else
1094 * we'll get a "friendly" abort 124 in pushdecl. Perhaps a
1095 * copy_to_permanent would be sufficient here, but then a
1096 * sharing problem might occur. I don't know -- niklas@appli.se */
1097 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1098 pushdecl_top_level (copy_node (decl
));
1101 pop_from_top_level ();
1111 if (t1
== NULL_TREE
)
1112 return t2
== NULL_TREE
;
1113 if (t2
== NULL_TREE
)
1115 /* Don't care if one declares its arg const and the other doesn't -- the
1116 main variant of the arg type is all that matters. */
1117 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1
))
1118 != TYPE_MAIN_VARIANT (TREE_VALUE (t2
)))
1120 return list_eq (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1124 lookup_nested_type_by_name (ctype
, name
)
1129 for (t
= CLASSTYPE_TAGS (ctype
); t
; t
= TREE_CHAIN (t
))
1131 if (name
== TREE_PURPOSE (t
))
1132 return TREE_VALUE (t
);
1138 search_nested_type_in_tmpl (tmpl
, type
)
1143 if (tmpl
== NULL
|| TYPE_CONTEXT(type
) == NULL
)
1145 t
= search_nested_type_in_tmpl (tmpl
, TYPE_CONTEXT(type
));
1146 if (t
== NULL
) return t
;
1147 t
= lookup_nested_type_by_name(t
, DECL_NAME(TYPE_NAME(type
)));
1152 tsubst (t
, args
, nargs
, in_decl
)
1159 if (t
== NULL_TREE
|| t
== error_mark_node
)
1162 type
= TREE_TYPE (t
);
1164 /* Minor optimization.
1165 ?? Are these really the most frequent cases? Is the savings
1167 && type
!= integer_type_node
1168 && type
!= void_type_node
1169 && type
!= char_type_node
)
1170 type
= tsubst (type
, args
, nargs
, in_decl
);
1172 switch (TREE_CODE (t
))
1175 if (TYPE_PTRMEMFUNC_P (t
))
1176 return build_ptrmemfunc_type
1177 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, nargs
, in_decl
));
1179 /* else fall through */
1182 case IDENTIFIER_NODE
:
1195 if (t
== integer_type_node
)
1198 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
1199 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
1201 return build_index_2_type
1202 (tsubst (TYPE_MIN_VALUE (t
), args
, nargs
, in_decl
),
1203 tsubst (TYPE_MAX_VALUE (t
), args
, nargs
, in_decl
));
1205 case TEMPLATE_TYPE_PARM
:
1207 tree arg
= args
[TEMPLATE_TYPE_IDX (t
)];
1208 return cp_build_type_variant
1209 (arg
, TYPE_READONLY (arg
) || TYPE_READONLY (t
),
1210 TYPE_VOLATILE (arg
) || TYPE_VOLATILE (t
));
1213 case TEMPLATE_CONST_PARM
:
1214 return args
[TEMPLATE_CONST_IDX (t
)];
1219 tree fnargs
, result
;
1221 if (type
== TREE_TYPE (t
)
1222 && (DECL_CONTEXT (t
) == NULL_TREE
1223 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) != 't'))
1225 fnargs
= tsubst (DECL_ARGUMENTS (t
), args
, nargs
, t
);
1226 result
= tsubst (DECL_RESULT (t
), args
, nargs
, t
);
1227 if (DECL_CONTEXT (t
) != NULL_TREE
1228 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) == 't')
1230 /* Look it up in that class, and return the decl node there,
1231 instead of creating a new one. */
1232 tree ctx
, methods
, name
, method
;
1236 name
= DECL_NAME (t
);
1237 ctx
= tsubst (DECL_CONTEXT (t
), args
, nargs
, t
);
1238 methods
= CLASSTYPE_METHOD_VEC (ctx
);
1239 if (methods
== NULL_TREE
)
1240 /* No methods at all -- no way this one can match. */
1242 n_methods
= TREE_VEC_LENGTH (methods
);
1246 if (!strncmp (OPERATOR_TYPENAME_FORMAT
,
1247 IDENTIFIER_POINTER (name
),
1248 sizeof (OPERATOR_TYPENAME_FORMAT
) - 1))
1250 /* Type-conversion operator. Reconstruct the name, in
1251 case it's the name of one of the template's parameters. */
1252 name
= build_typename_overload (TREE_TYPE (type
));
1255 if (DECL_CONTEXT (t
) != NULL_TREE
1256 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) == 't'
1257 && constructor_name (DECL_CONTEXT (t
)) == DECL_NAME (t
))
1258 name
= constructor_name (ctx
);
1260 if (DECL_CONSTRUCTOR_P (t
) && TYPE_USES_VIRTUAL_BASECLASSES (ctx
))
1262 /* Since we didn't know that this class had virtual bases until after
1263 we instantiated it, we have to recreate the arguments to this
1264 constructor, as otherwise it would miss the __in_chrg parameter. */
1266 tree parms
= TREE_CHAIN (TYPE_ARG_TYPES (type
));
1267 parms
= hash_tree_chain (integer_type_node
, parms
);
1268 newtype
= build_cplus_method_type (ctx
,
1271 newtype
= build_type_variant (newtype
,
1272 TYPE_READONLY (type
),
1273 TYPE_VOLATILE (type
));
1276 fnargs
= copy_node (DECL_ARGUMENTS (t
));
1277 TREE_CHAIN (fnargs
) = TREE_CHAIN (DECL_ARGUMENTS (t
));
1279 /* In this case we need "in-charge" flag saying whether
1280 this constructor is responsible for initialization
1281 of virtual baseclasses or not. */
1282 parm
= build_decl (PARM_DECL
, in_charge_identifier
, integer_type_node
);
1283 /* Mark the artificial `__in_chrg' parameter as "artificial". */
1284 SET_DECL_ARTIFICIAL (parm
);
1285 DECL_ARG_TYPE (parm
) = integer_type_node
;
1286 DECL_REGISTER (parm
) = 1;
1287 TREE_CHAIN (parm
) = TREE_CHAIN (fnargs
);
1288 TREE_CHAIN (fnargs
) = parm
;
1290 fnargs
= tsubst (fnargs
, args
, nargs
, t
);
1293 fprintf (stderr
, "\nfor function %s in class %s:\n",
1294 IDENTIFIER_POINTER (name
),
1295 IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx
)));
1297 for (i
= 0; i
< n_methods
; i
++)
1301 method
= TREE_VEC_ELT (methods
, i
);
1302 if (method
== NULL_TREE
|| DECL_NAME (method
) != name
)
1307 for (; method
; method
= DECL_CHAIN (method
))
1309 my_friendly_assert (TREE_CODE (method
) == FUNCTION_DECL
,
1311 if (! comptypes (type
, TREE_TYPE (method
), 1))
1313 tree mtype
= TREE_TYPE (method
);
1316 /* Keep looking for a method that matches
1317 perfectly. This takes care of the problem
1318 where destructors (which have implicit int args)
1319 look like constructors which have an int arg. */
1323 t1
= TYPE_ARG_TYPES (mtype
);
1324 t2
= TYPE_ARG_TYPES (type
);
1325 if (TREE_CODE (mtype
) == FUNCTION_TYPE
)
1326 t2
= TREE_CHAIN (t2
);
1328 if (list_eq (t1
, t2
))
1330 if (TREE_CODE (mtype
) == FUNCTION_TYPE
)
1333 newtype
= build_function_type (TREE_TYPE (type
),
1334 TYPE_ARG_TYPES (type
));
1335 newtype
= build_type_variant (newtype
,
1336 TYPE_READONLY (type
),
1337 TYPE_VOLATILE (type
));
1339 if (TREE_TYPE (type
) != TREE_TYPE (mtype
))
1340 goto maybe_bad_return_type
;
1342 else if (TYPE_METHOD_BASETYPE (mtype
)
1343 == TYPE_METHOD_BASETYPE (type
))
1345 /* Types didn't match, but arg types and
1346 `this' do match, so the return type is
1347 all that should be messing it up. */
1348 maybe_bad_return_type
:
1349 if (TREE_TYPE (type
) != TREE_TYPE (mtype
))
1350 error ("inconsistent return types for method `%s' in class `%s'",
1351 IDENTIFIER_POINTER (name
),
1352 IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx
)));
1361 fprintf (stderr
, "\tfound %s\n\n",
1362 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
)));
1364 if (DECL_ARTIFICIAL (method
))
1366 cp_error ("template for method `%D' which has default implementation in class `%T'", name
, ctx
);
1368 cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl
);
1369 return error_mark_node
;
1372 if (DECL_ARGUMENTS (method
)
1373 && ! TREE_PERMANENT (DECL_ARGUMENTS (method
)))
1374 /* @@ Is this early enough? Might we want to do
1375 this instead while processing the expansion? */
1376 DECL_ARGUMENTS (method
)
1377 = tsubst (DECL_ARGUMENTS (t
), args
, nargs
, t
);
1381 if (r
== NULL_TREE
&& pass
== 0)
1384 method
= TREE_VEC_ELT (methods
, i
);
1393 ? "template for method `%D' doesn't match any in class `%T'"
1394 : "method `%D' not found in class `%T'", name
, ctx
);
1396 cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl
);
1397 return error_mark_node
;
1407 decls
= lookup_name_nonclass (r
);
1408 if (decls
== NULL_TREE
)
1410 else if (TREE_CODE (decls
) == TREE_LIST
)
1411 for (decls
= TREE_VALUE (decls
); decls
;
1412 decls
= DECL_CHAIN (decls
))
1414 if (TREE_CODE (decls
) == FUNCTION_DECL
1415 && TREE_TYPE (decls
) == type
)
1426 if (TREE_CODE (val
) == FUNCTION_DECL
1427 && TREE_TYPE (val
) == type
)
1436 tree a
= build_decl_overload (r
, TYPE_VALUES (type
),
1437 DECL_CONTEXT (t
) != NULL_TREE
);
1438 r
= build_lang_decl (FUNCTION_DECL
, r
, type
);
1439 DECL_ASSEMBLER_NAME (r
) = a
;
1441 else if (TREE_STATIC (r
))
1443 /* This overrides the template version, use it. */
1448 TREE_PUBLIC (r
) = 1;
1449 DECL_EXTERNAL (r
) = 1;
1450 TREE_STATIC (r
) = 0;
1451 DECL_INTERFACE_KNOWN (r
) = 0;
1452 DECL_INLINE (r
) = DECL_INLINE (t
);
1454 #if 0 /* Maybe later. -jason */
1455 struct tinst_level
*til
= tinst_for_decl();
1457 /* should always be true under new approach */
1460 DECL_SOURCE_FILE (r
) = til
->file
;
1461 DECL_SOURCE_LINE (r
) = til
->line
;
1466 DECL_SOURCE_FILE (r
) = DECL_SOURCE_FILE (t
);
1467 DECL_SOURCE_LINE (r
) = DECL_SOURCE_LINE (t
);
1470 DECL_CLASS_CONTEXT (r
) = tsubst (DECL_CLASS_CONTEXT (t
), args
, nargs
, t
);
1471 make_decl_rtl (r
, NULL_PTR
, 1);
1472 DECL_ARGUMENTS (r
) = fnargs
;
1473 DECL_RESULT (r
) = result
;
1475 if (DECL_CONTEXT (t
) == NULL_TREE
1476 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) != 't')
1477 push_overloaded_decl_top_level (r
, 0);
1485 r
= build_decl (PARM_DECL
, DECL_NAME (t
), type
);
1486 DECL_INITIAL (r
) = TREE_TYPE (r
);
1488 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
, nargs
, TREE_CHAIN (t
));
1494 tree purpose
, value
, chain
, result
;
1495 int via_public
, via_virtual
, via_protected
;
1497 if (t
== void_list_node
)
1500 via_public
= TREE_VIA_PUBLIC (t
);
1501 via_protected
= TREE_VIA_PROTECTED (t
);
1502 via_virtual
= TREE_VIA_VIRTUAL (t
);
1504 purpose
= TREE_PURPOSE (t
);
1506 purpose
= tsubst (purpose
, args
, nargs
, in_decl
);
1507 value
= TREE_VALUE (t
);
1509 value
= tsubst (value
, args
, nargs
, in_decl
);
1510 chain
= TREE_CHAIN (t
);
1511 if (chain
&& chain
!= void_type_node
)
1512 chain
= tsubst (chain
, args
, nargs
, in_decl
);
1513 if (purpose
== TREE_PURPOSE (t
)
1514 && value
== TREE_VALUE (t
)
1515 && chain
== TREE_CHAIN (t
))
1517 result
= hash_tree_cons (via_public
, via_virtual
, via_protected
,
1518 purpose
, value
, chain
);
1519 TREE_PARMLIST (result
) = TREE_PARMLIST (t
);
1524 int len
= TREE_VEC_LENGTH (t
), need_new
= 0, i
;
1525 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
1526 bzero ((char *) elts
, len
* sizeof (tree
));
1528 for (i
= 0; i
< len
; i
++)
1530 elts
[i
] = tsubst (TREE_VEC_ELT (t
, i
), args
, nargs
, in_decl
);
1531 if (elts
[i
] != TREE_VEC_ELT (t
, i
))
1538 t
= make_tree_vec (len
);
1539 for (i
= 0; i
< len
; i
++)
1540 TREE_VEC_ELT (t
, i
) = elts
[i
];
1544 case REFERENCE_TYPE
:
1547 enum tree_code code
;
1548 if (type
== TREE_TYPE (t
))
1551 code
= TREE_CODE (t
);
1552 if (code
== POINTER_TYPE
)
1553 r
= build_pointer_type (type
);
1555 r
= build_reference_type (type
);
1556 r
= cp_build_type_variant (r
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1557 /* Will this ever be needed for TYPE_..._TO values? */
1562 return build_offset_type
1563 (tsubst (TYPE_OFFSET_BASETYPE (t
), args
, nargs
, in_decl
), type
);
1567 tree values
= TYPE_VALUES (t
); /* same as TYPE_ARG_TYPES */
1568 tree context
= TYPE_CONTEXT (t
);
1571 /* Don't bother recursing if we know it won't change anything. */
1572 if (values
!= void_list_node
)
1573 values
= tsubst (values
, args
, nargs
, in_decl
);
1575 context
= tsubst (context
, args
, nargs
, in_decl
);
1576 /* Could also optimize cases where return value and
1577 values have common elements (e.g., T min(const &T, const T&). */
1579 /* If the above parameters haven't changed, just return the type. */
1580 if (type
== TREE_TYPE (t
)
1581 && values
== TYPE_VALUES (t
)
1582 && context
== TYPE_CONTEXT (t
))
1585 /* Construct a new type node and return it. */
1586 if (TREE_CODE (t
) == FUNCTION_TYPE
1587 && context
== NULL_TREE
)
1589 new_value
= build_function_type (type
, values
);
1591 else if (context
== NULL_TREE
)
1593 tree base
= tsubst (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))),
1594 args
, nargs
, in_decl
);
1595 new_value
= build_cplus_method_type (base
, type
,
1596 TREE_CHAIN (values
));
1600 new_value
= make_node (TREE_CODE (t
));
1601 TREE_TYPE (new_value
) = type
;
1602 TYPE_CONTEXT (new_value
) = context
;
1603 TYPE_VALUES (new_value
) = values
;
1604 TYPE_SIZE (new_value
) = TYPE_SIZE (t
);
1605 TYPE_ALIGN (new_value
) = TYPE_ALIGN (t
);
1606 TYPE_MODE (new_value
) = TYPE_MODE (t
);
1607 if (TYPE_METHOD_BASETYPE (t
))
1608 TYPE_METHOD_BASETYPE (new_value
) = tsubst (TYPE_METHOD_BASETYPE (t
),
1609 args
, nargs
, in_decl
);
1610 /* Need to generate hash value. */
1611 my_friendly_abort (84);
1613 new_value
= build_type_variant (new_value
,
1620 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, nargs
, in_decl
);
1622 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
1624 r
= build_cplus_array_type (type
, domain
);
1628 case UNINSTANTIATED_P_TYPE
:
1630 int nparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (UPT_TEMPLATE (t
)));
1631 tree argvec
= make_tree_vec (nparms
);
1632 tree parmvec
= UPT_PARMS (t
);
1635 for (i
= 0; i
< nparms
; i
++)
1636 TREE_VEC_ELT (argvec
, i
) = tsubst (TREE_VEC_ELT (parmvec
, i
),
1637 args
, nargs
, in_decl
);
1638 id
= lookup_template_class (DECL_NAME (UPT_TEMPLATE (t
)), argvec
, NULL_TREE
);
1639 if (! IDENTIFIER_HAS_TYPE_VALUE (id
)) {
1640 instantiate_class_template(id
, 0);
1641 /* set up pending_classes */
1642 add_pending_template (id
);
1644 TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (id
)) =
1645 IDENTIFIER_TYPE_VALUE (id
);
1647 rt
= IDENTIFIER_TYPE_VALUE (id
);
1649 /* kung: this part handles nested type in template definition */
1651 if ( !ANON_AGGRNAME_P (DECL_NAME(TYPE_NAME(t
))))
1653 rt
= search_nested_type_in_tmpl (rt
, t
);
1656 return build_type_variant (rt
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1661 return fold (build (TREE_CODE (t
), TREE_TYPE (t
),
1662 tsubst (TREE_OPERAND (t
, 0), args
, nargs
, in_decl
),
1663 tsubst (TREE_OPERAND (t
, 1), args
, nargs
, in_decl
)));
1667 return fold (build1 (TREE_CODE (t
), TREE_TYPE (t
),
1668 tsubst (TREE_OPERAND (t
, 0), args
, nargs
, in_decl
)));
1671 sorry ("use of `%s' in function template",
1672 tree_code_name
[(int) TREE_CODE (t
)]);
1673 return error_mark_node
;
1678 instantiate_template (tmpl
, targ_ptr
)
1679 tree tmpl
, *targ_ptr
;
1683 struct pending_inline
*p
;
1684 struct template_info
*t
;
1685 struct obstack
*old_fmp_obstack
;
1686 extern struct obstack
*function_maybepermanent_obstack
;
1688 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1689 old_fmp_obstack
= function_maybepermanent_obstack
;
1690 function_maybepermanent_obstack
= &permanent_obstack
;
1692 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 283);
1693 len
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl
));
1697 targ_ptr
[i
] = copy_to_permanent (targ_ptr
[i
]);
1699 for (fndecl
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1700 fndecl
; fndecl
= TREE_CHAIN (fndecl
))
1702 tree
*t1
= &TREE_VEC_ELT (TREE_PURPOSE (fndecl
), 0);
1703 for (i
= len
- 1; i
>= 0; i
--)
1704 if (simple_cst_equal (t1
[i
], targ_ptr
[i
]) <= 0)
1707 /* Here, we have a match. */
1708 fndecl
= TREE_VALUE (fndecl
);
1715 targs
= make_tree_vec (len
);
1718 TREE_VEC_ELT (targs
, i
) = targ_ptr
[i
];
1720 /* substitute template parameters */
1721 fndecl
= tsubst (DECL_RESULT (tmpl
), targ_ptr
,
1722 TREE_VEC_LENGTH (targs
), tmpl
);
1724 if (fndecl
== error_mark_node
)
1727 assemble_external (fndecl
);
1729 /* If it's a static member fn in the template, we need to change it
1730 into a FUNCTION_TYPE and chop off its this pointer. */
1731 if (TREE_CODE (TREE_TYPE (DECL_RESULT (tmpl
))) == METHOD_TYPE
1732 && DECL_STATIC_FUNCTION_P (fndecl
))
1734 tree olddecl
= DECL_RESULT (tmpl
);
1735 revert_static_member_fn (&DECL_RESULT (tmpl
), NULL
, NULL
);
1736 /* Chop off the this pointer that grokclassfn so kindly added
1737 for us (it didn't know yet if the fn was static or not). */
1738 DECL_ARGUMENTS (olddecl
) = TREE_CHAIN (DECL_ARGUMENTS (olddecl
));
1739 DECL_ARGUMENTS (fndecl
) = TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
1742 t
= DECL_TEMPLATE_INFO (tmpl
);
1744 /* If we have a preexisting version of this function, don't expand
1745 the template version, use the other instead. */
1746 if (TREE_STATIC (fndecl
))
1748 SET_DECL_TEMPLATE_SPECIALIZATION (fndecl
);
1749 p
= (struct pending_inline
*)0;
1753 SET_DECL_IMPLICIT_INSTANTIATION (fndecl
);
1754 p
= (struct pending_inline
*) permalloc (sizeof (struct pending_inline
));
1755 p
->parm_vec
= t
->parm_vec
;
1756 p
->bindings
= targs
;
1764 char * f
= input_filename
;
1766 lineno
= p
->lineno
= t
->lineno
;
1767 input_filename
= p
->filename
= t
->filename
;
1769 extract_interface_info ();
1771 if (interface_unknown
&& flag_external_templates
)
1773 if (DECL_CLASS_CONTEXT (fndecl
)
1774 && CLASSTYPE_INTERFACE_KNOWN (DECL_CLASS_CONTEXT (fndecl
)))
1776 interface_unknown
= 0;
1778 = CLASSTYPE_INTERFACE_ONLY (DECL_CLASS_CONTEXT (fndecl
));
1780 else if (! DECL_IN_SYSTEM_HEADER (tmpl
))
1781 warn_if_unknown_interface (tmpl
);
1784 if (interface_unknown
|| ! flag_external_templates
)
1785 p
->interface
= 1; /* unknown */
1787 p
->interface
= interface_only
? 0 : 2;
1792 extract_interface_info ();
1796 p
= (struct pending_inline
*)0;
1798 DECL_TEMPLATE_INSTANTIATIONS (tmpl
) =
1799 tree_cons (targs
, fndecl
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1801 if (p
== (struct pending_inline
*)0)
1805 else if (DECL_INLINE (fndecl
))
1807 DECL_PENDING_INLINE_INFO (fndecl
) = p
;
1808 p
->next
= pending_inlines
;
1809 pending_inlines
= p
;
1813 p
->next
= pending_template_expansions
;
1814 pending_template_expansions
= p
;
1817 function_maybepermanent_obstack
= old_fmp_obstack
;
1823 /* classlevel should now never be true. jason 4/12/94 */
1825 undo_template_name_overload (id
, classlevel
)
1831 template = IDENTIFIER_TEMPLATE (id
);
1835 #if 0 /* not yet, should get fixed properly later */
1839 /* This was a botch... See `overload_template_name' just below. */
1845 /* classlevel should now never be true. jason 4/12/94 */
1847 overload_template_name (id
, classlevel
)
1851 tree
template, t
, decl
;
1852 struct template_info
*tinfo
;
1854 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 284);
1855 template = IDENTIFIER_TEMPLATE (id
);
1859 template = TREE_PURPOSE (template);
1860 tinfo
= DECL_TEMPLATE_INFO (template);
1861 template = DECL_NAME (template);
1862 my_friendly_assert (template != NULL_TREE
, 285);
1865 /* This was a botch... names of templates do not get their own private
1866 scopes. Rather, they should go into the binding level already created
1867 by push_template_decls. Except that there isn't one of those for
1872 declare_pseudo_global_level ();
1876 t
= xref_tag (tinfo
->aggr
, id
, NULL_TREE
, 1);
1877 my_friendly_assert (TREE_CODE (t
) == RECORD_TYPE
1878 || TREE_CODE (t
) == UNION_TYPE
1879 || TREE_CODE (t
) == UNINSTANTIATED_P_TYPE
, 286);
1881 decl
= build_decl (TYPE_DECL
, template, t
);
1882 SET_DECL_ARTIFICIAL (decl
);
1884 #if 0 /* fix this later */
1885 /* We don't want to call here if the work has already been done. */
1887 ? IDENTIFIER_CLASS_VALUE (template)
1888 : IDENTIFIER_LOCAL_VALUE (template));
1890 && TREE_CODE (t
) == TYPE_DECL
1891 && TREE_TYPE (t
) == t
)
1892 my_friendly_abort (85);
1896 pushdecl_class_level (decl
);
1900 #if 0 /* This seems bogus to me; if it isn't, explain why. (jason) */
1901 /* Fake this for now, just to make dwarfout.c happy. It will have to
1902 be done in a proper way later on. */
1903 DECL_CONTEXT (decl
) = t
;
1907 /* NAME is the IDENTIFIER value of a PRE_PARSED_CLASS_DECL. */
1909 end_template_instantiation (name
)
1912 extern struct pending_input
*to_be_restored
;
1915 processing_template_defn
--;
1916 if (!flag_external_templates
)
1917 interface_unknown
--;
1919 /* Restore the old parser input state. */
1920 if (yychar
== YYEMPTY
)
1922 if (yychar
!= END_OF_SAVED_INPUT
)
1923 error ("parse error at end of class template");
1926 restore_pending_input (to_be_restored
);
1930 /* Our declarations didn't get stored in the global slot, since
1931 there was a (supposedly tags-transparent) scope in between. */
1932 t
= IDENTIFIER_TYPE_VALUE (name
);
1933 my_friendly_assert (t
!= NULL_TREE
1934 && TREE_CODE_CLASS (TREE_CODE (t
)) == 't',
1936 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
1937 /* Make methods of template classes static, unless
1938 -fexternal-templates is given. */
1939 if (!flag_external_templates
)
1940 SET_CLASSTYPE_INTERFACE_UNKNOWN (t
);
1941 decl
= IDENTIFIER_GLOBAL_VALUE (name
);
1942 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 288);
1944 undo_template_name_overload (name
, 0);
1945 t
= IDENTIFIER_TEMPLATE (name
);
1946 pop_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (t
)), TREE_VALUE (t
),
1948 /* This will fix up the type-value field. */
1950 pop_from_top_level ();
1952 #ifdef DWARF_DEBUGGING_INFO
1953 if (write_symbols
== DWARF_DEBUG
&& TREE_CODE (decl
) == TYPE_DECL
)
1955 /* We just completed the definition of a new file-scope type,
1956 so we can go ahead and output debug-info for it now. */
1957 TYPE_STUB_DECL (TREE_TYPE (decl
)) = decl
;
1958 rest_of_type_compilation (TREE_TYPE (decl
), 1);
1960 #endif /* DWARF_DEBUGGING_INFO */
1962 /* Restore interface/implementation settings. */
1963 extract_interface_info ();
1966 /* Store away the text of an template. */
1969 reinit_parse_for_template (yychar
, d1
, d2
)
1973 struct template_info
*template_info
;
1974 extern struct obstack inline_text_obstack
; /* see comment in lex.c */
1976 if (d2
== NULL_TREE
|| d2
== error_mark_node
)
1979 /* @@ Should use temp obstack, and discard results. */
1980 reinit_parse_for_block (yychar
, &inline_text_obstack
, 1);
1984 if (TREE_CODE (d2
) == IDENTIFIER_NODE
)
1985 d2
= IDENTIFIER_GLOBAL_VALUE (d2
);
1988 template_info
= DECL_TEMPLATE_INFO (d2
);
1991 template_info
= (struct template_info
*) permalloc (sizeof (struct template_info
));
1992 bzero ((char *) template_info
, sizeof (struct template_info
));
1993 DECL_TEMPLATE_INFO (d2
) = template_info
;
1995 template_info
->filename
= input_filename
;
1996 template_info
->lineno
= lineno
;
1997 reinit_parse_for_block (yychar
, &inline_text_obstack
, 1);
1998 template_info
->text
= obstack_base (&inline_text_obstack
);
1999 template_info
->length
= obstack_object_size (&inline_text_obstack
);
2000 obstack_finish (&inline_text_obstack
);
2001 template_info
->parm_vec
= d1
;
2004 /* Type unification.
2006 We have a function template signature with one or more references to
2007 template parameters, and a parameter list we wish to fit to this
2008 template. If possible, produce a list of parameters for the template
2009 which will cause it to fit the supplied parameter list.
2011 Return zero for success, 2 for an incomplete match that doesn't resolve
2012 all the types, and 1 for complete failure. An error message will be
2013 printed only for an incomplete match.
2015 TPARMS[NTPARMS] is an array of template parameter types;
2016 TARGS[NTPARMS] is the array of template parameter values. PARMS is
2017 the function template's signature (using TEMPLATE_PARM_IDX nodes),
2018 and ARGS is the argument list we're trying to match against it.
2020 If SUBR is 1, we're being called recursively (to unify the arguments of
2021 a function or method parameter of a function template), so don't zero
2022 out targs and don't fail on an incomplete match. */
2025 type_unification (tparms
, targs
, parms
, args
, nsubsts
, subr
)
2026 tree tparms
, *targs
, parms
, args
;
2031 int ntparms
= TREE_VEC_LENGTH (tparms
);
2033 my_friendly_assert (TREE_CODE (tparms
) == TREE_VEC
, 289);
2034 my_friendly_assert (TREE_CODE (parms
) == TREE_LIST
, 290);
2035 /* ARGS could be NULL (via a call from parse.y to
2036 build_x_function_call). */
2038 my_friendly_assert (TREE_CODE (args
) == TREE_LIST
, 291);
2039 my_friendly_assert (ntparms
> 0, 292);
2042 bzero ((char *) targs
, sizeof (tree
) * ntparms
);
2045 && parms
!= void_list_node
2047 && args
!= void_list_node
)
2049 parm
= TREE_VALUE (parms
);
2050 parms
= TREE_CHAIN (parms
);
2051 arg
= TREE_VALUE (args
);
2052 args
= TREE_CHAIN (args
);
2054 if (arg
== error_mark_node
)
2056 if (arg
== unknown_type_node
)
2059 if (! uses_template_parms (parm
)
2060 && TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
2062 if (can_convert_arg (parm
, TREE_TYPE (arg
), arg
))
2068 if (TREE_CODE (arg
) == VAR_DECL
)
2069 arg
= TREE_TYPE (arg
);
2070 else if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'e')
2071 arg
= TREE_TYPE (arg
);
2073 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
2075 my_friendly_assert (TREE_TYPE (arg
) != NULL_TREE
, 293);
2076 if (TREE_CODE (arg
) == TREE_LIST
2077 && TREE_TYPE (arg
) == unknown_type_node
2078 && TREE_CODE (TREE_VALUE (arg
)) == TEMPLATE_DECL
)
2080 int nsubsts
, ntparms
;
2083 /* Have to back unify here */
2084 arg
= TREE_VALUE (arg
);
2086 ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (arg
));
2087 targs
= (tree
*) alloca (sizeof (tree
) * ntparms
);
2088 parm
= tree_cons (NULL_TREE
, parm
, NULL_TREE
);
2089 return type_unification (DECL_TEMPLATE_PARMS (arg
), targs
,
2090 TYPE_ARG_TYPES (TREE_TYPE (arg
)),
2093 arg
= TREE_TYPE (arg
);
2096 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
2097 arg
= TREE_TYPE (arg
);
2099 if (TREE_CODE (parm
) != REFERENCE_TYPE
)
2101 if (TREE_CODE (arg
) == FUNCTION_TYPE
2102 || TREE_CODE (arg
) == METHOD_TYPE
)
2103 arg
= build_pointer_type (arg
);
2104 else if (TREE_CODE (arg
) == ARRAY_TYPE
)
2105 arg
= build_pointer_type (TREE_TYPE (arg
));
2107 arg
= TYPE_MAIN_VARIANT (arg
);
2110 switch (unify (tparms
, targs
, ntparms
, parm
, arg
, nsubsts
))
2118 /* Fail if we've reached the end of the parm list, and more args
2119 are present, and the parm list isn't variadic. */
2120 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
2122 /* Fail if parms are left and they don't have default values. */
2124 && parms
!= void_list_node
2125 && TREE_PURPOSE (parms
) == NULL_TREE
)
2128 for (i
= 0; i
< ntparms
; i
++)
2131 error ("incomplete type unification");
2137 /* Tail recursion is your friend. */
2139 unify (tparms
, targs
, ntparms
, parm
, arg
, nsubsts
)
2140 tree tparms
, *targs
, parm
, arg
;
2141 int *nsubsts
, ntparms
;
2145 /* I don't think this will do the right thing with respect to types.
2146 But the only case I've seen it in so far has been array bounds, where
2147 signedness is the only information lost, and I think that will be
2149 while (TREE_CODE (parm
) == NOP_EXPR
)
2150 parm
= TREE_OPERAND (parm
, 0);
2152 if (arg
== error_mark_node
)
2154 if (arg
== unknown_type_node
)
2159 switch (TREE_CODE (parm
))
2161 case TEMPLATE_TYPE_PARM
:
2163 if (TEMPLATE_TYPE_TPARMLIST (parm
) != tparms
)
2165 error ("mixed template headers?!");
2166 my_friendly_abort (86);
2169 idx
= TEMPLATE_TYPE_IDX (parm
);
2171 /* Template type parameters cannot contain cv-quals; i.e.
2172 template <class T> void f (T& a, T& b) will not generate
2173 void f (const int& a, const int& b). */
2174 if (TYPE_READONLY (arg
) > TYPE_READONLY (parm
)
2175 || TYPE_VOLATILE (arg
) > TYPE_VOLATILE (parm
))
2177 arg
= TYPE_MAIN_VARIANT (arg
);
2180 int constp
= TYPE_READONLY (arg
) > TYPE_READONLY (parm
);
2181 int volatilep
= TYPE_VOLATILE (arg
) > TYPE_VOLATILE (parm
);
2182 arg
= cp_build_type_variant (arg
, constp
, volatilep
);
2185 /* Simple cases: Value already set, does match or doesn't. */
2186 if (targs
[idx
] == arg
)
2188 else if (targs
[idx
])
2190 /* Check for mixed types and values. */
2191 if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (tparms
, idx
))) != TYPE_DECL
)
2195 case TEMPLATE_CONST_PARM
:
2197 idx
= TEMPLATE_CONST_IDX (parm
);
2198 if (targs
[idx
] == arg
)
2200 else if (targs
[idx
])
2202 tree t
= targs
[idx
];
2203 if (TREE_CODE (t
) == TREE_CODE (arg
))
2204 switch (TREE_CODE (arg
))
2207 if (tree_int_cst_equal (t
, arg
))
2211 if (REAL_VALUES_EQUAL (TREE_REAL_CST (t
), TREE_REAL_CST (arg
)))
2214 /* STRING_CST values are not valid template const parms. */
2218 my_friendly_abort (87);
2221 /* else if (typeof arg != tparms[idx])
2224 targs
[idx
] = copy_to_permanent (arg
);
2228 if (TREE_CODE (arg
) != POINTER_TYPE
)
2230 return unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
), TREE_TYPE (arg
),
2233 case REFERENCE_TYPE
:
2234 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
2235 arg
= TREE_TYPE (arg
);
2236 return unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
), arg
, nsubsts
);
2239 if (TREE_CODE (arg
) != ARRAY_TYPE
)
2241 if (unify (tparms
, targs
, ntparms
, TYPE_DOMAIN (parm
), TYPE_DOMAIN (arg
),
2244 return unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
), TREE_TYPE (arg
),
2249 if (TREE_CODE (arg
) != TREE_CODE (parm
))
2252 if (TREE_CODE (parm
) == INTEGER_TYPE
)
2254 if (TYPE_MIN_VALUE (parm
) && TYPE_MIN_VALUE (arg
)
2255 && unify (tparms
, targs
, ntparms
,
2256 TYPE_MIN_VALUE (parm
), TYPE_MIN_VALUE (arg
), nsubsts
))
2258 if (TYPE_MAX_VALUE (parm
) && TYPE_MAX_VALUE (arg
)
2259 && unify (tparms
, targs
, ntparms
,
2260 TYPE_MAX_VALUE (parm
), TYPE_MAX_VALUE (arg
), nsubsts
))
2263 /* As far as unification is concerned, this wins. Later checks
2264 will invalidate it if necessary. */
2267 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
2269 if (TREE_CODE (arg
) != INTEGER_CST
)
2271 return !tree_int_cst_equal (parm
, arg
);
2276 t1
= TREE_OPERAND (parm
, 0);
2277 t2
= TREE_OPERAND (parm
, 1);
2278 return unify (tparms
, targs
, ntparms
, t1
,
2279 fold (build (PLUS_EXPR
, integer_type_node
, arg
, t2
)),
2286 if (TREE_CODE (arg
) != TREE_VEC
)
2288 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
2290 for (i
= TREE_VEC_LENGTH (parm
) - 1; i
>= 0; i
--)
2291 if (unify (tparms
, targs
, ntparms
,
2292 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
2298 case UNINSTANTIATED_P_TYPE
:
2301 /* Unification of something that is not a class fails. */
2302 if (! IS_AGGR_TYPE (arg
))
2304 a
= IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (arg
));
2305 if (a
&& UPT_TEMPLATE (parm
) == TREE_PURPOSE (a
))
2306 return unify (tparms
, targs
, ntparms
, UPT_PARMS (parm
),
2307 TREE_VALUE (a
), nsubsts
);
2308 /* FIXME: Should check base conversions here. */
2313 if (TYPE_PTRMEMFUNC_FLAG (parm
))
2314 return unify (tparms
, targs
, ntparms
, TYPE_PTRMEMFUNC_FN_TYPE (parm
),
2317 /* Allow trivial conversions. */
2318 if (TYPE_MAIN_VARIANT (parm
) != TYPE_MAIN_VARIANT (arg
)
2319 || TYPE_READONLY (parm
) < TYPE_READONLY (arg
)
2320 || TYPE_VOLATILE (parm
) < TYPE_VOLATILE (arg
))
2325 if (TREE_CODE (arg
) != METHOD_TYPE
)
2330 if (TREE_CODE (arg
) != FUNCTION_TYPE
)
2333 if (unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
),
2334 TREE_TYPE (arg
), nsubsts
))
2336 return type_unification (tparms
, targs
, TYPE_ARG_TYPES (parm
),
2337 TYPE_ARG_TYPES (arg
), nsubsts
, 1);
2340 if (TREE_CODE (arg
) != OFFSET_TYPE
)
2342 if (unify (tparms
, targs
, ntparms
, TYPE_OFFSET_BASETYPE (parm
),
2343 TYPE_OFFSET_BASETYPE (arg
), nsubsts
))
2345 return unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
),
2346 TREE_TYPE (arg
), nsubsts
);
2349 sorry ("use of `%s' in template type unification",
2350 tree_code_name
[(int) TREE_CODE (parm
)]);
2359 do_pending_expansions ()
2361 struct pending_inline
*i
, *new_list
= 0;
2363 if (!pending_template_expansions
)
2367 fprintf (stderr
, "\n\n\t\t IN DO_PENDING_EXPANSIONS\n\n");
2370 i
= pending_template_expansions
;
2375 struct pending_inline
*next
= i
->next
;
2379 #define DECIDE(N) do {decision=(N); goto decided;} while(0)
2381 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
2382 || TREE_CODE (t
) == VAR_DECL
, 294);
2383 if (TREE_ASM_WRITTEN (t
))
2386 if (DECL_EXPLICIT_INSTANTIATION (t
))
2387 DECIDE (! DECL_EXTERNAL (t
));
2388 else if (! flag_implicit_templates
)
2391 if (i
->interface
== 1)
2392 /* OK, it was an implicit instantiation. */
2393 TREE_PUBLIC (t
) = 0;
2395 /* If it's a method, let the class type decide it.
2396 @@ What if the method template is in a separate file?
2397 Maybe both file contexts should be taken into account?
2398 Maybe only do this if i->interface == 1 (unknown)? */
2399 context
= DECL_CONTEXT (t
);
2400 if (context
!= NULL_TREE
2401 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't')
2403 /* I'm interested in the context of this version of the function,
2404 not the original virtual declaration. */
2405 context
= DECL_CLASS_CONTEXT (t
);
2407 /* If `unknown', we might want a static copy.
2408 If `implementation', we want a global one.
2409 If `interface', ext ref. */
2410 if (CLASSTYPE_INTERFACE_KNOWN (context
))
2411 DECIDE (!CLASSTYPE_INTERFACE_ONLY (context
));
2412 #if 0 /* This doesn't get us stuff needed only by the file initializer. */
2413 DECIDE (TREE_USED (t
));
2414 #else /* This compiles too much stuff, but that's probably better in
2415 most cases than never compiling the stuff we need. */
2420 if (i
->interface
== 1)
2421 DECIDE (TREE_USED (t
));
2423 DECIDE (i
->interface
);
2427 print_node_brief (stderr
, decision
? "yes: " : "no: ", t
, 0);
2428 fprintf (stderr
, "\t%s\n",
2429 (DECL_ASSEMBLER_NAME (t
)
2430 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
))
2435 i
->next
= pending_inlines
;
2436 pending_inlines
= i
;
2445 pending_template_expansions
= new_list
;
2446 if (!pending_inlines
)
2448 do_pending_inlines ();
2453 struct pending_template
{
2454 struct pending_template
*next
;
2458 static struct pending_template
* pending_templates
;
2461 do_pending_templates ()
2463 struct pending_template
* t
;
2465 for ( t
= pending_templates
; t
; t
= t
->next
)
2467 instantiate_class_template (t
->id
, 1);
2470 for ( t
= pending_templates
; t
; t
= pending_templates
)
2472 pending_templates
= t
->next
;
2478 add_pending_template (pt
)
2481 struct pending_template
*p
;
2483 p
= (struct pending_template
*) malloc (sizeof (struct pending_template
));
2484 p
->next
= pending_templates
;
2485 pending_templates
= p
;
2489 /* called from the parser. */
2491 do_function_instantiation (declspecs
, declarator
, storage
)
2492 tree declspecs
, declarator
, storage
;
2494 tree decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, 0, 0);
2495 tree name
= DECL_NAME (decl
);
2496 tree fn
= IDENTIFIER_GLOBAL_VALUE (name
);
2497 tree result
= NULL_TREE
;
2500 for (fn
= get_first_fn (fn
); fn
; fn
= DECL_CHAIN (fn
))
2501 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2503 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (fn
));
2504 tree
*targs
= (tree
*) malloc (sizeof (tree
) * ntparms
);
2506 i
= type_unification (DECL_TEMPLATE_PARMS (fn
), targs
,
2507 TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2508 TYPE_ARG_TYPES (TREE_TYPE (decl
)),
2513 cp_error ("ambiguous template instantiation for `%D' requested", decl
);
2515 result
= instantiate_template (fn
, targs
);
2521 cp_error ("no matching template for `%D' found", decl
);
2523 if (flag_external_templates
)
2526 SET_DECL_EXPLICIT_INSTANTIATION (result
);
2527 TREE_PUBLIC (result
) = 1;
2529 if (storage
== NULL_TREE
)
2531 DECL_INTERFACE_KNOWN (result
) = 1;
2532 DECL_EXTERNAL (result
) = 0;
2533 TREE_STATIC (result
) = 1;
2535 else if (storage
== ridpointers
[(int) RID_EXTERN
])
2538 cp_error ("storage class `%D' applied to template instantiation",
2543 do_type_instantiation (name
, storage
)
2546 tree t
= TREE_TYPE (name
);
2549 /* With -fexternal-templates, explicit instantiations are treated the same
2550 as implicit ones. */
2551 if (flag_external_templates
)
2554 if (TYPE_SIZE (t
) == NULL_TREE
)
2556 cp_error ("explicit instantiation of `%#T' before definition of template",
2561 if (storage
== NULL_TREE
)
2563 else if (storage
== ridpointers
[(int) RID_EXTERN
])
2567 cp_error ("storage class `%D' applied to template instantiation",
2572 /* We've already instantiated this. */
2573 if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
) && ! CLASSTYPE_INTERFACE_ONLY (t
))
2576 cp_pedwarn ("multiple explicit instantiation of `%#T'", t
);
2580 if (! CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
2582 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
2583 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
2584 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
2585 CLASSTYPE_VTABLE_NEEDS_WRITING (t
) = ! extern_p
;
2586 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
2589 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2590 rest_of_type_compilation (t
, 1);
2596 /* Classes nested in template classes currently don't have an
2597 IDENTIFIER_TEMPLATE--their out-of-line members are handled
2598 by the enclosing template class. Note that there are name
2599 conflict bugs with this approach. */
2600 tmp
= TYPE_IDENTIFIER (t
);
2601 if (IDENTIFIER_TEMPLATE (tmp
))
2602 instantiate_member_templates (tmp
);
2604 /* this should really be done by instantiate_member_templates */
2605 tmp
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t
), 0);
2606 for (; tmp
; tmp
= TREE_CHAIN (tmp
))
2608 if (DECL_TEMPLATE_SPECIALIZATION (tmp
)
2609 || (DECL_USE_TEMPLATE (tmp
) == 0
2610 && CLASSTYPE_TEMPLATE_SPECIALIZATION (t
)))
2613 SET_DECL_EXPLICIT_INSTANTIATION (tmp
);
2614 TREE_PUBLIC (tmp
) = 1;
2617 DECL_INTERFACE_KNOWN (tmp
) = 1;
2618 DECL_EXTERNAL (tmp
) = 0;
2619 TREE_STATIC (tmp
) = 1;
2624 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
2626 if (TREE_CODE (tmp
) == VAR_DECL
)
2627 /* eventually do something */;
2631 for (tmp
= CLASSTYPE_TAGS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
2632 if (IS_AGGR_TYPE (TREE_VALUE (tmp
)))
2633 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp
)), storage
);
2638 create_nested_upt (scope
, name
)
2641 tree t
= make_lang_type (UNINSTANTIATED_P_TYPE
);
2642 tree d
= build_decl (TYPE_DECL
, name
, t
);
2645 TYPE_VALUES (t
) = TYPE_VALUES (scope
);
2646 TYPE_CONTEXT (t
) = scope
;