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

5.12.4.2.2.2.2.          解析实参列表

然后调用 cp_parser_enclosed_template_argument_list 来解析 template-id 中所包含的模板实参列表。在这个处理之前， parser 的 greater_than_is_operator_p 域将被设置为 false ，因为从现在起进来的“ > ”将不被视为操作符。而在实参列表中输入的“ >> ”将被解析作“ > ”和“ > ”，例如，“ A<B<>> a ”，前端将把它视为“ A<B<> > a ”。看到解析器将尝试从这个错误恢复并继续前行，但不保证可以产生正确的代码，因为程序员在这里犯了错误，因此给出错误信息。

 

14692 static tree

14693 cp_parser_enclosed_template_argument_list (cp_parser* parser)                 in parser.c

14694 {

14695    tree arguments;

14696    tree saved_scope;

14697    tree saved_qualifying_scope;

14698    tree saved_object_scope;

14699     bool saved_greater_than_is_operator_p;

14700

14701    /* [temp.names]

14702

14703      When parsing a template-id, the first non-nested `>' is taken as

14704      the end of the template-argument-list rather than a greater-than

14705      operator.  */

14706    saved_greater_than_is_operator_p

14707       = parser->greater_than_is_operator_p;

14708    parser->greater_than_is_operator_p = false;

14709    /* Parsing the argument list may modify SCOPE, so we save it

14710      here.  */

14711    saved_scope = parser->scope;

14712    saved_qualifying_scope = parser->qualifying_scope;

14713    saved_object_scope = parser->object_scope;

14714    /* Parse the template-argument-list itself.  */

14715    if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))

14716      arguments = NULL_TREE;

14717    else

14718      arguments = cp_parser_template_argument_list (parser);

14719    /* Look for the `>' that ends the template-argument-list. If we find

14720      a '>>' instead, it's probably just a typo.  */

14721    if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))

14722    {

14723      if (!saved_greater_than_is_operator_p)

14724      {

14725         /* If we're in a nested template argument list, the '>>' has to be

14726          a typo for '> >'. We emit the error message, but we continue

14727          parsing and we push a '>' as next token, so that the argument

14728          list will be parsed correctly..  */

14729        cp_token* token;

14730        error ("`>>' should be `> >' within a nested template argument list");

14731        token = cp_lexer_peek_token (parser->lexer);

14732        token->type = CPP_GREATER;

14733      }

14734      else

14735      {

14736        /* If this is not a nested template argument list, the '>>' is

14737          a typo for '>'. Emit an error message and continue.  */

14738        error ("spurious `>>', use `>' to terminate a template argument list");

14739        cp_lexer_consume_token (parser->lexer);

14740      }

14741    }

14742    else

14743      cp_parser_skip_until_found (parser, CPP_GREATER, "`>'");

14744    /* The `>' token might be a greater-than operator again now.  */

14745    parser->greater_than_is_operator_p

14746       = saved_greater_than_is_operator_p;

14747     /* Restore the SAVED_SCOPE.  */

14748    parser->scope = saved_scope;

14749    parser->qualifying_scope = saved_qualifying_scope;

14750    parser->object_scope = saved_object_scope;

14751

14752    return arguments;

14753 }

 

parser 的 in_template_argument_list_p 域如果为 true 表示我们正在模板实参列表中。因此我们首先需要缓存这个域的内容，并在解析实参列表之前临时将其设为 true 。

 

8265 static tree

8266 cp_parser_template_argument_list (cp_parser* parser)                                  in parser.c

