5.12.4.1.1.2.1.3. 在当前作用域查找
来到这里，没有指定作用域，该名字应该在当前作用域中来查找。这里的当前域可以是类域、名字空间、函数域、局部域（ FOR 循环、 WHILE 循环等）。
cp_parser_lookup_name (continue)
13832 else
13833 {
13834 decl = lookup_name_real (name, is_type, /*nonclass=*/ 0,
13835 is_namespace, flags);
13836 parser->qualifying_scope = NULL_TREE;
13837 parser->object_scope = NULL_TREE;
13838 }
注意参数 nonclass 的传入值是 0 ，这表示我们将要在类作用域中查找由参数 name 给出的名字；而 namespaces_only 则从 cp_parser_class_name 传入，其值来自 is_namespace 。
3912 tree
3913 lookup_name_real (tree name, int prefer_type, int nonclass, in name-lookup.c
3914 int namespaces_only, int flags)
3915 {
3916 cxx_binding *iter;
3917 tree val = NULL_TREE;
3918
3919 timevar_push (TV_NAME_LOOKUP);
3920 /* Conversion operators are handled specially because ordinary
3921 unqualified name lookup will not find template conversion
3922 operators. */
3923 if (IDENTIFIER_TYPENAME_P (name))
3924 {
3925 struct cp_binding_level *level;
3926
3927 for (level = current_binding_level ;
3928 level && level->kind != sk_namespace;
3929 level = level->level_chain)
3930 {
3931 tree class_type;
3932 tree operators;
3933
3934 /* A conversion operator can only be declared in a class
3935 scope. */
3936 if (level->kind != sk_class)
3937 continue ;
3938
3939 /* Lookup the conversion operator in the class. */
3940 class_type = level->this_entity;
3941 operators = lookup_fnfields (class_type, name, /*protect=*/ 0);
3942 if (operators)
3943 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3944 }
3945
3946 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3947 }
这里首先处理转换操作符。其原因，上面的注释已经解释了，因为模板形式的转换操作符不是普通的非限定名字查找的候选（还记得吗，模板，除非具现，不进行域绑定，因此普通的非限定名字查找找不出来）。
5.12.4.1.1.2.1.3.1. 转换操作符
在 3923 行，如果 name 命名了一个类型转换操作符， IDENTIFIER_TYPENAME_P 返回 true 。转换操作符必须在类中定义。因此查找局限在类中并且从最里层的类开始向外（看到 level_chain 域显示了嵌套类的封闭类（ enclosing class ），在嵌套类中找不到该名字就要沿着 level_chain 查找）。
1387 tree
1388 lookup_fnfields (tree xbasetype, tree name, int protect) in search.c
1389 {
1390 tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/ false);
1391
1392 /* Ignore non-functions. */
1393 if (rval && !BASELINK_P (rval))
1394 return NULL_TREE;
1395
1396 return rval;
1397 }
具体做法实际上与在指定类中查找一致。
如果名字不是转换操作符名，首先调用 lookup_flags 来设置为后面查找所使用的标记。
3562 static int
3563 lookup_flags (int prefer_type, int namespaces_only) in name-lookup.c
3564 {
3565 if (namespaces_only)
3566 return LOOKUP_PREFER_NAMESPACES;
3567 if (prefer_type > 1)
3568 return LOOKUP_PREFER_TYPES;
3569 if (prefer_type > 0)
3570 return LOOKUP_PREFER_BOTH;
3571 return 0;
3572 }
上面 LOOKUP_PREFER_NAMESPACES 表示不接受对象，结果可能是名字空间； LOOKUP_PREFER_TYPES 表示不接受对象，结果可能是类型； LOOKUP_PREFER_BOTH 表示结果应该是类或名字空间名。
lookup_name_real (continue)
3949 flags |= lookup_flags (prefer_type, namespaces_only);
3650
3951 /* First, look in non-namespace scopes. */
3952
3953 if (current_class_type == NULL_TREE)
3954 nonclass = 1;
3955
3956 for (iter = IDENTIFIER_BINDING (name); iter; iter = iter->previous)
3957 {
3958 tree binding;
3959
3960 if (!LOCAL_BINDING_P (iter) && nonclass)
3961 /* We're not looking for class-scoped bindings, so keep going. */
3962 continue ;
3963
3964 /* If this is the kind of thing we're looking for, we're done. */
3965 if (qualify_lookup (iter->value, flags))
3966 binding = iter->value;
3967 else if ((flags & LOOKUP_PREFER_TYPES)
3968 && qualify_lookup (iter->type, flags))
3969 binding = iter->type;
3970 else
3971 binding = NULL_TREE;
3972
3973 if (binding)
3974 {
3975 val = binding;
3976 break ;
3977 }
3978 }
节点 lang_identifier 的 binding 域指向一组非名字空间作用域，它是一个由 cxx_binding 节点构成的链表（参考图形： 内建类型的节点 作为例子）。 IDNEITIFIER_BINDING 访问这个 binding 域，并且通过每个节点的 previous 域来遍历整个链表。这个链表记录了该标识符声明目前已经出现的不同的作用域。而每个 cxx_binding 节点的 value 域记录了在该作用域中，该名字所绑定的非类型实体（通常是 TYPE_DECL 或 NAMESPACE_DECL ），而 type 域记录绑定的类型实体。
注意上面调用 qualify_lookup 的次序及参数；这个函数检查找到的是否就是目标。
3577 static tree
3578 qualify_lookup (tree val, int flags)
3579 {
3580 if (val == NULL_TREE)
3581 return val;
3582 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3583 return val;
3584 if ((flags & LOOKUP_PREFER_TYPES)
3585 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3586 return val;
3587 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3588 return NULL_TREE;
3589 return val;
3590 }
上面的 (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES) 就是 LOOKUP_PREFER_BOTH 的对于。注意如果 flags 是 0 ，它接受任何东西（没有过滤）。
lookup_name_real (continue)
3980 /* Now lookup in namespace scopes. */
3981 if (!val)
3982 {
3983 tree t = unqualified_namespace_lookup (name, flags);
3984 if (t)
3985 val = t;
3986 }
3987
3988 if (val)
3989 {
3990 /* If we have a single function from a using decl, pull it out. */
3991 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3992 val = OVL_FUNCTION (val);
3993 }
3994
3995 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3996 }
如果我们不能以这种快速的方式找到这个名字，该标识符一定被声明在某些名字空间或甚至是由 using 语句引入的名字空间里。我们不得不逐个查找这些名字空间。
3706 static tree
3707 unqualified_namespace_lookup (tree name, int flags) in name-lookup.c
3708 {
3709 tree initial = current_decl_namespace ();
3710 tree scope = initial;
3711 tree siter;
3712 struct cp_binding_level *level;
3713 tree val = NULL_TREE;
3714 cxx_binding binding;
3715
3716 timevar_push (TV_NAME_LOOKUP);
3717 cxx_binding_clear (&binding);
首先， current_decl_namespace 帮助找出最里层的封闭名字空间（ enclosing namespace ）。在下面，如果 decl_namespace_list 不是 NULL ，它保存所有封闭名字空间，越接近头部的封闭名字空间越靠近里层，因此最里面的名字空间在头部获得。
3039 tree
3040 current_decl_namespace (void) in name-lookup.c
3041 {
3042 tree result;
3043 /* If we have been pushed into a different namespace, use it. */
3044 if (decl_namespace_list )
3045 return TREE_PURPOSE (decl_namespace_list );
3046
3047 if (current_class_type )
3048 result = decl_namespace_context (current_class_type );
3049 else if (current_function_decl )
3050 result = decl_namespace_context (current_function_decl );
3051 else
3052 result = current_namespace ;
3053 return result;
3054 }
否则， decl_namespace_context 将不停进入上下文直到找到名字空间作用域。注意到名字空间总是可以找出来的，因为最顶层总是 global_namespace ，对于这个作用域将返回 NULL_TREE 。
1426 tree
1427 decl_namespace_context (tree decl) in tree.c
1428 {
1429 while (1)
1430 {
1431 if (TREE_CODE (decl) == NAMESPACE_DECL)
1432 return decl;
1433 else if (TYPE_P (decl))
1434 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1435 else
1436 decl = CP_DECL_CONTEXT (decl);
1437 }
1438 }
假定现在我们有以下的定义：
namespace C {
namespace B {
void func1() { … } // block scope A
void func2 () { // block scope D
using namespace Y;
using namespace X;
W w;
}
}
}
编译器准备查找 W 的定义。上面的作用域的层次结构如下图所示：
图 100 ： unqualified_namespace_lookup 的例子
对于这些语句， current_decl_namespace 将返回 B 的 NAMESPACE_DECL 作为结果。然后在 3719 行外层的 FOR 循环，函数将沿着层次结构访问名字空间，直到到达全局名字空间，如果一直没有找到定义的话。
unqualified_namespace_lookup (continue)
3719 for (; !val; scope = CP_DECL_CONTEXT (scope))
3720 {
3721 cxx_binding *b =
3722 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3723
3724 if (b)
3725 {
3726 if (b->value && DECL_P (b->value)
3727 && DECL_LANG_SPECIFIC (b->value)
3728 && DECL_ANTICIPATED (b->value))
3729 /* Ignore anticipated built-in functions. */
3730 ;
3731 else
3732 binding.value = b->value;
3733 binding.type = b->type;
3734 }
3735
3736 /* Add all _DECLs seen through local using-directives. */
3737 for (level = current_binding_level ;
3738 level->kind != sk_namespace;
3739 level = level->level_chain)
3740 if (!lookup_using_namespace (name, &binding, level->using_directives,
3741 scope, flags))
3742 /* Give up because of error. */
3743 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
而在 3737 行的内层的 FOR 循环， current_binding_level 将返回 D 的 cxx_scope （如果它是一个类域，因为 using 指示在类域是不被允许的， lookup_using_namespace 将立即返回）。因为在这些非名字空间作用域（类域除外）中，亦可以使用 using 指示来引入名字空间，使其在该域中可见，显然，这也是可见集的一部分，需要在其中查找，并进行二义性检查。
3809 static bool
3810 lookup_using_namespace (tree name, cxx_binding *val, tree usings, in name-lookup.c
3811 tree scope, int flags)
3812 {
3813 tree iter;
3814 timevar_push (TV_NAME_LOOKUP);
3815 /* Iterate over all used namespaces in current, searching for using
3816 directives of scope. */
3817 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3818 if (TREE_VALUE (iter) == scope)
3819 {
3820 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3821 cxx_binding *val1 =
3822 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3823 /* Resolve ambiguities. */
3824 if (val1)
3825 val = ambiguous_decl (name, val, val1, flags);
3826 }
3827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3828 }
为了理解 lookup_using_namespace 的行为，假定名字空间 X 被封闭在名字空间 B 中，并且在名字空间 X 有指示“ using namespace Z ”；而名字空间 Y 则被封闭在名字空间 C 中：
图 101 ： using_directives 的例子
那么在作用域 D 的 cxx_scope 节点的 using_directives 域的链表中应该有 3 个节点（注意上面的链表反序了，不过这里的次序没有关系）。第一个节点是“ using namespace X ”加入的；第二个节点是由名字空间 X 里的“ using namespace Z ”加入的；第三个则是“ using namespace Y ”加入的。对于每个节点，其 value 域是被引入名字空间的上下文与作用域 D 的上下文的公共祖先， purpose 域则是引入的名字空间。
注意 lookup_using_namespace 的 3818 行，一开始 scope 是作用域 D 的最里层封闭名字空间。这句条件语句严格维护了名字空间的层次性，避免了名字空间之间的穿越。否则例子中的“ using namespace Y ”将在名字空间 B 中引入名字空间 Y ，这是不可以的。但是如果在名字空间 B 中没有找到， scope 将上升一级，指向名字空间 C ，这时“ using namespace X ”及间接的“ using namespace Z ”已经处理过，它们亦被 3818 行过滤掉；而“ using namespace Y ”这次得到处理。
unqualified_namespace_lookup (continue)
3745 /* Add all _DECLs seen through global using-directives. */
3746 /* XXX local and global using lists should work equally. */
3747 siter = initial;
3748 while (1)
3749 {
3750 if (!lookup_using_namespace (name, &binding,
3751 DECL_NAMESPACE_USING (siter),
3752 scope, flags))
3753 /* Give up because of error. */
3754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3755 if (siter == scope) break ;
3756 siter = CP_DECL_CONTEXT (siter);
3757 }
3758
3759 val = select_decl (&binding, flags);
3760 if (scope == global_namespace )
3761 break ;
3762 }
3763 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3764 }
在 3747 行， initial 就是最开始的封闭名字空间。而 DECL_NAMESPACE_USING 则是名字空间节点，用来记录其中的 using 指示所引入的名字空间，的链表。其结构与上面看到的 using_directive 相似。 lookup_using_namespace 依然坚定地维护着名字空间的层次，并忠实地查找名字。对于找到的结果， select_decl 从中选择最合适的实体。
3765 static tree
3766 select_decl (cxx_binding *binding, int flags) in name-lookup.c
3767 {
3768 tree val;
3769 val = binding->value;
3770
3771 timevar_push (TV_NAME_LOOKUP);
3772 if (LOOKUP_NAMESPACES_ONLY (flags))
3773 {
3774 /* We are not interested in types. */
3775 if (val && TREE_CODE (val) == NAMESPACE_DECL)
3776 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3777 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3778 }
3779
3780 /* If looking for a type, or if there is no non-type binding, select
3781 the value binding. */
3782 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3783 val = binding->type;
3784 /* Don't return non-types if we really prefer types. */
3785 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
3786 && (TREE_CODE (val) != TEMPLATE_DECL
3787 || !DECL_CLASS_TEMPLATE_P (val)))
3788 val = NULL_TREE;
3789
3790 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3791 }
看到如果找到的对象不合适， select_decl 将返回 NULL ，但是不会清除 binding ，因此在下一次循环时，如果找到新的定义，可以进行二义性检查。而如果返回了有效的 val ，我们将一直返回到 cp_parser_lookup_name 。
cp_parser_lookup_name (continue)
13840 /* If the lookup failed, let our caller know. */
13841 if (!decl
13842 || decl == error_mark_node
13843 || (TREE_CODE (decl) == FUNCTION_DECL
13844 && DECL_ANTICIPATED (decl)))
13845 return error_mark_node;
13846
13847 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
13848 if (TREE_CODE (decl) == TREE_LIST)
13849 {
13850 /* The error message we have to print is too complicated for
13851 cp_parser_error, so we incorporate its actions directly. */
13852 if (!cp_parser_simulate_error (parser))
13853 {
13854 error ("reference to `%D' is ambiguous", name);
13855 print_candidates (decl);
13856 }
13857 return error_mark_node;
13858 }
13859
13860 my_friendly_assert (DECL_P (decl)
13861 || TREE_CODE (decl) == OVERLOAD
13862 || TREE_CODE (decl) == SCOPE_REF
13863 || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
13864 || BASELINK_P (decl),
13865 20000619);
13866
13867 /* If we have resolved the name of a member declaration, check to
13868 see if the declaration is accessible. When the name resolves to
13869 set of overloaded functions, accessibility is checked when
13870 overload resolution is done.
13871
13872 During an explicit instantiation, access is not checked at all,
13873 as per [temp.explicit]. */
13874 if (DECL_P (decl))
13875 check_accessibility_of_qualified_id (decl, object_type, parser->scope);
13876
13877 return decl;
13878 }
记得对于重载函数，返回的节点是 OVERLOAD 类型的，而不是 TREE_LIST ——这个形式意味着出现了二义性（虽然从这里的调用路径来看，二义性应该在进入回到函数前就被发现了）。
如果找到的名字是有效的，这个时候要检查其可访问性。
1311 void
1312 check_accessibility_of_qualified_id (tree decl, in semantics.c
1313 tree object_type,
1314 tree nested_name_specifier)
1315 {
1316 tree scope;
1317 tree qualifying_type = NULL_TREE;
1318
1319 /* Determine the SCOPE of DECL. */
1320 scope = context_for_name_lookup (decl);
首先，我们要找出封闭这个名字的上下文。看到匿名 union 的定义是个例外，其成员被认为定义在该 union 所声明的作用域中。
600 tree
601 context_for_name_lookup (tree decl)
602 {
603 /* [class.union]
604
605 For the purposes of name lookup, after the anonymous union
606 definition, the members of the anonymous union are considered to
607 have been defined in the scope in which the anonymous union is
608 declared. */
609 tree context = DECL_CONTEXT (decl);
610
611 while (context && TYPE_P (context) && ANON_AGGR_TYPE_P (context))
612 context = TYPE_CONTEXT (context);
613 if (!context)
614 context = global_namespace ;
615
616 return context;
617 }
注意对于 NAMESPACE_DECL ， TYPE_P 返回 false 。同时，对于名字空间，它永远是可访问的。
check_accessibility_of_qualified_id (continue)
1321 /* If the SCOPE is not a type, then DECL is not a member. */
1322 if (!TYPE_P (scope))
1323 return ;
1324 /* Compute the scope through which DECL is being accessed. */
1325 if (object_type
1326 /* OBJECT_TYPE might not be a class type; consider:
1327
1328 class A { typedef int I; };
1329 I *p;
1330 p->A::I::~I();
1331
1332 In this case, we will have "A::I" as the DECL, but "I" as the
1333 OBJECT_TYPE. */
1334 && CLASS_TYPE_P (object_type)
1335 && DERIVED_FROM_P (scope, object_type))
1336 /* If we are processing a `->' or `.' expression, use the type of the
1337 left-hand side. */
1338 qualifying_type = object_type;
1339 else if (nested_name_specifier)
1340 {
1341 /* If the reference is to a non-static member of the
1342 current class, treat it as if it were referenced through
1343 `this'. */
1344 if (DECL_NONSTATIC_MEMBER_P (decl)
1345 && current_class_ptr
1346 && DERIVED_FROM_P (scope, current_class_type ))
1347 qualifying_type = current_class_type ;
1348 /* Otherwise, use the type indicated by the
1349 nested-name-specifier. */
1350 else
1351 qualifying_type = nested_name_specifier;
1352 }
1353 else
1354 /* Otherwise, the name must be from the current class or one of
1355 its bases. */
1356 qualifying_type = currently_open_derived_class (scope);
1357
1358 if (qualifying_type)
1359 perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl);
1360 }
上面如果参数 decl 被命名为‘ A::B ’，那么参数 nested_name_specifier 是‘ A ’。显然，如果 object_type 或 nested_name_specifier 不是 NULL ，访问性检查应该根据该类型来进行。看到如果 object_type 不是类类型， qualifying_type 将保持为 NULL 。而如果这 2 个变量都是 NULL ，封闭域应该是当前打开的类的其中之一。它由 currently_open_derived_class 来确定。
5599 tree
5600 currently_open_derived_class (tree t) in class.c
5601 {
5602 int i;
5603
5604 /* The bases of a dependent type are unknown. */
5605 if (dependent_type_p (t))
5606 return NULL_TREE;
5607
5608 if (!current_class_type )
5609 return NULL_TREE;
5610
5611 if (DERIVED_FROM_P (t, current_class_type ))
5612 return current_class_type ;
5613
5614 for (i = current_class_depth - 1; i > 0; --i)
5615 if (DERIVED_FROM_P (t, current_class_stack [i].type))
5616 return current_class_stack [i].type;
5617
5618 return NULL_TREE;
5619 }
一旦封闭类型找到，对该声明的访问性检查由 perform_or_defer_access_check 执行。该声明被 cp_parser_lookup_name 返回。
5.12.4.1.1.2.2. 查找的结果
在经过名字查找，在这一点上，解析得到的参数及参数列表如图所示。
（ 点此打开 ）
图 102 ：构建的参数及参数列表
939
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
