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

5.12.4.1.1.2.1.1.2.            在指定类中的查找

而如果指定的作用域是一个类，那么查找的就是除非静态数据成员以外的类成员。不过这里尚不检查是否有违反，这由外部调用它们的函数来检查（ build_offset_ref ）。

在一个指定的类作用域中的查找工作，具体由 lookup_member 来进行。在这个函数中，注意参数 want_type 如果是 true ，这表示我们应该仅返回 TYPE_DECL 节点；参数 xbasetype 指向类的类型节点；而参数 protect 传入为 0 ，表示不要进行访问控制检查，并且对于有二义性的查找，我们应该返回 NULL 。

 

1275 tree

1276 lookup_member (tree xbasetype, tree name, int protect, bool want_type)               in search.c

1277 {

1278    tree rval, rval_binfo = NULL_TREE;

1279    tree type = NULL_TREE, basetype_path = NULL_TREE;

1280    struct lookup_field_info lfi;

1281

1282    /* rval_binfo is the binfo associated with the found member, note,

1283      this can be set with useful information, even when rval is not

1284      set, because it must deal with ALL members, not just non-function

1285      members. It is used for ambiguity checking and the hidden

1286      checks. Whereas rval is only set if a proper (not hidden)

1287      non-function member is found.  */

1288

1289    const char *errstr = 0;

1290

1291    my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030624);

1292

1293    if (TREE_CODE (xbasetype) == TREE_VEC)

1294    {

1295      type = BINFO_TYPE (xbasetype);

1296      basetype_path = xbasetype;

1297    }

1298    else

1299    {

1300      my_friendly_assert(IS_AGGR_TYPE_CODE(TREE_CODE(xbasetype)), 20030624);

1301      type = xbasetype;

1302      basetype_path = TYPE_BINFO (type);

1303      my_friendly_assert (!BINFO_INHERITANCE_CHAIN (basetype_path), 980827);

1304    }

1305

1306    if (type == current_class_type && TYPE_BEING_DEFINED (type)

1307        && IDENTIFIER_CLASS_VALUE (name))

1308    {

1309      tree field = IDENTIFIER_CLASS_VALUE (name);

1310      if (! is_overloaded_fn (field)

1311          && ! (want_type && TREE_CODE (field) != TYPE_DECL))

1312        /* We're in the scope of this class, and the value has already

1313          been looked up. Just return the cached value.  */

1314        return field;

1315    }

 

参考图形 binfo间的关系 ，显然上面的 type 指向与 binfo 关联的 RECORD_TYPE 节点。对于 name ，如果在 1307 行的 IDENTIFIER_CLASS_VALUE 不是 NULL ， name 被声明在当前类中，并且 IDENTIFIER_CLASS_VALUE 是其对应的声明。

如果封闭类（ enclosing class ）正在定义中（一定是 current_class_type ），如果由 IDENTIFIER_CLASS_VALUE 返回的对象是函数声明，那么我们需要继续下面的处理，因为方法 / 函数是可以重载的，因此有可能我们找到的是前一个定义。除此之外，如果 TYPE_DECL 是期望的返回值，但找到域不是 TYPE_DECL ，我们也需要进行处理（这里考虑如下代码：

struct F {

    int innerType;

};

 

struct G: public F {

    typedef int innerType;  // we are parsing this field, IDENTIFIER_CLASS_VALUE      // (innerType) still points to F::innerType

};

域“ typedef int innerType ”需要被加入类定义，必须摒弃找到的“ int innerType ”；而对于代码：

struct F {

    typedef int innerType;

};

 

struct G: public F {

    void func(int innerType);       // we are parsing this field

};

我们只需返回 F 的 innerType ，编译器随后会发现这个错误。

如果我们不能从 IDENTIFIER_CLASS_VALUE 所支持的快速查找中获益（只要 type 不是正在定义中，就没有风险，因为 IDENTIFIER_CLASS_VALUE 这时保存了前一次找出的链接）。我们不得不用强硬的方法来进行查找。

 

