Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / gcc / cp / name-lookup.c
1 /* Definitions for C++ name lookup routines.
2    Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
4
5 This file is part of GCC.
6
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)
10 any later version.
11
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.
16
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.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "flags.h"
27 #include "tree.h"
28 #include "cp-tree.h"
29 #include "name-lookup.h"
30 #include "timevar.h"
31 #include "toplev.h"
32 #include "diagnostic.h"
33
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 tree push_overloaded_decl (tree, int);
39 static bool lookup_using_namespace (tree, cxx_binding *, tree,
40                                     tree, int);
41 static bool qualified_lookup_using_namespace (tree, tree, cxx_binding *, int);
42 static tree lookup_type_current_level (tree);
43 static tree push_using_directive (tree);
44
45
46 /* The :: namespace.  */
47
48 tree global_namespace;
49
50 /* The name of the anonymous namespace, throughout this translation
51    unit.  */
52 GTY(()) tree anonymous_namespace_name;
53
54
55 /* Compute the chain index of a binding_entry given the HASH value of its
56    name and the total COUNT of chains.  COUNT is assumed to be a power
57    of 2.  */
58
59 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
60
61 /* A free list of "binding_entry"s awaiting for re-use.  */
62
63 static GTY((deletable(""))) binding_entry free_binding_entry = NULL;
64
65 /* Create a binding_entry object for (NAME, TYPE).  */
66
67 static inline binding_entry
68 binding_entry_make (tree name, tree type)
69 {
70   binding_entry entry;
71
72   if (free_binding_entry)
73     {
74       entry = free_binding_entry;
75       free_binding_entry = entry->chain;
76     }
77   else
78     entry = ggc_alloc (sizeof (struct binding_entry_s));
79
80   entry->name = name;
81   entry->type = type;
82   entry->chain = NULL;
83
84   return entry;
85 }
86
87 /* Put ENTRY back on the free list.  */
88
89 static inline void
90 binding_entry_free (binding_entry entry)
91 {
92   entry->name = NULL;
93   entry->type = NULL;
94   entry->chain = free_binding_entry;
95   free_binding_entry = entry;
96 }
97
98 /* The datatype used to implement the mapping from names to types at
99    a given scope.  */
100 struct binding_table_s GTY(())
101 {
102   /* Array of chains of "binding_entry"s  */
103   binding_entry * GTY((length ("%h.chain_count"))) chain;
104
105   /* The number of chains in this table.  This is the length of the
106      the member "chain" considered as an array.  */
107   size_t chain_count;
108
109   /* Number of "binding_entry"s in this table.  */
110   size_t entry_count;
111 };
112
113 /* Construct TABLE with an initial CHAIN_COUNT.  */
114
115 static inline void
116 binding_table_construct (binding_table table, size_t chain_count)
117 {
118   table->chain_count = chain_count;
119   table->entry_count = 0;
120   table->chain = ggc_alloc_cleared
121     (table->chain_count * sizeof (binding_entry));
122 }
123
124 /* Make TABLE's entries ready for reuse.  */
125
126 static void
127 binding_table_free (binding_table table)
128 {
129   size_t i;
130   size_t count;
131
132   if (table == NULL)
133     return;
134
135   for (i = 0, count = table->chain_count; i < count; ++i)
136     {
137       binding_entry temp = table->chain[i];
138       while (temp != NULL)
139         {
140           binding_entry entry = temp;
141           temp = entry->chain;
142           binding_entry_free (entry);
143         }
144       table->chain[i] = NULL;
145     }
146   table->entry_count = 0;
147 }
148
149 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two.  */
150
151 static inline binding_table
152 binding_table_new (size_t chain_count)
153 {
154   binding_table table = ggc_alloc (sizeof (struct binding_table_s));
155   table->chain = NULL;
156   binding_table_construct (table, chain_count);
157   return table;
158 }
159
160 /* Expand TABLE to twice its current chain_count.  */
161
162 static void
163 binding_table_expand (binding_table table)
164 {
165   const size_t old_chain_count = table->chain_count;
166   const size_t old_entry_count = table->entry_count;
167   const size_t new_chain_count = 2 * old_chain_count;
168   binding_entry *old_chains = table->chain;
169   size_t i;
170
171   binding_table_construct (table, new_chain_count);
172   for (i = 0; i < old_chain_count; ++i)
173     {
174       binding_entry entry = old_chains[i];
175       for (; entry != NULL; entry = old_chains[i])
176         {
177           const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
178           const size_t j = ENTRY_INDEX (hash, new_chain_count);
179
180           old_chains[i] = entry->chain;
181           entry->chain = table->chain[j];
182           table->chain[j] = entry;
183         }
184     }
185   table->entry_count = old_entry_count;
186 }
187
188 /* Insert a binding for NAME to TYPE into TABLE.  */
189
190 static void
191 binding_table_insert (binding_table table, tree name, tree type)
192 {
193   const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
194   const size_t i = ENTRY_INDEX (hash, table->chain_count);
195   binding_entry entry = binding_entry_make (name, type);
196
197   entry->chain = table->chain[i];
198   table->chain[i] = entry;
199   ++table->entry_count;
200
201   if (3 * table->chain_count < 5 * table->entry_count)
202     binding_table_expand (table);
203 }
204
205 /* Return the binding_entry, if any, that maps NAME.  */
206
207 binding_entry
208 binding_table_find (binding_table table, tree name)
209 {
210   const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
211   binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
212
213   while (entry != NULL && entry->name != name)
214     entry = entry->chain;
215
216   return entry;
217 }
218
219 /* Return the binding_entry, if any, that maps NAME to an anonymous type.  */
220
221 static tree
222 binding_table_find_anon_type (binding_table table, tree name)
223 {
224   const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
225   binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
226
227   while (entry != NULL && TYPE_IDENTIFIER (entry->type) != name)
228     entry = entry->chain;
229
230   return entry ? entry->type : NULL;
231 }
232
233 /* Return the binding_entry, if any, that has TYPE as target.  If NAME
234    is non-null, then set the domain and rehash that entry.  */
235
236 static binding_entry
237 binding_table_reverse_maybe_remap (binding_table table, tree type, tree name)
238 {
239   const size_t chain_count = table->chain_count;
240   binding_entry entry = NULL;
241   binding_entry *p = NULL;
242   size_t i;
243
244   for (i = 0; i < chain_count && entry == NULL; ++i)
245     {
246       p = &table->chain[i];
247       while (*p != NULL && entry == NULL)
248         if ((*p)->type == type)
249           entry = *p;
250         else
251           p = &(*p)->chain;
252     }
253
254   if (entry != NULL && name != NULL && entry->name != name)
255     {
256       /* Remove the bucket from the previous chain.  */
257       *p = (*p)->chain;
258
259       /* Remap the name type to type.  */
260       i = ENTRY_INDEX (IDENTIFIER_HASH_VALUE (name), chain_count);
261       entry->chain = table->chain[i];
262       entry->name = name;
263       table->chain[i] = entry;
264     }
265
266   return entry;
267 }
268
269 /* Remove from TABLE all entries that map to anonymous enums or
270    class-types.  */
271
272 void
273 binding_table_remove_anonymous_types (binding_table table)
274 {
275   const size_t chain_count = table->chain_count;
276   size_t i;
277
278   for (i = 0; i < chain_count; ++i)
279     {
280       binding_entry *p = &table->chain[i];
281
282       while (*p != NULL)
283         if (ANON_AGGRNAME_P ((*p)->name))
284           {
285             binding_entry e = *p;
286             *p = (*p)->chain;
287             --table->entry_count;
288             binding_entry_free (e);
289           }
290         else
291           p = &(*p)->chain;
292     }
293 }
294
295 /* Apply PROC -- with DATA -- to all entries in TABLE.  */
296
297 void
298 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
299 {
300   const size_t chain_count = table->chain_count;
301   size_t i;
302
303   for (i = 0; i < chain_count; ++i)
304     {
305       binding_entry entry = table->chain[i];
306       for (; entry != NULL; entry = entry->chain)
307         proc (entry, data);
308     }
309 }
310 \f
311 #ifndef ENABLE_SCOPE_CHECKING
312 #  define ENABLE_SCOPE_CHECKING 0
313 #else
314 #  define ENABLE_SCOPE_CHECKING 1
315 #endif
316
317 /* A free list of "cxx_binding"s, connected by their PREVIOUS.  */
318
319 static GTY((deletable (""))) cxx_binding *free_bindings;
320
321 /* Zero out a cxx_binding pointed to by B.  */
322 #define cxx_binding_clear(B) memset ((B), 0, sizeof (cxx_binding))
323
324 /* (GC)-allocate a binding object with VALUE and TYPE member initialized.  */
325
326 static cxx_binding *
327 cxx_binding_make (tree value, tree type)
328 {
329   cxx_binding *binding;
330   if (free_bindings)
331     {
332       binding = free_bindings;
333       free_bindings = binding->previous;
334     }
335   else
336     binding = ggc_alloc (sizeof (cxx_binding));
337
338   binding->value = value;
339   binding->type = type;
340   binding->previous = NULL;
341
342   return binding;
343 }
344
345 /* Put BINDING back on the free list.  */
346
347 static inline void
348 cxx_binding_free (cxx_binding *binding)
349 {
350   binding->scope = NULL;
351   binding->previous = free_bindings;
352   free_bindings = binding;
353 }
354
355 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
356    level at which this declaration is being bound.  */
357
358 static void
359 push_binding (tree id, tree decl, cxx_scope* level)
360 {
361    cxx_binding *binding = cxx_binding_make (decl, NULL);
362
363   /* Now, fill in the binding information.  */
364   binding->previous = IDENTIFIER_BINDING (id);
365   binding->scope = level;
366   INHERITED_VALUE_BINDING_P (binding) = 0;
367   LOCAL_BINDING_P (binding) = (level != class_binding_level);
368
369   /* And put it on the front of the list of bindings for ID.  */
370   IDENTIFIER_BINDING (id) = binding;
371 }
372
373 /* Remove the binding for DECL which should be the innermost binding
374    for ID.  */
375
376 void
377 pop_binding (tree id, tree decl)
378 {
379   cxx_binding *binding;
380
381   if (id == NULL_TREE)
382     /* It's easiest to write the loops that call this function without
383        checking whether or not the entities involved have names.  We
384        get here for such an entity.  */
385     return;
386
387   /* Get the innermost binding for ID.  */
388   binding = IDENTIFIER_BINDING (id);
389
390   /* The name should be bound.  */
391   my_friendly_assert (binding != NULL, 0);
392
393   /* The DECL will be either the ordinary binding or the type
394      binding for this identifier.  Remove that binding.  */
395   if (binding->value == decl)
396     binding->value = NULL_TREE;
397   else if (binding->type == decl)
398     binding->type = NULL_TREE;
399   else
400     abort ();
401
402   if (!binding->value && !binding->type)
403     {
404       /* We're completely done with the innermost binding for this
405          identifier.  Unhook it from the list of bindings.  */
406       IDENTIFIER_BINDING (id) = binding->previous;
407
408       /* Add it to the free list.  */
409       cxx_binding_free (binding);
410     }
411 }
412
413 /* BINDING records an existing declaration for a namein the current scope.
414    But, DECL is another declaration for that same identifier in the
415    same scope.  This is the `struct stat' hack whereby a non-typedef
416    class name or enum-name can be bound at the same level as some other
417    kind of entity.
418    3.3.7/1
419
420      A class name (9.1) or enumeration name (7.2) can be hidden by the
421      name of an object, function, or enumerator declared in the same scope.
422      If a class or enumeration name and an object, function, or enumerator
423      are declared in the same scope (in any order) with the same name, the
424      class or enumeration name is hidden wherever the object, function, or
425      enumerator name is visible.
426
427    It's the responsibility of the caller to check that
428    inserting this name is valid here.  Returns nonzero if the new binding
429    was successful.  */
430
431 static bool
432 supplement_binding (cxx_binding *binding, tree decl)
433 {
434   tree bval = binding->value;
435   bool ok = true;
436
437   timevar_push (TV_NAME_LOOKUP);
438   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
439     /* The new name is the type name.  */
440     binding->type = decl;
441   else if (/* BVAL is null when push_class_level_binding moves an
442               inherited type-binding out of the way to make room for a
443               new value binding.  */
444            !bval 
445            /* BVAL is error_mark_node when DECL's name has been used
446               in a non-class scope prior declaration.  In that case,
447               we should have already issued a diagnostic; for graceful
448               error recovery purpose, pretend this was the intended
449               declaration for that name.  */
450            || bval == error_mark_node
451            /* If BVAL is a built-in that has not yet been declared,
452               pretend it is not there at all.  */
453            || (TREE_CODE (bval) == FUNCTION_DECL
454                && DECL_ANTICIPATED (bval)))
455     binding->value = decl;
456   else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
457     {
458       /* The old binding was a type name.  It was placed in
459          VALUE field because it was thought, at the point it was
460          declared, to be the only entity with such a name.  Move the
461          type name into the type slot; it is now hidden by the new
462          binding.  */
463       binding->type = bval;
464       binding->value = decl;
465       binding->value_is_inherited = false;
466     }
467   else if (TREE_CODE (bval) == TYPE_DECL
468            && TREE_CODE (decl) == TYPE_DECL
469            && DECL_NAME (decl) == DECL_NAME (bval)
470            && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
471                /* If either type involves template parameters, we must
472                   wait until instantiation.  */
473                || uses_template_parms (TREE_TYPE (decl))
474                || uses_template_parms (TREE_TYPE (bval))))
475     /* We have two typedef-names, both naming the same type to have
476        the same name.  This is OK because of:
477
478          [dcl.typedef]
479
480          In a given scope, a typedef specifier can be used to redefine
481          the name of any type declared in that scope to refer to the
482          type to which it already refers.  */
483     ok = false;
484   /* There can be two block-scope declarations of the same variable,
485      so long as they are `extern' declarations.  However, there cannot
486      be two declarations of the same static data member:
487
488        [class.mem]
489
490        A member shall not be declared twice in the
491        member-specification.  */
492   else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
493            && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
494            && !DECL_CLASS_SCOPE_P (decl))
495     {
496       duplicate_decls (decl, binding->value);
497       ok = false;
498     }
499   else if (TREE_CODE (decl) == NAMESPACE_DECL
500            && TREE_CODE (bval) == NAMESPACE_DECL
501            && DECL_NAMESPACE_ALIAS (decl)
502            && DECL_NAMESPACE_ALIAS (bval)
503            && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
504     /* [namespace.alias]
505        
506       In a declarative region, a namespace-alias-definition can be
507       used to redefine a namespace-alias declared in that declarative
508       region to refer only to the namespace to which it already
509       refers.  */
510     ok = false;
511   else
512     {
513       error ("declaration of `%#D'", decl);
514       cp_error_at ("conflicts with previous declaration `%#D'", bval);
515       ok = false;
516     }
517
518   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
519 }
520
521 /* Add DECL to the list of things declared in B.  */
522
523 static void
524 add_decl_to_level (tree decl, cxx_scope *b)
525 {
526   if (TREE_CODE (decl) == NAMESPACE_DECL 
527       && !DECL_NAMESPACE_ALIAS (decl))
528     {
529       TREE_CHAIN (decl) = b->namespaces;
530       b->namespaces = decl;
531     }
532   else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
533     {
534       TREE_CHAIN (decl) = b->vtables;
535       b->vtables = decl;
536     }
537   else       
538     {
539       /* We build up the list in reverse order, and reverse it later if
540          necessary.  */
541       TREE_CHAIN (decl) = b->names;
542       b->names = decl;
543       b->names_size++;
544
545       /* If appropriate, add decl to separate list of statics.  We
546          include extern variables because they might turn out to be 
547          static later.  It's OK for this list to contain a few false
548          positives. */
549       if (b->kind == sk_namespace)
550         if ((TREE_CODE (decl) == VAR_DECL
551              && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
552             || (TREE_CODE (decl) == FUNCTION_DECL
553                 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
554           VARRAY_PUSH_TREE (b->static_decls, decl);
555     }
556 }
557
558 /* Record a decl-node X as belonging to the current lexical scope.
559    Check for errors (such as an incompatible declaration for the same
560    name already seen in the same scope).
561
562    Returns either X or an old decl for the same name.
563    If an old decl is returned, it may have been smashed
564    to agree with what X says.  */
565
566 tree
567 pushdecl (tree x)
568 {
569   tree t;
570   tree name;
571   int need_new_binding;
572
573   timevar_push (TV_NAME_LOOKUP);
574
575   need_new_binding = 1;
576
577   if (DECL_TEMPLATE_PARM_P (x))
578     /* Template parameters have no context; they are not X::T even
579        when declared within a class or namespace.  */
580     ;
581   else
582     {
583       if (current_function_decl && x != current_function_decl
584           /* A local declaration for a function doesn't constitute
585              nesting.  */
586           && TREE_CODE (x) != FUNCTION_DECL
587           /* A local declaration for an `extern' variable is in the
588              scope of the current namespace, not the current
589              function.  */
590           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
591           && !DECL_CONTEXT (x))
592         DECL_CONTEXT (x) = current_function_decl;
593
594       /* If this is the declaration for a namespace-scope function,
595          but the declaration itself is in a local scope, mark the
596          declaration.  */
597       if (TREE_CODE (x) == FUNCTION_DECL
598           && DECL_NAMESPACE_SCOPE_P (x)
599           && current_function_decl
600           && x != current_function_decl)
601         DECL_LOCAL_FUNCTION_P (x) = 1;
602     }
603
604   name = DECL_NAME (x);
605   if (name)
606     {
607       int different_binding_level = 0;
608
609       if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
610        check_default_args (x);
611
612       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
613         name = TREE_OPERAND (name, 0);
614
615       /* In case this decl was explicitly namespace-qualified, look it
616          up in its namespace context.  */
617       if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
618         t = namespace_binding (name, DECL_CONTEXT (x));
619       else
620         t = lookup_name_current_level (name);
621
622       /* [basic.link] If there is a visible declaration of an entity
623          with linkage having the same name and type, ignoring entities
624          declared outside the innermost enclosing namespace scope, the
625          block scope declaration declares that same entity and
626          receives the linkage of the previous declaration.  */
627       if (! t && current_function_decl && x != current_function_decl
628           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
629           && DECL_EXTERNAL (x))
630         {
631           /* Look in block scope.  */
632           t = IDENTIFIER_VALUE (name);
633           /* Or in the innermost namespace.  */
634           if (! t)
635             t = namespace_binding (name, DECL_CONTEXT (x));
636           /* Does it have linkage?  Note that if this isn't a DECL, it's an
637              OVERLOAD, which is OK.  */
638           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
639             t = NULL_TREE;
640           if (t)
641             different_binding_level = 1;
642         }
643
644       /* If we are declaring a function, and the result of name-lookup
645          was an OVERLOAD, look for an overloaded instance that is
646          actually the same as the function we are declaring.  (If
647          there is one, we have to merge our declaration with the
648          previous declaration.)  */
649       if (t && TREE_CODE (t) == OVERLOAD)
650         {
651           tree match;
652
653           if (TREE_CODE (x) == FUNCTION_DECL)
654             for (match = t; match; match = OVL_NEXT (match))
655               {
656                 if (decls_match (OVL_CURRENT (match), x))
657                   break;
658               }
659           else
660             /* Just choose one.  */
661             match = t;
662
663           if (match)
664             t = OVL_CURRENT (match);
665           else
666             t = NULL_TREE;
667         }
668
669       if (t == error_mark_node)
670         {
671           /* error_mark_node is 0 for a while during initialization!  */
672           t = NULL_TREE;
673           cp_error_at ("`%#D' used prior to declaration", x);
674         }
675       else if (t != NULL_TREE)
676         {
677           if (different_binding_level)
678             {
679               if (decls_match (x, t))
680                 /* The standard only says that the local extern
681                    inherits linkage from the previous decl; in
682                    particular, default args are not shared.  It would
683                    be nice to propagate inlining info, though.  FIXME.  */
684                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
685             }
686           else if (TREE_CODE (t) == PARM_DECL)
687             {
688               if (DECL_CONTEXT (t) == NULL_TREE)
689                 /* This is probably caused by too many errors, but calling
690                    abort will say that if errors have occurred.  */
691                 abort ();
692
693               /* Check for duplicate params.  */
694               if (duplicate_decls (x, t))
695                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
696             }
697           else if ((DECL_EXTERN_C_FUNCTION_P (x)
698                     || DECL_FUNCTION_TEMPLATE_P (x))
699                    && is_overloaded_fn (t))
700             /* Don't do anything just yet.  */;
701           else if (t == wchar_decl_node)
702             {
703               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
704                 pedwarn ("redeclaration of `wchar_t' as `%T'",
705                             TREE_TYPE (x));
706
707               /* Throw away the redeclaration.  */
708               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
709             }
710           else
711             {
712               tree olddecl = duplicate_decls (x, t);
713               
714               /* If the redeclaration failed, we can stop at this
715                  point.  */
716               if (olddecl == error_mark_node)
717                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
718
719               if (olddecl)
720                 {
721                   if (TREE_CODE (t) == TYPE_DECL)
722                     SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
723
724                   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
725                 }
726               else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
727                 {
728                   /* A redeclaration of main, but not a duplicate of the
729                      previous one.
730                      
731                      [basic.start.main]
732                      
733                      This function shall not be overloaded.  */
734                   cp_error_at ("invalid redeclaration of `%D'", t);
735                   error ("as `%D'", x);
736                   /* We don't try to push this declaration since that
737                      causes a crash.  */
738                   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
739                 }
740             }
741         }
742
743       check_template_shadow (x);
744
745       /* If this is a function conjured up by the backend, massage it
746          so it looks friendly.  */
747       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
748         {
749           retrofit_lang_decl (x);
750           SET_DECL_LANGUAGE (x, lang_c);
751         }
752
753       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
754         {
755           t = push_overloaded_decl (x, PUSH_LOCAL);
756           if (t != x)
757             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
758           if (!namespace_bindings_p ())
759             /* We do not need to create a binding for this name;
760                push_overloaded_decl will have already done so if
761                necessary.  */
762             need_new_binding = 0;
763         }
764       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
765         {
766           t = push_overloaded_decl (x, PUSH_GLOBAL);
767           if (t == x)
768             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
769           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
770         }
771
772       /* If declaring a type as a typedef, copy the type (unless we're
773          at line 0), and install this TYPE_DECL as the new type's typedef
774          name.  See the extensive comment in ../c-decl.c (pushdecl).  */
775       if (TREE_CODE (x) == TYPE_DECL)
776         {
777           tree type = TREE_TYPE (x);
778           if (DECL_SOURCE_LINE (x) == 0)
779             {
780               if (TYPE_NAME (type) == 0)
781                 TYPE_NAME (type) = x;
782             }
783           else if (type != error_mark_node && TYPE_NAME (type) != x
784                    /* We don't want to copy the type when all we're
785                       doing is making a TYPE_DECL for the purposes of
786                       inlining.  */
787                    && (!TYPE_NAME (type)
788                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
789             {
790               DECL_ORIGINAL_TYPE (x) = type;
791               type = build_type_copy (type);
792               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
793               TYPE_NAME (type) = x;
794               TREE_TYPE (x) = type;
795             }
796
797           if (type != error_mark_node
798               && TYPE_NAME (type)
799               && TYPE_IDENTIFIER (type))
800             set_identifier_type_value (DECL_NAME (x), x);
801         }
802
803       /* Multiple external decls of the same identifier ought to match.
804
805          We get warnings about inline functions where they are defined.
806          We get warnings about other functions from push_overloaded_decl.
807
808          Avoid duplicate warnings where they are used.  */
809       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
810         {
811           tree decl;
812
813           decl = IDENTIFIER_NAMESPACE_VALUE (name);
814           if (decl && TREE_CODE (decl) == OVERLOAD)
815             decl = OVL_FUNCTION (decl);
816
817           if (decl && decl != error_mark_node
818               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
819               /* If different sort of thing, we already gave an error.  */
820               && TREE_CODE (decl) == TREE_CODE (x)
821               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
822             {
823               pedwarn ("type mismatch with previous external decl of `%#D'", x);
824               cp_pedwarn_at ("previous external decl of `%#D'", decl);
825             }
826         }
827
828       /* This name is new in its binding level.
829          Install the new declaration and return it.  */
830       if (namespace_bindings_p ())
831         {
832           /* Install a global value.  */
833
834           /* If the first global decl has external linkage,
835              warn if we later see static one.  */
836           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
837             TREE_PUBLIC (name) = 1;
838
839           /* Bind the name for the entity.  */
840           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
841                 && t != NULL_TREE)
842               && (TREE_CODE (x) == TYPE_DECL
843                   || TREE_CODE (x) == VAR_DECL
844                   || TREE_CODE (x) == ALIAS_DECL
845                   || TREE_CODE (x) == NAMESPACE_DECL
846                   || TREE_CODE (x) == CONST_DECL
847                   || TREE_CODE (x) == TEMPLATE_DECL))
848             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
849
850           /* Don't forget if the function was used via an implicit decl.  */
851           if (IDENTIFIER_IMPLICIT_DECL (name)
852               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
853             TREE_USED (x) = 1;
854
855           /* Don't forget if its address was taken in that way.  */
856           if (IDENTIFIER_IMPLICIT_DECL (name)
857               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
858             TREE_ADDRESSABLE (x) = 1;
859
860           /* Warn about mismatches against previous implicit decl.  */
861           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
862               /* If this real decl matches the implicit, don't complain.  */
863               && ! (TREE_CODE (x) == FUNCTION_DECL
864                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
865             warning
866               ("`%D' was previously implicitly declared to return `int'", x);
867
868           /* If new decl is `static' and an `extern' was seen previously,
869              warn about it.  */
870           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
871             warn_extern_redeclared_static (x, t);
872         }
873       else
874         {
875           /* Here to install a non-global value.  */
876           tree oldlocal = IDENTIFIER_VALUE (name);
877           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
878
879           if (need_new_binding)
880             {
881               push_local_binding (name, x, 0);
882               /* Because push_local_binding will hook X on to the
883                  current_binding_level's name list, we don't want to
884                  do that again below.  */
885               need_new_binding = 0;
886             }
887
888           /* If this is a TYPE_DECL, push it into the type value slot.  */
889           if (TREE_CODE (x) == TYPE_DECL)
890             set_identifier_type_value (name, x);
891
892           /* Clear out any TYPE_DECL shadowed by a namespace so that
893              we won't think this is a type.  The C struct hack doesn't
894              go through namespaces.  */
895           if (TREE_CODE (x) == NAMESPACE_DECL)
896             set_identifier_type_value (name, NULL_TREE);
897
898           if (oldlocal)
899             {
900               tree d = oldlocal;
901
902               while (oldlocal
903                      && TREE_CODE (oldlocal) == VAR_DECL
904                      && DECL_DEAD_FOR_LOCAL (oldlocal))
905                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
906
907               if (oldlocal == NULL_TREE)
908                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
909             }
910
911           /* If this is an extern function declaration, see if we
912              have a global definition or declaration for the function.  */
913           if (oldlocal == NULL_TREE
914               && DECL_EXTERNAL (x)
915               && oldglobal != NULL_TREE
916               && TREE_CODE (x) == FUNCTION_DECL
917               && TREE_CODE (oldglobal) == FUNCTION_DECL)
918             {
919               /* We have one.  Their types must agree.  */
920               if (decls_match (x, oldglobal))
921                 /* OK */;
922               else
923                 {
924                   warning ("extern declaration of `%#D' doesn't match", x);
925                   cp_warning_at ("global declaration `%#D'", oldglobal);
926                 }
927             }
928           /* If we have a local external declaration,
929              and no file-scope declaration has yet been seen,
930              then if we later have a file-scope decl it must not be static.  */
931           if (oldlocal == NULL_TREE
932               && oldglobal == NULL_TREE
933               && DECL_EXTERNAL (x)
934               && TREE_PUBLIC (x))
935             TREE_PUBLIC (name) = 1;
936
937           /* Warn if shadowing an argument at the top level of the body.  */
938           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
939               /* Inline decls shadow nothing.  */
940               && !DECL_FROM_INLINE (x)
941               && TREE_CODE (oldlocal) == PARM_DECL
942               /* Don't check the `this' parameter.  */
943               && !DECL_ARTIFICIAL (oldlocal))
944             {
945               bool err = false;
946
947               /* Don't complain if it's from an enclosing function.  */
948               if (DECL_CONTEXT (oldlocal) == current_function_decl
949                   && TREE_CODE (x) != PARM_DECL)
950                 {
951                   /* Go to where the parms should be and see if we find
952                      them there.  */
953                   struct cp_binding_level *b = current_binding_level->level_chain;
954
955                   /* Skip the ctor/dtor cleanup level.  */
956                   b = b->level_chain;
957
958                   /* ARM $8.3 */
959                   if (b->kind == sk_function_parms)
960                     {
961                       error ("declaration of '%#D' shadows a parameter", x);
962                       err = true;
963                     }
964                 }
965
966               if (warn_shadow && !err)
967                 {
968                   warning ("declaration of '%#D' shadows a parameter", x);
969                   warning ("%Jshadowed declaration is here", oldlocal);
970                 }
971             }
972
973           /* Maybe warn if shadowing something else.  */
974           else if (warn_shadow && !DECL_EXTERNAL (x)
975               /* No shadow warnings for internally generated vars.  */
976               && ! DECL_ARTIFICIAL (x)
977               /* No shadow warnings for vars made for inlining.  */
978               && ! DECL_FROM_INLINE (x))
979             {
980               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
981                        && current_class_ptr
982                        && !TREE_STATIC (name))
983                 {
984                   /* Location of previous decl is not useful in this case.  */
985                   warning ("declaration of '%D' shadows a member of 'this'",
986                            x);
987                 }
988               else if (oldlocal != NULL_TREE
989                        && TREE_CODE (oldlocal) == VAR_DECL)
990                 {
991                   warning ("declaration of '%D' shadows a previous local", x);
992                   warning ("%Jshadowed declaration is here", oldlocal);
993                 }
994               else if (oldglobal != NULL_TREE
995                        && TREE_CODE (oldglobal) == VAR_DECL)
996                 /* XXX shadow warnings in outer-more namespaces */
997                 {
998                   warning ("declaration of '%D' shadows a global declaration",
999                            x);
1000                   warning ("%Jshadowed declaration is here", oldglobal);
1001                 }
1002             }
1003         }
1004
1005       if (TREE_CODE (x) == VAR_DECL)
1006         maybe_register_incomplete_var (x);
1007     }
1008
1009   if (need_new_binding)
1010     add_decl_to_level (x,
1011                        DECL_NAMESPACE_SCOPE_P (x)
1012                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1013                        : current_binding_level);
1014
1015   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1016 }
1017
1018 /* Enter DECL into the symbol table, if that's appropriate.  Returns
1019    DECL, or a modified version thereof.  */
1020
1021 tree
1022 maybe_push_decl (tree decl)
1023 {
1024   tree type = TREE_TYPE (decl);
1025
1026   /* Add this decl to the current binding level, but not if it comes
1027      from another scope, e.g. a static member variable.  TEM may equal
1028      DECL or it may be a previous decl of the same name.  */
1029   if (decl == error_mark_node
1030       || (TREE_CODE (decl) != PARM_DECL
1031           && DECL_CONTEXT (decl) != NULL_TREE
1032           /* Definitions of namespace members outside their namespace are
1033              possible.  */
1034           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1035       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1036       || TREE_CODE (type) == UNKNOWN_TYPE
1037       /* The declaration of a template specialization does not affect
1038          the functions available for overload resolution, so we do not
1039          call pushdecl.  */
1040       || (TREE_CODE (decl) == FUNCTION_DECL
1041           && DECL_TEMPLATE_SPECIALIZATION (decl)))
1042     return decl;
1043   else
1044     return pushdecl (decl);
1045 }
1046
1047 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1048    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1049    doesn't really belong to this binding level, that it got here
1050    through a using-declaration.  */
1051
1052 void
1053 push_local_binding (tree id, tree decl, int flags)
1054 {
1055   struct cp_binding_level *b;
1056
1057   /* Skip over any local classes.  This makes sense if we call
1058      push_local_binding with a friend decl of a local class.  */
1059   b = innermost_nonclass_level ();
1060
1061   if (lookup_name_current_level (id))
1062     {
1063       /* Supplement the existing binding.  */
1064       if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1065         /* It didn't work.  Something else must be bound at this
1066            level.  Do not add DECL to the list of things to pop
1067            later.  */
1068         return;
1069     }
1070   else
1071     /* Create a new binding.  */
1072     push_binding (id, decl, b);
1073
1074   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1075     /* We must put the OVERLOAD into a TREE_LIST since the
1076        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1077        decls that got here through a using-declaration.  */
1078     decl = build_tree_list (NULL_TREE, decl);
1079
1080   /* And put DECL on the list of things declared by the current
1081      binding level.  */
1082   add_decl_to_level (decl, b);
1083 }
1084
1085 /* The old ARM scoping rules injected variables declared in the
1086    initialization statement of a for-statement into the surrounding
1087    scope.  We support this usage, in order to be backward-compatible.
1088    DECL is a just-declared VAR_DECL; if necessary inject its
1089    declaration into the surrounding scope.  */
1090
1091 void
1092 maybe_inject_for_scope_var (tree decl)
1093 {
1094   timevar_push (TV_NAME_LOOKUP);
1095   if (!DECL_NAME (decl))
1096     {
1097       timevar_pop (TV_NAME_LOOKUP);
1098       return;
1099     }
1100   
1101   /* Declarations of __FUNCTION__ and its ilk appear magically when
1102      the variable is first used.  If that happens to be inside a
1103      for-loop, we don't want to do anything special.  */
1104   if (DECL_PRETTY_FUNCTION_P (decl))
1105     {
1106       timevar_pop (TV_NAME_LOOKUP);
1107       return;
1108     }
1109
1110   if (current_binding_level->kind == sk_for)
1111     {
1112       struct cp_binding_level *outer
1113         = current_binding_level->level_chain;
1114
1115       /* Check to see if the same name is already bound at the outer
1116          level, either because it was directly declared, or because a
1117          dead for-decl got preserved.  In either case, the code would
1118          not have been valid under the ARM scope rules, so clear
1119          is_for_scope for the current_binding_level.
1120
1121          Otherwise, we need to preserve the temp slot for decl to last
1122          into the outer binding level.  */
1123
1124       cxx_binding *outer_binding
1125         = IDENTIFIER_BINDING (DECL_NAME (decl))->previous;
1126
1127       if (outer_binding && outer_binding->scope == outer
1128           && (TREE_CODE (outer_binding->value) == VAR_DECL)
1129           && DECL_DEAD_FOR_LOCAL (outer_binding->value))
1130         {
1131           outer_binding->value = DECL_SHADOWED_FOR_VAR (outer_binding->value);
1132           current_binding_level->kind = sk_block;
1133         }
1134     }
1135   timevar_pop (TV_NAME_LOOKUP);
1136 }
1137
1138 /* Check to see whether or not DECL is a variable that would have been
1139    in scope under the ARM, but is not in scope under the ANSI/ISO
1140    standard.  If so, issue an error message.  If name lookup would
1141    work in both cases, but return a different result, this function
1142    returns the result of ANSI/ISO lookup.  Otherwise, it returns
1143    DECL.  */
1144
1145 tree
1146 check_for_out_of_scope_variable (tree decl)
1147 {
1148   tree shadowed;
1149
1150   /* We only care about out of scope variables.  */
1151   if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1152     return decl;
1153
1154   shadowed = DECL_SHADOWED_FOR_VAR (decl);
1155   while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1156          && DECL_DEAD_FOR_LOCAL (shadowed))
1157     shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1158   if (!shadowed)
1159     shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1160   if (shadowed)
1161     {
1162       if (!DECL_ERROR_REPORTED (decl))
1163         {
1164           warning ("name lookup of `%D' changed",
1165                       DECL_NAME (decl));
1166           cp_warning_at ("  matches this `%D' under ISO standard rules",
1167                          shadowed);
1168           cp_warning_at ("  matches this `%D' under old rules", decl);
1169           DECL_ERROR_REPORTED (decl) = 1;
1170         }
1171       return shadowed;
1172     }
1173
1174   /* If we have already complained about this declaration, there's no
1175      need to do it again.  */
1176   if (DECL_ERROR_REPORTED (decl))
1177     return decl;
1178
1179   DECL_ERROR_REPORTED (decl) = 1;
1180
1181   if (TREE_TYPE (decl) == error_mark_node)
1182     return decl;
1183
1184   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1185     {
1186       error ("name lookup of `%D' changed for new ISO `for' scoping",
1187              DECL_NAME (decl));
1188       cp_error_at ("  cannot use obsolete binding at `%D' because it has a destructor", decl);
1189       return error_mark_node;
1190     }
1191   else
1192     {
1193       pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
1194                DECL_NAME (decl));
1195       cp_pedwarn_at ("  using obsolete binding at `%D'", decl);
1196     }
1197
1198   return decl;
1199 }
1200 \f
1201 /* true means unconditionally make a BLOCK for the next level pushed.  */
1202
1203 static bool keep_next_level_flag;
1204
1205 static int binding_depth = 0;
1206 static int is_class_level = 0;
1207
1208 static void
1209 indent (int depth)
1210 {
1211   int i;
1212
1213   for (i = 0; i < depth * 2; i++)
1214     putc (' ', stderr);
1215 }
1216
1217 /* Return a string describing the kind of SCOPE we have.  */
1218 static const char *
1219 cxx_scope_descriptor (cxx_scope *scope)
1220 {
1221   /* The order of this table must match the "scope_kind"
1222      enumerators.  */
1223   static const char* scope_kind_names[] = {
1224     "block-scope",
1225     "cleanup-scope",
1226     "try-scope",
1227     "catch-scope",
1228     "for-scope",
1229     "function-parameter-scope",
1230     "class-scope",
1231     "namespace-scope",
1232     "template-parameter-scope",
1233     "template-explicit-spec-scope"
1234   };
1235   const scope_kind kind = scope->explicit_spec_p
1236     ? sk_template_spec : scope->kind;
1237
1238   return scope_kind_names[kind];
1239 }
1240
1241 /* Output a debugging information about SCOPE when performing
1242    ACTION at LINE.  */
1243 static void
1244 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1245 {
1246   const char *desc = cxx_scope_descriptor (scope);
1247   if (scope->this_entity)
1248     verbatim ("%s %s(%E) %p %d\n", action, desc,
1249               scope->this_entity, (void *) scope, line);
1250   else
1251     verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1252 }
1253
1254 /* Return the estimated initial size of the hashtable of a NAMESPACE
1255    scope.  */
1256
1257 static inline size_t
1258 namespace_scope_ht_size (tree ns)
1259 {
1260   tree name = DECL_NAME (ns);
1261
1262   return name == std_identifier
1263     ? NAMESPACE_STD_HT_SIZE
1264     : (name == global_scope_name
1265        ? GLOBAL_SCOPE_HT_SIZE
1266        : NAMESPACE_ORDINARY_HT_SIZE);
1267 }
1268
1269 /* A chain of binding_level structures awaiting reuse.  */
1270
1271 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
1272
1273 /* Create a new KIND scope and make it the top of the active scopes stack.
1274    ENTITY is the scope of the associated C++ entity (namespace, class,
1275    function); it is NULL otherwise.  */
1276
1277 cxx_scope *
1278 begin_scope (scope_kind kind, tree entity)
1279 {
1280   cxx_scope *scope;
1281   
1282   /* Reuse or create a struct for this binding level.  */
1283   if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1284     {
1285       scope = free_binding_level;
1286       free_binding_level = scope->level_chain;
1287     }
1288   else
1289     scope = ggc_alloc (sizeof (cxx_scope));
1290   memset (scope, 0, sizeof (cxx_scope));
1291
1292   scope->this_entity = entity;
1293   scope->more_cleanups_ok = true;
1294   switch (kind)
1295     {
1296     case sk_cleanup:
1297       scope->keep = true;
1298       break;
1299       
1300     case sk_template_spec:
1301       scope->explicit_spec_p = true;
1302       kind = sk_template_parms;
1303       /* Fall through.  */
1304     case sk_template_parms:
1305     case sk_block:
1306     case sk_try:
1307     case sk_catch:
1308     case sk_for:
1309     case sk_class:
1310     case sk_function_parms:
1311       scope->keep = keep_next_level_flag;
1312       break;
1313
1314     case sk_namespace:
1315       scope->type_decls = binding_table_new (namespace_scope_ht_size (entity));
1316       NAMESPACE_LEVEL (entity) = scope;
1317       VARRAY_TREE_INIT (scope->static_decls,
1318                         DECL_NAME (entity) == std_identifier
1319                         || DECL_NAME (entity) == global_scope_name
1320                         ? 200 : 10,
1321                         "Static declarations");
1322       break;
1323
1324     default:
1325       /* Should not happen.  */
1326       my_friendly_assert (false, 20030922);
1327       break;
1328     }
1329   scope->kind = kind;
1330
1331   /* Add it to the front of currently active scopes stack.  */
1332   scope->level_chain = current_binding_level;
1333   current_binding_level = scope;
1334   keep_next_level_flag = false;
1335
1336   if (ENABLE_SCOPE_CHECKING)
1337     {
1338       scope->binding_depth = binding_depth;
1339       indent (binding_depth);
1340       cxx_scope_debug (scope, input_location.line, "push");
1341       is_class_level = 0;
1342       binding_depth++;
1343     }
1344
1345   return scope;
1346 }
1347
1348 /* We're about to leave current scope.  Pop the top of the stack of
1349    currently active scopes.  Return the enclosing scope, now active.  */
1350
1351 cxx_scope *
1352 leave_scope (void)
1353 {
1354   cxx_scope *scope = current_binding_level;
1355
1356   if (scope->kind == sk_namespace && class_binding_level)
1357     current_binding_level = class_binding_level;
1358
1359   /* We cannot leave a scope, if there are none left.  */
1360   if (NAMESPACE_LEVEL (global_namespace))
1361     my_friendly_assert (!global_scope_p (scope), 20030527);
1362   
1363   if (ENABLE_SCOPE_CHECKING)
1364     {
1365       indent (--binding_depth);
1366       cxx_scope_debug (scope, input_location.line, "leave");
1367       if (is_class_level != (scope == class_binding_level))
1368         {
1369           indent (binding_depth);
1370           verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1371         }
1372       is_class_level = 0;
1373     }
1374
1375   /* Move one nesting level up.  */
1376   current_binding_level = scope->level_chain;
1377
1378   /* Namespace-scopes are left most probably temporarily, not completely;
1379      they can be reopen later, e.g. in namespace-extension or any name
1380      binding activity that requires us to resume a namespace.  For other
1381      scopes, we just make the structure available for reuse.  */
1382   if (scope->kind != sk_namespace)
1383     {
1384       scope->level_chain = free_binding_level;
1385       if (scope->kind == sk_class)
1386         scope->type_decls = NULL;
1387       else
1388         binding_table_free (scope->type_decls);
1389       my_friendly_assert (!ENABLE_SCOPE_CHECKING
1390                           || scope->binding_depth == binding_depth,
1391                           20030529);
1392       free_binding_level = scope;
1393     }
1394
1395   /* Find the innermost enclosing class scope, and reset
1396      CLASS_BINDING_LEVEL appropriately.  */
1397   for (scope = current_binding_level;
1398        scope && scope->kind != sk_class;
1399        scope = scope->level_chain)
1400     ;
1401   class_binding_level = scope && scope->kind == sk_class ? scope : NULL;
1402
1403   return current_binding_level;
1404 }
1405
1406 static void
1407 resume_scope (struct cp_binding_level* b)
1408 {
1409   /* Resuming binding levels is meant only for namespaces,
1410      and those cannot nest into classes.  */
1411   my_friendly_assert(!class_binding_level, 386);
1412   /* Also, resuming a non-directly nested namespace is a no-no.  */
1413   my_friendly_assert(b->level_chain == current_binding_level, 386);
1414   current_binding_level = b;
1415   if (ENABLE_SCOPE_CHECKING)
1416     {
1417       b->binding_depth = binding_depth;
1418       indent (binding_depth);
1419       cxx_scope_debug (b, input_location.line, "resume");
1420       is_class_level = 0;
1421       binding_depth++;
1422     }
1423 }
1424
1425 /* Return the innermost binding level that is not for a class scope.  */
1426
1427 static cxx_scope *
1428 innermost_nonclass_level (void)
1429 {
1430   cxx_scope *b;
1431
1432   b = current_binding_level;
1433   while (b->kind == sk_class)
1434     b = b->level_chain;
1435
1436   return b;
1437 }
1438
1439 /* We're defining an object of type TYPE.  If it needs a cleanup, but
1440    we're not allowed to add any more objects with cleanups to the current
1441    scope, create a new binding level.  */
1442
1443 void
1444 maybe_push_cleanup_level (tree type)
1445 {
1446   if (type != error_mark_node
1447       && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1448       && current_binding_level->more_cleanups_ok == 0)
1449     {
1450       begin_scope (sk_cleanup, NULL);
1451       clear_last_expr ();
1452       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
1453     }
1454 }
1455
1456 /* Nonzero if we are currently in the global binding level.  */
1457
1458 int
1459 global_bindings_p (void)
1460 {
1461   return global_scope_p (current_binding_level);
1462 }
1463
1464 /* True if we are currently in a toplevel binding level.  This
1465    means either the global binding level or a namespace in a toplevel
1466    binding level.  Since there are no non-toplevel namespace levels,
1467    this really means any namespace or template parameter level.  We
1468    also include a class whose context is toplevel.  */
1469
1470 bool
1471 toplevel_bindings_p (void)
1472 {
1473   struct cp_binding_level *b = innermost_nonclass_level ();
1474
1475   return b->kind == sk_namespace || b->kind == sk_template_parms;
1476 }
1477
1478 /* True if this is a namespace scope, or if we are defining a class
1479    which is itself at namespace scope, or whose enclosing class is
1480    such a class, etc.  */
1481
1482 bool
1483 namespace_bindings_p (void)
1484 {
1485   struct cp_binding_level *b = innermost_nonclass_level ();
1486
1487   return b->kind == sk_namespace;
1488 }
1489
1490 /* True if the current level needs to have a BLOCK made.  */
1491
1492 bool
1493 kept_level_p (void)
1494 {
1495   return (current_binding_level->blocks != NULL_TREE
1496           || current_binding_level->keep
1497           || current_binding_level->kind == sk_cleanup
1498           || current_binding_level->names != NULL_TREE
1499           || current_binding_level->type_decls != NULL);
1500 }
1501
1502 /* Returns the kind of the innermost scope.  */
1503
1504 scope_kind
1505 innermost_scope_kind (void)
1506 {
1507   return current_binding_level->kind;
1508 }
1509
1510 /* Returns true if this scope was created to store template parameters.  */
1511
1512 bool
1513 template_parm_scope_p (void)
1514 {
1515   return innermost_scope_kind () == sk_template_parms;
1516 }
1517
1518 /* If KEEP is true, make a BLOCK node for the next binding level,
1519    unconditionally.  Otherwise, use the normal logic to decide whether
1520    or not to create a BLOCK.  */
1521
1522 void
1523 keep_next_level (bool keep)
1524 {
1525   keep_next_level_flag = keep;
1526 }
1527
1528 /* Return the list of declarations of the current level.
1529    Note that this list is in reverse order unless/until
1530    you nreverse it; and when you do nreverse it, you must
1531    store the result back using `storedecls' or you will lose.  */
1532
1533 tree
1534 getdecls (void)
1535 {
1536   return current_binding_level->names;
1537 }
1538
1539 /* Set the current binding TABLE for type declarations..  This is a
1540    temporary workaround of the fact that the data structure classtypes
1541    does not currently carry its allocated cxx_scope structure.  */
1542 void
1543 cxx_remember_type_decls (binding_table table)
1544 {
1545   current_binding_level->type_decls = table;
1546 }
1547
1548 /* For debugging.  */
1549 static int no_print_functions = 0;
1550 static int no_print_builtins = 0;
1551
1552 /* Called from print_binding_level through binding_table_foreach to
1553    print the content of binding ENTRY.  DATA is a pointer to line offset
1554    marker.  */
1555 static void
1556 bt_print_entry (binding_entry entry, void *data)
1557 {
1558   int *p = (int *) data;
1559   int len;
1560
1561   if (entry->name == NULL)
1562     len = 3;
1563   else if (entry->name == TYPE_IDENTIFIER (entry->type))
1564     len = 2;
1565   else
1566     len = 4;
1567     len = 4;
1568
1569   *p += len;
1570
1571   if (*p > 5)
1572     {
1573       fprintf (stderr, "\n\t");
1574       *p = len;
1575     }
1576   if (entry->name == NULL)
1577     {
1578       print_node_brief (stderr, "<unnamed-typedef", entry->type, 0);
1579       fprintf (stderr, ">");
1580     }
1581   else if (entry->name == TYPE_IDENTIFIER (entry->type))
1582     print_node_brief (stderr, "", entry->type, 0);
1583   else
1584     {
1585       print_node_brief (stderr, "<typedef", entry->name, 0);
1586       print_node_brief (stderr, "", entry->type, 0);
1587       fprintf (stderr, ">");
1588     }
1589 }
1590
1591 void
1592 print_binding_level (struct cp_binding_level* lvl)
1593 {
1594   tree t;
1595   int i = 0, len;
1596   fprintf (stderr, " blocks=" HOST_PTR_PRINTF, (void *) lvl->blocks);
1597   if (lvl->more_cleanups_ok)
1598     fprintf (stderr, " more-cleanups-ok");
1599   if (lvl->have_cleanups)
1600     fprintf (stderr, " have-cleanups");
1601   fprintf (stderr, "\n");
1602   if (lvl->names)
1603     {
1604       fprintf (stderr, " names:\t");
1605       /* We can probably fit 3 names to a line?  */
1606       for (t = lvl->names; t; t = TREE_CHAIN (t))
1607         {
1608           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1609             continue;
1610           if (no_print_builtins
1611               && (TREE_CODE (t) == TYPE_DECL)
1612               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1613             continue;
1614
1615           /* Function decls tend to have longer names.  */
1616           if (TREE_CODE (t) == FUNCTION_DECL)
1617             len = 3;
1618           else
1619             len = 2;
1620           i += len;
1621           if (i > 6)
1622             {
1623               fprintf (stderr, "\n\t");
1624               i = len;
1625             }
1626           print_node_brief (stderr, "", t, 0);
1627           if (t == error_mark_node)
1628             break;
1629         }
1630       if (i)
1631         fprintf (stderr, "\n");
1632     }
1633   if (lvl->type_decls)
1634     {
1635       fprintf (stderr, " tags:\t");
1636       i = 0;
1637       binding_table_foreach (lvl->type_decls, bt_print_entry, &i);
1638       if (i)
1639         fprintf (stderr, "\n");
1640     }
1641   if (lvl->class_shadowed)
1642     {
1643       fprintf (stderr, " class-shadowed:");
1644       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1645         {
1646           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1647         }
1648       fprintf (stderr, "\n");
1649     }
1650   if (lvl->type_shadowed)
1651     {
1652       fprintf (stderr, " type-shadowed:");
1653       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1654         {
1655           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1656         }
1657       fprintf (stderr, "\n");
1658     }
1659 }
1660
1661 void
1662 print_other_binding_stack (struct cp_binding_level *stack)
1663 {
1664   struct cp_binding_level *level;
1665   for (level = stack; !global_scope_p (level); level = level->level_chain)
1666     {
1667       fprintf (stderr, "binding level " HOST_PTR_PRINTF "\n", (void *) level);
1668       print_binding_level (level);
1669     }
1670 }
1671
1672 void
1673 print_binding_stack (void)
1674 {
1675   struct cp_binding_level *b;
1676   fprintf (stderr, "current_binding_level=" HOST_PTR_PRINTF
1677            "\nclass_binding_level=" HOST_PTR_PRINTF
1678            "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF "\n",
1679            (void *) current_binding_level, (void *) class_binding_level,
1680            (void *) NAMESPACE_LEVEL (global_namespace));
1681   if (class_binding_level)
1682     {
1683       for (b = class_binding_level; b; b = b->level_chain)
1684         if (b == current_binding_level)
1685           break;
1686       if (b)
1687         b = class_binding_level;
1688       else
1689         b = current_binding_level;
1690     }
1691   else
1692     b = current_binding_level;
1693   print_other_binding_stack (b);
1694   fprintf (stderr, "global:\n");
1695   print_binding_level (NAMESPACE_LEVEL (global_namespace));
1696 }
1697 \f
1698 /* Return the type associated with id.  */
1699
1700 tree
1701 identifier_type_value (tree id)
1702 {
1703   timevar_push (TV_NAME_LOOKUP);
1704   /* There is no type with that name, anywhere.  */
1705   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1706     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1707   /* This is not the type marker, but the real thing.  */
1708   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1709     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1710   /* Have to search for it. It must be on the global level, now.
1711      Ask lookup_name not to return non-types.  */
1712   id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
1713   if (id)
1714     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1715   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1716 }
1717
1718 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1719    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
1720
1721 tree
1722 identifier_global_value (tree t)
1723 {
1724   return IDENTIFIER_GLOBAL_VALUE (t);
1725 }
1726
1727 /* Push a definition of struct, union or enum tag named ID.  into
1728    binding_level B.  DECL is a TYPE_DECL for the type.  We assume that
1729    the tag ID is not already defined.  */
1730
1731 static void
1732 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1733 {
1734   tree type;
1735
1736   if (b->kind != sk_namespace)
1737     {
1738       /* Shadow the marker, not the real thing, so that the marker
1739          gets restored later.  */
1740       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1741       b->type_shadowed
1742         = tree_cons (id, old_type_value, b->type_shadowed);
1743       type = decl ? TREE_TYPE (decl) : NULL_TREE;
1744     }
1745   else
1746     {
1747       cxx_binding *binding =
1748         binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1749       if (decl)
1750         {
1751           if (binding->value)
1752             supplement_binding (binding, decl);
1753           else
1754             binding->value = decl;
1755         }
1756       else
1757         abort ();
1758       /* Store marker instead of real type.  */
1759       type = global_type_node;
1760     }
1761   SET_IDENTIFIER_TYPE_VALUE (id, type);
1762 }
1763
1764 /* As set_identifier_type_value_with_scope, but using
1765    current_binding_level.  */
1766
1767 void
1768 set_identifier_type_value (tree id, tree decl)
1769 {
1770   set_identifier_type_value_with_scope (id, decl, current_binding_level);
1771 }
1772
1773 /* Return the name for the constructor (or destructor) for the
1774    specified class TYPE.  When given a template, this routine doesn't
1775    lose the specialization.  */
1776
1777 tree
1778 constructor_name_full (tree type)
1779 {
1780   type = TYPE_MAIN_VARIANT (type);
1781   if (CLASS_TYPE_P (type) && TYPE_WAS_ANONYMOUS (type) 
1782       && TYPE_HAS_CONSTRUCTOR (type))
1783     return DECL_NAME (OVL_CURRENT (CLASSTYPE_CONSTRUCTORS (type)));
1784   else
1785     return TYPE_IDENTIFIER (type);
1786 }
1787
1788 /* Return the name for the constructor (or destructor) for the
1789    specified class.  When given a template, return the plain
1790    unspecialized name.  */
1791
1792 tree
1793 constructor_name (tree type)
1794 {
1795   tree name;
1796   name = constructor_name_full (type);
1797   if (IDENTIFIER_TEMPLATE (name))
1798     name = IDENTIFIER_TEMPLATE (name);
1799   return name;
1800 }
1801
1802 /* Returns TRUE if NAME is the name for the constructor for TYPE.  */
1803
1804 bool
1805 constructor_name_p (tree name, tree type)
1806 {
1807   tree ctor_name;
1808
1809   if (!name)
1810     return false;
1811   
1812   if (TREE_CODE (name) != IDENTIFIER_NODE)
1813     return false;
1814   
1815   ctor_name = constructor_name_full (type);
1816   if (name == ctor_name)
1817     return true;
1818   if (IDENTIFIER_TEMPLATE (ctor_name)
1819       && name == IDENTIFIER_TEMPLATE (ctor_name))
1820     return true;
1821   return false;
1822 }
1823
1824 /* Counter used to create anonymous type names.  */
1825
1826 static GTY(()) int anon_cnt;
1827
1828 /* Return an IDENTIFIER which can be used as a name for
1829    anonymous structs and unions.  */
1830
1831 tree
1832 make_anon_name (void)
1833 {
1834   char buf[32];
1835
1836   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1837   return get_identifier (buf);
1838 }
1839
1840 /* Clear the TREE_PURPOSE slot of UTDs which have anonymous typenames.
1841    This keeps dbxout from getting confused.  */
1842
1843 void
1844 clear_anon_tags (void)
1845 {
1846   struct cp_binding_level *b;
1847   static int last_cnt = 0;
1848
1849   /* Fast out if no new anon names were declared.  */
1850   if (last_cnt == anon_cnt)
1851     return;
1852
1853   b = current_binding_level;
1854   while (b->kind == sk_cleanup)
1855     b = b->level_chain;
1856   if (b->type_decls != NULL)
1857     binding_table_remove_anonymous_types (b->type_decls);
1858   last_cnt = anon_cnt;
1859 }
1860 \f
1861 /* Return (from the stack of) the BINDING, if any, established at SCOPE.  */ 
1862
1863 static inline cxx_binding *
1864 find_binding (cxx_scope *scope, cxx_binding *binding)
1865 {
1866   timevar_push (TV_NAME_LOOKUP);
1867
1868   for (; binding != NULL; binding = binding->previous)
1869     if (binding->scope == scope)
1870       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1871
1872   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1873 }
1874
1875 /* Return the binding for NAME in SCOPE, if any.  Otherwise, return NULL.  */
1876
1877 static inline cxx_binding *
1878 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1879 {
1880   cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1881   if (b)
1882     {
1883       /* Fold-in case where NAME is used only once.  */
1884       if (scope == b->scope && b->previous == NULL)
1885         return b;
1886       return find_binding (scope, b);
1887     }
1888   return NULL;
1889 }
1890
1891 /* Always returns a binding for name in scope.  If no binding is
1892    found, make a new one.  */
1893
1894 static cxx_binding *
1895 binding_for_name (cxx_scope *scope, tree name)
1896 {
1897   cxx_binding *result;
1898
1899   result = cxx_scope_find_binding_for_name (scope, name);
1900   if (result)
1901     return result;
1902   /* Not found, make a new one.  */
1903   result = cxx_binding_make (NULL, NULL);
1904   result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1905   result->scope = scope;
1906   result->is_local = false;
1907   result->value_is_inherited = false;
1908   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1909   return result;
1910 }
1911
1912 /* Insert another USING_DECL into the current binding level, returning
1913    this declaration. If this is a redeclaration, do nothing, and
1914    return NULL_TREE if this not in namespace scope (in namespace
1915    scope, a using decl might extend any previous bindings).  */
1916
1917 tree
1918 push_using_decl (tree scope, tree name)
1919 {
1920   tree decl;
1921
1922   timevar_push (TV_NAME_LOOKUP);
1923   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
1924   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
1925   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1926     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
1927       break;
1928   if (decl)
1929     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1930                             namespace_bindings_p () ? decl : NULL_TREE);
1931   decl = build_lang_decl (USING_DECL, name, void_type_node);
1932   DECL_INITIAL (decl) = scope;
1933   TREE_CHAIN (decl) = current_binding_level->usings;
1934   current_binding_level->usings = decl;
1935   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1936 }
1937
1938 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
1939    caller to set DECL_CONTEXT properly.  */
1940
1941 tree
1942 pushdecl_with_scope (tree x, cxx_scope *level)
1943 {
1944   struct cp_binding_level *b;
1945   tree function_decl = current_function_decl;
1946
1947   timevar_push (TV_NAME_LOOKUP);
1948   current_function_decl = NULL_TREE;
1949   if (level->kind == sk_class)
1950     {
1951       b = class_binding_level;
1952       class_binding_level = level;
1953       pushdecl_class_level (x);
1954       class_binding_level = b;
1955     }
1956   else
1957     {
1958       b = current_binding_level;
1959       current_binding_level = level;
1960       x = pushdecl (x);
1961       current_binding_level = b;
1962     }
1963   current_function_decl = function_decl;
1964   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1965 }
1966
1967 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1968    other definitions already in place.  We get around this by making
1969    the value of the identifier point to a list of all the things that
1970    want to be referenced by that name.  It is then up to the users of
1971    that name to decide what to do with that list.
1972
1973    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1974    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
1975
1976    FLAGS is a bitwise-or of the following values:
1977      PUSH_LOCAL: Bind DECL in the current scope, rather than at
1978                  namespace scope.
1979      PUSH_USING: DECL is being pushed as the result of a using
1980                  declaration.
1981
1982    The value returned may be a previous declaration if we guessed wrong
1983    about what language DECL should belong to (C or C++).  Otherwise,
1984    it's always DECL (and never something that's not a _DECL).  */
1985
1986 static tree
1987 push_overloaded_decl (tree decl, int flags)
1988 {
1989   tree name = DECL_NAME (decl);
1990   tree old;
1991   tree new_binding;
1992   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1993
1994   timevar_push (TV_NAME_LOOKUP);
1995   if (doing_global)
1996     old = namespace_binding (name, DECL_CONTEXT (decl));
1997   else
1998     old = lookup_name_current_level (name);
1999
2000   if (old)
2001     {
2002       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2003         {
2004           tree t = TREE_TYPE (old);
2005           if (IS_AGGR_TYPE (t) && warn_shadow
2006               && (! DECL_IN_SYSTEM_HEADER (decl)
2007                   || ! DECL_IN_SYSTEM_HEADER (old)))
2008             warning ("`%#D' hides constructor for `%#T'", decl, t);
2009           old = NULL_TREE;
2010         }
2011       else if (is_overloaded_fn (old))
2012         {
2013           tree tmp;
2014
2015           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2016             {
2017               tree fn = OVL_CURRENT (tmp);
2018
2019               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2020                   && !(flags & PUSH_USING)
2021                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2022                                 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2023                   && ! decls_match (fn, decl))
2024                 error ("`%#D' conflicts with previous using declaration `%#D'",
2025                           decl, fn);
2026
2027               if (duplicate_decls (decl, fn) == fn)
2028                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
2029             }
2030         }
2031       else if (old == error_mark_node)
2032         /* Ignore the undefined symbol marker.  */
2033         old = NULL_TREE;
2034       else
2035         {
2036           cp_error_at ("previous non-function declaration `%#D'", old);
2037           error ("conflicts with function declaration `%#D'", decl);
2038           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2039         }
2040     }
2041
2042   if (old || TREE_CODE (decl) == TEMPLATE_DECL
2043       /* If it's a using declaration, we always need to build an OVERLOAD,
2044          because it's the only way to remember that the declaration comes
2045          from 'using', and have the lookup behave correctly.  */
2046       || (flags & PUSH_USING))
2047     {
2048       if (old && TREE_CODE (old) != OVERLOAD)
2049         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2050       else
2051         new_binding = ovl_cons (decl, old);
2052       if (flags & PUSH_USING)
2053         OVL_USED (new_binding) = 1;
2054     }
2055   else
2056     /* NAME is not ambiguous.  */
2057     new_binding = decl;
2058
2059   if (doing_global)
2060     set_namespace_binding (name, current_namespace, new_binding);
2061   else
2062     {
2063       /* We only create an OVERLOAD if there was a previous binding at
2064          this level, or if decl is a template. In the former case, we
2065          need to remove the old binding and replace it with the new
2066          binding.  We must also run through the NAMES on the binding
2067          level where the name was bound to update the chain.  */
2068
2069       if (TREE_CODE (new_binding) == OVERLOAD && old)
2070         {
2071           tree *d;
2072
2073           for (d = &IDENTIFIER_BINDING (name)->scope->names;
2074                *d;
2075                d = &TREE_CHAIN (*d))
2076             if (*d == old
2077                 || (TREE_CODE (*d) == TREE_LIST
2078                     && TREE_VALUE (*d) == old))
2079               {
2080                 if (TREE_CODE (*d) == TREE_LIST)
2081                   /* Just replace the old binding with the new.  */
2082                   TREE_VALUE (*d) = new_binding;
2083                 else
2084                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
2085                   *d = tree_cons (NULL_TREE, new_binding,
2086                                   TREE_CHAIN (*d));
2087
2088                 /* And update the cxx_binding node.  */
2089                 IDENTIFIER_BINDING (name)->value = new_binding;
2090                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2091               }
2092
2093           /* We should always find a previous binding in this case.  */
2094           abort ();
2095         }
2096
2097       /* Install the new binding.  */
2098       push_local_binding (name, new_binding, flags);
2099     }
2100
2101   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2102 }
2103
2104 /* Check a non-member using-declaration. Return the name and scope
2105    being used, and the USING_DECL, or NULL_TREE on failure.  */
2106
2107 static tree
2108 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2109 {
2110   if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2111     {
2112       /* 7.3.3/5
2113            A using-declaration shall not name a template-id.  */
2114       error ("a using-declaration cannot specify a template-id.  Try `using %D'", name);
2115       return NULL_TREE;
2116     }
2117
2118   if (TREE_CODE (decl) == NAMESPACE_DECL)
2119     {
2120       error ("namespace `%D' not allowed in using-declaration", decl);
2121       return NULL_TREE;
2122     }
2123
2124   if (TREE_CODE (decl) == SCOPE_REF)
2125     {
2126       /* It's a nested name with template parameter dependent scope.
2127          This can only be using-declaration for class member.  */
2128       error ("`%T' is not a namespace", TREE_OPERAND (decl, 0));
2129       return NULL_TREE;
2130     }
2131
2132   if (is_overloaded_fn (decl))
2133     decl = get_first_fn (decl);
2134
2135   my_friendly_assert (DECL_P (decl), 20020908);
2136
2137   /* [namespace.udecl]
2138        A using-declaration for a class member shall be a
2139        member-declaration.  */
2140   if (TYPE_P (scope))
2141     {
2142       error ("`%T' is not a namespace", scope);
2143       return NULL_TREE;
2144     }
2145
2146   /* Make a USING_DECL.  */
2147   return push_using_decl (scope, name);
2148 }
2149
2150 /* Process local and global using-declarations.  */
2151
2152 static void
2153 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2154                          tree *newval, tree *newtype)
2155 {
2156   cxx_binding decls;
2157
2158   *newval = *newtype = NULL_TREE;
2159   cxx_binding_clear (&decls);
2160   if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2161     /* Lookup error */
2162     return;
2163
2164   if (!decls.value && !decls.type)
2165     {
2166       error ("`%D' not declared", name);
2167       return;
2168     }
2169
2170   /* Check for using functions.  */
2171   if (decls.value && is_overloaded_fn (decls.value))
2172     {
2173       tree tmp, tmp1;
2174
2175       if (oldval && !is_overloaded_fn (oldval))
2176         {
2177           if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2178             error ("`%D' is already declared in this scope", name);
2179           oldval = NULL_TREE;
2180         }
2181
2182       *newval = oldval;
2183       for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2184         {
2185           tree new_fn = OVL_CURRENT (tmp);
2186
2187           /* [namespace.udecl]
2188
2189              If a function declaration in namespace scope or block
2190              scope has the same name and the same parameter types as a
2191              function introduced by a using declaration the program is
2192              ill-formed.  */
2193           for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2194             {
2195               tree old_fn = OVL_CURRENT (tmp1);
2196
2197               if (new_fn == old_fn)
2198                 /* The function already exists in the current namespace.  */
2199                 break;
2200               else if (OVL_USED (tmp1))
2201                 continue; /* this is a using decl */
2202               else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2203                                   TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2204                 {
2205                   /* There was already a non-using declaration in
2206                      this scope with the same parameter types. If both
2207                      are the same extern "C" functions, that's ok.  */
2208                   if (decls_match (new_fn, old_fn))
2209                     {
2210                       /* If the OLD_FN was a builtin, there is now a
2211                          real declaration.  */
2212                       if (DECL_ANTICIPATED (old_fn))
2213                         DECL_ANTICIPATED (old_fn) = 0;
2214                       break;
2215                     }
2216                   else if (!DECL_ANTICIPATED (old_fn))
2217                     {
2218                       /* If the OLD_FN was really declared, the
2219                          declarations don't match.  */
2220                       error ("`%D' is already declared in this scope", name);
2221                       break;
2222                     }
2223
2224                   /* If the OLD_FN was not really there, just ignore
2225                      it and keep going.  */
2226                 }
2227             }
2228
2229           /* If we broke out of the loop, there's no reason to add
2230              this function to the using declarations for this
2231              scope.  */
2232           if (tmp1)
2233             continue;
2234             
2235           /* If we are adding to an existing OVERLOAD, then we no
2236              longer know the type of the set of functions.  */
2237           if (*newval && TREE_CODE (*newval) == OVERLOAD)
2238             TREE_TYPE (*newval) = unknown_type_node;
2239           /* Add this new function to the set.  */
2240           *newval = build_overload (OVL_CURRENT (tmp), *newval);
2241           /* If there is only one function, then we use its type.  (A
2242              using-declaration naming a single function can be used in
2243              contexts where overload resolution cannot be
2244              performed.)  */
2245           if (TREE_CODE (*newval) != OVERLOAD)
2246             {
2247               *newval = ovl_cons (*newval, NULL_TREE);
2248               TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2249             }
2250           OVL_USED (*newval) = 1;
2251         }
2252     }
2253   else 
2254     {
2255       *newval = decls.value;
2256       if (oldval && !decls_match (*newval, oldval))
2257         error ("`%D' is already declared in this scope", name);
2258     }
2259
2260   *newtype = decls.type;
2261   if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2262     {
2263       error ("using declaration `%D' introduced ambiguous type `%T'",
2264                 name, oldtype);
2265       return;
2266     }
2267 }
2268
2269 /* Process a using-declaration at function scope.  */
2270
2271 void
2272 do_local_using_decl (tree decl, tree scope, tree name)
2273 {
2274   tree oldval, oldtype, newval, newtype;
2275
2276   decl = validate_nonmember_using_decl (decl, scope, name);
2277   if (decl == NULL_TREE)
2278     return;
2279
2280   if (building_stmt_tree ()
2281       && at_function_scope_p ())
2282     add_decl_stmt (decl);
2283
2284   oldval = lookup_name_current_level (name);
2285   oldtype = lookup_type_current_level (name);
2286
2287   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2288
2289   if (newval)
2290     {
2291       if (is_overloaded_fn (newval))
2292         {
2293           tree fn, term;
2294
2295           /* We only need to push declarations for those functions
2296              that were not already bound in the current level.
2297              The old value might be NULL_TREE, it might be a single
2298              function, or an OVERLOAD.  */
2299           if (oldval && TREE_CODE (oldval) == OVERLOAD)
2300             term = OVL_FUNCTION (oldval);
2301           else
2302             term = oldval;
2303           for (fn = newval; fn && OVL_CURRENT (fn) != term; 
2304                fn = OVL_NEXT (fn))
2305             push_overloaded_decl (OVL_CURRENT (fn), 
2306                                   PUSH_LOCAL | PUSH_USING);
2307         }
2308       else
2309         push_local_binding (name, newval, PUSH_USING);
2310     }
2311   if (newtype)
2312     {
2313       push_local_binding (name, newtype, PUSH_USING);
2314       set_identifier_type_value (name, newtype);
2315     }
2316 }
2317
2318 /* Return the type that should be used when TYPE's name is preceded
2319    by a tag such as 'struct' or 'union', or null if the name cannot
2320    be used in this way.
2321
2322    For example, when processing the third line of:
2323
2324         struct A;
2325         typedef struct A A;
2326         struct A;
2327
2328    lookup of A will find the typedef.  Given A's typedef, this function
2329    will return the type associated with "struct A".  For the tag to be
2330    anything other than TYPE, TYPE must be a typedef whose original type
2331    has the same name and context as TYPE itself.
2332
2333    It is not valid for a typedef of an anonymous type to be used with
2334    an explicit tag:
2335
2336        typedef struct { ... } B;
2337        struct B;
2338
2339    Return null for this case.  */
2340
2341 static tree
2342 follow_tag_typedef (tree type)
2343 {
2344   tree original;
2345
2346   original = original_type (type);
2347   if (! TYPE_NAME (original))
2348     return NULL_TREE;
2349   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
2350       && (CP_DECL_CONTEXT (TYPE_NAME (original))
2351           == CP_DECL_CONTEXT (TYPE_NAME (type)))
2352       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
2353     return original;
2354   else
2355     return NULL_TREE;
2356 }
2357
2358 /* Given NAME, an IDENTIFIER_NODE,
2359    return the structure (or union or enum) definition for that name.
2360    Searches binding levels from its SCOPE up to the global level.
2361    If THISLEVEL_ONLY is nonzero, searches only the specified context
2362    (but skips any sk_cleanup contexts to find one that is
2363    meaningful for tags).
2364    FORM says which kind of type the caller wants;
2365    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2366    If the wrong kind of type is found, and it's not a template, an error is
2367    reported.  */
2368
2369 tree
2370 lookup_tag (enum tree_code form, tree name,
2371             cxx_scope *binding_level, int thislevel_only)
2372 {
2373   struct cp_binding_level *level;
2374   /* Nonzero if, we should look past a template parameter level, even
2375      if THISLEVEL_ONLY.  */
2376   int allow_template_parms_p = 1;
2377   bool type_is_anonymous = ANON_AGGRNAME_P (name);
2378
2379   timevar_push (TV_NAME_LOOKUP);
2380   for (level = binding_level; level; level = level->level_chain)
2381     {
2382       tree tail;
2383       if (type_is_anonymous && level->type_decls != NULL)
2384         {
2385           tree type = binding_table_find_anon_type (level->type_decls, name);
2386           /* There is no need for error checking here, because
2387            anon names are unique throughout the compilation.  */
2388           if (type != NULL)
2389             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
2390         }
2391       else if (level->kind == sk_namespace)
2392         /* Do namespace lookup.  */
2393         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
2394           {
2395             cxx_binding *binding =
2396               cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (tail), name);
2397             tree old;
2398
2399             /* If we just skipped past a template parameter level,
2400                even though THISLEVEL_ONLY, and we find a template
2401                class declaration, then we use the _TYPE node for the
2402                template.  See the example below.  */
2403             if (thislevel_only && !allow_template_parms_p
2404                 && binding && binding->value
2405                 && DECL_CLASS_TEMPLATE_P (binding->value))
2406               old = binding->value;
2407             else if (binding)
2408               old = select_decl (binding, LOOKUP_PREFER_TYPES);
2409             else
2410               old = NULL_TREE;
2411
2412             if (old)
2413               {
2414                 /* We've found something at this binding level.  If it is
2415                    a typedef, extract the tag it refers to.  Lookup fails
2416                    if the typedef doesn't refer to a taggable type.  */
2417                 old = TREE_TYPE (old);
2418                 old = follow_tag_typedef (old);
2419                 if (!old)
2420                   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2421                 if (TREE_CODE (old) != form
2422                     && (form == ENUMERAL_TYPE
2423                         || TREE_CODE (old) == ENUMERAL_TYPE))
2424                   {
2425                     error ("`%#D' redeclared as %C", old, form);
2426                     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2427                   }
2428                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old);
2429               }
2430             if (thislevel_only || tail == global_namespace)
2431               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2432           }
2433       else if (level->type_decls != NULL)
2434         {
2435           binding_entry entry = binding_table_find (level->type_decls, name);
2436           if (entry != NULL)
2437             {
2438               enum tree_code code = TREE_CODE (entry->type);
2439                 
2440               if (code != form
2441                   && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
2442                 {
2443                   /* Definition isn't the kind we were looking for.  */
2444                   error ("`%#D' redeclared as %C", entry->type, form);
2445                   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2446                 }
2447               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->type);
2448             }
2449           }
2450       if (thislevel_only && level->kind != sk_cleanup)
2451         {
2452           if (level->kind == sk_template_parms && allow_template_parms_p)
2453             {
2454               /* We must deal with cases like this:
2455
2456                    template <class T> struct S;
2457                    template <class T> struct S {};
2458
2459                  When looking up `S', for the second declaration, we
2460                  would like to find the first declaration.  But, we
2461                  are in the pseudo-global level created for the
2462                  template parameters, rather than the (surrounding)
2463                  namespace level.  Thus, we keep going one more level,
2464                  even though THISLEVEL_ONLY is nonzero.  */
2465               allow_template_parms_p = 0;
2466               continue;
2467             }
2468           else
2469             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2470         }
2471     }
2472   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2473 }
2474
2475 /* Given a type, find the tag that was defined for it and return the tag name.
2476    Otherwise return 0.  However, the value can never be 0
2477    in the cases in which this is used.
2478
2479    C++: If NAME is nonzero, this is the new name to install.  This is
2480    done when replacing anonymous tags with real tag names.  */
2481
2482 tree
2483 lookup_tag_reverse (tree type, tree name)
2484 {
2485   struct cp_binding_level *level;
2486
2487   timevar_push (TV_NAME_LOOKUP);
2488   for (level = current_binding_level; level; level = level->level_chain)
2489     {
2490       binding_entry entry = level->type_decls == NULL
2491         ? NULL
2492         : binding_table_reverse_maybe_remap (level->type_decls, type, name);
2493       if (entry)
2494         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->name);
2495     }
2496   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2497 }
2498
2499 /* Returns true if ROOT (a namespace, class, or function) encloses
2500    CHILD.  CHILD may be either a class type or a namespace.  */
2501
2502 bool
2503 is_ancestor (tree root, tree child)
2504 {
2505   my_friendly_assert ((TREE_CODE (root) == NAMESPACE_DECL
2506                        || TREE_CODE (root) == FUNCTION_DECL
2507                        || CLASS_TYPE_P (root)), 20030307);
2508   my_friendly_assert ((TREE_CODE (child) == NAMESPACE_DECL
2509                        || CLASS_TYPE_P (child)),
2510                       20030307);
2511   
2512   /* The global namespace encloses everything.  */
2513   if (root == global_namespace)
2514     return true;
2515
2516   while (true)
2517     {
2518       /* If we've run out of scopes, stop.  */
2519       if (!child)
2520         return false;
2521       /* If we've reached the ROOT, it encloses CHILD.  */
2522       if (root == child)
2523         return true;
2524       /* Go out one level.  */
2525       if (TYPE_P (child))
2526         child = TYPE_NAME (child);
2527       child = DECL_CONTEXT (child);
2528     }
2529 }
2530
2531 /* Enter the class or namespace scope indicated by T.  Returns TRUE iff
2532    pop_scope should be called later to exit this scope.  */
2533
2534 bool
2535 push_scope (tree t)
2536 {
2537   bool pop = true;
2538
2539   if (TREE_CODE (t) == NAMESPACE_DECL)
2540     push_decl_namespace (t);
2541   else if (CLASS_TYPE_P (t))
2542     {
2543       if (!at_class_scope_p ()
2544           || !same_type_p (current_class_type, t))
2545         push_nested_class (t);
2546       else
2547         /* T is the same as the current scope.  There is therefore no
2548            need to re-enter the scope.  Since we are not actually
2549            pushing a new scope, our caller should not call
2550            pop_scope.  */
2551         pop = false;
2552     }
2553
2554   return pop;
2555 }
2556
2557 /* Leave scope pushed by push_scope.  */
2558
2559 void
2560 pop_scope (tree t)
2561 {
2562   if (TREE_CODE (t) == NAMESPACE_DECL)
2563     pop_decl_namespace ();
2564   else if CLASS_TYPE_P (t)
2565     pop_nested_class ();
2566 }
2567 \f
2568 /* Do a pushlevel for class declarations.  */
2569
2570 void
2571 pushlevel_class (void)
2572 {
2573   if (ENABLE_SCOPE_CHECKING)
2574     is_class_level = 1;
2575
2576   class_binding_level = begin_scope (sk_class, current_class_type);
2577 }
2578
2579 /* ...and a poplevel for class declarations.  */
2580
2581 void
2582 poplevel_class (void)
2583 {
2584   struct cp_binding_level *level = class_binding_level;
2585   tree shadowed;
2586
2587   timevar_push (TV_NAME_LOOKUP);
2588   my_friendly_assert (level != 0, 354);
2589
2590   /* If we're leaving a toplevel class, don't bother to do the setting
2591      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
2592      shouldn't even be used when current_class_type isn't set, and second,
2593      if we don't touch it here, we're able to use the cache effect if the
2594      next time we're entering a class scope, it is the same class.  */
2595   if (current_class_depth != 1)
2596     {
2597       struct cp_binding_level* b;
2598
2599       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
2600       for (shadowed = level->class_shadowed;
2601            shadowed;
2602            shadowed = TREE_CHAIN (shadowed))
2603         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
2604
2605       /* Find the next enclosing class, and recreate
2606          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
2607       b = level->level_chain;
2608       while (b && b->kind != sk_class)
2609         b = b->level_chain;
2610
2611       if (b)
2612         for (shadowed = b->class_shadowed;
2613              shadowed;
2614              shadowed = TREE_CHAIN (shadowed))
2615           {
2616             cxx_binding *binding;
2617             
2618             binding = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
2619             while (binding && binding->scope != b)
2620               binding = binding->previous;
2621
2622             if (binding)
2623               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
2624                 = binding->value;
2625           }
2626     }
2627   else
2628     /* Remember to save what IDENTIFIER's were bound in this scope so we
2629        can recover from cache misses.  */
2630     {
2631       previous_class_type = current_class_type;
2632       previous_class_values = class_binding_level->class_shadowed;
2633     }
2634   for (shadowed = level->type_shadowed;
2635        shadowed;
2636        shadowed = TREE_CHAIN (shadowed))
2637     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2638
2639   /* Remove the bindings for all of the class-level declarations.  */
2640   for (shadowed = level->class_shadowed;
2641        shadowed;
2642        shadowed = TREE_CHAIN (shadowed))
2643     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
2644
2645   /* Now, pop out of the binding level which we created up in the
2646      `pushlevel_class' routine.  */
2647   if (ENABLE_SCOPE_CHECKING)
2648     is_class_level = 1;
2649
2650   leave_scope ();
2651   timevar_pop (TV_NAME_LOOKUP);
2652 }
2653
2654 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
2655    binding was successful.  */
2656
2657 int
2658 push_class_binding (tree id, tree decl)
2659 {
2660   int result = 1;
2661   cxx_binding *binding = IDENTIFIER_BINDING (id);
2662   tree context;
2663
2664   timevar_push (TV_NAME_LOOKUP);
2665   /* Note that we declared this value so that we can issue an error if
2666      this is an invalid redeclaration of a name already used for some
2667      other purpose.  */
2668   note_name_declared_in_class (id, decl);
2669
2670   if (binding && binding->scope == class_binding_level)
2671     /* Supplement the existing binding.  */
2672     result = supplement_binding (IDENTIFIER_BINDING (id), decl);
2673   else
2674     /* Create a new binding.  */
2675     push_binding (id, decl, class_binding_level);
2676
2677   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
2678      class-level declaration.  Note that we do not use DECL here
2679      because of the possibility of the `struct stat' hack; if DECL is
2680      a class-name or enum-name we might prefer a field-name, or some
2681      such.  */
2682   IDENTIFIER_CLASS_VALUE (id) = IDENTIFIER_BINDING (id)->value;
2683
2684   /* If this is a binding from a base class, mark it as such.  */
2685   binding = IDENTIFIER_BINDING (id);
2686   if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2687     {
2688       if (TREE_CODE (decl) == OVERLOAD)
2689         context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2690       else
2691         {
2692           my_friendly_assert (DECL_P (decl), 0);
2693           context = context_for_name_lookup (decl);
2694         }
2695
2696       if (is_properly_derived_from (current_class_type, context))
2697         INHERITED_VALUE_BINDING_P (binding) = 1;
2698       else
2699         INHERITED_VALUE_BINDING_P (binding) = 0;
2700     }
2701   else if (binding->value == decl)
2702     /* We only encounter a TREE_LIST when push_class_decls detects an
2703        ambiguity.  Such an ambiguity can be overridden by a definition
2704        in this class.  */
2705     INHERITED_VALUE_BINDING_P (binding) = 1;
2706
2707   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result);
2708 }
2709
2710 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
2711    for any names in enclosing classes.  */
2712
2713 void
2714 clear_identifier_class_values (void)
2715 {
2716   tree t;
2717
2718   if (!class_binding_level)
2719     return;
2720
2721   for (t = class_binding_level->class_shadowed;
2722        t;
2723        t = TREE_CHAIN (t))
2724     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
2725 }
2726
2727 /* Make the declaration of X appear in CLASS scope.  */
2728
2729 bool
2730 pushdecl_class_level (tree x)
2731 {
2732   tree name;
2733   bool is_valid = true;
2734
2735   timevar_push (TV_NAME_LOOKUP);
2736   /* Get the name of X.  */
2737   if (TREE_CODE (x) == OVERLOAD)
2738     name = DECL_NAME (get_first_fn (x));
2739   else
2740     name = DECL_NAME (x);
2741
2742   if (name)
2743     {
2744       is_valid = push_class_level_binding (name, x);
2745       if (TREE_CODE (x) == TYPE_DECL)
2746         set_identifier_type_value (name, x);
2747     }
2748   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2749     {
2750       /* If X is an anonymous aggregate, all of its members are
2751          treated as if they were members of the class containing the
2752          aggregate, for naming purposes.  */
2753       tree f;
2754
2755       for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2756         {
2757           location_t save_location = input_location;
2758           input_location = DECL_SOURCE_LOCATION (f);
2759           if (!pushdecl_class_level (f))
2760             is_valid = false;
2761           input_location = save_location;
2762         }
2763     }
2764   timevar_pop (TV_NAME_LOOKUP);
2765
2766   return is_valid;
2767 }
2768
2769 /* Make the declaration(s) of X appear in CLASS scope under the name
2770    NAME.  Returns true if the binding is valid.  */
2771
2772 bool
2773 push_class_level_binding (tree name, tree x)
2774 {
2775   cxx_binding *binding;
2776
2777   timevar_push (TV_NAME_LOOKUP);
2778   /* The class_binding_level will be NULL if x is a template
2779      parameter name in a member template.  */
2780   if (!class_binding_level)
2781     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2782
2783   /* Make sure that this new member does not have the same name
2784      as a template parameter.  */
2785   if (TYPE_BEING_DEFINED (current_class_type))
2786     check_template_shadow (x);
2787
2788   /* [class.mem]
2789
2790      If T is the name of a class, then each of the following shall
2791      have a name different from T:
2792
2793      -- every static data member of class T;
2794
2795      -- every member of class T that is itself a type;
2796
2797      -- every enumerator of every member of class T that is an
2798         enumerated type;
2799
2800      -- every member of every anonymous union that is a member of
2801         class T.
2802
2803      (Non-static data members were also forbidden to have the same
2804      name as T until TC1.)  */
2805   if ((TREE_CODE (x) == VAR_DECL
2806        || TREE_CODE (x) == CONST_DECL
2807        || (TREE_CODE (x) == TYPE_DECL
2808            && !DECL_SELF_REFERENCE_P (x))
2809        || DECL_CLASS_TEMPLATE_P (x)
2810        /* A data member of an anonymous union.  */
2811        || (TREE_CODE (x) == FIELD_DECL
2812            && DECL_CONTEXT (x) != current_class_type))
2813       && DECL_NAME (x) == constructor_name (current_class_type))
2814     {
2815       tree scope = context_for_name_lookup (x);
2816       if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2817         {
2818           error ("`%D' has the same name as the class in which it is declared",
2819                  x);
2820           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2821         }
2822     }
2823
2824   /* If this declaration shadows a declaration from an enclosing
2825      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
2826      we leave this class.  Record the shadowed declaration here.  */
2827   binding = IDENTIFIER_BINDING (name);
2828   if (binding && binding->value)
2829     {
2830       tree bval = binding->value;
2831       tree old_decl = NULL_TREE;
2832
2833       if (INHERITED_VALUE_BINDING_P (binding))
2834         {
2835           /* If the old binding was from a base class, and was for a
2836              tag name, slide it over to make room for the new binding.
2837              The old binding is still visible if explicitly qualified
2838              with a class-key.  */
2839           if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2840               && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2841             {
2842               old_decl = binding->type;
2843               binding->type = bval;
2844               binding->value = NULL_TREE;
2845               INHERITED_VALUE_BINDING_P (binding) = 0;
2846             }
2847           else
2848             old_decl = bval;
2849         }
2850       else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2851         old_decl = bval;
2852       else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2853         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2854       else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2855         old_decl = bval;
2856       else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2857         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2858       
2859       if (old_decl)
2860         {
2861           tree shadow;
2862           
2863           /* Find the previous binding of name on the class-shadowed
2864              list, and update it.  */
2865           for (shadow = class_binding_level->class_shadowed;
2866                shadow;
2867                shadow = TREE_CHAIN (shadow))
2868             if (TREE_PURPOSE (shadow) == name
2869                 && TREE_TYPE (shadow) == old_decl)
2870               {
2871                 binding->value = x;
2872                 INHERITED_VALUE_BINDING_P (binding) = 0;
2873                 TREE_TYPE (shadow) = x;
2874                 IDENTIFIER_CLASS_VALUE (name) = x;
2875                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2876               }
2877         }
2878     }
2879
2880   /* If we didn't replace an existing binding, put the binding on the
2881      stack of bindings for the identifier, and update the shadowed list.  */
2882   if (push_class_binding (name, x))
2883     {
2884       class_binding_level->class_shadowed
2885         = tree_cons (name, NULL,
2886                      class_binding_level->class_shadowed);
2887       /* Record the value we are binding NAME to so that we can know
2888          what to pop later.  */
2889       TREE_TYPE (class_binding_level->class_shadowed) = x;
2890       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2891     }
2892
2893   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2894 }
2895
2896 tree
2897 do_class_using_decl (tree decl)
2898 {
2899   tree name, value, scope, type;
2900   
2901   if (TREE_CODE (decl) != SCOPE_REF
2902       || !TREE_OPERAND (decl, 0)
2903       || !TYPE_P (TREE_OPERAND (decl, 0)))
2904     {
2905       error ("using-declaration for non-member at class scope");
2906       return NULL_TREE;
2907     }
2908   scope = TREE_OPERAND (decl, 0);
2909   name = TREE_OPERAND (decl, 1);
2910   if (TREE_CODE (name) == BIT_NOT_EXPR)
2911     {
2912       error ("using-declaration cannot name destructor");
2913       return NULL_TREE;
2914     }
2915   if (TREE_CODE (name) == TYPE_DECL)
2916     name = DECL_NAME (name);
2917   else if (TREE_CODE (name) == TEMPLATE_DECL)
2918      name = DECL_NAME (name);
2919   else if (BASELINK_P (name))
2920     {
2921       tree fns = BASELINK_FUNCTIONS (name);
2922       name = DECL_NAME (get_first_fn (fns));
2923     }
2924
2925   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
2926
2927   /* Dependent using decls have a NULL type, non-dependent ones have a
2928      void type.  */
2929   type = dependent_type_p (scope) ? NULL_TREE : void_type_node;
2930   value = build_lang_decl (USING_DECL, name, type);
2931   DECL_INITIAL (value) = scope;
2932   return value;
2933 }
2934
2935 void
2936 set_class_shadows (tree shadows)
2937 {
2938   class_binding_level->class_shadowed = shadows;
2939 }
2940 \f
2941 /* Return the binding value for name in scope.  */
2942
2943 tree
2944 namespace_binding (tree name, tree scope)
2945 {
2946   cxx_binding *binding;
2947
2948   if (scope == NULL)
2949     scope = global_namespace;
2950   scope = ORIGINAL_NAMESPACE (scope);
2951   binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2952
2953   return binding ? binding->value : NULL_TREE;
2954 }
2955
2956 /* Set the binding value for name in scope.  */
2957
2958 void
2959 set_namespace_binding (tree name, tree scope, tree val)
2960 {
2961   cxx_binding *b;
2962
2963   timevar_push (TV_NAME_LOOKUP);
2964   if (scope == NULL_TREE)
2965     scope = global_namespace;
2966   b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2967   if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2968     b->value = val;
2969   else
2970     supplement_binding (b, val);
2971   timevar_pop (TV_NAME_LOOKUP);
2972 }
2973
2974 /* Set the context of a declaration to scope. Complain if we are not
2975    outside scope.  */
2976
2977 void
2978 set_decl_namespace (tree decl, tree scope, bool friendp)
2979 {
2980   tree old;
2981   
2982   /* Get rid of namespace aliases.  */
2983   scope = ORIGINAL_NAMESPACE (scope);
2984   
2985   /* It is ok for friends to be qualified in parallel space.  */
2986   if (!friendp && !is_ancestor (current_namespace, scope))
2987     error ("declaration of `%D' not in a namespace surrounding `%D'",
2988               decl, scope);
2989   DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2990   if (scope != current_namespace)
2991     {
2992       /* See whether this has been declared in the namespace.  */
2993       old = namespace_binding (DECL_NAME (decl), scope);
2994       if (!old)
2995         /* No old declaration at all.  */
2996         goto complain;
2997       /* A template can be explicitly specialized in any namespace.  */
2998       if (processing_explicit_instantiation)
2999         return;
3000       if (!is_overloaded_fn (decl))
3001         /* Don't compare non-function decls with decls_match here,
3002            since it can't check for the correct constness at this
3003            point. pushdecl will find those errors later.  */
3004         return;
3005       /* Since decl is a function, old should contain a function decl.  */
3006       if (!is_overloaded_fn (old))
3007         goto complain;
3008       if (processing_template_decl || processing_specialization)
3009         /* We have not yet called push_template_decl to turn a
3010            FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
3011            won't match.  But, we'll check later, when we construct the
3012            template.  */
3013         return;
3014       if (is_overloaded_fn (old))
3015         {
3016           for (; old; old = OVL_NEXT (old))
3017             if (decls_match (decl, OVL_CURRENT (old)))
3018               return;
3019         }
3020       else
3021         if (decls_match (decl, old))
3022           return;
3023     }
3024   else
3025     {
3026       /* Writing "int N::i" to declare a variable within "N" is invalid.  */
3027       if (at_namespace_scope_p ())
3028        error ("explicit qualification in declaration of `%D'", decl);
3029       return;
3030     }
3031
3032  complain:
3033   error ("`%D' should have been declared inside `%D'",
3034             decl, scope);
3035
3036
3037 /* Return the namespace where the current declaration is declared.  */
3038
3039 tree
3040 current_decl_namespace (void)
3041 {
3042   tree result;
3043   /* If we have been pushed into a different namespace, use it.  */
3044   if (decl_namespace_list)
3045     return TREE_PURPOSE (decl_namespace_list);
3046
3047   if (current_class_type)
3048     result = decl_namespace_context (current_class_type);
3049   else if (current_function_decl)
3050     result = decl_namespace_context (current_function_decl);
3051   else 
3052     result = current_namespace;
3053   return result;
3054 }
3055
3056 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
3057    select a name that is unique to this compilation unit.  */
3058
3059 void
3060 push_namespace (tree name)
3061 {
3062   tree d = NULL_TREE;
3063   int need_new = 1;
3064   int implicit_use = 0;
3065   bool anon = !name;
3066
3067   timevar_push (TV_NAME_LOOKUP);
3068   
3069   /* We should not get here if the global_namespace is not yet constructed
3070      nor if NAME designates the global namespace:  The global scope is
3071      constructed elsewhere.  */
3072   my_friendly_assert (global_namespace != NULL && name != global_scope_name,
3073                       20030531);
3074
3075   if (anon)
3076     {
3077       /* The name of anonymous namespace is unique for the translation
3078          unit.  */
3079       if (!anonymous_namespace_name)
3080         anonymous_namespace_name = get_file_function_name ('N');
3081       name = anonymous_namespace_name;
3082       d = IDENTIFIER_NAMESPACE_VALUE (name);
3083       if (d)
3084         /* Reopening anonymous namespace.  */
3085         need_new = 0;
3086       implicit_use = 1;
3087     }
3088   else
3089     {
3090       /* Check whether this is an extended namespace definition.  */
3091       d = IDENTIFIER_NAMESPACE_VALUE (name);
3092       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3093         {
3094           need_new = 0;
3095           if (DECL_NAMESPACE_ALIAS (d))
3096             {
3097               error ("namespace alias `%D' not allowed here, assuming `%D'",
3098                         d, DECL_NAMESPACE_ALIAS (d));
3099               d = DECL_NAMESPACE_ALIAS (d);
3100             }
3101         }
3102     }
3103
3104   if (need_new)
3105     {
3106       /* Make a new namespace, binding the name to it.  */
3107       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3108       DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3109       d = pushdecl (d);
3110       if (anon)
3111         {
3112           /* Clear DECL_NAME for the benefit of debugging back ends.  */
3113           SET_DECL_ASSEMBLER_NAME (d, name);
3114           DECL_NAME (d) = NULL_TREE;
3115         }
3116       begin_scope (sk_namespace, d);
3117     }
3118   else
3119     resume_scope (NAMESPACE_LEVEL (d));
3120
3121   if (implicit_use)
3122     do_using_directive (d);
3123   /* Enter the name space.  */
3124   current_namespace = d;
3125
3126   timevar_pop (TV_NAME_LOOKUP);
3127 }
3128
3129 /* Pop from the scope of the current namespace.  */
3130
3131 void
3132 pop_namespace (void)
3133 {
3134   my_friendly_assert (current_namespace != global_namespace, 20010801);
3135   current_namespace = CP_DECL_CONTEXT (current_namespace);
3136   /* The binding level is not popped, as it might be re-opened later.  */
3137   leave_scope ();
3138 }
3139
3140 /* Push into the scope of the namespace NS, even if it is deeply
3141    nested within another namespace.  */
3142
3143 void
3144 push_nested_namespace (tree ns)
3145 {
3146   if (ns == global_namespace)
3147     push_to_top_level ();
3148   else
3149     {
3150       push_nested_namespace (CP_DECL_CONTEXT (ns));
3151       push_namespace (DECL_NAME (ns));
3152     }
3153 }
3154
3155 /* Pop back from the scope of the namespace NS, which was previously
3156    entered with push_nested_namespace.  */
3157
3158 void
3159 pop_nested_namespace (tree ns)
3160 {
3161   timevar_push (TV_NAME_LOOKUP);
3162   while (ns != global_namespace)
3163     {
3164       pop_namespace ();
3165       ns = CP_DECL_CONTEXT (ns);
3166     }
3167
3168   pop_from_top_level ();
3169   timevar_pop (TV_NAME_LOOKUP);
3170 }
3171
3172 /* Temporarily set the namespace for the current declaration.  */
3173
3174 void
3175 push_decl_namespace (tree decl)
3176 {
3177   if (TREE_CODE (decl) != NAMESPACE_DECL)
3178     decl = decl_namespace_context (decl);
3179   decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3180                                    NULL_TREE, decl_namespace_list);
3181 }
3182
3183 /* [namespace.memdef]/2 */
3184
3185 void
3186 pop_decl_namespace (void)
3187 {
3188   decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3189 }
3190
3191 /* Return the namespace that is the common ancestor 
3192    of two given namespaces.  */
3193
3194 static tree
3195 namespace_ancestor (tree ns1, tree ns2)
3196 {
3197   timevar_push (TV_NAME_LOOKUP);
3198   if (is_ancestor (ns1, ns2))
3199     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3200   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3201                           namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3202 }
3203
3204 /* Process a namespace-alias declaration.  */
3205
3206 void
3207 do_namespace_alias (tree alias, tree namespace)
3208 {
3209   if (namespace == error_mark_node)
3210     return;
3211
3212   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 20050830);
3213
3214   namespace = ORIGINAL_NAMESPACE (namespace);
3215
3216   /* Build the alias.  */
3217   alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);     
3218   DECL_NAMESPACE_ALIAS (alias) = namespace;
3219   DECL_EXTERNAL (alias) = 1;
3220   DECL_CONTEXT (alias) = current_scope ();
3221   if (!DECL_CONTEXT (alias))
3222     DECL_CONTEXT (alias) = FROB_CONTEXT (current_namespace);
3223   pushdecl (alias);
3224 }
3225
3226 /* Like pushdecl, only it places X in the current namespace,
3227    if appropriate.  */
3228
3229 tree
3230 pushdecl_namespace_level (tree x)
3231 {
3232   struct cp_binding_level *b = current_binding_level;
3233   tree t;
3234
3235   timevar_push (TV_NAME_LOOKUP);
3236   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3237
3238   /* Now, the type_shadowed stack may screw us.  Munge it so it does
3239      what we want.  */
3240   if (TREE_CODE (x) == TYPE_DECL)
3241     {
3242       tree name = DECL_NAME (x);
3243       tree newval;
3244       tree *ptr = (tree *)0;
3245       for (; !global_scope_p (b); b = b->level_chain)
3246         {
3247           tree shadowed = b->type_shadowed;
3248           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3249             if (TREE_PURPOSE (shadowed) == name)
3250               {
3251                 ptr = &TREE_VALUE (shadowed);
3252                 /* Can't break out of the loop here because sometimes
3253                    a binding level will have duplicate bindings for
3254                    PT names.  It's gross, but I haven't time to fix it.  */
3255               }
3256         }
3257       newval = TREE_TYPE (x);
3258       if (ptr == (tree *)0)
3259         {
3260           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
3261              up here if this is changed to an assertion.  --KR  */
3262           SET_IDENTIFIER_TYPE_VALUE (name, x);
3263         }
3264       else
3265         {
3266           *ptr = newval;
3267         }
3268     }
3269   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3270 }
3271
3272 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3273    directive is not directly from the source. Also find the common
3274    ancestor and let our users know about the new namespace */
3275 static void 
3276 add_using_namespace (tree user, tree used, bool indirect)
3277 {
3278   tree t;
3279   timevar_push (TV_NAME_LOOKUP);
3280   /* Using oneself is a no-op.  */
3281   if (user == used)
3282     {
3283       timevar_pop (TV_NAME_LOOKUP);
3284       return;
3285     }
3286   my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
3287   my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
3288   /* Check if we already have this.  */
3289   t = purpose_member (used, DECL_NAMESPACE_USING (user));
3290   if (t != NULL_TREE)
3291     {
3292       if (!indirect)
3293         /* Promote to direct usage.  */
3294         TREE_INDIRECT_USING (t) = 0;
3295       timevar_pop (TV_NAME_LOOKUP);
3296       return;
3297     }
3298
3299   /* Add used to the user's using list.  */
3300   DECL_NAMESPACE_USING (user) 
3301     = tree_cons (used, namespace_ancestor (user, used), 
3302                  DECL_NAMESPACE_USING (user));
3303
3304   TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3305
3306   /* Add user to the used's users list.  */
3307   DECL_NAMESPACE_USERS (used)
3308     = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3309
3310   /* Recursively add all namespaces used.  */
3311   for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3312     /* indirect usage */
3313     add_using_namespace (user, TREE_PURPOSE (t), 1);
3314
3315   /* Tell everyone using us about the new used namespaces.  */
3316   for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3317     add_using_namespace (TREE_PURPOSE (t), used, 1);
3318   timevar_pop (TV_NAME_LOOKUP);
3319 }
3320
3321 /* Process a using-declaration not appearing in class or local scope.  */
3322
3323 void
3324 do_toplevel_using_decl (tree decl, tree scope, tree name)
3325 {
3326   tree oldval, oldtype, newval, newtype;
3327   cxx_binding *binding;
3328
3329   decl = validate_nonmember_using_decl (decl, scope, name);
3330   if (decl == NULL_TREE)
3331     return;
3332   
3333   binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3334
3335   oldval = binding->value;
3336   oldtype = binding->type;
3337
3338   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3339
3340   /* Copy declarations found.  */
3341   if (newval)
3342     binding->value = newval;
3343   if (newtype)
3344     binding->type = newtype;
3345   return;
3346 }
3347
3348 /* Process a using-directive.  */
3349
3350 void
3351 do_using_directive (tree namespace)
3352 {
3353   if (namespace == error_mark_node)
3354     return;
3355
3356   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 20050830);
3357
3358   if (building_stmt_tree ())
3359     add_stmt (build_stmt (USING_STMT, namespace));
3360   namespace = ORIGINAL_NAMESPACE (namespace);
3361
3362   if (!toplevel_bindings_p ())
3363     push_using_directive (namespace);
3364   else
3365     /* direct usage */
3366     add_using_namespace (current_namespace, namespace, 0);
3367 }
3368
3369 /* Deal with a using-directive seen by the parser.  Currently we only
3370    handle attributes here, since they cannot appear inside a template.  */
3371
3372 void
3373 parse_using_directive (tree namespace, tree attribs)
3374 {
3375   tree a;
3376
3377   do_using_directive (namespace);
3378
3379   for (a = attribs; a; a = TREE_CHAIN (a))
3380     {
3381       tree name = TREE_PURPOSE (a);
3382       if (is_attribute_p ("strong", name))
3383         {
3384           if (!toplevel_bindings_p ())
3385             error ("strong using only meaningful at namespace scope");
3386           else if (namespace != error_mark_node)
3387             DECL_NAMESPACE_ASSOCIATIONS (namespace)
3388               = tree_cons (current_namespace, 0,
3389                            DECL_NAMESPACE_ASSOCIATIONS (namespace));
3390         }
3391       else
3392         warning ("`%D' attribute directive ignored", name);
3393     }
3394 }
3395
3396 /* Like pushdecl, only it places X in the global scope if appropriate.
3397    Calls cp_finish_decl to register the variable, initializing it with
3398    *INIT, if INIT is non-NULL.  */
3399
3400 static tree
3401 pushdecl_top_level_1 (tree x, tree *init)
3402 {
3403   timevar_push (TV_NAME_LOOKUP);
3404   push_to_top_level ();
3405   x = pushdecl_namespace_level (x);
3406   if (init)
3407     cp_finish_decl (x, *init, NULL_TREE, 0);
3408   pop_from_top_level ();
3409   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3410 }
3411
3412 /* Like pushdecl, only it places X in the global scope if appropriate.  */
3413
3414 tree
3415 pushdecl_top_level (tree x)
3416 {
3417   return pushdecl_top_level_1 (x, NULL);
3418 }
3419
3420 /* Like pushdecl, only it places X in the global scope if
3421    appropriate.  Calls cp_finish_decl to register the variable,
3422    initializing it with INIT.  */
3423
3424 tree
3425 pushdecl_top_level_and_finish (tree x, tree init)
3426 {
3427   return pushdecl_top_level_1 (x, &init);
3428 }
3429
3430 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3431    duplicates.  The first list becomes the tail of the result.
3432
3433    The algorithm is O(n^2).  We could get this down to O(n log n) by
3434    doing a sort on the addresses of the functions, if that becomes
3435    necessary.  */
3436
3437 static tree
3438 merge_functions (tree s1, tree s2)
3439 {
3440   for (; s2; s2 = OVL_NEXT (s2))
3441     {
3442       tree fn2 = OVL_CURRENT (s2);
3443       tree fns1;
3444
3445       for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3446         {
3447           tree fn1 = OVL_CURRENT (fns1);
3448
3449           /* If the function from S2 is already in S1, there is no
3450              need to add it again.  For `extern "C"' functions, we
3451              might have two FUNCTION_DECLs for the same function, in
3452              different namespaces; again, we only need one of them.  */
3453           if (fn1 == fn2 
3454               || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3455                   && DECL_NAME (fn1) == DECL_NAME (fn2)))
3456             break;
3457         }
3458       
3459       /* If we exhausted all of the functions in S1, FN2 is new.  */
3460       if (!fns1)
3461         s1 = build_overload (fn2, s1);
3462     }
3463   return s1;
3464 }
3465
3466 /* This should return an error not all definitions define functions.
3467    It is not an error if we find two functions with exactly the
3468    same signature, only if these are selected in overload resolution.
3469    old is the current set of bindings, new the freshly-found binding.
3470    XXX Do we want to give *all* candidates in case of ambiguity?
3471    XXX In what way should I treat extern declarations?
3472    XXX I don't want to repeat the entire duplicate_decls here */
3473
3474 static cxx_binding *
3475 ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
3476 {
3477   tree val, type;
3478   my_friendly_assert (old != NULL, 393);
3479   /* Copy the value.  */
3480   val = new->value;
3481   if (val)
3482     switch (TREE_CODE (val))
3483       {
3484       case TEMPLATE_DECL:
3485         /* If we expect types or namespaces, and not templates,
3486            or this is not a template class.  */
3487         if (LOOKUP_QUALIFIERS_ONLY (flags)
3488             && !DECL_CLASS_TEMPLATE_P (val))
3489           val = NULL_TREE;
3490         break;
3491       case TYPE_DECL:
3492         if (LOOKUP_NAMESPACES_ONLY (flags))
3493           val = NULL_TREE;
3494         break;
3495       case NAMESPACE_DECL:
3496         if (LOOKUP_TYPES_ONLY (flags))
3497           val = NULL_TREE;
3498         break;
3499       case FUNCTION_DECL:
3500         /* Ignore built-in functions that are still anticipated.  */
3501         if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val))
3502           val = NULL_TREE;
3503         break;
3504       default:
3505         if (LOOKUP_QUALIFIERS_ONLY (flags))
3506           val = NULL_TREE;
3507       }
3508         
3509   if (!old->value)
3510     old->value = val;
3511   else if (val && val != old->value)
3512     {
3513       if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3514         old->value = merge_functions (old->value, val);
3515       else
3516         {
3517           /* Some declarations are functions, some are not.  */
3518           if (flags & LOOKUP_COMPLAIN)
3519             {
3520               /* If we've already given this error for this lookup,
3521                  old->value is error_mark_node, so let's not
3522                  repeat ourselves.  */
3523               if (old->value != error_mark_node)
3524                 {
3525                   error ("use of `%D' is ambiguous", name);
3526                   cp_error_at ("  first declared as `%#D' here",
3527                                old->value);
3528                 }
3529               cp_error_at ("  also declared as `%#D' here", val);
3530             }
3531           old->value = error_mark_node;
3532         }
3533     }
3534   /* ... and copy the type.  */
3535   type = new->type;
3536   if (LOOKUP_NAMESPACES_ONLY (flags))
3537     type = NULL_TREE;
3538   if (!old->type)
3539     old->type = type;
3540   else if (type && old->type != type)
3541     {
3542       if (flags & LOOKUP_COMPLAIN)
3543         {
3544           error ("`%D' denotes an ambiguous type",name);
3545           error ("%J  first type here", TYPE_MAIN_DECL (old->type));
3546           error ("%J  other type here", TYPE_MAIN_DECL (type));
3547         }
3548     }
3549   return old;
3550 }
3551
3552 /* Return the declarations that are members of the namespace NS.  */
3553
3554 tree
3555 cp_namespace_decls (tree ns)
3556 {
3557   return NAMESPACE_LEVEL (ns)->names;
3558 }
3559
3560 /* Combine prefer_type and namespaces_only into flags.  */
3561
3562 static int
3563 lookup_flags (int prefer_type, int namespaces_only)
3564 {
3565   if (namespaces_only)
3566     return LOOKUP_PREFER_NAMESPACES;
3567   if (prefer_type > 1)
3568     return LOOKUP_PREFER_TYPES;
3569   if (prefer_type > 0)
3570     return LOOKUP_PREFER_BOTH;
3571   return 0;
3572 }
3573
3574 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3575    ignore it or not.  Subroutine of lookup_name_real.  */
3576
3577 static tree
3578 qualify_lookup (tree val, int flags)
3579 {
3580   if (val == NULL_TREE)
3581     return val;
3582   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3583     return val;
3584   if ((flags & LOOKUP_PREFER_TYPES)
3585       && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3586     return val;
3587   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3588     return NULL_TREE;
3589   return val;
3590 }
3591
3592 /* Look up NAME in the NAMESPACE.  */
3593
3594 tree
3595 lookup_namespace_name (tree namespace, tree name)
3596 {
3597   tree val;
3598   tree template_id = NULL_TREE;
3599   cxx_binding binding;
3600
3601   timevar_push (TV_NAME_LOOKUP);
3602   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
3603
3604   if (TREE_CODE (name) == NAMESPACE_DECL)
3605     /* This happens for A::B<int> when B is a namespace.  */
3606     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3607   else if (TREE_CODE (name) == TEMPLATE_DECL)
3608     {
3609       /* This happens for A::B where B is a template, and there are no
3610          template arguments.  */
3611       error ("invalid use of `%D'", name);
3612       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3613     }
3614
3615   namespace = ORIGINAL_NAMESPACE (namespace);
3616
3617   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3618     {
3619       template_id = name;
3620       name = TREE_OPERAND (name, 0);
3621       if (TREE_CODE (name) == OVERLOAD)
3622         name = DECL_NAME (OVL_CURRENT (name));
3623       else if (DECL_P (name))
3624         name = DECL_NAME (name);
3625     }
3626
3627   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
3628
3629   cxx_binding_clear (&binding);
3630   if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3631     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3632
3633   if (binding.value)
3634     {
3635       val = binding.value;
3636
3637       if (template_id)
3638         {
3639           if (DECL_CLASS_TEMPLATE_P (val))
3640             val = lookup_template_class (val,
3641                                          TREE_OPERAND (template_id, 1),
3642                                          /*in_decl=*/NULL_TREE,
3643                                          /*context=*/NULL_TREE,
3644                                          /*entering_scope=*/0,
3645                                          tf_error | tf_warning);
3646           else if (DECL_FUNCTION_TEMPLATE_P (val)
3647                    || TREE_CODE (val) == OVERLOAD)
3648             val = lookup_template_function (val,
3649                                             TREE_OPERAND (template_id, 1));
3650           else
3651             {
3652               error ("`%D::%D' is not a template",
3653                         namespace, name);
3654               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3655             }
3656         }
3657
3658       /* If we have a single function from a using decl, pull it out.  */
3659       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3660         val = OVL_FUNCTION (val);
3661
3662       /* Ignore built-in functions that haven't been prototyped yet.  */
3663       if (!val || !DECL_P(val)
3664           || !DECL_LANG_SPECIFIC(val)
3665           || !DECL_ANTICIPATED (val))
3666         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3667     }
3668
3669   error ("`%D' undeclared in namespace `%D'", name, namespace);
3670   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3671 }
3672
3673 /* Select the right _DECL from multiple choices.  */
3674
3675 static tree
3676 select_decl (cxx_binding *binding, int flags)
3677 {
3678   tree val;
3679   val = binding->value;
3680
3681   timevar_push (TV_NAME_LOOKUP);
3682   if (LOOKUP_NAMESPACES_ONLY (flags))
3683     {
3684       /* We are not interested in types.  */
3685       if (val && TREE_CODE (val) == NAMESPACE_DECL)
3686         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3687       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3688     }
3689
3690   /* If looking for a type, or if there is no non-type binding, select
3691      the value binding.  */
3692   if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3693     val = binding->type;
3694   /* Don't return non-types if we really prefer types.  */
3695   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
3696            && (TREE_CODE (val) != TEMPLATE_DECL
3697                || !DECL_CLASS_TEMPLATE_P (val)))
3698     val = NULL_TREE;
3699
3700   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3701 }
3702
3703 /* Unscoped lookup of a global: iterate over current namespaces,
3704    considering using-directives.  */
3705
3706 static tree
3707 unqualified_namespace_lookup (tree name, int flags)
3708 {
3709   tree initial = current_decl_namespace ();
3710   tree scope = initial;
3711   tree siter;
3712   struct cp_binding_level *level;
3713   tree val = NULL_TREE;
3714   cxx_binding binding;
3715
3716   timevar_push (TV_NAME_LOOKUP);
3717   cxx_binding_clear (&binding);
3718
3719   for (; !val; scope = CP_DECL_CONTEXT (scope))
3720     {
3721       cxx_binding *b =
3722          cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3723
3724       if (b)
3725         {
3726           if (b->value && DECL_P (b->value)
3727               && DECL_LANG_SPECIFIC (b->value) 
3728               && DECL_ANTICIPATED (b->value))
3729             /* Ignore anticipated built-in functions.  */
3730             ;
3731           else
3732             binding.value = b->value;
3733           binding.type = b->type;
3734         }
3735
3736       /* Add all _DECLs seen through local using-directives.  */
3737       for (level = current_binding_level;
3738            level->kind != sk_namespace;
3739            level = level->level_chain)
3740         if (!lookup_using_namespace (name, &binding, level->using_directives,
3741                                      scope, flags))
3742           /* Give up because of error.  */
3743           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3744
3745       /* Add all _DECLs seen through global using-directives.  */
3746       /* XXX local and global using lists should work equally.  */
3747       siter = initial;
3748       while (1)
3749         {
3750           if (!lookup_using_namespace (name, &binding,
3751                                        DECL_NAMESPACE_USING (siter),
3752                                        scope, flags))
3753             /* Give up because of error.  */
3754             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3755           if (siter == scope) break;
3756           siter = CP_DECL_CONTEXT (siter);
3757         }
3758
3759       val = select_decl (&binding, flags);
3760       if (scope == global_namespace)
3761         break;
3762     }
3763   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3764 }
3765
3766 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3767    or a class TYPE).  If IS_TYPE_P is TRUE, then ignore non-type
3768    bindings.  
3769
3770    Returns a DECL (or OVERLOAD, or BASELINK) representing the
3771    declaration found.  If no suitable declaration can be found,
3772    ERROR_MARK_NODE is returned.  Iif COMPLAIN is true and SCOPE is
3773    neither a class-type nor a namespace a diagnostic is issued.  */
3774
3775 tree
3776 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3777 {
3778   int flags = 0;
3779
3780   if (TREE_CODE (scope) == NAMESPACE_DECL)
3781     {
3782       cxx_binding binding;
3783
3784       cxx_binding_clear (&binding);
3785       flags |= LOOKUP_COMPLAIN;
3786       if (is_type_p)
3787         flags |= LOOKUP_PREFER_TYPES;
3788       if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3789         return select_decl (&binding, flags);
3790     }
3791   else if (is_aggr_type (scope, complain))
3792     {
3793       tree t;
3794       t = lookup_member (scope, name, 0, is_type_p);
3795       if (t)
3796         return t;
3797     }
3798
3799   return error_mark_node;
3800 }
3801
3802 /* Subroutine of unqualified_namespace_lookup:
3803    Add the bindings of NAME in used namespaces to VAL.
3804    We are currently looking for names in namespace SCOPE, so we
3805    look through USINGS for using-directives of namespaces
3806    which have SCOPE as a common ancestor with the current scope.
3807    Returns false on errors.  */
3808
3809 static bool
3810 lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
3811                         int flags)
3812 {
3813   tree iter;
3814   timevar_push (TV_NAME_LOOKUP);
3815   /* Iterate over all used namespaces in current, searching for using
3816      directives of scope.  */
3817   for (iter = usings; iter; iter = TREE_CHAIN (iter))
3818     if (TREE_VALUE (iter) == scope)
3819       {
3820         tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3821         cxx_binding *val1 =
3822           cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3823         /* Resolve ambiguities.  */
3824         if (val1)
3825           val = ambiguous_decl (name, val, val1, flags);
3826       }
3827   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3828 }
3829
3830 /* [namespace.qual]
3831    Accepts the NAME to lookup and its qualifying SCOPE.
3832    Returns the name/type pair found into the cxx_binding *RESULT,
3833    or false on error.  */
3834
3835 static bool
3836 qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
3837                                   int flags)
3838 {
3839   /* Maintain a list of namespaces visited...  */
3840   tree seen = NULL_TREE;
3841   /* ... and a list of namespace yet to see.  */
3842   tree todo = NULL_TREE;
3843   tree todo_maybe = NULL_TREE;
3844   tree usings;
3845   timevar_push (TV_NAME_LOOKUP);
3846   /* Look through namespace aliases.  */
3847   scope = ORIGINAL_NAMESPACE (scope);
3848   while (scope && result->value != error_mark_node)
3849     {
3850       cxx_binding *binding =
3851         cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3852       seen = tree_cons (scope, NULL_TREE, seen);
3853       if (binding)
3854         result = ambiguous_decl (name, result, binding, flags);
3855
3856       /* Consider strong using directives always, and non-strong ones
3857          if we haven't found a binding yet.  ??? Shouldn't we consider
3858          non-strong ones if the initial RESULT is non-NULL, but the
3859          binding in the given namespace is?  */
3860       for (usings = DECL_NAMESPACE_USING (scope); usings;
3861            usings = TREE_CHAIN (usings))
3862         /* If this was a real directive, and we have not seen it.  */
3863         if (!TREE_INDIRECT_USING (usings))
3864           {
3865             /* Try to avoid queuing the same namespace more than once,
3866                the exception being when a namespace was already
3867                enqueued for todo_maybe and then a strong using is
3868                found for it.  We could try to remove it from
3869                todo_maybe, but it's probably not worth the effort.  */
3870             if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3871                 && !purpose_member (TREE_PURPOSE (usings), seen)
3872                 && !purpose_member (TREE_PURPOSE (usings), todo))
3873               todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3874             else if ((!result->value && !result->type)
3875                      && !purpose_member (TREE_PURPOSE (usings), seen)
3876                      && !purpose_member (TREE_PURPOSE (usings), todo)
3877                      && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3878               todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3879                                       todo_maybe);
3880           }
3881       if (todo)
3882         {
3883           scope = TREE_PURPOSE (todo);
3884           todo = TREE_CHAIN (todo);
3885         }
3886       else if (todo_maybe
3887                && (!result->value && !result->type))
3888         {
3889           scope = TREE_PURPOSE (todo_maybe);
3890           todo = TREE_CHAIN (todo_maybe);
3891           todo_maybe = NULL_TREE;
3892         }
3893       else
3894         scope = NULL_TREE; /* If there never was a todo list.  */
3895     }
3896   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3897 }
3898
3899 /* Look up NAME in the current binding level and its superiors in the
3900    namespace of variables, functions and typedefs.  Return a ..._DECL
3901    node of some kind representing its definition if there is only one
3902    such declaration, or return a TREE_LIST with all the overloaded
3903    definitions if there are many, or return 0 if it is undefined.
3904
3905    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3906    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3907    Otherwise we prefer non-TYPE_DECLs.
3908
3909    If NONCLASS is nonzero, we don't look for the NAME in class scope,
3910    using IDENTIFIER_CLASS_VALUE.  */
3911
3912 tree
3913 lookup_name_real (tree name, int prefer_type, int nonclass, 
3914                   int namespaces_only, int flags)
3915 {
3916   cxx_binding *iter;
3917   tree val = NULL_TREE;
3918
3919   timevar_push (TV_NAME_LOOKUP);
3920   /* Conversion operators are handled specially because ordinary
3921      unqualified name lookup will not find template conversion
3922      operators.  */
3923   if (IDENTIFIER_TYPENAME_P (name)) 
3924     {
3925       struct cp_binding_level *level;
3926
3927       for (level = current_binding_level; 
3928            level && level->kind != sk_namespace;
3929            level = level->level_chain)
3930         {
3931           tree class_type;
3932           tree operators;
3933           
3934           /* A conversion operator can only be declared in a class 
3935              scope.  */
3936           if (level->kind != sk_class)
3937             continue;
3938           
3939           /* Lookup the conversion operator in the class.  */
3940           class_type = level->this_entity;
3941           operators = lookup_fnfields (class_type, name, /*protect=*/0);
3942           if (operators)
3943             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3944         }
3945
3946       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3947     }
3948
3949   flags |= lookup_flags (prefer_type, namespaces_only);
3950
3951   /* First, look in non-namespace scopes.  */
3952
3953   if (current_class_type == NULL_TREE)
3954     nonclass = 1;
3955
3956   for (iter = IDENTIFIER_BINDING (name); iter; iter = iter->previous)
3957     {
3958       tree binding;
3959
3960       if (!LOCAL_BINDING_P (iter) && nonclass)
3961         /* We're not looking for class-scoped bindings, so keep going.  */
3962         continue;
3963
3964       /* If this is the kind of thing we're looking for, we're done.  */
3965       if (qualify_lookup (iter->value, flags))
3966         binding = iter->value;
3967       else if ((flags & LOOKUP_PREFER_TYPES)
3968                && qualify_lookup (iter->type, flags))
3969         binding = iter->type;
3970       else
3971         binding = NULL_TREE;
3972
3973       if (binding)
3974         {
3975           val = binding;
3976           break;
3977         }
3978     }
3979
3980   /* Now lookup in namespace scopes.  */
3981   if (!val)
3982     {
3983       tree t = unqualified_namespace_lookup (name, flags);
3984       if (t)
3985         val = t;
3986     }
3987
3988   if (val)
3989     {
3990       /* If we have a single function from a using decl, pull it out.  */
3991       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3992         val = OVL_FUNCTION (val);
3993     }
3994
3995   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3996 }
3997
3998 tree
3999 lookup_name_nonclass (tree name)
4000 {
4001   return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
4002 }
4003
4004 tree
4005 lookup_function_nonclass (tree name, tree args)
4006 {
4007   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
4008 }
4009
4010 tree
4011 lookup_name (tree name, int prefer_type)
4012 {
4013   return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
4014 }
4015
4016 /* Similar to `lookup_name' but look only in the innermost non-class
4017    binding level.  */
4018
4019 static tree
4020 lookup_name_current_level (tree name)
4021 {
4022   struct cp_binding_level *b;
4023   tree t = NULL_TREE;
4024
4025   timevar_push (TV_NAME_LOOKUP);
4026   b = innermost_nonclass_level ();
4027
4028   if (b->kind == sk_namespace)
4029     {
4030       t = IDENTIFIER_NAMESPACE_VALUE (name);
4031
4032       /* extern "C" function() */
4033       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4034         t = TREE_VALUE (t);
4035     }
4036   else if (IDENTIFIER_BINDING (name)
4037            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4038     {
4039       while (1)
4040         {
4041           if (IDENTIFIER_BINDING (name)->scope == b)
4042             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));
4043
4044           if (b->kind == sk_cleanup)
4045             b = b->level_chain;
4046           else
4047             break;
4048         }
4049     }
4050
4051   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4052 }
4053
4054 /* Like lookup_name_current_level, but for types.  */
4055
4056 static tree
4057 lookup_type_current_level (tree name)
4058 {
4059   tree t = NULL_TREE;
4060
4061   timevar_push (TV_NAME_LOOKUP);
4062   my_friendly_assert (current_binding_level->kind != sk_namespace, 
4063                       980716);
4064
4065   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4066       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4067     {
4068       struct cp_binding_level *b = current_binding_level;
4069       while (1)
4070         {
4071           if (purpose_member (name, b->type_shadowed))
4072             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4073                                     REAL_IDENTIFIER_TYPE_VALUE (name));
4074           if (b->kind == sk_cleanup)
4075             b = b->level_chain;
4076           else
4077             break;
4078         }
4079     }
4080
4081   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4082 }
4083
4084 /* [basic.lookup.koenig] */
4085 /* A nonzero return value in the functions below indicates an error.  */
4086
4087 struct arg_lookup
4088 {
4089   tree name;
4090   tree namespaces;
4091   tree classes;
4092   tree functions;
4093 };
4094
4095 static bool arg_assoc (struct arg_lookup*, tree);
4096 static bool arg_assoc_args (struct arg_lookup*, tree);
4097 static bool arg_assoc_type (struct arg_lookup*, tree);
4098 static bool add_function (struct arg_lookup *, tree);
4099 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4100 static bool arg_assoc_class (struct arg_lookup *, tree);
4101 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4102
4103 /* Add a function to the lookup structure.
4104    Returns true on error.  */
4105
4106 static bool
4107 add_function (struct arg_lookup *k, tree fn)
4108 {
4109   /* We used to check here to see if the function was already in the list,
4110      but that's O(n^2), which is just too expensive for function lookup.
4111      Now we deal with the occasional duplicate in joust.  In doing this, we
4112      assume that the number of duplicates will be small compared to the
4113      total number of functions being compared, which should usually be the
4114      case.  */
4115
4116   /* We must find only functions, or exactly one non-function.  */
4117   if (!k->functions) 
4118     k->functions = fn;
4119   else if (fn == k->functions)
4120     ;
4121   else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4122     k->functions = build_overload (fn, k->functions);
4123   else
4124     {
4125       tree f1 = OVL_CURRENT (k->functions);
4126       tree f2 = fn;
4127       if (is_overloaded_fn (f1))
4128         {
4129           fn = f1; f1 = f2; f2 = fn;
4130         }
4131       cp_error_at ("`%D' is not a function,", f1);
4132       cp_error_at ("  conflict with `%D'", f2);
4133       error ("  in call to `%D'", k->name);
4134       return true;
4135     }
4136
4137   return false;
4138 }
4139
4140 /* Returns true iff CURRENT has declared itself to be an associated
4141    namespace of SCOPE via a strong using-directive (or transitive chain
4142    thereof).  Both are namespaces.  */
4143
4144 bool
4145 is_associated_namespace (tree current, tree scope)
4146 {
4147   tree seen = NULL_TREE;