5.12.3.2.1.1.1. 解析类体 – typedef 声明
5.12.3.2.1.1.4.1. 找出 decl-specifier-spec 及 declarator
退出结构体“ Lock ”的定义，现在回到类“ SingleThreaded ”的定义。接下来的声明是“ typedef Host VolatileType; ”。
对于这个声明，“ typedef Host ”部分是 decl-specifier-seq ，而“ VolatileType ”就是声明符。再一次，我们的旅程从 cp_parser_member_declaration 开始，这个函数逐个处理类的方法。
12457 static void
12458 cp _parser_member_declaration (cp_parser* parser) in parser.c
12459 {
12460 tree decl_specifiers;
12461 tree prefix_attributes;
12462 tree decl;
12463 int declares_class_or_enum;
12464 bool friend_p;
12465 cp_token *token;
12466 int saved_pedantic;
…
12502 /* Parse the decl-specifier-seq. */
12503 decl_specifiers
12504 = cp_parser_decl_specifier_seq (parser,
12505 CP_PARSER_FLAGS_OPTIONAL,
12506 &prefix_attributes,
12507 &declares_class_or_enum);
关键字“ typedef ” 仅使得 cp_parser_decl_specifier_seq 返回表示“ typedef ”的全局唯一的标识符节点，这个节点在设置运行时环境时创建。同时标识符“ Host ”则经历以下的调用栈来找出对应的 TYPE_DECL 节点。
cp_parser_type_specifier à cp_parser_simple_type_specifier à cp_parser_type_name à cp_parser_class_name 。那么在 12504 行的 decl_specifiers 如下图所示。
（ 点此打开 ）
图 87 ：对应 typedef 声明的 decl-specifier-seq
那么对于声明符“ VolatileType ”，通过以下的调用栈，它被识别为一个新的标识符： cp_parser_declarator à cp_parser_direct_declarator à cp_parser_declarator_id à cp_parser_id_expression à cp_parser_unqualified_id à cp_parser_identifier 。
cp_parser_member_declaration (continue)
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);
…
12710 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
12711 {
…
12730 }
12731 /* Otherwise, there is no initializer. */
12732 else
12733 initializer = NULL_TREE;
5.12.3.2.1.1.4.2. 为类字段构建节点
在解析了 decl-specifier-seq 及 declarator 后，需要把结果打包入相应的节点，并插入中间树中。
cp_parser_member_declaration (continue)
12735 /* See if we are probably looking at a function
12736 definition. We are certainly not looking at at a
12737 member-declarator. Calling `grokfield' has
12738 side-effects, so we must not do it unless we are sure
12739 that we are looking at a member-declarator. */
12740 if (cp_parser_token_starts_function_definition_p
12741 ( cp_lexer_peek_token (parser->lexer)))
12742 {
…
12763 }
12764 else
12765 {
12766 /* Create the declaration. */
12767 decl = grokfield (declarator, decl_specifiers,
12768 initializer, asm_specification,
12769 attributes);
12770 /* Any initialization must have been from a
12771 constant-expression. */
12772 if (decl && TREE_CODE (decl) == VAR_DECL && initializer)
12773 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
12774 }
12775 }
相应地如果这不是一个函数定义，它被假设为域来处理。在前一节中，我们已经看过特殊函数定义的处理——构造函数。
821 tree
822 grokfield (tree declarator, tree declspecs, tree init, tree asmspec_tree, in decl2.c
823 tree attrlist)
824 {
825 tree value;
826 const char *asmspec = 0;
827 int flags = LOOKUP_ONLYCONVERTING;
828
829 if (declspecs == NULL_TREE
830 && TREE_CODE (declarator) == SCOPE_REF
831 && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE)
832 {
833 /* Access declaration */
834 if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
835 ;
836 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
837 pop_nested_class ();
838 return do_class_using_decl (declarator);
839 }
840
841 if (init
842 && TREE_CODE (init) == TREE_LIST
843 && TREE_VALUE (init) == error_mark_node
844 && TREE_CHAIN (init) == NULL_TREE)
845 init = NULL_TREE;
846
847 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
848 if (! value || error_operand_p (value))
849 /* friend or constructor went bad. */
850 return error_mark_node;
该函数也需要 grokdeclarator 来为域声明创建合适的树节点。在这次调用中， initialized 是 false ，而 attrlist 是 NULL_TREE 。
6462 tree
6463 grokdeclarator (tree declarator, in decl.c
6464 tree declspecs,
6465 enum decl_context decl_context,
6466 int initialized,
6467 tree* attrlist)
6468 {
6469 RID_BIT_TYPE specbits;
6470 int nclasses = 0;
6471 tree spec;
6472 tree type = NULL_TREE;
6473 int longlong = 0;
6474 int type_quals;
6475 int virtualp, explicitp, friendp, inlinep, staticp;
6476 int explicit_int = 0;
6477 int explicit_char = 0;
6478 int defaulted_int = 0;
6479 int extern_langp = 0;
6480 tree dependant_name = NULL_TREE;
6481
6482 tree typedef_decl = NULL_TREE;
6483 const char *name;
6484 tree typedef_type = NULL_TREE;
6485 int funcdef_flag = 0;
6486 enum tree_code innermost_code = ERROR_MARK;
6487 int bitfield = 0;
6488 #if 0
6489 /* See the code below that used this. */
6490 tree decl_attr = NULL_TREE;
6491 #endif
6492
6493 /* Keep track of what sort of function is being processed
6494 so that we can warn about default return values, or explicit
6495 return values which do not match prescribed defaults. */
6496 special_function_kind sfk = sfk_none;
6497
6498 tree dname = NULL_TREE;
6499 tree ctype = current_class_type ;
6500 tree ctor_return_type = NULL_TREE;
6501 enum overload_flags flags = NO_SPECIAL;
6502 tree quals = NULL_TREE;
6503 tree raises = NULL_TREE;
6504 int template_count = 0;
6505 tree in_namespace = NULL_TREE;
6506 tree returned_attrs = NULL_TREE;
6507 tree scope = NULL_TREE;
6508 tree parms = NULL_TREE;
6509
6510 RIDBIT_RESET_ALL (specbits);
6511 if (decl_context == FUNCDEF)
6512 funcdef_flag = 1, decl_context = NORMAL;
6513 else if (decl_context == MEMFUNCDEF)
6514 funcdef_flag = -1, decl_context = FIELD;
6515 else if (decl_context == BITFIELD)
6516 bitfield = 1, decl_context = FIELD;
6517
6518 /* Look inside a declarator for the name being declared
6519 and get it as a string, for an error message. */
6520 {
6521 tree *next = &declarator;
6522 tree decl;
6523 name = NULL;
6524
6525 while (next && *next)
6526 {
6527 decl = *next;
6528 switch (TREE_CODE (decl))
6529 {
…
6629 case IDENTIFIER_NODE:
6630 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6631 dname = decl;
6632
6633 next = 0;
6634
6635 if (C_IS_RESERVED_WORD (dname))
6636 {
6637 error ("declarator-id missing; using reserved word `%D'",
6638 dname);
6639 name = IDENTIFIER_POINTER (dname);
6640 }
6641 else if (!IDENTIFIER_TYPENAME_P (dname))
6642 name = IDENTIFIER_POINTER (dname);
6643 else
6644 {
6645 my_friendly_assert (flags == NO_SPECIAL, 154);
6646 flags = TYPENAME_FLAG;
6647 ctor_return_type = TREE_TYPE (dname);
6648 sfk = sfk_conversion;
6649 if (is_typename_at_global_scope (dname))
6650 name = IDENTIFIER_POINTER (dname);
6651 else
6652 name = "<invalid operator>";
6653 }
6654 break ;
…
6784 }
6785 }
6786 }
正如我们之前所见，首先，函数处理声明符来找出 decl-specifier-seq 所描述对象。这里，在 6631 行，标识符“ VolatileType ”被赋予 dname 。在 6642 行， IDENTIFIER_POINTER 返回该标识符中的代表名字的字符串（即字符串“ VolatileType ”）。
然后在对声明符处理结果的一些检查后，开始处理 decl-specifier-seq 部分。这里的 decl-specifier-seq 的第一部分是关键字“ typedef ”。我们已经在函数 init_reswords 中看到，它的信息被记录在全局数组 ridpointers 里，因此在下面的 6929 行， RIDBIT_SET 把看到 typedef 的事实记录入 specbits 。
grokdeclarator (continue)
6828 /* Look through the decl specs and record which ones appear.
6829 Some typespecs are defined as built-in typenames.
6830 Others, the ones that are modifiers of other types,
6831 are represented by bits in SPECBITS: set the bits for
6832 the modifiers that appear. Storage class keywords are also in SPECBITS.
6833
6834 If there is a typedef name or a type, store the type in TYPE.
6835 This includes builtin typedefs such as `int'.
6836
6837 Set EXPLICIT_INT if the type is `int' or `char' and did not
6838 come from a user typedef.
6839
6840 Set LONGLONG if `long' is mentioned twice.
6841
6842 For C++, constructors and destructors have their own fast treatment. */
6843
6844 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
6845 {
6846 int i;
6847 tree id;
6848
6849 /* Certain parse errors slip through. For example,
6850 `int class;' is not caught by the parser. Try
6851 weakly to recover here. */
6852 if (TREE_CODE (spec) != TREE_LIST)
6853 return 0;
6854
6855 id = TREE_VALUE (spec);
6856
6857 /* If the entire declaration is itself tagged as deprecated then
6858 suppress reports of deprecated items. */
6859 if (!adding_implicit_members && id && TREE_DEPRECATED (id))
6860 {
6861 if (deprecated_state != DEPRECATED_SUPPRESS)
6862 warn_deprecated_use (id);
6863 }
6864
6865 if (TREE_CODE (id) == IDENTIFIER_NODE)
6866 {
6867 if (id == ridpointers [(int) RID_INT]
6868 || id == ridpointers [(int) RID_CHAR]
6869 || id == ridpointers [(int) RID_BOOL]
6870 || id == ridpointers [(int) RID_WCHAR])
6871 {
6872 if (type)
6873 {
6874 if (id == ridpointers [(int) RID_BOOL])
6875 error ("`bool' is now a keyword");
6876 else
6877 error ("extraneous `%T' ignored", id);
6878 }
6879 else
6880 {
6881 if (id == ridpointers [(int) RID_INT])
6882 explicit_int = 1;
6883 else if (id == ridpointers [(int) RID_CHAR])
6884 explicit_char = 1;
6885 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
6886 }
6887 goto found;
6888 }
6889 /* C++ aggregate types. */
6890 if (IDENTIFIER_HAS_TYPE_VALUE (id))
6891 {
6892 if (type)
6893 error ("multiple declarations `%T' and `%T'", type, id);
6894 else
6895 type = IDENTIFIER_TYPE_VALUE (id);
6896 goto found;
6897 }
6898
6899 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
6900 {
6901 if (ridpointers [i] == id)
6902 {
6903 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
6904 {
6905 if (pedantic && ! in_system_header && warn_long_long )
6906 pedwarn ("ISO C++ does not support `long long'");
6907 if (longlong)
6908 error ("`long long long' is too long for GCC");
6909 else
6910 longlong = 1;
6911 }
6912 else if (RIDBIT_SETP (i, specbits))
6913 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
6914
6915 /* Diagnose "__thread extern" or "__thread static". */
6916 if (RIDBIT_SETP (RID_THREAD, specbits))
6917 {
6918 if (i == (int)RID_EXTERN)
6919 error ("`__thread' before `extern'");
6920 else if (i == (int)RID_STATIC)
6921 error ("`__thread' before `static'");
6922 }
6923
6924 if (i == (int)RID_EXTERN
6925 && TREE_PURPOSE (spec) == error_mark_node)
6926 /* This extern was part of a language linkage. */
6927 extern_langp = 1;
6928
6929 RIDBIT_SET (i, specbits);
6930 goto found;
6931 }
6932 }
6933 }
6934 else if (TREE_CODE (id) == TYPE_DECL)
6935 {
6936 if (type)
6937 error ("multiple declarations `%T' and `%T'", type,
6938 TREE_TYPE (id));
6939 else
6940 {
6941 type = TREE_TYPE (id);
6942 TREE_VALUE (spec) = type;
6943 typedef_decl = id;
6944 }
6945 goto found;
6946 }
6947 if (type)
6948 error ("two or more data types in declaration of `%s'", name);
6949 else if (TREE_CODE (id) == IDENTIFIER_NODE)
6950 {
6951 tree t = lookup_name (id, 1);
6952 if (!t || TREE_CODE (t) != TYPE_DECL)
6953 error ("`%s' fails to be a typedef or built in type",
6954 IDENTIFIER_POINTER (id));
6955 else
6956 {
6957 type = TREE_TYPE (t);
6958 typedef_decl = t;
6959 }
6960 }
6961 else if (id != error_mark_node)
6962 /* Can't change CLASS nodes into RECORD nodes here! */
6963 type = id;
6964
6965 found: ;
6966 }
而 decl-specifier-seq 的第二部分是代表“ Host ”的 TYPE_DECL ，它被 6934 到 6949 的代码所处理。注意到从 6949 到 6960 行的代码只是处理发现的未能解析的名字。此时， declspecs 看起来如下：
（ 点此打开 ）
图 88 ：处理 decl-specifier-seq 后的 declspecs
下面的 nclasses 记录了已经见到的存储类别声明符的数目。除了“ static __thread ”及“ extern __thread ”，每个声明符只允许有一个存储类别声明符。
grokdeclarator (continue)
6973 typedef_type = type;
…
7019 ctype = NULL_TREE;
…
7206 if (RIDBIT_ANY_SET (specbits))
7207 {
7208 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
7209 if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
7210 if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
7211 if (decl_context == PARM && nclasses > 0)
7212 error ("storage class specifiers invalid in parameter declarations");
7213 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7214 {
7215 if (decl_context == PARM)
7216 error ("typedef declaration invalid in parameter declaration");
7217 nclasses++;
7218 }
7219 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
7220 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
7221 if (!nclasses && !friendp && extern_langp)
7222 nclasses++;
7223 }
…
7249 if (nclasses > 1)
7250 error ("multiple storage classes in declaration of `%s'", name);
…
7930 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
7931 {
7932 tree decl;
7933
7934 /* Note that the grammar rejects storage classes
7935 in typenames, fields or parameters. */
7936 if (current_lang_name == lang_name_java)
7937 TYPE_FOR_JAVA (type) = 1;
7938
7939 if (decl_context == FIELD)
7940 {
7941 if (constructor_name_p (declarator, current_class_type ))
7942 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
7943 declarator);
7944 decl = build_lang_decl (TYPE_DECL, declarator, type);
7945 }
7946 else
7947 {
7948 decl = build_decl (TYPE_DECL, declarator, type);
7949 if (in_namespace || ctype)
7950 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7951 if (!current_function_decl )
7952 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7953 }
7954
7955 /* If the user declares "typedef struct {...} foo" then the
7956 struct will have an anonymous name. Fill that name in now.
7957 Nothing can refer to it, so nothing needs know about the name
7958 change. */
7959 if (type != error_mark_node
7960 && declarator
7961 && TYPE_NAME (type)
7962 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7963 && TYPE_ANONYMOUS_P (type)
7964 /* Don't do this if there are attributes. */
7965 && (!attrlist || !*attrlist)
7966 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7967 {
7968 tree oldname = TYPE_NAME (type);
7969 tree t;
7970
7971 /* Replace the anonymous name with the real name everywhere. */
7972 lookup_tag_reverse (type, declarator);
7973 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7974 if (TYPE_NAME (t) == oldname)
7975 TYPE_NAME (t) = decl;
7976
7977 if (TYPE_LANG_SPECIFIC (type))
7978 TYPE_WAS_ANONYMOUS (type) = 1;
7979
7980 /* If this is a typedef within a template class, the nested
7981 type is a (non-primary) template. The name for the
7982 template needs updating as well. */
7983 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7984 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7985 = TYPE_IDENTIFIER (type);
7986
7987 /* FIXME remangle member functions; member functions of a
7988 type with external linkage have external linkage. */
7989 }
7990
7991 if (quals)
7992 {
7993 if (ctype == NULL_TREE)
7994 {
7995 if (TREE_CODE (type) != METHOD_TYPE)
7996 error ("%Jinvalid type qualifier for non-member function type",
7997 decl);
7998 else
7999 ctype = TYPE_METHOD_BASETYPE (type);
8000 }
8001 if (ctype != NULL_TREE)
8002 grok_method_quals (ctype, decl, quals);
8003 }
8004
8005 if (RIDBIT_SETP (RID_SIGNED, specbits)
8006 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8007 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8008
8009 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
8010 inlinep, friendp, raises != NULL_TREE);
8011
8012 return decl;
8013 }
对于 typedef 声明，在创建了 TYPE_DEF 节点之后，绝大部分工作已经完成，在 8009 行， bad_specifier 检查不应该出现在声明符里的声明符。
5540 static void
5541 bad_specifiers (tree object, in decl.c
5542 const char* type,
5543 int virtualp,
5544 int quals,
5545 int inlinep,
5546 int friendp,
5547 int raises)
5548 {
5549 if (virtualp)
5550 error ("`%D' declared as a `virtual' %s", object, type);
5551 if (inlinep)
5552 error ("`%D' declared as an `inline' %s", object, type);
5553 if (quals)
5554 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
5555 object, type);
5556 if (friendp)
5557 cp_error_at ("`%D' declared as a friend", object);
5558 if (raises
5559 && (TREE_CODE (object) == TYPE_DECL
5560 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5561 && !TYPE_REFFN_P (TREE_TYPE (object))
5562 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5563 cp_error_at ("`%D' declared with an exception specification", object);
5564 }
5.12.3.2.1.1.4.3. 加入类字段的节点
下面的 value 是为 typedef 语句构建的 TYPE_DECL 节点。在 881 行的 push_template_decl 之前，它具有如下的结构。
（ 点此打开 ）
图 89 ： typedef 声明的 TYPE_DECL
同样，因为 current_class_type 是“ SingleThreaded ”，这是一个仍旧在定义中的模板，毫无疑问， push_template_decl 被调用来为 typedef 语句构建及插入相应的 TEMPLATE_DECL 节点。
grokfield (continue)
852 if (TREE_CODE (value) == TYPE_DECL && init)
853 {
854 error ("typedef `%D' is initialized (use __typeof__ instead)", value);
855 init = NULL_TREE;
856 }
857
858 /* Pass friendly classes back. */
859 if (value == void_type_node)
860 return value;
861
862 /* Pass friend decls back. */
863 if ((TREE_CODE (value) == FUNCTION_DECL
864 || TREE_CODE (value) == TEMPLATE_DECL)
865 && DECL_CONTEXT (value) != current_class_type )
866 return value;
867
868 if (DECL_NAME (value) != NULL_TREE
869 && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
870 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
871 error ("member `%D' conflicts with virtual function table field name",
872 value);
873
874 /* Stash away type declarations. */
875 if (TREE_CODE (value) == TYPE_DECL)
876 {
877 DECL_NONLOCAL (value) = 1;
878 DECL_CONTEXT (value) = current_class_type ;
879
880 if (processing_template_decl )
881 value = push_template_decl (value);
882
883 return value;
884 }
…
995 }
接下来在 push_template_decl_real 中，同样 primary 也是 false ，因为我们不是在 sk_template_parm 域中。整个过程与我们之前看到的相同。那么我们将得到以下的中间树，而在 881 行的 value 指向所创建的 TEMPLATE_DECL 节点的 result 域。
（ 点此打开 ）
图 90 ：插入 typedef 声明的节点
那么当从 grokfield 返回时， cp_parser_member_declaration 知道这是类的项，因此检查后续的符号，并在 12806 行由 finish_member_declaration 把该项加入类中。
cp_parser_member_declaration (continue)
12777 /* Reset PREFIX_ATTRIBUTES. */
12778 while (attributes && TREE_CHAIN (attributes) != first_attribute)
12779 attributes = TREE_CHAIN (attributes);
12780 if (attributes)
12781 TREE_CHAIN (attributes) = NULL_TREE;
12782
12783 /* If there is any qualification still in effect, clear it
12784 now; we will be starting fresh with the next declarator. */
12785 parser->scope = NULL_TREE;
12786 parser->qualifying_scope = NULL_TREE;
12787 parser->object_scope = NULL_TREE;
12788 /* If it's a `,', then there are more declarators. */
12789 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
12790 cp_lexer_consume_token (parser->lexer);
12791 /* If the next token isn't a `;', then we have a parse error. */
12792 else if (cp_lexer_next_token_is_not (parser->lexer,
12793 CPP_SEMICOLON))
12794 {
12795 cp_parser_error (parser, "expected `;'");
12796 /* Skip tokens until we find a `;'. */
12797 cp_parser_skip_to_end_of_statement (parser);
12798
12799 break ;
12800 }
12801
12802 if (decl)
12803 {
12804 /* Add DECL to the list of members. */
12805 if (!friend_p)
12806 finish_member_declaration (decl);
12807
12808 if (TREE_CODE (decl) == FUNCTION_DECL)
12809 cp_parser_save_default_args (parser, decl);
12810 }
12811 }
12812 }
12813
12814 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
12815 }
finish_member_declaration 的细节参考章节 作为成员加入类域 ，解析之后，中间树现在如下：
（ 点此打开 ）
图 91 ： 完成 typedef 语句
1030
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