1008 struct lookup_field_info {                                                                         in search.c

1009   /* The type in which we're looking.  */

1010   tree type;

1011   /* The name of the field for which we're looking.  */

1012   tree name;

1013   /* If non-NULL, the current result of the lookup.  */

1014   tree rval;

1015   /* The path to RVAL.  */

1016   tree rval_binfo;

1017   /* If non-NULL, the lookup was ambiguous, and this is a list of the

1018     candidates.  */

1019   tree ambiguous;

1020   /* If nonzero, we are looking for types, not data members.  */

1021   int want_type;

1022   /* If something went wrong, a message indicating what.  */

1023   const char *errstr;

1024 };

 

上面的结构体将被用来传递指引在被查找集中的查找过程的信息。并且它也将带回查找结果。

 

lookup_member (continue)

 

1317    complete_type (type);

1318

1319 #ifdef GATHER_STATISTICS

1320    n_calls_lookup_field ++;

1321 #endif /* GATHER_STATISTICS */

1322

1323    memset (&lfi, 0, sizeof (lfi));

1324    lfi.type = type;

1325    lfi.name = name;

1326    lfi.want_type = want_type;

1327    bfs_walk (basetype_path, &lookup_field_r , &lookup_field_queue_p , &lfi);

 

函数 bfs_walk 遍历由 basetype_path 支配的类层次结构。然后在这个宽度优先的前序遍历中，函数 lookup_field_r 为层次结构中的每个类所调用。如果这个函数返回非 NULL ，这个值被立即返回并且结束遍历。这意味着我们已经找到期望的东西，而且它在派生程度最高的子类中。

 

1607 static tree

1608 bfs_walk (tree binfo,                                                                                 in search.c

1609           tree (*fn) (tree, void *),

1610           tree (*qfn) (tree, int, void *),

1611           void *data)

1612 {

1613    tree rval = NULL_TREE;

1614

1615    tree bases_initial[BFS_WALK_INITIAL_QUEUE_SIZE];

1616    /* A circular queue of the base classes of BINFO. These will be

1617      built up in breadth-first order, except where QFN prunes the

1618      search.  */

1619    size_t head, tail;

1620    size_t base_buffer_size = BFS_WALK_INITIAL_QUEUE_SIZE;

1621    tree *base_buffer = bases_initial;

1622

1623    head = tail = 0;

1624    base_buffer[tail++] = binfo;

1625

1626    while (head != tail)

1627    {

1628      int n_bases, ix;

1629      tree binfo = base_buffer[head++];

1630      if (head == base_buffer_size)

1631        head = 0;

1632

1633      /* Is this the one we're looking for? If so, we're done.  */

1634      rval = fn (binfo, data);

1635      if (rval)

1636        goto done;

1637

1638      n_bases = BINFO_N_BASETYPES (binfo);

1639      for (ix = 0; ix != n_bases; ix++)

1640      {

1641        tree base_binfo;

1642     

1643        if (qfn)

1644          base_binfo = (*qfn) (binfo, ix, data);

1645        else

1646          base_binfo = BINFO_BASETYPE (binfo, ix);

1647     

1648        if (base_binfo)

1649        {

1650          base_buffer[tail++] = base_binfo;

1651          if (tail == base_buffer_size)

1652            tail = 0;

1653          if (tail == head)

1654          {

1655            tree *new_buffer = xmalloc (2 * base_buffer_size

1656                                    * sizeof (tree));

1657            memcpy (&new_buffer[0], &base_buffer[0],

1658                    tail * sizeof (tree));

1659            memcpy (&new_buffer[head + base_buffer_size],

1660                    &base_buffer[head],

1661                    (base_buffer_size - head) * sizeof (tree));

1662            if (base_buffer_size != BFS_WALK_INITIAL_QUEUE_SIZE)

1663              free (base_buffer);

1664            base_buffer = new_buffer;

1665            head += base_buffer_size;

1666            base_buffer_size *= 2;

1667          }

1668        }

1669      }

1670    }

1671

1672   done:

1673    if (base_buffer_size != BFS_WALK_INITIAL_QUEUE_SIZE)

1674      free (base_buffer);

1675    return rval;

1676 }

 

上面缓存 bases_initial 通过把树以前序展开入一个数组来辅助遍历。可以期望一个编译单元中的类层次结构树通常是相当简单的（ BFS_WALK_INITIAL_QUEUE_SIZE 为 10 ）。

在每次调用中，一个表示从当前访问子类到 basetype_path 的路径的 binfo 被传给 lookup_field_r 。而 lookup_field_queue_p 为 lookup_field_r 选出合格的对象。

 

