1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
34 static cxx_scope
*innermost_nonclass_level (void);
35 static tree
select_decl (cxx_binding
*, int);
36 static cxx_binding
*binding_for_name (cxx_scope
*, tree
);
37 static tree
lookup_name_current_level (tree
);
38 static void push_local_binding (tree
, tree
, int);
39 static tree
push_overloaded_decl (tree
, int);
40 static bool lookup_using_namespace (tree
, cxx_binding
*, tree
,
42 static bool qualified_lookup_using_namespace (tree
, tree
, cxx_binding
*, int);
43 static tree
lookup_type_current_level (tree
);
44 static tree
push_using_directive (tree
);
47 /* The :: namespace. */
49 tree global_namespace
;
51 /* The name of the anonymous namespace, throughout this translation
53 GTY(()) tree anonymous_namespace_name
;
56 /* Compute the chain index of a binding_entry given the HASH value of its
57 name and the total COUNT of chains. COUNT is assumed to be a power
60 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
62 /* A free list of "binding_entry"s awaiting for re-use. */
64 static GTY((deletable(""))) binding_entry free_binding_entry
= NULL
;
66 /* Create a binding_entry object for (NAME, TYPE). */
68 static inline binding_entry
69 binding_entry_make (tree name
, tree type
)
73 if (free_binding_entry
)
75 entry
= free_binding_entry
;
76 free_binding_entry
= entry
->chain
;
79 entry
= ggc_alloc (sizeof (struct binding_entry_s
));
88 /* Put ENTRY back on the free list. */
91 binding_entry_free (binding_entry entry
)
95 entry
->chain
= free_binding_entry
;
96 free_binding_entry
= entry
;
99 /* The datatype used to implement the mapping from names to types at
101 struct binding_table_s
GTY(())
103 /* Array of chains of "binding_entry"s */
104 binding_entry
* GTY((length ("%h.chain_count"))) chain
;
106 /* The number of chains in this table. This is the length of the
107 the member "chain" considered as an array. */
110 /* Number of "binding_entry"s in this table. */
114 /* Construct TABLE with an initial CHAIN_COUNT. */
117 binding_table_construct (binding_table table
, size_t chain_count
)
119 table
->chain_count
= chain_count
;
120 table
->entry_count
= 0;
121 table
->chain
= ggc_alloc_cleared
122 (table
->chain_count
* sizeof (binding_entry
));
125 /* Make TABLE's entries ready for reuse. */
128 binding_table_free (binding_table table
)
136 for (i
= 0, count
= table
->chain_count
; i
< count
; ++i
)
138 binding_entry temp
= table
->chain
[i
];
141 binding_entry entry
= temp
;
143 binding_entry_free (entry
);
145 table
->chain
[i
] = NULL
;
147 table
->entry_count
= 0;
150 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
152 static inline binding_table
153 binding_table_new (size_t chain_count
)
155 binding_table table
= ggc_alloc (sizeof (struct binding_table_s
));
157 binding_table_construct (table
, chain_count
);
161 /* Expand TABLE to twice its current chain_count. */
164 binding_table_expand (binding_table table
)
166 const size_t old_chain_count
= table
->chain_count
;
167 const size_t old_entry_count
= table
->entry_count
;
168 const size_t new_chain_count
= 2 * old_chain_count
;
169 binding_entry
*old_chains
= table
->chain
;
172 binding_table_construct (table
, new_chain_count
);
173 for (i
= 0; i
< old_chain_count
; ++i
)
175 binding_entry entry
= old_chains
[i
];
176 for (; entry
!= NULL
; entry
= old_chains
[i
])
178 const unsigned int hash
= IDENTIFIER_HASH_VALUE (entry
->name
);
179 const size_t j
= ENTRY_INDEX (hash
, new_chain_count
);
181 old_chains
[i
] = entry
->chain
;
182 entry
->chain
= table
->chain
[j
];
183 table
->chain
[j
] = entry
;
186 table
->entry_count
= old_entry_count
;
189 /* Insert a binding for NAME to TYPE into TABLE. */
192 binding_table_insert (binding_table table
, tree name
, tree type
)
194 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
195 const size_t i
= ENTRY_INDEX (hash
, table
->chain_count
);
196 binding_entry entry
= binding_entry_make (name
, type
);
198 entry
->chain
= table
->chain
[i
];
199 table
->chain
[i
] = entry
;
200 ++table
->entry_count
;
202 if (3 * table
->chain_count
< 5 * table
->entry_count
)
203 binding_table_expand (table
);
206 /* Return the binding_entry, if any, that maps NAME. */
209 binding_table_find (binding_table table
, tree name
)
211 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
212 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
214 while (entry
!= NULL
&& entry
->name
!= name
)
215 entry
= entry
->chain
;
220 /* Return the binding_entry, if any, that maps NAME to an anonymous type. */
223 binding_table_find_anon_type (binding_table table
, tree name
)
225 const unsigned int hash
= IDENTIFIER_HASH_VALUE (name
);
226 binding_entry entry
= table
->chain
[ENTRY_INDEX (hash
, table
->chain_count
)];
228 while (entry
!= NULL
&& TYPE_IDENTIFIER (entry
->type
) != name
)
229 entry
= entry
->chain
;
231 return entry
? entry
->type
: NULL
;
234 /* Return the binding_entry, if any, that has TYPE as target. If NAME
235 is non-null, then set the domain and rehash that entry. */
238 binding_table_reverse_maybe_remap (binding_table table
, tree type
, tree name
)
240 const size_t chain_count
= table
->chain_count
;
241 binding_entry entry
= NULL
;
242 binding_entry
*p
= NULL
;
245 for (i
= 0; i
< chain_count
&& entry
== NULL
; ++i
)
247 p
= &table
->chain
[i
];
248 while (*p
!= NULL
&& entry
== NULL
)
249 if ((*p
)->type
== type
)
255 if (entry
!= NULL
&& name
!= NULL
&& entry
->name
!= name
)
257 /* Remove the bucket from the previous chain. */
260 /* Remap the name type to type. */
261 i
= ENTRY_INDEX (IDENTIFIER_HASH_VALUE (name
), chain_count
);
262 entry
->chain
= table
->chain
[i
];
264 table
->chain
[i
] = entry
;
270 /* Remove from TABLE all entries that map to anonymous enums or
274 binding_table_remove_anonymous_types (binding_table table
)
276 const size_t chain_count
= table
->chain_count
;
279 for (i
= 0; i
< chain_count
; ++i
)
281 binding_entry
*p
= &table
->chain
[i
];
284 if (ANON_AGGRNAME_P ((*p
)->name
))
286 binding_entry e
= *p
;
288 --table
->entry_count
;
289 binding_entry_free (e
);
296 /* Apply PROC -- with DATA -- to all entries in TABLE. */
299 binding_table_foreach (binding_table table
, bt_foreach_proc proc
, void *data
)
301 const size_t chain_count
= table
->chain_count
;
304 for (i
= 0; i
< chain_count
; ++i
)
306 binding_entry entry
= table
->chain
[i
];
307 for (; entry
!= NULL
; entry
= entry
->chain
)
312 #ifndef ENABLE_SCOPE_CHECKING
313 # define ENABLE_SCOPE_CHECKING 0
315 # define ENABLE_SCOPE_CHECKING 1
318 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
320 static GTY((deletable (""))) cxx_binding
*free_bindings
;
322 /* Zero out a cxx_binding pointed to by B. */
323 #define cxx_binding_clear(B) memset ((B), 0, sizeof (cxx_binding))
325 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
328 cxx_binding_make (tree value
, tree type
)
330 cxx_binding
*binding
;
333 binding
= free_bindings
;
334 free_bindings
= binding
->previous
;
337 binding
= ggc_alloc (sizeof (cxx_binding
));
339 binding
->value
= value
;
340 binding
->type
= type
;
341 binding
->previous
= NULL
;
346 /* Put BINDING back on the free list. */
349 cxx_binding_free (cxx_binding
*binding
)
351 binding
->scope
= NULL
;
352 binding
->previous
= free_bindings
;
353 free_bindings
= binding
;
356 /* Make DECL the innermost binding for ID. The LEVEL is the binding
357 level at which this declaration is being bound. */
360 push_binding (tree id
, tree decl
, cxx_scope
* level
)
362 cxx_binding
*binding
= cxx_binding_make (decl
, NULL
);
364 /* Now, fill in the binding information. */
365 binding
->previous
= IDENTIFIER_BINDING (id
);
366 binding
->scope
= level
;
367 INHERITED_VALUE_BINDING_P (binding
) = 0;
368 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
370 /* And put it on the front of the list of bindings for ID. */
371 IDENTIFIER_BINDING (id
) = binding
;
374 /* Remove the binding for DECL which should be the innermost binding
378 pop_binding (tree id
, tree decl
)
380 cxx_binding
*binding
;
383 /* It's easiest to write the loops that call this function without
384 checking whether or not the entities involved have names. We
385 get here for such an entity. */
388 /* Get the innermost binding for ID. */
389 binding
= IDENTIFIER_BINDING (id
);
391 /* The name should be bound. */
392 my_friendly_assert (binding
!= NULL
, 0);
394 /* The DECL will be either the ordinary binding or the type
395 binding for this identifier. Remove that binding. */
396 if (binding
->value
== decl
)
397 binding
->value
= NULL_TREE
;
398 else if (binding
->type
== decl
)
399 binding
->type
= NULL_TREE
;
403 if (!binding
->value
&& !binding
->type
)
405 /* We're completely done with the innermost binding for this
406 identifier. Unhook it from the list of bindings. */
407 IDENTIFIER_BINDING (id
) = binding
->previous
;
409 /* Add it to the free list. */
410 cxx_binding_free (binding
);
414 /* BINDING records an existing declaration for a namein the current scope.
415 But, DECL is another declaration for that same identifier in the
416 same scope. This is the `struct stat' hack whereby a non-typedef
417 class name or enum-name can be bound at the same level as some other
421 A class name (9.1) or enumeration name (7.2) can be hidden by the
422 name of an object, function, or enumerator declared in the same scope.
423 If a class or enumeration name and an object, function, or enumerator
424 are declared in the same scope (in any order) with the same name, the
425 class or enumeration name is hidden wherever the object, function, or
426 enumerator name is visible.
428 It's the responsibility of the caller to check that
429 inserting this name is valid here. Returns nonzero if the new binding
433 supplement_binding (cxx_binding
*binding
, tree decl
)
435 tree bval
= binding
->value
;
438 timevar_push (TV_NAME_LOOKUP
);
439 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
440 /* The new name is the type name. */
441 binding
->type
= decl
;
442 else if (!bval
|| bval
== error_mark_node
)
443 /* VALUE is null when push_class_level_binding moves an inherited
444 type-binding out of the way to make room for a new value binding.
445 It is an error_mark_node when DECL's name has been used in a
446 non-class scope prior declaration. In that case, we should have
447 already issued a diagnostic; for graceful error recovery purpose,
448 pretend this was the intended declaration for that name. */
449 binding
->value
= decl
;
450 else if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
))
452 /* The old binding was a type name. It was placed in
453 VALUE field because it was thought, at the point it was
454 declared, to be the only entity with such a name. Move the
455 type name into the type slot; it is now hidden by the new
457 binding
->type
= bval
;
458 binding
->value
= decl
;
459 binding
->value_is_inherited
= false;
461 else if (TREE_CODE (bval
) == TYPE_DECL
462 && TREE_CODE (decl
) == TYPE_DECL
463 && DECL_NAME (decl
) == DECL_NAME (bval
)
464 && (same_type_p (TREE_TYPE (decl
), TREE_TYPE (bval
))
465 /* If either type involves template parameters, we must
466 wait until instantiation. */
467 || uses_template_parms (TREE_TYPE (decl
))
468 || uses_template_parms (TREE_TYPE (bval
))))
469 /* We have two typedef-names, both naming the same type to have
470 the same name. This is OK because of:
474 In a given scope, a typedef specifier can be used to redefine
475 the name of any type declared in that scope to refer to the
476 type to which it already refers. */
478 /* There can be two block-scope declarations of the same variable,
479 so long as they are `extern' declarations. However, there cannot
480 be two declarations of the same static data member:
484 A member shall not be declared twice in the
485 member-specification. */
486 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_CODE (bval
) == VAR_DECL
487 && DECL_EXTERNAL (decl
) && DECL_EXTERNAL (bval
)
488 && !DECL_CLASS_SCOPE_P (decl
))
490 duplicate_decls (decl
, binding
->value
);
495 error ("declaration of `%#D'", decl
);
496 cp_error_at ("conflicts with previous declaration `%#D'",
501 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ok
);
504 /* Add DECL to the list of things declared in B. */
507 add_decl_to_level (tree decl
, cxx_scope
*b
)
509 if (TREE_CODE (decl
) == NAMESPACE_DECL
510 && !DECL_NAMESPACE_ALIAS (decl
))
512 TREE_CHAIN (decl
) = b
->namespaces
;
513 b
->namespaces
= decl
;
515 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
517 TREE_CHAIN (decl
) = b
->vtables
;
522 /* We build up the list in reverse order, and reverse it later if
524 TREE_CHAIN (decl
) = b
->names
;
528 /* If appropriate, add decl to separate list of statics */
529 if (b
->kind
== sk_namespace
)
530 if ((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
531 || (TREE_CODE (decl
) == FUNCTION_DECL
532 && (!TREE_PUBLIC (decl
) || DECL_DECLARED_INLINE_P (decl
))))
533 VARRAY_PUSH_TREE (b
->static_decls
, decl
);
537 /* Record a decl-node X as belonging to the current lexical scope.
538 Check for errors (such as an incompatible declaration for the same
539 name already seen in the same scope).
541 Returns either X or an old decl for the same name.
542 If an old decl is returned, it may have been smashed
543 to agree with what X says. */
550 int need_new_binding
;
552 timevar_push (TV_NAME_LOOKUP
);
554 need_new_binding
= 1;
556 if (DECL_TEMPLATE_PARM_P (x
))
557 /* Template parameters have no context; they are not X::T even
558 when declared within a class or namespace. */
562 if (current_function_decl
&& x
!= current_function_decl
563 /* A local declaration for a function doesn't constitute
565 && !(TREE_CODE (x
) == FUNCTION_DECL
&& !DECL_INITIAL (x
))
566 /* A local declaration for an `extern' variable is in the
567 scope of the current namespace, not the current
569 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
570 && !DECL_CONTEXT (x
))
571 DECL_CONTEXT (x
) = current_function_decl
;
573 /* If this is the declaration for a namespace-scope function,
574 but the declaration itself is in a local scope, mark the
576 if (TREE_CODE (x
) == FUNCTION_DECL
577 && DECL_NAMESPACE_SCOPE_P (x
)
578 && current_function_decl
579 && x
!= current_function_decl
)
580 DECL_LOCAL_FUNCTION_P (x
) = 1;
583 name
= DECL_NAME (x
);
586 int different_binding_level
= 0;
588 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
589 name
= TREE_OPERAND (name
, 0);
591 /* In case this decl was explicitly namespace-qualified, look it
592 up in its namespace context. */
593 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
)
594 && namespace_bindings_p ())
595 t
= namespace_binding (name
, DECL_CONTEXT (x
));
597 t
= lookup_name_current_level (name
);
599 /* [basic.link] If there is a visible declaration of an entity
600 with linkage having the same name and type, ignoring entities
601 declared outside the innermost enclosing namespace scope, the
602 block scope declaration declares that same entity and
603 receives the linkage of the previous declaration. */
604 if (! t
&& current_function_decl
&& x
!= current_function_decl
605 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
606 && DECL_EXTERNAL (x
))
608 /* Look in block scope. */
609 t
= IDENTIFIER_VALUE (name
);
610 /* Or in the innermost namespace. */
612 t
= namespace_binding (name
, DECL_CONTEXT (x
));
613 /* Does it have linkage? Note that if this isn't a DECL, it's an
614 OVERLOAD, which is OK. */
615 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
618 different_binding_level
= 1;
621 /* If we are declaring a function, and the result of name-lookup
622 was an OVERLOAD, look for an overloaded instance that is
623 actually the same as the function we are declaring. (If
624 there is one, we have to merge our declaration with the
625 previous declaration.) */
626 if (t
&& TREE_CODE (t
) == OVERLOAD
)
630 if (TREE_CODE (x
) == FUNCTION_DECL
)
631 for (match
= t
; match
; match
= OVL_NEXT (match
))
633 if (decls_match (OVL_CURRENT (match
), x
))
637 /* Just choose one. */
641 t
= OVL_CURRENT (match
);
646 if (t
== error_mark_node
)
648 /* error_mark_node is 0 for a while during initialization! */
650 cp_error_at ("`%#D' used prior to declaration", x
);
652 else if (t
!= NULL_TREE
)
654 if (different_binding_level
)
656 if (decls_match (x
, t
))
657 /* The standard only says that the local extern
658 inherits linkage from the previous decl; in
659 particular, default args are not shared. It would
660 be nice to propagate inlining info, though. FIXME. */
661 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
663 else if (TREE_CODE (t
) == PARM_DECL
)
665 if (DECL_CONTEXT (t
) == NULL_TREE
)
666 /* This is probably caused by too many errors, but calling
667 abort will say that if errors have occurred. */
670 /* Check for duplicate params. */
671 if (duplicate_decls (x
, t
))
672 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
674 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
675 || DECL_FUNCTION_TEMPLATE_P (x
))
676 && is_overloaded_fn (t
))
677 /* Don't do anything just yet. */;
678 else if (t
== wchar_decl_node
)
680 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
681 pedwarn ("redeclaration of `wchar_t' as `%T'",
684 /* Throw away the redeclaration. */
685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
689 tree olddecl
= duplicate_decls (x
, t
);
691 /* If the redeclaration failed, we can stop at this
693 if (olddecl
== error_mark_node
)
694 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
698 if (TREE_CODE (t
) == TYPE_DECL
)
699 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
700 else if (TREE_CODE (t
) == FUNCTION_DECL
)
701 check_default_args (t
);
703 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
705 else if (DECL_MAIN_P (x
))
707 /* A redeclaration of main, but not a duplicate of the
712 This function shall not be overloaded. */
713 cp_error_at ("invalid redeclaration of `%D'", t
);
714 error ("as `%D'", x
);
715 /* We don't try to push this declaration since that
717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
722 check_template_shadow (x
);
724 /* If this is a function conjured up by the backend, massage it
725 so it looks friendly. */
726 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
728 retrofit_lang_decl (x
);
729 SET_DECL_LANGUAGE (x
, lang_c
);
732 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
734 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
736 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
737 if (!namespace_bindings_p ())
738 /* We do not need to create a binding for this name;
739 push_overloaded_decl will have already done so if
741 need_new_binding
= 0;
743 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
745 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
747 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
751 /* If declaring a type as a typedef, copy the type (unless we're
752 at line 0), and install this TYPE_DECL as the new type's typedef
753 name. See the extensive comment in ../c-decl.c (pushdecl). */
754 if (TREE_CODE (x
) == TYPE_DECL
)
756 tree type
= TREE_TYPE (x
);
757 if (DECL_SOURCE_LINE (x
) == 0)
759 if (TYPE_NAME (type
) == 0)
760 TYPE_NAME (type
) = x
;
762 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
763 /* We don't want to copy the type when all we're
764 doing is making a TYPE_DECL for the purposes of
766 && (!TYPE_NAME (type
)
767 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
769 DECL_ORIGINAL_TYPE (x
) = type
;
770 type
= build_type_copy (type
);
771 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
772 TYPE_NAME (type
) = x
;
773 TREE_TYPE (x
) = type
;
776 if (type
!= error_mark_node
778 && TYPE_IDENTIFIER (type
))
779 set_identifier_type_value (DECL_NAME (x
), x
);
782 /* Multiple external decls of the same identifier ought to match.
784 We get warnings about inline functions where they are defined.
785 We get warnings about other functions from push_overloaded_decl.
787 Avoid duplicate warnings where they are used. */
788 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
792 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
793 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
794 decl
= OVL_FUNCTION (decl
);
796 if (decl
&& decl
!= error_mark_node
797 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
798 /* If different sort of thing, we already gave an error. */
799 && TREE_CODE (decl
) == TREE_CODE (x
)
800 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
802 pedwarn ("type mismatch with previous external decl of `%#D'", x
);
803 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
807 /* This name is new in its binding level.
808 Install the new declaration and return it. */
809 if (namespace_bindings_p ())
811 /* Install a global value. */
813 /* If the first global decl has external linkage,
814 warn if we later see static one. */
815 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
816 TREE_PUBLIC (name
) = 1;
818 /* Bind the name for the entity. */
819 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
821 && (TREE_CODE (x
) == TYPE_DECL
822 || TREE_CODE (x
) == VAR_DECL
823 || TREE_CODE (x
) == ALIAS_DECL
824 || TREE_CODE (x
) == NAMESPACE_DECL
825 || TREE_CODE (x
) == CONST_DECL
826 || TREE_CODE (x
) == TEMPLATE_DECL
))
827 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
829 /* Don't forget if the function was used via an implicit decl. */
830 if (IDENTIFIER_IMPLICIT_DECL (name
)
831 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
834 /* Don't forget if its address was taken in that way. */
835 if (IDENTIFIER_IMPLICIT_DECL (name
)
836 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
837 TREE_ADDRESSABLE (x
) = 1;
839 /* Warn about mismatches against previous implicit decl. */
840 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
841 /* If this real decl matches the implicit, don't complain. */
842 && ! (TREE_CODE (x
) == FUNCTION_DECL
843 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
845 ("`%D' was previously implicitly declared to return `int'", x
);
847 /* If new decl is `static' and an `extern' was seen previously,
849 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
850 warn_extern_redeclared_static (x
, t
);
854 /* Here to install a non-global value. */
855 tree oldlocal
= IDENTIFIER_VALUE (name
);
856 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
858 if (need_new_binding
)
860 push_local_binding (name
, x
, 0);
861 /* Because push_local_binding will hook X on to the
862 current_binding_level's name list, we don't want to
863 do that again below. */
864 need_new_binding
= 0;
867 /* If this is a TYPE_DECL, push it into the type value slot. */
868 if (TREE_CODE (x
) == TYPE_DECL
)
869 set_identifier_type_value (name
, x
);
871 /* Clear out any TYPE_DECL shadowed by a namespace so that
872 we won't think this is a type. The C struct hack doesn't
873 go through namespaces. */
874 if (TREE_CODE (x
) == NAMESPACE_DECL
)
875 set_identifier_type_value (name
, NULL_TREE
);
882 && TREE_CODE (oldlocal
) == VAR_DECL
883 && DECL_DEAD_FOR_LOCAL (oldlocal
))
884 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
886 if (oldlocal
== NULL_TREE
)
887 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
890 /* If this is an extern function declaration, see if we
891 have a global definition or declaration for the function. */
892 if (oldlocal
== NULL_TREE
894 && oldglobal
!= NULL_TREE
895 && TREE_CODE (x
) == FUNCTION_DECL
896 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
898 /* We have one. Their types must agree. */
899 if (decls_match (x
, oldglobal
))
903 warning ("extern declaration of `%#D' doesn't match", x
);
904 cp_warning_at ("global declaration `%#D'", oldglobal
);
907 /* If we have a local external declaration,
908 and no file-scope declaration has yet been seen,
909 then if we later have a file-scope decl it must not be static. */
910 if (oldlocal
== NULL_TREE
911 && oldglobal
== NULL_TREE
914 TREE_PUBLIC (name
) = 1;
916 /* Warn if shadowing an argument at the top level of the body. */
917 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
918 /* Inline decls shadow nothing. */
919 && !DECL_FROM_INLINE (x
)
920 && TREE_CODE (oldlocal
) == PARM_DECL
921 /* Don't check the `this' parameter. */
922 && !DECL_ARTIFICIAL (oldlocal
))
926 /* Don't complain if it's from an enclosing function. */
927 if (DECL_CONTEXT (oldlocal
) == current_function_decl
928 && TREE_CODE (x
) != PARM_DECL
)
930 /* Go to where the parms should be and see if we find
932 struct cp_binding_level
*b
= current_binding_level
->level_chain
;
934 /* Skip the ctor/dtor cleanup level. */
938 if (b
->kind
== sk_function_parms
)
940 error ("declaration of `%#D' shadows a parameter",
946 if (warn_shadow
&& !err
)
947 shadow_warning (SW_PARAM
,
948 IDENTIFIER_POINTER (name
), oldlocal
);
951 /* Maybe warn if shadowing something else. */
952 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
953 /* No shadow warnings for internally generated vars. */
954 && ! DECL_ARTIFICIAL (x
)
955 /* No shadow warnings for vars made for inlining. */
956 && ! DECL_FROM_INLINE (x
))
958 if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
960 && !TREE_STATIC (name
))
961 warning ("declaration of `%s' shadows a member of `this'",
962 IDENTIFIER_POINTER (name
));
963 else if (oldlocal
!= NULL_TREE
964 && TREE_CODE (oldlocal
) == VAR_DECL
)
965 shadow_warning (SW_LOCAL
,
966 IDENTIFIER_POINTER (name
), oldlocal
);
967 else if (oldglobal
!= NULL_TREE
968 && TREE_CODE (oldglobal
) == VAR_DECL
)
969 /* XXX shadow warnings in outer-more namespaces */
970 shadow_warning (SW_GLOBAL
,
971 IDENTIFIER_POINTER (name
), oldglobal
);
975 if (TREE_CODE (x
) == FUNCTION_DECL
)
976 check_default_args (x
);
978 if (TREE_CODE (x
) == VAR_DECL
)
979 maybe_register_incomplete_var (x
);
982 if (need_new_binding
)
983 add_decl_to_level (x
,
984 DECL_NAMESPACE_SCOPE_P (x
)
985 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
986 : current_binding_level
);
988 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
991 /* Enter DECL into the symbol table, if that's appropriate. Returns
992 DECL, or a modified version thereof. */
995 maybe_push_decl (tree decl
)
997 tree type
= TREE_TYPE (decl
);
999 /* Add this decl to the current binding level, but not if it comes
1000 from another scope, e.g. a static member variable. TEM may equal
1001 DECL or it may be a previous decl of the same name. */
1002 if (decl
== error_mark_node
1003 || (TREE_CODE (decl
) != PARM_DECL
1004 && DECL_CONTEXT (decl
) != NULL_TREE
1005 /* Definitions of namespace members outside their namespace are
1007 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
1008 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
1009 || TREE_CODE (type
) == UNKNOWN_TYPE
1010 /* The declaration of a template specialization does not affect
1011 the functions available for overload resolution, so we do not
1013 || (TREE_CODE (decl
) == FUNCTION_DECL
1014 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
1017 return pushdecl (decl
);
1020 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1021 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1022 doesn't really belong to this binding level, that it got here
1023 through a using-declaration. */
1026 push_local_binding (tree id
, tree decl
, int flags
)
1028 struct cp_binding_level
*b
;
1030 /* Skip over any local classes. This makes sense if we call
1031 push_local_binding with a friend decl of a local class. */
1032 b
= innermost_nonclass_level ();
1034 if (lookup_name_current_level (id
))
1036 /* Supplement the existing binding. */
1037 if (!supplement_binding (IDENTIFIER_BINDING (id
), decl
))
1038 /* It didn't work. Something else must be bound at this
1039 level. Do not add DECL to the list of things to pop
1044 /* Create a new binding. */
1045 push_binding (id
, decl
, b
);
1047 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1048 /* We must put the OVERLOAD into a TREE_LIST since the
1049 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1050 decls that got here through a using-declaration. */
1051 decl
= build_tree_list (NULL_TREE
, decl
);
1053 /* And put DECL on the list of things declared by the current
1055 add_decl_to_level (decl
, b
);
1058 /* The old ARM scoping rules injected variables declared in the
1059 initialization statement of a for-statement into the surrounding
1060 scope. We support this usage, in order to be backward-compatible.
1061 DECL is a just-declared VAR_DECL; if necessary inject its
1062 declaration into the surrounding scope. */
1065 maybe_inject_for_scope_var (tree decl
)
1067 timevar_push (TV_NAME_LOOKUP
);
1068 if (!DECL_NAME (decl
))
1070 timevar_pop (TV_NAME_LOOKUP
);
1074 /* Declarations of __FUNCTION__ and its ilk appear magically when
1075 the variable is first used. If that happens to be inside a
1076 for-loop, we don't want to do anything special. */
1077 if (DECL_PRETTY_FUNCTION_P (decl
))
1079 timevar_pop (TV_NAME_LOOKUP
);
1083 if (current_binding_level
->kind
== sk_for
)
1085 struct cp_binding_level
*outer
1086 = current_binding_level
->level_chain
;
1088 /* Check to see if the same name is already bound at the outer
1089 level, either because it was directly declared, or because a
1090 dead for-decl got preserved. In either case, the code would
1091 not have been valid under the ARM scope rules, so clear
1092 is_for_scope for the current_binding_level.
1094 Otherwise, we need to preserve the temp slot for decl to last
1095 into the outer binding level. */
1097 cxx_binding
*outer_binding
1098 = IDENTIFIER_BINDING (DECL_NAME (decl
))->previous
;
1100 if (outer_binding
&& outer_binding
->scope
== outer
1101 && (TREE_CODE (outer_binding
->value
) == VAR_DECL
)
1102 && DECL_DEAD_FOR_LOCAL (outer_binding
->value
))
1104 outer_binding
->value
= DECL_SHADOWED_FOR_VAR (outer_binding
->value
);
1105 current_binding_level
->kind
= sk_block
;
1108 timevar_pop (TV_NAME_LOOKUP
);
1111 /* Check to see whether or not DECL is a variable that would have been
1112 in scope under the ARM, but is not in scope under the ANSI/ISO
1113 standard. If so, issue an error message. If name lookup would
1114 work in both cases, but return a different result, this function
1115 returns the result of ANSI/ISO lookup. Otherwise, it returns
1119 check_for_out_of_scope_variable (tree decl
)
1123 /* We only care about out of scope variables. */
1124 if (!(TREE_CODE (decl
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (decl
)))
1127 shadowed
= DECL_SHADOWED_FOR_VAR (decl
);
1128 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1129 && DECL_DEAD_FOR_LOCAL (shadowed
))
1130 shadowed
= DECL_SHADOWED_FOR_VAR (shadowed
);
1132 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl
));
1135 if (!DECL_ERROR_REPORTED (decl
))
1137 warning ("name lookup of `%D' changed",
1139 cp_warning_at (" matches this `%D' under ISO standard rules",
1141 cp_warning_at (" matches this `%D' under old rules", decl
);
1142 DECL_ERROR_REPORTED (decl
) = 1;
1147 /* If we have already complained about this declaration, there's no
1148 need to do it again. */
1149 if (DECL_ERROR_REPORTED (decl
))
1152 DECL_ERROR_REPORTED (decl
) = 1;
1153 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
1155 error ("name lookup of `%D' changed for new ISO `for' scoping",
1157 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", decl
);
1158 return error_mark_node
;
1162 pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
1164 cp_pedwarn_at (" using obsolete binding at `%D'", decl
);
1170 /* true means unconditionally make a BLOCK for the next level pushed. */
1172 static bool keep_next_level_flag
;
1174 static int binding_depth
= 0;
1175 static int is_class_level
= 0;
1182 for (i
= 0; i
< depth
* 2; i
++)
1186 /* Return a string describing the kind of SCOPE we have. */
1188 cxx_scope_descriptor (cxx_scope
*scope
)
1190 /* The order of this table must match the "scope_kind"
1192 static const char* scope_kind_names
[] = {
1198 "function-parameter-scope",
1201 "template-parameter-scope",
1202 "template-explicit-spec-scope"
1204 const scope_kind kind
= scope
->explicit_spec_p
1205 ? sk_template_spec
: scope
->kind
;
1207 return scope_kind_names
[kind
];
1210 /* Output a debugging information about SCOPE when performing
1213 cxx_scope_debug (cxx_scope
*scope
, int line
, const char *action
)
1215 const char *desc
= cxx_scope_descriptor (scope
);
1216 if (scope
->this_entity
)
1217 verbatim ("%s %s(%E) %p %d\n", action
, desc
,
1218 scope
->this_entity
, (void *) scope
, line
);
1220 verbatim ("%s %s %p %d\n", action
, desc
, (void *) scope
, line
);
1223 /* Return the estimated initial size of the hashtable of a NAMESPACE
1226 static inline size_t
1227 namespace_scope_ht_size (tree ns
)
1229 tree name
= DECL_NAME (ns
);
1231 return name
== std_identifier
1232 ? NAMESPACE_STD_HT_SIZE
1233 : (name
== global_scope_name
1234 ? GLOBAL_SCOPE_HT_SIZE
1235 : NAMESPACE_ORDINARY_HT_SIZE
);
1238 /* A chain of binding_level structures awaiting reuse. */
1240 static GTY((deletable (""))) struct cp_binding_level
*free_binding_level
;
1242 /* Create a new KIND scope and make it the top of the active scopes stack.
1243 ENTITY is the scope of the associated C++ entity (namespace, class,
1244 function); it is NULL otherwise. */
1247 begin_scope (scope_kind kind
, tree entity
)
1251 /* Reuse or create a struct for this binding level. */
1252 if (!ENABLE_SCOPE_CHECKING
&& free_binding_level
)
1254 scope
= free_binding_level
;
1255 free_binding_level
= scope
->level_chain
;
1258 scope
= ggc_alloc (sizeof (cxx_scope
));
1259 memset (scope
, 0, sizeof (cxx_scope
));
1261 scope
->this_entity
= entity
;
1262 scope
->more_cleanups_ok
= true;
1269 case sk_template_spec
:
1270 scope
->explicit_spec_p
= true;
1271 kind
= sk_template_parms
;
1273 case sk_template_parms
:
1279 case sk_function_parms
:
1280 scope
->keep
= keep_next_level_flag
;
1284 scope
->type_decls
= binding_table_new (namespace_scope_ht_size (entity
));
1285 NAMESPACE_LEVEL (entity
) = scope
;
1286 VARRAY_TREE_INIT (scope
->static_decls
,
1287 DECL_NAME (entity
) == std_identifier
1288 || DECL_NAME (entity
) == global_scope_name
1290 "Static declarations");
1294 /* Should not happen. */
1295 my_friendly_assert (false, 20030922);
1300 /* Add it to the front of currently active scopes stack. */
1301 scope
->level_chain
= current_binding_level
;
1302 current_binding_level
= scope
;
1303 keep_next_level_flag
= false;
1305 if (ENABLE_SCOPE_CHECKING
)
1307 scope
->binding_depth
= binding_depth
;
1308 indent (binding_depth
);
1309 cxx_scope_debug (scope
, input_location
.line
, "push");
1317 /* We're about to leave current scope. Pop the top of the stack of
1318 currently active scopes. Return the enclosing scope, now active. */
1323 cxx_scope
*scope
= current_binding_level
;
1325 if (scope
->kind
== sk_namespace
&& class_binding_level
)
1326 current_binding_level
= class_binding_level
;
1328 /* We cannot leave a scope, if there are none left. */
1329 if (NAMESPACE_LEVEL (global_namespace
))
1330 my_friendly_assert (!global_scope_p (scope
), 20030527);
1332 if (ENABLE_SCOPE_CHECKING
)
1334 indent (--binding_depth
);
1335 cxx_scope_debug (scope
, input_location
.line
, "leave");
1336 if (is_class_level
!= (scope
== class_binding_level
))
1338 indent (binding_depth
);
1339 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1344 /* Move one nesting level up. */
1345 current_binding_level
= scope
->level_chain
;
1347 /* Namespace-scopes are left most probably temporarily, not completely;
1348 they can be reopen later, e.g. in namespace-extension or any name
1349 binding activity that requires us to resume a namespace. For other
1350 scopes, we just make the structure available for reuse. */
1351 if (scope
->kind
!= sk_namespace
)
1353 scope
->level_chain
= free_binding_level
;
1354 if (scope
->kind
== sk_class
)
1355 scope
->type_decls
= NULL
;
1357 binding_table_free (scope
->type_decls
);
1358 my_friendly_assert (!ENABLE_SCOPE_CHECKING
1359 || scope
->binding_depth
== binding_depth
,
1361 free_binding_level
= scope
;
1364 /* Find the innermost enclosing class scope, and reset
1365 CLASS_BINDING_LEVEL appropriately. */
1366 for (scope
= current_binding_level
;
1367 scope
&& scope
->kind
!= sk_class
;
1368 scope
= scope
->level_chain
)
1370 class_binding_level
= scope
&& scope
->kind
== sk_class
? scope
: NULL
;
1372 return current_binding_level
;
1376 resume_scope (struct cp_binding_level
* b
)
1378 /* Resuming binding levels is meant only for namespaces,
1379 and those cannot nest into classes. */
1380 my_friendly_assert(!class_binding_level
, 386);
1381 /* Also, resuming a non-directly nested namespace is a no-no. */
1382 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
1383 current_binding_level
= b
;
1384 if (ENABLE_SCOPE_CHECKING
)
1386 b
->binding_depth
= binding_depth
;
1387 indent (binding_depth
);
1388 cxx_scope_debug (b
, input_location
.line
, "resume");
1394 /* Return the innermost binding level that is not for a class scope. */
1397 innermost_nonclass_level (void)
1401 b
= current_binding_level
;
1402 while (b
->kind
== sk_class
)
1408 /* We're defining an object of type TYPE. If it needs a cleanup, but
1409 we're not allowed to add any more objects with cleanups to the current
1410 scope, create a new binding level. */
1413 maybe_push_cleanup_level (tree type
)
1415 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
1416 && current_binding_level
->more_cleanups_ok
== 0)
1418 begin_scope (sk_cleanup
, NULL
);
1420 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
1424 /* Nonzero if we are currently in the global binding level. */
1427 global_bindings_p (void)
1429 return global_scope_p (current_binding_level
);
1432 /* True if we are currently in a toplevel binding level. This
1433 means either the global binding level or a namespace in a toplevel
1434 binding level. Since there are no non-toplevel namespace levels,
1435 this really means any namespace or template parameter level. We
1436 also include a class whose context is toplevel. */
1439 toplevel_bindings_p (void)
1441 struct cp_binding_level
*b
= innermost_nonclass_level ();
1443 return b
->kind
== sk_namespace
|| b
->kind
== sk_template_parms
;
1446 /* True if this is a namespace scope, or if we are defining a class
1447 which is itself at namespace scope, or whose enclosing class is
1448 such a class, etc. */
1451 namespace_bindings_p (void)
1453 struct cp_binding_level
*b
= innermost_nonclass_level ();
1455 return b
->kind
== sk_namespace
;
1458 /* True if the current level needs to have a BLOCK made. */
1463 return (current_binding_level
->blocks
!= NULL_TREE
1464 || current_binding_level
->keep
1465 || current_binding_level
->kind
== sk_cleanup
1466 || current_binding_level
->names
!= NULL_TREE
1467 || current_binding_level
->type_decls
!= NULL
);
1470 /* Returns the kind of the innermost scope. */
1473 innermost_scope_kind (void)
1475 return current_binding_level
->kind
;
1478 /* Returns true if this scope was created to store template parameters. */
1481 template_parm_scope_p (void)
1483 return innermost_scope_kind () == sk_template_parms
;
1486 /* If KEEP is true, make a BLOCK node for the next binding level,
1487 unconditionally. Otherwise, use the normal logic to decide whether
1488 or not to create a BLOCK. */
1491 keep_next_level (bool keep
)
1493 keep_next_level_flag
= keep
;
1496 /* Return the list of declarations of the current level.
1497 Note that this list is in reverse order unless/until
1498 you nreverse it; and when you do nreverse it, you must
1499 store the result back using `storedecls' or you will lose. */
1504 return current_binding_level
->names
;
1507 /* Set the current binding TABLE for type declarations.. This is a
1508 temporary workaround of the fact that the data structure classtypes
1509 does not currently carry its allocated cxx_scope structure. */
1511 cxx_remember_type_decls (binding_table table
)
1513 current_binding_level
->type_decls
= table
;
1516 /* For debugging. */
1517 static int no_print_functions
= 0;
1518 static int no_print_builtins
= 0;
1520 /* Called from print_binding_level through binding_table_foreach to
1521 print the content of binding ENTRY. DATA is a pointer to line offset
1524 bt_print_entry (binding_entry entry
, void *data
)
1526 int *p
= (int *) data
;
1529 if (entry
->name
== NULL
)
1531 else if (entry
->name
== TYPE_IDENTIFIER (entry
->type
))
1541 fprintf (stderr
, "\n\t");
1544 if (entry
->name
== NULL
)
1546 print_node_brief (stderr
, "<unnamed-typedef", entry
->type
, 0);
1547 fprintf (stderr
, ">");
1549 else if (entry
->name
== TYPE_IDENTIFIER (entry
->type
))
1550 print_node_brief (stderr
, "", entry
->type
, 0);
1553 print_node_brief (stderr
, "<typedef", entry
->name
, 0);
1554 print_node_brief (stderr
, "", entry
->type
, 0);
1555 fprintf (stderr
, ">");
1560 print_binding_level (struct cp_binding_level
* lvl
)
1564 fprintf (stderr
, " blocks=" HOST_PTR_PRINTF
, (void *) lvl
->blocks
);
1565 if (lvl
->more_cleanups_ok
)
1566 fprintf (stderr
, " more-cleanups-ok");
1567 if (lvl
->have_cleanups
)
1568 fprintf (stderr
, " have-cleanups");
1569 fprintf (stderr
, "\n");
1572 fprintf (stderr
, " names:\t");
1573 /* We can probably fit 3 names to a line? */
1574 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1576 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1578 if (no_print_builtins
1579 && (TREE_CODE (t
) == TYPE_DECL
)
1580 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
1583 /* Function decls tend to have longer names. */
1584 if (TREE_CODE (t
) == FUNCTION_DECL
)
1591 fprintf (stderr
, "\n\t");
1594 print_node_brief (stderr
, "", t
, 0);
1595 if (t
== error_mark_node
)
1599 fprintf (stderr
, "\n");
1601 if (lvl
->type_decls
)
1603 fprintf (stderr
, " tags:\t");
1605 binding_table_foreach (lvl
->type_decls
, bt_print_entry
, &i
);
1607 fprintf (stderr
, "\n");
1609 if (lvl
->class_shadowed
)
1611 fprintf (stderr
, " class-shadowed:");
1612 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
1614 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1616 fprintf (stderr
, "\n");
1618 if (lvl
->type_shadowed
)
1620 fprintf (stderr
, " type-shadowed:");
1621 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1623 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1625 fprintf (stderr
, "\n");
1630 print_other_binding_stack (struct cp_binding_level
*stack
)
1632 struct cp_binding_level
*level
;
1633 for (level
= stack
; !global_scope_p (level
); level
= level
->level_chain
)
1635 fprintf (stderr
, "binding level " HOST_PTR_PRINTF
"\n", (void *) level
);
1636 print_binding_level (level
);
1641 print_binding_stack (void)
1643 struct cp_binding_level
*b
;
1644 fprintf (stderr
, "current_binding_level=" HOST_PTR_PRINTF
1645 "\nclass_binding_level=" HOST_PTR_PRINTF
1646 "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF
"\n",
1647 (void *) current_binding_level
, (void *) class_binding_level
,
1648 (void *) NAMESPACE_LEVEL (global_namespace
));
1649 if (class_binding_level
)
1651 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1652 if (b
== current_binding_level
)
1655 b
= class_binding_level
;
1657 b
= current_binding_level
;
1660 b
= current_binding_level
;
1661 print_other_binding_stack (b
);
1662 fprintf (stderr
, "global:\n");
1663 print_binding_level (NAMESPACE_LEVEL (global_namespace
));
1666 /* Return the type associated with id. */
1669 identifier_type_value (tree id
)
1671 timevar_push (TV_NAME_LOOKUP
);
1672 /* There is no type with that name, anywhere. */
1673 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
1674 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1675 /* This is not the type marker, but the real thing. */
1676 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
1677 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, REAL_IDENTIFIER_TYPE_VALUE (id
));
1678 /* Have to search for it. It must be on the global level, now.
1679 Ask lookup_name not to return non-types. */
1680 id
= lookup_name_real (id
, 2, 1, 0, LOOKUP_COMPLAIN
);
1682 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, TREE_TYPE (id
));
1683 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
1686 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1687 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1690 identifier_global_value (tree t
)
1692 return IDENTIFIER_GLOBAL_VALUE (t
);
1695 /* Push a definition of struct, union or enum tag named ID. into
1696 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1697 the tag ID is not already defined. */
1700 set_identifier_type_value_with_scope (tree id
, tree decl
, cxx_scope
*b
)
1704 if (b
->kind
!= sk_namespace
)
1706 /* Shadow the marker, not the real thing, so that the marker
1707 gets restored later. */
1708 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
1710 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
1711 type
= decl
? TREE_TYPE (decl
) : NULL_TREE
;
1715 cxx_binding
*binding
=
1716 binding_for_name (NAMESPACE_LEVEL (current_namespace
), id
);
1720 supplement_binding (binding
, decl
);
1722 binding
->value
= decl
;
1726 /* Store marker instead of real type. */
1727 type
= global_type_node
;
1729 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
1732 /* As set_identifier_type_value_with_scope, but using
1733 current_binding_level. */
1736 set_identifier_type_value (tree id
, tree decl
)
1738 set_identifier_type_value_with_scope (id
, decl
, current_binding_level
);
1741 /* Return the name for the constructor (or destructor) for the
1742 specified class TYPE. When given a template, this routine doesn't
1743 lose the specialization. */
1746 constructor_name_full (tree type
)
1748 type
= TYPE_MAIN_VARIANT (type
);
1749 if (CLASS_TYPE_P (type
) && TYPE_WAS_ANONYMOUS (type
)
1750 && TYPE_HAS_CONSTRUCTOR (type
))
1751 return DECL_NAME (OVL_CURRENT (CLASSTYPE_CONSTRUCTORS (type
)));
1753 return TYPE_IDENTIFIER (type
);
1756 /* Return the name for the constructor (or destructor) for the
1757 specified class. When given a template, return the plain
1758 unspecialized name. */
1761 constructor_name (tree type
)
1764 name
= constructor_name_full (type
);
1765 if (IDENTIFIER_TEMPLATE (name
))
1766 name
= IDENTIFIER_TEMPLATE (name
);
1770 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1773 constructor_name_p (tree name
, tree type
)
1780 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1783 ctor_name
= constructor_name_full (type
);
1784 if (name
== ctor_name
)
1786 if (IDENTIFIER_TEMPLATE (ctor_name
)
1787 && name
== IDENTIFIER_TEMPLATE (ctor_name
))
1792 /* Counter used to create anonymous type names. */
1794 static GTY(()) int anon_cnt
;
1796 /* Return an IDENTIFIER which can be used as a name for
1797 anonymous structs and unions. */
1800 make_anon_name (void)
1804 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
1805 return get_identifier (buf
);
1808 /* Clear the TREE_PURPOSE slot of UTDs which have anonymous typenames.
1809 This keeps dbxout from getting confused. */
1812 clear_anon_tags (void)
1814 register struct cp_binding_level
*b
;
1815 static int last_cnt
= 0;
1817 /* Fast out if no new anon names were declared. */
1818 if (last_cnt
== anon_cnt
)
1821 b
= current_binding_level
;
1822 while (b
->kind
== sk_cleanup
)
1824 if (b
->type_decls
!= NULL
)
1825 binding_table_remove_anonymous_types (b
->type_decls
);
1826 last_cnt
= anon_cnt
;
1829 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1831 static inline cxx_binding
*
1832 find_binding (cxx_scope
*scope
, cxx_binding
*binding
)
1834 timevar_push (TV_NAME_LOOKUP
);
1836 for (; binding
!= NULL
; binding
= binding
->previous
)
1837 if (binding
->scope
== scope
)
1838 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, binding
);
1840 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, (cxx_binding
*)0);
1843 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1845 static inline cxx_binding
*
1846 cxx_scope_find_binding_for_name (cxx_scope
*scope
, tree name
)
1848 cxx_binding
*b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1851 /* Fold-in case where NAME is used only once. */
1852 if (scope
== b
->scope
&& b
->previous
== NULL
)
1854 return find_binding (scope
, b
);
1859 /* Always returns a binding for name in scope. If no binding is
1860 found, make a new one. */
1862 static cxx_binding
*
1863 binding_for_name (cxx_scope
*scope
, tree name
)
1865 cxx_binding
*result
;
1867 result
= cxx_scope_find_binding_for_name (scope
, name
);
1870 /* Not found, make a new one. */
1871 result
= cxx_binding_make (NULL
, NULL
);
1872 result
->previous
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1873 result
->scope
= scope
;
1874 result
->is_local
= false;
1875 result
->value_is_inherited
= false;
1876 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1880 /* Insert another USING_DECL into the current binding level, returning
1881 this declaration. If this is a redeclaration, do nothing, and
1882 return NULL_TREE if this not in namespace scope (in namespace
1883 scope, a using decl might extend any previous bindings). */
1886 push_using_decl (tree scope
, tree name
)
1890 timevar_push (TV_NAME_LOOKUP
);
1891 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
1892 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
1893 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
1894 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
1897 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
1898 namespace_bindings_p () ? decl
: NULL_TREE
);
1899 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
1900 DECL_INITIAL (decl
) = scope
;
1901 TREE_CHAIN (decl
) = current_binding_level
->usings
;
1902 current_binding_level
->usings
= decl
;
1903 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
1906 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1907 caller to set DECL_CONTEXT properly. */
1910 pushdecl_with_scope (tree x
, cxx_scope
*level
)
1912 register struct cp_binding_level
*b
;
1913 tree function_decl
= current_function_decl
;
1915 timevar_push (TV_NAME_LOOKUP
);
1916 current_function_decl
= NULL_TREE
;
1917 if (level
->kind
== sk_class
)
1919 b
= class_binding_level
;
1920 class_binding_level
= level
;
1921 pushdecl_class_level (x
);
1922 class_binding_level
= b
;
1926 b
= current_binding_level
;
1927 current_binding_level
= level
;
1929 current_binding_level
= b
;
1931 current_function_decl
= function_decl
;
1932 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
1935 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1936 other definitions already in place. We get around this by making
1937 the value of the identifier point to a list of all the things that
1938 want to be referenced by that name. It is then up to the users of
1939 that name to decide what to do with that list.
1941 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1942 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1944 FLAGS is a bitwise-or of the following values:
1945 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1947 PUSH_USING: DECL is being pushed as the result of a using
1950 The value returned may be a previous declaration if we guessed wrong
1951 about what language DECL should belong to (C or C++). Otherwise,
1952 it's always DECL (and never something that's not a _DECL). */
1955 push_overloaded_decl (tree decl
, int flags
)
1957 tree name
= DECL_NAME (decl
);
1960 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
1962 timevar_push (TV_NAME_LOOKUP
);
1964 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
1966 old
= lookup_name_current_level (name
);
1970 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
1972 tree t
= TREE_TYPE (old
);
1973 if (IS_AGGR_TYPE (t
) && warn_shadow
1974 && (! DECL_IN_SYSTEM_HEADER (decl
)
1975 || ! DECL_IN_SYSTEM_HEADER (old
)))
1976 warning ("`%#D' hides constructor for `%#T'", decl
, t
);
1979 else if (is_overloaded_fn (old
))
1983 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
1985 tree fn
= OVL_CURRENT (tmp
);
1987 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
1988 && !(flags
& PUSH_USING
)
1989 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1990 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
1991 error ("`%#D' conflicts with previous using declaration `%#D'",
1994 if (duplicate_decls (decl
, fn
) == fn
)
1995 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, fn
);
1998 else if (old
== error_mark_node
)
1999 /* Ignore the undefined symbol marker. */
2003 cp_error_at ("previous non-function declaration `%#D'", old
);
2004 error ("conflicts with function declaration `%#D'", decl
);
2005 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2009 /* FIXME: We should build OVERLOADs for all function declarations here.
2010 But right now, there are too many places where the code creates an
2011 artificial declaration and expects the name to be bound exactly
2012 to a FUNCTION_DECL. */
2013 if (!DECL_ARTIFICIAL (decl
))
2015 if (old
&& TREE_CODE (old
) != OVERLOAD
)
2016 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
2018 new_binding
= ovl_cons (decl
, old
);
2019 if (flags
& PUSH_USING
)
2020 OVL_USED (new_binding
) = 1;
2026 set_namespace_binding (name
, current_namespace
, new_binding
);
2029 /* We only create an OVERLOAD if there was a previous binding at
2030 this level, or if decl is a template. In the former case, we
2031 need to remove the old binding and replace it with the new
2032 binding. We must also run through the NAMES on the binding
2033 level where the name was bound to update the chain. */
2035 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
2039 for (d
= &IDENTIFIER_BINDING (name
)->scope
->names
;
2041 d
= &TREE_CHAIN (*d
))
2043 || (TREE_CODE (*d
) == TREE_LIST
2044 && TREE_VALUE (*d
) == old
))
2046 if (TREE_CODE (*d
) == TREE_LIST
)
2047 /* Just replace the old binding with the new. */
2048 TREE_VALUE (*d
) = new_binding
;
2050 /* Build a TREE_LIST to wrap the OVERLOAD. */
2051 *d
= tree_cons (NULL_TREE
, new_binding
,
2054 /* And update the cxx_binding node. */
2055 IDENTIFIER_BINDING (name
)->value
= new_binding
;
2056 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2059 /* We should always find a previous binding in this case. */
2063 /* Install the new binding. */
2064 push_local_binding (name
, new_binding
, flags
);
2067 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2070 /* Check a non-member using-declaration. Return the name and scope
2071 being used, and the USING_DECL, or NULL_TREE on failure. */
2074 validate_nonmember_using_decl (tree decl
, tree
*scope
, tree
*name
)
2076 *scope
= global_namespace
;
2079 if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
)
2081 *name
= TREE_OPERAND (decl
, 0);
2083 A using-declaration shall not name a template-id. */
2084 error ("a using-declaration cannot specify a template-id. Try `using %D'", *name
);
2088 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2090 error ("namespace `%D' not allowed in using-declaration", decl
);
2094 if (TREE_CODE (decl
) == SCOPE_REF
)
2096 /* It's a nested name with template parameter dependent scope.
2097 This can only be using-declaration for class member. */
2098 error ("`%T' is not a namespace", TREE_OPERAND (decl
, 0));
2102 if (is_overloaded_fn (decl
))
2103 decl
= get_first_fn (decl
);
2105 my_friendly_assert (DECL_P (decl
), 20020908);
2107 if (TREE_CODE (decl
) == CONST_DECL
)
2108 /* Enumeration constants to not have DECL_CONTEXT set. */
2109 *scope
= TYPE_CONTEXT (TREE_TYPE (decl
));
2111 *scope
= DECL_CONTEXT (decl
);
2113 *scope
= global_namespace
;
2115 /* [namespace.udecl]
2116 A using-declaration for a class member shall be a
2117 member-declaration. */
2118 if (TYPE_P (*scope
))
2120 error ("`%T' is not a namespace", *scope
);
2123 *name
= DECL_NAME (decl
);
2124 /* Make a USING_DECL. */
2125 return push_using_decl (*scope
, *name
);
2128 /* Process local and global using-declarations. */
2131 do_nonmember_using_decl (tree scope
, tree name
, tree oldval
, tree oldtype
,
2132 tree
*newval
, tree
*newtype
)
2136 *newval
= *newtype
= NULL_TREE
;
2137 cxx_binding_clear (&decls
);
2138 if (!qualified_lookup_using_namespace (name
, scope
, &decls
, 0))
2142 if (!decls
.value
&& !decls
.type
)
2144 error ("`%D' not declared", name
);
2148 /* Check for using functions. */
2149 if (decls
.value
&& is_overloaded_fn (decls
.value
))
2153 if (oldval
&& !is_overloaded_fn (oldval
))
2155 if (!DECL_IMPLICIT_TYPEDEF_P (oldval
))
2156 error ("`%D' is already declared in this scope", name
);
2161 for (tmp
= decls
.value
; tmp
; tmp
= OVL_NEXT (tmp
))
2163 tree new_fn
= OVL_CURRENT (tmp
);
2165 /* [namespace.udecl]
2167 If a function declaration in namespace scope or block
2168 scope has the same name and the same parameter types as a
2169 function introduced by a using declaration the program is
2171 for (tmp1
= oldval
; tmp1
; tmp1
= OVL_NEXT (tmp1
))
2173 tree old_fn
= OVL_CURRENT (tmp1
);
2175 if (new_fn
== old_fn
)
2176 /* The function already exists in the current namespace. */
2178 else if (OVL_USED (tmp1
))
2179 continue; /* this is a using decl */
2180 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn
)),
2181 TYPE_ARG_TYPES (TREE_TYPE (old_fn
))))
2183 /* There was already a non-using declaration in
2184 this scope with the same parameter types. If both
2185 are the same extern "C" functions, that's ok. */
2186 if (decls_match (new_fn
, old_fn
))
2188 /* If the OLD_FN was a builtin, there is now a
2189 real declaration. */
2190 if (DECL_ANTICIPATED (old_fn
))
2191 DECL_ANTICIPATED (old_fn
) = 0;
2194 else if (!DECL_ANTICIPATED (old_fn
))
2196 /* If the OLD_FN was really declared, the
2197 declarations don't match. */
2198 error ("`%D' is already declared in this scope", name
);
2202 /* If the OLD_FN was not really there, just ignore
2203 it and keep going. */
2207 /* If we broke out of the loop, there's no reason to add
2208 this function to the using declarations for this
2213 *newval
= build_overload (OVL_CURRENT (tmp
), *newval
);
2214 if (TREE_CODE (*newval
) != OVERLOAD
)
2215 *newval
= ovl_cons (*newval
, NULL_TREE
);
2216 OVL_USED (*newval
) = 1;
2221 *newval
= decls
.value
;
2222 if (oldval
&& !decls_match (*newval
, oldval
))
2223 error ("`%D' is already declared in this scope", name
);
2226 *newtype
= decls
.type
;
2227 if (oldtype
&& *newtype
&& !same_type_p (oldtype
, *newtype
))
2229 error ("using declaration `%D' introduced ambiguous type `%T'",
2235 /* Process a using-declaration at function scope. */
2238 do_local_using_decl (tree decl
)
2241 tree oldval
, oldtype
, newval
, newtype
;
2243 decl
= validate_nonmember_using_decl (decl
, &scope
, &name
);
2244 if (decl
== NULL_TREE
)
2247 if (building_stmt_tree ()
2248 && at_function_scope_p ())
2249 add_decl_stmt (decl
);
2251 oldval
= lookup_name_current_level (name
);
2252 oldtype
= lookup_type_current_level (name
);
2254 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
2258 if (is_overloaded_fn (newval
))
2262 /* We only need to push declarations for those functions
2263 that were not already bound in the current level.
2264 The old value might be NULL_TREE, it might be a single
2265 function, or an OVERLOAD. */
2266 if (oldval
&& TREE_CODE (oldval
) == OVERLOAD
)
2267 term
= OVL_FUNCTION (oldval
);
2270 for (fn
= newval
; fn
&& OVL_CURRENT (fn
) != term
;
2272 push_overloaded_decl (OVL_CURRENT (fn
),
2273 PUSH_LOCAL
| PUSH_USING
);
2276 push_local_binding (name
, newval
, PUSH_USING
);
2279 set_identifier_type_value (name
, newtype
);
2282 /* Return the type that should be used when TYPE's name is preceded
2283 by a tag such as 'struct' or 'union', or null if the name cannot
2284 be used in this way.
2286 For example, when processing the third line of:
2292 lookup of A will find the typedef. Given A's typedef, this function
2293 will return the type associated with "struct A". For the tag to be
2294 anything other than TYPE, TYPE must be a typedef whose original type
2295 has the same name and context as TYPE itself.
2297 It is not valid for a typedef of an anonymous type to be used with
2300 typedef struct { ... } B;
2303 Return null for this case. */
2306 follow_tag_typedef (tree type
)
2310 original
= original_type (type
);
2311 if (! TYPE_NAME (original
))
2313 if (TYPE_IDENTIFIER (original
) == TYPE_IDENTIFIER (type
)
2314 && (CP_DECL_CONTEXT (TYPE_NAME (original
))
2315 == CP_DECL_CONTEXT (TYPE_NAME (type
)))
2316 && !(CLASS_TYPE_P (original
) && TYPE_WAS_ANONYMOUS (original
)))
2322 /* Given NAME, an IDENTIFIER_NODE,
2323 return the structure (or union or enum) definition for that name.
2324 Searches binding levels from its SCOPE up to the global level.
2325 If THISLEVEL_ONLY is nonzero, searches only the specified context
2326 (but skips any sk_cleanup contexts to find one that is
2327 meaningful for tags).
2328 FORM says which kind of type the caller wants;
2329 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2330 If the wrong kind of type is found, and it's not a template, an error is
2334 lookup_tag (enum tree_code form
, tree name
,
2335 cxx_scope
*binding_level
, int thislevel_only
)
2337 register struct cp_binding_level
*level
;
2338 /* Nonzero if, we should look past a template parameter level, even
2339 if THISLEVEL_ONLY. */
2340 int allow_template_parms_p
= 1;
2341 bool type_is_anonymous
= ANON_AGGRNAME_P (name
);
2343 timevar_push (TV_NAME_LOOKUP
);
2344 for (level
= binding_level
; level
; level
= level
->level_chain
)
2347 if (type_is_anonymous
&& level
->type_decls
!= NULL
)
2349 tree type
= binding_table_find_anon_type (level
->type_decls
, name
);
2350 /* There is no need for error checking here, because
2351 anon names are unique throughout the compilation. */
2353 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, type
);
2355 else if (level
->kind
== sk_namespace
)
2356 /* Do namespace lookup. */
2357 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
2359 cxx_binding
*binding
=
2360 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (tail
), name
);
2363 /* If we just skipped past a template parameter level,
2364 even though THISLEVEL_ONLY, and we find a template
2365 class declaration, then we use the _TYPE node for the
2366 template. See the example below. */
2367 if (thislevel_only
&& !allow_template_parms_p
2368 && binding
&& binding
->value
2369 && DECL_CLASS_TEMPLATE_P (binding
->value
))
2370 old
= binding
->value
;
2372 old
= select_decl (binding
, LOOKUP_PREFER_TYPES
);
2378 /* We've found something at this binding level. If it is
2379 a typedef, extract the tag it refers to. Lookup fails
2380 if the typedef doesn't refer to a taggable type. */
2381 old
= TREE_TYPE (old
);
2382 old
= follow_tag_typedef (old
);
2384 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2385 if (TREE_CODE (old
) != form
2386 && (form
== ENUMERAL_TYPE
2387 || TREE_CODE (old
) == ENUMERAL_TYPE
))
2389 error ("`%#D' redeclared as %C", old
, form
);
2390 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2392 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, old
);
2394 if (thislevel_only
|| tail
== global_namespace
)
2395 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2397 else if (level
->type_decls
!= NULL
)
2399 binding_entry entry
= binding_table_find (level
->type_decls
, name
);
2402 enum tree_code code
= TREE_CODE (entry
->type
);
2405 && (form
== ENUMERAL_TYPE
|| code
== ENUMERAL_TYPE
))
2407 /* Definition isn't the kind we were looking for. */
2408 error ("`%#D' redeclared as %C", entry
->type
, form
);
2409 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2411 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, entry
->type
);
2414 if (thislevel_only
&& level
->kind
!= sk_cleanup
)
2416 if (level
->kind
== sk_template_parms
&& allow_template_parms_p
)
2418 /* We must deal with cases like this:
2420 template <class T> struct S;
2421 template <class T> struct S {};
2423 When looking up `S', for the second declaration, we
2424 would like to find the first declaration. But, we
2425 are in the pseudo-global level created for the
2426 template parameters, rather than the (surrounding)
2427 namespace level. Thus, we keep going one more level,
2428 even though THISLEVEL_ONLY is nonzero. */
2429 allow_template_parms_p
= 0;
2433 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2436 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2439 /* Given a type, find the tag that was defined for it and return the tag name.
2440 Otherwise return 0. However, the value can never be 0
2441 in the cases in which this is used.
2443 C++: If NAME is nonzero, this is the new name to install. This is
2444 done when replacing anonymous tags with real tag names. */
2447 lookup_tag_reverse (tree type
, tree name
)
2449 register struct cp_binding_level
*level
;
2451 timevar_push (TV_NAME_LOOKUP
);
2452 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
2454 binding_entry entry
= level
->type_decls
== NULL
2456 : binding_table_reverse_maybe_remap (level
->type_decls
, type
, name
);
2458 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, entry
->name
);
2460 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2463 /* Returns true if ROOT (a namespace, class, or function) encloses
2464 CHILD. CHILD may be either a class type or a namespace. */
2467 is_ancestor (tree root
, tree child
)
2469 my_friendly_assert ((TREE_CODE (root
) == NAMESPACE_DECL
2470 || TREE_CODE (root
) == FUNCTION_DECL
2471 || CLASS_TYPE_P (root
)), 20030307);
2472 my_friendly_assert ((TREE_CODE (child
) == NAMESPACE_DECL
2473 || CLASS_TYPE_P (child
)),
2476 /* The global namespace encloses everything. */
2477 if (root
== global_namespace
)
2482 /* If we've run out of scopes, stop. */
2485 /* If we've reached the ROOT, it encloses CHILD. */
2488 /* Go out one level. */
2490 child
= TYPE_NAME (child
);
2491 child
= DECL_CONTEXT (child
);
2495 /* Enter a class or namespace scope. */
2500 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2501 push_decl_namespace (t
);
2502 else if CLASS_TYPE_P (t
)
2503 push_nested_class (t
);
2506 /* Leave scope pushed by push_scope. */
2511 if (TREE_CODE (t
) == NAMESPACE_DECL
)
2512 pop_decl_namespace ();
2513 else if CLASS_TYPE_P (t
)
2514 pop_nested_class ();
2517 /* Do a pushlevel for class declarations. */
2520 pushlevel_class (void)
2522 if (ENABLE_SCOPE_CHECKING
)
2525 class_binding_level
= begin_scope (sk_class
, current_class_type
);
2528 /* ...and a poplevel for class declarations. */
2531 poplevel_class (void)
2533 register struct cp_binding_level
*level
= class_binding_level
;
2536 timevar_push (TV_NAME_LOOKUP
);
2537 my_friendly_assert (level
!= 0, 354);
2539 /* If we're leaving a toplevel class, don't bother to do the setting
2540 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
2541 shouldn't even be used when current_class_type isn't set, and second,
2542 if we don't touch it here, we're able to use the cache effect if the
2543 next time we're entering a class scope, it is the same class. */
2544 if (current_class_depth
!= 1)
2546 struct cp_binding_level
* b
;
2548 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
2549 for (shadowed
= level
->class_shadowed
;
2551 shadowed
= TREE_CHAIN (shadowed
))
2552 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
2554 /* Find the next enclosing class, and recreate
2555 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
2556 b
= level
->level_chain
;
2557 while (b
&& b
->kind
!= sk_class
)
2561 for (shadowed
= b
->class_shadowed
;
2563 shadowed
= TREE_CHAIN (shadowed
))
2565 cxx_binding
*binding
;
2567 binding
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
2568 while (binding
&& binding
->scope
!= b
)
2569 binding
= binding
->previous
;
2572 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
2577 /* Remember to save what IDENTIFIER's were bound in this scope so we
2578 can recover from cache misses. */
2580 previous_class_type
= current_class_type
;
2581 previous_class_values
= class_binding_level
->class_shadowed
;
2583 for (shadowed
= level
->type_shadowed
;
2585 shadowed
= TREE_CHAIN (shadowed
))
2586 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
2588 /* Remove the bindings for all of the class-level declarations. */
2589 for (shadowed
= level
->class_shadowed
;
2591 shadowed
= TREE_CHAIN (shadowed
))
2592 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
2594 /* Now, pop out of the binding level which we created up in the
2595 `pushlevel_class' routine. */
2596 if (ENABLE_SCOPE_CHECKING
)
2600 timevar_pop (TV_NAME_LOOKUP
);
2603 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
2604 binding was successful. */
2607 push_class_binding (tree id
, tree decl
)
2610 cxx_binding
*binding
= IDENTIFIER_BINDING (id
);
2613 timevar_push (TV_NAME_LOOKUP
);
2614 /* Note that we declared this value so that we can issue an error if
2615 this is an invalid redeclaration of a name already used for some
2617 note_name_declared_in_class (id
, decl
);
2619 if (binding
&& binding
->scope
== class_binding_level
)
2620 /* Supplement the existing binding. */
2621 result
= supplement_binding (IDENTIFIER_BINDING (id
), decl
);
2623 /* Create a new binding. */
2624 push_binding (id
, decl
, class_binding_level
);
2626 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
2627 class-level declaration. Note that we do not use DECL here
2628 because of the possibility of the `struct stat' hack; if DECL is
2629 a class-name or enum-name we might prefer a field-name, or some
2631 IDENTIFIER_CLASS_VALUE (id
) = IDENTIFIER_BINDING (id
)->value
;
2633 /* If this is a binding from a base class, mark it as such. */
2634 binding
= IDENTIFIER_BINDING (id
);
2635 if (binding
->value
== decl
&& TREE_CODE (decl
) != TREE_LIST
)
2637 if (TREE_CODE (decl
) == OVERLOAD
)
2638 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
2641 my_friendly_assert (DECL_P (decl
), 0);
2642 context
= context_for_name_lookup (decl
);
2645 if (is_properly_derived_from (current_class_type
, context
))
2646 INHERITED_VALUE_BINDING_P (binding
) = 1;
2648 INHERITED_VALUE_BINDING_P (binding
) = 0;
2650 else if (binding
->value
== decl
)
2651 /* We only encounter a TREE_LIST when push_class_decls detects an
2652 ambiguity. Such an ambiguity can be overridden by a definition
2654 INHERITED_VALUE_BINDING_P (binding
) = 1;
2656 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
);
2659 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
2660 for any names in enclosing classes. */
2663 clear_identifier_class_values (void)
2667 if (!class_binding_level
)
2670 for (t
= class_binding_level
->class_shadowed
;
2673 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
2676 /* Make the declaration of X appear in CLASS scope. */
2679 pushdecl_class_level (tree x
)
2682 bool is_valid
= true;
2684 timevar_push (TV_NAME_LOOKUP
);
2685 /* Get the name of X. */
2686 if (TREE_CODE (x
) == OVERLOAD
)
2687 name
= DECL_NAME (get_first_fn (x
));
2689 name
= DECL_NAME (x
);
2693 is_valid
= push_class_level_binding (name
, x
);
2694 if (TREE_CODE (x
) == TYPE_DECL
)
2695 set_identifier_type_value (name
, x
);
2697 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2699 /* If X is an anonymous aggregate, all of its members are
2700 treated as if they were members of the class containing the
2701 aggregate, for naming purposes. */
2704 for (f
= TYPE_FIELDS (TREE_TYPE (x
)); f
; f
= TREE_CHAIN (f
))
2706 location_t save_location
= input_location
;
2707 input_location
= DECL_SOURCE_LOCATION (f
);
2708 if (!pushdecl_class_level (f
))
2710 input_location
= save_location
;
2713 timevar_pop (TV_NAME_LOOKUP
);
2718 /* Make the declaration(s) of X appear in CLASS scope under the name
2719 NAME. Returns true if the binding is valid. */
2722 push_class_level_binding (tree name
, tree x
)
2724 cxx_binding
*binding
;
2726 timevar_push (TV_NAME_LOOKUP
);
2727 /* The class_binding_level will be NULL if x is a template
2728 parameter name in a member template. */
2729 if (!class_binding_level
)
2730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2732 /* Make sure that this new member does not have the same name
2733 as a template parameter. */
2734 if (TYPE_BEING_DEFINED (current_class_type
))
2735 check_template_shadow (x
);
2737 /* If this declaration shadows a declaration from an enclosing
2738 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
2739 we leave this class. Record the shadowed declaration here. */
2740 binding
= IDENTIFIER_BINDING (name
);
2741 if (binding
&& binding
->value
)
2743 tree bval
= binding
->value
;
2744 tree old_decl
= NULL_TREE
;
2746 if (INHERITED_VALUE_BINDING_P (binding
))
2748 /* If the old binding was from a base class, and was for a
2749 tag name, slide it over to make room for the new binding.
2750 The old binding is still visible if explicitly qualified
2751 with a class-key. */
2752 if (TREE_CODE (bval
) == TYPE_DECL
&& DECL_ARTIFICIAL (bval
)
2753 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
2755 old_decl
= binding
->type
;
2756 binding
->type
= bval
;
2757 binding
->value
= NULL_TREE
;
2758 INHERITED_VALUE_BINDING_P (binding
) = 0;
2763 else if (TREE_CODE (x
) == OVERLOAD
&& is_overloaded_fn (bval
))
2765 else if (TREE_CODE (x
) == USING_DECL
&& TREE_CODE (bval
) == USING_DECL
)
2766 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2767 else if (TREE_CODE (x
) == USING_DECL
&& is_overloaded_fn (bval
))
2769 else if (TREE_CODE (bval
) == USING_DECL
&& is_overloaded_fn (x
))
2770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2776 /* Find the previous binding of name on the class-shadowed
2777 list, and update it. */
2778 for (shadow
= class_binding_level
->class_shadowed
;
2780 shadow
= TREE_CHAIN (shadow
))
2781 if (TREE_PURPOSE (shadow
) == name
2782 && TREE_TYPE (shadow
) == old_decl
)
2785 INHERITED_VALUE_BINDING_P (binding
) = 0;
2786 TREE_TYPE (shadow
) = x
;
2787 IDENTIFIER_CLASS_VALUE (name
) = x
;
2788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2793 /* If we didn't replace an existing binding, put the binding on the
2794 stack of bindings for the identifier, and update the shadowed list. */
2795 if (push_class_binding (name
, x
))
2797 class_binding_level
->class_shadowed
2798 = tree_cons (name
, NULL
,
2799 class_binding_level
->class_shadowed
);
2800 /* Record the value we are binding NAME to so that we can know
2801 what to pop later. */
2802 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
2803 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, true);
2806 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, false);
2810 do_class_using_decl (tree decl
)
2812 tree name
, value
, scope
, type
;
2814 if (TREE_CODE (decl
) != SCOPE_REF
2815 || !TREE_OPERAND (decl
, 0)
2816 || !TYPE_P (TREE_OPERAND (decl
, 0)))
2818 error ("using-declaration for non-member at class scope");
2821 scope
= TREE_OPERAND (decl
, 0);
2822 name
= TREE_OPERAND (decl
, 1);
2823 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2825 error ("using-declaration cannot name destructor");
2828 if (TREE_CODE (name
) == TYPE_DECL
)
2829 name
= DECL_NAME (name
);
2830 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
2831 name
= DECL_NAME (name
);
2832 else if (BASELINK_P (name
))
2834 tree fns
= BASELINK_FUNCTIONS (name
);
2835 name
= DECL_NAME (get_first_fn (fns
));
2838 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 980716);
2840 /* Dependent using decls have a NULL type, non-dependent ones have a
2842 type
= dependent_type_p (scope
) ? NULL_TREE
: void_type_node
;
2843 value
= build_lang_decl (USING_DECL
, name
, type
);
2844 DECL_INITIAL (value
) = scope
;
2849 set_class_shadows (tree shadows
)
2851 class_binding_level
->class_shadowed
= shadows
;
2854 /* Return the binding value for name in scope. */
2857 namespace_binding (tree name
, tree scope
)
2859 cxx_binding
*binding
;
2862 scope
= global_namespace
;
2863 scope
= ORIGINAL_NAMESPACE (scope
);
2864 binding
= cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2866 return binding
? binding
->value
: NULL_TREE
;
2869 /* Set the binding value for name in scope. */
2872 set_namespace_binding (tree name
, tree scope
, tree val
)
2876 timevar_push (TV_NAME_LOOKUP
);
2877 if (scope
== NULL_TREE
)
2878 scope
= global_namespace
;
2879 b
= binding_for_name (NAMESPACE_LEVEL (scope
), name
);
2881 /* If OVL_CHAIN is NULL, it's the first FUNCTION_DECL for this name,
2882 and we still need to call supplement_binding. */
2883 || (TREE_CODE (val
) == OVERLOAD
&& OVL_CHAIN (val
))
2884 || val
== error_mark_node
)
2887 supplement_binding (b
, val
);
2888 timevar_pop (TV_NAME_LOOKUP
);
2891 /* Compute the namespace where a declaration is defined. */
2894 decl_namespace (tree decl
)
2896 timevar_push (TV_NAME_LOOKUP
);
2898 decl
= TYPE_STUB_DECL (decl
);
2899 while (DECL_CONTEXT (decl
))
2901 decl
= DECL_CONTEXT (decl
);
2902 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2903 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2905 decl
= TYPE_STUB_DECL (decl
);
2906 my_friendly_assert (DECL_P (decl
), 390);
2909 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, global_namespace
);
2912 /* Set the context of a declaration to scope. Complain if we are not
2916 set_decl_namespace (tree decl
, tree scope
, bool friendp
)
2920 /* Get rid of namespace aliases. */
2921 scope
= ORIGINAL_NAMESPACE (scope
);
2923 /* It is ok for friends to be qualified in parallel space. */
2924 if (!friendp
&& !is_ancestor (current_namespace
, scope
))
2925 error ("declaration of `%D' not in a namespace surrounding `%D'",
2927 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
2928 if (scope
!= current_namespace
)
2930 /* See whether this has been declared in the namespace. */
2931 old
= namespace_binding (DECL_NAME (decl
), scope
);
2933 /* No old declaration at all. */
2935 /* A template can be explicitly specialized in any namespace. */
2936 if (processing_explicit_instantiation
)
2938 if (!is_overloaded_fn (decl
))
2939 /* Don't compare non-function decls with decls_match here,
2940 since it can't check for the correct constness at this
2941 point. pushdecl will find those errors later. */
2943 /* Since decl is a function, old should contain a function decl. */
2944 if (!is_overloaded_fn (old
))
2946 if (processing_template_decl
|| processing_specialization
)
2947 /* We have not yet called push_template_decl to turn a
2948 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
2949 won't match. But, we'll check later, when we construct the
2952 if (is_overloaded_fn (old
))
2954 for (; old
; old
= OVL_NEXT (old
))
2955 if (decls_match (decl
, OVL_CURRENT (old
)))
2959 if (decls_match (decl
, old
))
2965 error ("`%D' should have been declared inside `%D'",
2969 /* Return the namespace where the current declaration is declared. */
2972 current_decl_namespace (void)
2975 /* If we have been pushed into a different namespace, use it. */
2976 if (decl_namespace_list
)
2977 return TREE_PURPOSE (decl_namespace_list
);
2979 if (current_class_type
)
2980 result
= decl_namespace (TYPE_STUB_DECL (current_class_type
));
2981 else if (current_function_decl
)
2982 result
= decl_namespace (current_function_decl
);
2984 result
= current_namespace
;
2988 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2989 select a name that is unique to this compilation unit. */
2992 push_namespace (tree name
)
2996 int implicit_use
= 0;
2999 timevar_push (TV_NAME_LOOKUP
);
3001 /* We should not get here if the global_namespace is not yet constructed
3002 nor if NAME designates the global namespace: The global scope is
3003 constructed elsewhere. */
3004 my_friendly_assert (global_namespace
!= NULL
&& name
!= global_scope_name
,
3009 /* The name of anonymous namespace is unique for the translation
3011 if (!anonymous_namespace_name
)
3012 anonymous_namespace_name
= get_file_function_name ('N');
3013 name
= anonymous_namespace_name
;
3014 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3016 /* Reopening anonymous namespace. */
3022 /* Check whether this is an extended namespace definition. */
3023 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
3024 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
3027 if (DECL_NAMESPACE_ALIAS (d
))
3029 error ("namespace alias `%D' not allowed here, assuming `%D'",
3030 d
, DECL_NAMESPACE_ALIAS (d
));
3031 d
= DECL_NAMESPACE_ALIAS (d
);
3038 /* Make a new namespace, binding the name to it. */
3039 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
3040 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
3044 /* Clear DECL_NAME for the benefit of debugging back ends. */
3045 SET_DECL_ASSEMBLER_NAME (d
, name
);
3046 DECL_NAME (d
) = NULL_TREE
;
3048 begin_scope (sk_namespace
, d
);
3051 resume_scope (NAMESPACE_LEVEL (d
));
3054 do_using_directive (d
);
3055 /* Enter the name space. */
3056 current_namespace
= d
;
3058 timevar_pop (TV_NAME_LOOKUP
);
3061 /* Pop from the scope of the current namespace. */
3064 pop_namespace (void)
3066 my_friendly_assert (current_namespace
!= global_namespace
, 20010801);
3067 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
3068 /* The binding level is not popped, as it might be re-opened later. */
3072 /* Push into the scope of the namespace NS, even if it is deeply
3073 nested within another namespace. */
3076 push_nested_namespace (tree ns
)
3078 if (ns
== global_namespace
)
3079 push_to_top_level ();
3082 push_nested_namespace (CP_DECL_CONTEXT (ns
));
3083 push_namespace (DECL_NAME (ns
));
3087 /* Pop back from the scope of the namespace NS, which was previously
3088 entered with push_nested_namespace. */
3091 pop_nested_namespace (tree ns
)
3093 timevar_push (TV_NAME_LOOKUP
);
3094 while (ns
!= global_namespace
)
3097 ns
= CP_DECL_CONTEXT (ns
);
3100 pop_from_top_level ();
3101 timevar_pop (TV_NAME_LOOKUP
);
3104 /* Temporarily set the namespace for the current declaration. */
3107 push_decl_namespace (tree decl
)
3109 if (TREE_CODE (decl
) != NAMESPACE_DECL
)
3110 decl
= decl_namespace (decl
);
3111 decl_namespace_list
= tree_cons (ORIGINAL_NAMESPACE (decl
),
3112 NULL_TREE
, decl_namespace_list
);
3115 /* [namespace.memdef]/2 */
3118 pop_decl_namespace (void)
3120 decl_namespace_list
= TREE_CHAIN (decl_namespace_list
);
3123 /* Return the namespace that is the common ancestor
3124 of two given namespaces. */
3127 namespace_ancestor (tree ns1
, tree ns2
)
3129 timevar_push (TV_NAME_LOOKUP
);
3130 if (is_ancestor (ns1
, ns2
))
3131 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ns1
);
3132 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3133 namespace_ancestor (CP_DECL_CONTEXT (ns1
), ns2
));
3136 /* Process a namespace-alias declaration. */
3139 do_namespace_alias (tree alias
, tree
namespace)
3141 if (TREE_CODE (namespace) != NAMESPACE_DECL
)
3143 /* The parser did not find it, so it's not there. */
3144 error ("unknown namespace `%D'", namespace);
3148 namespace = ORIGINAL_NAMESPACE (namespace);
3150 /* Build the alias. */
3151 alias
= build_lang_decl (NAMESPACE_DECL
, alias
, void_type_node
);
3152 DECL_NAMESPACE_ALIAS (alias
) = namespace;
3153 DECL_EXTERNAL (alias
) = 1;
3157 /* Like pushdecl, only it places X in the current namespace,
3161 pushdecl_namespace_level (tree x
)
3163 register struct cp_binding_level
*b
= current_binding_level
;
3166 timevar_push (TV_NAME_LOOKUP
);
3167 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
3169 /* Now, the type_shadowed stack may screw us. Munge it so it does
3171 if (TREE_CODE (x
) == TYPE_DECL
)
3173 tree name
= DECL_NAME (x
);
3175 tree
*ptr
= (tree
*)0;
3176 for (; !global_scope_p (b
); b
= b
->level_chain
)
3178 tree shadowed
= b
->type_shadowed
;
3179 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3180 if (TREE_PURPOSE (shadowed
) == name
)
3182 ptr
= &TREE_VALUE (shadowed
);
3183 /* Can't break out of the loop here because sometimes
3184 a binding level will have duplicate bindings for
3185 PT names. It's gross, but I haven't time to fix it. */
3188 newval
= TREE_TYPE (x
);
3189 if (ptr
== (tree
*)0)
3191 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3192 up here if this is changed to an assertion. --KR */
3193 SET_IDENTIFIER_TYPE_VALUE (name
, x
);
3200 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3203 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3204 directive is not directly from the source. Also find the common
3205 ancestor and let our users know about the new namespace */
3207 add_using_namespace (tree user
, tree used
, bool indirect
)
3210 timevar_push (TV_NAME_LOOKUP
);
3211 /* Using oneself is a no-op. */
3214 timevar_pop (TV_NAME_LOOKUP
);
3217 my_friendly_assert (TREE_CODE (user
) == NAMESPACE_DECL
, 380);
3218 my_friendly_assert (TREE_CODE (used
) == NAMESPACE_DECL
, 380);
3219 /* Check if we already have this. */
3220 t
= purpose_member (used
, DECL_NAMESPACE_USING (user
));
3224 /* Promote to direct usage. */
3225 TREE_INDIRECT_USING (t
) = 0;
3226 timevar_pop (TV_NAME_LOOKUP
);
3230 /* Add used to the user's using list. */
3231 DECL_NAMESPACE_USING (user
)
3232 = tree_cons (used
, namespace_ancestor (user
, used
),
3233 DECL_NAMESPACE_USING (user
));
3235 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user
)) = indirect
;
3237 /* Add user to the used's users list. */
3238 DECL_NAMESPACE_USERS (used
)
3239 = tree_cons (user
, 0, DECL_NAMESPACE_USERS (used
));
3241 /* Recursively add all namespaces used. */
3242 for (t
= DECL_NAMESPACE_USING (used
); t
; t
= TREE_CHAIN (t
))
3243 /* indirect usage */
3244 add_using_namespace (user
, TREE_PURPOSE (t
), 1);
3246 /* Tell everyone using us about the new used namespaces. */
3247 for (t
= DECL_NAMESPACE_USERS (user
); t
; t
= TREE_CHAIN (t
))
3248 add_using_namespace (TREE_PURPOSE (t
), used
, 1);
3249 timevar_pop (TV_NAME_LOOKUP
);
3252 /* Process a using-declaration not appearing in class or local scope. */
3255 do_toplevel_using_decl (tree decl
)
3258 tree oldval
, oldtype
, newval
, newtype
;
3259 cxx_binding
*binding
;
3261 decl
= validate_nonmember_using_decl (decl
, &scope
, &name
);
3262 if (decl
== NULL_TREE
)
3265 binding
= binding_for_name (NAMESPACE_LEVEL (current_namespace
), name
);
3267 oldval
= binding
->value
;
3268 oldtype
= binding
->type
;
3270 do_nonmember_using_decl (scope
, name
, oldval
, oldtype
, &newval
, &newtype
);
3272 /* Copy declarations found. */
3274 binding
->value
= newval
;
3276 binding
->type
= newtype
;
3280 /* Process a using-directive. */
3283 do_using_directive (tree
namespace)
3285 if (building_stmt_tree ())
3286 add_stmt (build_stmt (USING_STMT
, namespace));
3288 /* using namespace A::B::C; */
3289 if (TREE_CODE (namespace) == SCOPE_REF
)
3290 namespace = TREE_OPERAND (namespace, 1);
3291 if (TREE_CODE (namespace) == IDENTIFIER_NODE
)
3293 /* Lookup in lexer did not find a namespace. */
3294 if (!processing_template_decl
)
3295 error ("namespace `%T' undeclared", namespace);
3298 if (TREE_CODE (namespace) != NAMESPACE_DECL
)
3300 if (!processing_template_decl
)
3301 error ("`%T' is not a namespace", namespace);
3304 namespace = ORIGINAL_NAMESPACE (namespace);
3305 if (!toplevel_bindings_p ())
3306 push_using_directive (namespace);
3309 add_using_namespace (current_namespace
, namespace, 0);
3312 /* Deal with a using-directive seen by the parser. Currently we only
3313 handle attributes here, since they cannot appear inside a template. */
3316 parse_using_directive (tree
namespace, tree attribs
)
3320 do_using_directive (namespace);
3322 for (a
= attribs
; a
; a
= TREE_CHAIN (a
))
3324 tree name
= TREE_PURPOSE (a
);
3325 if (is_attribute_p ("strong", name
))
3327 if (!toplevel_bindings_p ())
3328 error ("strong using only meaningful at namespace scope");
3330 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3331 = tree_cons (current_namespace
, 0,
3332 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3335 warning ("`%D' attribute directive ignored", name
);
3339 /* Like pushdecl, only it places X in the global scope if appropriate.
3340 Calls cp_finish_decl to register the variable, initializing it with
3341 *INIT, if INIT is non-NULL. */
3344 pushdecl_top_level_1 (tree x
, tree
*init
)
3346 timevar_push (TV_NAME_LOOKUP
);
3347 push_to_top_level ();
3348 x
= pushdecl_namespace_level (x
);
3350 cp_finish_decl (x
, *init
, NULL_TREE
, 0);
3351 pop_from_top_level ();
3352 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, x
);
3355 /* Like pushdecl, only it places X in the global scope if appropriate. */
3358 pushdecl_top_level (tree x
)
3360 return pushdecl_top_level_1 (x
, NULL
);
3363 /* Like pushdecl, only it places X in the global scope if
3364 appropriate. Calls cp_finish_decl to register the variable,
3365 initializing it with INIT. */
3368 pushdecl_top_level_and_finish (tree x
, tree init
)
3370 return pushdecl_top_level_1 (x
, &init
);
3373 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3374 duplicates. The first list becomes the tail of the result.
3376 The algorithm is O(n^2). We could get this down to O(n log n) by
3377 doing a sort on the addresses of the functions, if that becomes
3381 merge_functions (tree s1
, tree s2
)
3383 for (; s2
; s2
= OVL_NEXT (s2
))
3385 tree fn2
= OVL_CURRENT (s2
);
3388 for (fns1
= s1
; fns1
; fns1
= OVL_NEXT (fns1
))
3390 tree fn1
= OVL_CURRENT (fns1
);
3392 /* If the function from S2 is already in S1, there is no
3393 need to add it again. For `extern "C"' functions, we
3394 might have two FUNCTION_DECLs for the same function, in
3395 different namespaces; again, we only need one of them. */
3397 || (DECL_EXTERN_C_P (fn1
) && DECL_EXTERN_C_P (fn2
)
3398 && DECL_NAME (fn1
) == DECL_NAME (fn2
)))
3402 /* If we exhausted all of the functions in S1, FN2 is new. */
3404 s1
= build_overload (fn2
, s1
);
3409 /* This should return an error not all definitions define functions.
3410 It is not an error if we find two functions with exactly the
3411 same signature, only if these are selected in overload resolution.
3412 old is the current set of bindings, new the freshly-found binding.
3413 XXX Do we want to give *all* candidates in case of ambiguity?
3414 XXX In what way should I treat extern declarations?
3415 XXX I don't want to repeat the entire duplicate_decls here */
3417 static cxx_binding
*
3418 ambiguous_decl (tree name
, cxx_binding
*old
, cxx_binding
*new, int flags
)
3421 my_friendly_assert (old
!= NULL
, 393);
3422 /* Copy the value. */
3425 switch (TREE_CODE (val
))
3428 /* If we expect types or namespaces, and not templates,
3429 or this is not a template class. */
3430 if (LOOKUP_QUALIFIERS_ONLY (flags
)
3431 && !DECL_CLASS_TEMPLATE_P (val
))
3435 if (LOOKUP_NAMESPACES_ONLY (flags
))
3438 case NAMESPACE_DECL
:
3439 if (LOOKUP_TYPES_ONLY (flags
))
3443 /* Ignore built-in functions that are still anticipated. */
3444 if (LOOKUP_QUALIFIERS_ONLY (flags
) || DECL_ANTICIPATED (val
))
3448 if (LOOKUP_QUALIFIERS_ONLY (flags
))
3454 else if (val
&& val
!= old
->value
)
3456 if (is_overloaded_fn (old
->value
) && is_overloaded_fn (val
))
3457 old
->value
= merge_functions (old
->value
, val
);
3460 /* Some declarations are functions, some are not. */
3461 if (flags
& LOOKUP_COMPLAIN
)
3463 /* If we've already given this error for this lookup,
3464 old->value is error_mark_node, so let's not
3465 repeat ourselves. */
3466 if (old
->value
!= error_mark_node
)
3468 error ("use of `%D' is ambiguous", name
);
3469 cp_error_at (" first declared as `%#D' here",
3472 cp_error_at (" also declared as `%#D' here", val
);
3474 old
->value
= error_mark_node
;
3477 /* ... and copy the type. */
3479 if (LOOKUP_NAMESPACES_ONLY (flags
))
3483 else if (type
&& old
->type
!= type
)
3485 if (flags
& LOOKUP_COMPLAIN
)
3487 error ("`%D' denotes an ambiguous type",name
);
3488 error ("%J first type here", TYPE_MAIN_DECL (old
->type
));
3489 error ("%J other type here", TYPE_MAIN_DECL (type
));
3495 /* Return the declarations that are members of the namespace NS. */
3498 cp_namespace_decls (tree ns
)
3500 return NAMESPACE_LEVEL (ns
)->names
;
3503 /* Combine prefer_type and namespaces_only into flags. */
3506 lookup_flags (int prefer_type
, int namespaces_only
)
3508 if (namespaces_only
)
3509 return LOOKUP_PREFER_NAMESPACES
;
3510 if (prefer_type
> 1)
3511 return LOOKUP_PREFER_TYPES
;
3512 if (prefer_type
> 0)
3513 return LOOKUP_PREFER_BOTH
;
3517 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3518 ignore it or not. Subroutine of lookup_name_real. */
3521 qualify_lookup (tree val
, int flags
)
3523 if (val
== NULL_TREE
)
3525 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
3527 if ((flags
& LOOKUP_PREFER_TYPES
)
3528 && (TREE_CODE (val
) == TYPE_DECL
|| TREE_CODE (val
) == TEMPLATE_DECL
))
3530 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
3535 /* Look up NAME in the NAMESPACE. */
3538 lookup_namespace_name (tree
namespace, tree name
)
3541 tree template_id
= NULL_TREE
;
3542 cxx_binding binding
;
3544 timevar_push (TV_NAME_LOOKUP
);
3545 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
3547 if (TREE_CODE (name
) == NAMESPACE_DECL
)
3548 /* This happens for A::B<int> when B is a namespace. */
3549 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, name
);
3550 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
3552 /* This happens for A::B where B is a template, and there are no
3553 template arguments. */
3554 error ("invalid use of `%D'", name
);
3555 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3558 namespace = ORIGINAL_NAMESPACE (namespace);
3560 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3563 name
= TREE_OPERAND (name
, 0);
3564 if (TREE_CODE (name
) == OVERLOAD
)
3565 name
= DECL_NAME (OVL_CURRENT (name
));
3566 else if (DECL_P (name
))
3567 name
= DECL_NAME (name
);
3570 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
3572 cxx_binding_clear (&binding
);
3573 if (!qualified_lookup_using_namespace (name
, namespace, &binding
, 0))
3574 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3578 val
= binding
.value
;
3582 if (DECL_CLASS_TEMPLATE_P (val
))
3583 val
= lookup_template_class (val
,
3584 TREE_OPERAND (template_id
, 1),
3585 /*in_decl=*/NULL_TREE
,
3586 /*context=*/NULL_TREE
,
3587 /*entering_scope=*/0,
3588 tf_error
| tf_warning
);
3589 else if (DECL_FUNCTION_TEMPLATE_P (val
)
3590 || TREE_CODE (val
) == OVERLOAD
)
3591 val
= lookup_template_function (val
,
3592 TREE_OPERAND (template_id
, 1));
3595 error ("`%D::%D' is not a template",
3597 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3601 /* If we have a single function from a using decl, pull it out. */
3602 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
3603 val
= OVL_FUNCTION (val
);
3605 /* Ignore built-in functions that haven't been prototyped yet. */
3606 if (!val
|| !DECL_P(val
)
3607 || !DECL_LANG_SPECIFIC(val
)
3608 || !DECL_ANTICIPATED (val
))
3609 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3612 error ("`%D' undeclared in namespace `%D'", name
, namespace);
3613 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3616 /* Select the right _DECL from multiple choices. */
3619 select_decl (cxx_binding
*binding
, int flags
)
3622 val
= binding
->value
;
3624 timevar_push (TV_NAME_LOOKUP
);
3625 if (LOOKUP_NAMESPACES_ONLY (flags
))
3627 /* We are not interested in types. */
3628 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
3629 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3630 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3633 /* If looking for a type, or if there is no non-type binding, select
3634 the value binding. */
3635 if (binding
->type
&& (!val
|| (flags
& LOOKUP_PREFER_TYPES
)))
3636 val
= binding
->type
;
3637 /* Don't return non-types if we really prefer types. */
3638 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
3639 && (TREE_CODE (val
) != TEMPLATE_DECL
3640 || !DECL_CLASS_TEMPLATE_P (val
)))
3643 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3646 /* Unscoped lookup of a global: iterate over current namespaces,
3647 considering using-directives. If SPACESP is non-NULL, store a list
3648 of the namespaces we've considered in it. */
3651 unqualified_namespace_lookup (tree name
, int flags
, tree
* spacesp
)
3653 tree initial
= current_decl_namespace ();
3654 tree scope
= initial
;
3656 struct cp_binding_level
*level
;
3657 tree val
= NULL_TREE
;
3658 cxx_binding binding
;
3660 timevar_push (TV_NAME_LOOKUP
);
3661 cxx_binding_clear (&binding
);
3663 *spacesp
= NULL_TREE
;
3665 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
3668 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3670 *spacesp
= tree_cons (scope
, NULL_TREE
, *spacesp
);
3672 /* Ignore anticipated built-in functions. */
3673 if (b
&& b
->value
&& DECL_P (b
->value
)
3674 && DECL_LANG_SPECIFIC (b
->value
) && DECL_ANTICIPATED (b
->value
))
3675 /* Keep binding cleared. */;
3678 /* Initialize binding for this context. */
3679 binding
.value
= b
->value
;
3680 binding
.type
= b
->type
;
3683 /* Add all _DECLs seen through local using-directives. */
3684 for (level
= current_binding_level
;
3685 level
->kind
!= sk_namespace
;
3686 level
= level
->level_chain
)
3687 if (!lookup_using_namespace (name
, &binding
, level
->using_directives
,
3688 scope
, flags
, spacesp
))
3689 /* Give up because of error. */
3690 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3692 /* Add all _DECLs seen through global using-directives. */
3693 /* XXX local and global using lists should work equally. */
3697 if (!lookup_using_namespace (name
, &binding
,
3698 DECL_NAMESPACE_USING (siter
),
3699 scope
, flags
, spacesp
))
3700 /* Give up because of error. */
3701 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
3702 if (siter
== scope
) break;
3703 siter
= CP_DECL_CONTEXT (siter
);
3706 val
= select_decl (&binding
, flags
);
3707 if (scope
== global_namespace
)
3710 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3713 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3714 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3717 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3718 declaration found. If no suitable declaration can be found,
3719 ERROR_MARK_NODE is returned. Iif COMPLAIN is true and SCOPE is
3720 neither a class-type nor a namespace a diagnostic is issued. */
3723 lookup_qualified_name (tree scope
, tree name
, bool is_type_p
, bool complain
)
3727 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3729 cxx_binding binding
;
3731 cxx_binding_clear (&binding
);
3732 flags
|= LOOKUP_COMPLAIN
;
3734 flags
|= LOOKUP_PREFER_TYPES
;
3735 if (qualified_lookup_using_namespace (name
, scope
, &binding
,
3737 return select_decl (&binding
, flags
);
3739 else if (is_aggr_type (scope
, complain
))
3742 t
= lookup_member (scope
, name
, 0, is_type_p
);
3747 return error_mark_node
;
3750 /* Subroutine of unqualified_namespace_lookup:
3751 Add the bindings of NAME in used namespaces to VAL.
3752 We are currently looking for names in namespace SCOPE, so we
3753 look through USINGS for using-directives of namespaces
3754 which have SCOPE as a common ancestor with the current scope.
3755 Returns false on errors. */
3758 lookup_using_namespace (tree name
, cxx_binding
*val
, tree usings
, tree scope
,
3759 int flags
, tree
*spacesp
)
3762 timevar_push (TV_NAME_LOOKUP
);
3763 /* Iterate over all used namespaces in current, searching for using
3764 directives of scope. */
3765 for (iter
= usings
; iter
; iter
= TREE_CHAIN (iter
))
3766 if (TREE_VALUE (iter
) == scope
)
3768 tree used
= ORIGINAL_NAMESPACE (TREE_PURPOSE (iter
));
3770 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used
), name
);
3772 *spacesp
= tree_cons (used
, NULL_TREE
, *spacesp
);
3773 /* Resolve ambiguities. */
3775 val
= ambiguous_decl (name
, val
, val1
, flags
);
3777 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
->value
!= error_mark_node
);
3781 Accepts the NAME to lookup and its qualifying SCOPE.
3782 Returns the name/type pair found into the cxx_binding *RESULT,
3783 or false on error. */
3786 qualified_lookup_using_namespace (tree name
, tree scope
, cxx_binding
*result
,
3789 /* Maintain a list of namespaces visited... */
3790 tree seen
= NULL_TREE
;
3791 /* ... and a list of namespace yet to see. */
3792 tree todo
= NULL_TREE
;
3794 timevar_push (TV_NAME_LOOKUP
);
3795 /* Look through namespace aliases. */
3796 scope
= ORIGINAL_NAMESPACE (scope
);
3797 while (scope
&& result
->value
!= error_mark_node
)
3799 cxx_binding
*binding
=
3800 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope
), name
);
3801 seen
= tree_cons (scope
, NULL_TREE
, seen
);
3803 result
= ambiguous_decl (name
, result
, binding
, flags
);
3804 if (!result
->value
&& !result
->type
)
3805 /* Consider using directives. */
3806 for (usings
= DECL_NAMESPACE_USING (scope
); usings
;
3807 usings
= TREE_CHAIN (usings
))
3808 /* If this was a real directive, and we have not seen it. */
3809 if (!TREE_INDIRECT_USING (usings
)
3810 && !purpose_member (TREE_PURPOSE (usings
), seen
))
3811 todo
= tree_cons (TREE_PURPOSE (usings
), NULL_TREE
, todo
);
3814 scope
= TREE_PURPOSE (todo
);
3815 todo
= TREE_CHAIN (todo
);
3818 scope
= NULL_TREE
; /* If there never was a todo list. */
3820 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, result
->value
!= error_mark_node
);
3823 /* Look up NAME in the current binding level and its superiors in the
3824 namespace of variables, functions and typedefs. Return a ..._DECL
3825 node of some kind representing its definition if there is only one
3826 such declaration, or return a TREE_LIST with all the overloaded
3827 definitions if there are many, or return 0 if it is undefined.
3829 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3830 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3831 Otherwise we prefer non-TYPE_DECLs.
3833 If NONCLASS is nonzero, we don't look for the NAME in class scope,
3834 using IDENTIFIER_CLASS_VALUE. */
3837 lookup_name_real (tree name
, int prefer_type
, int nonclass
,
3838 int namespaces_only
, int flags
)
3841 tree val
= NULL_TREE
;
3843 timevar_push (TV_NAME_LOOKUP
);
3844 /* Conversion operators are handled specially because ordinary
3845 unqualified name lookup will not find template conversion
3847 if (IDENTIFIER_TYPENAME_P (name
))
3849 struct cp_binding_level
*level
;
3851 for (level
= current_binding_level
;
3852 level
&& level
->kind
!= sk_namespace
;
3853 level
= level
->level_chain
)
3858 /* A conversion operator can only be declared in a class
3860 if (level
->kind
!= sk_class
)
3863 /* Lookup the conversion operator in the class. */
3864 class_type
= level
->this_entity
;
3865 operators
= lookup_fnfields (class_type
, name
, /*protect=*/0);
3867 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, operators
);
3870 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
3873 flags
|= lookup_flags (prefer_type
, namespaces_only
);
3875 /* First, look in non-namespace scopes. */
3877 if (current_class_type
== NULL_TREE
)
3880 for (iter
= IDENTIFIER_BINDING (name
); iter
; iter
= iter
->previous
)
3884 if (!LOCAL_BINDING_P (iter
) && nonclass
)
3885 /* We're not looking for class-scoped bindings, so keep going. */
3888 /* If this is the kind of thing we're looking for, we're done. */
3889 if (qualify_lookup (iter
->value
, flags
))
3890 binding
= iter
->value
;
3891 else if ((flags
& LOOKUP_PREFER_TYPES
)
3892 && qualify_lookup (iter
->type
, flags
))
3893 binding
= iter
->type
;
3895 binding
= NULL_TREE
;
3904 /* Now lookup in namespace scopes. */
3907 tree t
= unqualified_namespace_lookup (name
, flags
, 0);
3914 /* If we have a single function from a using decl, pull it out. */
3915 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
3916 val
= OVL_FUNCTION (val
);
3919 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, val
);
3923 lookup_name_nonclass (tree name
)
3925 return lookup_name_real (name
, 0, 1, 0, LOOKUP_COMPLAIN
);
3929 lookup_function_nonclass (tree name
, tree args
)
3931 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
3935 lookup_name (tree name
, int prefer_type
)
3937 return lookup_name_real (name
, prefer_type
, 0, 0, LOOKUP_COMPLAIN
);
3940 /* Similar to `lookup_name' but look only in the innermost non-class
3944 lookup_name_current_level (tree name
)
3946 struct cp_binding_level
*b
;
3949 timevar_push (TV_NAME_LOOKUP
);
3950 b
= innermost_nonclass_level ();
3952 if (b
->kind
== sk_namespace
)
3954 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
3956 /* extern "C" function() */
3957 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
3960 else if (IDENTIFIER_BINDING (name
)
3961 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
3965 if (IDENTIFIER_BINDING (name
)->scope
== b
)
3966 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, IDENTIFIER_VALUE (name
));
3968 if (b
->kind
== sk_cleanup
)
3975 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
3978 /* Like lookup_name_current_level, but for types. */
3981 lookup_type_current_level (tree name
)
3983 register tree t
= NULL_TREE
;
3985 timevar_push (TV_NAME_LOOKUP
);
3986 my_friendly_assert (current_binding_level
->kind
!= sk_namespace
,
3989 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
3990 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
3992 struct cp_binding_level
*b
= current_binding_level
;
3995 if (purpose_member (name
, b
->type_shadowed
))
3996 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
,
3997 REAL_IDENTIFIER_TYPE_VALUE (name
));
3998 if (b
->kind
== sk_cleanup
)
4005 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
4008 /* [basic.lookup.koenig] */
4009 /* A nonzero return value in the functions below indicates an error. */
4019 static bool arg_assoc (struct arg_lookup
*, tree
);
4020 static bool arg_assoc_args (struct arg_lookup
*, tree
);
4021 static bool arg_assoc_type (struct arg_lookup
*, tree
);
4022 static bool add_function (struct arg_lookup
*, tree
);
4023 static bool arg_assoc_namespace (struct arg_lookup
*, tree
);
4024 static bool arg_assoc_class (struct arg_lookup
*, tree
);
4025 static bool arg_assoc_template_arg (struct arg_lookup
*, tree
);
4027 /* Add a function to the lookup structure.
4028 Returns true on error. */
4031 add_function (struct arg_lookup
*k
, tree fn
)
4033 /* We used to check here to see if the function was already in the list,
4034 but that's O(n^2), which is just too expensive for function lookup.
4035 Now we deal with the occasional duplicate in joust. In doing this, we
4036 assume that the number of duplicates will be small compared to the
4037 total number of functions being compared, which should usually be the
4040 /* We must find only functions, or exactly one non-function. */
4043 else if (fn
== k
->functions
)
4045 else if (is_overloaded_fn (k
->functions
) && is_overloaded_fn (fn
))
4046 k
->functions
= build_overload (fn
, k
->functions
);
4049 tree f1
= OVL_CURRENT (k
->functions
);
4051 if (is_overloaded_fn (f1
))
4053 fn
= f1
; f1
= f2
; f2
= fn
;
4055 cp_error_at ("`%D' is not a function,", f1
);
4056 cp_error_at (" conflict with `%D'", f2
);
4057 error (" in call to `%D'", k
->name
);
4064 /* Returns true iff CURRENT has declared itself to be an associated
4065 namespace of SCOPE via a strong using-directive (or transitive chain
4066 thereof). Both are namespaces. */
4069 is_associated_namespace (tree current
, tree scope
)
4071 tree seen
= NULL_TREE
;
4072 tree todo
= NULL_TREE
;
4076 if (scope
== current
)
4078 seen
= tree_cons (scope
, NULL_TREE
, seen
);
4079 for (t
= DECL_NAMESPACE_ASSOCIATIONS (scope
); t
; t
= TREE_CHAIN (t
))
4080 if (!purpose_member (TREE_PURPOSE (t
), seen
))
4081 todo
= tree_cons (TREE_PURPOSE (t
), NULL_TREE
, todo
);
4084 scope
= TREE_PURPOSE (todo
);
4085 todo
= TREE_CHAIN (todo
);
4092 /* Add functions of a namespace to the lookup structure.
4093 Returns true on error. */
4096 arg_assoc_namespace (struct arg_lookup
*k
, tree scope
)
4100 if (purpose_member (scope
, k
->namespaces
))
4102 k
->namespaces
= tree_cons (scope
, NULL_TREE
, k
->namespaces
);
4104 /* Check out our super-users. */
4105 for (value
= DECL_NAMESPACE_ASSOCIATIONS (scope
); value
;
4106 value
= TREE_CHAIN (value
))
4107 if (arg_assoc_namespace (k
, TREE_PURPOSE (value
)))
4110 value
= namespace_binding (k
->name
, scope
);
4114 for (; value
; value
= OVL_NEXT (value
))
4115 if (add_function (k
, OVL_CURRENT (value
)))
4121 /* Adds everything associated with a template argument to the lookup
4122 structure. Returns true on error. */
4125 arg_assoc_template_arg (struct arg_lookup
*k
, tree arg
)
4127 /* [basic.lookup.koenig]
4129 If T is a template-id, its associated namespaces and classes are
4130 ... the namespaces and classes associated with the types of the
4131 template arguments provided for template type parameters
4132 (excluding template template parameters); the namespaces in which
4133 any template template arguments are defined; and the classes in
4134 which any member templates used as template template arguments
4135 are defined. [Note: non-type template arguments do not
4136 contribute to the set of associated namespaces. ] */
4138 /* Consider first template template arguments. */
4139 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4140 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
4142 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
4144 tree ctx
= CP_DECL_CONTEXT (arg
);
4146 /* It's not a member template. */
4147 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4148 return arg_assoc_namespace (k
, ctx
);
4149 /* Otherwise, it must be member template. */
4151 return arg_assoc_class (k
, ctx
);
4153 /* It's not a template template argument, but it is a type template
4155 else if (TYPE_P (arg
))
4156 return arg_assoc_type (k
, arg
);
4157 /* It's a non-type template argument. */
4162 /* Adds everything associated with class to the lookup structure.
4163 Returns true on error. */
4166 arg_assoc_class (struct arg_lookup
*k
, tree type
)
4168 tree list
, friends
, context
;
4171 /* Backend build structures, such as __builtin_va_list, aren't
4172 affected by all this. */
4173 if (!CLASS_TYPE_P (type
))
4176 if (purpose_member (type
, k
->classes
))
4178 k
->classes
= tree_cons (type
, NULL_TREE
, k
->classes
);
4180 context
= decl_namespace (TYPE_MAIN_DECL (type
));
4181 if (arg_assoc_namespace (k
, context
))
4184 /* Process baseclasses. */
4185 for (i
= 0; i
< CLASSTYPE_N_BASECLASSES (type
); i
++)
4186 if (arg_assoc_class (k
, TYPE_BINFO_BASETYPE (type
, i
)))
4189 /* Process friends. */
4190 for (list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
)); list
;
4191 list
= TREE_CHAIN (list
))
4192 if (k
->name
== FRIEND_NAME (list
))
4193 for (friends
= FRIEND_DECLS (list
); friends
;
4194 friends
= TREE_CHAIN (friends
))
4195 /* Only interested in global functions with potentially hidden
4196 (i.e. unqualified) declarations. */
4197 if (CP_DECL_CONTEXT (TREE_VALUE (friends
)) == context
)
4198 if (add_function (k
, TREE_VALUE (friends
)))
4201 /* Process template arguments. */
4202 if (CLASSTYPE_TEMPLATE_INFO (type
))
4204 list
= INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
4205 for (i
= 0; i
< TREE_VEC_LENGTH (list
); ++i
)
4206 arg_assoc_template_arg (k
, TREE_VEC_ELT (list
, i
));
4212 /* Adds everything associated with a given type.
4213 Returns 1 on error. */
4216 arg_assoc_type (struct arg_lookup
*k
, tree type
)
4218 /* As we do not get the type of non-type dependent expressions
4219 right, we can end up with such things without a type. */
4223 if (TYPE_PTRMEM_P (type
))
4225 /* Pointer to member: associate class type and value type. */
4226 if (arg_assoc_type (k
, TYPE_PTRMEM_CLASS_TYPE (type
)))
4228 return arg_assoc_type (k
, TYPE_PTRMEM_POINTED_TO_TYPE (type
));
4230 else switch (TREE_CODE (type
))
4243 if (TYPE_PTRMEMFUNC_P (type
))
4244 return arg_assoc_type (k
, TYPE_PTRMEMFUNC_FN_TYPE (type
));
4245 return arg_assoc_class (k
, type
);
4247 case REFERENCE_TYPE
:
4249 return arg_assoc_type (k
, TREE_TYPE (type
));
4252 return arg_assoc_namespace (k
, decl_namespace (TYPE_MAIN_DECL (type
)));
4254 /* The basetype is referenced in the first arg type, so just
4257 /* Associate the parameter types. */
4258 if (arg_assoc_args (k
, TYPE_ARG_TYPES (type
)))
4260 /* Associate the return type. */
4261 return arg_assoc_type (k
, TREE_TYPE (type
));
4262 case TEMPLATE_TYPE_PARM
:
4263 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4268 if (type
== unknown_type_node
)
4270 /* else fall through */
4277 /* Adds everything associated with arguments. Returns true on error. */
4280 arg_assoc_args (struct arg_lookup
*k
, tree args
)
4282 for (; args
; args
= TREE_CHAIN (args
))
4283 if (arg_assoc (k
, TREE_VALUE (args
)))
4288 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4291 arg_assoc (struct arg_lookup
*k
, tree n
)
4293 if (n
== error_mark_node
)
4297 return arg_assoc_type (k
, n
);
4299 if (! type_unknown_p (n
))
4300 return arg_assoc_type (k
, TREE_TYPE (n
));
4302 if (TREE_CODE (n
) == ADDR_EXPR
)
4303 n
= TREE_OPERAND (n
, 0);
4304 if (TREE_CODE (n
) == COMPONENT_REF
)
4305 n
= TREE_OPERAND (n
, 1);
4306 if (TREE_CODE (n
) == OFFSET_REF
)
4307 n
= TREE_OPERAND (n
, 1);
4308 while (TREE_CODE (n
) == TREE_LIST
)
4310 if (TREE_CODE (n
) == BASELINK
)
4311 n
= BASELINK_FUNCTIONS (n
);
4313 if (TREE_CODE (n
) == FUNCTION_DECL
)
4314 return arg_assoc_type (k
, TREE_TYPE (n
));
4315 if (TREE_CODE (n
) == TEMPLATE_ID_EXPR
)
4317 /* [basic.lookup.koenig]
4319 If T is a template-id, its associated namespaces and classes
4320 are the namespace in which the template is defined; for
4321 member templates, the member template's class... */
4322 tree
template = TREE_OPERAND (n
, 0);
4323 tree args
= TREE_OPERAND (n
, 1);
4327 if (TREE_CODE (template) == COMPONENT_REF
)
4328 template = TREE_OPERAND (template, 1);
4330 /* First, the template. There may actually be more than one if
4331 this is an overloaded function template. But, in that case,
4332 we only need the first; all the functions will be in the same
4334 template = OVL_CURRENT (template);
4336 ctx
= CP_DECL_CONTEXT (template);
4338 if (TREE_CODE (ctx
) == NAMESPACE_DECL
)
4340 if (arg_assoc_namespace (k
, ctx
) == 1)
4343 /* It must be a member template. */
4344 else if (arg_assoc_class (k
, ctx
) == 1)
4347 /* Now the arguments. */
4348 for (ix
= TREE_VEC_LENGTH (args
); ix
--;)
4349 if (arg_assoc_template_arg (k
, TREE_VEC_ELT (args
, ix
)) == 1)
4354 my_friendly_assert (TREE_CODE (n
) == OVERLOAD
, 980715);
4356 for (; n
; n
= OVL_CHAIN (n
))
4357 if (arg_assoc_type (k
, TREE_TYPE (OVL_FUNCTION (n
))))
4364 /* Performs Koenig lookup depending on arguments, where fns
4365 are the functions found in normal lookup. */
4368 lookup_arg_dependent (tree name
, tree fns
, tree args
)
4370 struct arg_lookup k
;
4371 tree fn
= NULL_TREE
;
4373 timevar_push (TV_NAME_LOOKUP
);
4376 k
.classes
= NULL_TREE
;
4378 /* Note that we've already looked at some namespaces during normal
4379 unqualified lookup, unless we found a decl in function scope. */
4381 fn
= OVL_CURRENT (fns
);
4382 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (fn
))
4383 k
.namespaces
= NULL_TREE
;
4385 unqualified_namespace_lookup (name
, 0, &k
.namespaces
);
4387 arg_assoc_args (&k
, args
);
4388 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, k
.functions
);
4391 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4392 changed (i.e. there was already a directive), or the fresh
4393 TREE_LIST otherwise. */
4396 push_using_directive (tree used
)
4398 tree ud
= current_binding_level
->using_directives
;
4399 tree iter
, ancestor
;
4401 timevar_push (TV_NAME_LOOKUP
);
4402 /* Check if we already have this. */
4403 if (purpose_member (used
, ud
) != NULL_TREE
)
4404 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
4406 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4407 ud
= current_binding_level
->using_directives
;
4408 ud
= tree_cons (used
, ancestor
, ud
);
4409 current_binding_level
->using_directives
= ud
;
4411 /* Recursively add all namespaces used. */
4412 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4413 push_using_directive (TREE_PURPOSE (iter
));
4415 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, ud
);
4418 /* The type TYPE is being declared. If it is a class template, or a
4419 specialization of a class template, do any processing required and
4420 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4421 being declared a friend. B is the binding level at which this TYPE
4424 Returns the TYPE_DECL for TYPE, which may have been altered by this
4428 maybe_process_template_type_declaration (tree type
, int globalize
,
4431 tree decl
= TYPE_NAME (type
);
4433 if (processing_template_parmlist
)
4434 /* You can't declare a new template type in a template parameter
4435 list. But, you can declare a non-template type:
4437 template <class A*> struct S;
4439 is a forward-declaration of `A'. */
4443 maybe_check_template_type (type
);
4445 my_friendly_assert (IS_AGGR_TYPE (type
)
4446 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
4449 if (processing_template_decl
)
4451 /* This may change after the call to
4452 push_template_decl_real, but we want the original value. */
4453 tree name
= DECL_NAME (decl
);
4455 decl
= push_template_decl_real (decl
, globalize
);
4456 /* If the current binding level is the binding level for the
4457 template parameters (see the comment in
4458 begin_template_parm_list) and the enclosing level is a class
4459 scope, and we're not looking at a friend, push the
4460 declaration of the member class into the class scope. In the
4461 friend case, push_template_decl will already have put the
4462 friend into global scope, if appropriate. */
4463 if (TREE_CODE (type
) != ENUMERAL_TYPE
4464 && !globalize
&& b
->kind
== sk_template_parms
4465 && b
->level_chain
->kind
== sk_class
)
4467 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
4468 /* Put this UDT in the table of UDTs for the class, since
4469 that won't happen below because B is not the class
4470 binding level, but is instead the pseudo-global level. */
4471 if (b
->level_chain
->type_decls
== NULL
)
4472 b
->level_chain
->type_decls
=
4473 binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4474 binding_table_insert (b
->level_chain
->type_decls
, name
, type
);
4475 if (!COMPLETE_TYPE_P (current_class_type
))
4477 maybe_add_class_template_decl_list (current_class_type
,
4478 type
, /*friend_p=*/0);
4479 CLASSTYPE_NESTED_UTDS (current_class_type
) =
4480 b
->level_chain
->type_decls
;
4489 /* Push a tag name NAME for struct/class/union/enum type TYPE.
4490 Normally put it into the inner-most non-sk_cleanup scope,
4491 but if GLOBALIZE is true, put it in the inner-most non-class scope.
4492 The latter is needed for implicit declarations. */
4495 pushtag (tree name
, tree type
, int globalize
)
4497 register struct cp_binding_level
*b
;
4499 timevar_push (TV_NAME_LOOKUP
);
4500 b
= current_binding_level
;
4501 while (b
->kind
== sk_cleanup
4502 || (b
->kind
== sk_class
4504 /* We may be defining a new type in the initializer
4505 of a static member variable. We allow this when
4506 not pedantic, and it is particularly useful for
4507 type punning via an anonymous union. */
4508 || COMPLETE_TYPE_P (b
->this_entity
))))
4511 if (b
->type_decls
== NULL
)
4512 b
->type_decls
= binding_table_new (SCOPE_DEFAULT_HT_SIZE
);
4513 binding_table_insert (b
->type_decls
, name
, type
);
4517 /* Do C++ gratuitous typedefing. */
4518 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
4520 register tree d
= NULL_TREE
;
4522 tree context
= TYPE_CONTEXT (type
);
4526 tree cs
= current_scope ();
4530 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
4531 /* When declaring a friend class of a local class, we want
4532 to inject the newly named class into the scope
4533 containing the local class, not the namespace scope. */
4534 context
= decl_function_context (get_type_decl (cs
));
4537 context
= current_namespace
;
4539 if (b
->kind
== sk_class
4540 || (b
->kind
== sk_template_parms
4541 && b
->level_chain
->kind
== sk_class
))
4544 if (current_lang_name
== lang_name_java
)
4545 TYPE_FOR_JAVA (type
) = 1;
4547 d
= create_implicit_typedef (name
, type
);
4548 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
4550 set_identifier_type_value_with_scope (name
, d
, b
);
4552 d
= maybe_process_template_type_declaration (type
,
4555 if (b
->kind
== sk_class
)
4557 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4558 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4559 class. But if it's a member template class, we
4560 want the TEMPLATE_DECL, not the TYPE_DECL, so this
4562 finish_member_declaration (d
);
4564 pushdecl_class_level (d
);
4567 d
= pushdecl_with_scope (d
, b
);
4569 /* FIXME what if it gets a name from typedef? */
4570 if (ANON_AGGRNAME_P (name
))
4571 DECL_IGNORED_P (d
) = 1;
4573 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
4575 /* If this is a local class, keep track of it. We need this
4576 information for name-mangling, and so that it is possible to find
4577 all function definitions in a translation unit in a convenient
4578 way. (It's otherwise tricky to find a member function definition
4579 it's only pointed to from within a local class.) */
4580 if (TYPE_CONTEXT (type
)
4581 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
4582 && !processing_template_decl
)
4583 VARRAY_PUSH_TREE (local_classes
, type
);
4585 if (b
->kind
== sk_class
4586 && !COMPLETE_TYPE_P (current_class_type
))
4588 maybe_add_class_template_decl_list (current_class_type
,
4589 type
, /*friend_p=*/0);
4590 CLASSTYPE_NESTED_UTDS (current_class_type
) = b
->type_decls
;
4594 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
4595 /* Use the canonical TYPE_DECL for this node. */
4596 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
4599 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
4600 will be the tagged type we just added to the current
4601 binding level. This fake NULL-named TYPE_DECL node helps
4602 dwarfout.c to know when it needs to output a
4603 representation of a tagged type, and it also gives us a
4604 convenient place to record the "scope start" address for
4607 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
4608 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
4610 timevar_pop (TV_NAME_LOOKUP
);
4613 /* Allocate storage for saving a C++ binding. */
4614 #define cxx_saved_binding_make() \
4615 (ggc_alloc (sizeof (cxx_saved_binding)))
4617 struct cxx_saved_binding
GTY(())
4619 /* Link that chains saved C++ bindings for a given name into a stack. */
4620 cxx_saved_binding
*previous
;
4621 /* The name of the current binding. */
4623 /* The binding we're saving. */
4624 cxx_binding
*binding
;
4626 tree real_type_value
;
4629 /* Subroutines for reverting temporarily to top-level for instantiation
4630 of templates and such. We actually need to clear out the class- and
4631 local-value slots of all identifiers, so that only the global values
4632 are at all visible. Simply setting current_binding_level to the global
4633 scope isn't enough, because more binding levels may be pushed. */
4634 struct saved_scope
*scope_chain
;
4636 static cxx_saved_binding
*
4637 store_bindings (tree names
, cxx_saved_binding
*old_bindings
)
4640 cxx_saved_binding
*search_bindings
= old_bindings
;
4642 timevar_push (TV_NAME_LOOKUP
);
4643 for (t
= names
; t
; t
= TREE_CHAIN (t
))
4646 cxx_saved_binding
*saved
;
4647 cxx_saved_binding
*t1
;
4649 if (TREE_CODE (t
) == TREE_LIST
)
4650 id
= TREE_PURPOSE (t
);
4655 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
4656 we have no IDENTIFIER_BINDING if we have left the class
4657 scope, but cached the class-level declarations. */
4658 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
4661 for (t1
= search_bindings
; t1
; t1
= t1
->previous
)
4662 if (t1
->identifier
== id
)
4665 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
4666 saved
= cxx_saved_binding_make ();
4667 saved
->previous
= old_bindings
;
4668 saved
->identifier
= id
;
4669 saved
->binding
= IDENTIFIER_BINDING (id
);
4670 saved
->class_value
= IDENTIFIER_CLASS_VALUE (id
);;
4671 saved
->real_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
4672 IDENTIFIER_BINDING (id
) = NULL
;
4673 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
4674 old_bindings
= saved
;
4678 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, old_bindings
);
4682 maybe_push_to_top_level (int pseudo
)
4684 struct saved_scope
*s
;
4685 struct cp_binding_level
*b
;
4686 cxx_saved_binding
*old_bindings
;
4689 timevar_push (TV_NAME_LOOKUP
);
4690 s
= ggc_alloc_cleared (sizeof (struct saved_scope
));
4692 b
= scope_chain
? current_binding_level
: 0;
4694 /* If we're in the middle of some function, save our state. */
4698 push_function_context_to (NULL_TREE
);
4703 old_bindings
= NULL
;
4704 if (scope_chain
&& previous_class_type
)
4705 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
4707 /* Have to include the global scope, because class-scope decls
4708 aren't listed anywhere useful. */
4709 for (; b
; b
= b
->level_chain
)
4713 /* Template IDs are inserted into the global level. If they were
4714 inserted into namespace level, finish_file wouldn't find them
4715 when doing pending instantiations. Therefore, don't stop at
4716 namespace level, but continue until :: . */
4717 if (global_scope_p (b
) || (pseudo
&& b
->kind
== sk_template_parms
))
4720 old_bindings
= store_bindings (b
->names
, old_bindings
);
4721 /* We also need to check class_shadowed to save class-level type
4722 bindings, since pushclass doesn't fill in b->names. */
4723 if (b
->kind
== sk_class
)
4724 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
4726 /* Unwind type-value slots back to top level. */
4727 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
4728 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
4730 s
->prev
= scope_chain
;
4731 s
->old_bindings
= old_bindings
;
4733 s
->need_pop_function_context
= need_pop
;
4734 s
->function_decl
= current_function_decl
;
4735 s
->last_parms
= last_function_parms
;
4738 current_function_decl
= NULL_TREE
;
4739 VARRAY_TREE_INIT (current_lang_base
, 10, "current_lang_base");
4740 current_lang_name
= lang_name_cplusplus
;
4741 current_namespace
= global_namespace
;
4742 timevar_pop (TV_NAME_LOOKUP
);
4746 push_to_top_level (void)
4748 maybe_push_to_top_level (0);
4752 pop_from_top_level (void)
4754 struct saved_scope
*s
= scope_chain
;
4755 cxx_saved_binding
*saved
;
4757 timevar_push (TV_NAME_LOOKUP
);
4758 /* Clear out class-level bindings cache. */
4759 if (previous_class_type
)
4760 invalidate_class_lookup_cache ();
4762 current_lang_base
= 0;
4764 scope_chain
= s
->prev
;
4765 for (saved
= s
->old_bindings
; saved
; saved
= saved
->previous
)
4767 tree id
= saved
->identifier
;
4769 IDENTIFIER_BINDING (id
) = saved
->binding
;
4770 IDENTIFIER_CLASS_VALUE (id
) = saved
->class_value
;
4771 SET_IDENTIFIER_TYPE_VALUE (id
, saved
->real_type_value
);
4774 /* If we were in the middle of compiling a function, restore our
4776 if (s
->need_pop_function_context
)
4777 pop_function_context_from (NULL_TREE
);
4778 current_function_decl
= s
->function_decl
;
4779 last_function_parms
= s
->last_parms
;
4780 timevar_pop (TV_NAME_LOOKUP
);
4783 /* Pop off extraneous binding levels left over due to syntax errors.
4785 We don't pop past namespaces, as they might be valid. */
4788 pop_everything (void)
4790 if (ENABLE_SCOPE_CHECKING
)
4791 verbatim ("XXX entering pop_everything ()\n");
4792 while (!toplevel_bindings_p ())
4794 if (current_binding_level
->kind
== sk_class
)
4795 pop_nested_class ();
4799 if (ENABLE_SCOPE_CHECKING
)
4800 verbatim ("XXX leaving pop_everything ()\n");
4803 #include "gt-cp-name-lookup.h"