1/* Handle parameterized types (templates) for GNU C++. 2 Copyright (C) 1992, 93-97, 1998, 1999 Free Software Foundation, Inc. 3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing. 4 Rewritten by Jason Merrill (jason@cygnus.com). 5 6This file is part of GNU CC. 7 8GNU CC is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GNU CC is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GNU CC; see the file COPYING. If not, write to 20the Free Software Foundation, 59 Temple Place - Suite 330, 21Boston, MA 02111-1307, USA. */ 22 23/* Known bugs or deficiencies include: 24 25 all methods must be provided in header files; can't use a source 26 file that contains only the method templates and "just win". */ 27 28#include "config.h" 29#include "system.h" 30#include "obstack.h" 31 32#include "tree.h" 33#include "flags.h" 34#include "cp-tree.h" 35#include "decl.h" 36#include "parse.h" 37#include "lex.h" 38#include "output.h" 39#include "defaults.h" 40#include "except.h" 41#include "toplev.h" 42#include "rtl.h" 43#include "varray.h" 44 45/* The type of functions taking a tree, and some additional data, and 46 returning an int. */ 47typedef int (*tree_fn_t) PROTO((tree, void*)); 48 49extern struct obstack permanent_obstack; 50 51extern int lineno; 52extern char *input_filename; 53 54tree current_template_parms; 55HOST_WIDE_INT processing_template_decl; 56 57/* The PENDING_TEMPLATES is a TREE_LIST of templates whose 58 instantiations have been deferred, either because their definitions 59 were not yet available, or because we were putting off doing the 60 work. The TREE_PURPOSE of each entry is a SRCLOC indicating where 61 the instantiate request occurred; the TREE_VALUE is a either a DECL 62 (for a function or static data member), or a TYPE (for a class) 63 indicating what we are hoping to instantiate. */ 64static tree pending_templates; 65static tree *template_tail = &pending_templates; 66 67static tree maybe_templates; 68static tree *maybe_template_tail = &maybe_templates; 69 70int minimal_parse_mode; 71 72int processing_specialization; 73int processing_explicit_instantiation; 74int processing_template_parmlist; 75static int template_header_count; 76 77static tree saved_trees; 78static varray_type inline_parm_levels; 79static size_t inline_parm_levels_used; 80 81#define obstack_chunk_alloc xmalloc 82#define obstack_chunk_free free 83 84#define UNIFY_ALLOW_NONE 0 85#define UNIFY_ALLOW_MORE_CV_QUAL 1 86#define UNIFY_ALLOW_LESS_CV_QUAL 2 87#define UNIFY_ALLOW_DERIVED 4 88#define UNIFY_ALLOW_INTEGER 8 89 90#define GTB_VIA_VIRTUAL 1 /* The base class we are examining is 91 virtual, or a base class of a virtual 92 base. */ 93#define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current 94 type with the desired type. */ 95 96static int resolve_overloaded_unification PROTO((tree, tree, tree, tree, 97 unification_kind_t, int)); 98static int try_one_overload PROTO((tree, tree, tree, tree, tree, 99 unification_kind_t, int)); 100static int unify PROTO((tree, tree, tree, tree, int)); 101static void add_pending_template PROTO((tree)); 102static int push_tinst_level PROTO((tree)); 103static tree classtype_mangled_name PROTO((tree)); 104static char *mangle_class_name_for_template PROTO((char *, tree, tree)); 105static tree tsubst_expr_values PROTO((tree, tree)); 106static int list_eq PROTO((tree, tree)); 107static tree get_class_bindings PROTO((tree, tree, tree)); 108static tree coerce_template_parms PROTO((tree, tree, tree, int, int)); 109static void tsubst_enum PROTO((tree, tree, tree)); 110static tree add_to_template_args PROTO((tree, tree)); 111static tree add_outermost_template_args PROTO((tree, tree)); 112static void maybe_adjust_types_for_deduction PROTO((unification_kind_t, tree*, 113 tree*)); 114static int type_unification_real PROTO((tree, tree, tree, tree, 115 int, unification_kind_t, int)); 116static void note_template_header PROTO((int)); 117static tree maybe_fold_nontype_arg PROTO((tree)); 118static tree convert_nontype_argument PROTO((tree, tree)); 119static tree convert_template_argument PROTO ((tree, tree, tree, int, 120 int , tree)); 121static tree get_bindings_overload PROTO((tree, tree, tree)); 122static int for_each_template_parm PROTO((tree, tree_fn_t, void*)); 123static tree build_template_parm_index PROTO((int, int, int, tree, tree)); 124static int inline_needs_template_parms PROTO((tree)); 125static void push_inline_template_parms_recursive PROTO((tree, int)); 126static tree retrieve_specialization PROTO((tree, tree)); 127static tree register_specialization PROTO((tree, tree, tree)); 128static int unregister_specialization PROTO((tree, tree)); 129static tree reduce_template_parm_level PROTO((tree, tree, int)); 130static tree build_template_decl PROTO((tree, tree)); 131static int mark_template_parm PROTO((tree, void *)); 132static tree tsubst_friend_function PROTO((tree, tree)); 133static tree tsubst_friend_class PROTO((tree, tree)); 134static tree get_bindings_real PROTO((tree, tree, tree, int)); 135static int template_decl_level PROTO((tree)); 136static tree maybe_get_template_decl_from_type_decl PROTO((tree)); 137static int check_cv_quals_for_unify PROTO((int, tree, tree)); 138static tree tsubst_template_arg_vector PROTO((tree, tree, int)); 139static tree tsubst_template_parms PROTO((tree, tree, int)); 140static void regenerate_decl_from_template PROTO((tree, tree)); 141static tree most_specialized PROTO((tree, tree, tree)); 142static tree most_specialized_class PROTO((tree, tree)); 143static tree most_general_template PROTO((tree)); 144static void set_mangled_name_for_template_decl PROTO((tree)); 145static int template_class_depth_real PROTO((tree, int)); 146static tree tsubst_aggr_type PROTO((tree, tree, int, tree, int)); 147static tree tsubst_decl PROTO((tree, tree, tree, tree)); 148static tree tsubst_arg_types PROTO((tree, tree, int, tree)); 149static tree tsubst_function_type PROTO((tree, tree, int, tree)); 150static void check_specialization_scope PROTO((void)); 151static tree process_partial_specialization PROTO((tree)); 152static void set_current_access_from_decl PROTO((tree)); 153static void check_default_tmpl_args PROTO((tree, tree, int, int)); 154static tree tsubst_call_declarator_parms PROTO((tree, tree, int, tree)); 155static tree get_template_base_recursive PROTO((tree, tree, 156 tree, tree, tree, int)); 157static tree get_template_base PROTO((tree, tree, tree, tree)); 158static tree try_class_unification PROTO((tree, tree, tree, tree)); 159static int coerce_template_template_parms PROTO((tree, tree, int, 160 tree, tree)); 161static tree determine_specialization PROTO((tree, tree, tree *, int)); 162static int template_args_equal PROTO((tree, tree)); 163static void print_template_context PROTO((int)); 164static int has_pvbases_p PROTO((tree, tree)); 165 166/* We use TREE_VECs to hold template arguments. If there is only one 167 level of template arguments, then the TREE_VEC contains the 168 arguments directly. If there is more than one level of template 169 arguments, then each entry in the TREE_VEC is itself a TREE_VEC, 170 containing the template arguments for a single level. The first 171 entry in the outer TREE_VEC is the outermost level of template 172 parameters; the last is the innermost. 173 174 It is incorrect to ever form a template argument vector containing 175 only one level of arguments, but which is a TREE_VEC containing as 176 its only entry the TREE_VEC for that level. */ 177 178/* Non-zero if the template arguments is actually a vector of vectors, 179 rather than just a vector. */ 180#define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \ 181 (NODE != NULL_TREE \ 182 && TREE_CODE (NODE) == TREE_VEC \ 183 && TREE_VEC_LENGTH (NODE) > 0 \ 184 && TREE_VEC_ELT (NODE, 0) != NULL_TREE \ 185 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC) 186 187/* The depth of a template argument vector. When called directly by 188 the parser, we use a TREE_LIST rather than a TREE_VEC to represent 189 template arguments. In fact, we may even see NULL_TREE if there 190 are no template arguments. In both of those cases, there is only 191 one level of template arguments. */ 192#define TMPL_ARGS_DEPTH(NODE) \ 193 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1) 194 195/* The LEVELth level of the template ARGS. Note that template 196 parameter levels are indexed from 1, not from 0. */ 197#define TMPL_ARGS_LEVEL(ARGS, LEVEL) \ 198 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \ 199 ? TREE_VEC_ELT ((ARGS), (LEVEL) - 1) : ARGS) 200 201/* Set the LEVELth level of the template ARGS to VAL. This macro does 202 not work with single-level argument vectors. */ 203#define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \ 204 (TREE_VEC_ELT ((ARGS), (LEVEL) - 1) = (VAL)) 205 206/* Accesses the IDXth parameter in the LEVELth level of the ARGS. */ 207#define TMPL_ARG(ARGS, LEVEL, IDX) \ 208 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX)) 209 210/* Set the IDXth element in the LEVELth level of ARGS to VAL. This 211 macro does not work with single-level argument vectors. */ 212#define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \ 213 (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL)) 214 215/* Given a single level of template arguments in NODE, return the 216 number of arguments. */ 217#define NUM_TMPL_ARGS(NODE) \ 218 ((NODE) == NULL_TREE ? 0 \ 219 : (TREE_CODE (NODE) == TREE_VEC \ 220 ? TREE_VEC_LENGTH (NODE) : list_length (NODE))) 221 222/* The number of levels of template parameters given by NODE. */ 223#define TMPL_PARMS_DEPTH(NODE) \ 224 (TREE_INT_CST_HIGH (TREE_PURPOSE (NODE))) 225 226/* Do any processing required when DECL (a member template declaration 227 using TEMPLATE_PARAMETERS as its innermost parameter list) is 228 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless 229 it is a specialization, in which case the DECL itself is returned. */ 230 231tree 232finish_member_template_decl (decl) 233 tree decl; 234{ 235 if (decl == NULL_TREE || decl == void_type_node) 236 return NULL_TREE; 237 else if (decl == error_mark_node) 238 /* By returning NULL_TREE, the parser will just ignore this 239 declaration. We have already issued the error. */ 240 return NULL_TREE; 241 else if (TREE_CODE (decl) == TREE_LIST) 242 { 243 /* Assume that the class is the only declspec. */ 244 decl = TREE_VALUE (decl); 245 if (IS_AGGR_TYPE (decl) && CLASSTYPE_TEMPLATE_INFO (decl) 246 && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl)) 247 { 248 tree tmpl = CLASSTYPE_TI_TEMPLATE (decl); 249 check_member_template (tmpl); 250 return tmpl; 251 } 252 return NULL_TREE; 253 } 254 else if (DECL_TEMPLATE_INFO (decl)) 255 { 256 if (!DECL_TEMPLATE_SPECIALIZATION (decl)) 257 { 258 check_member_template (DECL_TI_TEMPLATE (decl)); 259 return DECL_TI_TEMPLATE (decl); 260 } 261 else 262 return decl; 263 } 264 else 265 cp_error ("invalid member template declaration `%D'", decl); 266 267 return error_mark_node; 268} 269 270/* Returns the template nesting level of the indicated class TYPE. 271 272 For example, in: 273 template <class T> 274 struct A 275 { 276 template <class U> 277 struct B {}; 278 }; 279 280 A<T>::B<U> has depth two, while A<T> has depth one. 281 Both A<T>::B<int> and A<int>::B<U> have depth one, if 282 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not 283 specializations. 284 285 This function is guaranteed to return 0 if passed NULL_TREE so 286 that, for example, `template_class_depth (current_class_type)' is 287 always safe. */ 288 289static int 290template_class_depth_real (type, count_specializations) 291 tree type; 292 int count_specializations; 293{ 294 int depth; 295 296 for (depth = 0; 297 type && TREE_CODE (type) != NAMESPACE_DECL; 298 type = (TREE_CODE (type) == FUNCTION_DECL) 299 ? DECL_REAL_CONTEXT (type) : TYPE_CONTEXT (type)) 300 { 301 if (TREE_CODE (type) != FUNCTION_DECL) 302 { 303 if (CLASSTYPE_TEMPLATE_INFO (type) 304 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)) 305 && ((count_specializations 306 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)) 307 || uses_template_parms (CLASSTYPE_TI_ARGS (type)))) 308 ++depth; 309 } 310 else 311 { 312 if (DECL_TEMPLATE_INFO (type) 313 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type)) 314 && ((count_specializations 315 && DECL_TEMPLATE_SPECIALIZATION (type)) 316 || uses_template_parms (DECL_TI_ARGS (type)))) 317 ++depth; 318 } 319 } 320 321 return depth; 322} 323 324/* Returns the template nesting level of the indicated class TYPE. 325 Like template_class_depth_real, but instantiations do not count in 326 the depth. */ 327 328int 329template_class_depth (type) 330 tree type; 331{ 332 return template_class_depth_real (type, /*count_specializations=*/0); 333} 334 335/* Returns 1 if processing DECL as part of do_pending_inlines 336 needs us to push template parms. */ 337 338static int 339inline_needs_template_parms (decl) 340 tree decl; 341{ 342 if (! DECL_TEMPLATE_INFO (decl)) 343 return 0; 344 345 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl))) 346 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl))); 347} 348 349/* Subroutine of maybe_begin_member_template_processing. 350 Push the template parms in PARMS, starting from LEVELS steps into the 351 chain, and ending at the beginning, since template parms are listed 352 innermost first. */ 353 354static void 355push_inline_template_parms_recursive (parmlist, levels) 356 tree parmlist; 357 int levels; 358{ 359 tree parms = TREE_VALUE (parmlist); 360 int i; 361 362 if (levels > 1) 363 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1); 364 365 ++processing_template_decl; 366 current_template_parms 367 = tree_cons (build_int_2 (0, processing_template_decl), 368 parms, current_template_parms); 369 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1; 370 371 pushlevel (0); 372 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i) 373 { 374 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); 375 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm)) == 'd', 0); 376 377 switch (TREE_CODE (parm)) 378 { 379 case TYPE_DECL: 380 case TEMPLATE_DECL: 381 pushdecl (parm); 382 break; 383 384 case PARM_DECL: 385 { 386 /* Make a CONST_DECL as is done in process_template_parm. 387 It is ugly that we recreate this here; the original 388 version built in process_template_parm is no longer 389 available. */ 390 tree decl = build_decl (CONST_DECL, DECL_NAME (parm), 391 TREE_TYPE (parm)); 392 SET_DECL_ARTIFICIAL (decl); 393 DECL_INITIAL (decl) = DECL_INITIAL (parm); 394 DECL_TEMPLATE_PARM_P (decl) = 1; 395 pushdecl (decl); 396 } 397 break; 398 399 default: 400 my_friendly_abort (0); 401 } 402 } 403} 404 405/* Restore the template parameter context for a member template or 406 a friend template defined in a class definition. */ 407 408void 409maybe_begin_member_template_processing (decl) 410 tree decl; 411{ 412 tree parms; 413 int levels = 0; 414 415 if (inline_needs_template_parms (decl)) 416 { 417 parms = DECL_TEMPLATE_PARMS (most_general_template (decl)); 418 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl; 419 420 if (DECL_TEMPLATE_SPECIALIZATION (decl)) 421 { 422 --levels; 423 parms = TREE_CHAIN (parms); 424 } 425 426 push_inline_template_parms_recursive (parms, levels); 427 } 428 429 /* Remember how many levels of template parameters we pushed so that 430 we can pop them later. */ 431 if (!inline_parm_levels) 432 VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels"); 433 if (inline_parm_levels_used == inline_parm_levels->num_elements) 434 VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used); 435 VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels; 436 ++inline_parm_levels_used; 437} 438 439/* Undo the effects of begin_member_template_processing. */ 440 441void 442maybe_end_member_template_processing () 443{ 444 int i; 445 446 if (!inline_parm_levels_used) 447 return; 448 449 --inline_parm_levels_used; 450 for (i = 0; 451 i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used); 452 ++i) 453 { 454 --processing_template_decl; 455 current_template_parms = TREE_CHAIN (current_template_parms); 456 poplevel (0, 0, 0); 457 } 458} 459 460/* Returns non-zero iff T is a member template function. We must be 461 careful as in 462 463 template <class T> class C { void f(); } 464 465 Here, f is a template function, and a member, but not a member 466 template. This function does not concern itself with the origin of 467 T, only its present state. So if we have 468 469 template <class T> class C { template <class U> void f(U); } 470 471 then neither C<int>::f<char> nor C<T>::f<double> is considered 472 to be a member template. But, `template <class U> void 473 C<int>::f(U)' is considered a member template. */ 474 475int 476is_member_template (t) 477 tree t; 478{ 479 if (!DECL_FUNCTION_TEMPLATE_P (t)) 480 /* Anything that isn't a function or a template function is 481 certainly not a member template. */ 482 return 0; 483 484 /* A local class can't have member templates. */ 485 if (hack_decl_function_context (t)) 486 return 0; 487 488 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t)) 489 /* If there are more levels of template parameters than 490 there are template classes surrounding the declaration, 491 then we have a member template. */ 492 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) > 493 template_class_depth (DECL_CLASS_CONTEXT (t)))); 494} 495 496#if 0 /* UNUSED */ 497/* Returns non-zero iff T is a member template class. See 498 is_member_template for a description of what precisely constitutes 499 a member template. */ 500 501int 502is_member_template_class (t) 503 tree t; 504{ 505 if (!DECL_CLASS_TEMPLATE_P (t)) 506 /* Anything that isn't a class template, is certainly not a member 507 template. */ 508 return 0; 509 510 if (!DECL_CLASS_SCOPE_P (t)) 511 /* Anything whose context isn't a class type is surely not a 512 member template. */ 513 return 0; 514 515 /* If there are more levels of template parameters than there are 516 template classes surrounding the declaration, then we have a 517 member template. */ 518 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) > 519 template_class_depth (DECL_CONTEXT (t))); 520} 521#endif 522 523/* Return a new template argument vector which contains all of ARGS, 524 but has as its innermost set of arguments the EXTRA_ARGS. The 525 resulting vector will be built on a temporary obstack, and so must 526 be explicitly copied to the permanent obstack, if required. */ 527 528static tree 529add_to_template_args (args, extra_args) 530 tree args; 531 tree extra_args; 532{ 533 tree new_args; 534 int extra_depth; 535 int i; 536 int j; 537 538 extra_depth = TMPL_ARGS_DEPTH (extra_args); 539 new_args = make_temp_vec (TMPL_ARGS_DEPTH (args) + extra_depth); 540 541 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i) 542 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i)); 543 544 for (j = 1; j <= extra_depth; ++j, ++i) 545 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j)); 546 547 return new_args; 548} 549 550/* Like add_to_template_args, but only the outermost ARGS are added to 551 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH 552 (EXTRA_ARGS) levels are added. This function is used to combine 553 the template arguments from a partial instantiation with the 554 template arguments used to attain the full instantiation from the 555 partial instantiation. */ 556 557static tree 558add_outermost_template_args (args, extra_args) 559 tree args; 560 tree extra_args; 561{ 562 tree new_args; 563 564 /* If there are more levels of EXTRA_ARGS than there are ARGS, 565 something very fishy is going on. */ 566 my_friendly_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args), 567 0); 568 569 /* If *all* the new arguments will be the EXTRA_ARGS, just return 570 them. */ 571 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args)) 572 return extra_args; 573 574 /* For the moment, we make ARGS look like it contains fewer levels. */ 575 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args); 576 577 new_args = add_to_template_args (args, extra_args); 578 579 /* Now, we restore ARGS to its full dimensions. */ 580 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args); 581 582 return new_args; 583} 584 585/* We've got a template header coming up; push to a new level for storing 586 the parms. */ 587 588void 589begin_template_parm_list () 590{ 591 /* We use a non-tag-transparent scope here, which causes pushtag to 592 put tags in this scope, rather than in the enclosing class or 593 namespace scope. This is the right thing, since we want 594 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a 595 global template class, push_template_decl handles putting the 596 TEMPLATE_DECL into top-level scope. For a nested template class, 597 e.g.: 598 599 template <class T> struct S1 { 600 template <class T> struct S2 {}; 601 }; 602 603 pushtag contains special code to call pushdecl_with_scope on the 604 TEMPLATE_DECL for S2. */ 605 pushlevel (0); 606 declare_pseudo_global_level (); 607 ++processing_template_decl; 608 ++processing_template_parmlist; 609 note_template_header (0); 610} 611 612/* This routine is called when a specialization is declared. If it is 613 illegal to declare a specialization here, an error is reported. */ 614 615static void 616check_specialization_scope () 617{ 618 tree scope = current_scope (); 619 620 /* [temp.expl.spec] 621 622 An explicit specialization shall be declared in the namespace of 623 which the template is a member, or, for member templates, in the 624 namespace of which the enclosing class or enclosing class 625 template is a member. An explicit specialization of a member 626 function, member class or static data member of a class template 627 shall be declared in the namespace of which the class template 628 is a member. */ 629 if (scope && TREE_CODE (scope) != NAMESPACE_DECL) 630 cp_error ("explicit specialization in non-namespace scope `%D'", 631 scope); 632 633 /* [temp.expl.spec] 634 635 In an explicit specialization declaration for a member of a class 636 template or a member template that appears in namespace scope, 637 the member template and some of its enclosing class templates may 638 remain unspecialized, except that the declaration shall not 639 explicitly specialize a class member template if its enclosing 640 class templates are not explicitly specialized as well. */ 641 if (current_template_parms) 642 cp_error ("enclosing class templates are not explicitly specialized"); 643} 644 645/* We've just seen template <>. */ 646 647void 648begin_specialization () 649{ 650 note_template_header (1); 651 check_specialization_scope (); 652} 653 654/* Called at then end of processing a declaration preceeded by 655 template<>. */ 656 657void 658end_specialization () 659{ 660 reset_specialization (); 661} 662 663/* Any template <>'s that we have seen thus far are not referring to a 664 function specialization. */ 665 666void 667reset_specialization () 668{ 669 processing_specialization = 0; 670 template_header_count = 0; 671} 672 673/* We've just seen a template header. If SPECIALIZATION is non-zero, 674 it was of the form template <>. */ 675 676static void 677note_template_header (specialization) 678 int specialization; 679{ 680 processing_specialization = specialization; 681 template_header_count++; 682} 683 684/* We're beginning an explicit instantiation. */ 685 686void 687begin_explicit_instantiation () 688{ 689 ++processing_explicit_instantiation; 690} 691 692 693void 694end_explicit_instantiation () 695{ 696 my_friendly_assert(processing_explicit_instantiation > 0, 0); 697 --processing_explicit_instantiation; 698} 699 700/* The TYPE is being declared. If it is a template type, that means it 701 is a partial specialization. Do appropriate error-checking. */ 702 703void 704maybe_process_partial_specialization (type) 705 tree type; 706{ 707 if (IS_AGGR_TYPE (type) && CLASSTYPE_USE_TEMPLATE (type)) 708 { 709 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type) 710 && TYPE_SIZE (type) == NULL_TREE) 711 { 712 if (current_namespace 713 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type))) 714 { 715 cp_pedwarn ("specializing `%#T' in different namespace", type); 716 cp_pedwarn_at (" from definition of `%#D'", 717 CLASSTYPE_TI_TEMPLATE (type)); 718 } 719 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type); 720 if (processing_template_decl) 721 push_template_decl (TYPE_MAIN_DECL (type)); 722 } 723 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)) 724 cp_error ("specialization of `%T' after instantiation", type); 725 } 726 else if (processing_specialization) 727 cp_error ("explicit specialization of non-template `%T'", type); 728} 729 730/* Retrieve the specialization (in the sense of [temp.spec] - a 731 specialization is either an instantiation or an explicit 732 specialization) of TMPL for the given template ARGS. If there is 733 no such specialization, return NULL_TREE. The ARGS are a vector of 734 arguments, or a vector of vectors of arguments, in the case of 735 templates with more than one level of parameters. */ 736 737static tree 738retrieve_specialization (tmpl, args) 739 tree tmpl; 740 tree args; 741{ 742 tree s; 743 744 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); 745 746 /* There should be as many levels of arguments as there are 747 levels of parameters. */ 748 my_friendly_assert (TMPL_ARGS_DEPTH (args) 749 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)), 750 0); 751 752 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); 753 s != NULL_TREE; 754 s = TREE_CHAIN (s)) 755 if (comp_template_args (TREE_PURPOSE (s), args)) 756 return TREE_VALUE (s); 757 758 return NULL_TREE; 759} 760 761/* Returns non-zero iff DECL is a specialization of TMPL. */ 762 763int 764is_specialization_of (decl, tmpl) 765 tree decl; 766 tree tmpl; 767{ 768 tree t; 769 770 if (TREE_CODE (decl) == FUNCTION_DECL) 771 { 772 for (t = decl; 773 t != NULL_TREE; 774 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE) 775 if (t == tmpl) 776 return 1; 777 } 778 else 779 { 780 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 0); 781 782 for (t = TREE_TYPE (decl); 783 t != NULL_TREE; 784 t = CLASSTYPE_USE_TEMPLATE (t) 785 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE) 786 if (same_type_p (TYPE_MAIN_VARIANT (t), 787 TYPE_MAIN_VARIANT (TREE_TYPE (tmpl)))) 788 return 1; 789 } 790 791 return 0; 792} 793 794/* Register the specialization SPEC as a specialization of TMPL with 795 the indicated ARGS. Returns SPEC, or an equivalent prior 796 declaration, if available. */ 797 798static tree 799register_specialization (spec, tmpl, args) 800 tree spec; 801 tree tmpl; 802 tree args; 803{ 804 tree s; 805 806 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0); 807 808 if (TREE_CODE (spec) == FUNCTION_DECL 809 && uses_template_parms (DECL_TI_ARGS (spec))) 810 /* This is the FUNCTION_DECL for a partial instantiation. Don't 811 register it; we want the corresponding TEMPLATE_DECL instead. 812 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than 813 the more obvious `uses_template_parms (spec)' to avoid problems 814 with default function arguments. In particular, given 815 something like this: 816 817 template <class T> void f(T t1, T t = T()) 818 819 the default argument expression is not substituted for in an 820 instantiation unless and until it is actually needed. */ 821 return spec; 822 823 /* There should be as many levels of arguments as there are 824 levels of parameters. */ 825 my_friendly_assert (TMPL_ARGS_DEPTH (args) 826 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)), 827 0); 828 829 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); 830 s != NULL_TREE; 831 s = TREE_CHAIN (s)) 832 if (comp_template_args (TREE_PURPOSE (s), args)) 833 { 834 tree fn = TREE_VALUE (s); 835 836 if (DECL_TEMPLATE_SPECIALIZATION (spec)) 837 { 838 if (DECL_TEMPLATE_INSTANTIATION (fn)) 839 { 840 if (TREE_USED (fn) 841 || DECL_EXPLICIT_INSTANTIATION (fn)) 842 { 843 cp_error ("specialization of %D after instantiation", 844 fn); 845 return spec; 846 } 847 else 848 { 849 /* This situation should occur only if the first 850 specialization is an implicit instantiation, 851 the second is an explicit specialization, and 852 the implicit instantiation has not yet been 853 used. That situation can occur if we have 854 implicitly instantiated a member function and 855 then specialized it later. 856 857 We can also wind up here if a friend 858 declaration that looked like an instantiation 859 turns out to be a specialization: 860 861 template <class T> void foo(T); 862 class S { friend void foo<>(int) }; 863 template <> void foo(int); 864 865 We transform the existing DECL in place so that 866 any pointers to it become pointers to the 867 updated declaration. 868 869 If there was a definition for the template, but 870 not for the specialization, we want this to 871 look as if there is no definition, and vice 872 versa. */ 873 DECL_INITIAL (fn) = NULL_TREE; 874 duplicate_decls (spec, fn); 875 876 return fn; 877 } 878 } 879 else if (DECL_TEMPLATE_SPECIALIZATION (fn)) 880 { 881 duplicate_decls (spec, fn); 882 return fn; 883 } 884 } 885 } 886 887 DECL_TEMPLATE_SPECIALIZATIONS (tmpl) 888 = perm_tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl)); 889 890 return spec; 891} 892 893/* Unregister the specialization SPEC as a specialization of TMPL. 894 Returns nonzero if the SPEC was listed as a specialization of 895 TMPL. */ 896 897static int 898unregister_specialization (spec, tmpl) 899 tree spec; 900 tree tmpl; 901{ 902 tree* s; 903 904 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl); 905 *s != NULL_TREE; 906 s = &TREE_CHAIN (*s)) 907 if (TREE_VALUE (*s) == spec) 908 { 909 *s = TREE_CHAIN (*s); 910 return 1; 911 } 912 913 return 0; 914} 915 916/* Print the list of candidate FNS in an error message. */ 917 918void 919print_candidates (fns) 920 tree fns; 921{ 922 tree fn; 923 924 const char *str = "candidates are:"; 925 926 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn)) 927 { 928 tree f; 929 930 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f)) 931 cp_error_at ("%s %+#D", str, OVL_CURRENT (f)); 932 str = " "; 933 } 934} 935 936/* Returns the template (one of the functions given by TEMPLATE_ID) 937 which can be specialized to match the indicated DECL with the 938 explicit template args given in TEMPLATE_ID. The DECL may be 939 NULL_TREE if none is available. In that case, the functions in 940 TEMPLATE_ID are non-members. 941 942 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a 943 specialization of a member template. 944 945 The template args (those explicitly specified and those deduced) 946 are output in a newly created vector *TARGS_OUT. 947 948 If it is impossible to determine the result, an error message is 949 issued. The error_mark_node is returned to indicate failure. */ 950 951static tree 952determine_specialization (template_id, decl, targs_out, 953 need_member_template) 954 tree template_id; 955 tree decl; 956 tree* targs_out; 957 int need_member_template; 958{ 959 tree fn; 960 tree fns; 961 tree targs; 962 tree explicit_targs; 963 tree candidates = NULL_TREE; 964 tree templates = NULL_TREE; 965 966 *targs_out = NULL_TREE; 967 968 if (template_id == error_mark_node) 969 return error_mark_node; 970 971 fns = TREE_OPERAND (template_id, 0); 972 explicit_targs = TREE_OPERAND (template_id, 1); 973 974 if (fns == error_mark_node) 975 return error_mark_node; 976 977 /* Check for baselinks. */ 978 if (TREE_CODE (fns) == TREE_LIST) 979 fns = TREE_VALUE (fns); 980 981 for (; fns; fns = OVL_NEXT (fns)) 982 { 983 tree tmpl; 984 985 fn = OVL_CURRENT (fns); 986 987 if (TREE_CODE (fn) == TEMPLATE_DECL) 988 /* DECL might be a specialization of FN. */ 989 tmpl = fn; 990 else if (need_member_template) 991 /* FN is an ordinary member function, and we need a 992 specialization of a member template. */ 993 continue; 994 else if (TREE_CODE (fn) != FUNCTION_DECL) 995 /* We can get IDENTIFIER_NODEs here in certain erroneous 996 cases. */ 997 continue; 998 else if (!DECL_FUNCTION_MEMBER_P (fn)) 999 /* This is just an ordinary non-member function. Nothing can 1000 be a specialization of that. */ 1001 continue; 1002 else 1003 { 1004 tree decl_arg_types; 1005 1006 /* This is an ordinary member function. However, since 1007 we're here, we can assume it's enclosing class is a 1008 template class. For example, 1009 1010 template <typename T> struct S { void f(); }; 1011 template <> void S<int>::f() {} 1012 1013 Here, S<int>::f is a non-template, but S<int> is a 1014 template class. If FN has the same type as DECL, we 1015 might be in business. */ 1016 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)), 1017 TREE_TYPE (TREE_TYPE (fn)))) 1018 /* The return types differ. */ 1019 continue; 1020 1021 /* Adjust the type of DECL in case FN is a static member. */ 1022 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 1023 if (DECL_STATIC_FUNCTION_P (fn) 1024 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1025 decl_arg_types = TREE_CHAIN (decl_arg_types); 1026 1027 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)), 1028 decl_arg_types)) 1029 /* They match! */ 1030 candidates = tree_cons (NULL_TREE, fn, candidates); 1031 1032 continue; 1033 } 1034 1035 /* See whether this function might be a specialization of this 1036 template. */ 1037 targs = get_bindings (tmpl, decl, explicit_targs); 1038 1039 if (!targs) 1040 /* We cannot deduce template arguments that when used to 1041 specialize TMPL will produce DECL. */ 1042 continue; 1043 1044 /* Save this template, and the arguments deduced. */ 1045 templates = scratch_tree_cons (targs, tmpl, templates); 1046 } 1047 1048 if (templates && TREE_CHAIN (templates)) 1049 { 1050 /* We have: 1051 1052 [temp.expl.spec] 1053 1054 It is possible for a specialization with a given function 1055 signature to be instantiated from more than one function 1056 template. In such cases, explicit specification of the 1057 template arguments must be used to uniquely identify the 1058 function template specialization being specialized. 1059 1060 Note that here, there's no suggestion that we're supposed to 1061 determine which of the candidate templates is most 1062 specialized. However, we, also have: 1063 1064 [temp.func.order] 1065 1066 Partial ordering of overloaded function template 1067 declarations is used in the following contexts to select 1068 the function template to which a function template 1069 specialization refers: 1070 1071 -- when an explicit specialization refers to a function 1072 template. 1073 1074 So, we do use the partial ordering rules, at least for now. 1075 This extension can only serve to make illegal programs legal, 1076 so it's safe. And, there is strong anecdotal evidence that 1077 the committee intended the partial ordering rules to apply; 1078 the EDG front-end has that behavior, and John Spicer claims 1079 that the committee simply forgot to delete the wording in 1080 [temp.expl.spec]. */ 1081 tree tmpl = most_specialized (templates, decl, explicit_targs); 1082 if (tmpl && tmpl != error_mark_node) 1083 { 1084 targs = get_bindings (tmpl, decl, explicit_targs); 1085 templates = scratch_tree_cons (targs, tmpl, NULL_TREE); 1086 } 1087 } 1088 1089 if (templates == NULL_TREE && candidates == NULL_TREE) 1090 { 1091 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration", 1092 template_id, decl); 1093 return error_mark_node; 1094 } 1095 else if ((templates && TREE_CHAIN (templates)) 1096 || (candidates && TREE_CHAIN (candidates)) 1097 || (templates && candidates)) 1098 { 1099 cp_error_at ("ambiguous template specialization `%D' for `%+D'", 1100 template_id, decl); 1101 chainon (candidates, templates); 1102 print_candidates (candidates); 1103 return error_mark_node; 1104 } 1105 1106 /* We have one, and exactly one, match. */ 1107 if (candidates) 1108 { 1109 /* It was a specialization of an ordinary member function in a 1110 template class. */ 1111 *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates))); 1112 return DECL_TI_TEMPLATE (TREE_VALUE (candidates)); 1113 } 1114 1115 /* It was a specialization of a template. */ 1116 targs = DECL_TI_ARGS (DECL_RESULT (TREE_VALUE (templates))); 1117 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs)) 1118 { 1119 *targs_out = copy_node (targs); 1120 SET_TMPL_ARGS_LEVEL (*targs_out, 1121 TMPL_ARGS_DEPTH (*targs_out), 1122 TREE_PURPOSE (templates)); 1123 } 1124 else 1125 *targs_out = TREE_PURPOSE (templates); 1126 return TREE_VALUE (templates); 1127} 1128 1129/* Check to see if the function just declared, as indicated in 1130 DECLARATOR, and in DECL, is a specialization of a function 1131 template. We may also discover that the declaration is an explicit 1132 instantiation at this point. 1133 1134 Returns DECL, or an equivalent declaration that should be used 1135 instead if all goes well. Issues an error message if something is 1136 amiss. Returns error_mark_node if the error is not easily 1137 recoverable. 1138 1139 FLAGS is a bitmask consisting of the following flags: 1140 1141 2: The function has a definition. 1142 4: The function is a friend. 1143 1144 The TEMPLATE_COUNT is the number of references to qualifying 1145 template classes that appeared in the name of the function. For 1146 example, in 1147 1148 template <class T> struct S { void f(); }; 1149 void S<int>::f(); 1150 1151 the TEMPLATE_COUNT would be 1. However, explicitly specialized 1152 classes are not counted in the TEMPLATE_COUNT, so that in 1153 1154 template <class T> struct S {}; 1155 template <> struct S<int> { void f(); } 1156 template <> void S<int>::f(); 1157 1158 the TEMPLATE_COUNT would be 0. (Note that this declaration is 1159 illegal; there should be no template <>.) 1160 1161 If the function is a specialization, it is marked as such via 1162 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO 1163 is set up correctly, and it is added to the list of specializations 1164 for that template. */ 1165 1166tree 1167check_explicit_specialization (declarator, decl, template_count, flags) 1168 tree declarator; 1169 tree decl; 1170 int template_count; 1171 int flags; 1172{ 1173 int have_def = flags & 2; 1174 int is_friend = flags & 4; 1175 int specialization = 0; 1176 int explicit_instantiation = 0; 1177 int member_specialization = 0; 1178 1179 tree ctype = DECL_CLASS_CONTEXT (decl); 1180 tree dname = DECL_NAME (decl); 1181 1182 if (processing_specialization) 1183 { 1184 /* The last template header was of the form template <>. */ 1185 1186 if (template_header_count > template_count) 1187 { 1188 /* There were more template headers than qualifying template 1189 classes. */ 1190 if (template_header_count - template_count > 1) 1191 /* There shouldn't be that many template parameter lists. 1192 There can be at most one parameter list for every 1193 qualifying class, plus one for the function itself. */ 1194 cp_error ("too many template parameter lists in declaration of `%D'", decl); 1195 1196 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 1197 if (ctype) 1198 member_specialization = 1; 1199 else 1200 specialization = 1; 1201 } 1202 else if (template_header_count == template_count) 1203 { 1204 /* The counts are equal. So, this might be a 1205 specialization, but it is not a specialization of a 1206 member template. It might be something like 1207 1208 template <class T> struct S { 1209 void f(int i); 1210 }; 1211 template <> 1212 void S<int>::f(int i) {} */ 1213 specialization = 1; 1214 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 1215 } 1216 else 1217 { 1218 /* This cannot be an explicit specialization. There are not 1219 enough headers for all of the qualifying classes. For 1220 example, we might have: 1221 1222 template <> 1223 void S<int>::T<char>::f(); 1224 1225 But, we're missing another template <>. */ 1226 cp_error("too few template parameter lists in declaration of `%D'", decl); 1227 return decl; 1228 } 1229 } 1230 else if (processing_explicit_instantiation) 1231 { 1232 if (template_header_count) 1233 cp_error ("template parameter list used in explicit instantiation"); 1234 1235 if (have_def) 1236 cp_error ("definition provided for explicit instantiation"); 1237 1238 explicit_instantiation = 1; 1239 } 1240 else if (ctype != NULL_TREE 1241 && !TYPE_BEING_DEFINED (ctype) 1242 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype) 1243 && !is_friend) 1244 { 1245 /* This case catches outdated code that looks like this: 1246 1247 template <class T> struct S { void f(); }; 1248 void S<int>::f() {} // Missing template <> 1249 1250 We disable this check when the type is being defined to 1251 avoid complaining about default compiler-generated 1252 constructors, destructors, and assignment operators. 1253 Since the type is an instantiation, not a specialization, 1254 these are the only functions that can be defined before 1255 the class is complete. */ 1256 1257 /* If they said 1258 template <class T> void S<int>::f() {} 1259 that's bogus. */ 1260 if (template_header_count) 1261 { 1262 cp_error ("template parameters specified in specialization"); 1263 return decl; 1264 } 1265 1266 if (pedantic) 1267 cp_pedwarn 1268 ("explicit specialization not preceded by `template <>'"); 1269 specialization = 1; 1270 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 1271 } 1272 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) 1273 { 1274 if (is_friend) 1275 /* This could be something like: 1276 1277 template <class T> void f(T); 1278 class S { friend void f<>(int); } */ 1279 specialization = 1; 1280 else 1281 { 1282 /* This case handles bogus declarations like template <> 1283 template <class T> void f<int>(); */ 1284 1285 cp_error ("template-id `%D' in declaration of primary template", 1286 declarator); 1287 return decl; 1288 } 1289 } 1290 1291 if (specialization || member_specialization) 1292 { 1293 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl)); 1294 for (; t; t = TREE_CHAIN (t)) 1295 if (TREE_PURPOSE (t)) 1296 { 1297 cp_pedwarn 1298 ("default argument specified in explicit specialization"); 1299 break; 1300 } 1301 if (current_lang_name == lang_name_c) 1302 cp_error ("template specialization with C linkage"); 1303 } 1304 1305 if (specialization || member_specialization || explicit_instantiation) 1306 { 1307 tree tmpl = NULL_TREE; 1308 tree targs = NULL_TREE; 1309 1310 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */ 1311 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR) 1312 { 1313 tree fns; 1314 1315 my_friendly_assert (TREE_CODE (declarator) == IDENTIFIER_NODE, 1316 0); 1317 if (!ctype) 1318 fns = IDENTIFIER_NAMESPACE_VALUE (dname); 1319 else 1320 fns = dname; 1321 1322 declarator = 1323 lookup_template_function (fns, NULL_TREE); 1324 } 1325 1326 if (declarator == error_mark_node) 1327 return error_mark_node; 1328 1329 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype)) 1330 { 1331 if (!explicit_instantiation) 1332 /* A specialization in class scope. This is illegal, 1333 but the error will already have been flagged by 1334 check_specialization_scope. */ 1335 return error_mark_node; 1336 else 1337 { 1338 /* It's not legal to write an explicit instantiation in 1339 class scope, e.g.: 1340 1341 class C { template void f(); } 1342 1343 This case is caught by the parser. However, on 1344 something like: 1345 1346 template class C { void f(); }; 1347 1348 (which is illegal) we can get here. The error will be 1349 issued later. */ 1350 ; 1351 } 1352 1353 return decl; 1354 } 1355 else if (TREE_CODE (TREE_OPERAND (declarator, 0)) == LOOKUP_EXPR) 1356 { 1357 /* A friend declaration. We can't do much, because we don't 1358 know what this resolves to, yet. */ 1359 my_friendly_assert (is_friend != 0, 0); 1360 my_friendly_assert (!explicit_instantiation, 0); 1361 SET_DECL_IMPLICIT_INSTANTIATION (decl); 1362 return decl; 1363 } 1364 else if (ctype != NULL_TREE 1365 && (TREE_CODE (TREE_OPERAND (declarator, 0)) == 1366 IDENTIFIER_NODE)) 1367 { 1368 /* Find the list of functions in ctype that have the same 1369 name as the declared function. */ 1370 tree name = TREE_OPERAND (declarator, 0); 1371 tree fns = NULL_TREE; 1372 int idx; 1373 1374 if (name == constructor_name (ctype) 1375 || name == constructor_name_full (ctype)) 1376 { 1377 int is_constructor = DECL_CONSTRUCTOR_P (decl); 1378 1379 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype) 1380 : !TYPE_HAS_DESTRUCTOR (ctype)) 1381 { 1382 /* From [temp.expl.spec]: 1383 1384 If such an explicit specialization for the member 1385 of a class template names an implicitly-declared 1386 special member function (clause _special_), the 1387 program is ill-formed. 1388 1389 Similar language is found in [temp.explicit]. */ 1390 cp_error ("specialization of implicitly-declared special member function"); 1391 return error_mark_node; 1392 } 1393 1394 name = is_constructor ? ctor_identifier : dtor_identifier; 1395 } 1396 1397 if (!IDENTIFIER_TYPENAME_P (name)) 1398 { 1399 idx = lookup_fnfields_1 (ctype, name); 1400 if (idx >= 0) 1401 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), idx); 1402 } 1403 else 1404 { 1405 tree methods; 1406 1407 /* For a type-conversion operator, we cannot do a 1408 name-based lookup. We might be looking for `operator 1409 int' which will be a specialization of `operator T'. 1410 So, we find *all* the conversion operators, and then 1411 select from them. */ 1412 fns = NULL_TREE; 1413 1414 methods = CLASSTYPE_METHOD_VEC (ctype); 1415 if (methods) 1416 for (idx = 2; idx < TREE_VEC_LENGTH (methods); ++idx) 1417 { 1418 tree ovl = TREE_VEC_ELT (methods, idx); 1419 1420 if (!ovl || !DECL_CONV_FN_P (OVL_CURRENT (ovl))) 1421 /* There are no more conversion functions. */ 1422 break; 1423 1424 /* Glue all these conversion functions together 1425 with those we already have. */ 1426 for (; ovl; ovl = OVL_NEXT (ovl)) 1427 fns = ovl_cons (OVL_CURRENT (ovl), fns); 1428 } 1429 } 1430 1431 if (fns == NULL_TREE) 1432 { 1433 cp_error ("no member function `%D' declared in `%T'", 1434 name, ctype); 1435 return error_mark_node; 1436 } 1437 else 1438 TREE_OPERAND (declarator, 0) = fns; 1439 } 1440 1441 /* Figure out what exactly is being specialized at this point. 1442 Note that for an explicit instantiation, even one for a 1443 member function, we cannot tell apriori whether the 1444 instantiation is for a member template, or just a member 1445 function of a template class. Even if a member template is 1446 being instantiated, the member template arguments may be 1447 elided if they can be deduced from the rest of the 1448 declaration. */ 1449 tmpl = determine_specialization (declarator, decl, 1450 &targs, 1451 member_specialization); 1452 1453 if (!tmpl || tmpl == error_mark_node) 1454 /* We couldn't figure out what this declaration was 1455 specializing. */ 1456 return error_mark_node; 1457 else 1458 { 1459 tree gen_tmpl = most_general_template (tmpl); 1460 1461 if (explicit_instantiation) 1462 { 1463 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that 1464 is done by do_decl_instantiation later. */ 1465 1466 int arg_depth = TMPL_ARGS_DEPTH (targs); 1467 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)); 1468 1469 if (arg_depth > parm_depth) 1470 { 1471 /* If TMPL is not the most general template (for 1472 example, if TMPL is a friend template that is 1473 injected into namespace scope), then there will 1474 be too many levels fo TARGS. Remove some of them 1475 here. */ 1476 int i; 1477 tree new_targs; 1478 1479 new_targs = make_temp_vec (parm_depth); 1480 for (i = arg_depth - parm_depth; i < arg_depth; ++i) 1481 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth)) 1482 = TREE_VEC_ELT (targs, i); 1483 targs = new_targs; 1484 } 1485 1486 decl = instantiate_template (tmpl, targs); 1487 return decl; 1488 } 1489 1490 /* If we though that the DECL was a member function, but it 1491 turns out to be specializing a static member function, 1492 make DECL a static member function as well. */ 1493 if (DECL_STATIC_FUNCTION_P (tmpl) 1494 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1495 { 1496 revert_static_member_fn (&decl, 0, 0); 1497 last_function_parms = TREE_CHAIN (last_function_parms); 1498 } 1499 1500 /* Set up the DECL_TEMPLATE_INFO for DECL. */ 1501 DECL_TEMPLATE_INFO (decl) 1502 = perm_tree_cons (tmpl, targs, NULL_TREE); 1503 1504 /* Mangle the function name appropriately. Note that we do 1505 not mangle specializations of non-template member 1506 functions of template classes, e.g. with 1507 1508 template <class T> struct S { void f(); } 1509 1510 and given the specialization 1511 1512 template <> void S<int>::f() {} 1513 1514 we do not mangle S<int>::f() here. That's because it's 1515 just an ordinary member function and doesn't need special 1516 treatment. We do this here so that the ordinary, 1517 non-template, name-mangling algorith will not be used 1518 later. */ 1519 if ((is_member_template (tmpl) || ctype == NULL_TREE) 1520 && name_mangling_version >= 1) 1521 set_mangled_name_for_template_decl (decl); 1522 1523 if (is_friend && !have_def) 1524 /* This is not really a declaration of a specialization. 1525 It's just the name of an instantiation. But, it's not 1526 a request for an instantiation, either. */ 1527 SET_DECL_IMPLICIT_INSTANTIATION (decl); 1528 1529 /* Register this specialization so that we can find it 1530 again. */ 1531 decl = register_specialization (decl, gen_tmpl, targs); 1532 } 1533 } 1534 1535 return decl; 1536} 1537 1538/* TYPE is being declared. Verify that the use of template headers 1539 and such is reasonable. Issue error messages if not. */ 1540 1541void 1542maybe_check_template_type (type) 1543 tree type; 1544{ 1545 if (template_header_count) 1546 { 1547 /* We are in the scope of some `template <...>' header. */ 1548 1549 int context_depth 1550 = template_class_depth_real (TYPE_CONTEXT (type), 1551 /*count_specializations=*/1); 1552 1553 if (template_header_count <= context_depth) 1554 /* This is OK; the template headers are for the context. We 1555 are actually too lenient here; like 1556 check_explicit_specialization we should consider the number 1557 of template types included in the actual declaration. For 1558 example, 1559 1560 template <class T> struct S { 1561 template <class U> template <class V> 1562 struct I {}; 1563 }; 1564 1565 is illegal, but: 1566 1567 template <class T> struct S { 1568 template <class U> struct I; 1569 }; 1570 1571 template <class T> template <class U. 1572 struct S<T>::I {}; 1573 1574 is not. */ 1575 ; 1576 else if (template_header_count > context_depth + 1) 1577 /* There are two many template parameter lists. */ 1578 cp_error ("too many template parameter lists in declaration of `%T'", type); 1579 } 1580} 1581 1582/* Returns 1 iff PARMS1 and PARMS2 are identical sets of template 1583 parameters. These are represented in the same format used for 1584 DECL_TEMPLATE_PARMS. */ 1585 1586int comp_template_parms (parms1, parms2) 1587 tree parms1; 1588 tree parms2; 1589{ 1590 tree p1; 1591 tree p2; 1592 1593 if (parms1 == parms2) 1594 return 1; 1595 1596 for (p1 = parms1, p2 = parms2; 1597 p1 != NULL_TREE && p2 != NULL_TREE; 1598 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2)) 1599 { 1600 tree t1 = TREE_VALUE (p1); 1601 tree t2 = TREE_VALUE (p2); 1602 int i; 1603 1604 my_friendly_assert (TREE_CODE (t1) == TREE_VEC, 0); 1605 my_friendly_assert (TREE_CODE (t2) == TREE_VEC, 0); 1606 1607 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2)) 1608 return 0; 1609 1610 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i) 1611 { 1612 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i)); 1613 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i)); 1614 1615 if (TREE_CODE (parm1) != TREE_CODE (parm2)) 1616 return 0; 1617 1618 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM) 1619 continue; 1620 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2))) 1621 return 0; 1622 } 1623 } 1624 1625 if ((p1 != NULL_TREE) != (p2 != NULL_TREE)) 1626 /* One set of parameters has more parameters lists than the 1627 other. */ 1628 return 0; 1629 1630 return 1; 1631} 1632 1633/* Complain if DECL shadows a template parameter. 1634 1635 [temp.local]: A template-parameter shall not be redeclared within its 1636 scope (including nested scopes). */ 1637 1638void 1639check_template_shadow (decl) 1640 tree decl; 1641{ 1642 tree olddecl; 1643 1644 /* If we're not in a template, we can't possibly shadow a template 1645 parameter. */ 1646 if (!current_template_parms) 1647 return; 1648 1649 /* Figure out what we're shadowing. */ 1650 if (TREE_CODE (decl) == OVERLOAD) 1651 decl = OVL_CURRENT (decl); 1652 olddecl = IDENTIFIER_VALUE (DECL_NAME (decl)); 1653 1654 /* If there's no previous binding for this name, we're not shadowing 1655 anything, let alone a template parameter. */ 1656 if (!olddecl) 1657 return; 1658 1659 /* If we're not shadowing a template parameter, we're done. Note 1660 that OLDDECL might be an OVERLOAD (or perhaps even an 1661 ERROR_MARK), so we can't just blithely assume it to be a _DECL 1662 node. */ 1663 if (TREE_CODE_CLASS (TREE_CODE (olddecl)) != 'd' 1664 || !DECL_TEMPLATE_PARM_P (olddecl)) 1665 return; 1666 1667 /* We check for decl != olddecl to avoid bogus errors for using a 1668 name inside a class. We check TPFI to avoid duplicate errors for 1669 inline member templates. */ 1670 if (decl == olddecl 1671 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms)) 1672 return; 1673 1674 cp_error_at ("declaration of `%#D'", decl); 1675 cp_error_at (" shadows template parm `%#D'", olddecl); 1676} 1677 1678/* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL, 1679 ORIG_LEVEL, DECL, and TYPE. */ 1680 1681static tree 1682build_template_parm_index (index, level, orig_level, decl, type) 1683 int index; 1684 int level; 1685 int orig_level; 1686 tree decl; 1687 tree type; 1688{ 1689 tree t = make_node (TEMPLATE_PARM_INDEX); 1690 TEMPLATE_PARM_IDX (t) = index; 1691 TEMPLATE_PARM_LEVEL (t) = level; 1692 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level; 1693 TEMPLATE_PARM_DECL (t) = decl; 1694 TREE_TYPE (t) = type; 1695 1696 return t; 1697} 1698 1699/* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose 1700 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a 1701 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a 1702 new one is created. */ 1703 1704static tree 1705reduce_template_parm_level (index, type, levels) 1706 tree index; 1707 tree type; 1708 int levels; 1709{ 1710 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE 1711 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index)) 1712 != TEMPLATE_PARM_LEVEL (index) - levels)) 1713 { 1714 tree decl 1715 = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index)), 1716 DECL_NAME (TEMPLATE_PARM_DECL (index)), 1717 type); 1718 tree t 1719 = build_template_parm_index (TEMPLATE_PARM_IDX (index), 1720 TEMPLATE_PARM_LEVEL (index) - levels, 1721 TEMPLATE_PARM_ORIG_LEVEL (index), 1722 decl, type); 1723 TEMPLATE_PARM_DESCENDANTS (index) = t; 1724 1725 /* Template template parameters need this. */ 1726 DECL_TEMPLATE_PARMS (decl) 1727 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)); 1728 } 1729 1730 return TEMPLATE_PARM_DESCENDANTS (index); 1731} 1732 1733/* Process information from new template parameter NEXT and append it to the 1734 LIST being built. */ 1735 1736tree 1737process_template_parm (list, next) 1738 tree list, next; 1739{ 1740 tree parm; 1741 tree decl = 0; 1742 tree defval; 1743 int is_type, idx; 1744 1745 parm = next; 1746 my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259); 1747 defval = TREE_PURPOSE (parm); 1748 parm = TREE_VALUE (parm); 1749 is_type = TREE_PURPOSE (parm) == class_type_node; 1750 1751 if (list) 1752 { 1753 tree p = TREE_VALUE (tree_last (list)); 1754 1755 if (TREE_CODE (p) == TYPE_DECL) 1756 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p)); 1757 else if (TREE_CODE (p) == TEMPLATE_DECL) 1758 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p))); 1759 else 1760 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p)); 1761 ++idx; 1762 } 1763 else 1764 idx = 0; 1765 1766 if (!is_type) 1767 { 1768 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260); 1769 /* is a const-param */ 1770 parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), 1771 PARM, 0, NULL_TREE); 1772 1773 /* [temp.param] 1774 1775 The top-level cv-qualifiers on the template-parameter are 1776 ignored when determining its type. */ 1777 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm)); 1778 1779 /* A template parameter is not modifiable. */ 1780 TREE_READONLY (parm) = 1; 1781 if (IS_AGGR_TYPE (TREE_TYPE (parm)) 1782 && TREE_CODE (TREE_TYPE (parm)) != TEMPLATE_TYPE_PARM 1783 && TREE_CODE (TREE_TYPE (parm)) != TYPENAME_TYPE) 1784 { 1785 cp_error ("`%#T' is not a valid type for a template constant parameter", 1786 TREE_TYPE (parm)); 1787 if (DECL_NAME (parm) == NULL_TREE) 1788 error (" a template type parameter must begin with `class' or `typename'"); 1789 TREE_TYPE (parm) = void_type_node; 1790 } 1791 else if (pedantic 1792 && (TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE 1793 || TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE)) 1794 cp_pedwarn ("`%T' is not a valid type for a template constant parameter", 1795 TREE_TYPE (parm)); 1796 if (TREE_PERMANENT (parm) == 0) 1797 { 1798 parm = copy_node (parm); 1799 TREE_PERMANENT (parm) = 1; 1800 } 1801 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm)); 1802 DECL_INITIAL (parm) = DECL_INITIAL (decl) 1803 = build_template_parm_index (idx, processing_template_decl, 1804 processing_template_decl, 1805 decl, TREE_TYPE (parm)); 1806 } 1807 else 1808 { 1809 tree t; 1810 parm = TREE_VALUE (parm); 1811 1812 if (parm && TREE_CODE (parm) == TEMPLATE_DECL) 1813 { 1814 t = make_lang_type (TEMPLATE_TEMPLATE_PARM); 1815 /* This is for distinguishing between real templates and template 1816 template parameters */ 1817 TREE_TYPE (parm) = t; 1818 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t; 1819 decl = parm; 1820 } 1821 else 1822 { 1823 t = make_lang_type (TEMPLATE_TYPE_PARM); 1824 /* parm is either IDENTIFIER_NODE or NULL_TREE */ 1825 decl = build_decl (TYPE_DECL, parm, t); 1826 } 1827 1828 TYPE_NAME (t) = decl; 1829 TYPE_STUB_DECL (t) = decl; 1830 parm = decl; 1831 TEMPLATE_TYPE_PARM_INDEX (t) 1832 = build_template_parm_index (idx, processing_template_decl, 1833 processing_template_decl, 1834 decl, TREE_TYPE (parm)); 1835 } 1836 SET_DECL_ARTIFICIAL (decl); 1837 DECL_TEMPLATE_PARM_P (decl) = 1; 1838 pushdecl (decl); 1839 parm = build_tree_list (defval, parm); 1840 return chainon (list, parm); 1841} 1842 1843/* The end of a template parameter list has been reached. Process the 1844 tree list into a parameter vector, converting each parameter into a more 1845 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others 1846 as PARM_DECLs. */ 1847 1848tree 1849end_template_parm_list (parms) 1850 tree parms; 1851{ 1852 int nparms; 1853 tree parm; 1854 tree saved_parmlist = make_tree_vec (list_length (parms)); 1855 1856 current_template_parms 1857 = tree_cons (build_int_2 (0, processing_template_decl), 1858 saved_parmlist, current_template_parms); 1859 1860 for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++) 1861 TREE_VEC_ELT (saved_parmlist, nparms) = parm; 1862 1863 --processing_template_parmlist; 1864 1865 return saved_parmlist; 1866} 1867 1868/* end_template_decl is called after a template declaration is seen. */ 1869 1870void 1871end_template_decl () 1872{ 1873 reset_specialization (); 1874 1875 if (! processing_template_decl) 1876 return; 1877 1878 /* This matches the pushlevel in begin_template_parm_list. */ 1879 poplevel (0, 0, 0); 1880 1881 --processing_template_decl; 1882 current_template_parms = TREE_CHAIN (current_template_parms); 1883 (void) get_pending_sizes (); /* Why? */ 1884} 1885 1886/* Given a template argument vector containing the template PARMS. 1887 The innermost PARMS are given first. */ 1888 1889tree 1890current_template_args () 1891{ 1892 tree header; 1893 tree args = NULL_TREE; 1894 int length = TMPL_PARMS_DEPTH (current_template_parms); 1895 int l = length; 1896 1897 /* If there is only one level of template parameters, we do not 1898 create a TREE_VEC of TREE_VECs. Instead, we return a single 1899 TREE_VEC containing the arguments. */ 1900 if (length > 1) 1901 args = make_tree_vec (length); 1902 1903 for (header = current_template_parms; header; header = TREE_CHAIN (header)) 1904 { 1905 tree a = copy_node (TREE_VALUE (header)); 1906 int i; 1907 1908 TREE_TYPE (a) = NULL_TREE; 1909 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i) 1910 { 1911 tree t = TREE_VEC_ELT (a, i); 1912 1913 /* T will be a list if we are called from within a 1914 begin/end_template_parm_list pair, but a vector directly 1915 if within a begin/end_member_template_processing pair. */ 1916 if (TREE_CODE (t) == TREE_LIST) 1917 { 1918 t = TREE_VALUE (t); 1919 1920 if (TREE_CODE (t) == TYPE_DECL 1921 || TREE_CODE (t) == TEMPLATE_DECL) 1922 t = TREE_TYPE (t); 1923 else 1924 t = DECL_INITIAL (t); 1925 TREE_VEC_ELT (a, i) = t; 1926 } 1927 } 1928 1929 if (length > 1) 1930 TREE_VEC_ELT (args, --l) = a; 1931 else 1932 args = a; 1933 } 1934 1935 return args; 1936} 1937 1938/* Return a TEMPLATE_DECL corresponding to DECL, using the indicated 1939 template PARMS. Used by push_template_decl below. */ 1940 1941static tree 1942build_template_decl (decl, parms) 1943 tree decl; 1944 tree parms; 1945{ 1946 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE); 1947 DECL_TEMPLATE_PARMS (tmpl) = parms; 1948 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl); 1949 if (DECL_LANG_SPECIFIC (decl)) 1950 { 1951 DECL_CLASS_CONTEXT (tmpl) = DECL_CLASS_CONTEXT (decl); 1952 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl); 1953 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl); 1954 } 1955 1956 return tmpl; 1957} 1958 1959struct template_parm_data 1960{ 1961 /* The level of the template parameters we are currently 1962 processing. */ 1963 int level; 1964 1965 /* The index of the specialization argument we are currently 1966 processing. */ 1967 int current_arg; 1968 1969 /* An array whose size is the number of template parameters. The 1970 elements are non-zero if the parameter has been used in any one 1971 of the arguments processed so far. */ 1972 int* parms; 1973 1974 /* An array whose size is the number of template arguments. The 1975 elements are non-zero if the argument makes use of template 1976 parameters of this level. */ 1977 int* arg_uses_template_parms; 1978}; 1979 1980/* Subroutine of push_template_decl used to see if each template 1981 parameter in a partial specialization is used in the explicit 1982 argument list. If T is of the LEVEL given in DATA (which is 1983 treated as a template_parm_data*), then DATA->PARMS is marked 1984 appropriately. */ 1985 1986static int 1987mark_template_parm (t, data) 1988 tree t; 1989 void* data; 1990{ 1991 int level; 1992 int idx; 1993 struct template_parm_data* tpd = (struct template_parm_data*) data; 1994 1995 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX) 1996 { 1997 level = TEMPLATE_PARM_LEVEL (t); 1998 idx = TEMPLATE_PARM_IDX (t); 1999 } 2000 else 2001 { 2002 level = TEMPLATE_TYPE_LEVEL (t); 2003 idx = TEMPLATE_TYPE_IDX (t); 2004 } 2005 2006 if (level == tpd->level) 2007 { 2008 tpd->parms[idx] = 1; 2009 tpd->arg_uses_template_parms[tpd->current_arg] = 1; 2010 } 2011 2012 /* Return zero so that for_each_template_parm will continue the 2013 traversal of the tree; we want to mark *every* template parm. */ 2014 return 0; 2015} 2016 2017/* Process the partial specialization DECL. */ 2018 2019static tree 2020process_partial_specialization (decl) 2021 tree decl; 2022{ 2023 tree type = TREE_TYPE (decl); 2024 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type); 2025 tree specargs = CLASSTYPE_TI_ARGS (type); 2026 tree inner_args = innermost_args (specargs); 2027 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms); 2028 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl); 2029 int nargs = TREE_VEC_LENGTH (inner_args); 2030 int ntparms = TREE_VEC_LENGTH (inner_parms); 2031 int i; 2032 int did_error_intro = 0; 2033 struct template_parm_data tpd; 2034 struct template_parm_data tpd2; 2035 2036 /* We check that each of the template parameters given in the 2037 partial specialization is used in the argument list to the 2038 specialization. For example: 2039 2040 template <class T> struct S; 2041 template <class T> struct S<T*>; 2042 2043 The second declaration is OK because `T*' uses the template 2044 parameter T, whereas 2045 2046 template <class T> struct S<int>; 2047 2048 is no good. Even trickier is: 2049 2050 template <class T> 2051 struct S1 2052 { 2053 template <class U> 2054 struct S2; 2055 template <class U> 2056 struct S2<T>; 2057 }; 2058 2059 The S2<T> declaration is actually illegal; it is a 2060 full-specialization. Of course, 2061 2062 template <class U> 2063 struct S2<T (*)(U)>; 2064 2065 or some such would have been OK. */ 2066 tpd.level = TMPL_PARMS_DEPTH (current_template_parms); 2067 tpd.parms = alloca (sizeof (int) * ntparms); 2068 bzero ((PTR) tpd.parms, sizeof (int) * ntparms); 2069 2070 tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs); 2071 bzero ((PTR) tpd.arg_uses_template_parms, sizeof (int) * nargs); 2072 for (i = 0; i < nargs; ++i) 2073 { 2074 tpd.current_arg = i; 2075 for_each_template_parm (TREE_VEC_ELT (inner_args, i), 2076 &mark_template_parm, 2077 &tpd); 2078 } 2079 for (i = 0; i < ntparms; ++i) 2080 if (tpd.parms[i] == 0) 2081 { 2082 /* One of the template parms was not used in the 2083 specialization. */ 2084 if (!did_error_intro) 2085 { 2086 cp_error ("template parameters not used in partial specialization:"); 2087 did_error_intro = 1; 2088 } 2089 2090 cp_error (" `%D'", 2091 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))); 2092 } 2093 2094 /* [temp.class.spec] 2095 2096 The argument list of the specialization shall not be identical to 2097 the implicit argument list of the primary template. */ 2098 if (comp_template_args (inner_args, 2099 innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE 2100 (maintmpl))))) 2101 cp_error ("partial specialization `%T' does not specialize any template arguments", type); 2102 2103 /* [temp.class.spec] 2104 2105 A partially specialized non-type argument expression shall not 2106 involve template parameters of the partial specialization except 2107 when the argument expression is a simple identifier. 2108 2109 The type of a template parameter corresponding to a specialized 2110 non-type argument shall not be dependent on a parameter of the 2111 specialization. */ 2112 my_friendly_assert (nargs == DECL_NTPARMS (maintmpl), 0); 2113 tpd2.parms = 0; 2114 for (i = 0; i < nargs; ++i) 2115 { 2116 tree arg = TREE_VEC_ELT (inner_args, i); 2117 if (/* These first two lines are the `non-type' bit. */ 2118 TREE_CODE_CLASS (TREE_CODE (arg)) != 't' 2119 && TREE_CODE (arg) != TEMPLATE_DECL 2120 /* This next line is the `argument expression is not just a 2121 simple identifier' condition and also the `specialized 2122 non-type argument' bit. */ 2123 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX) 2124 { 2125 if (tpd.arg_uses_template_parms[i]) 2126 cp_error ("template argument `%E' involves template parameter(s)", arg); 2127 else 2128 { 2129 /* Look at the corresponding template parameter, 2130 marking which template parameters its type depends 2131 upon. */ 2132 tree type = 2133 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms, 2134 i))); 2135 2136 if (!tpd2.parms) 2137 { 2138 /* We haven't yet initialized TPD2. Do so now. */ 2139 tpd2.arg_uses_template_parms 2140 = (int*) alloca (sizeof (int) * nargs); 2141 /* The number of parameters here is the number in the 2142 main template, which, as checked in the assertion 2143 above, is NARGS. */ 2144 tpd2.parms = (int*) alloca (sizeof (int) * nargs); 2145 tpd2.level = 2146 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl)); 2147 } 2148 2149 /* Mark the template parameters. But this time, we're 2150 looking for the template parameters of the main 2151 template, not in the specialization. */ 2152 tpd2.current_arg = i; 2153 tpd2.arg_uses_template_parms[i] = 0; 2154 bzero ((PTR) tpd2.parms, sizeof (int) * nargs); 2155 for_each_template_parm (type, 2156 &mark_template_parm, 2157 &tpd2); 2158 2159 if (tpd2.arg_uses_template_parms [i]) 2160 { 2161 /* The type depended on some template parameters. 2162 If they are fully specialized in the 2163 specialization, that's OK. */ 2164 int j; 2165 for (j = 0; j < nargs; ++j) 2166 if (tpd2.parms[j] != 0 2167 && tpd.arg_uses_template_parms [j]) 2168 { 2169 cp_error ("type `%T' of template argument `%E' depends on template parameter(s)", 2170 type, 2171 arg); 2172 break; 2173 } 2174 } 2175 } 2176 } 2177 } 2178 2179 if (retrieve_specialization (maintmpl, specargs)) 2180 /* We've already got this specialization. */ 2181 return decl; 2182 2183 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) = CLASSTYPE_TI_SPEC_INFO (type) 2184 = perm_tree_cons (inner_args, inner_parms, 2185 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)); 2186 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type; 2187 return decl; 2188} 2189 2190/* Check that a template declaration's use of default arguments is not 2191 invalid. Here, PARMS are the template parameters. IS_PRIMARY is 2192 non-zero if DECL is the thing declared by a primary template. 2193 IS_PARTIAL is non-zero if DECL is a partial specialization. */ 2194 2195static void 2196check_default_tmpl_args (decl, parms, is_primary, is_partial) 2197 tree decl; 2198 tree parms; 2199 int is_primary; 2200 int is_partial; 2201{ 2202 const char *msg; 2203 int last_level_to_check; 2204 2205 /* [temp.param] 2206 2207 A default template-argument shall not be specified in a 2208 function template declaration or a function template definition, nor 2209 in the template-parameter-list of the definition of a member of a 2210 class template. */ 2211 2212 if (current_class_type 2213 && !TYPE_BEING_DEFINED (current_class_type) 2214 && DECL_LANG_SPECIFIC (decl) 2215 /* If this is either a friend defined in the scope of the class 2216 or a member function. */ 2217 && DECL_CLASS_CONTEXT (decl) == current_class_type 2218 /* And, if it was a member function, it really was defined in 2219 the scope of the class. */ 2220 && (!DECL_FUNCTION_MEMBER_P (decl) || DECL_DEFINED_IN_CLASS_P (decl))) 2221 /* We already checked these parameters when the template was 2222 declared, so there's no need to do it again now. This function 2223 was defined in class scope, but we're processing it's body now 2224 that the class is complete. */ 2225 return; 2226 2227 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary) 2228 /* For an ordinary class template, default template arguments are 2229 allowed at the innermost level, e.g.: 2230 template <class T = int> 2231 struct S {}; 2232 but, in a partial specialization, they're not allowed even 2233 there, as we have in [temp.class.spec]: 2234 2235 The template parameter list of a specialization shall not 2236 contain default template argument values. 2237 2238 So, for a partial specialization, or for a function template, 2239 we look at all of them. */ 2240 ; 2241 else 2242 /* But, for a primary class template that is not a partial 2243 specialization we look at all template parameters except the 2244 innermost ones. */ 2245 parms = TREE_CHAIN (parms); 2246 2247 /* Figure out what error message to issue. */ 2248 if (TREE_CODE (decl) == FUNCTION_DECL) 2249 msg = "default argument for template parameter in function template `%D'"; 2250 else if (is_partial) 2251 msg = "default argument in partial specialization `%D'"; 2252 else 2253 msg = "default argument for template parameter for class enclosing `%D'"; 2254 2255 if (current_class_type && TYPE_BEING_DEFINED (current_class_type)) 2256 /* If we're inside a class definition, there's no need to 2257 examine the parameters to the class itself. On the one 2258 hand, they will be checked when the class is defined, and, 2259 on the other, default arguments are legal in things like: 2260 template <class T = double> 2261 struct S { template <class U> void f(U); }; 2262 Here the default argument for `S' has no bearing on the 2263 declaration of `f'. */ 2264 last_level_to_check = template_class_depth (current_class_type) + 1; 2265 else 2266 /* Check everything. */ 2267 last_level_to_check = 0; 2268 2269 for (; parms && TMPL_PARMS_DEPTH (parms) >= last_level_to_check; 2270 parms = TREE_CHAIN (parms)) 2271 { 2272 tree inner_parms = TREE_VALUE (parms); 2273 int i, ntparms; 2274 2275 ntparms = TREE_VEC_LENGTH (inner_parms); 2276 for (i = 0; i < ntparms; ++i) 2277 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i))) 2278 { 2279 if (msg) 2280 { 2281 cp_error (msg, decl); 2282 msg = 0; 2283 } 2284 2285 /* Clear out the default argument so that we are not 2286 confused later. */ 2287 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE; 2288 } 2289 2290 /* At this point, if we're still interested in issuing messages, 2291 they must apply to classes surrounding the object declared. */ 2292 if (msg) 2293 msg = "default argument for template parameter for class enclosing `%D'"; 2294 } 2295} 2296 2297/* Creates a TEMPLATE_DECL for the indicated DECL using the template 2298 parameters given by current_template_args, or reuses a 2299 previously existing one, if appropriate. Returns the DECL, or an 2300 equivalent one, if it is replaced via a call to duplicate_decls. 2301 2302 If IS_FRIEND is non-zero, DECL is a friend declaration. */ 2303 2304tree 2305push_template_decl_real (decl, is_friend) 2306 tree decl; 2307 int is_friend; 2308{ 2309 tree tmpl; 2310 tree args; 2311 tree info; 2312 tree ctx; 2313 int primary; 2314 int is_partial; 2315 2316 /* See if this is a partial specialization. */ 2317 is_partial = (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl) 2318 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE 2319 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl))); 2320 2321 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl)); 2322 2323 if (is_friend) 2324 /* For a friend, we want the context of the friend function, not 2325 the type of which it is a friend. */ 2326 ctx = DECL_CONTEXT (decl); 2327 else if (DECL_REAL_CONTEXT (decl) 2328 && TREE_CODE (DECL_REAL_CONTEXT (decl)) != NAMESPACE_DECL) 2329 /* In the case of a virtual function, we want the class in which 2330 it is defined. */ 2331 ctx = DECL_REAL_CONTEXT (decl); 2332 else 2333 /* Otherwise, if we're currently definining some class, the DECL 2334 is assumed to be a member of the class. */ 2335 ctx = current_class_type; 2336 2337 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL) 2338 ctx = NULL_TREE; 2339 2340 if (!DECL_CONTEXT (decl)) 2341 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); 2342 2343 /* For determining whether this is a primary template or not, we're really 2344 interested in the lexical context, not the true context. */ 2345 if (is_friend) 2346 info = current_class_type; 2347 else 2348 info = ctx; 2349 2350 /* See if this is a primary template. */ 2351 if (info && TREE_CODE (info) == FUNCTION_DECL) 2352 primary = 0; 2353 /* Note that template_class_depth returns 0 if given NULL_TREE, so 2354 this next line works even when we are at global scope. */ 2355 else if (processing_template_decl > template_class_depth (info)) 2356 primary = 1; 2357 else 2358 primary = 0; 2359 2360 if (primary) 2361 { 2362 if (current_lang_name == lang_name_c) 2363 cp_error ("template with C linkage"); 2364 if (TREE_CODE (decl) == TYPE_DECL && ANON_AGGRNAME_P (DECL_NAME (decl))) 2365 cp_error ("template class without a name"); 2366 if (TREE_CODE (decl) == TYPE_DECL 2367 && TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) 2368 cp_error ("template declaration of `%#T'", TREE_TYPE (decl)); 2369 } 2370 2371 /* Check to see that the rules regarding the use of default 2372 arguments are not being violated. */ 2373 check_default_tmpl_args (decl, current_template_parms, 2374 primary, is_partial); 2375 2376 if (is_partial) 2377 return process_partial_specialization (decl); 2378 2379 args = current_template_args (); 2380 2381 if (!ctx 2382 || TREE_CODE (ctx) == FUNCTION_DECL 2383 || TYPE_BEING_DEFINED (ctx) 2384 || (is_friend && !DECL_TEMPLATE_INFO (decl))) 2385 { 2386 if (DECL_LANG_SPECIFIC (decl) 2387 && DECL_TEMPLATE_INFO (decl) 2388 && DECL_TI_TEMPLATE (decl)) 2389 tmpl = DECL_TI_TEMPLATE (decl); 2390 else 2391 { 2392 tmpl = build_template_decl (decl, current_template_parms); 2393 2394 if (DECL_LANG_SPECIFIC (decl) 2395 && DECL_TEMPLATE_SPECIALIZATION (decl)) 2396 { 2397 /* A specialization of a member template of a template 2398 class. */ 2399 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl); 2400 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl); 2401 DECL_TEMPLATE_INFO (decl) = NULL_TREE; 2402 } 2403 } 2404 } 2405 else 2406 { 2407 tree a, t, current, parms; 2408 int i; 2409 2410 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx)) 2411 cp_error ("must specialize `%#T' before defining member `%#D'", 2412 ctx, decl); 2413 if (TREE_CODE (decl) == TYPE_DECL) 2414 { 2415 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl))) 2416 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) 2417 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl)) 2418 && TYPE_TI_TEMPLATE (TREE_TYPE (decl))) 2419 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl)); 2420 else 2421 { 2422 cp_error ("`%D' does not declare a template type", decl); 2423 return decl; 2424 } 2425 } 2426 else if (! DECL_TEMPLATE_INFO (decl)) 2427 { 2428 cp_error ("template definition of non-template `%#D'", decl); 2429 return decl; 2430 } 2431 else 2432 tmpl = DECL_TI_TEMPLATE (decl); 2433 2434 if (is_member_template (tmpl) 2435 && DECL_FUNCTION_TEMPLATE_P (tmpl) 2436 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl) 2437 && DECL_TEMPLATE_SPECIALIZATION (decl)) 2438 { 2439 tree new_tmpl; 2440 2441 /* The declaration is a specialization of a member 2442 template, declared outside the class. Therefore, the 2443 innermost template arguments will be NULL, so we 2444 replace them with the arguments determined by the 2445 earlier call to check_explicit_specialization. */ 2446 args = DECL_TI_ARGS (decl); 2447 2448 new_tmpl 2449 = build_template_decl (decl, current_template_parms); 2450 DECL_TEMPLATE_RESULT (new_tmpl) = decl; 2451 TREE_TYPE (new_tmpl) = TREE_TYPE (decl); 2452 DECL_TI_TEMPLATE (decl) = new_tmpl; 2453 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl); 2454 DECL_TEMPLATE_INFO (new_tmpl) = 2455 perm_tree_cons (tmpl, args, NULL_TREE); 2456 2457 register_specialization (new_tmpl, tmpl, args); 2458 return decl; 2459 } 2460 2461 /* Make sure the template headers we got make sense. */ 2462 2463 parms = DECL_TEMPLATE_PARMS (tmpl); 2464 i = TMPL_PARMS_DEPTH (parms); 2465 if (TMPL_ARGS_DEPTH (args) != i) 2466 { 2467 cp_error ("expected %d levels of template parms for `%#D', got %d", 2468 i, decl, TMPL_ARGS_DEPTH (args)); 2469 } 2470 else 2471 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms)) 2472 { 2473 a = TMPL_ARGS_LEVEL (args, i); 2474 t = INNERMOST_TEMPLATE_PARMS (parms); 2475 2476 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a)) 2477 { 2478 if (current == decl) 2479 cp_error ("got %d template parameters for `%#D'", 2480 TREE_VEC_LENGTH (a), decl); 2481 else 2482 cp_error ("got %d template parameters for `%#T'", 2483 TREE_VEC_LENGTH (a), current); 2484 cp_error (" but %d required", TREE_VEC_LENGTH (t)); 2485 } 2486 2487 /* Perhaps we should also check that the parms are used in the 2488 appropriate qualifying scopes in the declarator? */ 2489 2490 if (current == decl) 2491 current = ctx; 2492 else 2493 current = TYPE_CONTEXT (current); 2494 } 2495 } 2496 2497 DECL_TEMPLATE_RESULT (tmpl) = decl; 2498 TREE_TYPE (tmpl) = TREE_TYPE (decl); 2499 2500 /* Push template declarations for global functions and types. Note 2501 that we do not try to push a global template friend declared in a 2502 template class; such a thing may well depend on the template 2503 parameters of the class. */ 2504 if (! ctx 2505 && !(is_friend && template_class_depth (current_class_type) > 0)) 2506 tmpl = pushdecl_namespace_level (tmpl); 2507 2508 if (primary) 2509 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl; 2510 2511 info = perm_tree_cons (tmpl, args, NULL_TREE); 2512 2513 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl)) 2514 { 2515 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info); 2516 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL) 2517 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE) 2518 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl)); 2519 } 2520 else if (! DECL_LANG_SPECIFIC (decl)) 2521 cp_error ("template declaration of `%#D'", decl); 2522 else 2523 DECL_TEMPLATE_INFO (decl) = info; 2524 2525 return DECL_TEMPLATE_RESULT (tmpl); 2526} 2527 2528tree 2529push_template_decl (decl) 2530 tree decl; 2531{ 2532 return push_template_decl_real (decl, 0); 2533} 2534 2535/* Called when a class template TYPE is redeclared with the indicated 2536 template PARMS, e.g.: 2537 2538 template <class T> struct S; 2539 template <class T> struct S {}; */ 2540 2541void 2542redeclare_class_template (type, parms) 2543 tree type; 2544 tree parms; 2545{ 2546 tree tmpl; 2547 tree tmpl_parms; 2548 int i; 2549 2550 if (!TYPE_TEMPLATE_INFO (type)) 2551 { 2552 cp_error ("`%T' is not a template type", type); 2553 return; 2554 } 2555 2556 tmpl = TYPE_TI_TEMPLATE (type); 2557 if (!PRIMARY_TEMPLATE_P (tmpl)) 2558 /* The type is nested in some template class. Nothing to worry 2559 about here; there are no new template parameters for the nested 2560 type. */ 2561 return; 2562 2563 parms = INNERMOST_TEMPLATE_PARMS (parms); 2564 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); 2565 2566 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms)) 2567 { 2568 cp_error_at ("previous declaration `%D'", tmpl); 2569 cp_error ("used %d template parameter%s instead of %d", 2570 TREE_VEC_LENGTH (tmpl_parms), 2571 TREE_VEC_LENGTH (tmpl_parms) == 1 ? "" : "s", 2572 TREE_VEC_LENGTH (parms)); 2573 return; 2574 } 2575 2576 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i) 2577 { 2578 tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i)); 2579 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); 2580 tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)); 2581 tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i)); 2582 2583 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)) 2584 { 2585 cp_error_at ("template parameter `%#D'", tmpl_parm); 2586 cp_error ("redeclared here as `%#D'", parm); 2587 return; 2588 } 2589 2590 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE) 2591 { 2592 /* We have in [temp.param]: 2593 2594 A template-parameter may not be given default arguments 2595 by two different declarations in the same scope. */ 2596 cp_error ("redefinition of default argument for `%#D'", parm); 2597 cp_error_at (" original definition appeared here", tmpl_parm); 2598 return; 2599 } 2600 2601 if (parm_default != NULL_TREE) 2602 /* Update the previous template parameters (which are the ones 2603 that will really count) with the new default value. */ 2604 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default; 2605 } 2606} 2607 2608/* Attempt to convert the non-type template parameter EXPR to the 2609 indicated TYPE. If the conversion is successful, return the 2610 converted value. If the conversion is unsuccesful, return 2611 NULL_TREE if we issued an error message, or error_mark_node if we 2612 did not. We issue error messages for out-and-out bad template 2613 parameters, but not simply because the conversion failed, since we 2614 might be just trying to do argument deduction. By the time this 2615 function is called, neither TYPE nor EXPR may make use of template 2616 parameters. */ 2617 2618static tree 2619convert_nontype_argument (type, expr) 2620 tree type; 2621 tree expr; 2622{ 2623 tree expr_type = TREE_TYPE (expr); 2624 2625 /* A template-argument for a non-type, non-template 2626 template-parameter shall be one of: 2627 2628 --an integral constant-expression of integral or enumeration 2629 type; or 2630 2631 --the name of a non-type template-parameter; or 2632 2633 --the name of an object or function with external linkage, 2634 including function templates and function template-ids but 2635 excluding non-static class members, expressed as id-expression; 2636 or 2637 2638 --the address of an object or function with external linkage, 2639 including function templates and function template-ids but 2640 excluding non-static class members, expressed as & id-expression 2641 where the & is optional if the name refers to a function or 2642 array; or 2643 2644 --a pointer to member expressed as described in _expr.unary.op_. */ 2645 2646 /* An integral constant-expression can include const variables 2647 or enumerators. */ 2648 if (INTEGRAL_TYPE_P (expr_type) && TREE_READONLY_DECL_P (expr)) 2649 expr = decl_constant_value (expr); 2650 2651 if (is_overloaded_fn (expr)) 2652 /* OK for now. We'll check that it has external linkage later. 2653 Check this first since if expr_type is the unknown_type_node 2654 we would otherwise complain below. */ 2655 ; 2656 else if (TYPE_PTRMEM_P (expr_type) 2657 || TYPE_PTRMEMFUNC_P (expr_type)) 2658 { 2659 if (TREE_CODE (expr) != PTRMEM_CST) 2660 goto bad_argument; 2661 } 2662 else if (TYPE_PTR_P (expr_type) 2663 || TYPE_PTRMEM_P (expr_type) 2664 || TREE_CODE (expr_type) == ARRAY_TYPE 2665 || TREE_CODE (type) == REFERENCE_TYPE 2666 /* If expr is the address of an overloaded function, we 2667 will get the unknown_type_node at this point. */ 2668 || expr_type == unknown_type_node) 2669 { 2670 tree referent; 2671 tree e = expr; 2672 STRIP_NOPS (e); 2673 2674 if (TREE_CODE (type) == REFERENCE_TYPE 2675 || TREE_CODE (expr_type) == ARRAY_TYPE) 2676 referent = e; 2677 else 2678 { 2679 if (TREE_CODE (e) != ADDR_EXPR) 2680 { 2681 bad_argument: 2682 cp_error ("`%E' is not a valid template argument", expr); 2683 if (TYPE_PTR_P (expr_type)) 2684 { 2685 if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE) 2686 cp_error ("it must be the address of a function with external linkage"); 2687 else 2688 cp_error ("it must be the address of an object with external linkage"); 2689 } 2690 else if (TYPE_PTRMEM_P (expr_type) 2691 || TYPE_PTRMEMFUNC_P (expr_type)) 2692 cp_error ("it must be a pointer-to-member of the form `&X::Y'"); 2693 2694 return NULL_TREE; 2695 } 2696 2697 referent = TREE_OPERAND (e, 0); 2698 STRIP_NOPS (referent); 2699 } 2700 2701 if (TREE_CODE (referent) == STRING_CST) 2702 { 2703 cp_error ("string literal %E is not a valid template argument", 2704 referent); 2705 error ("because it is the address of an object with static linkage"); 2706 return NULL_TREE; 2707 } 2708 2709 if (is_overloaded_fn (referent)) 2710 /* We'll check that it has external linkage later. */ 2711 ; 2712 else if (TREE_CODE (referent) != VAR_DECL) 2713 goto bad_argument; 2714 else if (!TREE_PUBLIC (referent)) 2715 { 2716 cp_error ("address of non-extern `%E' cannot be used as template argument", referent); 2717 return error_mark_node; 2718 } 2719 } 2720 else if (INTEGRAL_TYPE_P (expr_type) 2721 || TYPE_PTRMEM_P (expr_type) 2722 || TYPE_PTRMEMFUNC_P (expr_type) 2723 /* The next two are g++ extensions. */ 2724 || TREE_CODE (expr_type) == REAL_TYPE 2725 || TREE_CODE (expr_type) == COMPLEX_TYPE) 2726 { 2727 if (! TREE_CONSTANT (expr)) 2728 { 2729 non_constant: 2730 cp_error ("non-constant `%E' cannot be used as template argument", 2731 expr); 2732 return NULL_TREE; 2733 } 2734 } 2735 else 2736 { 2737 cp_error ("object `%E' cannot be used as template argument", expr); 2738 return NULL_TREE; 2739 } 2740 2741 switch (TREE_CODE (type)) 2742 { 2743 case INTEGER_TYPE: 2744 case BOOLEAN_TYPE: 2745 case ENUMERAL_TYPE: 2746 /* For a non-type template-parameter of integral or enumeration 2747 type, integral promotions (_conv.prom_) and integral 2748 conversions (_conv.integral_) are applied. */ 2749 if (!INTEGRAL_TYPE_P (expr_type)) 2750 return error_mark_node; 2751 2752 /* It's safe to call digest_init in this case; we know we're 2753 just converting one integral constant expression to another. */ 2754 expr = digest_init (type, expr, (tree*) 0); 2755 2756 if (TREE_CODE (expr) != INTEGER_CST) 2757 /* Curiously, some TREE_CONSTANT integral expressions do not 2758 simplify to integer constants. For example, `3 % 0', 2759 remains a TRUNC_MOD_EXPR. */ 2760 goto non_constant; 2761 2762 return expr; 2763 2764 case REAL_TYPE: 2765 case COMPLEX_TYPE: 2766 /* These are g++ extensions. */ 2767 if (TREE_CODE (expr_type) != TREE_CODE (type)) 2768 return error_mark_node; 2769 2770 expr = digest_init (type, expr, (tree*) 0); 2771 2772 if (TREE_CODE (expr) != REAL_CST) 2773 goto non_constant; 2774 2775 return expr; 2776 2777 case POINTER_TYPE: 2778 { 2779 tree type_pointed_to = TREE_TYPE (type); 2780 2781 if (TYPE_PTRMEM_P (type)) 2782 { 2783 tree e; 2784 2785 /* For a non-type template-parameter of type pointer to data 2786 member, qualification conversions (_conv.qual_) are 2787 applied. */ 2788 e = perform_qualification_conversions (type, expr); 2789 if (TREE_CODE (e) == NOP_EXPR) 2790 /* The call to perform_qualification_conversions will 2791 insert a NOP_EXPR over EXPR to do express conversion, 2792 if necessary. But, that will confuse us if we use 2793 this (converted) template parameter to instantiate 2794 another template; then the thing will not look like a 2795 valid template argument. So, just make a new 2796 constant, of the appropriate type. */ 2797 e = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr)); 2798 return e; 2799 } 2800 else if (TREE_CODE (type_pointed_to) == FUNCTION_TYPE) 2801 { 2802 /* For a non-type template-parameter of type pointer to 2803 function, only the function-to-pointer conversion 2804 (_conv.func_) is applied. If the template-argument 2805 represents a set of overloaded functions (or a pointer to 2806 such), the matching function is selected from the set 2807 (_over.over_). */ 2808 tree fns; 2809 tree fn; 2810 2811 if (TREE_CODE (expr) == ADDR_EXPR) 2812 fns = TREE_OPERAND (expr, 0); 2813 else 2814 fns = expr; 2815 2816 fn = instantiate_type (type_pointed_to, fns, 0); 2817 2818 if (fn == error_mark_node) 2819 return error_mark_node; 2820 2821 if (!TREE_PUBLIC (fn)) 2822 { 2823 if (really_overloaded_fn (fns)) 2824 return error_mark_node; 2825 else 2826 goto bad_argument; 2827 } 2828 2829 expr = build_unary_op (ADDR_EXPR, fn, 0); 2830 2831 my_friendly_assert (same_type_p (type, TREE_TYPE (expr)), 2832 0); 2833 return expr; 2834 } 2835 else 2836 { 2837 /* For a non-type template-parameter of type pointer to 2838 object, qualification conversions (_conv.qual_) and the 2839 array-to-pointer conversion (_conv.array_) are applied. 2840 [Note: In particular, neither the null pointer conversion 2841 (_conv.ptr_) nor the derived-to-base conversion 2842 (_conv.ptr_) are applied. Although 0 is a valid 2843 template-argument for a non-type template-parameter of 2844 integral type, it is not a valid template-argument for a 2845 non-type template-parameter of pointer type.] 2846 2847 The call to decay_conversion performs the 2848 array-to-pointer conversion, if appropriate. */ 2849 expr = decay_conversion (expr); 2850 2851 if (expr == error_mark_node) 2852 return error_mark_node; 2853 else 2854 return perform_qualification_conversions (type, expr); 2855 } 2856 } 2857 break; 2858 2859 case REFERENCE_TYPE: 2860 { 2861 tree type_referred_to = TREE_TYPE (type); 2862 2863 if (TREE_CODE (type_referred_to) == FUNCTION_TYPE) 2864 { 2865 /* For a non-type template-parameter of type reference to 2866 function, no conversions apply. If the 2867 template-argument represents a set of overloaded 2868 functions, the matching function is selected from the 2869 set (_over.over_). */ 2870 tree fns = expr; 2871 tree fn; 2872 2873 fn = instantiate_type (type_referred_to, fns, 0); 2874 2875 if (fn == error_mark_node) 2876 return error_mark_node; 2877 2878 if (!TREE_PUBLIC (fn)) 2879 { 2880 if (really_overloaded_fn (fns)) 2881 /* Don't issue an error here; we might get a different 2882 function if the overloading had worked out 2883 differently. */ 2884 return error_mark_node; 2885 else 2886 goto bad_argument; 2887 } 2888 2889 my_friendly_assert (same_type_p (type_referred_to, 2890 TREE_TYPE (fn)), 2891 0); 2892 2893 return fn; 2894 } 2895 else 2896 { 2897 /* For a non-type template-parameter of type reference to 2898 object, no conversions apply. The type referred to by the 2899 reference may be more cv-qualified than the (otherwise 2900 identical) type of the template-argument. The 2901 template-parameter is bound directly to the 2902 template-argument, which must be an lvalue. */ 2903 if ((TYPE_MAIN_VARIANT (expr_type) 2904 != TYPE_MAIN_VARIANT (type_referred_to)) 2905 || !at_least_as_qualified_p (type_referred_to, 2906 expr_type) 2907 || !real_lvalue_p (expr)) 2908 return error_mark_node; 2909 else 2910 return expr; 2911 } 2912 } 2913 break; 2914 2915 case RECORD_TYPE: 2916 { 2917 if (!TYPE_PTRMEMFUNC_P (type)) 2918 /* This handles templates like 2919 template<class T, T t> void f(); 2920 when T is substituted with any class. The second template 2921 parameter becomes invalid and the template candidate is 2922 rejected. */ 2923 return error_mark_node; 2924 2925 /* For a non-type template-parameter of type pointer to member 2926 function, no conversions apply. If the template-argument 2927 represents a set of overloaded member functions, the 2928 matching member function is selected from the set 2929 (_over.over_). */ 2930 2931 if (!TYPE_PTRMEMFUNC_P (expr_type) && 2932 expr_type != unknown_type_node) 2933 return error_mark_node; 2934 2935 if (TREE_CODE (expr) == PTRMEM_CST) 2936 { 2937 /* A ptr-to-member constant. */ 2938 if (!same_type_p (type, expr_type)) 2939 return error_mark_node; 2940 else 2941 return expr; 2942 } 2943 2944 if (TREE_CODE (expr) != ADDR_EXPR) 2945 return error_mark_node; 2946 2947 expr = instantiate_type (type, expr, 0); 2948 2949 if (expr == error_mark_node) 2950 return error_mark_node; 2951 2952 my_friendly_assert (same_type_p (type, TREE_TYPE (expr)), 2953 0); 2954 return expr; 2955 } 2956 break; 2957 2958 default: 2959 /* All non-type parameters must have one of these types. */ 2960 my_friendly_abort (0); 2961 break; 2962 } 2963 2964 return error_mark_node; 2965} 2966 2967/* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for 2968 template template parameters. Both PARM_PARMS and ARG_PARMS are 2969 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL 2970 or PARM_DECL. 2971 2972 ARG_PARMS may contain more parameters than PARM_PARMS. If this is 2973 the case, then extra parameters must have default arguments. 2974 2975 Consider the example: 2976 template <class T, class Allocator = allocator> class vector; 2977 template<template <class U> class TT> class C; 2978 2979 C<vector> is a valid instantiation. PARM_PARMS for the above code 2980 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for 2981 T and Allocator) and OUTER_ARGS contains the argument that is used to 2982 substitute the TT parameter. */ 2983 2984static int 2985coerce_template_template_parms (parm_parms, arg_parms, complain, 2986 in_decl, outer_args) 2987 tree parm_parms, arg_parms; 2988 int complain; 2989 tree in_decl, outer_args; 2990{ 2991 int nparms, nargs, i; 2992 tree parm, arg; 2993 2994 my_friendly_assert (TREE_CODE (parm_parms) == TREE_VEC, 0); 2995 my_friendly_assert (TREE_CODE (arg_parms) == TREE_VEC, 0); 2996 2997 nparms = TREE_VEC_LENGTH (parm_parms); 2998 nargs = TREE_VEC_LENGTH (arg_parms); 2999 3000 /* The rule here is opposite of coerce_template_parms. */ 3001 if (nargs < nparms 3002 || (nargs > nparms 3003 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE)) 3004 return 0; 3005 3006 for (i = 0; i < nparms; ++i) 3007 { 3008 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i)); 3009 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i)); 3010 3011 if (arg == NULL_TREE || arg == error_mark_node 3012 || parm == NULL_TREE || parm == error_mark_node) 3013 return 0; 3014 3015 if (TREE_CODE (arg) != TREE_CODE (parm)) 3016 return 0; 3017 3018 switch (TREE_CODE (parm)) 3019 { 3020 case TYPE_DECL: 3021 break; 3022 3023 case TEMPLATE_DECL: 3024 /* We encounter instantiations of templates like 3025 template <template <template <class> class> class TT> 3026 class C; */ 3027 { 3028 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); 3029 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); 3030 3031 if (!coerce_template_template_parms (parmparm, argparm, 3032 complain, in_decl, 3033 outer_args)) 3034 return 0; 3035 } 3036 break; 3037 3038 case PARM_DECL: 3039 /* The tsubst call is used to handle cases such as 3040 template <class T, template <T> class TT> class D; 3041 i.e. the parameter list of TT depends on earlier parameters. */ 3042 if (!same_type_p (tsubst (TREE_TYPE (parm), outer_args, 3043 complain, in_decl), 3044 TREE_TYPE (arg))) 3045 return 0; 3046 break; 3047 3048 default: 3049 my_friendly_abort (0); 3050 } 3051 } 3052 return 1; 3053} 3054 3055/* Convert the indicated template ARG as necessary to match the 3056 indicated template PARM. Returns the converted ARG, or 3057 error_mark_node if the conversion was unsuccessful. Error messages 3058 are issued if COMPLAIN is non-zero. This conversion is for the Ith 3059 parameter in the parameter list. ARGS is the full set of template 3060 arguments deduced so far. */ 3061 3062static tree 3063convert_template_argument (parm, arg, args, complain, i, in_decl) 3064 tree parm; 3065 tree arg; 3066 tree args; 3067 int complain; 3068 int i; 3069 tree in_decl; 3070{ 3071 tree val; 3072 tree inner_args; 3073 int is_type, requires_type, is_tmpl_type, requires_tmpl_type; 3074 3075 inner_args = innermost_args (args); 3076 3077 if (TREE_CODE (arg) == TREE_LIST 3078 && TREE_TYPE (arg) != NULL_TREE 3079 && TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE) 3080 { 3081 /* The template argument was the name of some 3082 member function. That's usually 3083 illegal, but static members are OK. In any 3084 case, grab the underlying fields/functions 3085 and issue an error later if required. */ 3086 arg = TREE_VALUE (arg); 3087 TREE_TYPE (arg) = unknown_type_node; 3088 } 3089 3090 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL; 3091 requires_type = (TREE_CODE (parm) == TYPE_DECL 3092 || requires_tmpl_type); 3093 3094 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true, 3095 we also accept implicitly created TYPE_DECL as a valid argument. 3096 This is necessary to handle the case where we pass a template name 3097 to a template template parameter in a scope where we've derived from 3098 in instantiation of that template, so the template name refers to that 3099 instantiation. We really ought to handle this better. */ 3100 is_tmpl_type 3101 = ((TREE_CODE (arg) == TEMPLATE_DECL 3102 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL) 3103 || (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM 3104 && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg)) 3105 || (TREE_CODE (arg) == RECORD_TYPE 3106 && CLASSTYPE_TEMPLATE_INFO (arg) 3107 && TREE_CODE (TYPE_NAME (arg)) == TYPE_DECL 3108 && DECL_ARTIFICIAL (TYPE_NAME (arg)) 3109 && requires_tmpl_type 3110 && is_base_of_enclosing_class (arg, current_class_type))); 3111 if (is_tmpl_type && TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) 3112 arg = TYPE_STUB_DECL (arg); 3113 else if (is_tmpl_type && TREE_CODE (arg) == RECORD_TYPE) 3114 arg = CLASSTYPE_TI_TEMPLATE (arg); 3115 3116 is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't' || is_tmpl_type; 3117 3118 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF 3119 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM) 3120 { 3121 cp_pedwarn ("to refer to a type member of a template parameter,"); 3122 cp_pedwarn (" use `typename %E'", arg); 3123 3124 arg = make_typename_type (TREE_OPERAND (arg, 0), 3125 TREE_OPERAND (arg, 1)); 3126 is_type = 1; 3127 } 3128 if (is_type != requires_type) 3129 { 3130 if (in_decl) 3131 { 3132 if (complain) 3133 { 3134 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'", 3135 i + 1, in_decl); 3136 if (is_type) 3137 cp_error (" expected a constant of type `%T', got `%T'", 3138 TREE_TYPE (parm), 3139 (is_tmpl_type ? DECL_NAME (arg) : arg)); 3140 else 3141 cp_error (" expected a type, got `%E'", arg); 3142 } 3143 } 3144 return error_mark_node; 3145 } 3146 if (is_tmpl_type ^ requires_tmpl_type) 3147 { 3148 if (in_decl && complain) 3149 { 3150 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'", 3151 i + 1, in_decl); 3152 if (is_tmpl_type) 3153 cp_error (" expected a type, got `%T'", DECL_NAME (arg)); 3154 else 3155 cp_error (" expected a class template, got `%T'", arg); 3156 } 3157 return error_mark_node; 3158 } 3159 3160 if (is_type) 3161 { 3162 if (requires_tmpl_type) 3163 { 3164 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm); 3165 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg); 3166 3167 if (coerce_template_template_parms (parmparm, argparm, complain, 3168 in_decl, inner_args)) 3169 { 3170 val = arg; 3171 3172 /* TEMPLATE_TEMPLATE_PARM node is preferred over 3173 TEMPLATE_DECL. */ 3174 if (val != error_mark_node 3175 && DECL_TEMPLATE_TEMPLATE_PARM_P (val)) 3176 val = TREE_TYPE (val); 3177 } 3178 else 3179 { 3180 if (in_decl && complain) 3181 { 3182 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'", 3183 i + 1, in_decl); 3184 cp_error (" expected a template of type `%D', got `%D'", parm, arg); 3185 } 3186 3187 val = error_mark_node; 3188 } 3189 } 3190 else 3191 { 3192 val = groktypename (arg); 3193 if (! processing_template_decl) 3194 { 3195 /* [basic.link]: A name with no linkage (notably, the 3196 name of a class or enumeration declared in a local 3197 scope) shall not be used to declare an entity with 3198 linkage. This implies that names with no linkage 3199 cannot be used as template arguments. */ 3200 tree t = no_linkage_check (val); 3201 if (t) 3202 { 3203 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))) 3204 cp_pedwarn 3205 ("template-argument `%T' uses anonymous type", val); 3206 else 3207 cp_error 3208 ("template-argument `%T' uses local type `%T'", 3209 val, t); 3210 return error_mark_node; 3211 } 3212 } 3213 } 3214 } 3215 else 3216 { 3217 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl); 3218 3219 if (processing_template_decl) 3220 arg = maybe_fold_nontype_arg (arg); 3221 3222 if (!uses_template_parms (arg) && !uses_template_parms (t)) 3223 /* We used to call digest_init here. However, digest_init 3224 will report errors, which we don't want when complain 3225 is zero. More importantly, digest_init will try too 3226 hard to convert things: for example, `0' should not be 3227 converted to pointer type at this point according to 3228 the standard. Accepting this is not merely an 3229 extension, since deciding whether or not these 3230 conversions can occur is part of determining which 3231 function template to call, or whether a given epxlicit 3232 argument specification is legal. */ 3233 val = convert_nontype_argument (t, arg); 3234 else 3235 val = arg; 3236 3237 if (val == NULL_TREE) 3238 val = error_mark_node; 3239 else if (val == error_mark_node && complain) 3240 cp_error ("could not convert template argument `%E' to `%T'", 3241 arg, t); 3242 } 3243 3244 return val; 3245} 3246 3247/* Convert all template arguments to their appropriate types, and 3248 return a vector containing the innermost resulting template 3249 arguments. If any error occurs, return error_mark_node, and, if 3250 COMPLAIN is non-zero, issue an error message. Some error messages 3251 are issued even if COMPLAIN is zero; for instance, if a template 3252 argument is composed from a local class. 3253 3254 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be 3255 provided in ARGLIST, or else trailing parameters must have default 3256 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument 3257 deduction for any unspecified trailing arguments. 3258 3259 The resulting TREE_VEC is allocated on a temporary obstack, and 3260 must be explicitly copied if it will be permanent. */ 3261 3262static tree 3263coerce_template_parms (parms, args, in_decl, 3264 complain, 3265 require_all_arguments) 3266 tree parms, args; 3267 tree in_decl; 3268 int complain; 3269 int require_all_arguments; 3270{ 3271 int nparms, nargs, i, lost = 0; 3272 tree inner_args; 3273 tree new_args; 3274 tree new_inner_args; 3275 3276 inner_args = innermost_args (args); 3277 nargs = NUM_TMPL_ARGS (inner_args); 3278 nparms = TREE_VEC_LENGTH (parms); 3279 3280 if (nargs > nparms 3281 || (nargs < nparms 3282 && require_all_arguments 3283 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE)) 3284 { 3285 if (complain) 3286 { 3287 cp_error ("wrong number of template arguments (%d, should be %d)", 3288 nargs, nparms); 3289 3290 if (in_decl) 3291 cp_error_at ("provided for `%D'", in_decl); 3292 } 3293 3294 return error_mark_node; 3295 } 3296 3297 new_inner_args = make_temp_vec (nparms); 3298 new_args = add_outermost_template_args (args, new_inner_args); 3299 for (i = 0; i < nparms; i++) 3300 { 3301 tree arg; 3302 tree parm; 3303 3304 /* Get the Ith template parameter. */ 3305 parm = TREE_VEC_ELT (parms, i); 3306 3307 /* Calculate the Ith argument. */ 3308 if (inner_args && TREE_CODE (inner_args) == TREE_LIST) 3309 { 3310 arg = TREE_VALUE (inner_args); 3311 inner_args = TREE_CHAIN (inner_args); 3312 } 3313 else if (i < nargs) 3314 arg = TREE_VEC_ELT (inner_args, i); 3315 /* If no template argument was supplied, look for a default 3316 value. */ 3317 else if (TREE_PURPOSE (parm) == NULL_TREE) 3318 { 3319 /* There was no default value. */ 3320 my_friendly_assert (!require_all_arguments, 0); 3321 break; 3322 } 3323 else if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL) 3324 arg = tsubst (TREE_PURPOSE (parm), new_args, complain, in_decl); 3325 else 3326 arg = tsubst_expr (TREE_PURPOSE (parm), new_args, complain, 3327 in_decl); 3328 3329 /* Now, convert the Ith argument, as necessary. */ 3330 if (arg == NULL_TREE) 3331 /* We're out of arguments. */ 3332 { 3333 my_friendly_assert (!require_all_arguments, 0); 3334 break; 3335 } 3336 else if (arg == error_mark_node) 3337 { 3338 cp_error ("template argument %d is invalid", i + 1); 3339 arg = error_mark_node; 3340 } 3341 else 3342 arg = convert_template_argument (TREE_VALUE (parm), 3343 arg, new_args, complain, i, 3344 in_decl); 3345 3346 if (arg == error_mark_node) 3347 lost++; 3348 TREE_VEC_ELT (new_inner_args, i) = arg; 3349 } 3350 3351 if (lost) 3352 return error_mark_node; 3353 3354 return new_inner_args; 3355} 3356 3357/* Returns 1 if template args OT and NT are equivalent. */ 3358 3359static int 3360template_args_equal (ot, nt) 3361 tree ot, nt; 3362{ 3363 if (nt == ot) 3364 return 1; 3365 if (TREE_CODE (nt) != TREE_CODE (ot)) 3366 return 0; 3367 if (TREE_CODE (nt) == TREE_VEC) 3368 /* For member templates */ 3369 return comp_template_args (ot, nt); 3370 else if (TREE_CODE_CLASS (TREE_CODE (ot)) == 't') 3371 return same_type_p (ot, nt); 3372 else 3373 return (cp_tree_equal (ot, nt) > 0); 3374} 3375 3376/* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets 3377 of template arguments. Returns 0 otherwise. */ 3378 3379int 3380comp_template_args (oldargs, newargs) 3381 tree oldargs, newargs; 3382{ 3383 int i; 3384 3385 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs)) 3386 return 0; 3387 3388 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i) 3389 { 3390 tree nt = TREE_VEC_ELT (newargs, i); 3391 tree ot = TREE_VEC_ELT (oldargs, i); 3392 3393 if (! template_args_equal (ot, nt)) 3394 return 0; 3395 } 3396 return 1; 3397} 3398 3399/* Given class template name and parameter list, produce a user-friendly name 3400 for the instantiation. */ 3401 3402static char * 3403mangle_class_name_for_template (name, parms, arglist) 3404 char *name; 3405 tree parms, arglist; 3406{ 3407 static struct obstack scratch_obstack; 3408 static char *scratch_firstobj; 3409 int i, nparms; 3410 3411 if (!scratch_firstobj) 3412 gcc_obstack_init (&scratch_obstack); 3413 else 3414 obstack_free (&scratch_obstack, scratch_firstobj); 3415 scratch_firstobj = obstack_alloc (&scratch_obstack, 1); 3416 3417#define ccat(c) obstack_1grow (&scratch_obstack, (c)); 3418#define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s)) 3419 3420 cat (name); 3421 ccat ('<'); 3422 nparms = TREE_VEC_LENGTH (parms); 3423 arglist = innermost_args (arglist); 3424 my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268); 3425 for (i = 0; i < nparms; i++) 3426 { 3427 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); 3428 tree arg = TREE_VEC_ELT (arglist, i); 3429 3430 if (i) 3431 ccat (','); 3432 3433 if (TREE_CODE (parm) == TYPE_DECL) 3434 { 3435 cat (type_as_string_real (arg, 0, 1)); 3436 continue; 3437 } 3438 else if (TREE_CODE (parm) == TEMPLATE_DECL) 3439 { 3440 if (TREE_CODE (arg) == TEMPLATE_DECL) 3441 { 3442 /* Already substituted with real template. Just output 3443 the template name here */ 3444 tree context = DECL_CONTEXT (arg); 3445 if (context) 3446 { 3447 my_friendly_assert (TREE_CODE (context) == NAMESPACE_DECL, 980422); 3448 cat(decl_as_string (DECL_CONTEXT (arg), 0)); 3449 cat("::"); 3450 } 3451 cat (IDENTIFIER_POINTER (DECL_NAME (arg))); 3452 } 3453 else 3454 /* Output the parameter declaration */ 3455 cat (type_as_string_real (arg, 0, 1)); 3456 continue; 3457 } 3458 else 3459 my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269); 3460 3461 if (TREE_CODE (arg) == TREE_LIST) 3462 { 3463 /* New list cell was built because old chain link was in 3464 use. */ 3465 my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270); 3466 arg = TREE_VALUE (arg); 3467 } 3468 /* No need to check arglist against parmlist here; we did that 3469 in coerce_template_parms, called from lookup_template_class. */ 3470 cat (expr_as_string (arg, 0)); 3471 } 3472 { 3473 char *bufp = obstack_next_free (&scratch_obstack); 3474 int offset = 0; 3475 while (bufp[offset - 1] == ' ') 3476 offset--; 3477 obstack_blank_fast (&scratch_obstack, offset); 3478 3479 /* B<C<char> >, not B<C<char>> */ 3480 if (bufp[offset - 1] == '>') 3481 ccat (' '); 3482 } 3483 ccat ('>'); 3484 ccat ('\0'); 3485 return (char *) obstack_base (&scratch_obstack); 3486} 3487 3488static tree 3489classtype_mangled_name (t) 3490 tree t; 3491{ 3492 if (CLASSTYPE_TEMPLATE_INFO (t) 3493 /* Specializations have already had their names set up in 3494 lookup_template_class. */ 3495 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) 3496 { 3497 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t)); 3498 3499 /* For non-primary templates, the template parameters are 3500 implicit from their surrounding context. */ 3501 if (PRIMARY_TEMPLATE_P (tmpl)) 3502 { 3503 tree name = DECL_NAME (tmpl); 3504 char *mangled_name = mangle_class_name_for_template 3505 (IDENTIFIER_POINTER (name), 3506 DECL_INNERMOST_TEMPLATE_PARMS (tmpl), 3507 CLASSTYPE_TI_ARGS (t)); 3508 tree id = get_identifier (mangled_name); 3509 IDENTIFIER_TEMPLATE (id) = name; 3510 return id; 3511 } 3512 } 3513 3514 return TYPE_IDENTIFIER (t); 3515} 3516 3517static void 3518add_pending_template (d) 3519 tree d; 3520{ 3521 tree ti; 3522 3523 if (TREE_CODE_CLASS (TREE_CODE (d)) == 't') 3524 ti = CLASSTYPE_TEMPLATE_INFO (d); 3525 else 3526 ti = DECL_TEMPLATE_INFO (d); 3527 3528 if (TI_PENDING_TEMPLATE_FLAG (ti)) 3529 return; 3530 3531 *template_tail = perm_tree_cons 3532 (build_srcloc_here (), d, NULL_TREE); 3533 template_tail = &TREE_CHAIN (*template_tail); 3534 TI_PENDING_TEMPLATE_FLAG (ti) = 1; 3535} 3536 3537 3538/* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which 3539 may be either a _DECL or an overloaded function or an 3540 IDENTIFIER_NODE), and ARGLIST. */ 3541 3542tree 3543lookup_template_function (fns, arglist) 3544 tree fns, arglist; 3545{ 3546 tree type; 3547 3548 if (fns == NULL_TREE) 3549 { 3550 cp_error ("non-template used as template"); 3551 return error_mark_node; 3552 } 3553 3554 type = TREE_TYPE (fns); 3555 if (TREE_CODE (fns) == OVERLOAD || !type) 3556 type = unknown_type_node; 3557 3558 if (processing_template_decl) 3559 return build_min (TEMPLATE_ID_EXPR, type, fns, arglist); 3560 else 3561 return build (TEMPLATE_ID_EXPR, type, fns, arglist); 3562} 3563 3564/* Within the scope of a template class S<T>, the name S gets bound 3565 (in build_self_reference) to a TYPE_DECL for the class, not a 3566 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type, 3567 or one of its enclosing classes, and that type is a template, 3568 return the associated TEMPLATE_DECL. Otherwise, the original 3569 DECL is returned. */ 3570 3571static tree 3572maybe_get_template_decl_from_type_decl (decl) 3573 tree decl; 3574{ 3575 return (decl != NULL_TREE 3576 && TREE_CODE (decl) == TYPE_DECL 3577 && DECL_ARTIFICIAL (decl) 3578 && CLASS_TYPE_P (TREE_TYPE (decl)) 3579 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl))) 3580 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl; 3581} 3582 3583/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of 3584 parameters, find the desired type. 3585 3586 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments. 3587 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will 3588 be a TREE_LIST if called directly from the parser, and a TREE_VEC 3589 otherwise.) 3590 3591 IN_DECL, if non-NULL, is the template declaration we are trying to 3592 instantiate. 3593 3594 If ENTERING_SCOPE is non-zero, we are about to enter the scope of 3595 the class we are looking up. 3596 3597 If the template class is really a local class in a template 3598 function, then the FUNCTION_CONTEXT is the function in which it is 3599 being instantiated. */ 3600 3601tree 3602lookup_template_class (d1, arglist, in_decl, context, entering_scope) 3603 tree d1, arglist; 3604 tree in_decl; 3605 tree context; 3606 int entering_scope; 3607{ 3608 tree template = NULL_TREE, parmlist; 3609 tree t; 3610 3611 if (TREE_CODE (d1) == IDENTIFIER_NODE) 3612 { 3613 if (IDENTIFIER_VALUE (d1) 3614 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1))) 3615 template = IDENTIFIER_VALUE (d1); 3616 else 3617 { 3618 if (context) 3619 push_decl_namespace (context); 3620 if (current_class_type != NULL_TREE) 3621 template = 3622 maybe_get_template_decl_from_type_decl 3623 (IDENTIFIER_CLASS_VALUE (d1)); 3624 if (template == NULL_TREE) 3625 template = lookup_name_nonclass (d1); 3626 if (context) 3627 pop_decl_namespace (); 3628 } 3629 if (template) 3630 context = DECL_CONTEXT (template); 3631 } 3632 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1))) 3633 { 3634 tree type = TREE_TYPE (d1); 3635 3636 /* If we are declaring a constructor, say A<T>::A<T>, we will get 3637 an implicit typename for the second A. Deal with it. */ 3638 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type)) 3639 type = TREE_TYPE (type); 3640 3641 if (CLASSTYPE_TEMPLATE_INFO (type)) 3642 { 3643 template = CLASSTYPE_TI_TEMPLATE (type); 3644 d1 = DECL_NAME (template); 3645 } 3646 } 3647 else if (TREE_CODE (d1) == ENUMERAL_TYPE 3648 || (TREE_CODE_CLASS (TREE_CODE (d1)) == 't' 3649 && IS_AGGR_TYPE (d1))) 3650 { 3651 template = TYPE_TI_TEMPLATE (d1); 3652 d1 = DECL_NAME (template); 3653 } 3654 else if (TREE_CODE (d1) == TEMPLATE_DECL 3655 && TREE_CODE (DECL_RESULT (d1)) == TYPE_DECL) 3656 { 3657 template = d1; 3658 d1 = DECL_NAME (template); 3659 context = DECL_CONTEXT (template); 3660 } 3661 else 3662 my_friendly_abort (272); 3663 3664 /* With something like `template <class T> class X class X { ... };' 3665 we could end up with D1 having nothing but an IDENTIFIER_VALUE. 3666 We don't want to do that, but we have to deal with the situation, 3667 so let's give them some syntax errors to chew on instead of a 3668 crash. */ 3669 if (! template) 3670 { 3671 cp_error ("`%T' is not a template", d1); 3672 return error_mark_node; 3673 } 3674 3675 if (context == NULL_TREE) 3676 context = global_namespace; 3677 3678 if (TREE_CODE (template) != TEMPLATE_DECL) 3679 { 3680 cp_error ("non-template type `%T' used as a template", d1); 3681 if (in_decl) 3682 cp_error_at ("for template declaration `%D'", in_decl); 3683 return error_mark_node; 3684 } 3685 3686 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template)) 3687 { 3688 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store 3689 template arguments */ 3690 3691 tree parm = copy_template_template_parm (TREE_TYPE (template)); 3692 tree template2 = TYPE_STUB_DECL (parm); 3693 tree arglist2; 3694 3695 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template); 3696 3697 arglist2 = coerce_template_parms (parmlist, arglist, template, 1, 1); 3698 if (arglist2 == error_mark_node) 3699 return error_mark_node; 3700 3701 arglist2 = copy_to_permanent (arglist2); 3702 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm) 3703 = perm_tree_cons (template2, arglist2, NULL_TREE); 3704 TYPE_SIZE (parm) = 0; 3705 return parm; 3706 } 3707 else 3708 { 3709 tree template_type = TREE_TYPE (template); 3710 tree gen_tmpl; 3711 tree type_decl; 3712 tree found = NULL_TREE; 3713 int arg_depth; 3714 int parm_depth; 3715 int is_partial_instantiation; 3716 3717 gen_tmpl = most_general_template (template); 3718 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl); 3719 parm_depth = TMPL_PARMS_DEPTH (parmlist); 3720 arg_depth = TMPL_ARGS_DEPTH (arglist); 3721 3722 /* We build up the coerced arguments and such on the 3723 momentary_obstack. */ 3724 push_momentary (); 3725 3726 if (arg_depth == 1 && parm_depth > 1) 3727 { 3728 /* We've been given an incomplete set of template arguments. 3729 For example, given: 3730 3731 template <class T> struct S1 { 3732 template <class U> struct S2 {}; 3733 template <class U> struct S2<U*> {}; 3734 }; 3735 3736 we will be called with an ARGLIST of `U*', but the 3737 TEMPLATE will be `template <class T> template 3738 <class U> struct S1<T>::S2'. We must fill in the missing 3739 arguments. */ 3740 arglist 3741 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)), 3742 arglist); 3743 arg_depth = TMPL_ARGS_DEPTH (arglist); 3744 } 3745 3746 /* Now we should enough arguments. */ 3747 my_friendly_assert (parm_depth == arg_depth, 0); 3748 3749 /* From here on, we're only interested in the most general 3750 template. */ 3751 template = gen_tmpl; 3752 3753 /* Calculate the BOUND_ARGS. These will be the args that are 3754 actually tsubst'd into the definition to create the 3755 instantiation. */ 3756 if (parm_depth > 1) 3757 { 3758 /* We have multiple levels of arguments to coerce, at once. */ 3759 int i; 3760 int saved_depth = TMPL_ARGS_DEPTH (arglist); 3761 3762 tree bound_args = make_temp_vec (parm_depth); 3763 3764 for (i = saved_depth, 3765 t = DECL_TEMPLATE_PARMS (template); 3766 i > 0 && t != NULL_TREE; 3767 --i, t = TREE_CHAIN (t)) 3768 { 3769 tree a = coerce_template_parms (TREE_VALUE (t), 3770 arglist, template, 1, 1); 3771 SET_TMPL_ARGS_LEVEL (bound_args, i, a); 3772 3773 /* We temporarily reduce the length of the ARGLIST so 3774 that coerce_template_parms will see only the arguments 3775 corresponding to the template parameters it is 3776 examining. */ 3777 TREE_VEC_LENGTH (arglist)--; 3778 } 3779 3780 /* Restore the ARGLIST to its full size. */ 3781 TREE_VEC_LENGTH (arglist) = saved_depth; 3782 3783 arglist = bound_args; 3784 } 3785 else 3786 arglist 3787 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist), 3788 innermost_args (arglist), 3789 template, 1, 1); 3790 3791 if (arglist == error_mark_node) 3792 /* We were unable to bind the arguments. */ 3793 return error_mark_node; 3794 3795 /* In the scope of a template class, explicit references to the 3796 template class refer to the type of the template, not any 3797 instantiation of it. For example, in: 3798 3799 template <class T> class C { void f(C<T>); } 3800 3801 the `C<T>' is just the same as `C'. Outside of the 3802 class, however, such a reference is an instantiation. */ 3803 if (comp_template_args (TYPE_TI_ARGS (template_type), 3804 arglist)) 3805 { 3806 found = template_type; 3807 3808 if (!entering_scope && PRIMARY_TEMPLATE_P (template)) 3809 { 3810 tree ctx; 3811 3812 /* Note that we use DECL_CONTEXT, rather than 3813 CP_DECL_CONTEXT, so that the termination test is 3814 always just `ctx'. We're not interested in namepace 3815 scopes. */ 3816 for (ctx = current_class_type; 3817 ctx; 3818 ctx = (TREE_CODE_CLASS (TREE_CODE (ctx)) == 't') 3819 ? TYPE_CONTEXT (ctx) : DECL_CONTEXT (ctx)) 3820 if (same_type_p (ctx, template_type)) 3821 break; 3822 3823 if (!ctx) 3824 /* We're not in the scope of the class, so the 3825 TEMPLATE_TYPE is not the type we want after 3826 all. */ 3827 found = NULL_TREE; 3828 } 3829 } 3830 3831 if (found) 3832 { 3833 pop_momentary (); 3834 return found; 3835 } 3836 3837 for (found = DECL_TEMPLATE_INSTANTIATIONS (template); 3838 found; found = TREE_CHAIN (found)) 3839 if (comp_template_args (TREE_PURPOSE (found), arglist)) 3840 { 3841 pop_momentary (); 3842 return TREE_VALUE (found); 3843 } 3844 3845 /* Since we didn't find the type, we'll have to create it. 3846 Since we'll be saving this type on the 3847 DECL_TEMPLATE_INSTANTIATIONS list, it must be permanent. */ 3848 push_obstacks (&permanent_obstack, &permanent_obstack); 3849 3850 /* This type is a "partial instantiation" if any of the template 3851 arguments still involve template parameters. Note that we set 3852 IS_PARTIAL_INSTANTIATION for partial specializations as 3853 well. */ 3854 is_partial_instantiation = uses_template_parms (arglist); 3855 3856 /* Create the type. */ 3857 if (TREE_CODE (template_type) == ENUMERAL_TYPE) 3858 { 3859 if (!is_partial_instantiation) 3860 t = start_enum (TYPE_IDENTIFIER (template_type)); 3861 else 3862 /* We don't want to call start_enum for this type, since 3863 the values for the enumeration constants may involve 3864 template parameters. And, no one should be interested 3865 in the enumeration constants for such a type. */ 3866 t = make_node (ENUMERAL_TYPE); 3867 } 3868 else 3869 { 3870 t = make_lang_type (TREE_CODE (template_type)); 3871 CLASSTYPE_DECLARED_CLASS (t) 3872 = CLASSTYPE_DECLARED_CLASS (template_type); 3873 CLASSTYPE_GOT_SEMICOLON (t) = 1; 3874 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t); 3875 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type); 3876 } 3877 3878 /* If we called start_enum above, this information will already 3879 be set up. */ 3880 if (!TYPE_NAME (t)) 3881 { 3882 TYPE_CONTEXT (t) = FROB_CONTEXT (context); 3883 3884 /* Create a stub TYPE_DECL for it. */ 3885 type_decl = build_decl (TYPE_DECL, DECL_NAME (template), t); 3886 SET_DECL_ARTIFICIAL (type_decl); 3887 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t); 3888 DECL_SOURCE_FILE (type_decl) 3889 = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type)); 3890 DECL_SOURCE_LINE (type_decl) 3891 = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type)); 3892 TYPE_STUB_DECL (t) = TYPE_NAME (t) = type_decl; 3893 } 3894 else 3895 type_decl = TYPE_NAME (t); 3896 3897 /* Set up the template information. We have to figure out which 3898 template is the immediate parent if this is a full 3899 instantiation. */ 3900 if (parm_depth == 1 || is_partial_instantiation 3901 || !PRIMARY_TEMPLATE_P (template)) 3902 /* This case is easy; there are no member templates involved. */ 3903 found = template; 3904 else 3905 { 3906 /* This is a full instantiation of a member template. Look 3907 for a partial instantiation of which this is an instance. */ 3908 3909 for (found = DECL_TEMPLATE_INSTANTIATIONS (template); 3910 found; found = TREE_CHAIN (found)) 3911 { 3912 int success; 3913 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found)); 3914 3915 /* We only want partial instantiations, here, not 3916 specializations or full instantiations. */ 3917 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found)) 3918 || !uses_template_parms (TREE_VALUE (found))) 3919 continue; 3920 3921 /* Temporarily reduce by one the number of levels in the 3922 ARGLIST and in FOUND so as to avoid comparing the 3923 last set of arguments. */ 3924 TREE_VEC_LENGTH (arglist)--; 3925 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --; 3926 3927 /* See if the arguments match. If they do, then TMPL is 3928 the partial instantiation we want. */ 3929 success = comp_template_args (TREE_PURPOSE (found), arglist); 3930 3931 /* Restore the argument vectors to their full size. */ 3932 TREE_VEC_LENGTH (arglist)++; 3933 TREE_VEC_LENGTH (TREE_PURPOSE (found))++; 3934 3935 if (success) 3936 { 3937 found = tmpl; 3938 break; 3939 } 3940 } 3941 3942 if (!found) 3943 { 3944 /* There was no partial instantiation. This happens 3945 where C<T> is a member template of A<T> and it's used 3946 in something like 3947 3948 template <typename T> struct B { A<T>::C<int> m; }; 3949 B<float>; 3950 3951 Create the partial instantiation. 3952 */ 3953 TREE_VEC_LENGTH (arglist)--; 3954 template = tsubst (template, arglist, /*complain=*/0, NULL_TREE); 3955 TREE_VEC_LENGTH (arglist)++; 3956 found = template; 3957 } 3958 } 3959 3960 arglist = copy_to_permanent (arglist); 3961 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE)); 3962 DECL_TEMPLATE_INSTANTIATIONS (template) 3963 = tree_cons (arglist, t, 3964 DECL_TEMPLATE_INSTANTIATIONS (template)); 3965 3966 if (TREE_CODE (t) == ENUMERAL_TYPE 3967 && !is_partial_instantiation) 3968 /* Now that the type has been registered on the instantiations 3969 list, we set up the enumerators. Because the enumeration 3970 constants may involve the enumeration type itself, we make 3971 sure to register the type first, and then create the 3972 constants. That way, doing tsubst_expr for the enumeration 3973 constants won't result in recursive calls here; we'll find 3974 the instantiation and exit above. */ 3975 tsubst_enum (template_type, t, arglist); 3976 3977 /* We're done with the permanent obstack, now. */ 3978 pop_obstacks (); 3979 /* We're also done with the momentary allocation we started 3980 above. */ 3981 pop_momentary (); 3982 3983 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO 3984 is set up. */ 3985 if (TREE_CODE (t) != ENUMERAL_TYPE) 3986 DECL_NAME (type_decl) = classtype_mangled_name (t); 3987 DECL_ASSEMBLER_NAME (type_decl) = DECL_NAME (type_decl); 3988 if (!is_partial_instantiation) 3989 { 3990 DECL_ASSEMBLER_NAME (type_decl) 3991 = get_identifier (build_overload_name (t, 1, 1)); 3992 3993 /* For backwards compatibility; code that uses 3994 -fexternal-templates expects looking up a template to 3995 instantiate it. I think DDD still relies on this. 3996 (jason 8/20/1998) */ 3997 if (TREE_CODE (t) != ENUMERAL_TYPE 3998 && flag_external_templates 3999 && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template)) 4000 && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template))) 4001 add_pending_template (t); 4002 } 4003 else 4004 /* If the type makes use of template parameters, the 4005 code that generates debugging information will crash. */ 4006 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1; 4007 4008 return t; 4009 } 4010} 4011 4012/* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or 4013 TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA. 4014 If FN returns non-zero, the iteration is terminated, and 4015 for_each_template_parm returns 1. Otherwise, the iteration 4016 continues. If FN never returns a non-zero value, the value 4017 returned by for_each_template_parm is 0. If FN is NULL, it is 4018 considered to be the function which always returns 1. */ 4019 4020static int 4021for_each_template_parm (t, fn, data) 4022 tree t; 4023 tree_fn_t fn; 4024 void* data; 4025{ 4026 if (!t) 4027 return 0; 4028 4029 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't' 4030 && for_each_template_parm (TYPE_CONTEXT (t), fn, data)) 4031 return 1; 4032 4033 switch (TREE_CODE (t)) 4034 { 4035 case INDIRECT_REF: 4036 case COMPONENT_REF: 4037 /* We assume that the object must be instantiated in order to build 4038 the COMPONENT_REF, so we test only whether the type of the 4039 COMPONENT_REF uses template parms. */ 4040 return for_each_template_parm (TREE_TYPE (t), fn, data); 4041 4042 case ARRAY_REF: 4043 case OFFSET_REF: 4044 return (for_each_template_parm (TREE_OPERAND (t, 0), fn, data) 4045 || for_each_template_parm (TREE_OPERAND (t, 1), fn, data)); 4046 4047 case IDENTIFIER_NODE: 4048 if (!IDENTIFIER_TEMPLATE (t)) 4049 return 0; 4050 my_friendly_abort (42); 4051 4052 /* aggregates of tree nodes */ 4053 case TREE_VEC: 4054 { 4055 int i = TREE_VEC_LENGTH (t); 4056 while (i--) 4057 if (for_each_template_parm (TREE_VEC_ELT (t, i), fn, data)) 4058 return 1; 4059 return 0; 4060 } 4061 case TREE_LIST: 4062 if (for_each_template_parm (TREE_PURPOSE (t), fn, data) 4063 || for_each_template_parm (TREE_VALUE (t), fn, data)) 4064 return 1; 4065 return for_each_template_parm (TREE_CHAIN (t), fn, data); 4066 4067 case OVERLOAD: 4068 if (for_each_template_parm (OVL_FUNCTION (t), fn, data)) 4069 return 1; 4070 return for_each_template_parm (OVL_CHAIN (t), fn, data); 4071 4072 /* constructed type nodes */ 4073 case POINTER_TYPE: 4074 case REFERENCE_TYPE: 4075 return for_each_template_parm (TREE_TYPE (t), fn, data); 4076 4077 case RECORD_TYPE: 4078 if (TYPE_PTRMEMFUNC_FLAG (t)) 4079 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE (t), 4080 fn, data); 4081 /* Fall through. */ 4082 4083 case UNION_TYPE: 4084 case ENUMERAL_TYPE: 4085 if (! TYPE_TEMPLATE_INFO (t)) 4086 return 0; 4087 return for_each_template_parm (TREE_VALUE 4088 (TYPE_TEMPLATE_INFO (t)), 4089 fn, data); 4090 case METHOD_TYPE: 4091 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data)) 4092 return 1; 4093 /* Fall through. */ 4094 4095 case FUNCTION_TYPE: 4096 /* Check the parameter types. Since default arguments are not 4097 instantiated until they are needed, the TYPE_ARG_TYPES may 4098 contain expressions that involve template parameters. But, 4099 no-one should be looking at them yet. And, once they're 4100 instantiated, they don't contain template parameters, so 4101 there's no point in looking at them then, either. */ 4102 { 4103 tree parm; 4104 4105 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm)) 4106 if (for_each_template_parm (TREE_VALUE (parm), fn, data)) 4107 return 1; 4108 } 4109 4110 /* Check the return type, too. */ 4111 return for_each_template_parm (TREE_TYPE (t), fn, data); 4112 4113 case ARRAY_TYPE: 4114 if (for_each_template_parm (TYPE_DOMAIN (t), fn, data)) 4115 return 1; 4116 return for_each_template_parm (TREE_TYPE (t), fn, data); 4117 case OFFSET_TYPE: 4118 if (for_each_template_parm (TYPE_OFFSET_BASETYPE (t), fn, data)) 4119 return 1; 4120 return for_each_template_parm (TREE_TYPE (t), fn, data); 4121 4122 /* decl nodes */ 4123 case TYPE_DECL: 4124 return for_each_template_parm (TREE_TYPE (t), fn, data); 4125 4126 case TEMPLATE_DECL: 4127 /* A template template parameter is encountered */ 4128 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)) 4129 return for_each_template_parm (TREE_TYPE (t), fn, data); 4130 /* Already substituted template template parameter */ 4131 return 0; 4132 4133 case CONST_DECL: 4134 if (for_each_template_parm (DECL_INITIAL (t), fn, data)) 4135 return 1; 4136 goto check_type_and_context; 4137 4138 case FUNCTION_DECL: 4139 case VAR_DECL: 4140 /* ??? What about FIELD_DECLs? */ 4141 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t) 4142 && for_each_template_parm (DECL_TI_ARGS (t), fn, data)) 4143 return 1; 4144 /* fall through */ 4145 case PARM_DECL: 4146 check_type_and_context: 4147 if (for_each_template_parm (TREE_TYPE (t), fn, data)) 4148 return 1; 4149 if (DECL_CONTEXT (t) 4150 && for_each_template_parm (DECL_CONTEXT (t), fn, data)) 4151 return 1; 4152 return 0; 4153 4154 case CALL_EXPR: 4155 return (for_each_template_parm (TREE_OPERAND (t, 0), fn, data) 4156 || for_each_template_parm (TREE_OPERAND (t, 1), fn, data)); 4157 4158 case ADDR_EXPR: 4159 return for_each_template_parm (TREE_OPERAND (t, 0), fn, data); 4160 4161 /* template parm nodes */ 4162 case TEMPLATE_TEMPLATE_PARM: 4163 /* Record template parameters such as `T' inside `TT<T>'. */ 4164 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t) 4165 && for_each_template_parm (TYPE_TI_ARGS (t), fn, data)) 4166 return 1; 4167 case TEMPLATE_TYPE_PARM: 4168 case TEMPLATE_PARM_INDEX: 4169 if (fn) 4170 return (*fn)(t, data); 4171 else 4172 return 1; 4173 4174 /* simple type nodes */ 4175 case INTEGER_TYPE: 4176 if (for_each_template_parm (TYPE_MIN_VALUE (t), fn, data)) 4177 return 1; 4178 return for_each_template_parm (TYPE_MAX_VALUE (t), fn, data); 4179 4180 case REAL_TYPE: 4181 case COMPLEX_TYPE: 4182 case VOID_TYPE: 4183 case BOOLEAN_TYPE: 4184 case NAMESPACE_DECL: 4185 return 0; 4186 4187 /* constants */ 4188 case INTEGER_CST: 4189 case REAL_CST: 4190 case STRING_CST: 4191 return 0; 4192 4193 case ERROR_MARK: 4194 /* Non-error_mark_node ERROR_MARKs are bad things. */ 4195 my_friendly_assert (t == error_mark_node, 274); 4196 /* NOTREACHED */ 4197 return 0; 4198 4199 case LOOKUP_EXPR: 4200 case TYPENAME_TYPE: 4201 return 1; 4202 4203 case PTRMEM_CST: 4204 return for_each_template_parm (TREE_TYPE (t), fn, data); 4205 4206 case SCOPE_REF: 4207 return for_each_template_parm (TREE_OPERAND (t, 0), fn, data); 4208 4209 case CONSTRUCTOR: 4210 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))) 4211 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE 4212 (TREE_TYPE (t)), fn, data); 4213 return for_each_template_parm (TREE_OPERAND (t, 1), fn, data); 4214 4215 case MODOP_EXPR: 4216 case CAST_EXPR: 4217 case REINTERPRET_CAST_EXPR: 4218 case CONST_CAST_EXPR: 4219 case STATIC_CAST_EXPR: 4220 case DYNAMIC_CAST_EXPR: 4221 case ARROW_EXPR: 4222 case DOTSTAR_EXPR: 4223 case TYPEID_EXPR: 4224 return 1; 4225 4226 case SIZEOF_EXPR: 4227 case ALIGNOF_EXPR: 4228 return for_each_template_parm (TREE_OPERAND (t, 0), fn, data); 4229 4230 default: 4231 switch (TREE_CODE_CLASS (TREE_CODE (t))) 4232 { 4233 case '1': 4234 case '2': 4235 case 'e': 4236 case '<': 4237 { 4238 int i; 4239 for (i = first_rtl_op (TREE_CODE (t)); --i >= 0;) 4240 if (for_each_template_parm (TREE_OPERAND (t, i), fn, data)) 4241 return 1; 4242 return 0; 4243 } 4244 default: 4245 break; 4246 } 4247 sorry ("testing %s for template parms", 4248 tree_code_name [(int) TREE_CODE (t)]); 4249 my_friendly_abort (82); 4250 /* NOTREACHED */ 4251 return 0; 4252 } 4253} 4254 4255int 4256uses_template_parms (t) 4257 tree t; 4258{ 4259 return for_each_template_parm (t, 0, 0); 4260} 4261 4262static struct tinst_level *current_tinst_level; 4263static struct tinst_level *free_tinst_level; 4264static int tinst_depth; 4265extern int max_tinst_depth; 4266#ifdef GATHER_STATISTICS 4267int depth_reached; 4268#endif 4269int tinst_level_tick; 4270int last_template_error_tick; 4271 4272/* Print out all the template instantiations that we are currently 4273 working on. If ERR, we are being called from cp_thing, so do 4274 the right thing for an error message. */ 4275 4276static void 4277print_template_context (err) 4278 int err; 4279{ 4280 struct tinst_level *p = current_tinst_level; 4281 int line = lineno; 4282 char *file = input_filename; 4283 4284 if (err && p) 4285 { 4286 if (current_function_decl != p->decl 4287 && current_function_decl != NULL_TREE) 4288 /* We can get here during the processing of some synthesized 4289 method. Then, p->decl will be the function that's causing 4290 the synthesis. */ 4291 ; 4292 else 4293 { 4294 if (current_function_decl == p->decl) 4295 /* Avoid redundancy with the the "In function" line. */; 4296 else 4297 fprintf (stderr, "%s: In instantiation of `%s':\n", 4298 file, decl_as_string (p->decl, 0)); 4299 4300 line = p->line; 4301 file = p->file; 4302 p = p->next; 4303 } 4304 } 4305 4306 for (; p; p = p->next) 4307 { 4308 fprintf (stderr, "%s:%d: instantiated from `%s'\n", file, line, 4309 decl_as_string (p->decl, 0)); 4310 line = p->line; 4311 file = p->file; 4312 } 4313 fprintf (stderr, "%s:%d: instantiated from here\n", file, line); 4314} 4315 4316/* Called from cp_thing to print the template context for an error. */ 4317 4318void 4319maybe_print_template_context () 4320{ 4321 if (last_template_error_tick == tinst_level_tick 4322 || current_tinst_level == 0) 4323 return; 4324 4325 last_template_error_tick = tinst_level_tick; 4326 print_template_context (1); 4327} 4328 4329static int 4330push_tinst_level (d) 4331 tree d; 4332{ 4333 struct tinst_level *new; 4334 4335 if (tinst_depth >= max_tinst_depth) 4336 { 4337 /* If the instantiation in question still has unbound template parms, 4338 we don't really care if we can't instantiate it, so just return. 4339 This happens with base instantiation for implicit `typename'. */ 4340 if (uses_template_parms (d)) 4341 return 0; 4342 4343 last_template_error_tick = tinst_level_tick; 4344 error ("template instantiation depth exceeds maximum of %d", 4345 max_tinst_depth); 4346 error (" (use -ftemplate-depth-NN to increase the maximum)"); 4347 cp_error (" instantiating `%D'", d); 4348 4349 print_template_context (0); 4350 4351 return 0; 4352 } 4353 4354 if (free_tinst_level) 4355 { 4356 new = free_tinst_level; 4357 free_tinst_level = new->next; 4358 } 4359 else 4360 new = (struct tinst_level *) xmalloc (sizeof (struct tinst_level)); 4361 4362 new->decl = d; 4363 new->line = lineno; 4364 new->file = input_filename; 4365 new->next = current_tinst_level; 4366 current_tinst_level = new; 4367 4368 ++tinst_depth; 4369#ifdef GATHER_STATISTICS 4370 if (tinst_depth > depth_reached) 4371 depth_reached = tinst_depth; 4372#endif 4373 4374 ++tinst_level_tick; 4375 return 1; 4376} 4377 4378void 4379pop_tinst_level () 4380{ 4381 struct tinst_level *old = current_tinst_level; 4382 4383 /* Restore the filename and line number stashed away when we started 4384 this instantiation. */ 4385 lineno = old->line; 4386 input_filename = old->file; 4387 extract_interface_info (); 4388 4389 current_tinst_level = old->next; 4390 old->next = free_tinst_level; 4391 free_tinst_level = old; 4392 --tinst_depth; 4393 ++tinst_level_tick; 4394} 4395 4396struct tinst_level * 4397tinst_for_decl () 4398{ 4399 struct tinst_level *p = current_tinst_level; 4400 4401 if (p) 4402 for (; p->next ; p = p->next ) 4403 ; 4404 return p; 4405} 4406 4407/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the 4408 vector of template arguments, as for tsubst. 4409 4410 Returns an appropriate tsbust'd friend declaration. */ 4411 4412static tree 4413tsubst_friend_function (decl, args) 4414 tree decl; 4415 tree args; 4416{ 4417 tree new_friend; 4418 int line = lineno; 4419 char *file = input_filename; 4420 4421 lineno = DECL_SOURCE_LINE (decl); 4422 input_filename = DECL_SOURCE_FILE (decl); 4423 4424 if (TREE_CODE (decl) == FUNCTION_DECL 4425 && DECL_TEMPLATE_INSTANTIATION (decl) 4426 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL) 4427 /* This was a friend declared with an explicit template 4428 argument list, e.g.: 4429 4430 friend void f<>(T); 4431 4432 to indicate that f was a template instantiation, not a new 4433 function declaration. Now, we have to figure out what 4434 instantiation of what template. */ 4435 { 4436 tree template_id; 4437 tree new_args; 4438 tree tmpl; 4439 4440 template_id 4441 = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl), 4442 args, /*complain=*/1, 4443 NULL_TREE), 4444 tsubst (DECL_TI_ARGS (decl), 4445 args, /*complain=*/1, 4446 NULL_TREE)); 4447 /* FIXME: The decl we create via the next tsubst could be 4448 created on a temporary obstack. */ 4449 new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE); 4450 tmpl = determine_specialization (template_id, new_friend, 4451 &new_args, 4452 /*need_member_template=*/0); 4453 new_friend = instantiate_template (tmpl, new_args); 4454 goto done; 4455 } 4456 4457 new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE); 4458 4459 /* The NEW_FRIEND will look like an instantiation, to the 4460 compiler, but is not an instantiation from the point of view of 4461 the language. For example, we might have had: 4462 4463 template <class T> struct S { 4464 template <class U> friend void f(T, U); 4465 }; 4466 4467 Then, in S<int>, template <class U> void f(int, U) is not an 4468 instantiation of anything. */ 4469 DECL_USE_TEMPLATE (new_friend) = 0; 4470 if (TREE_CODE (decl) == TEMPLATE_DECL) 4471 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0; 4472 4473 /* The mangled name for the NEW_FRIEND is incorrect. The call to 4474 tsubst will have resulted in a call to 4475 set_mangled_name_for_template_decl. But, the function is not a 4476 template instantiation and should not be mangled like one. 4477 Therefore, we remangle the function name. We don't have to do 4478 this if the NEW_FRIEND is a template since 4479 set_mangled_name_for_template_decl doesn't do anything if the 4480 function declaration still uses template arguments. */ 4481 if (TREE_CODE (new_friend) != TEMPLATE_DECL) 4482 { 4483 set_mangled_name_for_decl (new_friend); 4484 DECL_RTL (new_friend) = 0; 4485 make_decl_rtl (new_friend, NULL_PTR, 1); 4486 } 4487 4488 if (DECL_NAMESPACE_SCOPE_P (new_friend)) 4489 { 4490 tree old_decl; 4491 tree new_friend_template_info; 4492 tree new_friend_result_template_info; 4493 int new_friend_is_defn; 4494 4495 /* We must save some information from NEW_FRIEND before calling 4496 duplicate decls since that function will free NEW_FRIEND if 4497 possible. */ 4498 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend); 4499 if (TREE_CODE (new_friend) == TEMPLATE_DECL) 4500 { 4501 /* This declaration is a `primary' template. */ 4502 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend; 4503 4504 new_friend_is_defn 4505 = DECL_INITIAL (DECL_RESULT (new_friend)) != NULL_TREE; 4506 new_friend_result_template_info 4507 = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend)); 4508 } 4509 else 4510 { 4511 new_friend_is_defn = DECL_INITIAL (new_friend) != NULL_TREE; 4512 new_friend_result_template_info = NULL_TREE; 4513 } 4514 4515 old_decl = pushdecl_namespace_level (new_friend); 4516 4517 if (old_decl != new_friend) 4518 { 4519 /* This new friend declaration matched an existing 4520 declaration. For example, given: 4521 4522 template <class T> void f(T); 4523 template <class U> class C { 4524 template <class T> friend void f(T) {} 4525 }; 4526 4527 the friend declaration actually provides the definition 4528 of `f', once C has been instantiated for some type. So, 4529 old_decl will be the out-of-class template declaration, 4530 while new_friend is the in-class definition. 4531 4532 But, if `f' was called before this point, the 4533 instantiation of `f' will have DECL_TI_ARGS corresponding 4534 to `T' but not to `U', references to which might appear 4535 in the definition of `f'. Previously, the most general 4536 template for an instantiation of `f' was the out-of-class 4537 version; now it is the in-class version. Therefore, we 4538 run through all specialization of `f', adding to their 4539 DECL_TI_ARGS appropriately. In particular, they need a 4540 new set of outer arguments, corresponding to the 4541 arguments for this class instantiation. 4542 4543 The same situation can arise with something like this: 4544 4545 friend void f(int); 4546 template <class T> class C { 4547 friend void f(T) {} 4548 }; 4549 4550 when `C<int>' is instantiated. Now, `f(int)' is defined 4551 in the class. */ 4552 4553 if (!new_friend_is_defn) 4554 /* On the other hand, if the in-class declaration does 4555 *not* provide a definition, then we don't want to alter 4556 existing definitions. We can just leave everything 4557 alone. */ 4558 ; 4559 else 4560 { 4561 /* Overwrite whatever template info was there before, if 4562 any, with the new template information pertaining to 4563 the declaration. */ 4564 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info; 4565 4566 if (TREE_CODE (old_decl) != TEMPLATE_DECL) 4567 /* duplicate_decls will take care of this case. */ 4568 ; 4569 else 4570 { 4571 tree t; 4572 tree new_friend_args; 4573 4574 DECL_TEMPLATE_INFO (DECL_RESULT (old_decl)) 4575 = new_friend_result_template_info; 4576 4577 new_friend_args = TI_ARGS (new_friend_template_info); 4578 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl); 4579 t != NULL_TREE; 4580 t = TREE_CHAIN (t)) 4581 { 4582 tree spec = TREE_VALUE (t); 4583 4584 DECL_TI_ARGS (spec) 4585 = add_outermost_template_args (new_friend_args, 4586 DECL_TI_ARGS (spec)); 4587 DECL_TI_ARGS (spec) 4588 = copy_to_permanent (DECL_TI_ARGS (spec)); 4589 } 4590 4591 /* Now, since specializations are always supposed to 4592 hang off of the most general template, we must move 4593 them. */ 4594 t = most_general_template (old_decl); 4595 if (t != old_decl) 4596 { 4597 DECL_TEMPLATE_SPECIALIZATIONS (t) 4598 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t), 4599 DECL_TEMPLATE_SPECIALIZATIONS (old_decl)); 4600 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE; 4601 } 4602 } 4603 } 4604 4605 /* The information from NEW_FRIEND has been merged into OLD_DECL 4606 by duplicate_decls. */ 4607 new_friend = old_decl; 4608 } 4609 } 4610 else if (TYPE_SIZE (DECL_CONTEXT (new_friend))) 4611 { 4612 /* Check to see that the declaration is really present, and, 4613 possibly obtain an improved declaration. */ 4614 tree fn = check_classfn (DECL_CONTEXT (new_friend), 4615 new_friend); 4616 4617 if (fn) 4618 new_friend = fn; 4619 } 4620 4621 done: 4622 lineno = line; 4623 input_filename = file; 4624 return new_friend; 4625} 4626 4627/* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of 4628 template arguments, as for tsubst. 4629 4630 Returns an appropriate tsbust'd friend type. */ 4631 4632static tree 4633tsubst_friend_class (friend_tmpl, args) 4634 tree friend_tmpl; 4635 tree args; 4636{ 4637 tree friend_type; 4638 tree tmpl; 4639 4640 /* First, we look for a class template. */ 4641 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0); 4642 4643 /* But, if we don't find one, it might be because we're in a 4644 situation like this: 4645 4646 template <class T> 4647 struct S { 4648 template <class U> 4649 friend struct S; 4650 }; 4651 4652 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL 4653 for `S<int>', not the TEMPLATE_DECL. */ 4654 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl)) 4655 { 4656 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1); 4657 tmpl = maybe_get_template_decl_from_type_decl (tmpl); 4658 } 4659 4660 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl)) 4661 { 4662 /* The friend template has already been declared. Just 4663 check to see that the declarations match, and install any new 4664 default parameters. We must tsubst the default parameters, 4665 of course. We only need the innermost template parameters 4666 because that is all that redeclare_class_template will look 4667 at. */ 4668 tree parms 4669 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl), 4670 args, /*complain=*/1); 4671 redeclare_class_template (TREE_TYPE (tmpl), parms); 4672 friend_type = TREE_TYPE (tmpl); 4673 } 4674 else 4675 { 4676 /* The friend template has not already been declared. In this 4677 case, the instantiation of the template class will cause the 4678 injection of this template into the global scope. */ 4679 tmpl = tsubst (friend_tmpl, args, /*complain=*/1, NULL_TREE); 4680 4681 /* The new TMPL is not an instantiation of anything, so we 4682 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for 4683 the new type because that is supposed to be the corresponding 4684 template decl, i.e., TMPL. */ 4685 DECL_USE_TEMPLATE (tmpl) = 0; 4686 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE; 4687 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0; 4688 4689 /* Inject this template into the global scope. */ 4690 friend_type = TREE_TYPE (pushdecl_top_level (tmpl)); 4691 } 4692 4693 return friend_type; 4694} 4695 4696static int 4697has_pvbases_p (t, pattern) 4698 tree t, pattern; 4699{ 4700 if (!TYPE_USES_VIRTUAL_BASECLASSES (t)) 4701 return 0; 4702 4703 if (TYPE_USES_PVBASES (pattern)) 4704 return 1; 4705 4706 for (t = CLASSTYPE_VBASECLASSES (t); t; t = TREE_CHAIN (t)) 4707 if (TYPE_VIRTUAL_P (BINFO_TYPE (t))) 4708 return 1; 4709 4710 return 0; 4711} 4712 4713tree 4714instantiate_class_template (type) 4715 tree type; 4716{ 4717 tree template, args, pattern, t; 4718 tree typedecl; 4719 4720 if (type == error_mark_node) 4721 return error_mark_node; 4722 4723 if (TYPE_BEING_DEFINED (type) || TYPE_SIZE (type)) 4724 return type; 4725 4726 /* We want to allocate temporary vectors of template arguments and 4727 template argument expressions on the momentary obstack, not on 4728 the expression obstack. Otherwise, all the space allocated in 4729 argument coercion and such is simply lost. */ 4730 push_momentary (); 4731 4732 /* Figure out which template is being instantiated. */ 4733 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type)); 4734 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279); 4735 4736 /* Figure out which arguments are being used to do the 4737 instantiation. */ 4738 args = CLASSTYPE_TI_ARGS (type); 4739 PARTIAL_INSTANTIATION_P (type) = uses_template_parms (args); 4740 4741 if (pedantic && PARTIAL_INSTANTIATION_P (type)) 4742 /* If this is a partial instantiation, then we can't instantiate 4743 the type; there's no telling whether or not one of the 4744 template parameters might eventually be instantiated to some 4745 value that results in a specialization being used. For 4746 example, consider: 4747 4748 template <class T> 4749 struct S {}; 4750 4751 template <class U> 4752 void f(S<U>); 4753 4754 template <> 4755 struct S<int> {}; 4756 4757 Now, the `S<U>' in `f<int>' is the specialization, not an 4758 instantiation of the original template. */ 4759 goto end; 4760 4761 /* Determine what specialization of the original template to 4762 instantiate. */ 4763 if (PARTIAL_INSTANTIATION_P (type)) 4764 /* There's no telling which specialization is appropriate at this 4765 point. Since all peeking at the innards of this partial 4766 instantiation are extensions (like the "implicit typename" 4767 extension, which allows users to omit the keyword `typename' on 4768 names that are declared as types in template base classes), we 4769 are free to do what we please. 4770 4771 Trying to figure out which partial instantiation to use can 4772 cause a crash. (Some of the template arguments don't even have 4773 types.) So, we just use the most general version. */ 4774 t = NULL_TREE; 4775 else 4776 { 4777 t = most_specialized_class (template, args); 4778 4779 if (t == error_mark_node) 4780 { 4781 const char *str = "candidates are:"; 4782 cp_error ("ambiguous class template instantiation for `%#T'", type); 4783 for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t; 4784 t = TREE_CHAIN (t)) 4785 { 4786 if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), 4787 args)) 4788 { 4789 cp_error_at ("%s %+#T", str, TREE_TYPE (t)); 4790 str = " "; 4791 } 4792 } 4793 TYPE_BEING_DEFINED (type) = 1; 4794 type = error_mark_node; 4795 goto end; 4796 } 4797 } 4798 4799 if (t) 4800 pattern = TREE_TYPE (t); 4801 else 4802 pattern = TREE_TYPE (template); 4803 4804 /* If the template we're instantiating is incomplete, then clearly 4805 there's nothing we can do. */ 4806 if (TYPE_SIZE (pattern) == NULL_TREE) 4807 goto end; 4808 4809 /* If this is a partial instantiation, don't tsubst anything. We will 4810 only use this type for implicit typename, so the actual contents don't 4811 matter. All that matters is whether a particular name is a type. */ 4812 if (PARTIAL_INSTANTIATION_P (type)) 4813 { 4814 /* The fields set here must be kept in sync with those cleared 4815 in begin_class_definition. */ 4816 TYPE_BINFO_BASETYPES (type) = TYPE_BINFO_BASETYPES (pattern); 4817 TYPE_FIELDS (type) = TYPE_FIELDS (pattern); 4818 TYPE_METHODS (type) = TYPE_METHODS (pattern); 4819 CLASSTYPE_TAGS (type) = CLASSTYPE_TAGS (pattern); 4820 /* Pretend that the type is complete, so that we will look 4821 inside it during name lookup and such. */ 4822 TYPE_SIZE (type) = integer_zero_node; 4823 goto end; 4824 } 4825 4826 /* If we've recursively instantiated too many templates, stop. */ 4827 if (! push_tinst_level (type)) 4828 goto end; 4829 4830 /* Now we're really doing the instantiation. Mark the type as in 4831 the process of being defined. */ 4832 TYPE_BEING_DEFINED (type) = 1; 4833 4834 maybe_push_to_top_level (uses_template_parms (type)); 4835 4836 if (t) 4837 { 4838 /* This TYPE is actually a instantiation of of a partial 4839 specialization. We replace the innermost set of ARGS with 4840 the arguments appropriate for substitution. For example, 4841 given: 4842 4843 template <class T> struct S {}; 4844 template <class T> struct S<T*> {}; 4845 4846 and supposing that we are instantiating S<int*>, ARGS will 4847 present be {int*} but we need {int}. */ 4848 tree inner_args 4849 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), 4850 args); 4851 4852 /* If there were multiple levels in ARGS, replacing the 4853 innermost level would alter CLASSTYPE_TI_ARGS, which we don't 4854 want, so we make a copy first. */ 4855 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)) 4856 { 4857 args = copy_node (args); 4858 SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args); 4859 } 4860 else 4861 args = inner_args; 4862 } 4863 4864 if (flag_external_templates) 4865 { 4866 if (flag_alt_external_templates) 4867 { 4868 CLASSTYPE_INTERFACE_ONLY (type) = interface_only; 4869 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type, interface_unknown); 4870 CLASSTYPE_VTABLE_NEEDS_WRITING (type) 4871 = (! CLASSTYPE_INTERFACE_ONLY (type) 4872 && CLASSTYPE_INTERFACE_KNOWN (type)); 4873 } 4874 else 4875 { 4876 CLASSTYPE_INTERFACE_ONLY (type) = CLASSTYPE_INTERFACE_ONLY (pattern); 4877 SET_CLASSTYPE_INTERFACE_UNKNOWN_X 4878 (type, CLASSTYPE_INTERFACE_UNKNOWN (pattern)); 4879 CLASSTYPE_VTABLE_NEEDS_WRITING (type) 4880 = (! CLASSTYPE_INTERFACE_ONLY (type) 4881 && CLASSTYPE_INTERFACE_KNOWN (type)); 4882 } 4883 } 4884 else 4885 { 4886 SET_CLASSTYPE_INTERFACE_UNKNOWN (type); 4887 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1; 4888 } 4889 4890 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern); 4891 TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern); 4892 TYPE_OVERLOADS_CALL_EXPR (type) = TYPE_OVERLOADS_CALL_EXPR (pattern); 4893 TYPE_OVERLOADS_ARRAY_REF (type) = TYPE_OVERLOADS_ARRAY_REF (pattern); 4894 TYPE_OVERLOADS_ARROW (type) = TYPE_OVERLOADS_ARROW (pattern); 4895 TYPE_GETS_NEW (type) = TYPE_GETS_NEW (pattern); 4896 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern); 4897 TYPE_VEC_DELETE_TAKES_SIZE (type) = TYPE_VEC_DELETE_TAKES_SIZE (pattern); 4898 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern); 4899 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern); 4900 TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern); 4901 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern); 4902 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern); 4903 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern); 4904 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern); 4905 TYPE_USES_COMPLEX_INHERITANCE (type) 4906 = TYPE_USES_COMPLEX_INHERITANCE (pattern); 4907 TYPE_USES_MULTIPLE_INHERITANCE (type) 4908 = TYPE_USES_MULTIPLE_INHERITANCE (pattern); 4909 TYPE_USES_VIRTUAL_BASECLASSES (type) 4910 = TYPE_USES_VIRTUAL_BASECLASSES (pattern); 4911 TYPE_PACKED (type) = TYPE_PACKED (pattern); 4912 TYPE_ALIGN (type) = TYPE_ALIGN (pattern); 4913 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */ 4914 if (ANON_AGGR_TYPE_P (pattern)) 4915 SET_ANON_AGGR_TYPE_P (type); 4916 4917 /* We must copy the arguments to the permanent obstack since 4918 during the tsubst'ing below they may wind up in the 4919 DECL_TI_ARGS of some instantiated member template. */ 4920 args = copy_to_permanent (args); 4921 4922 if (TYPE_BINFO_BASETYPES (pattern)) 4923 { 4924 tree base_list = NULL_TREE; 4925 tree pbases = TYPE_BINFO_BASETYPES (pattern); 4926 int i; 4927 4928 /* Substitute into each of the bases to determine the actual 4929 basetypes. */ 4930 for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i) 4931 { 4932 tree base; 4933 tree access; 4934 tree pbase; 4935 4936 pbase = TREE_VEC_ELT (pbases, i); 4937 4938 /* Substitue to figure out the base class. */ 4939 base = tsubst (BINFO_TYPE (pbase), args, 4940 /*complain=*/1, NULL_TREE); 4941 if (base == error_mark_node) 4942 continue; 4943 4944 /* Calculate the correct access node. */ 4945 if (TREE_VIA_VIRTUAL (pbase)) 4946 { 4947 if (TREE_VIA_PUBLIC (pbase)) 4948 access = access_public_virtual_node; 4949 else if (TREE_VIA_PROTECTED (pbase)) 4950 access = access_protected_virtual_node; 4951 else 4952 access = access_private_virtual_node; 4953 } 4954 else 4955 { 4956 if (TREE_VIA_PUBLIC (pbase)) 4957 access = access_public_node; 4958 else if (TREE_VIA_PROTECTED (pbase)) 4959 access = access_protected_node; 4960 else 4961 access = access_private_node; 4962 } 4963 4964 base_list = tree_cons (access, base, base_list); 4965 } 4966 4967 /* The list is now in reverse order; correct that. */ 4968 base_list = nreverse (base_list); 4969 4970 /* Now call xref_basetypes to set up all the base-class 4971 information. */ 4972 xref_basetypes (TREE_CODE (pattern) == RECORD_TYPE 4973 ? (CLASSTYPE_DECLARED_CLASS (pattern) 4974 ? class_type_node : record_type_node) 4975 : union_type_node, 4976 DECL_NAME (TYPE_NAME (pattern)), 4977 type, 4978 base_list); 4979 } 4980 4981 /* Now that our base classes are set up, enter the scope of the 4982 class, so that name lookups into base classes, etc. will work 4983 corectly. This is precisely analagous to what we do in 4984 begin_class_definition when defining an ordinary non-template 4985 class. */ 4986 pushclass (type, 1); 4987 4988 for (t = CLASSTYPE_TAGS (pattern); t; t = TREE_CHAIN (t)) 4989 { 4990 tree tag = TREE_VALUE (t); 4991 tree name = TYPE_IDENTIFIER (tag); 4992 tree newtag; 4993 4994 newtag = tsubst (tag, args, /*complain=*/1, NULL_TREE); 4995 if (TREE_CODE (newtag) != ENUMERAL_TYPE) 4996 { 4997 if (TYPE_LANG_SPECIFIC (tag) && CLASSTYPE_IS_TEMPLATE (tag)) 4998 /* Unfortunately, lookup_template_class sets 4999 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial 5000 instantiation (i.e., for the type of a member template 5001 class nested within a template class.) This behavior is 5002 required for maybe_process_partial_specialization to work 5003 correctly, but is not accurate in this case; the TAG is not 5004 an instantiation of anything. (The corresponding 5005 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */ 5006 CLASSTYPE_USE_TEMPLATE (newtag) = 0; 5007 5008 /* Now, we call pushtag to put this NEWTAG into the scope of 5009 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid 5010 pushtag calling push_template_decl. We don't have to do 5011 this for enums because it will already have been done in 5012 tsubst_enum. */ 5013 if (name) 5014 SET_IDENTIFIER_TYPE_VALUE (name, newtag); 5015 pushtag (name, newtag, /*globalize=*/0); 5016 } 5017 } 5018 5019 /* Don't replace enum constants here. */ 5020 for (t = TYPE_FIELDS (pattern); t; t = TREE_CHAIN (t)) 5021 if (TREE_CODE (t) != CONST_DECL) 5022 { 5023 tree r; 5024 5025 /* The the file and line for this declaration, to assist in 5026 error message reporting. Since we called push_tinst_level 5027 above, we don't need to restore these. */ 5028 lineno = DECL_SOURCE_LINE (t); 5029 input_filename = DECL_SOURCE_FILE (t); 5030 5031 r = tsubst (t, args, /*complain=*/1, NULL_TREE); 5032 if (TREE_CODE (r) == VAR_DECL) 5033 { 5034 tree init; 5035 5036 if (DECL_DEFINED_IN_CLASS_P (r)) 5037 init = tsubst_expr (DECL_INITIAL (t), args, 5038 /*complain=*/1, NULL_TREE); 5039 else 5040 init = NULL_TREE; 5041 5042 finish_static_data_member_decl (r, init, 5043 /*asmspec_tree=*/NULL_TREE, 5044 /*need_pop=*/0, 5045 /*flags=*/0); 5046 5047 if (DECL_DEFINED_IN_CLASS_P (r)) 5048 check_static_variable_definition (r, TREE_TYPE (r)); 5049 } 5050 5051 /* R will have a TREE_CHAIN if and only if it has already been 5052 processed by finish_member_declaration. This can happen 5053 if, for example, it is a TYPE_DECL for a class-scoped 5054 ENUMERAL_TYPE; such a thing will already have been added to 5055 the field list by tsubst_enum above. */ 5056 if (!TREE_CHAIN (r)) 5057 { 5058 set_current_access_from_decl (r); 5059 finish_member_declaration (r); 5060 } 5061 } 5062 5063 /* After we have calculated the bases, we can now compute whether we 5064 have polymorphic vbases. This needs to happen before we 5065 instantiate the methods, because the constructors may take 5066 additional arguments. */ 5067 if (flag_vtable_thunks >= 2) 5068 TYPE_USES_PVBASES (type) = has_pvbases_p (type, pattern); 5069 5070 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC) 5071 for this instantiation. */ 5072 for (t = TYPE_METHODS (pattern); t; t = TREE_CHAIN (t)) 5073 { 5074 tree r = tsubst (t, args, /*complain=*/1, NULL_TREE); 5075 set_current_access_from_decl (r); 5076 finish_member_declaration (r); 5077 } 5078 5079 /* Construct the DECL_FRIENDLIST for the new class type. */ 5080 typedecl = TYPE_MAIN_DECL (type); 5081 for (t = DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern)); 5082 t != NULL_TREE; 5083 t = TREE_CHAIN (t)) 5084 { 5085 tree friends; 5086 5087 for (friends = TREE_VALUE (t); 5088 friends != NULL_TREE; 5089 friends = TREE_CHAIN (friends)) 5090 if (TREE_PURPOSE (friends) == error_mark_node) 5091 add_friend (type, 5092 tsubst_friend_function (TREE_VALUE (friends), 5093 args)); 5094 else 5095 add_friends (type, 5096 tsubst_copy (TREE_PURPOSE (t), args, 5097 /*complain=*/1, NULL_TREE), 5098 tsubst (TREE_PURPOSE (friends), args, 5099 /*complain=*/1, NULL_TREE)); 5100 } 5101 5102 for (t = CLASSTYPE_FRIEND_CLASSES (pattern); 5103 t != NULL_TREE; 5104 t = TREE_CHAIN (t)) 5105 { 5106 tree friend_type = TREE_VALUE (t); 5107 tree new_friend_type; 5108 5109 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 5110 new_friend_type = tsubst_friend_class (friend_type, args); 5111 else if (uses_template_parms (friend_type)) 5112 new_friend_type = tsubst (friend_type, args, /*complain=*/1, 5113 NULL_TREE); 5114 else 5115 /* The call to xref_tag_from_type does injection for friend 5116 classes. */ 5117 new_friend_type = 5118 xref_tag_from_type (friend_type, NULL_TREE, 1); 5119 5120 5121 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 5122 /* Trick make_friend_class into realizing that the friend 5123 we're adding is a template, not an ordinary class. It's 5124 important that we use make_friend_class since it will 5125 perform some error-checking and output cross-reference 5126 information. */ 5127 ++processing_template_decl; 5128 5129 make_friend_class (type, new_friend_type); 5130 5131 if (TREE_CODE (friend_type) == TEMPLATE_DECL) 5132 --processing_template_decl; 5133 } 5134 5135 /* This does injection for friend functions. */ 5136 if (!processing_template_decl) 5137 { 5138 t = tsubst (DECL_TEMPLATE_INJECT (template), args, 5139 /*complain=*/1, NULL_TREE); 5140 5141 for (; t; t = TREE_CHAIN (t)) 5142 { 5143 tree d = TREE_VALUE (t); 5144 5145 if (TREE_CODE (d) == TYPE_DECL) 5146 /* Already injected. */; 5147 else 5148 pushdecl (d); 5149 } 5150 } 5151 5152 for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t)) 5153 if (TREE_CODE (t) == FIELD_DECL) 5154 { 5155 TREE_TYPE (t) = complete_type (TREE_TYPE (t)); 5156 require_complete_type (t); 5157 } 5158 5159 /* Set the file and line number information to whatever is given for 5160 the class itself. This puts error messages involving generated 5161 implicit functions at a predictable point, and the same point 5162 that would be used for non-template classes. */ 5163 lineno = DECL_SOURCE_LINE (typedecl); 5164 input_filename = DECL_SOURCE_FILE (typedecl); 5165 5166 unreverse_member_declarations (type); 5167 finish_struct_1 (type, 0); 5168 CLASSTYPE_GOT_SEMICOLON (type) = 1; 5169 5170 /* Clear this now so repo_template_used is happy. */ 5171 TYPE_BEING_DEFINED (type) = 0; 5172 repo_template_used (type); 5173 5174 popclass (); 5175 pop_from_top_level (); 5176 pop_tinst_level (); 5177 5178 end: 5179 pop_momentary (); 5180 5181 return type; 5182} 5183 5184static int 5185list_eq (t1, t2) 5186 tree t1, t2; 5187{ 5188 if (t1 == NULL_TREE) 5189 return t2 == NULL_TREE; 5190 if (t2 == NULL_TREE) 5191 return 0; 5192 /* Don't care if one declares its arg const and the other doesn't -- the 5193 main variant of the arg type is all that matters. */ 5194 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1)) 5195 != TYPE_MAIN_VARIANT (TREE_VALUE (t2))) 5196 return 0; 5197 return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2)); 5198} 5199 5200/* If arg is a non-type template parameter that does not depend on template 5201 arguments, fold it like we weren't in the body of a template. */ 5202 5203static tree 5204maybe_fold_nontype_arg (arg) 5205 tree arg; 5206{ 5207 if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't' 5208 && !uses_template_parms (arg)) 5209 { 5210 /* Sometimes, one of the args was an expression involving a 5211 template constant parameter, like N - 1. Now that we've 5212 tsubst'd, we might have something like 2 - 1. This will 5213 confuse lookup_template_class, so we do constant folding 5214 here. We have to unset processing_template_decl, to 5215 fool build_expr_from_tree() into building an actual 5216 tree. */ 5217 5218 int saved_processing_template_decl = processing_template_decl; 5219 processing_template_decl = 0; 5220 arg = fold (build_expr_from_tree (arg)); 5221 processing_template_decl = saved_processing_template_decl; 5222 } 5223 return arg; 5224} 5225 5226/* Return the TREE_VEC with the arguments for the innermost template header, 5227 where ARGS is either that or the VEC of VECs for all the 5228 arguments. */ 5229 5230tree 5231innermost_args (args) 5232 tree args; 5233{ 5234 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args)); 5235} 5236 5237/* Substitute ARGS into the vector of template arguments T. */ 5238 5239static tree 5240tsubst_template_arg_vector (t, args, complain) 5241 tree t; 5242 tree args; 5243 int complain; 5244{ 5245 int len = TREE_VEC_LENGTH (t), need_new = 0, i; 5246 tree *elts = (tree *) alloca (len * sizeof (tree)); 5247 5248 bzero ((char *) elts, len * sizeof (tree)); 5249 5250 for (i = 0; i < len; i++) 5251 { 5252 if (TREE_VEC_ELT (t, i) != NULL_TREE 5253 && TREE_CODE (TREE_VEC_ELT (t, i)) == TREE_VEC) 5254 elts[i] = tsubst_template_arg_vector (TREE_VEC_ELT (t, i), 5255 args, complain); 5256 else 5257 elts[i] = maybe_fold_nontype_arg 5258 (tsubst_expr (TREE_VEC_ELT (t, i), args, complain, 5259 NULL_TREE)); 5260 5261 if (elts[i] != TREE_VEC_ELT (t, i)) 5262 need_new = 1; 5263 } 5264 5265 if (!need_new) 5266 return t; 5267 5268 t = make_temp_vec (len); 5269 for (i = 0; i < len; i++) 5270 TREE_VEC_ELT (t, i) = elts[i]; 5271 5272 return t; 5273} 5274 5275/* Return the result of substituting ARGS into the template parameters 5276 given by PARMS. If there are m levels of ARGS and m + n levels of 5277 PARMS, then the result will contain n levels of PARMS. For 5278 example, if PARMS is `template <class T> template <class U> 5279 template <T*, U, class V>' and ARGS is {{int}, {double}} then the 5280 result will be `template <int*, double, class V>'. */ 5281 5282static tree 5283tsubst_template_parms (parms, args, complain) 5284 tree parms; 5285 tree args; 5286 int complain; 5287{ 5288 tree r; 5289 tree* new_parms = &r; 5290 5291 for (new_parms = &r; 5292 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args); 5293 new_parms = &(TREE_CHAIN (*new_parms)), 5294 parms = TREE_CHAIN (parms)) 5295 { 5296 tree new_vec = 5297 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms))); 5298 int i; 5299 5300 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i) 5301 { 5302 tree default_value = 5303 TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms), i)); 5304 tree parm_decl = 5305 TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms), i)); 5306 5307 TREE_VEC_ELT (new_vec, i) 5308 = build_tree_list (tsubst (default_value, args, complain, 5309 NULL_TREE), 5310 tsubst (parm_decl, args, complain, 5311 NULL_TREE)); 5312 } 5313 5314 *new_parms = 5315 tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms) 5316 - TMPL_ARGS_DEPTH (args))), 5317 new_vec, NULL_TREE); 5318 } 5319 5320 return r; 5321} 5322 5323/* Substitute the ARGS into the indicated aggregate (or enumeration) 5324 type T. If T is not an aggregate or enumeration type, it is 5325 handled as if by tsubst. IN_DECL is as for tsubst. If 5326 ENTERING_SCOPE is non-zero, T is the context for a template which 5327 we are presently tsubst'ing. Return the subsituted value. */ 5328 5329static tree 5330tsubst_aggr_type (t, args, complain, in_decl, entering_scope) 5331 tree t; 5332 tree args; 5333 int complain; 5334 tree in_decl; 5335 int entering_scope; 5336{ 5337 if (t == NULL_TREE) 5338 return NULL_TREE; 5339 5340 switch (TREE_CODE (t)) 5341 { 5342 case RECORD_TYPE: 5343 if (TYPE_PTRMEMFUNC_P (t)) 5344 { 5345 tree r = build_ptrmemfunc_type 5346 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl)); 5347 return cp_build_qualified_type (r, TYPE_QUALS (t)); 5348 } 5349 5350 /* else fall through */ 5351 case ENUMERAL_TYPE: 5352 case UNION_TYPE: 5353 if (TYPE_TEMPLATE_INFO (t)) 5354 { 5355 tree argvec; 5356 tree context; 5357 tree r; 5358 5359 /* First, determine the context for the type we are looking 5360 up. */ 5361 if (TYPE_CONTEXT (t) != NULL_TREE) 5362 context = tsubst_aggr_type (TYPE_CONTEXT (t), args, 5363 complain, 5364 in_decl, /*entering_scope=*/1); 5365 else 5366 context = NULL_TREE; 5367 5368 /* Then, figure out what arguments are appropriate for the 5369 type we are trying to find. For example, given: 5370 5371 template <class T> struct S; 5372 template <class T, class U> void f(T, U) { S<U> su; } 5373 5374 and supposing that we are instantiating f<int, double>, 5375 then our ARGS will be {int, double}, but, when looking up 5376 S we only want {double}. */ 5377 push_momentary (); 5378 argvec = tsubst_template_arg_vector (TYPE_TI_ARGS (t), args, 5379 complain); 5380 5381 r = lookup_template_class (t, argvec, in_decl, context, 5382 entering_scope); 5383 pop_momentary (); 5384 5385 return cp_build_qualified_type (r, TYPE_QUALS (t)); 5386 } 5387 else 5388 /* This is not a template type, so there's nothing to do. */ 5389 return t; 5390 5391 default: 5392 return tsubst (t, args, complain, in_decl); 5393 } 5394} 5395 5396/* Substitute the ARGS into the T, which is a _DECL. TYPE is the 5397 (already computed) substitution of ARGS into TREE_TYPE (T), if 5398 appropriate. Return the result of the substitution. IN_DECL is as 5399 for tsubst. */ 5400 5401static tree 5402tsubst_decl (t, args, type, in_decl) 5403 tree t; 5404 tree args; 5405 tree type; 5406 tree in_decl; 5407{ 5408 int saved_lineno; 5409 char* saved_filename; 5410 tree r = NULL_TREE; 5411 5412 /* Set the filename and linenumber to improve error-reporting. */ 5413 saved_lineno = lineno; 5414 saved_filename = input_filename; 5415 lineno = DECL_SOURCE_LINE (t); 5416 input_filename = DECL_SOURCE_FILE (t); 5417 5418 switch (TREE_CODE (t)) 5419 { 5420 case TEMPLATE_DECL: 5421 { 5422 /* We can get here when processing a member template function 5423 of a template class. */ 5424 tree decl = DECL_TEMPLATE_RESULT (t); 5425 tree spec; 5426 int is_template_template_parm = DECL_TEMPLATE_TEMPLATE_PARM_P (t); 5427 5428 if (!is_template_template_parm) 5429 { 5430 /* We might already have an instance of this template. 5431 The ARGS are for the surrounding class type, so the 5432 full args contain the tsubst'd args for the context, 5433 plus the innermost args from the template decl. */ 5434 tree tmpl_args = DECL_CLASS_TEMPLATE_P (t) 5435 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t)) 5436 : DECL_TI_ARGS (DECL_RESULT (t)); 5437 tree full_args; 5438 5439 push_momentary (); 5440 full_args = tsubst_template_arg_vector (tmpl_args, args, 5441 /*complain=*/1); 5442 5443 /* tsubst_template_arg_vector doesn't copy the vector if 5444 nothing changed. But, *something* should have 5445 changed. */ 5446 my_friendly_assert (full_args != tmpl_args, 0); 5447 5448 spec = retrieve_specialization (t, full_args); 5449 pop_momentary (); 5450 if (spec != NULL_TREE) 5451 { 5452 r = spec; 5453 break; 5454 } 5455 } 5456 5457 /* Make a new template decl. It will be similar to the 5458 original, but will record the current template arguments. 5459 We also create a new function declaration, which is just 5460 like the old one, but points to this new template, rather 5461 than the old one. */ 5462 r = copy_node (t); 5463 copy_lang_decl (r); 5464 my_friendly_assert (DECL_LANG_SPECIFIC (r) != 0, 0); 5465 TREE_CHAIN (r) = NULL_TREE; 5466 5467 if (is_template_template_parm) 5468 { 5469 tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl); 5470 DECL_RESULT (r) = new_decl; 5471 TREE_TYPE (r) = TREE_TYPE (new_decl); 5472 break; 5473 } 5474 5475 DECL_CONTEXT (r) 5476 = tsubst_aggr_type (DECL_CONTEXT (t), args, /*complain=*/1, 5477 in_decl, /*entering_scope=*/1); 5478 DECL_CLASS_CONTEXT (r) 5479 = tsubst_aggr_type (DECL_CLASS_CONTEXT (t), args, 5480 /*complain=*/1, in_decl, 5481 /*entering_scope=*/1); 5482 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args); 5483 5484 if (TREE_CODE (decl) == TYPE_DECL) 5485 { 5486 tree new_type = tsubst (TREE_TYPE (t), args, 5487 /*complain=*/1, in_decl); 5488 TREE_TYPE (r) = new_type; 5489 CLASSTYPE_TI_TEMPLATE (new_type) = r; 5490 DECL_RESULT (r) = TYPE_MAIN_DECL (new_type); 5491 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type); 5492 } 5493 else 5494 { 5495 tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl); 5496 DECL_RESULT (r) = new_decl; 5497 DECL_TI_TEMPLATE (new_decl) = r; 5498 TREE_TYPE (r) = TREE_TYPE (new_decl); 5499 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl); 5500 } 5501 5502 SET_DECL_IMPLICIT_INSTANTIATION (r); 5503 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE; 5504 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE; 5505 5506 /* The template parameters for this new template are all the 5507 template parameters for the old template, except the 5508 outermost level of parameters. */ 5509 DECL_TEMPLATE_PARMS (r) 5510 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args, 5511 /*complain=*/1); 5512 5513 if (PRIMARY_TEMPLATE_P (t)) 5514 DECL_PRIMARY_TEMPLATE (r) = r; 5515 5516 /* We don't partially instantiate partial specializations. */ 5517 if (TREE_CODE (decl) == TYPE_DECL) 5518 break; 5519 5520 for (spec = DECL_TEMPLATE_SPECIALIZATIONS (t); 5521 spec != NULL_TREE; 5522 spec = TREE_CHAIN (spec)) 5523 { 5524 /* It helps to consider example here. Consider: 5525 5526 template <class T> 5527 struct S { 5528 template <class U> 5529 void f(U u); 5530 5531 template <> 5532 void f(T* t) {} 5533 }; 5534 5535 Now, for example, we are instantiating S<int>::f(U u). 5536 We want to make a template: 5537 5538 template <class U> 5539 void S<int>::f(U); 5540 5541 It will have a specialization, for the case U = int*, of 5542 the form: 5543 5544 template <> 5545 void S<int>::f<int*>(int*); 5546 5547 This specialization will be an instantiation of 5548 the specialization given in the declaration of S, with 5549 argument list int*. */ 5550 5551 tree fn = TREE_VALUE (spec); 5552 tree spec_args; 5553 tree new_fn; 5554 5555 if (!DECL_TEMPLATE_SPECIALIZATION (fn)) 5556 /* Instantiations are on the same list, but they're of 5557 no concern to us. */ 5558 continue; 5559 5560 if (TREE_CODE (fn) != TEMPLATE_DECL) 5561 /* A full specialization. There's no need to record 5562 that here. */ 5563 continue; 5564 5565 spec_args = tsubst (DECL_TI_ARGS (fn), args, 5566 /*complain=*/1, in_decl); 5567 new_fn = tsubst (DECL_RESULT (most_general_template (fn)), 5568 spec_args, /*complain=*/1, in_decl); 5569 DECL_TI_TEMPLATE (new_fn) = fn; 5570 register_specialization (new_fn, r, 5571 innermost_args (spec_args)); 5572 } 5573 5574 /* Record this partial instantiation. */ 5575 register_specialization (r, t, 5576 DECL_TI_ARGS (DECL_RESULT (r))); 5577 5578 } 5579 break; 5580 5581 case FUNCTION_DECL: 5582 { 5583 tree ctx; 5584 tree argvec = NULL_TREE; 5585 tree *friends; 5586 tree gen_tmpl; 5587 int member; 5588 int args_depth; 5589 int parms_depth; 5590 5591 /* Nobody should be tsubst'ing into non-template functions. */ 5592 my_friendly_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE, 0); 5593 5594 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL) 5595 { 5596 tree spec; 5597 5598 /* Allocate template arguments on the momentary obstack, 5599 in case we don't need to keep them. */ 5600 push_momentary (); 5601 5602 /* Calculate the most general template of which R is a 5603 specialization, and the complete set of arguments used to 5604 specialize R. */ 5605 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t)); 5606 argvec 5607 = tsubst_template_arg_vector (DECL_TI_ARGS 5608 (DECL_TEMPLATE_RESULT (gen_tmpl)), 5609 args, /*complain=*/1); 5610 5611 /* Check to see if we already have this specialization. */ 5612 spec = retrieve_specialization (gen_tmpl, argvec); 5613 5614 if (spec) 5615 { 5616 r = spec; 5617 pop_momentary (); 5618 break; 5619 } 5620 5621 /* We're going to need to keep the ARGVEC, so we copy it 5622 here. */ 5623 argvec = copy_to_permanent (argvec); 5624 pop_momentary (); 5625 5626 /* Here, we deal with the peculiar case: 5627 5628 template <class T> struct S { 5629 template <class U> friend void f(); 5630 }; 5631 template <class U> friend void f() {} 5632 template S<int>; 5633 template void f<double>(); 5634 5635 Here, the ARGS for the instantiation of will be {int, 5636 double}. But, we only need as many ARGS as there are 5637 levels of template parameters in CODE_PATTERN. We are 5638 careful not to get fooled into reducing the ARGS in 5639 situations like: 5640 5641 template <class T> struct S { template <class U> void f(U); } 5642 template <class T> template <> void S<T>::f(int) {} 5643 5644 which we can spot because the pattern will be a 5645 specialization in this case. */ 5646 args_depth = TMPL_ARGS_DEPTH (args); 5647 parms_depth = 5648 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t))); 5649 if (args_depth > parms_depth 5650 && !DECL_TEMPLATE_SPECIALIZATION (t)) 5651 { 5652 my_friendly_assert (DECL_FRIEND_P (t), 0); 5653 5654 if (parms_depth > 1) 5655 { 5656 int i; 5657 5658 args = make_temp_vec (parms_depth); 5659 for (i = 0; i < parms_depth; ++i) 5660 TREE_VEC_ELT (args, i) = 5661 TREE_VEC_ELT (args, i + (args_depth - parms_depth)); 5662 } 5663 else 5664 args = TREE_VEC_ELT (args, args_depth - parms_depth); 5665 } 5666 } 5667 else 5668 { 5669 /* This special case arises when we have something like this: 5670 5671 template <class T> struct S { 5672 friend void f<int>(int, double); 5673 }; 5674 5675 Here, the DECL_TI_TEMPLATE for the friend declaration 5676 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are 5677 being called from tsubst_friend_function, and we want 5678 only to create a new decl (R) with appropriate types so 5679 that we can call determine_specialization. */ 5680 my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t)) 5681 == LOOKUP_EXPR) 5682 || (TREE_CODE (DECL_TI_TEMPLATE (t)) 5683 == IDENTIFIER_NODE), 0); 5684 gen_tmpl = NULL_TREE; 5685 } 5686 5687 if (DECL_CLASS_SCOPE_P (t)) 5688 { 5689 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t))) 5690 member = 2; 5691 else 5692 member = 1; 5693 ctx = tsubst_aggr_type (DECL_CLASS_CONTEXT (t), args, 5694 /*complain=*/1, t, 5695 /*entering_scope=*/1); 5696 } 5697 else 5698 { 5699 member = 0; 5700 ctx = NULL_TREE; 5701 } 5702 type = tsubst (type, args, /*complain=*/1, in_decl); 5703 5704 /* We do NOT check for matching decls pushed separately at this 5705 point, as they may not represent instantiations of this 5706 template, and in any case are considered separate under the 5707 discrete model. Instead, see add_maybe_template. */ 5708 5709 r = copy_node (t); 5710 copy_lang_decl (r); 5711 DECL_USE_TEMPLATE (r) = 0; 5712 TREE_TYPE (r) = type; 5713 5714 DECL_CONTEXT (r) 5715 = tsubst_aggr_type (DECL_CONTEXT (t), args, /*complain=*/1, t, 5716 /*entering_scope=*/1); 5717 DECL_CLASS_CONTEXT (r) = ctx; 5718 5719 if (member && IDENTIFIER_TYPENAME_P (DECL_NAME (r))) 5720 /* Type-conversion operator. Reconstruct the name, in 5721 case it's the name of one of the template's parameters. */ 5722 DECL_NAME (r) = build_typename_overload (TREE_TYPE (type)); 5723 5724 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, 5725 /*complain=*/1, t); 5726 DECL_MAIN_VARIANT (r) = r; 5727 DECL_RESULT (r) = NULL_TREE; 5728 5729 TREE_STATIC (r) = 0; 5730 TREE_PUBLIC (r) = TREE_PUBLIC (t); 5731 DECL_EXTERNAL (r) = 1; 5732 DECL_INTERFACE_KNOWN (r) = 0; 5733 DECL_DEFER_OUTPUT (r) = 0; 5734 TREE_CHAIN (r) = NULL_TREE; 5735 DECL_PENDING_INLINE_INFO (r) = 0; 5736 TREE_USED (r) = 0; 5737 5738 /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled 5739 name. There's no need to do this in the special friend 5740 case mentioned above where GEN_TMPL is NULL. */ 5741 if (gen_tmpl) 5742 { 5743 /* The ARGVEC was built on the momentary obstack. Make it 5744 permanent now. */ 5745 argvec = copy_to_permanent (argvec); 5746 DECL_TEMPLATE_INFO (r) 5747 = perm_tree_cons (gen_tmpl, argvec, NULL_TREE); 5748 SET_DECL_IMPLICIT_INSTANTIATION (r); 5749 register_specialization (r, gen_tmpl, argvec); 5750 5751 5752 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r)) 5753 { 5754 maybe_retrofit_in_chrg (r); 5755 grok_ctor_properties (ctx, r); 5756 } 5757 5758 /* Set the mangled name for R. */ 5759 if (DECL_DESTRUCTOR_P (t)) 5760 DECL_ASSEMBLER_NAME (r) = 5761 build_destructor_name (ctx, DECL_DESTRUCTOR_FOR_PVBASE_P (r)); 5762 else 5763 { 5764 /* Instantiations of template functions must be mangled 5765 specially, in order to conform to 14.5.5.1 5766 [temp.over.link]. */ 5767 tree tmpl = DECL_TI_TEMPLATE (t); 5768 5769 /* TMPL will be NULL if this is a specialization of a 5770 member function of a template class. */ 5771 if (name_mangling_version < 1 5772 || tmpl == NULL_TREE 5773 || (member && !is_member_template (tmpl) 5774 && !DECL_TEMPLATE_INFO (tmpl))) 5775 set_mangled_name_for_decl (r); 5776 else 5777 set_mangled_name_for_template_decl (r); 5778 } 5779 5780 DECL_RTL (r) = 0; 5781 make_decl_rtl (r, NULL_PTR, 1); 5782 5783 /* Like grokfndecl. If we don't do this, pushdecl will 5784 mess up our TREE_CHAIN because it doesn't find a 5785 previous decl. Sigh. */ 5786 if (member 5787 && ! uses_template_parms (r) 5788 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r)) 5789 == NULL_TREE)) 5790 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r), r); 5791 } 5792 5793 /* Copy the list of befriending classes. */ 5794 for (friends = &DECL_BEFRIENDING_CLASSES (r); 5795 *friends; 5796 friends = &TREE_CHAIN (*friends)) 5797 { 5798 *friends = copy_node (*friends); 5799 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends), 5800 args, /*complain=*/1, 5801 in_decl); 5802 } 5803 5804#if 0 5805 /* This has now moved further up. */ 5806 if (DECL_CONSTRUCTOR_P (r)) 5807 { 5808 maybe_retrofit_in_chrg (r); 5809 grok_ctor_properties (ctx, r); 5810 } 5811#endif 5812 if (IDENTIFIER_OPNAME_P (DECL_NAME (r))) 5813 grok_op_properties (r, DECL_VIRTUAL_P (r), DECL_FRIEND_P (r)); 5814 } 5815 break; 5816 5817 case PARM_DECL: 5818 { 5819 r = copy_node (t); 5820 TREE_TYPE (r) = type; 5821 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r); 5822 5823 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX) 5824 DECL_INITIAL (r) = TREE_TYPE (r); 5825 else 5826 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args, 5827 /*complain=*/1, in_decl); 5828 5829 DECL_CONTEXT (r) = NULL_TREE; 5830#ifdef PROMOTE_PROTOTYPES 5831 if ((TREE_CODE (type) == INTEGER_TYPE 5832 || TREE_CODE (type) == ENUMERAL_TYPE) 5833 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) 5834 DECL_ARG_TYPE (r) = integer_type_node; 5835#endif 5836 if (TREE_CHAIN (t)) 5837 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, 5838 /*complain=*/1, TREE_CHAIN (t)); 5839 } 5840 break; 5841 5842 case FIELD_DECL: 5843 { 5844 r = copy_node (t); 5845 copy_lang_decl (r); 5846 TREE_TYPE (r) = type; 5847 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r); 5848 5849 /* We don't have to set DECL_CONTEXT here; it is set by 5850 finish_member_declaration. */ 5851 DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args, 5852 /*complain=*/1, in_decl); 5853 TREE_CHAIN (r) = NULL_TREE; 5854 if (TREE_CODE (type) == VOID_TYPE) 5855 cp_error_at ("instantiation of `%D' as type void", r); 5856 } 5857 break; 5858 5859 case USING_DECL: 5860 { 5861 r = copy_node (t); 5862 DECL_INITIAL (r) 5863 = tsubst_copy (DECL_INITIAL (t), args, /*complain=*/1, in_decl); 5864 TREE_CHAIN (r) = NULL_TREE; 5865 } 5866 break; 5867 5868 case VAR_DECL: 5869 { 5870 tree argvec; 5871 tree gen_tmpl; 5872 tree spec; 5873 tree tmpl; 5874 tree ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, 5875 /*complain=*/1, 5876 in_decl, /*entering_scope=*/1); 5877 5878 /* Nobody should be tsubst'ing into non-template variables. */ 5879 my_friendly_assert (DECL_LANG_SPECIFIC (t) 5880 && DECL_TEMPLATE_INFO (t) != NULL_TREE, 0); 5881 5882 /* Check to see if we already have this specialization. */ 5883 tmpl = DECL_TI_TEMPLATE (t); 5884 gen_tmpl = most_general_template (tmpl); 5885 argvec = tsubst (DECL_TI_ARGS (t), args, /*complain=*/1, in_decl); 5886 spec = retrieve_specialization (gen_tmpl, argvec); 5887 5888 if (spec) 5889 { 5890 r = spec; 5891 break; 5892 } 5893 5894 r = copy_node (t); 5895 TREE_TYPE (r) = type; 5896 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r); 5897 DECL_CONTEXT (r) = ctx; 5898 5899 /* Don't try to expand the initializer until someone tries to use 5900 this variable; otherwise we run into circular dependencies. */ 5901 DECL_INITIAL (r) = NULL_TREE; 5902 DECL_RTL (r) = 0; 5903 DECL_SIZE (r) = 0; 5904 copy_lang_decl (r); 5905 DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r); 5906 5907 /* A static data member declaration is always marked external 5908 when it is declared in-class, even if an initializer is 5909 present. We mimic the non-template processing here. */ 5910 DECL_EXTERNAL (r) = 1; 5911 5912 DECL_TEMPLATE_INFO (r) = perm_tree_cons (tmpl, argvec, NULL_TREE); 5913 SET_DECL_IMPLICIT_INSTANTIATION (r); 5914 register_specialization (r, gen_tmpl, argvec); 5915 5916 TREE_CHAIN (r) = NULL_TREE; 5917 if (TREE_CODE (type) == VOID_TYPE) 5918 cp_error_at ("instantiation of `%D' as type void", r); 5919 } 5920 break; 5921 5922 case TYPE_DECL: 5923 if (t == TYPE_NAME (TREE_TYPE (t))) 5924 r = TYPE_NAME (type); 5925 else 5926 { 5927 r = copy_node (t); 5928 TREE_TYPE (r) = type; 5929 DECL_CONTEXT (r) = current_class_type; 5930 TREE_CHAIN (r) = NULL_TREE; 5931 } 5932 break; 5933 5934 default: 5935 my_friendly_abort (0); 5936 } 5937 5938 /* Restore the file and line information. */ 5939 lineno = saved_lineno; 5940 input_filename = saved_filename; 5941 5942 return r; 5943} 5944 5945/* Substitue into the ARG_TYPES of a function type. */ 5946 5947static tree 5948tsubst_arg_types (arg_types, args, complain, in_decl) 5949 tree arg_types; 5950 tree args; 5951 int complain; 5952 tree in_decl; 5953{ 5954 tree remaining_arg_types; 5955 tree type; 5956 5957 if (!arg_types || arg_types == void_list_node) 5958 return arg_types; 5959 5960 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types), 5961 args, complain, in_decl); 5962 if (remaining_arg_types == error_mark_node) 5963 return error_mark_node; 5964 5965 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl); 5966 if (type == error_mark_node) 5967 return error_mark_node; 5968 5969 /* Do array-to-pointer, function-to-pointer conversion, and ignore 5970 top-level qualifiers as required. */ 5971 type = TYPE_MAIN_VARIANT (type_decays_to (type)); 5972 5973 /* Note that we do not substitute into default arguments here. The 5974 standard mandates that they be instantiated only when needed, 5975 which is done in build_over_call. */ 5976 return hash_tree_cons (TREE_PURPOSE (arg_types), type, 5977 remaining_arg_types); 5978 5979} 5980 5981/* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does 5982 *not* handle the exception-specification for FNTYPE, because the 5983 initial substitution of explicitly provided template parameters 5984 during argument deduction forbids substitution into the 5985 exception-specification: 5986 5987 [temp.deduct] 5988 5989 All references in the function type of the function template to the 5990 corresponding template parameters are replaced by the specified tem- 5991 plate argument values. If a substitution in a template parameter or 5992 in the function type of the function template results in an invalid 5993 type, type deduction fails. [Note: The equivalent substitution in 5994 exception specifications is done only when the function is instanti- 5995 ated, at which point a program is ill-formed if the substitution 5996 results in an invalid type.] */ 5997 5998static tree 5999tsubst_function_type (t, args, complain, in_decl) 6000 tree t; 6001 tree args; 6002 int complain; 6003 tree in_decl; 6004{ 6005 tree return_type; 6006 tree arg_types; 6007 tree fntype; 6008 6009 /* The TYPE_CONTEXT is not used for function/method types. */ 6010 my_friendly_assert (TYPE_CONTEXT (t) == NULL_TREE, 0); 6011 6012 /* Substitue the return type. */ 6013 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl); 6014 if (return_type == error_mark_node) 6015 return error_mark_node; 6016 6017 /* Substitue the argument types. */ 6018 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, 6019 complain, in_decl); 6020 if (arg_types == error_mark_node) 6021 return error_mark_node; 6022 6023 /* Construct a new type node and return it. */ 6024 if (TREE_CODE (t) == FUNCTION_TYPE) 6025 fntype = build_function_type (return_type, arg_types); 6026 else 6027 { 6028 tree r = TREE_TYPE (TREE_VALUE (arg_types)); 6029 if (! IS_AGGR_TYPE (r)) 6030 { 6031 /* [temp.deduct] 6032 6033 Type deduction may fail for any of the following 6034 reasons: 6035 6036 -- Attempting to create "pointer to member of T" when T 6037 is not a class type. */ 6038 if (complain) 6039 cp_error ("creating pointer to member function of non-class type `%T'", 6040 r); 6041 return error_mark_node; 6042 } 6043 6044 fntype = build_cplus_method_type (r, return_type, TREE_CHAIN 6045 (arg_types)); 6046 } 6047 fntype = build_qualified_type (fntype, TYPE_QUALS (t)); 6048 fntype = build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t)); 6049 6050 return fntype; 6051} 6052 6053/* Substitute into the PARMS of a call-declarator. */ 6054 6055static tree 6056tsubst_call_declarator_parms (parms, args, complain, in_decl) 6057 tree parms; 6058 tree args; 6059 int complain; 6060 tree in_decl; 6061{ 6062 tree new_parms; 6063 tree type; 6064 tree defarg; 6065 6066 if (!parms || parms == void_list_node) 6067 return parms; 6068 6069 new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms), 6070 args, complain, in_decl); 6071 6072 /* Figure out the type of this parameter. */ 6073 type = tsubst (TREE_VALUE (parms), args, complain, in_decl); 6074 6075 /* Figure out the default argument as well. Note that we use 6076 tsubst_expr since the default argument is really an expression. */ 6077 defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl); 6078 6079 /* Chain this parameter on to the front of those we have already 6080 processed. We don't use hash_tree_cons because that function 6081 doesn't check TREE_PARMLIST. */ 6082 new_parms = tree_cons (defarg, type, new_parms); 6083 6084 /* And note that these are parameters. */ 6085 TREE_PARMLIST (new_parms) = 1; 6086 6087 return new_parms; 6088} 6089 6090/* Take the tree structure T and replace template parameters used 6091 therein with the argument vector ARGS. IN_DECL is an associated 6092 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE. 6093 An appropriate error message is issued only if COMPLAIN is 6094 non-zero. Note that we must be relatively non-tolerant of 6095 extensions here, in order to preserve conformance; if we allow 6096 substitutions that should not be allowed, we may allow argument 6097 deductions that should not succeed, and therefore report ambiguous 6098 overload situations where there are none. In theory, we could 6099 allow the substitution, but indicate that it should have failed, 6100 and allow our caller to make sure that the right thing happens, but 6101 we don't try to do this yet. 6102 6103 This function is used for dealing with types, decls and the like; 6104 for expressions, use tsubst_expr or tsubst_copy. */ 6105 6106tree 6107tsubst (t, args, complain, in_decl) 6108 tree t, args; 6109 int complain; 6110 tree in_decl; 6111{ 6112 tree type, r; 6113 6114 if (t == NULL_TREE || t == error_mark_node 6115 || t == integer_type_node 6116 || t == void_type_node 6117 || t == char_type_node 6118 || TREE_CODE (t) == NAMESPACE_DECL) 6119 return t; 6120 6121 if (TREE_CODE (t) == IDENTIFIER_NODE) 6122 type = IDENTIFIER_TYPE_VALUE (t); 6123 else 6124 type = TREE_TYPE (t); 6125 if (type == unknown_type_node) 6126 my_friendly_abort (42); 6127 6128 if (type && TREE_CODE (t) != FUNCTION_DECL 6129 && TREE_CODE (t) != TYPENAME_TYPE 6130 && TREE_CODE (t) != TEMPLATE_DECL 6131 && TREE_CODE (t) != IDENTIFIER_NODE 6132 && TREE_CODE (t) != FUNCTION_TYPE 6133 && TREE_CODE (t) != METHOD_TYPE) 6134 type = tsubst (type, args, complain, in_decl); 6135 if (type == error_mark_node) 6136 return error_mark_node; 6137 6138 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'd') 6139 return tsubst_decl (t, args, type, in_decl); 6140 6141 switch (TREE_CODE (t)) 6142 { 6143 case RECORD_TYPE: 6144 case UNION_TYPE: 6145 case ENUMERAL_TYPE: 6146 return tsubst_aggr_type (t, args, complain, in_decl, 6147 /*entering_scope=*/0); 6148 6149 case ERROR_MARK: 6150 case IDENTIFIER_NODE: 6151 case OP_IDENTIFIER: 6152 case VOID_TYPE: 6153 case REAL_TYPE: 6154 case COMPLEX_TYPE: 6155 case BOOLEAN_TYPE: 6156 case INTEGER_CST: 6157 case REAL_CST: 6158 case STRING_CST: 6159 return t; 6160 6161 case INTEGER_TYPE: 6162 if (t == integer_type_node) 6163 return t; 6164 6165 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST 6166 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST) 6167 return t; 6168 6169 { 6170 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0); 6171 6172 max = tsubst_expr (omax, args, complain, in_decl); 6173 if (max == error_mark_node) 6174 return error_mark_node; 6175 6176 /* See if we can reduce this expression to something simpler. */ 6177 max = maybe_fold_nontype_arg (max); 6178 if (!processing_template_decl && TREE_READONLY_DECL_P (max)) 6179 max = decl_constant_value (max); 6180 6181 if (processing_template_decl 6182 /* When providing explicit arguments to a template 6183 function, but leaving some arguments for subsequent 6184 deduction, MAX may be template-dependent even if we're 6185 not PROCESSING_TEMPLATE_DECL. */ 6186 || TREE_CODE (max) != INTEGER_CST) 6187 { 6188 tree itype = make_node (INTEGER_TYPE); 6189 TYPE_MIN_VALUE (itype) = size_zero_node; 6190 TYPE_MAX_VALUE (itype) = build_min (MINUS_EXPR, sizetype, max, 6191 integer_one_node); 6192 return itype; 6193 } 6194 6195 if (integer_zerop (omax)) 6196 { 6197 /* Still allow an explicit array of size zero. */ 6198 if (pedantic) 6199 pedwarn ("creating array with size zero"); 6200 } 6201 // [zooey]: added this for BeOS-R5 compatibility: 6202 // <beos-patch> 6203 else if (integer_zerop (max)) 6204 if (pedantic) 6205 pedwarn ("creating array with size zero"); 6206 // </beos-patch> 6207 else if (INT_CST_LT (max, integer_zero_node)) 6208 { 6209 /* [temp.deduct] 6210 6211 Type deduction may fail for any of the following 6212 reasons: 6213 6214 Attempting to create an array with a size that is negative. */ 6215 if (complain) 6216 cp_error ("creating array with size `%E'", max); 6217 6218 return error_mark_node; 6219 } 6220 6221 max = fold (build_binary_op (MINUS_EXPR, max, integer_one_node)); 6222 if (!TREE_PERMANENT (max) && !allocation_temporary_p ()) 6223 max = copy_to_permanent (max); 6224 return build_index_type (max); 6225 } 6226 6227 case TEMPLATE_TYPE_PARM: 6228 case TEMPLATE_TEMPLATE_PARM: 6229 case TEMPLATE_PARM_INDEX: 6230 { 6231 int idx; 6232 int level; 6233 int levels; 6234 6235 r = NULL_TREE; 6236 6237 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM 6238 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM) 6239 { 6240 idx = TEMPLATE_TYPE_IDX (t); 6241 level = TEMPLATE_TYPE_LEVEL (t); 6242 } 6243 else 6244 { 6245 idx = TEMPLATE_PARM_IDX (t); 6246 level = TEMPLATE_PARM_LEVEL (t); 6247 } 6248 6249 if (TREE_VEC_LENGTH (args) > 0) 6250 { 6251 tree arg = NULL_TREE; 6252 6253 levels = TMPL_ARGS_DEPTH (args); 6254 if (level <= levels) 6255 arg = TMPL_ARG (args, level, idx); 6256 6257 if (arg == error_mark_node) 6258 return error_mark_node; 6259 else if (arg != NULL_TREE) 6260 { 6261 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM) 6262 { 6263 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg)) 6264 == 't', 0); 6265 return cp_build_qualified_type 6266 (arg, CP_TYPE_QUALS (arg) | CP_TYPE_QUALS (t)); 6267 } 6268 else if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM) 6269 { 6270 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t)) 6271 { 6272 /* We are processing a type constructed from 6273 a template template parameter */ 6274 tree argvec = tsubst (TYPE_TI_ARGS (t), 6275 args, complain, in_decl); 6276 if (argvec == error_mark_node) 6277 return error_mark_node; 6278 6279 /* We can get a TEMPLATE_TEMPLATE_PARM here when 6280 we are resolving nested-types in the signature of 6281 a member function templates. 6282 Otherwise ARG is a TEMPLATE_DECL and is the real 6283 template to be instantiated. */ 6284 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) 6285 arg = TYPE_NAME (arg); 6286 6287 r = lookup_template_class (DECL_NAME (arg), 6288 argvec, in_decl, 6289 DECL_CONTEXT (arg), 6290 /*entering_scope=*/0); 6291 return cp_build_qualified_type (r, TYPE_QUALS (t)); 6292 } 6293 else 6294 /* We are processing a template argument list. */ 6295 return arg; 6296 } 6297 else 6298 return arg; 6299 } 6300 } 6301 else 6302 my_friendly_abort (981018); 6303 6304 if (level == 1) 6305 /* This can happen during the attempted tsubst'ing in 6306 unify. This means that we don't yet have any information 6307 about the template parameter in question. */ 6308 return t; 6309 6310 /* If we get here, we must have been looking at a parm for a 6311 more deeply nested template. Make a new version of this 6312 template parameter, but with a lower level. */ 6313 switch (TREE_CODE (t)) 6314 { 6315 case TEMPLATE_TYPE_PARM: 6316 case TEMPLATE_TEMPLATE_PARM: 6317 r = copy_node (t); 6318 TEMPLATE_TYPE_PARM_INDEX (r) 6319 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t), 6320 r, levels); 6321 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r); 6322 TYPE_MAIN_VARIANT (r) = r; 6323 TYPE_POINTER_TO (r) = NULL_TREE; 6324 TYPE_REFERENCE_TO (r) = NULL_TREE; 6325 6326 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM 6327 && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t)) 6328 { 6329 tree argvec = tsubst (TYPE_TI_ARGS (t), args, 6330 complain, in_decl); 6331 if (argvec == error_mark_node) 6332 return error_mark_node; 6333 6334 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r) 6335 = perm_tree_cons (TYPE_NAME (t), argvec, NULL_TREE); 6336 } 6337 break; 6338 6339 case TEMPLATE_PARM_INDEX: 6340 r = reduce_template_parm_level (t, type, levels); 6341 break; 6342 6343 default: 6344 my_friendly_abort (0); 6345 } 6346 6347 return r; 6348 } 6349 6350 case TREE_LIST: 6351 { 6352 tree purpose, value, chain, result; 6353 6354 if (t == void_list_node) 6355 return t; 6356 6357 purpose = TREE_PURPOSE (t); 6358 if (purpose) 6359 { 6360 purpose = tsubst (purpose, args, complain, in_decl); 6361 if (purpose == error_mark_node) 6362 return error_mark_node; 6363 } 6364 value = TREE_VALUE (t); 6365 if (value) 6366 { 6367 value = tsubst (value, args, complain, in_decl); 6368 if (value == error_mark_node) 6369 return error_mark_node; 6370 } 6371 chain = TREE_CHAIN (t); 6372 if (chain && chain != void_type_node) 6373 { 6374 chain = tsubst (chain, args, complain, in_decl); 6375 if (chain == error_mark_node) 6376 return error_mark_node; 6377 } 6378 if (purpose == TREE_PURPOSE (t) 6379 && value == TREE_VALUE (t) 6380 && chain == TREE_CHAIN (t)) 6381 return t; 6382 result = hash_tree_cons (purpose, value, chain); 6383 TREE_PARMLIST (result) = TREE_PARMLIST (t); 6384 return result; 6385 } 6386 case TREE_VEC: 6387 if (type != NULL_TREE) 6388 { 6389 /* A binfo node. We always need to make a copy, of the node 6390 itself and of its BINFO_BASETYPES. */ 6391 6392 t = copy_node (t); 6393 6394 /* Make sure type isn't a typedef copy. */ 6395 type = BINFO_TYPE (TYPE_BINFO (type)); 6396 6397 TREE_TYPE (t) = complete_type (type); 6398 if (IS_AGGR_TYPE (type)) 6399 { 6400 BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type); 6401 BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type); 6402 if (TYPE_BINFO_BASETYPES (type) != NULL_TREE) 6403 BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type)); 6404 } 6405 return t; 6406 } 6407 6408 /* Otherwise, a vector of template arguments. */ 6409 return tsubst_template_arg_vector (t, args, complain); 6410 6411 case POINTER_TYPE: 6412 case REFERENCE_TYPE: 6413 { 6414 enum tree_code code; 6415 6416 if (type == TREE_TYPE (t)) 6417 return t; 6418 6419 code = TREE_CODE (t); 6420 6421 6422 /* [temp.deduct] 6423 6424 Type deduction may fail for any of the following 6425 reasons: 6426 6427 -- Attempting to create a pointer to reference type. 6428 -- Attempting to create a reference to a reference type or 6429 a reference to void. */ 6430 if (TREE_CODE (type) == REFERENCE_TYPE 6431 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE)) 6432 { 6433 static int last_line = 0; 6434 static char* last_file = 0; 6435 6436 /* We keep track of the last time we issued this error 6437 message to avoid spewing a ton of messages during a 6438 single bad template instantiation. */ 6439 if (complain && (last_line != lineno || 6440 last_file != input_filename)) 6441 { 6442 if (TREE_CODE (type) == VOID_TYPE) 6443 cp_error ("forming reference to void"); 6444 else 6445 cp_error ("forming %s to reference type `%T'", 6446 (code == POINTER_TYPE) ? "pointer" : "reference", 6447 type); 6448 last_line = lineno; 6449 last_file = input_filename; 6450 } 6451 6452 return error_mark_node; 6453 } 6454 else if (code == POINTER_TYPE) 6455 r = build_pointer_type (type); 6456 else 6457 r = build_reference_type (type); 6458 r = cp_build_qualified_type (r, TYPE_QUALS (t)); 6459 6460 /* Will this ever be needed for TYPE_..._TO values? */ 6461 layout_type (r); 6462 return r; 6463 } 6464 case OFFSET_TYPE: 6465 { 6466 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl); 6467 if (r == error_mark_node || !IS_AGGR_TYPE (r)) 6468 { 6469 /* [temp.deduct] 6470 6471 Type deduction may fail for any of the following 6472 reasons: 6473 6474 -- Attempting to create "pointer to member of T" when T 6475 is not a class type. */ 6476 if (complain) 6477 cp_error ("creating pointer to member of non-class type `%T'", 6478 r); 6479 return error_mark_node; 6480 } 6481 return build_offset_type (r, type); 6482 } 6483 case FUNCTION_TYPE: 6484 case METHOD_TYPE: 6485 { 6486 tree fntype; 6487 tree raises; 6488 6489 fntype = tsubst_function_type (t, args, complain, in_decl); 6490 if (fntype == error_mark_node) 6491 return error_mark_node; 6492 6493 /* Substitue the exception specification. */ 6494 raises = TYPE_RAISES_EXCEPTIONS (t); 6495 if (raises) 6496 { 6497 raises = tsubst (raises, args, complain, in_decl); 6498 if (raises == error_mark_node) 6499 return raises; 6500 fntype = build_exception_variant (fntype, raises); 6501 } 6502 return fntype; 6503 } 6504 case ARRAY_TYPE: 6505 { 6506 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl); 6507 if (domain == error_mark_node) 6508 return error_mark_node; 6509 6510 /* As an optimization, we avoid regenerating the array type if 6511 it will obviously be the same as T. */ 6512 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t)) 6513 return t; 6514 6515 /* These checks should match the ones in grokdeclarator. 6516 6517 [temp.deduct] 6518 6519 The deduction may fail for any of the following reasons: 6520 6521 -- Attempting to create an array with an element type that 6522 is void, a function type, or a reference type. */ 6523 if (TREE_CODE (type) == VOID_TYPE 6524 || TREE_CODE (type) == FUNCTION_TYPE 6525 || TREE_CODE (type) == REFERENCE_TYPE) 6526 { 6527 if (complain) 6528 cp_error ("creating array of `%T'", type); 6529 return error_mark_node; 6530 } 6531 6532 r = build_cplus_array_type (type, domain); 6533 return r; 6534 } 6535 6536 case PLUS_EXPR: 6537 case MINUS_EXPR: 6538 { 6539 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, 6540 in_decl); 6541 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, 6542 in_decl); 6543 6544 if (e1 == error_mark_node || e2 == error_mark_node) 6545 return error_mark_node; 6546 6547 return fold (build (TREE_CODE (t), TREE_TYPE (t), e1, e2)); 6548 } 6549 6550 case NEGATE_EXPR: 6551 case NOP_EXPR: 6552 { 6553 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, 6554 in_decl); 6555 if (e == error_mark_node) 6556 return error_mark_node; 6557 6558 return fold (build (TREE_CODE (t), TREE_TYPE (t), e)); 6559 } 6560 6561 case TYPENAME_TYPE: 6562 { 6563 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain, 6564 in_decl, /*entering_scope=*/1); 6565 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args, 6566 complain, in_decl); 6567 6568 if (ctx == error_mark_node || f == error_mark_node) 6569 return error_mark_node; 6570 6571 if (!IS_AGGR_TYPE (ctx)) 6572 { 6573 if (complain) 6574 cp_error ("`%T' is not a class, struct, or union type", 6575 ctx); 6576 return error_mark_node; 6577 } 6578 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx)) 6579 { 6580 /* Normally, make_typename_type does not require that the CTX 6581 have complete type in order to allow things like: 6582 6583 template <class T> struct S { typename S<T>::X Y; }; 6584 6585 But, such constructs have already been resolved by this 6586 point, so here CTX really should have complete type, unless 6587 it's a partial instantiation. */ 6588 ctx = complete_type (ctx); 6589 if (!TYPE_SIZE (ctx)) 6590 { 6591 if (complain) 6592 incomplete_type_error (NULL_TREE, ctx); 6593 return error_mark_node; 6594 } 6595 } 6596 6597 f = make_typename_type (ctx, f); 6598 if (f == error_mark_node) 6599 return f; 6600 return cp_build_qualified_type (f, 6601 CP_TYPE_QUALS (f) 6602 | CP_TYPE_QUALS (t)); 6603 } 6604 6605 case INDIRECT_REF: 6606 { 6607 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, 6608 in_decl); 6609 if (e == error_mark_node) 6610 return error_mark_node; 6611 return make_pointer_declarator (type, e); 6612 } 6613 6614 case ADDR_EXPR: 6615 { 6616 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, 6617 in_decl); 6618 if (e == error_mark_node) 6619 return error_mark_node; 6620 return make_reference_declarator (type, e); 6621 } 6622 6623 case ARRAY_REF: 6624 { 6625 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, 6626 in_decl); 6627 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, 6628 in_decl); 6629 if (e1 == error_mark_node || e2 == error_mark_node) 6630 return error_mark_node; 6631 6632 return build_parse_node (ARRAY_REF, e1, e2, tsubst_expr); 6633 } 6634 6635 case CALL_EXPR: 6636 { 6637 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, 6638 in_decl); 6639 tree e2 = tsubst_call_declarator_parms (TREE_OPERAND (t, 1), args, 6640 complain, in_decl); 6641 tree e3 = tsubst (TREE_TYPE (t), args, complain, in_decl); 6642 6643 if (e1 == error_mark_node || e2 == error_mark_node 6644 || e3 == error_mark_node) 6645 return error_mark_node; 6646 6647 return make_call_declarator (e1, e2, TREE_OPERAND (t, 2), e3); 6648 } 6649 6650 case SCOPE_REF: 6651 { 6652 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, 6653 in_decl); 6654 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl); 6655 if (e1 == error_mark_node || e2 == error_mark_node) 6656 return error_mark_node; 6657 6658 return build_parse_node (TREE_CODE (t), e1, e2); 6659 } 6660 6661 case TYPEOF_TYPE: 6662 { 6663 tree e1 = tsubst_expr (TYPE_FIELDS (t), args, complain, 6664 in_decl); 6665 if (e1 == error_mark_node) 6666 return error_mark_node; 6667 6668 return TREE_TYPE (e1); 6669 } 6670 6671 default: 6672 sorry ("use of `%s' in template", 6673 tree_code_name [(int) TREE_CODE (t)]); 6674 return error_mark_node; 6675 } 6676} 6677 6678void 6679do_pushlevel () 6680{ 6681 emit_line_note (input_filename, lineno); 6682 pushlevel (0); 6683 clear_last_expr (); 6684 push_momentary (); 6685 expand_start_bindings (0); 6686} 6687 6688tree 6689do_poplevel () 6690{ 6691 tree t; 6692 int saved_warn_unused = 0; 6693 6694 if (processing_template_decl) 6695 { 6696 saved_warn_unused = warn_unused; 6697 warn_unused = 0; 6698 } 6699 expand_end_bindings (getdecls (), kept_level_p (), 0); 6700 if (processing_template_decl) 6701 warn_unused = saved_warn_unused; 6702 t = poplevel (kept_level_p (), 1, 0); 6703 pop_momentary (); 6704 return t; 6705} 6706 6707/* Like tsubst, but deals with expressions. This function just replaces 6708 template parms; to finish processing the resultant expression, use 6709 tsubst_expr. */ 6710 6711tree 6712tsubst_copy (t, args, complain, in_decl) 6713 tree t, args; 6714 int complain; 6715 tree in_decl; 6716{ 6717 enum tree_code code; 6718 tree r; 6719 6720 if (t == NULL_TREE || t == error_mark_node) 6721 return t; 6722 6723 code = TREE_CODE (t); 6724 6725 switch (code) 6726 { 6727 case PARM_DECL: 6728 return do_identifier (DECL_NAME (t), 0, NULL_TREE); 6729 6730 case CONST_DECL: 6731 { 6732 tree enum_type; 6733 tree v; 6734 6735 if (!DECL_CONTEXT (t)) 6736 /* This is a global enumeration constant. */ 6737 return t; 6738 6739 /* Unfortunately, we cannot just call lookup_name here. 6740 Consider: 6741 6742 template <int I> int f() { 6743 enum E { a = I }; 6744 struct S { void g() { E e = a; } }; 6745 }; 6746 6747 When we instantiate f<7>::S::g(), say, lookup_name is not 6748 clever enough to find f<7>::a. */ 6749 enum_type 6750 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl, 6751 /*entering_scope=*/0); 6752 6753 for (v = TYPE_VALUES (enum_type); 6754 v != NULL_TREE; 6755 v = TREE_CHAIN (v)) 6756 if (TREE_PURPOSE (v) == DECL_NAME (t)) 6757 return TREE_VALUE (v); 6758 6759 /* We didn't find the name. That should never happen; if 6760 name-lookup found it during preliminary parsing, we 6761 should find it again here during instantiation. */ 6762 my_friendly_abort (0); 6763 } 6764 return t; 6765 6766 case FIELD_DECL: 6767 if (DECL_CONTEXT (t)) 6768 { 6769 tree ctx; 6770 6771 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl, 6772 /*entering_scope=*/1); 6773 if (ctx != DECL_CONTEXT (t)) 6774 return lookup_field (ctx, DECL_NAME (t), 0, 0); 6775 } 6776 return t; 6777 6778 case VAR_DECL: 6779 case FUNCTION_DECL: 6780 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)) 6781 t = tsubst (t, args, complain, in_decl); 6782 mark_used (t); 6783 return t; 6784 6785 case TEMPLATE_DECL: 6786 if (is_member_template (t)) 6787 return tsubst (t, args, complain, in_decl); 6788 else 6789 return t; 6790 6791 case LOOKUP_EXPR: 6792 { 6793 /* We must tsbust into a LOOKUP_EXPR in case the names to 6794 which it refers is a conversion operator; in that case the 6795 name will change. We avoid making unnecessary copies, 6796 however. */ 6797 6798 tree id = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl); 6799 6800 if (id != TREE_OPERAND (t, 0)) 6801 { 6802 r = build_nt (LOOKUP_EXPR, id); 6803 LOOKUP_EXPR_GLOBAL (r) = LOOKUP_EXPR_GLOBAL (t); 6804 t = r; 6805 } 6806 6807 return t; 6808 } 6809 6810 case CAST_EXPR: 6811 case REINTERPRET_CAST_EXPR: 6812 case CONST_CAST_EXPR: 6813 case STATIC_CAST_EXPR: 6814 case DYNAMIC_CAST_EXPR: 6815 case NOP_EXPR: 6816 return build1 6817 (code, tsubst (TREE_TYPE (t), args, complain, in_decl), 6818 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); 6819 6820 case INDIRECT_REF: 6821 case PREDECREMENT_EXPR: 6822 case PREINCREMENT_EXPR: 6823 case POSTDECREMENT_EXPR: 6824 case POSTINCREMENT_EXPR: 6825 case NEGATE_EXPR: 6826 case TRUTH_NOT_EXPR: 6827 case BIT_NOT_EXPR: 6828 case ADDR_EXPR: 6829 case CONVERT_EXPR: /* Unary + */ 6830 case SIZEOF_EXPR: 6831 case ALIGNOF_EXPR: 6832 case ARROW_EXPR: 6833 case THROW_EXPR: 6834 case TYPEID_EXPR: 6835 return build1 6836 (code, tsubst (TREE_TYPE (t), args, complain, in_decl), 6837 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)); 6838 6839 case PLUS_EXPR: 6840 case MINUS_EXPR: 6841 case MULT_EXPR: 6842 case TRUNC_DIV_EXPR: 6843 case CEIL_DIV_EXPR: 6844 case FLOOR_DIV_EXPR: 6845 case ROUND_DIV_EXPR: 6846 case EXACT_DIV_EXPR: 6847 case BIT_AND_EXPR: 6848 case BIT_ANDTC_EXPR: 6849 case BIT_IOR_EXPR: 6850 case BIT_XOR_EXPR: 6851 case TRUNC_MOD_EXPR: 6852 case FLOOR_MOD_EXPR: 6853 case TRUTH_ANDIF_EXPR: 6854 case TRUTH_ORIF_EXPR: 6855 case TRUTH_AND_EXPR: 6856 case TRUTH_OR_EXPR: 6857 case RSHIFT_EXPR: 6858 case LSHIFT_EXPR: 6859 case RROTATE_EXPR: 6860 case LROTATE_EXPR: 6861 case EQ_EXPR: 6862 case NE_EXPR: 6863 case MAX_EXPR: 6864 case MIN_EXPR: 6865 case LE_EXPR: 6866 case GE_EXPR: 6867 case LT_EXPR: 6868 case GT_EXPR: 6869 case COMPONENT_REF: 6870 case ARRAY_REF: 6871 case COMPOUND_EXPR: 6872 case SCOPE_REF: 6873 case DOTSTAR_EXPR: 6874 case MEMBER_REF: 6875 return build_nt 6876 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 6877 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); 6878 6879 case CALL_EXPR: 6880 { 6881 tree fn = TREE_OPERAND (t, 0); 6882 if (is_overloaded_fn (fn)) 6883 fn = tsubst_copy (get_first_fn (fn), args, complain, in_decl); 6884 else 6885 /* Sometimes FN is a LOOKUP_EXPR. */ 6886 fn = tsubst_copy (fn, args, complain, in_decl); 6887 return build_nt 6888 (code, fn, tsubst_copy (TREE_OPERAND (t, 1), args, complain, 6889 in_decl), 6890 NULL_TREE); 6891 } 6892 6893 case METHOD_CALL_EXPR: 6894 { 6895 tree name = TREE_OPERAND (t, 0); 6896 if (TREE_CODE (name) == BIT_NOT_EXPR) 6897 { 6898 name = tsubst_copy (TREE_OPERAND (name, 0), args, 6899 complain, in_decl); 6900 name = build1 (BIT_NOT_EXPR, NULL_TREE, name); 6901 } 6902 else if (TREE_CODE (name) == SCOPE_REF 6903 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR) 6904 { 6905 tree base = tsubst_copy (TREE_OPERAND (name, 0), args, 6906 complain, in_decl); 6907 name = TREE_OPERAND (name, 1); 6908 name = tsubst_copy (TREE_OPERAND (name, 0), args, 6909 complain, in_decl); 6910 name = build1 (BIT_NOT_EXPR, NULL_TREE, name); 6911 name = build_nt (SCOPE_REF, base, name); 6912 } 6913 else 6914 name = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl); 6915 return build_nt 6916 (code, name, tsubst_copy (TREE_OPERAND (t, 1), args, 6917 complain, in_decl), 6918 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl), 6919 NULL_TREE); 6920 } 6921 6922 case BIND_EXPR: 6923 case COND_EXPR: 6924 case MODOP_EXPR: 6925 { 6926 r = build_nt 6927 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 6928 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), 6929 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); 6930 6931 if (code == BIND_EXPR && !processing_template_decl) 6932 { 6933 /* This processing should really occur in tsubst_expr, 6934 However, tsubst_expr does not recurse into expressions, 6935 since it assumes that there aren't any statements 6936 inside them. Instead, it simply calls 6937 build_expr_from_tree. So, we need to expand the 6938 BIND_EXPR here. */ 6939 tree rtl_expr = begin_stmt_expr (); 6940 tree block = tsubst_expr (TREE_OPERAND (r, 1), args, 6941 complain, in_decl); 6942 r = finish_stmt_expr (rtl_expr, block); 6943 } 6944 6945 return r; 6946 } 6947 6948 case NEW_EXPR: 6949 { 6950 r = build_nt 6951 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 6952 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl), 6953 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl)); 6954 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t); 6955 return r; 6956 } 6957 6958 case DELETE_EXPR: 6959 { 6960 r = build_nt 6961 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), 6962 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl)); 6963 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t); 6964 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t); 6965 return r; 6966 } 6967 6968 case TEMPLATE_ID_EXPR: 6969 { 6970 /* Substituted template arguments */ 6971 tree targs = tsubst_copy (TREE_OPERAND (t, 1), args, complain, 6972 in_decl); 6973 6974 if (targs && TREE_CODE (targs) == TREE_LIST) 6975 { 6976 tree chain; 6977 for (chain = targs; chain; chain = TREE_CHAIN (chain)) 6978 TREE_VALUE (chain) = maybe_fold_nontype_arg (TREE_VALUE (chain)); 6979 } 6980 else if (targs) 6981 { 6982 int i; 6983 for (i = 0; i < TREE_VEC_LENGTH (targs); ++i) 6984 TREE_VEC_ELT (targs, i) 6985 = maybe_fold_nontype_arg (TREE_VEC_ELT (targs, i)); 6986 } 6987 6988 return lookup_template_function 6989 (tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), targs); 6990 } 6991 6992 case TREE_LIST: 6993 { 6994 tree purpose, value, chain; 6995 6996 if (t == void_list_node) 6997 return t; 6998 6999 purpose = TREE_PURPOSE (t); 7000 if (purpose) 7001 purpose = tsubst_copy (purpose, args, complain, in_decl); 7002 value = TREE_VALUE (t); 7003 if (value) 7004 value = tsubst_copy (value, args, complain, in_decl); 7005 chain = TREE_CHAIN (t); 7006 if (chain && chain != void_type_node) 7007 chain = tsubst_copy (chain, args, complain, in_decl); 7008 if (purpose == TREE_PURPOSE (t) 7009 && value == TREE_VALUE (t) 7010 && chain == TREE_CHAIN (t)) 7011 return t; 7012 return tree_cons (purpose, value, chain); 7013 } 7014 7015 case RECORD_TYPE: 7016 case UNION_TYPE: 7017 case ENUMERAL_TYPE: 7018 case INTEGER_TYPE: 7019 case TEMPLATE_TYPE_PARM: 7020 case TEMPLATE_TEMPLATE_PARM: 7021 case TEMPLATE_PARM_INDEX: 7022 case POINTER_TYPE: 7023 case REFERENCE_TYPE: 7024 case OFFSET_TYPE: 7025 case FUNCTION_TYPE: 7026 case METHOD_TYPE: 7027 case ARRAY_TYPE: 7028 case TYPENAME_TYPE: 7029 case TYPE_DECL: 7030 return tsubst (t, args, complain, in_decl); 7031 7032 case IDENTIFIER_NODE: 7033 if (IDENTIFIER_TYPENAME_P (t) 7034 /* Make sure it's not just a variable named `__opr', for instance, 7035 which can occur in some existing code. */ 7036 && TREE_TYPE (t)) 7037 return build_typename_overload 7038 (tsubst (TREE_TYPE (t), args, complain, in_decl)); 7039 else 7040 return t; 7041 7042 case CONSTRUCTOR: 7043 { 7044 r = build 7045 (CONSTRUCTOR, tsubst (TREE_TYPE (t), args, complain, in_decl), 7046 NULL_TREE, tsubst_copy (CONSTRUCTOR_ELTS (t), args, 7047 complain, in_decl)); 7048 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t); 7049 return r; 7050 } 7051 7052 default: 7053 return t; 7054 } 7055} 7056 7057/* Like tsubst_copy, but also does semantic processing and RTL expansion. */ 7058 7059tree 7060tsubst_expr (t, args, complain, in_decl) 7061 tree t, args; 7062 int complain; 7063 tree in_decl; 7064{ 7065 if (t == NULL_TREE || t == error_mark_node) 7066 return t; 7067 7068 if (processing_template_decl) 7069 return tsubst_copy (t, args, complain, in_decl); 7070 7071 switch (TREE_CODE (t)) 7072 { 7073 case RETURN_STMT: 7074 lineno = TREE_COMPLEXITY (t); 7075 finish_return_stmt (tsubst_expr (RETURN_EXPR (t), 7076 args, complain, in_decl)); 7077 break; 7078 7079 case EXPR_STMT: 7080 lineno = TREE_COMPLEXITY (t); 7081 finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t), 7082 args, complain, in_decl)); 7083 break; 7084 7085 case DECL_STMT: 7086 { 7087 int i = suspend_momentary (); 7088 tree dcl, init; 7089 7090 lineno = TREE_COMPLEXITY (t); 7091 emit_line_note (input_filename, lineno); 7092 dcl = start_decl 7093 (tsubst (TREE_OPERAND (t, 0), args, complain, in_decl), 7094 tsubst (TREE_OPERAND (t, 1), args, complain, in_decl), 7095 TREE_OPERAND (t, 2) != 0, NULL_TREE, NULL_TREE); 7096 init = tsubst_expr (TREE_OPERAND (t, 2), args, complain, in_decl); 7097 cp_finish_decl 7098 (dcl, init, NULL_TREE, 1, /*init ? LOOKUP_ONLYCONVERTING :*/ 0); 7099 resume_momentary (i); 7100 return dcl; 7101 } 7102 7103 case FOR_STMT: 7104 { 7105 tree tmp; 7106 lineno = TREE_COMPLEXITY (t); 7107 7108 begin_for_stmt (); 7109 for (tmp = FOR_INIT_STMT (t); tmp; tmp = TREE_CHAIN (tmp)) 7110 tsubst_expr (tmp, args, complain, in_decl); 7111 finish_for_init_stmt (NULL_TREE); 7112 finish_for_cond (tsubst_expr (FOR_COND (t), args, 7113 complain, in_decl), 7114 NULL_TREE); 7115 tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl); 7116 finish_for_expr (tmp, NULL_TREE); 7117 tsubst_expr (FOR_BODY (t), args, complain, in_decl); 7118 finish_for_stmt (tmp, NULL_TREE); 7119 } 7120 break; 7121 7122 case WHILE_STMT: 7123 { 7124 lineno = TREE_COMPLEXITY (t); 7125 begin_while_stmt (); 7126 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t), 7127 args, complain, in_decl), 7128 NULL_TREE); 7129 tsubst_expr (WHILE_BODY (t), args, complain, in_decl); 7130 finish_while_stmt (NULL_TREE); 7131 } 7132 break; 7133 7134 case DO_STMT: 7135 { 7136 lineno = TREE_COMPLEXITY (t); 7137 begin_do_stmt (); 7138 tsubst_expr (DO_BODY (t), args, complain, in_decl); 7139 finish_do_body (NULL_TREE); 7140 finish_do_stmt (tsubst_expr (DO_COND (t), args, 7141 complain, in_decl), 7142 NULL_TREE); 7143 } 7144 break; 7145 7146 case IF_STMT: 7147 { 7148 tree tmp; 7149 7150 lineno = TREE_COMPLEXITY (t); 7151 begin_if_stmt (); 7152 finish_if_stmt_cond (tsubst_expr (IF_COND (t), 7153 args, complain, in_decl), 7154 NULL_TREE); 7155 7156 if (tmp = THEN_CLAUSE (t), tmp) 7157 { 7158 tsubst_expr (tmp, args, complain, in_decl); 7159 finish_then_clause (NULL_TREE); 7160 } 7161 7162 if (tmp = ELSE_CLAUSE (t), tmp) 7163 { 7164 begin_else_clause (); 7165 tsubst_expr (tmp, args, complain, in_decl); 7166 finish_else_clause (NULL_TREE); 7167 } 7168 7169 finish_if_stmt (); 7170 } 7171 break; 7172 7173 case COMPOUND_STMT: 7174 { 7175 tree substmt; 7176 7177 lineno = TREE_COMPLEXITY (t); 7178 begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t)); 7179 for (substmt = COMPOUND_BODY (t); 7180 substmt != NULL_TREE; 7181 substmt = TREE_CHAIN (substmt)) 7182 tsubst_expr (substmt, args, complain, in_decl); 7183 return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t), 7184 NULL_TREE); 7185 } 7186 break; 7187 7188 case BREAK_STMT: 7189 lineno = TREE_COMPLEXITY (t); 7190 finish_break_stmt (); 7191 break; 7192 7193 case CONTINUE_STMT: 7194 lineno = TREE_COMPLEXITY (t); 7195 finish_continue_stmt (); 7196 break; 7197 7198 case SWITCH_STMT: 7199 { 7200 tree val, tmp; 7201 7202 lineno = TREE_COMPLEXITY (t); 7203 begin_switch_stmt (); 7204 val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl); 7205 finish_switch_cond (val); 7206 7207 if (tmp = TREE_OPERAND (t, 1), tmp) 7208 tsubst_expr (tmp, args, complain, in_decl); 7209 7210 finish_switch_stmt (val, NULL_TREE); 7211 } 7212 break; 7213 7214 case CASE_LABEL: 7215 finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl), 7216 tsubst_expr (CASE_HIGH (t), args, complain, in_decl)); 7217 break; 7218 7219 case LABEL_DECL: 7220 t = define_label (DECL_SOURCE_FILE (t), DECL_SOURCE_LINE (t), 7221 DECL_NAME (t)); 7222 if (t) 7223 expand_label (t); 7224 break; 7225 7226 case GOTO_STMT: 7227 lineno = TREE_COMPLEXITY (t); 7228 t = GOTO_DESTINATION (t); 7229 if (TREE_CODE (t) != IDENTIFIER_NODE) 7230 /* Computed goto's must be tsubst'd into. On the other hand, 7231 non-computed gotos must not be; the identifier in question 7232 will have no binding. */ 7233 t = tsubst_expr (t, args, complain, in_decl); 7234 finish_goto_stmt (t); 7235 break; 7236 7237 case ASM_STMT: 7238 lineno = TREE_COMPLEXITY (t); 7239 finish_asm_stmt (tsubst_expr (ASM_CV_QUAL (t), args, complain, in_decl), 7240 tsubst_expr (ASM_STRING (t), args, complain, in_decl), 7241 tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl), 7242 tsubst_expr (ASM_INPUTS (t), args, complain, in_decl), 7243 tsubst_expr (ASM_CLOBBERS (t), args, complain, 7244 in_decl)); 7245 break; 7246 7247 case TRY_BLOCK: 7248 lineno = TREE_COMPLEXITY (t); 7249 begin_try_block (); 7250 tsubst_expr (TRY_STMTS (t), args, complain, in_decl); 7251 finish_try_block (NULL_TREE); 7252 { 7253 tree handler = TRY_HANDLERS (t); 7254 for (; handler; handler = TREE_CHAIN (handler)) 7255 tsubst_expr (handler, args, complain, in_decl); 7256 } 7257 finish_handler_sequence (NULL_TREE); 7258 break; 7259 7260 case HANDLER: 7261 lineno = TREE_COMPLEXITY (t); 7262 begin_handler (); 7263 if (HANDLER_PARMS (t)) 7264 { 7265 tree d = HANDLER_PARMS (t); 7266 expand_start_catch_block 7267 (tsubst (TREE_OPERAND (d, 1), args, complain, in_decl), 7268 tsubst (TREE_OPERAND (d, 0), args, complain, in_decl)); 7269 } 7270 else 7271 expand_start_catch_block (NULL_TREE, NULL_TREE); 7272 finish_handler_parms (NULL_TREE); 7273 tsubst_expr (HANDLER_BODY (t), args, complain, in_decl); 7274 finish_handler (NULL_TREE); 7275 break; 7276 7277 case TAG_DEFN: 7278 lineno = TREE_COMPLEXITY (t); 7279 t = TREE_TYPE (t); 7280 if (TREE_CODE (t) == ENUMERAL_TYPE) 7281 tsubst (t, args, complain, NULL_TREE); 7282 break; 7283 7284 default: 7285 return build_expr_from_tree (tsubst_copy (t, args, complain, in_decl)); 7286 } 7287 return NULL_TREE; 7288} 7289 7290/* Instantiate the indicated variable or function template TMPL with 7291 the template arguments in TARG_PTR. */ 7292 7293tree 7294instantiate_template (tmpl, targ_ptr) 7295 tree tmpl, targ_ptr; 7296{ 7297 tree fndecl; 7298 tree gen_tmpl; 7299 tree spec; 7300 int i, len; 7301 struct obstack *old_fmp_obstack; 7302 extern struct obstack *function_maybepermanent_obstack; 7303 tree inner_args; 7304 7305 if (tmpl == error_mark_node) 7306 return error_mark_node; 7307 7308 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283); 7309 7310 /* Check to see if we already have this specialization. */ 7311 spec = retrieve_specialization (tmpl, targ_ptr); 7312 if (spec != NULL_TREE) 7313 return spec; 7314 7315 if (DECL_TEMPLATE_INFO (tmpl)) 7316 { 7317 /* The TMPL is a partial instantiation. To get a full set of 7318 arguments we must add the arguments used to perform the 7319 partial instantiation. */ 7320 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl), 7321 targ_ptr); 7322 gen_tmpl = most_general_template (tmpl); 7323 7324 /* Check to see if we already have this specialization. */ 7325 spec = retrieve_specialization (gen_tmpl, targ_ptr); 7326 if (spec != NULL_TREE) 7327 return spec; 7328 } 7329 else 7330 gen_tmpl = tmpl; 7331 7332 push_obstacks (&permanent_obstack, &permanent_obstack); 7333 old_fmp_obstack = function_maybepermanent_obstack; 7334 function_maybepermanent_obstack = &permanent_obstack; 7335 7336 len = DECL_NTPARMS (gen_tmpl); 7337 inner_args = innermost_args (targ_ptr); 7338 i = len; 7339 while (i--) 7340 { 7341 tree t = TREE_VEC_ELT (inner_args, i); 7342 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') 7343 { 7344 tree nt = target_type (t); 7345 if (IS_AGGR_TYPE (nt) && decl_function_context (TYPE_MAIN_DECL (nt))) 7346 { 7347 cp_error ("type `%T' composed from a local class is not a valid template-argument", t); 7348 cp_error (" trying to instantiate `%D'", gen_tmpl); 7349 fndecl = error_mark_node; 7350 goto out; 7351 } 7352 } 7353 } 7354 targ_ptr = copy_to_permanent (targ_ptr); 7355 7356 /* substitute template parameters */ 7357 fndecl = tsubst (DECL_RESULT (gen_tmpl), targ_ptr, /*complain=*/1, gen_tmpl); 7358 /* The DECL_TI_TEMPLATE should always be the immediate parent 7359 template, not the most general template. */ 7360 DECL_TI_TEMPLATE (fndecl) = tmpl; 7361 7362 if (flag_external_templates) 7363 add_pending_template (fndecl); 7364 7365 out: 7366 function_maybepermanent_obstack = old_fmp_obstack; 7367 pop_obstacks (); 7368 7369 return fndecl; 7370} 7371 7372/* Push the name of the class template into the scope of the instantiation. */ 7373 7374void 7375overload_template_name (type) 7376 tree type; 7377{ 7378 tree id = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)); 7379 tree decl; 7380 7381 if (IDENTIFIER_CLASS_VALUE (id) 7382 && TREE_TYPE (IDENTIFIER_CLASS_VALUE (id)) == type) 7383 return; 7384 7385 decl = build_decl (TYPE_DECL, id, type); 7386 SET_DECL_ARTIFICIAL (decl); 7387 pushdecl_class_level (decl); 7388} 7389 7390/* The FN is a TEMPLATE_DECL for a function. The ARGS are the 7391 arguments that are being used when calling it. TARGS is a vector 7392 into which the deduced template arguments are placed. 7393 7394 Return zero for success, 2 for an incomplete match that doesn't resolve 7395 all the types, and 1 for complete failure. An error message will be 7396 printed only for an incomplete match. 7397 7398 If FN is a conversion operator, RETURN_TYPE is the type desired as 7399 the result of the conversion operator. 7400 7401 TPARMS is a vector of template parameters. 7402 7403 The EXPLICIT_TARGS are explicit template arguments provided via a 7404 template-id. 7405 7406 The parameter STRICT is one of: 7407 7408 DEDUCE_CALL: 7409 We are deducing arguments for a function call, as in 7410 [temp.deduct.call]. 7411 7412 DEDUCE_CONV: 7413 We are deducing arguments for a conversion function, as in 7414 [temp.deduct.conv]. 7415 7416 DEDUCE_EXACT: 7417 We are deducing arguments when calculating the partial 7418 ordering between specializations of function or class 7419 templates, as in [temp.func.order] and [temp.class.order], 7420 when doing an explicit instantiation as in [temp.explicit], 7421 when determining an explicit specialization as in 7422 [temp.expl.spec], or when taking the address of a function 7423 template, as in [temp.deduct.funcaddr]. 7424 7425 The other arguments are as for type_unification. */ 7426 7427int 7428fn_type_unification (fn, explicit_targs, targs, args, return_type, 7429 strict) 7430 tree fn, explicit_targs, targs, args, return_type; 7431 unification_kind_t strict; 7432{ 7433 tree parms; 7434 tree fntype; 7435 7436 my_friendly_assert (TREE_CODE (fn) == TEMPLATE_DECL, 0); 7437 7438 fntype = TREE_TYPE (fn); 7439 if (explicit_targs) 7440 { 7441 /* [temp.deduct] 7442 7443 The specified template arguments must match the template 7444 parameters in kind (i.e., type, nontype, template), and there 7445 must not be more arguments than there are parameters; 7446 otherwise type deduction fails. 7447 7448 Nontype arguments must match the types of the corresponding 7449 nontype template parameters, or must be convertible to the 7450 types of the corresponding nontype parameters as specified in 7451 _temp.arg.nontype_, otherwise type deduction fails. 7452 7453 All references in the function type of the function template 7454 to the corresponding template parameters are replaced by the 7455 specified template argument values. If a substitution in a 7456 template parameter or in the function type of the function 7457 template results in an invalid type, type deduction fails. */ 7458 int i; 7459 tree converted_args; 7460 7461 converted_args 7462 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn), 7463 explicit_targs, NULL_TREE, /*complain=*/0, 7464 /*require_all_arguments=*/0)); 7465 if (converted_args == error_mark_node) 7466 return 1; 7467 7468 fntype = tsubst (fntype, converted_args, /*complain=*/0, NULL_TREE); 7469 if (fntype == error_mark_node) 7470 return 1; 7471 7472 /* Place the explicitly specified arguments in TARGS. */ 7473 for (i = 0; i < TREE_VEC_LENGTH (targs); i++) 7474 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i); 7475 } 7476 7477 parms = TYPE_ARG_TYPES (fntype); 7478 7479 if (DECL_CONV_FN_P (fn)) 7480 { 7481 /* This is a template conversion operator. Use the return types 7482 as well as the argument types. We use it instead of 'this', since 7483 we could be comparing conversions from different classes. */ 7484 parms = scratch_tree_cons (NULL_TREE, TREE_TYPE (fntype), 7485 TREE_CHAIN (parms)); 7486 args = scratch_tree_cons (NULL_TREE, return_type, TREE_CHAIN (args)); 7487 } 7488 7489 /* We allow incomplete unification without an error message here 7490 because the standard doesn't seem to explicitly prohibit it. Our 7491 callers must be ready to deal with unification failures in any 7492 event. */ 7493 return type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn), 7494 targs, parms, args, /*subr=*/0, 7495 strict, /*allow_incomplete*/1); 7496} 7497 7498/* Adjust types before performing type deduction, as described in 7499 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two 7500 sections are symmetric. PARM is the type of a function parameter 7501 or the return type of the conversion function. ARG is the type of 7502 the argument passed to the call, or the type of the value 7503 intialized with the result of the conversion function. */ 7504 7505static void 7506maybe_adjust_types_for_deduction (strict, parm, arg) 7507 unification_kind_t strict; 7508 tree* parm; 7509 tree* arg; 7510{ 7511 switch (strict) 7512 { 7513 case DEDUCE_CALL: 7514 break; 7515 7516 case DEDUCE_CONV: 7517 { 7518 /* Swap PARM and ARG throughout the remainder of this 7519 function; the handling is precisely symmetric since PARM 7520 will initialize ARG rather than vice versa. */ 7521 tree* temp = parm; 7522 parm = arg; 7523 arg = temp; 7524 break; 7525 } 7526 7527 case DEDUCE_EXACT: 7528 /* There is nothing to do in this case. */ 7529 return; 7530 7531 default: 7532 my_friendly_abort (0); 7533 } 7534 7535 if (TREE_CODE (*parm) != REFERENCE_TYPE) 7536 { 7537 /* [temp.deduct.call] 7538 7539 If P is not a reference type: 7540 7541 --If A is an array type, the pointer type produced by the 7542 array-to-pointer standard conversion (_conv.array_) is 7543 used in place of A for type deduction; otherwise, 7544 7545 --If A is a function type, the pointer type produced by 7546 the function-to-pointer standard conversion 7547 (_conv.func_) is used in place of A for type deduction; 7548 otherwise, 7549 7550 --If A is a cv-qualified type, the top level 7551 cv-qualifiers of A's type are ignored for type 7552 deduction. */ 7553 if (TREE_CODE (*arg) == ARRAY_TYPE) 7554 *arg = build_pointer_type (TREE_TYPE (*arg)); 7555 else if (TREE_CODE (*arg) == FUNCTION_TYPE) 7556 *arg = build_pointer_type (*arg); 7557 else 7558 *arg = TYPE_MAIN_VARIANT (*arg); 7559 } 7560 7561 /* [temp.deduct.call] 7562 7563 If P is a cv-qualified type, the top level cv-qualifiers 7564 of P's type are ignored for type deduction. If P is a 7565 reference type, the type referred to by P is used for 7566 type deduction. */ 7567 *parm = TYPE_MAIN_VARIANT (*parm); 7568 if (TREE_CODE (*parm) == REFERENCE_TYPE) 7569 *parm = TREE_TYPE (*parm); 7570} 7571 7572/* Like type_unfication. 7573 7574 If SUBR is 1, we're being called recursively (to unify the 7575 arguments of a function or method parameter of a function 7576 template). */ 7577 7578static int 7579type_unification_real (tparms, targs, parms, args, subr, 7580 strict, allow_incomplete) 7581 tree tparms, targs, parms, args; 7582 int subr; 7583 unification_kind_t strict; 7584 int allow_incomplete; 7585{ 7586 tree parm, arg; 7587 int i; 7588 int ntparms = TREE_VEC_LENGTH (tparms); 7589 int sub_strict; 7590 7591 my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289); 7592 my_friendly_assert (parms == NULL_TREE 7593 || TREE_CODE (parms) == TREE_LIST, 290); 7594 /* ARGS could be NULL (via a call from parse.y to 7595 build_x_function_call). */ 7596 if (args) 7597 my_friendly_assert (TREE_CODE (args) == TREE_LIST, 291); 7598 my_friendly_assert (ntparms > 0, 292); 7599 7600 switch (strict) 7601 { 7602 case DEDUCE_CALL: 7603 sub_strict = UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_DERIVED; 7604 break; 7605 7606 case DEDUCE_CONV: 7607 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL; 7608 break; 7609 7610 case DEDUCE_EXACT: 7611 sub_strict = UNIFY_ALLOW_NONE; 7612 break; 7613 7614 default: 7615 my_friendly_abort (0); 7616 } 7617 7618 while (parms 7619 && parms != void_list_node 7620 && args 7621 && args != void_list_node) 7622 { 7623 parm = TREE_VALUE (parms); 7624 parms = TREE_CHAIN (parms); 7625 arg = TREE_VALUE (args); 7626 args = TREE_CHAIN (args); 7627 7628 if (arg == error_mark_node) 7629 return 1; 7630 if (arg == unknown_type_node) 7631 /* We can't deduce anything from this, but we might get all the 7632 template args from other function args. */ 7633 continue; 7634 7635 /* Conversions will be performed on a function argument that 7636 corresponds with a function parameter that contains only 7637 non-deducible template parameters and explicitly specified 7638 template parameters. */ 7639 if (! uses_template_parms (parm)) 7640 { 7641 tree type; 7642 7643 if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't') 7644 type = TREE_TYPE (arg); 7645 else 7646 { 7647 type = arg; 7648 arg = NULL_TREE; 7649 } 7650 7651 if (strict == DEDUCE_EXACT) 7652 { 7653 if (same_type_p (parm, type)) 7654 continue; 7655 } 7656 else 7657 /* It might work; we shouldn't check now, because we might 7658 get into infinite recursion. Overload resolution will 7659 handle it. */ 7660 continue; 7661 7662 return 1; 7663 } 7664 7665 if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't') 7666 { 7667 my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293); 7668 if (type_unknown_p (arg)) 7669 { 7670 /* [temp.deduct.type] A template-argument can be deduced from 7671 a pointer to function or pointer to member function 7672 argument if the set of overloaded functions does not 7673 contain function templates and at most one of a set of 7674 overloaded functions provides a unique match. */ 7675 7676 if (resolve_overloaded_unification 7677 (tparms, targs, parm, arg, strict, sub_strict) 7678 != 0) 7679 return 1; 7680 continue; 7681 } 7682 arg = TREE_TYPE (arg); 7683 } 7684 7685 if (!subr) 7686 maybe_adjust_types_for_deduction (strict, &parm, &arg); 7687 7688 switch (unify (tparms, targs, parm, arg, sub_strict)) 7689 { 7690 case 0: 7691 break; 7692 case 1: 7693 return 1; 7694 } 7695 } 7696 /* Fail if we've reached the end of the parm list, and more args 7697 are present, and the parm list isn't variadic. */ 7698 if (args && args != void_list_node && parms == void_list_node) 7699 return 1; 7700 /* Fail if parms are left and they don't have default values. */ 7701 if (parms 7702 && parms != void_list_node 7703 && TREE_PURPOSE (parms) == NULL_TREE) 7704 return 1; 7705 if (!subr) 7706 for (i = 0; i < ntparms; i++) 7707 if (TREE_VEC_ELT (targs, i) == NULL_TREE) 7708 { 7709 if (!allow_incomplete) 7710 error ("incomplete type unification"); 7711 return 2; 7712 } 7713 return 0; 7714} 7715 7716/* Subroutine of type_unification_real. Args are like the variables at the 7717 call site. ARG is an overloaded function (or template-id); we try 7718 deducing template args from each of the overloads, and if only one 7719 succeeds, we go with that. Modifies TARGS and returns 0 on success. */ 7720 7721static int 7722resolve_overloaded_unification (tparms, targs, parm, arg, strict, 7723 sub_strict) 7724 tree tparms, targs, parm, arg; 7725 unification_kind_t strict; 7726 int sub_strict; 7727{ 7728 tree tempargs = copy_node (targs); 7729 int good = 0; 7730 7731 if (TREE_CODE (arg) == ADDR_EXPR) 7732 arg = TREE_OPERAND (arg, 0); 7733 7734 if (TREE_CODE (arg) == COMPONENT_REF) 7735 /* Handle `&x' where `x' is some static or non-static member 7736 function name. */ 7737 arg = TREE_OPERAND (arg, 1); 7738 7739 if (TREE_CODE (arg) == OFFSET_REF) 7740 arg = TREE_OPERAND (arg, 1); 7741 7742 /* Strip baselink information. */ 7743 while (TREE_CODE (arg) == TREE_LIST) 7744 arg = TREE_VALUE (arg); 7745 7746 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR) 7747 { 7748 /* If we got some explicit template args, we need to plug them into 7749 the affected templates before we try to unify, in case the 7750 explicit args will completely resolve the templates in question. */ 7751 7752 tree expl_subargs = TREE_OPERAND (arg, 1); 7753 arg = TREE_OPERAND (arg, 0); 7754 7755 for (; arg; arg = OVL_NEXT (arg)) 7756 { 7757 tree fn = OVL_CURRENT (arg); 7758 tree subargs, elem; 7759 7760 if (TREE_CODE (fn) != TEMPLATE_DECL) 7761 continue; 7762 7763 subargs = get_bindings_overload (fn, DECL_RESULT (fn), expl_subargs); 7764 if (subargs) 7765 { 7766 elem = tsubst (TREE_TYPE (fn), subargs, /*complain=*/0, 7767 NULL_TREE); 7768 if (TREE_CODE (elem) == METHOD_TYPE) 7769 elem = build_ptrmemfunc_type (build_pointer_type (elem)); 7770 good += try_one_overload (tparms, targs, tempargs, parm, elem, 7771 strict, sub_strict); 7772 } 7773 } 7774 } 7775 else if (TREE_CODE (arg) == OVERLOAD) 7776 { 7777 for (; arg; arg = OVL_NEXT (arg)) 7778 { 7779 tree type = TREE_TYPE (OVL_CURRENT (arg)); 7780 if (TREE_CODE (type) == METHOD_TYPE) 7781 type = build_ptrmemfunc_type (build_pointer_type (type)); 7782 good += try_one_overload (tparms, targs, tempargs, parm, 7783 type, 7784 strict, sub_strict); 7785 } 7786 } 7787 else 7788 my_friendly_abort (981006); 7789 7790 /* [temp.deduct.type] A template-argument can be deduced from a pointer 7791 to function or pointer to member function argument if the set of 7792 overloaded functions does not contain function templates and at most 7793 one of a set of overloaded functions provides a unique match. 7794 7795 So if we found multiple possibilities, we return success but don't 7796 deduce anything. */ 7797 7798 if (good == 1) 7799 { 7800 int i = TREE_VEC_LENGTH (targs); 7801 for (; i--; ) 7802 if (TREE_VEC_ELT (tempargs, i)) 7803 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i); 7804 } 7805 if (good) 7806 return 0; 7807 7808 return 1; 7809} 7810 7811/* Subroutine of resolve_overloaded_unification; does deduction for a single 7812 overload. Fills TARGS with any deduced arguments, or error_mark_node if 7813 different overloads deduce different arguments for a given parm. 7814 Returns 1 on success. */ 7815 7816static int 7817try_one_overload (tparms, orig_targs, targs, parm, arg, strict, 7818 sub_strict) 7819 tree tparms, orig_targs, targs, parm, arg; 7820 unification_kind_t strict; 7821 int sub_strict; 7822{ 7823 int nargs; 7824 tree tempargs; 7825 int i; 7826 7827 /* [temp.deduct.type] A template-argument can be deduced from a pointer 7828 to function or pointer to member function argument if the set of 7829 overloaded functions does not contain function templates and at most 7830 one of a set of overloaded functions provides a unique match. 7831 7832 So if this is a template, just return success. */ 7833 7834 if (uses_template_parms (arg)) 7835 return 1; 7836 7837 maybe_adjust_types_for_deduction (strict, &parm, &arg); 7838 7839 /* We don't copy orig_targs for this because if we have already deduced 7840 some template args from previous args, unify would complain when we 7841 try to deduce a template parameter for the same argument, even though 7842 there isn't really a conflict. */ 7843 nargs = TREE_VEC_LENGTH (targs); 7844 tempargs = make_scratch_vec (nargs); 7845 7846 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0) 7847 return 0; 7848 7849 /* First make sure we didn't deduce anything that conflicts with 7850 explicitly specified args. */ 7851 for (i = nargs; i--; ) 7852 { 7853 tree elt = TREE_VEC_ELT (tempargs, i); 7854 tree oldelt = TREE_VEC_ELT (orig_targs, i); 7855 7856 if (elt == NULL_TREE) 7857 continue; 7858 else if (uses_template_parms (elt)) 7859 { 7860 /* Since we're unifying against ourselves, we will fill in template 7861 args used in the function parm list with our own template parms. 7862 Discard them. */ 7863 TREE_VEC_ELT (tempargs, i) = NULL_TREE; 7864 continue; 7865 } 7866 else if (oldelt && ! template_args_equal (oldelt, elt)) 7867 return 0; 7868 } 7869 7870 for (i = nargs; i--; ) 7871 { 7872 tree elt = TREE_VEC_ELT (tempargs, i); 7873 7874 if (elt) 7875 TREE_VEC_ELT (targs, i) = elt; 7876 } 7877 7878 return 1; 7879} 7880 7881/* PARM is a template class (perhaps with unbound template 7882 parameters). ARG is a fully instantiated type. If ARG can be 7883 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and 7884 TARGS are as for unify. */ 7885 7886static tree 7887try_class_unification (tparms, targs, parm, arg) 7888 tree tparms; 7889 tree targs; 7890 tree parm; 7891 tree arg; 7892{ 7893 int i; 7894 tree copy_of_targs; 7895 7896 if (!CLASSTYPE_TEMPLATE_INFO (arg) 7897 || CLASSTYPE_TI_TEMPLATE (arg) != CLASSTYPE_TI_TEMPLATE (parm)) 7898 return NULL_TREE; 7899 7900 /* We need to make a new template argument vector for the call to 7901 unify. If we used TARGS, we'd clutter it up with the result of 7902 the attempted unification, even if this class didn't work out. 7903 We also don't want to commit ourselves to all the unifications 7904 we've already done, since unification is supposed to be done on 7905 an argument-by-argument basis. In other words, consider the 7906 following pathological case: 7907 7908 template <int I, int J, int K> 7909 struct S {}; 7910 7911 template <int I, int J> 7912 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {}; 7913 7914 template <int I, int J, int K> 7915 void f(S<I, J, K>, S<I, I, I>); 7916 7917 void g() { 7918 S<0, 0, 0> s0; 7919 S<0, 1, 2> s2; 7920 7921 f(s0, s2); 7922 } 7923 7924 Now, by the time we consider the unification involving `s2', we 7925 already know that we must have `f<0, 0, 0>'. But, even though 7926 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal 7927 because there are two ways to unify base classes of S<0, 1, 2> 7928 with S<I, I, I>. If we kept the already deduced knowledge, we 7929 would reject the possibility I=1. */ 7930 push_momentary (); 7931 copy_of_targs = make_temp_vec (TREE_VEC_LENGTH (targs)); 7932 i = unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm), 7933 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE); 7934 pop_momentary (); 7935 7936 /* If unification failed, we're done. */ 7937 if (i != 0) 7938 return NULL_TREE; 7939 else 7940 return arg; 7941} 7942 7943/* Subroutine of get_template_base. RVAL, if non-NULL, is a base we 7944 have alreay discovered to be satisfactory. ARG_BINFO is the binfo 7945 for the base class of ARG that we are currently examining. */ 7946 7947static tree 7948get_template_base_recursive (tparms, targs, parm, 7949 arg_binfo, rval, flags) 7950 tree tparms; 7951 tree targs; 7952 tree arg_binfo; 7953 tree rval; 7954 tree parm; 7955 int flags; 7956{ 7957 tree binfos; 7958 int i, n_baselinks; 7959 tree arg = BINFO_TYPE (arg_binfo); 7960 7961 if (!(flags & GTB_IGNORE_TYPE)) 7962 { 7963 tree r = try_class_unification (tparms, targs, 7964 parm, arg); 7965 7966 /* If there is more than one satisfactory baseclass, then: 7967 7968 [temp.deduct.call] 7969 7970 If they yield more than one possible deduced A, the type 7971 deduction fails. 7972 7973 applies. */ 7974 if (r && rval && !same_type_p (r, rval)) 7975 return error_mark_node; 7976 else if (r) 7977 rval = r; 7978 } 7979 7980 binfos = BINFO_BASETYPES (arg_binfo); 7981 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; 7982 7983 /* Process base types. */ 7984 for (i = 0; i < n_baselinks; i++) 7985 { 7986 tree base_binfo = TREE_VEC_ELT (binfos, i); 7987 int this_virtual; 7988 7989 /* Skip this base, if we've already seen it. */ 7990 if (BINFO_MARKED (base_binfo)) 7991 continue; 7992 7993 this_virtual = 7994 (flags & GTB_VIA_VIRTUAL) || TREE_VIA_VIRTUAL (base_binfo); 7995 7996 /* When searching for a non-virtual, we cannot mark virtually 7997 found binfos. */ 7998 if (! this_virtual) 7999 SET_BINFO_MARKED (base_binfo); 8000 8001 rval = get_template_base_recursive (tparms, targs, 8002 parm, 8003 base_binfo, 8004 rval, 8005 GTB_VIA_VIRTUAL * this_virtual); 8006 8007 /* If we discovered more than one matching base class, we can 8008 stop now. */ 8009 if (rval == error_mark_node) 8010 return error_mark_node; 8011 } 8012 8013 return rval; 8014} 8015 8016/* Given a template type PARM and a class type ARG, find the unique 8017 base type in ARG that is an instance of PARM. We do not examine 8018 ARG itself; only its base-classes. If there is no appropriate base 8019 class, return NULL_TREE. If there is more than one, return 8020 error_mark_node. PARM may be the type of a partial specialization, 8021 as well as a plain template type. Used by unify. */ 8022 8023static tree 8024get_template_base (tparms, targs, parm, arg) 8025 tree tparms; 8026 tree targs; 8027 tree parm; 8028 tree arg; 8029{ 8030 tree rval; 8031 tree arg_binfo; 8032 8033 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)), 92); 8034 8035 arg_binfo = TYPE_BINFO (complete_type (arg)); 8036 rval = get_template_base_recursive (tparms, targs, 8037 parm, arg_binfo, 8038 NULL_TREE, 8039 GTB_IGNORE_TYPE); 8040 8041 /* Since get_template_base_recursive marks the bases classes, we 8042 must unmark them here. */ 8043 dfs_walk (arg_binfo, dfs_unmark, markedp, 0); 8044 8045 return rval; 8046} 8047 8048/* Returns the level of DECL, which declares a template parameter. */ 8049 8050static int 8051template_decl_level (decl) 8052 tree decl; 8053{ 8054 switch (TREE_CODE (decl)) 8055 { 8056 case TYPE_DECL: 8057 case TEMPLATE_DECL: 8058 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl)); 8059 8060 case PARM_DECL: 8061 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl)); 8062 8063 default: 8064 my_friendly_abort (0); 8065 return 0; 8066 } 8067} 8068 8069/* Decide whether ARG can be unified with PARM, considering only the 8070 cv-qualifiers of each type, given STRICT as documented for unify. 8071 Returns non-zero iff the unification is OK on that basis.*/ 8072 8073static int 8074check_cv_quals_for_unify (strict, arg, parm) 8075 int strict; 8076 tree arg; 8077 tree parm; 8078{ 8079 return !((!(strict & UNIFY_ALLOW_MORE_CV_QUAL) 8080 && !at_least_as_qualified_p (arg, parm)) 8081 || (!(strict & UNIFY_ALLOW_LESS_CV_QUAL) 8082 && (!at_least_as_qualified_p (parm, arg)))); 8083} 8084 8085/* Takes parameters as for type_unification. Returns 0 if the 8086 type deduction suceeds, 1 otherwise. The parameter STRICT is a 8087 bitwise or of the following flags: 8088 8089 UNIFY_ALLOW_NONE: 8090 Require an exact match between PARM and ARG. 8091 UNIFY_ALLOW_MORE_CV_QUAL: 8092 Allow the deduced ARG to be more cv-qualified than ARG. 8093 UNIFY_ALLOW_LESS_CV_QUAL: 8094 Allow the deduced ARG to be less cv-qualified than ARG. 8095 UNIFY_ALLOW_DERIVED: 8096 Allow the deduced ARG to be a template base class of ARG, 8097 or a pointer to a template base class of the type pointed to by 8098 ARG. 8099 UNIFY_ALLOW_INTEGER: 8100 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX 8101 case for more information. */ 8102 8103static int 8104unify (tparms, targs, parm, arg, strict) 8105 tree tparms, targs, parm, arg; 8106 int strict; 8107{ 8108 int idx; 8109 tree targ; 8110 tree tparm; 8111 8112 /* I don't think this will do the right thing with respect to types. 8113 But the only case I've seen it in so far has been array bounds, where 8114 signedness is the only information lost, and I think that will be 8115 okay. */ 8116 while (TREE_CODE (parm) == NOP_EXPR) 8117 parm = TREE_OPERAND (parm, 0); 8118 8119 if (arg == error_mark_node) 8120 return 1; 8121 if (arg == unknown_type_node) 8122 /* We can't deduce anything from this, but we might get all the 8123 template args from other function args. */ 8124 return 0; 8125 8126 /* If PARM uses template parameters, then we can't bail out here, 8127 even if ARG == PARM, since we won't record unifications for the 8128 template parameters. We might need them if we're trying to 8129 figure out which of two things is more specialized. */ 8130 if (arg == parm && !uses_template_parms (parm)) 8131 return 0; 8132 8133 /* Immediately reject some pairs that won't unify because of 8134 cv-qualification mismatches. */ 8135 if (TREE_CODE (arg) == TREE_CODE (parm) 8136 && TREE_CODE_CLASS (TREE_CODE (arg)) == 't' 8137 /* We check the cv-qualifiers when unifying with template type 8138 parameters below. We want to allow ARG `const T' to unify with 8139 PARM `T' for example, when computing which of two templates 8140 is more specialized, for example. */ 8141 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM 8142 && !check_cv_quals_for_unify (strict, arg, parm)) 8143 return 1; 8144 8145 switch (TREE_CODE (parm)) 8146 { 8147 case TYPENAME_TYPE: 8148 /* In a type which contains a nested-name-specifier, template 8149 argument values cannot be deduced for template parameters used 8150 within the nested-name-specifier. */ 8151 return 0; 8152 8153 case TEMPLATE_TYPE_PARM: 8154 case TEMPLATE_TEMPLATE_PARM: 8155 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); 8156 8157 if (TEMPLATE_TYPE_LEVEL (parm) 8158 != template_decl_level (tparm)) 8159 /* The PARM is not one we're trying to unify. Just check 8160 to see if it matches ARG. */ 8161 return (TREE_CODE (arg) == TREE_CODE (parm) 8162 && same_type_p (parm, arg)) ? 0 : 1; 8163 idx = TEMPLATE_TYPE_IDX (parm); 8164 targ = TREE_VEC_ELT (targs, idx); 8165 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx)); 8166 8167 /* Check for mixed types and values. */ 8168 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM 8169 && TREE_CODE (tparm) != TYPE_DECL) 8170 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM 8171 && TREE_CODE (tparm) != TEMPLATE_DECL)) 8172 return 1; 8173 8174 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM) 8175 { 8176 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm)) 8177 { 8178 /* We arrive here when PARM does not involve template 8179 specialization. */ 8180 8181 /* ARG must be constructed from a template class. */ 8182 if (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)) 8183 return 1; 8184 8185 { 8186 tree parmtmpl = TYPE_TI_TEMPLATE (parm); 8187 tree parmvec = TYPE_TI_ARGS (parm); 8188 tree argvec = CLASSTYPE_TI_ARGS (arg); 8189 tree argtmplvec 8190 = DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg)); 8191 int i; 8192 8193 /* The parameter and argument roles have to be switched here 8194 in order to handle default arguments properly. For example, 8195 template<template <class> class TT> void f(TT<int>) 8196 should be able to accept vector<int> which comes from 8197 template <class T, class Allocator = allocator> 8198 class vector. */ 8199 8200 if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1) 8201 == error_mark_node) 8202 return 1; 8203 8204 /* Deduce arguments T, i from TT<T> or TT<i>. 8205 We check each element of PARMVEC and ARGVEC individually 8206 rather than the whole TREE_VEC since they can have 8207 different number of elements. */ 8208 8209 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i) 8210 { 8211 tree t = TREE_VEC_ELT (parmvec, i); 8212 8213 if (unify (tparms, targs, t, 8214 TREE_VEC_ELT (argvec, i), 8215 UNIFY_ALLOW_NONE)) 8216 return 1; 8217 } 8218 } 8219 arg = CLASSTYPE_TI_TEMPLATE (arg); 8220 } 8221 } 8222 else 8223 { 8224 /* If PARM is `const T' and ARG is only `int', we don't have 8225 a match unless we are allowing additional qualification. 8226 If ARG is `const int' and PARM is just `T' that's OK; 8227 that binds `const int' to `T'. */ 8228 if (!check_cv_quals_for_unify (strict | UNIFY_ALLOW_LESS_CV_QUAL, 8229 arg, parm)) 8230 return 1; 8231 8232 /* Consider the case where ARG is `const volatile int' and 8233 PARM is `const T'. Then, T should be `volatile int'. */ 8234 arg = 8235 cp_build_qualified_type (arg, 8236 CP_TYPE_QUALS (arg) 8237 & ~CP_TYPE_QUALS (parm)); 8238 } 8239 8240 /* Simple cases: Value already set, does match or doesn't. */ 8241 if (targ != NULL_TREE && same_type_p (targ, arg)) 8242 return 0; 8243 else if (targ) 8244 return 1; 8245 8246 /* Make sure that ARG is not a variable-sized array. (Note that 8247 were talking about variable-sized arrays (like `int[n]'), 8248 rather than arrays of unknown size (like `int[]').) We'll 8249 get very confused by such a type since the bound of the array 8250 will not be computable in an instantiation. Besides, such 8251 types are not allowed in ISO C++, so we can do as we please 8252 here. */ 8253 if (TREE_CODE (arg) == ARRAY_TYPE 8254 && !uses_template_parms (arg) 8255 && (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (arg))) 8256 != INTEGER_CST)) 8257 return 1; 8258 8259 TREE_VEC_ELT (targs, idx) = arg; 8260 return 0; 8261 8262 case TEMPLATE_PARM_INDEX: 8263 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0)); 8264 8265 if (TEMPLATE_PARM_LEVEL (parm) 8266 != template_decl_level (tparm)) 8267 /* The PARM is not one we're trying to unify. Just check 8268 to see if it matches ARG. */ 8269 return (TREE_CODE (arg) == TREE_CODE (parm) 8270 && cp_tree_equal (parm, arg) > 0) ? 0 : 1; 8271 8272 idx = TEMPLATE_PARM_IDX (parm); 8273 targ = TREE_VEC_ELT (targs, idx); 8274 8275 if (targ) 8276 { 8277 int i = (cp_tree_equal (targ, arg) > 0); 8278 if (i == 1) 8279 return 0; 8280 else if (i == 0) 8281 return 1; 8282 else 8283 my_friendly_abort (42); 8284 } 8285 8286 /* [temp.deduct.type] If, in the declaration of a function template 8287 with a non-type template-parameter, the non-type 8288 template-parameter is used in an expression in the function 8289 parameter-list and, if the corresponding template-argument is 8290 deduced, the template-argument type shall match the type of the 8291 template-parameter exactly, except that a template-argument 8292 deduced from an array bound may be of any integral type. */ 8293 if (same_type_p (TREE_TYPE (arg), TREE_TYPE (parm))) 8294 /* OK */; 8295 else if ((strict & UNIFY_ALLOW_INTEGER) 8296 && (TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE 8297 || TREE_CODE (TREE_TYPE (parm)) == BOOLEAN_TYPE)) 8298 /* OK */; 8299 else 8300 return 1; 8301 8302 TREE_VEC_ELT (targs, idx) = copy_to_permanent (arg); 8303 return 0; 8304 8305 case POINTER_TYPE: 8306 { 8307 int sub_strict; 8308 8309 if (TREE_CODE (arg) == RECORD_TYPE && TYPE_PTRMEMFUNC_FLAG (arg)) 8310 return (unify (tparms, targs, parm, 8311 TYPE_PTRMEMFUNC_FN_TYPE (arg), strict)); 8312 8313 if (TREE_CODE (arg) != POINTER_TYPE) 8314 return 1; 8315 8316 /* [temp.deduct.call] 8317 8318 A can be another pointer or pointer to member type that can 8319 be converted to the deduced A via a qualification 8320 conversion (_conv.qual_). 8321 8322 We pass down STRICT here rather than UNIFY_ALLOW_NONE. 8323 This will allow for additional cv-qualification of the 8324 pointed-to types if appropriate. In general, this is a bit 8325 too generous; we are only supposed to allow qualification 8326 conversions and this method will allow an ARG of char** and 8327 a deduced ARG of const char**. However, overload 8328 resolution will subsequently invalidate the candidate, so 8329 this is probably OK. */ 8330 sub_strict = strict; 8331 8332 if (TREE_CODE (TREE_TYPE (arg)) != RECORD_TYPE 8333 || TYPE_PTRMEMFUNC_FLAG (TREE_TYPE (arg))) 8334 /* The derived-to-base conversion only persists through one 8335 level of pointers. */ 8336 sub_strict &= ~UNIFY_ALLOW_DERIVED; 8337 8338 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE 8339 (arg), sub_strict); 8340 } 8341 8342 case REFERENCE_TYPE: 8343 if (TREE_CODE (arg) != REFERENCE_TYPE) 8344 return 1; 8345 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), 8346 UNIFY_ALLOW_NONE); 8347 8348 case ARRAY_TYPE: 8349 if (TREE_CODE (arg) != ARRAY_TYPE) 8350 return 1; 8351 if ((TYPE_DOMAIN (parm) == NULL_TREE) 8352 != (TYPE_DOMAIN (arg) == NULL_TREE)) 8353 return 1; 8354 if (TYPE_DOMAIN (parm) != NULL_TREE 8355 && unify (tparms, targs, TYPE_DOMAIN (parm), 8356 TYPE_DOMAIN (arg), UNIFY_ALLOW_NONE) != 0) 8357 return 1; 8358 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), 8359 UNIFY_ALLOW_NONE); 8360 8361 case REAL_TYPE: 8362 case COMPLEX_TYPE: 8363 case INTEGER_TYPE: 8364 case BOOLEAN_TYPE: 8365 case VOID_TYPE: 8366 if (TREE_CODE (arg) != TREE_CODE (parm)) 8367 return 1; 8368 8369 if (TREE_CODE (parm) == INTEGER_TYPE 8370 && TREE_CODE (TYPE_MAX_VALUE (parm)) != INTEGER_CST) 8371 { 8372 if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg) 8373 && unify (tparms, targs, TYPE_MIN_VALUE (parm), 8374 TYPE_MIN_VALUE (arg), UNIFY_ALLOW_INTEGER)) 8375 return 1; 8376 if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg) 8377 && unify (tparms, targs, TYPE_MAX_VALUE (parm), 8378 TYPE_MAX_VALUE (arg), UNIFY_ALLOW_INTEGER)) 8379 return 1; 8380 } 8381 /* We use the TYPE_MAIN_VARIANT since we have already 8382 checked cv-qualification at the top of the 8383 function. */ 8384 else if (!same_type_p (TYPE_MAIN_VARIANT (arg), 8385 TYPE_MAIN_VARIANT (parm))) 8386 return 1; 8387 8388 /* As far as unification is concerned, this wins. Later checks 8389 will invalidate it if necessary. */ 8390 return 0; 8391 8392 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */ 8393 /* Type INTEGER_CST can come from ordinary constant template args. */ 8394 case INTEGER_CST: 8395 while (TREE_CODE (arg) == NOP_EXPR) 8396 arg = TREE_OPERAND (arg, 0); 8397 8398 if (TREE_CODE (arg) != INTEGER_CST) 8399 return 1; 8400 return !tree_int_cst_equal (parm, arg); 8401 8402 case TREE_VEC: 8403 { 8404 int i; 8405 if (TREE_CODE (arg) != TREE_VEC) 8406 return 1; 8407 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg)) 8408 return 1; 8409 for (i = TREE_VEC_LENGTH (parm) - 1; i >= 0; i--) 8410 if (unify (tparms, targs, 8411 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i), 8412 UNIFY_ALLOW_NONE)) 8413 return 1; 8414 return 0; 8415 } 8416 8417 case RECORD_TYPE: 8418 case UNION_TYPE: 8419 if (TYPE_PTRMEMFUNC_FLAG (parm)) 8420 return unify (tparms, targs, TYPE_PTRMEMFUNC_FN_TYPE (parm), 8421 arg, strict); 8422 8423 if (TREE_CODE (arg) != TREE_CODE (parm)) 8424 return 1; 8425 8426 if (CLASSTYPE_TEMPLATE_INFO (parm)) 8427 { 8428 tree t = NULL_TREE; 8429 8430 if (strict & UNIFY_ALLOW_DERIVED) 8431 { 8432 /* First, we try to unify the PARM and ARG directly. */ 8433 t = try_class_unification (tparms, targs, 8434 parm, arg); 8435 8436 if (!t) 8437 { 8438 /* Fallback to the special case allowed in 8439 [temp.deduct.call]: 8440 8441 If P is a class, and P has the form 8442 template-id, then A can be a derived class of 8443 the deduced A. Likewise, if P is a pointer to 8444 a class of the form template-id, A can be a 8445 pointer to a derived class pointed to by the 8446 deduced A. */ 8447 t = get_template_base (tparms, targs, 8448 parm, arg); 8449 8450 if (! t || t == error_mark_node) 8451 return 1; 8452 } 8453 } 8454 else if (CLASSTYPE_TEMPLATE_INFO (arg) 8455 && (CLASSTYPE_TI_TEMPLATE (parm) 8456 == CLASSTYPE_TI_TEMPLATE (arg))) 8457 /* Perhaps PARM is something like S<U> and ARG is S<int>. 8458 Then, we should unify `int' and `U'. */ 8459 t = arg; 8460 else 8461 /* There's no chance of unication succeeding. */ 8462 return 1; 8463 8464 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm), 8465 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE); 8466 } 8467 else if (!same_type_p (TYPE_MAIN_VARIANT (parm), 8468 TYPE_MAIN_VARIANT (arg))) 8469 return 1; 8470 return 0; 8471 8472 case METHOD_TYPE: 8473 case FUNCTION_TYPE: 8474 if (TREE_CODE (arg) != TREE_CODE (parm)) 8475 return 1; 8476 8477 if (unify (tparms, targs, TREE_TYPE (parm), 8478 TREE_TYPE (arg), UNIFY_ALLOW_NONE)) 8479 return 1; 8480 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm), 8481 TYPE_ARG_TYPES (arg), 1, 8482 DEDUCE_EXACT, 0); 8483 8484 case OFFSET_TYPE: 8485 if (TREE_CODE (arg) != OFFSET_TYPE) 8486 return 1; 8487 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm), 8488 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE)) 8489 return 1; 8490 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg), 8491 strict); 8492 8493 case CONST_DECL: 8494 if (arg != decl_constant_value (parm)) 8495 return 1; 8496 return 0; 8497 8498 case TEMPLATE_DECL: 8499 /* Matched cases are handled by the ARG == PARM test above. */ 8500 return 1; 8501 8502 case MINUS_EXPR: 8503 if (TREE_CODE (TREE_OPERAND (parm, 1)) == INTEGER_CST) 8504 { 8505 /* We handle this case specially, since it comes up with 8506 arrays. In particular, something like: 8507 8508 template <int N> void f(int (&x)[N]); 8509 8510 Here, we are trying to unify the range type, which 8511 looks like [0 ... (N - 1)]. */ 8512 tree t, t1, t2; 8513 t1 = TREE_OPERAND (parm, 0); 8514 t2 = TREE_OPERAND (parm, 1); 8515 8516 /* Should this be a regular fold? */ 8517 t = maybe_fold_nontype_arg (build (PLUS_EXPR, 8518 integer_type_node, 8519 arg, t2)); 8520 8521 return unify (tparms, targs, t1, t, strict); 8522 } 8523 /* else fall through */ 8524 8525 default: 8526 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm)))) 8527 /* We're looking at an expression. This can happen with 8528 something like: 8529 8530 template <int I> 8531 void foo(S<I>, S<I + 2>); 8532 8533 This is a "nondeduced context": 8534 8535 [deduct.type] 8536 8537 The nondeduced contexts are: 8538 8539 --A type that is a template-id in which one or more of 8540 the template-arguments is an expression that references 8541 a template-parameter. 8542 8543 In these cases, we assume deduction succeeded, but don't 8544 actually infer any unifications. */ 8545 return 0; 8546 else 8547 sorry ("use of `%s' in template type unification", 8548 tree_code_name [(int) TREE_CODE (parm)]); 8549 8550 return 1; 8551 } 8552} 8553 8554/* Called if RESULT is explicitly instantiated, or is a member of an 8555 explicitly instantiated class, or if using -frepo and the 8556 instantiation of RESULT has been assigned to this file. */ 8557 8558void 8559mark_decl_instantiated (result, extern_p) 8560 tree result; 8561 int extern_p; 8562{ 8563 if (TREE_CODE (result) != FUNCTION_DECL) 8564 /* The TREE_PUBLIC flag for function declarations will have been 8565 set correctly by tsubst. */ 8566 TREE_PUBLIC (result) = 1; 8567 8568 if (! extern_p) 8569 { 8570 DECL_INTERFACE_KNOWN (result) = 1; 8571 DECL_NOT_REALLY_EXTERN (result) = 1; 8572 8573 /* Always make artificials weak. */ 8574 if (DECL_ARTIFICIAL (result) && flag_weak) 8575 comdat_linkage (result); 8576 /* For WIN32 we also want to put explicit instantiations in 8577 linkonce sections. */ 8578 else if (TREE_PUBLIC (result)) 8579 maybe_make_one_only (result); 8580 } 8581 else if (TREE_CODE (result) == FUNCTION_DECL) 8582 mark_inline_for_output (result); 8583} 8584 8585/* Given two function templates PAT1 and PAT2, and explicit template 8586 arguments EXPLICIT_ARGS return: 8587 8588 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order]. 8589 -1 if PAT2 is more specialized than PAT1. 8590 0 if neither is more specialized. */ 8591 8592int 8593more_specialized (pat1, pat2, explicit_args) 8594 tree pat1, pat2, explicit_args; 8595{ 8596 tree targs; 8597 int winner = 0; 8598 8599 targs = get_bindings_overload (pat1, DECL_RESULT (pat2), explicit_args); 8600 if (targs) 8601 --winner; 8602 8603 targs = get_bindings_overload (pat2, DECL_RESULT (pat1), explicit_args); 8604 if (targs) 8605 ++winner; 8606 8607 return winner; 8608} 8609 8610/* Given two class template specialization list nodes PAT1 and PAT2, return: 8611 8612 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order]. 8613 -1 if PAT2 is more specialized than PAT1. 8614 0 if neither is more specialized. */ 8615 8616int 8617more_specialized_class (pat1, pat2) 8618 tree pat1, pat2; 8619{ 8620 tree targs; 8621 int winner = 0; 8622 8623 targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1), 8624 TREE_PURPOSE (pat2)); 8625 if (targs) 8626 --winner; 8627 8628 targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2), 8629 TREE_PURPOSE (pat1)); 8630 if (targs) 8631 ++winner; 8632 8633 return winner; 8634} 8635 8636/* Return the template arguments that will produce the function signature 8637 DECL from the function template FN, with the explicit template 8638 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must 8639 also match. Return NULL_TREE if no satisfactory arguments could be 8640 found. */ 8641 8642static tree 8643get_bindings_real (fn, decl, explicit_args, check_rettype) 8644 tree fn, decl, explicit_args; 8645 int check_rettype; 8646{ 8647 int ntparms = DECL_NTPARMS (fn); 8648 tree targs = make_scratch_vec (ntparms); 8649 tree decl_type; 8650 tree decl_arg_types; 8651 int i; 8652 8653 /* Substitute the explicit template arguments into the type of DECL. 8654 The call to fn_type_unification will handle substitution into the 8655 FN. */ 8656 decl_type = TREE_TYPE (decl); 8657 if (explicit_args && uses_template_parms (decl_type)) 8658 { 8659 tree tmpl; 8660 tree converted_args; 8661 8662 if (DECL_TEMPLATE_INFO (decl)) 8663 tmpl = DECL_TI_TEMPLATE (decl); 8664 else 8665 /* We can get here for some illegal specializations. */ 8666 return NULL_TREE; 8667 8668 converted_args 8669 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl), 8670 explicit_args, NULL_TREE, 8671 /*complain=*/0, 8672 /*require_all_arguments=*/0)); 8673 if (converted_args == error_mark_node) 8674 return NULL_TREE; 8675 8676 decl_type = tsubst (decl_type, converted_args, /*complain=*/0, 8677 NULL_TREE); 8678 if (decl_type == error_mark_node) 8679 return NULL_TREE; 8680 } 8681 8682 /* If FN is a static member function, adjust the type of DECL 8683 appropriately. */ 8684 decl_arg_types = TYPE_ARG_TYPES (decl_type); 8685 if (DECL_STATIC_FUNCTION_P (fn) 8686 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 8687 decl_arg_types = TREE_CHAIN (decl_arg_types); 8688 8689 i = fn_type_unification (fn, explicit_args, targs, 8690 decl_arg_types, 8691 TREE_TYPE (decl_type), 8692 DEDUCE_EXACT); 8693 8694 if (i != 0) 8695 return NULL_TREE; 8696 8697 if (check_rettype) 8698 { 8699 /* Check to see that the resulting return type is also OK. */ 8700 tree t = tsubst (TREE_TYPE (TREE_TYPE (fn)), targs, 8701 /*complain=*/0, NULL_TREE); 8702 8703 if (!same_type_p (t, TREE_TYPE (TREE_TYPE (decl)))) 8704 return NULL_TREE; 8705 } 8706 8707 return targs; 8708} 8709 8710/* For most uses, we want to check the return type. */ 8711 8712tree 8713get_bindings (fn, decl, explicit_args) 8714 tree fn, decl, explicit_args; 8715{ 8716 return get_bindings_real (fn, decl, explicit_args, 1); 8717} 8718 8719/* But for more_specialized, we only care about the parameter types. */ 8720 8721static tree 8722get_bindings_overload (fn, decl, explicit_args) 8723 tree fn, decl, explicit_args; 8724{ 8725 return get_bindings_real (fn, decl, explicit_args, 0); 8726} 8727 8728/* Return the innermost template arguments that, when applied to a 8729 template specialization whose innermost template parameters are 8730 TPARMS, and whose specialization arguments are ARGS, yield the 8731 ARGS. 8732 8733 For example, suppose we have: 8734 8735 template <class T, class U> struct S {}; 8736 template <class T> struct S<T*, int> {}; 8737 8738 Then, suppose we want to get `S<double*, int>'. The TPARMS will be 8739 {T}, the PARMS will be {T*, int} and the ARGS will be {double*, 8740 int}. The resulting vector will be {double}, indicating that `T' 8741 is bound to `double'. */ 8742 8743static tree 8744get_class_bindings (tparms, parms, args) 8745 tree tparms, parms, args; 8746{ 8747 int i, ntparms = TREE_VEC_LENGTH (tparms); 8748 tree vec = make_temp_vec (ntparms); 8749 8750 args = innermost_args (args); 8751 8752 if (unify (tparms, vec, parms, args, UNIFY_ALLOW_NONE)) 8753 return NULL_TREE; 8754 8755 for (i = 0; i < ntparms; ++i) 8756 if (! TREE_VEC_ELT (vec, i)) 8757 return NULL_TREE; 8758 8759 return vec; 8760} 8761 8762/* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs. 8763 Pick the most specialized template, and return the corresponding 8764 instantiation, or if there is no corresponding instantiation, the 8765 template itself. EXPLICIT_ARGS is any template arguments explicity 8766 mentioned in a template-id. If there is no most specialized 8767 tempalte, error_mark_node is returned. If there are no templates 8768 at all, NULL_TREE is returned. */ 8769 8770tree 8771most_specialized_instantiation (instantiations, explicit_args) 8772 tree instantiations; 8773 tree explicit_args; 8774{ 8775 tree fn, champ; 8776 int fate; 8777 8778 if (!instantiations) 8779 return NULL_TREE; 8780 8781 champ = instantiations; 8782 for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn)) 8783 { 8784 fate = more_specialized (TREE_VALUE (champ), 8785 TREE_VALUE (fn), explicit_args); 8786 if (fate == 1) 8787 ; 8788 else 8789 { 8790 if (fate == 0) 8791 { 8792 fn = TREE_CHAIN (fn); 8793 if (! fn) 8794 return error_mark_node; 8795 } 8796 champ = fn; 8797 } 8798 } 8799 8800 for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn)) 8801 { 8802 fate = more_specialized (TREE_VALUE (champ), 8803 TREE_VALUE (fn), explicit_args); 8804 if (fate != 1) 8805 return error_mark_node; 8806 } 8807 8808 return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ); 8809} 8810 8811/* Return the most specialized of the list of templates in FNS that can 8812 produce an instantiation matching DECL, given the explicit template 8813 arguments EXPLICIT_ARGS. */ 8814 8815static tree 8816most_specialized (fns, decl, explicit_args) 8817 tree fns, decl, explicit_args; 8818{ 8819 tree candidates = NULL_TREE; 8820 tree fn, args; 8821 8822 for (fn = fns; fn; fn = TREE_CHAIN (fn)) 8823 { 8824 tree candidate = TREE_VALUE (fn); 8825 8826 args = get_bindings (candidate, decl, explicit_args); 8827 if (args) 8828 candidates = scratch_tree_cons (NULL_TREE, candidate, 8829 candidates); 8830 } 8831 8832 return most_specialized_instantiation (candidates, explicit_args); 8833} 8834 8835/* If DECL is a specialization of some template, return the most 8836 general such template. For example, given: 8837 8838 template <class T> struct S { template <class U> void f(U); }; 8839 8840 if TMPL is `template <class U> void S<int>::f(U)' this will return 8841 the full template. This function will not trace past partial 8842 specializations, however. For example, given in addition: 8843 8844 template <class T> struct S<T*> { template <class U> void f(U); }; 8845 8846 if TMPL is `template <class U> void S<int*>::f(U)' this will return 8847 `template <class T> template <class U> S<T*>::f(U)'. */ 8848 8849static tree 8850most_general_template (decl) 8851 tree decl; 8852{ 8853 while (DECL_TEMPLATE_INFO (decl)) 8854 decl = DECL_TI_TEMPLATE (decl); 8855 8856 return decl; 8857} 8858 8859/* Return the most specialized of the class template specializations 8860 of TMPL which can produce an instantiation matching ARGS, or 8861 error_mark_node if the choice is ambiguous. */ 8862 8863static tree 8864most_specialized_class (tmpl, args) 8865 tree tmpl; 8866 tree args; 8867{ 8868 tree list = NULL_TREE; 8869 tree t; 8870 tree champ; 8871 int fate; 8872 8873 tmpl = most_general_template (tmpl); 8874 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t)) 8875 { 8876 tree spec_args 8877 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args); 8878 if (spec_args) 8879 { 8880 list = decl_tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list); 8881 TREE_TYPE (list) = TREE_TYPE (t); 8882 } 8883 } 8884 8885 if (! list) 8886 return NULL_TREE; 8887 8888 t = list; 8889 champ = t; 8890 t = TREE_CHAIN (t); 8891 for (; t; t = TREE_CHAIN (t)) 8892 { 8893 fate = more_specialized_class (champ, t); 8894 if (fate == 1) 8895 ; 8896 else 8897 { 8898 if (fate == 0) 8899 { 8900 t = TREE_CHAIN (t); 8901 if (! t) 8902 return error_mark_node; 8903 } 8904 champ = t; 8905 } 8906 } 8907 8908 for (t = list; t && t != champ; t = TREE_CHAIN (t)) 8909 { 8910 fate = more_specialized_class (champ, t); 8911 if (fate != 1) 8912 return error_mark_node; 8913 } 8914 8915 return champ; 8916} 8917 8918/* called from the parser. */ 8919 8920void 8921do_decl_instantiation (declspecs, declarator, storage) 8922 tree declspecs, declarator, storage; 8923{ 8924 tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, NULL_TREE); 8925 tree result = NULL_TREE; 8926 int extern_p = 0; 8927 8928 if (! DECL_LANG_SPECIFIC (decl)) 8929 { 8930 cp_error ("explicit instantiation of non-template `%#D'", decl); 8931 return; 8932 } 8933 else if (TREE_CODE (decl) == VAR_DECL) 8934 { 8935 /* There is an asymmetry here in the way VAR_DECLs and 8936 FUNCTION_DECLs are handled by grokdeclarator. In the case of 8937 the latter, the DECL we get back will be marked as a 8938 template instantiation, and the appropriate 8939 DECL_TEMPLATE_INFO will be set up. This does not happen for 8940 VAR_DECLs so we do the lookup here. Probably, grokdeclarator 8941 should handle VAR_DECLs as it currently handles 8942 FUNCTION_DECLs. */ 8943 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, 0); 8944 if (result && TREE_CODE (result) != VAR_DECL) 8945 { 8946 cp_error ("no matching template for `%D' found", result); 8947 return; 8948 } 8949 } 8950 else if (TREE_CODE (decl) != FUNCTION_DECL) 8951 { 8952 cp_error ("explicit instantiation of `%#D'", decl); 8953 return; 8954 } 8955 else 8956 result = decl; 8957 8958 /* Check for various error cases. Note that if the explicit 8959 instantiation is legal the RESULT will currently be marked as an 8960 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set 8961 until we get here. */ 8962 8963 if (DECL_TEMPLATE_SPECIALIZATION (result)) 8964 { 8965 /* [temp.spec] 8966 8967 No program shall both explicitly instantiate and explicitly 8968 specialize a template. */ 8969 cp_pedwarn ("explicit instantiation of `%#D' after", result); 8970 cp_pedwarn_at ("explicit specialization here", result); 8971 return; 8972 } 8973 else if (DECL_EXPLICIT_INSTANTIATION (result)) 8974 { 8975 /* [temp.spec] 8976 8977 No program shall explicitly instantiate any template more 8978 than once. 8979 8980 We check DECL_INTERFACE_KNOWN so as not to complain when the 8981 first instantiation was `extern' and the second is not, and 8982 EXTERN_P for the opposite case. */ 8983 if (DECL_INTERFACE_KNOWN (result) && !extern_p && !flag_use_repository) 8984 cp_pedwarn ("duplicate explicit instantiation of `%#D'", result); 8985 8986 /* If we've already instantiated the template, just return now. */ 8987 if (DECL_INTERFACE_KNOWN (result)) 8988 return; 8989 } 8990 else if (!DECL_IMPLICIT_INSTANTIATION (result)) 8991 { 8992 cp_error ("no matching template for `%D' found", result); 8993 return; 8994 } 8995 else if (!DECL_TEMPLATE_INFO (result)) 8996 { 8997 cp_pedwarn ("explicit instantiation of non-template `%#D'", result); 8998 return; 8999 } 9000 9001 if (flag_external_templates) 9002 return; 9003 9004 if (storage == NULL_TREE) 9005 ; 9006 else if (storage == ridpointers[(int) RID_EXTERN]) 9007 { 9008 if (pedantic) 9009 cp_pedwarn ("ANSI C++ forbids the use of `extern' on explicit instantiations"); 9010 extern_p = 1; 9011 } 9012 else 9013 cp_error ("storage class `%D' applied to template instantiation", 9014 storage); 9015 9016 SET_DECL_EXPLICIT_INSTANTIATION (result); 9017 mark_decl_instantiated (result, extern_p); 9018 repo_template_instantiated (result, extern_p); 9019 if (! extern_p) 9020 instantiate_decl (result); 9021} 9022 9023void 9024mark_class_instantiated (t, extern_p) 9025 tree t; 9026 int extern_p; 9027{ 9028 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t); 9029 SET_CLASSTYPE_INTERFACE_KNOWN (t); 9030 CLASSTYPE_INTERFACE_ONLY (t) = extern_p; 9031 CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p; 9032 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p; 9033 if (! extern_p) 9034 { 9035 CLASSTYPE_DEBUG_REQUESTED (t) = 1; 9036 rest_of_type_compilation (t, 1); 9037 } 9038} 9039 9040void 9041do_type_instantiation (t, storage) 9042 tree t, storage; 9043{ 9044 int extern_p = 0; 9045 int nomem_p = 0; 9046 int static_p = 0; 9047 9048 if (TREE_CODE (t) == TYPE_DECL) 9049 t = TREE_TYPE (t); 9050 9051 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t)) 9052 { 9053 cp_error ("explicit instantiation of non-template type `%T'", t); 9054 return; 9055 } 9056 9057 complete_type (t); 9058 9059 /* With -fexternal-templates, explicit instantiations are treated the same 9060 as implicit ones. */ 9061 if (flag_external_templates) 9062 return; 9063 9064 if (TYPE_SIZE (t) == NULL_TREE) 9065 { 9066 cp_error ("explicit instantiation of `%#T' before definition of template", 9067 t); 9068 return; 9069 } 9070 9071 if (storage != NULL_TREE) 9072 { 9073 if (pedantic) 9074 cp_pedwarn("ANSI C++ forbids the use of `%s' on explicit instantiations", 9075 IDENTIFIER_POINTER (storage)); 9076 9077 if (storage == ridpointers[(int) RID_INLINE]) 9078 nomem_p = 1; 9079 else if (storage == ridpointers[(int) RID_EXTERN]) 9080 extern_p = 1; 9081 else if (storage == ridpointers[(int) RID_STATIC]) 9082 static_p = 1; 9083 else 9084 { 9085 cp_error ("storage class `%D' applied to template instantiation", 9086 storage); 9087 extern_p = 0; 9088 } 9089 } 9090 9091 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) 9092 { 9093 /* [temp.spec] 9094 9095 No program shall both explicitly instantiate and explicitly 9096 specialize a template. */ 9097 cp_error ("explicit instantiation of `%#T' after", t); 9098 cp_error_at ("explicit specialization here", t); 9099 return; 9100 } 9101 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t)) 9102 { 9103 /* [temp.spec] 9104 9105 No program shall explicitly instantiate any template more 9106 than once. 9107 9108 If CLASSTYPE_INTERFACE_ONLY, then the first explicit 9109 instantiation was `extern', and if EXTERN_P then the second 9110 is. Both cases are OK. */ 9111 if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository) 9112 cp_pedwarn ("duplicate explicit instantiation of `%#T'", t); 9113 9114 /* If we've already instantiated the template, just return now. */ 9115 if (!CLASSTYPE_INTERFACE_ONLY (t)) 9116 return; 9117 } 9118 9119 mark_class_instantiated (t, extern_p); 9120 repo_template_instantiated (t, extern_p); 9121 9122 if (nomem_p) 9123 return; 9124 9125 { 9126 tree tmp; 9127 9128 /* In contrast to implicit instantiation, where only the 9129 declarations, and not the definitions, of members are 9130 instantiated, we have here: 9131 9132 [temp.explicit] 9133 9134 The explicit instantiation of a class template specialization 9135 implies the instantiation of all of its members not 9136 previously explicitly specialized in the translation unit 9137 containing the explicit instantiation. 9138 9139 Of course, we can't instantiate member template classes, since 9140 we don't have any arguments for them. Note that the standard 9141 is unclear on whether the instatiation of the members are 9142 *explicit* instantiations or not. We choose to be generous, 9143 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow 9144 the explicit instantiation of a class where some of the members 9145 have no definition in the current translation unit. */ 9146 9147 if (! static_p) 9148 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp)) 9149 if (TREE_CODE (tmp) == FUNCTION_DECL 9150 && DECL_TEMPLATE_INSTANTIATION (tmp)) 9151 { 9152 mark_decl_instantiated (tmp, extern_p); 9153 repo_template_instantiated (tmp, extern_p); 9154 if (! extern_p) 9155 instantiate_decl (tmp); 9156 } 9157 9158 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp)) 9159 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp)) 9160 { 9161 mark_decl_instantiated (tmp, extern_p); 9162 repo_template_instantiated (tmp, extern_p); 9163 if (! extern_p) 9164 instantiate_decl (tmp); 9165 } 9166 9167 for (tmp = CLASSTYPE_TAGS (t); tmp; tmp = TREE_CHAIN (tmp)) 9168 if (IS_AGGR_TYPE (TREE_VALUE (tmp)) 9169 && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp)))) 9170 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp)), storage); 9171 } 9172} 9173 9174/* Given a function DECL, which is a specialization of TMPL, modify 9175 DECL to be a re-instantiation of TMPL with the same template 9176 arguments. TMPL should be the template into which tsubst'ing 9177 should occur for DECL, not the most general template. 9178 9179 One reason for doing this is a scenario like this: 9180 9181 template <class T> 9182 void f(const T&, int i); 9183 9184 void g() { f(3, 7); } 9185 9186 template <class T> 9187 void f(const T& t, const int i) { } 9188 9189 Note that when the template is first instantiated, with 9190 instantiate_template, the resulting DECL will have no name for the 9191 first parameter, and the wrong type for the second. So, when we go 9192 to instantiate the DECL, we regenerate it. */ 9193 9194static void 9195regenerate_decl_from_template (decl, tmpl) 9196 tree decl; 9197 tree tmpl; 9198{ 9199 tree args; 9200 tree code_pattern; 9201 tree new_decl; 9202 tree gen_tmpl; 9203 int unregistered; 9204 9205 args = DECL_TI_ARGS (decl); 9206 code_pattern = DECL_TEMPLATE_RESULT (tmpl); 9207 9208 /* Unregister the specialization so that when we tsubst we will not 9209 just return DECL. We don't have to unregister DECL from TMPL 9210 because if would only be registered there if it were a partial 9211 instantiation of a specialization, which it isn't: it's a full 9212 instantiation. */ 9213 gen_tmpl = most_general_template (tmpl); 9214 unregistered = unregister_specialization (decl, gen_tmpl); 9215 9216 /* If the DECL was not unregistered then something peculiar is 9217 happening: we created a specialization but did not call 9218 register_specialization for it. */ 9219 my_friendly_assert (unregistered, 0); 9220 9221 if (TREE_CODE (decl) == VAR_DECL) 9222 /* Make sure that we can see identifiers, and compute access 9223 correctly, for the class members used in the declaration of 9224 this static variable. */ 9225 pushclass (DECL_CONTEXT (decl), 2); 9226 9227 /* Do the substitution to get the new declaration. */ 9228 new_decl = tsubst (code_pattern, args, /*complain=*/1, NULL_TREE); 9229 9230 if (TREE_CODE (decl) == VAR_DECL) 9231 { 9232 /* Set up DECL_INITIAL, since tsubst doesn't. */ 9233 DECL_INITIAL (new_decl) = 9234 tsubst_expr (DECL_INITIAL (code_pattern), args, 9235 /*complain=*/1, DECL_TI_TEMPLATE (decl)); 9236 /* Pop the class context we pushed above. */ 9237 popclass (); 9238 } 9239 else if (TREE_CODE (decl) == FUNCTION_DECL) 9240 { 9241 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the 9242 new decl. */ 9243 DECL_INITIAL (new_decl) = error_mark_node; 9244 /* And don't complain about a duplicate definition. */ 9245 DECL_INITIAL (decl) = NULL_TREE; 9246 } 9247 9248 /* The immediate parent of the new template is still whatever it was 9249 before, even though tsubst sets DECL_TI_TEMPLATE up as the most 9250 general template. We also reset the DECL_ASSEMBLER_NAME since 9251 tsubst always calculates the name as if the function in question 9252 were really a template instance, and sometimes, with friend 9253 functions, this is not so. See tsubst_friend_function for 9254 details. */ 9255 DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl); 9256 DECL_ASSEMBLER_NAME (new_decl) = DECL_ASSEMBLER_NAME (decl); 9257 DECL_RTL (new_decl) = DECL_RTL (decl); 9258 9259 /* Call duplicate decls to merge the old and new declarations. */ 9260 duplicate_decls (new_decl, decl); 9261 9262 /* Now, re-register the specialization. */ 9263 register_specialization (decl, gen_tmpl, args); 9264} 9265 9266/* Produce the definition of D, a _DECL generated from a template. */ 9267 9268tree 9269instantiate_decl (d) 9270 tree d; 9271{ 9272 tree tmpl = DECL_TI_TEMPLATE (d); 9273 tree args = DECL_TI_ARGS (d); 9274 tree td; 9275 tree code_pattern; 9276 tree spec; 9277 tree gen_tmpl; 9278 int nested = in_function_p (); 9279 int pattern_defined; 9280 int line = lineno; 9281 char *file = input_filename; 9282 9283 /* This function should only be used to instantiate templates for 9284 functions and static member variables. */ 9285 my_friendly_assert (TREE_CODE (d) == FUNCTION_DECL 9286 || TREE_CODE (d) == VAR_DECL, 0); 9287 9288 if (DECL_TEMPLATE_INSTANTIATED (d)) 9289 /* D has already been instantiated. It might seem reasonable to 9290 check whether or not D is an explict instantiation, and, if so, 9291 stop here. But when an explicit instantiation is deferred 9292 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION 9293 is set, even though we still need to do the instantiation. */ 9294 return d; 9295 9296 /* If we already have a specialization of this declaration, then 9297 there's no reason to instantiate it. Note that 9298 retrieve_specialization gives us both instantiations and 9299 specializations, so we must explicitly check 9300 DECL_TEMPLATE_SPECIALIZATION. */ 9301 gen_tmpl = most_general_template (tmpl); 9302 spec = retrieve_specialization (gen_tmpl, args); 9303 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec)) 9304 return spec; 9305 9306 /* This needs to happen before any tsubsting. */ 9307 if (! push_tinst_level (d)) 9308 return d; 9309 9310 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern 9311 for the instantiation. This is not always the most general 9312 template. Consider, for example: 9313 9314 template <class T> 9315 struct S { template <class U> void f(); 9316 template <> void f<int>(); }; 9317 9318 and an instantiation of S<double>::f<int>. We want TD to be the 9319 specialization S<T>::f<int>, not the more general S<T>::f<U>. */ 9320 td = tmpl; 9321 for (td = tmpl; 9322 /* An instantiation cannot have a definition, so we need a 9323 more general template. */ 9324 DECL_TEMPLATE_INSTANTIATION (td) 9325 /* We must also deal with friend templates. Given: 9326 9327 template <class T> struct S { 9328 template <class U> friend void f() {}; 9329 }; 9330 9331 S<int>::f<U> say, is not an instantiation of S<T>::f<U>, 9332 so far as the language is concerned, but that's still 9333 where we get the pattern for the instantiation from. On 9334 ther hand, if the definition comes outside the class, say: 9335 9336 template <class T> struct S { 9337 template <class U> friend void f(); 9338 }; 9339 template <class U> friend void f() {} 9340 9341 we don't need to look any further. That's what the check for 9342 DECL_INITIAL is for. */ 9343 || (TREE_CODE (d) == FUNCTION_DECL 9344 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td) 9345 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td))); 9346 ) 9347 { 9348 /* The present template, TD, should not be a definition. If it 9349 were a definition, we should be using it! Note that we 9350 cannot restructure the loop to just keep going until we find 9351 a template with a definition, since that might go too far if 9352 a specialization was declared, but not defined. */ 9353 my_friendly_assert (!(TREE_CODE (d) == VAR_DECL 9354 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td))), 9355 0); 9356 9357 /* Fetch the more general template. */ 9358 td = DECL_TI_TEMPLATE (td); 9359 } 9360 9361 code_pattern = DECL_TEMPLATE_RESULT (td); 9362 9363 if (TREE_CODE (d) == FUNCTION_DECL) 9364 pattern_defined = (DECL_INITIAL (code_pattern) != NULL_TREE); 9365 else 9366 pattern_defined = ! DECL_IN_AGGR_P (code_pattern); 9367 9368 push_to_top_level (); 9369 lineno = DECL_SOURCE_LINE (d); 9370 input_filename = DECL_SOURCE_FILE (d); 9371 9372 if (pattern_defined) 9373 { 9374 repo_template_used (d); 9375 9376 if (flag_external_templates && ! DECL_INTERFACE_KNOWN (d)) 9377 { 9378 if (flag_alt_external_templates) 9379 { 9380 if (interface_unknown) 9381 warn_if_unknown_interface (d); 9382 } 9383 else if (DECL_INTERFACE_KNOWN (code_pattern)) 9384 { 9385 DECL_INTERFACE_KNOWN (d) = 1; 9386 DECL_NOT_REALLY_EXTERN (d) = ! DECL_EXTERNAL (code_pattern); 9387 } 9388 else 9389 warn_if_unknown_interface (code_pattern); 9390 } 9391 9392 if (at_eof) 9393 import_export_decl (d); 9394 } 9395 9396 /* Reject all external templates except inline functions. */ 9397 if (DECL_INTERFACE_KNOWN (d) 9398 && ! DECL_NOT_REALLY_EXTERN (d) 9399 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))) 9400 goto out; 9401 9402 if (TREE_CODE (d) == VAR_DECL 9403 && TREE_READONLY (d) 9404 && DECL_INITIAL (d) == NULL_TREE 9405 && DECL_INITIAL (code_pattern) != NULL_TREE) 9406 /* We need to set up DECL_INITIAL regardless of pattern_defined if 9407 the variable is a static const initialized in the class body. */; 9408 else if (! pattern_defined 9409 || (! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d) && nested) 9410 && ! at_eof)) 9411 { 9412 /* Defer all templates except inline functions used in another 9413 function. We restore the source position here because it's used 9414 by add_pending_template. */ 9415 lineno = line; 9416 input_filename = file; 9417 9418 if (at_eof && !pattern_defined 9419 && DECL_EXPLICIT_INSTANTIATION (d)) 9420 /* [temp.explicit] 9421 9422 The definition of a non-exported function template, a 9423 non-exported member function template, or a non-exported 9424 member function or static data member of a class template 9425 shall be present in every translation unit in which it is 9426 explicitly instantiated. */ 9427 cp_error ("explicit instantiation of `%D' but no definition available", 9428 d); 9429 9430 add_pending_template (d); 9431 goto out; 9432 } 9433 9434 /* We're now committed to instantiating this template. Mark it as 9435 instantiated so that recursive calls to instantiate_decl do not 9436 try to instantiate it again. */ 9437 DECL_TEMPLATE_INSTANTIATED (d) = 1; 9438 9439 /* Regenerate the declaration in case the template has been modified 9440 by a subsequent redeclaration. */ 9441 regenerate_decl_from_template (d, td); 9442 9443 /* We already set the file and line above. Reset them now in case 9444 they changed as a result of calling regenerate_decl_from_template. */ 9445 lineno = DECL_SOURCE_LINE (d); 9446 input_filename = DECL_SOURCE_FILE (d); 9447 9448 if (TREE_CODE (d) == VAR_DECL) 9449 { 9450 DECL_IN_AGGR_P (d) = 0; 9451 if (DECL_INTERFACE_KNOWN (d)) 9452 DECL_EXTERNAL (d) = ! DECL_NOT_REALLY_EXTERN (d); 9453 else 9454 { 9455 DECL_EXTERNAL (d) = 1; 9456 DECL_NOT_REALLY_EXTERN (d) = 1; 9457 } 9458 cp_finish_decl (d, DECL_INITIAL (d), NULL_TREE, 0, 0); 9459 } 9460 else if (TREE_CODE (d) == FUNCTION_DECL) 9461 { 9462 tree t = DECL_SAVED_TREE (code_pattern); 9463 9464 start_function (NULL_TREE, d, NULL_TREE, 1); 9465 store_parm_decls (); 9466 9467 if (t && TREE_CODE (t) == RETURN_INIT) 9468 { 9469 store_return_init 9470 (TREE_OPERAND (t, 0), 9471 tsubst_expr (TREE_OPERAND (t, 1), args, /*complain=*/1, tmpl)); 9472 t = TREE_CHAIN (t); 9473 } 9474 9475 if (t && TREE_CODE (t) == CTOR_INITIALIZER) 9476 { 9477 current_member_init_list 9478 = tsubst_expr_values (TREE_OPERAND (t, 0), args); 9479 current_base_init_list 9480 = tsubst_expr_values (TREE_OPERAND (t, 1), args); 9481 t = TREE_CHAIN (t); 9482 } 9483 9484 setup_vtbl_ptr (); 9485 /* Always keep the BLOCK node associated with the outermost 9486 pair of curly braces of a function. These are needed 9487 for correct operation of dwarfout.c. */ 9488 keep_next_level (); 9489 9490 my_friendly_assert (TREE_CODE (t) == COMPOUND_STMT, 42); 9491 tsubst_expr (t, args, /*complain=*/1, tmpl); 9492 9493 finish_function (lineno, 0, nested); 9494 } 9495 9496out: 9497 lineno = line; 9498 input_filename = file; 9499 9500 pop_from_top_level (); 9501 pop_tinst_level (); 9502 9503 return d; 9504} 9505 9506/* Run through the list of templates that we wish we could 9507 instantiate, and instantiate any we can. */ 9508 9509int 9510instantiate_pending_templates () 9511{ 9512 tree *t; 9513 int instantiated_something = 0; 9514 int reconsider; 9515 9516 do 9517 { 9518 reconsider = 0; 9519 9520 t = &pending_templates; 9521 while (*t) 9522 { 9523 tree srcloc = TREE_PURPOSE (*t); 9524 tree instantiation = TREE_VALUE (*t); 9525 9526 input_filename = SRCLOC_FILE (srcloc); 9527 lineno = SRCLOC_LINE (srcloc); 9528 9529 if (TREE_CODE_CLASS (TREE_CODE (instantiation)) == 't') 9530 { 9531 tree fn; 9532 9533 if (!TYPE_SIZE (instantiation)) 9534 { 9535 instantiate_class_template (instantiation); 9536 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation)) 9537 for (fn = TYPE_METHODS (instantiation); 9538 fn; 9539 fn = TREE_CHAIN (fn)) 9540 if (! DECL_ARTIFICIAL (fn)) 9541 instantiate_decl (fn); 9542 if (TYPE_SIZE (instantiation)) 9543 { 9544 instantiated_something = 1; 9545 reconsider = 1; 9546 } 9547 } 9548 9549 if (TYPE_SIZE (instantiation)) 9550 /* If INSTANTIATION has been instantiated, then we don't 9551 need to consider it again in the future. */ 9552 *t = TREE_CHAIN (*t); 9553 else 9554 t = &TREE_CHAIN (*t); 9555 } 9556 else 9557 { 9558 if (DECL_TEMPLATE_INSTANTIATION (instantiation) 9559 && !DECL_TEMPLATE_INSTANTIATED (instantiation)) 9560 { 9561 instantiation = instantiate_decl (instantiation); 9562 if (DECL_TEMPLATE_INSTANTIATED (instantiation)) 9563 { 9564 instantiated_something = 1; 9565 reconsider = 1; 9566 } 9567 } 9568 9569 if (!DECL_TEMPLATE_INSTANTIATION (instantiation) 9570 || DECL_TEMPLATE_INSTANTIATED (instantiation)) 9571 /* If INSTANTIATION has been instantiated, then we don't 9572 need to consider it again in the future. */ 9573 *t = TREE_CHAIN (*t); 9574 else 9575 t = &TREE_CHAIN (*t); 9576 } 9577 } 9578 template_tail = t; 9579 9580 /* Go through the things that are template instantiations if we are 9581 using guiding declarations. */ 9582 t = &maybe_templates; 9583 while (*t) 9584 { 9585 tree template; 9586 tree fn; 9587 tree args; 9588 9589 fn = TREE_VALUE (*t); 9590 9591 if (DECL_INITIAL (fn)) 9592 /* If the FN is already defined, then it was either already 9593 instantiated or, even though guiding declarations were 9594 allowed, a non-template definition was provided. */ 9595 ; 9596 else 9597 { 9598 template = TREE_PURPOSE (*t); 9599 args = get_bindings (template, fn, NULL_TREE); 9600 fn = instantiate_template (template, args); 9601 instantiate_decl (fn); 9602 reconsider = 1; 9603 } 9604 9605 /* Remove this entry from the chain. */ 9606 *t = TREE_CHAIN (*t); 9607 } 9608 maybe_template_tail = t; 9609 } 9610 while (reconsider); 9611 9612 return instantiated_something; 9613} 9614 9615/* Substitute ARGVEC into T, which is a TREE_LIST. In particular, it 9616 is an initializer list: the TREE_PURPOSEs are DECLs, and the 9617 TREE_VALUEs are initializer values. Used by instantiate_decl. */ 9618 9619static tree 9620tsubst_expr_values (t, argvec) 9621 tree t, argvec; 9622{ 9623 tree first = NULL_TREE; 9624 tree *p = &first; 9625 9626 for (; t; t = TREE_CHAIN (t)) 9627 { 9628 tree pur = tsubst_copy (TREE_PURPOSE (t), argvec, 9629 /*complain=*/1, NULL_TREE); 9630 tree val = tsubst_expr (TREE_VALUE (t), argvec, /*complain=*/1, 9631 NULL_TREE); 9632 *p = build_tree_list (pur, val); 9633 p = &TREE_CHAIN (*p); 9634 } 9635 return first; 9636} 9637 9638tree last_tree; 9639 9640void 9641add_tree (t) 9642 tree t; 9643{ 9644 last_tree = TREE_CHAIN (last_tree) = t; 9645} 9646 9647 9648void 9649begin_tree () 9650{ 9651 saved_trees = tree_cons (NULL_TREE, last_tree, saved_trees); 9652 last_tree = NULL_TREE; 9653} 9654 9655 9656void 9657end_tree () 9658{ 9659 my_friendly_assert (saved_trees != NULL_TREE, 0); 9660 9661 last_tree = TREE_VALUE (saved_trees); 9662 saved_trees = TREE_CHAIN (saved_trees); 9663} 9664 9665/* D is an undefined function declaration in the presence of templates with 9666 the same name, listed in FNS. If one of them can produce D as an 9667 instantiation, remember this so we can instantiate it at EOF if D has 9668 not been defined by that time. */ 9669 9670void 9671add_maybe_template (d, fns) 9672 tree d, fns; 9673{ 9674 tree t; 9675 9676 if (DECL_MAYBE_TEMPLATE (d)) 9677 return; 9678 9679 t = most_specialized (fns, d, NULL_TREE); 9680 if (! t) 9681 return; 9682 if (t == error_mark_node) 9683 { 9684 cp_error ("ambiguous template instantiation for `%D'", d); 9685 return; 9686 } 9687 9688 *maybe_template_tail = perm_tree_cons (t, d, NULL_TREE); 9689 maybe_template_tail = &TREE_CHAIN (*maybe_template_tail); 9690 DECL_MAYBE_TEMPLATE (d) = 1; 9691} 9692 9693/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */ 9694 9695static void 9696set_current_access_from_decl (decl) 9697 tree decl; 9698{ 9699 if (TREE_PRIVATE (decl)) 9700 current_access_specifier = access_private_node; 9701 else if (TREE_PROTECTED (decl)) 9702 current_access_specifier = access_protected_node; 9703 else 9704 current_access_specifier = access_public_node; 9705} 9706 9707/* Instantiate an enumerated type. TAG is the template type, NEWTAG 9708 is the instantiation (which should have been created with 9709 start_enum) and ARGS are the template arguments to use. */ 9710 9711static void 9712tsubst_enum (tag, newtag, args) 9713 tree tag; 9714 tree newtag; 9715 tree args; 9716{ 9717 tree e; 9718 9719 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e)) 9720 { 9721 tree value; 9722 tree elt; 9723 9724 /* Note that in a template enum, the TREE_VALUE is the 9725 CONST_DECL, not the corresponding INTEGER_CST. */ 9726 value = tsubst_expr (DECL_INITIAL (TREE_VALUE (e)), 9727 args, /*complain=*/1, 9728 NULL_TREE); 9729 9730 /* Give this enumeration constant the correct access. */ 9731 set_current_access_from_decl (TREE_VALUE (e)); 9732 9733 /* Actually build the enumerator itself. */ 9734 elt = build_enumerator (TREE_PURPOSE (e), value, newtag); 9735 9736 /* We save the enumerators we have built so far in the 9737 TYPE_VALUES so that if the enumeration constants for 9738 subsequent enumerators involve those for previous ones, 9739 tsubst_copy will be able to find them. */ 9740 TREE_CHAIN (elt) = TYPE_VALUES (newtag); 9741 TYPE_VALUES (newtag) = elt; 9742 } 9743 9744 finish_enum (newtag); 9745} 9746 9747/* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that 9748 is either an instantiation or specialization of a template 9749 function. */ 9750 9751static void 9752set_mangled_name_for_template_decl (decl) 9753 tree decl; 9754{ 9755 tree saved_namespace; 9756 tree context = NULL_TREE; 9757 tree fn_type; 9758 tree ret_type; 9759 tree parm_types; 9760 tree tparms; 9761 tree targs; 9762 tree tmpl; 9763 int parm_depth; 9764 9765 my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0); 9766 my_friendly_assert (DECL_TEMPLATE_INFO (decl) != NULL_TREE, 0); 9767 9768 /* The names of template functions must be mangled so as to indicate 9769 what template is being specialized with what template arguments. 9770 For example, each of the following three functions must get 9771 different mangled names: 9772 9773 void f(int); 9774 template <> void f<7>(int); 9775 template <> void f<8>(int); */ 9776 9777 targs = DECL_TI_ARGS (decl); 9778 if (uses_template_parms (targs)) 9779 /* This DECL is for a partial instantiation. There's no need to 9780 mangle the name of such an entity. */ 9781 return; 9782 9783 tmpl = most_general_template (DECL_TI_TEMPLATE (decl)); 9784 tparms = DECL_TEMPLATE_PARMS (tmpl); 9785 parm_depth = TMPL_PARMS_DEPTH (tparms); 9786 9787 /* There should be as many levels of arguments as there are levels 9788 of parameters. */ 9789 my_friendly_assert (parm_depth == TMPL_ARGS_DEPTH (targs), 0); 9790 9791 /* We now compute the PARMS and RET_TYPE to give to 9792 build_decl_overload_real. The PARMS and RET_TYPE are the 9793 parameter and return types of the template, after all but the 9794 innermost template arguments have been substituted, not the 9795 parameter and return types of the function DECL. For example, 9796 given: 9797 9798 template <class T> T f(T); 9799 9800 both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'. 9801 A more subtle example is: 9802 9803 template <class T> struct S { template <class U> void f(T, U); } 9804 9805 Here, if DECL is `void S<int>::f(int, double)', PARMS should be 9806 {int, U}. Thus, the args that we want to subsitute into the 9807 return and parameter type for the function are those in TARGS, 9808 with the innermost level omitted. */ 9809 fn_type = TREE_TYPE (tmpl); 9810 if (DECL_STATIC_FUNCTION_P (decl)) 9811 context = DECL_CLASS_CONTEXT (decl); 9812 9813 if (parm_depth == 1) 9814 /* No substitution is necessary. */ 9815 ; 9816 else 9817 { 9818 int i; 9819 tree partial_args; 9820 9821 /* Replace the innermost level of the TARGS with NULL_TREEs to 9822 let tsubst know not to subsitute for those parameters. */ 9823 partial_args = make_temp_vec (TREE_VEC_LENGTH (targs)); 9824 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i) 9825 SET_TMPL_ARGS_LEVEL (partial_args, i, 9826 TMPL_ARGS_LEVEL (targs, i)); 9827 SET_TMPL_ARGS_LEVEL (partial_args, 9828 TMPL_ARGS_DEPTH (targs), 9829 make_temp_vec (DECL_NTPARMS (tmpl))); 9830 9831 /* Now, do the (partial) substitution to figure out the 9832 appropriate function type. */ 9833 fn_type = tsubst (fn_type, partial_args, /*complain=*/1, NULL_TREE); 9834 if (DECL_STATIC_FUNCTION_P (decl)) 9835 context = tsubst (context, partial_args, /*complain=*/1, NULL_TREE); 9836 9837 /* Substitute into the template parameters to obtain the real 9838 innermost set of parameters. This step is important if the 9839 innermost set of template parameters contains value 9840 parameters whose types depend on outer template parameters. */ 9841 TREE_VEC_LENGTH (partial_args)--; 9842 tparms = tsubst_template_parms (tparms, partial_args, /*complain=*/1); 9843 } 9844 9845 /* Now, get the innermost parameters and arguments, and figure out 9846 the parameter and return types. */ 9847 tparms = INNERMOST_TEMPLATE_PARMS (tparms); 9848 targs = innermost_args (targs); 9849 ret_type = TREE_TYPE (fn_type); 9850 parm_types = TYPE_ARG_TYPES (fn_type); 9851 9852 /* For a static member function, we generate a fake `this' pointer, 9853 for the purposes of mangling. This indicates of which class the 9854 function is a member. Because of: 9855 9856 [class.static] 9857 9858 There shall not be a static and a nonstatic member function 9859 with the same name and the same parameter types 9860 9861 we don't have to worry that this will result in a clash with a 9862 non-static member function. */ 9863 if (DECL_STATIC_FUNCTION_P (decl)) 9864 parm_types = hash_tree_chain (build_pointer_type (context), parm_types); 9865 9866 /* There should be the same number of template parameters as 9867 template arguments. */ 9868 my_friendly_assert (TREE_VEC_LENGTH (tparms) == TREE_VEC_LENGTH (targs), 9869 0); 9870 9871 /* If the template is in a namespace, we need to put that into the 9872 mangled name. Unfortunately, build_decl_overload_real does not 9873 get the decl to mangle, so it relies on the current 9874 namespace. Therefore, we set that here temporarily. */ 9875 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd', 980702); 9876 saved_namespace = current_namespace; 9877 current_namespace = CP_DECL_CONTEXT (decl); 9878 9879 /* Actually set the DCL_ASSEMBLER_NAME. */ 9880 DECL_ASSEMBLER_NAME (decl) 9881 = build_decl_overload_real (DECL_NAME (decl), parm_types, ret_type, 9882 tparms, targs, 9883 DECL_FUNCTION_MEMBER_P (decl) 9884 + DECL_CONSTRUCTOR_P (decl)); 9885 9886 /* Restore the previously active namespace. */ 9887 current_namespace = saved_namespace; 9888} 9889