1136 static tree

1137 lookup_field_r (tree binfo, void *data)                                                        in search.c

1138 {

1139    struct lookup_field_info *lfi = (struct lookup_field_info *) data;

1140    tree type = BINFO_TYPE (binfo);

1141    tree nval = NULL_TREE;

1142

1143    /* First, look for a function. There can't be a function and a data

1144      member with the same name, and if there's a function and a type

1145      with the same name, the type is hidden by the function.  */

1146    if (!lfi->want_type)

1147    {

1148      int idx = lookup_fnfields_1 (type, lfi->name);

1149      if (idx >= 0)

1150        nval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), idx);

1151    }

1152

1153    if (!nval)

1154      /* Look for a data member or type.  */

1155      nval = lookup_field_1 (type, lfi->name, lfi->want_type);

1156

1157    /* If there is no declaration with the indicated name in this type,

1158      then there's nothing to do.  */

1159    if (!nval)

1160      return NULL_TREE;

 

在类的节点中，其方法被记录在一个向量（ vector 中）； lookup_fnfields_1 返回由 name 所指定方法所对应的索引。下面的 CLASSTYPE_METHOD_VEC 就是这个向量。

 

1458 int

1459 lookup_fnfields_1 (tree type, tree name)                                                      in search.c

1460 {

1461    tree method_vec;

1462    tree *methods;

1463    tree tmp;

1464    int i;

1465    int len;

1466

1467    if (!CLASS_TYPE_P (type))

1468      return -1;

1469

1470    method_vec = CLASSTYPE_METHOD_VEC (type);

1471

1472    if (!method_vec)

1473      return -1;

1474

1475    methods = &TREE_VEC_ELT (method_vec, 0);

1476    len = TREE_VEC_LENGTH (method_vec);

1477

1478 #ifdef GATHER_STATISTICS

1479    n_calls_lookup_fnfields_1 ++;

1480 #endif /* GATHER_STATISTICS */

1481

1482    /* Constructors are first...  */

1483    if (name == ctor_identifier)

1484      return (methods[CLASSTYPE_CONSTRUCTOR_SLOT]

1485            ? CLASSTYPE_CONSTRUCTOR_SLOT : -1);

1486    /* and destructors are second.  */

1487    if (name == dtor_identifier)

1488      return (methods[CLASSTYPE_DESTRUCTOR_SLOT]

1489            ? CLASSTYPE_DESTRUCTOR_SLOT : -1);

1490    if (IDENTIFIER_TYPENAME_P (name))

1491      return lookup_conversion_operator (type, TREE_TYPE (name));

 

构造函数及析构函数，如果被定义了，它们被放置在固定的地方，因为它们是最常调用的方法。如果有作为转换操作符的构造函数，它们紧跟随后。对于转换操作符的查找有点麻烦，如 ISO-IEC-14882-2003 所要求，对于同名的转换操作符，非模板的版本要优先于模板版本。

 

1404 static int

1405 lookup_conversion_operator (tree class_type, tree type)                                in search.c

1406 {

1407    int pass;

1408    int i;

1409

1410    tree methods = CLASSTYPE_METHOD_VEC (class_type);

1411

1412    for (pass = 0; pass < 2; ++pass)

1413      for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;

1414           i < TREE_VEC_LENGTH (methods);

1415          ++i)

1416      {

1417        tree fn = TREE_VEC_ELT (methods, i);

1418        /* The size of the vector may have some unused slots at the

1419          end.  */

1420        if (!fn)

1421          break ;

1422

1423        /* All the conversion operators come near the beginning of the

1424          class. Therefore, if FN is not a conversion operator, there

1425          is no matching conversion operator in CLASS_TYPE.  * /

1426        fn = OVL_CURRENT (fn);

1427        if (!DECL_CONV_FN_P (fn))

1428          break ;

1429       

1430        if (pass == 0)

1431        {

1432          /* On the first pass we only consider exact matches. If

1433            the types match, this slot is the one where the right

1434            conversion operators can be found.  */

1435          if (TREE_CODE (fn) != TEMPLATE_DECL

1436            && same_type_p (DECL_CONV_FN_TYPE (fn), type))

1437            return i;

1438        }

1439        else

1440        {

1441          /* On the second pass we look for template conversion

1442            operators. It may be possible to instantiate the

1443            template to get the type desired. All of the template

1444            conversion operators share a slot. By looking for

1445            templates second we ensure that specializations are

1446            preferred over templates.  */

1447          if (TREE_CODE (fn) == TEMPLATE_DECL)

1448            return i;

1449        }

1450      }