8267 {

8268    tree fixed_args[10];

8269    unsigned n_args = 0;

8270    unsigned alloced = 10;

8271    tree *arg_ary = fixed_args;

8272    tree vec;

8273    bool saved_in_template_argument_list_p;

8274

8275    saved_in_template_argument_list_p = parser->in_template_argument_list_p;

8276    parser->in_template_argument_list_p = true;

8277    do

8278    {

8279      tree argument;

8280

8281      if (n_args)

8282        /* Consume the comma.  */

8283        cp_lexer_consume_token (parser->lexer);

8284       

8285      /* Parse the template-argument.  */

8286      argument = cp_parser_template_argument (parser);

8287      if (n_args == alloced)

8288      {

8289        alloced *= 2;

8290  

8291        if (arg_ary == fixed_args)

8292        {

8293          arg_ary = xmalloc (sizeof (tree) * alloced);

8294          memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);

8295        }

8296        else

8297          arg_ary = xrealloc (arg_ary, sizeof (tree) * alloced);

8298      }

8299      arg_ary[n_args++] = argument;

8300    }

8301    while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));

8302

8303    vec = make_tree_vec (n_args);

8304

8305    while (n_args--)

8306      TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];

8307   

8308    if (arg_ary != fixed_args)

8309      free (arg_ary);

8310    parser->in_template_argument_list_p = saved_in_template_argument_list_p;

8311    return vec;

8312 }

 

在列表中的每个参数由 cp_parser_template_argument 解析。当所有的实参都被处理后，相应的所产生的节点被填充入 TREE_VEC 节点，并且该节点被作为返回值返回。

5.12.4.2.2.2.2.1.    解析实参

模板实参的语法树显示如下。

（ 点此打开 ）

根据【 8 】，在一个模板实参中，由 type-id 及 id-expression 所导致的二义性，按 type-id 来解析，而不考虑对应模板实参的形式（缺省模板实参不存在这样的二义性，因为 template-parameter 的形式确定了缺省 template-argument 必须是 type-id ）。

例如：

template <class T> void f();

template <int I> void f();

void g() {

f<int()>(); // int() is a type-id: call the first f()

}

因此我们首先尝试 type-id 。

 

8330 static tree

8331 cp_parser_template_argument (cp_parser* parser)                                       in parser.c

8332 {

8333    tree argument;

8334    bool template_p;

8335    bool address_p;

8336    bool maybe_type_id = false;

8337    cp_token *token;

8338    cp_id_kind idk;

8339    tree qualifying_class;

8340

8341    /* There's really no way to know what we're looking at, so we just

8342      try each alternative in order. 

8343

8344        [temp.arg]

8345

8346        In a template-argument, an ambiguity between a type-id and an

8347        expression is resolved to a type-id, regardless of the form of

8348        the corresponding template-parameter. 

8349

8350      Therefore, we try a type-id first.  */

8351    cp_parser_parse_tentatively (parser);

8352    argument = cp_parser_type_id (parser);

8353    /* If there was no error parsing the type-id but the next token is a '>>',

8354      we probably found a typo for '> >'. But there are type-id which are

8355      also valid expressions. For instance:

8356

8357          struct X { int operator >> (int); };

8358          template <int V> struct Foo {};

8359          Foo<X () >> 5> r;

8360

8361      Here 'X()' is a valid type-id of a function type, but the user just

8362      wanted to write the expression "X() >> 5". Thus, we remember that we

8363      found a valid type-id, but we still try to parse the argument as an

8364      expression to see what happens.  */

8365    if (!cp_parser_error_occurred (parser)

8366        && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))

8367    {

8368      maybe_type_id = true;

8369      cp_parser_abort_tentative_parse (parser);

8370    }

8371    else

8372    {

8373      /* If the next token isn't a `,' or a `>', then this argument wasn't

8374        really finished. This means that the argument is not a valid

8375        type-id.  */

8376      if (!cp_parser_next_token_ends_template_argument_p (parser))

8377        cp_parser_error (parser, "expected template-argument");

8378      /* If that worked, we're done.  */

8379      if (cp_parser_parse_definitely (parser))

8380        return argument;

8381    }

 

这里有一个棘手的情形需要小心处理。考虑在上面注释中给出的例子（这个例子不能通过编译，但不是因为 >> ）：

struct X { int operator >> (int); };

template <int V> struct Foo {};

