From 68642fb604a842d9e3e36b82c19498bf54bb8970 Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Mon, 3 Jan 2000 21:33:10 +0000 Subject: [PATCH] (flag_isoc9x): New variable to be able to use code in c-common.c. For now always zero. From-SVN: r31185 --- gcc/cp/decl.c | 597 +++++++++++++++++++++++++------------------------- 1 file changed, 300 insertions(+), 297 deletions(-) diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index f0b7f8acab29..83b3b9ea69ec 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -191,7 +191,7 @@ static void indent PROTO((void)); tree error_mark_list; /* The following symbols are subsumed in the cp_global_trees array, and - listed here individually for documentation purposes. + listed here individually for documentation purposes. C++ extensions tree wchar_decl_node; @@ -322,6 +322,10 @@ tree current_function_decl; tree current_function_return_value; +/* Nonzero means use the ISO C9x dialect of C. */ + +int flag_isoc9x; + /* Nonzero means give `double' the same size as `float'. */ extern int flag_short_double; @@ -490,7 +494,7 @@ struct binding_level }; #define NULL_BINDING_LEVEL ((struct binding_level *) NULL) - + /* The binding level currently in effect. */ #define current_binding_level \ @@ -1022,13 +1026,13 @@ push_class_binding (id, decl) /* Remove the binding for DECL which should be the innermost binding for ID. */ -static void -pop_binding (id, decl) +static void +pop_binding (id, decl) tree id; tree decl; { tree binding; - + if (id == NULL_TREE) /* It's easiest to write the loops that call this function without checking whether or not the entities involved have names. We @@ -1081,7 +1085,7 @@ pop_label (link) } /* At the end of a function, all labels declared within the fucntion - go out of scope. BLOCK is the top-level block for the + go out of scope. BLOCK is the top-level block for the function. */ static void @@ -1248,7 +1252,7 @@ poplevel (keep, reverse, functionbody) in a for-init statement were in scope after the for-statement ended. We only use the new rules in flag_new_for_scope is nonzero. */ - leaving_for_scope + leaving_for_scope = current_binding_level->is_for_scope && flag_new_for_scope == 1; /* Remove declarations for all the DECLs in this level. */ @@ -1256,7 +1260,7 @@ poplevel (keep, reverse, functionbody) { if (leaving_for_scope && TREE_CODE (link) == VAR_DECL) { - tree outer_binding + tree outer_binding = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link))); tree ns_binding; @@ -1265,21 +1269,21 @@ poplevel (keep, reverse, functionbody) else ns_binding = NULL_TREE; - if (outer_binding - && (BINDING_LEVEL (outer_binding) + if (outer_binding + && (BINDING_LEVEL (outer_binding) == current_binding_level->level_chain)) /* We have something like: - + int i; for (int i; ;); - + and we are leaving the `for' scope. There's no reason to keep the binding of the inner `i' in this case. */ pop_binding (DECL_NAME (link), link); - else if ((outer_binding - && (TREE_CODE (BINDING_VALUE (outer_binding)) + else if ((outer_binding + && (TREE_CODE (BINDING_VALUE (outer_binding)) == TYPE_DECL)) - || (ns_binding + || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL)) /* Here, we have something like: @@ -1297,11 +1301,11 @@ poplevel (keep, reverse, functionbody) /* Mark this VAR_DECL as dead so that we can tell we left it there only for backward compatibility. */ DECL_DEAD_FOR_LOCAL (link) = 1; - + /* Keep track of what should of have happenned when we popped the binding. */ if (outer_binding && BINDING_VALUE (outer_binding)) - DECL_SHADOWED_FOR_VAR (link) + DECL_SHADOWED_FOR_VAR (link) = BINDING_VALUE (outer_binding); /* Add it to the list of dead variables in the next @@ -1318,7 +1322,7 @@ poplevel (keep, reverse, functionbody) = 0; } } - else + else { /* Remove the binding. */ decl = link; @@ -1328,7 +1332,7 @@ poplevel (keep, reverse, functionbody) pop_binding (DECL_NAME (decl), decl); else if (TREE_CODE (decl) == OVERLOAD) pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl); - else + else my_friendly_abort (0); } } @@ -1346,7 +1350,7 @@ poplevel (keep, reverse, functionbody) /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */ for (link = current_binding_level->shadowed_labels; - link; + link; link = TREE_CHAIN (link)) pop_label (link); @@ -1429,7 +1433,7 @@ poplevel (keep, reverse, functionbody) { tree scope_stmts; - scope_stmts + scope_stmts = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1); if (block) { @@ -1529,7 +1533,7 @@ poplevel_class () tree shadowed; my_friendly_assert (level != 0, 354); - + /* If we're leaving a toplevel class, don't bother to do the setting of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot shouldn't even be used when current_class_type isn't set, and second, @@ -1544,7 +1548,7 @@ poplevel_class () shadowed; shadowed = TREE_CHAIN (shadowed)) IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE; - + /* Find the next enclosing class, and recreate IDENTIFIER_CLASS_VALUEs appropriate for that class. */ b = level->level_chain; @@ -1552,8 +1556,8 @@ poplevel_class () b = b->level_chain; if (b) - for (shadowed = b->class_shadowed; - shadowed; + for (shadowed = b->class_shadowed; + shadowed; shadowed = TREE_CHAIN (shadowed)) { tree t; @@ -1561,9 +1565,9 @@ poplevel_class () t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed)); while (t && BINDING_LEVEL (t) != b) t = TREE_CHAIN (t); - + if (t) - IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) + IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = BINDING_VALUE (t); } } @@ -1580,8 +1584,8 @@ poplevel_class () SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed)); /* Remove the bindings for all of the class-level declarations. */ - for (shadowed = level->class_shadowed; - shadowed; + for (shadowed = level->class_shadowed; + shadowed; shadowed = TREE_CHAIN (shadowed)) pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed)); @@ -1705,7 +1709,7 @@ struct walk_globals_data { for which P returns non-zero, call F with its address. If any call to F returns a non-zero value, return a non-zero value. */ -static int +static int walk_globals_r (namespace, data) tree namespace; void *data; @@ -1776,10 +1780,10 @@ wrapup_globals_for_namespace (namespace, data) /* Process the decls in reverse order--earliest first. Put them into VEC from back to front, then take out from front. */ - + for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl)) vec[len - i - 1] = decl; - + if (last_time) { check_global_declarations (vec, len); @@ -1865,7 +1869,7 @@ print_binding_level (lvl) /* We can probably fit 3 names to a line? */ for (t = lvl->names; t; t = TREE_CHAIN (t)) { - if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL)) + if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL)) continue; if (no_print_builtins && (TREE_CODE (t) == TYPE_DECL) @@ -2004,7 +2008,7 @@ find_binding (name, scope) tree iter, prev = NULL_TREE; scope = ORIGINAL_NAMESPACE (scope); - + for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter; iter = TREE_CHAIN (iter)) { @@ -2039,7 +2043,7 @@ binding_for_name (name, scope) tree result; scope = ORIGINAL_NAMESPACE (scope); - + if (b && TREE_CODE (b) != CPLUS_BINDING) { /* Get rid of optimization for global scope. */ @@ -2093,7 +2097,7 @@ set_namespace_binding (name, scope, val) if (scope == NULL_TREE) scope = global_namespace; - + if (scope == global_namespace) { b = IDENTIFIER_NAMESPACE_BINDINGS (name); @@ -2158,7 +2162,7 @@ push_namespace (name) } } } - + if (need_new) { /* Make a new namespace, binding the name to it. */ @@ -2216,7 +2220,7 @@ push_nested_namespace (ns) /* Pop back from the scope of the namespace NS, which was previously entered with push_nested_namespace. */ - + void pop_nested_namespace (ns) tree ns; @@ -2293,7 +2297,7 @@ store_bindings (names, old_bindings) else id = DECL_NAME (t); - if (!id + if (!id /* Note that we may have an IDENTIFIER_CLASS_VALUE even when we have no IDENTIFIER_BINDING if we have left the class scope, but cached the class-level declarations. */ @@ -2433,7 +2437,7 @@ pop_from_top_level () } /* Push a definition of struct, union or enum tag "name". - into binding_level "b". "type" should be the type node, + into binding_level "b". "type" should be the type node, We assume that the tag "name" is not already defined. Note that the definition may really be just a forward reference. @@ -2530,30 +2534,30 @@ pop_everything () Returns the TYPE_DECL for TYPE, which may have been altered by this processing. */ -static tree +static tree maybe_process_template_type_declaration (type, globalize, b) tree type; int globalize; struct binding_level* b; { tree decl = TYPE_NAME (type); - + if (processing_template_parmlist) /* You can't declare a new template type in a template parameter list. But, you can declare a non-template type: - + template struct S; - + is a forward-declaration of `A'. */ ; - else + else { maybe_check_template_type (type); - my_friendly_assert (IS_AGGR_TYPE (type) + my_friendly_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE, 0); - - + + if (processing_template_decl) { /* This may change after the call to @@ -2576,7 +2580,7 @@ maybe_process_template_type_declaration (type, globalize, b) /* Put this tag on the list of tags for the class, since that won't happen below because B is not the class binding level, but is instead the pseudo-global level. */ - b->level_chain->tags = + b->level_chain->tags = tree_cons (name, type, b->level_chain->tags); if (TYPE_SIZE (current_class_type) == NULL_TREE) CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags; @@ -2644,7 +2648,7 @@ pushtag (name, type, globalize) if (! globalize) context = cs; - else if (cs != NULL_TREE + else if (cs != NULL_TREE && TREE_CODE_CLASS (TREE_CODE (cs)) == 't') /* When declaring a friend class of a local class, we want to inject the newly named class into the scope @@ -2846,7 +2850,7 @@ decls_match (newdecl, olddecl) if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), DECL_TEMPLATE_PARMS (olddecl))) return 0; - + if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) types_match = 1; else @@ -2890,10 +2894,10 @@ warn_extern_redeclared_static (newdecl, olddecl) tree name; - if (TREE_CODE (newdecl) == TYPE_DECL + if (TREE_CODE (newdecl) == TYPE_DECL || TREE_CODE (newdecl) == TEMPLATE_DECL) return; - + /* Don't get confused by static member functions; that's a different use of `static'. */ if (TREE_CODE (newdecl) == FUNCTION_DECL @@ -2945,7 +2949,7 @@ duplicate_decls (newdecl, olddecl) if (TREE_TYPE (newdecl) == error_mark_node || TREE_TYPE (olddecl) == error_mark_node) types_match = 1; - + /* Check for redeclaration and other discrepancies. */ if (TREE_CODE (olddecl) == FUNCTION_DECL && DECL_ARTIFICIAL (olddecl)) @@ -3001,7 +3005,7 @@ duplicate_decls (newdecl, olddecl) /* Discard the old built-in function. */ return 0; } - + if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl)) { /* If a builtin function is redeclared as `static', merge @@ -3113,14 +3117,14 @@ duplicate_decls (newdecl, olddecl) cp_error_at ("previous declaration as `%#D'", olddecl); } } - else if (TREE_CODE (newdecl) == FUNCTION_DECL + else if (TREE_CODE (newdecl) == FUNCTION_DECL && ((DECL_TEMPLATE_SPECIALIZATION (olddecl) && (!DECL_TEMPLATE_INFO (newdecl) - || (DECL_TI_TEMPLATE (newdecl) + || (DECL_TI_TEMPLATE (newdecl) != DECL_TI_TEMPLATE (olddecl)))) || (DECL_TEMPLATE_SPECIALIZATION (newdecl) && (!DECL_TEMPLATE_INFO (olddecl) - || (DECL_TI_TEMPLATE (olddecl) + || (DECL_TI_TEMPLATE (olddecl) != DECL_TI_TEMPLATE (newdecl)))))) /* It's OK to have a template specialization and a non-template with the same type, or to have specializations of two @@ -3131,8 +3135,8 @@ duplicate_decls (newdecl, olddecl) specialize one of its methods. This situation is legal, but the declarations must be merged in the usual way. */ return 0; - else if (TREE_CODE (newdecl) == FUNCTION_DECL - && ((DECL_TEMPLATE_INSTANTIATION (olddecl) + else if (TREE_CODE (newdecl) == FUNCTION_DECL + && ((DECL_TEMPLATE_INSTANTIATION (olddecl) && !DECL_USE_TEMPLATE (newdecl)) || (DECL_TEMPLATE_INSTANTIATION (newdecl) && !DECL_USE_TEMPLATE (olddecl)))) @@ -3193,7 +3197,7 @@ duplicate_decls (newdecl, olddecl) if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE) t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2); - + for (; t1 && t1 != void_list_node; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++) if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2)) @@ -3255,7 +3259,7 @@ duplicate_decls (newdecl, olddecl) DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl); DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl); new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE; - + /* Optionally warn about more than one declaration for the same name, but don't warn about a function declaration followed by a definition. */ @@ -3288,7 +3292,7 @@ duplicate_decls (newdecl, olddecl) /* Copy all the DECL_... slots specified in the new decl except for any that we copy here from the old type. */ - DECL_MACHINE_ATTRIBUTES (newdecl) + DECL_MACHINE_ATTRIBUTES (newdecl) = merge_machine_decl_attributes (olddecl, newdecl); if (TREE_CODE (newdecl) == TEMPLATE_DECL) @@ -3297,13 +3301,13 @@ duplicate_decls (newdecl, olddecl) DECL_TEMPLATE_RESULT (olddecl))) cp_error ("invalid redeclaration of %D", newdecl); TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)); - DECL_TEMPLATE_SPECIALIZATIONS (olddecl) + DECL_TEMPLATE_SPECIALIZATIONS (olddecl) = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl), DECL_TEMPLATE_SPECIALIZATIONS (newdecl)); - + return 1; } - + if (types_match) { /* Automatically handles default parameters. */ @@ -3415,13 +3419,13 @@ duplicate_decls (newdecl, olddecl) TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl); if (! DECL_EXTERNAL (olddecl)) DECL_EXTERNAL (newdecl) = 0; - + if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl)) { DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl); DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl); DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl); - DECL_TEMPLATE_INSTANTIATED (newdecl) + DECL_TEMPLATE_INSTANTIATED (newdecl) |= DECL_TEMPLATE_INSTANTIATED (olddecl); /* Don't really know how much of the language-specific values we should copy from old to new. */ @@ -3441,8 +3445,8 @@ duplicate_decls (newdecl, olddecl) if (TREE_CODE (newdecl) == FUNCTION_DECL) { - if (DECL_TEMPLATE_INSTANTIATION (olddecl) - && !DECL_TEMPLATE_INSTANTIATION (newdecl)) + if (DECL_TEMPLATE_INSTANTIATION (olddecl) + && !DECL_TEMPLATE_INSTANTIATION (newdecl)) { /* If newdecl is not a specialization, then it is not a template-related function at all. And that means that we @@ -3450,16 +3454,16 @@ duplicate_decls (newdecl, olddecl) my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl), 0); - if (TREE_USED (olddecl)) + if (TREE_USED (olddecl)) /* From [temp.expl.spec]: - + If a template, a member template or the member of a class template is explicitly specialized then that specialization shall be declared before the first use of that specialization that would cause an implicit instantiation to take place, in every translation unit in which such a use occurs. */ - cp_error ("explicit specialization of %D after first use", + cp_error ("explicit specialization of %D after first use", olddecl); SET_DECL_TEMPLATE_SPECIALIZATION (olddecl); @@ -3545,16 +3549,16 @@ duplicate_decls (newdecl, olddecl) the following sequence of events has occurred: o A friend function was declared in a class template. The - class template was instantiated. + class template was instantiated. - o The instantiation of the friend declaration was - recorded on the instantiation list, and is newdecl. + o The instantiation of the friend declaration was + recorded on the instantiation list, and is newdecl. o Later, however, instantiate_class_template called pushdecl on the newdecl to perform name injection. But, pushdecl in turn called duplicate_decls when it discovered that another declaration of a global function with the same name already - existed. + existed. o Here, in duplicate_decls, we decided to clobber newdecl. @@ -3563,8 +3567,8 @@ duplicate_decls (newdecl, olddecl) instantiations so that if we try to do the instantiation again we won't get the clobbered declaration. */ - tree tmpl = DECL_TI_TEMPLATE (newdecl); - tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); + tree tmpl = DECL_TI_TEMPLATE (newdecl); + tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); for (; decls; decls = TREE_CHAIN (decls)) if (TREE_VALUE (decls) == newdecl) @@ -3638,7 +3642,7 @@ pushdecl (x) /* If this is the declaration for a namespace-scope function, but the declaration itself is in a local scope, mark the declaration. */ - if (TREE_CODE (x) == FUNCTION_DECL + if (TREE_CODE (x) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (x) && current_function_decl && x != current_function_decl) @@ -3660,7 +3664,7 @@ pushdecl (x) #endif if (TREE_CODE (name) == TEMPLATE_ID_EXPR) name = TREE_OPERAND (name, 0); - + /* Namespace-scoped variables are not found in the current level. */ if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)) t = namespace_binding (name, DECL_CONTEXT (x)); @@ -3749,7 +3753,7 @@ pushdecl (x) else if (DECL_MAIN_P (x)) { /* A redeclaration of main, but not a duplicate of the - previous one. + previous one. [basic.start.main] @@ -3807,7 +3811,7 @@ pushdecl (x) /* We don't want to copy the type when all we're doing is making a TYPE_DECL for the purposes of inlining. */ - && (!TYPE_NAME (type) + && (!TYPE_NAME (type) || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))) { DECL_ORIGINAL_TYPE (x) = type; @@ -3820,7 +3824,7 @@ pushdecl (x) if (type != error_mark_node && TYPE_NAME (type) && TYPE_IDENTIFIER (type)) - set_identifier_type_value_with_scope (DECL_NAME (x), type, + set_identifier_type_value_with_scope (DECL_NAME (x), type, current_binding_level); } @@ -3829,7 +3833,7 @@ pushdecl (x) We get warnings about inline functions where they are defined. We get warnings about other functions from push_overloaded_decl. - + Avoid duplicate warnings where they are used. */ if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL) { @@ -3869,11 +3873,11 @@ pushdecl (x) the mangled name (i.e., NAME) to the DECL. But, for an `extern "C"' function, the mangled name and the ordinary name are the same so we need not do this. */ - && !(TREE_CODE (x) == FUNCTION_DECL && + && !(TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)) { if (TREE_CODE (x) == FUNCTION_DECL) - my_friendly_assert + my_friendly_assert ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE) || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378); SET_IDENTIFIER_NAMESPACE_VALUE (name, x); @@ -3919,14 +3923,14 @@ pushdecl (x) /* If this is a TYPE_DECL, push it into the type value slot. */ if (TREE_CODE (x) == TYPE_DECL) - set_identifier_type_value_with_scope (name, TREE_TYPE (x), + set_identifier_type_value_with_scope (name, TREE_TYPE (x), current_binding_level); /* Clear out any TYPE_DECL shadowed by a namespace so that we won't think this is a type. The C struct hack doesn't go through namespaces. */ if (TREE_CODE (x) == NAMESPACE_DECL) - set_identifier_type_value_with_scope (name, NULL_TREE, + set_identifier_type_value_with_scope (name, NULL_TREE, current_binding_level); /* If this is an extern function declaration, see if we @@ -3983,7 +3987,7 @@ pushdecl (x) warning ("variable `%s' shadows local", IDENTIFIER_POINTER (name)); cp_warning_at (" this is the shadowed declaration", oldlocal); - } + } /* Maybe warn if shadowing something else. */ else if (warn_shadow && !DECL_EXTERNAL (x) /* No shadow warnings for internally generated vars. */ @@ -4020,12 +4024,12 @@ pushdecl (x) /* RTTI TD entries are created while defining the type_info. */ || (TYPE_LANG_SPECIFIC (TREE_TYPE (x)) && TYPE_BEING_DEFINED (TREE_TYPE (x))))) - current_binding_level->incomplete + current_binding_level->incomplete = tree_cons (NULL_TREE, x, current_binding_level->incomplete); } if (need_new_binding) - add_decl_to_level (x, + add_decl_to_level (x, DECL_NAMESPACE_SCOPE_P (x) ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x)) : current_binding_level); @@ -4165,8 +4169,8 @@ maybe_push_decl (decl) /* Add this decl to the current binding level, but not if it comes from another scope, e.g. a static member variable. TEM may equal DECL or it may be a previous decl of the same name. */ - if ((TREE_CODE (decl) != PARM_DECL - && DECL_CONTEXT (decl) != NULL_TREE + if ((TREE_CODE (decl) != PARM_DECL + && DECL_CONTEXT (decl) != NULL_TREE /* Definitions of namespace members outside their namespace are possible. */ && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL) @@ -4214,7 +4218,7 @@ push_class_level_binding (name, x) tree x; { tree binding; - /* The class_binding_level will be NULL if x is a template + /* The class_binding_level will be NULL if x is a template parameter name in a member template. */ if (!class_binding_level) return; @@ -4228,7 +4232,7 @@ push_class_level_binding (name, x) class, then we will need to restore IDENTIFIER_CLASS_VALUE when we leave this class. Record the shadowed declaration here. */ binding = IDENTIFIER_BINDING (name); - if (binding + if (binding && ((TREE_CODE (x) == OVERLOAD && BINDING_VALUE (binding) && is_overloaded_fn (BINDING_VALUE (binding))) @@ -4295,7 +4299,7 @@ push_using_decl (scope, name) tree name; { tree decl; - + my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383); my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384); for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl)) @@ -4320,7 +4324,7 @@ push_using_directive (used) { tree ud = current_binding_level->using_directives; tree iter, ancestor; - + /* Check if we already have this. */ if (purpose_member (used, ud) != NULL_TREE) return NULL_TREE; @@ -4349,7 +4353,7 @@ push_using_directive (used) PUSH_LOCAL: Bind DECL in the current scope, rather than at namespace scope. PUSH_USING: DECL is being pushed as the result of a using - declaration. + declaration. The value returned may be a previous declaration if we guessed wrong about what language DECL should belong to (C or C++). Otherwise, @@ -4384,7 +4388,7 @@ push_overloaded_decl (decl, flags) else if (is_overloaded_fn (old)) { tree tmp; - + for (tmp = old; tmp; tmp = OVL_NEXT (tmp)) { tree fn = OVL_CURRENT (tmp); @@ -4395,7 +4399,7 @@ push_overloaded_decl (decl, flags) TYPE_ARG_TYPES (TREE_TYPE (decl)))) cp_error ("`%#D' conflicts with previous using declaration `%#D'", decl, fn); - + if (duplicate_decls (decl, fn)) return fn; } @@ -4434,7 +4438,7 @@ push_overloaded_decl (decl, flags) if (TREE_CODE (new_binding) == OVERLOAD && old) { tree *d; - + for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names; *d; d = &TREE_CHAIN (*d)) @@ -4447,7 +4451,7 @@ push_overloaded_decl (decl, flags) TREE_VALUE (*d) = new_binding; else /* Build a TREE_LIST to wrap the OVERLOAD. */ - *d = tree_cons (NULL_TREE, new_binding, + *d = tree_cons (NULL_TREE, new_binding, TREE_CHAIN (*d)); /* And update the CPLUS_BINDING node. */ @@ -4633,7 +4637,7 @@ make_label_decl (id, local_p) be found, create one. (We keep track of used, but undefined, labels, and complain about them at the end of a function.) */ -tree +tree lookup_label (id) tree id; { @@ -4646,7 +4650,7 @@ lookup_label (id) IDENTIFIER_POINTER (id)); return NULL_TREE; } - + /* See if we've already got this label. */ decl = IDENTIFIER_LABEL_VALUE (id); if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl) @@ -4676,14 +4680,14 @@ declare_local_label (id) /* Add a new entry to the SHADOWED_LABELS list so that when we leave this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */ - current_binding_level->shadowed_labels + current_binding_level->shadowed_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE, current_binding_level->shadowed_labels); /* Look for the label. */ decl = make_label_decl (id, /*local_p=*/1); /* Now fill in the information we didn't have before. */ TREE_VALUE (current_binding_level->shadowed_labels) = decl; - + return decl; } @@ -4853,7 +4857,7 @@ define_case_label () if (! switch_stack) /* Don't crash; we'll complain in do_case. */ return; - + if (cleanup) { static int explained = 0; @@ -4982,10 +4986,10 @@ lookup_tag (form, name, binding_level, thislevel_only) declaration, then we use the _TYPE node for the template. See the example below. */ if (thislevel_only && !allow_pseudo_global - && old && BINDING_VALUE (old) + && old && BINDING_VALUE (old) && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old))) old = TREE_TYPE (BINDING_VALUE (old)); - else + else old = BINDING_TYPE (old); /* If it has an original type, it is a typedef, and we @@ -5027,10 +5031,10 @@ lookup_tag (form, name, binding_level, thislevel_only) if (level->pseudo_global && allow_pseudo_global) { /* We must deal with cases like this: - + template struct S; template struct S {}; - + When looking up `S', for the second declaration, we would like to find the first declaration. But, we are in the pseudo-global level created for the @@ -5121,7 +5125,7 @@ lookup_namespace_name (namespace, name) } my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373); - + val = make_node (CPLUS_BINDING); if (!qualified_lookup_using_namespace (name, namespace, val, 0)) return error_mark_node; @@ -5133,14 +5137,14 @@ lookup_namespace_name (namespace, name) if (template_id) { if (DECL_CLASS_TEMPLATE_P (val)) - val = lookup_template_class (val, + val = lookup_template_class (val, TREE_OPERAND (template_id, 1), /*in_decl=*/NULL_TREE, /*context=*/NULL_TREE, /*entering_scope=*/0); else if (DECL_FUNCTION_TEMPLATE_P (val) || TREE_CODE (val) == OVERLOAD) - val = lookup_template_function (val, + val = lookup_template_function (val, TREE_OPERAND (template_id, 1)); else { @@ -5192,10 +5196,10 @@ typename_compare (k1, k2) t2 = (tree) k2; d1 = TYPE_NAME (t1); d2 = TYPE_NAME (t2); - + return (DECL_NAME (d1) == DECL_NAME (d2) && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)) - && ((TREE_TYPE (t1) != NULL_TREE) + && ((TREE_TYPE (t1) != NULL_TREE) == (TREE_TYPE (t2) != NULL_TREE)) && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)) && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2)); @@ -5205,7 +5209,7 @@ typename_compare (k1, k2) the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE is non-NULL, this type is being created by the implicit typename extension, and BASE_TYPE is a type named `t' in some base class of - `T' which depends on template parameters. + `T' which depends on template parameters. Returns the new TYPENAME_TYPE. */ @@ -5225,7 +5229,7 @@ build_typename_type (context, name, fullname, base_type) if (!ht.table) { static struct hash_table *h = &ht; - if (!hash_table_init (&ht, &hash_newfunc, &typename_hash, + if (!hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare)) fatal ("virtual memory exhausted"); ggc_add_tree_hash_table_root (&h, 1); @@ -5268,8 +5272,8 @@ make_typename_type (context, name, complain) if (TREE_CODE_CLASS (TREE_CODE (name)) == 't') { - if (!(TYPE_LANG_SPECIFIC (name) - && (CLASSTYPE_IS_TEMPLATE (name) + if (!(TYPE_LANG_SPECIFIC (name) + && (CLASSTYPE_IS_TEMPLATE (name) || CLASSTYPE_USE_TEMPLATE (name)))) name = TYPE_IDENTIFIER (name); else @@ -5318,15 +5322,15 @@ make_typename_type (context, name, complain) return error_mark_node; } - return lookup_template_class (tmpl, + return lookup_template_class (tmpl, TREE_OPERAND (fullname, 1), - NULL_TREE, context, + NULL_TREE, context, /*entering_scope=*/0); } else { tree t; - + if (!IS_AGGR_TYPE (context)) { if (complain) @@ -5348,8 +5352,8 @@ make_typename_type (context, name, complain) cp_error ("no type named `%#T' in `%#T'", name, context); return error_mark_node; } - - + + return build_typename_type (context, name, fullname, NULL_TREE); } @@ -5369,7 +5373,7 @@ select_decl (binding, flags) return val; return NULL_TREE; } - + /* If we could have a type and we have nothing or we need a type and have none. */ if (BINDING_TYPE (binding) @@ -5416,7 +5420,7 @@ unqualified_namespace_lookup (name, flags, spacesp) BINDING_TYPE (b) = BINDING_TYPE (val); /* Add all _DECLs seen through local using-directives. */ - for (level = current_binding_level; + for (level = current_binding_level; !level->namespace_p; level = level->level_chain) if (!lookup_using_namespace (name, b, level->using_directives, @@ -5429,7 +5433,7 @@ unqualified_namespace_lookup (name, flags, spacesp) siter = initial; while (1) { - if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter), + if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter), scope, flags, spacesp)) /* Give up because of error. */ return error_mark_node; @@ -5498,7 +5502,7 @@ warn_about_implicit_typename_lookup (typename, binding) && ! (TREE_CODE (binding) == TYPE_DECL && same_type_p (TREE_TYPE (binding), subtype))) { - cp_warning ("lookup of `%D' finds `%#D'", + cp_warning ("lookup of `%D' finds `%#D'", name, binding); cp_warning (" instead of `%D' from dependent base class", typename); @@ -5516,7 +5520,7 @@ warn_about_implicit_typename_lookup (typename, binding) If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces. If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces). If PREFER_TYPE is -2, we're being called from yylex(). (UGLY) - Otherwise we prefer non-TYPE_DECLs. + Otherwise we prefer non-TYPE_DECLs. If NONCLASS is non-zero, we don't look for the NAME in class scope, using IDENTIFIER_CLASS_VALUE. */ @@ -5558,7 +5562,7 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only) type = got_scope; else if (got_object != error_mark_node) type = got_object; - + if (type) { if (type == error_mark_node) @@ -5617,11 +5621,11 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only) if (!LOCAL_BINDING_P (t) && nonclass) /* We're not looking for class-scoped bindings, so keep going. */ continue; - + /* If this is the kind of thing we're looking for, we're done. */ if (qualify_lookup (BINDING_VALUE (t), flags)) binding = BINDING_VALUE (t); - else if ((flags & LOOKUP_PREFER_TYPES) + else if ((flags & LOOKUP_PREFER_TYPES) && qualify_lookup (BINDING_TYPE (t), flags)) binding = BINDING_TYPE (t); else @@ -5633,7 +5637,7 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only) if (val_is_implicit_typename && !yylex) warn_about_implicit_typename_lookup (val, binding); val = binding; - val_is_implicit_typename + val_is_implicit_typename = IMPLICIT_TYPENAME_TYPE_DECL_P (val); if (!val_is_implicit_typename) break; @@ -5738,14 +5742,14 @@ lookup_name_current_level (name) if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST) t = TREE_VALUE (t); } - else if (IDENTIFIER_BINDING (name) + else if (IDENTIFIER_BINDING (name) && LOCAL_BINDING_P (IDENTIFIER_BINDING (name))) { while (1) { if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b) return IDENTIFIER_VALUE (name); - + if (b->keep == 2) b = b->level_chain; else @@ -5843,7 +5847,7 @@ record_builtin_type (rid_index, name, type) tname = get_identifier (name); TYPE_BUILT_IN (type) = 1; - + if (tname) { tdecl = pushdecl (build_decl (TYPE_DECL, tname, type)); @@ -5917,7 +5921,7 @@ record_unknown_type (type, name) TYPE_SIZE (type) = TYPE_SIZE (void_type_node); TYPE_ALIGN (type) = 1; TYPE_MODE (type) = TYPE_MODE (void_type_node); -} +} /* Push overloaded decl, in global scope, with one argument so it can be used as a callback from define_function. */ @@ -6070,11 +6074,11 @@ init_decl_processing () /* Create the widest literal types. */ widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2); - pushdecl (build_decl (TYPE_DECL, NULL_TREE, + pushdecl (build_decl (TYPE_DECL, NULL_TREE, widest_integer_literal_type_node)); widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2); - pushdecl (build_decl (TYPE_DECL, NULL_TREE, + pushdecl (build_decl (TYPE_DECL, NULL_TREE, widest_unsigned_literal_type_node)); /* These are types that type_for_size and type_for_mode use. */ @@ -6145,7 +6149,7 @@ init_decl_processing () string_type_node = build_pointer_type (char_type_node); const_string_type_node - = build_pointer_type (build_qualified_type (char_type_node, + = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST)); empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE); #if 0 @@ -6273,7 +6277,7 @@ init_decl_processing () layout_type (vtbl_ptr_type_node); record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node); - std_node = build_decl (NAMESPACE_DECL, + std_node = build_decl (NAMESPACE_DECL, get_identifier (flag_honor_std ? "fake std":"std"), void_type_node); pushdecl (std_node); @@ -6414,7 +6418,7 @@ define_function (name, type, pfn, library_name) } -/* Wrapper around define_function, for the benefit of +/* Wrapper around define_function, for the benefit of c_common_nodes_and_builtins. FUNCTION_CODE tells later passes how to compile calls to this function. See tree.h for its possible values. */ @@ -6664,7 +6668,7 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes) decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, attrlist); - + if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE) return NULL_TREE; @@ -6735,7 +6739,7 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes) #ifdef SET_DEFAULT_DECL_ATTRIBUTES SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes); #endif - + /* Set attributes here so if duplicate decl, will have proper attributes. */ cplus_decl_attributes (decl, attributes, prefix_attributes); @@ -6777,7 +6781,7 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes) /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */ DECL_IN_AGGR_P (decl) = 0; - if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) + if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) || CLASSTYPE_USE_TEMPLATE (context)) { SET_DECL_TEMPLATE_SPECIALIZATION (decl); @@ -6810,7 +6814,7 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes) data segment. */ DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem); #endif - + if (! processing_template_decl) start_decl_1 (tem); @@ -6936,7 +6940,7 @@ grok_reference_init (decl, type, init) /* Note: default conversion is only called in very special cases. */ init = default_conversion (init); } - + /* Convert INIT to the reference type TYPE. This may involve the creation of a temporary, whose lifetime must be the same as that of the reference. If so, a DECL_STMT for the temporary will be @@ -7067,7 +7071,7 @@ layout_var_decl (decl) /* If we haven't already layed out this declaration, do so now. Note that we must not call complete type for an external object because it's type might involve templates that we are not - supposed to isntantiate yet. (And it's perfectly legal to say + supposed to isntantiate yet. (And it's perfectly legal to say `extern X x' for some incomplete type `X'.) */ if (!DECL_EXTERNAL (decl)) complete_type (type); @@ -7306,7 +7310,7 @@ check_initializer (decl, init) } else check_for_uninitialized_const_var (decl); - + return init; } @@ -7419,7 +7423,7 @@ maybe_inject_for_scope_var (decl) { if (current_binding_level->is_for_scope) { - struct binding_level *outer + struct binding_level *outer = current_binding_level->level_chain; /* Check to see if the same name is already bound at the outer @@ -7431,11 +7435,11 @@ maybe_inject_for_scope_var (decl) Otherwise, we need to preserve the temp slot for decl to last into the outer binding level. */ - tree outer_binding + tree outer_binding = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl))); - + if (outer_binding && BINDING_LEVEL (outer_binding) == outer - && (TREE_CODE (BINDING_VALUE (outer_binding)) + && (TREE_CODE (BINDING_VALUE (outer_binding)) == VAR_DECL) && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding))) { @@ -7482,7 +7486,7 @@ initialize_local_var (decl, init, flags) if (DECL_SIZE (decl) && type != error_mark_node) { int already_used; - + /* Compute and store the initial value. */ already_used = TREE_USED (decl) || TREE_USED (type); @@ -7506,7 +7510,7 @@ initialize_local_var (decl, init, flags) marked used. (see TREE_USED, above.) */ if (TYPE_NEEDS_CONSTRUCTING (type) && ! already_used - && !TYPE_NEEDS_DESTRUCTOR (type) + && !TYPE_NEEDS_DESTRUCTOR (type) && DECL_NAME (decl)) TREE_USED (decl) = 0; else if (already_used) @@ -7516,7 +7520,7 @@ initialize_local_var (decl, init, flags) /* Generate code to destroy DECL (a local variable). */ -static void +static void destroy_local_var (decl) tree decl; { @@ -7526,7 +7530,7 @@ destroy_local_var (decl) /* Only variables get cleaned up. */ if (TREE_CODE (decl) != VAR_DECL) return; - + /* And only things with destructors need cleaning up. */ if (!TYPE_NEEDS_DESTRUCTOR (type)) return; @@ -7537,7 +7541,7 @@ destroy_local_var (decl) translation unit, or that need a static cleanup. The latter are handled by finish_file. */ return; - + /* Compute the cleanup. */ cleanup = maybe_build_cleanup (decl); @@ -7557,14 +7561,14 @@ emit_local_var (decl) if (DECL_RTL (decl)) /* Only a RESULT_DECL should have non-NULL RTL when arriving here. All other local variables are assigned RTL in this function. */ - my_friendly_assert (TREE_CODE (decl) == RESULT_DECL, + my_friendly_assert (TREE_CODE (decl) == RESULT_DECL, 19990828); else { if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)) /* The user must have specified an assembler name for this variable. Set that up now. */ - rest_of_decl_compilation + rest_of_decl_compilation (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), /*top_level=*/0, /*at_end=*/0); else @@ -7619,7 +7623,7 @@ cp_finish_decl (decl, init, asmspec_tree, flags) /* Handling __FUNCTION__ and its ilk in a template-function requires some special processing because we are called from language-independent code. */ - if (cfun && processing_template_decl + if (cfun && processing_template_decl && current_function_name_declared == 2) { /* Since we're in a template function, we need to @@ -7628,7 +7632,7 @@ cp_finish_decl (decl, init, asmspec_tree, flags) retrofit_lang_decl (decl); decl = push_template_decl (decl); - if (strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), + if (strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "__PRETTY_FUNCTION__") == 0) { init = build (FUNCTION_NAME, const_string_type_node); @@ -7653,7 +7657,7 @@ cp_finish_decl (decl, init, asmspec_tree, flags) && (DECL_INITIAL (decl) || init)) DECL_DEFINED_IN_CLASS_P (decl) = 1; - if (TREE_CODE (decl) == VAR_DECL + if (TREE_CODE (decl) == VAR_DECL && DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL && DECL_CONTEXT (decl) != current_namespace @@ -7759,11 +7763,11 @@ cp_finish_decl (decl, init, asmspec_tree, flags) make_rtl_for_nonlocal_decl (decl, init, asmspec); - if (TREE_CODE (type) == FUNCTION_TYPE + if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE) - abstract_virtuals_error (decl, + abstract_virtuals_error (decl, strip_array_types (TREE_TYPE (type))); - else + else abstract_virtuals_error (decl, strip_array_types (type)); if (TREE_CODE (decl) == FUNCTION_DECL) @@ -7913,7 +7917,7 @@ get_atexit_node () We build up the argument types and then then function type itself. */ - + /* First, build the pointer-to-function type for the first argument. */ arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node); @@ -7931,7 +7935,7 @@ get_atexit_node () else { /* The declaration for `atexit' is: - + int atexit (void (*)()); We build up the argument types and then then function type @@ -8127,7 +8131,7 @@ expand_static_init (decl, init) initialization is complete. This ensures that an exception, thrown during the construction, will cause the variable to reinitialized when we pass through this code again, as per: - + [stmt.dcl] If the initialization exits by throwing an exception, the @@ -8143,7 +8147,7 @@ expand_static_init (decl, init) /* Begin the conditional initialization. */ if_stmt = begin_if_stmt (); finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp, - integer_zero_node), + integer_zero_node), if_stmt); then_clause = begin_compound_stmt (/*has_no_scope=*/0); @@ -8170,7 +8174,7 @@ expand_static_init (decl, init) if (assignment) { assignment = tree_cons (NULL_TREE, assignment, - build_tree_list (NULL_TREE, + build_tree_list (NULL_TREE, temp_init)); assignment = build_compound_expr (assignment); } @@ -8232,7 +8236,7 @@ complete_array_type (type, initial_value, do_default) { register tree maxindex = NULL_TREE; int value = 0; - + if (initial_value) { /* Note MAXINDEX is really the maximum index, @@ -8358,7 +8362,7 @@ bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises) or `volatile'. RAISES is a list of exceptions that this function can raise. CHECK is 1 if we must find this method in CTYPE, 0 if we should - not look, and -1 if we should not call `grokclassfn' at all. + not look, and -1 if we should not call `grokclassfn' at all. Returns `NULL_TREE' if something goes wrong, after issuing applicable error messages. */ @@ -8511,7 +8515,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals, if (PROCESSING_REAL_TEMPLATE_DECL_P ()) { /* Something like `template friend void f()'. */ - cp_error ("template-id `%D' in declaration of primary template", + cp_error ("template-id `%D' in declaration of primary template", orig_declarator); return NULL_TREE; } @@ -8534,7 +8538,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals, if (inlinep) { - cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'", + cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'", decl); return NULL_TREE; } @@ -8572,8 +8576,8 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals, grokclassfn (ctype, decl, flags, quals); decl = check_explicit_specialization (orig_declarator, decl, - template_count, - 2 * (funcdef_flag != 0) + + template_count, + 2 * (funcdef_flag != 0) + 4 * (friendp != 0)); if (decl == error_mark_node) return NULL_TREE; @@ -8605,8 +8609,8 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals, grokclassfn (ctype, decl, flags, quals); decl = check_explicit_specialization (orig_declarator, decl, - template_count, - 2 * (funcdef_flag != 0) + + template_count, + 2 * (funcdef_flag != 0) + 4 * (friendp != 0)); if (decl == error_mark_node) return NULL_TREE; @@ -8619,7 +8623,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals, if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL) tmp = DECL_TEMPLATE_RESULT (tmp); - + if (tmp && DECL_STATIC_FUNCTION_P (tmp) && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) { @@ -8691,7 +8695,7 @@ grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace) else context = NULL_TREE; - if (processing_template_decl) + if (processing_template_decl) /* If we're in a template, we need DECL_LANG_SPECIFIC so that we can call push_template_decl. */ decl = build_lang_decl (VAR_DECL, declarator, type); @@ -8781,7 +8785,7 @@ build_ptrmemfunc_type (type) /* Make sure that we always have the unqualified pointer-to-member type first. */ if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED) - unqualified_variant + unqualified_variant = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type)); u = make_aggr_type (UNION_TYPE); @@ -8850,7 +8854,7 @@ check_static_variable_definition (decl, type) required. */ if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE) { - cp_error ("in-class initialization of static data member of non-integral type `%T'", + cp_error ("in-class initialization of static data member of non-integral type `%T'", type); /* If we just return the declaration, crashes will sometimes occur. We therefore return void_type_node, as if this was a @@ -8941,7 +8945,7 @@ compute_array_index_type (name, size) size = integer_one_node; } /* Except that an extension we allow zero-sized arrays. We - always allow them in system headers because glibc uses + always allow them in system headers because glibc uses them. */ else if (integer_zerop (size) && pedantic && !in_system_header) { @@ -8959,7 +8963,7 @@ compute_array_index_type (name, size) cp_convert (ssizetype, size), cp_convert (ssizetype, integer_one_node))); - + /* Check for variable-sized arrays. We allow such things as an extension, even though they are not allowed in ANSI/ISO C++. */ if (!TREE_CONSTANT (itype)) @@ -8984,7 +8988,7 @@ compute_array_index_type (name, size) error ("overflow in array dimension"); TREE_OVERFLOW (itype) = 0; } - + /* Create and return the appropriate index type. */ return build_index_type (itype); } @@ -9048,7 +9052,7 @@ create_array_type_for_decl (name, type, size) } /* [dcl.array] - + The constant expressions that specify the bounds of the arrays can be omitted only for the first member of the sequence. */ if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)) @@ -9320,7 +9324,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) } ctype = NULL_TREE; break; - + case TEMPLATE_ID_EXPR: { tree fns = TREE_OPERAND (decl, 0); @@ -9513,7 +9517,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) if (name == NULL) name = decl_context == PARM ? "parameter" : "type name"; - + /* Look through the decl specs and record which ones appear. Some typespecs are defined as built-in typenames. Others, the ones that are modifiers of other types, @@ -9716,7 +9720,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) && TYPE_MAIN_VARIANT (type) == double_type_node) { RIDBIT_RESET (RID_LONG, specbits); - type = build_qualified_type (long_double_type_node, + type = build_qualified_type (long_double_type_node, CP_TYPE_QUALS (type)); } @@ -9785,7 +9789,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) It is implementation-defined whether a plain (neither explicitly signed or unsigned) char, short, int, or long bit-field is signed or unsigned. - + Naturally, we extend this to long long as well. Note that this does not include wchar_t. */ || (bitfield && !flag_signed_bitfields @@ -9793,7 +9797,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) /* A typedef for plain `int' without `signed' can be controlled just like plain `int', but a typedef for `signed int' cannot be so controlled. */ - && !(typedef_decl + && !(typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)) && (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == CHAR_TYPE) @@ -9847,7 +9851,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) type = build_complex_type (type); } - if (return_type == return_conversion + if (return_type == return_conversion && (RIDBIT_SETP (RID_CONST, specbits) || RIDBIT_SETP (RID_VOLATILE, specbits) || RIDBIT_SETP (RID_RESTRICT, specbits))) @@ -9859,9 +9863,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) Likewise for VOLATILEP. */ constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type); - restrictp = + restrictp = !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type); - volatilep = + volatilep = !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type); type_quals = ((constp ? TYPE_QUAL_CONST : 0) | (restrictp ? TYPE_QUAL_RESTRICT : 0) @@ -9946,7 +9950,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) if (declarator) { - /* Avoid trying to get an operand off an identifier node. */ + /* Avoid trying to get an operand off an identifier node. */ if (TREE_CODE (declarator) == IDENTIFIER_NODE) tmp = declarator; else @@ -9998,7 +10002,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) the declared identifier (or NULL_TREE, in an absolute declarator). */ inner_attrs = NULL_TREE; - ignore_attrs = 0; + ignore_attrs = 0; while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE && TREE_CODE (declarator) != TEMPLATE_ID_EXPR) @@ -10121,7 +10125,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF) inner_decl = TREE_OPERAND (inner_decl, 1); - if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR) + if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR) inner_decl = dname; /* Pick up type qualifiers which should be applied to `this'. */ @@ -10133,11 +10137,11 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) /* Say it's a definition only for the CALL_EXPR closest to the identifier. */ funcdecl_p - = inner_decl + = inner_decl && (TREE_CODE (inner_decl) == IDENTIFIER_NODE - || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR + || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR || TREE_CODE (inner_decl) == BIT_NOT_EXPR); - + if (ctype == NULL_TREE && decl_context == FIELD && funcdecl_p @@ -10250,7 +10254,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) want the underlying IDENTIFIER. */ if (TREE_CODE (declarator) == BIT_NOT_EXPR) declarator = TREE_OPERAND (declarator, 0); - + if (strict_prototype == 0 && arg_types == NULL_TREE) arg_types = void_list_node; else if (arg_types == NULL_TREE @@ -10437,7 +10441,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) ctype = TREE_OPERAND (declarator, 0); t = ctype; - while (t != NULL_TREE && CLASS_TYPE_P (t)) + while (t != NULL_TREE && CLASS_TYPE_P (t)) { if (CLASSTYPE_TEMPLATE_INFO (t) && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) @@ -10673,10 +10677,10 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) type is a (non-primary) template. The name for the template needs updating as well. */ if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type)) - DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)) + DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)) = TYPE_IDENTIFIER (type); - /* XXX Temporarily set the scope. + /* XXX Temporarily set the scope. When returning, start_decl expects it as NULL_TREE, and will then then set it using pushdecl. */ my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404); @@ -10845,7 +10849,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) return NULL_TREE; } } - + { register tree decl; @@ -10930,11 +10934,11 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) } /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */ - function_context = (ctype != NULL_TREE) ? + function_context = (ctype != NULL_TREE) ? hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE; publicp = (! friendp || ! staticp) && function_context == NULL_TREE; - decl = grokfndecl (ctype, type, + decl = grokfndecl (ctype, type, TREE_CODE (declarator) != TEMPLATE_ID_EXPR ? declarator : dname, declarator, @@ -10966,7 +10970,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) We don't look at the first parameter, which is really just the `this' parameter for the new object. */ - tree arg_types = + tree arg_types = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl))); /* Skip the `in_chrg' argument too, if present. */ @@ -10974,8 +10978,8 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) arg_types = TREE_CHAIN (arg_types); if (arg_types == void_list_node - || (arg_types - && TREE_CHAIN (arg_types) + || (arg_types + && TREE_CHAIN (arg_types) && TREE_CHAIN (arg_types) != void_list_node && !TREE_PURPOSE (TREE_CHAIN (arg_types)))) DECL_NONCONVERTING_P (decl) = 1; @@ -11039,8 +11043,8 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) { if (template_class_depth (current_class_type) == 0) { - decl - = check_explicit_specialization + decl + = check_explicit_specialization (declarator, decl, template_count, 2 * (funcdef_flag != 0) + 4); if (decl == error_mark_node) @@ -11053,7 +11057,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) } if (t && funcdef_flag) return t; - + return void_type_node; } } @@ -11068,11 +11072,11 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) { /* An attempt is being made to initialize a non-static member. But, from [class.mem]: - + 4 A member-declarator can contain a constant-initializer only if it declares a static member (_class.static_) of integral or enumeration - type, see _class.static.data_. + type, see _class.static.data_. This used to be relatively common practice, but the rest of the compiler does not correctly @@ -11160,7 +11164,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) else pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name); } - + if (ctype == NULL_TREE) { if (virtualp) @@ -11181,7 +11185,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) decl = grokfndecl (ctype, type, original_name, declarator, virtualp, flags, quals, raises, 1, friendp, - publicp, inlinep, funcdef_flag, + publicp, inlinep, funcdef_flag, template_count, in_namespace); if (decl == NULL_TREE) return NULL_TREE; @@ -11216,9 +11220,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) /* It's a variable. */ /* An uninitialized decl with `extern' is a reference. */ - decl = grokvardecl (type, declarator, &specbits, - initialized, - (type_quals & TYPE_QUAL_CONST) != 0, + decl = grokvardecl (type, declarator, &specbits, + initialized, + (type_quals & TYPE_QUAL_CONST) != 0, in_namespace); bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE, inlinep, friendp, raises != NULL_TREE); @@ -11330,7 +11334,7 @@ int local_variable_p (t) tree t; { - if ((TREE_CODE (t) == VAR_DECL + if ((TREE_CODE (t) == VAR_DECL /* A VAR_DECL with a context that is a _TYPE is a static data member. */ && !TYPE_P (CP_DECL_CONTEXT (t)) @@ -11364,7 +11368,7 @@ local_variable_p_walkfn (tp, walk_subtrees, data) int *walk_subtrees ATTRIBUTE_UNUSED; void *data ATTRIBUTE_UNUSED; { - return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp)) + return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp)) ? *tp : NULL_TREE); } @@ -11402,7 +11406,7 @@ check_default_argument (decl, arg) else decl_type = TREE_TYPE (decl); - if (arg == error_mark_node + if (arg == error_mark_node || decl == error_mark_node || TREE_TYPE (arg) == error_mark_node || decl_type == error_mark_node) @@ -11411,14 +11415,14 @@ check_default_argument (decl, arg) return error_mark_node; /* [dcl.fct.default] - + A default argument expression is implicitly converted to the parameter type. */ if (!TREE_TYPE (arg) || !can_convert_arg (decl_type, TREE_TYPE (arg), arg)) { if (decl) - cp_error ("default argument for `%#D' has type `%T'", + cp_error ("default argument for `%#D' has type `%T'", decl, TREE_TYPE (arg)); else cp_error ("default argument for parameter of type `%T' has type `%T'", @@ -11430,7 +11434,7 @@ check_default_argument (decl, arg) /* [dcl.fct.default] Local variables shall not be used in default argument - expressions. + expressions. The keyword `this' shall not be used in a default argument of a member function. */ @@ -11521,7 +11525,7 @@ grokparms (first_parm, funcdef_flag) chain = TREE_CHAIN (parm); /* @@ weak defense against parse errors. */ - if (TREE_CODE (decl) != VOID_TYPE + if (TREE_CODE (decl) != VOID_TYPE && TREE_CODE (decl) != TREE_LIST) { /* Give various messages as the need arises. */ @@ -11738,7 +11742,7 @@ grok_ctor_properties (ctype, decl) A declaration of a constructor for a class X is ill-formed if its first parameter is of type (optionally cv-qualified) X and either there are no other parameters or else all other parameters have - default arguments. + default arguments. We *don't* complain about member template instantiations that have this form, though; they can occur as we try to decide what @@ -11843,7 +11847,7 @@ grok_op_properties (decl, virtualp, friendp) doesn't look at the class declaration to find out if it's static. */ if (methodp) revert_static_member_fn (&decl, NULL, NULL); - + /* Take care of function decl if we had syntax errors. */ if (argtypes == NULL_TREE) TREE_TYPE (decl) @@ -11858,7 +11862,7 @@ grok_op_properties (decl, virtualp, friendp) { if (methodp) revert_static_member_fn (&decl, NULL, NULL); - + if (argtypes == NULL_TREE) TREE_TYPE (decl) = build_function_type (void_type_node, @@ -11915,7 +11919,7 @@ grok_op_properties (decl, virtualp, friendp) ; } } - + if (name == ansi_opname[(int) CALL_EXPR]) return; /* No restrictions on args. */ @@ -11969,7 +11973,7 @@ grok_op_properties (decl, virtualp, friendp) { /* 13.4.0.3 */ cp_error ("ANSI C++ prohibits overloading operator ?:"); - } + } else if (ambi_op_p (name)) { if (list_length (argtypes) == 2) @@ -12190,11 +12194,11 @@ xref_tag (code_type_node, name, globalize) } else ref = lookup_tag (code, name, b, 0); - + if (! ref) { /* Try finding it as a type declaration. If that wins, - use it. */ + use it. */ ref = lookup_name (name, 1); if (ref != NULL_TREE @@ -12212,9 +12216,9 @@ xref_tag (code_type_node, name, globalize) ref = NULL_TREE; } - if (ref && current_class_type - && template_class_depth (current_class_type) - && PROCESSING_REAL_TEMPLATE_DECL_P ()) + if (ref && current_class_type + && template_class_depth (current_class_type) + && PROCESSING_REAL_TEMPLATE_DECL_P ()) { /* Since GLOBALIZE is non-zero, we are not looking at a definition of this tag. Since, in addition, we are currently @@ -12303,7 +12307,7 @@ xref_tag (code_type_node, name, globalize) else { /* If it no longer looks like a nested type, make sure it's - in global scope. + in global scope. If it is not an IDENTIFIER, this is not a declaration */ if (b->namespace_p && !class_binding_level && TREE_CODE (name) == IDENTIFIER_NODE @@ -12444,7 +12448,7 @@ xref_basetypes (code_type_node, name, ref, binfo) } if (TYPE_FOR_JAVA (basetype) - && (current_lang_stack + && (current_lang_stack == &VARRAY_TREE (current_lang_base, 0))) TYPE_FOR_JAVA (ref) = 1; @@ -12455,14 +12459,14 @@ xref_basetypes (code_type_node, name, ref, binfo) derived classes. (Each BINFO record describing an individual inheritance contains flags which say what the `accessibility' of that particular inheritance is.) */ - - base_binfo + + base_binfo = make_binfo (integer_zero_node, basetype, CLASS_TYPE_P (basetype) ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE, CLASS_TYPE_P (basetype) ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE); - + TREE_VEC_ELT (binfos, i) = base_binfo; TREE_VIA_PUBLIC (base_binfo) = via_public; TREE_VIA_PROTECTED (base_binfo) = via_protected; @@ -12490,12 +12494,12 @@ xref_basetypes (code_type_node, name, ref, binfo) TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype); TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype); /* If the base-class uses multiple inheritance, so do we. */ - TYPE_USES_MULTIPLE_INHERITANCE (ref) + TYPE_USES_MULTIPLE_INHERITANCE (ref) |= TYPE_USES_MULTIPLE_INHERITANCE (basetype); /* Likewise, if converting to a base of the base may require code, then we may need to generate code to convert to a base as well. */ - TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) + TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype); } @@ -12524,7 +12528,7 @@ xref_basetypes (code_type_node, name, ref, binfo) bases. */ get_vbase_types (ref); } - + /* Begin compiling the definition of an enumeration type. NAME is its name (or null if anonymous). @@ -12614,7 +12618,7 @@ finish_enum (enumtype) reason to do that when processing_template_decl. And, if the expression is something like a TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will - wreak havoc on the intended type of the expression. + wreak havoc on the intended type of the expression. Of course, there's also no point in trying to compute minimum or maximum values if we're in a template. */ @@ -12628,7 +12632,7 @@ finish_enum (enumtype) minnode = value; } - if (processing_template_decl) + if (processing_template_decl) /* If this is just a template, leave the CONST_DECL alone. That way tsubst_copy will find CONST_DECLs for CONST_DECLs, and not INTEGER_CSTs. */ @@ -12670,7 +12674,7 @@ finish_enum (enumtype) if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node))) /* Use the width of the narrowest normal C type which is wide - enough. */ + enough. */ TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1)); else @@ -12678,7 +12682,7 @@ finish_enum (enumtype) TYPE_SIZE (enumtype) = 0; layout_type (enumtype); - + /* Fix up all variant types of this enum type. */ for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem)) @@ -12754,7 +12758,7 @@ build_enumerator (name, value, enumtype) prev_value, integer_one_node, PLUS_EXPR); - + if (tree_int_cst_lt (value, prev_value)) cp_error ("overflow in enumeration values at `%D'", name); } @@ -12861,7 +12865,7 @@ check_function_type (decl) TREE_TYPE (decl) = build_function_type (void_type_node, TYPE_ARG_TYPES (TREE_TYPE (decl))); - TREE_TYPE (decl) + TREE_TYPE (decl) = build_exception_variant (fntype, TYPE_RAISES_EXCEPTIONS (fntype)); } @@ -12879,8 +12883,8 @@ check_function_type (decl) process and that DECLSPECS should be ignored), SF_INCLASS_INLINE indicating that the function is an inline defined in-class, and SF_EXPAND indicating that we should generate RTL for this - function. - + function. + This function creates a binding context for the function body as well as setting up the FUNCTION_DECL in current_function_decl. @@ -12983,7 +12987,7 @@ start_function (declspecs, declarator, attrs, flags) } } } - + /* Sometimes we don't notice that a function is a static member, and build a METHOD_TYPE for it. Fix that up now. */ if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1) @@ -13030,7 +13034,7 @@ start_function (declspecs, declarator, attrs, flags) #ifdef SET_DEFAULT_DECL_ATTRIBUTES SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs); #endif - + /* This function exists in static storage. (This does not mean `static' in the C sense!) */ TREE_STATIC (decl1) = 1; @@ -13064,8 +13068,8 @@ start_function (declspecs, declarator, attrs, flags) { DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype)); - c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype), - DECL_RESULT (decl1)); + c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype), + DECL_RESULT (decl1)); } } else @@ -13102,7 +13106,7 @@ start_function (declspecs, declarator, attrs, flags) if (!processing_template_decl && !(flags & SF_PRE_PARSED)) { /* A specialization is not used to guide overload resolution. */ - if ((flag_guiding_decls + if ((flag_guiding_decls || !DECL_TEMPLATE_SPECIALIZATION (decl1)) && ! DECL_FUNCTION_MEMBER_P (decl1)) decl1 = pushdecl (decl1); @@ -13151,13 +13155,13 @@ start_function (declspecs, declarator, attrs, flags) never get us to that point. Here we keep the consistency between `current_class_type' and `current_class_ptr'. */ tree t = DECL_ARGUMENTS (decl1); - - my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL, + + my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL, 162); my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE, 19990811); - - cp_function_chain->x_current_class_ref + + cp_function_chain->x_current_class_ref = build_indirect_ref (t, NULL_PTR); cp_function_chain->x_current_class_ptr = t; @@ -13180,7 +13184,7 @@ start_function (declspecs, declarator, attrs, flags) if (DECL_NOT_REALLY_EXTERN (decl1)) DECL_EXTERNAL (decl1) = 0; - if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx) + if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx) && TREE_PUBLIC (ctx)) /* This is a function in a local class in an extern inline function. */ @@ -13246,7 +13250,7 @@ start_function (declspecs, declarator, attrs, flags) if (attrs) cplus_decl_attributes (decl1, NULL_TREE, attrs); - + if (!building_stmt_tree ()) { GNU_xref_function (decl1, current_function_parms); @@ -13353,7 +13357,7 @@ store_parm_decls () if (doing_semantic_analysis_p ()) { tree cleanup; - + if (DECL_NAME (parm) == NULL_TREE || TREE_CODE (parm) != VOID_TYPE) pushdecl (parm); @@ -13361,7 +13365,7 @@ store_parm_decls () cp_error ("parameter `%D' declared void", parm); cleanup = maybe_build_cleanup (parm); - + if (cleanup) cleanups = tree_cons (parm, cleanup, cleanups); } @@ -13414,7 +13418,7 @@ store_parm_decls () should not be called before the parm can be used. */ while (cleanups) { - finish_decl_cleanup (TREE_PURPOSE (cleanups), + finish_decl_cleanup (TREE_PURPOSE (cleanups), TREE_VALUE (cleanups)); cleanups = TREE_CHAIN (cleanups); } @@ -13430,8 +13434,8 @@ store_parm_decls () } /* Do the starting of the exception specifications, if we have any. */ - if (flag_exceptions && !processing_template_decl - && building_stmt_tree () + if (flag_exceptions && !processing_template_decl + && building_stmt_tree () && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl))) current_eh_spec_try_block = expand_start_eh_spec (); } @@ -13474,9 +13478,9 @@ save_function_data (decl) get it back when we really expand this function. */ my_friendly_assert (!DECL_PENDING_INLINE_P (decl), 19990908); - + /* Make a copy. */ - f = ((struct language_function *) + f = ((struct language_function *) xmalloc (sizeof (struct language_function))); bcopy ((char *) cp_function_chain, (char *) f, sizeof (struct language_function)); @@ -13555,9 +13559,9 @@ finish_destructor_body () in_charge = current_in_charge_parm; exprstmt = build_delete (current_class_type, - current_class_ref, + current_class_ref, in_charge, - LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, + LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0); if (exprstmt != error_mark_node @@ -13576,7 +13580,7 @@ finish_destructor_body () tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type))); tree if_stmt = begin_if_stmt (); finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node, - current_in_charge_parm, + current_in_charge_parm, integer_two_node), if_stmt); @@ -13599,16 +13603,16 @@ finish_destructor_body () finish_if_stmt (); } } - + virtual_size = c_sizeof (current_class_type); /* At the end, call delete if that's what's requested. */ - + /* FDIS sez: At the point of definition of a virtual destructor (including an implicit definition), non-placement operator delete shall be looked up in the scope of the destructor's class and if found shall be accessible and unambiguous. - + This is somewhat unclear, but I take it to mean that if the class only defines placement deletes we don't do anything here. So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if @@ -13643,8 +13647,8 @@ finish_destructor_body () This is called after parsing the body of the function definition. LINENO is the current line number. - FLAGS is a bitwise or of the following values: - 1 - CALL_POPLEVEL + FLAGS is a bitwise or of the following values: + 1 - CALL_POPLEVEL An extra call to poplevel (and expand_end_bindings) must be made to take care of the binding contour for the base initializers. This is only relevant for constructors. @@ -13709,7 +13713,7 @@ finish_function (lineno, flags) /* Finish dealing with exception specifiers. */ if (flag_exceptions && !processing_template_decl && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl))) - expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS + expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)), current_eh_spec_try_block); } @@ -13760,7 +13764,7 @@ finish_function (lineno, flags) /* If this function is supposed to return a value, ensure that we do not fall into the cleanups by mistake. The end of our function will look like this: - + user code (may have return stmt somewhere) goto no_return_label cleanup_label: @@ -13770,7 +13774,7 @@ finish_function (lineno, flags) NOTE_INSN_FUNCTION_END return_label: things for return - + If the user omits a return stmt in the USER CODE section, we will have a control path which reaches NOTE_INSN_FUNCTION_END. Otherwise, we won't. */ @@ -13825,7 +13829,7 @@ finish_function (lineno, flags) maybe_end_member_template_processing decides to pop all the template parameters. */ expand_p = !building_stmt_tree (); - + /* If we're saving up tree structure, tie off the function now. */ if (!expand_p) finish_stmt_tree (&DECL_SAVED_TREE (fndecl)); @@ -14067,7 +14071,7 @@ start_method (declspecs, declarator, attrlist) { if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type) { - if (DECL_CONTEXT (fndecl) + if (DECL_CONTEXT (fndecl) && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL) cp_error ("`%D' is already defined in class %s", fndecl, TYPE_NAME_STRING (DECL_CONTEXT (fndecl))); @@ -14114,7 +14118,7 @@ start_method (declspecs, declarator, attrlist) /* Make a place for the parms */ pushlevel (0); current_binding_level->parm_flag = 1; - + DECL_IN_AGGR_P (fndecl) = 1; return fndecl; } @@ -14307,7 +14311,7 @@ cplus_expand_expr_stmt (exp) { if (stmts_are_full_exprs_p) exp = convert_to_void (exp, "statement"); - + #if 0 /* We should do this eventually, but right now this causes regex.o from libg++ to miscompile, and tString to core dump. */ @@ -14347,9 +14351,9 @@ revert_static_member_fn (decl, fn, argtypes) tree function = fn ? *fn : TREE_TYPE (*decl); tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function); - if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args))) + if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args))) != TYPE_UNQUALIFIED) - cp_error ("static member function `%#D' declared with type qualifiers", + cp_error ("static member function `%#D' declared with type qualifiers", *decl); args = TREE_CHAIN (args); @@ -14367,15 +14371,15 @@ revert_static_member_fn (decl, fn, argtypes) *argtypes = args; } -/* Initialize the variables used during compilation of a C++ - function. */ +/* Initialize the variables used during compilation of a C++ + function. */ static void push_cp_function_context (f) struct function *f; { - struct language_function *p - = ((struct language_function *) + struct language_function *p + = ((struct language_function *) xcalloc (1, sizeof (struct language_function))); f->language = p; @@ -14513,7 +14517,7 @@ lang_mark_tree (t) { struct lang_type *lt = TYPE_LANG_SPECIFIC (t); - if (lt && !(TREE_CODE (t) == POINTER_TYPE + if (lt && !(TREE_CODE (t) == POINTER_TYPE && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE)) { ggc_mark (lt); @@ -14535,4 +14539,3 @@ lang_mark_tree (t) ggc_mark_tree ((tree) lt); } } -