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

5.12.5.

第三个例子

现在我们已经有了“
SmallObject
”的定义，那么我们使用下面的“
main
”函数来使用这个类，从中看一下将会产生怎样的中间树。

using
namespace Loki;

int main ()

{

SmallObject<>
object_;

return
1;

}

5.12.5.1.

using
指示

假定这个“
main
”函数在另一个源文件中，它也构成一个编译单元，因此解析器由以下调用开始，
cp_parser_translation_unit

à

cp_parser_declaration_seq_opt

，其中的
WHILE
循环将依次处理语句。

对于第一个是
using
指示的语句，调用栈进一步延伸，从
cp_parser_declaration

à

cp_parser_block_declaration

à

cp_parser_using_directive

à

parse_using_directive

à

do_using_directive

。

3350

void

3351

do_using_directive

(tree namespace)

in name-lookup.c

3352

{

3353

if (namespace == error_mark_node)

3354

return
;

3355

3356

my_friendly_assert (TREE_CODE (namespace) ==
NAMESPACE_DECL, 20050830);

3357

3358

if (building_stmt_tree ())

3359

add_stmt (build_stmt (USING_STMT,
namespace));

3360

namespace =
ORIGINAL_NAMESPACE

(namespace);

3361

3362

if (!toplevel_bindings_p ())

3363

push_using_directive (namespace);

3364

else

3365

/* direct usage */

3366

add_using_namespace
(
current_namespace

,
namespace, 0);

3367

}

如果
building_stmt_tree

是非
0
值，表示正在为函数、块等结构产生语句，那么
using
指示将有
USING_STMT
为之生成。这里的实参
namespace

是相应的
NAMESPACE_DECL
。在
3362
行，如果最里层的有效非类作用域是一个名字空间（
using
指示不允许在类域中使用，但可以用在其方法作用域中），
toplevel_bindings_p

返回非
0
值。例如：

namespace
A {

int i;

}

class
B {

int func() {

using
namespace A;

return
i;

}

};

对于用在名字空间域的那些
using
指示，在对应于该名字空间作用域的
NAMESPACE_DECL
节点中，域
DECL_NAMESPACE_USING
将是一个
tree_list
，通过
add_using_namespace

用来把这些
using
指示串接起来。

3275

static
void

3276

add_using_namespace

(tree user, tree
used, bool indirect)

in name-lookup.c

3277

{

3278

tree t;

3279

timevar_push (TV_NAME_LOOKUP);

3280

/* Using oneself is
a no-op.
*/

3281

if (user == used)

3282

{

3283

timevar_pop (TV_NAME_LOOKUP);

3284

return
;

3285

}

3286

my_friendly_assert (TREE_CODE (user) ==
NAMESPACE_DECL, 380);

3287

my_friendly_assert (TREE_CODE (used) ==
NAMESPACE_DECL, 380);

3288

/* Check if we
already have this.
*/

3290

t = purpose_member (used,
DECL_NAMESPACE_USING (user));

3291

if (t != NULL_TREE)

3292

{

3293

if (!indirect)

3294

/* Promote to
direct usage.
*/

3295

TREE_INDIRECT_USING (t) = 0;

3296

timevar_pop (TV_NAME_LOOKUP);

3297

return
;

3298

}

3299

3300

/* Add used to the
user's using list.
*/

3301

DECL_NAMESPACE_USING (user)

3302

= tree_cons
(used,
namespace_ancestor
(user, used),

3303

DECL_NAMESPACE_USING (user));

3304

3305

TREE_INDIRECT_USING (DECL_NAMESPACE_USING
(user)) = indirect;

3306

3307

/* Add user to the
used's users list.
*/

3308

DECL_NAMESPACE_USERS (used)

3309

= tree_cons
(user,
0, DECL_NAMESPACE_USERS (used));

3310

3311

/* Recursively add
all namespaces used.
*/

3312

for
(t =
DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))

3313

/* indirect usage
*/

3314

add_using_namespace
(user, TREE_PURPOSE (t), 1);