Foo<X() >> 5> r;

“ X() ”是一个 type-id 的实例，但“ X() >> 5 ”则是移位表达式的实例（这是 assignment-expression 的一个变形，其中“ X() ”是一个 postfix-expression ）。因为解析器要尽可能多地在一次中解析符号，它将把该字符串解析为移位表达式。然而由于失误，程序员也可能将“ > > ”写作“ >> ”，而把 type-id 从解析器的角度伸展为移位表达式。因此当成功解析一个后跟“ >> ”的 type-id 时，需要记住这个可能性，并且接着尝试按移位表达式来解析（此时，模板参数是非类型的）。细节在下面 assignment-expression 的情况一节。

5.12.4.2.2.2.2.1.1.            type-id 的情形

从其语法树，可以看到 type-id 包含了 type-specifier-seq 及可选的 abstract- declarator 。在经过解析之后，这些部分被包含在一个 TREE_LIST 节点，在其中， type-specifier-seq 在 purpose 域，而 abstract-declarator 在 value 域中。

 

10924 static tree

10925 cp_parser_type_id (cp_parser* parser)                                                      in parser.c

10926 {

10927    tree type_specifier_seq;

10928    tree abstract_declarator;

10929

10930    /* Parse the type-specifier-seq.  */

10931    type_specifier_seq

10932      = cp_parser_type_specifier_seq (parser);

10933    if (type_specifier_seq == error_mark_node)

10934      return error_mark_node;

10935

10936    /* There might or might not be an abstract declarator.  */

10937    cp_parser_parse_tentatively (parser);

10938    /* Look for the declarator.  */

10939    abstract_declarator

10940      = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,

10941                         /*parenthesized_p=*/ NULL,

10942                         /*member_p=*/ false);

10943    /* Check to see if there really was a declarator.  */

10944    if (!cp_parser_parse_definitely (parser))

10945      abstract_declarator = NULL_TREE;

10946

10947    return groktypename (build_tree_list (type_specifier_seq,

10948                                   abstract_declarator));

10949 }

 

type-specifier-seq 的语法给出如下。

type-specifier-seq

├ type-specifier type-specifier-seq [opt]

GUN Ext Ⅼ attributes type-specifier-seq

 

10964 static tree

10965 cp_parser_type_specifier_seq (cp_parser* parser)                                      in parser.c

10966 {

10967    bool seen_type_specifier = false;

10968    tree type_specifier_seq = NULL_TREE;

10969

10970    /* Parse the type-specifiers and attributes.  */

10971    while (true)

10972    {

10973      tree type_specifier;

10974

10975      /* Check for attributes first.  */

10976      if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))

10977      {

10978        type_specifier_seq = tree_cons (cp_parser_attributes_opt (parser),

10979                                  NULL_TREE,

10980                                  type_specifier_seq);

10981        continue ;

10982      }

10983

10984       /* After the first type-specifier, others are optional.  */

10985      if (seen_type_specifier)

10986        cp_parser_parse_tentatively (parser);

10987       /* Look for the type-specifier.  */

10988      type_specifier = cp_parser_type_specifier (parser,

10989                                         CP_PARSER_FLAGS_NONE,

10990                                         /*is_friend=*/ false,

10991                                         /*is_declaration=*/ false,

10992                                         NULL,

10993                                         NULL);

10994      /* If the first type-specifier could not be found, this is not a

10995        type-specifier-seq at all.  */

10996      if (!seen_type_specifier && type_specifier == error_mark_node)

10997        return error_mark_node;

10998      /* If subsequent type-specifiers could not be found, the

10999        type-specifier-seq is complete.  */

11000      else if (seen_type_specifier && !cp_parser_parse_definitely (parser))

11001        break ;

11002

11003      /* Add the new type-specifier to the list.  */

11004      type_specifier_seq

11005         = tree_cons (NULL_TREE, type_specifier, type_specifier_seq);

11006      seen_type_specifier = true;