1451

1452    return -1;

1453 }

 

对于其他方法，则需要老老实实地在这个向量中查找。对于解析过的类，其方法已经按其名字所对应的标识符的地址排序，因此可以使用二分查找；而对于正在解析的类，其方法还未排序，只能依次查找。

 

lookup_fnfields_1 (continue)

 

1493    /* Skip the conversion operators.  */

1494    i = CLASSTYPE_FIRST_CONVERSION_SLOT;

1495    while (i < len && methods[i] && DECL_CONV_FN_P (OVL_CURRENT (methods[i])))

1496      i++;

1497

1498    /* If the type is complete, use binary search.  */

1499    if (COMPLETE_TYPE_P (type))

1500    {

1501      int lo = i;

1502      int hi = len;

1503

1504      while (lo < hi)

1505      {

1506        i = (lo + hi) / 2;

1507

1508 #ifdef GATHER_STATISTICS

1509        n_outer_fields_searched ++;

1510 #endif /* GATHER_STATISTICS */

1511

1512        tmp = methods[i];

1513        /* This slot may be empty; we allocate more slots than we

1514          need. In that case, the entry we're looking for is

1515           closer to the beginning of the list.  */

1516        if (tmp)

1517          tmp = DECL_NAME (OVL_CURRENT (tmp));

1518        if (!tmp || tmp > name)

1519          hi = i;

1520        else if (tmp < name)

1521          lo = i + 1;

1522        else

1523          return i;

1524      }

1525    }

1526    else

1527      for (; i < len && methods[i]; ++i)

1528      {

1529 #ifdef GATHER_STATISTICS

1530        n_outer_fields_searched ++;

1531 #endif /* GATHER_STATISTICS */

1532       

1533        tmp = OVL_CURRENT (methods[i]);

1534        if (DECL_NAME (tmp) == name)

1535          return i;

1536      }

1537

1538    return -1;

1539 }

 

查找转换操作符由上述代码完成，不过 lookup_field _r 也可被用于查找数据成员或类中的类型，在这里我们也看一下这部分功能。

查找数据成员由 lookup_field_1 完成，看到如果不是严格地要求 TYPE_DECL ，方法（ method ）将隐藏同名的类型。

 

427  tree

428  lookup_field_1 (tree type, tree name, bool want_type)                                   in search.c

429  {

430    tree field;

431 

432    if (TREE_CODE (type) == TEMPLATE_TYPE_PARM

433        || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM

434        || TREE_CODE (type) == TYPENAME_TYPE)

435      /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and

436        BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;

437        instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,

438        the code often worked even when we treated the index as a list

439        of fields!)

440        The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */

441      return NULL_TREE;

442 

443    if (TYPE_NAME (type)

444        && DECL_LANG_SPECIFIC (TYPE_NAME (type))

445        && DECL_SORTED_FIELDS (TYPE_NAME (type)))

446    {

447      tree *fields = &DECL_SORTED_FIELDS (TYPE_NAME (type))->elts[0];

448      int lo = 0, hi = DECL_SORTED_FIELDS (TYPE_NAME (type))->len;

449      int i;

450 

451      while (lo < hi)

452      {

453        i = (lo + hi) / 2;

454 

455    #ifdef GATHER_STATISTICS

456        n_fields_searched ++;

457    #endif /* GATHER_STATISTICS */

458 

459        if (DECL_NAME (fields[i]) > name)

460          hi = i;

461        else if (DECL_NAME (fields[i]) < name)

462          lo = i + 1;

463        else

464        {

465          field = NULL_TREE;

466 

467           /* We might have a nested class and a field with the

468            same name; we sorted them appropriately via

469            field_decl_cmp, so just look for the first or last

470            field with this name.  */

471           if (want_type)

472          {

473            do

474              field = fields[i--];

475            while (i >= lo && DECL_NAME (fields[i]) == name);

476            if (TREE_CODE (field) != TYPE_DECL

477               && !DECL_CLASS_TEMPLATE_P (field))

478              field = NULL_TREE;

479          }

480          else

481          {

482            do

483              field = fields[i++];

484            while (i < hi && DECL_NAME (fields[i]) == name);

485          }

486          return field;

487        }

488      }

489      return NULL_TREE;

490    }

