| blob | e75b153e0a7bb0e901ab33b374186698bd88c574 |
1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 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. */
71 /* A map from local variable declarations in the body of the template
72 presently being instantiated to the corresponding instantiated
73 local variables. */
76 #define obstack_chunk_alloc xmalloc
77 #define obstack_chunk_free free
79 #define UNIFY_ALLOW_NONE 0
80 #define UNIFY_ALLOW_MORE_CV_QUAL 1
81 #define UNIFY_ALLOW_LESS_CV_QUAL 2
82 #define UNIFY_ALLOW_DERIVED 4
83 #define UNIFY_ALLOW_INTEGER 8
84 #define UNIFY_ALLOW_OUTER_LEVEL 16
85 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
86 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
87 #define UNIFY_ALLOW_MAX_CORRECTION 128
90 virtual, or a base class of a virtual
91 base. */
93 type with the desired type. */
112 tree*));
169 /* Called once to initialize pt.c. */
171 void
173 {
177 }
179 /* Do any processing required when DECL (a member template declaration
180 using TEMPLATE_PARAMETERS as its innermost parameter list) is
181 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
182 it is a specialization, in which case the DECL itself is returned. */
184 tree
186 tree decl;
187 {
191 /* By returning NULL_TREE, the parser will just ignore this
192 declaration. We have already issued the error. */
195 {
196 /* Assume that the class is the only declspec. */
200 {
204 }
206 }
210 {
212 {
215 }
216 else
218 }
219 else
223 }
225 /* Returns the template nesting level of the indicated class TYPE.
227 For example, in:
228 template <class T>
229 struct A
230 {
231 template <class U>
232 struct B {};
233 };
235 A<T>::B<U> has depth two, while A<T> has depth one.
236 Both A<T>::B<int> and A<int>::B<U> have depth one, if
237 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
238 specializations.
240 This function is guaranteed to return 0 if passed NULL_TREE so
241 that, for example, `template_class_depth (current_class_type)' is
242 always safe. */
244 static int
246 tree type;
248 {
255 {
257 {
260 && ((count_specializations
264 }
265 else
266 {
269 && ((count_specializations
273 }
274 }
277 }
279 /* Returns the template nesting level of the indicated class TYPE.
280 Like template_class_depth_real, but instantiations do not count in
281 the depth. */
283 int
285 tree type;
286 {
288 }
290 /* Returns 1 if processing DECL as part of do_pending_inlines
291 needs us to push template parms. */
293 static int
295 tree decl;
296 {
302 }
304 /* Subroutine of maybe_begin_member_template_processing.
305 Push the template parms in PARMS, starting from LEVELS steps into the
306 chain, and ending at the beginning, since template parms are listed
307 innermost first. */
309 static void
311 tree parmlist;
313 {
321 current_template_parms
328 {
333 {
340 {
341 /* Make a CONST_DECL as is done in process_template_parm.
342 It is ugly that we recreate this here; the original
343 version built in process_template_parm is no longer
344 available. */
351 }
356 }
357 }
358 }
360 /* Restore the template parameter context for a member template or
361 a friend template defined in a class definition. */
363 void
365 tree decl;
366 {
367 tree parms;
371 {
376 {
379 }
382 }
384 /* Remember how many levels of template parameters we pushed so that
385 we can pop them later. */
392 }
394 /* Undo the effects of begin_member_template_processing. */
396 void
398 {
408 {
412 }
413 }
415 /* Returns non-zero iff T is a member template function. We must be
416 careful as in
418 template <class T> class C { void f(); }
420 Here, f is a template function, and a member, but not a member
421 template. This function does not concern itself with the origin of
422 T, only its present state. So if we have
424 template <class T> class C { template <class U> void f(U); }
426 then neither C<int>::f<char> nor C<T>::f<double> is considered
427 to be a member template. But, `template <class U> void
428 C<int>::f(U)' is considered a member template. */
430 int
432 tree t;
433 {
435 /* Anything that isn't a function or a template function is
436 certainly not a member template. */
439 /* A local class can't have member templates. */
444 /* If there are more levels of template parameters than
445 there are template classes surrounding the declaration,
446 then we have a member template. */
449 }
452 /* Returns non-zero iff T is a member template class. See
453 is_member_template for a description of what precisely constitutes
454 a member template. */
456 int
458 tree t;
459 {
461 /* Anything that isn't a class template, is certainly not a member
462 template. */
466 /* Anything whose context isn't a class type is surely not a
467 member template. */
470 /* If there are more levels of template parameters than there are
471 template classes surrounding the declaration, then we have a
472 member template. */
475 }
476 #endif
478 /* Return a new template argument vector which contains all of ARGS,
479 but has as its innermost set of arguments the EXTRA_ARGS. */
481 static tree
483 tree args;
484 tree extra_args;
485 {
486 tree new_args;
501 }
503 /* Like add_to_template_args, but only the outermost ARGS are added to
504 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
505 (EXTRA_ARGS) levels are added. This function is used to combine
506 the template arguments from a partial instantiation with the
507 template arguments used to attain the full instantiation from the
508 partial instantiation. */
510 static tree
512 tree args;
513 tree extra_args;
514 {
515 tree new_args;
517 /* If there are more levels of EXTRA_ARGS than there are ARGS,
518 something very fishy is going on. */
522 /* If *all* the new arguments will be the EXTRA_ARGS, just return
523 them. */
527 /* For the moment, we make ARGS look like it contains fewer levels. */
532 /* Now, we restore ARGS to its full dimensions. */
536 }
538 /* Return the N levels of innermost template arguments from the ARGS. */
540 tree
542 tree args;
544 {
545 tree new_args;
551 /* If N is 1, just return the innermost set of template arguments. */
555 /* If we're not removing anything, just return the arguments we were
556 given. */
562 /* Make a new set of arguments, not containing the outer arguments. */
569 }
571 /* We've got a template header coming up; push to a new level for storing
572 the parms. */
574 void
576 {
577 /* We use a non-tag-transparent scope here, which causes pushtag to
578 put tags in this scope, rather than in the enclosing class or
579 namespace scope. This is the right thing, since we want
580 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
581 global template class, push_template_decl handles putting the
582 TEMPLATE_DECL into top-level scope. For a nested template class,
583 e.g.:
585 template <class T> struct S1 {
586 template <class T> struct S2 {};
587 };
589 pushtag contains special code to call pushdecl_with_scope on the
590 TEMPLATE_DECL for S2. */
595 }
597 /* This routine is called when a specialization is declared. If it is
598 illegal to declare a specialization here, an error is reported. */
600 static void
602 {
605 /* [temp.expl.spec]
607 An explicit specialization shall be declared in the namespace of
608 which the template is a member, or, for member templates, in the
609 namespace of which the enclosing class or enclosing class
610 template is a member. An explicit specialization of a member
611 function, member class or static data member of a class template
612 shall be declared in the namespace of which the class template
613 is a member. */
616 scope);
618 /* [temp.expl.spec]
620 In an explicit specialization declaration for a member of a class
621 template or a member template that appears in namespace scope,
622 the member template and some of its enclosing class templates may
623 remain unspecialized, except that the declaration shall not
624 explicitly specialize a class member template if its enclosing
625 class templates are not explicitly specialized as well. */
628 }
630 /* We've just seen template <>. */
632 void
634 {
638 }
640 /* Called at then end of processing a declaration preceded by
641 template<>. */
643 void
645 {
648 }
650 /* Any template <>'s that we have seen thus far are not referring to a
651 function specialization. */
653 void
655 {
658 }
660 /* We've just seen a template header. If SPECIALIZATION is non-zero,
661 it was of the form template <>. */
663 static void
666 {
668 template_header_count++;
669 }
671 /* We're beginning an explicit instantiation. */
673 void
675 {
677 }
680 void
682 {
685 }
687 /* The TYPE is being declared. If it is a template type, that means it
688 is a partial specialization. Do appropriate error-checking. */
690 void
692 tree type;
693 {
695 {
698 {
701 {
705 }
709 }
712 }
715 }
717 /* Retrieve the specialization (in the sense of [temp.spec] - a
718 specialization is either an instantiation or an explicit
719 specialization) of TMPL for the given template ARGS. If there is
720 no such specialization, return NULL_TREE. The ARGS are a vector of
721 arguments, or a vector of vectors of arguments, in the case of
722 templates with more than one level of parameters. */
724 static tree
726 tree tmpl;
727 tree args;
728 {
729 tree s;
733 /* There should be as many levels of arguments as there are
734 levels of parameters. */
746 }
748 /* Like retrieve_specialization, but for local declarations. */
750 static tree
752 tree tmpl;
753 {
755 }
757 /* Returns non-zero iff DECL is a specialization of TMPL. */
759 int
761 tree decl;
762 tree tmpl;
763 {
764 tree t;
767 {
773 }
774 else
775 {
784 }
787 }
789 /* Register the specialization SPEC as a specialization of TMPL with
790 the indicated ARGS. Returns SPEC, or an equivalent prior
791 declaration, if available. */
793 static tree
795 tree spec;
796 tree tmpl;
797 tree args;
798 {
799 tree s;
805 /* This is the FUNCTION_DECL for a partial instantiation. Don't
806 register it; we want the corresponding TEMPLATE_DECL instead.
807 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
808 the more obvious `uses_template_parms (spec)' to avoid problems
809 with default function arguments. In particular, given
810 something like this:
812 template <class T> void f(T t1, T t = T())
814 the default argument expression is not substituted for in an
815 instantiation unless and until it is actually needed. */
818 /* There should be as many levels of arguments as there are
819 levels of parameters. */
827 {
830 /* We can sometimes try to re-register a specialization that we've
831 already got. In particular, regenerate_decl_from_template
832 calls duplicate_decls which will update the specialization
833 list. But, we'll still get called again here anyhow. It's
834 more convenient to simply allow this than to try to prevent it. */
838 {
840 {
842 {
845 {
847 fn);
849 }
850 else
851 {
852 /* This situation should occur only if the first
853 specialization is an implicit instantiation,
854 the second is an explicit specialization, and
855 the implicit instantiation has not yet been
856 used. That situation can occur if we have
857 implicitly instantiated a member function and
858 then specialized it later.
860 We can also wind up here if a friend
861 declaration that looked like an instantiation
862 turns out to be a specialization:
864 template <class T> void foo(T);
865 class S { friend void foo<>(int) };
866 template <> void foo(int);
868 We transform the existing DECL in place so that
869 any pointers to it become pointers to the
870 updated declaration.
872 If there was a definition for the template, but
873 not for the specialization, we want this to
874 look as if there is no definition, and vice
875 versa. */
880 }
881 }
883 {
886 }
887 }
888 }
889 }
895 }
897 /* Unregister the specialization SPEC as a specialization of TMPL.
898 Returns nonzero if the SPEC was listed as a specialization of
899 TMPL. */
901 static int
903 tree spec;
904 tree tmpl;
905 {
912 {
915 }
918 }
920 /* Like register_specialization, but for local declarations. We are
921 registering SPEC, an instantiation of TMPL. */
923 static void
925 tree spec;
926 tree tmpl;
927 {
932 }
934 /* Print the list of candidate FNS in an error message. */
936 void
938 tree fns;
939 {
940 tree fn;
945 {
946 tree f;
951 }
952 }
954 /* Returns the template (one of the functions given by TEMPLATE_ID)
955 which can be specialized to match the indicated DECL with the
956 explicit template args given in TEMPLATE_ID. The DECL may be
957 NULL_TREE if none is available. In that case, the functions in
958 TEMPLATE_ID are non-members.
960 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
961 specialization of a member template.
963 The template args (those explicitly specified and those deduced)
964 are output in a newly created vector *TARGS_OUT.
966 If it is impossible to determine the result, an error message is
967 issued. The error_mark_node is returned to indicate failure. */
969 static tree
971 need_member_template)
972 tree template_id;
973 tree decl;
976 {
977 tree fns;
978 tree targs;
979 tree explicit_targs;
994 /* Check for baselinks. */
999 {
1002 }
1005 {
1006 tree tmpl;
1011 /* DECL might be a specialization of FN. */
1014 /* FN is an ordinary member function, and we need a
1015 specialization of a member template. */
1018 /* We can get IDENTIFIER_NODEs here in certain erroneous
1019 cases. */
1022 /* This is just an ordinary non-member function. Nothing can
1023 be a specialization of that. */
1026 /* Cannot specialize functions that are created implicitly. */
1028 else
1029 {
1030 tree decl_arg_types;
1032 /* This is an ordinary member function. However, since
1033 we're here, we can assume it's enclosing class is a
1034 template class. For example,
1036 template <typename T> struct S { void f(); };
1037 template <> void S<int>::f() {}
1039 Here, S<int>::f is a non-template, but S<int> is a
1040 template class. If FN has the same type as DECL, we
1041 might be in business. */
1044 /* Its enclosing class is an explicit specialization
1045 of a template class. This is not a candidate. */
1050 /* The return types differ. */
1053 /* Adjust the type of DECL in case FN is a static member. */
1060 decl_arg_types))
1061 /* They match! */
1065 }
1067 /* See whether this function might be a specialization of this
1068 template. */
1072 /* We cannot deduce template arguments that when used to
1073 specialize TMPL will produce DECL. */
1076 /* Save this template, and the arguments deduced. */
1078 }
1081 {
1082 /* We have:
1084 [temp.expl.spec]
1086 It is possible for a specialization with a given function
1087 signature to be instantiated from more than one function
1088 template. In such cases, explicit specification of the
1089 template arguments must be used to uniquely identify the
1090 function template specialization being specialized.
1092 Note that here, there's no suggestion that we're supposed to
1093 determine which of the candidate templates is most
1094 specialized. However, we, also have:
1096 [temp.func.order]
1098 Partial ordering of overloaded function template
1099 declarations is used in the following contexts to select
1100 the function template to which a function template
1101 specialization refers:
1103 -- when an explicit specialization refers to a function
1104 template.
1106 So, we do use the partial ordering rules, at least for now.
1107 This extension can only serve to make illegal programs legal,
1108 so it's safe. And, there is strong anecdotal evidence that
1109 the committee intended the partial ordering rules to apply;
1110 the EDG front-end has that behavior, and John Spicer claims
1111 that the committee simply forgot to delete the wording in
1112 [temp.expl.spec]. */
1115 {
1118 }
1119 }
1122 {
1126 }
1130 {
1136 }
1138 /* We have one, and exactly one, match. */
1140 {
1141 /* It was a specialization of an ordinary member function in a
1142 template class. */
1145 }
1147 /* It was a specialization of a template. */
1150 {
1155 }
1156 else
1159 }
1161 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1162 but with the default argument values filled in from those in the
1163 TMPL_TYPES. */
1165 static tree
1167 tmpl_types)
1168 tree spec_types;
1169 tree tmpl_types;
1170 {
1171 tree new_spec_types;
1179 /* Substitute into the rest of the list. */
1180 new_spec_types =
1184 /* Add the default argument for this parameter. */
1187 new_spec_types);
1188 }
1190 /* DECL is an explicit specialization. Replicate default arguments
1191 from the template it specializes. (That way, code like:
1193 template <class T> void f(T = 3);
1194 template <> void f(double);
1195 void g () { f (); }
1197 works, as required.) An alternative approach would be to look up
1198 the correct default arguments at the call-site, but this approach
1199 is consistent with how implicit instantiations are handled. */
1201 static void
1203 tree decl;
1204 {
1205 tree tmpl;
1206 tree spec_types;
1207 tree tmpl_types;
1208 tree new_spec_types;
1209 tree old_type;
1210 tree new_type;
1211 tree t;
1216 /* See if there's anything we need to do. */
1229 {
1230 /* Remove the this pointer, but remember the object's type for
1231 CV quals. */
1237 {
1238 /* DECL may contain more parameters than TMPL due to the extra
1239 in-charge parameter in constructors and destructors. */
1242 }
1244 {
1247 }
1248 }
1250 /* Compute the merged default arguments. */
1251 new_spec_types =
1254 /* Compute the new FUNCTION_TYPE. */
1256 {
1260 new_spec_types);
1263 /* Put the in-charge parameter back. */
1266 new_spec_types);
1270 new_spec_types);
1271 }
1272 else
1274 new_spec_types);
1280 }
1282 /* Check to see if the function just declared, as indicated in
1283 DECLARATOR, and in DECL, is a specialization of a function
1284 template. We may also discover that the declaration is an explicit
1285 instantiation at this point.
1287 Returns DECL, or an equivalent declaration that should be used
1288 instead if all goes well. Issues an error message if something is
1289 amiss. Returns error_mark_node if the error is not easily
1290 recoverable.
1292 FLAGS is a bitmask consisting of the following flags:
1294 2: The function has a definition.
1295 4: The function is a friend.
1297 The TEMPLATE_COUNT is the number of references to qualifying
1298 template classes that appeared in the name of the function. For
1299 example, in
1301 template <class T> struct S { void f(); };
1302 void S<int>::f();
1304 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1305 classes are not counted in the TEMPLATE_COUNT, so that in
1307 template <class T> struct S {};
1308 template <> struct S<int> { void f(); }
1309 template <> void S<int>::f();
1311 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1312 illegal; there should be no template <>.)
1314 If the function is a specialization, it is marked as such via
1315 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1316 is set up correctly, and it is added to the list of specializations
1317 for that template. */
1319 tree
1321 tree declarator;
1322 tree decl;
1325 {
1333 tmpl_spec_kind tsk;
1338 {
1341 {
1344 }
1346 {
1348 /* This could be something like:
1350 template <class T> void f(T);
1351 class S { friend void f<>(int); } */
1353 else
1354 {
1355 /* This case handles bogus declarations like template <>
1356 template <class T> void f<int>(); */
1359 declarator);
1361 }
1362 }
1366 /* The error has already been reported in
1367 check_specialization_scope. */
1373 /* Fall through. */
1384 decl);
1387 /* Fall through. */
1392 else
1398 {
1400 decl);
1402 }
1407 {
1408 /* For backwards compatibility, we accept:
1410 template <class T> struct S { void f(); };
1411 void S<int>::f() {} // Missing template <>
1413 That used to be legal C++. */
1415 pedwarn
1419 }
1424 {
1425 /* This case handles bogus declarations like template <>
1426 template <class T> void f<int>(); */
1430 declarator);
1431 else
1433 declarator);
1435 }
1438 /* This is a specialization of a member template, without
1439 specialization the containing class. Something like:
1441 template <class T> struct S {
1442 template <class U> void f (U);
1443 };
1444 template <> template <class U> void S<int>::f(U) {}
1446 That's a specialization -- but of the entire template. */
1452 }
1455 {
1459 {
1460 pedwarn
1463 }
1466 }
1469 {
1473 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1475 {
1476 tree fns;
1482 else
1485 declarator =
1487 }
1493 {
1495 /* A specialization in class scope. This is illegal,
1496 but the error will already have been flagged by
1497 check_specialization_scope. */
1499 else
1500 {
1501 /* It's not legal to write an explicit instantiation in
1502 class scope, e.g.:
1504 class C { template void f(); }
1506 This case is caught by the parser. However, on
1507 something like:
1509 template class C { void f(); };
1511 (which is illegal) we can get here. The error will be
1512 issued later. */
1513 ;
1514 }
1517 }
1519 {
1520 /* A friend declaration. We can't do much, because we don't
1521 know what this resolves to, yet. */
1526 }
1529 IDENTIFIER_NODE))
1530 {
1531 /* Find the list of functions in ctype that have the same
1532 name as the declared function. */
1539 {
1544 {
1545 /* From [temp.expl.spec]:
1547 If such an explicit specialization for the member
1548 of a class template names an implicitly-declared
1549 special member function (clause _special_), the
1550 program is ill-formed.
1552 Similar language is found in [temp.explicit]. */
1555 }
1558 }
1561 {
1565 }
1566 else
1567 {
1568 tree methods;
1570 /* For a type-conversion operator, we cannot do a
1571 name-based lookup. We might be looking for `operator
1572 int' which will be a specialization of `operator T'.
1573 So, we find *all* the conversion operators, and then
1574 select from them. */
1580 {
1584 /* There are no more conversion functions. */
1587 /* Glue all these conversion functions together
1588 with those we already have. */
1591 }
1592 }
1595 {
1599 }
1600 else
1602 }
1604 /* Figure out what exactly is being specialized at this point.
1605 Note that for an explicit instantiation, even one for a
1606 member function, we cannot tell apriori whether the
1607 instantiation is for a member template, or just a member
1608 function of a template class. Even if a member template is
1609 being instantiated, the member template arguments may be
1610 elided if they can be deduced from the rest of the
1611 declaration. */
1614 member_specialization);
1617 /* We couldn't figure out what this declaration was
1618 specializing. */
1620 else
1621 {
1625 {
1626 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1627 is done by do_decl_instantiation later. */
1633 {
1634 /* If TMPL is not the most general template (for
1635 example, if TMPL is a friend template that is
1636 injected into namespace scope), then there will
1637 be too many levels of TARGS. Remove some of them
1638 here. */
1640 tree new_targs;
1647 }
1650 }
1652 /* If this is a specialization of a member template of a
1653 template class. In we want to return the TEMPLATE_DECL,
1654 not the specialization of it. */
1656 {
1660 }
1662 /* If we thought that the DECL was a member function, but it
1663 turns out to be specializing a static member function,
1664 make DECL a static member function as well. */
1667 {
1670 }
1672 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1675 /* Inherit default function arguments from the template
1676 DECL is specializing. */
1679 /* This specialization has the same protection as the
1680 template it specializes. */
1685 /* This is not really a declaration of a specialization.
1686 It's just the name of an instantiation. But, it's not
1687 a request for an instantiation, either. */
1690 /* This is indeed a specialization. In case of constructors
1691 and destructors, we need in-charge and not-in-charge
1692 versions in V3 ABI. */
1695 /* Register this specialization so that we can find it
1696 again. */
1698 }
1699 }
1702 }
1704 /* TYPE is being declared. Verify that the use of template headers
1705 and such is reasonable. Issue error messages if not. */
1707 void
1709 tree type;
1710 {
1712 {
1713 /* We are in the scope of some `template <...>' header. */
1715 int context_depth
1720 /* This is OK; the template headers are for the context. We
1721 are actually too lenient here; like
1722 check_explicit_specialization we should consider the number
1723 of template types included in the actual declaration. For
1724 example,
1726 template <class T> struct S {
1727 template <class U> template <class V>
1728 struct I {};
1729 };
1731 is illegal, but:
1733 template <class T> struct S {
1734 template <class U> struct I;
1735 };
1737 template <class T> template <class U.
1738 struct S<T>::I {};
1740 is not. */
1741 ;
1743 /* There are two many template parameter lists. */
1745 }
1746 }
1748 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1749 parameters. These are represented in the same format used for
1750 DECL_TEMPLATE_PARMS. */
1753 tree parms1;
1754 tree parms2;
1755 {
1756 tree p1;
1757 tree p2;
1765 {
1777 {
1788 }
1789 }
1792 /* One set of parameters has more parameters lists than the
1793 other. */
1797 }
1799 /* Complain if DECL shadows a template parameter.
1801 [temp.local]: A template-parameter shall not be redeclared within its
1802 scope (including nested scopes). */
1804 void
1806 tree decl;
1807 {
1808 tree olddecl;
1810 /* If we're not in a template, we can't possibly shadow a template
1811 parameter. */
1815 /* Figure out what we're shadowing. */
1820 /* If there's no previous binding for this name, we're not shadowing
1821 anything, let alone a template parameter. */
1825 /* If we're not shadowing a template parameter, we're done. Note
1826 that OLDDECL might be an OVERLOAD (or perhaps even an
1827 ERROR_MARK), so we can't just blithely assume it to be a _DECL
1828 node. */
1832 /* We check for decl != olddecl to avoid bogus errors for using a
1833 name inside a class. We check TPFI to avoid duplicate errors for
1834 inline member templates. */
1841 }
1843 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1844 ORIG_LEVEL, DECL, and TYPE. */
1846 static tree
1851 tree decl;
1852 tree type;
1853 {
1862 }
1864 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1865 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1866 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1867 new one is created. */
1869 static tree
1871 tree index;
1872 tree type;
1874 {
1878 {
1879 tree decl
1882 type);
1883 tree t
1893 /* Template template parameters need this. */
1896 }
1899 }
1901 /* Process information from new template parameter NEXT and append it to the
1902 LIST being built. */
1904 tree
1907 {
1908 tree parm;
1910 tree defval;
1920 {
1925 else
1928 }
1929 else
1933 {
1935 /* is a const-param */
1940 /* [temp.param]
1942 The top-level cv-qualifiers on the template-parameter are
1943 ignored when determining its type. */
1946 /* A template parameter is not modifiable. */
1953 processing_template_decl,
1955 }
1956 else
1957 {
1958 tree t;
1962 {
1964 /* This is for distinguishing between real templates and template
1965 template parameters */
1969 }
1970 else
1971 {
1973 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1975 }
1982 processing_template_decl,
1984 }
1990 }
1992 /* The end of a template parameter list has been reached. Process the
1993 tree list into a parameter vector, converting each parameter into a more
1994 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1995 as PARM_DECLs. */
1997 tree
1999 tree parms;
2000 {
2005 current_template_parms
2010 {
2014 }
2019 }
2021 /* end_template_decl is called after a template declaration is seen. */
2023 void
2025 {
2031 /* This matches the pushlevel in begin_template_parm_list. */
2036 }
2038 /* Given a template argument vector containing the template PARMS.
2039 The innermost PARMS are given first. */
2041 tree
2043 {
2044 tree header;
2049 /* If there is only one level of template parameters, we do not
2050 create a TREE_VEC of TREE_VECs. Instead, we return a single
2051 TREE_VEC containing the arguments. */
2056 {
2062 {
2065 /* T will be a list if we are called from within a
2066 begin/end_template_parm_list pair, but a vector directly
2067 if within a begin/end_member_template_processing pair. */
2069 {
2075 else
2078 }
2079 }
2083 else
2085 }
2088 }
2090 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2091 template PARMS. Used by push_template_decl below. */
2093 static tree
2095 tree decl;
2096 tree parms;
2097 {
2102 {
2112 }
2115 }
2117 struct template_parm_data
2118 {
2119 /* The level of the template parameters we are currently
2120 processing. */
2123 /* The index of the specialization argument we are currently
2124 processing. */
2127 /* An array whose size is the number of template parameters. The
2128 elements are non-zero if the parameter has been used in any one
2129 of the arguments processed so far. */
2132 /* An array whose size is the number of template arguments. The
2133 elements are non-zero if the argument makes use of template
2134 parameters of this level. */
2136 };
2138 /* Subroutine of push_template_decl used to see if each template
2139 parameter in a partial specialization is used in the explicit
2140 argument list. If T is of the LEVEL given in DATA (which is
2141 treated as a template_parm_data*), then DATA->PARMS is marked
2142 appropriately. */
2144 static int
2146 tree t;
2148 {
2154 {
2157 }
2158 else
2159 {
2162 }
2165 {
2168 }
2170 /* Return zero so that for_each_template_parm will continue the
2171 traversal of the tree; we want to mark *every* template parm. */
2173 }
2175 /* Process the partial specialization DECL. */
2177 static tree
2179 tree decl;
2180 {
2194 /* We check that each of the template parameters given in the
2195 partial specialization is used in the argument list to the
2196 specialization. For example:
2198 template <class T> struct S;
2199 template <class T> struct S<T*>;
2201 The second declaration is OK because `T*' uses the template
2202 parameter T, whereas
2204 template <class T> struct S<int>;
2206 is no good. Even trickier is:
2208 template <class T>
2209 struct S1
2210 {
2211 template <class U>
2212 struct S2;
2213 template <class U>
2214 struct S2<T>;
2215 };
2217 The S2<T> declaration is actually illegal; it is a
2218 full-specialization. Of course,
2220 template <class U>
2221 struct S2<T (*)(U)>;
2223 or some such would have been OK. */
2231 {
2236 }
2239 {
2240 /* One of the template parms was not used in the
2241 specialization. */
2243 {
2246 }
2250 }
2252 /* [temp.class.spec]
2254 The argument list of the specialization shall not be identical to
2255 the implicit argument list of the primary template. */
2262 /* [temp.class.spec]
2264 A partially specialized non-type argument expression shall not
2265 involve template parameters of the partial specialization except
2266 when the argument expression is a simple identifier.
2268 The type of a template parameter corresponding to a specialized
2269 non-type argument shall not be dependent on a parameter of the
2270 specialization. */
2274 {
2279 /* This next line is the `argument expression is not just a
2280 simple identifier' condition and also the `specialized
2281 non-type argument' bit. */
2283 {
2286 else
2287 {
2288 /* Look at the corresponding template parameter,
2289 marking which template parameters its type depends
2290 upon. */
2291 tree type =
2293 i)));
2296 {
2297 /* We haven't yet initialized TPD2. Do so now. */
2298 tpd2.arg_uses_template_parms
2300 /* The number of parameters here is the number in the
2301 main template, which, as checked in the assertion
2302 above, is NARGS. */
2306 }
2308 /* Mark the template parameters. But this time, we're
2309 looking for the template parameters of the main
2310 template, not in the specialization. */
2319 {
2320 /* The type depended on some template parameters.
2321 If they are fully specialized in the
2322 specialization, that's OK. */
2327 {
2329 type,
2330 arg);
2332 }
2333 }
2334 }
2335 }
2336 }
2339 /* We've already got this specialization. */
2347 }
2349 /* Check that a template declaration's use of default arguments is not
2350 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2351 non-zero if DECL is the thing declared by a primary template.
2352 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2354 static void
2356 tree decl;
2357 tree parms;
2360 {
2363 tree parm_level;
2365 /* [temp.param]
2367 A default template-argument shall not be specified in a
2368 function template declaration or a function template definition, nor
2369 in the template-parameter-list of the definition of a member of a
2370 class template. */
2373 /* You can't have a function template declaration in a local
2374 scope, nor you can you define a member of a class template in a
2375 local scope. */
2381 /* If this is either a friend defined in the scope of the class
2382 or a member function. */
2387 current_class_type)))
2388 /* And, if it was a member function, it really was defined in
2389 the scope of the class. */
2391 /* We already checked these parameters when the template was
2392 declared, so there's no need to do it again now. This function
2393 was defined in class scope, but we're processing it's body now
2394 that the class is complete. */
2397 /* [temp.param]
2399 If a template-parameter has a default template-argument, all
2400 subsequent template-parameters shall have a default
2401 template-argument supplied. */
2403 {
2410 {
2415 {
2417 /* For better subsequent error-recovery, we indicate that
2418 there should have been a default argument. */
2420 }
2421 }
2422 }
2425 /* For an ordinary class template, default template arguments are
2426 allowed at the innermost level, e.g.:
2427 template <class T = int>
2428 struct S {};
2429 but, in a partial specialization, they're not allowed even
2430 there, as we have in [temp.class.spec]:
2432 The template parameter list of a specialization shall not
2433 contain default template argument values.
2435 So, for a partial specialization, or for a function template,
2436 we look at all of them. */
2437 ;
2438 else
2439 /* But, for a primary class template that is not a partial
2440 specialization we look at all template parameters except the
2441 innermost ones. */
2444 /* Figure out what error message to issue. */
2449 else
2453 /* If we're inside a class definition, there's no need to
2454 examine the parameters to the class itself. On the one
2455 hand, they will be checked when the class is defined, and,
2456 on the other, default arguments are legal in things like:
2457 template <class T = double>
2458 struct S { template <class U> void f(U); };
2459 Here the default argument for `S' has no bearing on the
2460 declaration of `f'. */
2462 else
2463 /* Check everything. */
2469 {
2477 {
2479 {
2482 }
2484 /* Clear out the default argument so that we are not
2485 confused later. */
2487 }
2489 /* At this point, if we're still interested in issuing messages,
2490 they must apply to classes surrounding the object declared. */
2493 }
2494 }
2496 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2497 parameters given by current_template_args, or reuses a
2498 previously existing one, if appropriate. Returns the DECL, or an
2499 equivalent one, if it is replaced via a call to duplicate_decls.
2501 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2503 tree
2505 tree decl;
2507 {
2508 tree tmpl;
2509 tree args;
2510 tree info;
2511 tree ctx;
2516 /* See if this is a partial specialization. */
2524 /* For a friend, we want the context of the friend function, not
2525 the type of which it is a friend. */
2529 /* In the case of a virtual function, we want the class in which
2530 it is defined. */
2532 else
2533 /* Otherwise, if we're currently defining some class, the DECL
2534 is assumed to be a member of the class. */
2543 /* See if this is a primary template. */
2547 {
2558 else
2560 }
2562 /* Check to see that the rules regarding the use of default
2563 arguments are not being violated. */
2576 {
2581 /* If DECL is a TYPE_DECL for a class-template, then there won't
2582 be DECL_LANG_SPECIFIC. The information equivalent to
2583 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2587 {
2588 /* Since a template declaration already existed for this
2589 class-type, we must be redeclaring it here. Make sure
2590 that the redeclaration is legal. */
2592 current_template_parms);
2593 /* We don't need to create a new TEMPLATE_DECL; just use the
2594 one we already had. */
2596 }
2597 else
2598 {
2604 {
2605 /* A specialization of a member template of a template
2606 class. */
2610 }
2611 }
2612 }
2613 else
2614 {
2619 {
2625 else
2626 {
2629 }
2630 }
2632 {
2635 }
2636 else
2643 {
2644 tree new_tmpl;
2646 /* The declaration is a specialization of a member
2647 template, declared outside the class. Therefore, the
2648 innermost template arguments will be NULL, so we
2649 replace them with the arguments determined by the
2650 earlier call to check_explicit_specialization. */
2653 new_tmpl
2664 args);
2666 }
2668 /* Make sure the template headers we got make sense. */
2673 {
2676 }
2677 else
2679 {
2684 {
2688 else
2692 }
2694 /* Perhaps we should also check that the parms are used in the
2695 appropriate qualifying scopes in the declarator? */
2699 else
2701 }
2702 }
2707 /* Push template declarations for global functions and types. Note
2708 that we do not try to push a global template friend declared in a
2709 template class; such a thing may well depend on the template
2710 parameters of the class. */
2721 {
2725 /* Don't change the name if we've already set it up. */
2728 }
2733 }
2735 tree
2737 tree decl;
2738 {
2740 }
2742 /* Called when a class template TYPE is redeclared with the indicated
2743 template PARMS, e.g.:
2745 template <class T> struct S;
2746 template <class T> struct S {}; */
2748 void
2750 tree type;
2751 tree parms;
2752 {
2753 tree tmpl;
2754 tree tmpl_parms;
2758 {
2761 }
2765 /* The type is nested in some template class. Nothing to worry
2766 about here; there are no new template parameters for the nested
2767 type. */
2774 {
2781 }
2784 {
2791 {
2795 }
2798 {
2799 /* We have in [temp.param]:
2801 A template-parameter may not be given default arguments
2802 by two different declarations in the same scope. */
2806 }
2809 /* Update the previous template parameters (which are the ones
2810 that will really count) with the new default value. */
2813 /* Update the new parameters, too; they'll be used as the
2814 parameters for any members. */
2816 }
2817 }
2819 /* Attempt to convert the non-type template parameter EXPR to the
2820 indicated TYPE. If the conversion is successful, return the
2821 converted value. If the conversion is unsuccessful, return
2822 NULL_TREE if we issued an error message, or error_mark_node if we
2823 did not. We issue error messages for out-and-out bad template
2824 parameters, but not simply because the conversion failed, since we
2825 might be just trying to do argument deduction. By the time this
2826 function is called, neither TYPE nor EXPR may make use of template
2827 parameters. */
2829 static tree
2831 tree type;
2832 tree expr;
2833 {
2836 /* A template-argument for a non-type, non-template
2837 template-parameter shall be one of:
2839 --an integral constant-expression of integral or enumeration
2840 type; or
2842 --the name of a non-type template-parameter; or
2844 --the name of an object or function with external linkage,
2845 including function templates and function template-ids but
2846 excluding non-static class members, expressed as id-expression;
2847 or
2849 --the address of an object or function with external linkage,
2850 including function templates and function template-ids but
2851 excluding non-static class members, expressed as & id-expression
2852 where the & is optional if the name refers to a function or
2853 array; or
2855 --a pointer to member expressed as described in _expr.unary.op_. */
2857 /* An integral constant-expression can include const variables or
2858 enumerators. Simplify things by folding them to their values,
2859 unless we're about to bind the declaration to a reference
2860 parameter. */
2866 /* OK for now. We'll check that it has external linkage later.
2867 Check this first since if expr_type is the unknown_type_node
2868 we would otherwise complain below. */
2869 ;
2872 {
2875 }
2880 /* If expr is the address of an overloaded function, we
2881 will get the unknown_type_node at this point. */
2883 {
2884 tree referent;
2892 else
2893 {
2895 {
2896 bad_argument:
2899 {
2902 else
2904 }
2910 }
2914 }
2917 {
2918 error ("string literal %E is not a valid template argument because it is the address of an object with static linkage",
2919 referent);
2921 }
2924 /* We'll check that it has external linkage later. */
2925 ;
2929 {
2932 }
2933 }
2937 {
2939 {
2940 non_constant:
2942 expr);
2944 }
2945 }
2946 else
2947 {
2950 }
2953 {
2957 /* For a non-type template-parameter of integral or enumeration
2958 type, integral promotions (_conv.prom_) and integral
2959 conversions (_conv.integral_) are applied. */
2963 /* It's safe to call digest_init in this case; we know we're
2964 just converting one integral constant expression to another. */
2968 /* Curiously, some TREE_CONSTANT integral expressions do not
2969 simplify to integer constants. For example, `3 % 0',
2970 remains a TRUNC_MOD_EXPR. */
2976 {
2980 {
2981 tree e;
2983 /* For a non-type template-parameter of type pointer to data
2984 member, qualification conversions (_conv.qual_) are
2985 applied. */
2988 /* The call to perform_qualification_conversions will
2989 insert a NOP_EXPR over EXPR to do express conversion,
2990 if necessary. But, that will confuse us if we use
2991 this (converted) template parameter to instantiate
2992 another template; then the thing will not look like a
2993 valid template argument. So, just make a new
2994 constant, of the appropriate type. */
2997 }
2999 {
3000 /* For a non-type template-parameter of type pointer to
3001 function, only the function-to-pointer conversion
3002 (_conv.func_) is applied. If the template-argument
3003 represents a set of overloaded functions (or a pointer to
3004 such), the matching function is selected from the set
3005 (_over.over_). */
3006 tree fns;
3007 tree fn;
3011 else
3020 {
3023 else
3025 }
3032 }
3033 else
3034 {
3035 /* For a non-type template-parameter of type pointer to
3036 object, qualification conversions (_conv.qual_) and the
3037 array-to-pointer conversion (_conv.array_) are applied.
3038 [Note: In particular, neither the null pointer conversion
3039 (_conv.ptr_) nor the derived-to-base conversion
3040 (_conv.ptr_) are applied. Although 0 is a valid
3041 template-argument for a non-type template-parameter of
3042 integral type, it is not a valid template-argument for a
3043 non-type template-parameter of pointer type.]
3045 The call to decay_conversion performs the
3046 array-to-pointer conversion, if appropriate. */
3051 else
3053 }
3054 }
3058 {
3061 /* If this expression already has reference type, get the
3062 underling object. */
3064 {
3068 }
3071 {
3072 /* For a non-type template-parameter of type reference to
3073 function, no conversions apply. If the
3074 template-argument represents a set of overloaded
3075 functions, the matching function is selected from the
3076 set (_over.over_). */
3077 tree fn;
3085 {
3087 /* Don't issue an error here; we might get a different
3088 function if the overloading had worked out
3089 differently. */
3091 else
3093 }
3100 }
3101 else
3102 {
3103 /* For a non-type template-parameter of type reference to
3104 object, no conversions apply. The type referred to by the
3105 reference may be more cv-qualified than the (otherwise
3106 identical) type of the template-argument. The
3107 template-parameter is bound directly to the
3108 template-argument, which must be an lvalue. */
3112 expr_type)
3115 }
3119 }
3123 {
3126 /* For a non-type template-parameter of type pointer to member
3127 function, no conversions apply. If the template-argument
3128 represents a set of overloaded member functions, the
3129 matching member function is selected from the set
3130 (_over.over_). */
3137 {
3138 /* A ptr-to-member constant. */
3141 else
3143 }
3156 }
3160 /* All non-type parameters must have one of these types. */
3163 }
3166 }
3168 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3169 template template parameters. Both PARM_PARMS and ARG_PARMS are
3170 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3171 or PARM_DECL.
3173 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3174 the case, then extra parameters must have default arguments.
3176 Consider the example:
3177 template <class T, class Allocator = allocator> class vector;
3178 template<template <class U> class TT> class C;
3180 C<vector> is a valid instantiation. PARM_PARMS for the above code
3181 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3182 T and Allocator) and OUTER_ARGS contains the argument that is used to
3183 substitute the TT parameter. */
3185 static int
3191 {
3201 /* The rule here is opposite of coerce_template_parms. */
3208 {
3220 {
3225 /* We encounter instantiations of templates like
3226 template <template <template <class> class> class TT>
3227 class C; */
3228 {
3234 outer_args))
3236 }
3240 /* The tsubst call is used to handle cases such as
3241 template <class T, template <T> class TT> class D;
3242 i.e. the parameter list of TT depends on earlier parameters. */
3251 }
3252 }
3254 }
3256 /* Convert the indicated template ARG as necessary to match the
3257 indicated template PARM. Returns the converted ARG, or
3258 error_mark_node if the conversion was unsuccessful. Error messages
3259 are issued if COMPLAIN is non-zero. This conversion is for the Ith
3260 parameter in the parameter list. ARGS is the full set of template
3261 arguments deduced so far. */
3263 static tree
3265 tree parm;
3266 tree arg;
3267 tree args;
3270 tree in_decl;
3271 {
3272 tree val;
3273 tree inner_args;
3281 {
3282 /* The template argument was the name of some
3283 member function. That's usually
3284 illegal, but static members are OK. In any
3285 case, grab the underlying fields/functions
3286 and issue an error later if required. */
3289 }
3302 {
3304 /* This is a template name used within the scope of the
3305 template. It could be the template, or it could be the
3306 instantiation. Choose whichever makes sense. */
3308 else
3310 }
3311 else
3312 /* It is a non-template class, or a specialization of a template
3313 class, or a non-template member of a template class. */
3327 {
3332 complain);
3334 }
3336 {
3338 {
3340 {
3347 else
3349 }
3350 }
3352 }
3354 {
3356 {
3361 else
3363 }
3365 }
3368 {
3370 {
3372 /* The number of argument required is not known yet.
3373 Just accept it for now. */
3375 else
3376 {
3382 inner_args))
3383 {
3386 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3387 TEMPLATE_DECL. */
3391 }
3392 else
3393 {
3395 {
3399 }
3402 }
3403 }
3404 }
3405 else
3406 {
3409 {
3410 /* [basic.link]: A name with no linkage (notably, the
3411 name of a class or enumeration declared in a local
3412 scope) shall not be used to declare an entity with
3413 linkage. This implies that names with no linkage
3414 cannot be used as template arguments. */
3417 {
3419 pedwarn
3421 else
3422 error
3426 }
3427 }
3428 }
3429 }
3430 else
3431 {
3441 /* We used to call digest_init here. However, digest_init
3442 will report errors, which we don't want when complain
3443 is zero. More importantly, digest_init will try too
3444 hard to convert things: for example, `0' should not be
3445 converted to pointer type at this point according to
3446 the standard. Accepting this is not merely an
3447 extension, since deciding whether or not these
3448 conversions can occur is part of determining which
3449 function template to call, or whether a given explicit
3450 argument specification is legal. */
3452 else
3460 }
3463 }
3465 /* Convert all template arguments to their appropriate types, and
3466 return a vector containing the innermost resulting template
3467 arguments. If any error occurs, return error_mark_node, and, if
3468 COMPLAIN is non-zero, issue an error message. Some error messages
3469 are issued even if COMPLAIN is zero; for instance, if a template
3470 argument is composed from a local class.
3472 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3473 provided in ARGLIST, or else trailing parameters must have default
3474 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3475 deduction for any unspecified trailing arguments. */
3477 static tree
3479 complain,
3480 require_all_arguments)
3482 tree in_decl;
3485 {
3487 tree inner_args;
3488 tree new_args;
3489 tree new_inner_args;
3497 && require_all_arguments
3499 {
3501 {
3507 }
3510 }
3515 {
3516 tree arg;
3517 tree parm;
3519 /* Get the Ith template parameter. */
3522 /* Calculate the Ith argument. */
3524 {
3527 }
3530 /* If no template argument was supplied, look for a default
3531 value. */
3533 {
3534 /* There was no default value. */
3537 }
3540 else
3542 in_decl);
3544 /* Now, convert the Ith argument, as necessary. */
3546 /* We're out of arguments. */
3547 {
3550 }
3552 {
3555 }
3556 else
3559 in_decl);
3562 lost++;
3564 }
3570 }
3572 /* Returns 1 if template args OT and NT are equivalent. */
3574 static int
3577 {
3582 /* For member templates */
3588 else
3590 }
3592 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3593 of template arguments. Returns 0 otherwise. */
3595 int
3598 {
3605 {
3611 }
3613 }
3615 /* Given class template name and parameter list, produce a user-friendly name
3616 for the instantiation. */
3622 {
3629 else
3633 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
3634 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
3642 {
3650 {
3653 }
3655 {
3657 {
3658 /* Already substituted with real template. Just output
3659 the template name here */
3662 {
3663 /* The template may be defined in a namespace, or
3664 may be a member template. */
3670 }
3672 }
3673 else
3674 /* Output the parameter declaration */
3677 }
3678 else
3682 {
3683 /* New list cell was built because old chain link was in
3684 use. */
3687 }
3688 /* No need to check arglist against parmlist here; we did that
3689 in coerce_template_parms, called from lookup_template_class. */
3691 }
3692 {
3696 offset--;
3699 /* B<C<char> >, not B<C<char>> */
3702 }
3706 }
3708 static tree
3710 tree t;
3711 {
3713 /* Specializations have already had their names set up in
3714 lookup_template_class. */
3716 {
3719 /* For non-primary templates, the template parameters are
3720 implicit from their surrounding context. */
3722 {
3731 }
3732 }
3735 }
3737 static void
3739 tree d;
3740 {
3744 tree pt;
3750 /* We are called both from instantiate_decl, where we've already had a
3751 tinst_level pushed, and instantiate_template, where we haven't.
3752 Compensate. */
3761 else
3770 }
3773 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3774 may be either a _DECL or an overloaded function or an
3775 IDENTIFIER_NODE), and ARGLIST. */
3777 tree
3780 {
3781 tree type;
3784 {
3787 }
3795 else
3797 }
3799 /* Within the scope of a template class S<T>, the name S gets bound
3800 (in build_self_reference) to a TYPE_DECL for the class, not a
3801 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3802 or one of its enclosing classes, and that type is a template,
3803 return the associated TEMPLATE_DECL. Otherwise, the original
3804 DECL is returned. */
3806 static tree
3808 tree decl;
3809 {
3816 }
3818 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3819 parameters, find the desired type.
3821 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3822 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3823 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3824 otherwise.)
3826 IN_DECL, if non-NULL, is the template declaration we are trying to
3827 instantiate.
3829 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3830 the class we are looking up.
3832 If COMPLAIN is non-zero, issue error messages.
3834 If the template class is really a local class in a template
3835 function, then the FUNCTION_CONTEXT is the function in which it is
3836 being instantiated. */
3838 tree
3841 tree in_decl;
3842 tree context;
3845 {
3847 tree t;
3850 {
3854 else
3855 {
3862 }
3865 }
3867 {
3870 /* If we are declaring a constructor, say A<T>::A<T>, we will get
3871 an implicit typename for the second A. Deal with it. */
3876 {
3879 }
3880 }
3883 {
3886 }
3889 {
3893 }
3895 /* With something like `template <class T> class X class X { ... };'
3896 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3897 We don't want to do that, but we have to deal with the situation,
3898 so let's give them some syntax errors to chew on instead of a
3899 crash. Alternatively D1 might not be a template type at all. */
3901 {
3905 }
3908 /* If we're called from the parser, make sure it's a user visible
3909 template. */
3913 {
3915 {
3919 }
3921 }
3924 {
3925 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3926 template arguments */
3928 tree parm;
3929 tree arglist2;
3933 /* Consider an example where a template template parameter declared as
3935 template <class T, class U = std::allocator<T> > class TT
3937 The template parameter level of T and U are one level larger than
3938 of TT. To proper process the default argument of U, say when an
3939 instantiation `TT<int>' is seen, we need to build the full
3940 arguments containing {int} as the innermost level. Outer levels
3941 can be obtained from `current_template_args ()'. */
3953 }
3954 else
3955 {
3957 tree gen_tmpl;
3958 tree type_decl;
3971 {
3972 /* We've been given an incomplete set of template arguments.
3973 For example, given:
3975 template <class T> struct S1 {
3976 template <class U> struct S2 {};
3977 template <class U> struct S2<U*> {};
3978 };
3980 we will be called with an ARGLIST of `U*', but the
3981 TEMPLATE will be `template <class T> template
3982 <class U> struct S1<T>::S2'. We must fill in the missing
3983 arguments. */
3984 arglist
3986 arglist);
3988 }
3990 /* Now we should have enough arguments. */
3993 /* From here on, we're only interested in the most general
3994 template. */
3997 /* Calculate the BOUND_ARGS. These will be the args that are
3998 actually tsubst'd into the definition to create the
3999 instantiation. */
4001 {
4002 /* We have multiple levels of arguments to coerce, at once. */
4012 {
4018 /* We temporarily reduce the length of the ARGLIST so
4019 that coerce_template_parms will see only the arguments
4020 corresponding to the template parameters it is
4021 examining. */
4023 }
4025 /* Restore the ARGLIST to its full size. */
4029 }
4030 else
4031 arglist
4038 /* We were unable to bind the arguments. */
4041 /* In the scope of a template class, explicit references to the
4042 template class refer to the type of the template, not any
4043 instantiation of it. For example, in:
4045 template <class T> class C { void f(C<T>); }
4047 the `C<T>' is just the same as `C'. Outside of the
4048 class, however, such a reference is an instantiation. */
4050 arglist))
4051 {
4055 {
4056 tree ctx;
4058 /* Note that we use DECL_CONTEXT, rather than
4059 CP_DECL_CONTEXT, so that the termination test is
4060 always just `ctx'. We're not interested in namespace
4061 scopes. */
4063 ctx;
4069 /* We're not in the scope of the class, so the
4070 TEMPLATE_TYPE is not the type we want after
4071 all. */
4073 }
4074 }
4082 {
4085 /* Use the move-to-front heuristic to speed up future
4086 searches. */
4093 }
4095 /* This type is a "partial instantiation" if any of the template
4096 arguments still involve template parameters. Note that we set
4097 IS_PARTIAL_INSTANTIATION for partial specializations as
4098 well. */
4104 {
4109 }
4116 /* Create the type. */
4118 {
4120 {
4123 }
4124 else
4125 /* We don't want to call start_enum for this type, since
4126 the values for the enumeration constants may involve
4127 template parameters. And, no one should be interested
4128 in the enumeration constants for such a type. */
4130 }
4131 else
4132 {
4140 /* A local class. Make sure the decl gets registered properly. */
4143 }
4145 /* If we called start_enum or pushtag above, this information
4146 will already be set up. */
4148 {
4158 }
4159 else
4162 /* Set up the template information. We have to figure out which
4163 template is the immediate parent if this is a full
4164 instantiation. */
4167 /* This case is easy; there are no member templates involved. */
4169 else
4170 {
4171 /* This is a full instantiation of a member template. Look
4172 for a partial instantiation of which this is an instance. */
4176 {
4180 /* We only want partial instantiations, here, not
4181 specializations or full instantiations. */
4186 /* Temporarily reduce by one the number of levels in the
4187 ARGLIST and in FOUND so as to avoid comparing the
4188 last set of arguments. */
4192 /* See if the arguments match. If they do, then TMPL is
4193 the partial instantiation we want. */
4196 /* Restore the argument vectors to their full size. */
4201 {
4204 }
4205 }
4208 {
4209 /* There was no partial instantiation. This happens
4210 where C<T> is a member template of A<T> and it's used
4211 in something like
4213 template <typename T> struct B { A<T>::C<int> m; };
4214 B<float>;
4216 Create the partial instantiation.
4217 */
4221 }
4222 }
4231 /* Now that the type has been registered on the instantiations
4232 list, we set up the enumerators. Because the enumeration
4233 constants may involve the enumeration type itself, we make
4234 sure to register the type first, and then create the
4235 constants. That way, doing tsubst_expr for the enumeration
4236 constants won't result in recursive calls here; we'll find
4237 the instantiation and exit above. */
4240 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4241 is set up. */
4245 {
4246 /* For backwards compatibility; code that uses
4247 -fexternal-templates expects looking up a template to
4248 instantiate it. I think DDD still relies on this.
4249 (jason 8/20/1998) */
4251 && flag_external_templates
4255 }
4256 else
4257 /* If the type makes use of template parameters, the
4258 code that generates debugging information will crash. */
4262 }
4263 }
4264 \f
4265 struct pair_fn_data
4266 {
4267 tree_fn_t fn;
4269 };
4271 /* Called from for_each_template_parm via walk_tree. */
4273 static tree
4278 {
4289 {
4293 /* Fall through. */
4305 /* Since we're not going to walk subtrees, we have to do this
4306 explicitly here. */
4309 /* Fall through. */
4312 /* Check the return type. */
4316 /* Check the parameter types. Since default arguments are not
4317 instantiated until they are needed, the TYPE_ARG_TYPES may
4318 contain expressions that involve template parameters. But,
4319 no-one should be looking at them yet. And, once they're
4320 instantiated, they don't contain template parameters, so
4321 there's no point in looking at them then, either. */
4322 {
4323 tree parm;
4329 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4330 want walk_tree walking into them itself. */
4332 }
4340 /* Fall through. */
4350 /* Record template parameters such as `T' inside `TT<T>'. */
4353 /* Fall through. */
4365 /* A template template parameter is encountered */
4370 /* Already substituted template template parameter */
4388 /* If there's no type, then this thing must be some expression
4389 involving template parameters. */
4411 }
4413 /* We didn't find any template parameters we liked. */
4415 }
4417 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4418 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4419 call FN with the parameter and the DATA.
4420 If FN returns non-zero, the iteration is terminated, and
4421 for_each_template_parm returns 1. Otherwise, the iteration
4422 continues. If FN never returns a non-zero value, the value
4423 returned by for_each_template_parm is 0. If FN is NULL, it is
4424 considered to be the function which always returns 1. */
4426 static int
4428 tree t;
4429 tree_fn_t fn;
4431 {
4434 /* Set up. */
4438 /* Walk the tree. (Conceptually, we would like to walk without
4439 duplicates, but for_each_template_parm_r recursively calls
4440 for_each_template_parm, so we would need to reorganize a fair
4441 bit to use walk_tree_without_duplicates.) */
4443 for_each_template_parm_r,
4446 }
4448 int
4450 tree t;
4451 {
4453 }
4457 #ifdef GATHER_STATISTICS
4459 #endif
4463 /* We're starting to instantiate D; record the template instantiation context
4464 for diagnostics and to restore it later. */
4466 int
4468 tree d;
4469 {
4473 {
4474 /* If the instantiation in question still has unbound template parms,
4475 we don't really care if we can't instantiate it, so just return.
4476 This happens with base instantiation for implicit `typename'. */
4481 error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
4487 }
4494 #ifdef GATHER_STATISTICS
4497 #endif
4501 }
4503 /* We're done instantiating this template; return to the instantiation
4504 context. */
4506 void
4508 {
4511 /* Restore the filename and line number stashed away when we started
4512 this instantiation. */
4520 }
4522 /* We're instantiating a deferred template; restore the template
4523 instantiation context in which the instantiation was requested, which
4524 is one step out from LEVEL. */
4526 static void
4528 tree level;
4529 {
4530 tree t;
4538 }
4540 /* Return the outermost template instantiation context, for use with
4541 -falt-external-templates. */
4543 tree
4545 {
4550 ;
4552 }
4554 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4555 vector of template arguments, as for tsubst.
4557 Returns an appropriate tsubst'd friend declaration. */
4559 static tree
4561 tree decl;
4562 tree args;
4563 {
4564 tree new_friend;
4574 /* This was a friend declared with an explicit template
4575 argument list, e.g.:
4577 friend void f<>(T);
4579 to indicate that f was a template instantiation, not a new
4580 function declaration. Now, we have to figure out what
4581 instantiation of what template. */
4582 {
4584 tree new_args;
4585 tree tmpl;
4588 /* Friend functions are looked up in the containing namespace scope.
4589 We must enter that scope, to avoid finding member functions of the
4590 current cless with same name. */
4605 }
4609 /* The NEW_FRIEND will look like an instantiation, to the
4610 compiler, but is not an instantiation from the point of view of
4611 the language. For example, we might have had:
4613 template <class T> struct S {
4614 template <class U> friend void f(T, U);
4615 };
4617 Then, in S<int>, template <class U> void f(int, U) is not an
4618 instantiation of anything. */
4621 {
4625 }
4627 /* The mangled name for the NEW_FRIEND is incorrect. The function
4628 is not a template instantiation and should not be mangled like
4629 one. Therefore, we forget the mangling here; we'll recompute it
4630 later if we need it. */
4632 {
4635 }
4638 {
4639 tree old_decl;
4640 tree new_friend_template_info;
4641 tree new_friend_result_template_info;
4642 tree ns;
4645 /* We must save some information from NEW_FRIEND before calling
4646 duplicate decls since that function will free NEW_FRIEND if
4647 possible. */
4650 {
4651 /* This declaration is a `primary' template. */
4654 new_friend_is_defn
4656 new_friend_result_template_info
4658 }
4659 else
4660 {
4663 }
4665 /* Inside pushdecl_namespace_level, we will push into the
4666 current namespace. However, the friend function should go
4667 into the namespace of the template. */
4674 {
4675 /* This new friend declaration matched an existing
4676 declaration. For example, given:
4678 template <class T> void f(T);
4679 template <class U> class C {
4680 template <class T> friend void f(T) {}
4681 };
4683 the friend declaration actually provides the definition
4684 of `f', once C has been instantiated for some type. So,
4685 old_decl will be the out-of-class template declaration,
4686 while new_friend is the in-class definition.
4688 But, if `f' was called before this point, the
4689 instantiation of `f' will have DECL_TI_ARGS corresponding
4690 to `T' but not to `U', references to which might appear
4691 in the definition of `f'. Previously, the most general
4692 template for an instantiation of `f' was the out-of-class
4693 version; now it is the in-class version. Therefore, we
4694 run through all specialization of `f', adding to their
4695 DECL_TI_ARGS appropriately. In particular, they need a
4696 new set of outer arguments, corresponding to the
4697 arguments for this class instantiation.
4699 The same situation can arise with something like this:
4701 friend void f(int);
4702 template <class T> class C {
4703 friend void f(T) {}
4704 };
4706 when `C<int>' is instantiated. Now, `f(int)' is defined
4707 in the class. */
4710 /* On the other hand, if the in-class declaration does
4711 *not* provide a definition, then we don't want to alter
4712 existing definitions. We can just leave everything
4713 alone. */
4714 ;
4715 else
4716 {
4717 /* Overwrite whatever template info was there before, if
4718 any, with the new template information pertaining to
4719 the declaration. */
4723 /* duplicate_decls will take care of this case. */
4724 ;
4725 else
4726 {
4727 tree t;
4728 tree new_friend_args;
4737 {
4743 }
4745 /* Now, since specializations are always supposed to
4746 hang off of the most general template, we must move
4747 them. */
4750 {
4755 }
4756 }
4757 }
4759 /* The information from NEW_FRIEND has been merged into OLD_DECL
4760 by duplicate_decls. */
4762 }
4763 }
4765 {
4766 /* Check to see that the declaration is really present, and,
4767 possibly obtain an improved declaration. */
4769 new_friend);
4773 }
4775 done:
4779 }
4781 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4782 template arguments, as for tsubst.
4784 Returns an appropriate tsubst'd friend type or error_mark_node on
4785 failure. */
4787 static tree
4789 tree friend_tmpl;
4790 tree args;
4791 {
4792 tree friend_type;
4793 tree tmpl;
4795 /* First, we look for a class template. */
4798 /* But, if we don't find one, it might be because we're in a
4799 situation like this:
4801 template <class T>
4802 struct S {
4803 template <class U>
4804 friend struct S;
4805 };
4807 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
4808 for `S<int>', not the TEMPLATE_DECL. */
4810 {
4813 }
4816 {
4817 /* The friend template has already been declared. Just
4818 check to see that the declarations match, and install any new
4819 default parameters. We must tsubst the default parameters,
4820 of course. We only need the innermost template parameters
4821 because that is all that redeclare_class_template will look
4822 at. */
4823 tree parms
4830 }
4831 else
4832 {
4833 /* The friend template has not already been declared. In this
4834 case, the instantiation of the template class will cause the
4835 injection of this template into the global scope. */
4838 /* The new TMPL is not an instantiation of anything, so we
4839 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4840 the new type because that is supposed to be the corresponding
4841 template decl, i.e., TMPL. */
4846 /* Inject this template into the global scope. */
4848 }
4851 }
4853 tree
4855 tree type;
4856 {
4858 tree typedecl;
4866 /* Figure out which template is being instantiated. */
4870 /* Figure out which arguments are being used to do the
4871 instantiation. */
4876 /* If this is a partial instantiation, then we can't instantiate
4877 the type; there's no telling whether or not one of the
4878 template parameters might eventually be instantiated to some
4879 value that results in a specialization being used. For
4880 example, consider:
4882 template <class T>
4883 struct S {};
4885 template <class U>
4886 void f(S<U>);
4888 template <>
4889 struct S<int> {};
4891 Now, the `S<U>' in `f<int>' is the specialization, not an
4892 instantiation of the original template. */
4895 /* Determine what specialization of the original template to
4896 instantiate. */
4898 /* There's no telling which specialization is appropriate at this
4899 point. Since all peeking at the innards of this partial
4900 instantiation are extensions (like the "implicit typename"
4901 extension, which allows users to omit the keyword `typename' on
4902 names that are declared as types in template base classes), we
4903 are free to do what we please.
4905 Trying to figure out which partial instantiation to use can
4906 cause a crash. (Some of the template arguments don't even have
4907 types.) So, we just use the most general version. */
4909 else
4910 {
4914 {
4919 {
4921 args))
4922 {
4925 }
4926 }
4929 }
4930 }
4934 else
4937 /* If the template we're instantiating is incomplete, then clearly
4938 there's nothing we can do. */
4942 /* If this is a partial instantiation, don't tsubst anything. We will
4943 only use this type for implicit typename, so the actual contents don't
4944 matter. All that matters is whether a particular name is a type. */
4946 {
4947 /* The fields set here must be kept in sync with those cleared
4948 in begin_class_definition. */
4955 /* Pretend that the type is complete, so that we will look
4956 inside it during name lookup and such. */
4959 }
4961 /* If we've recursively instantiated too many templates, stop. */
4965 /* Now we're really doing the instantiation. Mark the type as in
4966 the process of being defined. */
4972 {
4973 /* This TYPE is actually a instantiation of of a partial
4974 specialization. We replace the innermost set of ARGS with
4975 the arguments appropriate for substitution. For example,
4976 given:
4978 template <class T> struct S {};
4979 template <class T> struct S<T*> {};
4981 and supposing that we are instantiating S<int*>, ARGS will
4982 present be {int*} but we need {int}. */
4983 tree inner_args
4985 args);
4987 /* If there were multiple levels in ARGS, replacing the
4988 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4989 want, so we make a copy first. */
4991 {
4994 }
4995 else
4997 }
5000 {
5002 {
5005 }
5006 else
5007 {
5009 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
5011 }
5012 }
5013 else
5014 {
5016 }
5047 {
5052 /* Substitute into each of the bases to determine the actual
5053 basetypes. */
5055 {
5056 tree base;
5057 tree access;
5058 tree pbase;
5062 /* Substitute to figure out the base class. */
5068 /* Calculate the correct access node. */
5070 {
5075 else
5077 }
5078 else
5079 {
5084 else
5086 }
5089 }
5091 /* The list is now in reverse order; correct that. */
5094 /* Now call xref_basetypes to set up all the base-class
5095 information. */
5101 type,
5102 base_list);
5103 }
5105 /* Now that our base classes are set up, enter the scope of the
5106 class, so that name lookups into base classes, etc. will work
5107 correctly. This is precisely analogous to what we do in
5108 begin_class_definition when defining an ordinary non-template
5109 class. */
5113 {
5116 tree newtag;
5121 {
5123 /* Unfortunately, lookup_template_class sets
5124 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5125 instantiation (i.e., for the type of a member template
5126 class nested within a template class.) This behavior is
5127 required for maybe_process_partial_specialization to work
5128 correctly, but is not accurate in this case; the TAG is not
5129 an instantiation of anything. (The corresponding
5130 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
5133 /* Now, we call pushtag to put this NEWTAG into the scope of
5134 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5135 pushtag calling push_template_decl. We don't have to do
5136 this for enums because it will already have been done in
5137 tsubst_enum. */
5141 }
5142 }
5144 /* Don't replace enum constants here. */
5147 {
5148 tree r;
5150 /* The the file and line for this declaration, to assist in
5151 error message reporting. Since we called push_tinst_level
5152 above, we don't need to restore these. */
5158 {
5159 tree init;
5164 else
5173 }
5175 /* R will have a TREE_CHAIN if and only if it has already been
5176 processed by finish_member_declaration. This can happen
5177 if, for example, it is a TYPE_DECL for a class-scoped
5178 ENUMERAL_TYPE; such a thing will already have been added to
5179 the field list by tsubst_enum above. */
5181 {
5184 }
5185 }
5187 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
5188 for this instantiation. */
5190 {
5195 }
5197 /* Construct the DECL_FRIENDLIST for the new class type. */
5202 {
5203 tree friends;
5211 args));
5212 else
5214 }
5219 {
5221 tree new_friend_type;
5227 NULL_TREE);
5228 else
5229 {
5232 /* The call to xref_tag_from_type does injection for friend
5233 classes. */
5235 new_friend_type =
5238 }
5241 /* Trick make_friend_class into realizing that the friend
5242 we're adding is a template, not an ordinary class. It's
5243 important that we use make_friend_class since it will
5244 perform some error-checking and output cross-reference
5245 information. */
5253 }
5257 {
5260 }
5262 /* Set the file and line number information to whatever is given for
5263 the class itself. This puts error messages involving generated
5264 implicit functions at a predictable point, and the same point
5265 that would be used for non-template classes. */
5273 /* Clear this now so repo_template_used is happy. */
5277 /* Now that the class is complete, instantiate default arguments for
5278 any member functions. We don't do this earlier because the
5279 default arguments may reference members of the class. */
5283 /* Implicitly generated member functions will not have template
5284 information; they are not instantiations, but instead are
5285 created "fresh" for each instantiation. */
5294 }
5296 static int
5299 {
5304 /* Don't care if one declares its arg const and the other doesn't -- the
5305 main variant of the arg type is all that matters. */
5310 }
5312 /* If arg is a non-type template parameter that does not depend on template
5313 arguments, fold it like we weren't in the body of a template. */
5315 static tree
5317 tree arg;
5318 {
5320 {
5321 /* Sometimes, one of the args was an expression involving a
5322 template constant parameter, like N - 1. Now that we've
5323 tsubst'd, we might have something like 2 - 1. This will
5324 confuse lookup_template_class, so we do constant folding
5325 here. We have to unset processing_template_decl, to
5326 fool build_expr_from_tree() into building an actual
5327 tree. */
5329 /* If the TREE_TYPE of ARG is not NULL_TREE, ARG is already
5330 as simple as it's going to get, and trying to reprocess
5331 the trees will break. */
5333 {
5338 }
5341 }
5343 }
5345 /* Substitute ARGS into the vector of template arguments T. */
5347 static tree
5349 tree t;
5350 tree args;
5352 {
5359 {
5364 else
5367 NULL_TREE));
5374 }
5384 }
5386 /* Return the result of substituting ARGS into the template parameters
5387 given by PARMS. If there are m levels of ARGS and m + n levels of
5388 PARMS, then the result will contain n levels of PARMS. For
5389 example, if PARMS is `template <class T> template <class U>
5390 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5391 result will be `template <int*, double, class V>'. */
5393 static tree
5395 tree parms;
5396 tree args;
5398 {
5406 {
5407 tree new_vec =
5412 {
5421 parm_decl);
5423 }
5429 }
5432 }
5434 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5435 type T. If T is not an aggregate or enumeration type, it is
5436 handled as if by tsubst. IN_DECL is as for tsubst. If
5437 ENTERING_SCOPE is non-zero, T is the context for a template which
5438 we are presently tsubst'ing. Return the substituted value. */
5440 static tree
5442 tree t;
5443 tree args;
5445 tree in_decl;
5447 {
5452 {
5457 /* else fall through */
5461 {
5462 tree argvec;
5463 tree context;
5464 tree r;
5466 /* First, determine the context for the type we are looking
5467 up. */
5470 complain,
5472 else
5475 /* Then, figure out what arguments are appropriate for the
5476 type we are trying to find. For example, given:
5478 template <class T> struct S;
5479 template <class T, class U> void f(T, U) { S<U> su; }
5481 and supposing that we are instantiating f<int, double>,
5482 then our ARGS will be {int, double}, but, when looking up
5483 S we only want {double}. */
5485 complain);
5493 complain);
5494 }
5495 else
5496 /* This is not a template type, so there's nothing to do. */
5501 }
5502 }
5504 /* Substitute into the default argument ARG (a default argument for
5505 FN), which has the indicated TYPE. */
5507 tree
5509 tree fn;
5510 tree type;
5511 tree arg;
5512 {
5513 /* This default argument came from a template. Instantiate the
5514 default argument here, not in tsubst. In the case of
5515 something like:
5517 template <class T>
5518 struct S {
5519 static T t();
5520 void f(T = t());
5521 };
5523 we must be careful to do name lookup in the scope of S<T>,
5524 rather than in the current class. */
5533 /* Make sure the default argument is reasonable. */
5537 }
5539 /* Substitute into all the default arguments for FN. */
5541 static void
5543 tree fn;
5544 {
5545 tree arg;
5546 tree tmpl_args;
5550 /* If this function is not yet instantiated, we certainly don't need
5551 its default arguments. */
5556 arg;
5562 }
5564 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5565 (already computed) substitution of ARGS into TREE_TYPE (T), if
5566 appropriate. Return the result of the substitution. */
5568 static tree
5570 tree t;
5571 tree args;
5572 tree type;
5573 {
5579 /* Set the filename and linenumber to improve error-reporting. */
5586 {
5588 {
5589 /* We can get here when processing a member template function
5590 of a template class. */
5592 tree spec;
5596 {
5597 /* We might already have an instance of this template.
5598 The ARGS are for the surrounding class type, so the
5599 full args contain the tsubst'd args for the context,
5600 plus the innermost args from the template decl. */
5604 tree full_args;
5609 /* tsubst_template_arg_vector doesn't copy the vector if
5610 nothing changed. But, *something* should have
5611 changed. */
5616 {
5619 }
5620 }
5622 /* Make a new template decl. It will be similar to the
5623 original, but will record the current template arguments.
5624 We also create a new function declaration, which is just
5625 like the old one, but points to this new template, rather
5626 than the old one. */
5632 {
5637 }
5650 {
5657 }
5658 else
5659 {
5666 }
5672 /* The template parameters for this new template are all the
5673 template parameters for the old template, except the
5674 outermost level of parameters. */
5682 /* We don't partially instantiate partial specializations. */
5686 /* Record this partial instantiation. */
5690 }
5694 {
5695 tree ctx;
5698 tree gen_tmpl;
5703 /* Nobody should be tsubst'ing into non-template functions. */
5707 {
5708 tree spec;
5710 /* Calculate the most general template of which R is a
5711 specialization, and the complete set of arguments used to
5712 specialize R. */
5714 argvec
5719 /* Check to see if we already have this specialization. */
5723 {
5726 }
5728 /* We can see more levels of arguments than parameters if
5729 there was a specialization of a member template, like
5730 this:
5732 template <class T> struct S { template <class U> void f(); }
5733 template <> template <class U> void S<int>::f(U);
5735 Here, we'll be substituting into the specialization,
5736 because that's where we can find the code we actually
5737 want to generate, but we'll have enough arguments for
5738 the most general template.
5740 We also deal with the peculiar case:
5742 template <class T> struct S {
5743 template <class U> friend void f();
5744 };
5745 template <class U> void f() {}
5746 template S<int>;
5747 template void f<double>();
5749 Here, the ARGS for the instantiation of will be {int,
5750 double}. But, we only need as many ARGS as there are
5751 levels of template parameters in CODE_PATTERN. We are
5752 careful not to get fooled into reducing the ARGS in
5753 situations like:
5755 template <class T> struct S { template <class U> void f(U); }
5756 template <class T> template <> void S<T>::f(int) {}
5758 which we can spot because the pattern will be a
5759 specialization in this case. */
5761 parms_depth =
5766 }
5767 else
5768 {
5769 /* This special case arises when we have something like this:
5771 template <class T> struct S {
5772 friend void f<int>(int, double);
5773 };
5775 Here, the DECL_TI_TEMPLATE for the friend declaration
5776 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5777 being called from tsubst_friend_function, and we want
5778 only to create a new decl (R) with appropriate types so
5779 that we can call determine_specialization. */
5785 }
5788 {
5791 else
5796 }
5797 else
5798 {
5801 }
5806 /* We do NOT check for matching decls pushed separately at this
5807 point, as they may not represent instantiations of this
5808 template, and in any case are considered separate under the
5809 discrete model. */
5813 /* Clear out the mangled name and RTL for the instantiation. */
5824 /* Type-conversion operator. Reconstruct the name, in
5825 case it's the name of one of the template's parameters. */
5843 {
5848 }
5850 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
5851 this in the special friend case mentioned above where
5852 GEN_TMPL is NULL. */
5854 {
5860 /* We're not supposed to instantiate default arguments
5861 until they are called, for a template. But, for a
5862 declaration like:
5864 template <class T> void f ()
5865 { extern void g(int i = T()); }
5867 we should do the substitution when the template is
5868 instantiated. We handle the member function case in
5869 instantiate_class_template since the default arguments
5870 might refer to other members of the class. */
5875 }
5877 /* Copy the list of befriending classes. */
5881 {
5885 in_decl);
5886 }
5889 {
5893 /* If this is an instantiation of a member template, clone it.
5894 If it isn't, that'll be handled by
5895 clone_constructors_and_destructors. */
5898 }
5901 }
5905 {
5915 else
5927 }
5931 {
5936 /* We don't have to set DECL_CONTEXT here; it is set by
5937 finish_member_declaration. */
5943 }
5947 {
5952 }
5958 {
5959 /* If this is the canonical decl, we don't have to mess with
5960 instantiations, and often we can't (for typename, template
5961 type parms and such). Note that TYPE_NAME is not correct for
5962 the above test if we've copied the type for a typedef. */
5965 }
5967 /* Fall through. */
5970 {
5973 tree spec;
5975 tree ctx;
5978 /* Assume this is a non-local variable. */
5987 else
5988 {
5989 /* Subsequent calls to pushdecl will fill this in. */
5992 }
5994 /* Check to see if we already have this specialization. */
5996 {
6001 }
6002 else
6006 {
6009 }
6015 /* Clear out the mangled name and RTL for the instantiation. */
6019 /* Don't try to expand the initializer until someone tries to use
6020 this variable; otherwise we run into circular dependencies. */
6025 /* For __PRETTY_FUNCTION__ we have to adjust the initializer. */
6027 {
6032 }
6034 /* Even if the original location is out of scope, the newly
6035 substituted one is not. */
6040 {
6041 /* A static data member declaration is always marked
6042 external when it is declared in-class, even if an
6043 initializer is present. We mimic the non-template
6044 processing here. */
6050 }
6051 else
6057 }
6062 }
6064 /* Restore the file and line information. */
6069 }
6071 /* Substitue into the ARG_TYPES of a function type. */
6073 static tree
6075 tree arg_types;
6076 tree args;
6078 tree in_decl;
6079 {
6080 tree remaining_arg_types;
6081 tree type;
6095 {
6097 {
6101 }
6103 }
6105 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6106 top-level qualifiers as required. */
6109 /* Note that we do not substitute into default arguments here. The
6110 standard mandates that they be instantiated only when needed,
6111 which is done in build_over_call. */
6113 remaining_arg_types);
6115 }
6117 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6118 *not* handle the exception-specification for FNTYPE, because the
6119 initial substitution of explicitly provided template parameters
6120 during argument deduction forbids substitution into the
6121 exception-specification:
6123 [temp.deduct]
6125 All references in the function type of the function template to the
6126 corresponding template parameters are replaced by the specified tem-
6127 plate argument values. If a substitution in a template parameter or
6128 in the function type of the function template results in an invalid
6129 type, type deduction fails. [Note: The equivalent substitution in
6130 exception specifications is done only when the function is instanti-
6131 ated, at which point a program is ill-formed if the substitution
6132 results in an invalid type.] */
6134 static tree
6136 tree t;
6137 tree args;
6139 tree in_decl;
6140 {
6141 tree return_type;
6142 tree arg_types;
6143 tree fntype;
6145 /* The TYPE_CONTEXT is not used for function/method types. */
6148 /* Substitute the return type. */
6153 /* Substitue the argument types. */
6159 /* Construct a new type node and return it. */
6162 else
6163 {
6166 {
6167 /* [temp.deduct]
6169 Type deduction may fail for any of the following
6170 reasons:
6172 -- Attempting to create "pointer to member of T" when T
6173 is not a class type. */
6176 r);
6178 }
6182 }
6187 }
6189 /* Substitute into the PARMS of a call-declarator. */
6191 static tree
6193 tree parms;
6194 tree args;
6196 tree in_decl;
6197 {
6198 tree new_parms;
6199 tree type;
6200 tree defarg;
6208 /* Figure out the type of this parameter. */
6211 /* Figure out the default argument as well. Note that we use
6212 tsubst_expr since the default argument is really an expression. */
6215 /* Chain this parameter on to the front of those we have already
6216 processed. We don't use hash_tree_cons because that function
6217 doesn't check TREE_PARMLIST. */
6220 /* And note that these are parameters. */
6224 }
6226 /* Take the tree structure T and replace template parameters used
6227 therein with the argument vector ARGS. IN_DECL is an associated
6228 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6229 An appropriate error message is issued only if COMPLAIN is
6230 non-zero. Note that we must be relatively non-tolerant of
6231 extensions here, in order to preserve conformance; if we allow
6232 substitutions that should not be allowed, we may allow argument
6233 deductions that should not succeed, and therefore report ambiguous
6234 overload situations where there are none. In theory, we could
6235 allow the substitution, but indicate that it should have failed,
6236 and allow our caller to make sure that the right thing happens, but
6237 we don't try to do this yet.
6239 This function is used for dealing with types, decls and the like;
6240 for expressions, use tsubst_expr or tsubst_copy. */
6242 tree
6246 tree in_decl;
6247 {
6259 else
6278 {
6305 {
6312 /* See if we can reduce this expression to something simpler. */
6318 /* When providing explicit arguments to a template
6319 function, but leaving some arguments for subsequent
6320 deduction, MAX may be template-dependent even if we're
6321 not PROCESSING_TEMPLATE_DECL. We still need to check for
6322 template parms, though; MAX won't be an INTEGER_CST for
6323 dynamic arrays, either. */
6326 {
6330 integer_one_node);
6332 }
6335 {
6336 /* Still allow an explicit array of size zero. */
6339 }
6343 {
6344 /* [temp.deduct]
6346 Type deduction may fail for any of the following
6347 reasons:
6349 Attempting to create an array with a size that is
6350 zero or negative. */
6355 }
6358 }
6364 {
6374 {
6377 }
6378 else
6379 {
6382 }
6385 {
6395 {
6397 {
6399 return cp_build_qualified_type_real
6401 complain);
6402 }
6404 {
6405 /* We are processing a type constructed from
6406 a template template parameter */
6412 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6413 we are resolving nested-types in the signature of
6414 a member function templates.
6415 Otherwise ARG is a TEMPLATE_DECL and is the real
6416 template to be instantiated. */
6424 complain);
6427 complain);
6428 }
6429 else
6430 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
6432 }
6433 }
6434 else
6438 /* This can happen during the attempted tsubst'ing in
6439 unify. This means that we don't yet have any information
6440 about the template parameter in question. */
6443 /* If we get here, we must have been looking at a parm for a
6444 more deeply nested template. Make a new version of this
6445 template parameter, but with a lower level. */
6447 {
6452 {
6455 complain);
6456 }
6457 else
6458 {
6469 {
6477 }
6478 }
6487 }
6490 }
6493 {
6501 {
6505 }
6508 {
6512 }
6515 {
6519 }
6525 {
6528 }
6529 else
6532 }
6535 {
6536 /* A binfo node. We always need to make a copy, of the node
6537 itself and of its BINFO_BASETYPES. */
6541 /* Make sure type isn't a typedef copy. */
6546 {
6551 }
6553 }
6555 /* Otherwise, a vector of template arguments. */
6560 {
6569 /* [temp.deduct]
6571 Type deduction may fail for any of the following
6572 reasons:
6574 -- Attempting to create a pointer to reference type.
6575 -- Attempting to create a reference to a reference type or
6576 a reference to void. */
6579 {
6583 /* We keep track of the last time we issued this error
6584 message to avoid spewing a ton of messages during a
6585 single bad template instantiation. */
6588 {
6591 else
6594 type);
6597 }
6600 }
6602 {
6606 }
6607 else
6612 /* Will this ever be needed for TYPE_..._TO values? */
6616 }
6618 {
6621 {
6622 /* [temp.deduct]
6624 Type deduction may fail for any of the following
6625 reasons:
6627 -- Attempting to create "pointer to member of T" when T
6628 is not a class type. */
6631 r);
6633 }
6635 {
6640 }
6643 /* This is really a method type. The cv qualifiers of the
6644 this pointer should _not_ be determined by the cv
6645 qualifiers of the class type. They should be held
6646 somewhere in the FUNCTION_TYPE, but we don't do that at
6647 the moment. Consider
6648 typedef void (Func) () const;
6650 template <typename T1> void Foo (Func T1::*);
6652 */
6656 else
6658 }
6661 {
6662 tree fntype;
6663 tree raises;
6669 /* Substitue the exception specification. */
6672 {
6677 else
6679 {
6686 }
6688 }
6690 }
6692 {
6697 /* As an optimization, we avoid regenerating the array type if
6698 it will obviously be the same as T. */
6702 /* These checks should match the ones in grokdeclarator.
6704 [temp.deduct]
6706 The deduction may fail for any of the following reasons:
6708 -- Attempting to create an array with an element type that
6709 is void, a function type, or a reference type. */
6713 {
6717 }
6721 }
6725 {
6727 in_decl);
6729 in_decl);
6735 }
6739 {
6741 in_decl);
6746 }
6749 {
6759 {
6762 ctx);
6764 }
6766 {
6767 /* Normally, make_typename_type does not require that the CTX
6768 have complete type in order to allow things like:
6770 template <class T> struct S { typename S<T>::X Y; };
6772 But, such constructs have already been resolved by this
6773 point, so here CTX really should have complete type, unless
6774 it's a partial instantiation. */
6777 {
6781 }
6782 }
6790 complain);
6791 }
6794 {
6803 }
6806 {
6808 in_decl);
6812 }
6815 {
6817 in_decl);
6821 }
6824 {
6826 in_decl);
6828 in_decl);
6833 }
6836 {
6838 in_decl);
6839 tree e2 = (tsubst_call_declarator_parms
6849 }
6852 {
6854 in_decl);
6860 }
6863 {
6865 in_decl);
6870 }
6876 }
6877 }
6879 /* Like tsubst, but deals with expressions. This function just replaces
6880 template parms; to finish processing the resultant expression, use
6881 tsubst_expr. */
6883 tree
6887 tree in_decl;
6888 {
6890 tree r;
6898 {
6903 {
6904 tree enum_type;
6905 tree v;
6908 /* This is a global enumeration constant. */
6911 /* Unfortunately, we cannot just call lookup_name here.
6912 Consider:
6914 template <int I> int f() {
6915 enum E { a = I };
6916 struct S { void g() { E e = a; } };
6917 };
6919 When we instantiate f<7>::S::g(), say, lookup_name is not
6920 clever enough to find f<7>::a. */
6921 enum_type
6931 /* We didn't find the name. That should never happen; if
6932 name-lookup found it during preliminary parsing, we
6933 should find it again here during instantiation. */
6935 }
6940 {
6941 tree ctx;
6947 }
6960 else
6964 {
6965 /* We must tsubst into a LOOKUP_EXPR in case the names to
6966 which it refers is a conversion operator; in that case the
6967 name will change. We avoid making unnecessary copies,
6968 however. */
6973 {
6977 }
6980 }
6988 return build1
7005 return build1
7049 return build_nt
7054 {
7058 else
7059 /* Sometimes FN is a LOOKUP_EXPR. */
7061 return build_nt
7063 in_decl),
7064 NULL_TREE);
7065 }
7068 {
7071 {
7075 }
7078 {
7086 }
7087 else
7089 return build_nt
7093 NULL_TREE);
7094 }
7097 /* This processing should really occur in tsubst_expr, However,
7098 tsubst_expr does not recurse into expressions, since it
7099 assumes that there aren't any statements inside them.
7100 Instead, it simply calls build_expr_from_tree. So, we need
7101 to expand the STMT_EXPR here. */
7103 {
7108 }
7115 {
7116 r = build_nt
7121 }
7124 {
7125 r = build_nt
7131 }
7134 {
7135 r = build_nt
7141 }
7144 {
7145 /* Substituted template arguments */
7147 in_decl);
7150 {
7151 tree chain;
7154 }
7156 {
7161 }
7163 return lookup_template_function
7165 }
7168 {
7188 }
7212 {
7215 }
7216 else
7220 {
7221 r = build
7227 }
7231 in_decl),
7236 }
7237 }
7239 /* Like tsubst_copy, but also does semantic processing. */
7241 tree
7245 tree in_decl;
7246 {
7259 {
7262 finish_named_return_value
7268 {
7269 tree member_init_list;
7270 tree base_init_list;
7273 member_init_list
7275 base_init_list
7279 }
7300 {
7301 tree decl;
7302 tree init;
7309 {
7315 }
7316 else
7317 {
7322 else
7325 {
7327 /* Make sure the type is instantiated now. */
7331 /* By marking the declaration as instantiated, we avoid
7332 trying to instantiate it. Since instantiate_decl can't
7333 handle local variables, and since we've already done
7334 all that needs to be done, that's the right thing to
7335 do. */
7340 }
7341 }
7343 /* A DECL_STMT can also be used as an expression, in the condition
7344 clause of a if/for/while construct. If we aren't followed by
7345 another statement, return our decl. */
7348 }
7352 {
7360 stmt);
7365 }
7369 {
7374 stmt);
7377 }
7381 {
7388 stmt);
7389 }
7393 {
7398 stmt);
7401 {
7404 }
7407 {
7411 }
7414 }
7418 {
7422 else
7429 else
7431 }
7445 {
7446 tree val;
7454 }
7461 in_decl));
7473 /* Computed goto's must be tsubst'd into. On the other hand,
7474 non-computed gotos must not be; the identifier in question
7475 will have no binding. */
7477 else
7489 in_decl));
7495 {
7501 stmt);
7502 }
7503 else
7504 {
7507 else
7514 else
7520 else
7522 }
7526 {
7527 tree decl;
7532 {
7535 /* Prevent instantiate_decl from trying to instantiate
7536 this variable. We've already done all that needs to be
7537 done. */
7539 }
7540 else
7545 }
7559 }
7562 }
7564 /* Instantiate the indicated variable or function template TMPL with
7565 the template arguments in TARG_PTR. */
7567 tree
7570 {
7571 tree fndecl;
7572 tree gen_tmpl;
7573 tree spec;
7575 tree inner_args;
7582 /* If this function is a clone, handle it specially. */
7584 {
7586 tree clone;
7588 /* Look for the clone. */
7594 /* We should always have found the clone by now. */
7597 }
7599 /* Check to see if we already have this specialization. */
7606 {
7607 /* The TMPL is a partial instantiation. To get a full set of
7608 arguments we must add the arguments used to perform the
7609 partial instantiation. */
7611 targ_ptr);
7613 /* Check to see if we already have this specialization. */
7617 }
7623 {
7626 {
7629 {
7633 }
7634 }
7635 }
7637 /* substitute template parameters */
7640 /* The DECL_TI_TEMPLATE should always be the immediate parent
7641 template, not the most general template. */
7647 /* If we've just instantiated the main entry point for a function,
7648 instantiate all the alternate entry points as well. We do this
7649 by cloning the instantiation of the main entry point, not by
7650 instantiating the template clones. */
7655 }
7657 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
7658 arguments that are being used when calling it. TARGS is a vector
7659 into which the deduced template arguments are placed.
7661 Return zero for success, 2 for an incomplete match that doesn't resolve
7662 all the types, and 1 for complete failure. An error message will be
7663 printed only for an incomplete match.
7665 If FN is a conversion operator, or we are trying to produce a specific
7666 specialization, RETURN_TYPE is the return type desired.
7668 The EXPLICIT_TARGS are explicit template arguments provided via a
7669 template-id.
7671 The parameter STRICT is one of:
7673 DEDUCE_CALL:
7674 We are deducing arguments for a function call, as in
7675 [temp.deduct.call].
7677 DEDUCE_CONV:
7678 We are deducing arguments for a conversion function, as in
7679 [temp.deduct.conv].
7681 DEDUCE_EXACT:
7682 We are deducing arguments when doing an explicit instantiation
7683 as in [temp.explicit], when determining an explicit specialization
7684 as in [temp.expl.spec], or when taking the address of a function
7685 template, as in [temp.deduct.funcaddr].
7687 DEDUCE_ORDER:
7688 We are deducing arguments when calculating the partial
7689 ordering between specializations of function or class
7690 templates, as in [temp.func.order] and [temp.class.order].
7692 LEN is the number of parms to consider before returning success, or -1
7693 for all. This is used in partial ordering to avoid comparing parms for
7694 which no actual argument was passed, since they are not considered in
7695 overload resolution (and are explicitly excluded from consideration in
7696 partial ordering in [temp.func.order]/6). */
7698 int
7702 unification_kind_t strict;
7704 {
7705 tree parms;
7706 tree fntype;
7713 {
7714 /* [temp.deduct]
7716 The specified template arguments must match the template
7717 parameters in kind (i.e., type, nontype, template), and there
7718 must not be more arguments than there are parameters;
7719 otherwise type deduction fails.
7721 Nontype arguments must match the types of the corresponding
7722 nontype template parameters, or must be convertible to the
7723 types of the corresponding nontype parameters as specified in
7724 _temp.arg.nontype_, otherwise type deduction fails.
7726 All references in the function type of the function template
7727 to the corresponding template parameters are replaced by the
7728 specified template argument values. If a substitution in a
7729 template parameter or in the function type of the function
7730 template results in an invalid type, type deduction fails. */
7732 tree converted_args;
7734 converted_args
7745 /* Place the explicitly specified arguments in TARGS. */
7748 }
7751 /* Never do unification on the 'this' parameter. */
7756 {
7757 /* We've been given a return type to match, prepend it. */
7762 }
7764 /* We allow incomplete unification without an error message here
7765 because the standard doesn't seem to explicitly prohibit it. Our
7766 callers must be ready to deal with unification failures in any
7767 event. */
7773 /* All is well so far. Now, check:
7775 [temp.deduct]
7777 When all template arguments have been deduced, all uses of
7778 template parameters in nondeduced contexts are replaced with
7779 the corresponding deduced argument values. If the
7780 substitution results in an invalid type, as described above,
7781 type deduction fails. */
7787 }
7789 /* Adjust types before performing type deduction, as described in
7790 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
7791 sections are symmetric. PARM is the type of a function parameter
7792 or the return type of the conversion function. ARG is the type of
7793 the argument passed to the call, or the type of the value
7794 initialized with the result of the conversion function. */
7796 static int
7798 unification_kind_t strict;
7801 {
7805 {
7810 {
7811 /* Swap PARM and ARG throughout the remainder of this
7812 function; the handling is precisely symmetric since PARM
7813 will initialize ARG rather than vice versa. */
7818 }
7821 /* There is nothing to do in this case. */
7825 /* DR 214. [temp.func.order] is underspecified, and leads to no
7826 ordering between things like `T *' and `T const &' for `U *'.
7827 The former has T=U and the latter T=U*. The former looks more
7828 specialized and John Spicer considers it well-formed (the EDG
7829 compiler accepts it).
7831 John also confirms that deduction should proceed as in a function
7832 call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL.
7833 However, in ordering, ARG can have REFERENCE_TYPE, but no argument
7834 to an actual call can have such a type.
7836 If both ARG and PARM are REFERENCE_TYPE, we change neither.
7837 If only ARG is a REFERENCE_TYPE, we look through that and then
7838 proceed as with DEDUCE_CALL (which could further convert it). */
7840 {
7844 }
7848 }
7851 {
7852 /* [temp.deduct.call]
7854 If P is not a reference type:
7856 --If A is an array type, the pointer type produced by the
7857 array-to-pointer standard conversion (_conv.array_) is
7858 used in place of A for type deduction; otherwise,
7860 --If A is a function type, the pointer type produced by
7861 the function-to-pointer standard conversion
7862 (_conv.func_) is used in place of A for type deduction;
7863 otherwise,
7865 --If A is a cv-qualified type, the top level
7866 cv-qualifiers of A's type are ignored for type
7867 deduction. */
7872 else
7874 }
7876 /* [temp.deduct.call]
7878 If P is a cv-qualified type, the top level cv-qualifiers
7879 of P's type are ignored for type deduction. If P is a
7880 reference type, the type referred to by P is used for
7881 type deduction. */
7884 {
7887 }
7889 }
7891 /* Most parms like fn_type_unification.
7893 If SUBR is 1, we're being called recursively (to unify the
7894 arguments of a function or method parameter of a function
7895 template). */
7897 static int
7902 unification_kind_t strict;
7904 {
7916 /* ARGS could be NULL (via a call from parse.y to
7917 build_x_function_call). */
7923 {
7943 }
7948 again:
7955 && args
7957 {
7966 /* We can't deduce anything from this, but we might get all the
7967 template args from other function args. */
7970 /* Conversions will be performed on a function argument that
7971 corresponds with a function parameter that contains only
7972 non-deducible template parameters and explicitly specified
7973 template parameters. */
7975 {
7976 tree type;
7980 else
7981 {
7984 }
7987 {
7990 }
7991 else
7992 /* It might work; we shouldn't check now, because we might
7993 get into infinite recursion. Overload resolution will
7994 handle it. */
7998 }
8001 {
8004 {
8005 /* [temp.deduct.type] A template-argument can be deduced from
8006 a pointer to function or pointer to member function
8007 argument if the set of overloaded functions does not
8008 contain function templates and at most one of a set of
8009 overloaded functions provides a unique match. */
8016 }
8018 }
8020 {
8028 }
8030 /* Are we done with the interesting parms? */
8033 }
8034 /* Fail if we've reached the end of the parm list, and more args
8035 are present, and the parm list isn't variadic. */
8038 /* Fail if parms are left and they don't have default values. */
8044 done:
8048 {
8051 /* If this is an undeduced nontype parameter that depends on
8052 a type parameter, try another pass; its type may have been
8053 deduced from a later argument than the one from which
8054 this parameter can be deduced. */
8063 }
8065 }
8067 /* Subroutine of type_unification_real. Args are like the variables at the
8068 call site. ARG is an overloaded function (or template-id); we try
8069 deducing template args from each of the overloads, and if only one
8070 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
8072 static int
8074 sub_strict)
8076 unification_kind_t strict;
8078 {
8086 /* Handle `&x' where `x' is some static or non-static member
8087 function name. */
8093 /* Strip baselink information. */
8098 {
8099 /* If we got some explicit template args, we need to plug them into
8100 the affected templates before we try to unify, in case the
8101 explicit args will completely resolve the templates in question. */
8107 {
8115 expl_subargs);
8117 {
8119 NULL_TREE);
8124 }
8125 }
8126 }
8128 {
8130 {
8135 type,
8137 }
8138 }
8139 else
8142 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8143 to function or pointer to member function argument if the set of
8144 overloaded functions does not contain function templates and at most
8145 one of a set of overloaded functions provides a unique match.
8147 So if we found multiple possibilities, we return success but don't
8148 deduce anything. */
8151 {
8156 }
8161 }
8163 /* Subroutine of resolve_overloaded_unification; does deduction for a single
8164 overload. Fills TARGS with any deduced arguments, or error_mark_node if
8165 different overloads deduce different arguments for a given parm.
8166 Returns 1 on success. */
8168 static int
8170 sub_strict)
8172 unification_kind_t strict;
8174 {
8176 tree tempargs;
8179 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8180 to function or pointer to member function argument if the set of
8181 overloaded functions does not contain function templates and at most
8182 one of a set of overloaded functions provides a unique match.
8184 So if this is a template, just return success. */
8191 /* We don't copy orig_targs for this because if we have already deduced
8192 some template args from previous args, unify would complain when we
8193 try to deduce a template parameter for the same argument, even though
8194 there isn't really a conflict. */
8201 /* First make sure we didn't deduce anything that conflicts with
8202 explicitly specified args. */
8204 {
8211 {
8212 /* Since we're unifying against ourselves, we will fill in template
8213 args used in the function parm list with our own template parms.
8214 Discard them. */
8217 }
8220 }
8223 {
8228 }
8231 }
8233 /* Verify that nondeduce template argument agrees with the type
8234 obtained from argument deduction. Return nonzero if the
8235 verification fails.
8237 For example:
8239 struct A { typedef int X; };
8240 template <class T, class U> struct C {};
8241 template <class T> struct C<T, typename T::X> {};
8243 Then with the instantiation `C<A, int>', we can deduce that
8244 `T' is `A' but unify () does not check whether `typename T::X'
8245 is `int'. This function ensure that they agree.
8247 TARGS, PARMS are the same as the arguments of unify.
8248 ARGS contains template arguments from all levels. */
8250 static int
8253 {
8264 {
8268 /* In case we are deducing from a function argument of a function
8269 templates, some parameters may not be deduced yet. So we
8270 make sure that only fully substituted elements of PARM are
8271 compared below. */
8275 }
8277 }
8279 /* PARM is a template class (perhaps with unbound template
8280 parameters). ARG is a fully instantiated type. If ARG can be
8281 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
8282 TARGS are as for unify. */
8284 static tree
8286 tree tparms;
8287 tree targs;
8288 tree parm;
8289 tree arg;
8290 {
8291 tree copy_of_targs;
8297 /* We need to make a new template argument vector for the call to
8298 unify. If we used TARGS, we'd clutter it up with the result of
8299 the attempted unification, even if this class didn't work out.
8300 We also don't want to commit ourselves to all the unifications
8301 we've already done, since unification is supposed to be done on
8302 an argument-by-argument basis. In other words, consider the
8303 following pathological case:
8305 template <int I, int J, int K>
8306 struct S {};
8308 template <int I, int J>
8309 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
8311 template <int I, int J, int K>
8312 void f(S<I, J, K>, S<I, I, I>);
8314 void g() {
8315 S<0, 0, 0> s0;
8316 S<0, 1, 2> s2;
8318 f(s0, s2);
8319 }
8321 Now, by the time we consider the unification involving `s2', we
8322 already know that we must have `f<0, 0, 0>'. But, even though
8323 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal
8324 because there are two ways to unify base classes of S<0, 1, 2>
8325 with S<I, I, I>. If we kept the already deduced knowledge, we
8326 would reject the possibility I=1. */
8329 /* If unification failed, we're done. */
8335 }
8337 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
8338 have already discovered to be satisfactory. ARG_BINFO is the binfo
8339 for the base class of ARG that we are currently examining. */
8341 static tree
8344 tree tparms;
8345 tree targs;
8346 tree arg_binfo;
8347 tree rval;
8348 tree parm;
8350 {
8351 tree binfos;
8356 {
8360 /* If there is more than one satisfactory baseclass, then:
8362 [temp.deduct.call]
8364 If they yield more than one possible deduced A, the type
8365 deduction fails.
8367 applies. */
8372 }
8377 /* Process base types. */
8379 {
8383 /* Skip this base, if we've already seen it. */
8387 this_virtual =
8390 /* When searching for a non-virtual, we cannot mark virtually
8391 found binfos. */
8396 parm,
8397 base_binfo,
8398 rval,
8401 /* If we discovered more than one matching base class, we can
8402 stop now. */
8405 }
8408 }
8410 /* Given a template type PARM and a class type ARG, find the unique
8411 base type in ARG that is an instance of PARM. We do not examine
8412 ARG itself; only its base-classes. If there is no appropriate base
8413 class, return NULL_TREE. If there is more than one, return
8414 error_mark_node. PARM may be the type of a partial specialization,
8415 as well as a plain template type. Used by unify. */
8417 static tree
8419 tree tparms;
8420 tree targs;
8421 tree parm;
8422 tree arg;
8423 {
8424 tree rval;
8425 tree arg_binfo;
8432 NULL_TREE,
8433 GTB_IGNORE_TYPE);
8435 /* Since get_template_base_recursive marks the bases classes, we
8436 must unmark them here. */
8440 }
8442 /* Returns the level of DECL, which declares a template parameter. */
8444 static int
8446 tree decl;
8447 {
8449 {
8460 }
8461 }
8463 /* Decide whether ARG can be unified with PARM, considering only the
8464 cv-qualifiers of each type, given STRICT as documented for unify.
8465 Returns non-zero iff the unification is OK on that basis.*/
8467 static int
8470 tree arg;
8471 tree parm;
8472 {
8482 }
8484 /* Takes parameters as for type_unification. Returns 0 if the
8485 type deduction succeeds, 1 otherwise. The parameter STRICT is a
8486 bitwise or of the following flags:
8488 UNIFY_ALLOW_NONE:
8489 Require an exact match between PARM and ARG.
8490 UNIFY_ALLOW_MORE_CV_QUAL:
8491 Allow the deduced ARG to be more cv-qualified (by qualification
8492 conversion) than ARG.
8493 UNIFY_ALLOW_LESS_CV_QUAL:
8494 Allow the deduced ARG to be less cv-qualified than ARG.
8495 UNIFY_ALLOW_DERIVED:
8496 Allow the deduced ARG to be a template base class of ARG,
8497 or a pointer to a template base class of the type pointed to by
8498 ARG.
8499 UNIFY_ALLOW_INTEGER:
8500 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
8501 case for more information.
8502 UNIFY_ALLOW_OUTER_LEVEL:
8503 This is the outermost level of a deduction. Used to determine validity
8504 of qualification conversions. A valid qualification conversion must
8505 have const qualified pointers leading up to the inner type which
8506 requires additional CV quals, except at the outer level, where const
8507 is not required [conv.qual]. It would be normal to set this flag in
8508 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
8509 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
8510 This is the outermost level of a deduction, and PARM can be more CV
8511 qualified at this point.
8512 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
8513 This is the outermost level of a deduction, and PARM can be less CV
8514 qualified at this point.
8515 UNIFY_ALLOW_MAX_CORRECTION:
8516 This is an INTEGER_TYPE's maximum value. Used if the range may
8517 have been derived from a size specification, such as an array size.
8518 If the size was given by a nontype template parameter N, the maximum
8519 value will have the form N-1. The flag says that we can (and indeed
8520 must) unify N with (ARG + 1), an exception to the normal rules on
8521 folding PARM. */
8523 static int
8527 {
8529 tree targ;
8530 tree tparm;
8533 /* I don't think this will do the right thing with respect to types.
8534 But the only case I've seen it in so far has been array bounds, where
8535 signedness is the only information lost, and I think that will be
8536 okay. */
8543 /* We can't deduce anything from this, but we might get all the
8544 template args from other function args. */
8547 /* If PARM uses template parameters, then we can't bail out here,
8548 even if ARG == PARM, since we won't record unifications for the
8549 template parameters. We might need them if we're trying to
8550 figure out which of two things is more specialized. */
8554 /* Immediately reject some pairs that won't unify because of
8555 cv-qualification mismatches. */
8558 /* It is the elements of the array which hold the cv quals of an array
8559 type, and the elements might be template type parms. We'll check
8560 when we recurse. */
8562 /* We check the cv-qualifiers when unifying with template type
8563 parameters below. We want to allow ARG `const T' to unify with
8564 PARM `T' for example, when computing which of two templates
8565 is more specialized, for example. */
8580 {
8584 /* In a type which contains a nested-name-specifier, template
8585 argument values cannot be deduced for template parameters used
8586 within the nested-name-specifier. */
8596 /* The PARM is not one we're trying to unify. Just check
8597 to see if it matches ARG. */
8604 /* Check for mixed types and values. */
8612 {
8613 /* ARG must be constructed from a template class or a template
8614 template parameter. */
8619 {
8623 tree argtmplvec
8627 /* The parameter and argument roles have to be switched here
8628 in order to handle default arguments properly. For example,
8629 template<template <class> class TT> void f(TT<int>)
8630 should be able to accept vector<int> which comes from
8631 template <class T, class Allocator = allocator>
8632 class vector. */
8638 /* Deduce arguments T, i from TT<T> or TT<i>.
8639 We check each element of PARMVEC and ARGVEC individually
8640 rather than the whole TREE_VEC since they can have
8641 different number of elements. */
8644 {
8649 UNIFY_ALLOW_NONE))
8651 }
8652 }
8655 /* Fall through to deduce template name. */
8656 }
8660 {
8661 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
8663 /* Simple cases: Value already set, does match or doesn't. */
8668 }
8669 else
8670 {
8671 /* If PARM is `const T' and ARG is only `int', we don't have
8672 a match unless we are allowing additional qualification.
8673 If ARG is `const int' and PARM is just `T' that's OK;
8674 that binds `const int' to `T'. */
8679 /* Consider the case where ARG is `const volatile int' and
8680 PARM is `const T'. Then, T should be `volatile int'. */
8681 arg =
8689 /* Simple cases: Value already set, does match or doesn't. */
8694 }
8696 /* Make sure that ARG is not a variable-sized array. (Note that
8697 were talking about variable-sized arrays (like `int[n]'),
8698 rather than arrays of unknown size (like `int[]').) We'll
8699 get very confused by such a type since the bound of the array
8700 will not be computable in an instantiation. Besides, such
8701 types are not allowed in ISO C++, so we can do as we please
8702 here. */
8718 /* The PARM is not one we're trying to unify. Just check
8719 to see if it matches ARG. */
8727 {
8733 else
8735 }
8737 /* [temp.deduct.type] If, in the declaration of a function template
8738 with a non-type template-parameter, the non-type
8739 template-parameter is used in an expression in the function
8740 parameter-list and, if the corresponding template-argument is
8741 deduced, the template-argument type shall match the type of the
8742 template-parameter exactly, except that a template-argument
8743 deduced from an array bound may be of any integral type.
8744 The non-type parameter might use already deduced type parameters. */
8753 /* We haven't deduced the type of this parameter yet. Try again
8754 later. */
8756 else
8763 {
8767 /* [temp.deduct.call]
8769 A can be another pointer or pointer to member type that can
8770 be converted to the deduced A via a qualification
8771 conversion (_conv.qual_).
8773 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
8774 This will allow for additional cv-qualification of the
8775 pointed-to types if appropriate. */
8778 /* The derived-to-base conversion only persists through one
8779 level of pointers. */
8784 {
8785 /* Avoid getting confused about cv-quals; don't recurse here.
8786 Pointers to members should really be just OFFSET_TYPE, not
8787 this two-level nonsense... */
8792 }
8796 }
8815 UNIFY_ALLOW_NONE);
8828 {
8838 }
8839 /* We have already checked cv-qualification at the top of the
8840 function. */
8844 /* As far as unification is concerned, this wins. Later checks
8845 will invalidate it if necessary. */
8848 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
8849 /* Type INTEGER_CST can come from ordinary constant template args. */
8859 {
8868 UNIFY_ALLOW_NONE))
8871 }
8879 {
8886 strict);
8887 }
8890 {
8894 {
8895 /* First, we try to unify the PARM and ARG directly. */
8900 {
8901 /* Fallback to the special case allowed in
8902 [temp.deduct.call]:
8904 If P is a class, and P has the form
8905 template-id, then A can be a derived class of
8906 the deduced A. Likewise, if P is a pointer to
8907 a class of the form template-id, A can be a
8908 pointer to a derived class pointed to by the
8909 deduced A. */
8915 }
8916 }
8920 /* Perhaps PARM is something like S<U> and ARG is S<int>.
8921 Then, we should unify `int' and `U'. */
8923 else
8924 /* There's no chance of unification succeeding. */
8929 }
8947 offset:
8954 strict);
8962 /* Matched cases are handled by the ARG == PARM test above. */
8968 {
8969 /* We handle this case specially, since it comes up with
8970 arrays. In particular, something like:
8972 template <int N> void f(int (&x)[N]);
8974 Here, we are trying to unify the range type, which
8975 looks like [0 ... (N - 1)]. */
8983 }
8984 /* else fall through */
8988 {
8990 /* We're looking at an expression. This can happen with
8991 something like:
8993 template <int I>
8994 void foo(S<I>, S<I + 2>);
8996 This is a "nondeduced context":
8998 [deduct.type]
9000 The nondeduced contexts are:
9002 --A type that is a template-id in which one or more of
9003 the template-arguments is an expression that references
9004 a template-parameter.
9006 In these cases, we assume deduction succeeded, but don't
9007 actually infer any unifications. */
9012 else
9014 }
9015 else
9020 }
9021 }
9022 \f
9023 /* Called if RESULT is explicitly instantiated, or is a member of an
9024 explicitly instantiated class, or if using -frepo and the
9025 instantiation of RESULT has been assigned to this file. */
9027 void
9029 tree result;
9031 {
9033 /* The TREE_PUBLIC flag for function declarations will have been
9034 set correctly by tsubst. */
9037 /* We used to set this unconditionally; we moved that to
9038 do_decl_instantiation so it wouldn't get set on members of
9039 explicit class template instantiations. But we still need to set
9040 it here for the 'extern template' case in order to suppress
9041 implicit instantiations. */
9046 {
9050 /* Always make artificials weak. */
9053 /* For WIN32 we also want to put explicit instantiations in
9054 linkonce sections. */
9057 }
9060 }
9062 /* Given two function templates PAT1 and PAT2, return:
9064 DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER.
9066 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
9067 -1 if PAT2 is more specialized than PAT1.
9068 0 if neither is more specialized.
9070 LEN is passed through to fn_type_unification. */
9072 int
9077 {
9078 tree targs;
9092 }
9094 /* Given two class template specialization list nodes PAT1 and PAT2, return:
9096 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
9097 -1 if PAT2 is more specialized than PAT1.
9098 0 if neither is more specialized. */
9100 int
9103 {
9104 tree targs;
9118 }
9120 /* Return the template arguments that will produce the function signature
9121 DECL from the function template FN, with the explicit template
9122 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
9123 also match. Return NULL_TREE if no satisfactory arguments could be
9124 found. DEDUCE and LEN are passed through to fn_type_unification. */
9126 static tree
9130 {
9133 tree decl_type;
9134 tree decl_arg_types;
9137 /* Substitute the explicit template arguments into the type of DECL.
9138 The call to fn_type_unification will handle substitution into the
9139 FN. */
9142 {
9143 tree tmpl;
9144 tree converted_args;
9148 else
9149 /* We can get here for some illegal specializations. */
9152 converted_args
9161 NULL_TREE);
9164 }
9167 /* Never do unification on the 'this' parameter. */
9172 decl_arg_types,
9181 }
9183 /* For most uses, we want to check the return type. */
9185 tree
9188 {
9190 }
9192 /* But for resolve_overloaded_unification, we only care about the parameter
9193 types. */
9195 static tree
9198 {
9200 }
9202 /* Return the innermost template arguments that, when applied to a
9203 template specialization whose innermost template parameters are
9204 TPARMS, and whose specialization arguments are PARMS, yield the
9205 ARGS.
9207 For example, suppose we have:
9209 template <class T, class U> struct S {};
9210 template <class T> struct S<T*, int> {};
9212 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
9213 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
9214 int}. The resulting vector will be {double}, indicating that `T'
9215 is bound to `double'. */
9217 static tree
9220 {
9225 UNIFY_ALLOW_NONE))
9236 }
9238 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
9239 Pick the most specialized template, and return the corresponding
9240 instantiation, or if there is no corresponding instantiation, the
9241 template itself. If there is no most specialized template,
9242 error_mark_node is returned. If there are no templates at all,
9243 NULL_TREE is returned. */
9245 tree
9247 tree instantiations;
9248 {
9257 {
9261 ;
9262 else
9263 {
9265 {
9269 }
9271 }
9272 }
9275 {
9280 }
9283 }
9285 /* Return the most specialized of the list of templates in FNS that can
9286 produce an instantiation matching DECL, given the explicit template
9287 arguments EXPLICIT_ARGS. */
9289 static tree
9292 {
9297 {
9303 }
9306 }
9308 /* If DECL is a specialization of some template, return the most
9309 general such template. Otherwise, returns NULL_TREE.
9311 For example, given:
9313 template <class T> struct S { template <class U> void f(U); };
9315 if TMPL is `template <class U> void S<int>::f(U)' this will return
9316 the full template. This function will not trace past partial
9317 specializations, however. For example, given in addition:
9319 template <class T> struct S<T*> { template <class U> void f(U); };
9321 if TMPL is `template <class U> void S<int*>::f(U)' this will return
9322 `template <class T> template <class U> S<T*>::f(U)'. */
9324 tree
9326 tree decl;
9327 {
9328 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
9329 an immediate specialization. */
9331 {
9335 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
9336 template friend. */
9341 }
9343 /* Look for more and more general templates. */
9345 {
9346 /* The DECL_TI_TEMPLATE can be a LOOKUP_EXPR or IDENTIFIER_NODE
9347 in some cases. (See cp-tree.h for details.) */
9351 /* Stop if we run into an explicitly specialized class template. */
9358 }
9361 }
9363 /* Return the most specialized of the class template specializations
9364 of TMPL which can produce an instantiation matching ARGS, or
9365 error_mark_node if the choice is ambiguous. */
9367 static tree
9369 tree tmpl;
9370 tree args;
9371 {
9373 tree t;
9374 tree champ;
9379 {
9380 tree spec_args
9383 {
9386 }
9387 }
9396 {
9399 ;
9400 else
9401 {
9403 {
9407 }
9409 }
9410 }
9413 {
9417 }
9420 }
9422 /* called from the parser. */
9424 void
9427 {
9433 /* An error occurred, for which grokdeclarator has already issued
9434 an appropriate message. */
9437 {
9440 }
9442 {
9443 /* There is an asymmetry here in the way VAR_DECLs and
9444 FUNCTION_DECLs are handled by grokdeclarator. In the case of
9445 the latter, the DECL we get back will be marked as a
9446 template instantiation, and the appropriate
9447 DECL_TEMPLATE_INFO will be set up. This does not happen for
9448 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
9449 should handle VAR_DECLs as it currently handles
9450 FUNCTION_DECLs. */
9453 {
9456 }
9457 }
9459 {
9462 }
9463 else
9466 /* Check for various error cases. Note that if the explicit
9467 instantiation is legal the RESULT will currently be marked as an
9468 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
9469 until we get here. */
9472 {
9473 /* [temp.spec]
9475 No program shall both explicitly instantiate and explicitly
9476 specialize a template. */
9480 }
9482 {
9483 /* [temp.spec]
9485 No program shall explicitly instantiate any template more
9486 than once.
9488 We check DECL_INTERFACE_KNOWN so as not to complain when the first
9489 instantiation was `extern' and the second is not, and EXTERN_P for
9490 the opposite case. If -frepo, chances are we already got marked
9491 as an explicit instantiation because of the repo file. */
9495 /* If we've already instantiated the template, just return now. */
9498 }
9500 {
9503 }
9505 {
9508 }
9514 ;
9516 {
9520 }
9521 else
9523 storage);
9530 }
9532 void
9534 tree t;
9536 {
9542 {
9545 }
9546 }
9548 /* Perform an explicit instantiation of template class T. STORAGE, if
9549 non-null, is the RID for extern, inline or static. COMPLAIN is
9550 non-zero if this is called from the parser, zero if called recursively,
9551 since the standard is unclear (as detailed below). */
9553 void
9557 {
9566 {
9569 }
9573 /* With -fexternal-templates, explicit instantiations are treated the same
9574 as implicit ones. */
9579 {
9582 t);
9584 }
9587 {
9598 else
9599 {
9601 storage);
9603 }
9604 }
9607 {
9608 /* [temp.spec]
9610 No program shall both explicitly instantiate and explicitly
9611 specialize a template. */
9613 {
9616 }
9618 }
9620 {
9621 /* [temp.spec]
9623 No program shall explicitly instantiate any template more
9624 than once.
9626 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
9627 was `extern'. If EXTERN_P then the second is. If -frepo, chances
9628 are we already got marked as an explicit instantiation because of the
9629 repo file. All these cases are OK. */
9634 /* If we've already instantiated the template, just return now. */
9637 }
9645 {
9646 tree tmp;
9648 /* In contrast to implicit instantiation, where only the
9649 declarations, and not the definitions, of members are
9650 instantiated, we have here:
9652 [temp.explicit]
9654 The explicit instantiation of a class template specialization
9655 implies the instantiation of all of its members not
9656 previously explicitly specialized in the translation unit
9657 containing the explicit instantiation.
9659 Of course, we can't instantiate member template classes, since
9660 we don't have any arguments for them. Note that the standard
9661 is unclear on whether the instantiation of the members are
9662 *explicit* instantiations or not. We choose to be generous,
9663 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
9664 the explicit instantiation of a class where some of the members
9665 have no definition in the current translation unit. */
9671 {
9676 }
9680 {
9685 }
9691 }
9692 }
9694 /* Given a function DECL, which is a specialization of TMPL, modify
9695 DECL to be a re-instantiation of TMPL with the same template
9696 arguments. TMPL should be the template into which tsubst'ing
9697 should occur for DECL, not the most general template.
9699 One reason for doing this is a scenario like this:
9701 template <class T>
9702 void f(const T&, int i);
9704 void g() { f(3, 7); }
9706 template <class T>
9707 void f(const T& t, const int i) { }
9709 Note that when the template is first instantiated, with
9710 instantiate_template, the resulting DECL will have no name for the
9711 first parameter, and the wrong type for the second. So, when we go
9712 to instantiate the DECL, we regenerate it. */
9714 static void
9716 tree decl;
9717 tree tmpl;
9718 {
9719 /* The most general version of TMPL. */
9720 tree gen_tmpl;
9721 /* The arguments used to instantiate DECL, from the most general
9722 template. */
9723 tree args;
9724 tree code_pattern;
9725 tree new_decl;
9731 /* Unregister the specialization so that when we tsubst we will not
9732 just return DECL. We don't have to unregister DECL from TMPL
9733 because if would only be registered there if it were a partial
9734 instantiation of a specialization, which it isn't: it's a full
9735 instantiation. */
9739 /* If the DECL was not unregistered then something peculiar is
9740 happening: we created a specialization but did not call
9741 register_specialization for it. */
9745 /* Make sure that we can see identifiers, and compute access
9746 correctly, for the class members used in the declaration of
9747 this static variable. */
9750 /* Do the substitution to get the new declaration. */
9754 {
9755 /* Set up DECL_INITIAL, since tsubst doesn't. */
9759 /* Pop the class context we pushed above. */
9761 }
9763 {
9764 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
9765 new decl. */
9767 /* And don't complain about a duplicate definition. */
9769 }
9771 /* The immediate parent of the new template is still whatever it was
9772 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
9773 general template. We also reset the DECL_ASSEMBLER_NAME since
9774 tsubst always calculates the name as if the function in question
9775 were really a template instance, and sometimes, with friend
9776 functions, this is not so. See tsubst_friend_function for
9777 details. */
9783 /* Call duplicate decls to merge the old and new declarations. */
9786 /* Now, re-register the specialization. */
9788 }
9790 /* Produce the definition of D, a _DECL generated from a template. If
9791 DEFER_OK is non-zero, then we don't have to actually do the
9792 instantiation now; we just have to do it sometime. */
9794 tree
9796 tree d;
9798 {
9801 tree td;
9802 tree code_pattern;
9803 tree spec;
9804 tree gen_tmpl;
9810 /* This function should only be used to instantiate templates for
9811 functions and static member variables. */
9815 /* Don't instantiate cloned functions. Instead, instantiate the
9816 functions they cloned. */
9821 /* D has already been instantiated. It might seem reasonable to
9822 check whether or not D is an explicit instantiation, and, if so,
9823 stop here. But when an explicit instantiation is deferred
9824 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
9825 is set, even though we still need to do the instantiation. */
9828 /* If we already have a specialization of this declaration, then
9829 there's no reason to instantiate it. Note that
9830 retrieve_specialization gives us both instantiations and
9831 specializations, so we must explicitly check
9832 DECL_TEMPLATE_SPECIALIZATION. */
9838 /* This needs to happen before any tsubsting. */
9844 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
9845 for the instantiation. This is not always the most general
9846 template. Consider, for example:
9848 template <class T>
9849 struct S { template <class U> void f();
9850 template <> void f<int>(); };
9852 and an instantiation of S<double>::f<int>. We want TD to be the
9853 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
9856 more general template. */
9858 /* We must also deal with friend templates. Given:
9860 template <class T> struct S {
9861 template <class U> friend void f() {};
9862 };
9864 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
9865 so far as the language is concerned, but that's still
9866 where we get the pattern for the instantiation from. On
9867 other hand, if the definition comes outside the class, say:
9869 template <class T> struct S {
9870 template <class U> friend void f();
9871 };
9872 template <class U> friend void f() {}
9874 we don't need to look any further. That's what the check for
9875 DECL_INITIAL is for. */
9879 {
9880 /* The present template, TD, should not be a definition. If it
9881 were a definition, we should be using it! Note that we
9882 cannot restructure the loop to just keep going until we find
9883 a template with a definition, since that might go too far if
9884 a specialization was declared, but not defined. */
9889 /* Fetch the more general template. */
9891 }
9897 else
9904 {
9905 /* Let the repository code that this template definition is
9906 available.
9908 The repository doesn't need to know about cloned functions
9909 because they never actually show up in the object file. It
9910 does need to know about the clones; those are the symbols
9911 that the linker will be emitting error messages about. */
9914 {
9915 tree t;
9921 }
9922 else
9926 {
9928 {
9931 }
9933 {
9936 }
9937 else
9939 }
9943 }
9947 /* We should have set up DECL_INITIAL in instantiate_class_template. */
9949 /* Reject all external templates except inline functions. */
9955 /* Defer all other templates, unless we have been explicitly
9956 forbidden from doing so. We restore the source position here
9957 because it's used by add_pending_template. */
9959 {
9965 /* [temp.explicit]
9967 The definition of a non-exported function template, a
9968 non-exported member function template, or a non-exported
9969 member function or static data member of a class template
9970 shall be present in every translation unit in which it is
9971 explicitly instantiated. */
9972 pedwarn
9977 }
9983 /* We're now committed to instantiating this template. Mark it as
9984 instantiated so that recursive calls to instantiate_decl do not
9985 try to instantiate it again. */
9988 /* Regenerate the declaration in case the template has been modified
9989 by a subsequent redeclaration. */
9992 /* We already set the file and line above. Reset them now in case
9993 they changed as a result of calling regenerate_decl_from_template. */
9998 {
10002 else
10003 {
10006 }
10008 }
10010 {
10011 htab_t saved_local_specializations;
10013 /* Save away the current list, in case we are instantiating one
10014 template from within the body of another. */
10017 /* Set up the list of local specializations. */
10019 htab_hash_pointer,
10020 htab_eq_pointer,
10021 NULL);
10023 /* Set up context. */
10026 /* Substitute into the body of the function. */
10030 /* We don't need the local specializations any more. */
10034 /* Finish the function. */
10036 }
10038 /* We're not deferring instantiation any more. */
10044 out:
10053 }
10055 /* Run through the list of templates that we wish we could
10056 instantiate, and instantiate any we can. */
10058 int
10060 {
10066 do
10067 {
10072 {
10078 {
10079 tree fn;
10082 {
10086 fn;
10091 {
10094 }
10095 }
10098 /* If INSTANTIATION has been instantiated, then we don't
10099 need to consider it again in the future. */
10101 else
10102 {
10105 }
10106 }
10107 else
10108 {
10111 {
10115 {
10118 }
10119 }
10123 /* If INSTANTIATION has been instantiated, then we don't
10124 need to consider it again in the future. */
10126 else
10127 {
10130 }
10131 }
10134 }
10136 }
10140 }
10142 /* Substitute ARGVEC into T, which is a list of initializers for
10143 either base class or a non-static data member. The TREE_PURPOSEs
10144 are DECLs, and the TREE_VALUEs are the initializer values. Used by
10145 instantiate_decl. */
10147 static tree
10150 {
10155 {
10156 tree decl;
10157 tree init;
10158 tree val;
10161 NULL_TREE);
10163 NULL_TREE);
10166 ;
10170 else
10175 }
10177 }
10179 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
10181 static void
10183 tree decl;
10184 {
10189 else
10191 }
10193 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
10194 is the instantiation (which should have been created with
10195 start_enum) and ARGS are the template arguments to use. */
10197 static void
10199 tree tag;
10200 tree newtag;
10201 tree args;
10202 {
10203 tree e;
10206 {
10207 tree value;
10209 /* Note that in a template enum, the TREE_VALUE is the
10210 CONST_DECL, not the corresponding INTEGER_CST. */
10213 NULL_TREE);
10215 /* Give this enumeration constant the correct access. */
10218 /* Actually build the enumerator itself. */
10220 }
10225 }
10227 /* DECL is a FUNCTION_DECL that is a template specialization. Return
10228 its type -- but without substituting the innermost set of template
10229 arguments. So, innermost set of template parameters will appear in
10230 the type. If CONTEXTP is non-NULL, then the partially substituted
10231 DECL_CONTEXT (if any) will also be filled in. Similarly, TPARMSP
10232 will be filled in with the substituted template parameters, if it
10233 is non-NULL. */
10235 tree
10237 tree decl;
10240 {
10242 tree fn_type;
10243 tree tmpl;
10244 tree targs;
10245 tree tparms;
10253 /* There should be as many levels of arguments as there are levels
10254 of parameters. */
10262 /* No substitution is necessary. */
10263 ;
10264 else
10265 {
10267 tree partial_args;
10269 /* Replace the innermost level of the TARGS with NULL_TREEs to
10270 let tsubst know not to substitute for those parameters. */
10279 /* Now, do the (partial) substitution to figure out the
10280 appropriate function type. */
10285 /* Substitute into the template parameters to obtain the real
10286 innermost set of parameters. This step is important if the
10287 innermost set of template parameters contains value
10288 parameters whose types depend on outer template parameters. */
10291 }
10299 }
10301 /* Return truthvalue if we're processing a template different from
10302 the last one involved in diagnostics. */
10303 int
10305 {
10307 }
10309 /* Remember current template involved in diagnostics. */
10310 void
10312 {
10314 }
10316 tree
10318 {
10320 }
10322 /* [temp.param] Check that template non-type parm TYPE is of an allowable
10323 type. Return zero for ok, non-zero for disallowed. If COMPLAIN is
10324 non-zero, then complain. */
10326 static int
10328 tree type;
10330 {
10346 type);
10348 }