Studying note of GCC-3.4.6 source (114)

最新推荐文章于 2024-10-18 21:10:45 发布

wuhui_gdnt

最新推荐文章于 2024-10-18 21:10:45 发布

阅读量638

点赞数

分类专栏： Studying note of GCC-3.4.6 source 文章标签： tree token class list processing binding

本文链接：https://blog.csdn.net/wuhui_gdnt/article/details/5948395

版权

Studying note of GCC-3.4.6 source 专栏收录该内容

202 篇文章 1 订阅

订阅专栏

5.12.4. The second example

We have seen the procedure parser handles the template-class “SingleThreaded”, however, this example is quite simple in view of template declaration. Next we will see template declaration that derived from “SingleThreaded”, it can give us enlightment about how front-end processes template-template parameter, and inheritage. Here is the class-head we will hanlde:

template

template <class > class ThreadingModel = DEFAULT_THREADING,

std ::size_t chunkSize = DEFAULT_CHUNK_SIZE,

std ::size_t maxSmallObjectSize = MAX_SMALL_OBJECT_SIZE

class SmallObject : public ThreadingModel<

SmallObject<ThreadingModel, chunkSize, maxSmallObjectSize> >

In which DEFAULT_THREADING aliases to “::Loki::SingleThreaded”. The declaration obeys the rule:

template-declaration:

export [opt] template-parameter-list-seq decl-specifier-seq [opt] init-declarator [opt] ;

5.12.4.1. Parse template parameter list

5.12.4.1.1. Template template parameter

5.12.4.1.1.1. The parameter

Like previous example, it undergoes the calls stack of cp_parser_template_declaration à cp_parser_template_declaration_after_export à begin_template_parm_list (inserts scope of sk_template_parms), cp_parser_template_parameter_list à cp_parser_template_parameter à cp_parser_type_parameter . Following code of cp_parser_type_parameter is run for the example.

7720 static tree

7721 cp_parser_type_parameter (cp_parser* parser) in parser.c

