Index: parser.c =================================================================== --- parser.c (revision 160819) +++ parser.c (working copy) @@ -1514,6 +1514,21 @@ cp_parser_context_new (cp_parser_context return context; } +/* An entry in a stack for member functions of local classes. */ + +typedef struct GTY(()) cp_unparsed_functions_entry_d { + /* Functions with default arguments that require post-processing. + Functions appear in this list in declaration order. */ + VEC(tree,gc) *funs_with_default_args; + + /* Functions with defintions that require post-processing. Functions + appear in this list in declaration order. */ + VEC(tree,gc) *funs_with_definitions; +} cp_unparsed_functions_entry; + +DEF_VEC_O(cp_unparsed_functions_entry); +DEF_VEC_ALLOC_O(cp_unparsed_functions_entry,gc); + /* The cp_parser structure represents the C++ parser. */ typedef struct GTY(()) cp_parser { @@ -1640,21 +1655,10 @@ typedef struct GTY(()) cp_parser { issued as an error message if a type is defined. */ const char *type_definition_forbidden_message; - /* A list of lists. The outer list is a stack, used for member - functions of local classes. At each level there are two sub-list, - one on TREE_VALUE and one on TREE_PURPOSE. Each of those - sub-lists has a FUNCTION_DECL or TEMPLATE_DECL on their - TREE_VALUE's. The functions are chained in reverse declaration - order. - - The TREE_PURPOSE sublist contains those functions with default - arguments that need post processing, and the TREE_VALUE sublist - contains those functions with definitions that need post - processing. - - These lists can only be processed once the outermost class being - defined is complete. */ - tree unparsed_functions_queues; + /* A stack used for member functions of local classes. The lists + contained in an individual entry can only be processed once the + outermost class being defined is complete. */ + VEC(cp_unparsed_functions_entry,gc) *unparsed_queues; /* The number of classes whose definitions are currently in progress. */ @@ -1665,6 +1669,30 @@ typedef struct GTY(()) cp_parser { unsigned num_template_parameter_lists; } cp_parser; +/* Managing the unparsed function queues. */ + +#define unparsed_funs_with_default_args \ + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_default_args +#define unparsed_funs_with_definitions \ + VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_definitions + +static void +push_unparsed_function_queues (cp_parser *parser) +{ + VEC_safe_push (cp_unparsed_functions_entry, gc, + parser->unparsed_queues, NULL); + unparsed_funs_with_default_args = make_tree_vector (); + unparsed_funs_with_definitions = make_tree_vector (); +} + +static void +pop_unparsed_function_queues (cp_parser *parser) +{ + release_tree_vector (unparsed_funs_with_definitions); + release_tree_vector (unparsed_funs_with_default_args); + VEC_pop (cp_unparsed_functions_entry, parser->unparsed_queues); +} + /* Prototypes. */ /* Constructors and destructors. */ @@ -3151,7 +3179,7 @@ cp_parser_new (void) parser->in_function_body = false; /* The unparsed function queue is empty. */ - parser->unparsed_functions_queues = build_tree_list (NULL_TREE, NULL_TREE); + push_unparsed_function_queues (parser); /* There are no classes being defined. */ parser->num_classes_being_defined = 0; @@ -16248,10 +16276,10 @@ cp_parser_class_specifier (cp_parser* pa there is no need to delay the parsing of `A::B::f'. */ if (--parser->num_classes_being_defined == 0) { - tree queue_entry; tree fn; tree class_type = NULL_TREE; tree pushed_scope = NULL_TREE; + unsigned ix; /* In a first pass, parse default arguments to the functions. Then, in a second pass, parse the bodies of the functions. @@ -16263,20 +16291,20 @@ cp_parser_class_specifier (cp_parser* pa }; */ - for (TREE_PURPOSE (parser->unparsed_functions_queues) - = nreverse (TREE_PURPOSE (parser->unparsed_functions_queues)); - (queue_entry = TREE_PURPOSE (parser->unparsed_functions_queues)); - TREE_PURPOSE (parser->unparsed_functions_queues) - = TREE_CHAIN (TREE_PURPOSE (parser->unparsed_functions_queues))) - { - fn = TREE_VALUE (queue_entry); + for (ix = 0; + VEC_iterate (tree, unparsed_funs_with_default_args, ix, fn); + ix++) + { + tree ctype = (DECL_FUNCTION_MEMBER_P (fn) + ? DECL_CONTEXT (fn) + : DECL_FRIEND_CONTEXT (fn)); /* If there are default arguments that have not yet been processed, take care of them now. */ - if (class_type != TREE_PURPOSE (queue_entry)) + if (class_type != ctype) { if (pushed_scope) pop_scope (pushed_scope); - class_type = TREE_PURPOSE (queue_entry); + class_type = ctype; pushed_scope = push_scope (class_type); } /* Make sure that any template parameters are in scope. */ @@ -16288,18 +16316,13 @@ cp_parser_class_specifier (cp_parser* pa } if (pushed_scope) pop_scope (pushed_scope); + VEC_truncate (tree, unparsed_funs_with_default_args, 0); /* Now parse the body of the functions. */ - for (TREE_VALUE (parser->unparsed_functions_queues) - = nreverse (TREE_VALUE (parser->unparsed_functions_queues)); - (queue_entry = TREE_VALUE (parser->unparsed_functions_queues)); - TREE_VALUE (parser->unparsed_functions_queues) - = TREE_CHAIN (TREE_VALUE (parser->unparsed_functions_queues))) - { - /* Figure out which function we need to process. */ - fn = TREE_VALUE (queue_entry); - /* Parse the function. */ - cp_parser_late_parsing_for_member (parser, fn); - } + for (ix = 0; + VEC_iterate (tree, unparsed_funs_with_definitions, ix, fn); + ix++) + cp_parser_late_parsing_for_member (parser, fn); + VEC_truncate (tree, unparsed_funs_with_definitions, 0); } /* Put back any saved access checks. */ @@ -19152,9 +19175,7 @@ cp_parser_template_declaration_after_exp if (member_p && decl && (TREE_CODE (decl) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (decl))) - TREE_VALUE (parser->unparsed_functions_queues) - = tree_cons (NULL_TREE, decl, - TREE_VALUE (parser->unparsed_functions_queues)); + VEC_safe_push (tree, gc, unparsed_funs_with_definitions, decl); } /* Perform the deferred access checks from a template-parameter-list. @@ -19424,9 +19445,7 @@ cp_parser_save_member_function_body (cp_ DECL_INITIALIZED_IN_CLASS_P (fn) = 1; /* Add FN to the queue of functions to be parsed later. */ - TREE_VALUE (parser->unparsed_functions_queues) - = tree_cons (NULL_TREE, fn, - TREE_VALUE (parser->unparsed_functions_queues)); + VEC_safe_push (tree, gc, unparsed_funs_with_definitions, fn); return fn; } @@ -19557,8 +19576,7 @@ cp_parser_late_parsing_for_member (cp_pa classes. We want to handle them right away, but we don't want them getting mixed up with functions that are currently in the queue. */ - parser->unparsed_functions_queues - = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues); + push_unparsed_function_queues (parser); /* Make sure that any template parameters are in scope. */ maybe_begin_member_template_processing (member_function); @@ -19610,8 +19628,7 @@ cp_parser_late_parsing_for_member (cp_pa maybe_end_member_template_processing (); /* Restore the queue. */ - parser->unparsed_functions_queues - = TREE_CHAIN (parser->unparsed_functions_queues); + pop_unparsed_function_queues (parser); } /* If DECL contains any default args, remember it on the unparsed @@ -19627,9 +19644,7 @@ cp_parser_save_default_args (cp_parser* probe = TREE_CHAIN (probe)) if (TREE_PURPOSE (probe)) { - TREE_PURPOSE (parser->unparsed_functions_queues) - = tree_cons (current_class_type, decl, - TREE_PURPOSE (parser->unparsed_functions_queues)); + VEC_safe_push (tree, gc, unparsed_funs_with_default_args, decl); break; } } @@ -19649,8 +19664,7 @@ cp_parser_late_parsing_default_args (cp_ statement expression extension) encounter more classes. We want to handle them right away, but we don't want them getting mixed up with default args that are currently in the queue. */ - parser->unparsed_functions_queues - = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues); + push_unparsed_function_queues (parser); /* Local variable names (and the `this' keyword) may not appear in a default argument. */ @@ -19722,8 +19736,7 @@ cp_parser_late_parsing_default_args (cp_ parser->local_variables_forbidden_p = saved_local_variables_forbidden_p; /* Restore the queue. */ - parser->unparsed_functions_queues - = TREE_CHAIN (parser->unparsed_functions_queues); + pop_unparsed_function_queues (parser); } /* Parse the operand of `sizeof' (or a similar operator). Returns