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

5.12.3.2.1.2.1.2.


解析函数体


对于在
14368
行所见的，跟在“
)
”后面的关键字“
return
”，其解释参见章节
为方法构建节点

。

14356

static
tree

14357

cp_parser_function_definition_after_declarator

(cp_parser* parser,

in parser.c

14358

bool
inline_p)

14359

{

14360

tree fn;

14361

bool ctor_initializer_p =
false;

14362

bool
saved_in_unbraced_linkage_specification_p;

14363

unsigned
saved_num_template_parameter_lists;

14364

14365

/*
If the next token is `return', then the code may be trying to

14366

make
use of the "named return value" extension that G++ used to

14367

support.
*/

14368

if (cp_lexer_next_token_is_keyword
(parser->lexer, RID_RETURN))

14369

{

14370

/*
Consume the `return' keyword.
*/

14371

cp_lexer_consume_token
(parser->lexer);

14372

/*
Look for the identifier that indicates what value is to be

14373

returned.
*/

14374

cp_parser_identifier
(parser);

14375

/*
Issue an error message.
*/

14376

error ("named return
values are no longer supported");

14377

/*
Skip tokens until we reach the start of the function body.
*/

14378

while
(cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)

14379

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

14380

cp_lexer_consume_token

(parser->lexer);

14381

}

14382

/*
The `extern' in `extern "C" void f () { ... }' does not apply to

14383

anything declared inside `f'.
*/

14384

saved_in_unbraced_linkage_specification_p

14385

=
parser->in_unbraced_linkage_specification_p;

14386

parser->in_unbraced_linkage_specification_p = false;

14387

/*
Inside the function, surrounding template-parameter-lists do not

14388

apply.
*/

14389

saved_num_template_parameter_lists

14390

=
parser->num_template_parameter_lists;

14391

parser->num_template_parameter_lists = 0;

14392

/*
If the next token is `try', then we are looking at a

14393

function-try-block.
*/

14394

if (cp_lexer_next_token_is_keyword
(parser->lexer, RID_TRY))

14395

ctor_initializer_p =
cp_parser_function_try_block (parser);

14396

/*
A function-try-block includes the function-body, so we only do

14397

this
next part if we're not processing a function-try-block.
*/

14398

else

14399

ctor_initializer_p

14400

= cp_parser_ctor_initializer_opt_and_function_body
(parser);

14401

14402

/*
Finish the function.
*/

14403

fn = finish_function
((ctor_initializer_p ? 1 : 0) |

14404

(inline_p ?
2 : 0));

14405

/*
Generate code for it, if necessary.
*/

14406

expand_or_defer_fn (fn);

14407

/*
Restore the saved values.
*/

14408

parser->in_unbraced_linkage_specification_p

14409

=
saved_in_unbraced_linkage_specification_p;

14410

parser->num_template_parameter_lists

14411

=
saved_num_template_parameter_lists;

14412

14413

return
fn;

14414

}

5.12.3.2.1.2.1.2.1.


准备阶段


虽然我们用作例子的方法包含了空的函数体，不过处理空函数体仍然包括了相当复杂的过程。

11469

static
bool

11470

cp_parser_ctor_initializer_opt_and_function_body

(cp_parser *parser)

in parser.c

11471

{

11472

tree body;

11473

bool ctor_initializer_p;

11474

11475

/*
Begin the function body.
*/

11476

body = begin_function_body
();

11477

/*
Parse the optional ctor-initializer.
*/

11478

ctor_initializer_p =
cp_parser_ctor_initializer_opt (parser);

11479

/*
Parse the function-body.
*/

11480

cp_parser_function_body
(parser);

11481

/*
Finish the function body.
*/

11482

finish_function_body
(body);

11483

11484

return
ctor_initializer_p;

11485

}

函数体本身是一个复合语句，它具有以下规则：

compound-statement:

{ statement-seq [opt] }

statement-seq
被一对大括号所包含，这对大括号构成了一个作用域来把这个
statement-seq
与外部分隔开来。因此在真正处理函数体前，它需要某些准备工作。

10756

tree

10757

begin_function_body

(void)

in decl.c

10758

{

10759

tree stmt;

10760

10761

if (processing_template_decl
)

10762

/*
Do nothing now.
*/;

10763

else

10764

/*
Always keep the BLOCK node associated with the outermost pair of

10765

curly braces of a function. These are needed for correct

10766

operation of dwarfout.c.
*/

10767

keep_next_level (true);

10768

10769

stmt = begin_compound_stmt
(/*has_no_scope=*/
false);

10770

COMPOUND_STMT_BODY_BLOCK
(stmt) = 1;

10771

10772

if (processing_template_decl
)

10773

/*
Do nothing now.
*/;

10774

else if (DECL_CONSTRUCTOR_P
(current_function_decl

))

10775

begin_constructor_body ();

10776

else if (DECL_DESTRUCTOR_P (current_function_decl

))

10777

begin_destructor_body ();

10778

10779

return
stmt;

10780

}

看到对于这次调用参数
has_no_scope

是
false
，它表示该复合语句定义了一个作用域。

998

tree

999

begin_compound_stmt

(bool has_no_scope)

in semantics.c

1000

{

1001

tree r;

1002

int is_try = 0;

1003

1004

r = build_stmt
(COMPOUND_STMT, NULL_TREE);

1005

1006

if (last_tree && TREE_CODE
(last_tree) == TRY_BLOCK)

1007

is_try = 1;

1008

1009

add_stmt
(r);

1010

if (has_no_scope)

1011

COMPOUND_STMT_NO_SCOPE (r)
= 1;

1012

1013

last_expr_type = NULL_TREE;

1014

1015

if (!has_no_scope)

1016

do_pushlevel
(is_try ? sk_try : sk_block);

1017

else

1018

/* Normally, we try hard to keep the BLOCK for
a

1019

statement-expression. But, if it's a statement-expression with

1020

a
scopeless block, there's nothing to keep, and we don't want

1021

to
accidentally keep a block *inside* the scopeless block.
*/

1022

keep_next_level (false);

1023

1024

return
r;

1025

}

在中间树里，大括号及中括号都不能出现。为了标记在该复合语句中的所有的语句，在语句链表的头部构建一个
COMPOUND_STMT
节点。在
84
行，在
begin_stmt_tree

中，
last_expr_filename

被更新为
input_filename

。而如果当前输入文件不是当前函数所在的文件，构建
FILE_STMT
节点来记录这个不同。

81

tree

82

add_stmt

(tree t)

in c-semantics.c

83

{

84

if (input_filename !=
last_expr_filename)

85

{

86

/* If the filename
has changed, also add in a FILE_STMT. Do a string

87

compare first, though, as it might be an
equivalent string.
*/

88

int add = (strcmp
(input_filename, last_expr_filename) != 0);

89

last_expr_filename =
input_filename;

90

if (add)

91

{

92

tree pos = build_nt
(FILE_STMT,
get_identifier

(input_filename));

93

add_stmt (pos);

94

}

95

}

96

97

/*
Add T to the statement-tree.
*/

98

TREE_CHAIN (last_tree) = t;

99

last_tree = t;

100

101

/*
When we expand a statement-tree, we must know whether or not the

102

statements are full-expressions. We record that fact here.
*/

103

STMT_IS_FULL_EXPR_P
(last_tree) = stmts_are_full_exprs_p
();

104

105

return
t;

106

}

注意到语句被加到语句链表的末尾，不过
FUNCTION_DECL
的
saved_tree

域仍旧指向该链表的末尾。如果当前语句是一个完整的表达式（即，在该语句中构建的临时对象，在语句的末尾被毁灭），函数
stmts_are_full_exprs_p

返回
true
。在
cxx_push_function_context

的
11299
行，设置了
stmts_are_full_exprs_p

域为
1
。

306

int

307

stmts_are_full_exprs_p

(void)

in semantics.c

308

{

309

return
current_stmt_tree
()->stmts_are_full_exprs_p;

310

}

那么如果该复合语句定义了一个作用域，将加入一个新的
sk_block
或
try_block
作用域。

364

void

365

do_pushlevel

(scope_kind sk)

in semantics.c

366

{

367

if (stmts_are_full_exprs_p
())

368

{

369

if (!processing_template_decl
)

370

add_scope_stmt
(/*begin_p=*/
1, /*partial_p=*/
0);

371

begin_scope

(sk, NULL);

372

}

373

}

如果不是一个模板声明，向语句链表插入一个
SCOPE_STMT
节点。参数
begin_p

表示该语句是否开启或结束一个作用域；对于一个部分作用域（即在一个标签（
label
）后开始的作用域，而该标签处构建了一个需要清除操作的对象），
partial_p

是
true
。在
C++
中，作用域可以被其他作用域完全包含，但不会彼此部分重叠。因此栈是适合记录作用域的，其中新的节点代表新的作用域。

131

tree

132

add_scope_stmt

(int begin_p, int partial_p)

in c-semantics.c

133

{

134

tree *stack_ptr = current_scope_stmt_stack
();

135

tree ss;

136

tree top = *stack_ptr;

137

138

/*
Build the statement.
*/

139

ss = build_stmt (SCOPE_STMT,
NULL_TREE);

140

SCOPE_BEGIN_P (ss) =
begin_p;

141

SCOPE_PARTIAL_P (ss) =
partial_p;

142

143

/*
Keep the scope stack up to date.
*/

144

if (begin_p)

145

{

146

top = tree_cons (ss,
NULL_TREE, top);

147

*stack_ptr = top;

148

}

149

else

150

{

151

if (partial_p !=
SCOPE_PARTIAL_P (TREE_PURPOSE (top)))

152

abort ();

153

TREE_VALUE (top) = ss;

154

*stack_ptr = TREE_CHAIN
(top);

155

}

156

157

/*
Add the new statement to the statement-tree.

*/

158

add_stmt
(ss);

159

160

return
top;

161

}

上面提及的
SCOPE_STMT
栈由
current_scope_stmt_stack

返回。

1199

tree *

1200

current_scope_stmt_stack

(void)

in c-semantics.c

1201

{

1202

return
&cfun

->language->base.x_scope_stmt_stack;

1203

}

在
151
行，
SCOPE_PARTIAL_P
表示部分作用域（
partial scope
），例如：

S s;

l:

S s2;

goto
l;

在‘
1
’后面是一个（隐含的）新的作用域，即便没有大括号。特别的，当我们执行
goto
，我们必须破坏
s2
然后再重新构建它。

那么在进行函数体解析前，以下的决定将被构建。这里我们忽略
last_tree

节点，因为它总是指向链表的末尾。

（
点此打开

）

图
94

：在解析函数体之前