7722 {

7723 cp_token *token;

7724 tree parameter;

7725

7726 /* Look for a keyword to tell us what kind of parameter this is. */

7727 token = cp_parser_require (parser, CPP_KEYWORD,

7728 "`class', `typename', or `template'");

7729 if (!token)

7730 return error_mark_node;

7731

7732 switch (token->keyword)

7733 {

7734 case RID_CLASS:

7735 case RID_TYPENAME:

7736 {

...

7764 }

7765 break ;

7766

7767 case RID_TEMPLATE:

7768 {

7769 tree parameter_list;

7770 tree identifier;

7771 tree default_argument;

7772

7773 /* Look for the `<'. */

7774 cp_parser_require (parser, CPP_LESS, "`<'");

7775 /* Parse the template-parameter-list. */

7776 begin_template_parm_list ();

7777 parameter_list

7778 = cp_parser_template_parameter_list (parser);

7779 parameter_list = end_template_parm_list (parameter_list);

The first template parameter of our example is the template template parameter which begins with keyword template. This keyword template makes thing interesting now – a further scope of sk_template_parms is pushed in, and we will get following structure.

Figure 96 : before handling template template parameter

For the template template parameter, itself is a template declaration too. Here in the example, the template template parameter is: “template <class> class ThreadingModel”, and now the leading “template <” is consumed by parser. So in cp_parser_template_parameter (invoked by cp_parser_template_parameter_list at line 7778) following code is performed for the coming token “class”.

7654 static tree

7655 cp_parser_template_parameter (cp_parser* parser) in parser.c

7656 {

7657 cp_token *token;

7658

7659 /* Peek at the next token. */

7660 token = cp_lexer_peek_token (parser->lexer);

7661 /* If it is `class' or `template', we have a type-parameter. */

7662 if (token->keyword == RID_TEMPLATE)

7663 return cp_parser_type_parameter (parser);

7664 /* If it is `class' or `typename' we do not know yet whether it is a

7665 type parameter or a non-type parameter. Consider:

7666

7667 template <typename T, typename T::X X> ...

7668

7669 or:

7670

7671 template <class C, class D*> ...

7672

7673 Here, the first parameter is a type parameter, and the second is

7674 a non-type parameter. We can tell by looking at the token after

7675 the identifier -- if it is a `,', `=', or `>' then we have a type

7676 parameter. */

7677 if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)

7678 {

7679 /* Peek at the token after `class' or `typename'. */

7680 token = cp_lexer_peek_nth_token (parser->lexer, 2);

7681 /* If it's an identifier, skip it. */

7682 if (token->type == CPP_NAME)

7683 token = cp_lexer_peek_nth_token (parser->lexer, 3);

7684 /* Now, see if the token looks like the end of a template

7685 parameter. */

7686 if (token->type == CPP_COMMA

7687 || token->type == CPP_EQ

7688 || token->type == CPP_GREATER)

7689 return cp_parser_type_parameter (parser);

7690 }

…

7703 }

Obviously, part “<class>” is the template parameter for the template template parameter; it is awkward-sounding, but shows the power of C++. Template can be nested to deep level – the standard defines that at least 12 levels should be allowed, in fact, every commercial compiler offers nesting level no less than 128.

For this template parameter “<class>”, cp_parser_type_parameter is recursed.

7720 static tree

7721 cp_parser_type_parameter (cp_parser* parser) in parser.c

7722 {

7723 cp_token *token;

7724 tree parameter;

7725

7726 /* Look for a keyword to tell us what kind of parameter this is. */

7727 token = cp_parser_require (parser, CPP_KEYWORD,

7728 "`class', `typename', or `template'");

7729 if (!token)

7730 return error_mark_node;

7731

7732 switch (token->keyword)

7733 {

7734 case RID_CLASS:

7735 case RID_TYPENAME:

7736 {

7737 tree identifier;

7738 tree default_argument;

7739

7740 /* If the next token is an identifier, then it names the

7741 parameter. */

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

7743 identifier = cp_parser_identifier (parser);

7744 else

7745 identifier = NULL_TREE;

7746

7747 /* Create the parameter. */

7748 parameter = finish_template_type_parm (class_type_node, identifier);

7749

7750 /* If the next token is an `=', we have a default argument. */

7751 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))

7752 {

...

7757 }

7758 else

7759 default_argument = NULL_TREE;

7760

7761 /* Create the combined representation of the parameter and the

7762 default argument. */

7763 parameter = build_tree_list (default_argument, parameter);

7764 }

7765 break ;

…

7848 }

7849

7850 return parameter;

7851 }

Above finish_template_type_parm creates a tree_list for the paramete; and further integrating into another tree_list at line 7763. Then parameter refers to nodes as below as the parameter is nameless and hasn’t default value.

Figure 97 : parameter node for template template parameter

Then back into cp_parser_template_parameter_list , process_template_parm packs template parameters. And note that it is the template parameter for the template template parameter! The argument next just refers to the node parameter in above figure.

2161 tree

2162 process_template_parm (tree list, tree next) in pt.c

2163 {

2164 tree parm;

2165 tree decl = 0;

2166 tree defval;

2167 int is_type, idx;

2168

2169 parm = next;

2170 my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);

2171 defval = TREE_PURPOSE (parm);

2172 parm = TREE_VALUE (parm);

2173 is_type = TREE_PURPOSE (parm) == class_type_node;

2174

2175 if (list)

2176 {

…

2184 }

2185 else

2186 idx = 0;

2187

2188 if (!is_type)

2189 {

…

2212 }

2213 else

2214 {

2215 tree t;

2216 parm = TREE_VALUE (parm);

2217

2218 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)

2219 {

...

2226 }

2227 else

2228 {

2229 t = make_aggr_type (TEMPLATE_TYPE_PARM);

2230 /* parm is either IDENTIFIER_NODE or NULL_TREE. */

2231 decl = build_decl (TYPE_DECL, parm, t);

2232 }

2233