491 

492    field = TYPE_FIELDS (type);

493 

494  #ifdef GATHER_STATISTICS

495    n_calls_lookup_field_1 ++;

496  #endif /* GATHER_STATISTICS */

497    for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))

498    {

499  #ifdef GATHER_STATISTICS

500      n_fields_searched ++;

501  #endif /* GATHER_STATISTICS */

502      my_friendly_assert (DECL_P (field), 0);

503      if (DECL_NAME (field) == NULL_TREE

504        && ANON_AGGR_TYPE_P (TREE_TYPE (field)))

505      {

506        tree temp = lookup_field_1 (TREE_TYPE (field), name, want_type);

507        if (temp)

508          return temp;

509      }

510      if (TREE_CODE (field) == USING_DECL)

511         /* For now, we're just treating member using declarations as

512          old ARM-style access declarations. Thus, there's no reason

513          to return a USING_DECL, and the rest of the compiler can't

514          handle it. Once the class is defined, these are purged

515          from TYPE_FIELDS anyhow; see handle_using_decl.  */

516        continue ;

517 

518      if (DECL_NAME (field) == name

519        && (!want_type

520            || TREE_CODE (field) == TYPE_DECL

521            || DECL_CLASS_TEMPLATE_P (field)))

522        return field;

523    }

524    /* Not found.  */

525    if (name == vptr_identifier )

526    {

527      /* Give the user what s/he thinks s/he wants.  */

528      if (TYPE_POLYMORPHIC_P (type))

529        return TYPE_VFIELD (type);

530    }

531    return NULL_TREE;

532  }

 

这个函数类似于 lookup_fnfields_1 的后半部分。注意在 444 行，在 C++ 前端中， *_DECL 节点中具有 DECL_LANG_SPECIFIC 部分。对于类，虚表（ vtable ）被链接在 TYPE_FIELDS 的头部，它被虚表指针（ vptr_identifier ）所指向。注意只有定义了虚函数或从虚基类派生的类才具有虚表及虚表指针。

如果我们查找一个类型，但所找到的（ nval ）不是 TYPE_DECL 并且与当前类同名；对于这个情况， nval 一定不是方法（在 1148 行的 lookup_fnfields_1 被跳过），而是一个域。正如下面 1169 行的注释所描述的， nval 可以是与类型同名的一个域。回忆对于类，为其有 TYPE_DECL 被构建，并且链入 TYPE_FIELDS ，因此在 1173 行的 FOR 循环查找这个 TYPE_DECL 。

 

lookup_field_r (continue)

 

1162    /* If we're looking up a type (as with an elaborated type specifier)

1163      we ignore all non-types we find.  */

1164    if (lfi->want_type && TREE_CODE (nval) != TYPE_DECL

1165        && !DECL_CLASS_TEMPLATE_P (nval))

1166    {

1167      if (lfi->name == TYPE_IDENTIFIER (type))

1168      {

1169        /* If the aggregate has no user defined constructors, we allow

1170          it to have fields with the same name as the enclosing type.

1171          If we are looking for that name, find the corresponding

1172          TYPE_DECL.  */

1173        for (nval = TREE_CHAIN (nval); nval; nval = TREE_CHAIN (nval))

1174          if (DECL_NAME (nval) == lfi->name

1175                && TREE_CODE (nval) == TYPE_DECL)

1176            break ;

1177      }

1178      else

1179         nval = NULL_TREE;

1180      if (!nval && CLASSTYPE_NESTED_UTDS (type) != NULL)

1181      {

1182        binding_entry e = binding_table_find (CLASSTYPE_NESTED_UTDS (type),

1183                                        lfi->name);

1184        if (e != NULL)

1185          nval = TYPE_MAIN_DECL (e->type);

1186        else

1187          return NULL_TREE;

1188      }

1189    }

1190

1191    /* You must name a template base class with a template-id.  */

1192    if (!same_type_p (type, lfi->type)

1193        && template_self_reference_p (type, nval))

1194      return NULL_TREE;

 

