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

5.12.3.2.1.1.2. 开始类定义
跟在class-head后，应该是符号“{”，那么在下面的11890行的函数cp_parser_check_type_definition 检查定义新的类型在当前上下文是否允许（通过检查parser的type_definition_forbidden_message是否为non-null）。

cp_parser_class_specifier (continue)

11882 /* Look for the `{'. */
11883 if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
11884 {
11885 pop_deferring_access_checks ();
11886 return error_mark_node;
11887 }
11888
11889 /* Issue an error message if type-definitions are forbidden here. */
11890 cp_parser_check_type_definition (parser);
11891 /* Remember that we are defining one more class. */
11892 ++parser->num_classes_being_defined;
11893 /* Inside the class, surrounding template-parameter-lists do not
11894 apply. */
11895 saved_num_template_parameter_lists
11896 = parser->num_template_parameter_lists;
11897 parser->num_template_parameter_lists = 0;
11898
11899 /* Start the class. */
11900 if (nested_name_specifier_p)
11901 {
11902 scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
11903 pop_p = push_scope (scope);
11904 }
11905 type = begin_class_definition (type);

一旦看到“{”符号，就需要为类准备上下文，并使其成为当前的上下文环境。

2011 tree
2012 begin_class_definition (tree t) in semantics.c
2013 {
2014 if (t == error_mark_node)
2015 return error_mark_node;
2016
2017 if (processing_template_parmlist)
2018 {
2019 error ("definition of `%#T' inside template parameter list", t);
2020 return error_mark_node;
2021 }
2022 /* A non-implicit typename comes from code like:
2023
2024 template <typename T> struct A {
2025 template <typename U> struct A<T>::B ...
2026
2027 This is erroneous. */
2028 else if (TREE_CODE (t) == TYPENAME_TYPE)
2029 {
2030 error ("invalid definition of qualified type `%T'", t);
2031 t = error_mark_node;
2032 }
2033
2034 if (t == error_mark_node || ! IS_AGGR_TYPE (t))
2035 {
2036 t = make_aggr_type (RECORD_TYPE);
2037 pushtag (make_anon_name (), t, 0);
2038 }
2039
2040 /* If this type was already complete, and we see another definition,
2041 that's an error. */
2042 if (COMPLETE_TYPE_P (t))
2043 {
2044 error ("redefinition of `%#T'", t);
2045 cp_error_at ("previous definition of `%#T'", t);
2046 return error_mark_node;
2047 }
2048
2049 /* Update the location of the decl. */
2050 DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
2051
2052 if (TYPE_BEING_DEFINED (t))
2053 {
2054 t = make_aggr_type (TREE_CODE (t));
2055 pushtag (TYPE_IDENTIFIER (t), t, 0);
2056 }
2057 maybe_process_partial_specialization (t);
2058 pushclass (t);

上面，TYPE_BEING_DEFINED如果非0，表示我们正在定义一个类型，对于我们的例子，这个标记将在不久后被设置，但现在这个域是0。
进一步的，如果声明的不是目标的偏特化，例程maybe_process_partial_specialization不做任何事情。那么对于我们在该函数内第一件有意义的事情，是调用pushclass来建立该类的上下文。
C++中的类是可以嵌套定义的，每个类都构成了一个自己的作用域。显而易见，这些打开的类构成了一个栈。在前端中，current_class_stack就是这样的栈。它由class_stack_node_t节点构成。

50 typedef struct class_stack_node { in class.c
51 /* The name of the class. */
52 tree name;
53
54 /* The _TYPE node for the class. */
55 tree type;
56
57 /* The access specifier pending for new declarations in the scope of
58 this class. */
59 tree access;
60
61 /* If were defining TYPE, the names used in this class. */
62 splay_tree names_used;
63 }* class_stack_node_t;

那么当进入pushclass时，首先把封闭类（enclosing class）压入栈中（虽然该类现为current_class_name所指向，它实际上已经是前一个类了，当前类是正在处理的这个），而变量currnet_class_depth则记录了栈的深度。

5452 void
5453 pushclass (tree type) in class.c
5454 {
5455 type = TYPE_MAIN_VARIANT (type);
5456
5457 /* Make sure there is enough room for the new entry on the stack. */
5458 if (current_class_depth + 1 >= current_class_stack_size)
5459 {
5460 current_class_stack_size *= 2;
5461 current_class_stack
5462 = xrealloc (current_class_stack,
5463 current_class_stack_size
5464 * sizeof (struct class_stack_node));
5465 }
5466
5467 /* Insert a new entry on the class stack. */
5468 current_class_stack[current_class_depth].name = current_class_name;
5469 current_class_stack[current_class_depth].type = current_class_type;
5470 current_class_stack[current_class_depth].access = current_access_specifier;
5471 current_class_stack[current_class_depth].names_used = 0;
5472 current_class_depth++;
5473
5474 /* Now set up the new type. */
5475 current_class_name = TYPE_NAME (type);
5476 if (TREE_CODE (current_class_name) == TYPE_DECL)
5477 current_class_name = DECL_NAME (current_class_name);
5478 current_class_type = type;
5479
5480 /* By default, things in classes are private, while things in
5481 structures or unions are public. */
5482 current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5483 ? access_private_node
5484 : access_public_node);
5485
5486 if (previous_class_type != NULL_TREE
5487 && (type != previous_class_type
5488 || !COMPLETE_TYPE_P (previous_class_type))
5489 && current_class_depth == 1)
5490 {
5491 /* Forcibly remove any old class remnants. */
5492 invalidate_class_lookup_cache ();
5493 }
5494
5495 /* If we're about to enter a nested class, clear
5496 IDENTIFIER_CLASS_VALUE for the enclosing classes. */
5497 if (current_class_depth > 1)
5498 clear_identifier_class_values ();

当前类的信息则保存在全局变量scope_chain里，部分相关宏的定义如下。

240 #define class_binding_level scope_chain->class_bindings in cp-tree.h
727 #define current_class_name scope_chain->class_name
738 #define current_access_specifier scope_chain->access_specifier
756 #define previous_class_type scope_chain->x_previous_class_type

如果current_class_depth是1，这表示我们进入类栈顶。previous_class_type，如果我们之前访问过类栈，则指向前一个位于栈顶的这个类，这在popclass中设置。同时previous_class_value保存了previous_class_type类中的项。如果当前类与previous_class_type相同，这些缓存的数据能大大加快类上下文环境建立的速度。而如果当前类与previous_class_type不相同，就没有必要保留这些数据了。

5548 void
5549 invalidate_class_lookup_cache (void) in class.c
5550 {
5551 tree t;
5552
5553 /* The IDENTIFIER_CLASS_VALUEs are no longer valid. */
5554 for (t = previous_class_values; t; t = TREE_CHAIN (t))
5555 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
5556
5557 previous_class_values = NULL_TREE;
5558 previous_class_type = NULL_TREE;
5559 }

如果current_class_depth大于1，意味着我们正深入类栈，对于这个情形，class_binding_level指向封闭类（enclosing class）。域class_shadowed用作绑定在该类域中标识符的缓存，这些标识符的IDENTIFIER_CLASS_VALUE域被设置为绑定时的值。因为我们马上就要更新class_binding_level，这些IDENTIFIER_CLASS_VALUE首先要被清零。

2713 void
2714 clear_identifier_class_values (void) in name-lookup.c
2715 {
2716 tree t;
2717
2718 if (!class_binding_level)
2719 return;
2720
2721 for (t = class_binding_level->class_shadowed;
2722 t;
2723 t = TREE_CHAIN (t))
2724 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
2725 }

随后通过pushlevel_class，我们使得当前正在定义的类的作用域成为当前作用域（即被current_binding_level及class_binding_level所指向。

pushclass (continue)

5500 pushlevel_class ();

在前端中，class_binding_level指向当前打开的最里层的类域，或者最近打开的类域（如果我们当前不在类域中）。因而我们将得到类似下图的中间树的布局，看到绑定域被创建，已准备好接收成员定义了。

2570 void
2571 pushlevel_class (void) in name-lookup.c
2572 {
2573 if (ENABLE_SCOPE_CHECKING)
2574 is_class_level = 1;
2575
2576 class_binding_level = begin_scope (sk_class, current_class_type);
2577 }

（点此打开）
图59：SingleThreaded作为当前作用域
因为对于我们的例子，previous_class_type是null，5502行的条件满足。块中的代码加入类的域，不过当前，该类还没有任何域，因此这些代码不作任何事（对于派生类，这些代码将加入代表基类的域）。

pushclass (continue)

5502 if (type != previous_class_type || current_class_depth > 1)
5503 {
5504 push_class_decls (type);
5505 if (CLASSTYPE_TEMPLATE_INFO (type) && !CLASSTYPE_USE_TEMPLATE (type))
5506 {
5507 /* If we are entering the scope of a template declaration (not a
5508 specialization), we need to push all the using decls with
5509 dependent scope too. */
5510 tree fields;
5511
5512 for (fields = TYPE_FIELDS (type);
5513 fields; fields = TREE_CHAIN (fields))
5514 if (TREE_CODE (fields) == USING_DECL && !TREE_TYPE (fields))
5515 pushdecl_class_level (fields);
5516 }
5517 }
…
5540 cxx_remember_type_decls (CLASSTYPE_NESTED_UTDS (type));
5541 }

在上面的5540行，在CLASSTYPE_NESTED_UTDS中的NESTED_UTDS表示嵌套的用户定义类型的意思。这个宏访问一个保存该类中所有嵌套的用户定义类型的绑定表。注意下面的current_binding_level返回的是cp_binding_level（也即是cxx_scope）对象，代表当前作用域。其type_decl项表示在该作用域中所声明的类型。当一个类成为当前作用域时，代表类的节点与代表作用域的节点要同步。

1542 void
1543 cxx_remember_type_decls (binding_table table) in name-lookup.c
1544 {
1545 current_binding_level->type_decls = table;
1546 }

然后，回到begin_class_definition，注意到2059行的TYPE_BEING_DEFINED，它表示类的定义尚未完整。

begin_class_definition (continue)

2059 TYPE_BEING_DEFINED (t) = 1;
2060 if (flag_pack_struct)
2061 {
2062 tree v;
2063 TYPE_PACKED (t) = 1;
2064 /* Even though the type is being defined for the first time
2065 here, there might have been a forward declaration, so there
2066 might be cv-qualified variants of T. */
2067 for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2068 TYPE_PACKED (v) = 1;
2069 }
2070 /* Reset the interface data, at the earliest possible
2071 moment, as it might have been set via a class foo;
2072 before. */
2073 if (! TYPE_ANONYMOUS_P (t))
2074 {
2075 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2076 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2077 (t, interface_unknown);
2078 }
2079 reset_specialization();
2080
2081 /* Make a declaration for this class in its own scope. */
2082 build_self_reference ();
2083
2084 return t;
2085 }