5.12.3.2.1.1.3.1. 解析默认构造函数
类似于类“SingleThreaded”解析其成员，依次调用cp_parser_class_specifier，cp_parser_member_specification_opt，cp_parser_member_declaration，cp_parser_decl_specifier_seq，在下面的代码片段中按照构造函数解析这个decl-specifier。
cp_parser_decl_specifier_seq (continue)
6741 /* Constructors are a special case. The `S' in `S()' is not a
6742 decl-specifier; it is the beginning of the declarator. */
6743 constructor_p = (!decl_spec
6744 && constructor_possible_p
6745 && cp_parser_constructor_declarator_p (parser,
6746 friend_p));
在6744行，constructor_possible_p是parser的in_declarator_p域取反。该域在解析声明符期间为true。
14161 static bool
14162 cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p) in parser.c
14163 {
14164 bool constructor_p;
14165 tree type_decl = NULL_TREE;
14166 bool nested_name_p;
14167 cp_token *next_token;
14168
14169 /* The common case is that this is not a constructor declarator, so
14170 try to avoid doing lots of work if at all possible. It's not
14171 valid declare a constructor at function scope. */
14172 if (at_function_scope_p ())
14173 return false;
14174 /* And only certain tokens can begin a constructor declarator. */
14175 next_token = cp_lexer_peek_token (parser->lexer);
14176 if (next_token->type != CPP_NAME
14177 && next_token->type != CPP_SCOPE
14178 && next_token->type != CPP_NESTED_NAME_SPECIFIER
14179 && next_token->type != CPP_TEMPLATE_ID)
14180 return false;
14181
14182 /* Parse tentatively; we are going to roll back all of the tokens
14183 consumed here. */
14184 cp_parser_parse_tentatively (parser);
14185 /* Assume that we are looking at a constructor declarator. */
14186 constructor_p = true;
14187
14188 /* Look for the optional `::' operator. */
14189 cp_parser_global_scope_opt (parser,
14190 /*current_scope_valid_p=*/false);
14191 /* Look for the nested-name-specifier. */
14192 nested_name_p
14193 = (cp_parser_nested_name_specifier_opt (parser,
14194 /*typename_keyword_p=*/false,
14195 /*check_dependency_p=*/false,
14196 /*type_p=*/false,
14197 /*is_declaration=*/false)
14198 != NULL_TREE);
14199 /* Outside of a class-specifier, there must be a
14200 nested-name-specifier. */
14201 if (!nested_name_p &&
14202 (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type)
14203 || friend_p))
14204 constructor_p = false;
14205 /* If we still think that this might be a constructor-declarator,
14206 look for a class-name. */
14207 if (constructor_p)
14208 {
14209 /* If we have:
14210
14211 template <typename T> struct S { S(); };
14212 template <typename T> S<T>::S ();
14213
14214 we must recognize that the nested `S' names a class.
14215 Similarly, for:
14216
14217 template <typename T> S<T>::S<T> ();
14218
14219 we must recognize that the nested `S' names a template. */
14220 type_decl = cp_parser_class_name (parser,
14221 /*typename_keyword_p=*/false,
14222 /*template_keyword_p=*/false,
14223 /*type_p=*/false,
14224 /*check_dependency_p=*/false,
14225 /*class_head_p=*/false,
14226 /*is_declaration=*/false);
14227 /* If there was no class-name, then this is not a constructor. */
14228 constructor_p = !cp_parser_error_occurred (parser);
14229 }
注意到上面14217行的注释中给出的例子，对于例子“template <typename T> S<T>::S();”“template <typename T> S<T>::”部分是nested-name-specifier，函数cp_parser_class_name 确定“S”是否代表类名；如果不是，cp_parser_error_occurred将返回非0值。而由cp_parser_class_name返回的type_decl是代表该类的TYPE_DECL。我们在后面来看名字查找的过程。
cp_parser_constructor_declarator_p (continue)
14231 /* If we're still considering a constructor, we have to see a `(',
14232 to begin the parameter-declaration-clause, followed by either a
14233 `)', an `...', or a decl-specifier. We need to check for a
14234 type-specifier to avoid being fooled into thinking that:
14235
14236 S::S (f) (int);
14237
14238 is a constructor. (It is actually a function named `f' that
14239 takes one parameter (of type `int') and returns a value of type
14240 `S::S'. */
14241 if (constructor_p
14242 && cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
14243 {
14244 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
14245 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
14246 /* A parameter declaration begins with a decl-specifier,
14247 which is either the "attribute" keyword, a storage class
14248 specifier, or (usually) a type-specifier. */
14249 && !cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE)
14250 && !cp_parser_storage_class_specifier_opt (parser))
14251 {
…
14298 }
14299 }
14300 else
14301 constructor_p = false;
14302 /* We did not really want to consume any tokens. */
14303 cp_parser_abort_tentative_parse (parser);
14304
14305 return constructor_p;
14306 }
接着，当cp_parser_constructor_declarator_p返回到cp_parser_decl_specifier_seq时，decl_spec保持为NULL。因此执行下面的代码。
cp_parser_decl_specifier_seq (continue)
6807 /* If we still do not have a DECL_SPEC, then there are no more
6808 decl-specifiers. */
6809 if (!decl_spec)
6810 {
6811 /* Issue an error message, unless the entire construct was
6812 optional. */
6813 if (!(flags & CP_PARSER_FLAGS_OPTIONAL))
6814 {
6815 cp_parser_error (parser, "expected decl specifier");
6816 return error_mark_node;
6817 }
6818
6819 break;
6820 }
注意到在调用该函数时，flags是CP_PARSER_FLAGS_OPTIONAL，它表示构造函数是可选的。在6819行，将跳出WHILE循环，并且返回NULL，因为构造函数是声明符（declarator）而不是decl-specifier。
5.12.3.2.1.1.3.4.1. 解析声明符
因为构造函数或析构函数是声明符，如果我们写下正确的构造函数或析构函数，我们将进入12603行的ELSE块，开始按照声明符来解析构造函数。
在一个可选的decl-specifier-seq后，跟着一列声明符。每个声明符仅包含一个declarator-id，它命名了所声明的标识符。出现在一个declarator-id中的unqualified-id应该是一个简单的标识符，除了某些特殊函数的声明及模板特化或偏特化的声明。一个declarator-id不应该是被修饰的（qualified），除非是在类定义体外的成员函数或静态数据成员的定义，或是在其名字空间外的变量或函数的定义及显式具现，或是在其名字空间外先前所声明的一个显式特化的定义，或是为另一个类或名字空间成员的友元函数的声明。当该declarator-id具有修饰时，该声明应该援引一个先前所声明的成员，该成员属于该修饰符所引用的名字空间或类，并且该成员不能由using声明引入，该using声明在该declarator-id的nested-name-specifie部分所限定的类或名字空间域中。[注意：如果修饰符是全局域::的解析操作符（resolution operator），该declarator-id援引声明在全局名字空间的名字。]
一个auto，static，extern，register，mutable，friend，inline，virtual或typedef说明符直接应用到每个在init-declarator-list中的declarator-id；每个declarator-id的类型依赖于该decl-specifier-seq及其声明符。
因此，一个特定标识符的声明具有形式：“T D”，其中T是一个decl-specifier-seq，而D是一个声明符。下面是一个确定由这样一个声明中所包含的declarator-id所指定的类型的递归过程。
首先，该decl-specifier-seq确定了一个类型。在声明T D中，decl-specifier-seq T确定了类型“T”。[例如：在声明int unsigned i;中，类型指示符int unsigned确定了类型“unsigned int”]
声明T D，其中D是一个未加修饰（unadorned）的标识符，该标识符的类型是“T”。
声明T D，其中D具有形式“( D1 )”，其中所包含的declarator-id的类型，与声明T D1中所包含的declarator-id的类型相同。
括号不改变嵌入的（embedded）declarator-id的类型，但它们可以改变复杂声明符的绑定。
cp_parser_member_declaration (continue)
12508 /* Check for an invalid type-name. */
12509 if (cp_parser_diagnose_invalid_type_name (parser))
12510 return;
12511 /* If there is no declarator, then the decl-specifier-seq should
12512 specify a type. */
12513 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
12514 {
…
12602 }
12603 else
12604 {
12605 /* See if these declarations will be friends. */
12606 friend_p = cp_parser_friend_p (decl_specifiers);
12607
12608 /* Keep going until we hit the `;' at the end of the
12609 declaration. */
12610 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
12611 {
12612 tree attributes = NULL_TREE;
12613 tree first_attribute;
12614
12615 /* Peek at the next token. */
12616 token = cp_lexer_peek_token (parser->lexer);
12617
12618 /* Check for a bitfield declaration. */
12619 if (token->type == CPP_COLON
12620 || (token->type == CPP_NAME
12621 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
12622 == CPP_COLON))
12623 {
…
12657 }
12658 else
12659 {
12660 tree declarator;
12661 tree initializer;
12662 tree asm_specification;
12663 int ctor_dtor_or_conv_p;
12664
12665 /* Parse the declarator. */
12666 declarator
12667 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
12668 &ctor_dtor_or_conv_p,
12669 /*parenthesized_p=*/NULL,
12670 /*member_p=*/true);
在我们的例子中，上面的decl_specifiers是NULL（即，没有decl-specifier-seq部分）。那么declarator部分由下面的函数来解析。
10259 static tree
10260 cp_parser_declarator (cp_parser* parser, in parser.c
10261 cp_parser_declarator_kind dcl_kind,
10262 int* ctor_dtor_or_conv_p,
10263 bool* parenthesized_p,
10264 bool member_p)
10265 {
10266 cp_token *token;
10267 tree declarator;
10268 enum tree_code code;
10269 tree cv_qualifier_seq;
10270 tree class_type;
10271 tree attributes = NULL_TREE;
10272
10273 /* Assume this is not a constructor, destructor, or type-conversion
10274 operator. */
10275 if (ctor_dtor_or_conv_p)
10276 *ctor_dtor_or_conv_p = 0;
10277
10278 if (cp_parser_allow_gnu_extensions_p (parser))
10279 attributes = cp_parser_attributes_opt (parser);
10280
10281 /* Peek at the next token. */
10282 token = cp_lexer_peek_token (parser->lexer);
10283
10284 /* Check for the ptr-operator production. */
10285 cp_parser_parse_tentatively (parser);
10286 /* Parse the ptr-operator. */
10287 code = cp_parser_ptr_operator (parser,
10288 &class_type,
10289 &cv_qualifier_seq);
10290 /* If that worked, then we have a ptr-operator. */
10291 if (cp_parser_parse_definitely (parser))
10292 {
…
10324 }
10325 /* Everything else is a direct-declarator. */
10326 else
10327 {
10328 if (parenthesized_p)
10329 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
10330 CPP_OPEN_PAREN);
10331 declarator = cp_parser_direct_declarator (parser, dcl_kind,
10332 ctor_dtor_or_conv_p,
10333 member_p);
10334 }
10335
10336 if (attributes && declarator != error_mark_node)
10337 declarator = tree_cons (attributes, declarator, NULL_TREE);
10338
10339 return declarator;
10340 }
Declarator及abstract-declarator的语法如下：
declarator
├ ptr-operator declarator
├ direct-declarator
GNU Ext ├ attributes [opt] ptr-operator declarator
GNU Ext Ⅼ attributes [opt] director-declarator
abstract-declarator
├ ptr-operator abstract-declarator [opt]
├ direct-abstract-declarator
GNU Ext ├ attributes [opt] ptr-operator abstract-declarator [opt]
GNU Ext Ⅼ attributes [opt] direct-abstract-declarator
声明符可以是一个标识符，例如：“int j;”，或者direct- declarator，例如：“int (*pf)()”（跟在int后面的符号构成了一个direct-declarator，int本身是type-specifier）；或者abstract- declarator，例如：“int (*)()”（跟在int后面的符号构成一个abstract-declarator，int本身是type-specifier，它们放在一起形成type-id）。
这里ptr-operator部分不出现。在10287行，cp_parser_ptr_operator使得在10291行的测试失败。
10378 static tree
10379 cp_parser_direct_declarator (cp_parser* parser, in parser.c
10380 cp_parser_declarator_kind dcl_kind,
10381 int* ctor_dtor_or_conv_p,
10382 bool member_p)
10383 {
10384 cp_token *token;
10385 tree declarator = NULL_TREE;
10386 tree scope = NULL_TREE;
10387 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
10388 bool saved_in_declarator_p = parser->in_declarator_p;
10389 bool first = true;
10390 bool pop_p = false;
10391
10392 while (true)
10393 {
10394 /* Peek at the next token. */
10395 token = cp_lexer_peek_token (parser->lexer);
10396 if (token->type == CPP_OPEN_PAREN)
10397 {
…
10537 }
10538 else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
10539 && token->type == CPP_OPEN_SQUARE)
10540 {
…
10577 }
10578 else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
10579 {
10580 /* Parse a declarator-id */
10581 if (dcl_kind == CP_PARSER_DECLARATOR_EITHER)
10582 cp_parser_parse_tentatively (parser);
10583 declarator = cp_parser_declarator_id (parser);
10584 if (dcl_kind == CP_PARSER_DECLARATOR_EITHER)
10585 {
…
10593 }
10594
10595 if (declarator == error_mark_node)
10596 break;
10597
10598 if (TREE_CODE (declarator) == SCOPE_REF
10599 && !current_scope ())
10600 {
…
10636 }
注意到dcl_kind是CP_PARSER_DECLARATOR_NAMED，而第一次进入WHILE块时，first是true。亦即，如果第一个符号是CPP_NAME，应该表示是一个declarator-id。
10882 static tree
10883 cp_parser_declarator_id (cp_parser* parser) in parser.c
10884 {
10885 tree id_expression;
10886
10887 /* The expression must be an id-expression. Assume that qualified
10888 names are the names of types so that:
10889
10890 template <class T>
10891 int S<T>::R::i = 3;
10892
10893 will work; we must treat `S<T>::R' as the name of a type.
10894 Similarly, assume that qualified names are templates, where
10895 required, so that:
10896
10897 template <class T>
10898 int S<T>::R<T>::i = 3;
10899
10900 will work, too. */
10901 id_expression = cp_parser_id_expression (parser,
10902 /*template_keyword_p=*/false,
10903 /*check_dependency_p=*/false,
10904 /*template_p=*/NULL,
10905 /*declarator_p=*/true);
10906 /* If the name was qualified, create a SCOPE_REF to represent
10907 that. */
10908 if (parser->scope && id_expression != error_mark_node)
10909 {
10910 id_expression = build_nt (SCOPE_REF, parser->scope, id_expression);
10911 parser->scope = NULL_TREE;
10912 }
10913
10914 return id_expression;
10915 }
declarator-id
├ ::[opt] nested-name-specifier [opt] type-name
Ⅼ id-expression ├ class-name
├ unqualified-id | ├ identifier
Ⅼ qualifier-id | Ⅼ template-id
├ :: identifier ├ enum-name --- identifier
├ :: operator-function-id Ⅼ typedef-name --- identifier
├ :: [opt] nested-name-specifier [opt] template [opt] unqualified-id
Ⅼ :: template-id
Ⅼ template-name <template-argument-list [opt]>
Ⅼ identifier ├ template-argument-list, template-argument
Ⅼ template-argument
├ assignment-expression
├ type-id
Ⅼ id-expression
从这个语法树，可以看到id-expression可能与其他规则中的declarator-id共享相同的前缀“::[opt] nested-name-specifier [opt]”。另外，id-expresion与type-name的多个规则重叠。看到前端首先尝试按id-expression来解析declarator-id。
unqualified-id
├ identifier
├ operator-function-id
├ conversion-function-id
├ template-id
Ⅼ ~class-name
2685 static tree
2686 cp_parser_id_expression (cp_parser *parser, in parser.c
2687 bool template_keyword_p,
2688 bool check_dependency_p,
2689 bool *template_p,
2690 bool declarator_p)
2691 {
2692 bool global_scope_p;
2693 bool nested_name_specifier_p;
2694
2695 /* Assume the `template' keyword was not used. */
2696 if (template_p)
2697 *template_p = false;
2698
2699 /* Look for the optional `::' operator. */
2700 global_scope_p
2701 = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)
2702 != NULL_TREE);
2703 /* Look for the optional nested-name-specifier. */
2704 nested_name_specifier_p
2705 = (cp_parser_nested_name_specifier_opt (parser,
2706 /*typename_keyword_p=*/false,
2707 check_dependency_p,
2708 /*type_p=*/false,
2709 declarator_p)
2710 != NULL_TREE);
2711 /* If there is a nested-name-specifier, then we are looking at
2712 the first qualified-id production. */
2713 if (nested_name_specifier_p)
2714 {
…
2740 }
2741 /* Otherwise, if we are in global scope, then we are looking at one
2742 of the other qualified-id productions. */
2743 else if (global_scope_p)
2744 {
…
2787 }
2788 else
2789 return cp_parser_unqualified_id (parser, template_keyword_p,
2790 /*check_dependency_p=*/true,
2791 declarator_p);
2792 }
对于例子中的构造函数，这个unqualifier-id是一个简单的标识符。
2816 static tree
2817 cp_parser_unqualified_id (cp_parser* parser, in parser.c
2818 bool template_keyword_p,
2819 bool check_dependency_p,
2820 bool declarator_p)
2821 {
2822 cp_token *token;
2823
2824 /* Peek at the next token. */
2825 token = cp_lexer_peek_token (parser->lexer);
2826
2827 switch (token->type)
2828 {
2829 case CPP_NAME:
2830 {
2831 tree id;
2832
2833 /* We don't know yet whether or not this will be a
2834 template-id. */
2835 cp_parser_parse_tentatively (parser);
2836 /* Try a template-id. */
2837 id = cp_parser_template_id (parser, template_keyword_p,
2838 check_dependency_p,
2839 declarator_p);
2840 /* If it worked, we're done. */
2841 if (cp_parser_parse_definitely (parser))
2842 return id;
2843 /* Otherwise, it's an ordinary identifier. */
2844 return cp_parser_identifier (parser);
2845 }
…
3033 }
3034 }
在10583行，标识符“Lock”作为声明符取入declarator中。注意到在下面的10640行，ctor_dtor_or_conv_p是一个指针，现在它指向在cp_parser_member_declaration中12668行的变量ctor_dtor_or_conv_p。因为我们现在在类“Lock”中，满足10643行的条件。
cp_parser_direct_declarator (continue)
10638 /* Check to see whether the declarator-id names a constructor,
10639 destructor, or conversion. */
10640 if (declarator && ctor_dtor_or_conv_p
10641 && ((TREE_CODE (declarator) == SCOPE_REF
10642 && CLASS_TYPE_P (TREE_OPERAND (declarator, 0)))
10643 || (TREE_CODE (declarator) != SCOPE_REF
10644 && at_class_scope_p ())))
10645 {
10646 tree unqualified_name;
10647 tree class_type;
10648
10649 /* Get the unqualified part of the name. */
10650 if (TREE_CODE (declarator) == SCOPE_REF)
10651 {
10652 class_type = TREE_OPERAND (declarator, 0);
10653 unqualified_name = TREE_OPERAND (declarator, 1);
10654 }
10655 else
10656 {
10657 class_type = current_class_type;
10658 unqualified_name = declarator;
10659 }
10660
10661 /* See if it names ctor, dtor or conv. */
10662 if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR
10663 || IDENTIFIER_TYPENAME_P (unqualified_name)
10664 || constructor_name_p (unqualified_name, class_type)
10665 || (TREE_CODE (unqualified_name) == TYPE_DECL
10666 && same_type_p (TREE_TYPE (unqualified_name),
10667 class_type)))
10668 *ctor_dtor_or_conv_p = -1;
10669 }
10670
10671 handle_declarator:;
10672 scope = get_scope_of_declarator (declarator);
10673 if (scope)
10674 /* Any names that appear after the declarator-id for a
10675 member are looked up in the containing scope. */
10676 pop_p = push_scope (scope);
10677 parser->in_declarator_p = true;
10678 if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
10679 || (declarator
10680 && (TREE_CODE (declarator) == SCOPE_REF
10681 || TREE_CODE (declarator) == IDENTIFIER_NODE)))
10682 /* Default args are only allowed on function
10683 declarations. */
10684 parser->default_arg_ok_p = saved_default_arg_ok_p;
10685 else
10686 parser->default_arg_ok_p = false;
10687
10688 first = false;
10689 }
10690 /* We're done. */
10691 else
10692 break;
10693 }
10694
10695 /* For an abstract declarator, we might wind up with nothing at this
10696 point. That's an error; the declarator is not optional. */
10697 if (!declarator)
10698 cp_parser_error (parser, "expected declarator");
10699
10700 /* If we entered a scope, we must exit it now. */
10701 if (pop_p)
10702 pop_scope (scope);
10703
10704 parser->default_arg_ok_p = saved_default_arg_ok_p;
10705 parser->in_declarator_p = saved_in_declarator_p;
10706
10707 return declarator;
10708 }
在这里ctor_dtor_or_conv_p用于检测构造函数，析构函数或转换操作符。如果该声明符是一个名字，它被设置为-1，如果是一个函数则是+1，否则就被设置为0。因此在10668行，ctor_dtor_or_conv_p被设置为-1。
进一步的，如果获得的声明符是SCOPE_REF，它指出了其后符号的绑定作用域，在处理后续符号之前，需要使得这个域成为当前作用域。在10672行，函数get_scope_of_declarator 检查是否有任何一个这样的域能从declarator获取，如果有，该函数返回相应的树节点。
注意在10677行的赋值，因为我们已经见到声明符，设置parser中的标记in_declarator_p来表明这个事实。这个标记将影响声明符后续符号的解析过程。对于我们的例子“Lock() {}”，“Lock”后面的符号是“(”。它将回到10392行的WHILE循环，并执行下面的代码。注意这里的member_p是true。
cp_parser_direct_declarator (continue)
10392 while (true)
10393 {
10394 /* Peek at the next token. */
10395 token = cp_lexer_peek_token (parser->lexer);
10396 if (token->type == CPP_OPEN_PAREN)
10397 {
10398 /* This is either a parameter-declaration-clause, or a
10399 parenthesized declarator. When we know we are parsing a
10400 named declarator, it must be a parenthesized declarator
10401 if FIRST is true. For instance, `(int)' is a
10402 parameter-declaration-clause, with an omitted
10403 direct-abstract-declarator. But `((*))', is a
10404 parenthesized abstract declarator. Finally, when T is a
10405 template parameter `(T)' is a
10406 parameter-declaration-clause, and not a parenthesized
10407 named declarator.
10408
10409 We first try and parse a parameter-declaration-clause,
10410 and then try a nested declarator (if FIRST is true).
10411
10412 It is not an error for it not to be a
10413 parameter-declaration-clause, even when FIRST is
10414 false. Consider,
10415
10416 int i (int);
10417 int i (3);
10418
10419 The first is the declaration of a function while the
10420 second is a the definition of a variable, including its
10421 initializer.
10422
10423 Having seen only the parenthesis, we cannot know which of
10424 these two alternatives should be selected. Even more
10425 complex are examples like:
10426
10427 int i (int (a));
10428 int i (int (3));
10429
10430 The former is a function-declaration; the latter is a
10431 variable initialization.
10432
10433 Thus again, we try a parameter-declaration-clause, and if
10434 that fails, we back out and return. */
10435
10436 if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
10437 {
10438 tree params;
10439 unsigned saved_num_template_parameter_lists;
10440
10441 /* In a member-declarator, the only valid interpretation
10442 of a parenthesis is the start of a
10443 parameter-declaration-clause. (It is invalid to
10444 initialize a static data member with a parenthesized
10445 initializer; only the "=" form of initialization is
10446 permitted.) */
10447 if (!member_p)
10448 cp_parser_parse_tentatively (parser);
10449
10450 /* Consume the `('. */
10451 cp_lexer_consume_token (parser->lexer);
10452 if (first)
10453 {
10454 /* If this is going to be an abstract declarator, we're
10455 in a declarator and we can't have default args. */
10456 parser->default_arg_ok_p = false;
10457 parser->in_declarator_p = true;
10458 }
10459
10460 /* Inside the function parameter list, surrounding
10461 template-parameter-lists do not apply. */
10462 saved_num_template_parameter_lists
10463 = parser->num_template_parameter_lists;
10464 parser->num_template_parameter_lists = 0;
10465
10466 /* Parse the parameter-declaration-clause. */
10467 params = cp_parser_parameter_declaration_clause (parser);
10468
10469 parser->num_template_parameter_lists
10470 = saved_num_template_parameter_lists;
10471
10472 /* If all went well, parse the cv-qualifier-seq and the
10473 exception-specification. */
10474 if (member_p || cp_parser_parse_definitely (parser))
10475 {
10476 tree cv_qualifiers;
10477 tree exception_specification;
10478
10479 if (ctor_dtor_or_conv_p)
10480 *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
10481 first = false;
10482 /* Consume the `)'. */
10483 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
10484
10485 /* Parse the cv-qualifier-seq. */
10486 cv_qualifiers = cp_parser_cv_qualifier_seq_opt (parser);
10487 /* And the exception-specification. */
10488 exception_specification
10489 = cp_parser_exception_specification_opt (parser);
10490
10491 /* Create the function-declarator. */
10492 declarator = make_call_declarator (declarator,
10493 params,
10494 cv_qualifiers,
10495 exception_specification);
10496 /* Any subsequent parameter lists are to do with
10497 return type, so are not those of the declared
10498 function. */
10499 parser->default_arg_ok_p = false;
10500
10501 /* Repeat the main loop. */
10502 continue;
10503 }
10504 }
看到后面的符号中没有参数，cv-qualifier-seq及exception-specification出现，仅执行make_call_declarator。
121 tree
122 make_call_declarator (tree target, tree parms, tree cv_qualifiers, in lex.c
123 tree exception_specification)
124 {
125 target = build_nt (CALL_EXPR, target,
126 tree_cons (parms, cv_qualifiers, NULL_TREE),
127 /* The third operand is really RTL. We
128 shouldn't put anything there. */
129 NULL_TREE);
130 CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
131 return target;
132 }
通过这个函数，为声明符创建了树节点CALL_EXPR。那么返回到cp_parser_declarator进一步把它连同可能出现的属性封装入另一个tree_list节点。当返回到cp_parser_member_declaration时，如下的节点将得到创建。
（点此打开）
图67：类“Lock”构造函数的CALL_EXPR
3558
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
