5.12.4.2.3.1.1.3. 生成template-id
那么作为结果，对于这个非类型实参，“ chunkSize ”的 IDENTIFIER_NODE 被返回。类似的还有下一个实参“ maxSmallObjectSize ”。因此在 lookup_template_class 的 4346 行退出 coerce_template_parms 时， arglist 为下图中标记为红色的节点。
（ 点此打开 ）
图 111 ：构建的 arglist
lookup_template_class (continue)
4352 if (arglist == error_mark_node)
4353 /* We were unable to bind the arguments. */
4354 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4355
4356 /* In the scope of a template class, explicit references to the
4357 template class refer to the type of the template, not any
4358 instantiation of it. For example, in:
4359
4360 template <class T> class C { void f(C<T>); }
4361
4362 the `C<T>' is just the same as `C'. Outside of the
4363 class, however, such a reference is an instantiation. */
4364 if (comp_template_args (TYPE_TI_ARGS (template_type),
4365 arglist))
4366 {
…
4386 }
4387 if (found)
4388 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4389
4390 for (tp = &DECL_TEMPLATE_INSTANTIATIONS (template);
4391 *tp;
4392 tp = &TREE_CHAIN (*tp))
4393 if (comp_template_args (TREE_PURPOSE (*tp), arglist))
4394 {
…
4405 }
4406
4407 /* This type is a "partial instantiation" if any of the template
4408 arguments still involve template parameters. Note that we set
4409 IS_PARTIAL_INSTANTIATION for partial specializations as
4410 well. */
4411 is_partial_instantiation = uses_template_parms (arglist);
4412
4413 /* If the deduced arguments are invalid, then the binding
4414 failed. */
4415 if (!is_partial_instantiation
4416 && check_instantiated_args (template,
4417 INNERMOST_TEMPLATE_ARGS (arglist),
4418 complain))
4419 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4420
4421 if (!is_partial_instantiation
4422 && !PRIMARY_TEMPLATE_P (template)
4423 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4424 {
4425 found = xref_tag_from_type (TREE_TYPE (template),
4426 DECL_NAME (template),
4427 /*globalize=*/ 1);
4428 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4429 }
4430
4431 context = tsubst (DECL_CONTEXT (template), arglist,
4432 complain, in_decl);
4433 if (!context)
4434 context = global_namespace ;
在 4411 行对于标记为红色的 TREE_VEC ， uses_template_parms 将依次遍历其成员，任一成员为类型依赖或值依赖都将导致该函数返回非 0 值，使得 is_partial_instantiation 成为 1 。 同样在 4431 行，变量 template 指向“ SmallObject ”的 TEMPLATE_DECL ，因此其上下文是 Loki 的 NAMESPACE_DECL ，它由 tsubst 返回不作任何处理。
lookup_template_class (continue)
4436 /* Create the type. */
4437 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4438 {
…
4450 }
4451 else
4452 {
4453 t = make_aggr_type (TREE_CODE (template_type));
4454 CLASSTYPE_DECLARED_CLASS (t)
4455 = CLASSTYPE_DECLARED_CLASS (template_type);
4456 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4457 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4458
4459 /* A local class. Make sure the decl gets registered properly. */
4460 if (context == current_function_decl )
4461 pushtag (DECL_NAME (template), t, 0);
4462 }
4463
4464 /* If we called start_enum or pushtag above, this information
4465 will already be set up. */
4466 if (!TYPE_NAME (t))
4467 {
4468 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4469
4470 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4471 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4472 TYPE_STUB_DECL (t) = type_decl;
4473 DECL_SOURCE_LOCATION (type_decl)
4474 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4475 }
4476 else
4477 type_decl = TYPE_NAME (t);
4478
4479 TREE_PRIVATE (type_decl)
4480 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4481 TREE_PROTECTED (type_decl)
4482 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4483
4484 /* Set up the template information. We have to figure out which
4485 template is the immediate parent if this is a full
4486 instantiation. */
4487 if (parm_depth == 1 || is_partial_instantiation
4488 || !PRIMARY_TEMPLATE_P (template))
4489 /* This case is easy; there are no member templates involved. */
4490 found = template;
4491 else
4492 {
…
4544 }
4545
4546 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4547 DECL_TEMPLATE_INSTANTIATIONS (template)
4548 = tree_cons (arglist, t,
4549 DECL_TEMPLATE_INSTANTIATIONS (template));
4550
4551 if (TREE_CODE (t) == ENUMERAL_TYPE
4552 && !is_partial_instantiation)
4553 /* Now that the type has been registered on the instantiations
4554 list, we set up the enumerators. Because the enumeration
4555 constants may involve the enumeration type itself, we make
4556 sure to register the type first, and then create the
4557 constants. That way, doing tsubst_expr for the enumeration
4558 constants won't result in recursive calls here; we'll find
4559 the instantiation and exit above. */
4560 tsubst_enum (template_type, t, arglist);
4561
4562 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4563 is set up. */
4564 if (TREE_CODE (t) != ENUMERAL_TYPE)
4565 DECL_NAME (type_decl) = classtype_mangled_name (t);
4566 if (is_partial_instantiation)
4567 /* If the type makes use of template parameters, the
4568 code that generates debugging information will crash. */
4569 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4570
4571 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4572 }
4573 timevar_pop (TV_NAME_LOOKUP);
4574 }
变量 template_type 是“ SmallObject ”的 RECORD_TYPE 节点。首先在 4551 行之前，下面红色的节点被构建了。
（ 点此打开 ）
作为具现的实例，要求一个修饰名而不是之前看到的朴素名（ plain name ）。
4002 static tree
4003 classtype_mangled_name (tree t) in pt.c
4004 {
4005 if (CLASSTYPE_TEMPLATE_INFO (t)
4006 /* Specializations have already had their names set up in
4007 lookup_template_class. */
4008 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4009 {
4010 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4011
4012 /* For non-primary templates, the template parameters are
4013 implicit from their surrounding context. */
4014 if (PRIMARY_TEMPLATE_P (tmpl))
4015 {
4016 tree name = DECL_NAME (tmpl);
4017 char *mangled_name = mangle_class_name_for_template
4018 (IDENTIFIER_POINTER (name),
4019 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4020 CLASSTYPE_TI_ARGS (t));
4021 tree id = get_identifier (mangled_name);
4022 IDENTIFIER_TEMPLATE (id) = name;
4023 return id;
4024 }
4025 }
4026
4027 return TYPE_IDENTIFIER (t);
4028 }
修饰名根据主模板来构建（它通常就是最泛化的模板，通过 most_general_template 来获取），其中主模板的名字是一个标识符（作为比较，一个偏特化的模板的名字是一个 template-id ）。以下的宏用于检查指定的模板是否为主模板。
2783 #define DECL_PRIMARY_TEMPLATE (NODE) / in cp-tree.h
2784 (TREE_TYPE (DECL_INNERMOST_TEMPLATE_PARMS (NODE)))
2785
2786 /* Returns nonzero if NODE is a primary template. */
27873 #define PRIMARY_TEMPLATE_P (NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
2661 #define DECL_INNERMOST_TEMPLATE_PARMS (NODE) /
2662 INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (NODE))
INNERMOST_TEMPLATE_P ARMS 只是返回节点 value 域中的内容；而 DECL_TEMPLATE_PARMS 返回 TEMPLATE_DECL 的 arguments 域的指针。
那么具现实例的 TYPE_DECL 被更新为如下的修饰名。
（ 点此打开 ）
图 112 ：内层的 template-id
作为结果， lookup_template_class 返回具现实例所对应的 RECORD_TYPE 节点。接下来，通过其 chain 域（在 finish_template_type 中的 TYPE_STUB_DECL ）把 TYPE_DECL （粗红线节点）作为 template-id 返回。
5.12.4.2.3.1.2. 外层 template-id
对于外层的 template-id ，内层 template-id ——“ SmallObject<ThreadingModel, chunkSize, maxSmallObjectSize> ”是其一个实参；而且下面的 arguments 是一个具有单个成员为该 template-id 的 tree_vec 。然后我们又以下面的代码进行解析。
cp_parser_template_id
7991 /* Build a representation of the specialization. */
7992 if (TREE_CODE (template) == IDENTIFIER_NODE)
7993 template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments);
7994 else if (DECL_CLASS_TEMPLATE_P (template)
7995 || DECL_TEMPLATE_TEMPLATE_PARM_P (template))
7996 template_id
7997 = finish_template_type (template, arguments,
7998 cp_lexer_next_token_is (parser->lexer,
7999 CPP_SCOPE));
不过在 lookup_template_class 中的处理有一些不同，因为“ ThreadingModel ”是模板参数。
4133 tree
4134 lookup_template_class (tree d1, in pt.c
4135 tree arglist,
4136 tree in_decl,
4137 tree context,
4138 int entering_scope,
4139 tsubst_flags_t complain)
4140 {
4141 tree template = NULL_TREE, parmlist;
4142 tree t;
4143
4144 timevar_push (TV_NAME_LOOKUP);
4145
4146 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4147 {
4148 if (IDENTIFIER_VALUE (d1)
4149 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1)))
4150 template = IDENTIFIER_VALUE (d1);
4151 else
4152 {
4153 if (context)
4154 push_decl_namespace (context);
4155 template = lookup_name (d1, /*prefer_type=*/ 0);
4156 template = maybe_get_template_decl_from_type_decl (template);
4157 if (context)
4158 pop_decl_namespace ();
4159 }
4160 if (template)
4161 context = DECL_CONTEXT (template);
4162 }
4163 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4164 {
4165 tree type = TREE_TYPE (d1);
4166
4167 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4168 an implicit typename for the second A. Deal with it. */
4169 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4170 type = TREE_TYPE (type);
4171
4172 if (CLASSTYPE_TEMPLATE_INFO (type))
4173 {
4174 template = CLASSTYPE_TI_TEMPLATE (type);
4175 d1 = DECL_NAME (template);
4176 }
4177 }
4178 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4179 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4180 {
4181 template = TYPE_TI_TEMPLATE (d1);
4182 d1 = DECL_NAME (template);
4183 }
4184 else if (TREE_CODE (d1) == TEMPLATE_DECL
4185 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4186 {
4187 template = d1;
4188 d1 = DECL_NAME (template);
4189 context = DECL_CONTEXT (template);
4190 }
4191
4192 /* With something like `template <class T> class X class X { ... };'
4193 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
4194 We don't want to do that, but we have to deal with the situation,
4195 so let's give them some syntax errors to chew on instead of a
4196 crash. Alternatively D1 might not be a template type at all. */
4197 if (! template)
4198 {
4199 if (complain & tf_error)
4200 error ("`%T' is not a template", d1);
4201 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4202 }
4203
4204 if (TREE_CODE (template) != TEMPLATE_DECL
4205 /* Make sure it's a user visible template, if it was named by
4206 the user. */
4207 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4208 && !PRIMARY_TEMPLATE_P (template)))
4209 {
4210 if (complain & tf_error)
4211 {
4212 error ("non-template type `%T' used as a template", d1);
4213 if (in_decl)
4214 cp_error_at ("for template declaration `%D'", in_decl);
4215 }
4216 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4217 }
4218
4219 complain &= ~tf_user;
4220
4221 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4222 {
4223 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4224 template arguments */
4225
4226 tree parm;
4227 tree arglist2;
4228
4229 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4230
4231 /* Consider an example where a template template parameter declared as
4232
4233 template <class T, class U = std::allocator<T> > class TT
4234
4235 The template parameter level of T and U are one level larger than
4236 of TT. To proper process the default argument of U, say when an
4237 instantiation `TT<int>' is seen, we need to build the full
4238 arguments containing {int} as the innermost level. Outer levels,
4239 available when not appearing as default template argument, can be
4240 obtained from `current_template_args ()'.
4241
4242 Suppose that TT is later substituted with std::vector. The above
4243 instantiation is `TT<int, std::allocator<T> >' with TT at
4244 level 1, and T at level 2, while the template arguments at level 1
4245 becomes {std::vector} and the inner level 2 is {int}. */
4246
4247 if (current_template_parms )
4248 arglist = add_to_template_args (current_template_args (), arglist);
4249
4250 arglist2 = coerce_template_parms (parmlist, arglist, template,
4251 complain, /*require_all_args=*/ 1);
4252 if (arglist2 == error_mark_node
4253 || (!uses_template_parms (arglist2)
4254 && check_instantiated_args (template, arglist2, complain)))
4255 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4256
4257 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4258 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4259 }
…
4574 }
上面的 d1 指向下图的 TEMPLATE_DECL 。而 arglist 指向代表内层 template-id 的子树。
（ 点此打开 ）
还有注意 current_template_parms 指向的节点，它是“ SmallObject ”的实参。它还应该是“ ThreadingModel ”的实参，因为“ ThreadingModel ”被包括在“ SmallObject ”的参数列表中。因此在 4248 行，函数 current_template_args 拷贝出这个向量，不过拷贝节点的 type 域是空的。
511 static tree
512 add_to_template_args (tree args, tree extra_args) in pt.c
513 {
514 tree new_args;
515 int extra_depth;
516 int i;
517 int j;
518
519 extra_depth = TMPL_ARGS_DEPTH (extra_args);
520 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
521
522 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
523 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
524
525 for (j = 1; j <= extra_depth; ++j, ++i)
526 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
527
528 return new_args;
529 }
接着在 4248 行，构建了 TREE_VEC 类型的 arglists ，其第一个成员指向上图中红色的 TREE_VEC ，而第二个成员指向内层 template-id （在下面传递给 args ）的 TREE_VEC 。那么在 4250 行的 parmlist （在下面传递给 parms ）指向图 112 中的其他 TREE_VEC ，这个节点代表“ ThreadingModel ”的实参。
3805 static tree
3806 coerce_template_parms (tree parms, in pt.c
3807 tree args,
3808 tree in_decl,
3809 tsubst_flags_t complain,
3810 int require_all_arguments)
3811 {
3812 int nparms, nargs, i, lost = 0;
3813 tree inner_args;
3814 tree new_args;
3815 tree new_inner_args;
3816
3817 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3818 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
3819 nparms = TREE_VEC_LENGTH (parms);
3820
3821 if (nargs > nparms
3822 || (nargs < nparms
3823 && require_all_arguments
3824 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
3825 {
3826 if (complain & tf_error)
3827 {
3828 error ("wrong number of template arguments (%d, should be %d)",
3829 nargs, nparms);
3830
3831 if (in_decl)
3832 cp_error_at ("provided for `%D'", in_decl);
3833 }
3834
3835 return error_mark_node;
3836 }
3837
3838 new_inner_args = make_tree_vec (nparms);
3839 new_args = add_outermost_template_args (args, new_inner_args);
在 3817 行， INNERMOST_TEMPLATE_ARGS 返回先前所构建的 arglists 的最后一个成员，这是代表内层 template-id 的节点。作为结果，我们得到 nparms （ 1 ）， nargs （ 1 ）。
538 static tree
539 add_outermost_template_args (tree args, tree extra_args) in pt.c
540 {
541 tree new_args;
542
543 /* If there are more levels of EXTRA_ARGS than there are ARGS,
544 something very fishy is going on. */
545 my_friendly_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args),
546 0);
547
548 /* If *all* the new arguments will be the EXTRA_ARGS, just return
549 them. */
550 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
551 return extra_args;
552
553 /* For the moment, we make ARGS look like it contains fewer levels. */
554 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
555
556 new_args = add_to_template_args (args, extra_args);
557
558 /* Now, we restore ARGS to its full dimensions. */
559 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
560
561 return new_args;
562 }
因为 args 是包含 TREE_VEC 的 TREE_VEC ， TMPL_ARGS_DEPTH 返回的外层向量的长度（它是 2 ）， extra_args 是长度是 1 的 TREE_VEC ，因为不是包含 TREE_VEC 的 TREE_VEC ， TMPL_ARGS_DEPTH 对其总是返回 1 。因此 add_outermost_template_args 的总体效果是使用 extra_args 来替代 args 的最后的成员。
coerce_template_parms (continue)
3840 for (i = 0; i < nparms; i++)
3841 {
3842 tree arg;
3843 tree parm;
3844
3845 /* Get the Ith template parameter. */
3846 parm = TREE_VEC_ELT (parms, i);
3847
3848 /* Calculate the Ith argument. */
3849 if (i < nargs)
3850 arg = TREE_VEC_ELT (inner_args, i);
3851 else if (require_all_arguments)
3852 /* There must be a default arg in this case. */
3853 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
3854 complain, in_decl);
3855 else
3856 break ;
3857
3858 my_friendly_assert (arg, 20030727);
3859 if (arg == error_mark_node)
3860 error ("template argument %d is invalid", i + 1);
3861 else
3862 arg = convert_template_argument (TREE_VALUE (parm),
3863 arg, new_args, complain, i,
3864 i n_decl);
3865
3866 if (arg == error_mark_node)
3867 lost++;
3868 TREE_VEC_ELT (new_inner_args, i) = arg;
3869 }
3870
3871 if (lost)
3872 return error_mark_node;
3873
3874 return new_inner_args;
3875 }
在这个函数的调用中，参数 parm 是上图（不是图 112 ）中的 TYPE_DECL ； arg 是内层 template-id （它是 TYPE_DECL 节点）； args 是由 add_outermost_template_args 构建的包含 TREE_VEC 的 TREE_VEC 。
3636 static tree
3637 convert_template_argument (tree parm, in pt.c
3638 tree arg,
3639 tree args,
3640 tsubst_flags_t complain,
3641 int i,
3642 tree in_decl)
3643 {
3644 tree val;
3645 tree inner_args;
3646 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3647
3648 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3649
3650 if (TREE_CODE (arg) == TREE_LIST
3651 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3652 {
…
3660 }
3661
3662 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3663 requires_type = (TREE_CODE (parm) == TYPE_DECL
3664 || requires_tmpl_type);
3665
3666 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3667 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3668 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3669 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3670
3671 if (is_tmpl_type
3672 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3673 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3674 arg = TYPE_STUB_DECL (arg);
3675
3676 is_type = TYPE_P (arg) || is_tmpl_type;
…
3722 if (is_type)
3723 {
3724 if (requires_tmpl_type)
3725 {
…
3759 }
3760 else
3761 val = groktypename (arg);
3762 }
3763 else
3764 {
…
3790 }
3791
3792 return val;
3793 }
因为 arg 是一个 TYPE_DECL 节点，在 3761 行， groktypename 不对它做任何事，只是返回它。然后在 3868 行，在 coerce_template_parms 中该节点被填入 new_inner_args 。记得当构建 new_inner_args 时，这个节点被刻意忽略了，但现在我们开始照顾到它了。因此从 4250 行返回到 lookup_template_class 时， arglist2 与 arglist 相同。
记住在 4257 行的 template 指向代表“ ThreadingModel ”的 TEMPLATE_DECL 。接下来，将构建 BOUND_TEMPLATE_TEMPLATE_PARM 节点，正如其名字所暗示，它代表模板模板参数的一个绑定。
995 tree
996 bind_template_template_parm (tree t, tree newargs) in tree.c
997 {
998 tree decl = TYPE_NAME (t);
999 tree t2;
1000
1001 t2 = make_aggr_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1002 decl = build_decl (TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1003
1004 /* These nodes have to be created to reflect new TYPE_DECL and template
1005 arguments. */
1006 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1007 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1008 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1009 = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t),
1010 newargs, NULL_TREE);
1011
1012 TREE_TYPE (decl) = t2;
1013 TYPE_NAME (t2) = decl;
1014 TYPE_STUB_DECL (t2) = decl;
1015 TYPE_SIZE (t2) = 0;
1016
1017 return t2;
1018 }
最终，所构建的 BOUND_TEMPLATE_TEMPLATE_PARM 节点如下图所示。并且它被 lookup_template_class 返回。
（ 点此打开 ）
图 113 ： BOUND_TEMPLATE_TEMPLATE_PARM 节点
那么在 finish_template_type 及 cp_parser_template_id 中，通过该节点的 chain 域得到的 TYPE_DECL 被返回作为该 template-id 的代表。
接着该节点为 cp_parser_class_name 返回给 cp_parser_base_specifier 。相关代码参照章节 完成类名查找 。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