上面，在 1180 行， CLASSTYPE_NESTED_UTDS 是在类中找到的嵌套用户定义类型（类或枚举）的字典。如果 nval 不是 TYPE_DECL 并且不与类的同名，我们进入 1180 行的 IF 块；在这种情况下， nval 可能会屏蔽在类中声明的类型。比如：

class A {

public :

    class a { public : int i; };

    int a;

};

 

int main () {

    class A::a a;     // class A::a is the elaborated-type-specifier

    return 0;

}

为了是 IF 块找出被域‘ a ’所屏蔽的类型‘ a ’，必须使用 elaborated-type-specifier 来显式地指明类型（看到这在上面会使得 want_type 成为 true ）。

以下，【 3 】，条款 3.3.7 “名字屏蔽”系统地描述了名字屏蔽的规则。

1.  在一个嵌套声明域或派生类中，一个名字可以被同名的显式声明所屏蔽（ 10.2 ）。 2.  一个类名（ 9.1 ）或枚举名（ 7.2 ）可以被在同一个域中声明的对象，函数或枚举值的名字所屏蔽。如果一个类或枚举类型与同名的一个对象，函数或枚举值，以任意的次序，声明在同一个域中，该类或枚举类型在该对象，函数或枚举值可见处被屏蔽。 3.  在一个方法的定义中的一个局部声明屏蔽在该类中声明的同名成员；参考 3.3.6 。在一个派生类中的一个成员声明（条款 10 ）屏蔽基类中声明的同名成员；参考 10.2 。 4.  在查找被一个名字空间名所限定的名字的过程中，那些通过 using-directive 可见的声明为包含这个 using-directive 的名字空间内的同名声明所屏蔽；参考（ 3.4.3.2 ）。 5.  如果一个名字在作用域内并且没有被屏蔽，它被称为可见（ visible ）。

 

lookup_field_r (continue)

 

1196    /* If the lookup already found a match, and the new value doesn't

1197      hide the old one, we might have an ambiguity.  */

1198    if (lfi->rval_binfo

1199        && !is_subobject_of_p (lfi->rval_binfo, binfo))

1200     

1201    {

1202      if (nval == lfi->rval && shared_member_p (nval))

1203         /* The two things are really the same.  */

1204         ;

1205      else if (is_subobject_of_p (binfo, lfi->rval_binfo))

1206          /* The previous value hides the new one.  */

1207         ;

1208      else

1209      {

1210          /* We have a real ambiguity. We keep a chain of all the

1211          candidates.  */

1212          if (!lfi->ambiguous && lfi->rval)

1213        {

1214          /* This is the first time we noticed an ambiguity. Add

1215             what we previously thought was a reasonable candidate

1216             to the list.  */

1217          lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE);

1218          TREE_TYPE (lfi->ambiguous) = error_mark_node;

1219        }

1220

1221         /* Add the new value.  */

1222        lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous);

1223        TREE_TYPE (lfi->ambiguous) = error_mark_node;

1224        lfi->errstr = "request for member `%D' is ambiguous";

1225      }

1226    }

1227    else

1228    {

1229       lfi->rval = nval;

1230      lfi->rval_binfo = binfo;

1231    }

1232

1233    return NULL_TREE;

1234 }

 

在上面的 lfi 中， rval 域记录了最后的查找结果，而 rval_binfo 则是对应的 binfo 。因为 lfi 在整个遍历中都存活着，这些域如果不是 NULL ，则表示了有二义性的可能，除非 rval_binfo 与 binfo （现在正在查找的类型）具有继承关系。另一个例外是这 2 个项都是同一个。

 

1114 static int

1115 is_subobject_of_p (tree parent, tree binfo)                                                   in search.c

1116 {

1117    tree probe;

1118   

1119    for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe))

1120    {

1121      if (probe == binfo)

1122       return 1;

1123      if (TREE_VIA_VIRTUAL (probe))

1124       return (purpose_member (BINFO_TYPE (probe),

1125                       CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))

1126             != NULL_TREE);

1127    }

1128    return 0;

1129 }

 

函数 is_subobject_of_p 分辨给定的类型是否具有继承关系。它的实现简单直接。

在遍历后，如果有所发现， lfi 中的 rval 及 rval_binfo 记录了查找的结果。而且如果发现了二义性，具有二义性的域被记录在 ambiguous 域。

 

lookup_member (continue)

 

1328    rval = lfi.rval;