2234 TYPE_NAME (t) = decl;

2235 TYPE_STUB_DECL (t) = decl;

2236 parm = decl;

2237 TEMPLATE_TYPE_PARM_INDEX (t)

2238 = build_template_parm_index (idx, processing_template_decl ,

2239 processing_template_decl ,

2240 decl, TREE_TYPE (parm));

2241 }

2242 DECL_ARTIFICIAL (decl) = 1;

2243 SET_DECL_TEMPLATE_PARM_P (decl);

2244 pushdecl (decl);

2245 parm = build_tree_list (defval, parm);

2246 return chainon (list, parm);

2247 }

Here begin_template_parm_list has been invoked twice so far, then processing_template_decl is 2. Note that TYPE_DECL of TEMPLATE_TPYE_PARM is nameless, so in pushdecl below, this TYPE_DECL is linked into names field of the relevant cxx_scope by add_decl_to_level .

566 tree

567 pushdecl (tree x) in name-lookup.c

568 {

569 tree t;

570 tree name;

571 int need_new_binding;

572

573 timevar_push (TV_NAME_LOOKUP);

574

575 need_new_binding = 1;

576

577 if (DECL_TEMPLATE_PARM_P (x))

578 /* Template parameters have no context; they are not X::T even

579 when declared within a class or namespace. */

580 ;

581 else

582 {

…

602 }

603

604 name = DECL_NAME (x);

605 if (name)

606 {

…

1007 }

1008

1009 if (need_new_binding)

1010 add_decl_to_level (x,

1011 DECL_NAMESPACE_SCOPE_P (x)

1012 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))

1013 : current_binding_level);

1014

1015 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);

1016 }

Then back outer cp_parser_type_parameter from cp_parser_template_parameter_list , end_template_parm_list following prepares current_template_parms . And parameter_list returned is that in below figure.

(Click here for open )

Figure 98 : parameter list for template parameter of template template parameter

The following token must be “> class identifier [opt]”. By these tokens, the template template parameter comes into being.

cp_parser_type_parameter (continue)

7780 /* Look for the `>'. */

7781 cp_parser_require (parser, CPP_GREATER, "`>'");

7782 /* Look for the `class' keyword. */

7783 cp_parser_require_keyword (parser, RID_CLASS, "`class'");

7784 /* If the next token is an `=', then there is a

7785 default-argument. If the next token is a `>', we are at

7786 the end of the parameter-list. If the next token is a `,',

7787 then we are at the end of this parameter. */

7788 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)

7789 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)

7790 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))

7791 {

7792 identifier = cp_parser_identifier (parser);

7793 /* Treat invalid names as if the parameter were nameless. */

7794 if (identifier == error_mark_node)

7795 identifier = NULL_TREE;

7796 }

7797 else

7798 identifier = NULL_TREE;

7799

7800 /* Create the template parameter. */

7801 parameter = finish_template_template_parm (class_type_node ,

7802 identifier);

The template template parameter is a template declaration used in template parameter, it should be associated with a TEMPLATE_DECL to stand for this template declaration.

1943 tree

1944 finish_template_template_parm (tree aggr, tree identifier) in semantics.c

1945 {

1946 tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);

1947 tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);

1948 DECL_TEMPLATE_PARMS (tmpl) = current_template_parms ;

1949 DECL_TEMPLATE_RESULT (tmpl) = decl;

1950 DECL_ARTIFICIAL (decl) = 1;

1951 end_template_decl ();

1952

1953 my_friendly_assert (DECL_TEMPLATE_PARMS (tmpl), 20010110);

1954

1955 return finish_template_type_parm (aggr, tmpl);

1956 }

As this template declaration is closed when the optional identifier is read, end_template_decl must be invoked to decrease processing_template_decl and jump out of the binding scope of the declaration (see it is the sk_template_parms). Further finish_template_type_parm packs the TEMPLATE_DECL into the template parameter for the host template declaraion. So before parsing the optional default value, we can get following figure.

( Click here for open )

Figure 99 : template template parameter created