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 ，它还将处理额外的“ >> ”返回）。
1969
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