1329    rval_binfo = lfi.rval_binfo;

1330    if (rval_binfo)

1331      type = BINFO_TYPE (rval_binfo);

1332    errstr = lfi.errstr;

1333

1334    /* If we are not interested in ambiguities, don't report them;

1335      just return NULL_TREE.  */

1336    if (!protect && lfi.ambiguous)

1337      return NULL_TREE;

1338   

1339    if (protect == 2)

1340    {

1341      if (lfi.ambiguous)

1342       return lfi.ambiguous;

1343      else

1344       protect = 0;

1345    }

1346

1347    /* [class.access]

1348

1349      In the case of overloaded function names, access control is

1350      applied to the function selected by overloaded resolution.  */

1351    if (rval && protect && !is_overloaded_fn (rval))

1352      perform_or_defer_access_check (basetype_path, rval);

1353

1354    if (errstr && protect)

1355    {

1356      error (errstr, name, type);

1357      if (lfi.ambiguous)

1358        print_candidates (lfi.ambiguous);

1359      rval = error_mark_node;

1360    }

1361

1362    if (rval && is_overloaded_fn (rval))

1363      rval = build_baselink (rval_binfo, basetype_path, rval,

1364                        (IDENTIFIER_TYPENAME_P (name)

1365                         ? TREE_TYPE (name): NULL_TREE));

1366    return rval;

1367 }

 

注意上面的 is_overloaded_fn 返回 true 如果 rval 可以被重载。对于可以被重载及访问的方法，要构建 BASELINK 节点，它代表对一个或一组基类的方法的引用。注意到类本身可以作为自己的基类。

 

1240 tree

1241 build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)

1242 {

1243    tree baselink;

1244

1245    my_friendly_assert (TREE_CODE (functions) == FUNCTION_DECL

1246                     || TREE_CODE (functions) == TEMPLATE_DECL

1247                     || TREE_CODE (functions) == TEMPLATE_ID_EXPR

1248                     || TREE_CODE (functions) == OVERLOAD,

1249                     20020730);

1250    my_friendly_assert (!optype || TYPE_P (optype), 20020730);

1251    my_friendly_assert (TREE_TYPE (functions), 20020805);

1252

1253    baselink = make_node (BASELINK);

1254    TREE_TYPE (baselink) = TREE_TYPE (functions);

1255    BASELINK_BINFO (baselink) = binfo;

1256    BASELINK_ACCESS_BINFO (baselink) = access_binfo;

1257    BASELINK_FUNCTIONS (baselink) = functions;

1258    BASELINK_OPTYPE (baselink) = optype;

1259

1260    return baselink;

1261 }

 

BASELINK_FUNCTIONS 给出了对应于函数的 FUNCTION_DECL ， TEMPLATE_DECL ， OVERLOAD 或 TEMPLATE_ID_EXPR 。 BASELINK_BINFO 给出了这些函数所来自的基类，即，在调用这些函数之前，“ this ”指针需要被转换至的基类（这个 BINFO 指示了 BASELINK_FUNCTIONS 所来自的基类）。 BASELINK_ACCESS_BINFO 给出了命名这些函数的基类（在这个 BINFO 中开始查找由这个 baselink 所指明的函数。这个基类通常用来确定由重载解析所选定函数的可访问性）。 BASELINK_BINFO 及 BASELINK_ACCESS_BINFO 可能会由 adjust_result_of_qualified_name_lookup 调整。

一个 BASELINK 是一个表达式； BASELINK 的 TREE_TYPE 给出了表达式的类型。这个类型或者是一个 FUNCTION_TYPE ， METHOD_TYPE 或者表示重载函数的 unknown_type_node 。

在结束这一节之前，让我们看一下，在 lookup_member 的 1327 行的 bfs_walk 中，如何选择合适的 binfo 。这是函数 lookup_field_queue_p 。

 

1041 static tree

1042 lookup_field_queue_p (tree derived, int ix, void *data)

