GCC-3.4.6源代码学习笔记（126）

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

。相关代码参照章节
完成类名查找

。