11007    }

11008

11009    /* We built up the list in reverse order.  */

11010    return nreverse (type_specifier_seq);

11011 }

 

函数 cp_parser_declarator 在这里被递归调用，不过仅是为了 abstract-declarator 。因为 type-id 在语义上是一个对象或函数的声明，其类型忽略对象或函数的名字，这个声明是一个类型的名字。根据解析的结果，应该由 groktypename 构建 *_TYPE 节点。

 

3640 tree

3641 groktypename (tree typename)                                                                   in decl.c

3642 {

3643    tree specs, attrs;

3644    tree type;

3645    if (TREE_CODE (typename) != TREE_LIST)

3646      return typename;

3647    split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);

3648    type = grokdeclarator (TREE_VALUE (typename), specs,

3649                       TYPENAME, 0, &attrs);

3650    if (attrs)

3651      cplus_decl_attributes (&type, attrs, 0);

3652    return type;

3653 }

 

上面，属性及 type-specifier 被串接入同一个链表，需要把这个链表分成 2 个链表。下面的参数 declspecs 将持有 type-specifier-seq 部分，而 prefix_attributes 将保存属性链表如果出现的话。在 340 行的条件找出了一个整型常量，如‘ 5 ’等。而如果 spec_attrs 不是 tree_list ，则意味着没有属性。

 

334  void

335  split_specs_attrs (tree specs_attrs, tree *declspecs, tree *prefix_attributes)     in attribs.c

336  {

337    tree t, s, a, next, specs, attrs;

338 

339    /* This can happen after an __extension__ in pedantic mode.  */

340    if (specs_attrs != NULL_TREE

341        && TREE_CODE (specs_attrs) == INTEGER_CST)

342    {

343      *declspecs = NULL_TREE;

344      *prefix_attributes = NULL_TREE;

345      return ;

346    }

347 

348    /* This can happen in c++ (eg: decl: typespec initdecls ';').  */

349    if (specs_attrs != NULL_TREE

350        && TREE_CODE (specs_attrs) != TREE_LIST)

351    {

352      *declspecs = specs_attrs;

353      *prefix_attributes = NULL_TREE;

354      return ;

355    }

356 

357    /* Remember to keep the lists in the same order, element-wise.  */

358 

359    specs = s = NULL_TREE;

360    attrs = a = NULL_TREE;

361    for (t = specs_attrs; t; t = next)

362    {

363      next = TREE_CHAIN (t);

364      /* Declspecs have a non-NULL TREE_VALUE.  */

365      if (TREE_VALUE (t) != NULL_TREE)

366      {

367        if (specs == NULL_TREE)

368          specs = s = t;

369        else

370        {

371          TREE_CHAIN (s) = t;

372          s = t;

373        }

374      }

375      /* The TREE_PURPOSE may also be empty in the case of

376        __attribute__(()).  */

377      else if (TREE_PURPOSE (t) != NULL_TREE)

378      {

379        if (attrs == NULL_TREE)

380          attrs = a = TREE_PURPOSE (t);

381        else

382        {

383          TREE_CHAIN (a) = TREE_PURPOSE (t);

384          a = TREE_PURPOSE (t);

385        }

386         /* More attrs can be linked here, move A to the end.  */

387        while (TREE_CHAIN (a) != NULL_TREE)

388          a = TREE_CHAIN (a);

389      }

390    }

391 

392    /* Terminate the lists.  */

393    if (s != NULL_TREE)

394      TREE_CHAIN (s) = NULL_TREE;

395    if (a != NULL_TREE)

396      TREE_CHAIN (a) = NULL_TREE;

397 

398    /* All done.  */

399    *declspecs = specs;

400    *prefix_attributes = attrs;

401  }

 