1043 {

1044    tree binfo = BINFO_BASETYPE (derived, ix);

1045    struct lookup_field_info *lfi = (struct lookup_field_info *) data;

1046

1047    /* Don't look for constructors or destructors in base classes.  */

1048    if (IDENTIFIER_CTOR_OR_DTOR_P (lfi->name))

1049      return NULL_TREE;

1050

1051    /* If this base class is hidden by the best-known value so far, we

1052      don't need to look.  */

1053    if (lfi->rval_binfo && original_binfo (binfo, lfi->rval_binfo))

1054      return NULL_TREE;

1055

1056    /* If this is a dependent base, don't look in it.  */

1057    if (BINFO_DEPENDENT_BASE_P (binfo))

1058      return NULL_TREE;

1059   

1060    return binfo;

1061 }

 

上面在 1053 行， binfo 可能是在由 lfi->rval_binfo 支配的类层次树中的原始 original_binfo binfo ，或者是一个复制的 binfo 。对于复制的 binfo ， original_binfo 返回 NULL ，否则返回层次树中的原始的 binfo 。

那么如果 original_binfo 返回值不为 NULL ，表示 lfi->rval_binfo （记住这个域保存了发现所查找名字的 binfo ）包含了 binfo 作为基类，不需要在其中查找。

5.12.4.1.1.2.1.2.    在指定对象中查找

而对于类似“ a->b ”或“ a.b ”的表达式，作用域‘ a ’被记录在“ parser->context->object_type ”，此时它被下面的 object_type 所指向。【 3 】规定：

如果在一个类成员访问中的 id-expression 是一个以下形式的 qualified-id ：

class-name-or-namespace-name::...

跟在操作符 . 或 -> 后的 class-name-or-namespace-name 同时在整个 postfix-expression 上下文中及对象表达式（ object-expression ）的类的作用域中查找。如果只在该对象表达式的类的作用域中找到该名字，该名字应该是一个类名。如果仅在整个 postfix-expression 的上下文中找到该名字，这个名字应该是一个类名或名字空间名。如果在 2 个上下文中都找到这个名字， 它们应该指向同一个实体。 [ 注意： class-name-or-namespace-name 查找出来的结果不要求为该对象表达式的类中唯一的基类，只要被限定 id （ qualified id ）命名的实体是对象表达式的类的成员并且根据 10.2 没有二义性。

struct A {

int a;

};

struct B: virtual A { };

struct C: B { };

struct D: B { };

struct E: public C, public D { };

struct F: public A { };

void f() {

E e;

e.B::a = 0; // OK, only one A::a in E

F f;

f.A::a = 1; // OK, A::a is a member of F

}

不过我尚未想明白什么情况下 class-name-or-namespace-name 可以是名字空间名 L 。例如：

namespace NA {

int i;

struct A { };

void func () {

   A a;

   a.NA::i = 5;

}

}

 

int main () {

    return 1;

}

根据上面的规则，“ a.NA::i ”中的 NA 将在 func 所在上下文查找，并最终确定为名字空间名，但是在 finish_class_member_access_expr 中，这个表达式最终被确认为错误。

 

cp_parser_lookup_name (continue)

 

13811    else if (object_type)

13812    {

13813      tree object_decl = NULL_TREE;

13814      /* Look up the name in the scope of the OBJECT_TYPE, unless the

13815         OBJECT_TYPE is not a class.  */

13816      if (CLASS_TYPE_P (object_type))

13817         /* If the OBJECT_TYPE is a template specialization, it may

13818          be instantiated during name lookup. In that case, errors

13819          may be issued. Even if we rollback the current tentative

13820          parse, those errors are valid.  */

13821           object_decl = lookup_member (object_type,

13822                                      name,

13823                                      /*protect=*/ 0, is_type);

13824       /* Look it up in the enclosing context, too.  */

13825      decl = lookup_name_real (name, is_type, /*nonclass=*/ 0,

13826                             is_namespace, flags);

13827      parser->object_scope = object_type;

13828      parser->qualifying_scope = NULL_TREE;

13829      if (object_decl)

13830         decl = object_decl;

13831    }

 

【 3 】并没有规定在 2 个上下文中同时找到名字时采取何者。 GCC 采用在对象表达式的类作用域中找到的那个。注意，函数 lookup_member 及 lookup_name_real 都能保证找到的结果没有二义性。

上面在 13827 行， parser 的 object_scope 及 qualifying_scope 保存了最后一次查找所在的作用域。如果使用了形如“ x->y ”或“ x.y ”的表达式，使用 object_scope ，它分别给出类型“ *x ”或“ x ”；对于形如“ X::Y ”的表达式，使用 qualifying_scope ，它指向 X 。