| blob | 1b24233af2d8ed2d70855e8106ce39e610097086 |
1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
46 /* The type of functions taking a tree, and some additional data, and
47 returning an int. */
52 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
53 instantiations have been deferred, either because their definitions
54 were not yet available, or because we were putting off doing the
55 work. The TREE_PURPOSE of each entry is a SRCLOC indicating where
56 the instantiate request occurred; the TREE_VALUE is a either a DECL
57 (for a function or static data member), or a TYPE (for a class)
58 indicating what we are hoping to instantiate. */
74 /* A map from local variable declarations in the body of the template
75 presently being instantiated to the corresponding instantiated
76 local variables. */
79 #define obstack_chunk_alloc xmalloc
80 #define obstack_chunk_free free
82 #define UNIFY_ALLOW_NONE 0
83 #define UNIFY_ALLOW_MORE_CV_QUAL 1
84 #define UNIFY_ALLOW_LESS_CV_QUAL 2
85 #define UNIFY_ALLOW_DERIVED 4
86 #define UNIFY_ALLOW_INTEGER 8
87 #define UNIFY_ALLOW_OUTER_LEVEL 16
88 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
89 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
92 virtual, or a base class of a virtual
93 base. */
95 type with the desired type. */
115 tree*));
173 /* Called once to initialize pt.c. */
175 void
177 {
182 }
184 /* Do any processing required when DECL (a member template declaration
185 using TEMPLATE_PARAMETERS as its innermost parameter list) is
186 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
187 it is a specialization, in which case the DECL itself is returned. */
189 tree
191 tree decl;
192 {
196 /* By returning NULL_TREE, the parser will just ignore this
197 declaration. We have already issued the error. */
200 {
201 /* Assume that the class is the only declspec. */
205 {
209 }
211 }
215 {
217 {
220 }
221 else
223 }
224 else
228 }
230 /* Returns the template nesting level of the indicated class TYPE.
232 For example, in:
233 template <class T>
234 struct A
235 {
236 template <class U>
237 struct B {};
238 };
240 A<T>::B<U> has depth two, while A<T> has depth one.
241 Both A<T>::B<int> and A<int>::B<U> have depth one, if
242 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
243 specializations.
245 This function is guaranteed to return 0 if passed NULL_TREE so
246 that, for example, `template_class_depth (current_class_type)' is
247 always safe. */
249 static int
251 tree type;
253 {
260 {
262 {
265 && ((count_specializations
269 }
270 else
271 {
274 && ((count_specializations
278 }
279 }
282 }
284 /* Returns the template nesting level of the indicated class TYPE.
285 Like template_class_depth_real, but instantiations do not count in
286 the depth. */
288 int
290 tree type;
291 {
293 }
295 /* Returns 1 if processing DECL as part of do_pending_inlines
296 needs us to push template parms. */
298 static int
300 tree decl;
301 {
307 }
309 /* Subroutine of maybe_begin_member_template_processing.
310 Push the template parms in PARMS, starting from LEVELS steps into the
311 chain, and ending at the beginning, since template parms are listed
312 innermost first. */
314 static void
316 tree parmlist;
318 {
326 current_template_parms
333 {
338 {
345 {
346 /* Make a CONST_DECL as is done in process_template_parm.
347 It is ugly that we recreate this here; the original
348 version built in process_template_parm is no longer
349 available. */
356 }
361 }
362 }
363 }
365 /* Restore the template parameter context for a member template or
366 a friend template defined in a class definition. */
368 void
370 tree decl;
371 {
372 tree parms;
376 {
381 {
384 }
387 }
389 /* Remember how many levels of template parameters we pushed so that
390 we can pop them later. */
397 }
399 /* Undo the effects of begin_member_template_processing. */
401 void
403 {
413 {
417 }
418 }
420 /* Returns non-zero iff T is a member template function. We must be
421 careful as in
423 template <class T> class C { void f(); }
425 Here, f is a template function, and a member, but not a member
426 template. This function does not concern itself with the origin of
427 T, only its present state. So if we have
429 template <class T> class C { template <class U> void f(U); }
431 then neither C<int>::f<char> nor C<T>::f<double> is considered
432 to be a member template. But, `template <class U> void
433 C<int>::f(U)' is considered a member template. */
435 int
437 tree t;
438 {
440 /* Anything that isn't a function or a template function is
441 certainly not a member template. */
444 /* A local class can't have member templates. */
449 /* If there are more levels of template parameters than
450 there are template classes surrounding the declaration,
451 then we have a member template. */
454 }
457 /* Returns non-zero iff T is a member template class. See
458 is_member_template for a description of what precisely constitutes
459 a member template. */
461 int
463 tree t;
464 {
466 /* Anything that isn't a class template, is certainly not a member
467 template. */
471 /* Anything whose context isn't a class type is surely not a
472 member template. */
475 /* If there are more levels of template parameters than there are
476 template classes surrounding the declaration, then we have a
477 member template. */
480 }
481 #endif
483 /* Return a new template argument vector which contains all of ARGS,
484 but has as its innermost set of arguments the EXTRA_ARGS. */
486 static tree
488 tree args;
489 tree extra_args;
490 {
491 tree new_args;
506 }
508 /* Like add_to_template_args, but only the outermost ARGS are added to
509 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
510 (EXTRA_ARGS) levels are added. This function is used to combine
511 the template arguments from a partial instantiation with the
512 template arguments used to attain the full instantiation from the
513 partial instantiation. */
515 static tree
517 tree args;
518 tree extra_args;
519 {
520 tree new_args;
522 /* If there are more levels of EXTRA_ARGS than there are ARGS,
523 something very fishy is going on. */
527 /* If *all* the new arguments will be the EXTRA_ARGS, just return
528 them. */
532 /* For the moment, we make ARGS look like it contains fewer levels. */
537 /* Now, we restore ARGS to its full dimensions. */
541 }
543 /* Return the N levels of innermost template arguments from the ARGS. */
545 tree
547 tree args;
549 {
550 tree new_args;
556 /* If N is 1, just return the innermost set of template arguments. */
560 /* If we're not removing anything, just return the arguments we were
561 given. */
567 /* Make a new set of arguments, not containing the outer arguments. */
574 }
576 /* We've got a template header coming up; push to a new level for storing
577 the parms. */
579 void
581 {
582 /* We use a non-tag-transparent scope here, which causes pushtag to
583 put tags in this scope, rather than in the enclosing class or
584 namespace scope. This is the right thing, since we want
585 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
586 global template class, push_template_decl handles putting the
587 TEMPLATE_DECL into top-level scope. For a nested template class,
588 e.g.:
590 template <class T> struct S1 {
591 template <class T> struct S2 {};
592 };
594 pushtag contains special code to call pushdecl_with_scope on the
595 TEMPLATE_DECL for S2. */
600 }
602 /* This routine is called when a specialization is declared. If it is
603 illegal to declare a specialization here, an error is reported. */
605 static void
607 {
610 /* [temp.expl.spec]
612 An explicit specialization shall be declared in the namespace of
613 which the template is a member, or, for member templates, in the
614 namespace of which the enclosing class or enclosing class
615 template is a member. An explicit specialization of a member
616 function, member class or static data member of a class template
617 shall be declared in the namespace of which the class template
618 is a member. */
621 scope);
623 /* [temp.expl.spec]
625 In an explicit specialization declaration for a member of a class
626 template or a member template that appears in namespace scope,
627 the member template and some of its enclosing class templates may
628 remain unspecialized, except that the declaration shall not
629 explicitly specialize a class member template if its enclosing
630 class templates are not explicitly specialized as well. */
633 }
635 /* We've just seen template <>. */
637 void
639 {
643 }
645 /* Called at then end of processing a declaration preceded by
646 template<>. */
648 void
650 {
653 }
655 /* Any template <>'s that we have seen thus far are not referring to a
656 function specialization. */
658 void
660 {
663 }
665 /* We've just seen a template header. If SPECIALIZATION is non-zero,
666 it was of the form template <>. */
668 static void
671 {
673 template_header_count++;
674 }
676 /* We're beginning an explicit instantiation. */
678 void
680 {
682 }
685 void
687 {
690 }
692 /* The TYPE is being declared. If it is a template type, that means it
693 is a partial specialization. Do appropriate error-checking. */
695 void
697 tree type;
698 {
700 {
703 {
706 {
710 }
714 }
717 }
720 }
722 /* Retrieve the specialization (in the sense of [temp.spec] - a
723 specialization is either an instantiation or an explicit
724 specialization) of TMPL for the given template ARGS. If there is
725 no such specialization, return NULL_TREE. The ARGS are a vector of
726 arguments, or a vector of vectors of arguments, in the case of
727 templates with more than one level of parameters. */
729 static tree
731 tree tmpl;
732 tree args;
733 {
734 tree s;
738 /* There should be as many levels of arguments as there are
739 levels of parameters. */
751 }
753 /* Like retrieve_specialization, but for local declarations. */
755 static tree
757 tree tmpl;
758 {
760 }
762 /* Returns non-zero iff DECL is a specialization of TMPL. */
764 int
766 tree decl;
767 tree tmpl;
768 {
769 tree t;
772 {
778 }
779 else
780 {
789 }
792 }
794 /* Register the specialization SPEC as a specialization of TMPL with
795 the indicated ARGS. Returns SPEC, or an equivalent prior
796 declaration, if available. */
798 static tree
800 tree spec;
801 tree tmpl;
802 tree args;
803 {
804 tree s;
810 /* This is the FUNCTION_DECL for a partial instantiation. Don't
811 register it; we want the corresponding TEMPLATE_DECL instead.
812 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
813 the more obvious `uses_template_parms (spec)' to avoid problems
814 with default function arguments. In particular, given
815 something like this:
817 template <class T> void f(T t1, T t = T())
819 the default argument expression is not substituted for in an
820 instantiation unless and until it is actually needed. */
823 /* There should be as many levels of arguments as there are
824 levels of parameters. */
832 {
835 /* We can sometimes try to re-register a specialization that we've
836 already got. In particular, regenerate_decl_from_template
837 calls duplicate_decls which will update the specialization
838 list. But, we'll still get called again here anyhow. It's
839 more convenient to simply allow this than to try to prevent it. */
843 {
845 {
847 {
850 {
852 fn);
854 }
855 else
856 {
857 /* This situation should occur only if the first
858 specialization is an implicit instantiation,
859 the second is an explicit specialization, and
860 the implicit instantiation has not yet been
861 used. That situation can occur if we have
862 implicitly instantiated a member function and
863 then specialized it later.
865 We can also wind up here if a friend
866 declaration that looked like an instantiation
867 turns out to be a specialization:
869 template <class T> void foo(T);
870 class S { friend void foo<>(int) };
871 template <> void foo(int);
873 We transform the existing DECL in place so that
874 any pointers to it become pointers to the
875 updated declaration.
877 If there was a definition for the template, but
878 not for the specialization, we want this to
879 look as if there is no definition, and vice
880 versa. */
885 }
886 }
888 {
891 }
892 }
893 }
894 }
900 }
902 /* Unregister the specialization SPEC as a specialization of TMPL.
903 Returns nonzero if the SPEC was listed as a specialization of
904 TMPL. */
906 static int
908 tree spec;
909 tree tmpl;
910 {
917 {
920 }
923 }
925 /* Like register_specialization, but for local declarations. We are
926 registering SPEC, an instantiation of TMPL. */
928 static void
930 tree spec;
931 tree tmpl;
932 {
937 }
939 /* Print the list of candidate FNS in an error message. */
941 void
943 tree fns;
944 {
945 tree fn;
950 {
951 tree f;
956 }
957 }
959 /* Returns the template (one of the functions given by TEMPLATE_ID)
960 which can be specialized to match the indicated DECL with the
961 explicit template args given in TEMPLATE_ID. The DECL may be
962 NULL_TREE if none is available. In that case, the functions in
963 TEMPLATE_ID are non-members.
965 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
966 specialization of a member template.
968 The template args (those explicitly specified and those deduced)
969 are output in a newly created vector *TARGS_OUT.
971 If it is impossible to determine the result, an error message is
972 issued. The error_mark_node is returned to indicate failure. */
974 static tree
976 need_member_template)
977 tree template_id;
978 tree decl;
981 {
982 tree fns;
983 tree targs;
984 tree explicit_targs;
999 /* Check for baselinks. */
1004 {
1007 }
1010 {
1011 tree tmpl;
1016 /* DECL might be a specialization of FN. */
1019 /* FN is an ordinary member function, and we need a
1020 specialization of a member template. */
1023 /* We can get IDENTIFIER_NODEs here in certain erroneous
1024 cases. */
1027 /* This is just an ordinary non-member function. Nothing can
1028 be a specialization of that. */
1030 else
1031 {
1032 tree decl_arg_types;
1034 /* This is an ordinary member function. However, since
1035 we're here, we can assume it's enclosing class is a
1036 template class. For example,
1038 template <typename T> struct S { void f(); };
1039 template <> void S<int>::f() {}
1041 Here, S<int>::f is a non-template, but S<int> is a
1042 template class. If FN has the same type as DECL, we
1043 might be in business. */
1046 /* The return types differ. */
1049 /* Adjust the type of DECL in case FN is a static member. */
1056 decl_arg_types))
1057 /* They match! */
1061 }
1063 /* See whether this function might be a specialization of this
1064 template. */
1068 /* We cannot deduce template arguments that when used to
1069 specialize TMPL will produce DECL. */
1072 /* Save this template, and the arguments deduced. */
1074 }
1077 {
1078 /* We have:
1080 [temp.expl.spec]
1082 It is possible for a specialization with a given function
1083 signature to be instantiated from more than one function
1084 template. In such cases, explicit specification of the
1085 template arguments must be used to uniquely identify the
1086 function template specialization being specialized.
1088 Note that here, there's no suggestion that we're supposed to
1089 determine which of the candidate templates is most
1090 specialized. However, we, also have:
1092 [temp.func.order]
1094 Partial ordering of overloaded function template
1095 declarations is used in the following contexts to select
1096 the function template to which a function template
1097 specialization refers:
1099 -- when an explicit specialization refers to a function
1100 template.
1102 So, we do use the partial ordering rules, at least for now.
1103 This extension can only serve to make illegal programs legal,
1104 so it's safe. And, there is strong anecdotal evidence that
1105 the committee intended the partial ordering rules to apply;
1106 the EDG front-end has that behavior, and John Spicer claims
1107 that the committee simply forgot to delete the wording in
1108 [temp.expl.spec]. */
1111 {
1114 }
1115 }
1118 {
1122 }
1126 {
1132 }
1134 /* We have one, and exactly one, match. */
1136 {
1137 /* It was a specialization of an ordinary member function in a
1138 template class. */
1141 }
1143 /* It was a specialization of a template. */
1146 {
1151 }
1152 else
1155 }
1157 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1158 but with the default argument values filled in from those in the
1159 TMPL_TYPES. */
1161 static tree
1163 tmpl_types)
1164 tree spec_types;
1165 tree tmpl_types;
1166 {
1167 tree new_spec_types;
1175 /* Substitute into the rest of the list. */
1176 new_spec_types =
1180 /* Add the default argument for this parameter. */
1183 new_spec_types);
1184 }
1186 /* DECL is an explicit specialization. Replicate default arguments
1187 from the template it specializes. (That way, code like:
1189 template <class T> void f(T = 3);
1190 template <> void f(double);
1191 void g () { f (); }
1193 works, as required.) An alternative approach would be to look up
1194 the correct default arguments at the call-site, but this approach
1195 is consistent with how implicit instantiations are handled. */
1197 static void
1199 tree decl;
1200 {
1201 tree tmpl;
1202 tree spec_types;
1203 tree tmpl_types;
1204 tree new_spec_types;
1205 tree old_type;
1206 tree new_type;
1207 tree t;
1212 /* See if there's anything we need to do. */
1225 {
1226 /* Remove the this pointer, but remember the object's type for
1227 CV quals. */
1233 {
1234 /* DECL may contain more parameters than TMPL due to the extra
1235 in-charge parameter in constructors and destructors. */
1238 }
1240 {
1243 }
1244 }
1246 /* Compute the merged default arguments. */
1247 new_spec_types =
1250 /* Compute the new FUNCTION_TYPE. */
1252 {
1256 new_spec_types);
1259 /* Put the in-charge parameter back. */
1262 new_spec_types);
1266 new_spec_types);
1267 }
1268 else
1270 new_spec_types);
1276 }
1278 /* Check to see if the function just declared, as indicated in
1279 DECLARATOR, and in DECL, is a specialization of a function
1280 template. We may also discover that the declaration is an explicit
1281 instantiation at this point.
1283 Returns DECL, or an equivalent declaration that should be used
1284 instead if all goes well. Issues an error message if something is
1285 amiss. Returns error_mark_node if the error is not easily
1286 recoverable.
1288 FLAGS is a bitmask consisting of the following flags:
1290 2: The function has a definition.
1291 4: The function is a friend.
1293 The TEMPLATE_COUNT is the number of references to qualifying
1294 template classes that appeared in the name of the function. For
1295 example, in
1297 template <class T> struct S { void f(); };
1298 void S<int>::f();
1300 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1301 classes are not counted in the TEMPLATE_COUNT, so that in
1303 template <class T> struct S {};
1304 template <> struct S<int> { void f(); }
1305 template <> void S<int>::f();
1307 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1308 illegal; there should be no template <>.)
1310 If the function is a specialization, it is marked as such via
1311 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1312 is set up correctly, and it is added to the list of specializations
1313 for that template. */
1315 tree
1317 tree declarator;
1318 tree decl;
1321 {
1329 tmpl_spec_kind tsk;
1334 {
1337 {
1340 }
1342 {
1344 /* This could be something like:
1346 template <class T> void f(T);
1347 class S { friend void f<>(int); } */
1349 else
1350 {
1351 /* This case handles bogus declarations like template <>
1352 template <class T> void f<int>(); */
1355 declarator);
1357 }
1358 }
1362 /* The error has already been reported in
1363 check_specialization_scope. */
1369 /* Fall through. */
1380 decl);
1383 /* Fall through. */
1388 else
1394 {
1396 decl);
1398 }
1403 {
1404 /* For backwards compatibility, we accept:
1406 template <class T> struct S { void f(); };
1407 void S<int>::f() {} // Missing template <>
1409 That used to be legal C++. */
1411 cp_pedwarn
1415 }
1420 {
1421 /* This case handles bogus declarations like template <>
1422 template <class T> void f<int>(); */
1426 declarator);
1427 else
1429 declarator);
1431 }
1434 /* This is a specialization of a member template, without
1435 specialization the containing class. Something like:
1437 template <class T> struct S {
1438 template <class U> void f (U);
1439 };
1440 template <> template <class U> void S<int>::f(U) {}
1442 That's a specialization -- but of the entire template. */
1448 }
1451 {
1455 {
1456 cp_pedwarn
1459 }
1462 }
1465 {
1469 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1471 {
1472 tree fns;
1478 else
1481 declarator =
1483 }
1489 {
1491 /* A specialization in class scope. This is illegal,
1492 but the error will already have been flagged by
1493 check_specialization_scope. */
1495 else
1496 {
1497 /* It's not legal to write an explicit instantiation in
1498 class scope, e.g.:
1500 class C { template void f(); }
1502 This case is caught by the parser. However, on
1503 something like:
1505 template class C { void f(); };
1507 (which is illegal) we can get here. The error will be
1508 issued later. */
1509 ;
1510 }
1513 }
1515 {
1516 /* A friend declaration. We can't do much, because we don't
1517 know what this resolves to, yet. */
1522 }
1525 IDENTIFIER_NODE))
1526 {
1527 /* Find the list of functions in ctype that have the same
1528 name as the declared function. */
1535 {
1540 {
1541 /* From [temp.expl.spec]:
1543 If such an explicit specialization for the member
1544 of a class template names an implicitly-declared
1545 special member function (clause _special_), the
1546 program is ill-formed.
1548 Similar language is found in [temp.explicit]. */
1551 }
1554 }
1557 {
1561 }
1562 else
1563 {
1564 tree methods;
1566 /* For a type-conversion operator, we cannot do a
1567 name-based lookup. We might be looking for `operator
1568 int' which will be a specialization of `operator T'.
1569 So, we find *all* the conversion operators, and then
1570 select from them. */
1576 {
1580 /* There are no more conversion functions. */
1583 /* Glue all these conversion functions together
1584 with those we already have. */
1587 }
1588 }
1591 {
1595 }
1596 else
1598 }
1600 /* Figure out what exactly is being specialized at this point.
1601 Note that for an explicit instantiation, even one for a
1602 member function, we cannot tell apriori whether the
1603 instantiation is for a member template, or just a member
1604 function of a template class. Even if a member template is
1605 being instantiated, the member template arguments may be
1606 elided if they can be deduced from the rest of the
1607 declaration. */
1610 member_specialization);
1613 /* We couldn't figure out what this declaration was
1614 specializing. */
1616 else
1617 {
1621 {
1622 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1623 is done by do_decl_instantiation later. */
1629 {
1630 /* If TMPL is not the most general template (for
1631 example, if TMPL is a friend template that is
1632 injected into namespace scope), then there will
1633 be too many levels of TARGS. Remove some of them
1634 here. */
1636 tree new_targs;
1643 }
1646 }
1648 /* If this is a specialization of a member template of a
1649 template class. In we want to return the TEMPLATE_DECL,
1650 not the specialization of it. */
1652 {
1656 }
1658 /* If we thought that the DECL was a member function, but it
1659 turns out to be specializing a static member function,
1660 make DECL a static member function as well. */
1663 {
1666 }
1668 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1671 /* Inherit default function arguments from the template
1672 DECL is specializing. */
1676 /* This is not really a declaration of a specialization.
1677 It's just the name of an instantiation. But, it's not
1678 a request for an instantiation, either. */
1681 /* This is indeed a specialization. In case of constructors
1682 and destructors, we need in-charge and not-in-charge
1683 versions in V3 ABI. */
1686 /* Register this specialization so that we can find it
1687 again. */
1689 }
1690 }
1693 }
1695 /* TYPE is being declared. Verify that the use of template headers
1696 and such is reasonable. Issue error messages if not. */
1698 void
1700 tree type;
1701 {
1703 {
1704 /* We are in the scope of some `template <...>' header. */
1706 int context_depth
1711 /* This is OK; the template headers are for the context. We
1712 are actually too lenient here; like
1713 check_explicit_specialization we should consider the number
1714 of template types included in the actual declaration. For
1715 example,
1717 template <class T> struct S {
1718 template <class U> template <class V>
1719 struct I {};
1720 };
1722 is illegal, but:
1724 template <class T> struct S {
1725 template <class U> struct I;
1726 };
1728 template <class T> template <class U.
1729 struct S<T>::I {};
1731 is not. */
1732 ;
1734 /* There are two many template parameter lists. */
1736 }
1737 }
1739 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1740 parameters. These are represented in the same format used for
1741 DECL_TEMPLATE_PARMS. */
1744 tree parms1;
1745 tree parms2;
1746 {
1747 tree p1;
1748 tree p2;
1756 {
1768 {
1779 }
1780 }
1783 /* One set of parameters has more parameters lists than the
1784 other. */
1788 }
1790 /* Complain if DECL shadows a template parameter.
1792 [temp.local]: A template-parameter shall not be redeclared within its
1793 scope (including nested scopes). */
1795 void
1797 tree decl;
1798 {
1799 tree olddecl;
1801 /* If we're not in a template, we can't possibly shadow a template
1802 parameter. */
1806 /* Figure out what we're shadowing. */
1811 /* If there's no previous binding for this name, we're not shadowing
1812 anything, let alone a template parameter. */
1816 /* If we're not shadowing a template parameter, we're done. Note
1817 that OLDDECL might be an OVERLOAD (or perhaps even an
1818 ERROR_MARK), so we can't just blithely assume it to be a _DECL
1819 node. */
1823 /* We check for decl != olddecl to avoid bogus errors for using a
1824 name inside a class. We check TPFI to avoid duplicate errors for
1825 inline member templates. */
1832 }
1834 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1835 ORIG_LEVEL, DECL, and TYPE. */
1837 static tree
1842 tree decl;
1843 tree type;
1844 {
1853 }
1855 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1856 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1857 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1858 new one is created. */
1860 static tree
1862 tree index;
1863 tree type;
1865 {
1869 {
1870 tree decl
1873 type);
1874 tree t
1884 /* Template template parameters need this. */
1887 }
1890 }
1892 /* Process information from new template parameter NEXT and append it to the
1893 LIST being built. */
1895 tree
1898 {
1899 tree parm;
1901 tree defval;
1911 {
1916 else
1919 }
1920 else
1924 {
1926 /* is a const-param */
1930 /* [temp.param]
1932 The top-level cv-qualifiers on the template-parameter are
1933 ignored when determining its type. */
1936 /* A template parameter is not modifiable. */
1943 processing_template_decl,
1945 }
1946 else
1947 {
1948 tree t;
1952 {
1954 /* This is for distinguishing between real templates and template
1955 template parameters */
1959 }
1960 else
1961 {
1963 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1965 }
1972 processing_template_decl,
1974 }
1980 }
1982 /* The end of a template parameter list has been reached. Process the
1983 tree list into a parameter vector, converting each parameter into a more
1984 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1985 as PARM_DECLs. */
1987 tree
1989 tree parms;
1990 {
1992 tree parm;
1995 current_template_parms
2000 parm;
2007 }
2009 /* end_template_decl is called after a template declaration is seen. */
2011 void
2013 {
2019 /* This matches the pushlevel in begin_template_parm_list. */
2024 }
2026 /* Given a template argument vector containing the template PARMS.
2027 The innermost PARMS are given first. */
2029 tree
2031 {
2032 tree header;
2037 /* If there is only one level of template parameters, we do not
2038 create a TREE_VEC of TREE_VECs. Instead, we return a single
2039 TREE_VEC containing the arguments. */
2044 {
2050 {
2053 /* T will be a list if we are called from within a
2054 begin/end_template_parm_list pair, but a vector directly
2055 if within a begin/end_member_template_processing pair. */
2057 {
2063 else
2066 }
2067 }
2071 else
2073 }
2076 }
2078 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2079 template PARMS. Used by push_template_decl below. */
2081 static tree
2083 tree decl;
2084 tree parms;
2085 {
2090 {
2100 }
2103 }
2105 struct template_parm_data
2106 {
2107 /* The level of the template parameters we are currently
2108 processing. */
2111 /* The index of the specialization argument we are currently
2112 processing. */
2115 /* An array whose size is the number of template parameters. The
2116 elements are non-zero if the parameter has been used in any one
2117 of the arguments processed so far. */
2120 /* An array whose size is the number of template arguments. The
2121 elements are non-zero if the argument makes use of template
2122 parameters of this level. */
2124 };
2126 /* Subroutine of push_template_decl used to see if each template
2127 parameter in a partial specialization is used in the explicit
2128 argument list. If T is of the LEVEL given in DATA (which is
2129 treated as a template_parm_data*), then DATA->PARMS is marked
2130 appropriately. */
2132 static int
2134 tree t;
2136 {
2142 {
2145 }
2146 else
2147 {
2150 }
2153 {
2156 }
2158 /* Return zero so that for_each_template_parm will continue the
2159 traversal of the tree; we want to mark *every* template parm. */
2161 }
2163 /* Process the partial specialization DECL. */
2165 static tree
2167 tree decl;
2168 {
2182 /* We check that each of the template parameters given in the
2183 partial specialization is used in the argument list to the
2184 specialization. For example:
2186 template <class T> struct S;
2187 template <class T> struct S<T*>;
2189 The second declaration is OK because `T*' uses the template
2190 parameter T, whereas
2192 template <class T> struct S<int>;
2194 is no good. Even trickier is:
2196 template <class T>
2197 struct S1
2198 {
2199 template <class U>
2200 struct S2;
2201 template <class U>
2202 struct S2<T>;
2203 };
2205 The S2<T> declaration is actually illegal; it is a
2206 full-specialization. Of course,
2208 template <class U>
2209 struct S2<T (*)(U)>;
2211 or some such would have been OK. */
2219 {
2224 }
2227 {
2228 /* One of the template parms was not used in the
2229 specialization. */
2231 {
2234 }
2238 }
2240 /* [temp.class.spec]
2242 The argument list of the specialization shall not be identical to
2243 the implicit argument list of the primary template. */
2250 /* [temp.class.spec]
2252 A partially specialized non-type argument expression shall not
2253 involve template parameters of the partial specialization except
2254 when the argument expression is a simple identifier.
2256 The type of a template parameter corresponding to a specialized
2257 non-type argument shall not be dependent on a parameter of the
2258 specialization. */
2262 {
2267 /* This next line is the `argument expression is not just a
2268 simple identifier' condition and also the `specialized
2269 non-type argument' bit. */
2271 {
2274 else
2275 {
2276 /* Look at the corresponding template parameter,
2277 marking which template parameters its type depends
2278 upon. */
2279 tree type =
2281 i)));
2284 {
2285 /* We haven't yet initialized TPD2. Do so now. */
2286 tpd2.arg_uses_template_parms
2288 /* The number of parameters here is the number in the
2289 main template, which, as checked in the assertion
2290 above, is NARGS. */
2294 }
2296 /* Mark the template parameters. But this time, we're
2297 looking for the template parameters of the main
2298 template, not in the specialization. */
2307 {
2308 /* The type depended on some template parameters.
2309 If they are fully specialized in the
2310 specialization, that's OK. */
2315 {
2317 type,
2318 arg);
2320 }
2321 }
2322 }
2323 }
2324 }
2327 /* We've already got this specialization. */
2335 }
2337 /* Check that a template declaration's use of default arguments is not
2338 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2339 non-zero if DECL is the thing declared by a primary template.
2340 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2342 static void
2344 tree decl;
2345 tree parms;
2348 {
2351 tree parm_level;
2353 /* [temp.param]
2355 A default template-argument shall not be specified in a
2356 function template declaration or a function template definition, nor
2357 in the template-parameter-list of the definition of a member of a
2358 class template. */
2361 /* You can't have a function template declaration in a local
2362 scope, nor you can you define a member of a class template in a
2363 local scope. */
2369 /* If this is either a friend defined in the scope of the class
2370 or a member function. */
2375 current_class_type)))
2376 /* And, if it was a member function, it really was defined in
2377 the scope of the class. */
2379 /* We already checked these parameters when the template was
2380 declared, so there's no need to do it again now. This function
2381 was defined in class scope, but we're processing it's body now
2382 that the class is complete. */
2385 /* [temp.param]
2387 If a template-parameter has a default template-argument, all
2388 subsequent template-parameters shall have a default
2389 template-argument supplied. */
2391 {
2398 {
2403 {
2405 /* For better subsequent error-recovery, we indicate that
2406 there should have been a default argument. */
2408 }
2409 }
2410 }
2413 /* For an ordinary class template, default template arguments are
2414 allowed at the innermost level, e.g.:
2415 template <class T = int>
2416 struct S {};
2417 but, in a partial specialization, they're not allowed even
2418 there, as we have in [temp.class.spec]:
2420 The template parameter list of a specialization shall not
2421 contain default template argument values.
2423 So, for a partial specialization, or for a function template,
2424 we look at all of them. */
2425 ;
2426 else
2427 /* But, for a primary class template that is not a partial
2428 specialization we look at all template parameters except the
2429 innermost ones. */
2432 /* Figure out what error message to issue. */
2437 else
2441 /* If we're inside a class definition, there's no need to
2442 examine the parameters to the class itself. On the one
2443 hand, they will be checked when the class is defined, and,
2444 on the other, default arguments are legal in things like:
2445 template <class T = double>
2446 struct S { template <class U> void f(U); };
2447 Here the default argument for `S' has no bearing on the
2448 declaration of `f'. */
2450 else
2451 /* Check everything. */
2457 {
2465 {
2467 {
2470 }
2472 /* Clear out the default argument so that we are not
2473 confused later. */
2475 }
2477 /* At this point, if we're still interested in issuing messages,
2478 they must apply to classes surrounding the object declared. */
2481 }
2482 }
2484 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2485 parameters given by current_template_args, or reuses a
2486 previously existing one, if appropriate. Returns the DECL, or an
2487 equivalent one, if it is replaced via a call to duplicate_decls.
2489 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2491 tree
2493 tree decl;
2495 {
2496 tree tmpl;
2497 tree args;
2498 tree info;
2499 tree ctx;
2504 /* See if this is a partial specialization. */
2512 /* For a friend, we want the context of the friend function, not
2513 the type of which it is a friend. */
2517 /* In the case of a virtual function, we want the class in which
2518 it is defined. */
2520 else
2521 /* Otherwise, if we're currently defining some class, the DECL
2522 is assumed to be a member of the class. */
2531 /* See if this is a primary template. */
2535 {
2546 else
2548 }
2550 /* Check to see that the rules regarding the use of default
2551 arguments are not being violated. */
2564 {
2569 /* If DECL is a TYPE_DECL for a class-template, then there won't
2570 be DECL_LANG_SPECIFIC. The information equivalent to
2571 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2575 {
2576 /* Since a template declaration already existed for this
2577 class-type, we must be redeclaring it here. Make sure
2578 that the redeclaration is legal. */
2580 current_template_parms);
2581 /* We don't need to create a new TEMPLATE_DECL; just use the
2582 one we already had. */
2584 }
2585 else
2586 {
2592 {
2593 /* A specialization of a member template of a template
2594 class. */
2598 }
2599 }
2600 }
2601 else
2602 {
2607 {
2613 else
2614 {
2617 }
2618 }
2620 {
2623 }
2624 else
2631 {
2632 tree new_tmpl;
2634 /* The declaration is a specialization of a member
2635 template, declared outside the class. Therefore, the
2636 innermost template arguments will be NULL, so we
2637 replace them with the arguments determined by the
2638 earlier call to check_explicit_specialization. */
2641 new_tmpl
2652 args);
2654 }
2656 /* Make sure the template headers we got make sense. */
2661 {
2664 }
2665 else
2667 {
2672 {
2676 else
2680 }
2682 /* Perhaps we should also check that the parms are used in the
2683 appropriate qualifying scopes in the declarator? */
2687 else
2689 }
2690 }
2695 /* Push template declarations for global functions and types. Note
2696 that we do not try to push a global template friend declared in a
2697 template class; such a thing may well depend on the template
2698 parameters of the class. */
2709 {
2713 /* Don't change the name if we've already set it up. */
2716 }
2721 }
2723 tree
2725 tree decl;
2726 {
2728 }
2730 /* Called when a class template TYPE is redeclared with the indicated
2731 template PARMS, e.g.:
2733 template <class T> struct S;
2734 template <class T> struct S {}; */
2736 void
2738 tree type;
2739 tree parms;
2740 {
2741 tree tmpl;
2742 tree tmpl_parms;
2746 {
2749 }
2753 /* The type is nested in some template class. Nothing to worry
2754 about here; there are no new template parameters for the nested
2755 type. */
2762 {
2769 }
2772 {
2779 {
2783 }
2786 {
2787 /* We have in [temp.param]:
2789 A template-parameter may not be given default arguments
2790 by two different declarations in the same scope. */
2794 }
2797 /* Update the previous template parameters (which are the ones
2798 that will really count) with the new default value. */
2801 /* Update the new parameters, too; they'll be used as the
2802 parameters for any members. */
2804 }
2805 }
2807 /* Attempt to convert the non-type template parameter EXPR to the
2808 indicated TYPE. If the conversion is successful, return the
2809 converted value. If the conversion is unsuccessful, return
2810 NULL_TREE if we issued an error message, or error_mark_node if we
2811 did not. We issue error messages for out-and-out bad template
2812 parameters, but not simply because the conversion failed, since we
2813 might be just trying to do argument deduction. By the time this
2814 function is called, neither TYPE nor EXPR may make use of template
2815 parameters. */
2817 static tree
2819 tree type;
2820 tree expr;
2821 {
2824 /* A template-argument for a non-type, non-template
2825 template-parameter shall be one of:
2827 --an integral constant-expression of integral or enumeration
2828 type; or
2830 --the name of a non-type template-parameter; or
2832 --the name of an object or function with external linkage,
2833 including function templates and function template-ids but
2834 excluding non-static class members, expressed as id-expression;
2835 or
2837 --the address of an object or function with external linkage,
2838 including function templates and function template-ids but
2839 excluding non-static class members, expressed as & id-expression
2840 where the & is optional if the name refers to a function or
2841 array; or
2843 --a pointer to member expressed as described in _expr.unary.op_. */
2845 /* An integral constant-expression can include const variables or
2846 enumerators. Simplify things by folding them to their values,
2847 unless we're about to bind the declaration to a reference
2848 parameter. */
2854 /* OK for now. We'll check that it has external linkage later.
2855 Check this first since if expr_type is the unknown_type_node
2856 we would otherwise complain below. */
2857 ;
2860 {
2863 }
2868 /* If expr is the address of an overloaded function, we
2869 will get the unknown_type_node at this point. */
2871 {
2872 tree referent;
2880 else
2881 {
2883 {
2884 bad_argument:
2887 {
2890 else
2892 }
2898 }
2902 }
2905 {
2906 cp_error ("string literal %E is not a valid template argument because it is the address of an object with static linkage",
2907 referent);
2909 }
2912 /* We'll check that it has external linkage later. */
2913 ;
2917 {
2920 }
2921 }
2925 /* The next two are g++ extensions. */
2928 {
2930 {
2931 non_constant:
2933 expr);
2935 }
2936 }
2937 else
2938 {
2941 }
2944 {
2948 /* For a non-type template-parameter of integral or enumeration
2949 type, integral promotions (_conv.prom_) and integral
2950 conversions (_conv.integral_) are applied. */
2954 /* It's safe to call digest_init in this case; we know we're
2955 just converting one integral constant expression to another. */
2959 /* Curiously, some TREE_CONSTANT integral expressions do not
2960 simplify to integer constants. For example, `3 % 0',
2961 remains a TRUNC_MOD_EXPR. */
2968 /* These are g++ extensions. */
2980 {
2984 {
2985 tree e;
2987 /* For a non-type template-parameter of type pointer to data
2988 member, qualification conversions (_conv.qual_) are
2989 applied. */
2992 /* The call to perform_qualification_conversions will
2993 insert a NOP_EXPR over EXPR to do express conversion,
2994 if necessary. But, that will confuse us if we use
2995 this (converted) template parameter to instantiate
2996 another template; then the thing will not look like a
2997 valid template argument. So, just make a new
2998 constant, of the appropriate type. */
3001 }
3003 {
3004 /* For a non-type template-parameter of type pointer to
3005 function, only the function-to-pointer conversion
3006 (_conv.func_) is applied. If the template-argument
3007 represents a set of overloaded functions (or a pointer to
3008 such), the matching function is selected from the set
3009 (_over.over_). */
3010 tree fns;
3011 tree fn;
3015 else
3024 {
3027 else
3029 }
3036 }
3037 else
3038 {
3039 /* For a non-type template-parameter of type pointer to
3040 object, qualification conversions (_conv.qual_) and the
3041 array-to-pointer conversion (_conv.array_) are applied.
3042 [Note: In particular, neither the null pointer conversion
3043 (_conv.ptr_) nor the derived-to-base conversion
3044 (_conv.ptr_) are applied. Although 0 is a valid
3045 template-argument for a non-type template-parameter of
3046 integral type, it is not a valid template-argument for a
3047 non-type template-parameter of pointer type.]
3049 The call to decay_conversion performs the
3050 array-to-pointer conversion, if appropriate. */
3055 else
3057 }
3058 }
3062 {
3065 /* If this expression already has reference type, get the
3066 underling object. */
3068 {
3072 }
3075 {
3076 /* For a non-type template-parameter of type reference to
3077 function, no conversions apply. If the
3078 template-argument represents a set of overloaded
3079 functions, the matching function is selected from the
3080 set (_over.over_). */
3081 tree fn;
3089 {
3091 /* Don't issue an error here; we might get a different
3092 function if the overloading had worked out
3093 differently. */
3095 else
3097 }
3104 }
3105 else
3106 {
3107 /* For a non-type template-parameter of type reference to
3108 object, no conversions apply. The type referred to by the
3109 reference may be more cv-qualified than the (otherwise
3110 identical) type of the template-argument. The
3111 template-parameter is bound directly to the
3112 template-argument, which must be an lvalue. */
3116 expr_type)
3119 }
3123 }
3127 {
3130 /* For a non-type template-parameter of type pointer to member
3131 function, no conversions apply. If the template-argument
3132 represents a set of overloaded member functions, the
3133 matching member function is selected from the set
3134 (_over.over_). */
3141 {
3142 /* A ptr-to-member constant. */
3145 else
3147 }
3160 }
3164 /* All non-type parameters must have one of these types. */
3167 }
3170 }
3172 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3173 template template parameters. Both PARM_PARMS and ARG_PARMS are
3174 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3175 or PARM_DECL.
3177 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3178 the case, then extra parameters must have default arguments.
3180 Consider the example:
3181 template <class T, class Allocator = allocator> class vector;
3182 template<template <class U> class TT> class C;
3184 C<vector> is a valid instantiation. PARM_PARMS for the above code
3185 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3186 T and Allocator) and OUTER_ARGS contains the argument that is used to
3187 substitute the TT parameter. */
3189 static int
3195 {
3205 /* The rule here is opposite of coerce_template_parms. */
3212 {
3224 {
3229 /* We encounter instantiations of templates like
3230 template <template <template <class> class> class TT>
3231 class C; */
3232 {
3238 outer_args))
3240 }
3244 /* The tsubst call is used to handle cases such as
3245 template <class T, template <T> class TT> class D;
3246 i.e. the parameter list of TT depends on earlier parameters. */
3255 }
3256 }
3258 }
3260 /* Convert the indicated template ARG as necessary to match the
3261 indicated template PARM. Returns the converted ARG, or
3262 error_mark_node if the conversion was unsuccessful. Error messages
3263 are issued if COMPLAIN is non-zero. This conversion is for the Ith
3264 parameter in the parameter list. ARGS is the full set of template
3265 arguments deduced so far. */
3267 static tree
3269 tree parm;
3270 tree arg;
3271 tree args;
3274 tree in_decl;
3275 {
3276 tree val;
3277 tree inner_args;
3285 {
3286 /* The template argument was the name of some
3287 member function. That's usually
3288 illegal, but static members are OK. In any
3289 case, grab the underlying fields/functions
3290 and issue an error later if required. */
3293 }
3299 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true,
3300 we also accept implicitly created TYPE_DECL as a valid argument.
3301 This is necessary to handle the case where we pass a template name
3302 to a template template parameter in a scope where we've derived from
3303 in instantiation of that template, so the template name refers to that
3304 instantiation. We really ought to handle this better. */
3305 is_tmpl_type
3313 && requires_tmpl_type
3324 {
3329 complain);
3331 }
3333 {
3335 {
3337 {
3344 else
3346 }
3347 }
3349 }
3351 {
3353 {
3358 else
3360 }
3362 }
3365 {
3367 {
3373 {
3376 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3377 TEMPLATE_DECL. */
3381 }
3382 else
3383 {
3385 {
3389 }
3392 }
3393 }
3394 else
3395 {
3398 {
3399 /* [basic.link]: A name with no linkage (notably, the
3400 name of a class or enumeration declared in a local
3401 scope) shall not be used to declare an entity with
3402 linkage. This implies that names with no linkage
3403 cannot be used as template arguments. */
3406 {
3408 cp_pedwarn
3410 else
3411 cp_error
3415 }
3416 }
3417 }
3418 }
3419 else
3420 {
3430 /* We used to call digest_init here. However, digest_init
3431 will report errors, which we don't want when complain
3432 is zero. More importantly, digest_init will try too
3433 hard to convert things: for example, `0' should not be
3434 converted to pointer type at this point according to
3435 the standard. Accepting this is not merely an
3436 extension, since deciding whether or not these
3437 conversions can occur is part of determining which
3438 function template to call, or whether a given explicit
3439 argument specification is legal. */
3441 else
3449 }
3452 }
3454 /* Convert all template arguments to their appropriate types, and
3455 return a vector containing the innermost resulting template
3456 arguments. If any error occurs, return error_mark_node, and, if
3457 COMPLAIN is non-zero, issue an error message. Some error messages
3458 are issued even if COMPLAIN is zero; for instance, if a template
3459 argument is composed from a local class.
3461 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3462 provided in ARGLIST, or else trailing parameters must have default
3463 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3464 deduction for any unspecified trailing arguments. */
3466 static tree
3468 complain,
3469 require_all_arguments)
3471 tree in_decl;
3474 {
3476 tree inner_args;
3477 tree new_args;
3478 tree new_inner_args;
3486 && require_all_arguments
3488 {
3490 {
3496 }
3499 }
3504 {
3505 tree arg;
3506 tree parm;
3508 /* Get the Ith template parameter. */
3511 /* Calculate the Ith argument. */
3513 {
3516 }
3519 /* If no template argument was supplied, look for a default
3520 value. */
3522 {
3523 /* There was no default value. */
3526 }
3529 else
3531 in_decl);
3533 /* Now, convert the Ith argument, as necessary. */
3535 /* We're out of arguments. */
3536 {
3539 }
3541 {
3544 }
3545 else
3548 in_decl);
3551 lost++;
3553 }
3559 }
3561 /* Returns 1 if template args OT and NT are equivalent. */
3563 static int
3566 {
3571 /* For member templates */
3577 else
3579 }
3581 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3582 of template arguments. Returns 0 otherwise. */
3584 int
3587 {
3594 {
3600 }
3602 }
3604 /* Given class template name and parameter list, produce a user-friendly name
3605 for the instantiation. */
3611 {
3618 else
3622 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3623 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
3631 {
3639 {
3642 }
3644 {
3646 {
3647 /* Already substituted with real template. Just output
3648 the template name here */
3651 {
3652 /* The template may be defined in a namespace, or
3653 may be a member template. */
3659 }
3661 }
3662 else
3663 /* Output the parameter declaration */
3666 }
3667 else
3671 {
3672 /* New list cell was built because old chain link was in
3673 use. */
3676 }
3677 /* No need to check arglist against parmlist here; we did that
3678 in coerce_template_parms, called from lookup_template_class. */
3680 }
3681 {
3685 offset--;
3688 /* B<C<char> >, not B<C<char>> */
3691 }
3695 }
3697 static tree
3699 tree t;
3700 {
3702 /* Specializations have already had their names set up in
3703 lookup_template_class. */
3705 {
3708 /* For non-primary templates, the template parameters are
3709 implicit from their surrounding context. */
3711 {
3720 }
3721 }
3724 }
3726 static void
3728 tree d;
3729 {
3738 /* We are called both from instantiate_decl, where we've already had a
3739 tinst_level pushed, and instantiate_template, where we haven't.
3740 Compensate. */
3752 }
3755 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3756 may be either a _DECL or an overloaded function or an
3757 IDENTIFIER_NODE), and ARGLIST. */
3759 tree
3762 {
3763 tree type;
3766 {
3769 }
3777 else
3779 }
3781 /* Within the scope of a template class S<T>, the name S gets bound
3782 (in build_self_reference) to a TYPE_DECL for the class, not a
3783 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3784 or one of its enclosing classes, and that type is a template,
3785 return the associated TEMPLATE_DECL. Otherwise, the original
3786 DECL is returned. */
3788 static tree
3790 tree decl;
3791 {
3798 }
3800 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3801 parameters, find the desired type.
3803 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3804 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3805 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3806 otherwise.)
3808 IN_DECL, if non-NULL, is the template declaration we are trying to
3809 instantiate.
3811 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3812 the class we are looking up.
3814 If COMPLAIN is non-zero, issue error messages.
3816 If the template class is really a local class in a template
3817 function, then the FUNCTION_CONTEXT is the function in which it is
3818 being instantiated. */
3820 tree
3823 tree in_decl;
3824 tree context;
3827 {
3829 tree t;
3832 {
3836 else
3837 {
3844 }
3847 }
3849 {
3852 /* If we are declaring a constructor, say A<T>::A<T>, we will get
3853 an implicit typename for the second A. Deal with it. */
3858 {
3861 }
3862 }
3865 {
3868 }
3871 {
3875 }
3877 /* With something like `template <class T> class X class X { ... };'
3878 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3879 We don't want to do that, but we have to deal with the situation,
3880 so let's give them some syntax errors to chew on instead of a
3881 crash. Alternatively D1 might not be a template type at all. */
3883 {
3887 }
3890 /* If we're called from the parser, make sure it's a user visible
3891 template. */
3895 {
3897 {
3901 }
3903 }
3906 {
3907 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3908 template arguments */
3910 tree parm;
3911 tree arglist2;
3923 }
3924 else
3925 {
3927 tree gen_tmpl;
3928 tree type_decl;
3941 {
3942 /* We've been given an incomplete set of template arguments.
3943 For example, given:
3945 template <class T> struct S1 {
3946 template <class U> struct S2 {};
3947 template <class U> struct S2<U*> {};
3948 };
3950 we will be called with an ARGLIST of `U*', but the
3951 TEMPLATE will be `template <class T> template
3952 <class U> struct S1<T>::S2'. We must fill in the missing
3953 arguments. */
3954 arglist
3956 arglist);
3958 }
3960 /* Now we should enough arguments. */
3963 /* From here on, we're only interested in the most general
3964 template. */
3967 /* Calculate the BOUND_ARGS. These will be the args that are
3968 actually tsubst'd into the definition to create the
3969 instantiation. */
3971 {
3972 /* We have multiple levels of arguments to coerce, at once. */
3982 {
3988 /* We temporarily reduce the length of the ARGLIST so
3989 that coerce_template_parms will see only the arguments
3990 corresponding to the template parameters it is
3991 examining. */
3993 }
3995 /* Restore the ARGLIST to its full size. */
3999 }
4000 else
4001 arglist
4008 /* We were unable to bind the arguments. */
4011 /* In the scope of a template class, explicit references to the
4012 template class refer to the type of the template, not any
4013 instantiation of it. For example, in:
4015 template <class T> class C { void f(C<T>); }
4017 the `C<T>' is just the same as `C'. Outside of the
4018 class, however, such a reference is an instantiation. */
4020 arglist))
4021 {
4025 {
4026 tree ctx;
4028 /* Note that we use DECL_CONTEXT, rather than
4029 CP_DECL_CONTEXT, so that the termination test is
4030 always just `ctx'. We're not interested in namespace
4031 scopes. */
4033 ctx;
4039 /* We're not in the scope of the class, so the
4040 TEMPLATE_TYPE is not the type we want after
4041 all. */
4043 }
4044 }
4052 {
4055 /* Use the move-to-front heuristic to speed up future
4056 searches. */
4063 }
4065 /* This type is a "partial instantiation" if any of the template
4066 arguments still involve template parameters. Note that we set
4067 IS_PARTIAL_INSTANTIATION for partial specializations as
4068 well. */
4074 {
4079 }
4086 /* Create the type. */
4088 {
4090 {
4093 }
4094 else
4095 /* We don't want to call start_enum for this type, since
4096 the values for the enumeration constants may involve
4097 template parameters. And, no one should be interested
4098 in the enumeration constants for such a type. */
4100 }
4101 else
4102 {
4110 /* A local class. Make sure the decl gets registered properly. */
4113 }
4115 /* If we called start_enum or pushtag above, this information
4116 will already be set up. */
4118 {
4128 }
4129 else
4132 /* Set up the template information. We have to figure out which
4133 template is the immediate parent if this is a full
4134 instantiation. */
4137 /* This case is easy; there are no member templates involved. */
4139 else
4140 {
4141 /* This is a full instantiation of a member template. Look
4142 for a partial instantiation of which this is an instance. */
4146 {
4150 /* We only want partial instantiations, here, not
4151 specializations or full instantiations. */
4156 /* Temporarily reduce by one the number of levels in the
4157 ARGLIST and in FOUND so as to avoid comparing the
4158 last set of arguments. */
4162 /* See if the arguments match. If they do, then TMPL is
4163 the partial instantiation we want. */
4166 /* Restore the argument vectors to their full size. */
4171 {
4174 }
4175 }
4178 {
4179 /* There was no partial instantiation. This happens
4180 where C<T> is a member template of A<T> and it's used
4181 in something like
4183 template <typename T> struct B { A<T>::C<int> m; };
4184 B<float>;
4186 Create the partial instantiation.
4187 */
4192 }
4193 }
4202 /* Now that the type has been registered on the instantiations
4203 list, we set up the enumerators. Because the enumeration
4204 constants may involve the enumeration type itself, we make
4205 sure to register the type first, and then create the
4206 constants. That way, doing tsubst_expr for the enumeration
4207 constants won't result in recursive calls here; we'll find
4208 the instantiation and exit above. */
4211 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4212 is set up. */
4216 {
4217 /* For backwards compatibility; code that uses
4218 -fexternal-templates expects looking up a template to
4219 instantiate it. I think DDD still relies on this.
4220 (jason 8/20/1998) */
4222 && flag_external_templates
4226 }
4227 else
4228 /* If the type makes use of template parameters, the
4229 code that generates debugging information will crash. */
4233 }
4234 }
4235 \f
4236 struct pair_fn_data
4237 {
4238 tree_fn_t fn;
4240 };
4242 /* Called from for_each_template_parm via walk_tree. */
4244 static tree
4249 {
4260 {
4264 /* Fall through. */
4276 /* Since we're not going to walk subtrees, we have to do this
4277 explicitly here. */
4280 /* Fall through. */
4283 /* Check the return type. */
4287 /* Check the parameter types. Since default arguments are not
4288 instantiated until they are needed, the TYPE_ARG_TYPES may
4289 contain expressions that involve template parameters. But,
4290 no-one should be looking at them yet. And, once they're
4291 instantiated, they don't contain template parameters, so
4292 there's no point in looking at them then, either. */
4293 {
4294 tree parm;
4300 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4301 want walk_tree walking into them itself. */
4303 }
4311 /* Fall through. */
4321 /* Record template parameters such as `T' inside `TT<T>'. */
4324 /* Fall through. */
4336 /* A template template parameter is encountered */
4341 /* Already substituted template template parameter */
4359 /* If there's no type, then this thing must be some expression
4360 involving template parameters. */
4382 }
4384 /* We didn't find any template parameters we liked. */
4386 }
4388 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4389 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4390 call FN with the parameter and the DATA.
4391 If FN returns non-zero, the iteration is terminated, and
4392 for_each_template_parm returns 1. Otherwise, the iteration
4393 continues. If FN never returns a non-zero value, the value
4394 returned by for_each_template_parm is 0. If FN is NULL, it is
4395 considered to be the function which always returns 1. */
4397 static int
4399 tree t;
4400 tree_fn_t fn;
4402 {
4405 /* Set up. */
4409 /* Walk the tree. (Conceptually, we would like to walk without
4410 duplicates, but for_each_template_parm_r recursively calls
4411 for_each_template_parm, so we would need to reorganize a fair
4412 bit to use walk_tree_without_duplicates.) */
4414 for_each_template_parm_r,
4417 }
4419 int
4421 tree t;
4422 {
4424 }
4428 #ifdef GATHER_STATISTICS
4430 #endif
4434 /* We're starting to instantiate D; record the template instantiation context
4435 for diagnostics and to restore it later. */
4437 static int
4439 tree d;
4440 {
4444 {
4445 /* If the instantiation in question still has unbound template parms,
4446 we don't really care if we can't instantiate it, so just return.
4447 This happens with base instantiation for implicit `typename'. */
4452 cp_error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
4458 }
4465 #ifdef GATHER_STATISTICS
4468 #endif
4472 }
4474 /* We're done instantiating this template; return to the instantiation
4475 context. */
4477 void
4479 {
4482 /* Restore the filename and line number stashed away when we started
4483 this instantiation. */
4491 }
4493 /* We're instantiating a deferred template; restore the template
4494 instantiation context in which the instantiation was requested, which
4495 is one step out from LEVEL. */
4497 static void
4499 tree level;
4500 {
4501 tree t;
4509 }
4511 /* Return the outermost template instantiation context, for use with
4512 -falt-external-templates. */
4514 tree
4516 {
4521 ;
4523 }
4525 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4526 vector of template arguments, as for tsubst.
4528 Returns an appropriate tsubst'd friend declaration. */
4530 static tree
4532 tree decl;
4533 tree args;
4534 {
4535 tree new_friend;
4545 /* This was a friend declared with an explicit template
4546 argument list, e.g.:
4548 friend void f<>(T);
4550 to indicate that f was a template instantiation, not a new
4551 function declaration. Now, we have to figure out what
4552 instantiation of what template. */
4553 {
4555 tree new_args;
4556 tree tmpl;
4559 /* Friend functions are looked up in the containing namespace scope.
4560 We must enter that scope, to avoid finding member functions of the
4561 current cless with same name. */
4576 }
4580 /* The NEW_FRIEND will look like an instantiation, to the
4581 compiler, but is not an instantiation from the point of view of
4582 the language. For example, we might have had:
4584 template <class T> struct S {
4585 template <class U> friend void f(T, U);
4586 };
4588 Then, in S<int>, template <class U> void f(int, U) is not an
4589 instantiation of anything. */
4592 {
4596 }
4598 /* The mangled name for the NEW_FRIEND is incorrect. The function
4599 is not a template instantiation and should not be mangled like
4600 one. Therefore, we forget the mangling here; we'll recompute it
4601 later if we need it. */
4603 {
4606 }
4609 {
4610 tree old_decl;
4611 tree new_friend_template_info;
4612 tree new_friend_result_template_info;
4613 tree ns;
4616 /* We must save some information from NEW_FRIEND before calling
4617 duplicate decls since that function will free NEW_FRIEND if
4618 possible. */
4621 {
4622 /* This declaration is a `primary' template. */
4625 new_friend_is_defn
4627 new_friend_result_template_info
4629 }
4630 else
4631 {
4634 }
4636 /* Inside pushdecl_namespace_level, we will push into the
4637 current namespace. However, the friend function should go
4638 into the namespace of the template. */
4645 {
4646 /* This new friend declaration matched an existing
4647 declaration. For example, given:
4649 template <class T> void f(T);
4650 template <class U> class C {
4651 template <class T> friend void f(T) {}
4652 };
4654 the friend declaration actually provides the definition
4655 of `f', once C has been instantiated for some type. So,
4656 old_decl will be the out-of-class template declaration,
4657 while new_friend is the in-class definition.
4659 But, if `f' was called before this point, the
4660 instantiation of `f' will have DECL_TI_ARGS corresponding
4661 to `T' but not to `U', references to which might appear
4662 in the definition of `f'. Previously, the most general
4663 template for an instantiation of `f' was the out-of-class
4664 version; now it is the in-class version. Therefore, we
4665 run through all specialization of `f', adding to their
4666 DECL_TI_ARGS appropriately. In particular, they need a
4667 new set of outer arguments, corresponding to the
4668 arguments for this class instantiation.
4670 The same situation can arise with something like this:
4672 friend void f(int);
4673 template <class T> class C {
4674 friend void f(T) {}
4675 };
4677 when `C<int>' is instantiated. Now, `f(int)' is defined
4678 in the class. */
4681 /* On the other hand, if the in-class declaration does
4682 *not* provide a definition, then we don't want to alter
4683 existing definitions. We can just leave everything
4684 alone. */
4685 ;
4686 else
4687 {
4688 /* Overwrite whatever template info was there before, if
4689 any, with the new template information pertaining to
4690 the declaration. */
4694 /* duplicate_decls will take care of this case. */
4695 ;
4696 else
4697 {
4698 tree t;
4699 tree new_friend_args;
4708 {
4714 }
4716 /* Now, since specializations are always supposed to
4717 hang off of the most general template, we must move
4718 them. */
4721 {
4726 }
4727 }
4728 }
4730 /* The information from NEW_FRIEND has been merged into OLD_DECL
4731 by duplicate_decls. */
4733 }
4734 }
4736 {
4737 /* Check to see that the declaration is really present, and,
4738 possibly obtain an improved declaration. */
4740 new_friend);
4744 }
4746 done:
4750 }
4752 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4753 template arguments, as for tsubst.
4755 Returns an appropriate tsubst'd friend type or error_mark_node on
4756 failure. */
4758 static tree
4760 tree friend_tmpl;
4761 tree args;
4762 {
4763 tree friend_type;
4764 tree tmpl;
4766 /* First, we look for a class template. */
4769 /* But, if we don't find one, it might be because we're in a
4770 situation like this:
4772 template <class T>
4773 struct S {
4774 template <class U>
4775 friend struct S;
4776 };
4778 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
4779 for `S<int>', not the TEMPLATE_DECL. */
4781 {
4784 }
4787 {
4788 /* The friend template has already been declared. Just
4789 check to see that the declarations match, and install any new
4790 default parameters. We must tsubst the default parameters,
4791 of course. We only need the innermost template parameters
4792 because that is all that redeclare_class_template will look
4793 at. */
4794 tree parms
4801 }
4802 else
4803 {
4804 /* The friend template has not already been declared. In this
4805 case, the instantiation of the template class will cause the
4806 injection of this template into the global scope. */
4809 /* The new TMPL is not an instantiation of anything, so we
4810 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4811 the new type because that is supposed to be the corresponding
4812 template decl, i.e., TMPL. */
4817 /* Inject this template into the global scope. */
4819 }
4822 }
4824 tree
4826 tree type;
4827 {
4829 tree typedecl;
4837 /* Figure out which template is being instantiated. */
4841 /* Figure out which arguments are being used to do the
4842 instantiation. */
4847 /* If this is a partial instantiation, then we can't instantiate
4848 the type; there's no telling whether or not one of the
4849 template parameters might eventually be instantiated to some
4850 value that results in a specialization being used. For
4851 example, consider:
4853 template <class T>
4854 struct S {};
4856 template <class U>
4857 void f(S<U>);
4859 template <>
4860 struct S<int> {};
4862 Now, the `S<U>' in `f<int>' is the specialization, not an
4863 instantiation of the original template. */
4866 /* Determine what specialization of the original template to
4867 instantiate. */
4869 /* There's no telling which specialization is appropriate at this
4870 point. Since all peeking at the innards of this partial
4871 instantiation are extensions (like the "implicit typename"
4872 extension, which allows users to omit the keyword `typename' on
4873 names that are declared as types in template base classes), we
4874 are free to do what we please.
4876 Trying to figure out which partial instantiation to use can
4877 cause a crash. (Some of the template arguments don't even have
4878 types.) So, we just use the most general version. */
4880 else
4881 {
4885 {
4890 {
4892 args))
4893 {
4896 }
4897 }
4900 }
4901 }
4905 else
4908 /* If the template we're instantiating is incomplete, then clearly
4909 there's nothing we can do. */
4913 /* If this is a partial instantiation, don't tsubst anything. We will
4914 only use this type for implicit typename, so the actual contents don't
4915 matter. All that matters is whether a particular name is a type. */
4917 {
4918 /* The fields set here must be kept in sync with those cleared
4919 in begin_class_definition. */
4926 /* Pretend that the type is complete, so that we will look
4927 inside it during name lookup and such. */
4930 }
4932 /* If we've recursively instantiated too many templates, stop. */
4936 /* Now we're really doing the instantiation. Mark the type as in
4937 the process of being defined. */
4943 {
4944 /* This TYPE is actually a instantiation of of a partial
4945 specialization. We replace the innermost set of ARGS with
4946 the arguments appropriate for substitution. For example,
4947 given:
4949 template <class T> struct S {};
4950 template <class T> struct S<T*> {};
4952 and supposing that we are instantiating S<int*>, ARGS will
4953 present be {int*} but we need {int}. */
4954 tree inner_args
4956 args);
4958 /* If there were multiple levels in ARGS, replacing the
4959 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4960 want, so we make a copy first. */
4962 {
4965 }
4966 else
4968 }
4971 {
4973 {
4979 }
4980 else
4981 {
4983 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
4988 }
4989 }
4990 else
4991 {
4994 }
5026 {
5031 /* Substitute into each of the bases to determine the actual
5032 basetypes. */
5034 {
5035 tree base;
5036 tree access;
5037 tree pbase;
5041 /* Substitute to figure out the base class. */
5047 /* Calculate the correct access node. */
5049 {
5054 else
5056 }
5057 else
5058 {
5063 else
5065 }
5068 }
5070 /* The list is now in reverse order; correct that. */
5073 /* Now call xref_basetypes to set up all the base-class
5074 information. */
5080 type,
5081 base_list);
5082 }
5084 /* Now that our base classes are set up, enter the scope of the
5085 class, so that name lookups into base classes, etc. will work
5086 correctly. This is precisely analogous to what we do in
5087 begin_class_definition when defining an ordinary non-template
5088 class. */
5092 {
5095 tree newtag;
5100 {
5102 /* Unfortunately, lookup_template_class sets
5103 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5104 instantiation (i.e., for the type of a member template
5105 class nested within a template class.) This behavior is
5106 required for maybe_process_partial_specialization to work
5107 correctly, but is not accurate in this case; the TAG is not
5108 an instantiation of anything. (The corresponding
5109 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
5112 /* Now, we call pushtag to put this NEWTAG into the scope of
5113 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5114 pushtag calling push_template_decl. We don't have to do
5115 this for enums because it will already have been done in
5116 tsubst_enum. */
5120 }
5121 }
5123 /* Don't replace enum constants here. */
5126 {
5127 tree r;
5129 /* The the file and line for this declaration, to assist in
5130 error message reporting. Since we called push_tinst_level
5131 above, we don't need to restore these. */
5137 {
5138 tree init;
5143 else
5152 }
5154 /* R will have a TREE_CHAIN if and only if it has already been
5155 processed by finish_member_declaration. This can happen
5156 if, for example, it is a TYPE_DECL for a class-scoped
5157 ENUMERAL_TYPE; such a thing will already have been added to
5158 the field list by tsubst_enum above. */
5160 {
5163 }
5164 }
5166 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
5167 for this instantiation. */
5169 {
5173 }
5175 /* Construct the DECL_FRIENDLIST for the new class type. */
5180 {
5181 tree friends;
5189 args));
5190 else
5192 }
5197 {
5199 tree new_friend_type;
5205 NULL_TREE);
5206 else
5207 {
5210 /* The call to xref_tag_from_type does injection for friend
5211 classes. */
5213 new_friend_type =
5216 }
5219 /* Trick make_friend_class into realizing that the friend
5220 we're adding is a template, not an ordinary class. It's
5221 important that we use make_friend_class since it will
5222 perform some error-checking and output cross-reference
5223 information. */
5231 }
5235 {
5238 }
5240 /* Set the file and line number information to whatever is given for
5241 the class itself. This puts error messages involving generated
5242 implicit functions at a predictable point, and the same point
5243 that would be used for non-template classes. */
5251 /* Clear this now so repo_template_used is happy. */
5255 /* Now that the class is complete, instantiate default arguments for
5256 any member functions. We don't do this earlier because the
5257 default arguments may reference members of the class. */
5261 /* Implicitly generated member functions will not have template
5262 information; they are not instantiations, but instead are
5263 created "fresh" for each instantiation. */
5272 }
5274 static int
5277 {
5282 /* Don't care if one declares its arg const and the other doesn't -- the
5283 main variant of the arg type is all that matters. */
5288 }
5290 /* If arg is a non-type template parameter that does not depend on template
5291 arguments, fold it like we weren't in the body of a template. */
5293 static tree
5295 tree arg;
5296 {
5297 /* If we're not in a template, ARG is already as simple as it's going to
5298 get, and trying to reprocess the trees will break. */
5303 {
5304 /* Sometimes, one of the args was an expression involving a
5305 template constant parameter, like N - 1. Now that we've
5306 tsubst'd, we might have something like 2 - 1. This will
5307 confuse lookup_template_class, so we do constant folding
5308 here. We have to unset processing_template_decl, to
5309 fool build_expr_from_tree() into building an actual
5310 tree. */
5316 }
5318 }
5320 /* Substitute ARGS into the vector of template arguments T. */
5322 static tree
5324 tree t;
5325 tree args;
5327 {
5334 {
5339 else
5342 NULL_TREE));
5349 }
5359 }
5361 /* Return the result of substituting ARGS into the template parameters
5362 given by PARMS. If there are m levels of ARGS and m + n levels of
5363 PARMS, then the result will contain n levels of PARMS. For
5364 example, if PARMS is `template <class T> template <class U>
5365 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5366 result will be `template <int*, double, class V>'. */
5368 static tree
5370 tree parms;
5371 tree args;
5373 {
5381 {
5382 tree new_vec =
5387 {
5388 tree default_value =
5390 tree parm_decl =
5395 NULL_TREE),
5397 NULL_TREE));
5398 }
5404 }
5407 }
5409 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5410 type T. If T is not an aggregate or enumeration type, it is
5411 handled as if by tsubst. IN_DECL is as for tsubst. If
5412 ENTERING_SCOPE is non-zero, T is the context for a template which
5413 we are presently tsubst'ing. Return the substituted value. */
5415 static tree
5417 tree t;
5418 tree args;
5420 tree in_decl;
5422 {
5427 {
5430 {
5431 tree r = build_ptrmemfunc_type
5434 complain);
5435 }
5437 /* else fall through */
5441 {
5442 tree argvec;
5443 tree context;
5444 tree r;
5446 /* First, determine the context for the type we are looking
5447 up. */
5450 complain,
5452 else
5455 /* Then, figure out what arguments are appropriate for the
5456 type we are trying to find. For example, given:
5458 template <class T> struct S;
5459 template <class T, class U> void f(T, U) { S<U> su; }
5461 and supposing that we are instantiating f<int, double>,
5462 then our ARGS will be {int, double}, but, when looking up
5463 S we only want {double}. */
5465 complain);
5473 complain);
5474 }
5475 else
5476 /* This is not a template type, so there's nothing to do. */
5481 }
5482 }
5484 /* Substitute into the default argument ARG (a default argument for
5485 FN), which has the indicated TYPE. */
5487 tree
5489 tree fn;
5490 tree type;
5491 tree arg;
5492 {
5493 /* This default argument came from a template. Instantiate the
5494 default argument here, not in tsubst. In the case of
5495 something like:
5497 template <class T>
5498 struct S {
5499 static T t();
5500 void f(T = t());
5501 };
5503 we must be careful to do name lookup in the scope of S<T>,
5504 rather than in the current class. */
5513 /* Make sure the default argument is reasonable. */
5517 }
5519 /* Substitute into all the default arguments for FN. */
5521 static void
5523 tree fn;
5524 {
5525 tree arg;
5526 tree tmpl_args;
5530 /* If this function is not yet instantiated, we certainly don't need
5531 its default arguments. */
5536 arg;
5542 }
5544 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5545 (already computed) substitution of ARGS into TREE_TYPE (T), if
5546 appropriate. Return the result of the substitution. */
5548 static tree
5550 tree t;
5551 tree args;
5552 tree type;
5553 {
5559 /* Set the filename and linenumber to improve error-reporting. */
5566 {
5568 {
5569 /* We can get here when processing a member template function
5570 of a template class. */
5572 tree spec;
5576 {
5577 /* We might already have an instance of this template.
5578 The ARGS are for the surrounding class type, so the
5579 full args contain the tsubst'd args for the context,
5580 plus the innermost args from the template decl. */
5584 tree full_args;
5589 /* tsubst_template_arg_vector doesn't copy the vector if
5590 nothing changed. But, *something* should have
5591 changed. */
5596 {
5599 }
5600 }
5602 /* Make a new template decl. It will be similar to the
5603 original, but will record the current template arguments.
5604 We also create a new function declaration, which is just
5605 like the old one, but points to this new template, rather
5606 than the old one. */
5612 {
5617 }
5630 {
5637 }
5638 else
5639 {
5646 }
5652 /* The template parameters for this new template are all the
5653 template parameters for the old template, except the
5654 outermost level of parameters. */
5662 /* We don't partially instantiate partial specializations. */
5666 /* Record this partial instantiation. */
5670 }
5674 {
5675 tree ctx;
5678 tree gen_tmpl;
5683 /* Nobody should be tsubst'ing into non-template functions. */
5687 {
5688 tree spec;
5690 /* Calculate the most general template of which R is a
5691 specialization, and the complete set of arguments used to
5692 specialize R. */
5694 argvec
5699 /* Check to see if we already have this specialization. */
5703 {
5706 }
5708 /* We can see more levels of arguments than parameters if
5709 there was a specialization of a member template, like
5710 this:
5712 template <class T> struct S { template <class U> void f(); }
5713 template <> template <class U> void S<int>::f(U);
5715 Here, we'll be substituting into the specialization,
5716 because that's where we can find the code we actually
5717 want to generate, but we'll have enough arguments for
5718 the most general template.
5720 We also deal with the peculiar case:
5722 template <class T> struct S {
5723 template <class U> friend void f();
5724 };
5725 template <class U> void f() {}
5726 template S<int>;
5727 template void f<double>();
5729 Here, the ARGS for the instantiation of will be {int,
5730 double}. But, we only need as many ARGS as there are
5731 levels of template parameters in CODE_PATTERN. We are
5732 careful not to get fooled into reducing the ARGS in
5733 situations like:
5735 template <class T> struct S { template <class U> void f(U); }
5736 template <class T> template <> void S<T>::f(int) {}
5738 which we can spot because the pattern will be a
5739 specialization in this case. */
5741 parms_depth =
5746 }
5747 else
5748 {
5749 /* This special case arises when we have something like this:
5751 template <class T> struct S {
5752 friend void f<int>(int, double);
5753 };
5755 Here, the DECL_TI_TEMPLATE for the friend declaration
5756 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5757 being called from tsubst_friend_function, and we want
5758 only to create a new decl (R) with appropriate types so
5759 that we can call determine_specialization. */
5765 }
5768 {
5771 else
5776 }
5777 else
5778 {
5781 }
5786 /* We do NOT check for matching decls pushed separately at this
5787 point, as they may not represent instantiations of this
5788 template, and in any case are considered separate under the
5789 discrete model. */
5793 /* Clear out the mangled name and RTL for the instantiation. */
5804 /* Type-conversion operator. Reconstruct the name, in
5805 case it's the name of one of the template's parameters. */
5823 {
5828 }
5830 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
5831 this in the special friend case mentioned above where
5832 GEN_TMPL is NULL. */
5834 {
5840 /* We're not supposed to instantiate default arguments
5841 until they are called, for a template. But, for a
5842 declaration like:
5844 template <class T> void f ()
5845 { extern void g(int i = T()); }
5847 we should do the substitution when the template is
5848 instantiated. We handle the member function case in
5849 instantiate_class_template since the default arguments
5850 might refer to other members of the class. */
5855 }
5857 /* Copy the list of befriending classes. */
5861 {
5865 in_decl);
5866 }
5869 {
5873 /* If this is an instantiation of a member template, clone it.
5874 If it isn't, that'll be handled by
5875 clone_constructors_and_destructors. */
5878 }
5881 }
5885 {
5892 else
5904 }
5908 {
5913 /* We don't have to set DECL_CONTEXT here; it is set by
5914 finish_member_declaration. */
5920 }
5924 {
5929 }
5935 {
5936 /* If this is the canonical decl, we don't have to mess with
5937 instantiations, and often we can't (for typename, template
5938 type parms and such). Note that TYPE_NAME is not correct for
5939 the above test if we've copied the type for a typedef. */
5942 }
5944 /* Fall through. */
5947 {
5950 tree spec;
5952 tree ctx;
5955 /* Assume this is a non-local variable. */
5964 else
5965 {
5966 /* Subsequent calls to pushdecl will fill this in. */
5969 }
5971 /* Check to see if we already have this specialization. */
5973 {
5978 }
5979 else
5983 {
5986 }
5992 /* Clear out the mangled name and RTL for the instantiation. */
5996 /* Don't try to expand the initializer until someone tries to use
5997 this variable; otherwise we run into circular dependencies. */
6002 /* For __PRETTY_FUNCTION__ we have to adjust the initializer. */
6004 {
6006 args,
6008 NULL_TREE);
6010 }
6012 /* Even if the original location is out of scope, the newly
6013 substituted one is not. */
6018 {
6019 /* A static data member declaration is always marked
6020 external when it is declared in-class, even if an
6021 initializer is present. We mimic the non-template
6022 processing here. */
6028 }
6029 else
6035 }
6040 }
6042 /* Restore the file and line information. */
6047 }
6049 /* Substitue into the ARG_TYPES of a function type. */
6051 static tree
6053 tree arg_types;
6054 tree args;
6056 tree in_decl;
6057 {
6058 tree remaining_arg_types;
6059 tree type;
6073 {
6075 {
6079 }
6081 }
6083 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6084 top-level qualifiers as required. */
6087 /* Note that we do not substitute into default arguments here. The
6088 standard mandates that they be instantiated only when needed,
6089 which is done in build_over_call. */
6091 remaining_arg_types);
6093 }
6095 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6096 *not* handle the exception-specification for FNTYPE, because the
6097 initial substitution of explicitly provided template parameters
6098 during argument deduction forbids substitution into the
6099 exception-specification:
6101 [temp.deduct]
6103 All references in the function type of the function template to the
6104 corresponding template parameters are replaced by the specified tem-
6105 plate argument values. If a substitution in a template parameter or
6106 in the function type of the function template results in an invalid
6107 type, type deduction fails. [Note: The equivalent substitution in
6108 exception specifications is done only when the function is instanti-
6109 ated, at which point a program is ill-formed if the substitution
6110 results in an invalid type.] */
6112 static tree
6114 tree t;
6115 tree args;
6117 tree in_decl;
6118 {
6119 tree return_type;
6120 tree arg_types;
6121 tree fntype;
6123 /* The TYPE_CONTEXT is not used for function/method types. */
6126 /* Substitue the return type. */
6131 /* Substitue the argument types. */
6137 /* Construct a new type node and return it. */
6140 else
6141 {
6144 {
6145 /* [temp.deduct]
6147 Type deduction may fail for any of the following
6148 reasons:
6150 -- Attempting to create "pointer to member of T" when T
6151 is not a class type. */
6154 r);
6156 }
6160 }
6165 }
6167 /* Substitute into the PARMS of a call-declarator. */
6169 static tree
6171 tree parms;
6172 tree args;
6174 tree in_decl;
6175 {
6176 tree new_parms;
6177 tree type;
6178 tree defarg;
6186 /* Figure out the type of this parameter. */
6189 /* Figure out the default argument as well. Note that we use
6190 tsubst_expr since the default argument is really an expression. */
6193 /* Chain this parameter on to the front of those we have already
6194 processed. We don't use hash_tree_cons because that function
6195 doesn't check TREE_PARMLIST. */
6198 /* And note that these are parameters. */
6202 }
6204 /* Take the tree structure T and replace template parameters used
6205 therein with the argument vector ARGS. IN_DECL is an associated
6206 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6207 An appropriate error message is issued only if COMPLAIN is
6208 non-zero. Note that we must be relatively non-tolerant of
6209 extensions here, in order to preserve conformance; if we allow
6210 substitutions that should not be allowed, we may allow argument
6211 deductions that should not succeed, and therefore report ambiguous
6212 overload situations where there are none. In theory, we could
6213 allow the substitution, but indicate that it should have failed,
6214 and allow our caller to make sure that the right thing happens, but
6215 we don't try to do this yet.
6217 This function is used for dealing with types, decls and the like;
6218 for expressions, use tsubst_expr or tsubst_copy. */
6220 tree
6224 tree in_decl;
6225 {
6237 else
6256 {
6284 {
6291 /* See if we can reduce this expression to something simpler. */
6297 /* When providing explicit arguments to a template
6298 function, but leaving some arguments for subsequent
6299 deduction, MAX may be template-dependent even if we're
6300 not PROCESSING_TEMPLATE_DECL. We still need to check for
6301 template parms, though; MAX won't be an INTEGER_CST for
6302 dynamic arrays, either. */
6305 {
6309 integer_one_node);
6311 }
6314 {
6315 /* Still allow an explicit array of size zero. */
6318 }
6322 {
6323 /* [temp.deduct]
6325 Type deduction may fail for any of the following
6326 reasons:
6328 Attempting to create an array with a size that is
6329 zero or negative. */
6334 }
6337 }
6343 {
6353 {
6356 }
6357 else
6358 {
6361 }
6364 {
6374 {
6376 {
6378 return cp_build_qualified_type_real
6380 complain);
6381 }
6383 {
6384 /* We are processing a type constructed from
6385 a template template parameter */
6391 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6392 we are resolving nested-types in the signature of
6393 a member function templates.
6394 Otherwise ARG is a TEMPLATE_DECL and is the real
6395 template to be instantiated. */
6403 complain);
6406 complain);
6407 }
6408 else
6409 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
6411 }
6412 }
6413 else
6417 /* This can happen during the attempted tsubst'ing in
6418 unify. This means that we don't yet have any information
6419 about the template parameter in question. */
6422 /* If we get here, we must have been looking at a parm for a
6423 more deeply nested template. Make a new version of this
6424 template parameter, but with a lower level. */
6426 {
6431 {
6434 complain);
6435 }
6436 else
6437 {
6448 {
6456 }
6457 }
6466 }
6469 }
6472 {
6480 {
6484 }
6487 {
6491 }
6494 {
6498 }
6504 {
6507 }
6508 else
6511 }
6514 {
6515 /* A binfo node. We always need to make a copy, of the node
6516 itself and of its BINFO_BASETYPES. */
6520 /* Make sure type isn't a typedef copy. */
6525 {
6530 }
6532 }
6534 /* Otherwise, a vector of template arguments. */
6539 {
6548 /* [temp.deduct]
6550 Type deduction may fail for any of the following
6551 reasons:
6553 -- Attempting to create a pointer to reference type.
6554 -- Attempting to create a reference to a reference type or
6555 a reference to void. */
6558 {
6562 /* We keep track of the last time we issued this error
6563 message to avoid spewing a ton of messages during a
6564 single bad template instantiation. */
6567 {
6570 else
6573 type);
6576 }
6579 }
6582 else
6587 /* Will this ever be needed for TYPE_..._TO values? */
6591 }
6593 {
6596 {
6597 /* [temp.deduct]
6599 Type deduction may fail for any of the following
6600 reasons:
6602 -- Attempting to create "pointer to member of T" when T
6603 is not a class type. */
6606 r);
6608 }
6610 }
6613 {
6614 tree fntype;
6615 tree raises;
6621 /* Substitue the exception specification. */
6624 {
6629 else
6631 {
6638 }
6640 }
6642 }
6644 {
6649 /* As an optimization, we avoid regenerating the array type if
6650 it will obviously be the same as T. */
6654 /* These checks should match the ones in grokdeclarator.
6656 [temp.deduct]
6658 The deduction may fail for any of the following reasons:
6660 -- Attempting to create an array with an element type that
6661 is void, a function type, or a reference type. */
6665 {
6669 }
6673 }
6677 {
6679 in_decl);
6681 in_decl);
6687 }
6691 {
6693 in_decl);
6698 }
6701 {
6711 {
6714 ctx);
6716 }
6718 {
6719 /* Normally, make_typename_type does not require that the CTX
6720 have complete type in order to allow things like:
6722 template <class T> struct S { typename S<T>::X Y; };
6724 But, such constructs have already been resolved by this
6725 point, so here CTX really should have complete type, unless
6726 it's a partial instantiation. */
6729 {
6733 }
6734 }
6742 complain);
6743 }
6746 {
6748 in_decl);
6752 }
6755 {
6757 in_decl);
6761 }
6764 {
6766 in_decl);
6768 in_decl);
6773 }
6776 {
6778 in_decl);
6779 tree e2 = (tsubst_call_declarator_parms
6789 }
6792 {
6794 in_decl);
6800 }
6803 {
6805 in_decl);
6810 }
6813 {
6816 tree type;
6817 tree str;
6819 /* This code should match declare_hidden_char_array in
6820 c-common.c. */
6828 }
6834 }
6835 }
6837 /* Like tsubst, but deals with expressions. This function just replaces
6838 template parms; to finish processing the resultant expression, use
6839 tsubst_expr. */
6841 tree
6845 tree in_decl;
6846 {
6848 tree r;
6856 {
6861 {
6862 tree enum_type;
6863 tree v;
6866 /* This is a global enumeration constant. */
6869 /* Unfortunately, we cannot just call lookup_name here.
6870 Consider:
6872 template <int I> int f() {
6873 enum E { a = I };
6874 struct S { void g() { E e = a; } };
6875 };
6877 When we instantiate f<7>::S::g(), say, lookup_name is not
6878 clever enough to find f<7>::a. */
6879 enum_type
6889 /* We didn't find the name. That should never happen; if
6890 name-lookup found it during preliminary parsing, we
6891 should find it again here during instantiation. */
6893 }
6898 {
6899 tree ctx;
6905 }
6918 else
6922 {
6923 /* We must tsubst into a LOOKUP_EXPR in case the names to
6924 which it refers is a conversion operator; in that case the
6925 name will change. We avoid making unnecessary copies,
6926 however. */
6931 {
6935 }
6938 }
6946 return build1
6963 return build1
7007 return build_nt
7012 {
7016 else
7017 /* Sometimes FN is a LOOKUP_EXPR. */
7019 return build_nt
7021 in_decl),
7022 NULL_TREE);
7023 }
7026 {
7029 {
7033 }
7036 {
7044 }
7045 else
7047 return build_nt
7051 NULL_TREE);
7052 }
7055 /* This processing should really occur in tsubst_expr, However,
7056 tsubst_expr does not recurse into expressions, since it
7057 assumes that there aren't any statements inside them.
7058 Instead, it simply calls build_expr_from_tree. So, we need
7059 to expand the STMT_EXPR here. */
7061 {
7066 }
7073 {
7074 r = build_nt
7079 }
7082 {
7083 r = build_nt
7089 }
7092 {
7093 r = build_nt
7099 }
7102 {
7103 /* Substituted template arguments */
7105 in_decl);
7108 {
7109 tree chain;
7112 }
7114 {
7119 }
7121 return lookup_template_function
7123 }
7126 {
7146 }
7168 {
7171 }
7172 else
7176 {
7177 r = build
7183 }
7187 in_decl),
7195 }
7196 }
7198 /* Like tsubst_copy, but also does semantic processing. */
7200 tree
7204 tree in_decl;
7205 {
7206 tree stmt;
7215 {
7218 finish_named_return_value
7225 {
7226 tree member_init_list;
7227 tree base_init_list;
7230 member_init_list
7232 base_init_list
7237 }
7258 {
7259 tree decl;
7260 tree init;
7267 {
7273 }
7274 else
7275 {
7280 {
7282 /* Make sure the type is instantiated now. */
7286 /* By marking the declaration as instantiated, we avoid
7287 trying to instantiate it. Since instantiate_decl can't
7288 handle local variables, and since we've already done
7289 all that needs to be done, that's the right thing to
7290 do. */
7295 }
7296 }
7298 }
7301 {
7302 tree tmp;
7311 stmt);
7316 }
7320 {
7325 stmt);
7328 }
7332 {
7339 stmt);
7340 }
7344 {
7345 tree tmp;
7351 stmt);
7354 {
7357 }
7360 {
7364 }
7367 }
7371 {
7372 tree substmt;
7381 }
7395 {
7396 tree val;
7404 }
7411 in_decl));
7423 /* Computed goto's must be tsubst'd into. On the other hand,
7424 non-computed gotos must not be; the identifier in question
7425 will have no binding. */
7427 else
7439 in_decl));
7445 {
7451 stmt);
7452 }
7453 else
7454 {
7455 tree handler;
7459 else
7466 else
7474 else
7476 }
7480 {
7481 tree decl;
7482 tree blocks;
7487 {
7490 /* Prevent instantiate_decl from trying to instantiate
7491 this variable. We've already done all that needs to be
7492 done. */
7494 }
7495 else
7500 }
7511 }
7513 }
7515 /* TMPL is a TEMPLATE_DECL for a cloned constructor or destructor.
7516 Instantiate it with the ARGS. */
7518 static tree
7520 tree tmpl;
7521 tree args;
7522 {
7523 tree spec;
7524 tree clone;
7526 /* Instantiated the cloned function, rather than the clone. */
7529 /* Then, see if we've already cloned the instantiation. */
7536 /* If we haven't, do so know. */
7540 /* Look again. */
7547 /* We should always have found the clone by now. */
7550 }
7552 /* Instantiate the indicated variable or function template TMPL with
7553 the template arguments in TARG_PTR. */
7555 tree
7558 {
7559 tree clone;
7560 tree fndecl;
7561 tree gen_tmpl;
7562 tree spec;
7564 tree inner_args;
7571 /* If this function is a clone, handle it specially. */
7575 /* Check to see if we already have this specialization. */
7582 {
7583 /* The TMPL is a partial instantiation. To get a full set of
7584 arguments we must add the arguments used to perform the
7585 partial instantiation. */
7587 targ_ptr);
7589 /* Check to see if we already have this specialization. */
7593 }
7599 {
7602 {
7605 {
7609 }
7610 }
7611 }
7613 /* substitute template parameters */
7616 /* The DECL_TI_TEMPLATE should always be the immediate parent
7617 template, not the most general template. */
7623 /* If we've just instantiated the main entry point for a function,
7624 instantiate all the alternate entry points as well. */
7631 }
7633 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
7634 arguments that are being used when calling it. TARGS is a vector
7635 into which the deduced template arguments are placed.
7637 Return zero for success, 2 for an incomplete match that doesn't resolve
7638 all the types, and 1 for complete failure. An error message will be
7639 printed only for an incomplete match.
7641 If FN is a conversion operator, or we are trying to produce a specific
7642 specialization, RETURN_TYPE is the return type desired.
7644 The EXPLICIT_TARGS are explicit template arguments provided via a
7645 template-id.
7647 The parameter STRICT is one of:
7649 DEDUCE_CALL:
7650 We are deducing arguments for a function call, as in
7651 [temp.deduct.call].
7653 DEDUCE_CONV:
7654 We are deducing arguments for a conversion function, as in
7655 [temp.deduct.conv].
7657 DEDUCE_EXACT:
7658 We are deducing arguments when doing an explicit instantiation
7659 as in [temp.explicit], when determining an explicit specialization
7660 as in [temp.expl.spec], or when taking the address of a function
7661 template, as in [temp.deduct.funcaddr].
7663 DEDUCE_ORDER:
7664 We are deducing arguments when calculating the partial
7665 ordering between specializations of function or class
7666 templates, as in [temp.func.order] and [temp.class.order].
7668 LEN is the number of parms to consider before returning success, or -1
7669 for all. This is used in partial ordering to avoid comparing parms for
7670 which no actual argument was passed, since they are not considered in
7671 overload resolution (and are explicitly excluded from consideration in
7672 partial ordering in [temp.func.order]/6). */
7674 int
7678 unification_kind_t strict;
7680 {
7681 tree parms;
7682 tree fntype;
7689 {
7690 /* [temp.deduct]
7692 The specified template arguments must match the template
7693 parameters in kind (i.e., type, nontype, template), and there
7694 must not be more arguments than there are parameters;
7695 otherwise type deduction fails.
7697 Nontype arguments must match the types of the corresponding
7698 nontype template parameters, or must be convertible to the
7699 types of the corresponding nontype parameters as specified in
7700 _temp.arg.nontype_, otherwise type deduction fails.
7702 All references in the function type of the function template
7703 to the corresponding template parameters are replaced by the
7704 specified template argument values. If a substitution in a
7705 template parameter or in the function type of the function
7706 template results in an invalid type, type deduction fails. */
7708 tree converted_args;
7710 converted_args
7721 /* Place the explicitly specified arguments in TARGS. */
7724 }
7727 /* Never do unification on the 'this' parameter. */
7732 {
7733 /* We've been given a return type to match, prepend it. */
7738 }
7740 /* We allow incomplete unification without an error message here
7741 because the standard doesn't seem to explicitly prohibit it. Our
7742 callers must be ready to deal with unification failures in any
7743 event. */
7749 /* All is well so far. Now, check:
7751 [temp.deduct]
7753 When all template arguments have been deduced, all uses of
7754 template parameters in nondeduced contexts are replaced with
7755 the corresponding deduced argument values. If the
7756 substitution results in an invalid type, as described above,
7757 type deduction fails. */
7763 }
7765 /* Adjust types before performing type deduction, as described in
7766 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
7767 sections are symmetric. PARM is the type of a function parameter
7768 or the return type of the conversion function. ARG is the type of
7769 the argument passed to the call, or the type of the value
7770 initialized with the result of the conversion function. */
7772 static int
7774 unification_kind_t strict;
7777 {
7781 {
7786 {
7787 /* Swap PARM and ARG throughout the remainder of this
7788 function; the handling is precisely symmetric since PARM
7789 will initialize ARG rather than vice versa. */
7794 }
7797 /* There is nothing to do in this case. */
7801 /* DR 214. [temp.func.order] is underspecified, and leads to no
7802 ordering between things like `T *' and `T const &' for `U *'.
7803 The former has T=U and the latter T=U*. The former looks more
7804 specialized and John Spicer considers it well-formed (the EDG
7805 compiler accepts it).
7807 John also confirms that deduction should proceed as in a function
7808 call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL.
7809 However, in ordering, ARG can have REFERENCE_TYPE, but no argument
7810 to an actual call can have such a type.
7812 If both ARG and PARM are REFERENCE_TYPE, we change neither.
7813 If only ARG is a REFERENCE_TYPE, we look through that and then
7814 proceed as with DEDUCE_CALL (which could further convert it). */
7816 {
7820 }
7824 }
7827 {
7828 /* [temp.deduct.call]
7830 If P is not a reference type:
7832 --If A is an array type, the pointer type produced by the
7833 array-to-pointer standard conversion (_conv.array_) is
7834 used in place of A for type deduction; otherwise,
7836 --If A is a function type, the pointer type produced by
7837 the function-to-pointer standard conversion
7838 (_conv.func_) is used in place of A for type deduction;
7839 otherwise,
7841 --If A is a cv-qualified type, the top level
7842 cv-qualifiers of A's type are ignored for type
7843 deduction. */
7848 else
7850 }
7852 /* [temp.deduct.call]
7854 If P is a cv-qualified type, the top level cv-qualifiers
7855 of P's type are ignored for type deduction. If P is a
7856 reference type, the type referred to by P is used for
7857 type deduction. */
7860 {
7863 }
7865 }
7867 /* Most parms like fn_type_unification.
7869 If SUBR is 1, we're being called recursively (to unify the
7870 arguments of a function or method parameter of a function
7871 template). */
7873 static int
7878 unification_kind_t strict;
7880 {
7892 /* ARGS could be NULL (via a call from parse.y to
7893 build_x_function_call). */
7899 {
7919 }
7924 again:
7931 && args
7933 {
7942 /* We can't deduce anything from this, but we might get all the
7943 template args from other function args. */
7946 /* Conversions will be performed on a function argument that
7947 corresponds with a function parameter that contains only
7948 non-deducible template parameters and explicitly specified
7949 template parameters. */
7951 {
7952 tree type;
7956 else
7957 {
7960 }
7963 {
7966 }
7967 else
7968 /* It might work; we shouldn't check now, because we might
7969 get into infinite recursion. Overload resolution will
7970 handle it. */
7974 }
7977 {
7980 {
7981 /* [temp.deduct.type] A template-argument can be deduced from
7982 a pointer to function or pointer to member function
7983 argument if the set of overloaded functions does not
7984 contain function templates and at most one of a set of
7985 overloaded functions provides a unique match. */
7992 }
7994 }
7996 {
8004 }
8006 /* Are we done with the interesting parms? */
8009 }
8010 /* Fail if we've reached the end of the parm list, and more args
8011 are present, and the parm list isn't variadic. */
8014 /* Fail if parms are left and they don't have default values. */
8020 done:
8024 {
8027 /* If this is an undeduced nontype parameter that depends on
8028 a type parameter, try another pass; its type may have been
8029 deduced from a later argument than the one from which
8030 this parameter can be deduced. */
8039 }
8041 }
8043 /* Subroutine of type_unification_real. Args are like the variables at the
8044 call site. ARG is an overloaded function (or template-id); we try
8045 deducing template args from each of the overloads, and if only one
8046 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
8048 static int
8050 sub_strict)
8052 unification_kind_t strict;
8054 {
8062 /* Handle `&x' where `x' is some static or non-static member
8063 function name. */
8069 /* Strip baselink information. */
8074 {
8075 /* If we got some explicit template args, we need to plug them into
8076 the affected templates before we try to unify, in case the
8077 explicit args will completely resolve the templates in question. */
8083 {
8091 expl_subargs);
8093 {
8095 NULL_TREE);
8100 }
8101 }
8102 }
8104 {
8106 {
8111 type,
8113 }
8114 }
8115 else
8118 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8119 to function or pointer to member function argument if the set of
8120 overloaded functions does not contain function templates and at most
8121 one of a set of overloaded functions provides a unique match.
8123 So if we found multiple possibilities, we return success but don't
8124 deduce anything. */
8127 {
8132 }
8137 }
8139 /* Subroutine of resolve_overloaded_unification; does deduction for a single
8140 overload. Fills TARGS with any deduced arguments, or error_mark_node if
8141 different overloads deduce different arguments for a given parm.
8142 Returns 1 on success. */
8144 static int
8146 sub_strict)
8148 unification_kind_t strict;
8150 {
8152 tree tempargs;
8155 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8156 to function or pointer to member function argument if the set of
8157 overloaded functions does not contain function templates and at most
8158 one of a set of overloaded functions provides a unique match.
8160 So if this is a template, just return success. */
8167 /* We don't copy orig_targs for this because if we have already deduced
8168 some template args from previous args, unify would complain when we
8169 try to deduce a template parameter for the same argument, even though
8170 there isn't really a conflict. */
8177 /* First make sure we didn't deduce anything that conflicts with
8178 explicitly specified args. */
8180 {
8187 {
8188 /* Since we're unifying against ourselves, we will fill in template
8189 args used in the function parm list with our own template parms.
8190 Discard them. */
8193 }
8196 }
8199 {
8204 }
8207 }
8209 /* Verify that nondeduce template argument agrees with the type
8210 obtained from argument deduction. Return nonzero if the
8211 verification fails.
8213 For example:
8215 struct A { typedef int X; };
8216 template <class T, class U> struct C {};
8217 template <class T> struct C<T, typename T::X> {};
8219 Then with the instantiation `C<A, int>', we can deduce that
8220 `T' is `A' but unify () does not check whether `typename T::X'
8221 is `int'. This function ensure that they agree.
8223 TARGS, PARMS are the same as the arguments of unify.
8224 ARGS contains template arguments from all levels. */
8226 static int
8229 {
8240 {
8244 /* In case we are deducing from a function argument of a function
8245 templates, some parameters may not be deduced yet. So we
8246 make sure that only fully substituted elements of PARM are
8247 compared below. */
8251 }
8253 }
8255 /* PARM is a template class (perhaps with unbound template
8256 parameters). ARG is a fully instantiated type. If ARG can be
8257 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
8258 TARGS are as for unify. */
8260 static tree
8262 tree tparms;
8263 tree targs;
8264 tree parm;
8265 tree arg;
8266 {
8267 tree copy_of_targs;
8273 /* We need to make a new template argument vector for the call to
8274 unify. If we used TARGS, we'd clutter it up with the result of
8275 the attempted unification, even if this class didn't work out.
8276 We also don't want to commit ourselves to all the unifications
8277 we've already done, since unification is supposed to be done on
8278 an argument-by-argument basis. In other words, consider the
8279 following pathological case:
8281 template <int I, int J, int K>
8282 struct S {};
8284 template <int I, int J>
8285 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
8287 template <int I, int J, int K>
8288 void f(S<I, J, K>, S<I, I, I>);
8290 void g() {
8291 S<0, 0, 0> s0;
8292 S<0, 1, 2> s2;
8294 f(s0, s2);
8295 }
8297 Now, by the time we consider the unification involving `s2', we
8298 already know that we must have `f<0, 0, 0>'. But, even though
8299 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal
8300 because there are two ways to unify base classes of S<0, 1, 2>
8301 with S<I, I, I>. If we kept the already deduced knowledge, we
8302 would reject the possibility I=1. */
8305 /* If unification failed, we're done. */
8311 }
8313 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
8314 have already discovered to be satisfactory. ARG_BINFO is the binfo
8315 for the base class of ARG that we are currently examining. */
8317 static tree
8320 tree tparms;
8321 tree targs;
8322 tree arg_binfo;
8323 tree rval;
8324 tree parm;
8326 {
8327 tree binfos;
8332 {
8336 /* If there is more than one satisfactory baseclass, then:
8338 [temp.deduct.call]
8340 If they yield more than one possible deduced A, the type
8341 deduction fails.
8343 applies. */
8348 }
8353 /* Process base types. */
8355 {
8359 /* Skip this base, if we've already seen it. */
8363 this_virtual =
8366 /* When searching for a non-virtual, we cannot mark virtually
8367 found binfos. */
8372 parm,
8373 base_binfo,
8374 rval,
8377 /* If we discovered more than one matching base class, we can
8378 stop now. */
8381 }
8384 }
8386 /* Given a template type PARM and a class type ARG, find the unique
8387 base type in ARG that is an instance of PARM. We do not examine
8388 ARG itself; only its base-classes. If there is no appropriate base
8389 class, return NULL_TREE. If there is more than one, return
8390 error_mark_node. PARM may be the type of a partial specialization,
8391 as well as a plain template type. Used by unify. */
8393 static tree
8395 tree tparms;
8396 tree targs;
8397 tree parm;
8398 tree arg;
8399 {
8400 tree rval;
8401 tree arg_binfo;
8408 NULL_TREE,
8409 GTB_IGNORE_TYPE);
8411 /* Since get_template_base_recursive marks the bases classes, we
8412 must unmark them here. */
8416 }
8418 /* Returns the level of DECL, which declares a template parameter. */
8420 static int
8422 tree decl;
8423 {
8425 {
8436 }
8437 }
8439 /* Decide whether ARG can be unified with PARM, considering only the
8440 cv-qualifiers of each type, given STRICT as documented for unify.
8441 Returns non-zero iff the unification is OK on that basis.*/
8443 static int
8446 tree arg;
8447 tree parm;
8448 {
8458 }
8460 /* Takes parameters as for type_unification. Returns 0 if the
8461 type deduction succeeds, 1 otherwise. The parameter STRICT is a
8462 bitwise or of the following flags:
8464 UNIFY_ALLOW_NONE:
8465 Require an exact match between PARM and ARG.
8466 UNIFY_ALLOW_MORE_CV_QUAL:
8467 Allow the deduced ARG to be more cv-qualified (by qualification
8468 conversion) than ARG.
8469 UNIFY_ALLOW_LESS_CV_QUAL:
8470 Allow the deduced ARG to be less cv-qualified than ARG.
8471 UNIFY_ALLOW_DERIVED:
8472 Allow the deduced ARG to be a template base class of ARG,
8473 or a pointer to a template base class of the type pointed to by
8474 ARG.
8475 UNIFY_ALLOW_INTEGER:
8476 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
8477 case for more information.
8478 UNIFY_ALLOW_OUTER_LEVEL:
8479 This is the outermost level of a deduction. Used to determine validity
8480 of qualification conversions. A valid qualification conversion must
8481 have const qualified pointers leading up to the inner type which
8482 requires additional CV quals, except at the outer level, where const
8483 is not required [conv.qual]. It would be normal to set this flag in
8484 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
8485 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
8486 This is the outermost level of a deduction, and PARM can be more CV
8487 qualified at this point.
8488 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
8489 This is the outermost level of a deduction, and PARM can be less CV
8490 qualified at this point. */
8492 static int
8496 {
8498 tree targ;
8499 tree tparm;
8502 /* I don't think this will do the right thing with respect to types.
8503 But the only case I've seen it in so far has been array bounds, where
8504 signedness is the only information lost, and I think that will be
8505 okay. */
8512 /* We can't deduce anything from this, but we might get all the
8513 template args from other function args. */
8516 /* If PARM uses template parameters, then we can't bail out here,
8517 even if ARG == PARM, since we won't record unifications for the
8518 template parameters. We might need them if we're trying to
8519 figure out which of two things is more specialized. */
8523 /* Immediately reject some pairs that won't unify because of
8524 cv-qualification mismatches. */
8527 /* It is the elements of the array which hold the cv quals of an array
8528 type, and the elements might be template type parms. We'll check
8529 when we recurse. */
8531 /* We check the cv-qualifiers when unifying with template type
8532 parameters below. We want to allow ARG `const T' to unify with
8533 PARM `T' for example, when computing which of two templates
8534 is more specialized, for example. */
8548 {
8550 /* In a type which contains a nested-name-specifier, template
8551 argument values cannot be deduced for template parameters used
8552 within the nested-name-specifier. */
8562 /* The PARM is not one we're trying to unify. Just check
8563 to see if it matches ARG. */
8570 /* Check for mixed types and values. */
8578 {
8579 /* ARG must be constructed from a template class or a template
8580 template parameter. */
8585 {
8589 tree argtmplvec
8593 /* The parameter and argument roles have to be switched here
8594 in order to handle default arguments properly. For example,
8595 template<template <class> class TT> void f(TT<int>)
8596 should be able to accept vector<int> which comes from
8597 template <class T, class Allocator = allocator>
8598 class vector. */
8604 /* Deduce arguments T, i from TT<T> or TT<i>.
8605 We check each element of PARMVEC and ARGVEC individually
8606 rather than the whole TREE_VEC since they can have
8607 different number of elements. */
8610 {
8615 UNIFY_ALLOW_NONE))
8617 }
8618 }
8621 /* Fall through to deduce template name. */
8622 }
8626 {
8627 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
8629 /* Simple cases: Value already set, does match or doesn't. */
8634 }
8635 else
8636 {
8637 /* If PARM is `const T' and ARG is only `int', we don't have
8638 a match unless we are allowing additional qualification.
8639 If ARG is `const int' and PARM is just `T' that's OK;
8640 that binds `const int' to `T'. */
8645 /* Consider the case where ARG is `const volatile int' and
8646 PARM is `const T'. Then, T should be `volatile int'. */
8647 arg =
8655 /* Simple cases: Value already set, does match or doesn't. */
8660 }
8662 /* Make sure that ARG is not a variable-sized array. (Note that
8663 were talking about variable-sized arrays (like `int[n]'),
8664 rather than arrays of unknown size (like `int[]').) We'll
8665 get very confused by such a type since the bound of the array
8666 will not be computable in an instantiation. Besides, such
8667 types are not allowed in ISO C++, so we can do as we please
8668 here. */
8684 /* The PARM is not one we're trying to unify. Just check
8685 to see if it matches ARG. */
8693 {
8699 else
8701 }
8703 /* [temp.deduct.type] If, in the declaration of a function template
8704 with a non-type template-parameter, the non-type
8705 template-parameter is used in an expression in the function
8706 parameter-list and, if the corresponding template-argument is
8707 deduced, the template-argument type shall match the type of the
8708 template-parameter exactly, except that a template-argument
8709 deduced from an array bound may be of any integral type.
8710 The non-type parameter might use already deduced type parameters. */
8719 /* We haven't deduced the type of this parameter yet. Try again
8720 later. */
8722 else
8729 {
8733 /* [temp.deduct.call]
8735 A can be another pointer or pointer to member type that can
8736 be converted to the deduced A via a qualification
8737 conversion (_conv.qual_).
8739 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
8740 This will allow for additional cv-qualification of the
8741 pointed-to types if appropriate. */
8744 /* The derived-to-base conversion only persists through one
8745 level of pointers. */
8750 {
8751 /* Avoid getting confused about cv-quals; don't recurse here.
8752 Pointers to members should really be just OFFSET_TYPE, not
8753 this two-level nonsense... */
8758 }
8762 }
8781 UNIFY_ALLOW_NONE);
8794 {
8803 }
8804 /* We have already checked cv-qualification at the top of the
8805 function. */
8809 /* As far as unification is concerned, this wins. Later checks
8810 will invalidate it if necessary. */
8813 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
8814 /* Type INTEGER_CST can come from ordinary constant template args. */
8824 {
8833 UNIFY_ALLOW_NONE))
8836 }
8844 {
8851 strict);
8852 }
8855 {
8859 {
8860 /* First, we try to unify the PARM and ARG directly. */
8865 {
8866 /* Fallback to the special case allowed in
8867 [temp.deduct.call]:
8869 If P is a class, and P has the form
8870 template-id, then A can be a derived class of
8871 the deduced A. Likewise, if P is a pointer to
8872 a class of the form template-id, A can be a
8873 pointer to a derived class pointed to by the
8874 deduced A. */
8880 }
8881 }
8885 /* Perhaps PARM is something like S<U> and ARG is S<int>.
8886 Then, we should unify `int' and `U'. */
8888 else
8889 /* There's no chance of unification succeeding. */
8894 }
8912 offset:
8919 strict);
8927 /* Matched cases are handled by the ARG == PARM test above. */
8932 {
8933 /* We handle this case specially, since it comes up with
8934 arrays. In particular, something like:
8936 template <int N> void f(int (&x)[N]);
8938 Here, we are trying to unify the range type, which
8939 looks like [0 ... (N - 1)]. */
8947 }
8948 /* else fall through */
8952 {
8954 /* We're looking at an expression. This can happen with
8955 something like:
8957 template <int I>
8958 void foo(S<I>, S<I + 2>);
8960 This is a "nondeduced context":
8962 [deduct.type]
8964 The nondeduced contexts are:
8966 --A type that is a template-id in which one or more of
8967 the template-arguments is an expression that references
8968 a template-parameter.
8970 In these cases, we assume deduction succeeded, but don't
8971 actually infer any unifications. */
8976 else
8978 }
8979 else
8984 }
8985 }
8986 \f
8987 /* Called if RESULT is explicitly instantiated, or is a member of an
8988 explicitly instantiated class, or if using -frepo and the
8989 instantiation of RESULT has been assigned to this file. */
8991 void
8993 tree result;
8995 {
8997 /* The TREE_PUBLIC flag for function declarations will have been
8998 set correctly by tsubst. */
9001 /* We used to set this unconditionally; we moved that to
9002 do_decl_instantiation so it wouldn't get set on members of
9003 explicit class template instantiations. But we still need to set
9004 it here for the 'extern template' case in order to suppress
9005 implicit instantiations. */
9010 {
9014 /* Always make artificials weak. */
9017 /* For WIN32 we also want to put explicit instantiations in
9018 linkonce sections. */
9021 }
9024 }
9026 /* Given two function templates PAT1 and PAT2, return:
9028 DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER.
9030 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
9031 -1 if PAT2 is more specialized than PAT1.
9032 0 if neither is more specialized.
9034 LEN is passed through to fn_type_unification. */
9036 int
9041 {
9042 tree targs;
9056 }
9058 /* Given two class template specialization list nodes PAT1 and PAT2, return:
9060 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
9061 -1 if PAT2 is more specialized than PAT1.
9062 0 if neither is more specialized. */
9064 int
9067 {
9068 tree targs;
9082 }
9084 /* Return the template arguments that will produce the function signature
9085 DECL from the function template FN, with the explicit template
9086 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
9087 also match. Return NULL_TREE if no satisfactory arguments could be
9088 found. DEDUCE and LEN are passed through to fn_type_unification. */
9090 static tree
9094 {
9097 tree decl_type;
9098 tree decl_arg_types;
9101 /* Substitute the explicit template arguments into the type of DECL.
9102 The call to fn_type_unification will handle substitution into the
9103 FN. */
9106 {
9107 tree tmpl;
9108 tree converted_args;
9112 else
9113 /* We can get here for some illegal specializations. */
9116 converted_args
9125 NULL_TREE);
9128 }
9131 /* Never do unification on the 'this' parameter. */
9136 decl_arg_types,
9145 }
9147 /* For most uses, we want to check the return type. */
9149 tree
9152 {
9154 }
9156 /* But for resolve_overloaded_unification, we only care about the parameter
9157 types. */
9159 static tree
9162 {
9164 }
9166 /* Return the innermost template arguments that, when applied to a
9167 template specialization whose innermost template parameters are
9168 TPARMS, and whose specialization arguments are ARGS, yield the
9169 ARGS.
9171 For example, suppose we have:
9173 template <class T, class U> struct S {};
9174 template <class T> struct S<T*, int> {};
9176 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
9177 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
9178 int}. The resulting vector will be {double}, indicating that `T'
9179 is bound to `double'. */
9181 static tree
9184 {
9189 UNIFY_ALLOW_NONE))
9200 }
9202 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
9203 Pick the most specialized template, and return the corresponding
9204 instantiation, or if there is no corresponding instantiation, the
9205 template itself. If there is no most specialized template,
9206 error_mark_node is returned. If there are no templates at all,
9207 NULL_TREE is returned. */
9209 tree
9211 tree instantiations;
9212 {
9221 {
9225 ;
9226 else
9227 {
9229 {
9233 }
9235 }
9236 }
9239 {
9244 }
9247 }
9249 /* Return the most specialized of the list of templates in FNS that can
9250 produce an instantiation matching DECL, given the explicit template
9251 arguments EXPLICIT_ARGS. */
9253 static tree
9256 {
9261 {
9267 }
9270 }
9272 /* If DECL is a specialization of some template, return the most
9273 general such template. Otherwise, returns NULL_TREE.
9275 For example, given:
9277 template <class T> struct S { template <class U> void f(U); };
9279 if TMPL is `template <class U> void S<int>::f(U)' this will return
9280 the full template. This function will not trace past partial
9281 specializations, however. For example, given in addition:
9283 template <class T> struct S<T*> { template <class U> void f(U); };
9285 if TMPL is `template <class U> void S<int*>::f(U)' this will return
9286 `template <class T> template <class U> S<T*>::f(U)'. */
9288 tree
9290 tree decl;
9291 {
9292 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
9293 an immediate specialization. */
9295 {
9299 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
9300 template friend. */
9305 }
9307 /* Look for more and more general templates. */
9309 {
9310 /* The DECL_TI_TEMPLATE can be a LOOKUP_EXPR or IDENTIFIER_NODE
9311 in some cases. (See cp-tree.h for details.) */
9315 /* Stop if we run into an explicitly specialized class template. */
9322 }
9325 }
9327 /* Return the most specialized of the class template specializations
9328 of TMPL which can produce an instantiation matching ARGS, or
9329 error_mark_node if the choice is ambiguous. */
9331 static tree
9333 tree tmpl;
9334 tree args;
9335 {
9337 tree t;
9338 tree champ;
9343 {
9344 tree spec_args
9347 {
9350 }
9351 }
9360 {
9363 ;
9364 else
9365 {
9367 {
9371 }
9373 }
9374 }
9377 {
9381 }
9384 }
9386 /* called from the parser. */
9388 void
9391 {
9397 /* An error occurred, for which grokdeclarator has already issued
9398 an appropriate message. */
9401 {
9404 }
9406 {
9407 /* There is an asymmetry here in the way VAR_DECLs and
9408 FUNCTION_DECLs are handled by grokdeclarator. In the case of
9409 the latter, the DECL we get back will be marked as a
9410 template instantiation, and the appropriate
9411 DECL_TEMPLATE_INFO will be set up. This does not happen for
9412 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
9413 should handle VAR_DECLs as it currently handles
9414 FUNCTION_DECLs. */
9417 {
9420 }
9421 }
9423 {
9426 }
9427 else
9430 /* Check for various error cases. Note that if the explicit
9431 instantiation is legal the RESULT will currently be marked as an
9432 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
9433 until we get here. */
9436 {
9437 /* [temp.spec]
9439 No program shall both explicitly instantiate and explicitly
9440 specialize a template. */
9444 }
9446 {
9447 /* [temp.spec]
9449 No program shall explicitly instantiate any template more
9450 than once.
9452 We check DECL_INTERFACE_KNOWN so as not to complain when the first
9453 instantiation was `extern' and the second is not, and EXTERN_P for
9454 the opposite case. If -frepo, chances are we already got marked
9455 as an explicit instantiation because of the repo file. */
9459 /* If we've already instantiated the template, just return now. */
9462 }
9464 {
9467 }
9469 {
9472 }
9478 ;
9480 {
9484 }
9485 else
9487 storage);
9494 }
9496 void
9498 tree t;
9500 {
9507 {
9510 }
9511 }
9513 /* Perform an explicit instantiation of template class T. STORAGE, if
9514 non-null, is the RID for extern, inline or static. COMPLAIN is
9515 non-zero if this is called from the parser, zero if called recursively,
9516 since the standard is unclear (as detailed below). */
9518 void
9522 {
9531 {
9534 }
9538 /* With -fexternal-templates, explicit instantiations are treated the same
9539 as implicit ones. */
9544 {
9547 t);
9549 }
9552 {
9563 else
9564 {
9566 storage);
9568 }
9569 }
9572 {
9573 /* [temp.spec]
9575 No program shall both explicitly instantiate and explicitly
9576 specialize a template. */
9578 {
9581 }
9583 }
9585 {
9586 /* [temp.spec]
9588 No program shall explicitly instantiate any template more
9589 than once.
9591 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
9592 was `extern'. If EXTERN_P then the second is. If -frepo, chances
9593 are we already got marked as an explicit instantion because of the
9594 repo file. All these cases are OK. */
9599 /* If we've already instantiated the template, just return now. */
9602 }
9610 {
9611 tree tmp;
9613 /* In contrast to implicit instantiation, where only the
9614 declarations, and not the definitions, of members are
9615 instantiated, we have here:
9617 [temp.explicit]
9619 The explicit instantiation of a class template specialization
9620 implies the instantiation of all of its members not
9621 previously explicitly specialized in the translation unit
9622 containing the explicit instantiation.
9624 Of course, we can't instantiate member template classes, since
9625 we don't have any arguments for them. Note that the standard
9626 is unclear on whether the instantiation of the members are
9627 *explicit* instantiations or not. We choose to be generous,
9628 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
9629 the explicit instantiation of a class where some of the members
9630 have no definition in the current translation unit. */
9636 {
9641 }
9645 {
9650 }
9656 }
9657 }
9659 /* Given a function DECL, which is a specialization of TMPL, modify
9660 DECL to be a re-instantiation of TMPL with the same template
9661 arguments. TMPL should be the template into which tsubst'ing
9662 should occur for DECL, not the most general template.
9664 One reason for doing this is a scenario like this:
9666 template <class T>
9667 void f(const T&, int i);
9669 void g() { f(3, 7); }
9671 template <class T>
9672 void f(const T& t, const int i) { }
9674 Note that when the template is first instantiated, with
9675 instantiate_template, the resulting DECL will have no name for the
9676 first parameter, and the wrong type for the second. So, when we go
9677 to instantiate the DECL, we regenerate it. */
9679 static void
9681 tree decl;
9682 tree tmpl;
9683 {
9684 /* The most general version of TMPL. */
9685 tree gen_tmpl;
9686 /* The arguments used to instantiate DECL, from the most general
9687 template. */
9688 tree args;
9689 tree code_pattern;
9690 tree new_decl;
9696 /* Unregister the specialization so that when we tsubst we will not
9697 just return DECL. We don't have to unregister DECL from TMPL
9698 because if would only be registered there if it were a partial
9699 instantiation of a specialization, which it isn't: it's a full
9700 instantiation. */
9704 /* If the DECL was not unregistered then something peculiar is
9705 happening: we created a specialization but did not call
9706 register_specialization for it. */
9710 /* Make sure that we can see identifiers, and compute access
9711 correctly, for the class members used in the declaration of
9712 this static variable. */
9715 /* Do the substitution to get the new declaration. */
9719 {
9720 /* Set up DECL_INITIAL, since tsubst doesn't. */
9724 /* Pop the class context we pushed above. */
9726 }
9728 {
9729 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
9730 new decl. */
9732 /* And don't complain about a duplicate definition. */
9734 }
9736 /* The immediate parent of the new template is still whatever it was
9737 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
9738 general template. We also reset the DECL_ASSEMBLER_NAME since
9739 tsubst always calculates the name as if the function in question
9740 were really a template instance, and sometimes, with friend
9741 functions, this is not so. See tsubst_friend_function for
9742 details. */
9748 /* Call duplicate decls to merge the old and new declarations. */
9751 /* Now, re-register the specialization. */
9753 }
9755 /* Produce the definition of D, a _DECL generated from a template. If
9756 DEFER_OK is non-zero, then we don't have to actually do the
9757 instantiation now; we just have to do it sometime. */
9759 tree
9761 tree d;
9763 {
9766 tree td;
9767 tree code_pattern;
9768 tree spec;
9769 tree gen_tmpl;
9775 /* This function should only be used to instantiate templates for
9776 functions and static member variables. */
9780 /* Don't instantiate cloned functions. Instead, instantiate the
9781 functions they cloned. */
9786 /* D has already been instantiated. It might seem reasonable to
9787 check whether or not D is an explicit instantiation, and, if so,
9788 stop here. But when an explicit instantiation is deferred
9789 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
9790 is set, even though we still need to do the instantiation. */
9793 /* If we already have a specialization of this declaration, then
9794 there's no reason to instantiate it. Note that
9795 retrieve_specialization gives us both instantiations and
9796 specializations, so we must explicitly check
9797 DECL_TEMPLATE_SPECIALIZATION. */
9803 /* This needs to happen before any tsubsting. */
9809 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
9810 for the instantiation. This is not always the most general
9811 template. Consider, for example:
9813 template <class T>
9814 struct S { template <class U> void f();
9815 template <> void f<int>(); };
9817 and an instantiation of S<double>::f<int>. We want TD to be the
9818 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
9821 more general template. */
9823 /* We must also deal with friend templates. Given:
9825 template <class T> struct S {
9826 template <class U> friend void f() {};
9827 };
9829 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
9830 so far as the language is concerned, but that's still
9831 where we get the pattern for the instantiation from. On
9832 other hand, if the definition comes outside the class, say:
9834 template <class T> struct S {
9835 template <class U> friend void f();
9836 };
9837 template <class U> friend void f() {}
9839 we don't need to look any further. That's what the check for
9840 DECL_INITIAL is for. */
9844 {
9845 /* The present template, TD, should not be a definition. If it
9846 were a definition, we should be using it! Note that we
9847 cannot restructure the loop to just keep going until we find
9848 a template with a definition, since that might go too far if
9849 a specialization was declared, but not defined. */
9854 /* Fetch the more general template. */
9856 }
9862 else
9869 {
9870 /* Let the repository code that this template definition is
9871 available.
9873 The repository doesn't need to know about cloned functions
9874 because they never actually show up in the object file. It
9875 does need to know about the clones; those are the symbols
9876 that the linker will be emitting error messages about. */
9879 {
9880 tree t;
9886 }
9887 else
9891 {
9893 {
9896 }
9898 {
9901 }
9902 else
9904 }
9908 }
9912 /* We should have set up DECL_INITIAL in instantiate_class_template. */
9914 /* Reject all external templates except inline functions. */
9919 /* Defer all other templates, unless we have been explicitly
9920 forbidden from doing so. We restore the source position here
9921 because it's used by add_pending_template. */
9923 {
9929 /* [temp.explicit]
9931 The definition of a non-exported function template, a
9932 non-exported member function template, or a non-exported
9933 member function or static data member of a class template
9934 shall be present in every translation unit in which it is
9935 explicitly instantiated. */
9937 d);
9941 }
9947 /* We're now committed to instantiating this template. Mark it as
9948 instantiated so that recursive calls to instantiate_decl do not
9949 try to instantiate it again. */
9952 /* Regenerate the declaration in case the template has been modified
9953 by a subsequent redeclaration. */
9956 /* We already set the file and line above. Reset them now in case
9957 they changed as a result of calling regenerate_decl_from_template. */
9962 {
9966 else
9967 {
9970 }
9972 }
9974 {
9975 htab_t saved_local_specializations;
9977 /* Save away the current list, in case we are instantiating one
9978 template from within the body of another. */
9981 /* Set up the list of local specializations. */
9983 htab_hash_pointer,
9984 htab_eq_pointer,
9985 NULL);
9987 /* Set up context. */
9990 /* We already set up __FUNCTION__, etc., so we don't want to do
9991 it again now. */
9994 /* Substitute into the body of the function. */
9998 /* We don't need the local specializations any more. */
10002 /* Finish the function. */
10004 }
10006 /* We're not deferring instantiation any more. */
10012 out:
10021 }
10023 /* Run through the list of templates that we wish we could
10024 instantiate, and instantiate any we can. */
10026 int
10028 {
10033 do
10034 {
10039 {
10045 {
10046 tree fn;
10049 {
10053 fn;
10058 {
10061 }
10062 }
10065 /* If INSTANTIATION has been instantiated, then we don't
10066 need to consider it again in the future. */
10068 else
10070 }
10071 else
10072 {
10075 {
10079 {
10082 }
10083 }
10087 /* If INSTANTIATION has been instantiated, then we don't
10088 need to consider it again in the future. */
10090 else
10092 }
10095 }
10098 /* Go through the things that are template instantiations if we are
10099 using guiding declarations. */
10102 {
10104 tree fn;
10105 tree args;
10110 /* If the FN is already defined, then it was either already
10111 instantiated or, even though guiding declarations were
10112 allowed, a non-template definition was provided. */
10113 ;
10114 else
10115 {
10121 }
10123 /* Remove this entry from the chain. */
10125 }
10127 }
10131 }
10133 /* Substitute ARGVEC into T, which is a list of initializers for
10134 either base class or a non-static data member. The TREE_PURPOSEs
10135 are DECLs, and the TREE_VALUEs are the initializer values. Used by
10136 instantiate_decl. */
10138 static tree
10141 {
10146 {
10147 tree decl;
10148 tree init;
10149 tree val;
10152 NULL_TREE);
10154 NULL_TREE);
10157 ;
10161 else
10166 }
10168 }
10170 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
10172 static void
10174 tree decl;
10175 {
10180 else
10182 }
10184 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
10185 is the instantiation (which should have been created with
10186 start_enum) and ARGS are the template arguments to use. */
10188 static void
10190 tree tag;
10191 tree newtag;
10192 tree args;
10193 {
10194 tree e;
10197 {
10198 tree value;
10200 /* Note that in a template enum, the TREE_VALUE is the
10201 CONST_DECL, not the corresponding INTEGER_CST. */
10204 NULL_TREE);
10206 /* Give this enumeration constant the correct access. */
10209 /* Actually build the enumerator itself. */
10211 }
10216 }
10218 /* DECL is a FUNCTION_DECL that is a template specialization. Return
10219 its type -- but without substituting the innermost set of template
10220 arguments. So, innermost set of template parameters will appear in
10221 the type. If CONTEXTP is non-NULL, then the partially substituted
10222 DECL_CONTEXT (if any) will also be filled in. Similarly, TPARMSP
10223 will be filled in with the substituted template parameters, if it
10224 is non-NULL. */
10226 tree
10228 tree decl;
10231 {
10233 tree fn_type;
10234 tree tmpl;
10235 tree targs;
10236 tree tparms;
10244 /* There should be as many levels of arguments as there are levels
10245 of parameters. */
10253 /* No substitution is necessary. */
10254 ;
10255 else
10256 {
10258 tree partial_args;
10260 /* Replace the innermost level of the TARGS with NULL_TREEs to
10261 let tsubst know not to substitute for those parameters. */
10270 /* Now, do the (partial) substitution to figure out the
10271 appropriate function type. */
10276 /* Substitute into the template parameters to obtain the real
10277 innermost set of parameters. This step is important if the
10278 innermost set of template parameters contains value
10279 parameters whose types depend on outer template parameters. */
10282 }
10290 }
10292 /* Return truthvalue if we're processing a template different from
10293 the last one involved in diagnostics. */
10294 int
10296 {
10298 }
10300 /* Remember current template involved in diagnostics. */
10301 void
10303 {
10305 }
10307 tree
10309 {
10311 }
10313 /* [temp.param] Check that template non-type parm TYPE is of an allowable
10314 type. Return zero for ok, non-zero for disallowed. If COMPLAIN is
10315 non-zero, then complain. */
10317 static int
10319 tree type;
10321 {
10331 {
10335 }
10337 {
10341 }
10349 type);
10351 }