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
41 extern struct obstack permanent_obstack
;
42 extern tree
grokdeclarator ();
45 extern char *input_filename
;
46 struct pending_inline
*pending_template_expansions
;
48 int processing_template_decl
;
49 int processing_template_defn
;
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
55 static void add_pending_template ();
57 void overload_template_name (), pop_template_decls ();
59 /* We've got a template header coming up; set obstacks up to save the
60 nodes created permanently. (There might be cases with nested templates
61 where we don't have to do this, but they aren't implemented, and it
62 probably wouldn't be worth the effort.) */
64 begin_template_parm_list ()
67 push_obstacks (&permanent_obstack
, &permanent_obstack
);
71 /* Process information from new template parameter NEXT and append it to the
72 LIST being built. The rules for use of a template parameter type name
73 by later parameters are not well-defined for us just yet. However, the
74 only way to avoid having to parse expressions of unknown complexity (and
75 with tokens of unknown types) is to disallow it completely. So for now,
76 that is what is assumed. */
78 process_template_parm (list
, next
)
85 my_friendly_assert (TREE_CODE (parm
) == TREE_LIST
, 259);
86 is_type
= TREE_CODE (TREE_PURPOSE (parm
)) == IDENTIFIER_NODE
;
90 parm
= TREE_PURPOSE (parm
);
91 my_friendly_assert (TREE_CODE (parm
) == TREE_LIST
, 260);
92 parm
= TREE_VALUE (parm
);
93 /* is a const-param */
94 parm
= grokdeclarator (TREE_VALUE (next
), TREE_PURPOSE (next
),
96 /* A template parameter is not modifiable. */
97 TREE_READONLY (parm
) = 1;
98 if (TREE_CODE (TREE_TYPE (parm
)) == RECORD_TYPE
99 || TREE_CODE (TREE_TYPE (parm
)) == UNION_TYPE
)
101 sorry ("aggregate template parameter types");
102 TREE_TYPE (parm
) = void_type_node
;
104 tinfo
= make_node (TEMPLATE_CONST_PARM
);
105 my_friendly_assert (TREE_PERMANENT (tinfo
), 260.5);
106 if (TREE_PERMANENT (parm
) == 0)
108 parm
= copy_node (parm
);
109 TREE_PERMANENT (parm
) = 1;
111 TREE_TYPE (tinfo
) = TREE_TYPE (parm
);
112 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
113 DECL_INITIAL (decl
) = tinfo
;
114 DECL_INITIAL (parm
) = tinfo
;
118 tree t
= make_node (TEMPLATE_TYPE_PARM
);
119 decl
= build_lang_decl (TYPE_DECL
, TREE_PURPOSE (parm
), t
);
120 TYPE_NAME (t
) = decl
;
121 TREE_VALUE (parm
) = t
;
124 return chainon (list
, parm
);
127 /* The end of a template parameter list has been reached. Process the
128 tree list into a parameter vector, converting each parameter into a more
129 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
133 end_template_parm_list (parms
)
139 for (parm
= parms
; parm
; parm
= TREE_CHAIN (parm
))
141 saved_parmlist
= make_tree_vec (nparms
);
143 for (parm
= parms
, nparms
= 0; parm
; parm
= TREE_CHAIN (parm
), nparms
++)
146 if (TREE_CODE (p
) == TREE_LIST
)
148 tree t
= TREE_VALUE (p
);
149 TREE_VALUE (p
) = NULL_TREE
;
150 p
= TREE_PURPOSE (p
);
151 my_friendly_assert (TREE_CODE (p
) == IDENTIFIER_NODE
, 261);
152 TEMPLATE_TYPE_SET_INFO (t
, saved_parmlist
, nparms
);
156 tree tinfo
= DECL_INITIAL (p
);
157 DECL_INITIAL (p
) = NULL_TREE
;
158 TEMPLATE_CONST_SET_INFO (tinfo
, saved_parmlist
, nparms
);
160 TREE_VEC_ELT (saved_parmlist
, nparms
) = p
;
162 set_current_level_tags_transparency (1);
163 processing_template_decl
++;
164 return saved_parmlist
;
167 /* end_template_decl is called after a template declaration is seen.
168 D1 is template header; D2 is class_head_sans_basetype or a
169 TEMPLATE_DECL with its DECL_RESULT field set. */
171 end_template_decl (d1
, d2
, is_class
, defn
)
172 tree d1
, d2
, is_class
;
176 struct template_info
*tmpl
;
178 tmpl
= (struct template_info
*) obstack_alloc (&permanent_obstack
,
179 sizeof (struct template_info
));
182 tmpl
->aggr
= is_class
;
184 /* cloned from reinit_parse_for_template */
185 tmpl
->filename
= input_filename
;
186 tmpl
->lineno
= lineno
;
187 tmpl
->parm_vec
= d1
; /* [eichin:19911015.2306EST] */
189 if (d2
== NULL_TREE
|| d2
== error_mark_node
)
197 decl
= build_lang_decl (TEMPLATE_DECL
, d2
, NULL_TREE
);
201 if (TREE_CODE (d2
) == TEMPLATE_DECL
)
205 /* Class destructor templates and operator templates are
206 slipping past as non-template nodes. Process them here, since
207 I haven't figured out where to catch them earlier. I could
208 go do that, but it's a choice between getting that done and
209 staying only N months behind schedule. Sorry.... */
211 my_friendly_assert (TREE_CODE (d2
) == CALL_EXPR
, 263);
212 code
= TREE_CODE (TREE_OPERAND (d2
, 0));
213 my_friendly_assert (code
== BIT_NOT_EXPR
214 || code
== OP_IDENTIFIER
215 || code
== SCOPE_REF
, 264);
216 d2
= grokdeclarator (d2
, NULL_TREE
, MEMFUNCDEF
, 0, NULL_TREE
);
217 decl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (d2
),
219 DECL_TEMPLATE_RESULT (decl
) = d2
;
220 DECL_CONTEXT (decl
) = DECL_CONTEXT (d2
);
221 DECL_CLASS_CONTEXT (decl
) = DECL_CLASS_CONTEXT (d2
);
222 DECL_NAME (decl
) = DECL_NAME (d2
);
223 TREE_TYPE (decl
) = TREE_TYPE (d2
);
224 if (interface_unknown
&& flag_external_templates
&& ! DECL_IN_SYSTEM_HEADER (decl
))
225 warn_if_unknown_interface ();
226 TREE_PUBLIC (decl
) = TREE_PUBLIC (d2
) = flag_external_templates
&& !interface_unknown
;
227 DECL_EXTERNAL (decl
) = (DECL_EXTERNAL (d2
)
228 && !(DECL_CLASS_CONTEXT (d2
)
229 && !DECL_THIS_EXTERN (d2
)));
232 /* All routines creating TEMPLATE_DECL nodes should now be using
233 build_lang_decl, which will have set this up already. */
234 my_friendly_assert (DECL_LANG_SPECIFIC (decl
) != 0, 265);
236 /* @@ Somewhere, permanent allocation isn't being used. */
237 if (! DECL_TEMPLATE_IS_CLASS (decl
)
238 && TREE_CODE (DECL_TEMPLATE_RESULT (decl
)) == FUNCTION_DECL
)
240 tree result
= DECL_TEMPLATE_RESULT (decl
);
241 /* Will do nothing if allocation was already permanent. */
242 DECL_ARGUMENTS (result
) = copy_to_permanent (DECL_ARGUMENTS (result
));
245 /* If this is for a method, there's an extra binding level here. */
246 if (! DECL_TEMPLATE_IS_CLASS (decl
)
247 && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl
)) != NULL_TREE
)
249 /* @@ Find out where this should be getting set! */
250 tree r
= DECL_TEMPLATE_RESULT (decl
);
251 if (DECL_CLASS_CONTEXT (r
) == NULL_TREE
)
252 DECL_CLASS_CONTEXT (r
) = DECL_CONTEXT (r
);
255 DECL_TEMPLATE_INFO (decl
) = tmpl
;
256 DECL_TEMPLATE_PARMS (decl
) = d1
;
258 /* So that duplicate_decls can do the right thing. */
260 DECL_INITIAL (decl
) = error_mark_node
;
262 /* If context of decl is non-null (i.e., method template), add it
263 to the appropriate class template, and pop the binding levels. */
264 if (! DECL_TEMPLATE_IS_CLASS (decl
)
265 && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl
)) != NULL_TREE
)
267 tree ctx
= DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl
));
269 my_friendly_assert (TREE_CODE (ctx
) == UNINSTANTIATED_P_TYPE
, 266);
270 tmpl
= UPT_TEMPLATE (ctx
);
271 DECL_TEMPLATE_MEMBERS (tmpl
) =
272 perm_tree_cons (DECL_NAME (decl
), decl
,
273 DECL_TEMPLATE_MEMBERS (tmpl
));
277 /* Otherwise, go back to top level first, and push the template decl
286 #if 0 /* It happens sometimes, with syntactic or semantic errors.
289 template <class A, int X, int Y> class Foo { ... };
290 template <class A, int X, int y> Foo<X,Y>::method (Foo& x) { ... }
291 Note the missing "A" in the class containing "method". */
292 my_friendly_assert (global_bindings_p (), 267);
294 while (! global_bindings_p ())
298 processing_template_decl
--;
299 (void) get_pending_sizes ();
302 /* If TYPE contains a template parm type, then substitute that type
303 with its actual type that is found in TVEC. */
305 grok_template_type (tvec
, type
)
309 switch (TREE_CODE (*type
))
311 case TEMPLATE_TYPE_PARM
:
312 if (*type
!= TYPE_MAIN_VARIANT (*type
))
314 /* we are here for cases like const T* etc. */
315 grok_template_type (tvec
, &TYPE_MAIN_VARIANT (*type
));
316 *type
= build_type_variant (TYPE_MAIN_VARIANT (*type
),
317 TYPE_READONLY (*type
),
318 TYPE_VOLATILE (*type
));
321 *type
= TREE_VEC_ELT (tvec
, TEMPLATE_TYPE_IDX (*type
));
325 grok_template_type (tvec
, &TREE_TYPE (*type
));
331 /* take care of function's return type first */
332 grok_template_type (tvec
, &TREE_TYPE (*type
));
334 /* take care of function's arguments */
335 for (p
= TYPE_ARG_TYPES (*type
); p
; p
= TREE_CHAIN (p
))
336 grok_template_type (tvec
, &TREE_VALUE (p
));
345 /* Convert all template arguments to their appropriate types, and return
346 a vector containing the resulting values. If any error occurs, return
349 coerce_template_parms (parms
, arglist
, in_decl
)
353 int nparms
, i
, lost
= 0;
356 if (TREE_CODE (arglist
) == TREE_VEC
)
357 nparms
= TREE_VEC_LENGTH (arglist
);
359 nparms
= list_length (arglist
);
360 if (nparms
!= TREE_VEC_LENGTH (parms
))
362 error ("incorrect number of parameters (%d, should be %d)",
363 nparms
, TREE_VEC_LENGTH (parms
));
365 cp_error_at ("in template expansion for decl `%D'", in_decl
);
366 return error_mark_node
;
369 if (TREE_CODE (arglist
) == TREE_VEC
)
370 vec
= copy_node (arglist
);
373 vec
= make_tree_vec (nparms
);
374 for (i
= 0; i
< nparms
; i
++)
377 arglist
= TREE_CHAIN (arglist
);
378 if (arg
== error_mark_node
)
381 arg
= TREE_VALUE (arg
);
382 TREE_VEC_ELT (vec
, i
) = arg
;
385 for (i
= 0; i
< nparms
; i
++)
387 tree arg
= TREE_VEC_ELT (vec
, i
);
388 tree parm
= TREE_VEC_ELT (parms
, i
);
390 int is_type
, requires_type
;
392 is_type
= TREE_CODE_CLASS (TREE_CODE (arg
)) == 't';
393 requires_type
= TREE_CODE (parm
) == IDENTIFIER_NODE
;
394 if (is_type
!= requires_type
)
397 cp_error_at ("type/value mismatch in template parameter list for `%D'", in_decl
);
399 TREE_VEC_ELT (vec
, i
) = error_mark_node
;
403 val
= groktypename (arg
);
404 else if (TREE_CODE (arg
) == STRING_CST
)
406 cp_error ("string literal %E is not a valid template argument", arg
);
407 error ("because it is the address of an object with static linkage");
408 val
= error_mark_node
;
412 grok_template_type (vec
, &TREE_TYPE (parm
));
413 val
= digest_init (TREE_TYPE (parm
), arg
, (tree
*) 0);
415 if (val
== error_mark_node
)
418 /* 14.2: Other template-arguments must be constant-expressions,
419 addresses of objects or functions with external linkage, or of
420 static class members. */
421 else if (!TREE_CONSTANT (val
))
423 cp_error ("non-const `%E' cannot be used as template argument",
425 val
= error_mark_node
;
427 else if (TREE_CODE (val
) == ADDR_EXPR
)
429 tree a
= TREE_OPERAND (val
, 0);
430 if ((TREE_CODE (a
) == VAR_DECL
431 || TREE_CODE (a
) == FUNCTION_DECL
)
434 cp_error ("address of non-extern `%E' cannot be used as template argument", a
);
435 val
= error_mark_node
;
440 if (val
== error_mark_node
)
443 TREE_VEC_ELT (vec
, i
) = val
;
446 return error_mark_node
;
450 /* Given class template name and parameter list, produce a user-friendly name
451 for the instantiation. */
453 mangle_class_name_for_template (name
, parms
, arglist
)
457 static struct obstack scratch_obstack
;
458 static char *scratch_firstobj
;
461 if (!scratch_firstobj
)
463 gcc_obstack_init (&scratch_obstack
);
464 scratch_firstobj
= obstack_alloc (&scratch_obstack
, 1);
467 obstack_free (&scratch_obstack
, scratch_firstobj
);
470 #define buflen sizeof(buf)
471 #define check if (bufp >= buf+buflen-1) goto too_long
472 #define ccat(c) *bufp++=(c); check
473 #define advance bufp+=strlen(bufp); check
474 #define cat(s) strncpy(bufp, s, buf+buflen-bufp-1); advance
477 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
479 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
484 nparms
= TREE_VEC_LENGTH (parms
);
485 my_friendly_assert (nparms
== TREE_VEC_LENGTH (arglist
), 268);
486 for (i
= 0; i
< nparms
; i
++)
488 tree parm
= TREE_VEC_ELT (parms
, i
), arg
= TREE_VEC_ELT (arglist
, i
);
493 if (TREE_CODE (parm
) == IDENTIFIER_NODE
)
495 cat (type_as_string (arg
, 0));
499 my_friendly_assert (TREE_CODE (parm
) == PARM_DECL
, 269);
501 if (TREE_CODE (arg
) == TREE_LIST
)
503 /* New list cell was built because old chain link was in
505 my_friendly_assert (TREE_PURPOSE (arg
) == NULL_TREE
, 270);
506 arg
= TREE_VALUE (arg
);
508 /* No need to check arglist against parmlist here; we did that
509 in coerce_template_parms, called from lookup_template_class. */
510 cat (expr_as_string (arg
, 0));
513 char *bufp
= obstack_next_free (&scratch_obstack
);
515 while (bufp
[offset
- 1] == ' ')
517 obstack_blank_fast (&scratch_obstack
, offset
);
519 /* B<C<char> >, not B<C<char>> */
520 if (bufp
[offset
- 1] == '>')
525 return (char *) obstack_base (&scratch_obstack
);
530 fatal ("out of (preallocated) string space creating template instantiation name");
535 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
536 parameters, find the desired type.
538 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
539 Since ARGLIST is build on the decl_obstack, we must copy it here
540 to keep it from being reclaimed when the decl storage is reclaimed.
542 IN_DECL, if non-NULL, is the template declaration we are trying to
545 lookup_template_class (d1
, arglist
, in_decl
)
549 tree
template, parmlist
;
553 my_friendly_assert (TREE_CODE (d1
) == IDENTIFIER_NODE
, 272);
554 template = IDENTIFIER_GLOBAL_VALUE (d1
); /* XXX */
556 template = IDENTIFIER_CLASS_VALUE (d1
);
557 /* With something like `template <class T> class X class X { ... };'
558 we could end up with D1 having nothing but an IDENTIFIER_LOCAL_VALUE.
559 We don't want to do that, but we have to deal with the situation, so
560 let's give them some syntax errors to chew on instead of a crash. */
562 return error_mark_node
;
563 if (TREE_CODE (template) != TEMPLATE_DECL
)
565 cp_error ("non-template type `%T' used as a template", d1
);
567 cp_error_at ("for template declaration `%D'", in_decl
);
568 return error_mark_node
;
570 parmlist
= DECL_TEMPLATE_PARMS (template);
572 arglist
= coerce_template_parms (parmlist
, arglist
, in_decl
);
573 if (arglist
== error_mark_node
)
574 return error_mark_node
;
575 if (uses_template_parms (arglist
))
577 tree t
= make_lang_type (UNINSTANTIATED_P_TYPE
);
579 id
= make_anon_name ();
580 d
= build_lang_decl (TYPE_DECL
, id
, t
);
582 TYPE_VALUES (t
) = build_tree_list (template, arglist
);
583 pushdecl_top_level (d
);
587 mangled_name
= mangle_class_name_for_template (IDENTIFIER_POINTER (d1
),
589 id
= get_identifier (mangled_name
);
591 if (!IDENTIFIER_TEMPLATE (id
))
593 arglist
= copy_to_permanent (arglist
);
594 IDENTIFIER_TEMPLATE (id
) = perm_tree_cons (template, arglist
, NULL_TREE
);
600 push_template_decls (parmlist
, arglist
, class_level
)
601 tree parmlist
, arglist
;
606 /* Don't want to push values into global context. */
610 declare_pseudo_global_level ();
613 nparms
= TREE_VEC_LENGTH (parmlist
);
615 for (i
= 0; i
< nparms
; i
++)
617 int requires_type
, is_type
;
618 tree parm
= TREE_VEC_ELT (parmlist
, i
);
619 tree arg
= TREE_VEC_ELT (arglist
, i
);
622 requires_type
= TREE_CODE (parm
) == IDENTIFIER_NODE
;
623 is_type
= TREE_CODE_CLASS (TREE_CODE (arg
)) == 't';
626 /* add typename to namespace */
629 error ("template use error: type provided where value needed");
633 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 't', 273);
634 decl
= build_lang_decl (TYPE_DECL
, parm
, decl
);
638 /* add const decl to namespace */
642 error ("template use error: value provided where type needed");
645 val
= digest_init (TREE_TYPE (parm
), arg
, (tree
*) 0);
646 if (val
!= error_mark_node
)
648 decl
= build_decl (VAR_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
649 DECL_INITIAL (decl
) = val
;
650 TREE_READONLY (decl
) = 1;
655 layout_decl (decl
, 0);
657 pushdecl_class_level (decl
);
665 pop_template_decls (parmlist
, arglist
, class_level
)
666 tree parmlist
, arglist
;
673 /* Should be defined in parse.h. */
677 uses_template_parms (t
)
682 switch (TREE_CODE (t
))
686 /* We assume that the object must be instantiated in order to build
687 the COMPONENT_REF, so we test only whether the type of the
688 COMPONENT_REF uses template parms. */
689 return uses_template_parms (TREE_TYPE (t
));
691 case IDENTIFIER_NODE
:
692 if (!IDENTIFIER_TEMPLATE (t
))
694 return uses_template_parms (TREE_VALUE (IDENTIFIER_TEMPLATE (t
)));
696 /* aggregates of tree nodes */
699 int i
= TREE_VEC_LENGTH (t
);
701 if (uses_template_parms (TREE_VEC_ELT (t
, i
)))
706 if (uses_template_parms (TREE_PURPOSE (t
))
707 || uses_template_parms (TREE_VALUE (t
)))
709 return uses_template_parms (TREE_CHAIN (t
));
711 /* constructed type nodes */
714 return uses_template_parms (TREE_TYPE (t
));
719 if (!TYPE_IDENTIFIER (t
))
721 return uses_template_parms (TYPE_IDENTIFIER (t
));
723 if (uses_template_parms (TYPE_ARG_TYPES (t
)))
725 return uses_template_parms (TREE_TYPE (t
));
727 if (uses_template_parms (TYPE_DOMAIN (t
)))
729 return uses_template_parms (TREE_TYPE (t
));
731 if (uses_template_parms (TYPE_OFFSET_BASETYPE (t
)))
733 return uses_template_parms (TREE_TYPE (t
));
735 if (uses_template_parms (TYPE_OFFSET_BASETYPE (t
)))
737 if (uses_template_parms (TYPE_ARG_TYPES (t
)))
739 return uses_template_parms (TREE_TYPE (t
));
743 return uses_template_parms (DECL_NAME (t
));
745 if (uses_template_parms (TREE_TYPE (t
)))
750 /* ??? What about FIELD_DECLs? */
751 /* The type of a decl can't use template parms if the name of the
752 variable doesn't, because it's impossible to resolve them. So
753 ignore the type field for now. */
754 if (DECL_CONTEXT (t
) && uses_template_parms (DECL_CONTEXT (t
)))
756 if (uses_template_parms (TREE_TYPE (t
)))
758 error ("template parms used where they can't be resolved");
763 return uses_template_parms (TREE_TYPE (t
));
765 return uses_template_parms (TREE_OPERAND (t
, 0));
767 /* template parm nodes */
768 case TEMPLATE_TYPE_PARM
:
769 case TEMPLATE_CONST_PARM
:
772 /* simple type nodes */
774 if (uses_template_parms (TYPE_MIN_VALUE (t
)))
776 return uses_template_parms (TYPE_MAX_VALUE (t
));
790 /* Non-error_mark_node ERROR_MARKs are bad things. */
791 my_friendly_assert (t
== error_mark_node
, 274);
795 case UNINSTANTIATED_P_TYPE
:
799 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
807 for (i
= tree_code_length
[(int) TREE_CODE (t
)]; --i
>= 0;)
808 if (uses_template_parms (TREE_OPERAND (t
, i
)))
815 sorry ("testing %s for template parms",
816 tree_code_name
[(int) TREE_CODE (t
)]);
817 my_friendly_abort (82);
824 instantiate_member_templates (classname
)
829 tree members
= DECL_TEMPLATE_MEMBERS (TREE_PURPOSE (IDENTIFIER_TEMPLATE (id
)));
831 for (t
= members
; t
; t
= TREE_CHAIN (t
))
833 tree parmvec
, type
, classparms
, tdecl
, t2
;
834 int nparms
, xxx
= 0, i
;
836 my_friendly_assert (TREE_VALUE (t
) != NULL_TREE
, 275);
837 my_friendly_assert (TREE_CODE (TREE_VALUE (t
)) == TEMPLATE_DECL
, 276);
838 /* @@ Should verify that class parm list is a list of
839 distinct template parameters, and covers all the template
841 tdecl
= TREE_VALUE (t
);
842 type
= DECL_CONTEXT (DECL_TEMPLATE_RESULT (tdecl
));
843 classparms
= UPT_PARMS (type
);
844 nparms
= TREE_VEC_LENGTH (classparms
);
845 parmvec
= make_tree_vec (nparms
);
846 for (i
= 0; i
< nparms
; i
++)
847 TREE_VEC_ELT (parmvec
, i
) = NULL_TREE
;
848 switch (unify (DECL_TEMPLATE_PARMS (tdecl
),
849 &TREE_VEC_ELT (parmvec
, 0), nparms
,
850 type
, IDENTIFIER_TYPE_VALUE (classname
),
854 /* Success -- well, no inconsistency, at least. */
855 for (i
= 0; i
< nparms
; i
++)
856 if (TREE_VEC_ELT (parmvec
, i
) == NULL_TREE
)
858 t2
= instantiate_template (tdecl
,
859 &TREE_VEC_ELT (parmvec
, 0));
860 type
= IDENTIFIER_TYPE_VALUE (id
);
861 my_friendly_assert (type
!= 0, 277);
862 if (CLASSTYPE_INTERFACE_UNKNOWN (type
))
864 DECL_EXTERNAL (t2
) = 0;
865 TREE_PUBLIC (t2
) = 0;
869 DECL_EXTERNAL (t2
) = CLASSTYPE_INTERFACE_ONLY (type
);
870 TREE_PUBLIC (t2
) = 1;
876 cp_error ("type unification error instantiating %T::%D",
878 cp_error_at ("for template declaration `%D'", tdecl
);
880 continue /* loop of members */;
883 my_friendly_abort (83);
888 struct tinst_level
*current_tinst_level
= 0;
889 struct tinst_level
*free_tinst_level
= 0;
892 push_tinst_level (name
)
895 struct tinst_level
*new;
896 tree global
= IDENTIFIER_GLOBAL_VALUE (name
);
898 if (free_tinst_level
)
900 new = free_tinst_level
;
901 free_tinst_level
= new->next
;
904 new = (struct tinst_level
*) xmalloc (sizeof (struct tinst_level
));
906 new->classname
= name
;
909 new->line
= DECL_SOURCE_LINE (global
);
910 new->file
= DECL_SOURCE_FILE (global
);
915 new->file
= input_filename
;
917 new->next
= current_tinst_level
;
918 current_tinst_level
= new;
924 struct tinst_level
*old
= current_tinst_level
;
926 current_tinst_level
= old
->next
;
927 old
->next
= free_tinst_level
;
928 free_tinst_level
= old
;
934 struct tinst_level
*p
= current_tinst_level
;
937 for (; p
->next
; p
= p
->next
)
943 instantiate_class_template (classname
, setup_parse
)
947 struct template_info
*template_info
;
950 if (classname
== error_mark_node
)
951 return error_mark_node
;
953 my_friendly_assert (TREE_CODE (classname
) == IDENTIFIER_NODE
, 278);
954 template = IDENTIFIER_TEMPLATE (classname
);
956 if (IDENTIFIER_HAS_TYPE_VALUE (classname
))
958 tree type
= IDENTIFIER_TYPE_VALUE (classname
);
959 if (TREE_CODE (type
) == UNINSTANTIATED_P_TYPE
)
961 if (TYPE_BEING_DEFINED (type
)
963 || CLASSTYPE_USE_TEMPLATE (type
) != 0)
967 /* If IDENTIFIER_LOCAL_VALUE is already set on this template classname
968 (it's something like `foo<int>'), that means we're already working on
969 the instantiation for it. Normally, a classname comes in with nothing
970 but its IDENTIFIER_TEMPLATE slot set. If we were to try to instantiate
971 this again, we'd get a redeclaration error. Since we're already working
972 on it, we'll pass back this classname's TYPE_DECL (it's the value of
973 the classname's IDENTIFIER_LOCAL_VALUE). Only do this if we're setting
974 things up for the parser, though---if we're just trying to instantiate
975 it (e.g., via tsubst) we can trip up cuz it may not have an
976 IDENTIFIER_TYPE_VALUE when it will need one. */
977 if (setup_parse
&& IDENTIFIER_LOCAL_VALUE (classname
))
978 return IDENTIFIER_LOCAL_VALUE (classname
);
980 if (uses_template_parms (classname
))
982 if (!TREE_TYPE (classname
))
984 tree t
= make_lang_type (RECORD_TYPE
);
985 tree d
= build_lang_decl (TYPE_DECL
, classname
, t
);
986 DECL_NAME (d
) = classname
;
993 t1
= TREE_PURPOSE (template);
994 my_friendly_assert (TREE_CODE (t1
) == TEMPLATE_DECL
, 279);
996 /* If a template is declared but not defined, accept it; don't crash.
997 Later uses requiring the definition will be flagged as errors by
998 other code. Thanks to niklas@appli.se for this bug fix. */
999 if (DECL_TEMPLATE_INFO (t1
)->text
== 0)
1002 push_to_top_level ();
1003 template_info
= DECL_TEMPLATE_INFO (t1
);
1006 push_tinst_level (classname
);
1007 push_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (template)),
1008 TREE_VALUE (template), 0);
1009 set_current_level_tags_transparency (1);
1010 feed_input (template_info
->text
, template_info
->length
, (struct obstack
*)0);
1011 lineno
= template_info
->lineno
;
1012 input_filename
= template_info
->filename
;
1013 /* Get interface/implementation back in sync. */
1014 extract_interface_info ();
1015 overload_template_name (classname
, 0);
1016 /* Kludge so that we don't get screwed by our own base classes. */
1017 TYPE_BEING_DEFINED (TREE_TYPE (classname
)) = 1;
1018 yychar
= PRE_PARSED_CLASS_DECL
;
1019 yylval
.ttype
= classname
;
1020 processing_template_defn
++;
1021 if (!flag_external_templates
)
1022 interface_unknown
++;
1026 tree t
, decl
, id
, tmpl
;
1029 tmpl
= TREE_PURPOSE (IDENTIFIER_TEMPLATE (id
));
1030 t
= xref_tag (DECL_TEMPLATE_INFO (tmpl
)->aggr
, id
, NULL_TREE
, 0);
1031 my_friendly_assert (TREE_CODE (t
) == RECORD_TYPE
1032 || TREE_CODE (t
) == UNION_TYPE
, 280);
1034 /* Now, put a copy of the decl in global scope, to avoid
1035 * recursive expansion. */
1036 decl
= IDENTIFIER_LOCAL_VALUE (id
);
1038 decl
= IDENTIFIER_CLASS_VALUE (id
);
1041 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 281);
1042 /* We'd better make sure we're on the permanent obstack or else
1043 * we'll get a "friendly" abort 124 in pushdecl. Perhaps a
1044 * copy_to_permanent would be sufficient here, but then a
1045 * sharing problem might occur. I don't know -- niklas@appli.se */
1046 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1047 pushdecl_top_level (copy_node (decl
));
1050 pop_from_top_level ();
1060 if (t1
== NULL_TREE
)
1061 return t2
== NULL_TREE
;
1062 if (t2
== NULL_TREE
)
1064 /* Don't care if one declares its arg const and the other doesn't -- the
1065 main variant of the arg type is all that matters. */
1066 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1
))
1067 != TYPE_MAIN_VARIANT (TREE_VALUE (t2
)))
1069 return list_eq (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1073 lookup_nested_type_by_name (ctype
, name
)
1078 t
= TREE_VALUE(CLASSTYPE_TAGS(ctype
));
1081 if (strcmp(IDENTIFIER_POINTER(name
), IDENTIFIER_POINTER(TYPE_IDENTIFIER(t
)))
1091 search_nested_type_in_tmpl (tmpl
, type
)
1096 if (tmpl
== NULL
|| TYPE_CONTEXT(type
) == NULL
)
1098 t
= search_nested_type_in_tmpl (tmpl
, TYPE_CONTEXT(type
));
1099 if (t
== NULL
) return t
;
1100 t
= lookup_nested_type_by_name(t
, DECL_NAME(TYPE_NAME(type
)));
1105 tsubst (t
, args
, nargs
, in_decl
)
1112 if (t
== NULL_TREE
|| t
== error_mark_node
)
1115 type
= TREE_TYPE (t
);
1117 /* Minor optimization.
1118 ?? Are these really the most frequent cases? Is the savings
1120 && type
!= integer_type_node
1121 && type
!= void_type_node
1122 && type
!= char_type_node
)
1123 type
= build_type_variant (tsubst (type
, args
, nargs
, in_decl
),
1124 TYPE_READONLY (type
),
1125 TYPE_VOLATILE (type
));
1126 switch (TREE_CODE (t
))
1129 if (TYPE_PTRMEMFUNC_P (t
))
1130 return build_ptrmemfunc_type
1131 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, nargs
, in_decl
));
1133 /* else fall through */
1136 case IDENTIFIER_NODE
:
1148 if (t
== integer_type_node
)
1151 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
1152 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
1154 return build_index_2_type
1155 (tsubst (TYPE_MIN_VALUE (t
), args
, nargs
, in_decl
),
1156 tsubst (TYPE_MAX_VALUE (t
), args
, nargs
, in_decl
));
1158 case TEMPLATE_TYPE_PARM
:
1159 return build_type_variant (args
[TEMPLATE_TYPE_IDX (t
)],
1163 case TEMPLATE_CONST_PARM
:
1164 return args
[TEMPLATE_CONST_IDX (t
)];
1169 tree fnargs
, result
;
1171 if (type
== TREE_TYPE (t
)
1172 && (DECL_CONTEXT (t
) == NULL_TREE
1173 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) != 't'))
1175 fnargs
= tsubst (DECL_ARGUMENTS (t
), args
, nargs
, t
);
1176 result
= tsubst (DECL_RESULT (t
), args
, nargs
, t
);
1177 if (DECL_CONTEXT (t
) != NULL_TREE
1178 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) == 't')
1180 /* Look it up in that class, and return the decl node there,
1181 instead of creating a new one. */
1182 tree ctx
, methods
, name
, method
;
1186 name
= DECL_NAME (t
);
1187 ctx
= tsubst (DECL_CONTEXT (t
), args
, nargs
, t
);
1188 methods
= CLASSTYPE_METHOD_VEC (ctx
);
1189 if (methods
== NULL_TREE
)
1190 /* No methods at all -- no way this one can match. */
1192 n_methods
= TREE_VEC_LENGTH (methods
);
1196 if (!strncmp (OPERATOR_TYPENAME_FORMAT
,
1197 IDENTIFIER_POINTER (name
),
1198 sizeof (OPERATOR_TYPENAME_FORMAT
) - 1))
1200 /* Type-conversion operator. Reconstruct the name, in
1201 case it's the name of one of the template's parameters. */
1202 name
= build_typename_overload (TREE_TYPE (type
));
1205 if (DECL_CONTEXT (t
) != NULL_TREE
1206 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) == 't'
1207 && constructor_name (DECL_CONTEXT (t
)) == DECL_NAME (t
))
1208 name
= constructor_name (ctx
);
1210 fprintf (stderr
, "\nfor function %s in class %s:\n",
1211 IDENTIFIER_POINTER (name
),
1212 IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx
)));
1214 for (i
= 0; i
< n_methods
; i
++)
1218 method
= TREE_VEC_ELT (methods
, i
);
1219 if (method
== NULL_TREE
|| DECL_NAME (method
) != name
)
1224 for (; method
; method
= DECL_CHAIN (method
))
1226 my_friendly_assert (TREE_CODE (method
) == FUNCTION_DECL
,
1228 if (! comptypes (type
, TREE_TYPE (method
), 1))
1230 tree mtype
= TREE_TYPE (method
);
1233 /* Keep looking for a method that matches
1234 perfectly. This takes care of the problem
1235 where destructors (which have implicit int args)
1236 look like constructors which have an int arg. */
1240 t1
= TYPE_ARG_TYPES (mtype
);
1241 t2
= TYPE_ARG_TYPES (type
);
1242 if (TREE_CODE (mtype
) == FUNCTION_TYPE
)
1243 t2
= TREE_CHAIN (t2
);
1245 if (list_eq (t1
, t2
))
1247 if (TREE_CODE (mtype
) == FUNCTION_TYPE
)
1250 newtype
= build_function_type (TREE_TYPE (type
),
1251 TYPE_ARG_TYPES (type
));
1252 newtype
= build_type_variant (newtype
,
1253 TYPE_READONLY (type
),
1254 TYPE_VOLATILE (type
));
1256 if (TREE_TYPE (type
) != TREE_TYPE (mtype
))
1257 goto maybe_bad_return_type
;
1259 else if (TYPE_METHOD_BASETYPE (mtype
)
1260 == TYPE_METHOD_BASETYPE (type
))
1262 /* Types didn't match, but arg types and
1263 `this' do match, so the return type is
1264 all that should be messing it up. */
1265 maybe_bad_return_type
:
1266 if (TREE_TYPE (type
) != TREE_TYPE (mtype
))
1267 error ("inconsistent return types for method `%s' in class `%s'",
1268 IDENTIFIER_POINTER (name
),
1269 IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx
)));
1278 fprintf (stderr
, "\tfound %s\n\n",
1279 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method
)));
1282 if (DECL_ARGUMENTS (method
)
1283 && ! TREE_PERMANENT (DECL_ARGUMENTS (method
)))
1284 /* @@ Is this early enough? Might we want to do
1285 this instead while processing the expansion? */
1286 DECL_ARGUMENTS (method
)
1287 = tsubst (DECL_ARGUMENTS (t
), args
, nargs
, t
);
1291 if (r
== NULL_TREE
&& pass
== 0)
1294 method
= TREE_VEC_ELT (methods
, i
);
1303 ? "template for method `%D' doesn't match any in class `%T'"
1304 : "method `%D' not found in class `%T'", name
, ctx
);
1306 cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl
);
1307 return error_mark_node
;
1317 decls
= lookup_name (r
, 0);
1318 if (decls
== NULL_TREE
)
1320 else if (TREE_CODE (decls
) == TREE_LIST
)
1321 for (decls
= TREE_VALUE (decls
); decls
;
1322 decls
= DECL_CHAIN (decls
))
1324 if (TREE_CODE (decls
) == FUNCTION_DECL
1325 && TREE_TYPE (decls
) == type
)
1336 if (TREE_CODE (val
) == FUNCTION_DECL
1337 && TREE_TYPE (val
) == type
)
1346 r
= build_decl_overload (r
, TYPE_VALUES (type
),
1347 DECL_CONTEXT (t
) != NULL_TREE
);
1348 r
= build_lang_decl (FUNCTION_DECL
, r
, type
);
1352 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
1353 DECL_EXTERNAL (r
) = DECL_EXTERNAL (t
);
1354 TREE_STATIC (r
) = TREE_STATIC (t
);
1355 DECL_INLINE (r
) = DECL_INLINE (t
);
1357 #if 0 /* Maybe later. -jason */
1358 struct tinst_level
*til
= tinst_for_decl();
1360 /* should always be true under new approach */
1363 DECL_SOURCE_FILE (r
) = til
->file
;
1364 DECL_SOURCE_LINE (r
) = til
->line
;
1369 DECL_SOURCE_FILE (r
) = DECL_SOURCE_FILE (t
);
1370 DECL_SOURCE_LINE (r
) = DECL_SOURCE_LINE (t
);
1373 DECL_CLASS_CONTEXT (r
) = tsubst (DECL_CLASS_CONTEXT (t
), args
, nargs
, t
);
1374 make_decl_rtl (r
, NULL_PTR
, 1);
1375 DECL_ARGUMENTS (r
) = fnargs
;
1376 DECL_RESULT (r
) = result
;
1377 if (DECL_CONTEXT (t
) == NULL_TREE
1378 || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t
))) != 't')
1379 push_overloaded_decl_top_level (r
, 0);
1386 r
= build_decl (PARM_DECL
, DECL_NAME (t
), type
);
1387 DECL_INITIAL (r
) = TREE_TYPE (r
);
1389 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
, nargs
, TREE_CHAIN (t
));
1395 tree purpose
, value
, chain
, result
;
1396 int via_public
, via_virtual
, via_protected
;
1398 if (t
== void_list_node
)
1401 via_public
= TREE_VIA_PUBLIC (t
);
1402 via_protected
= TREE_VIA_PROTECTED (t
);
1403 via_virtual
= TREE_VIA_VIRTUAL (t
);
1405 purpose
= TREE_PURPOSE (t
);
1407 purpose
= tsubst (purpose
, args
, nargs
, in_decl
);
1408 value
= TREE_VALUE (t
);
1410 value
= tsubst (value
, args
, nargs
, in_decl
);
1411 chain
= TREE_CHAIN (t
);
1412 if (chain
&& chain
!= void_type_node
)
1413 chain
= tsubst (chain
, args
, nargs
, in_decl
);
1414 if (purpose
== TREE_PURPOSE (t
)
1415 && value
== TREE_VALUE (t
)
1416 && chain
== TREE_CHAIN (t
))
1418 result
= hash_tree_cons (via_public
, via_virtual
, via_protected
,
1419 purpose
, value
, chain
);
1420 TREE_PARMLIST (result
) = TREE_PARMLIST (t
);
1425 int len
= TREE_VEC_LENGTH (t
), need_new
= 0, i
;
1426 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
1427 bzero (elts
, len
* sizeof (tree
));
1429 for (i
= 0; i
< len
; i
++)
1431 elts
[i
] = tsubst (TREE_VEC_ELT (t
, i
), args
, nargs
, in_decl
);
1432 if (elts
[i
] != TREE_VEC_ELT (t
, i
))
1439 t
= make_tree_vec (len
);
1440 for (i
= 0; i
< len
; i
++)
1441 TREE_VEC_ELT (t
, i
) = elts
[i
];
1445 case REFERENCE_TYPE
:
1448 enum tree_code code
;
1449 if (type
== TREE_TYPE (t
))
1452 code
= TREE_CODE (t
);
1453 if (code
== POINTER_TYPE
)
1454 r
= build_pointer_type (type
);
1456 r
= build_reference_type (type
);
1457 r
= build_type_variant (r
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1458 /* Will this ever be needed for TYPE_..._TO values? */
1465 tree values
= TYPE_VALUES (t
); /* same as TYPE_ARG_TYPES */
1466 tree context
= TYPE_CONTEXT (t
);
1469 /* Don't bother recursing if we know it won't change anything. */
1470 if (values
!= void_list_node
)
1471 values
= tsubst (values
, args
, nargs
, in_decl
);
1473 context
= tsubst (context
, args
, nargs
, in_decl
);
1474 /* Could also optimize cases where return value and
1475 values have common elements (e.g., T min(const &T, const T&). */
1477 /* If the above parameters haven't changed, just return the type. */
1478 if (type
== TREE_TYPE (t
)
1479 && values
== TYPE_VALUES (t
)
1480 && context
== TYPE_CONTEXT (t
))
1483 /* Construct a new type node and return it. */
1484 if (TREE_CODE (t
) == FUNCTION_TYPE
1485 && context
== NULL_TREE
)
1487 new_value
= build_function_type (type
, values
);
1489 else if (context
== NULL_TREE
)
1491 tree base
= tsubst (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t
))),
1492 args
, nargs
, in_decl
);
1493 new_value
= build_cplus_method_type (base
, type
,
1494 TREE_CHAIN (values
));
1498 new_value
= make_node (TREE_CODE (t
));
1499 TREE_TYPE (new_value
) = type
;
1500 TYPE_CONTEXT (new_value
) = context
;
1501 TYPE_VALUES (new_value
) = values
;
1502 TYPE_SIZE (new_value
) = TYPE_SIZE (t
);
1503 TYPE_ALIGN (new_value
) = TYPE_ALIGN (t
);
1504 TYPE_MODE (new_value
) = TYPE_MODE (t
);
1505 if (TYPE_METHOD_BASETYPE (t
))
1506 TYPE_METHOD_BASETYPE (new_value
) = tsubst (TYPE_METHOD_BASETYPE (t
),
1507 args
, nargs
, in_decl
);
1508 /* Need to generate hash value. */
1509 my_friendly_abort (84);
1511 new_value
= build_type_variant (new_value
,
1518 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, nargs
, in_decl
);
1520 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
1522 r
= build_cplus_array_type (type
, domain
);
1526 case UNINSTANTIATED_P_TYPE
:
1528 int nparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (UPT_TEMPLATE (t
)));
1529 tree argvec
= make_tree_vec (nparms
);
1530 tree parmvec
= UPT_PARMS (t
);
1533 for (i
= 0; i
< nparms
; i
++)
1534 TREE_VEC_ELT (argvec
, i
) = tsubst (TREE_VEC_ELT (parmvec
, i
),
1535 args
, nargs
, in_decl
);
1536 id
= lookup_template_class (DECL_NAME (UPT_TEMPLATE (t
)), argvec
, NULL_TREE
);
1537 if (! IDENTIFIER_HAS_TYPE_VALUE (id
)) {
1538 instantiate_class_template(id
, 0);
1539 /* set up pending_classes */
1540 add_pending_template (id
);
1542 TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (id
)) =
1543 IDENTIFIER_TYPE_VALUE (id
);
1545 rt
= IDENTIFIER_TYPE_VALUE (id
);
1547 /* kung: this part handles nested type in template definition */
1549 if ( !ANON_AGGRNAME_P (DECL_NAME(TYPE_NAME(t
))))
1551 rt
= search_nested_type_in_tmpl (rt
, t
);
1554 return build_type_variant (rt
, TYPE_READONLY (t
), TYPE_VOLATILE (t
));
1559 return fold (build (TREE_CODE (t
), TREE_TYPE (t
),
1560 tsubst (TREE_OPERAND (t
, 0), args
, nargs
, in_decl
),
1561 tsubst (TREE_OPERAND (t
, 1), args
, nargs
, in_decl
)));
1565 return fold (build1 (TREE_CODE (t
), TREE_TYPE (t
),
1566 tsubst (TREE_OPERAND (t
, 0), args
, nargs
, in_decl
)));
1569 sorry ("use of `%s' in function template",
1570 tree_code_name
[(int) TREE_CODE (t
)]);
1571 return error_mark_node
;
1576 instantiate_template (tmpl
, targ_ptr
)
1577 tree tmpl
, *targ_ptr
;
1581 struct pending_inline
*p
;
1582 struct template_info
*t
;
1583 struct obstack
*old_fmp_obstack
;
1584 extern struct obstack
*function_maybepermanent_obstack
;
1586 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1587 old_fmp_obstack
= function_maybepermanent_obstack
;
1588 function_maybepermanent_obstack
= &permanent_obstack
;
1590 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 283);
1591 len
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl
));
1593 for (fndecl
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1594 fndecl
; fndecl
= TREE_CHAIN (fndecl
))
1596 tree
*t1
= &TREE_VEC_ELT (TREE_PURPOSE (fndecl
), 0);
1597 for (i
= len
- 1; i
>= 0; i
--)
1598 if (t1
[i
] != targ_ptr
[i
])
1601 /* Here, we have a match. */
1602 fndecl
= TREE_VALUE (fndecl
);
1603 function_maybepermanent_obstack
= old_fmp_obstack
;
1611 targs
= make_tree_vec (len
);
1614 TREE_VEC_ELT (targs
, i
) = targ_ptr
[i
];
1616 /* substitute template parameters */
1617 fndecl
= tsubst (DECL_RESULT (tmpl
), targ_ptr
,
1618 TREE_VEC_LENGTH (targs
), tmpl
);
1620 /* If it's a static member fn in the template, we need to change it
1621 into a FUNCTION_TYPE and chop off its this pointer. */
1622 if (TREE_CODE (TREE_TYPE (DECL_RESULT (tmpl
))) == METHOD_TYPE
1623 && fndecl
!= error_mark_node
1624 && DECL_STATIC_FUNCTION_P (fndecl
))
1626 tree olddecl
= DECL_RESULT (tmpl
);
1627 revert_static_member_fn (&DECL_RESULT (tmpl
), NULL
, NULL
);
1628 /* Chop off the this pointer that grokclassfn so kindly added
1629 for us (it didn't know yet if the fn was static or not). */
1630 DECL_ARGUMENTS (olddecl
) = TREE_CHAIN (DECL_ARGUMENTS (olddecl
));
1631 DECL_ARGUMENTS (fndecl
) = TREE_CHAIN (DECL_ARGUMENTS (fndecl
));
1634 t
= DECL_TEMPLATE_INFO (tmpl
);
1637 p
= (struct pending_inline
*) permalloc (sizeof (struct pending_inline
));
1638 p
->parm_vec
= t
->parm_vec
;
1639 p
->bindings
= targs
;
1647 char * f
= input_filename
;
1649 lineno
= p
->lineno
= t
->lineno
;
1650 input_filename
= p
->filename
= t
->filename
;
1652 extract_interface_info ();
1654 if (interface_unknown
&& flag_external_templates
&& ! DECL_IN_SYSTEM_HEADER (tmpl
))
1655 warn_if_unknown_interface ();
1656 if (interface_unknown
|| !flag_external_templates
)
1657 p
->interface
= 1; /* unknown */
1659 p
->interface
= interface_only
? 0 : 2;
1664 extract_interface_info ();
1668 p
= (struct pending_inline
*)0;
1670 DECL_TEMPLATE_INSTANTIATIONS (tmpl
) =
1671 tree_cons (targs
, fndecl
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1673 function_maybepermanent_obstack
= old_fmp_obstack
;
1676 if (fndecl
== error_mark_node
|| p
== (struct pending_inline
*)0)
1680 else if (DECL_INLINE (fndecl
))
1682 DECL_PENDING_INLINE_INFO (fndecl
) = p
;
1683 p
->next
= pending_inlines
;
1684 pending_inlines
= p
;
1688 p
->next
= pending_template_expansions
;
1689 pending_template_expansions
= p
;
1694 /* classlevel should now never be true. jason 4/12/94 */
1696 undo_template_name_overload (id
, classlevel
)
1702 template = IDENTIFIER_TEMPLATE (id
);
1706 #if 0 /* not yet, should get fixed properly later */
1710 /* This was a botch... See `overload_template_name' just below. */
1716 /* classlevel should now never be true. jason 4/12/94 */
1718 overload_template_name (id
, classlevel
)
1722 tree
template, t
, decl
;
1723 struct template_info
*tinfo
;
1725 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 284);
1726 template = IDENTIFIER_TEMPLATE (id
);
1730 template = TREE_PURPOSE (template);
1731 tinfo
= DECL_TEMPLATE_INFO (template);
1732 template = DECL_NAME (template);
1733 my_friendly_assert (template != NULL_TREE
, 285);
1736 /* This was a botch... names of templates do not get their own private
1737 scopes. Rather, they should go into the binding level already created
1738 by push_template_decls. Except that there isn't one of those for
1743 declare_pseudo_global_level ();
1747 t
= xref_tag (tinfo
->aggr
, id
, NULL_TREE
, 0);
1748 my_friendly_assert (TREE_CODE (t
) == RECORD_TYPE
1749 || TREE_CODE (t
) == UNION_TYPE
1750 || TREE_CODE (t
) == UNINSTANTIATED_P_TYPE
, 286);
1752 decl
= build_decl (TYPE_DECL
, template, t
);
1754 #if 0 /* fix this later */
1755 /* We don't want to call here if the work has already been done. */
1757 ? IDENTIFIER_CLASS_VALUE (template)
1758 : IDENTIFIER_LOCAL_VALUE (template));
1760 && TREE_CODE (t
) == TYPE_DECL
1761 && TREE_TYPE (t
) == t
)
1762 my_friendly_abort (85);
1766 pushdecl_class_level (decl
);
1770 #if 0 /* This seems bogus to me; if it isn't, explain why. (jason) */
1771 /* Fake this for now, just to make dwarfout.c happy. It will have to
1772 be done in a proper way later on. */
1773 DECL_CONTEXT (decl
) = t
;
1777 /* NAME is the IDENTIFIER value of a PRE_PARSED_CLASS_DECL. */
1779 end_template_instantiation (name
)
1782 extern struct pending_input
*to_be_restored
;
1785 processing_template_defn
--;
1786 if (!flag_external_templates
)
1787 interface_unknown
--;
1789 /* Restore the old parser input state. */
1790 if (yychar
== YYEMPTY
)
1792 if (yychar
!= END_OF_SAVED_INPUT
)
1793 error ("parse error at end of class template");
1796 restore_pending_input (to_be_restored
);
1800 /* Our declarations didn't get stored in the global slot, since
1801 there was a (supposedly tags-transparent) scope in between. */
1802 t
= IDENTIFIER_TYPE_VALUE (name
);
1803 my_friendly_assert (t
!= NULL_TREE
1804 && TREE_CODE_CLASS (TREE_CODE (t
)) == 't',
1806 CLASSTYPE_USE_TEMPLATE (t
) = 2;
1807 /* Make methods of template classes static, unless
1808 -fexternal-templates is given. */
1809 if (!flag_external_templates
)
1810 SET_CLASSTYPE_INTERFACE_UNKNOWN (t
);
1811 decl
= IDENTIFIER_GLOBAL_VALUE (name
);
1812 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 288);
1814 undo_template_name_overload (name
, 0);
1815 t
= IDENTIFIER_TEMPLATE (name
);
1816 pop_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (t
)), TREE_VALUE (t
),
1818 /* This will fix up the type-value field. */
1820 pop_from_top_level ();
1822 #ifdef DWARF_DEBUGGING_INFO
1823 if (write_symbols
== DWARF_DEBUG
&& TREE_CODE (decl
) == TYPE_DECL
)
1825 /* We just completed the definition of a new file-scope type,
1826 so we can go ahead and output debug-info for it now. */
1827 TYPE_STUB_DECL (TREE_TYPE (decl
)) = decl
;
1828 rest_of_type_compilation (TREE_TYPE (decl
), 1);
1830 #endif /* DWARF_DEBUGGING_INFO */
1832 /* Restore interface/implementation settings. */
1833 extract_interface_info ();
1836 /* Store away the text of an template. */
1839 reinit_parse_for_template (yychar
, d1
, d2
)
1843 struct template_info
*template_info
;
1844 extern struct obstack inline_text_obstack
; /* see comment in lex.c */
1846 if (d2
== NULL_TREE
|| d2
== error_mark_node
)
1849 /* @@ Should use temp obstack, and discard results. */
1850 reinit_parse_for_block (yychar
, &inline_text_obstack
, 1);
1854 if (TREE_CODE (d2
) == IDENTIFIER_NODE
)
1855 d2
= IDENTIFIER_GLOBAL_VALUE (d2
);
1858 template_info
= DECL_TEMPLATE_INFO (d2
);
1861 template_info
= (struct template_info
*) permalloc (sizeof (struct template_info
));
1862 bzero (template_info
, sizeof (struct template_info
));
1863 DECL_TEMPLATE_INFO (d2
) = template_info
;
1865 template_info
->filename
= input_filename
;
1866 template_info
->lineno
= lineno
;
1867 reinit_parse_for_block (yychar
, &inline_text_obstack
, 1);
1868 template_info
->text
= obstack_base (&inline_text_obstack
);
1869 template_info
->length
= obstack_object_size (&inline_text_obstack
);
1870 obstack_finish (&inline_text_obstack
);
1871 template_info
->parm_vec
= d1
;
1874 /* Type unification.
1876 We have a function template signature with one or more references to
1877 template parameters, and a parameter list we wish to fit to this
1878 template. If possible, produce a list of parameters for the template
1879 which will cause it to fit the supplied parameter list.
1881 Return zero for success, 2 for an incomplete match that doesn't resolve
1882 all the types, and 1 for complete failure. An error message will be
1883 printed only for an incomplete match.
1885 TPARMS[NTPARMS] is an array of template parameter types;
1886 TARGS[NTPARMS] is the array of template parameter values. PARMS is
1887 the function template's signature (using TEMPLATE_PARM_IDX nodes),
1888 and ARGS is the argument list we're trying to match against it.
1890 If SUBR is 1, we're being called recursively (to unify the arguments of
1891 a function or method parameter of a function template), so don't zero
1892 out targs and don't fail on an incomplete match. */
1895 type_unification (tparms
, targs
, parms
, args
, nsubsts
, subr
)
1896 tree tparms
, *targs
, parms
, args
;
1901 int ntparms
= TREE_VEC_LENGTH (tparms
);
1903 my_friendly_assert (TREE_CODE (tparms
) == TREE_VEC
, 289);
1904 my_friendly_assert (TREE_CODE (parms
) == TREE_LIST
, 290);
1905 /* ARGS could be NULL (via a call from parse.y to
1906 build_x_function_call). */
1908 my_friendly_assert (TREE_CODE (args
) == TREE_LIST
, 291);
1909 my_friendly_assert (ntparms
> 0, 292);
1912 bzero (targs
, sizeof (tree
) * ntparms
);
1915 && parms
!= void_list_node
1917 && args
!= void_list_node
)
1919 parm
= TREE_VALUE (parms
);
1920 parms
= TREE_CHAIN (parms
);
1921 arg
= TREE_VALUE (args
);
1922 args
= TREE_CHAIN (args
);
1924 if (arg
== error_mark_node
)
1926 if (arg
== unknown_type_node
)
1929 if (TREE_CODE (arg
) == VAR_DECL
)
1930 arg
= TREE_TYPE (arg
);
1931 else if (TREE_CODE_CLASS (TREE_CODE (arg
)) == 'e')
1932 arg
= TREE_TYPE (arg
);
1934 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
1936 my_friendly_assert (TREE_TYPE (arg
) != NULL_TREE
, 293);
1937 arg
= TREE_TYPE (arg
);
1940 if (TREE_CODE (arg
) == FUNCTION_TYPE
1941 || TREE_CODE (arg
) == METHOD_TYPE
)
1942 arg
= build_pointer_type (arg
);
1944 switch (unify (tparms
, targs
, ntparms
, parm
, arg
, nsubsts
))
1952 /* Fail if we've reached the end of the parm list, and more args
1953 are present, and the parm list isn't variadic. */
1954 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
1956 /* Fail if parms are left and they don't have default values. */
1958 && parms
!= void_list_node
1959 && TREE_PURPOSE (parms
) == NULL_TREE
)
1962 for (i
= 0; i
< ntparms
; i
++)
1965 error ("incomplete type unification");
1971 /* Tail recursion is your friend. */
1973 unify (tparms
, targs
, ntparms
, parm
, arg
, nsubsts
)
1974 tree tparms
, *targs
, parm
, arg
;
1975 int *nsubsts
, ntparms
;
1979 /* I don't think this will do the right thing with respect to types.
1980 But the only case I've seen it in so far has been array bounds, where
1981 signedness is the only information lost, and I think that will be
1983 while (TREE_CODE (parm
) == NOP_EXPR
)
1984 parm
= TREE_OPERAND (parm
, 0);
1986 if (arg
== error_mark_node
)
1988 if (arg
== unknown_type_node
)
1993 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
1994 arg
= TREE_TYPE (arg
);
1996 switch (TREE_CODE (parm
))
1998 case TEMPLATE_TYPE_PARM
:
2000 if (TEMPLATE_TYPE_TPARMLIST (parm
) != tparms
)
2002 error ("mixed template headers?!");
2003 my_friendly_abort (86);
2006 idx
= TEMPLATE_TYPE_IDX (parm
);
2007 /* Simple cases: Value already set, does match or doesn't. */
2008 if (targs
[idx
] == arg
)
2010 else if (targs
[idx
])
2012 /* Check for mixed types and values. */
2013 if (TREE_CODE (TREE_VEC_ELT (tparms
, idx
)) != IDENTIFIER_NODE
)
2017 case TEMPLATE_CONST_PARM
:
2019 idx
= TEMPLATE_CONST_IDX (parm
);
2020 if (targs
[idx
] == arg
)
2022 else if (targs
[idx
])
2024 tree t
= targs
[idx
];
2025 if (TREE_CODE (t
) == TREE_CODE (arg
))
2026 switch (TREE_CODE (arg
))
2029 if (tree_int_cst_equal (t
, arg
))
2033 if (REAL_VALUES_EQUAL (TREE_REAL_CST (t
), TREE_REAL_CST (arg
)))
2036 /* STRING_CST values are not valid template const parms. */
2040 my_friendly_abort (87);
2043 /* else if (typeof arg != tparms[idx])
2046 targs
[idx
] = copy_to_permanent (arg
);
2050 if (TREE_CODE (arg
) != POINTER_TYPE
)
2052 return unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
), TREE_TYPE (arg
),
2055 case REFERENCE_TYPE
:
2056 return unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
), arg
, nsubsts
);
2059 if (TREE_CODE (arg
) != ARRAY_TYPE
)
2061 if (unify (tparms
, targs
, ntparms
, TYPE_DOMAIN (parm
), TYPE_DOMAIN (arg
),
2064 return unify (tparms
, targs
, ntparms
, TREE_TYPE (parm
), TREE_TYPE (arg
),
2069 if (TREE_CODE (parm
) == INTEGER_TYPE
&& TREE_CODE (arg
) == INTEGER_TYPE
)
2071 if (TYPE_MIN_VALUE (parm
) && TYPE_MIN_VALUE (arg
)
2072 && unify (tparms
, targs
, ntparms
,
2073 TYPE_MIN_VALUE (parm
), TYPE_MIN_VALUE (arg
), nsubsts
))
2075 if (TYPE_MAX_VALUE (parm
) && TYPE_MAX_VALUE (arg
)
2076 && unify (tparms
, targs
, ntparms
,
2077 TYPE_MAX_VALUE (parm
), TYPE_MAX_VALUE (arg
), nsubsts
))
2080 /* As far as unification is concerned, this wins. Later checks
2081 will invalidate it if necessary. */
2084 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
2086 if (TREE_CODE (arg
) != INTEGER_CST
)
2088 return !tree_int_cst_equal (parm
, arg
);
2093 t1
= TREE_OPERAND (parm
, 0);
2094 t2
= TREE_OPERAND (parm
, 1);
2095 if (TREE_CODE (t1
) != TEMPLATE_CONST_PARM
)
2097 return unify (tparms
, targs
, ntparms
, t1
,
2098 fold (build (PLUS_EXPR
, integer_type_node
, arg
, t2
)),
2105 if (TREE_CODE (arg
) != TREE_VEC
)
2107 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
2109 for (i
= TREE_VEC_LENGTH (parm
) - 1; i
>= 0; i
--)
2110 if (unify (tparms
, targs
, ntparms
,
2111 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
2117 case UNINSTANTIATED_P_TYPE
:
2120 /* Unification of something that is not a template fails. (mrs) */
2121 if (TYPE_NAME (arg
) == 0)
2123 a
= IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (arg
));
2124 /* Unification of something that is not a template fails. (mrs) */
2127 if (UPT_TEMPLATE (parm
) != TREE_PURPOSE (a
))
2128 /* different templates */
2130 return unify (tparms
, targs
, ntparms
, UPT_PARMS (parm
), TREE_VALUE (a
),
2135 if (TYPE_PTRMEMFUNC_P (parm
))
2136 return unify (tparms
, targs
, ntparms
, TYPE_PTRMEMFUNC_FN_TYPE (parm
),
2139 /* Unification of something that is not a template fails. (mrs) */
2143 if (TREE_CODE (arg
) != METHOD_TYPE
)
2148 if (TREE_CODE (arg
) != FUNCTION_TYPE
)
2151 return type_unification (tparms
, targs
, TYPE_ARG_TYPES (parm
),
2152 TYPE_ARG_TYPES (arg
), nsubsts
, 1);
2155 sorry ("use of `%s' in template type unification",
2156 tree_code_name
[(int) TREE_CODE (parm
)]);
2165 do_pending_expansions ()
2167 struct pending_inline
*i
, *new_list
= 0;
2169 if (!pending_template_expansions
)
2173 fprintf (stderr
, "\n\n\t\t IN DO_PENDING_EXPANSIONS\n\n");
2176 i
= pending_template_expansions
;
2181 struct pending_inline
*next
= i
->next
;
2185 #define DECIDE(N) do {decision=(N); goto decided;} while(0)
2187 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
2188 || TREE_CODE (t
) == VAR_DECL
, 294);
2189 if (TREE_ASM_WRITTEN (t
))
2192 if (DECL_EXPLICITLY_INSTANTIATED (t
))
2195 /* If it's a method, let the class type decide it.
2196 @@ What if the method template is in a separate file?
2197 Maybe both file contexts should be taken into account?
2198 Maybe only do this if i->interface == 1 (unknown)? */
2199 context
= DECL_CONTEXT (t
);
2200 if (context
!= NULL_TREE
2201 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't')
2203 /* I'm interested in the context of this version of the function,
2204 not the original virtual declaration. */
2205 context
= DECL_CLASS_CONTEXT (t
);
2207 /* If `unknown', we might want a static copy.
2208 If `implementation', we want a global one.
2209 If `interface', ext ref. */
2210 if (CLASSTYPE_INTERFACE_KNOWN (context
))
2211 DECIDE (!CLASSTYPE_INTERFACE_ONLY (context
));
2212 #if 0 /* This doesn't get us stuff needed only by the file initializer. */
2213 DECIDE (TREE_USED (t
));
2214 #else /* This compiles too much stuff, but that's probably better in
2215 most cases than never compiling the stuff we need. */
2220 if (i
->interface
== 1)
2221 DECIDE (TREE_USED (t
));
2223 DECIDE (i
->interface
);
2227 print_node_brief (stderr
, decision
? "yes: " : "no: ", t
, 0);
2228 fprintf (stderr
, "\t%s\n",
2229 (DECL_ASSEMBLER_NAME (t
)
2230 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
))
2235 i
->next
= pending_inlines
;
2236 pending_inlines
= i
;
2245 pending_template_expansions
= new_list
;
2246 if (!pending_inlines
)
2248 do_pending_inlines ();
2253 struct pending_template
{
2254 struct pending_template
*next
;
2258 static struct pending_template
* pending_templates
;
2261 do_pending_templates ()
2263 struct pending_template
* t
;
2265 for ( t
= pending_templates
; t
; t
= t
->next
)
2267 instantiate_class_template (t
->id
, 1);
2270 for ( t
= pending_templates
; t
; t
= pending_templates
)
2272 pending_templates
= t
->next
;
2278 add_pending_template (pt
)
2281 struct pending_template
*p
;
2283 p
= (struct pending_template
*) malloc (sizeof (struct pending_template
));
2284 p
->next
= pending_templates
;
2285 pending_templates
= p
;
2289 /* called from the parser. */
2291 do_function_instantiation (declspecs
, declarator
)
2292 tree declspecs
, declarator
;
2294 tree decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, 0, 0);
2295 tree name
= DECL_NAME (decl
);
2296 tree fn
= IDENTIFIER_GLOBAL_VALUE (name
);
2297 tree result
= NULL_TREE
;
2300 for (fn
= get_first_fn (fn
); fn
; fn
= DECL_CHAIN (fn
))
2301 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2303 int ntparms
= TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (fn
));
2304 tree
*targs
= (tree
*) malloc (sizeof (tree
) * ntparms
);
2306 i
= type_unification (DECL_TEMPLATE_PARMS (fn
), targs
,
2307 TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2308 TYPE_ARG_TYPES (TREE_TYPE (decl
)),
2313 cp_error ("ambiguous template instantiation for `%D' requested", decl
);
2315 result
= instantiate_template (fn
, targs
);
2320 cp_error ("no matching template for `%D' found", decl
);
2322 DECL_EXPLICITLY_INSTANTIATED (result
) = 1;
2326 do_type_instantiation (name
)
2329 tree t
= TREE_TYPE (name
);
2331 CLASSTYPE_EXPLICITLY_INSTANTIATED (t
) = 1;
2332 CLASSTYPE_VTABLE_NEEDS_WRITING (t
) = 1;
2334 /* this should really be done by instantiate_member_templates */
2336 tree method
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t
), 0);
2337 for (; method
; method
= TREE_CHAIN (method
))
2338 DECL_EXPLICITLY_INSTANTIATED (method
) = 1;
2341 /* and data member templates, too */
2345 create_nested_upt (scope
, name
)
2348 tree t
= make_lang_type (UNINSTANTIATED_P_TYPE
);
2349 tree d
= build_lang_decl (TYPE_DECL
, name
, t
);
2352 TYPE_VALUES (t
) = TYPE_VALUES (scope
);
2353 TYPE_CONTEXT (t
) = scope
;