3315

3316

/* Tell everyone
using us about the new used namespaces.

*/

3317

for
(t =
DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))

3318

add_using_namespace
(TREE_PURPOSE (t), used, 1);

3319

timevar_pop (TV_NAME_LOOKUP);

3320

}

在
5.12.4.1.1.2.1.3.2.
其他名字

一节中，我们看到
using
指示的使用必须不能混淆名字空间的层次，在名字查找时，前端将严格按照其层次进行搜寻。
add_using_namespace

需要记录必要的层次信息。这里
namespace_ancestor

找出
ns1
及
ns2
最接近的公共祖先。看到所有的名字空间都有相同的公共祖先——全局名字空间。（关于
add_using_namespace

生成的这个列表的使用，参考
lookup_using_namespace

）。

3194

static
tree

3195

namespace_ancestor

(tree ns1, tree ns2)

in name-lookup.c

3196

{

3197

timevar_push (TV_NAME_LOOKUP);

3198

if (is_ancestor
(ns1, ns2))

3199

POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
ns1);

3200

POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,

3201

namespace_ancestor
(CP_DECL_CONTEXT (ns1),
ns2));

3202

}

这里参数
root

是当前名字空间，而
child

是由
using
指示指定的名字空间。那么
is_ancestor

持续地从
child

开始获取上下文，直到找到
root

或离开这棵树。对于前一种情形，
root

是
child

的祖先，并且函数返回非
0
值；反之，函数返回
0
。

2502

bool

2503

is_ancestor

(tree root, tree child)

in name-lookup.c

2504

{

2505

my_friendly_assert ((TREE_CODE (root) ==
NAMESPACE_DECL

2506

|| TREE_CODE (root) ==
FUNCTION_DECL

2507

|| CLASS_TYPE_P (root)),
20030307);

2508

my_friendly_assert ((TREE_CODE (child) ==
NAMESPACE_DECL

2509

|| CLASS_TYPE_P (child)),

2510

20030307);

2511

2512

/* The global
namespace encloses everything.
*/

2513

if (root == global_namespace

)

2514

return
true;

2515

2516

while
(true)

2517

{

2518

/* If we've run
out of scopes, stop.
*/

2519

if (!child)

2520

return
false;

2521

/* If we've
reached the ROOT, it encloses CHILD.
*/

2522

if (root == child)

2523

return
true;

2524

/* Go out one level.
*/

2525

if (TYPE_P (child))

2526

child = TYPE_NAME (child);

2527

child = DECL_CONTEXT (child);

2528

}

2529

}

那么对于我们的例子，全局名字空间在其
DECL_NAMESPACE_USERS
域串接了“
Loki
”。

5.12.5.2.

Main()
的定义

5.12.5.2.1.

函数定义
–
声明符部分

对于
main
函数，
cp_parser_declaration

又一次调用
cp_parser_block_declaration

à

cp_parser_simple_declaration

。在我们的上下文中，参数
function_definition_allowed_p

是
true
，这表示我们同时把一个函数定义（
function-definition
）识别作简单声明（
simple-declaration
）。

block-declaration
的语法如下：

block-declaration:

simple-declaration | asm-definition |
namespace-alias-definition | using-declaration |

using-directive

GNU
Extension:

block-declaration: __extension__

block-declaration |
label-declaration

6370

static
void

6371

cp_parser_block_declaration

(cp_parser
*parser,

in parser.c

6372

bool

statement_p)

6373

