OSDN Git Service

* cp/cp-tree.h (struct cp_language_function): Remove x_result_rtx.
[pf3gnuchains/gcc-fork.git] / gcc / cp / decl.c
1 /* Process declarations and variables for C compiler.
2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3    Free Software Foundation, Inc.
4    Contributed by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GNU CC.
7
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.  */
22
23
24 /* Process declarations and symbol lookup for C front end.
25    Also constructs types; the standard scalar types at initialization,
26    and structure, union, array and enum types when they are declared.  */
27
28 /* ??? not all decl nodes are given the most useful possible
29    line numbers.  For example, the CONST_DECLs for enum values.  */
30
31 #include "config.h"
32 #include "system.h"
33 #include "tree.h"
34 #include "rtl.h"
35 #include "expr.h"
36 #include "flags.h"
37 #include "cp-tree.h"
38 #include "decl.h"
39 #include "lex.h"
40 #include "defaults.h"
41 #include "output.h"
42 #include "except.h"
43 #include "toplev.h"
44 #include "../hash.h"
45 #include "ggc.h"
46
47 extern int current_class_depth;
48
49 extern tree global_namespace;
50
51 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
52
53 /* Use garbage collection.  */
54
55 int ggc_p = 1;
56
57 #ifndef BOOL_TYPE_SIZE
58 #ifdef SLOW_BYTE_ACCESS
59 /* In the new ABI, `bool' has size and alignment `1', on all
60    platforms.  */
61 #define BOOL_TYPE_SIZE \
62   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
63 #else
64 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
65 #endif
66 #endif
67
68 /* We let tm.h override the types used here, to handle trivial differences
69    such as the choice of unsigned int or long unsigned int for size_t.
70    When machines start needing nontrivial differences in the size type,
71    it would be best to do something here to figure out automatically
72    from other information what type to use.  */
73
74 #ifndef SIZE_TYPE
75 #define SIZE_TYPE "long unsigned int"
76 #endif
77
78 #ifndef PTRDIFF_TYPE
79 #define PTRDIFF_TYPE "long int"
80 #endif
81
82 #ifndef WCHAR_TYPE
83 #define WCHAR_TYPE "int"
84 #endif
85
86 static tree grokparms                           PARAMS ((tree, int));
87 static const char *redeclaration_error_message  PARAMS ((tree, tree));
88
89 static void push_binding_level PARAMS ((struct binding_level *, int,
90                                       int));
91 static void pop_binding_level PARAMS ((void));
92 static void suspend_binding_level PARAMS ((void));
93 static void resume_binding_level PARAMS ((struct binding_level *));
94 static struct binding_level *make_binding_level PARAMS ((void));
95 static void declare_namespace_level PARAMS ((void));
96 static int decl_jump_unsafe PARAMS ((tree));
97 static void storedecls PARAMS ((tree));
98 static void require_complete_types_for_parms PARAMS ((tree));
99 static int ambi_op_p PARAMS ((enum tree_code));
100 static int unary_op_p PARAMS ((enum tree_code));
101 static tree store_bindings PARAMS ((tree, tree));
102 static tree lookup_tag_reverse PARAMS ((tree, tree));
103 static tree obscure_complex_init PARAMS ((tree, tree));
104 static tree lookup_name_real PARAMS ((tree, int, int, int));
105 static void warn_extern_redeclared_static PARAMS ((tree, tree));
106 static void grok_reference_init PARAMS ((tree, tree, tree));
107 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
108                               enum overload_flags, tree,
109                               tree, int, int, int, int, int, int, tree));
110 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
111 static tree lookup_tag PARAMS ((enum tree_code, tree,
112                               struct binding_level *, int));
113 static void set_identifier_type_value_with_scope
114         PARAMS ((tree, tree, struct binding_level *));
115 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
116 static void record_unknown_type PARAMS ((tree, const char *));
117 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
118 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
119 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
120                                   int));
121 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
122 static void check_for_uninitialized_const_var PARAMS ((tree));
123 static unsigned long typename_hash PARAMS ((hash_table_key));
124 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
125 static void push_binding PARAMS ((tree, tree, struct binding_level*));
126 static int add_binding PARAMS ((tree, tree));
127 static void pop_binding PARAMS ((tree, tree));
128 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
129 static tree find_binding PARAMS ((tree, tree));
130 static tree select_decl PARAMS ((tree, int));
131 static int lookup_flags PARAMS ((int, int));
132 static tree qualify_lookup PARAMS ((tree, int));
133 static tree record_builtin_java_type PARAMS ((const char *, int));
134 static const char *tag_name PARAMS ((enum tag_types code));
135 static void find_class_binding_level PARAMS ((void));
136 static struct binding_level *innermost_nonclass_level PARAMS ((void));
137 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
138 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
139 static int walk_globals_r PARAMS ((tree, void *));
140 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
141 static tree make_label_decl PARAMS ((tree, int));
142 static void use_label PARAMS ((tree));
143 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
144                                            const char *, int));
145 static void check_previous_goto PARAMS ((struct named_label_use_list *));
146 static void check_switch_goto PARAMS ((struct binding_level *));
147 static void check_previous_gotos PARAMS ((tree));
148 static void pop_label PARAMS ((tree, tree));
149 static void pop_labels PARAMS ((tree));
150 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
151 static void layout_var_decl PARAMS ((tree));
152 static void maybe_commonize_var PARAMS ((tree));
153 static tree check_initializer PARAMS ((tree, tree));
154 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
155 static void push_cp_function_context PARAMS ((struct function *));
156 static void pop_cp_function_context PARAMS ((struct function *));
157 static void mark_binding_level PARAMS ((void *));
158 static void mark_named_label_lists PARAMS ((void *, void *));
159 static void mark_cp_function_context PARAMS ((struct function *));
160 static void mark_saved_scope PARAMS ((void *));
161 static void mark_lang_function PARAMS ((struct cp_language_function *));
162 static void save_function_data PARAMS ((tree));
163 static void check_function_type PARAMS ((tree, tree));
164 static void destroy_local_var PARAMS ((tree));
165 static void finish_constructor_body PARAMS ((void));
166 static void finish_destructor_body PARAMS ((void));
167 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
168 static tree get_atexit_node PARAMS ((void));
169 static tree get_dso_handle_node PARAMS ((void));
170 static tree start_cleanup_fn PARAMS ((void));
171 static void end_cleanup_fn PARAMS ((void));
172 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
173 static void initialize_predefined_identifiers PARAMS ((void));
174 static tree check_special_function_return_type 
175   PARAMS ((special_function_kind, tree, tree, tree));
176 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
177 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
178 static void store_parm_decls PARAMS ((tree));
179
180 #if defined (DEBUG_CP_BINDING_LEVELS)
181 static void indent PARAMS ((void));
182 #endif
183
184 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
185 tree error_mark_list;
186
187 /* The following symbols are subsumed in the cp_global_trees array, and
188    listed here individually for documentation purposes.
189
190    C++ extensions
191         tree wchar_decl_node;
192
193         tree vtable_entry_type;
194         tree delta_type_node;
195 #if 0
196    Old rtti stuff.
197         tree __baselist_desc_type_node;
198         tree __i_desc_type_node, __m_desc_type_node;
199         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
200 #endif
201         tree __t_desc_type_node;
202 #if 0
203         tree __tp_desc_type_node;
204 #endif
205         tree ti_desc_type_node;
206         tree bltn_desc_type_node, ptr_desc_type_node;
207         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
208         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
209         tree ptm_desc_type_node;
210         tree base_desc_type_node;
211 #if 0
212    Not needed yet?  May be needed one day?
213         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
214         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
215         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
216 #endif
217
218         tree class_type_node, record_type_node, union_type_node, enum_type_node;
219         tree unknown_type_node;
220
221    Array type `vtable_entry_type[]'
222
223         tree vtbl_type_node;
224         tree vtbl_ptr_type_node;
225
226    Namespaces,
227
228         tree std_node;
229         tree abi_node;
230
231    A FUNCTION_DECL which can call `abort'.  Not necessarily the
232    one that the user will declare, but sufficient to be called
233    by routines that want to abort the program.
234
235         tree abort_fndecl;
236
237    The FUNCTION_DECL for the default `::operator delete'.
238
239         tree global_delete_fndecl;
240
241    Used by RTTI
242         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
243         tree tinfo_var_id;
244
245 */
246
247 tree cp_global_trees[CPTI_MAX];
248
249 /* Indicates that there is a type value in some namespace, although
250    that is not necessarily in scope at the moment.  */
251
252 static tree global_type_node;
253
254 /* Namespace std.  */
255 int in_std;
256
257 /* Expect only namespace names now. */
258 static int only_namespace_names;
259
260 /* Used only for jumps to as-yet undefined labels, since jumps to
261    defined labels can have their validity checked immediately.  */
262
263 struct named_label_use_list
264 {
265   struct binding_level *binding_level;
266   tree names_in_scope;
267   tree label_decl;
268   const char *filename_o_goto;
269   int lineno_o_goto;
270   struct named_label_use_list *next;
271 };
272
273 #define named_label_uses cp_function_chain->x_named_label_uses
274
275 /* A list of objects which have constructors or destructors
276    which reside in the global scope.  The decl is stored in
277    the TREE_VALUE slot and the initializer is stored
278    in the TREE_PURPOSE slot.  */
279 tree static_aggregates;
280
281 /* -- end of C++ */
282
283 /* A node for the integer constants 2, and 3.  */
284
285 tree integer_two_node, integer_three_node;
286
287 /* Parsing a function declarator leaves here a chain of structure
288    and enum types declared in the parmlist.  */
289
290 static tree last_function_parm_tags;
291
292 /* Similar, for last_function_parm_tags.  */
293 tree last_function_parms;
294 static tree current_function_parm_tags;
295
296 /* A list of all LABEL_DECLs in the function that have names.  Here so
297    we can clear out their names' definitions at the end of the
298    function, and so we can check the validity of jumps to these labels.  */
299
300 struct named_label_list
301 {
302   struct binding_level *binding_level;
303   tree names_in_scope;
304   tree old_value;
305   tree label_decl;
306   tree bad_decls;
307   int eh_region;
308   struct named_label_list *next;
309 };
310
311 #define named_labels cp_function_chain->x_named_labels
312
313 /* Set to 0 at beginning of a function definition, and whenever
314    a label (case or named) is defined.  Set to value of expression
315    returned from function when that value can be transformed into
316    a named return value.  */
317
318 tree current_function_return_value;
319
320 /* Nonzero means use the ISO C94 dialect of C.  */
321
322 int flag_isoc94;
323
324 /* Nonzero means use the ISO C99 dialect of C.  */
325
326 int flag_isoc99;
327
328 /* Nonzero means we are a hosted implementation for code shared with C.  */
329
330 int flag_hosted = 1;
331
332 /* Nonzero means add default format_arg attributes for functions not
333    in ISO C.  */
334
335 int flag_noniso_default_format_attributes = 1;
336
337 /* Nonzero means give `double' the same size as `float'.  */
338
339 extern int flag_short_double;
340
341 /* Nonzero means don't recognize any builtin functions.  */
342
343 extern int flag_no_builtin;
344
345 /* Nonzero means don't recognize the non-ANSI builtin functions.
346    -ansi sets this.  */
347
348 extern int flag_no_nonansi_builtin;
349
350 /* Nonzero if we want to conserve space in the .o files.  We do this
351    by putting uninitialized data and runtime initialized data into
352    .common instead of .data at the expense of not flagging multiple
353    definitions.  */
354 extern int flag_conserve_space;
355 \f
356 /* C and C++ flags are in decl2.c.  */
357
358 /* Flag used when debugging spew.c */
359
360 extern int spew_debug;
361
362 /* A expression of value 0 with the same precision as a sizetype
363    node, but signed.  */
364 tree signed_size_zero_node;
365
366 /* The name of the anonymous namespace, throughout this translation
367    unit.  */
368 tree anonymous_namespace_name;
369
370 /* The number of function bodies which we are currently processing.
371    (Zero if we are at namespace scope, one inside the body of a
372    function, two inside the body of a function in a local class, etc.)  */
373 int function_depth;
374 \f
375 /* For each binding contour we allocate a binding_level structure
376    which records the names defined in that contour.
377    Contours include:
378     0) the global one
379     1) one for each function definition,
380        where internal declarations of the parameters appear.
381     2) one for each compound statement,
382        to record its declarations.
383
384    The current meaning of a name can be found by searching the levels
385    from the current one out to the global one.
386
387    Off to the side, may be the class_binding_level.  This exists only
388    to catch class-local declarations.  It is otherwise nonexistent.
389
390    Also there may be binding levels that catch cleanups that must be
391    run when exceptions occur.  Thus, to see whether a name is bound in
392    the current scope, it is not enough to look in the
393    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
394    instead.  */
395
396 /* Note that the information in the `names' component of the global contour
397    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
398
399 struct binding_level
400   {
401     /* A chain of _DECL nodes for all variables, constants, functions,
402        and typedef types.  These are in the reverse of the order
403        supplied.  There may be OVERLOADs on this list, too, but they
404        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
405     tree names;
406
407     /* A list of structure, union and enum definitions, for looking up
408        tag names.
409        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
410        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
411        or ENUMERAL_TYPE node.
412
413        C++: the TREE_VALUE nodes can be simple types for
414        component_bindings.  */
415     tree tags;
416
417     /* A list of USING_DECL nodes. */
418     tree usings;
419
420     /* A list of used namespaces. PURPOSE is the namespace,
421        VALUE the common ancestor with this binding_level's namespace. */
422     tree using_directives;
423
424     /* If this binding level is the binding level for a class, then
425        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
426        is the name of an entity bound in the class; the TREE_VALUE is
427        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
428        when leaving class scope, we can restore the
429        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
430        the DECL bound by this name in the class.  */
431     tree class_shadowed;
432
433     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
434        is used for all binding levels.  */
435     tree type_shadowed;
436
437     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
438        label in this scope.  The TREE_PURPOSE is the previous value of
439        the IDENTIFIER_LABEL VALUE.  */
440     tree shadowed_labels;
441
442     /* For each level (except not the global one),
443        a chain of BLOCK nodes for all the levels
444        that were entered and exited one level down.  */
445     tree blocks;
446
447     /* The _TYPE node for this level, if parm_flag == 2.  */
448     tree this_class;
449
450     /* The binding level which this one is contained in (inherits from).  */
451     struct binding_level *level_chain;
452
453     /* List of decls in `names' that have incomplete
454        structure or union types.  */
455     tree incomplete;
456
457     /* List of VAR_DECLS saved from a previous for statement.
458        These would be dead in ISO-conforming code, but might
459        be referenced in ARM-era code.  These are stored in a
460        TREE_LIST; the TREE_VALUE is the actual declaration.  */
461     tree dead_vars_from_for;
462
463     /* 1 for the level that holds the parameters of a function.
464        2 for the level that holds a class declaration.  */
465     unsigned parm_flag : 2;
466
467     /* 1 means make a BLOCK for this level regardless of all else.
468        2 for temporary binding contours created by the compiler.  */
469     unsigned keep : 2;
470
471     /* Nonzero if this level "doesn't exist" for tags.  */
472     unsigned tag_transparent : 1;
473
474     /* Nonzero if this level can safely have additional
475        cleanup-needing variables added to it.  */
476     unsigned more_cleanups_ok : 1;
477     unsigned have_cleanups : 1;
478
479     /* Nonzero if this scope is for storing the decls for template
480        parameters and generic decls; these decls will be discarded and
481        replaced with a TEMPLATE_DECL.  */
482     unsigned template_parms_p : 1;
483
484     /* Nonzero if this scope corresponds to the `<>' in a 
485        `template <>' clause.  Whenever this flag is set,
486        TEMPLATE_PARMS_P will be set as well.  */
487     unsigned template_spec_p : 1;
488
489     /* This is set for a namespace binding level.  */
490     unsigned namespace_p : 1;
491
492     /* True if this level is that of a for-statement where we need to
493        worry about ambiguous (ARM or ISO) scope rules.  */
494     unsigned is_for_scope : 1;
495
496     /* True if this level corresponds to an EH region, as for a try block.
497        Currently this information is only available while building the
498        tree structure.  */
499     unsigned eh_region : 1;
500
501     /* Four bits left for this word.  */
502
503 #if defined(DEBUG_CP_BINDING_LEVELS)
504     /* Binding depth at which this level began.  */
505     unsigned binding_depth;
506 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
507   };
508
509 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
510
511 /* The binding level currently in effect.  */
512
513 #define current_binding_level                   \
514   (cfun                                         \
515    ? cp_function_chain->bindings                \
516    : scope_chain->bindings)
517
518 /* The binding level of the current class, if any.  */
519
520 #define class_binding_level scope_chain->class_bindings
521
522 /* A chain of binding_level structures awaiting reuse.  */
523
524 static struct binding_level *free_binding_level;
525
526 /* The outermost binding level, for names of file scope.
527    This is created when the compiler is started and exists
528    through the entire run.  */
529
530 static struct binding_level *global_binding_level;
531
532 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
533
534 static int keep_next_level_flag;
535
536 #if defined(DEBUG_CP_BINDING_LEVELS)
537 static int binding_depth = 0;
538 static int is_class_level = 0;
539
540 static void
541 indent ()
542 {
543   register unsigned i;
544
545   for (i = 0; i < binding_depth*2; i++)
546     putc (' ', stderr);
547 }
548 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
549
550 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
551
552 static void
553 push_binding_level (newlevel, tag_transparent, keep)
554      struct binding_level *newlevel;
555      int tag_transparent, keep;
556 {
557   /* Add this level to the front of the chain (stack) of levels that
558      are active.  */
559   bzero ((char*) newlevel, sizeof (struct binding_level));
560   newlevel->level_chain = current_binding_level;
561   current_binding_level = newlevel;
562   newlevel->tag_transparent = tag_transparent;
563   newlevel->more_cleanups_ok = 1;
564
565   newlevel->keep = keep;
566 #if defined(DEBUG_CP_BINDING_LEVELS)
567   newlevel->binding_depth = binding_depth;
568   indent ();
569   fprintf (stderr, "push %s level 0x%08x line %d\n",
570            (is_class_level) ? "class" : "block", newlevel, lineno);
571   is_class_level = 0;
572   binding_depth++;
573 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
574 }
575
576 /* Find the innermost enclosing class scope, and reset
577    CLASS_BINDING_LEVEL appropriately.  */
578
579 static void
580 find_class_binding_level ()
581 {
582   struct binding_level *level = current_binding_level;
583
584   while (level && level->parm_flag != 2)
585     level = level->level_chain;
586   if (level && level->parm_flag == 2)
587     class_binding_level = level;
588   else
589     class_binding_level = 0;
590 }
591
592 static void
593 pop_binding_level ()
594 {
595   if (global_binding_level)
596     {
597       /* Cannot pop a level, if there are none left to pop.  */
598       if (current_binding_level == global_binding_level)
599         my_friendly_abort (123);
600     }
601   /* Pop the current level, and free the structure for reuse.  */
602 #if defined(DEBUG_CP_BINDING_LEVELS)
603   binding_depth--;
604   indent ();
605   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
606           (is_class_level) ? "class" : "block",
607           current_binding_level, lineno);
608   if (is_class_level != (current_binding_level == class_binding_level))
609     {
610       indent ();
611       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
612     }
613   is_class_level = 0;
614 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
615   {
616     register struct binding_level *level = current_binding_level;
617     current_binding_level = current_binding_level->level_chain;
618     level->level_chain = free_binding_level;
619 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
620     if (level->binding_depth != binding_depth)
621       abort ();
622 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
623     free_binding_level = level;
624     find_class_binding_level ();
625   }
626 }
627
628 static void
629 suspend_binding_level ()
630 {
631   if (class_binding_level)
632     current_binding_level = class_binding_level;
633
634   if (global_binding_level)
635     {
636       /* Cannot suspend a level, if there are none left to suspend.  */
637       if (current_binding_level == global_binding_level)
638         my_friendly_abort (123);
639     }
640   /* Suspend the current level.  */
641 #if defined(DEBUG_CP_BINDING_LEVELS)
642   binding_depth--;
643   indent ();
644   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
645           (is_class_level) ? "class" : "block",
646           current_binding_level, lineno);
647   if (is_class_level != (current_binding_level == class_binding_level))
648     {
649       indent ();
650       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
651     }
652   is_class_level = 0;
653 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
654   current_binding_level = current_binding_level->level_chain;
655   find_class_binding_level ();
656 }
657
658 static void
659 resume_binding_level (b)
660      struct binding_level *b;
661 {
662   /* Resuming binding levels is meant only for namespaces,
663      and those cannot nest into classes. */
664   my_friendly_assert(!class_binding_level, 386);
665   /* Also, resuming a non-directly nested namespace is a no-no.  */
666   my_friendly_assert(b->level_chain == current_binding_level, 386);
667   current_binding_level = b;
668 #if defined(DEBUG_CP_BINDING_LEVELS)
669   b->binding_depth = binding_depth;
670   indent ();
671   fprintf (stderr, "resume %s level 0x%08x line %d\n",
672            (is_class_level) ? "class" : "block", b, lineno);
673   is_class_level = 0;
674   binding_depth++;
675 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
676 }
677 \f
678 /* Create a new `struct binding_level'.  */
679
680 static
681 struct binding_level *
682 make_binding_level ()
683 {
684   /* NOSTRICT */
685   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
686 }
687
688 /* Nonzero if we are currently in the global binding level.  */
689
690 int
691 global_bindings_p ()
692 {
693   return current_binding_level == global_binding_level;
694 }
695
696 /* Return the innermost binding level that is not for a class scope.  */
697
698 static struct binding_level *
699 innermost_nonclass_level ()
700 {
701   struct binding_level *b;
702
703   b = current_binding_level;
704   while (b->parm_flag == 2)
705     b = b->level_chain;
706
707   return b;
708 }
709
710 /* Nonzero if we are currently in a toplevel binding level.  This
711    means either the global binding level or a namespace in a toplevel
712    binding level.  Since there are no non-toplevel namespace levels,
713    this really means any namespace or template parameter level.  We
714    also include a class whose context is toplevel.  */
715
716 int
717 toplevel_bindings_p ()
718 {
719   struct binding_level *b = innermost_nonclass_level ();
720
721   return b->namespace_p || b->template_parms_p;
722 }
723
724 /* Nonzero if this is a namespace scope, or if we are defining a class
725    which is itself at namespace scope, or whose enclosing class is
726    such a class, etc.  */
727
728 int
729 namespace_bindings_p ()
730 {
731   struct binding_level *b = innermost_nonclass_level ();
732
733   return b->namespace_p;
734 }
735
736 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
737    unconditionally.  Otherwise, use the normal logic to decide whether
738    or not to create a BLOCK.  */
739
740 void
741 keep_next_level (keep)
742      int keep;
743 {
744   keep_next_level_flag = keep;
745 }
746
747 /* Nonzero if the current level needs to have a BLOCK made.  */
748
749 int
750 kept_level_p ()
751 {
752   return (current_binding_level->blocks != NULL_TREE
753           || current_binding_level->keep
754           || current_binding_level->names != NULL_TREE
755           || (current_binding_level->tags != NULL_TREE
756               && !current_binding_level->tag_transparent));
757 }
758
759 static void
760 declare_namespace_level ()
761 {
762   current_binding_level->namespace_p = 1;
763 }
764
765 /* Returns non-zero if this scope was created to store template
766    parameters.  */
767
768 int
769 template_parm_scope_p ()
770 {
771   return current_binding_level->template_parms_p;
772 }
773
774 /* Returns the kind of template specialization we are currently
775    processing, given that it's declaration contained N_CLASS_SCOPES
776    explicit scope qualifications.  */
777
778 tmpl_spec_kind
779 current_tmpl_spec_kind (n_class_scopes)
780      int n_class_scopes;
781 {
782   int n_template_parm_scopes = 0;
783   int seen_specialization_p = 0;
784   int innermost_specialization_p = 0;
785   struct binding_level *b;
786
787   /* Scan through the template parameter scopes.  */
788   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
789     {
790       /* If we see a specialization scope inside a parameter scope,
791          then something is wrong.  That corresponds to a declaration
792          like:
793
794             template <class T> template <> ...
795
796          which is always illegal since [temp.expl.spec] forbids the
797          specialization of a class member template if the enclosing
798          class templates are not explicitly specialized as well.  */
799       if (b->template_spec_p)
800         {
801           if (n_template_parm_scopes == 0)
802             innermost_specialization_p = 1;
803           else
804             seen_specialization_p = 1;
805         }
806       else if (seen_specialization_p == 1)
807         return tsk_invalid_member_spec;
808
809       ++n_template_parm_scopes;
810     }
811
812   /* Handle explicit instantiations.  */
813   if (processing_explicit_instantiation)
814     {
815       if (n_template_parm_scopes != 0)
816         /* We've seen a template parameter list during an explicit
817            instantiation.  For example:
818
819              template <class T> template void f(int);
820
821            This is erroneous.  */
822         return tsk_invalid_expl_inst;
823       else
824         return tsk_expl_inst;
825     }
826
827   if (n_template_parm_scopes < n_class_scopes)
828     /* We've not seen enough template headers to match all the
829        specialized classes present.  For example:
830
831          template <class T> void R<T>::S<T>::f(int);
832
833        This is illegal; there needs to be one set of template
834        parameters for each class.  */
835     return tsk_insufficient_parms;
836   else if (n_template_parm_scopes == n_class_scopes)
837     /* We're processing a non-template declaration (even though it may
838        be a member of a template class.)  For example:
839
840          template <class T> void S<T>::f(int);
841
842        The `class T' maches the `S<T>', leaving no template headers
843        corresponding to the `f'.  */
844     return tsk_none;
845   else if (n_template_parm_scopes > n_class_scopes + 1)
846     /* We've got too many template headers.  For example:
847
848          template <> template <class T> void f (T);
849
850        There need to be more enclosing classes.  */
851     return tsk_excessive_parms;
852   else
853     /* This must be a template.  It's of the form:
854
855          template <class T> template <class U> void S<T>::f(U);
856
857        This is a specialization if the innermost level was a
858        specialization; otherwise it's just a definition of the
859        template.  */
860     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
861 }
862
863 void
864 set_class_shadows (shadows)
865      tree shadows;
866 {
867   class_binding_level->class_shadowed = shadows;
868 }
869
870 /* Enter a new binding level.
871    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
872    not for that of tags.  */
873
874 void
875 pushlevel (tag_transparent)
876      int tag_transparent;
877 {
878   struct binding_level *newlevel;
879
880   if (cfun && !doing_semantic_analysis_p ())
881     return;
882
883   /* Reuse or create a struct for this binding level.  */
884 #if defined(DEBUG_CP_BINDING_LEVELS)
885   if (0)
886 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
887   if (free_binding_level)
888 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
889     {
890       newlevel = free_binding_level;
891       free_binding_level = free_binding_level->level_chain;
892     }
893   else
894     newlevel = make_binding_level ();
895
896   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
897   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
898   keep_next_level_flag = 0;
899 }
900
901 /* Enter a new scope.  The KIND indicates what kind of scope is being
902    created.  */
903
904 void
905 begin_scope (sk)
906      scope_kind sk;
907 {
908   pushlevel (0);
909
910   switch (sk)
911     {
912     case sk_template_spec:
913       current_binding_level->template_spec_p = 1;
914       /* Fall through.  */
915
916     case sk_template_parms:
917       current_binding_level->template_parms_p = 1;
918       break;
919
920     default:
921       my_friendly_abort (20000309);
922     }
923 }
924
925 /* Exit the current scope.  */
926
927 void
928 finish_scope ()
929 {
930   poplevel (0, 0, 0);
931 }
932
933 void
934 note_level_for_for ()
935 {
936   current_binding_level->is_for_scope = 1;
937 }
938
939 /* Record that the current binding level represents a try block.  */
940
941 void
942 note_level_for_eh ()
943 {
944   current_binding_level->eh_region = 1;
945 }
946
947 /* For a binding between a name and an entity at a block scope,
948    this is the `struct binding_level' for the block.  */
949 #define BINDING_LEVEL(NODE) \
950    (((struct tree_binding*)NODE)->scope.level)
951
952 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
953    level at which this declaration is being bound.  */
954
955 static void
956 push_binding (id, decl, level)
957      tree id;
958      tree decl;
959      struct binding_level* level;
960 {
961   tree binding;
962
963   binding = make_node (CPLUS_BINDING);
964
965   /* Now, fill in the binding information.  */
966   BINDING_VALUE (binding) = decl;
967   BINDING_TYPE (binding) = NULL_TREE;
968   BINDING_LEVEL (binding) = level;
969   INHERITED_VALUE_BINDING_P (binding) = 0;
970   LOCAL_BINDING_P (binding) = (level != class_binding_level);
971   BINDING_HAS_LEVEL_P (binding) = 1;
972
973   /* And put it on the front of the list of bindings for ID.  */
974   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
975   IDENTIFIER_BINDING (id) = binding;
976 }
977
978 /* ID is already bound in the current scope.  But, DECL is an
979    additional binding for ID in the same scope.  This is the `struct
980    stat' hack whereby a non-typedef class-name or enum-name can be
981    bound at the same level as some other kind of entity.  It's the
982    responsibility of the caller to check that inserting this name is
983    legal here.  Returns nonzero if the new binding was successful.  */
984 static int
985 add_binding (id, decl)
986      tree id;
987      tree decl;
988 {
989   tree binding = IDENTIFIER_BINDING (id);
990   int ok = 1;
991
992   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
993     /* The new name is the type name.  */
994     BINDING_TYPE (binding) = decl;
995   else if (!BINDING_VALUE (binding))
996     /* This situation arises when push_class_level_binding moves an
997        inherited type-binding out of the way to make room for a new
998        value binding.  */
999     BINDING_VALUE (binding) = decl;
1000   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1001            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1002     {
1003       /* The old binding was a type name.  It was placed in
1004          BINDING_VALUE because it was thought, at the point it was
1005          declared, to be the only entity with such a name.  Move the
1006          type name into the type slot; it is now hidden by the new
1007          binding.  */
1008       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1009       BINDING_VALUE (binding) = decl;
1010       INHERITED_VALUE_BINDING_P (binding) = 0;
1011     }
1012   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1013            && TREE_CODE (decl) == TYPE_DECL
1014            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1015            && same_type_p (TREE_TYPE (decl),
1016                            TREE_TYPE (BINDING_VALUE (binding))))
1017     /* We have two typedef-names, both naming the same type to have
1018        the same name.  This is OK because of:
1019
1020          [dcl.typedef]
1021
1022          In a given scope, a typedef specifier can be used to redefine
1023          the name of any type declared in that scope to refer to the
1024          type to which it already refers.  */
1025     ok = 0;
1026   /* There can be two block-scope declarations of the same variable,
1027      so long as they are `extern' declarations.  */
1028   else if (TREE_CODE (decl) == VAR_DECL
1029            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1030            && DECL_EXTERNAL (decl)
1031            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1032     {
1033       duplicate_decls (decl, BINDING_VALUE (binding));
1034       ok = 0;
1035     }
1036   else
1037     {
1038       cp_error ("declaration of `%#D'", decl);
1039       cp_error_at ("conflicts with previous declaration `%#D'",
1040                    BINDING_VALUE (binding));
1041       ok = 0;
1042     }
1043
1044   return ok;
1045 }
1046
1047 /* Add DECL to the list of things declared in B.  */
1048
1049 static void
1050 add_decl_to_level (decl, b)
1051      tree decl;
1052      struct binding_level *b;
1053 {
1054   /* We build up the list in reverse order, and reverse it later if
1055      necessary.  */
1056   TREE_CHAIN (decl) = b->names;
1057   b->names = decl;
1058 }
1059
1060 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1061    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1062    doesn't really belong to this binding level, that it got here
1063    through a using-declaration.  */
1064
1065 void
1066 push_local_binding (id, decl, flags)
1067      tree id;
1068      tree decl;
1069      int flags;
1070 {
1071   struct binding_level *b;
1072
1073   /* Skip over any local classes.  This makes sense if we call
1074      push_local_binding with a friend decl of a local class.  */
1075   b = current_binding_level;
1076   while (b->parm_flag == 2)
1077     b = b->level_chain;
1078
1079   if (lookup_name_current_level (id))
1080     {
1081       /* Supplement the existing binding.  */
1082       if (!add_binding (id, decl))
1083         /* It didn't work.  Something else must be bound at this
1084            level.  Do not add DECL to the list of things to pop
1085            later.  */
1086         return;
1087     }
1088   else
1089     /* Create a new binding.  */
1090     push_binding (id, decl, b);
1091
1092   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1093     /* We must put the OVERLOAD into a TREE_LIST since the
1094        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1095        decls that got here through a using-declaration.  */
1096     decl = build_tree_list (NULL_TREE, decl);
1097
1098   /* And put DECL on the list of things declared by the current
1099      binding level.  */
1100   add_decl_to_level (decl, b);
1101 }
1102
1103 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1104    binding was successful.  */
1105
1106 int
1107 push_class_binding (id, decl)
1108      tree id;
1109      tree decl;
1110 {
1111   int result = 1;
1112   tree binding = IDENTIFIER_BINDING (id);
1113   tree context;
1114
1115   /* Note that we declared this value so that we can issue an error if
1116      this an illegal redeclaration of a name already used for some
1117      other purpose.  */
1118   note_name_declared_in_class (id, decl);
1119
1120   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1121     /* Supplement the existing binding.  */
1122     result = add_binding (id, decl);
1123   else
1124     /* Create a new binding.  */
1125     push_binding (id, decl, class_binding_level);
1126
1127   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1128      class-level declaration.  Note that we do not use DECL here
1129      because of the possibility of the `struct stat' hack; if DECL is
1130      a class-name or enum-name we might prefer a field-name, or some
1131      such.  */
1132   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1133
1134   /* If this is a binding from a base class, mark it as such.  */
1135   binding = IDENTIFIER_BINDING (id);
1136   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1137     {
1138       /* Any implicit typename must be from a base-class.  The
1139          context for an implicit typename declaration is always
1140          the derived class in which the lookup was done, so the checks
1141          based on the context of DECL below will not trigger.  */
1142       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1143         INHERITED_VALUE_BINDING_P (binding) = 1;
1144       else
1145         {
1146           if (TREE_CODE (decl) == OVERLOAD)
1147             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1148           else
1149             {
1150               my_friendly_assert (DECL_P (decl), 0);
1151               context = CP_DECL_CONTEXT (decl);
1152             }
1153
1154           if (is_properly_derived_from (current_class_type, context))
1155             INHERITED_VALUE_BINDING_P (binding) = 1;
1156           else
1157             INHERITED_VALUE_BINDING_P (binding) = 0;
1158         }
1159     }
1160   else if (BINDING_VALUE (binding) == decl)
1161     /* We only encounter a TREE_LIST when push_class_decls detects an
1162        ambiguity.  Such an ambiguity can be overridden by a definition
1163        in this class.  */
1164     INHERITED_VALUE_BINDING_P (binding) = 1;
1165
1166   return result;
1167 }
1168
1169 /* Remove the binding for DECL which should be the innermost binding
1170    for ID.  */
1171
1172 static void
1173 pop_binding (id, decl)
1174      tree id;
1175      tree decl;
1176 {
1177   tree binding;
1178
1179   if (id == NULL_TREE)
1180     /* It's easiest to write the loops that call this function without
1181        checking whether or not the entities involved have names.  We
1182        get here for such an entity.  */
1183     return;
1184
1185   /* Get the innermost binding for ID.  */
1186   binding = IDENTIFIER_BINDING (id);
1187
1188   /* The name should be bound.  */
1189   my_friendly_assert (binding != NULL_TREE, 0);
1190
1191   /* The DECL will be either the ordinary binding or the type
1192      binding for this identifier.  Remove that binding.  */
1193   if (BINDING_VALUE (binding) == decl)
1194     BINDING_VALUE (binding) = NULL_TREE;
1195   else if (BINDING_TYPE (binding) == decl)
1196     BINDING_TYPE (binding) = NULL_TREE;
1197   else
1198     my_friendly_abort (0);
1199
1200   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1201     /* We're completely done with the innermost binding for this
1202        identifier.  Unhook it from the list of bindings.  */
1203     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1204 }
1205
1206 /* When a label goes out of scope, check to see if that label was used
1207    in a valid manner, and issue any appropriate warnings or errors.  */
1208
1209 static void
1210 pop_label (label, old_value)
1211      tree label;
1212      tree old_value;
1213 {
1214   if (!processing_template_decl && doing_semantic_analysis_p ())
1215     {
1216       if (DECL_INITIAL (label) == NULL_TREE)
1217         {
1218           cp_error_at ("label `%D' used but not defined", label);
1219           /* Avoid crashing later.  */
1220           define_label (input_filename, 1, DECL_NAME (label));
1221         }
1222       else if (warn_unused_label && !TREE_USED (label))
1223         cp_warning_at ("label `%D' defined but not used", label);
1224     }
1225
1226   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1227 }
1228
1229 /* At the end of a function, all labels declared within the function
1230    go out of scope.  BLOCK is the top-level block for the
1231    function.  */
1232
1233 static void
1234 pop_labels (block)
1235      tree block;
1236 {
1237   struct named_label_list *link;
1238
1239   /* Clear out the definitions of all label names, since their scopes
1240      end here.  */
1241   for (link = named_labels; link; link = link->next)
1242     {
1243       pop_label (link->label_decl, link->old_value);
1244       /* Put the labels into the "variables" of the top-level block,
1245          so debugger can see them.  */
1246       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1247       BLOCK_VARS (block) = link->label_decl;
1248     }
1249
1250   named_labels = NULL;
1251 }
1252
1253 /* Exit a binding level.
1254    Pop the level off, and restore the state of the identifier-decl mappings
1255    that were in effect when this level was entered.
1256
1257    If KEEP == 1, this level had explicit declarations, so
1258    and create a "block" (a BLOCK node) for the level
1259    to record its declarations and subblocks for symbol table output.
1260
1261    If FUNCTIONBODY is nonzero, this level is the body of a function,
1262    so create a block as if KEEP were set and also clear out all
1263    label names.
1264
1265    If REVERSE is nonzero, reverse the order of decls before putting
1266    them into the BLOCK.  */
1267
1268 tree
1269 poplevel (keep, reverse, functionbody)
1270      int keep;
1271      int reverse;
1272      int functionbody;
1273 {
1274   register tree link;
1275   /* The chain of decls was accumulated in reverse order.
1276      Put it into forward order, just for cleanliness.  */
1277   tree decls;
1278   int tmp = functionbody;
1279   int real_functionbody;
1280   tree tags;
1281   tree subblocks;
1282   tree block = NULL_TREE;
1283   tree decl;
1284   int leaving_for_scope;
1285
1286   if (cfun && !doing_semantic_analysis_p ())
1287     return NULL_TREE;
1288
1289   my_friendly_assert (current_binding_level->parm_flag != 2,
1290                       19990916);
1291
1292   real_functionbody = (current_binding_level->keep == 2
1293                        ? ((functionbody = 0), tmp) : functionbody);
1294   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1295   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1296
1297   my_friendly_assert (!current_binding_level->class_shadowed,
1298                       19990414);
1299
1300   /* We used to use KEEP == 2 to indicate that the new block should go
1301      at the beginning of the list of blocks at this binding level,
1302      rather than the end.  This hack is no longer used.  */
1303   my_friendly_assert (keep == 0 || keep == 1, 0);
1304
1305   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1306                       (HOST_WIDE_INT) current_binding_level->level_chain,
1307                       current_binding_level->parm_flag,
1308                       current_binding_level->keep);
1309
1310   if (current_binding_level->keep == 1)
1311     keep = 1;
1312
1313   /* Any uses of undefined labels, and any defined labels, now operate
1314      under constraints of next binding contour.  */
1315   if (cfun && !functionbody)
1316     {
1317       struct binding_level *level_chain;
1318       level_chain = current_binding_level->level_chain;
1319       if (level_chain)
1320         {
1321           struct named_label_use_list *uses;
1322           struct named_label_list *labels;
1323           for (labels = named_labels; labels; labels = labels->next)
1324             if (labels->binding_level == current_binding_level)
1325               {
1326                 tree decl;
1327                 if (current_binding_level->eh_region)
1328                   labels->eh_region = 1;
1329                 for (decl = labels->names_in_scope; decl;
1330                      decl = TREE_CHAIN (decl))
1331                   if (decl_jump_unsafe (decl))
1332                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1333                                                    labels->bad_decls);
1334                 labels->binding_level = level_chain;
1335                 labels->names_in_scope = level_chain->names;
1336               }
1337
1338           for (uses = named_label_uses; uses; uses = uses->next)
1339             if (uses->binding_level == current_binding_level)
1340               {
1341                 uses->binding_level = level_chain;
1342                 uses->names_in_scope = level_chain->names;
1343               }
1344         }
1345     }
1346
1347   /* Get the decls in the order they were written.
1348      Usually current_binding_level->names is in reverse order.
1349      But parameter decls were previously put in forward order.  */
1350
1351   if (reverse)
1352     current_binding_level->names
1353       = decls = nreverse (current_binding_level->names);
1354   else
1355     decls = current_binding_level->names;
1356
1357   /* Output any nested inline functions within this block
1358      if they weren't already output.  */
1359   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1360     if (TREE_CODE (decl) == FUNCTION_DECL
1361         && ! TREE_ASM_WRITTEN (decl)
1362         && DECL_INITIAL (decl) != NULL_TREE
1363         && TREE_ADDRESSABLE (decl)
1364         && decl_function_context (decl) == current_function_decl)
1365       {
1366         /* If this decl was copied from a file-scope decl
1367            on account of a block-scope extern decl,
1368            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1369         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1370           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1371         else
1372           {
1373             push_function_context ();
1374             output_inline_function (decl);
1375             pop_function_context ();
1376           }
1377       }
1378
1379   /* When not in function-at-a-time mode, expand_end_bindings will
1380      warn about unused variables.  But, in function-at-a-time mode
1381      expand_end_bindings is not passed the list of variables in the
1382      current scope, and therefore no warning is emitted.  So, we
1383      explicitly warn here.  */
1384   if (!processing_template_decl)
1385     warn_about_unused_variables (getdecls ());
1386
1387   /* If there were any declarations or structure tags in that level,
1388      or if this level is a function body,
1389      create a BLOCK to record them for the life of this function.  */
1390   block = NULL_TREE;
1391   if (keep == 1 || functionbody)
1392     block = make_node (BLOCK);
1393   if (block != NULL_TREE)
1394     {
1395       BLOCK_VARS (block) = decls;
1396       BLOCK_SUBBLOCKS (block) = subblocks;
1397     }
1398
1399   /* In each subblock, record that this is its superior.  */
1400   if (keep >= 0)
1401     for (link = subblocks; link; link = TREE_CHAIN (link))
1402       BLOCK_SUPERCONTEXT (link) = block;
1403
1404   /* We still support the old for-scope rules, whereby the variables
1405      in a for-init statement were in scope after the for-statement
1406      ended.  We only use the new rules in flag_new_for_scope is
1407      nonzero.  */
1408   leaving_for_scope
1409     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1410
1411   /* Remove declarations for all the DECLs in this level.  */
1412   for (link = decls; link; link = TREE_CHAIN (link))
1413     {
1414       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1415           && DECL_NAME (link))
1416         {
1417           tree outer_binding
1418             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1419           tree ns_binding;
1420
1421           if (!outer_binding)
1422             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1423           else
1424             ns_binding = NULL_TREE;
1425
1426           if (outer_binding
1427               && (BINDING_LEVEL (outer_binding)
1428                   == current_binding_level->level_chain))
1429             /* We have something like:
1430
1431                  int i;
1432                  for (int i; ;);
1433
1434                and we are leaving the `for' scope.  There's no reason to
1435                keep the binding of the inner `i' in this case.  */
1436             pop_binding (DECL_NAME (link), link);
1437           else if ((outer_binding
1438                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1439                         == TYPE_DECL))
1440                    || (ns_binding
1441                        && TREE_CODE (ns_binding) == TYPE_DECL))
1442             /* Here, we have something like:
1443
1444                  typedef int I;
1445
1446                  void f () {
1447                    for (int I; ;);
1448                  }
1449
1450                We must pop the for-scope binding so we know what's a
1451                type and what isn't.  */
1452             pop_binding (DECL_NAME (link), link);
1453           else
1454             {
1455               /* Mark this VAR_DECL as dead so that we can tell we left it
1456                  there only for backward compatibility.  */
1457               DECL_DEAD_FOR_LOCAL (link) = 1;
1458
1459               /* Keep track of what should of have happenned when we
1460                  popped the binding.  */
1461               if (outer_binding && BINDING_VALUE (outer_binding))
1462                 DECL_SHADOWED_FOR_VAR (link)
1463                   = BINDING_VALUE (outer_binding);
1464
1465               /* Add it to the list of dead variables in the next
1466                  outermost binding to that we can remove these when we
1467                  leave that binding.  */
1468               current_binding_level->level_chain->dead_vars_from_for
1469                 = tree_cons (NULL_TREE, link,
1470                              current_binding_level->level_chain->
1471                              dead_vars_from_for);
1472
1473               /* Although we don't pop the CPLUS_BINDING, we do clear
1474                  its BINDING_LEVEL since the level is going away now.  */
1475               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1476                 = 0;
1477             }
1478         }
1479       else
1480         {
1481           /* Remove the binding.  */
1482           decl = link;
1483           if (TREE_CODE (decl) == TREE_LIST)
1484             decl = TREE_VALUE (decl);
1485           if (DECL_P (decl))
1486             pop_binding (DECL_NAME (decl), decl);
1487           else if (TREE_CODE (decl) == OVERLOAD)
1488             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1489           else
1490             my_friendly_abort (0);
1491         }
1492     }
1493
1494   /* Remove declarations for any `for' variables from inner scopes
1495      that we kept around.  */
1496   for (link = current_binding_level->dead_vars_from_for;
1497        link; link = TREE_CHAIN (link))
1498     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1499
1500   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1501   for (link = current_binding_level->type_shadowed;
1502        link; link = TREE_CHAIN (link))
1503     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1504
1505   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1506   for (link = current_binding_level->shadowed_labels;
1507        link;
1508        link = TREE_CHAIN (link))
1509     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1510
1511   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1512      list if a `using' declaration put them there.  The debugging
1513      back-ends won't understand OVERLOAD, so we remove them here.
1514      Because the BLOCK_VARS are (temporarily) shared with
1515      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1516      popped all the bindings.  */
1517   if (block)
1518     {
1519       tree* d;
1520
1521       for (d = &BLOCK_VARS (block); *d; )
1522         {
1523           if (TREE_CODE (*d) == TREE_LIST)
1524             *d = TREE_CHAIN (*d);
1525           else
1526             d = &TREE_CHAIN (*d);
1527         }
1528     }
1529
1530   /* If the level being exited is the top level of a function,
1531      check over all the labels.  */
1532   if (functionbody)
1533     {
1534       /* Since this is the top level block of a function, the vars are
1535          the function's parameters.  Don't leave them in the BLOCK
1536          because they are found in the FUNCTION_DECL instead.  */
1537       BLOCK_VARS (block) = 0;
1538       pop_labels (block);
1539     }
1540
1541   tmp = current_binding_level->keep;
1542
1543   pop_binding_level ();
1544   if (functionbody)
1545     DECL_INITIAL (current_function_decl) = block;
1546   else if (block)
1547     current_binding_level->blocks
1548       = chainon (current_binding_level->blocks, block);
1549
1550   /* If we did not make a block for the level just exited,
1551      any blocks made for inner levels
1552      (since they cannot be recorded as subblocks in that level)
1553      must be carried forward so they will later become subblocks
1554      of something else.  */
1555   else if (subblocks)
1556     current_binding_level->blocks
1557       = chainon (current_binding_level->blocks, subblocks);
1558
1559   /* Each and every BLOCK node created here in `poplevel' is important
1560      (e.g. for proper debugging information) so if we created one
1561      earlier, mark it as "used".  */
1562   if (block)
1563     TREE_USED (block) = 1;
1564
1565   /* Take care of compiler's internal binding structures.  */
1566   if (tmp == 2)
1567     {
1568       tree scope_stmts;
1569
1570       scope_stmts
1571         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1572       if (block)
1573         {
1574           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1575           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1576         }
1577
1578       block = poplevel (keep, reverse, functionbody);
1579     }
1580
1581   return block;
1582 }
1583
1584 /* Delete the node BLOCK from the current binding level.
1585    This is used for the block inside a stmt expr ({...})
1586    so that the block can be reinserted where appropriate.  */
1587
1588 void
1589 delete_block (block)
1590      tree block;
1591 {
1592   tree t;
1593   if (current_binding_level->blocks == block)
1594     current_binding_level->blocks = TREE_CHAIN (block);
1595   for (t = current_binding_level->blocks; t;)
1596     {
1597       if (TREE_CHAIN (t) == block)
1598         TREE_CHAIN (t) = TREE_CHAIN (block);
1599       else
1600         t = TREE_CHAIN (t);
1601     }
1602   TREE_CHAIN (block) = NULL_TREE;
1603   /* Clear TREE_USED which is always set by poplevel.
1604      The flag is set again if insert_block is called.  */
1605   TREE_USED (block) = 0;
1606 }
1607
1608 /* Insert BLOCK at the end of the list of subblocks of the
1609    current binding level.  This is used when a BIND_EXPR is expanded,
1610    to handle the BLOCK node inside the BIND_EXPR.  */
1611
1612 void
1613 insert_block (block)
1614      tree block;
1615 {
1616   TREE_USED (block) = 1;
1617   current_binding_level->blocks
1618     = chainon (current_binding_level->blocks, block);
1619 }
1620
1621 /* Set the BLOCK node for the innermost scope
1622    (the one we are currently in).  */
1623
1624 void
1625 set_block (block)
1626     tree block ATTRIBUTE_UNUSED;
1627 {
1628   /* The RTL expansion machinery requires us to provide this callback,
1629      but it is not applicable in function-at-a-time mode.  */
1630   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1631 }
1632
1633 /* Do a pushlevel for class declarations.  */
1634
1635 void
1636 pushlevel_class ()
1637 {
1638   register struct binding_level *newlevel;
1639
1640   /* Reuse or create a struct for this binding level.  */
1641 #if defined(DEBUG_CP_BINDING_LEVELS)
1642   if (0)
1643 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1644   if (free_binding_level)
1645 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1646     {
1647       newlevel = free_binding_level;
1648       free_binding_level = free_binding_level->level_chain;
1649     }
1650   else
1651     newlevel = make_binding_level ();
1652
1653 #if defined(DEBUG_CP_BINDING_LEVELS)
1654   is_class_level = 1;
1655 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1656
1657   push_binding_level (newlevel, 0, 0);
1658
1659   class_binding_level = current_binding_level;
1660   class_binding_level->parm_flag = 2;
1661   class_binding_level->this_class = current_class_type;
1662 }
1663
1664 /* ...and a poplevel for class declarations.  */
1665
1666 void
1667 poplevel_class ()
1668 {
1669   register struct binding_level *level = class_binding_level;
1670   tree shadowed;
1671
1672   my_friendly_assert (level != 0, 354);
1673
1674   /* If we're leaving a toplevel class, don't bother to do the setting
1675      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1676      shouldn't even be used when current_class_type isn't set, and second,
1677      if we don't touch it here, we're able to use the cache effect if the
1678      next time we're entering a class scope, it is the same class.  */
1679   if (current_class_depth != 1)
1680     {
1681       struct binding_level* b;
1682
1683       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1684       for (shadowed = level->class_shadowed;
1685            shadowed;
1686            shadowed = TREE_CHAIN (shadowed))
1687         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1688
1689       /* Find the next enclosing class, and recreate
1690          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1691       b = level->level_chain;
1692       while (b && b->parm_flag != 2)
1693         b = b->level_chain;
1694
1695       if (b)
1696         for (shadowed = b->class_shadowed;
1697              shadowed;
1698              shadowed = TREE_CHAIN (shadowed))
1699           {
1700             tree t;
1701
1702             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1703             while (t && BINDING_LEVEL (t) != b)
1704               t = TREE_CHAIN (t);
1705
1706             if (t)
1707               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1708                 = BINDING_VALUE (t);
1709           }
1710     }
1711   else
1712     /* Remember to save what IDENTIFIER's were bound in this scope so we
1713        can recover from cache misses.  */
1714     {
1715       previous_class_type = current_class_type;
1716       previous_class_values = class_binding_level->class_shadowed;
1717     }
1718   for (shadowed = level->type_shadowed;
1719        shadowed;
1720        shadowed = TREE_CHAIN (shadowed))
1721     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1722
1723   /* Remove the bindings for all of the class-level declarations.  */
1724   for (shadowed = level->class_shadowed;
1725        shadowed;
1726        shadowed = TREE_CHAIN (shadowed))
1727     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1728
1729   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1730                       (HOST_WIDE_INT) class_binding_level->level_chain,
1731                       class_binding_level->parm_flag,
1732                       class_binding_level->keep);
1733
1734   /* Now, pop out of the binding level which we created up in the
1735      `pushlevel_class' routine.  */
1736 #if defined(DEBUG_CP_BINDING_LEVELS)
1737   is_class_level = 1;
1738 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1739
1740   pop_binding_level ();
1741 }
1742
1743 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1744    for any names in enclosing classes.  */
1745
1746 void
1747 clear_identifier_class_values ()
1748 {
1749   tree t;
1750
1751   if (!class_binding_level)
1752     return;
1753
1754   for (t = class_binding_level->class_shadowed;
1755        t;
1756        t = TREE_CHAIN (t))
1757     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1758 }
1759
1760 /* Returns non-zero if T is a virtual function table.  */
1761
1762 int
1763 vtable_decl_p (t, data)
1764      tree t;
1765      void *data ATTRIBUTE_UNUSED;
1766 {
1767   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1768 }
1769
1770 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1771    functions.  */
1772
1773 int
1774 vtype_decl_p (t, data)
1775      tree t;
1776      void *data ATTRIBUTE_UNUSED;
1777 {
1778   return (TREE_CODE (t) == TYPE_DECL
1779           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1780           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1781 }
1782
1783 /* Return the declarations that are members of the namespace NS.  */
1784
1785 tree
1786 cp_namespace_decls (ns)
1787      tree ns;
1788 {
1789   return NAMESPACE_LEVEL (ns)->names;
1790 }
1791
1792 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1793    itself, calling F for each.  The DATA is passed to F as well.  */
1794
1795 static int
1796 walk_namespaces_r (namespace, f, data)
1797      tree namespace;
1798      walk_namespaces_fn f;
1799      void *data;
1800 {
1801   tree current;
1802   int result = 0;
1803
1804   result |= (*f) (namespace, data);
1805
1806   for (current = cp_namespace_decls (namespace);
1807        current;
1808        current = TREE_CHAIN (current))
1809     {
1810       if (TREE_CODE (current) != NAMESPACE_DECL
1811           || DECL_NAMESPACE_ALIAS (current))
1812         continue;
1813       if (!DECL_LANG_SPECIFIC (current))
1814         {
1815           /* Hmm. std. */
1816           my_friendly_assert (current == std_node, 393);
1817           continue;
1818         }
1819
1820       /* We found a namespace.  */
1821       result |= walk_namespaces_r (current, f, data);
1822     }
1823
1824   return result;
1825 }
1826
1827 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1828    F as well.  */
1829
1830 int
1831 walk_namespaces (f, data)
1832      walk_namespaces_fn f;
1833      void *data;
1834 {
1835   return walk_namespaces_r (global_namespace, f, data);
1836 }
1837
1838 struct walk_globals_data {
1839   walk_globals_pred p;
1840   walk_globals_fn f;
1841   void *data;
1842 };
1843
1844 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1845    for which P returns non-zero, call F with its address.  If any call
1846    to F returns a non-zero value, return a non-zero value.  */
1847
1848 static int
1849 walk_globals_r (namespace, data)
1850      tree namespace;
1851      void *data;
1852 {
1853   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1854   walk_globals_pred p = wgd->p;
1855   walk_globals_fn f = wgd->f;
1856   void *d = wgd->data;
1857   tree *t;
1858   int result = 0;
1859
1860   t = &NAMESPACE_LEVEL (namespace)->names;
1861
1862   while (*t)
1863     {
1864       tree glbl = *t;
1865
1866       if ((*p) (glbl, d))
1867         result |= (*f) (t, d);
1868
1869       /* If F changed *T, then *T still points at the next item to
1870          examine.  */
1871       if (*t == glbl)
1872         t = &TREE_CHAIN (*t);
1873     }
1874
1875   return result;
1876 }
1877
1878 /* Walk the global declarations.  Whenever one is found for which P
1879    returns non-zero, call F with its address.  If any call to F
1880    returns a non-zero value, return a non-zero value.  */
1881
1882 int
1883 walk_globals (p, f, data)
1884      walk_globals_pred p;
1885      walk_globals_fn f;
1886      void *data;
1887 {
1888   struct walk_globals_data wgd;
1889   wgd.p = p;
1890   wgd.f = f;
1891   wgd.data = data;
1892
1893   return walk_namespaces (walk_globals_r, &wgd);
1894 }
1895
1896 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1897    DATA is non-NULL, this is the last time we will call
1898    wrapup_global_declarations for this NAMESPACE.  */
1899
1900 int
1901 wrapup_globals_for_namespace (namespace, data)
1902      tree namespace;
1903      void *data;
1904 {
1905   tree globals = cp_namespace_decls (namespace);
1906   int len = list_length (globals);
1907   tree *vec = (tree *) alloca (sizeof (tree) * len);
1908   int i;
1909   int result;
1910   tree decl;
1911   int last_time = (data != 0);
1912
1913   if (last_time && namespace == global_namespace)
1914     /* Let compile_file handle the global namespace.  */
1915     return 0;
1916
1917   /* Process the decls in reverse order--earliest first.
1918      Put them into VEC from back to front, then take out from front.  */
1919
1920   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1921     {
1922       /* Pretend we've output an unused static variable.  This ensures
1923          that the toplevel __FUNCTION__ etc won't be emitted, unless
1924          needed. */
1925       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1926           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1927         {
1928           TREE_ASM_WRITTEN (decl) = 1;
1929           DECL_IGNORED_P (decl) = 1;
1930         }
1931       vec[len - i - 1] = decl;
1932     }
1933
1934   if (last_time)
1935     {
1936       check_global_declarations (vec, len);
1937       return 0;
1938     }
1939
1940   /* Temporarily mark vtables as external.  That prevents
1941      wrapup_global_declarations from writing them out; we must process
1942      them ourselves in finish_vtable_vardecl.  */
1943   for (i = 0; i < len; ++i)
1944     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1945       {
1946         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1947         DECL_EXTERNAL (vec[i]) = 1;
1948       }
1949
1950   /* Write out any globals that need to be output.  */
1951   result = wrapup_global_declarations (vec, len);
1952
1953   /* Undo the hack to DECL_EXTERNAL above.  */
1954   for (i = 0; i < len; ++i)
1955     if (vtable_decl_p (vec[i], /*data=*/0)
1956         && DECL_NOT_REALLY_EXTERN (vec[i]))
1957       {
1958         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1959         DECL_EXTERNAL (vec[i]) = 0;
1960       }
1961
1962   return result;
1963 }
1964
1965 \f
1966 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1967
1968 static void
1969 mark_binding_level (arg)
1970      void *arg;
1971 {
1972   struct binding_level *lvl = *(struct binding_level **)arg;
1973
1974   for (; lvl; lvl = lvl->level_chain)
1975     {
1976       ggc_mark_tree (lvl->names);
1977       ggc_mark_tree (lvl->tags);
1978       ggc_mark_tree (lvl->usings);
1979       ggc_mark_tree (lvl->using_directives);
1980       ggc_mark_tree (lvl->class_shadowed);
1981       ggc_mark_tree (lvl->type_shadowed);
1982       ggc_mark_tree (lvl->shadowed_labels);
1983       ggc_mark_tree (lvl->blocks);
1984       ggc_mark_tree (lvl->this_class);
1985       ggc_mark_tree (lvl->incomplete);
1986       ggc_mark_tree (lvl->dead_vars_from_for);
1987     }
1988 }
1989
1990 static void
1991 mark_named_label_lists (labs, uses)
1992      void *labs;
1993      void *uses;
1994 {
1995   struct named_label_list *l = *(struct named_label_list **)labs;
1996   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1997
1998   for (; l; l = l->next)
1999     {
2000       ggc_mark (l);
2001       mark_binding_level (l->binding_level);
2002       ggc_mark_tree (l->old_value);
2003       ggc_mark_tree (l->label_decl);
2004       ggc_mark_tree (l->bad_decls);
2005     }
2006
2007   for (; u; u = u->next)
2008     ggc_mark (u);
2009 }
2010 \f
2011 /* For debugging.  */
2012 static int no_print_functions = 0;
2013 static int no_print_builtins = 0;
2014
2015 void
2016 print_binding_level (lvl)
2017      struct binding_level *lvl;
2018 {
2019   tree t;
2020   int i = 0, len;
2021   fprintf (stderr, " blocks=");
2022   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2023   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2024            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2025   if (lvl->tag_transparent)
2026     fprintf (stderr, " tag-transparent");
2027   if (lvl->more_cleanups_ok)
2028     fprintf (stderr, " more-cleanups-ok");
2029   if (lvl->have_cleanups)
2030     fprintf (stderr, " have-cleanups");
2031   fprintf (stderr, "\n");
2032   if (lvl->names)
2033     {
2034       fprintf (stderr, " names:\t");
2035       /* We can probably fit 3 names to a line?  */
2036       for (t = lvl->names; t; t = TREE_CHAIN (t))
2037         {
2038           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2039             continue;
2040           if (no_print_builtins
2041               && (TREE_CODE (t) == TYPE_DECL)
2042               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2043             continue;
2044
2045           /* Function decls tend to have longer names.  */
2046           if (TREE_CODE (t) == FUNCTION_DECL)
2047             len = 3;
2048           else
2049             len = 2;
2050           i += len;
2051           if (i > 6)
2052             {
2053               fprintf (stderr, "\n\t");
2054               i = len;
2055             }
2056           print_node_brief (stderr, "", t, 0);
2057           if (t == error_mark_node)
2058             break;
2059         }
2060       if (i)
2061         fprintf (stderr, "\n");
2062     }
2063   if (lvl->tags)
2064     {
2065       fprintf (stderr, " tags:\t");
2066       i = 0;
2067       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2068         {
2069           if (TREE_PURPOSE (t) == NULL_TREE)
2070             len = 3;
2071           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2072             len = 2;
2073           else
2074             len = 4;
2075           i += len;
2076           if (i > 5)
2077             {
2078               fprintf (stderr, "\n\t");
2079               i = len;
2080             }
2081           if (TREE_PURPOSE (t) == NULL_TREE)
2082             {
2083               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2084               fprintf (stderr, ">");
2085             }
2086           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2087             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2088           else
2089             {
2090               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2091               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2092               fprintf (stderr, ">");
2093             }
2094         }
2095       if (i)
2096         fprintf (stderr, "\n");
2097     }
2098   if (lvl->class_shadowed)
2099     {
2100       fprintf (stderr, " class-shadowed:");
2101       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2102         {
2103           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2104         }
2105       fprintf (stderr, "\n");
2106     }
2107   if (lvl->type_shadowed)
2108     {
2109       fprintf (stderr, " type-shadowed:");
2110       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2111         {
2112           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2113         }
2114       fprintf (stderr, "\n");
2115     }
2116 }
2117
2118 void
2119 print_other_binding_stack (stack)
2120      struct binding_level *stack;
2121 {
2122   struct binding_level *level;
2123   for (level = stack; level != global_binding_level; level = level->level_chain)
2124     {
2125       fprintf (stderr, "binding level ");
2126       fprintf (stderr, HOST_PTR_PRINTF, level);
2127       fprintf (stderr, "\n");
2128       print_binding_level (level);
2129     }
2130 }
2131
2132 void
2133 print_binding_stack ()
2134 {
2135   struct binding_level *b;
2136   fprintf (stderr, "current_binding_level=");
2137   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2138   fprintf (stderr, "\nclass_binding_level=");
2139   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2140   fprintf (stderr, "\nglobal_binding_level=");
2141   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2142   fprintf (stderr, "\n");
2143   if (class_binding_level)
2144     {
2145       for (b = class_binding_level; b; b = b->level_chain)
2146         if (b == current_binding_level)
2147           break;
2148       if (b)
2149         b = class_binding_level;
2150       else
2151         b = current_binding_level;
2152     }
2153   else
2154     b = current_binding_level;
2155   print_other_binding_stack (b);
2156   fprintf (stderr, "global:\n");
2157   print_binding_level (global_binding_level);
2158 }
2159
2160 /* Namespace binding access routines: The namespace_bindings field of
2161    the identifier is polymorphic, with three possible values:
2162    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2163    indicating the BINDING_VALUE of global_namespace. */
2164
2165 /* Check whether the a binding for the name to scope is known.
2166    Assumes that the bindings of the name are already a list
2167    of bindings. Returns the binding found, or NULL_TREE. */
2168
2169 static tree
2170 find_binding (name, scope)
2171      tree name;
2172      tree scope;
2173 {
2174   tree iter, prev = NULL_TREE;
2175
2176   scope = ORIGINAL_NAMESPACE (scope);
2177
2178   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2179        iter = TREE_CHAIN (iter))
2180     {
2181       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2182       if (BINDING_SCOPE (iter) == scope)
2183         {
2184           /* Move binding found to the front of the list, so
2185              subsequent lookups will find it faster. */
2186           if (prev)
2187             {
2188               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2189               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2190               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2191             }
2192           return iter;
2193         }
2194       prev = iter;
2195     }
2196   return NULL_TREE;
2197 }
2198
2199 /* Always returns a binding for name in scope. If the
2200    namespace_bindings is not a list, convert it to one first.
2201    If no binding is found, make a new one. */
2202
2203 tree
2204 binding_for_name (name, scope)
2205      tree name;
2206      tree scope;
2207 {
2208   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2209   tree result;
2210
2211   scope = ORIGINAL_NAMESPACE (scope);
2212
2213   if (b && TREE_CODE (b) != CPLUS_BINDING)
2214     {
2215       /* Get rid of optimization for global scope. */
2216       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2217       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2218       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2219     }
2220   if (b && (result = find_binding (name, scope)))
2221     return result;
2222   /* Not found, make a new one. */
2223   result = make_node (CPLUS_BINDING);
2224   TREE_CHAIN (result) = b;
2225   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2226   BINDING_SCOPE (result) = scope;
2227   BINDING_TYPE (result) = NULL_TREE;
2228   BINDING_VALUE (result) = NULL_TREE;
2229   return result;
2230 }
2231
2232 /* Return the binding value for name in scope, considering that
2233    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2234
2235 tree
2236 namespace_binding (name, scope)
2237      tree name;
2238      tree scope;
2239 {
2240   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241   if (b == NULL_TREE)
2242     return NULL_TREE;
2243   if (scope == NULL_TREE)
2244     scope = global_namespace;
2245   if (TREE_CODE (b) != CPLUS_BINDING)
2246     return (scope == global_namespace) ? b : NULL_TREE;
2247   name = find_binding (name,scope);
2248   if (name == NULL_TREE)
2249     return name;
2250   return BINDING_VALUE (name);
2251 }
2252
2253 /* Set the binding value for name in scope. If modifying the binding
2254    of global_namespace is attempted, try to optimize it. */
2255
2256 void
2257 set_namespace_binding (name, scope, val)
2258      tree name;
2259      tree scope;
2260      tree val;
2261 {
2262   tree b;
2263
2264   if (scope == NULL_TREE)
2265     scope = global_namespace;
2266
2267   if (scope == global_namespace)
2268     {
2269       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2270       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2271         {
2272           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2273           return;
2274         }
2275     }
2276   b = binding_for_name (name, scope);
2277   BINDING_VALUE (b) = val;
2278 }
2279
2280 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2281    select a name that is unique to this compilation unit.  */
2282
2283 void
2284 push_namespace (name)
2285      tree name;
2286 {
2287   tree d = NULL_TREE;
2288   int need_new = 1;
2289   int implicit_use = 0;
2290   int global = 0;
2291   if (!global_namespace)
2292     {
2293       /* This must be ::. */
2294       my_friendly_assert (name == get_identifier ("::"), 377);
2295       global = 1;
2296     }
2297   else if (!name)
2298     {
2299       /* The name of anonymous namespace is unique for the translation
2300          unit.  */
2301       if (!anonymous_namespace_name)
2302         anonymous_namespace_name = get_file_function_name ('N');
2303       name = anonymous_namespace_name;
2304       d = IDENTIFIER_NAMESPACE_VALUE (name);
2305       if (d)
2306         /* Reopening anonymous namespace.  */
2307         need_new = 0;
2308       implicit_use = 1;
2309     }
2310   else if (current_namespace == global_namespace
2311            && name == DECL_NAME (std_node))
2312     {
2313       in_std++;
2314       return;
2315     }
2316   else
2317     {
2318       /* Check whether this is an extended namespace definition. */
2319       d = IDENTIFIER_NAMESPACE_VALUE (name);
2320       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2321         {
2322           need_new = 0;
2323           if (DECL_NAMESPACE_ALIAS (d))
2324             {
2325               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2326                         d, DECL_NAMESPACE_ALIAS (d));
2327               d = DECL_NAMESPACE_ALIAS (d);
2328             }
2329         }
2330     }
2331
2332   if (need_new)
2333     {
2334       /* Make a new namespace, binding the name to it. */
2335       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2336       /* The global namespace is not pushed, and the global binding
2337          level is set elsewhere.  */
2338       if (!global)
2339         {
2340           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2341           d = pushdecl (d);
2342           pushlevel (0);
2343           declare_namespace_level ();
2344           NAMESPACE_LEVEL (d) = current_binding_level;
2345         }
2346     }
2347   else
2348     resume_binding_level (NAMESPACE_LEVEL (d));
2349
2350   if (implicit_use)
2351     do_using_directive (d);
2352   /* Enter the name space. */
2353   current_namespace = d;
2354 }
2355
2356 /* Pop from the scope of the current namespace.  */
2357
2358 void
2359 pop_namespace ()
2360 {
2361   if (current_namespace == global_namespace)
2362     {
2363       my_friendly_assert (in_std>0, 980421);
2364       in_std--;
2365       return;
2366     }
2367   current_namespace = CP_DECL_CONTEXT (current_namespace);
2368   /* The binding level is not popped, as it might be re-opened later.  */
2369   suspend_binding_level ();
2370 }
2371
2372 /* Push into the scope of the namespace NS, even if it is deeply
2373    nested within another namespace.  */
2374
2375 void
2376 push_nested_namespace (ns)
2377      tree ns;
2378 {
2379   if (ns == global_namespace)
2380     push_to_top_level ();
2381   else
2382     {
2383       push_nested_namespace (CP_DECL_CONTEXT (ns));
2384       push_namespace (DECL_NAME (ns));
2385     }
2386 }
2387
2388 /* Pop back from the scope of the namespace NS, which was previously
2389    entered with push_nested_namespace.  */
2390
2391 void
2392 pop_nested_namespace (ns)
2393      tree ns;
2394 {
2395   while (ns != global_namespace)
2396     {
2397       pop_namespace ();
2398       ns = CP_DECL_CONTEXT (ns);
2399     }
2400
2401   pop_from_top_level ();
2402 }
2403
2404 \f
2405 /* Subroutines for reverting temporarily to top-level for instantiation
2406    of templates and such.  We actually need to clear out the class- and
2407    local-value slots of all identifiers, so that only the global values
2408    are at all visible.  Simply setting current_binding_level to the global
2409    scope isn't enough, because more binding levels may be pushed.  */
2410 struct saved_scope *scope_chain;
2411
2412 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2413
2414 static void
2415 mark_saved_scope (arg)
2416      void *arg;
2417 {
2418   struct saved_scope *t = *(struct saved_scope **)arg;
2419   while (t)
2420     {
2421       mark_binding_level (&t->class_bindings);
2422       ggc_mark_tree (t->old_bindings);
2423       ggc_mark_tree (t->old_namespace);
2424       ggc_mark_tree (t->class_name);
2425       ggc_mark_tree (t->class_type);
2426       ggc_mark_tree (t->access_specifier);
2427       ggc_mark_tree (t->function_decl);
2428       if (t->lang_base)
2429         ggc_mark_tree_varray (t->lang_base);
2430       ggc_mark_tree (t->lang_name);
2431       ggc_mark_tree (t->template_parms);
2432       ggc_mark_tree (t->x_previous_class_type);
2433       ggc_mark_tree (t->x_previous_class_values);
2434       ggc_mark_tree (t->x_saved_tree);
2435       ggc_mark_tree (t->incomplete);
2436       ggc_mark_tree (t->lookups);
2437
2438       mark_stmt_tree (&t->x_stmt_tree);
2439       mark_binding_level (&t->bindings);
2440       t = t->prev;
2441     }
2442 }
2443
2444 static tree
2445 store_bindings (names, old_bindings)
2446      tree names, old_bindings;
2447 {
2448   tree t;
2449   for (t = names; t; t = TREE_CHAIN (t))
2450     {
2451       tree binding, t1, id;
2452
2453       if (TREE_CODE (t) == TREE_LIST)
2454         id = TREE_PURPOSE (t);
2455       else
2456         id = DECL_NAME (t);
2457
2458       if (!id
2459           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2460              we have no IDENTIFIER_BINDING if we have left the class
2461              scope, but cached the class-level declarations.  */
2462           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2463         continue;
2464
2465       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2466         if (TREE_VEC_ELT (t1, 0) == id)
2467           goto skip_it;
2468
2469       binding = make_tree_vec (4);
2470
2471       if (id)
2472         {
2473           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2474           TREE_VEC_ELT (binding, 0) = id;
2475           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2476           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2477           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2478           IDENTIFIER_BINDING (id) = NULL_TREE;
2479           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2480         }
2481       TREE_CHAIN (binding) = old_bindings;
2482       old_bindings = binding;
2483     skip_it:
2484       ;
2485     }
2486   return old_bindings;
2487 }
2488
2489 void
2490 maybe_push_to_top_level (pseudo)
2491      int pseudo;
2492 {
2493   struct saved_scope *s;
2494   struct binding_level *b;
2495   tree old_bindings;
2496   int need_pop;
2497
2498   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2499
2500   b = scope_chain ? current_binding_level : 0;
2501
2502   /* If we're in the middle of some function, save our state.  */
2503   if (cfun)
2504     {
2505       need_pop = 1;
2506       push_function_context_to (NULL_TREE);
2507     }
2508   else
2509     need_pop = 0;
2510
2511   old_bindings = NULL_TREE;
2512   if (scope_chain && previous_class_type)
2513     old_bindings = store_bindings (previous_class_values, old_bindings);
2514
2515   /* Have to include global_binding_level, because class-level decls
2516      aren't listed anywhere useful.  */
2517   for (; b; b = b->level_chain)
2518     {
2519       tree t;
2520
2521       /* Template IDs are inserted into the global level. If they were
2522          inserted into namespace level, finish_file wouldn't find them
2523          when doing pending instantiations. Therefore, don't stop at
2524          namespace level, but continue until :: .  */
2525       if (b == global_binding_level || (pseudo && b->template_parms_p))
2526         break;
2527
2528       old_bindings = store_bindings (b->names, old_bindings);
2529       /* We also need to check class_shadowed to save class-level type
2530          bindings, since pushclass doesn't fill in b->names.  */
2531       if (b->parm_flag == 2)
2532         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2533
2534       /* Unwind type-value slots back to top level.  */
2535       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2536         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2537     }
2538   s->prev = scope_chain;
2539   s->old_bindings = old_bindings;
2540   s->bindings = b;
2541   s->need_pop_function_context = need_pop;
2542   s->function_decl = current_function_decl;
2543
2544   scope_chain = s;
2545   current_function_decl = NULL_TREE;
2546   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2547   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2548   current_lang_name = lang_name_cplusplus;
2549   current_namespace = global_namespace;
2550 }
2551
2552 void
2553 push_to_top_level ()
2554 {
2555   maybe_push_to_top_level (0);
2556 }
2557
2558 void
2559 pop_from_top_level ()
2560 {
2561   struct saved_scope *s = scope_chain;
2562   tree t;
2563
2564   /* Clear out class-level bindings cache.  */
2565   if (previous_class_type)
2566     invalidate_class_lookup_cache ();
2567
2568   VARRAY_FREE (current_lang_base);
2569
2570   scope_chain = s->prev;
2571   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2572     {
2573       tree id = TREE_VEC_ELT (t, 0);
2574       if (id)
2575         {
2576           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2577           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2578           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2579         }
2580     }
2581
2582   /* If we were in the middle of compiling a function, restore our
2583      state.  */
2584   if (s->need_pop_function_context)
2585     pop_function_context_from (NULL_TREE);
2586   current_function_decl = s->function_decl;
2587
2588   free (s);
2589 }
2590 \f
2591 /* Push a definition of struct, union or enum tag "name".
2592    into binding_level "b".   "type" should be the type node,
2593    We assume that the tag "name" is not already defined.
2594
2595    Note that the definition may really be just a forward reference.
2596    In that case, the TYPE_SIZE will be a NULL_TREE.
2597
2598    C++ gratuitously puts all these tags in the name space.  */
2599
2600 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2601    record the shadowed value for this binding contour.  TYPE is
2602    the type that ID maps to.  */
2603
2604 static void
2605 set_identifier_type_value_with_scope (id, type, b)
2606      tree id;
2607      tree type;
2608      struct binding_level *b;
2609 {
2610   if (!b->namespace_p)
2611     {
2612       /* Shadow the marker, not the real thing, so that the marker
2613          gets restored later. */
2614       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2615       b->type_shadowed
2616         = tree_cons (id, old_type_value, b->type_shadowed);
2617     }
2618   else
2619     {
2620       tree binding = binding_for_name (id, current_namespace);
2621       BINDING_TYPE (binding) = type;
2622       /* Store marker instead of real type. */
2623       type = global_type_node;
2624     }
2625   SET_IDENTIFIER_TYPE_VALUE (id, type);
2626 }
2627
2628 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2629
2630 void
2631 set_identifier_type_value (id, type)
2632      tree id;
2633      tree type;
2634 {
2635   set_identifier_type_value_with_scope (id, type, current_binding_level);
2636 }
2637
2638 /* Return the type associated with id. */
2639
2640 tree
2641 identifier_type_value (id)
2642      tree id;
2643 {
2644   /* There is no type with that name, anywhere. */
2645   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2646     return NULL_TREE;
2647   /* This is not the type marker, but the real thing. */
2648   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2649     return REAL_IDENTIFIER_TYPE_VALUE (id);
2650   /* Have to search for it. It must be on the global level, now.
2651      Ask lookup_name not to return non-types. */
2652   id = lookup_name_real (id, 2, 1, 0);
2653   if (id)
2654     return TREE_TYPE (id);
2655   return NULL_TREE;
2656 }
2657
2658 /* Pop off extraneous binding levels left over due to syntax errors.
2659
2660    We don't pop past namespaces, as they might be valid.  */
2661
2662 void
2663 pop_everything ()
2664 {
2665 #ifdef DEBUG_CP_BINDING_LEVELS
2666   fprintf (stderr, "XXX entering pop_everything ()\n");
2667 #endif
2668   while (!toplevel_bindings_p ())
2669     {
2670       if (current_binding_level->parm_flag == 2)
2671         pop_nested_class ();
2672       else
2673         poplevel (0, 0, 0);
2674     }
2675 #ifdef DEBUG_CP_BINDING_LEVELS
2676   fprintf (stderr, "XXX leaving pop_everything ()\n");
2677 #endif
2678 }
2679
2680 /* The type TYPE is being declared.  If it is a class template, or a
2681    specialization of a class template, do any processing required and
2682    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2683    being declared a friend.  B is the binding level at which this TYPE
2684    should be bound.
2685
2686    Returns the TYPE_DECL for TYPE, which may have been altered by this
2687    processing.  */
2688
2689 static tree
2690 maybe_process_template_type_declaration (type, globalize, b)
2691      tree type;
2692      int globalize;
2693      struct binding_level* b;
2694 {
2695   tree decl = TYPE_NAME (type);
2696
2697   if (processing_template_parmlist)
2698     /* You can't declare a new template type in a template parameter
2699        list.  But, you can declare a non-template type:
2700
2701          template <class A*> struct S;
2702
2703        is a forward-declaration of `A'.  */
2704     ;
2705   else
2706     {
2707       maybe_check_template_type (type);
2708
2709       my_friendly_assert (IS_AGGR_TYPE (type)
2710                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2711
2712
2713       if (processing_template_decl)
2714         {
2715           /* This may change after the call to
2716              push_template_decl_real, but we want the original value.  */
2717           tree name = DECL_NAME (decl);
2718
2719           decl = push_template_decl_real (decl, globalize);
2720           /* If the current binding level is the binding level for the
2721              template parameters (see the comment in
2722              begin_template_parm_list) and the enclosing level is a class
2723              scope, and we're not looking at a friend, push the
2724              declaration of the member class into the class scope.  In the
2725              friend case, push_template_decl will already have put the
2726              friend into global scope, if appropriate.  */
2727           if (TREE_CODE (type) != ENUMERAL_TYPE
2728               && !globalize && b->template_parms_p
2729               && b->level_chain->parm_flag == 2)
2730             {
2731               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2732               /* Put this tag on the list of tags for the class, since
2733                  that won't happen below because B is not the class
2734                  binding level, but is instead the pseudo-global level.  */
2735               b->level_chain->tags =
2736                 tree_cons (name, type, b->level_chain->tags);
2737               if (!COMPLETE_TYPE_P (current_class_type))
2738                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2739             }
2740         }
2741     }
2742
2743   return decl;
2744 }
2745
2746 /* In C++, you don't have to write `struct S' to refer to `S'; you
2747    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2748    if the user had written `typedef struct S S'.  Create and return
2749    the TYPE_DECL for TYPE.  */
2750
2751 tree
2752 create_implicit_typedef (name, type)
2753      tree name;
2754      tree type;
2755 {
2756   tree decl;
2757
2758   decl = build_decl (TYPE_DECL, name, type);
2759   DECL_ARTIFICIAL (decl) = 1;
2760   /* There are other implicit type declarations, like the one *within*
2761      a class that allows you to write `S::S'.  We must distinguish
2762      amongst these.  */
2763   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2764   TYPE_NAME (type) = decl;
2765
2766   return decl;
2767 }
2768
2769 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2770    Normally put it into the inner-most non-tag-transparent scope,
2771    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2772    The latter is needed for implicit declarations.  */
2773
2774 void
2775 pushtag (name, type, globalize)
2776      tree name, type;
2777      int globalize;
2778 {
2779   register struct binding_level *b;
2780
2781   b = current_binding_level;
2782   while (b->tag_transparent
2783          || (globalize && b->parm_flag == 2))
2784     b = b->level_chain;
2785
2786   b->tags = tree_cons (name, type, b->tags);
2787
2788   if (name)
2789     {
2790       /* Do C++ gratuitous typedefing.  */
2791       if (IDENTIFIER_TYPE_VALUE (name) != type)
2792         {
2793           register tree d = NULL_TREE;
2794           int in_class = 0;
2795           tree context = TYPE_CONTEXT (type);
2796
2797           if (! context)
2798             {
2799               tree cs = current_scope ();
2800
2801               if (! globalize)
2802                 context = cs;
2803               else if (cs != NULL_TREE && TYPE_P (cs))
2804                 /* When declaring a friend class of a local class, we want
2805                    to inject the newly named class into the scope
2806                    containing the local class, not the namespace scope.  */
2807                 context = decl_function_context (get_type_decl (cs));
2808             }
2809           if (!context)
2810             context = current_namespace;
2811
2812           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2813               || b->parm_flag == 2)
2814             in_class = 1;
2815
2816           if (current_lang_name == lang_name_java)
2817             TYPE_FOR_JAVA (type) = 1;
2818
2819           d = create_implicit_typedef (name, type);
2820           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2821           if (! in_class)
2822             set_identifier_type_value_with_scope (name, type, b);
2823
2824           d = maybe_process_template_type_declaration (type,
2825                                                        globalize, b);
2826
2827           if (b->parm_flag == 2)
2828             {
2829               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2830                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2831                    class.  But if it's a member template class, we
2832                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2833                    is done later.  */
2834                 finish_member_declaration (d);
2835               else
2836                 pushdecl_class_level (d);
2837             }
2838           else
2839             d = pushdecl_with_scope (d, b);
2840
2841           if (ANON_AGGRNAME_P (name))
2842             DECL_IGNORED_P (d) = 1;
2843
2844           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2845           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2846
2847           /* If this is a local class, keep track of it.  We need this
2848              information for name-mangling, and so that it is possible to find
2849              all function definitions in a translation unit in a convenient
2850              way.  (It's otherwise tricky to find a member function definition
2851              it's only pointed to from within a local class.)  */
2852           if (TYPE_CONTEXT (type) 
2853               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2854               && !processing_template_decl)
2855             VARRAY_PUSH_TREE (local_classes, type);
2856
2857           if (!uses_template_parms (type)) 
2858             {
2859               if (flag_new_abi)
2860                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2861               else
2862                 DECL_ASSEMBLER_NAME (d)
2863                   = get_identifier (build_overload_name (type, 1, 1));
2864             }
2865         }
2866       if (b->parm_flag == 2)
2867         {
2868           if (!COMPLETE_TYPE_P (current_class_type))
2869             CLASSTYPE_TAGS (current_class_type) = b->tags;
2870         }
2871     }
2872
2873   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2874     /* Use the canonical TYPE_DECL for this node.  */
2875     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2876   else
2877     {
2878       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2879          will be the tagged type we just added to the current
2880          binding level.  This fake NULL-named TYPE_DECL node helps
2881          dwarfout.c to know when it needs to output a
2882          representation of a tagged type, and it also gives us a
2883          convenient place to record the "scope start" address for
2884          the tagged type.  */
2885
2886       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2887       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2888     }
2889 }
2890
2891 /* Counter used to create anonymous type names.  */
2892
2893 static int anon_cnt = 0;
2894
2895 /* Return an IDENTIFIER which can be used as a name for
2896    anonymous structs and unions.  */
2897
2898 tree
2899 make_anon_name ()
2900 {
2901   char buf[32];
2902
2903   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2904   return get_identifier (buf);
2905 }
2906
2907 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2908    This keeps dbxout from getting confused.  */
2909
2910 void
2911 clear_anon_tags ()
2912 {
2913   register struct binding_level *b;
2914   register tree tags;
2915   static int last_cnt = 0;
2916
2917   /* Fast out if no new anon names were declared.  */
2918   if (last_cnt == anon_cnt)
2919     return;
2920
2921   b = current_binding_level;
2922   while (b->tag_transparent)
2923     b = b->level_chain;
2924   tags = b->tags;
2925   while (tags)
2926     {
2927       /* A NULL purpose means we have already processed all tags
2928          from here to the end of the list.  */
2929       if (TREE_PURPOSE (tags) == NULL_TREE)
2930         break;
2931       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2932         TREE_PURPOSE (tags) = NULL_TREE;
2933       tags = TREE_CHAIN (tags);
2934     }
2935   last_cnt = anon_cnt;
2936 }
2937 \f
2938 /* Subroutine of duplicate_decls: return truthvalue of whether
2939    or not types of these decls match.
2940
2941    For C++, we must compare the parameter list so that `int' can match
2942    `int&' in a parameter position, but `int&' is not confused with
2943    `const int&'.  */
2944
2945 int
2946 decls_match (newdecl, olddecl)
2947      tree newdecl, olddecl;
2948 {
2949   int types_match;
2950
2951   if (newdecl == olddecl)
2952     return 1;
2953
2954   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2955     /* If the two DECLs are not even the same kind of thing, we're not
2956        interested in their types.  */
2957     return 0;
2958
2959   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2960     {
2961       tree f1 = TREE_TYPE (newdecl);
2962       tree f2 = TREE_TYPE (olddecl);
2963       tree p1 = TYPE_ARG_TYPES (f1);
2964       tree p2 = TYPE_ARG_TYPES (f2);
2965
2966       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2967           && ! (DECL_EXTERN_C_P (newdecl)
2968                 && DECL_EXTERN_C_P (olddecl)))
2969         return 0;
2970
2971       if (TREE_CODE (f1) != TREE_CODE (f2))
2972         return 0;
2973
2974       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2975         {
2976           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2977               && (DECL_BUILT_IN (olddecl)
2978 #ifndef NO_IMPLICIT_EXTERN_C
2979                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2980                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2981 #endif
2982               ))
2983             {
2984               types_match = self_promoting_args_p (p1);
2985               if (p1 == void_list_node)
2986                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2987             }
2988 #ifndef NO_IMPLICIT_EXTERN_C
2989           else if (p1 == NULL_TREE
2990                    && (DECL_EXTERN_C_P (olddecl)
2991                        && DECL_IN_SYSTEM_HEADER (olddecl)
2992                        && !DECL_CLASS_SCOPE_P (olddecl))
2993                    && (DECL_EXTERN_C_P (newdecl)
2994                        && DECL_IN_SYSTEM_HEADER (newdecl)
2995                        && !DECL_CLASS_SCOPE_P (newdecl)))
2996             {
2997               types_match = self_promoting_args_p (p2);
2998               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2999             }
3000 #endif
3001           else
3002             types_match = compparms (p1, p2);
3003         }
3004       else
3005         types_match = 0;
3006     }
3007   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3008     {
3009       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3010                                 DECL_TEMPLATE_PARMS (olddecl)))
3011         return 0;
3012
3013       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3014           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3015         return 0;
3016
3017       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3018         types_match = 1;
3019       else
3020         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3021                                    DECL_TEMPLATE_RESULT (newdecl));
3022     }
3023   else
3024     {
3025       if (TREE_TYPE (newdecl) == error_mark_node)
3026         types_match = TREE_TYPE (olddecl) == error_mark_node;
3027       else if (TREE_TYPE (olddecl) == NULL_TREE)
3028         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3029       else if (TREE_TYPE (newdecl) == NULL_TREE)
3030         types_match = 0;
3031       else
3032         types_match = comptypes (TREE_TYPE (newdecl),
3033                                  TREE_TYPE (olddecl),
3034                                  COMPARE_REDECLARATION);
3035     }
3036
3037   return types_match;
3038 }
3039
3040 /* If NEWDECL is `static' and an `extern' was seen previously,
3041    warn about it.  OLDDECL is the previous declaration.
3042
3043    Note that this does not apply to the C++ case of declaring
3044    a variable `extern const' and then later `const'.
3045
3046    Don't complain about built-in functions, since they are beyond
3047    the user's control.  */
3048
3049 static void
3050 warn_extern_redeclared_static (newdecl, olddecl)
3051      tree newdecl, olddecl;
3052 {
3053   static const char *explicit_extern_static_warning
3054     = "`%D' was declared `extern' and later `static'";
3055   static const char *implicit_extern_static_warning
3056     = "`%D' was declared implicitly `extern' and later `static'";
3057
3058   tree name;
3059
3060   if (TREE_CODE (newdecl) == TYPE_DECL
3061       || TREE_CODE (newdecl) == TEMPLATE_DECL
3062       || TREE_CODE (newdecl) == CONST_DECL)
3063     return;
3064
3065   /* Don't get confused by static member functions; that's a different
3066      use of `static'.  */
3067   if (TREE_CODE (newdecl) == FUNCTION_DECL
3068       && DECL_STATIC_FUNCTION_P (newdecl))
3069     return;
3070
3071   /* If the old declaration was `static', or the new one isn't, then
3072      then everything is OK.  */
3073   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3074     return;
3075
3076   /* It's OK to declare a builtin function as `static'.  */
3077   if (TREE_CODE (olddecl) == FUNCTION_DECL
3078       && DECL_ARTIFICIAL (olddecl))
3079     return;
3080
3081   name = DECL_ASSEMBLER_NAME (newdecl);
3082   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3083               ? implicit_extern_static_warning
3084               : explicit_extern_static_warning, newdecl);
3085   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3086 }
3087
3088 /* Handle when a new declaration NEWDECL has the same name as an old
3089    one OLDDECL in the same binding contour.  Prints an error message
3090    if appropriate.
3091
3092    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3093    Otherwise, return 0.  */
3094
3095 int
3096 duplicate_decls (newdecl, olddecl)
3097      tree newdecl, olddecl;
3098 {
3099   unsigned olddecl_uid = DECL_UID (olddecl);
3100   int olddecl_friend = 0, types_match = 0;
3101   int new_defines_function = 0;
3102
3103   if (newdecl == olddecl)
3104     return 1;
3105
3106   types_match = decls_match (newdecl, olddecl);
3107
3108   /* If either the type of the new decl or the type of the old decl is an
3109      error_mark_node, then that implies that we have already issued an
3110      error (earlier) for some bogus type specification, and in that case,
3111      it is rather pointless to harass the user with yet more error message
3112      about the same declaration, so just pretend the types match here.  */
3113   if (TREE_TYPE (newdecl) == error_mark_node
3114       || TREE_TYPE (olddecl) == error_mark_node)
3115     types_match = 1;
3116
3117   /* Check for redeclaration and other discrepancies. */
3118   if (TREE_CODE (olddecl) == FUNCTION_DECL
3119       && DECL_ARTIFICIAL (olddecl))
3120     {
3121       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3122         {
3123           /* If you declare a built-in or predefined function name as static,
3124              the old definition is overridden, but optionally warn this was a
3125              bad choice of name.  */
3126           if (! TREE_PUBLIC (newdecl))
3127             {
3128               if (warn_shadow)
3129                 cp_warning ("shadowing %s function `%#D'",
3130                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3131                             olddecl);
3132               /* Discard the old built-in function.  */
3133               return 0;
3134             }
3135           /* If the built-in is not ansi, then programs can override
3136              it even globally without an error.  */
3137           else if (! DECL_BUILT_IN (olddecl))
3138             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3139                         olddecl, newdecl);
3140           else
3141             {
3142               cp_error ("declaration of `%#D'", newdecl);
3143               cp_error ("conflicts with built-in declaration `%#D'",
3144                         olddecl);
3145             }
3146           return 0;
3147         }
3148       else if (!types_match)
3149         {
3150           if ((DECL_EXTERN_C_P (newdecl)
3151                && DECL_EXTERN_C_P (olddecl))
3152               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3153                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3154             {
3155               /* A near match; override the builtin.  */
3156
3157               if (TREE_PUBLIC (newdecl))
3158                 {
3159                   cp_warning ("new declaration `%#D'", newdecl);
3160                   cp_warning ("ambiguates built-in declaration `%#D'",
3161                               olddecl);
3162                 }
3163               else if (warn_shadow)
3164                 cp_warning ("shadowing %s function `%#D'",
3165                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3166                             olddecl);
3167             }
3168           else
3169             /* Discard the old built-in function.  */
3170             return 0;
3171         }
3172
3173       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3174         {
3175           /* If a builtin function is redeclared as `static', merge
3176              the declarations, but make the original one static.  */
3177           DECL_THIS_STATIC (olddecl) = 1;
3178           TREE_PUBLIC (olddecl) = 0;
3179
3180           /* Make the old declaration consistent with the new one so
3181              that all remnants of the builtin-ness of this function
3182              will be banished.  */
3183           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3184           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3185           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3186           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3187                                        newdecl);
3188         }
3189     }
3190   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3191     {
3192       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3193            && TREE_CODE (newdecl) != TYPE_DECL
3194            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3195                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3196           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3197               && TREE_CODE (olddecl) != TYPE_DECL
3198               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3199                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3200                         == TYPE_DECL))))
3201         {
3202           /* We do nothing special here, because C++ does such nasty
3203              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3204              get shadowed, and know that if we need to find a TYPE_DECL
3205              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3206              slot of the identifier.  */
3207           return 0;
3208         }
3209
3210       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3211            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3212           || (TREE_CODE (olddecl) == FUNCTION_DECL
3213               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3214         return 0;
3215
3216       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3217       if (TREE_CODE (olddecl) == TREE_LIST)
3218         olddecl = TREE_VALUE (olddecl);
3219       cp_error_at ("previous declaration of `%#D'", olddecl);
3220
3221       /* New decl is completely inconsistent with the old one =>
3222          tell caller to replace the old one.  */
3223
3224       return 0;
3225     }
3226   else if (!types_match)
3227     {
3228       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3229         /* These are certainly not duplicate declarations; they're
3230            from different scopes.  */
3231         return 0;
3232
3233       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3234         {
3235           /* The name of a class template may not be declared to refer to
3236              any other template, class, function, object, namespace, value,
3237              or type in the same scope.  */
3238           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3239               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3240             {
3241               cp_error ("declaration of template `%#D'", newdecl);
3242               cp_error_at ("conflicts with previous declaration `%#D'",
3243                            olddecl);
3244             }
3245           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3246                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3247                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3248                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3249                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3250                                            DECL_TEMPLATE_PARMS (olddecl)))
3251             {
3252               cp_error ("new declaration `%#D'", newdecl);
3253               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3254             }
3255           return 0;
3256         }
3257       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3258         {
3259           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3260             {
3261               cp_error ("declaration of C function `%#D' conflicts with",
3262                         newdecl);
3263               cp_error_at ("previous declaration `%#D' here", olddecl);
3264             }
3265           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3266                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3267             {
3268               cp_error ("new declaration `%#D'", newdecl);
3269               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3270             }
3271           else
3272             return 0;
3273         }
3274
3275       /* Already complained about this, so don't do so again.  */
3276       else if (current_class_type == NULL_TREE
3277           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3278         {
3279           cp_error ("conflicting types for `%#D'", newdecl);
3280           cp_error_at ("previous declaration as `%#D'", olddecl);
3281         }
3282     }
3283   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3284             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3285                  && (!DECL_TEMPLATE_INFO (newdecl)
3286                      || (DECL_TI_TEMPLATE (newdecl)
3287                          != DECL_TI_TEMPLATE (olddecl))))
3288                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3289                     && (!DECL_TEMPLATE_INFO (olddecl)
3290                         || (DECL_TI_TEMPLATE (olddecl)
3291                             != DECL_TI_TEMPLATE (newdecl))))))
3292     /* It's OK to have a template specialization and a non-template
3293        with the same type, or to have specializations of two
3294        different templates with the same type.  Note that if one is a
3295        specialization, and the other is an instantiation of the same
3296        template, that we do not exit at this point.  That situation
3297        can occur if we instantiate a template class, and then
3298        specialize one of its methods.  This situation is legal, but
3299        the declarations must be merged in the usual way.  */
3300     return 0;
3301   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3302            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3303                 && !DECL_USE_TEMPLATE (newdecl))
3304                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3305                    && !DECL_USE_TEMPLATE (olddecl))))
3306     /* One of the declarations is a template instantiation, and the
3307        other is not a template at all.  That's OK.  */
3308     return 0;
3309   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3310            && DECL_NAMESPACE_ALIAS (newdecl)
3311            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3312     /* Redeclaration of namespace alias, ignore it. */
3313     return 1;
3314   else
3315     {
3316       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3317       if (errmsg)
3318         {
3319           cp_error (errmsg, newdecl);
3320           if (DECL_NAME (olddecl) != NULL_TREE)
3321             cp_error_at ((DECL_INITIAL (olddecl)
3322                           && namespace_bindings_p ())
3323                          ? "`%#D' previously defined here"
3324                          : "`%#D' previously declared here", olddecl);
3325         }
3326       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3327                && DECL_INITIAL (olddecl) != NULL_TREE
3328                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3329                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3330         {
3331           /* Prototype decl follows defn w/o prototype.  */
3332           cp_warning_at ("prototype for `%#D'", newdecl);
3333           cp_warning_at ("follows non-prototype definition here", olddecl);
3334         }
3335       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3336                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3337         {
3338           /* extern "C" int foo ();
3339              int foo () { bar (); }
3340              is OK.  */
3341           if (current_lang_stack
3342               == &VARRAY_TREE (current_lang_base, 0))
3343             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3344           else
3345             {
3346               cp_error_at ("previous declaration of `%#D' with %L linkage",
3347                            olddecl, DECL_LANGUAGE (olddecl));
3348               cp_error ("conflicts with new declaration with %L linkage",
3349                         DECL_LANGUAGE (newdecl));
3350             }
3351         }
3352
3353       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3354         ;
3355       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3356         {
3357           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3358           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3359           int i = 1;
3360
3361           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3362             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3363
3364           for (; t1 && t1 != void_list_node;
3365                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3366             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3367               {
3368                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3369                                            TREE_PURPOSE (t2)))
3370                   {
3371                     if (pedantic)
3372                       {
3373                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3374                                     i, newdecl);
3375                         cp_pedwarn_at ("after previous specification in `%#D'",
3376                                        olddecl);
3377                       }
3378                   }
3379                 else
3380                   {
3381                     cp_error ("default argument given for parameter %d of `%#D'",
3382                               i, newdecl);
3383                     cp_error_at ("after previous specification in `%#D'",
3384                                  olddecl);
3385                   }
3386               }
3387
3388           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3389               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3390             {
3391               cp_warning ("`%#D' was used before it was declared inline",
3392                           newdecl);
3393               cp_warning_at ("previous non-inline declaration here",
3394                              olddecl);
3395             }
3396         }
3397     }
3398
3399   /* If new decl is `static' and an `extern' was seen previously,
3400      warn about it.  */
3401   warn_extern_redeclared_static (newdecl, olddecl);
3402
3403   /* We have committed to returning 1 at this point.  */
3404   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3405     {
3406       /* Now that functions must hold information normally held
3407          by field decls, there is extra work to do so that
3408          declaration information does not get destroyed during
3409          definition.  */
3410       if (DECL_VINDEX (olddecl))
3411         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3412       if (DECL_VIRTUAL_CONTEXT (olddecl))
3413         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3414       if (DECL_CONTEXT (olddecl))
3415         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3416       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3417         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3418       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3419       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3420       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3421       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3422       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3423       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3424       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3425       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3426
3427       /* Optionally warn about more than one declaration for the same
3428          name, but don't warn about a function declaration followed by a
3429          definition.  */
3430       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3431           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3432           /* Don't warn about extern decl followed by definition. */
3433           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3434           /* Don't warn about friends, let add_friend take care of it. */
3435           && ! DECL_FRIEND_P (newdecl))
3436         {
3437           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3438           cp_warning_at ("previous declaration of `%D'", olddecl);
3439         }
3440     }
3441
3442   /* Deal with C++: must preserve virtual function table size.  */
3443   if (TREE_CODE (olddecl) == TYPE_DECL)
3444     {
3445       register tree newtype = TREE_TYPE (newdecl);
3446       register tree oldtype = TREE_TYPE (olddecl);
3447
3448       if (newtype != error_mark_node && oldtype != error_mark_node
3449           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3450         {
3451           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3452           CLASSTYPE_FRIEND_CLASSES (newtype)
3453             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3454         }
3455
3456       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3457     }
3458
3459   /* Copy all the DECL_... slots specified in the new decl
3460      except for any that we copy here from the old type.  */
3461   DECL_MACHINE_ATTRIBUTES (newdecl)
3462     = merge_machine_decl_attributes (olddecl, newdecl);
3463
3464   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3465     {
3466       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3467       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3468         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3469                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3470
3471       return 1;
3472     }
3473
3474   if (types_match)
3475     {
3476       /* Automatically handles default parameters.  */
3477       tree oldtype = TREE_TYPE (olddecl);
3478       tree newtype;
3479
3480       /* Merge the data types specified in the two decls.  */
3481       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3482
3483       /* If common_type produces a non-typedef type, just use the old type.  */
3484       if (TREE_CODE (newdecl) == TYPE_DECL
3485           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3486         newtype = oldtype;
3487
3488       if (TREE_CODE (newdecl) == VAR_DECL)
3489         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3490       /* Do this after calling `common_type' so that default
3491          parameters don't confuse us.  */
3492       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3493           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3494               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3495         {
3496           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3497                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3498           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3499                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3500
3501           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3502               && DECL_SOURCE_LINE (olddecl) != 0
3503               && flag_exceptions
3504               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3505                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3506             {
3507               cp_error ("declaration of `%F' throws different exceptions",
3508                         newdecl);
3509               cp_error_at ("than previous declaration `%F'", olddecl);
3510             }
3511         }
3512       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3513
3514       /* Lay the type out, unless already done.  */
3515       if (! same_type_p (newtype, oldtype)
3516           && TREE_TYPE (newdecl) != error_mark_node
3517           && !(processing_template_decl && uses_template_parms (newdecl)))
3518         layout_type (TREE_TYPE (newdecl));
3519
3520       if ((TREE_CODE (newdecl) == VAR_DECL
3521            || TREE_CODE (newdecl) == PARM_DECL
3522            || TREE_CODE (newdecl) == RESULT_DECL
3523            || TREE_CODE (newdecl) == FIELD_DECL
3524            || TREE_CODE (newdecl) == TYPE_DECL)
3525           && !(processing_template_decl && uses_template_parms (newdecl)))
3526         layout_decl (newdecl, 0);
3527
3528       /* Merge the type qualifiers.  */
3529       if (TREE_READONLY (newdecl))
3530         TREE_READONLY (olddecl) = 1;
3531       if (TREE_THIS_VOLATILE (newdecl))
3532         TREE_THIS_VOLATILE (olddecl) = 1;
3533
3534       /* Merge the initialization information.  */
3535       if (DECL_INITIAL (newdecl) == NULL_TREE
3536           && DECL_INITIAL (olddecl) != NULL_TREE)
3537         {
3538           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3539           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3540           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3541           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3542               && DECL_LANG_SPECIFIC (newdecl)
3543               && DECL_LANG_SPECIFIC (olddecl))
3544             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3545         }
3546
3547       /* Merge the section attribute.
3548          We want to issue an error if the sections conflict but that must be
3549          done later in decl_attributes since we are called before attributes
3550          are assigned.  */
3551       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3552         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3553
3554       /* Keep the old rtl since we can safely use it.  */
3555       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3556
3557       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3558         {
3559           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3560             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3561           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3562             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3563           DECL_NO_LIMIT_STACK (newdecl)
3564             |= DECL_NO_LIMIT_STACK (olddecl);
3565         }
3566     }
3567   /* If cannot merge, then use the new type and qualifiers,
3568      and don't preserve the old rtl.  */
3569   else
3570     {
3571       /* Clean out any memory we had of the old declaration.  */
3572       tree oldstatic = value_member (olddecl, static_aggregates);
3573       if (oldstatic)
3574         TREE_VALUE (oldstatic) = error_mark_node;
3575
3576       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3577       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3578       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3579       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3580     }
3581
3582   /* Merge the storage class information.  */
3583   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3584   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3585   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3586   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3587   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3588   if (! DECL_EXTERNAL (olddecl))
3589     DECL_EXTERNAL (newdecl) = 0;
3590