对于 type-specifier-seq ，此处，可以看到 type-specifiers 总是通过 tree_list 的 value 域串接起来，而 abstract-declarator 连同其属性总是由 purpose 域来串接。然后函数 grokdeclarator 为该对象或函数的类型返回相应的 TYPE_DECL 节点。在前面的章节中，我们已经看过这个函数的几个例子，因此这里我们跳过它。接下来 type-id 的属性将由 cplus_decl_attributes 安装入这个 TYPE_DECL 节点。

在 4.3.1.7.5.6.5. 处理内建函数的属性 一节中，我们已经看到前端使用数据结构 attribute_spec 来描述每个属性。表 common_attribute_table ， attribute_table ， format_attribute_table 用于 C++ ，而 format_attribute_table 用于 x86 （目标机器）。它们预定义了可以在语言中及指定平台上使用的所有属性。

 

1102 void

1103 cplus_decl_attributes (tree *decl, tree attributes, int flags)                                    in decl2.c

1104 {

1105    if (*decl == NULL_TREE || *decl == void_type_node)

1106      return ;

1107

1108    if (TREE_CODE (*decl) == TEMPLATE_DECL)

1109      decl = &DECL_TEMPLATE_RESULT (*decl);

1110

1111    decl_attributes (decl, attributes, flags);

1112

1113    if (TREE_CODE (*decl) == TYPE_DECL)

1114      SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));

1115 }

 

当调用 decl_attributes 时，我们可以通过向参数 flags 设置特定的 enum attribute_flags 的值，来指定要安装的属性，而没有安装的属性将通过一个链表返回。这里我们把 flags 指定为 0 ，表示安装所有提供的属性。

在 4.3.1.7.5.6.5. 处理内建函数的属性 一节中，我们已经看到绝大多数属性具有关联的处理句柄，这些句柄将适当地修改树节点。除此之外，已应用的属性通过宏 *_ATTRIBUTES 链接入树节点的 attributes 域。这些宏同时也作为一个快速的方法来查看在该节点上应用了哪些属性。

5.12.4.2.2.2.2.1.2.            id-expression 的情形

如果这不是 type-id ，那么我们按 id-expression 重新解析符号。

 

cp_parser_template_argument (continue)

 

8382    /* We're still not sure what the argument will be.  */

8383    cp_parser_parse_tentatively (parser);

8384    /* Try a template.  */

8385    argument = cp_parser_id_expression (parser,

8386                                    /*template_keyword_p=*/ false,

8387                                     /*check_dependency_p=*/ true,

8388                                    &template_p,

8389                                    /*declarator_p=*/ false);

8390    /* If the next token isn't a `,' or a `>', then this argument wasn't

8391      really finished.  */

8392    if (!cp_parser_next_token_ends_template_argument_p (parser))

8393      cp_parser_error (parser, "expected template-argument");

8394    if (!cp_parser_error_occurred (parser))

8395    {

8396      /* Figure out what is being referred to. If the id-expression

8397         was for a class template specialization, then we will have a

8398         TYPE_DECL at this point. There is no need to do name lookup

8399         at this point in that case.  */

8400      if (TREE_CODE (argument) != TYPE_DECL)

8401        argument = cp_parser_lookup_name (parser, argument,

8402                                       /*is_type=*/ false,

8403                                       /*is_template=*/ template_p,

8404                                        /*is_namespace=*/ false,

8405                                       /*check_dependency=*/ true);

8406      if (TREE_CODE (argument) != TEMPLATE_DECL

8407          && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)

8408        cp_parser_error (parser, "expected template-name");

8409    }

8410    if (cp_parser_parse_definitely (parser))

8411      return argument;

 

在 5.12.3.2.1.1.3.4.1. 解析声明符 一节中已经给出了一个 cp_parser_id_expression 的例子。如果查找的结果不是 TYPE_DECL 或 CPP_TEMPLATE_ID ，如果没有发生错误，它必须是一个标识符；那么这个名字将进一步被查找以找出关联的声明，就像 8401 行所作的那样。

5.12.4.2.2.2.2.1.3.            assignment-expression 的情形