{

6374

cp_token *token1;

6375

int saved_pedantic;

6376

6377

/* Check for the
`__extension__' keyword.
*/

6378

if (cp_parser_extension_opt (parser,
&saved_pedantic))

6379

{

…

6386

}

6387

6388

/* Peek at the next
token to figure out which kind of declaration is

6389

present.
*/

6390

token1 = cp_lexer_peek_token
(parser->lexer);

6391

6392

/* If the next
keyword is `asm', we have an asm-definition.

*/

6393

if (token1->keyword == RID_ASM)

6394

{

…

6398

}

6399

/* If the next
keyword is `namespace', we have a

6400

namespace-alias-definition.
*/

6401

else if (token1->keyword == RID_NAMESPACE)

6402

cp_parser_namespace_alias_definition
(parser);

6403

/* If the next
keyword is `using', we have either a

6404

using-declaration or a
using-directive.
*/

6405

else if (token1->keyword == RID_USING)

6406

{

…

6419

}

6420

/* If the next
keyword is `__label__' we have a label declaration.
*/

6421

else if (token1->keyword == RID_LABEL)

6422

{

…

6426

}

6427

/* Anything else must
be a simple-declaration.
*/

6428

else

6429

cp_parser_simple_declaration
(parser, !statement_p);

6430

}

simple-declaration
的语法是：

simple-declaration:

decl-specifier-seq [opt] init-declarator-list
[opt] ;

init-declarator-list:

init-declarator | init-declarator-list ,
init-declarator

看到
simple-declaration
可能被包含在一个
block-declaraition
中，而该
block-declaraition
则可能在一个函数域或类方法域中，其中要求访问控制，因此期望一个新的延迟访问实例。而在
6475
行的
stop_deferring_access_checks

防止加入更多由
perform_or_defer_access_check

检查的延迟访问控制，不过对于
decl-specifier-seq
及
init-declarator-list
访问检查都是需要的，因此稍后将通过
resume_deferring_access_checks

重新开始检查。

6444

static
void

6445

cp_parser_simple_declaration

(cp_parser*
parser,

in parser.c

6446

bool function_definition_allowed_p)

6447