如果我们按 type-id 解析成功，并且看到后面跟着“ >> ”，或者上面的尝试都失败了，该模板实参可能是 assignment-expression 的形式。在这个情形下，这个模板实参必须是非类型实参。根据 ^[3] ，非类型模板实参可以是：

— 一个具有整型或枚举类型的整形常量表达式；或者

— 一个非类型模板参数的名字；或者

— 表达为 & id-expression ，其中 & 是可选的，如果该名字引用一个函数或数组，具有外部链接性的对象或函数的地址，包括函数模板及函数 template-id ，但不包括的非静态类成员；或者对应的模板参数是一个引用，具有外部链接性的对象或函数；或者

— 指向一个成员的指针

 

cp_parser_template_argument (continue)

 

8412    /* It must be a non-type argument. There permitted cases are given

8413      in [temp.arg.nontype]:

8414

8415      -- an integral constant-expression of integral or enumeration

8416        type; or

8417

8418      -- the name of a non-type template-parameter; or

8419

8420      -- the name of an object or function with external linkage...

8421

8422      -- the address of an object or function with external linkage...

8423

8424      -- a pointer to member...  */

8425     /* Look for a non-type template parameter.  */

8426    if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))

8427    {

8428      cp_parser_parse_tentatively (parser);

8429      argument = cp_parser_primary_expression (parser,

8430                                          &idk,

8431                                          &qualifying_class);

8432      if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX

8433         || !cp_parser_next_token_ends_template_argument_p (parser))

8434        cp_parser_simulate_error (parser);

8435      if (cp_parser_parse_definitely (parser))

8436        return argument;

8437    }

 

在按 assignment-expression 解析该模板实参期间，如果我们看到第一个符号是一个标识符，从图形： 语句语法树 ，可以看到它一定是 assignment-expression 语法树中 primary-expression 部分的头部。如果 primary-expression 能被成功解析，我们就做完了。

否则，就检查在 primary-expression 之前是否有引导的 & 。这样形式的实参对应于后 2 种形式的非类型实参（记住该实参必须是编译时常量，对于指向成员的指针，它必须像：“ &A::f ”）。同样如果模板实参可以被解析为 primary-expression ，我们就完成了。我们不进入 primary-expression 的处理细节。在 5.12.4.1.2. 非类型参数 一节中可以找到一些相关的解释。

 

cp_parser_template_argument (continue)

 

8438    /* If the next token is "&", the argument must be the address of an

8439      object or function with external linkage.  */

8440    address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);

8441    if (address_p)

8442      cp_lexer_consume_token (parser->lexer);

8443    /* See if we might have an id-expression.  */

8444    token = cp_lexer_peek_token (parser->lexer);

8445    if (token->type == CPP_NAME

8446        || token->keyword == RID_OPERATOR

8447        || token->type == CPP_SCOPE

8448        || token->type == CPP_TEMPLATE_ID

8449        || token->type == CPP_NESTED_NAME_SPECIFIER)

8450    {

8451      cp_parser_parse_tentatively (parser);

8452      argument = cp_parser_primary_expression (parser,

8453                                          &idk,

8454                                          &qualifying_class);

8455      if (cp_parser_error_occurred (parser)

8456          || !cp_parser_next_token_ends_template_argument_p (parser))

8457        cp_parser_abort_tentative_parse (parser);

8458      else

8459      {

8460        if (qualifying_class)

8461          argument = finish_qualified_id_expr (qualifying_class,

8462                                          argument,

8463                                         /*done=*/ true,

8464                                         address_p);

8465        if (TREE_CODE (argument) == VAR_DECL)

8466        {

8467          /* A variable without external linkage might still be a

8468             valid constant-expression, so no error is issued here

8469             if the external-linkage check fails.  */

8470          if (!DECL_EXTERNAL_LINKAGE_P (argument))

8471            cp_parser_simulate_error (parser);

8472        }

8473        else if (is_overloaded_fn (argument))

8474          /* All overloaded functions are allowed; if the external

8475             linkage test does not pass, an error will be issued

8476             later.  */

8477          ;

8478        else if (address_p

8479              && (TREE_CODE (argument) == OFFSET_REF

8480                  || TREE_CODE (argument) == SCOPE_REF))

8481          /* A pointer-to-member.  */

8482          ;

8483        else

8484          cp_parser_simulate_error (parser);

8485

8486        if (cp_parser_parse_definitely (parser))

8487        {

8488          if (address_p)

8489            argument = build_x_unary_op (ADDR_EXPR, argument);

8490          return argument;

8491         }

8492      }

8493    }

8494     /* If the argument started with "&", there are no other valid

8495      alternatives at this point.  */

8496    if (address_p)

8497    {

8498      cp_parser_error (parser, "invalid non-type template argument");

8499      return error_mark_node;

8500    }

 

上面 qualifying_class 由 cp_parser_primary_expression 设置，表示 pointer-to-member 中的限定类。如果设置了 qualifyng_class ，在 8461 行， finish_qualified_id_expr 在 qualifying_class 的上下文查找 argument ，并为形如：“ A::f ”或“ a.*f ”的表达式构建相应的 OFFSET_REF 节点。然后在 8489 行， build_x_unary_op 为形如：“ &A::f ”的表达式构建相应的 ADDR_EXPR 节点。

如果上面的尝试都失败，那么看一下 assignment-expression 的语法树，根据【 3 】的要求，非类型模板实参必须是常量表达式。在这个语法树中，第二及第三规则不是常量表达式；而且常量表达式（ constant-expression ）可直接降为条件表达式（ xxx? xxx: xxx ）。

assignment-expression

├ condition-expression

|              Ⅼ condition-expression

├ logical-or-expression assignment-operator assignment-expression

Ⅼ throw-expression

因此下一步我们尝试常量表达式。看到下面的 maybe_type_id 如果是 true 表示一开始按 type-id 来解析是成功的，并且其后跟着“ >> ”。因此如果 maybe_type_id 是 true ，意味着我们要尝试把模板实参按移位表达式来解析，它为常量表达式语法所涵盖。

 

cp_parser_template_argument (continue)

 

8501     /* If the argument wasn't successfully parsed as a type-id followed

8502      by '>>', the argument can only be a constant expression now. 

8503      Otherwise, we try parsing the constant-expression tentatively,

8504      because the argument could really be a type-id.  */

8505    if (maybe_type_id)

8506      cp_parser_parse_tentatively (parser);

8507    argument = cp_parser_constant_expression (parser,

8508                                        /*allow_non_constant_p=*/ false,

8509                                         /*non_constant_p=*/ NULL);

8510    argument = fold_non_dependent_expr (argument);

8511    if (!maybe_type_id)

8512      return argument;

8513    if (!cp_parser_next_token_ends_template_argument_p (parser))

8514      cp_parser_error (parser, "expected template-argument");

8515    if (cp_parser_parse_definitely (parser))

8516      return argument;

8517    /* We did our best to parse the argument as a non type-id, but that

8518      was the only alternative that matched (albeit with a '>' after

8519      it). We can assume it's just a typo from the user, and a

8520      diagnostic will then be issued.  */

8521    return cp_parser_type_id (parser);

8522 }

 

而如果 maybe_type_id 是 false ，这是我们最后的机会，返回这个结果，不检查是否发生错误（错误消息由处理函数产生）。否则，需要确认该移位表达式正确构成了实参——即在它之后是否跟着“ , ”或“ > ”（注意，如果错把正确的非类型实参给了类型参数，这里是无法查出的，但在后面的处理中会发现实参与参数类型的不匹配）。如果不能，重新按 type-id 来解析符号，因为很可能是误把“ > > ”写作“ >> ”，这样编译器可以给出更合理的错误信息（看回 cp_parser_enclosed_template_argument_list ，它还将处理额外的“ >> ”返回）。