{

6448

tree decl_specifiers;

6449

tree attributes;

6450

int declares_class_or_enum;

6451

bool saw_declarator;

6452

6453

/* Defer access
checks until we know what is being declared; the

6454

checks for names appearing in
the decl-specifier-seq should be

6455

done as if we were in the
scope of the thing being declared.
*/

6456

push_deferring_access_checks
(dk_deferred);

6457

6458

/* Parse the
decl-specifier-seq. We have to keep track of whether

6459

or not the decl-specifier-seq
declares a named class or

6460

enumeration type, since that
is the only case in which the

6461

init-declarator-list is
allowed to be empty.

6462

6463

[dcl.dcl]

6464

6465

I
n a simple-declaration, the optional
init-declarator-list can be

6466

omitted only when declaring a
class or enumeration, that is when

6467

the decl-specifier-seq
contains either a class-specifier, an

6468

elaborated-type-specifier, or
an enum-specifier.

*/

6469

decl_specifiers

6470

= cp_parser_decl_specifier_seq (parser,

6471

CP_PARSER_FLAGS_OPTIONAL,

6472

&attributes,

6473

&declares_class_or_enum);

6474

/* We no longer
need to defer access checks.
*/

6475

stop_deferring_access_checks ();

6476

6477

/* In a block
scope, a valid declaration must always have a

6478

decl-specifier-seq. By not
trying to parse declarators, we can

6479

resolve the
declaration/expression ambiguity more quickly.

*/

6480

if (!function_definition_allowed_p &&
!decl_specifiers)

6481

{

6482

cp_parser_error (parser, "expected
declaration");

6483

goto
done;

6484

}

6485

6486

/* If the next two
tokens are both identifiers, the code is

6487

erroneous. The usual cause of
this situation is code like:

6488

6489

T t;

6490

6491

where "T" should
name a type -- but does not.
*/

6492

if (cp_parser_diagnose_invalid_type_name
(parser))

6493

{

6494

/* If parsing
tentatively, we should commit; we really are

6495

looking at a
declaration.
*/

6496

cp_parser_commit_to_tentative_parse
(parser);

6497

/* Give up.
*/

6498

goto
done;

6499

}

我们前面已经看到，
cp_parser_decl_specifier_seq

将解析函数的返回类型；那么在这里
decl_specifiers

是一个
tree_list
，其中的
TREE_VALUE
域指向
integer_type_node

节点。注意一个函数定义可能没有返回类型（它默认为
int
）。

1950

static
bool

1951

cp_parser_diagnose_invalid_type_name

(cp_parser *parser)

in parser.c

1952

{

1953

/* If the next two
tokens are both identifiers, the code is

1954

erroneous. The usual cause of
this situation is code like:

1955

1956

T t;

1957

1958

where "T" should
name a type -- but does not.
*/

1959

if (cp_lexer_next_token_is
(parser->lexer, CPP_NAME)

1960

&& cp_lexer_peek_nth_token
(parser->lexer, 2)->type
== CPP_NAME)

1961

{

1962

tree name;

1963

1964

/* If parsing
tentatively, we should commit; we really are

1965

looking at a
declaration.
*/

1966

/* Consume the first
identifier.
*/

1967

name = cp_lexer_consume_token
(parser->lexer)->value;

1968

/* Issue an error
message.
*/

1969

error ("`%s' does not name a
type", IDENTIFIER_POINTER (name));

1970

/* If we're in a
template class, it's possible that the user was

1971

referring to a type from a
base class. For example:

1972

1973

template <typename T>
struct A { typedef T X; };

1974

template <typename T>
struct B : public A<T> { X x; };

1975

1976

The user should have said
"typename A<T>::X".
*/

1977

if (processing_template_decl
&& current_class_type

)

1978

{

1979

tree b;

1980

1981

for
(b =
TREE_CHAIN (TYPE_BINFO (current_class_type

));

1982

b;

1983

b = TREE_CHAIN (b))

1984

{

1985

tree base_type = BINFO_TYPE (b);

1986

if (CLASS_TYPE_P (base_type)

1987

&& dependent_type_p
(base_type))

1988

{

1989

tree field;

1990

/* Go from
a particular instantiation of the

1991

template (which will
have an empty TYPE_FIELDs),

1992

to the main
version.
*/

1993

base_type =
CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);

1994

for
(field = TYPE_FIELDS (base_type);

1995

field;

1996

field = TREE_CHAIN (field))

1997

if (TREE_CODE (field) == TYPE_DECL

1998

&& DECL_NAME (field) ==
name)

1999

{

2000

error ("(perhaps `typename
%T::%s' was intended)",

2001

BINFO_TYPE (b),
IDENTIFIER_POINTER (name));

2002

break
;

2003

}

2004

if (field)

2005

break
;

2006

}

2007

}

2008

}

2009

/* Skip to the end
of the declaration; there's no point in

2010

trying to process it.
*/

2011

cp_parser_skip_to_end_of_statement
(parser);

2012

2013

return
true;

2014

}

2015

2016

return
false;

2017

}

作为正确的形式，
decl-specifier-seq
的核心部分应该命名一个类型。通过名字查找规则找到的该类型将被返回给
decl-specifiers

；而如果没有找到适合的类型，这个符号保持为标识符，那么
cp_parser_diagnose_invalid_type_name

诊断这个错误情况，并给出诊断消息。

cp_parser_simple_declaration
(continue)

6501

/* If we have seen
at least one decl-specifier, and the next token

6502

is not a parenthesis, then we
must be looking at a declaration.

6503

(After "int (" we
might be looking at a functional cast.)

*/

6504

if (decl_specifiers

6505

&& cp_lexer_next_token_is_not
(parser->lexer, CPP_OPEN_PAREN))

6506

cp_parser_commit_to_tentative_parse
(parser);

6507

6508

/* Keep going until
we hit the `;' at the end of the simple

6509

declaration.
*/

6510

saw_declarator = false;

6511

while
(cp_lexer_next_token_is_not (parser->lexer,

6512

CPP_SEMICOLON))

6513

{

6514

cp_token *token;

6515

bool function_definition_p;

6516

tree decl;

6517

6518

saw_declarator = true;

6519

/* Parse the
init-declarator.
*/

6520

decl = cp_parser_init_declarator
(parser, decl_specifiers, attributes,

6521

function_definition_allowed_p,

6522

/*member_p=*/
false,

6523

declares_class_or_enum,

6524

&function_definition_p);

6525

/* If an error
occurred while parsing tentatively, exit quickly.

6526

(That usually happens when
in the body of a function; each

6527

statement is treated as a
declaration-statement until proven

6528

otherwise.)
*/

6529

if (cp_parser_error_occurred (parser))

6530

goto
done;

6531

/* Handle
function definitions specially.
*/

6532

if (function_definition_p)

6533

{

6534

/* If the next
token is a `,', then we are probably

6535

processing something like:

6536

6537

void f() {}, *p;

6538

6539

which is erroneous.
*/

6540

if (cp_lexer_next_token_is
(parser->lexer, CPP_COMMA))

6541

error ("mixing declarations and
function-definitions is forbidden");

6542

/* Otherwise,
we're done with the list of declarators.

*/

6543

else

6544

{

6545

pop_deferring_access_checks ();

6546

return
;

6547

}

6548

}

…

6580

}

…

6593

/* Consume the
`;'.
*/

6594

cp_parser_require (parser, CPP_SEMICOLON,
"`;'");

6595

6596

done:

6597

pop_deferring_access_checks ();

6598

}

注意到参数
declares_class_or_enum

是
0
，因为该
type-specifier
不是
class-specifier
，
enum-specifier
，也不是
elaborated-type-specifier
。
init-declarator
的内容包括：

init-declarator:

declarator initializer [opt]

function-definition:

decl-specifier-seq [opt] declarator
ctor-initializer [opt] function-body

decl-specifier-seq [opt] declarator
function-try-block

GNU
Extension:

init-declarator:

declarator asm-specification [opt]
attributes [opt] initializer [opt]

function-definition:

__extension__

function-definition

注意
ctor-initializer
仅用于构造函数中。

9933

static
tree

9934

cp_parser_init_declarator

(cp_parser*
parser,

in parser.c

9935

tree decl_specifiers,

9936

tree prefix_attributes,

9937

bool
function_definition_allowed_p,

9938

bool member_p,

9939

int
declares_class_or_enum,

9940

bool*
function_definition_p)

9941

{

9942

cp_token *token;

9943

tree declarator;

9944

tree attributes;

9945

tree asm_specification;

9946

tree initializer;

9947

tree decl = NULL_TREE;

9948

tree scope;

9949

bool is_initialized;

9950

bool is_parenthesized_init;

9951

bool is_non_constant_init;

9952

int ctor_dtor_or_conv_p;

9953

bool friend_p;

9954

bool pop_p = false;

9955

9956

/* Assume that this
is not the declarator for a function

9957

definition.
*/

9958

if (function_definition_p)

9959

*function_definition_p = false;

9960

9961

/* Defer access
checks while parsing the declarator; we cannot know

9962

what names are accessible
until we know what is being

9963

declared.
*/

9964

resume_deferring_access_checks ();

9965

9966

/* Parse the declarator.
*/

9967

declarator

9968

= cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,

9969

&ctor_dtor_or_conv_p,

9970

/*parenthesized_p=*/
NULL,

9971

/*member_p=*/
false);

9972

/* Gather up the
deferred checks.
*/

9973

stop_deferring_access_checks ();

“
main ()
”部分是声明符，其中包括作为
declarator-id
的“
main
”，而“
()
”是参数列表。那么在
cp_parser_declarator

中，
cp_parser_direct_declarator

迭代其主
WHILE

循环
2
次。在第一次中调用：
cp_parser_declarator_id

à

cp_parser_id_expression

à

cp_parser_identifier

返回“
main
”的
IDENTIFIER_NODE
。第二次中调用：
cp_parser_parameter_declaration_clause

返回空参数列表对应的
void_list_node

。然后
make_call_declarator

把这个
declarator-id
及
parameter-list
组合成一个如下图的
CALL_EXPR
（它极像我们之前看到的类方法的解析）。