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 "flags.h"
  36 #include "cp-tree.h"
  37 #include "decl.h"
  38 #include "lex.h"
  39 #include <signal.h>
  40 #include "obstack.h"
  41 #include "defaults.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "../hash.h"
  46 #include "defaults.h"
  47 #include "ggc.h"
  48
  49 #define obstack_chunk_alloc xmalloc
  50 #define obstack_chunk_free free
  51
  52 extern struct obstack permanent_obstack;
  53
  54 extern int current_class_depth;
  55
  56 extern tree static_ctors, static_dtors;
  57
  58 extern tree global_namespace;
  59
  60 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  61
  62 /* Use garbage collection.  */
  63
  64 int ggc_p = 1;
  65
  66 #ifndef WCHAR_UNSIGNED
  67 #define WCHAR_UNSIGNED 0
  68 #endif
  69
  70 #ifndef CHAR_TYPE_SIZE
  71 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  72 #endif
  73
  74 #ifndef BOOL_TYPE_SIZE
  75 #ifdef SLOW_BYTE_ACCESS
  76 /* In the new ABI, `bool' has size and alignment `1', on all
  77    platforms.  */
  78 #define BOOL_TYPE_SIZE \
  79   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  80 #else
  81 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  82 #endif
  83 #endif
  84
  85 /* We let tm.h override the types used here, to handle trivial differences
  86    such as the choice of unsigned int or long unsigned int for size_t.
  87    When machines start needing nontrivial differences in the size type,
  88    it would be best to do something here to figure out automatically
  89    from other information what type to use.  */
  90
  91 #ifndef SIZE_TYPE
  92 #define SIZE_TYPE "long unsigned int"
  93 #endif
  94
  95 #ifndef PTRDIFF_TYPE
  96 #define PTRDIFF_TYPE "long int"
  97 #endif
  98
  99 #ifndef WCHAR_TYPE
 100 #define WCHAR_TYPE "int"
 101 #endif
 102
 103 static tree grokparms                           PARAMS ((tree, int));
 104 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 105
 106 static void push_binding_level PARAMS ((struct binding_level *, int,
 107                                       int));
 108 static void pop_binding_level PARAMS ((void));
 109 static void suspend_binding_level PARAMS ((void));
 110 static void resume_binding_level PARAMS ((struct binding_level *));
 111 static struct binding_level *make_binding_level PARAMS ((void));
 112 static void declare_namespace_level PARAMS ((void));
 113 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 114 static void storedecls PARAMS ((tree));
 115 static void require_complete_types_for_parms PARAMS ((tree));
 116 static void push_overloaded_decl_1 PARAMS ((tree));
 117 static int ambi_op_p PARAMS ((tree));
 118 static int unary_op_p PARAMS ((tree));
 119 static tree store_bindings PARAMS ((tree, tree));
 120 static tree lookup_tag_reverse PARAMS ((tree, tree));
 121 static tree obscure_complex_init PARAMS ((tree, tree));
 122 static tree maybe_build_cleanup_1 PARAMS ((tree, tree));
 123 static tree lookup_name_real PARAMS ((tree, int, int, int));
 124 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 125 static void grok_reference_init PARAMS ((tree, tree, tree));
 126 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 127                               enum overload_flags, tree,
 128                               tree, int, int, int, int, int, int, tree));
 129 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 130 static tree lookup_tag PARAMS ((enum tree_code, tree,
 131                               struct binding_level *, int));
 132 static void set_identifier_type_value_with_scope
 133         PARAMS ((tree, tree, struct binding_level *));
 134 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 135 static void record_unknown_type PARAMS ((tree, const char *));
 136 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 137 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 138                                   int));
 139 static void lang_print_error_function PARAMS ((const char *));
 140 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 141 static void check_for_uninitialized_const_var PARAMS ((tree));
 142 static unsigned long typename_hash PARAMS ((hash_table_key));
 143 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 144 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 145 static int add_binding PARAMS ((tree, tree));
 146 static void pop_binding PARAMS ((tree, tree));
 147 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 148 static tree find_binding PARAMS ((tree, tree));
 149 static tree select_decl PARAMS ((tree, int));
 150 static int lookup_flags PARAMS ((int, int));
 151 static tree qualify_lookup PARAMS ((tree, int));
 152 static tree record_builtin_java_type PARAMS ((const char *, int));
 153 static const char *tag_name PARAMS ((enum tag_types code));
 154 static void find_class_binding_level PARAMS ((void));
 155 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 156 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 157 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 158 static int walk_globals_r PARAMS ((tree, void *));
 159 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 160 static tree make_label_decl PARAMS ((tree, int));
 161 static void pop_label PARAMS ((tree));
 162 static void pop_labels PARAMS ((tree));
 163 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 164 static void layout_var_decl PARAMS ((tree));
 165 static void maybe_commonize_var PARAMS ((tree));
 166 static tree check_initializer PARAMS ((tree, tree));
 167 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 168 static void push_cp_function_context PARAMS ((struct function *));
 169 static void pop_cp_function_context PARAMS ((struct function *));
 170 static void mark_binding_level PARAMS ((void *));
 171 static void mark_cp_function_context PARAMS ((struct function *));
 172 static void mark_saved_scope PARAMS ((void *));
 173 static void mark_lang_function PARAMS ((struct language_function *));
 174 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 175 static void save_function_data PARAMS ((tree));
 176 static void check_function_type PARAMS ((tree));
 177 static void destroy_local_var PARAMS ((tree));
 178 static void finish_constructor_body PARAMS ((void));
 179 static void finish_destructor_body PARAMS ((void));
 180 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 181 static tree get_atexit_node PARAMS ((void));
 182 static tree get_dso_handle_node PARAMS ((void));
 183 static tree start_cleanup_fn PARAMS ((void));
 184 static void end_cleanup_fn PARAMS ((void));
 185 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 186
 187 #if defined (DEBUG_CP_BINDING_LEVELS)
 188 static void indent PARAMS ((void));
 189 #endif
 190
 191 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 192 tree error_mark_list;
 193
 194 /* The following symbols are subsumed in the cp_global_trees array, and
 195    listed here individually for documentation purposes.
 196
 197    C++ extensions
 198         tree wchar_decl_node;
 199         tree void_zero_node;
 200
 201         tree vtable_entry_type;
 202         tree delta_type_node;
 203 #if 0
 204    Old rtti stuff.
 205         tree __baselist_desc_type_node;
 206         tree __i_desc_type_node, __m_desc_type_node;
 207         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 208 #endif
 209         tree __t_desc_type_node;
 210 #if 0
 211         tree __tp_desc_type_node;
 212 #endif
 213         tree ti_desc_type_node;
 214         tree bltn_desc_type_node, ptr_desc_type_node, ref_desc_type_node;
 215         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 216         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 217         tree ptmd_desc_type_node;
 218         tree base_desc_type_node;
 219 #if 0
 220    Not needed yet?  May be needed one day?
 221         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 222         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 223         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 224 #endif
 225
 226         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 227         tree unknown_type_node;
 228
 229    Array type `vtable_entry_type[]'
 230
 231         tree vtbl_type_node;
 232         tree vtbl_ptr_type_node;
 233
 234    Nnamespace std
 235
 236         tree std_node;
 237
 238    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 239    one that the user will declare, but sufficient to be called
 240    by routines that want to abort the program.
 241
 242         tree abort_fndecl;
 243
 244    The FUNCTION_DECL for the default `::operator delete'.
 245
 246         tree global_delete_fndecl;
 247
 248    Used by RTTI
 249         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 250         tree tinfo_var_id;
 251
 252 */
 253
 254 tree cp_global_trees[CPTI_MAX];
 255
 256 /* Indicates that there is a type value in some namespace, although
 257    that is not necessarily in scope at the moment.  */
 258
 259 static tree global_type_node;
 260
 261 /* Namespace std.  */
 262 int in_std;
 263
 264 /* Expect only namespace names now. */
 265 static int only_namespace_names;
 266
 267 /* If original DECL_RESULT of current function was a register,
 268    but due to being an addressable named return value, would up
 269    on the stack, this variable holds the named return value's
 270    original location.  */
 271
 272 #define original_result_rtx cp_function_chain->x_result_rtx
 273
 274 struct named_label_list
 275 {
 276   struct binding_level *binding_level;
 277   tree names_in_scope;
 278   tree label_decl;
 279   const char *filename_o_goto;
 280   int lineno_o_goto;
 281   struct named_label_list *next;
 282 };
 283
 284 /* Used only for jumps to as-yet undefined labels, since jumps to
 285    defined labels can have their validity checked by stmt.c.  */
 286
 287 #define named_label_uses cp_function_chain->x_named_label_uses
 288
 289 /* A list of objects which have constructors or destructors
 290    which reside in the global scope.  The decl is stored in
 291    the TREE_VALUE slot and the initializer is stored
 292    in the TREE_PURPOSE slot.  */
 293 tree static_aggregates;
 294
 295 /* -- end of C++ */
 296
 297 /* A node for the integer constants 2, and 3.  */
 298
 299 tree integer_two_node, integer_three_node;
 300
 301 /* Parsing a function declarator leaves here a chain of structure
 302    and enum types declared in the parmlist.  */
 303
 304 static tree last_function_parm_tags;
 305
 306 /* Similar, for last_function_parm_tags.  */
 307 tree last_function_parms;
 308 static tree current_function_parm_tags;
 309
 310 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 311    that have names.  Here so we can clear out their names' definitions
 312    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 313    TREE_PURPOSE is the previous binding of the label.  */
 314
 315 #define named_labels cp_function_chain->x_named_labels
 316
 317 /* Set to 0 at beginning of a function definition, and whenever
 318    a label (case or named) is defined.  Set to value of expression
 319    returned from function when that value can be transformed into
 320    a named return value.  */
 321
 322 tree current_function_return_value;
 323
 324 /* Nonzero means use the ISO C99 dialect of C.  */
 325
 326 int flag_isoc99;
 327
 328 /* Nonzero means give `double' the same size as `float'.  */
 329
 330 extern int flag_short_double;
 331
 332 /* Nonzero means don't recognize any builtin functions.  */
 333
 334 extern int flag_no_builtin;
 335
 336 /* Nonzero means don't recognize the non-ANSI builtin functions.
 337    -ansi sets this.  */
 338
 339 extern int flag_no_nonansi_builtin;
 340
 341 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 342    objects.  */
 343 extern int flag_huge_objects;
 344
 345 /* Nonzero if we want to conserve space in the .o files.  We do this
 346    by putting uninitialized data and runtime initialized data into
 347    .common instead of .data at the expense of not flagging multiple
 348    definitions.  */
 349 extern int flag_conserve_space;
 350 \f
 351 /* C and C++ flags are in decl2.c.  */
 352
 353 /* Flag used when debugging spew.c */
 354
 355 extern int spew_debug;
 356
 357 /* A expression of value 0 with the same precision as a sizetype
 358    node, but signed.  */
 359 tree signed_size_zero_node;
 360
 361 /* The name of the anonymous namespace, throughout this translation
 362    unit.  */
 363 tree anonymous_namespace_name;
 364
 365 \f
 366 /* For each binding contour we allocate a binding_level structure
 367    which records the names defined in that contour.
 368    Contours include:
 369     0) the global one
 370     1) one for each function definition,
 371        where internal declarations of the parameters appear.
 372     2) one for each compound statement,
 373        to record its declarations.
 374
 375    The current meaning of a name can be found by searching the levels
 376    from the current one out to the global one.
 377
 378    Off to the side, may be the class_binding_level.  This exists only
 379    to catch class-local declarations.  It is otherwise nonexistent.
 380
 381    Also there may be binding levels that catch cleanups that must be
 382    run when exceptions occur.  Thus, to see whether a name is bound in
 383    the current scope, it is not enough to look in the
 384    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 385    instead.  */
 386
 387 /* Note that the information in the `names' component of the global contour
 388    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 389
 390 struct binding_level
 391   {
 392     /* A chain of _DECL nodes for all variables, constants, functions,
 393        and typedef types.  These are in the reverse of the order
 394        supplied.  There may be OVERLOADs on this list, too, but they
 395        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 396     tree names;
 397
 398     /* A list of structure, union and enum definitions, for looking up
 399        tag names.
 400        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 401        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 402        or ENUMERAL_TYPE node.
 403
 404        C++: the TREE_VALUE nodes can be simple types for
 405        component_bindings.  */
 406     tree tags;
 407
 408     /* A list of USING_DECL nodes. */
 409     tree usings;
 410
 411     /* A list of used namespaces. PURPOSE is the namespace,
 412        VALUE the common ancestor with this binding_level's namespace. */
 413     tree using_directives;
 414
 415     /* If this binding level is the binding level for a class, then
 416        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 417        is the name of an entity bound in the class; the TREE_VALUE is
 418        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 419        when leaving class scope, we can restore the
 420        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 421        the DECL bound by this name in the class.  */
 422     tree class_shadowed;
 423
 424     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 425        is used for all binding levels.  */
 426     tree type_shadowed;
 427
 428     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 429        label in this scope.  The TREE_PURPOSE is the previous value of
 430        the IDENTIFIER_LABEL VALUE.  */
 431     tree shadowed_labels;
 432
 433     /* For each level (except not the global one),
 434        a chain of BLOCK nodes for all the levels
 435        that were entered and exited one level down.  */
 436     tree blocks;
 437
 438     /* The BLOCK node for this level, if one has been preallocated.
 439        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 440     tree this_block;
 441
 442     /* The _TYPE node for this level, if parm_flag == 2.  */
 443     tree this_class;
 444
 445     /* The binding level which this one is contained in (inherits from).  */
 446     struct binding_level *level_chain;
 447
 448     /* List of decls in `names' that have incomplete
 449        structure or union types.  */
 450     tree incomplete;
 451
 452     /* List of VAR_DECLS saved from a previous for statement.
 453        These would be dead in ISO-conforming code, but might
 454        be referenced in ARM-era code.  These are stored in a
 455        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 456     tree dead_vars_from_for;
 457
 458     /* 1 for the level that holds the parameters of a function.
 459        2 for the level that holds a class declaration.
 460        3 for levels that hold parameter declarations.  */
 461     unsigned parm_flag : 4;
 462
 463     /* 1 means make a BLOCK for this level regardless of all else.
 464        2 for temporary binding contours created by the compiler.  */
 465     unsigned keep : 3;
 466
 467     /* Nonzero if this level "doesn't exist" for tags.  */
 468     unsigned tag_transparent : 1;
 469
 470     /* Nonzero if this level can safely have additional
 471        cleanup-needing variables added to it.  */
 472     unsigned more_cleanups_ok : 1;
 473     unsigned have_cleanups : 1;
 474
 475     /* Nonzero if this level is for storing the decls for template
 476        parameters and generic decls; these decls will be discarded and
 477        replaced with a TEMPLATE_DECL.  */
 478     unsigned pseudo_global : 1;
 479
 480     /* This is set for a namespace binding level.  */
 481     unsigned namespace_p : 1;
 482
 483     /* True if this level is that of a for-statement where we need to
 484        worry about ambiguous (ARM or ISO) scope rules.  */
 485     unsigned is_for_scope : 1;
 486
 487     /* True if this level corresponds to an EH region, as for a try block.  */
 488     unsigned eh_region : 1;
 489
 490     /* One bit left for this word.  */
 491
 492 #if defined(DEBUG_CP_BINDING_LEVELS)
 493     /* Binding depth at which this level began.  */
 494     unsigned binding_depth;
 495 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 496   };
 497
 498 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 499
 500 /* The binding level currently in effect.  */
 501
 502 #define current_binding_level                   \
 503   (cfun                                         \
 504    ? cp_function_chain->bindings                \
 505    : scope_chain->bindings)
 506
 507 /* The binding level of the current class, if any.  */
 508
 509 #define class_binding_level scope_chain->class_bindings
 510
 511 /* A chain of binding_level structures awaiting reuse.  */
 512
 513 static struct binding_level *free_binding_level;
 514
 515 /* The outermost binding level, for names of file scope.
 516    This is created when the compiler is started and exists
 517    through the entire run.  */
 518
 519 static struct binding_level *global_binding_level;
 520
 521 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 522
 523 static int keep_next_level_flag;
 524
 525 #if defined(DEBUG_CP_BINDING_LEVELS)
 526 static int binding_depth = 0;
 527 static int is_class_level = 0;
 528
 529 static void
 530 indent ()
 531 {
 532   register unsigned i;
 533
 534   for (i = 0; i < binding_depth*2; i++)
 535     putc (' ', stderr);
 536 }
 537 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 538
 539 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 540
 541 static void
 542 push_binding_level (newlevel, tag_transparent, keep)
 543      struct binding_level *newlevel;
 544      int tag_transparent, keep;
 545 {
 546   /* Add this level to the front of the chain (stack) of levels that
 547      are active.  */
 548   bzero ((char*) newlevel, sizeof (struct binding_level));
 549   newlevel->level_chain = current_binding_level;
 550   current_binding_level = newlevel;
 551   newlevel->tag_transparent = tag_transparent;
 552   newlevel->more_cleanups_ok = 1;
 553
 554   /* We are called before expand_start_bindings, but after
 555      expand_eh_region_start for a try block; so we check this now,
 556      before the EH block is covered up.  */
 557   newlevel->eh_region = is_eh_region ();
 558
 559   newlevel->keep = keep;
 560 #if defined(DEBUG_CP_BINDING_LEVELS)
 561   newlevel->binding_depth = binding_depth;
 562   indent ();
 563   fprintf (stderr, "push %s level 0x%08x line %d\n",
 564            (is_class_level) ? "class" : "block", newlevel, lineno);
 565   is_class_level = 0;
 566   binding_depth++;
 567 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 568 }
 569
 570 /* Find the innermost enclosing class scope, and reset
 571    CLASS_BINDING_LEVEL appropriately.  */
 572
 573 static void
 574 find_class_binding_level ()
 575 {
 576   struct binding_level *level = current_binding_level;
 577
 578   while (level && level->parm_flag != 2)
 579     level = level->level_chain;
 580   if (level && level->parm_flag == 2)
 581     class_binding_level = level;
 582   else
 583     class_binding_level = 0;
 584 }
 585
 586 static void
 587 pop_binding_level ()
 588 {
 589   if (global_binding_level)
 590     {
 591       /* Cannot pop a level, if there are none left to pop.  */
 592       if (current_binding_level == global_binding_level)
 593         my_friendly_abort (123);
 594     }
 595   /* Pop the current level, and free the structure for reuse.  */
 596 #if defined(DEBUG_CP_BINDING_LEVELS)
 597   binding_depth--;
 598   indent ();
 599   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 600           (is_class_level) ? "class" : "block",
 601           current_binding_level, lineno);
 602   if (is_class_level != (current_binding_level == class_binding_level))
 603     {
 604       indent ();
 605       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 606     }
 607   is_class_level = 0;
 608 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 609   {
 610     register struct binding_level *level = current_binding_level;
 611     current_binding_level = current_binding_level->level_chain;
 612     level->level_chain = free_binding_level;
 613 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 614     if (level->binding_depth != binding_depth)
 615       abort ();
 616 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 617     free_binding_level = level;
 618     find_class_binding_level ();
 619   }
 620 }
 621
 622 static void
 623 suspend_binding_level ()
 624 {
 625   if (class_binding_level)
 626     current_binding_level = class_binding_level;
 627
 628   if (global_binding_level)
 629     {
 630       /* Cannot suspend a level, if there are none left to suspend.  */
 631       if (current_binding_level == global_binding_level)
 632         my_friendly_abort (123);
 633     }
 634   /* Suspend the current level.  */
 635 #if defined(DEBUG_CP_BINDING_LEVELS)
 636   binding_depth--;
 637   indent ();
 638   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 639           (is_class_level) ? "class" : "block",
 640           current_binding_level, lineno);
 641   if (is_class_level != (current_binding_level == class_binding_level))
 642     {
 643       indent ();
 644       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 645     }
 646   is_class_level = 0;
 647 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 648   current_binding_level = current_binding_level->level_chain;
 649   find_class_binding_level ();
 650 }
 651
 652 static void
 653 resume_binding_level (b)
 654      struct binding_level *b;
 655 {
 656   /* Resuming binding levels is meant only for namespaces,
 657      and those cannot nest into classes. */
 658   my_friendly_assert(!class_binding_level, 386);
 659   /* Also, resuming a non-directly nested namespace is a no-no.  */
 660   my_friendly_assert(b->level_chain == current_binding_level, 386);
 661   current_binding_level = b;
 662 #if defined(DEBUG_CP_BINDING_LEVELS)
 663   b->binding_depth = binding_depth;
 664   indent ();
 665   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 666            (is_class_level) ? "class" : "block", b, lineno);
 667   is_class_level = 0;
 668   binding_depth++;
 669 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 670 }
 671 \f
 672 /* Create a new `struct binding_level'.  */
 673
 674 static
 675 struct binding_level *
 676 make_binding_level ()
 677 {
 678   /* NOSTRICT */
 679   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 680 }
 681
 682 /* Nonzero if we are currently in the global binding level.  */
 683
 684 int
 685 global_bindings_p ()
 686 {
 687   return current_binding_level == global_binding_level;
 688 }
 689
 690 /* Return the innermost binding level that is not for a class scope.  */
 691
 692 static struct binding_level *
 693 innermost_nonclass_level ()
 694 {
 695   struct binding_level *b;
 696
 697   b = current_binding_level;
 698   while (b->parm_flag == 2)
 699     b = b->level_chain;
 700
 701   return b;
 702 }
 703
 704 /* Nonzero if we are currently in a toplevel binding level.  This
 705    means either the global binding level or a namespace in a toplevel
 706    binding level.  Since there are no non-toplevel namespace levels,
 707    this really means any namespace or pseudo-global level.  We also
 708    include a class whose context is toplevel.  */
 709
 710 int
 711 toplevel_bindings_p ()
 712 {
 713   struct binding_level *b = innermost_nonclass_level ();
 714
 715   return b->namespace_p || b->pseudo_global;
 716 }
 717
 718 /* Nonzero if this is a namespace scope, or if we are defining a class
 719    which is itself at namespace scope, or whose enclosing class is
 720    such a class, etc.  */
 721
 722 int
 723 namespace_bindings_p ()
 724 {
 725   struct binding_level *b = innermost_nonclass_level ();
 726
 727   return b->namespace_p;
 728 }
 729
 730 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 731    unconditionally.  Otherwise, use the normal logic to decide whether
 732    or not to create a BLOCK.  */
 733
 734 void
 735 keep_next_level (keep)
 736      int keep;
 737 {
 738   keep_next_level_flag = keep;
 739 }
 740
 741 /* Nonzero if the current level needs to have a BLOCK made.  */
 742
 743 int
 744 kept_level_p ()
 745 {
 746   return (current_binding_level->blocks != NULL_TREE
 747           || current_binding_level->keep
 748           || current_binding_level->names != NULL_TREE
 749           || (current_binding_level->tags != NULL_TREE
 750               && !current_binding_level->tag_transparent));
 751 }
 752
 753 void
 754 declare_pseudo_global_level ()
 755 {
 756   current_binding_level->pseudo_global = 1;
 757 }
 758
 759 static void
 760 declare_namespace_level ()
 761 {
 762   current_binding_level->namespace_p = 1;
 763 }
 764
 765 int
 766 pseudo_global_level_p ()
 767 {
 768   return current_binding_level->pseudo_global;
 769 }
 770
 771 void
 772 set_class_shadows (shadows)
 773      tree shadows;
 774 {
 775   class_binding_level->class_shadowed = shadows;
 776 }
 777
 778 /* Enter a new binding level.
 779    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 780    not for that of tags.  */
 781
 782 void
 783 pushlevel (tag_transparent)
 784      int tag_transparent;
 785 {
 786   struct binding_level *newlevel;
 787
 788   if (cfun && !doing_semantic_analysis_p ())
 789     return;
 790
 791   /* Reuse or create a struct for this binding level.  */
 792 #if defined(DEBUG_CP_BINDING_LEVELS)
 793   if (0)
 794 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 795   if (free_binding_level)
 796 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 797     {
 798       newlevel = free_binding_level;
 799       free_binding_level = free_binding_level->level_chain;
 800     }
 801   else
 802     newlevel = make_binding_level ();
 803
 804   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 805   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 806   keep_next_level_flag = 0;
 807 }
 808
 809 void
 810 note_level_for_for ()
 811 {
 812   current_binding_level->is_for_scope = 1;
 813 }
 814
 815 /* For a binding between a name and an entity at a block scope,
 816    this is the `struct binding_level' for the block.  */
 817 #define BINDING_LEVEL(NODE) \
 818    (((struct tree_binding*)NODE)->scope.level)
 819
 820 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 821    level at which this declaration is being bound.  */
 822
 823 static void
 824 push_binding (id, decl, level)
 825      tree id;
 826      tree decl;
 827      struct binding_level* level;
 828 {
 829   tree binding;
 830
 831   binding = make_node (CPLUS_BINDING);
 832
 833   /* Now, fill in the binding information.  */
 834   BINDING_VALUE (binding) = decl;
 835   BINDING_TYPE (binding) = NULL_TREE;
 836   BINDING_LEVEL (binding) = level;
 837   INHERITED_VALUE_BINDING_P (binding) = 0;
 838   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 839   BINDING_HAS_LEVEL_P (binding) = 1;
 840
 841   /* And put it on the front of the list of bindings for ID.  */
 842   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 843   IDENTIFIER_BINDING (id) = binding;
 844 }
 845
 846 /* ID is already bound in the current scope.  But, DECL is an
 847    additional binding for ID in the same scope.  This is the `struct
 848    stat' hack whereby a non-typedef class-name or enum-name can be
 849    bound at the same level as some other kind of entity.  It's the
 850    responsibility of the caller to check that inserting this name is
 851    legal here.  Returns nonzero if the new binding was successful.  */
 852 static int
 853 add_binding (id, decl)
 854      tree id;
 855      tree decl;
 856 {
 857   tree binding = IDENTIFIER_BINDING (id);
 858   int ok = 1;
 859
 860   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 861     /* The new name is the type name.  */
 862     BINDING_TYPE (binding) = decl;
 863   else if (!BINDING_VALUE (binding))
 864     /* This situation arises when push_class_level_binding moves an
 865        inherited type-binding out of the way to make room for a new
 866        value binding.  */
 867     BINDING_VALUE (binding) = decl;
 868   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 869            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 870     {
 871       /* The old binding was a type name.  It was placed in
 872          BINDING_VALUE because it was thought, at the point it was
 873          declared, to be the only entity with such a name.  Move the
 874          type name into the type slot; it is now hidden by the new
 875          binding.  */
 876       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 877       BINDING_VALUE (binding) = decl;
 878       INHERITED_VALUE_BINDING_P (binding) = 0;
 879     }
 880   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 881            && TREE_CODE (decl) == TYPE_DECL
 882            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 883            && same_type_p (TREE_TYPE (decl),
 884                            TREE_TYPE (BINDING_VALUE (binding))))
 885     /* We have two typedef-names, both naming the same type to have
 886        the same name.  This is OK because of:
 887
 888          [dcl.typedef]
 889
 890          In a given scope, a typedef specifier can be used to redefine
 891          the name of any type declared in that scope to refer to the
 892          type to which it already refers.  */
 893     ok = 0;
 894   else
 895     {
 896       cp_error ("declaration of `%#D'", decl);
 897       cp_error_at ("conflicts with previous declaration `%#D'",
 898                    BINDING_VALUE (binding));
 899       ok = 0;
 900     }
 901
 902   return ok;
 903 }
 904
 905 /* Add DECL to the list of things declared in B.  */
 906
 907 static void
 908 add_decl_to_level (decl, b)
 909      tree decl;
 910      struct binding_level *b;
 911 {
 912   /* We build up the list in reverse order, and reverse it later if
 913      necessary.  */
 914   TREE_CHAIN (decl) = b->names;
 915   b->names = decl;
 916 }
 917
 918 /* Bind DECL to ID in the current_binding_level, assumed to be a local
 919    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
 920    doesn't really belong to this binding level, that it got here
 921    through a using-declaration.  */
 922
 923 void
 924 push_local_binding (id, decl, flags)
 925      tree id;
 926      tree decl;
 927      int flags;
 928 {
 929   struct binding_level *b;
 930
 931   /* Skip over any local classes.  This makes sense if we call
 932      push_local_binding with a friend decl of a local class.  */
 933   b = current_binding_level;
 934   while (b->parm_flag == 2)
 935     b = b->level_chain;
 936
 937   if (lookup_name_current_level (id))
 938     {
 939       /* Supplement the existing binding.  */
 940       if (!add_binding (id, decl))
 941         /* It didn't work.  Something else must be bound at this
 942            level.  Do not add DECL to the list of things to pop
 943            later.  */
 944         return;
 945     }
 946   else
 947     /* Create a new binding.  */
 948     push_binding (id, decl, b);
 949
 950   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
 951     /* We must put the OVERLOAD into a TREE_LIST since the
 952        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
 953        decls that got here through a using-declaration.  */
 954     decl = build_tree_list (NULL_TREE, decl);
 955
 956   /* And put DECL on the list of things declared by the current
 957      binding level.  */
 958   add_decl_to_level (decl, b);
 959 }
 960
 961 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
 962    binding was successful.  */
 963
 964 int
 965 push_class_binding (id, decl)
 966      tree id;
 967      tree decl;
 968 {
 969   int result = 1;
 970   tree binding = IDENTIFIER_BINDING (id);
 971   tree context;
 972
 973   /* Note that we declared this value so that we can issue an error if
 974      this an illegal redeclaration of a name already used for some
 975      other purpose.  */
 976   note_name_declared_in_class (id, decl);
 977
 978   if (binding && BINDING_LEVEL (binding) == class_binding_level)
 979     /* Supplement the existing binding.  */
 980     result = add_binding (id, decl);
 981   else
 982     /* Create a new binding.  */
 983     push_binding (id, decl, class_binding_level);
 984
 985   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
 986      class-level declaration.  Note that we do not use DECL here
 987      because of the possibility of the `struct stat' hack; if DECL is
 988      a class-name or enum-name we might prefer a field-name, or some
 989      such.  */
 990   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
 991
 992   /* If this is a binding from a base class, mark it as such.  */
 993   binding = IDENTIFIER_BINDING (id);
 994   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
 995     {
 996       /* Any implicit typename must be from a base-class.  The
 997          context for an implicit typename declaration is always
 998          the derived class in which the lookup was done, so the checks
 999          based on the context of DECL below will not trigger.  */
1000       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1001         INHERITED_VALUE_BINDING_P (binding) = 1;
1002       else
1003         {
1004           if (TREE_CODE (decl) == OVERLOAD)
1005             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1006           else
1007             {
1008               my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1009                                   0);
1010               context = CP_DECL_CONTEXT (decl);
1011             }
1012
1013           if (is_properly_derived_from (current_class_type, context))
1014             INHERITED_VALUE_BINDING_P (binding) = 1;
1015           else
1016             INHERITED_VALUE_BINDING_P (binding) = 0;
1017         }
1018     }
1019   else if (BINDING_VALUE (binding) == decl)
1020     /* We only encounter a TREE_LIST when push_class_decls detects an
1021        ambiguity.  Such an ambiguity can be overridden by a definition
1022        in this class.  */
1023     INHERITED_VALUE_BINDING_P (binding) = 1;
1024
1025   return result;
1026 }
1027
1028 /* Remove the binding for DECL which should be the innermost binding
1029    for ID.  */
1030
1031 static void
1032 pop_binding (id, decl)
1033      tree id;
1034      tree decl;
1035 {
1036   tree binding;
1037
1038   if (id == NULL_TREE)
1039     /* It's easiest to write the loops that call this function without
1040        checking whether or not the entities involved have names.  We
1041        get here for such an entity.  */
1042     return;
1043
1044   /* Get the innermost binding for ID.  */
1045   binding = IDENTIFIER_BINDING (id);
1046
1047   /* The name should be bound.  */
1048   my_friendly_assert (binding != NULL_TREE, 0);
1049
1050   /* The DECL will be either the ordinary binding or the type
1051      binding for this identifier.  Remove that binding.  */
1052   if (BINDING_VALUE (binding) == decl)
1053     BINDING_VALUE (binding) = NULL_TREE;
1054   else if (BINDING_TYPE (binding) == decl)
1055     BINDING_TYPE (binding) = NULL_TREE;
1056   else
1057     my_friendly_abort (0);
1058
1059   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1060     /* We're completely done with the innermost binding for this
1061        identifier.  Unhook it from the list of bindings.  */
1062     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1063 }
1064
1065 /* When a label goes out of scope, check to see if that label was used
1066    in a valid manner, and issue any appropriate warnings or errors.  */
1067
1068 static void
1069 pop_label (link)
1070      tree link;
1071 {
1072   tree label = TREE_VALUE (link);
1073
1074   if (!processing_template_decl && doing_semantic_analysis_p ())
1075     {
1076       if (DECL_INITIAL (label) == NULL_TREE)
1077         {
1078           cp_error_at ("label `%D' used but not defined", label);
1079           /* Avoid crashing later.  */
1080           define_label (input_filename, 1, DECL_NAME (label));
1081         }
1082       else if (warn_unused && !TREE_USED (label))
1083         cp_warning_at ("label `%D' defined but not used", label);
1084     }
1085
1086   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1087 }
1088
1089 /* At the end of a function, all labels declared within the fucntion
1090    go out of scope.  BLOCK is the top-level block for the
1091    function.  */
1092
1093 static void
1094 pop_labels (block)
1095      tree block;
1096 {
1097   tree link;
1098
1099   /* Clear out the definitions of all label names, since their scopes
1100      end here.  */
1101   for (link = named_labels; link; link = TREE_CHAIN (link))
1102     {
1103       pop_label (link);
1104       /* Put the labels into the "variables" of the top-level block,
1105          so debugger can see them.  */
1106       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1107       BLOCK_VARS (block) = TREE_VALUE (link);
1108     }
1109
1110   named_labels = NULL_TREE;
1111 }
1112
1113 /* Exit a binding level.
1114    Pop the level off, and restore the state of the identifier-decl mappings
1115    that were in effect when this level was entered.
1116
1117    If KEEP == 1, this level had explicit declarations, so
1118    and create a "block" (a BLOCK node) for the level
1119    to record its declarations and subblocks for symbol table output.
1120
1121    If FUNCTIONBODY is nonzero, this level is the body of a function,
1122    so create a block as if KEEP were set and also clear out all
1123    label names.
1124
1125    If REVERSE is nonzero, reverse the order of decls before putting
1126    them into the BLOCK.  */
1127
1128 tree
1129 poplevel (keep, reverse, functionbody)
1130      int keep;
1131      int reverse;
1132      int functionbody;
1133 {
1134   register tree link;
1135   /* The chain of decls was accumulated in reverse order.
1136      Put it into forward order, just for cleanliness.  */
1137   tree decls;
1138   int tmp = functionbody;
1139   int real_functionbody;
1140   tree tags;
1141   tree subblocks;
1142   tree block = NULL_TREE;
1143   tree decl;
1144   int block_previously_created;
1145   int leaving_for_scope;
1146
1147   if (cfun && !doing_semantic_analysis_p ())
1148     return NULL_TREE;
1149
1150   my_friendly_assert (current_binding_level->parm_flag != 2,
1151                       19990916);
1152
1153   real_functionbody = (current_binding_level->keep == 2
1154                        ? ((functionbody = 0), tmp) : functionbody);
1155   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1156   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1157
1158   my_friendly_assert (!current_binding_level->class_shadowed,
1159                       19990414);
1160
1161   /* We used to use KEEP == 2 to indicate that the new block should go
1162      at the beginning of the list of blocks at this binding level,
1163      rather than the end.  This hack is no longer used.  */
1164   my_friendly_assert (keep == 0 || keep == 1, 0);
1165
1166   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1167                       (HOST_WIDE_INT) current_binding_level->level_chain,
1168                       current_binding_level->parm_flag,
1169                       current_binding_level->keep);
1170
1171   if (current_binding_level->keep == 1)
1172     keep = 1;
1173
1174   /* Get the decls in the order they were written.
1175      Usually current_binding_level->names is in reverse order.
1176      But parameter decls were previously put in forward order.  */
1177
1178   if (reverse)
1179     current_binding_level->names
1180       = decls = nreverse (current_binding_level->names);
1181   else
1182     decls = current_binding_level->names;
1183
1184   /* Output any nested inline functions within this block
1185      if they weren't already output.  */
1186   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1187     if (TREE_CODE (decl) == FUNCTION_DECL
1188         && ! TREE_ASM_WRITTEN (decl)
1189         && DECL_INITIAL (decl) != NULL_TREE
1190         && TREE_ADDRESSABLE (decl)
1191         && decl_function_context (decl) == current_function_decl)
1192       {
1193         /* If this decl was copied from a file-scope decl
1194            on account of a block-scope extern decl,
1195            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1196         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1197           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1198         else
1199           {
1200             push_function_context ();
1201             output_inline_function (decl);
1202             pop_function_context ();
1203           }
1204       }
1205
1206   /* When not in function-at-a-time mode, expand_end_bindings will
1207      warn about unused variables.  But, in function-at-a-time mode
1208      expand_end_bindings is not passed the list of variables in the
1209      current scope, and therefore no warning is emitted.  So, we
1210      explicitly warn here.  */
1211   if (!processing_template_decl)
1212     warn_about_unused_variables (getdecls ());
1213
1214   /* If there were any declarations or structure tags in that level,
1215      or if this level is a function body,
1216      create a BLOCK to record them for the life of this function.  */
1217   block = NULL_TREE;
1218   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1219   if (block_previously_created)
1220     block = current_binding_level->this_block;
1221   else if (keep == 1 || functionbody)
1222     block = make_node (BLOCK);
1223   if (block != NULL_TREE)
1224     {
1225       if (block_previously_created)
1226         {
1227           if (decls || tags || subblocks)
1228             {
1229               if (BLOCK_VARS (block))
1230                 warning ("internal compiler error: debugging info corrupted");
1231
1232               BLOCK_VARS (block) = decls;
1233
1234               /* We can have previous subblocks and new subblocks when
1235                  doing fixup_gotos with complex cleanups.  We chain the new
1236                  subblocks onto the end of any pre-existing subblocks.  */
1237               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1238                                                  subblocks);
1239             }
1240         }
1241       else
1242         {
1243           BLOCK_VARS (block) = decls;
1244           BLOCK_SUBBLOCKS (block) = subblocks;
1245         }
1246     }
1247
1248   /* In each subblock, record that this is its superior.  */
1249   if (keep >= 0)
1250     for (link = subblocks; link; link = TREE_CHAIN (link))
1251       BLOCK_SUPERCONTEXT (link) = block;
1252
1253   /* We still support the old for-scope rules, whereby the variables
1254      in a for-init statement were in scope after the for-statement
1255      ended.  We only use the new rules in flag_new_for_scope is
1256      nonzero.  */
1257   leaving_for_scope
1258     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1259
1260   /* Remove declarations for all the DECLs in this level.  */
1261   for (link = decls; link; link = TREE_CHAIN (link))
1262     {
1263       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1264         {
1265           tree outer_binding
1266             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1267           tree ns_binding;
1268
1269           if (!outer_binding)
1270             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1271           else
1272             ns_binding = NULL_TREE;
1273
1274           if (outer_binding
1275               && (BINDING_LEVEL (outer_binding)
1276                   == current_binding_level->level_chain))
1277             /* We have something like:
1278
1279                  int i;
1280                  for (int i; ;);
1281
1282                and we are leaving the `for' scope.  There's no reason to
1283                keep the binding of the inner `i' in this case.  */
1284             pop_binding (DECL_NAME (link), link);
1285           else if ((outer_binding
1286                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1287                         == TYPE_DECL))
1288                    || (ns_binding
1289                        && TREE_CODE (ns_binding) == TYPE_DECL))
1290             /* Here, we have something like:
1291
1292                  typedef int I;
1293
1294                  void f () {
1295                    for (int I; ;);
1296                  }
1297
1298                We must pop the for-scope binding so we know what's a
1299                type and what isn't.  */
1300             pop_binding (DECL_NAME (link), link);
1301           else
1302             {
1303               /* Mark this VAR_DECL as dead so that we can tell we left it
1304                  there only for backward compatibility.  */
1305               DECL_DEAD_FOR_LOCAL (link) = 1;
1306
1307               /* Keep track of what should of have happenned when we
1308                  popped the binding.  */
1309               if (outer_binding && BINDING_VALUE (outer_binding))
1310                 DECL_SHADOWED_FOR_VAR (link)
1311                   = BINDING_VALUE (outer_binding);
1312
1313               /* Add it to the list of dead variables in the next
1314                  outermost binding to that we can remove these when we
1315                  leave that binding.  */
1316               current_binding_level->level_chain->dead_vars_from_for
1317                 = tree_cons (NULL_TREE, link,
1318                              current_binding_level->level_chain->
1319                              dead_vars_from_for);
1320
1321               /* Although we don't pop the CPLUS_BINDING, we do clear
1322                  its BINDING_LEVEL since the level is going away now.  */
1323               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1324                 = 0;
1325             }
1326         }
1327       else
1328         {
1329           /* Remove the binding.  */
1330           decl = link;
1331           if (TREE_CODE (decl) == TREE_LIST)
1332             decl = TREE_VALUE (decl);
1333           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1334             pop_binding (DECL_NAME (decl), decl);
1335           else if (TREE_CODE (decl) == OVERLOAD)
1336             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1337           else
1338             my_friendly_abort (0);
1339         }
1340     }
1341
1342   /* Remove declarations for any `for' variables from inner scopes
1343      that we kept around.  */
1344   for (link = current_binding_level->dead_vars_from_for;
1345        link; link = TREE_CHAIN (link))
1346     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1347
1348   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1349   for (link = current_binding_level->type_shadowed;
1350        link; link = TREE_CHAIN (link))
1351     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1352
1353   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1354   for (link = current_binding_level->shadowed_labels;
1355        link;
1356        link = TREE_CHAIN (link))
1357     pop_label (link);
1358
1359   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1360      list if a `using' declaration put them there.  The debugging
1361      back-ends won't understand OVERLOAD, so we remove them here.
1362      Because the BLOCK_VARS are (temporarily) shared with
1363      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1364      popped all the bindings.  */
1365   if (block)
1366     {
1367       tree* d;
1368
1369       for (d = &BLOCK_VARS (block); *d; )
1370         {
1371           if (TREE_CODE (*d) == TREE_LIST)
1372             *d = TREE_CHAIN (*d);
1373           else
1374             d = &TREE_CHAIN (*d);
1375         }
1376     }
1377
1378   /* If the level being exited is the top level of a function,
1379      check over all the labels.  */
1380   if (functionbody)
1381     {
1382       /* Since this is the top level block of a function, the vars are
1383          the function's parameters.  Don't leave them in the BLOCK
1384          because they are found in the FUNCTION_DECL instead.  */
1385       BLOCK_VARS (block) = 0;
1386       pop_labels (block);
1387     }
1388
1389   /* Any uses of undefined labels now operate under constraints
1390      of next binding contour.  */
1391   if (cfun)
1392     {
1393       struct binding_level *level_chain;
1394       level_chain = current_binding_level->level_chain;
1395       if (level_chain)
1396         {
1397           struct named_label_list *labels;
1398           for (labels = named_label_uses; labels; labels = labels->next)
1399             if (labels->binding_level == current_binding_level)
1400               {
1401                 labels->binding_level = level_chain;
1402                 labels->names_in_scope = level_chain->names;
1403               }
1404         }
1405     }
1406
1407   tmp = current_binding_level->keep;
1408
1409   pop_binding_level ();
1410   if (functionbody)
1411     DECL_INITIAL (current_function_decl) = block;
1412   else if (block)
1413     {
1414       if (!block_previously_created)
1415         current_binding_level->blocks
1416           = chainon (current_binding_level->blocks, block);
1417     }
1418   /* If we did not make a block for the level just exited,
1419      any blocks made for inner levels
1420      (since they cannot be recorded as subblocks in that level)
1421      must be carried forward so they will later become subblocks
1422      of something else.  */
1423   else if (subblocks)
1424     current_binding_level->blocks
1425       = chainon (current_binding_level->blocks, subblocks);
1426
1427   /* Each and every BLOCK node created here in `poplevel' is important
1428      (e.g. for proper debugging information) so if we created one
1429      earlier, mark it as "used".  */
1430   if (block)
1431     TREE_USED (block) = 1;
1432
1433   /* Take care of compiler's internal binding structures.  */
1434   if (tmp == 2)
1435     {
1436       tree scope_stmts;
1437
1438       scope_stmts
1439         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1440       if (block)
1441         {
1442           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1443           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1444         }
1445
1446       block = poplevel (keep, reverse, functionbody);
1447     }
1448
1449   return block;
1450 }
1451
1452 /* Delete the node BLOCK from the current binding level.
1453    This is used for the block inside a stmt expr ({...})
1454    so that the block can be reinserted where appropriate.  */
1455
1456 void
1457 delete_block (block)
1458      tree block;
1459 {
1460   tree t;
1461   if (current_binding_level->blocks == block)
1462     current_binding_level->blocks = TREE_CHAIN (block);
1463   for (t = current_binding_level->blocks; t;)
1464     {
1465       if (TREE_CHAIN (t) == block)
1466         TREE_CHAIN (t) = TREE_CHAIN (block);
1467       else
1468         t = TREE_CHAIN (t);
1469     }
1470   TREE_CHAIN (block) = NULL_TREE;
1471   /* Clear TREE_USED which is always set by poplevel.
1472      The flag is set again if insert_block is called.  */
1473   TREE_USED (block) = 0;
1474 }
1475
1476 /* Insert BLOCK at the end of the list of subblocks of the
1477    current binding level.  This is used when a BIND_EXPR is expanded,
1478    to handle the BLOCK node inside the BIND_EXPR.  */
1479
1480 void
1481 insert_block (block)
1482      tree block;
1483 {
1484   TREE_USED (block) = 1;
1485   current_binding_level->blocks
1486     = chainon (current_binding_level->blocks, block);
1487 }
1488
1489 /* Set the BLOCK node for the innermost scope
1490    (the one we are currently in).  */
1491
1492 void
1493 set_block (block)
1494     register tree block;
1495 {
1496   current_binding_level->this_block = block;
1497 }
1498
1499 /* Do a pushlevel for class declarations.  */
1500
1501 void
1502 pushlevel_class ()
1503 {
1504   register struct binding_level *newlevel;
1505
1506   /* Reuse or create a struct for this binding level.  */
1507 #if defined(DEBUG_CP_BINDING_LEVELS)
1508   if (0)
1509 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1510   if (free_binding_level)
1511 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1512     {
1513       newlevel = free_binding_level;
1514       free_binding_level = free_binding_level->level_chain;
1515     }
1516   else
1517     newlevel = make_binding_level ();
1518
1519 #if defined(DEBUG_CP_BINDING_LEVELS)
1520   is_class_level = 1;
1521 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1522
1523   push_binding_level (newlevel, 0, 0);
1524
1525   class_binding_level = current_binding_level;
1526   class_binding_level->parm_flag = 2;
1527   class_binding_level->this_class = current_class_type;
1528 }
1529
1530 /* ...and a poplevel for class declarations.  */
1531
1532 void
1533 poplevel_class ()
1534 {
1535   register struct binding_level *level = class_binding_level;
1536   tree shadowed;
1537
1538   my_friendly_assert (level != 0, 354);
1539
1540   /* If we're leaving a toplevel class, don't bother to do the setting
1541      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1542      shouldn't even be used when current_class_type isn't set, and second,
1543      if we don't touch it here, we're able to use the cache effect if the
1544      next time we're entering a class scope, it is the same class.  */
1545   if (current_class_depth != 1)
1546     {
1547       struct binding_level* b;
1548
1549       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1550       for (shadowed = level->class_shadowed;
1551            shadowed;
1552            shadowed = TREE_CHAIN (shadowed))
1553         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1554
1555       /* Find the next enclosing class, and recreate
1556          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1557       b = level->level_chain;
1558       while (b && b->parm_flag != 2)
1559         b = b->level_chain;
1560
1561       if (b)
1562         for (shadowed = b->class_shadowed;
1563              shadowed;
1564              shadowed = TREE_CHAIN (shadowed))
1565           {
1566             tree t;
1567
1568             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1569             while (t && BINDING_LEVEL (t) != b)
1570               t = TREE_CHAIN (t);
1571
1572             if (t)
1573               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1574                 = BINDING_VALUE (t);
1575           }
1576     }
1577   else
1578     /* Remember to save what IDENTIFIER's were bound in this scope so we
1579        can recover from cache misses.  */
1580     {
1581       previous_class_type = current_class_type;
1582       previous_class_values = class_binding_level->class_shadowed;
1583     }
1584   for (shadowed = level->type_shadowed;
1585        shadowed;
1586        shadowed = TREE_CHAIN (shadowed))
1587     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1588
1589   /* Remove the bindings for all of the class-level declarations.  */
1590   for (shadowed = level->class_shadowed;
1591        shadowed;
1592        shadowed = TREE_CHAIN (shadowed))
1593     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1594
1595   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1596                       (HOST_WIDE_INT) class_binding_level->level_chain,
1597                       class_binding_level->parm_flag,
1598                       class_binding_level->keep);
1599
1600   /* Now, pop out of the binding level which we created up in the
1601      `pushlevel_class' routine.  */
1602 #if defined(DEBUG_CP_BINDING_LEVELS)
1603   is_class_level = 1;
1604 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1605
1606   pop_binding_level ();
1607 }
1608
1609 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1610    for any names in enclosing classes.  */
1611
1612 void
1613 clear_identifier_class_values ()
1614 {
1615   tree t;
1616
1617   if (!class_binding_level)
1618     return;
1619
1620   for (t = class_binding_level->class_shadowed;
1621        t;
1622        t = TREE_CHAIN (t))
1623     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1624 }
1625
1626 /* Returns non-zero if T is a virtual function table.  */
1627
1628 int
1629 vtable_decl_p (t, data)
1630      tree t;
1631      void *data ATTRIBUTE_UNUSED;
1632 {
1633   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1634 }
1635
1636 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1637    functions.  */
1638
1639 int
1640 vtype_decl_p (t, data)
1641      tree t;
1642      void *data ATTRIBUTE_UNUSED;
1643 {
1644   return (TREE_CODE (t) == TYPE_DECL
1645           && TREE_TYPE (t) != error_mark_node
1646           && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1647           && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1648 }
1649
1650 /* Return the declarations that are members of the namespace NS.  */
1651
1652 tree
1653 cp_namespace_decls (ns)
1654      tree ns;
1655 {
1656   return NAMESPACE_LEVEL (ns)->names;
1657 }
1658
1659 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1660    itself, calling F for each.  The DATA is passed to F as well.  */
1661
1662 static int
1663 walk_namespaces_r (namespace, f, data)
1664      tree namespace;
1665      walk_namespaces_fn f;
1666      void *data;
1667 {
1668   tree current;
1669   int result = 0;
1670
1671   result |= (*f) (namespace, data);
1672
1673   for (current = cp_namespace_decls (namespace);
1674        current;
1675        current = TREE_CHAIN (current))
1676     {
1677       if (TREE_CODE (current) != NAMESPACE_DECL
1678           || DECL_NAMESPACE_ALIAS (current))
1679         continue;
1680       if (!DECL_LANG_SPECIFIC (current))
1681         {
1682           /* Hmm. std. */
1683           my_friendly_assert (current == std_node, 393);
1684           continue;
1685         }
1686
1687       /* We found a namespace.  */
1688       result |= walk_namespaces_r (current, f, data);
1689     }
1690
1691   return result;
1692 }
1693
1694 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1695    F as well.  */
1696
1697 int
1698 walk_namespaces (f, data)
1699      walk_namespaces_fn f;
1700      void *data;
1701 {
1702   return walk_namespaces_r (global_namespace, f, data);
1703 }
1704
1705 struct walk_globals_data {
1706   walk_globals_pred p;
1707   walk_globals_fn f;
1708   void *data;
1709 };
1710
1711 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1712    for which P returns non-zero, call F with its address.  If any call
1713    to F returns a non-zero value, return a non-zero value.  */
1714
1715 static int
1716 walk_globals_r (namespace, data)
1717      tree namespace;
1718      void *data;
1719 {
1720   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1721   walk_globals_pred p = wgd->p;
1722   walk_globals_fn f = wgd->f;
1723   void *d = wgd->data;
1724   tree *t;
1725   int result = 0;
1726
1727   t = &NAMESPACE_LEVEL (namespace)->names;
1728
1729   while (*t)
1730     {
1731       tree glbl = *t;
1732
1733       if ((*p) (glbl, d))
1734         result |= (*f) (t, d);
1735
1736       /* If F changed *T, then *T still points at the next item to
1737          examine.  */
1738       if (*t == glbl)
1739         t = &TREE_CHAIN (*t);
1740     }
1741
1742   return result;
1743 }
1744
1745 /* Walk the global declarations.  Whenever one is found for which P
1746    returns non-zero, call F with its address.  If any call to F
1747    returns a non-zero value, return a non-zero value.  */
1748
1749 int
1750 walk_globals (p, f, data)
1751      walk_globals_pred p;
1752      walk_globals_fn f;
1753      void *data;
1754 {
1755   struct walk_globals_data wgd;
1756   wgd.p = p;
1757   wgd.f = f;
1758   wgd.data = data;
1759
1760   return walk_namespaces (walk_globals_r, &wgd);
1761 }
1762
1763 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1764    DATA is non-NULL, this is the last time we will call
1765    wrapup_global_declarations for this NAMESPACE.  */
1766
1767 int
1768 wrapup_globals_for_namespace (namespace, data)
1769      tree namespace;
1770      void *data;
1771 {
1772   tree globals = cp_namespace_decls (namespace);
1773   int len = list_length (globals);
1774   tree *vec = (tree *) alloca (sizeof (tree) * len);
1775   int i;
1776   int result;
1777   tree decl;
1778   int last_time = (data != 0);
1779
1780   if (last_time && namespace == global_namespace)
1781     /* Let compile_file handle the global namespace.  */
1782     return 0;
1783
1784   /* Process the decls in reverse order--earliest first.
1785      Put them into VEC from back to front, then take out from front.  */
1786
1787   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1788     {
1789       /* Pretend we've output an unused static variable.  This ensures
1790          that the toplevel __FUNCTION__ etc won't be emitted, unless
1791          needed. */
1792       if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
1793           && !TREE_USED (decl))
1794         TREE_ASM_WRITTEN (decl) = 1;
1795       vec[len - i - 1] = decl;
1796     }
1797
1798   if (last_time)
1799     {
1800       check_global_declarations (vec, len);
1801       return 0;
1802     }
1803
1804   /* Temporarily mark vtables as external.  That prevents
1805      wrapup_global_declarations from writing them out; we must process
1806      them ourselves in finish_vtable_vardecl.  */
1807   for (i = 0; i < len; ++i)
1808     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1809       {
1810         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1811         DECL_EXTERNAL (vec[i]) = 1;
1812       }
1813
1814   /* Write out any globals that need to be output.  */
1815   result = wrapup_global_declarations (vec, len);
1816
1817   /* Undo the hack to DECL_EXTERNAL above.  */
1818   for (i = 0; i < len; ++i)
1819     if (vtable_decl_p (vec[i], /*data=*/0)
1820         && DECL_NOT_REALLY_EXTERN (vec[i]))
1821       {
1822         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1823         DECL_EXTERNAL (vec[i]) = 0;
1824       }
1825
1826   return result;
1827 }
1828
1829 \f
1830 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1831
1832 static void
1833 mark_binding_level (arg)
1834      void *arg;
1835 {
1836   struct binding_level *lvl = *(struct binding_level **)arg;
1837
1838   while (lvl)
1839     {
1840       ggc_mark_tree (lvl->names);
1841       ggc_mark_tree (lvl->tags);
1842       ggc_mark_tree (lvl->usings);
1843       ggc_mark_tree (lvl->using_directives);
1844       ggc_mark_tree (lvl->class_shadowed);
1845       ggc_mark_tree (lvl->type_shadowed);
1846       ggc_mark_tree (lvl->shadowed_labels);
1847       ggc_mark_tree (lvl->blocks);
1848       ggc_mark_tree (lvl->this_block);
1849       ggc_mark_tree (lvl->this_class);
1850       ggc_mark_tree (lvl->incomplete);
1851       ggc_mark_tree (lvl->dead_vars_from_for);
1852
1853       lvl = lvl->level_chain;
1854     }
1855 }
1856 \f
1857 /* For debugging.  */
1858 static int no_print_functions = 0;
1859 static int no_print_builtins = 0;
1860
1861 void
1862 print_binding_level (lvl)
1863      struct binding_level *lvl;
1864 {
1865   tree t;
1866   int i = 0, len;
1867   fprintf (stderr, " blocks=");
1868   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1869   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1870            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1871   if (lvl->tag_transparent)
1872     fprintf (stderr, " tag-transparent");
1873   if (lvl->more_cleanups_ok)
1874     fprintf (stderr, " more-cleanups-ok");
1875   if (lvl->have_cleanups)
1876     fprintf (stderr, " have-cleanups");
1877   fprintf (stderr, "\n");
1878   if (lvl->names)
1879     {
1880       fprintf (stderr, " names:\t");
1881       /* We can probably fit 3 names to a line?  */
1882       for (t = lvl->names; t; t = TREE_CHAIN (t))
1883         {
1884           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1885             continue;
1886           if (no_print_builtins
1887               && (TREE_CODE (t) == TYPE_DECL)
1888               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1889             continue;
1890
1891           /* Function decls tend to have longer names.  */
1892           if (TREE_CODE (t) == FUNCTION_DECL)
1893             len = 3;
1894           else
1895             len = 2;
1896           i += len;
1897           if (i > 6)
1898             {
1899               fprintf (stderr, "\n\t");
1900               i = len;
1901             }
1902           print_node_brief (stderr, "", t, 0);
1903           if (t == error_mark_node)
1904             break;
1905         }
1906       if (i)
1907         fprintf (stderr, "\n");
1908     }
1909   if (lvl->tags)
1910     {
1911       fprintf (stderr, " tags:\t");
1912       i = 0;
1913       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1914         {
1915           if (TREE_PURPOSE (t) == NULL_TREE)
1916             len = 3;
1917           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1918             len = 2;
1919           else
1920             len = 4;
1921           i += len;
1922           if (i > 5)
1923             {
1924               fprintf (stderr, "\n\t");
1925               i = len;
1926             }
1927           if (TREE_PURPOSE (t) == NULL_TREE)
1928             {
1929               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1930               fprintf (stderr, ">");
1931             }
1932           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1933             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1934           else
1935             {
1936               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1937               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1938               fprintf (stderr, ">");
1939             }
1940         }
1941       if (i)
1942         fprintf (stderr, "\n");
1943     }
1944   if (lvl->class_shadowed)
1945     {
1946       fprintf (stderr, " class-shadowed:");
1947       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1948         {
1949           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1950         }
1951       fprintf (stderr, "\n");
1952     }
1953   if (lvl->type_shadowed)
1954     {
1955       fprintf (stderr, " type-shadowed:");
1956       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1957         {
1958           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1959         }
1960       fprintf (stderr, "\n");
1961     }
1962 }
1963
1964 void
1965 print_other_binding_stack (stack)
1966      struct binding_level *stack;
1967 {
1968   struct binding_level *level;
1969   for (level = stack; level != global_binding_level; level = level->level_chain)
1970     {
1971       fprintf (stderr, "binding level ");
1972       fprintf (stderr, HOST_PTR_PRINTF, level);
1973       fprintf (stderr, "\n");
1974       print_binding_level (level);
1975     }
1976 }
1977
1978 void
1979 print_binding_stack ()
1980 {
1981   struct binding_level *b;
1982   fprintf (stderr, "current_binding_level=");
1983   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1984   fprintf (stderr, "\nclass_binding_level=");
1985   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1986   fprintf (stderr, "\nglobal_binding_level=");
1987   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1988   fprintf (stderr, "\n");
1989   if (class_binding_level)
1990     {
1991       for (b = class_binding_level; b; b = b->level_chain)
1992         if (b == current_binding_level)
1993           break;
1994       if (b)
1995         b = class_binding_level;
1996       else
1997         b = current_binding_level;
1998     }
1999   else
2000     b = current_binding_level;
2001   print_other_binding_stack (b);
2002   fprintf (stderr, "global:\n");
2003   print_binding_level (global_binding_level);
2004 }
2005
2006 /* Namespace binding access routines: The namespace_bindings field of
2007    the identifier is polymorphic, with three possible values:
2008    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2009    indicating the BINDING_VALUE of global_namespace. */
2010
2011 /* Check whether the a binding for the name to scope is known.
2012    Assumes that the bindings of the name are already a list
2013    of bindings. Returns the binding found, or NULL_TREE. */
2014
2015 static tree
2016 find_binding (name, scope)
2017      tree name;
2018      tree scope;
2019 {
2020   tree iter, prev = NULL_TREE;
2021
2022   scope = ORIGINAL_NAMESPACE (scope);
2023
2024   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2025        iter = TREE_CHAIN (iter))
2026     {
2027       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2028       if (BINDING_SCOPE (iter) == scope)
2029         {
2030           /* Move binding found to the front of the list, so
2031              subsequent lookups will find it faster. */
2032           if (prev)
2033             {
2034               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2035               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2036               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2037             }
2038           return iter;
2039         }
2040       prev = iter;
2041     }
2042   return NULL_TREE;
2043 }
2044
2045 /* Always returns a binding for name in scope. If the
2046    namespace_bindings is not a list, convert it to one first.
2047    If no binding is found, make a new one. */
2048
2049 tree
2050 binding_for_name (name, scope)
2051      tree name;
2052      tree scope;
2053 {
2054   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2055   tree result;
2056
2057   scope = ORIGINAL_NAMESPACE (scope);
2058
2059   if (b && TREE_CODE (b) != CPLUS_BINDING)
2060     {
2061       /* Get rid of optimization for global scope. */
2062       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2063       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2064       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2065     }
2066   if (b && (result = find_binding (name, scope)))
2067     return result;
2068   /* Not found, make a new one. */
2069   result = make_node (CPLUS_BINDING);
2070   TREE_CHAIN (result) = b;
2071   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2072   BINDING_SCOPE (result) = scope;
2073   BINDING_TYPE (result) = NULL_TREE;
2074   BINDING_VALUE (result) = NULL_TREE;
2075   return result;
2076 }
2077
2078 /* Return the binding value for name in scope, considering that
2079    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2080
2081 tree
2082 namespace_binding (name, scope)
2083      tree name;
2084      tree scope;
2085 {
2086   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2087   if (b == NULL_TREE)
2088     return NULL_TREE;
2089   if (scope == NULL_TREE)
2090     scope = global_namespace;
2091   if (TREE_CODE (b) != CPLUS_BINDING)
2092     return (scope == global_namespace) ? b : NULL_TREE;
2093   name = find_binding (name,scope);
2094   if (name == NULL_TREE)
2095     return name;
2096   return BINDING_VALUE (name);
2097 }
2098
2099 /* Set the binding value for name in scope. If modifying the binding
2100    of global_namespace is attempted, try to optimize it. */
2101
2102 void
2103 set_namespace_binding (name, scope, val)
2104      tree name;
2105      tree scope;
2106      tree val;
2107 {
2108   tree b;
2109
2110   if (scope == NULL_TREE)
2111     scope = global_namespace;
2112
2113   if (scope == global_namespace)
2114     {
2115       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2116       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2117         {
2118           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2119           return;
2120         }
2121     }
2122   b = binding_for_name (name, scope);
2123   BINDING_VALUE (b) = val;
2124 }
2125
2126 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2127    select a name that is unique to this compilation unit.  */
2128
2129 void
2130 push_namespace (name)
2131      tree name;
2132 {
2133   tree d = NULL_TREE;
2134   int need_new = 1;
2135   int implicit_use = 0;
2136   int global = 0;
2137   if (!global_namespace)
2138     {
2139       /* This must be ::. */
2140       my_friendly_assert (name == get_identifier ("::"), 377);
2141       global = 1;
2142     }
2143   else if (!name)
2144     {
2145       /* The name of anonymous namespace is unique for the translation
2146          unit.  */
2147       if (!anonymous_namespace_name)
2148         anonymous_namespace_name = get_file_function_name ('N');
2149       name = anonymous_namespace_name;
2150       d = IDENTIFIER_NAMESPACE_VALUE (name);
2151       if (d)
2152         /* Reopening anonymous namespace.  */
2153         need_new = 0;
2154       implicit_use = 1;
2155     }
2156   else if (current_namespace == global_namespace
2157            && name == DECL_NAME (std_node))
2158     {
2159       in_std++;
2160       return;
2161     }
2162   else
2163     {
2164       /* Check whether this is an extended namespace definition. */
2165       d = IDENTIFIER_NAMESPACE_VALUE (name);
2166       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2167         {
2168           need_new = 0;
2169           if (DECL_NAMESPACE_ALIAS (d))
2170             {
2171               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2172                         d, DECL_NAMESPACE_ALIAS (d));
2173               d = DECL_NAMESPACE_ALIAS (d);
2174             }
2175         }
2176     }
2177
2178   if (need_new)
2179     {
2180       /* Make a new namespace, binding the name to it. */
2181       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2182       /* The global namespace is not pushed, and the global binding
2183          level is set elsewhere.  */
2184       if (!global)
2185         {
2186           d = pushdecl (d);
2187           pushlevel (0);
2188           declare_namespace_level ();
2189           NAMESPACE_LEVEL (d) = current_binding_level;
2190         }
2191     }
2192   else
2193     resume_binding_level (NAMESPACE_LEVEL (d));
2194
2195   if (implicit_use)
2196     do_using_directive (d);
2197   /* Enter the name space. */
2198   current_namespace = d;
2199 }
2200
2201 /* Pop from the scope of the current namespace.  */
2202
2203 void
2204 pop_namespace ()
2205 {
2206   if (current_namespace == global_namespace)
2207     {
2208       my_friendly_assert (in_std>0, 980421);
2209       in_std--;
2210       return;
2211     }
2212   current_namespace = CP_DECL_CONTEXT (current_namespace);
2213   /* The binding level is not popped, as it might be re-opened later.  */
2214   suspend_binding_level ();
2215 }
2216
2217 /* Push into the scope of the namespace NS, even if it is deeply
2218    nested within another namespace.  */
2219
2220 void
2221 push_nested_namespace (ns)
2222      tree ns;
2223 {
2224   if (ns == global_namespace)
2225     push_to_top_level ();
2226   else
2227     {
2228       push_nested_namespace (CP_DECL_CONTEXT (ns));
2229       push_namespace (DECL_NAME (ns));
2230     }
2231 }
2232
2233 /* Pop back from the scope of the namespace NS, which was previously
2234    entered with push_nested_namespace.  */
2235
2236 void
2237 pop_nested_namespace (ns)
2238      tree ns;
2239 {
2240   while (ns != global_namespace)
2241     {
2242       pop_namespace ();
2243       ns = CP_DECL_CONTEXT (ns);
2244     }
2245
2246   pop_from_top_level ();
2247 }
2248
2249 \f
2250 /* Subroutines for reverting temporarily to top-level for instantiation
2251    of templates and such.  We actually need to clear out the class- and
2252    local-value slots of all identifiers, so that only the global values
2253    are at all visible.  Simply setting current_binding_level to the global
2254    scope isn't enough, because more binding levels may be pushed.  */
2255 struct saved_scope *scope_chain;
2256
2257 /* Mark ST for GC.  */
2258
2259 static void
2260 mark_stmt_tree (st)
2261      struct stmt_tree *st;
2262 {
2263   ggc_mark_tree (st->x_last_stmt);
2264   ggc_mark_tree (st->x_last_expr_type);
2265 }
2266
2267 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2268
2269 static void
2270 mark_saved_scope (arg)
2271      void *arg;
2272 {
2273   struct saved_scope *t = *(struct saved_scope **)arg;
2274   while (t)
2275     {
2276       mark_binding_level (&t->class_bindings);
2277       ggc_mark_tree (t->old_bindings);
2278       ggc_mark_tree (t->old_namespace);
2279       ggc_mark_tree (t->class_name);
2280       ggc_mark_tree (t->class_type);
2281       ggc_mark_tree (t->access_specifier);
2282       ggc_mark_tree (t->function_decl);
2283       if (t->lang_base)
2284         ggc_mark_tree_varray (t->lang_base);
2285       ggc_mark_tree (t->lang_name);
2286       ggc_mark_tree (t->x_function_parms);
2287       ggc_mark_tree (t->template_parms);
2288       ggc_mark_tree (t->x_previous_class_type);
2289       ggc_mark_tree (t->x_previous_class_values);
2290       ggc_mark_tree (t->x_saved_tree);
2291       ggc_mark_tree (t->incomplete);
2292       ggc_mark_tree (t->lookups);
2293
2294       mark_stmt_tree (&t->x_stmt_tree);
2295       mark_binding_level (&t->bindings);
2296       t = t->prev;
2297     }
2298 }
2299
2300 static tree
2301 store_bindings (names, old_bindings)
2302      tree names, old_bindings;
2303 {
2304   tree t;
2305   for (t = names; t; t = TREE_CHAIN (t))
2306     {
2307       tree binding, t1, id;
2308
2309       if (TREE_CODE (t) == TREE_LIST)
2310         id = TREE_PURPOSE (t);
2311       else
2312         id = DECL_NAME (t);
2313
2314       if (!id
2315           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2316              we have no IDENTIFIER_BINDING if we have left the class
2317              scope, but cached the class-level declarations.  */
2318           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2319         continue;
2320
2321       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2322         if (TREE_VEC_ELT (t1, 0) == id)
2323           goto skip_it;
2324
2325       binding = make_tree_vec (4);
2326
2327       if (id)
2328         {
2329           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2330           TREE_VEC_ELT (binding, 0) = id;
2331           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2332           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2333           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2334           IDENTIFIER_BINDING (id) = NULL_TREE;
2335           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2336         }
2337       TREE_CHAIN (binding) = old_bindings;
2338       old_bindings = binding;
2339     skip_it:
2340       ;
2341     }
2342   return old_bindings;
2343 }
2344
2345 void
2346 maybe_push_to_top_level (pseudo)
2347      int pseudo;
2348 {
2349   struct saved_scope *s;
2350   struct binding_level *b;
2351   tree old_bindings;
2352   int need_pop;
2353
2354   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2355
2356   b = scope_chain ? current_binding_level : 0;
2357
2358   /* If we're in the middle of some function, save our state.  */
2359   if (cfun)
2360     {
2361       need_pop = 1;
2362       push_function_context_to (NULL_TREE);
2363     }
2364   else
2365     need_pop = 0;
2366
2367   old_bindings = NULL_TREE;
2368   if (scope_chain && previous_class_type)
2369     old_bindings = store_bindings (previous_class_values, old_bindings);
2370
2371   /* Have to include global_binding_level, because class-level decls
2372      aren't listed anywhere useful.  */
2373   for (; b; b = b->level_chain)
2374     {
2375       tree t;
2376
2377       /* Template IDs are inserted into the global level. If they were
2378          inserted into namespace level, finish_file wouldn't find them
2379          when doing pending instantiations. Therefore, don't stop at
2380          namespace level, but continue until :: .  */
2381       if (b == global_binding_level || (pseudo && b->pseudo_global))
2382         break;
2383
2384       old_bindings = store_bindings (b->names, old_bindings);
2385       /* We also need to check class_shadowed to save class-level type
2386          bindings, since pushclass doesn't fill in b->names.  */
2387       if (b->parm_flag == 2)
2388         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2389
2390       /* Unwind type-value slots back to top level.  */
2391       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2392         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2393     }
2394   s->prev = scope_chain;
2395   s->old_bindings = old_bindings;
2396   s->bindings = b;
2397   s->need_pop_function_context = need_pop;
2398   s->function_decl = current_function_decl;
2399
2400   scope_chain = s;
2401   current_function_decl = NULL_TREE;
2402   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2403   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2404   current_lang_name = lang_name_cplusplus;
2405   strict_prototype = strict_prototypes_lang_cplusplus;
2406   current_namespace = global_namespace;
2407 }
2408
2409 void
2410 push_to_top_level ()
2411 {
2412   maybe_push_to_top_level (0);
2413 }
2414
2415 void
2416 pop_from_top_level ()
2417 {
2418   struct saved_scope *s = scope_chain;
2419   tree t;
2420
2421   /* Clear out class-level bindings cache.  */
2422   if (previous_class_type)
2423     invalidate_class_lookup_cache ();
2424
2425   VARRAY_FREE (current_lang_base);
2426
2427   scope_chain = s->prev;
2428   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2429     {
2430       tree id = TREE_VEC_ELT (t, 0);
2431       if (id)
2432         {
2433           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2434           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2435           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2436         }
2437     }
2438
2439   if (current_lang_name == lang_name_cplusplus)
2440     strict_prototype = strict_prototypes_lang_cplusplus;
2441   else if (current_lang_name == lang_name_c)
2442     strict_prototype = strict_prototypes_lang_c;
2443
2444   /* If we were in the middle of compiling a function, restore our
2445      state.  */
2446   if (s->need_pop_function_context)
2447     pop_function_context_from (NULL_TREE);
2448   current_function_decl = s->function_decl;
2449
2450   free (s);
2451 }
2452 \f
2453 /* Push a definition of struct, union or enum tag "name".
2454    into binding_level "b".   "type" should be the type node,
2455    We assume that the tag "name" is not already defined.
2456
2457    Note that the definition may really be just a forward reference.
2458    In that case, the TYPE_SIZE will be a NULL_TREE.
2459
2460    C++ gratuitously puts all these tags in the name space.  */
2461
2462 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2463    record the shadowed value for this binding contour.  TYPE is
2464    the type that ID maps to.  */
2465
2466 static void
2467 set_identifier_type_value_with_scope (id, type, b)
2468      tree id;
2469      tree type;
2470      struct binding_level *b;
2471 {
2472   if (!b->namespace_p)
2473     {
2474       /* Shadow the marker, not the real thing, so that the marker
2475          gets restored later. */
2476       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2477       b->type_shadowed
2478         = tree_cons (id, old_type_value, b->type_shadowed);
2479     }
2480   else
2481     {
2482       tree binding = binding_for_name (id, current_namespace);
2483       BINDING_TYPE (binding) = type;
2484       /* Store marker instead of real type. */
2485       type = global_type_node;
2486     }
2487   SET_IDENTIFIER_TYPE_VALUE (id, type);
2488 }
2489
2490 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2491
2492 void
2493 set_identifier_type_value (id, type)
2494      tree id;
2495      tree type;
2496 {
2497   set_identifier_type_value_with_scope (id, type, current_binding_level);
2498 }
2499
2500 /* Return the type associated with id. */
2501
2502 tree
2503 identifier_type_value (id)
2504      tree id;
2505 {
2506   /* There is no type with that name, anywhere. */
2507   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2508     return NULL_TREE;
2509   /* This is not the type marker, but the real thing. */
2510   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2511     return REAL_IDENTIFIER_TYPE_VALUE (id);
2512   /* Have to search for it. It must be on the global level, now.
2513      Ask lookup_name not to return non-types. */
2514   id = lookup_name_real (id, 2, 1, 0);
2515   if (id)
2516     return TREE_TYPE (id);
2517   return NULL_TREE;
2518 }
2519
2520 /* Pop off extraneous binding levels left over due to syntax errors.
2521
2522    We don't pop past namespaces, as they might be valid.  */
2523
2524 void
2525 pop_everything ()
2526 {
2527 #ifdef DEBUG_CP_BINDING_LEVELS
2528   fprintf (stderr, "XXX entering pop_everything ()\n");
2529 #endif
2530   while (!toplevel_bindings_p ())
2531     {
2532       if (current_binding_level->parm_flag == 2)
2533         pop_nested_class ();
2534       else
2535         poplevel (0, 0, 0);
2536     }
2537 #ifdef DEBUG_CP_BINDING_LEVELS
2538   fprintf (stderr, "XXX leaving pop_everything ()\n");
2539 #endif
2540 }
2541
2542 /* The type TYPE is being declared.  If it is a class template, or a
2543    specialization of a class template, do any processing required and
2544    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2545    being declared a friend.  B is the binding level at which this TYPE
2546    should be bound.
2547
2548    Returns the TYPE_DECL for TYPE, which may have been altered by this
2549    processing.  */
2550
2551 static tree
2552 maybe_process_template_type_declaration (type, globalize, b)
2553      tree type;
2554      int globalize;
2555      struct binding_level* b;
2556 {
2557   tree decl = TYPE_NAME (type);
2558
2559   if (processing_template_parmlist)
2560     /* You can't declare a new template type in a template parameter
2561        list.  But, you can declare a non-template type:
2562
2563          template <class A*> struct S;
2564
2565        is a forward-declaration of `A'.  */
2566     ;
2567   else
2568     {
2569       maybe_check_template_type (type);
2570
2571       my_friendly_assert (IS_AGGR_TYPE (type)
2572                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2573
2574
2575       if (processing_template_decl)
2576         {
2577           /* This may change after the call to
2578              push_template_decl_real, but we want the original value.  */
2579           tree name = DECL_NAME (decl);
2580
2581           decl = push_template_decl_real (decl, globalize);
2582           /* If the current binding level is the binding level for the
2583              template parameters (see the comment in
2584              begin_template_parm_list) and the enclosing level is a class
2585              scope, and we're not looking at a friend, push the
2586              declaration of the member class into the class scope.  In the
2587              friend case, push_template_decl will already have put the
2588              friend into global scope, if appropriate.  */
2589           if (TREE_CODE (type) != ENUMERAL_TYPE
2590               && !globalize && b->pseudo_global
2591               && b->level_chain->parm_flag == 2)
2592             {
2593               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2594               /* Put this tag on the list of tags for the class, since
2595                  that won't happen below because B is not the class
2596                  binding level, but is instead the pseudo-global level.  */
2597               b->level_chain->tags =
2598                 tree_cons (name, type, b->level_chain->tags);
2599               if (TYPE_SIZE (current_class_type) == NULL_TREE)
2600                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2601             }
2602         }
2603     }
2604
2605   return decl;
2606 }
2607
2608 /* In C++, you don't have to write `struct S' to refer to `S'; you
2609    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2610    if the user had written `typedef struct S S'.  Create and return
2611    the TYPE_DECL for TYPE.  */
2612
2613 tree
2614 create_implicit_typedef (name, type)
2615      tree name;
2616      tree type;
2617 {
2618   tree decl;
2619
2620   decl = build_decl (TYPE_DECL, name, type);
2621   SET_DECL_ARTIFICIAL (decl);
2622   /* There are other implicit type declarations, like the one *within*
2623      a class that allows you to write `S::S'.  We must distinguish
2624      amongst these.  */
2625   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2626   TYPE_NAME (type) = decl;
2627
2628   return decl;
2629 }
2630
2631 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2632    Normally put it into the inner-most non-tag-transparent scope,
2633    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2634    The latter is needed for implicit declarations.  */
2635
2636 void
2637 pushtag (name, type, globalize)
2638      tree name, type;
2639      int globalize;
2640 {
2641   register struct binding_level *b;
2642
2643   b = current_binding_level;
2644   while (b->tag_transparent
2645          || (globalize && b->parm_flag == 2))
2646     b = b->level_chain;
2647
2648   b->tags = tree_cons (name, type, b->tags);
2649
2650   if (name)
2651     {
2652       /* Do C++ gratuitous typedefing.  */
2653       if (IDENTIFIER_TYPE_VALUE (name) != type)
2654         {
2655           register tree d = NULL_TREE;
2656           int in_class = 0;
2657           tree context = TYPE_CONTEXT (type);
2658
2659           if (! context)
2660             {
2661               tree cs = current_scope ();
2662
2663               if (! globalize)
2664                 context = cs;
2665               else if (cs != NULL_TREE
2666                        && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2667                 /* When declaring a friend class of a local class, we want
2668                    to inject the newly named class into the scope
2669                    containing the local class, not the namespace scope.  */
2670                 context = decl_function_context (get_type_decl (cs));
2671             }
2672           if (!context)
2673             context = current_namespace;
2674
2675           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2676               || b->parm_flag == 2)
2677             in_class = 1;
2678
2679           if (current_lang_name == lang_name_java)
2680             TYPE_FOR_JAVA (type) = 1;
2681
2682           d = create_implicit_typedef (name, type);
2683           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2684           if (! in_class)
2685             set_identifier_type_value_with_scope (name, type, b);
2686
2687           d = maybe_process_template_type_declaration (type,
2688                                                        globalize, b);
2689
2690           if (b->parm_flag == 2)
2691             {
2692               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2693                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2694                    class.  But if it's a member template class, we
2695                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2696                    is done later.  */
2697                 finish_member_declaration (d);
2698               else
2699                 pushdecl_class_level (d);
2700             }
2701           else
2702             d = pushdecl_with_scope (d, b);
2703
2704           if (ANON_AGGRNAME_P (name))
2705             DECL_IGNORED_P (d) = 1;
2706
2707           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2708           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2709           if (!uses_template_parms (type))
2710             DECL_ASSEMBLER_NAME (d)
2711               = get_identifier (build_overload_name (type, 1, 1));
2712         }
2713       if (b->parm_flag == 2)
2714         {
2715           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2716             CLASSTYPE_TAGS (current_class_type) = b->tags;
2717         }
2718     }
2719
2720   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2721     /* Use the canonical TYPE_DECL for this node.  */
2722     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2723   else
2724     {
2725       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2726          will be the tagged type we just added to the current
2727          binding level.  This fake NULL-named TYPE_DECL node helps
2728          dwarfout.c to know when it needs to output a
2729          representation of a tagged type, and it also gives us a
2730          convenient place to record the "scope start" address for
2731          the tagged type.  */
2732
2733       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2734       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2735     }
2736 }
2737
2738 /* Counter used to create anonymous type names.  */
2739
2740 static int anon_cnt = 0;
2741
2742 /* Return an IDENTIFIER which can be used as a name for
2743    anonymous structs and unions.  */
2744
2745 tree
2746 make_anon_name ()
2747 {
2748   char buf[32];
2749
2750   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2751   return get_identifier (buf);
2752 }
2753
2754 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2755    This keeps dbxout from getting confused.  */
2756
2757 void
2758 clear_anon_tags ()
2759 {
2760   register struct binding_level *b;
2761   register tree tags;
2762   static int last_cnt = 0;
2763
2764   /* Fast out if no new anon names were declared.  */
2765   if (last_cnt == anon_cnt)
2766     return;
2767
2768   b = current_binding_level;
2769   while (b->tag_transparent)
2770     b = b->level_chain;
2771   tags = b->tags;
2772   while (tags)
2773     {
2774       /* A NULL purpose means we have already processed all tags
2775          from here to the end of the list.  */
2776       if (TREE_PURPOSE (tags) == NULL_TREE)
2777         break;
2778       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2779         TREE_PURPOSE (tags) = NULL_TREE;
2780       tags = TREE_CHAIN (tags);
2781     }
2782   last_cnt = anon_cnt;
2783 }
2784 \f
2785 /* Subroutine of duplicate_decls: return truthvalue of whether
2786    or not types of these decls match.
2787
2788    For C++, we must compare the parameter list so that `int' can match
2789    `int&' in a parameter position, but `int&' is not confused with
2790    `const int&'.  */
2791
2792 int
2793 decls_match (newdecl, olddecl)
2794      tree newdecl, olddecl;
2795 {
2796   int types_match;
2797
2798   if (newdecl == olddecl)
2799     return 1;
2800
2801   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2802     /* If the two DECLs are not even the same kind of thing, we're not
2803        interested in their types.  */
2804     return 0;
2805
2806   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2807     {
2808       tree f1 = TREE_TYPE (newdecl);
2809       tree f2 = TREE_TYPE (olddecl);
2810       tree p1 = TYPE_ARG_TYPES (f1);
2811       tree p2 = TYPE_ARG_TYPES (f2);
2812
2813       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2814           && ! (DECL_LANGUAGE (newdecl) == lang_c
2815                 && DECL_LANGUAGE (olddecl) == lang_c))
2816         return 0;
2817
2818       if (TREE_CODE (f1) != TREE_CODE (f2))
2819         return 0;
2820
2821       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2822         {
2823           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2824               && p2 == NULL_TREE)
2825             {
2826               types_match = self_promoting_args_p (p1);
2827               if (p1 == void_list_node)
2828                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2829             }
2830           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2831                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2832             {
2833               types_match = self_promoting_args_p (p2);
2834               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2835             }
2836           else
2837             types_match = compparms (p1, p2);
2838         }
2839       else
2840         types_match = 0;
2841     }
2842   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2843     {
2844       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2845                                 DECL_TEMPLATE_PARMS (olddecl)))
2846         return 0;
2847
2848       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2849         types_match = 1;
2850       else
2851         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2852                                    DECL_TEMPLATE_RESULT (newdecl));
2853     }
2854   else
2855     {
2856       if (TREE_TYPE (newdecl) == error_mark_node)
2857         types_match = TREE_TYPE (olddecl) == error_mark_node;
2858       else if (TREE_TYPE (olddecl) == NULL_TREE)
2859         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2860       else if (TREE_TYPE (newdecl) == NULL_TREE)
2861         types_match = 0;
2862       else
2863         types_match = comptypes (TREE_TYPE (newdecl),
2864                                  TREE_TYPE (olddecl),
2865                                  COMPARE_REDECLARATION);
2866     }
2867
2868   return types_match;
2869 }
2870
2871 /* If NEWDECL is `static' and an `extern' was seen previously,
2872    warn about it.  OLDDECL is the previous declaration.
2873
2874    Note that this does not apply to the C++ case of declaring
2875    a variable `extern const' and then later `const'.
2876
2877    Don't complain about built-in functions, since they are beyond
2878    the user's control.  */
2879
2880 static void
2881 warn_extern_redeclared_static (newdecl, olddecl)
2882      tree newdecl, olddecl;
2883 {
2884   static const char *explicit_extern_static_warning
2885     = "`%D' was declared `extern' and later `static'";
2886   static const char *implicit_extern_static_warning
2887     = "`%D' was declared implicitly `extern' and later `static'";
2888
2889   tree name;
2890
2891   if (TREE_CODE (newdecl) == TYPE_DECL
2892       || TREE_CODE (newdecl) == TEMPLATE_DECL)
2893     return;
2894
2895   /* Don't get confused by static member functions; that's a different
2896      use of `static'.  */
2897   if (TREE_CODE (newdecl) == FUNCTION_DECL
2898       && DECL_STATIC_FUNCTION_P (newdecl))
2899     return;
2900
2901   /* If the old declaration was `static', or the new one isn't, then
2902      then everything is OK.  */
2903   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2904     return;
2905
2906   /* It's OK to declare a builtin function as `static'.  */
2907   if (TREE_CODE (olddecl) == FUNCTION_DECL
2908       && DECL_ARTIFICIAL (olddecl))
2909     return;
2910
2911   name = DECL_ASSEMBLER_NAME (newdecl);
2912   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2913               ? implicit_extern_static_warning
2914               : explicit_extern_static_warning, newdecl);
2915   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2916 }
2917
2918 /* Handle when a new declaration NEWDECL has the same name as an old
2919    one OLDDECL in the same binding contour.  Prints an error message
2920    if appropriate.
2921
2922    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2923    Otherwise, return 0.  */
2924
2925 int
2926 duplicate_decls (newdecl, olddecl)
2927      tree newdecl, olddecl;
2928 {
2929   unsigned olddecl_uid = DECL_UID (olddecl);
2930   int olddecl_friend = 0, types_match = 0;
2931   int new_defines_function = 0;
2932
2933   if (newdecl == olddecl)
2934     return 1;
2935
2936   types_match = decls_match (newdecl, olddecl);
2937
2938   /* If either the type of the new decl or the type of the old decl is an
2939      error_mark_node, then that implies that we have already issued an
2940      error (earlier) for some bogus type specification, and in that case,
2941      it is rather pointless to harass the user with yet more error message
2942      about the same declaration, so just pretend the types match here.  */
2943   if (TREE_TYPE (newdecl) == error_mark_node
2944       || TREE_TYPE (olddecl) == error_mark_node)
2945     types_match = 1;
2946
2947   /* Check for redeclaration and other discrepancies. */
2948   if (TREE_CODE (olddecl) == FUNCTION_DECL
2949       && DECL_ARTIFICIAL (olddecl))
2950     {
2951       if (TREE_CODE (newdecl) != FUNCTION_DECL)
2952         {
2953           /* If you declare a built-in or predefined function name as static,
2954              the old definition is overridden, but optionally warn this was a
2955              bad choice of name.  */
2956           if (! TREE_PUBLIC (newdecl))
2957             {
2958               if (warn_shadow)
2959                 cp_warning ("shadowing %s function `%#D'",
2960                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2961                             olddecl);
2962               /* Discard the old built-in function.  */
2963               return 0;
2964             }
2965           /* If the built-in is not ansi, then programs can override
2966              it even globally without an error.  */
2967           else if (! DECL_BUILT_IN (olddecl))
2968             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2969                         olddecl, newdecl);
2970           else
2971             {
2972               cp_error ("declaration of `%#D'", newdecl);
2973               cp_error ("conflicts with built-in declaration `%#D'",
2974                         olddecl);
2975             }
2976           return 0;
2977         }
2978       else if (!types_match)
2979         {
2980           if ((DECL_LANGUAGE (newdecl) == lang_c
2981                && DECL_LANGUAGE (olddecl) == lang_c)
2982               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2983                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
2984             {
2985               /* A near match; override the builtin.  */
2986
2987               if (TREE_PUBLIC (newdecl))
2988                 {
2989                   cp_warning ("new declaration `%#D'", newdecl);
2990                   cp_warning ("ambiguates built-in declaration `%#D'",
2991                               olddecl);
2992                 }
2993               else if (warn_shadow)
2994                 cp_warning ("shadowing %s function `%#D'",
2995                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2996                             olddecl);
2997             }
2998           else
2999             /* Discard the old built-in function.  */
3000             return 0;
3001         }
3002
3003       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3004         {
3005           /* If a builtin function is redeclared as `static', merge
3006              the declarations, but make the original one static.  */
3007           DECL_THIS_STATIC (olddecl) = 1;
3008           TREE_PUBLIC (olddecl) = 0;
3009
3010           /* Make the olddeclaration consistent with the new one so that
3011              all remnants of the builtin-ness of this function will be
3012              banished.  */
3013           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3014           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3015           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3016           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3017                                        newdecl);
3018         }
3019     }
3020   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3021     {
3022       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3023            && TREE_CODE (newdecl) != TYPE_DECL
3024            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3025                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3026           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3027               && TREE_CODE (olddecl) != TYPE_DECL
3028               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3029                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3030                         == TYPE_DECL))))
3031         {
3032           /* We do nothing special here, because C++ does such nasty
3033              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3034              get shadowed, and know that if we need to find a TYPE_DECL
3035              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3036              slot of the identifier.  */
3037           return 0;
3038         }
3039
3040       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3041            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3042           || (TREE_CODE (olddecl) == FUNCTION_DECL
3043               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3044         return 0;
3045
3046       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3047       if (TREE_CODE (olddecl) == TREE_LIST)
3048         olddecl = TREE_VALUE (olddecl);
3049       cp_error_at ("previous declaration of `%#D'", olddecl);
3050
3051       /* New decl is completely inconsistent with the old one =>
3052          tell caller to replace the old one.  */
3053
3054       return 0;
3055     }
3056   else if (!types_match)
3057     {
3058       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3059         /* These are certainly not duplicate declarations; they're
3060            from different scopes.  */
3061         return 0;
3062
3063       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3064         {
3065           /* The name of a class template may not be declared to refer to
3066              any other template, class, function, object, namespace, value,
3067              or type in the same scope.  */
3068           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3069               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3070             {
3071               cp_error ("declaration of template `%#D'", newdecl);
3072               cp_error_at ("conflicts with previous declaration `%#D'",
3073                            olddecl);
3074             }
3075           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3076                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3077                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3078                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3079                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3080                                            DECL_TEMPLATE_PARMS (olddecl)))
3081             {
3082               cp_error ("new declaration `%#D'", newdecl);
3083               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3084             }
3085           return 0;
3086         }
3087       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3088         {
3089           if (DECL_LANGUAGE (newdecl) == lang_c
3090               && DECL_LANGUAGE (olddecl) == lang_c)
3091             {
3092               cp_error ("declaration of C function `%#D' conflicts with",
3093                         newdecl);
3094               cp_error_at ("previous declaration `%#D' here", olddecl);
3095             }
3096           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3097                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3098             {
3099               cp_error ("new declaration `%#D'", newdecl);
3100               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3101             }
3102           else
3103             return 0;
3104         }
3105
3106       /* Already complained about this, so don't do so again.  */
3107       else if (current_class_type == NULL_TREE
3108           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3109         {
3110           cp_error ("conflicting types for `%#D'", newdecl);
3111           cp_error_at ("previous declaration as `%#D'", olddecl);
3112         }
3113     }
3114   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3115             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3116                  && (!DECL_TEMPLATE_INFO (newdecl)
3117                      || (DECL_TI_TEMPLATE (newdecl)
3118                          != DECL_TI_TEMPLATE (olddecl))))
3119                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3120                     && (!DECL_TEMPLATE_INFO (olddecl)
3121                         || (DECL_TI_TEMPLATE (olddecl)
3122                             != DECL_TI_TEMPLATE (newdecl))))))
3123     /* It's OK to have a template specialization and a non-template
3124        with the same type, or to have specializations of two
3125        different templates with the same type.  Note that if one is a
3126        specialization, and the other is an instantiation of the same
3127        template, that we do not exit at this point.  That situation
3128        can occur if we instantiate a template class, and then
3129        specialize one of its methods.  This situation is legal, but
3130        the declarations must be merged in the usual way.  */
3131     return 0;
3132   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3133            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3134                 && !DECL_USE_TEMPLATE (newdecl))
3135                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3136                    && !DECL_USE_TEMPLATE (olddecl))))
3137     /* One of the declarations is a template instantiation, and the
3138        other is not a template at all.  That's OK.  */
3139     return 0;
3140   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3141            && DECL_NAMESPACE_ALIAS (newdecl)
3142            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3143     /* Redeclaration of namespace alias, ignore it. */
3144     return 1;
3145   else
3146     {
3147       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3148       if (errmsg)
3149         {
3150           cp_error (errmsg, newdecl);
3151           if (DECL_NAME (olddecl) != NULL_TREE)
3152             cp_error_at ((DECL_INITIAL (olddecl)
3153                           && namespace_bindings_p ())
3154                          ? "`%#D' previously defined here"
3155                          : "`%#D' previously declared here", olddecl);
3156         }
3157       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3158                && DECL_INITIAL (olddecl) != NULL_TREE
3159                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3160                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3161         {
3162           /* Prototype decl follows defn w/o prototype.  */
3163           cp_warning_at ("prototype for `%#D'", newdecl);
3164           cp_warning_at ("follows non-prototype definition here", olddecl);
3165         }
3166       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3167                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3168         {
3169           /* extern "C" int foo ();
3170              int foo () { bar (); }
3171              is OK.  */
3172           if (current_lang_stack
3173               == &VARRAY_TREE (current_lang_base, 0))
3174             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3175           else
3176             {
3177               cp_error_at ("previous declaration of `%#D' with %L linkage",
3178                            olddecl, DECL_LANGUAGE (olddecl));
3179               cp_error ("conflicts with new declaration with %L linkage",
3180                         DECL_LANGUAGE (newdecl));
3181             }
3182         }
3183
3184       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3185         ;
3186       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3187         {
3188           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3189           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3190           int i = 1;
3191
3192           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3193             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3194
3195           for (; t1 && t1 != void_list_node;
3196                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3197             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3198               {
3199                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3200                                            TREE_PURPOSE (t2)))
3201                   {
3202                     if (pedantic)
3203                       {
3204                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3205                                     i, newdecl);
3206                         cp_pedwarn_at ("after previous specification in `%#D'",
3207                                        olddecl);
3208                       }
3209                   }
3210                 else
3211                   {
3212                     cp_error ("default argument given for parameter %d of `%#D'",
3213                               i, newdecl);
3214                     cp_error_at ("after previous specification in `%#D'",
3215                                  olddecl);
3216                   }
3217               }
3218
3219           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3220               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3221             {
3222               cp_warning ("`%#D' was used before it was declared inline",
3223                           newdecl);
3224               cp_warning_at ("previous non-inline declaration here",
3225                              olddecl);
3226             }
3227         }
3228     }
3229
3230   /* If new decl is `static' and an `extern' was seen previously,
3231      warn about it.  */
3232   warn_extern_redeclared_static (newdecl, olddecl);
3233
3234   /* We have committed to returning 1 at this point.  */
3235   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3236     {
3237       /* Now that functions must hold information normally held
3238          by field decls, there is extra work to do so that
3239          declaration information does not get destroyed during
3240          definition.  */
3241       if (DECL_VINDEX (olddecl))
3242         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3243       if (DECL_VIRTUAL_CONTEXT (olddecl))
3244         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3245       if (DECL_CONTEXT (olddecl))
3246         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3247       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3248         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3249       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3250       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3251       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3252       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3253       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3254       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3255       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3256
3257       /* Optionally warn about more than one declaration for the same
3258          name, but don't warn about a function declaration followed by a
3259          definition.  */
3260       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3261           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3262           /* Don't warn about extern decl followed by definition. */
3263           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3264           /* Don't warn about friends, let add_friend take care of it. */
3265           && ! DECL_FRIEND_P (newdecl))
3266         {
3267           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3268           cp_warning_at ("previous declaration of `%D'", olddecl);
3269         }
3270     }
3271
3272   /* Deal with C++: must preserve virtual function table size.  */
3273   if (TREE_CODE (olddecl) == TYPE_DECL)
3274     {
3275       register tree newtype = TREE_TYPE (newdecl);
3276       register tree oldtype = TREE_TYPE (olddecl);
3277
3278       if (newtype != error_mark_node && oldtype != error_mark_node
3279           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3280         {
3281           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3282           CLASSTYPE_FRIEND_CLASSES (newtype)
3283             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3284         }
3285     }
3286
3287   /* Copy all the DECL_... slots specified in the new decl
3288      except for any that we copy here from the old type.  */
3289   DECL_MACHINE_ATTRIBUTES (newdecl)
3290     = merge_machine_decl_attributes (olddecl, newdecl);
3291
3292   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3293     {
3294       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3295                              DECL_TEMPLATE_RESULT (olddecl)))
3296         cp_error ("invalid redeclaration of %D", newdecl);
3297       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3298       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3299         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3300                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3301
3302       return 1;
3303     }
3304
3305   if (types_match)
3306     {
3307       /* Automatically handles default parameters.  */
3308       tree oldtype = TREE_TYPE (olddecl);
3309       tree newtype;
3310
3311       /* Merge the data types specified in the two decls.  */
3312       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3313
3314       if (TREE_CODE (newdecl) == VAR_DECL)
3315         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3316       /* Do this after calling `common_type' so that default
3317          parameters don't confuse us.  */
3318       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3319           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3320               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3321         {
3322           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3323                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3324           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3325                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3326
3327           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3328               && DECL_SOURCE_LINE (olddecl) != 0
3329               && flag_exceptions
3330               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3331                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3332             {
3333               cp_error ("declaration of `%F' throws different exceptions",
3334                         newdecl);
3335               cp_error_at ("than previous declaration `%F'", olddecl);
3336             }
3337         }
3338       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3339
3340       /* Lay the type out, unless already done.  */
3341       if (! same_type_p (newtype, oldtype)
3342           && TREE_TYPE (newdecl) != error_mark_node
3343           && !(processing_template_decl && uses_template_parms (newdecl)))
3344         layout_type (TREE_TYPE (newdecl));
3345
3346       if ((TREE_CODE (newdecl) == VAR_DECL
3347            || TREE_CODE (newdecl) == PARM_DECL
3348            || TREE_CODE (newdecl) == RESULT_DECL
3349            || TREE_CODE (newdecl) == FIELD_DECL
3350            || TREE_CODE (newdecl) == TYPE_DECL)
3351           && !(processing_template_decl && uses_template_parms (newdecl)))
3352         layout_decl (newdecl, 0);
3353
3354       /* Merge the type qualifiers.  */
3355       if (TREE_READONLY (newdecl))
3356         TREE_READONLY (olddecl) = 1;
3357       if (TREE_THIS_VOLATILE (newdecl))
3358         TREE_THIS_VOLATILE (olddecl) = 1;
3359
3360       /* Merge the initialization information.  */
3361       if (DECL_INITIAL (newdecl) == NULL_TREE
3362           && DECL_INITIAL (olddecl) != NULL_TREE)
3363         {
3364           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3365           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3366           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3367           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3368               && DECL_LANG_SPECIFIC (newdecl)
3369               && DECL_LANG_SPECIFIC (olddecl))
3370             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3371         }
3372
3373       /* Merge the section attribute.
3374          We want to issue an error if the sections conflict but that must be
3375          done later in decl_attributes since we are called before attributes
3376          are assigned.  */
3377       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3378         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3379
3380       /* Keep the old rtl since we can safely use it.  */
3381       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3382
3383       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3384         {
3385           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3386             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3387           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3388             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3389           DECL_NO_LIMIT_STACK (newdecl)
3390             |= DECL_NO_LIMIT_STACK (olddecl);
3391         }
3392     }
3393   /* If cannot merge, then use the new type and qualifiers,
3394      and don't preserve the old rtl.  */
3395   else
3396     {
3397       /* Clean out any memory we had of the old declaration.  */
3398       tree oldstatic = value_member (olddecl, static_aggregates);
3399       if (oldstatic)
3400         TREE_VALUE (oldstatic) = error_mark_node;
3401
3402       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3403       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3404       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3405       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3406     }
3407
3408   /* Merge the storage class information.  */
3409   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3410   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3411   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3412   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3413   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3414   if (! DECL_EXTERNAL (olddecl))
3415     DECL_EXTERNAL (newdecl) = 0;
3416
3417   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3418     {
3419       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3420       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3421       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3422       DECL_TEMPLATE_INSTANTIATED (newdecl)
3423         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3424       /* Don't really know how much of the language-specific
3425          values we should copy from old to new.  */
3426       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3427       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3428       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3429       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3430       olddecl_friend = DECL_FRIEND_P (olddecl);
3431
3432       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3433       if (TREE_CODE (newdecl) == FUNCTION_DECL
3434           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3435         DECL_BEFRIENDING_CLASSES (newdecl)
3436           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3437                      DECL_BEFRIENDING_CLASSES (olddecl));
3438     }
3439
3440   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3441     {
3442       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3443           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3444         {
3445           /* If newdecl is not a specialization, then it is not a
3446              template-related function at all.  And that means that we
3447              shoud have exited above, returning 0.  */
3448           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3449                               0);
3450
3451           if (TREE_USED (olddecl))
3452             /* From [temp.expl.spec]:
3453
3454                If a template, a member template or the member of a class
3455                template is explicitly specialized then that
3456                specialization shall be declared before the first use of
3457                that specialization that would cause an implicit
3458                instantiation to take place, in every translation unit in
3459                which such a use occurs.  */
3460             cp_error ("explicit specialization of %D after first use",
3461                       olddecl);
3462
3463           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3464         }
3465       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3466
3467       /* If either decl says `inline', this fn is inline, unless its
3468          definition was passed already.  */
3469       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3470         DECL_INLINE (olddecl) = 1;
3471       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3472
3473       if (! types_match)
3474         {
3475           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3476           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3477           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3478         }
3479       if (! types_match || new_defines_function)
3480         {
3481           /* These need to be copied so that the names are available.
3482              Note that if the types do match, we'll preserve inline
3483              info and other bits, but if not, we won't.  */
3484           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3485           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3486         }
3487       if (new_defines_function)
3488         /* If defining a function declared with other language
3489            linkage, use the previously declared language linkage.  */
3490         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3491       else if (types_match)
3492         {
3493           /* If redeclaring a builtin function, and not a definition,
3494              it stays built in.  */
3495           if (DECL_BUILT_IN (olddecl))
3496             {
3497               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3498               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3499               /* If we're keeping the built-in definition, keep the rtl,
3500                  regardless of declaration matches.  */
3501               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3502             }
3503           else
3504             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3505
3506           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3507           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3508             /* Previously saved insns go together with
3509                the function's previous definition.  */
3510             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3511           /* Don't clear out the arguments if we're redefining a function.  */
3512           if (DECL_ARGUMENTS (olddecl))
3513             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3514         }
3515       if (DECL_LANG_SPECIFIC (olddecl))
3516         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3517     }
3518
3519   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3520     {
3521       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3522     }
3523
3524   /* Now preserve various other info from the definition.  */
3525   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3526   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3527   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3528   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3529
3530   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3531     {
3532       int function_size;
3533
3534       function_size = sizeof (struct tree_decl);
3535
3536       bcopy ((char *) newdecl + sizeof (struct tree_common),
3537              (char *) olddecl + sizeof (struct tree_common),
3538              function_size - sizeof (struct tree_common));
3539
3540       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3541         {
3542           /* If newdecl is a template instantiation, it is possible that
3543              the following sequence of events has occurred:
3544
3545              o A friend function was declared in a class template.  The
3546              class template was instantiated.
3547
3548              o The instantiation of the friend declaration was
3549              recorded on the instantiation list, and is newdecl.
3550
3551              o Later, however, instantiate_class_template called pushdecl
3552              on the newdecl to perform name injection.  But, pushdecl in
3553              turn called duplicate_decls when it discovered that another
3554              declaration of a global function with the same name already
3555              existed.
3556
3557              o Here, in duplicate_decls, we decided to clobber newdecl.
3558
3559              If we're going to do that, we'd better make sure that
3560              olddecl, and not newdecl, is on the list of
3561              instantiations so that if we try to do the instantiation
3562              again we won't get the clobbered declaration.  */
3563
3564           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3565           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3566
3567           for (; decls; decls = TREE_CHAIN (decls))
3568             if (TREE_VALUE (decls) == newdecl)
3569               TREE_VALUE (decls) = olddecl;
3570         }
3571     }
3572   else
3573     {
3574       bcopy ((char *) newdecl + sizeof (struct tree_common),
3575              (char *) olddecl + sizeof (struct tree_common),
3576              sizeof (struct tree_decl) - sizeof (struct tree_common)
3577              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3578     }
3579
3580   DECL_UID (olddecl) = olddecl_uid;
3581   if (olddecl_friend)
3582     DECL_FRIEND_P (olddecl) = 1;
3583
3584   /* NEWDECL contains the merged attribute lists.
3585      Update OLDDECL to be the same.  */
3586   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3587
3588   return 1;
3589 }
3590
3591 /* Record a decl-node X as belonging to the current lexical scope.
3592    Check for errors (such as an incompatible declaration for the same
3593    name already seen in the same scope).
3594
3595    Returns either X or an old decl for the same name.
3596    If an old decl is returned, it may have been smashed
3597    to agree with what X says.  */
3598
3599 tree
3600 pushdecl (x)
3601      tree x;
3602 {
3603   register tree t;
3604   register tree name;
3605   int need_new_binding;
3606
3607   /* We shouldn't be calling pushdecl when we're generating RTL for a
3608      function that we already did semantic analysis on previously.  */
3609   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3610                       19990913);
3611
3612   name = DECL_ASSEMBLER_NAME (x);
3613   need_new_binding = 1;
3614
3615   if (DECL_TEMPLATE_PARM_P (x))
3616     /* Template parameters have no context; they are not X::T even
3617        when declared within a class or namespace.  */
3618     ;
3619   else
3620     {
3621       if (current_function_decl && x != current_function_decl
3622           /* A local declaration for a function doesn't constitute
3623              nesting.  */
3624           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3625           /* A local declaration for an `extern' variable is in the
3626              scoped of the current namespace, not the current
3627              function.  */
3628           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3629           && !DECL_CONTEXT (x))
3630         DECL_CONTEXT (x) = current_function_decl;
3631       if (!DECL_CONTEXT (x))
3632         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3633
3634       /* If this is the declaration for a namespace-scope function,
3635          but the declaration itself is in a local scope, mark the
3636          declaration.  */
3637       if (TREE_CODE (x) == FUNCTION_DECL
3638           && DECL_NAMESPACE_SCOPE_P (x)
3639           && current_function_decl
3640           && x != current_function_decl)
3641         DECL_LOCAL_FUNCTION_P (x) = 1;
3642     }
3643
3644   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3645      compiler wants to use.  */
3646   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3647       || TREE_CODE (x) == NAMESPACE_DECL)
3648     name = DECL_NAME (x);
3649
3650   if (name)
3651     {
3652 #if 0
3653       /* Not needed...see below.  */
3654       char *file;
3655       int line;
3656 #endif
3657       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3658         name = TREE_OPERAND (name, 0);
3659
3660       /* Namespace-scoped variables are not found in the current level. */
3661       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3662         t = namespace_binding (name, DECL_CONTEXT (x));
3663       else
3664         t = lookup_name_current_level (name);
3665       if (t == error_mark_node)
3666         {
3667           /* error_mark_node is 0 for a while during initialization!  */
3668           t = NULL_TREE;
3669           cp_error_at ("`%#D' used prior to declaration", x);
3670         }
3671
3672       else if (t != NULL_TREE)
3673         {
3674 #if 0
3675           /* This is turned off until I have time to do it right (bpk).  */
3676           /* With the code below that uses it...  */
3677           file = DECL_SOURCE_FILE (t);
3678           line = DECL_SOURCE_LINE (t);
3679 #endif
3680           if (TREE_CODE (t) == PARM_DECL)
3681             {
3682               if (DECL_CONTEXT (t) == NULL_TREE)
3683                 fatal ("parse errors have confused me too much");
3684
3685               /* Check for duplicate params.  */
3686               if (duplicate_decls (x, t))
3687                 return t;
3688             }
3689           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3690                     || DECL_FUNCTION_TEMPLATE_P (x))
3691                    && is_overloaded_fn (t))
3692             /* Don't do anything just yet. */;
3693           else if (t == wchar_decl_node)
3694             {
3695               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3696                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3697
3698               /* Throw away the redeclaration.  */
3699               return t;
3700             }
3701           else if (TREE_CODE (t) != TREE_CODE (x))
3702             {
3703               if (duplicate_decls (x, t))
3704                 return t;
3705             }
3706           else if (duplicate_decls (x, t))
3707             {
3708 #if 0
3709               /* This is turned off until I have time to do it right (bpk).  */
3710
3711               /* Also warn if they did a prototype with `static' on it, but
3712                  then later left the `static' off.  */
3713               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3714                 {
3715                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3716                     return t;
3717
3718                   if (extra_warnings)
3719                     {
3720                       cp_warning ("`static' missing from declaration of `%D'",
3721                                   t);
3722                       warning_with_file_and_line (file, line,
3723                                                   "previous declaration of `%s'",
3724                                                   decl_as_string (t, 0));
3725                     }
3726
3727                   /* Now fix things so it'll do what they expect.  */
3728                   if (current_function_decl)
3729                     TREE_PUBLIC (current_function_decl) = 0;
3730                 }
3731               /* Due to interference in memory reclamation (X may be
3732                  obstack-deallocated at this point), we must guard against
3733                  one really special case.  [jason: This should be handled
3734                  by start_function]  */
3735               if (current_function_decl == x)
3736                 current_function_decl = t;
3737 #endif
3738               if (TREE_CODE (t) == TYPE_DECL)
3739                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3740               else if (TREE_CODE (t) == FUNCTION_DECL)
3741                 check_default_args (t);
3742
3743               return t;
3744             }
3745           else if (DECL_MAIN_P (x))
3746             {
3747               /* A redeclaration of main, but not a duplicate of the
3748                  previous one.
3749
3750                  [basic.start.main]
3751
3752                  This function shall not be overloaded.  */
3753               cp_error_at ("invalid redeclaration of `%D'", t);
3754               cp_error ("as `%D'", x);
3755               /* We don't try to push this declaration since that
3756                  causes a crash.  */
3757               return x;
3758             }
3759         }
3760
3761       check_template_shadow (x);
3762
3763       /* If this is a function conjured up by the backend, massage it
3764          so it looks friendly.  */
3765       if (TREE_CODE (x) == FUNCTION_DECL
3766           && ! DECL_LANG_SPECIFIC (x))
3767         {
3768           retrofit_lang_decl (x);
3769           DECL_LANGUAGE (x) = lang_c;
3770         }
3771
3772       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3773         {
3774           t = push_overloaded_decl (x, PUSH_LOCAL);
3775           if (t != x)
3776             return t;
3777           if (!namespace_bindings_p ())
3778             /* We do not need to create a binding for this name;
3779                push_overloaded_decl will have already done so if
3780                necessary.  */
3781             need_new_binding = 0;
3782         }
3783       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3784         {
3785           t = push_overloaded_decl (x, PUSH_GLOBAL);
3786           if (t == x)
3787             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3788           return t;
3789         }
3790
3791       /* If declaring a type as a typedef, copy the type (unless we're
3792          at line 0), and install this TYPE_DECL as the new type's typedef
3793          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3794       if (TREE_CODE (x) == TYPE_DECL)
3795         {
3796           tree type = TREE_TYPE (x);
3797           if (DECL_SOURCE_LINE (x) == 0)
3798             {
3799               if (TYPE_NAME (type) == 0)
3800                 TYPE_NAME (type) = x;
3801             }
3802           else if (type != error_mark_node && TYPE_NAME (type) != x
3803                    /* We don't want to copy the type when all we're
3804                       doing is making a TYPE_DECL for the purposes of
3805                       inlining.  */
3806                    && (!TYPE_NAME (type)
3807                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3808             {
3809               DECL_ORIGINAL_TYPE (x) = type;
3810               type = build_type_copy (type);
3811               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3812               TYPE_NAME (type) = x;
3813               TREE_TYPE (x) = type;
3814             }
3815
3816           if (type != error_mark_node
3817               && TYPE_NAME (type)
3818               && TYPE_IDENTIFIER (type))
3819             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3820                                                   current_binding_level);
3821
3822         }
3823
3824       /* Multiple external decls of the same identifier ought to match.
3825
3826          We get warnings about inline functions where they are defined.
3827          We get warnings about other functions from push_overloaded_decl.
3828
3829          Avoid duplicate warnings where they are used.  */
3830       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3831         {
3832           tree decl;
3833
3834           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3835               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3836                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3837             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3838           else
3839             decl = NULL_TREE;
3840
3841           if (decl
3842               /* If different sort of thing, we already gave an error.  */
3843               && TREE_CODE (decl) == TREE_CODE (x)
3844               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3845             {
3846               cp_pedwarn ("type mismatch with previous external decl", x);
3847               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3848             }
3849         }
3850
3851       /* This name is new in its binding level.
3852          Install the new declaration and return it.  */
3853       if (namespace_bindings_p ())
3854         {
3855           /* Install a global value.  */
3856
3857           /* If the first global decl has external linkage,
3858              warn if we later see static one.  */
3859           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3860             TREE_PUBLIC (name) = 1;
3861
3862           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3863                 && t != NULL_TREE)
3864               /* For an ordinary function, we create a binding from
3865                  the mangled name (i.e., NAME) to the DECL.  But, for
3866                  an `extern "C"' function, the mangled name and the
3867                  ordinary name are the same so we need not do this.  */
3868               && !(TREE_CODE (x) == FUNCTION_DECL &&
3869                    DECL_LANGUAGE (x) == lang_c))
3870             {
3871               if (TREE_CODE (x) == FUNCTION_DECL)
3872                 my_friendly_assert
3873                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3874                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3875               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3876             }
3877
3878           /* Don't forget if the function was used via an implicit decl.  */
3879           if (IDENTIFIER_IMPLICIT_DECL (name)
3880               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3881             TREE_USED (x) = 1;
3882
3883           /* Don't forget if its address was taken in that way.  */
3884           if (IDENTIFIER_IMPLICIT_DECL (name)
3885               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3886             TREE_ADDRESSABLE (x) = 1;
3887
3888           /* Warn about mismatches against previous implicit decl.  */
3889           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3890               /* If this real decl matches the implicit, don't complain.  */
3891               && ! (TREE_CODE (x) == FUNCTION_DECL
3892                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3893             cp_warning
3894               ("`%D' was previously implicitly declared to return `int'", x);
3895
3896           /* If new decl is `static' and an `extern' was seen previously,
3897              warn about it.  */
3898           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3899             warn_extern_redeclared_static (x, t);
3900         }
3901       else
3902         {
3903           /* Here to install a non-global value.  */
3904           tree oldlocal = IDENTIFIER_VALUE (name);
3905           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3906
3907           if (need_new_binding)
3908             {
3909               push_local_binding (name, x, 0);
3910               /* Because push_local_binding will hook X on to the
3911                  current_binding_level's name list, we don't want to
3912                  do that again below.  */
3913               need_new_binding = 0;
3914             }
3915
3916           /* If this is a TYPE_DECL, push it into the type value slot.  */
3917           if (TREE_CODE (x) == TYPE_DECL)
3918             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3919                                                   current_binding_level);
3920
3921           /* Clear out any TYPE_DECL shadowed by a namespace so that
3922              we won't think this is a type.  The C struct hack doesn't
3923              go through namespaces.  */
3924           if (TREE_CODE (x) == NAMESPACE_DECL)
3925             set_identifier_type_value_with_scope (name, NULL_TREE,
3926                                                   current_binding_level);
3927
3928           if (oldlocal)
3929             {
3930               tree d = oldlocal;
3931               while (oldlocal
3932                      && TREE_CODE (oldlocal) == VAR_DECL
3933                      && DECL_DEAD_FOR_LOCAL (oldlocal))
3934                 {
3935                   oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
3936                 }
3937               if (oldlocal == NULL_TREE)
3938                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
3939             }
3940
3941           /* If this is an extern function declaration, see if we
3942              have a global definition or declaration for the function.  */
3943           if (oldlocal == NULL_TREE
3944               && DECL_EXTERNAL (x)
3945               && oldglobal != NULL_TREE
3946               && TREE_CODE (x) == FUNCTION_DECL
3947               && TREE_CODE (oldglobal) == FUNCTION_DECL)
3948             {
3949               /* We have one.  Their types must agree.  */
3950               if (decls_match (x, oldglobal))
3951                 /* OK */;
3952               else
3953                 {
3954                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3955                   cp_warning_at ("global declaration `%#D'", oldglobal);
3956                 }
3957             }
3958           /* If we have a local external declaration,
3959              and no file-scope declaration has yet been seen,
3960              then if we later have a file-scope decl it must not be static.  */
3961           if (oldlocal == NULL_TREE
3962               && oldglobal == NULL_TREE
3963               && DECL_EXTERNAL (x)
3964               && TREE_PUBLIC (x))
3965             TREE_PUBLIC (name) = 1;
3966
3967           /* Warn if shadowing an argument at the top level of the body.  */
3968           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3969               /* Inline decls shadow nothing.  */
3970               && !DECL_FROM_INLINE (x)
3971               && TREE_CODE (oldlocal) == PARM_DECL
3972               /* Don't complain if it's from an enclosing function.  */
3973               && DECL_CONTEXT (oldlocal) == current_function_decl
3974               && TREE_CODE (x) != PARM_DECL)
3975             {
3976               /* Go to where the parms should be and see if we
3977                  find them there.  */
3978               struct binding_level *b = current_binding_level->level_chain;
3979
3980               if (cleanup_label)
3981                 b = b->level_chain;
3982
3983               /* ARM $8.3 */
3984               if (b->parm_flag == 1)
3985                 cp_error ("declaration of `%#D' shadows a parameter", name);
3986             }
3987
3988           /* Maybe warn if shadowing something else.  */
3989           if (warn_shadow && !DECL_EXTERNAL (x)
3990               /* Inline decls shadow nothing.  */
3991               && !DECL_FROM_INLINE (x)
3992               /* No shadow warnings for internally generated vars.  */
3993               && ! DECL_ARTIFICIAL (x)
3994               /* No shadow warnings for vars made for inlining.  */
3995               && ! DECL_FROM_INLINE (x))
3996             {
3997               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3998                 warning ("declaration of `%s' shadows a parameter",
3999                         IDENTIFIER_POINTER (name));
4000               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4001                        && current_class_ptr
4002                        && !TREE_STATIC (name))
4003                 warning ("declaration of `%s' shadows a member of `this'",
4004                         IDENTIFIER_POINTER (name));
4005               else if (oldlocal != NULL_TREE)
4006                 warning ("declaration of `%s' shadows previous local",
4007                         IDENTIFIER_POINTER (name));
4008               else if (oldglobal != NULL_TREE)
4009                 /* XXX shadow warnings in outer-more namespaces */
4010                 warning ("declaration of `%s' shadows global declaration",
4011                         IDENTIFIER_POINTER (name));
4012             }
4013         }
4014
4015       if (TREE_CODE (x) == FUNCTION_DECL)
4016         check_default_args (x);
4017
4018       /* Keep count of variables in this level with incomplete type.  */
4019       if (TREE_CODE (x) == VAR_DECL
4020           && TREE_TYPE (x) != error_mark_node
4021           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4022                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4023               /* RTTI TD entries are created while defining the type_info.  */
4024               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4025                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4026         {
4027           if (namespace_bindings_p ())
4028             namespace_scope_incomplete
4029               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4030           else
4031             current_binding_level->incomplete
4032               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4033         }
4034     }
4035
4036   if (need_new_binding)
4037     add_decl_to_level (x,
4038                        DECL_NAMESPACE_SCOPE_P (x)
4039                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4040                        : current_binding_level);
4041
4042   return x;
4043 }
4044
4045 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4046    caller to set DECL_CONTEXT properly.  */
4047
4048 static tree
4049 pushdecl_with_scope (x, level)
4050      tree x;
4051      struct binding_level *level;
4052 {
4053   register struct binding_level *b;
4054   tree function_decl = current_function_decl;
4055
4056   current_function_decl = NULL_TREE;
4057   if (level->parm_flag == 2)
4058     {
4059       b = class_binding_level;
4060       class_binding_level = level;
4061       pushdecl_class_level (x);
4062       class_binding_level = b;
4063     }
4064   else
4065     {
4066       b = current_binding_level;
4067       current_binding_level = level;
4068       x = pushdecl (x);
4069       current_binding_level = b;
4070     }
4071   current_function_decl = function_decl;
4072   return x;
4073 }
4074
4075 /* Like pushdecl, only it places X in the current namespace,
4076    if appropriate.  */
4077
4078 tree
4079 pushdecl_namespace_level (x)
4080      tree x;
4081 {
4082   register struct binding_level *b = current_binding_level;
4083   register tree t;
4084
4085   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4086
4087   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4088      what we want.  */
4089   if (TREE_CODE (x) == TYPE_DECL)
4090     {
4091       tree name = DECL_NAME (x);
4092       tree newval;
4093       tree *ptr = (tree *)0;
4094       for (; b != global_binding_level; b = b->level_chain)
4095         {
4096           tree shadowed = b->type_shadowed;
4097           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4098             if (TREE_PURPOSE (shadowed) == name)
4099               {
4100                 ptr = &TREE_VALUE (shadowed);
4101                 /* Can't break out of the loop here because sometimes
4102                    a binding level will have duplicate bindings for
4103                    PT names.  It's gross, but I haven't time to fix it.  */
4104               }
4105         }
4106       newval = TREE_TYPE (x);
4107       if (ptr == (tree *)0)
4108         {
4109           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4110              up here if this is changed to an assertion.  --KR  */
4111           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4112         }
4113       else
4114         {
4115           *ptr = newval;
4116         }
4117     }
4118   return t;
4119 }
4120
4121 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4122    if appropriate.  */
4123
4124 tree
4125 pushdecl_top_level (x)
4126      tree x;
4127 {
4128   push_to_top_level ();
4129   x = pushdecl_namespace_level (x);
4130   pop_from_top_level ();
4131   return x;
4132 }
4133
4134 /* Make the declaration of X appear in CLASS scope.  */
4135
4136 void
4137 pushdecl_class_level (x)
4138      tree x;
4139 {
4140   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4141      scope looks for the pre-mangled name.  */
4142   register tree name;
4143
4144   if (TREE_CODE (x) == OVERLOAD)
4145     x = OVL_CURRENT (x);
4146   name = DECL_NAME (x);
4147
4148   if (name)
4149     {
4150       push_class_level_binding (name, x);
4151       if (TREE_CODE (x) == TYPE_DECL)
4152         set_identifier_type_value (name, TREE_TYPE (x));
4153     }
4154   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4155     {
4156       tree f;
4157
4158       for (f = TYPE_FIELDS (TREE_TYPE (x));
4159            f;
4160            f = TREE_CHAIN (f))
4161         pushdecl_class_level (f);
4162     }
4163 }
4164
4165 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4166    DECL, or a modified version thereof.  */
4167
4168 tree
4169 maybe_push_decl (decl)
4170      tree decl;
4171 {
4172   tree type = TREE_TYPE (decl);
4173
4174   /* Add this decl to the current binding level, but not if it comes
4175      from another scope, e.g. a static member variable.  TEM may equal
4176      DECL or it may be a previous decl of the same name.  */
4177   if (decl == error_mark_node
4178       || (TREE_CODE (decl) != PARM_DECL
4179           && DECL_CONTEXT (decl) != NULL_TREE
4180           /* Definitions of namespace members outside their namespace are
4181              possible. */
4182           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4183       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4184       || TREE_CODE (type) == UNKNOWN_TYPE
4185       /* The declaration of a template specialization does not affect
4186          the functions available for overload resolution, so we do not
4187          call pushdecl.  */
4188       || (TREE_CODE (decl) == FUNCTION_DECL
4189           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4190     return decl;
4191   else
4192     return pushdecl (decl);
4193 }
4194
4195 #if 0
4196 /* This function is used to push the mangled decls for nested types into
4197    the appropriate scope.  Previously pushdecl_top_level was used, but that
4198    is incorrect for members of local classes.  */
4199
4200 void
4201 pushdecl_nonclass_level (x)
4202      tree x;
4203 {
4204   struct binding_level *b = current_binding_level;
4205
4206   my_friendly_assert (b->parm_flag != 2, 180);
4207
4208 #if 0
4209   /* Get out of template binding levels */
4210   while (b->pseudo_global)
4211     b = b->level_chain;
4212 #endif
4213
4214   pushdecl_with_scope (x, b);
4215 }
4216 #endif
4217
4218 /* Make the declaration(s) of X appear in CLASS scope
4219    under the name NAME.  */
4220
4221 void
4222 push_class_level_binding (name, x)
4223      tree name;
4224      tree x;
4225 {
4226   tree binding;
4227   /* The class_binding_level will be NULL if x is a template
4228      parameter name in a member template.  */
4229   if (!class_binding_level)
4230     return;
4231
4232   /* Make sure that this new member does not have the same name
4233      as a template parameter.  */
4234   if (TYPE_BEING_DEFINED (current_class_type))
4235     check_template_shadow (x);
4236
4237   /* If this declaration shadows a declaration from an enclosing
4238      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4239      we leave this class.  Record the shadowed declaration here.  */
4240   binding = IDENTIFIER_BINDING (name);
4241   if (binding
4242       && ((TREE_CODE (x) == OVERLOAD
4243            && BINDING_VALUE (binding)
4244            && is_overloaded_fn (BINDING_VALUE (binding)))
4245           || INHERITED_VALUE_BINDING_P (binding)))
4246     {
4247       tree shadow;
4248       tree old_decl;
4249
4250       /* If the old binding was from a base class, and was for a tag
4251          name, slide it over to make room for the new binding.  The
4252          old binding is still visible if explicitly qualified with a
4253          class-key.  */
4254       if (INHERITED_VALUE_BINDING_P (binding)
4255           && BINDING_VALUE (binding)
4256           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4257           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4258           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4259         {
4260           old_decl = BINDING_TYPE (binding);
4261           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4262           BINDING_VALUE (binding) = NULL_TREE;
4263           INHERITED_VALUE_BINDING_P (binding) = 0;
4264         }
4265       else
4266         old_decl = BINDING_VALUE (binding);
4267
4268       /* There was already a binding for X containing fewer
4269          functions than are named in X.  Find the previous
4270          declaration of X on the class-shadowed list, and update it.  */
4271       for (shadow = class_binding_level->class_shadowed;
4272            shadow;
4273            shadow = TREE_CHAIN (shadow))
4274         if (TREE_PURPOSE (shadow) == name
4275             && TREE_TYPE (shadow) == old_decl)
4276           {
4277             BINDING_VALUE (binding) = x;
4278             INHERITED_VALUE_BINDING_P (binding) = 0;
4279             TREE_TYPE (shadow) = x;
4280             return;
4281           }
4282     }
4283
4284   /* If we didn't replace an existing binding, put the binding on the
4285      stack of bindings for the identifier, and update
4286      IDENTIFIER_CLASS_VALUE.  */
4287   if (push_class_binding (name, x))
4288     {
4289       class_binding_level->class_shadowed
4290         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4291                      class_binding_level->class_shadowed);
4292       /* Record the value we are binding NAME to so that we can know
4293          what to pop later.  */
4294       TREE_TYPE (class_binding_level->class_shadowed) = x;
4295     }
4296 }
4297
4298 /* Insert another USING_DECL into the current binding level,
4299    returning this declaration. If this is a redeclaration,
4300    do nothing and return NULL_TREE.  */
4301
4302 tree
4303 push_using_decl (scope, name)
4304      tree scope;
4305      tree name;
4306 {
4307   tree decl;
4308
4309   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4310   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4311   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4312     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4313       break;
4314   if (decl)
4315     return NULL_TREE;
4316   decl = build_lang_decl (USING_DECL, name, void_type_node);
4317   DECL_INITIAL (decl) = scope;
4318   TREE_CHAIN (decl) = current_binding_level->usings;
4319   current_binding_level->usings = decl;
4320   return decl;
4321 }
4322
4323 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4324    changed (i.e. there was already a directive), or the fresh
4325    TREE_LIST otherwise.  */
4326
4327 tree
4328 push_using_directive (used)
4329      tree used;
4330 {
4331   tree ud = current_binding_level->using_directives;
4332   tree iter, ancestor;
4333
4334   /* Check if we already have this. */
4335   if (purpose_member (used, ud) != NULL_TREE)
4336     return NULL_TREE;
4337
4338   /* Recursively add all namespaces used. */
4339   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4340     push_using_directive (TREE_PURPOSE (iter));
4341
4342   ancestor = namespace_ancestor (current_decl_namespace (), used);
4343   ud = current_binding_level->using_directives;
4344   ud = tree_cons (used, ancestor, ud);
4345   current_binding_level->using_directives = ud;
4346   return ud;
4347 }
4348
4349 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4350    other definitions already in place.  We get around this by making
4351    the value of the identifier point to a list of all the things that
4352    want to be referenced by that name.  It is then up to the users of
4353    that name to decide what to do with that list.
4354
4355    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4356    slot.  It is dealt with the same way.
4357
4358    FLAGS is a bitwise-or of the following values:
4359      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4360                  namespace scope.
4361      PUSH_USING: DECL is being pushed as the result of a using
4362                  declaration.
4363
4364    The value returned may be a previous declaration if we guessed wrong
4365    about what language DECL should belong to (C or C++).  Otherwise,
4366    it's always DECL (and never something that's not a _DECL).  */
4367
4368 tree
4369 push_overloaded_decl (decl, flags)
4370      tree decl;
4371      int flags;
4372 {
4373   tree name = DECL_NAME (decl);
4374   tree old;
4375   tree new_binding;
4376   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4377
4378   if (doing_global)
4379     old = namespace_binding (name, DECL_CONTEXT (decl));
4380   else
4381     old = lookup_name_current_level (name);
4382
4383   if (old)
4384     {
4385       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4386         {
4387           tree t = TREE_TYPE (old);
4388           if (IS_AGGR_TYPE (t) && warn_shadow
4389               && (! DECL_IN_SYSTEM_HEADER (decl)
4390                   || ! DECL_IN_SYSTEM_HEADER (old)))
4391             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4392           old = NULL_TREE;
4393         }
4394       else if (is_overloaded_fn (old))
4395         {
4396           tree tmp;
4397
4398           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4399             {
4400               tree fn = OVL_CURRENT (tmp);
4401
4402               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4403                   && !(flags & PUSH_USING)
4404                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4405                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4406                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4407                           decl, fn);
4408
4409               if (duplicate_decls (decl, fn))
4410                 return fn;
4411             }
4412         }
4413       else
4414         {
4415           cp_error_at ("previous non-function declaration `%#D'", old);
4416           cp_error ("conflicts with function declaration `%#D'", decl);
4417           return decl;
4418         }
4419     }
4420
4421   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4422     {
4423       if (old && TREE_CODE (old) != OVERLOAD)
4424         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4425       else
4426         new_binding = ovl_cons (decl, old);
4427       if (flags & PUSH_USING)
4428         OVL_USED (new_binding) = 1;
4429     }
4430   else
4431     /* NAME is not ambiguous.  */
4432     new_binding = decl;
4433
4434   if (doing_global)
4435     set_namespace_binding (name, current_namespace, new_binding);
4436   else
4437     {
4438       /* We only create an OVERLOAD if there was a previous binding at
4439          this level, or if decl is a template. In the former case, we
4440          need to remove the old binding and replace it with the new
4441          binding.  We must also run through the NAMES on the binding
4442          level where the name was bound to update the chain.  */
4443
4444       if (TREE_CODE (new_binding) == OVERLOAD && old)
4445         {
4446           tree *d;
4447
4448           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4449                *d;
4450                d = &TREE_CHAIN (*d))
4451             if (*d == old
4452                 || (TREE_CODE (*d) == TREE_LIST
4453                     && TREE_VALUE (*d) == old))
4454               {
4455                 if (TREE_CODE (*d) == TREE_LIST)
4456                   /* Just replace the old binding with the new.  */
4457                   TREE_VALUE (*d) = new_binding;
4458                 else
4459                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4460                   *d = tree_cons (NULL_TREE, new_binding,
4461                                   TREE_CHAIN (*d));
4462
4463                 /* And update the CPLUS_BINDING node.  */
4464                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4465                   = new_binding;
4466                 return decl;
4467               }
4468
4469           /* We should always find a previous binding in this case.  */
4470           my_friendly_abort (0);
4471         }
4472
4473       /* Install the new binding.  */
4474       push_local_binding (name, new_binding, flags);
4475     }
4476
4477   return decl;
4478 }
4479 \f
4480 /* Generate an implicit declaration for identifier FUNCTIONID
4481    as a function of type int ().  Print a warning if appropriate.  */
4482
4483 tree
4484 implicitly_declare (functionid)
4485      tree functionid;
4486 {
4487   register tree decl;
4488
4489   /* We used to reuse an old implicit decl here,
4490      but this loses with inline functions because it can clobber
4491      the saved decl chains.  */
4492   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4493
4494   DECL_EXTERNAL (decl) = 1;
4495   TREE_PUBLIC (decl) = 1;
4496
4497   /* ISO standard says implicit declarations are in the innermost block.
4498      So we record the decl in the standard fashion.  */
4499   pushdecl (decl);
4500   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4501
4502   if (warn_implicit
4503       /* Only one warning per identifier.  */
4504       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4505     {
4506       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4507     }
4508
4509   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4510
4511   return decl;
4512 }
4513
4514 /* Return zero if the declaration NEWDECL is valid
4515    when the declaration OLDDECL (assumed to be for the same name)
4516    has already been seen.
4517    Otherwise return an error message format string with a %s
4518    where the identifier should go.  */
4519
4520 static const char *
4521 redeclaration_error_message (newdecl, olddecl)
4522      tree newdecl, olddecl;
4523 {
4524   if (TREE_CODE (newdecl) == TYPE_DECL)
4525     {
4526       /* Because C++ can put things into name space for free,
4527          constructs like "typedef struct foo { ... } foo"
4528          would look like an erroneous redeclaration.  */
4529       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4530         return 0;
4531       else
4532         return "redefinition of `%#D'";
4533     }
4534   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4535     {
4536       /* If this is a pure function, its olddecl will actually be
4537          the original initialization to `0' (which we force to call
4538          abort()).  Don't complain about redefinition in this case.  */
4539       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4540         return 0;
4541
4542       /* If both functions come from different namespaces, this is not
4543          a redeclaration - this is a conflict with a used function. */
4544       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4545           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4546         return "`%D' conflicts with used function";
4547
4548       /* We'll complain about linkage mismatches in
4549          warn_extern_redeclared_static.  */
4550
4551       /* Defining the same name twice is no good.  */
4552       if (DECL_INITIAL (olddecl) != NULL_TREE
4553           && DECL_INITIAL (newdecl) != NULL_TREE)
4554         {
4555           if (DECL_NAME (olddecl) == NULL_TREE)
4556             return "`%#D' not declared in class";
4557           else
4558             return "redefinition of `%#D'";
4559         }
4560       return 0;
4561     }
4562   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4563     {
4564       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4565            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4566            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4567           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4568               && TYPE_SIZE (TREE_TYPE (newdecl))
4569               && TYPE_SIZE (TREE_TYPE (olddecl))))
4570         return "redefinition of `%#D'";
4571       return 0;
4572     }
4573   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4574     {
4575       /* Objects declared at top level:  */
4576       /* If at least one is a reference, it's ok.  */
4577       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4578         return 0;
4579       /* Reject two definitions.  */
4580       return "redefinition of `%#D'";
4581     }
4582   else
4583     {
4584       /* Objects declared with block scope:  */
4585       /* Reject two definitions, and reject a definition
4586          together with an external reference.  */
4587       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4588         return "redeclaration of `%#D'";
4589       return 0;
4590     }
4591 }
4592 \f
4593 /* Create a new label, named ID.  */
4594
4595 static tree
4596 make_label_decl (id, local_p)
4597      tree id;
4598      int local_p;
4599 {
4600   tree decl;
4601
4602   decl = build_decl (LABEL_DECL, id, void_type_node);
4603   if (expanding_p)
4604     /* Make sure every label has an rtx.  */
4605     label_rtx (decl);
4606
4607   DECL_CONTEXT (decl) = current_function_decl;
4608   DECL_MODE (decl) = VOIDmode;
4609   C_DECLARED_LABEL_FLAG (decl) = local_p;
4610
4611   /* Say where one reference is to the label, for the sake of the
4612      error if it is not defined.  */
4613   DECL_SOURCE_LINE (decl) = lineno;
4614   DECL_SOURCE_FILE (decl) = input_filename;
4615
4616   /* Record the fact that this identifier is bound to this label.  */
4617   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4618
4619   /* Record this label on the list of used labels so that we can check
4620      at the end of the function to see whether or not the label was
4621      actually defined.  */
4622   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4623       && (named_label_uses == NULL
4624           || named_label_uses->names_in_scope != current_binding_level->names
4625           || named_label_uses->label_decl != decl))
4626     {
4627       struct named_label_list *new_ent;
4628       new_ent
4629         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4630       new_ent->label_decl = decl;
4631       new_ent->names_in_scope = current_binding_level->names;
4632       new_ent->binding_level = current_binding_level;
4633       new_ent->lineno_o_goto = lineno;
4634       new_ent->filename_o_goto = input_filename;
4635       new_ent->next = named_label_uses;
4636       named_label_uses = new_ent;
4637     }
4638
4639   return decl;
4640 }
4641
4642 /* Look for a label named ID in the current function.  If one cannot
4643    be found, create one.  (We keep track of used, but undefined,
4644    labels, and complain about them at the end of a function.)  */
4645
4646 tree
4647 lookup_label (id)
4648      tree id;
4649 {
4650   tree decl;
4651
4652   /* You can't use labels at global scope.  */
4653   if (current_function_decl == NULL_TREE)
4654     {
4655       error ("label `%s' referenced outside of any function",
4656              IDENTIFIER_POINTER (id));
4657       return NULL_TREE;
4658     }
4659
4660   /* See if we've already got this label.  */
4661   decl = IDENTIFIER_LABEL_VALUE (id);
4662   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4663     return decl;
4664
4665   /* Record this label on the list of labels used in this function.
4666      We do this before calling make_label_decl so that we get the
4667      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4668   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4669                             named_labels);
4670   /* We need a new label.  */
4671   decl = make_label_decl (id, /*local_p=*/0);
4672   /* Now fill in the information we didn't have before.  */
4673   TREE_VALUE (named_labels) = decl;
4674
4675   return decl;
4676 }
4677
4678 /* Declare a local label named ID.  */
4679
4680 tree
4681 declare_local_label (id)
4682      tree id;
4683 {
4684   tree decl;
4685
4686   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4687      this scope we can restore the old value of
4688      IDENTIFIER_TYPE_VALUE.  */
4689   current_binding_level->shadowed_labels
4690     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4691                  current_binding_level->shadowed_labels);
4692   /* Look for the label.  */
4693   decl = make_label_decl (id, /*local_p=*/1);
4694   /* Now fill in the information we didn't have before.  */
4695   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4696
4697   return decl;
4698 }
4699
4700 /* Define a label, specifying the location in the source file.
4701    Return the LABEL_DECL node for the label, if the definition is valid.
4702    Otherwise return 0.  */
4703
4704 tree
4705 define_label (filename, line, name)
4706      char *filename;
4707      int line;
4708      tree name;
4709 {
4710   tree decl = lookup_label (name);
4711
4712   /* After labels, make any new cleanups go into their
4713      own new (temporary) binding contour.  */
4714   current_binding_level->more_cleanups_ok = 0;
4715
4716   if (name == get_identifier ("wchar_t"))
4717     cp_pedwarn ("label named wchar_t");
4718
4719   if (DECL_INITIAL (decl) != NULL_TREE)
4720     {
4721       cp_error ("duplicate label `%D'", decl);
4722       return 0;
4723     }
4724   else
4725     {
4726       struct named_label_list *uses, *prev;
4727       int identified = 0;
4728       int saw_eh = 0;
4729
4730       /* Mark label as having been defined.  */
4731       DECL_INITIAL (decl) = error_mark_node;
4732       /* Say where in the source.  */
4733       DECL_SOURCE_FILE (decl) = filename;
4734       DECL_SOURCE_LINE (decl) = line;
4735
4736       prev = NULL;
4737       uses = named_label_uses;
4738       while (uses != NULL)
4739         if (uses->label_decl == decl)
4740           {
4741             struct binding_level *b = current_binding_level;
4742             while (b)
4743               {
4744                 tree new_decls = b->names;
4745                 tree old_decls = (b == uses->binding_level)
4746                                   ? uses->names_in_scope : NULL_TREE;
4747                 while (new_decls != old_decls)
4748                   {
4749                     if (TREE_CODE (new_decls) == VAR_DECL
4750                         /* Don't complain about crossing initialization
4751                            of internal entities.  They can't be accessed,
4752                            and they should be cleaned up
4753                            by the time we get to the label.  */
4754                         && ! DECL_ARTIFICIAL (new_decls)
4755                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4756                              && pod_type_p (TREE_TYPE (new_decls))))
4757                       {
4758                         /* This is really only important if we're crossing
4759                            an initialization.  The POD stuff is just
4760                            pedantry; why should it matter if the class
4761                            contains a field of pointer to member type?  */
4762                         int problem = (DECL_INITIAL (new_decls)
4763                                        || (TYPE_NEEDS_CONSTRUCTING
4764                                            (TREE_TYPE (new_decls))));
4765
4766                         if (! identified)
4767                           {
4768                             if (problem)
4769                               {
4770                                 cp_error ("jump to label `%D'", decl);
4771                                 error_with_file_and_line
4772                                   (uses->filename_o_goto,
4773                                    uses->lineno_o_goto, "  from here");
4774                               }
4775                             else
4776                               {
4777                                 cp_pedwarn ("jump to label `%D'", decl);
4778                                 pedwarn_with_file_and_line
4779                                   (uses->filename_o_goto,
4780                                    uses->lineno_o_goto, "  from here");
4781                               }
4782                             identified = 1;
4783                           }
4784
4785                         if (problem)
4786                           cp_error_at ("  crosses initialization of `%#D'",
4787                                        new_decls);
4788                         else
4789                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4790                                          new_decls);
4791                       }
4792                     new_decls = TREE_CHAIN (new_decls);
4793                   }
4794                 if (b == uses->binding_level)
4795                   break;
4796                 if (b->eh_region && ! saw_eh)
4797                   {
4798                     if (! identified)
4799                       {
4800                         cp_error ("jump to label `%D'", decl);
4801                         error_with_file_and_line
4802                           (uses->filename_o_goto,
4803                            uses->lineno_o_goto, "  from here");
4804                         identified = 1;
4805                       }
4806                     error ("  enters exception handling block");
4807                     saw_eh = 1;
4808                   }
4809                 b = b->level_chain;
4810               }
4811
4812             if (prev != NULL)
4813               prev->next = uses->next;
4814             else
4815               named_label_uses = uses->next;
4816
4817             uses = uses->next;
4818           }
4819         else
4820           {
4821             prev = uses;
4822             uses = uses->next;
4823           }
4824       current_function_return_value = NULL_TREE;
4825       return decl;
4826     }
4827 }
4828
4829 struct cp_switch
4830 {
4831   struct binding_level *level;
4832   struct cp_switch *next;
4833 };
4834
4835 static struct cp_switch *switch_stack;
4836
4837 void
4838 push_switch ()
4839 {
4840   struct cp_switch *p
4841     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4842   p->level = current_binding_level;
4843   p->next = switch_stack;
4844   switch_stack = p;
4845 }
4846
4847 void
4848 pop_switch ()
4849 {
4850   switch_stack = switch_stack->next;
4851 }
4852
4853 /* Note that we've seen a definition of a case label, and complain if this
4854    is a bad place for one.  */
4855
4856 void
4857 define_case_label ()
4858 {
4859   tree cleanup = last_cleanup_this_contour ();
4860   struct binding_level *b = current_binding_level;
4861   int identified = 0;
4862
4863   if (! switch_stack)
4864     /* Don't crash; we'll complain in do_case.  */
4865     return;
4866
4867   if (cleanup)
4868     {
4869       static int explained = 0;
4870       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4871       warning ("where case label appears here");
4872       if (!explained)
4873         {
4874           warning ("(enclose actions of previous case statements requiring");
4875           warning ("destructors in their own binding contours.)");
4876           explained = 1;
4877         }
4878     }
4879
4880   for (; b && b != switch_stack->level; b = b->level_chain)
4881     {
4882       tree new_decls = b->names;
4883       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4884         {
4885           if (TREE_CODE (new_decls) == VAR_DECL
4886               /* Don't complain about crossing initialization
4887                  of internal entities.  They can't be accessed,
4888                  and they should be cleaned up
4889                  by the time we get to the label.  */
4890               && ! DECL_ARTIFICIAL (new_decls)
4891               && ((DECL_INITIAL (new_decls) != NULL_TREE
4892                    && DECL_INITIAL (new_decls) != error_mark_node)
4893                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4894             {
4895               if (! identified)
4896                 error ("jump to case label");
4897               identified = 1;
4898               cp_error_at ("  crosses initialization of `%#D'",
4899                            new_decls);
4900             }
4901         }
4902     }
4903
4904   /* After labels, make any new cleanups go into their
4905      own new (temporary) binding contour.  */
4906
4907   current_binding_level->more_cleanups_ok = 0;
4908   current_function_return_value = NULL_TREE;
4909 }
4910 \f
4911 /* Return the list of declarations of the current level.
4912    Note that this list is in reverse order unless/until
4913    you nreverse it; and when you do nreverse it, you must
4914    store the result back using `storedecls' or you will lose.  */
4915
4916 tree
4917 getdecls ()
4918 {
4919   return current_binding_level->names;
4920 }
4921
4922 /* Return the list of type-tags (for structs, etc) of the current level.  */
4923
4924 tree
4925 gettags ()
4926 {
4927   return current_binding_level->tags;
4928 }
4929
4930 /* Store the list of declarations of the current level.
4931    This is done for the parameter declarations of a function being defined,
4932    after they are modified in the light of any missing parameters.  */
4933
4934 static void
4935 storedecls (decls)
4936      tree decls;
4937 {
4938   current_binding_level->names = decls;
4939 }
4940
4941 /* Similarly, store the list of tags of the current level.  */
4942
4943 void
4944 storetags (tags)
4945      tree tags;
4946 {
4947   current_binding_level->tags = tags;
4948 }
4949 \f
4950 /* Given NAME, an IDENTIFIER_NODE,
4951    return the structure (or union or enum) definition for that name.
4952    Searches binding levels from BINDING_LEVEL up to the global level.
4953    If THISLEVEL_ONLY is nonzero, searches only the specified context
4954    (but skips any tag-transparent contexts to find one that is
4955    meaningful for tags).
4956    FORM says which kind of type the caller wants;
4957    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4958    If the wrong kind of type is found, and it's not a template, an error is
4959    reported.  */
4960
4961 static tree
4962 lookup_tag (form, name, binding_level, thislevel_only)
4963      enum tree_code form;
4964      tree name;
4965      struct binding_level *binding_level;
4966      int thislevel_only;
4967 {
4968   register struct binding_level *level;
4969   /* Non-zero if, we should look past a pseudo-global level, even if
4970      THISLEVEL_ONLY.  */
4971   int allow_pseudo_global = 1;
4972
4973   for (level = binding_level; level; level = level->level_chain)
4974     {
4975       register tree tail;
4976       if (ANON_AGGRNAME_P (name))
4977         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4978           {
4979             /* There's no need for error checking here, because
4980                anon names are unique throughout the compilation.  */
4981             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4982               return TREE_VALUE (tail);
4983           }
4984       else if (level->namespace_p)
4985         /* Do namespace lookup. */
4986         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
4987           {
4988             tree old = binding_for_name (name, tail);
4989
4990             /* If we just skipped past a pseudo global level, even
4991                though THISLEVEL_ONLY, and we find a template class
4992                declaration, then we use the _TYPE node for the
4993                template.  See the example below.  */
4994             if (thislevel_only && !allow_pseudo_global
4995                 && old && BINDING_VALUE (old)
4996                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
4997               old = TREE_TYPE (BINDING_VALUE (old));
4998             else
4999               old = BINDING_TYPE (old);
5000
5001             /* If it has an original type, it is a typedef, and we
5002                should not return it.  */
5003             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5004               old = NULL_TREE;
5005             if (old && TREE_CODE (old) != form
5006                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5007               {
5008                 cp_error ("`%#D' redeclared as %C", old, form);
5009                 return NULL_TREE;
5010               }
5011             if (old)
5012               return old;
5013             if (thislevel_only || tail == global_namespace)
5014               return NULL_TREE;
5015           }
5016       else
5017         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5018           {
5019             if (TREE_PURPOSE (tail) == name)
5020               {
5021                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5022                 /* Should tighten this up; it'll probably permit
5023                    UNION_TYPE and a struct template, for example.  */
5024                 if (code != form
5025                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5026                   {
5027                     /* Definition isn't the kind we were looking for.  */
5028                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5029                               form);
5030                     return NULL_TREE;
5031                   }
5032                 return TREE_VALUE (tail);
5033               }
5034           }
5035       if (thislevel_only && ! level->tag_transparent)
5036         {
5037           if (level->pseudo_global && allow_pseudo_global)
5038             {
5039               /* We must deal with cases like this:
5040
5041                    template <class T> struct S;
5042                    template <class T> struct S {};
5043
5044                  When looking up `S', for the second declaration, we
5045                  would like to find the first declaration.  But, we
5046                  are in the pseudo-global level created for the
5047                  template parameters, rather than the (surrounding)
5048                  namespace level.  Thus, we keep going one more level,
5049                  even though THISLEVEL_ONLY is non-zero.  */
5050               allow_pseudo_global = 0;
5051               continue;
5052             }
5053           else
5054             return NULL_TREE;
5055         }
5056     }
5057   return NULL_TREE;
5058 }
5059
5060 #if 0
5061 void
5062 set_current_level_tags_transparency (tags_transparent)
5063      int tags_transparent;
5064 {
5065   current_binding_level->tag_transparent = tags_transparent;
5066 }
5067 #endif
5068
5069 /* Given a type, find the tag that was defined for it and return the tag name.
5070    Otherwise return 0.  However, the value can never be 0
5071    in the cases in which this is used.
5072
5073    C++: If NAME is non-zero, this is the new name to install.  This is
5074    done when replacing anonymous tags with real tag names.  */
5075
5076 static tree
5077 lookup_tag_reverse (type, name)
5078      tree type;
5079      tree name;
5080 {
5081   register struct binding_level *level;
5082
5083   for (level = current_binding_level; level; level = level->level_chain)
5084     {
5085       register tree tail;
5086       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5087         {
5088           if (TREE_VALUE (tail) == type)
5089             {
5090               if (name)
5091                 TREE_PURPOSE (tail) = name;
5092               return TREE_PURPOSE (tail);
5093             }
5094         }
5095     }
5096   return NULL_TREE;
5097 }
5098 \f
5099 /* Look up NAME in the NAMESPACE.  */
5100
5101 tree
5102 lookup_namespace_name (namespace, name)
5103      tree namespace, name;
5104 {
5105   tree val;
5106   tree template_id = NULL_TREE;
5107
5108   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5109
5110   if (TREE_CODE (name) == NAMESPACE_DECL)
5111     /* This happens for A::B<int> when B is a namespace. */
5112     return name;
5113   else if (TREE_CODE (name) == TEMPLATE_DECL)
5114     {
5115       /* This happens for A::B where B is a template, and there are no
5116          template arguments.  */
5117       cp_error ("invalid use of `%D'", name);
5118       return error_mark_node;
5119     }
5120
5121   namespace = ORIGINAL_NAMESPACE (namespace);
5122
5123   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5124     {
5125       template_id = name;
5126       name = TREE_OPERAND (name, 0);
5127       if (TREE_CODE (name) == OVERLOAD)
5128         name = DECL_NAME (OVL_CURRENT (name));
5129       else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5130         name = DECL_NAME (name);
5131     }
5132
5133   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5134
5135   val = make_node (CPLUS_BINDING);
5136   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5137     return error_mark_node;
5138
5139   if (BINDING_VALUE (val))
5140     {
5141       val = BINDING_VALUE (val);
5142
5143       if (template_id)
5144         {
5145           if (DECL_CLASS_TEMPLATE_P (val))
5146             val = lookup_template_class (val,
5147                                          TREE_OPERAND (template_id, 1),
5148                                          /*in_decl=*/NULL_TREE,
5149                                          /*context=*/NULL_TREE,
5150                                          /*entering_scope=*/0);
5151           else if (DECL_FUNCTION_TEMPLATE_P (val)
5152                    || TREE_CODE (val) == OVERLOAD)
5153             val = lookup_template_function (val,
5154                                             TREE_OPERAND (template_id, 1));
5155           else
5156             {
5157               cp_error ("`%D::%D' is not a template",
5158                         namespace, name);
5159               return error_mark_node;
5160             }
5161         }
5162
5163       /* If we have a single function from a using decl, pull it out.  */
5164       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5165         val = OVL_FUNCTION (val);
5166       return val;
5167     }
5168
5169   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5170   return error_mark_node;
5171 }
5172
5173 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5174
5175 static unsigned long
5176 typename_hash (k)
5177      hash_table_key k;
5178 {
5179   unsigned long hash;
5180   tree t;
5181
5182   t = (tree) k;
5183   hash = (((unsigned long) TYPE_CONTEXT (t))
5184           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5185
5186   return hash;
5187 }
5188
5189 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5190
5191 static boolean
5192 typename_compare (k1, k2)
5193      hash_table_key k1;
5194      hash_table_key k2;
5195 {
5196   tree t1;
5197   tree t2;
5198   tree d1;
5199   tree d2;
5200
5201   t1 = (tree) k1;
5202   t2 = (tree) k2;
5203   d1 = TYPE_NAME (t1);
5204   d2 = TYPE_NAME (t2);
5205
5206   return (DECL_NAME (d1) == DECL_NAME (d2)
5207           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5208           && ((TREE_TYPE (t1) != NULL_TREE)
5209               == (TREE_TYPE (t2) != NULL_TREE))
5210           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5211           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5212 }
5213
5214 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5215    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5216    is non-NULL, this type is being created by the implicit typename
5217    extension, and BASE_TYPE is a type named `t' in some base class of
5218    `T' which depends on template parameters.
5219
5220    Returns the new TYPENAME_TYPE.  */
5221
5222 tree
5223 build_typename_type (context, name, fullname, base_type)
5224      tree context;
5225      tree name;
5226      tree fullname;
5227      tree base_type;
5228 {
5229   tree t;
5230   tree d;
5231   struct hash_entry* e;
5232
5233   static struct hash_table ht;
5234
5235   if (!ht.table)
5236     {
5237       static struct hash_table *h = &ht;
5238       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5239                             &typename_compare))
5240         fatal ("virtual memory exhausted");
5241       ggc_add_tree_hash_table_root (&h, 1);
5242     }
5243
5244   /* Build the TYPENAME_TYPE.  */
5245   t = make_aggr_type (TYPENAME_TYPE);
5246   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5247   TYPENAME_TYPE_FULLNAME (t) = fullname;
5248   TREE_TYPE (t) = base_type;
5249
5250   /* Build the corresponding TYPE_DECL.  */
5251   d = build_decl (TYPE_DECL, name, t);
5252   TYPE_NAME (TREE_TYPE (d)) = d;
5253   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5254   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5255   DECL_ARTIFICIAL (d) = 1;
5256
5257   /* See if we already have this type.  */
5258   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5259   if (e)
5260     t = (tree) e->key;
5261   else
5262     /* Insert the type into the table.  */
5263     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5264
5265   return t;
5266 }
5267
5268 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5269    unless an error occurs, in which case error_mark_node is returned.
5270    If COMPLAIN zero, don't complain about any errors that occur.  */
5271
5272 tree
5273 make_typename_type (context, name, complain)
5274      tree context, name;
5275      int complain;
5276 {
5277   tree fullname;
5278
5279   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5280     {
5281       if (!(TYPE_LANG_SPECIFIC (name)
5282             && (CLASSTYPE_IS_TEMPLATE (name)
5283                 || CLASSTYPE_USE_TEMPLATE (name))))
5284         name = TYPE_IDENTIFIER (name);
5285       else
5286         /* Create a TEMPLATE_ID_EXPR for the type.  */
5287         name = build_nt (TEMPLATE_ID_EXPR,
5288                          CLASSTYPE_TI_TEMPLATE (name),
5289                          CLASSTYPE_TI_ARGS (name));
5290     }
5291   else if (TREE_CODE (name) == TYPE_DECL)
5292     name = DECL_NAME (name);
5293
5294   fullname = name;
5295
5296   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5297     {
5298       name = TREE_OPERAND (name, 0);
5299       if (TREE_CODE (name) == TEMPLATE_DECL)
5300         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5301     }
5302   if (TREE_CODE (name) != IDENTIFIER_NODE)
5303     my_friendly_abort (2000);
5304
5305   if (TREE_CODE (context) == NAMESPACE_DECL)
5306     {
5307       /* We can get here from typename_sub0 in the explicit_template_type
5308          expansion.  Just fail.  */
5309       if (complain)
5310         cp_error ("no class template named `%#T' in `%#T'",
5311                   name, context);
5312       return error_mark_node;
5313     }
5314
5315   if (! uses_template_parms (context)
5316       || currently_open_class (context))
5317     {
5318       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5319         {
5320           tree tmpl = NULL_TREE;
5321           if (IS_AGGR_TYPE (context))
5322             tmpl = lookup_field (context, name, 0, 0);
5323           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5324             {
5325               if (complain)
5326                 cp_error ("no class template named `%#T' in `%#T'",
5327                           name, context);
5328               return error_mark_node;
5329             }
5330
5331           return lookup_template_class (tmpl,
5332                                         TREE_OPERAND (fullname, 1),
5333                                         NULL_TREE, context,
5334                                         /*entering_scope=*/0);
5335         }
5336       else
5337         {
5338           tree t;
5339
5340           if (!IS_AGGR_TYPE (context))
5341             {
5342               if (complain)
5343                 cp_error ("no type named `%#T' in `%#T'", name, context);
5344               return error_mark_node;
5345             }
5346
5347           t = lookup_field (context, name, 0, 1);
5348           if (t)
5349             return TREE_TYPE (t);
5350         }
5351     }
5352
5353   /* If the CONTEXT is not a template type, then either the field is
5354      there now or its never going to be.  */
5355   if (!uses_template_parms (context))
5356     {
5357       if (complain)
5358         cp_error ("no type named `%#T' in `%#T'", name, context);
5359       return error_mark_node;
5360     }
5361
5362
5363   return build_typename_type (context, name, fullname,  NULL_TREE);
5364 }
5365
5366 /* Select the right _DECL from multiple choices. */
5367
5368 static tree
5369 select_decl (binding, flags)
5370      tree binding;
5371      int flags;
5372 {
5373   tree val;
5374   val = BINDING_VALUE (binding);
5375   if (LOOKUP_NAMESPACES_ONLY (flags))
5376     {
5377       /* We are not interested in types. */
5378       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5379         return val;
5380       return NULL_TREE;
5381     }
5382
5383   /* If we could have a type and
5384      we have nothing or we need a type and have none.  */
5385   if (BINDING_TYPE (binding)
5386       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5387                    && TREE_CODE (val) != TYPE_DECL)))
5388     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5389   /* Don't return non-types if we really prefer types. */
5390   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5391            && (TREE_CODE (val) != TEMPLATE_DECL
5392                || !DECL_CLASS_TEMPLATE_P (val)))
5393     val = NULL_TREE;
5394
5395   return val;
5396 }
5397
5398 /* Unscoped lookup of a global: iterate over current namespaces,
5399    considering using-directives.  If SPACESP is non-NULL, store a list
5400    of the namespaces we've considered in it.  */
5401
5402 tree
5403 unqualified_namespace_lookup (name, flags, spacesp)
5404      tree name;
5405      int flags;
5406      tree *spacesp;
5407 {
5408   tree b = make_node (CPLUS_BINDING);
5409   tree initial = current_decl_namespace();
5410   tree scope = initial;
5411   tree siter;
5412   struct binding_level *level;
5413   tree val = NULL_TREE;
5414
5415   if (spacesp)
5416     *spacesp = NULL_TREE;
5417
5418   for (; !val; scope = CP_DECL_CONTEXT (scope))
5419     {
5420       if (spacesp)
5421         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5422       val = binding_for_name (name, scope);
5423
5424       /* Initialize binding for this context. */
5425       BINDING_VALUE (b) = BINDING_VALUE (val);
5426       BINDING_TYPE (b) = BINDING_TYPE (val);
5427
5428       /* Add all _DECLs seen through local using-directives. */
5429       for (level = current_binding_level;
5430            !level->namespace_p;
5431            level = level->level_chain)
5432         if (!lookup_using_namespace (name, b, level->using_directives,
5433                                      scope, flags, spacesp))
5434           /* Give up because of error. */
5435           return error_mark_node;
5436
5437       /* Add all _DECLs seen through global using-directives. */
5438       /* XXX local and global using lists should work equally. */
5439       siter = initial;
5440       while (1)
5441         {
5442           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5443                                        scope, flags, spacesp))
5444             /* Give up because of error. */
5445             return error_mark_node;
5446           if (siter == scope) break;
5447           siter = CP_DECL_CONTEXT (siter);
5448         }
5449
5450       val = select_decl (b, flags);
5451       if (scope == global_namespace)
5452         break;
5453     }
5454   return val;
5455 }
5456
5457 /* Combine prefer_type and namespaces_only into flags.  */
5458
5459 static int
5460 lookup_flags (prefer_type, namespaces_only)
5461   int prefer_type, namespaces_only;
5462 {
5463   if (namespaces_only)
5464     return LOOKUP_PREFER_NAMESPACES;
5465   if (prefer_type > 1)
5466     return LOOKUP_PREFER_TYPES;
5467   if (prefer_type > 0)
5468     return LOOKUP_PREFER_BOTH;
5469   return 0;
5470 }
5471
5472 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5473    ignore it or not.  Subroutine of lookup_name_real.  */
5474
5475 static tree
5476 qualify_lookup (val, flags)
5477      tree val;
5478      int flags;
5479 {
5480   if (val == NULL_TREE)
5481     return val;
5482   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5483     return val;
5484   if ((flags & LOOKUP_PREFER_TYPES)
5485       && (TREE_CODE (val) == TYPE_DECL
5486           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5487               && DECL_CLASS_TEMPLATE_P (val))))
5488     return val;
5489   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5490     return NULL_TREE;
5491   return val;
5492 }
5493
5494 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5495    that.  */
5496
5497 static void
5498 warn_about_implicit_typename_lookup (typename, binding)
5499      tree typename;
5500      tree binding;
5501 {
5502   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5503   tree name = DECL_NAME (typename);
5504
5505   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5506          && CLASSTYPE_TEMPLATE_INFO (subtype)
5507          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5508       && ! (TREE_CODE (binding) == TYPE_DECL
5509             && same_type_p (TREE_TYPE (binding), subtype)))
5510     {
5511       cp_warning ("lookup of `%D' finds `%#D'",
5512                   name, binding);
5513       cp_warning ("  instead of `%D' from dependent base class",
5514                   typename);
5515       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5516                   constructor_name (current_class_type), name);
5517     }
5518 }
5519
5520 /* Look up NAME in the current binding level and its superiors in the
5521    namespace of variables, functions and typedefs.  Return a ..._DECL
5522    node of some kind representing its definition if there is only one
5523    such declaration, or return a TREE_LIST with all the overloaded
5524    definitions if there are many, or return 0 if it is undefined.
5525
5526    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5527    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5528    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5529    Otherwise we prefer non-TYPE_DECLs.
5530
5531    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5532    using IDENTIFIER_CLASS_VALUE.  */
5533
5534 static tree
5535 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5536      tree name;
5537      int prefer_type, nonclass, namespaces_only;
5538 {
5539   tree t;
5540   tree val = NULL_TREE;
5541   int yylex = 0;
5542   tree from_obj = NULL_TREE;
5543   int flags;
5544   int val_is_implicit_typename = 0;
5545
5546   /* Hack: copy flag set by parser, if set. */
5547   if (only_namespace_names)
5548     namespaces_only = 1;
5549
5550   if (prefer_type == -2)
5551     {
5552       extern int looking_for_typename;
5553       tree type = NULL_TREE;
5554
5555       yylex = 1;
5556       prefer_type = looking_for_typename;
5557
5558       flags = lookup_flags (prefer_type, namespaces_only);
5559       /* If the next thing is '<', class templates are types. */
5560       if (looking_for_template)
5561         flags |= LOOKUP_TEMPLATES_EXPECTED;
5562
5563       /* std:: becomes :: for now.  */
5564       if (got_scope == std_node)
5565         got_scope = void_type_node;
5566
5567       if (got_scope)
5568         type = got_scope;
5569       else if (got_object != error_mark_node)
5570         type = got_object;
5571
5572       if (type)
5573         {
5574           if (type == error_mark_node)
5575             return error_mark_node;
5576           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5577             type = TREE_TYPE (type);
5578
5579           if (TYPE_P (type))
5580             type = complete_type (type);
5581
5582           if (TREE_CODE (type) == VOID_TYPE)
5583             type = global_namespace;
5584           if (TREE_CODE (type) == NAMESPACE_DECL)
5585             {
5586               val = make_node (CPLUS_BINDING);
5587               flags |= LOOKUP_COMPLAIN;
5588               if (!qualified_lookup_using_namespace (name, type, val, flags))
5589                 return NULL_TREE;
5590               val = select_decl (val, flags);
5591             }
5592           else if (! IS_AGGR_TYPE (type)
5593                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5594                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5595                    || TREE_CODE (type) == TYPENAME_TYPE)
5596             /* Someone else will give an error about this if needed.  */
5597             val = NULL_TREE;
5598           else if (type == current_class_type)
5599             val = IDENTIFIER_CLASS_VALUE (name);
5600           else
5601             {
5602               val = lookup_member (type, name, 0, prefer_type);
5603               type_access_control (type, val);
5604             }
5605         }
5606       else
5607         val = NULL_TREE;
5608
5609       if (got_scope)
5610         goto done;
5611       else if (got_object && val)
5612         from_obj = val;
5613     }
5614   else
5615     {
5616       flags = lookup_flags (prefer_type, namespaces_only);
5617       /* If we're not parsing, we need to complain. */
5618       flags |= LOOKUP_COMPLAIN;
5619     }
5620
5621   /* First, look in non-namespace scopes.  */
5622
5623   if (current_class_type == NULL_TREE)
5624     nonclass = 1;
5625
5626   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5627     {
5628       tree binding;
5629
5630       if (!LOCAL_BINDING_P (t) && nonclass)
5631         /* We're not looking for class-scoped bindings, so keep going.  */
5632         continue;
5633
5634       /* If this is the kind of thing we're looking for, we're done.  */
5635       if (qualify_lookup (BINDING_VALUE (t), flags))
5636         binding = BINDING_VALUE (t);
5637       else if ((flags & LOOKUP_PREFER_TYPES)
5638                && qualify_lookup (BINDING_TYPE (t), flags))
5639         binding = BINDING_TYPE (t);
5640       else
5641         binding = NULL_TREE;
5642
5643       /* Handle access control on types from enclosing or base classes.  */
5644       if (binding && ! yylex
5645           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5646         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5647
5648       if (binding
5649           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5650         {
5651           if (val_is_implicit_typename && !yylex)
5652             warn_about_implicit_typename_lookup (val, binding);
5653           val = binding;
5654           val_is_implicit_typename
5655             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5656           if (!val_is_implicit_typename)
5657             break;
5658         }
5659     }
5660
5661   /* Now lookup in namespace scopes.  */
5662   if (!val || val_is_implicit_typename)
5663     {
5664       t = unqualified_namespace_lookup (name, flags, 0);
5665       if (t)
5666         {
5667           if (val_is_implicit_typename && !yylex)
5668             warn_about_implicit_typename_lookup (val, t);
5669           val = t;
5670         }
5671     }
5672
5673  done:
5674   if (val)
5675     {
5676       /* This should only warn about types used in qualified-ids.  */
5677       if (from_obj && from_obj != val)
5678         {
5679           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5680               && TREE_CODE (val) == TYPE_DECL
5681               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5682             {
5683               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5684                           name, got_object, TREE_TYPE (from_obj));
5685               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5686                           TREE_TYPE (val));
5687             }
5688
5689           /* We don't change val to from_obj if got_object depends on
5690              template parms because that breaks implicit typename for
5691              destructor calls.  */
5692           if (! uses_template_parms (got_object))
5693             val = from_obj;
5694         }
5695
5696       /* If we have a single function from a using decl, pull it out.  */
5697       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5698         val = OVL_FUNCTION (val);
5699     }
5700   else if (from_obj)
5701     val = from_obj;
5702
5703   return val;
5704 }
5705
5706 tree
5707 lookup_name_nonclass (name)
5708      tree name;
5709 {
5710   return lookup_name_real (name, 0, 1, 0);
5711 }
5712
5713 tree
5714 lookup_function_nonclass (name, args)
5715      tree name;
5716      tree args;
5717 {
5718   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5719 }
5720
5721 tree
5722 lookup_name_namespace_only (name)
5723      tree name;
5724 {
5725   /* type-or-namespace, nonclass, namespace_only */
5726   return lookup_name_real (name, 1, 1, 1);
5727 }
5728
5729 tree
5730 lookup_name (name, prefer_type)
5731      tree name;
5732      int prefer_type;
5733 {
5734   return lookup_name_real (name, prefer_type, 0, 0);
5735 }
5736
5737 /* Similar to `lookup_name' but look only in the innermost non-class
5738    binding level.  */
5739
5740 tree
5741 lookup_name_current_level (name)
5742      tree name;
5743 {
5744   struct binding_level *b;
5745   tree t = NULL_TREE;
5746
5747   b = current_binding_level;
5748   while (b->parm_flag == 2)
5749     b = b->level_chain;
5750
5751   if (b->namespace_p)
5752     {
5753       t = IDENTIFIER_NAMESPACE_VALUE (name);
5754
5755       /* extern "C" function() */
5756       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5757         t = TREE_VALUE (t);
5758     }
5759   else if (IDENTIFIER_BINDING (name)
5760            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5761     {
5762       while (1)
5763         {
5764           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5765             return IDENTIFIER_VALUE (name);
5766
5767           if (b->keep == 2)
5768             b = b->level_chain;
5769           else
5770             break;
5771         }
5772     }
5773
5774   return t;
5775 }
5776
5777 /* Like lookup_name_current_level, but for types.  */
5778
5779 tree
5780 lookup_type_current_level (name)
5781      tree name;
5782 {
5783   register tree t = NULL_TREE;
5784
5785   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5786
5787   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5788       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5789     {
5790       struct binding_level *b = current_binding_level;
5791       while (1)
5792         {
5793           if (purpose_member (name, b->type_shadowed))
5794             return REAL_IDENTIFIER_TYPE_VALUE (name);
5795           if (b->keep == 2)
5796             b = b->level_chain;
5797           else
5798             break;
5799         }
5800     }
5801
5802   return t;
5803 }
5804
5805 void
5806 begin_only_namespace_names ()
5807 {
5808   only_namespace_names = 1;
5809 }
5810
5811 void
5812 end_only_namespace_names ()
5813 {
5814   only_namespace_names = 0;
5815 }
5816 \f
5817 /* Arrange for the user to get a source line number, even when the
5818    compiler is going down in flames, so that she at least has a
5819    chance of working around problems in the compiler.  We used to
5820    call error(), but that let the segmentation fault continue
5821    through; now, it's much more passive by asking them to send the
5822    maintainers mail about the problem.  */
5823
5824 static void
5825 signal_catch (sig)
5826      int sig ATTRIBUTE_UNUSED;
5827 {
5828   signal (SIGSEGV, SIG_DFL);
5829 #ifdef SIGIOT
5830   signal (SIGIOT, SIG_DFL);
5831 #endif
5832 #ifdef SIGILL
5833   signal (SIGILL, SIG_DFL);
5834 #endif
5835 #ifdef SIGABRT
5836   signal (SIGABRT, SIG_DFL);
5837 #endif
5838 #ifdef SIGBUS
5839   signal (SIGBUS, SIG_DFL);
5840 #endif
5841   my_friendly_abort (0);
5842 }
5843
5844 /* Push the declarations of builtin types into the namespace.
5845    RID_INDEX, if < RID_MAX is the index of the builtin type
5846    in the array RID_POINTERS.  NAME is the name used when looking
5847    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5848
5849 static void
5850 record_builtin_type (rid_index, name, type)
5851      enum rid rid_index;
5852      const char *name;
5853      tree type;
5854 {
5855   tree rname = NULL_TREE, tname = NULL_TREE;
5856   tree tdecl = NULL_TREE;
5857
5858   if ((int) rid_index < (int) RID_MAX)
5859     rname = ridpointers[(int) rid_index];
5860   if (name)
5861     tname = get_identifier (name);
5862
5863   TYPE_BUILT_IN (type) = 1;
5864
5865   if (tname)
5866     {
5867       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5868       set_identifier_type_value (tname, NULL_TREE);
5869       if ((int) rid_index < (int) RID_MAX)
5870         /* Built-in types live in the global namespace. */
5871         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5872     }
5873   if (rname != NULL_TREE)
5874     {
5875       if (tname != NULL_TREE)
5876         {
5877           set_identifier_type_value (rname, NULL_TREE);
5878           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5879         }
5880       else
5881         {
5882           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5883           set_identifier_type_value (rname, NULL_TREE);
5884         }
5885     }
5886 }
5887
5888 /* Record one of the standard Java types.
5889  * Declare it as having the given NAME.
5890  * If SIZE > 0, it is the size of one of the integral types;
5891  * otherwise it is the negative of the size of one of the other types.  */
5892
5893 static tree
5894 record_builtin_java_type (name, size)
5895      const char *name;
5896      int size;
5897 {
5898   tree type, decl;
5899   if (size > 0)
5900     type = make_signed_type (size);
5901   else if (size > -32)
5902     { /* "__java_char" or ""__java_boolean". */
5903       type = make_unsigned_type (-size);
5904       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5905     }
5906   else
5907     { /* "__java_float" or ""__java_double". */
5908       type = make_node (REAL_TYPE);
5909       TYPE_PRECISION (type) = - size;
5910       layout_type (type);
5911     }
5912   record_builtin_type (RID_MAX, name, type);
5913   decl = TYPE_NAME (type);
5914
5915   /* Suppress generate debug symbol entries for these types,
5916      since for normal C++ they are just clutter.
5917      However, push_lang_context undoes this if extern "Java" is seen. */
5918   DECL_IGNORED_P (decl) = 1;
5919
5920   TYPE_FOR_JAVA (type) = 1;
5921   return type;
5922 }
5923
5924 /* Push a type into the namespace so that the back-ends ignore it. */
5925
5926 static void
5927 record_unknown_type (type, name)
5928      tree type;
5929      const char *name;
5930 {
5931   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5932   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5933   DECL_IGNORED_P (decl) = 1;
5934   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5935   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5936   TYPE_ALIGN (type) = 1;
5937   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5938 }
5939
5940 /* Push overloaded decl, in global scope, with one argument so it
5941    can be used as a callback from define_function.  */
5942
5943 static void
5944 push_overloaded_decl_1 (x)
5945      tree x;
5946 {
5947   pushdecl (x);
5948 }
5949
5950 inline tree
5951 auto_function (name, type)
5952      tree name, type;
5953 {
5954   return define_function
5955     (IDENTIFIER_POINTER (name), type, push_overloaded_decl_1,
5956      IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5957                                               0)));
5958 }
5959
5960 /* Create the predefined scalar types of C,
5961    and some nodes representing standard constants (0, 1, (void *)0).
5962    Initialize the global binding level.
5963    Make definitions for built-in primitive functions.  */
5964
5965 void
5966 init_decl_processing ()
5967 {
5968   tree fields[20];
5969   int wchar_type_size;
5970   tree array_domain_type;
5971
5972   /* Check to see that the user did not specify an invalid combination
5973      of command-line options.  */
5974   if (flag_new_abi && !flag_vtable_thunks)
5975     fatal ("the new ABI requires vtable thunks");
5976
5977   /* Have to make these distinct before we try using them.  */
5978   lang_name_cplusplus = get_identifier ("C++");
5979   lang_name_c = get_identifier ("C");
5980   lang_name_java = get_identifier ("Java");
5981
5982   /* Let the back-end now how to save and restore language-specific
5983      per-function globals.  */
5984   init_lang_status = &push_cp_function_context;
5985   free_lang_status = &pop_cp_function_context;
5986   mark_lang_status = &mark_cp_function_context;
5987
5988   cp_parse_init ();
5989   init_decl2 ();
5990   init_pt ();
5991
5992   /* Create the global variables.  */
5993   push_to_top_level ();
5994
5995   /* Enter the global namespace. */
5996   my_friendly_assert (global_namespace == NULL_TREE, 375);
5997   push_namespace (get_identifier ("::"));
5998   global_namespace = current_namespace;
5999   current_lang_name = NULL_TREE;
6000
6001   /* Adjust various flags based on command-line settings.  */
6002   if (flag_strict_prototype == 2)
6003     flag_strict_prototype = pedantic;
6004   if (! flag_permissive && ! pedantic)
6005     flag_pedantic_errors = 1;
6006   if (!flag_no_inline)
6007     flag_inline_trees = 1;
6008
6009   strict_prototypes_lang_c = flag_strict_prototype;
6010
6011   /* Initially, C.  */
6012   current_lang_name = lang_name_c;
6013
6014   current_function_decl = NULL_TREE;
6015   current_binding_level = NULL_BINDING_LEVEL;
6016   free_binding_level = NULL_BINDING_LEVEL;
6017
6018   /* Because most segmentation signals can be traced back into user
6019      code, catch them and at least give the user a chance of working
6020      around compiler bugs.  */
6021   signal (SIGSEGV, signal_catch);
6022
6023   /* We will also catch aborts in the back-end through signal_catch and
6024      give the user a chance to see where the error might be, and to defeat
6025      aborts in the back-end when there have been errors previously in their
6026      code.  */
6027 #ifdef SIGIOT
6028   signal (SIGIOT, signal_catch);
6029 #endif
6030 #ifdef SIGILL
6031   signal (SIGILL, signal_catch);
6032 #endif
6033 #ifdef SIGABRT
6034   signal (SIGABRT, signal_catch);
6035 #endif
6036 #ifdef SIGBUS
6037   signal (SIGBUS, signal_catch);
6038 #endif
6039
6040   build_common_tree_nodes (flag_signed_char);
6041
6042   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6043   TREE_TYPE (error_mark_list) = error_mark_node;
6044
6045   /* Make the binding_level structure for global names.  */
6046   pushlevel (0);
6047   global_binding_level = current_binding_level;
6048   /* The global level is the namespace level of ::.  */
6049   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6050   declare_namespace_level ();
6051
6052   this_identifier = get_identifier (THIS_NAME);
6053   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6054   ctor_identifier = get_identifier (CTOR_NAME);
6055   dtor_identifier = get_identifier (DTOR_NAME);
6056   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6057   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6058   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6059   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6060   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6061
6062   /* Define `int' and `char' first so that dbx will output them first.  */
6063   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6064   record_builtin_type (RID_CHAR, "char", char_type_node);
6065
6066   /* `signed' is the same as `int' */
6067   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6068   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6069   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6070   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6071   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6072   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6073   record_builtin_type (RID_MAX, "long long unsigned int",
6074                        long_long_unsigned_type_node);
6075   record_builtin_type (RID_MAX, "long long unsigned",
6076                        long_long_unsigned_type_node);
6077   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6078   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6079   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6080
6081   ptrdiff_type_node
6082     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6083
6084   /* Define both `signed char' and `unsigned char'.  */
6085   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6086   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6087
6088   /* `unsigned long' is the standard type for sizeof.
6089      Note that stddef.h uses `unsigned long',
6090      and this must agree, even if long and int are the same size.  */
6091   set_sizetype
6092     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6093
6094   /* Create the widest literal types. */
6095   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6096   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6097                         widest_integer_literal_type_node));
6098
6099   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6100   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6101                         widest_unsigned_literal_type_node));
6102
6103   /* These are types that type_for_size and type_for_mode use.  */
6104   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6105   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6106   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6107   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6108 #if HOST_BITS_PER_WIDE_INT >= 64
6109   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6110 #endif
6111   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6112   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6113   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6114   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6115 #if HOST_BITS_PER_WIDE_INT >= 64
6116   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6117 #endif
6118
6119   build_common_tree_nodes_2 (flag_short_double);
6120
6121   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6122   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6123   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6124   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6125   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6126   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6127   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6128   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6129
6130   integer_two_node = build_int_2 (2, 0);
6131   TREE_TYPE (integer_two_node) = integer_type_node;
6132   integer_three_node = build_int_2 (3, 0);
6133   TREE_TYPE (integer_three_node) = integer_type_node;
6134
6135   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6136   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6137   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6138   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6139   TYPE_PRECISION (boolean_type_node) = 1;
6140   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6141   boolean_false_node = build_int_2 (0, 0);
6142   TREE_TYPE (boolean_false_node) = boolean_type_node;
6143   boolean_true_node = build_int_2 (1, 0);
6144   TREE_TYPE (boolean_true_node) = boolean_type_node;
6145
6146   signed_size_zero_node = build_int_2 (0, 0);  record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6147   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6148   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6149
6150   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6151                         complex_integer_type_node));
6152   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6153                         complex_float_type_node));
6154   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6155                         complex_double_type_node));
6156   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6157                         complex_long_double_type_node));
6158
6159   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6160
6161   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6162   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6163   TREE_PARMLIST (void_list_node) = 1;
6164
6165   /* Used for expressions that do nothing, but are not errors.  */
6166   void_zero_node = build_int_2 (0, 0);
6167   TREE_TYPE (void_zero_node) = void_type_node;
6168
6169   string_type_node = build_pointer_type (char_type_node);
6170   const_string_type_node
6171     = build_pointer_type (build_qualified_type (char_type_node,
6172                                                 TYPE_QUAL_CONST));
6173   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6174 #if 0
6175   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6176 #endif
6177
6178   /* Make a type to be the domain of a few array types
6179      whose domains don't really matter.
6180      200 is small enough that it always fits in size_t.  */
6181   array_domain_type = build_index_type (build_int_2 (200, 0));
6182
6183   /* Make a type for arrays of characters.
6184      With luck nothing will ever really depend on the length of this
6185      array type.  */
6186   char_array_type_node
6187     = build_array_type (char_type_node, array_domain_type);
6188   /* Likewise for arrays of ints.  */
6189   int_array_type_node
6190     = build_array_type (integer_type_node, array_domain_type);
6191
6192   if (flag_new_abi)
6193     delta_type_node = ptrdiff_type_node;
6194   else if (flag_huge_objects)
6195     delta_type_node = long_integer_type_node;
6196   else
6197     delta_type_node = short_integer_type_node;
6198
6199   if (flag_new_abi)
6200     vtable_index_type = ptrdiff_type_node;
6201   else
6202     vtable_index_type = delta_type_node;
6203
6204   default_function_type
6205     = build_function_type (integer_type_node, NULL_TREE);
6206
6207   ptr_type_node = build_pointer_type (void_type_node);
6208   const_ptr_type_node
6209     = build_pointer_type (build_qualified_type (void_type_node,
6210                                                 TYPE_QUAL_CONST));
6211   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6212   lang_type_promotes_to = convert_type_from_ellipsis;
6213
6214   void_ftype_ptr
6215     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6216
6217   /* C++ extensions */
6218
6219   unknown_type_node = make_node (UNKNOWN_TYPE);
6220   record_unknown_type (unknown_type_node, "unknown type");
6221
6222   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6223   TREE_TYPE (unknown_type_node) = unknown_type_node;
6224
6225   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6226
6227   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6228      result.  */
6229   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6230   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6231
6232   /* This is special for C++ so functions can be overloaded.  */
6233   wchar_type_node = get_identifier (flag_short_wchar
6234                                     ? "short unsigned int"
6235                                     : WCHAR_TYPE);
6236   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6237   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6238   signed_wchar_type_node = make_signed_type (wchar_type_size);
6239   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6240   wchar_type_node
6241     = TREE_UNSIGNED (wchar_type_node)
6242       ? unsigned_wchar_type_node
6243       : signed_wchar_type_node;
6244   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6245
6246   /* Artificial declaration of wchar_t -- can be bashed */
6247   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6248                                 wchar_type_node);
6249   pushdecl (wchar_decl_node);
6250
6251   /* This is for wide string constants.  */
6252   wchar_array_type_node
6253     = build_array_type (wchar_type_node, array_domain_type);
6254
6255   if (flag_vtable_thunks)
6256     {
6257       /* Make sure we get a unique function type, so we can give
6258          its pointer type a name.  (This wins for gdb.) */
6259       tree vfunc_type = make_node (FUNCTION_TYPE);
6260       TREE_TYPE (vfunc_type) = integer_type_node;
6261       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6262       layout_type (vfunc_type);
6263
6264       vtable_entry_type = build_pointer_type (vfunc_type);
6265     }
6266   else
6267     {
6268       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6269       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6270                                    delta_type_node);
6271       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6272                                    delta_type_node);
6273       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6274                                    ptr_type_node);
6275       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6276                            double_type_node);
6277
6278       /* Make this part of an invisible union.  */
6279       fields[3] = copy_node (fields[2]);
6280       TREE_TYPE (fields[3]) = delta_type_node;
6281       DECL_NAME (fields[3]) = delta2_identifier;
6282       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6283       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6284       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6285       TREE_UNSIGNED (fields[3]) = 0;
6286       TREE_CHAIN (fields[2]) = fields[3];
6287       vtable_entry_type = build_qualified_type (vtable_entry_type,
6288                                                 TYPE_QUAL_CONST);
6289     }
6290   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6291
6292   vtbl_type_node
6293     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6294   layout_type (vtbl_type_node);
6295   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6296   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6297   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6298   layout_type (vtbl_ptr_type_node);
6299   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6300
6301   std_node = build_decl (NAMESPACE_DECL,
6302                          get_identifier (flag_honor_std ? "fake std":"std"),
6303                          void_type_node);
6304   pushdecl (std_node);
6305
6306   global_type_node = make_node (LANG_TYPE);
6307   record_unknown_type (global_type_node, "global type");
6308
6309   /* Now, C++.  */
6310   current_lang_name = lang_name_cplusplus;
6311
6312   {
6313     tree bad_alloc_type_node, newtype, deltype;
6314     if (flag_honor_std)
6315       push_namespace (get_identifier ("std"));
6316     bad_alloc_type_node = xref_tag
6317       (class_type_node, get_identifier ("bad_alloc"), 1);
6318     if (flag_honor_std)
6319       pop_namespace ();
6320     newtype = build_exception_variant
6321       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6322     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6323     auto_function (ansi_opname[(int) NEW_EXPR], newtype);
6324     auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6325     global_delete_fndecl = auto_function (ansi_opname[(int) DELETE_EXPR],
6326                                           deltype);
6327     auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6328   }
6329
6330   abort_fndecl
6331     = define_function ("__pure_virtual", void_ftype, 0, 0);
6332
6333   /* Perform other language dependent initializations.  */
6334   init_class_processing ();
6335   init_init_processing ();
6336   init_search_processing ();
6337   init_rtti_processing ();
6338
6339   if (flag_exceptions)
6340     init_exception_processing ();
6341   if (flag_no_inline)
6342     {
6343       flag_inline_functions = 0;
6344     }
6345
6346   if (! supports_one_only ())
6347     flag_weak = 0;
6348
6349   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6350   make_fname_decl = cp_make_fname_decl;
6351   declare_function_name ();
6352
6353   /* Prepare to check format strings against argument lists.  */
6354   init_function_format_info ();
6355
6356   /* Show we use EH for cleanups.  */
6357   using_eh_for_cleanups ();
6358
6359   print_error_function = lang_print_error_function;
6360   lang_get_alias_set = &c_get_alias_set;
6361   valid_lang_attribute = cp_valid_lang_attribute;
6362
6363   /* Maintain consistency.  Perhaps we should just complain if they
6364      say -fwritable-strings?  */
6365   if (flag_writable_strings)
6366     flag_const_strings = 0;
6367
6368   /* Add GC roots for all of our global variables.  */
6369   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6370   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6371   ggc_add_tree_root (&integer_three_node, 1);
6372   ggc_add_tree_root (&integer_two_node, 1);
6373   ggc_add_tree_root (&signed_size_zero_node, 1);
6374   ggc_add_tree_root (&size_one_node, 1);
6375   ggc_add_tree_root (&size_zero_node, 1);
6376   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6377                 mark_binding_level);
6378   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6379   ggc_add_tree_root (&static_ctors, 1);
6380   ggc_add_tree_root (&static_dtors, 1);
6381   ggc_add_tree_root (&lastiddecl, 1);
6382
6383   ggc_add_tree_root (&last_function_parm_tags, 1);
6384   ggc_add_tree_root (&current_function_return_value, 1);
6385   ggc_add_tree_root (&current_function_parms, 1);
6386   ggc_add_tree_root (&current_function_parm_tags, 1);
6387   ggc_add_tree_root (&last_function_parms, 1);
6388   ggc_add_tree_root (&error_mark_list, 1);
6389
6390   ggc_add_tree_root (&global_namespace, 1);
6391   ggc_add_tree_root (&global_type_node, 1);
6392   ggc_add_tree_root (&anonymous_namespace_name, 1);
6393
6394   ggc_add_tree_root (&got_object, 1);
6395   ggc_add_tree_root (&got_scope, 1);
6396
6397   ggc_add_tree_root (&current_lang_name, 1);
6398   ggc_add_tree_root (&static_aggregates, 1);
6399 }
6400
6401 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6402    decl, NAME is the initialization string and TYPE_DEP indicates whether
6403    NAME depended on the type of the function. We make use of that to detect
6404    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6405    the function before emitting any of it, we don't need to treat the
6406    VAR_DECL specially. We can decide whether to emit it later, if it was
6407    used.  */
6408
6409 static tree
6410 cp_make_fname_decl (id, name, type_dep)
6411      tree id;
6412      const char *name;
6413      int type_dep;
6414 {
6415   tree decl, type, init;
6416   size_t length = strlen (name);
6417   tree domain = NULL_TREE;
6418
6419   if (!processing_template_decl)
6420     type_dep = 0;
6421   if (!type_dep)
6422     domain = build_index_type (build_int_2 (length, 0));
6423
6424   type =  build_cplus_array_type
6425           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6426            domain);
6427
6428   decl = build_lang_decl (VAR_DECL, id, type);
6429   TREE_STATIC (decl) = 1;
6430   TREE_READONLY (decl) = 1;
6431   DECL_SOURCE_LINE (decl) = 0;
6432   DECL_ARTIFICIAL (decl) = 1;
6433   DECL_IN_SYSTEM_HEADER (decl) = 1;
6434   pushdecl (decl);
6435   if (processing_template_decl)
6436     decl = push_template_decl (decl);
6437   if (type_dep)
6438     {
6439       init = build (FUNCTION_NAME, type);
6440       DECL_PRETTY_FUNCTION_P (decl) = 1;
6441     }
6442   else
6443     {
6444       init = build_string (length + 1, name);
6445       TREE_TYPE (init) = type;
6446     }
6447   DECL_INITIAL (decl) = init;
6448   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6449
6450   /* We will have to make sure we only emit this, if it is actually used. */
6451   return decl;
6452 }
6453
6454 /* Function to print any language-specific context for an error message.  */
6455
6456 static void
6457 lang_print_error_function (file)
6458      const char *file;
6459 {
6460   default_print_error_function (file);
6461   maybe_print_template_context ();
6462 }
6463
6464 /* Make a definition for a builtin function named NAME and whose data type
6465    is TYPE.  TYPE should be a function type with argument types.
6466
6467    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6468    the name to be called if we can't opencode the function.  */
6469
6470 tree
6471 define_function (name, type, pfn, library_name)
6472      const char *name;
6473      tree type;
6474      void (*pfn) PARAMS ((tree));
6475      const char *library_name;
6476 {
6477   tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6478   DECL_EXTERNAL (decl) = 1;
6479   TREE_PUBLIC (decl) = 1;
6480   DECL_ARTIFICIAL (decl) = 1;
6481
6482   /* If no exception specifier was given, assume it doesn't throw.  */
6483   if (TYPE_RAISES_EXCEPTIONS (type) == NULL_TREE)
6484     TREE_NOTHROW (decl) = 1;
6485
6486   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6487   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6488
6489   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6490      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6491      function in the namespace.  */
6492   if (pfn) (*pfn) (decl);
6493   if (library_name)
6494     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6495   make_function_rtl (decl);
6496   return decl;
6497 }
6498
6499
6500 /* Wrapper around define_function, for the benefit of
6501    c_common_nodes_and_builtins.
6502    FUNCTION_CODE tells later passes how to compile calls to this function.
6503    See tree.h for its possible values.  */
6504
6505 tree
6506 builtin_function (name, type, code, class, libname)
6507      const char *name;
6508      tree type;
6509      int code;
6510      enum built_in_class class;
6511      const char *libname;
6512 {
6513   tree decl = define_function (name, type, (void (*) PARAMS ((tree)))pushdecl,
6514                                libname);
6515   DECL_BUILT_IN_CLASS (decl) = class;
6516   DECL_FUNCTION_CODE (decl) = code;
6517   return decl;
6518 }
6519 \f
6520 /* When we call finish_struct for an anonymous union, we create
6521    default copy constructors and such.  But, an anonymous union
6522    shouldn't have such things; this function undoes the damage to the
6523    anonymous union type T.
6524
6525    (The reason that we create the synthesized methods is that we don't
6526    distinguish `union { int i; }' from `typedef union { int i; } U'.
6527    The first is an anonymous union; the second is just an ordinary
6528    union type.)  */
6529
6530 void
6531 fixup_anonymous_aggr (t)
6532      tree t;
6533 {
6534   tree *q;
6535
6536   /* Wipe out memory of synthesized methods */
6537   TYPE_HAS_CONSTRUCTOR (t) = 0;
6538   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6539   TYPE_HAS_INIT_REF (t) = 0;
6540   TYPE_HAS_CONST_INIT_REF (t) = 0;
6541   TYPE_HAS_ASSIGN_REF (t) = 0;
6542   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6543
6544   /* Splice the implicitly generated functions out of the TYPE_METHODS
6545      list.  */
6546   q = &TYPE_METHODS (t);
6547   while (*q)
6548     {
6549       if (DECL_ARTIFICIAL (*q))
6550         *q = TREE_CHAIN (*q);
6551       else
6552         q = &TREE_CHAIN (*q);
6553     }
6554
6555   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6556   if (TYPE_METHODS (t))
6557     error ("an anonymous union cannot have function members");
6558 }
6559
6560 /* Make sure that a declaration with no declarator is well-formed, i.e.
6561    just defines a tagged type or anonymous union.
6562
6563    Returns the type defined, if any.  */
6564
6565 tree
6566 check_tag_decl (declspecs)
6567      tree declspecs;
6568 {
6569   int found_type = 0;
6570   tree ob_modifier = NULL_TREE;
6571   register tree link;
6572   register tree t = NULL_TREE;
6573
6574   for (link = declspecs; link; link = TREE_CHAIN (link))
6575     {
6576       register tree value = TREE_VALUE (link);
6577
6578       if (TYPE_P (value))
6579         {
6580           ++found_type;
6581
6582           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6583             {
6584               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6585               t = value;
6586             }
6587         }
6588       else if (value == ridpointers[(int) RID_FRIEND])
6589         {
6590           if (current_class_type == NULL_TREE
6591               || current_scope () != current_class_type)
6592             ob_modifier = value;
6593         }
6594       else if (value == ridpointers[(int) RID_STATIC]
6595                || value == ridpointers[(int) RID_EXTERN]
6596                || value == ridpointers[(int) RID_AUTO]
6597                || value == ridpointers[(int) RID_REGISTER]
6598                || value == ridpointers[(int) RID_INLINE]
6599                || value == ridpointers[(int) RID_VIRTUAL]
6600                || value == ridpointers[(int) RID_CONST]
6601                || value == ridpointers[(int) RID_VOLATILE]
6602                || value == ridpointers[(int) RID_EXPLICIT])
6603         ob_modifier = value;
6604     }
6605
6606   if (found_type > 1)
6607     error ("multiple types in one declaration");
6608
6609   /* Inside a class, we might be in a friend or access declaration.
6610      Until we have a good way of detecting the latter, don't warn.  */
6611   if (t == NULL_TREE && ! current_class_type)
6612     pedwarn ("declaration does not declare anything");
6613
6614   /* Check for an anonymous union.  We're careful
6615      accessing TYPE_IDENTIFIER because some built-in types, like
6616      pointer-to-member types, do not have TYPE_NAME.  */
6617   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6618            && TYPE_NAME (t)
6619            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6620     {
6621       /* Anonymous unions are objects, so they can have specifiers.  */;
6622       SET_ANON_AGGR_TYPE_P (t);
6623
6624       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6625         pedwarn ("ISO C++ prohibits anonymous structs");
6626     }
6627
6628   else if (ob_modifier)
6629     {
6630       if (ob_modifier == ridpointers[(int) RID_INLINE]
6631           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6632         cp_error ("`%D' can only be specified for functions", ob_modifier);
6633       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6634         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6635       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6636         cp_error ("`%D' can only be specified for constructors",
6637                   ob_modifier);
6638       else
6639         cp_error ("`%D' can only be specified for objects and functions",
6640                   ob_modifier);
6641     }
6642
6643   return t;
6644 }
6645
6646 /* Called when a declaration is seen that contains no names to declare.
6647    If its type is a reference to a structure, union or enum inherited
6648    from a containing scope, shadow that tag name for the current scope
6649    with a forward reference.
6650    If its type defines a new named structure or union
6651    or defines an enum, it is valid but we need not do anything here.
6652    Otherwise, it is an error.
6653
6654    C++: may have to grok the declspecs to learn about static,
6655    complain for anonymous unions.  */
6656
6657 void
6658 shadow_tag (declspecs)
6659      tree declspecs;
6660 {
6661   tree t = check_tag_decl (declspecs);
6662
6663   if (t)
6664     maybe_process_partial_specialization (t);
6665
6666   /* This is where the variables in an anonymous union are
6667      declared.  An anonymous union declaration looks like:
6668      union { ... } ;
6669      because there is no declarator after the union, the parser
6670      sends that declaration here.  */
6671   if (t && ANON_AGGR_TYPE_P (t))
6672     {
6673       fixup_anonymous_aggr (t);
6674
6675       if (TYPE_FIELDS (t))
6676         {
6677           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6678                                       NULL_TREE);
6679           finish_anon_union (decl);
6680         }
6681     }
6682 }
6683 \f
6684 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6685
6686 tree
6687 groktypename (typename)
6688      tree typename;
6689 {
6690   if (TREE_CODE (typename) != TREE_LIST)
6691     return typename;
6692   return grokdeclarator (TREE_VALUE (typename),
6693                          TREE_PURPOSE (typename),
6694                          TYPENAME, 0, NULL_TREE);
6695 }
6696
6697 /* Decode a declarator in an ordinary declaration or data definition.
6698    This is called as soon as the type information and variable name
6699    have been parsed, before parsing the initializer if any.
6700    Here we create the ..._DECL node, fill in its type,
6701    and put it on the list of decls for the current context.
6702    The ..._DECL node is returned as the value.
6703
6704    Exception: for arrays where the length is not specified,
6705    the type is left null, to be filled in by `cp_finish_decl'.
6706
6707    Function definitions do not come here; they go to start_function
6708    instead.  However, external and forward declarations of functions
6709    do go through here.  Structure field declarations are done by
6710    grokfield and not through here.  */
6711
6712 /* Set this to zero to debug not using the temporary obstack
6713    to parse initializers.  */
6714 int debug_temp_inits = 1;
6715
6716 tree
6717 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6718      tree declarator, declspecs;
6719      int initialized;
6720      tree attributes, prefix_attributes;
6721 {
6722   register tree decl;
6723   register tree type, tem;
6724   tree context;
6725   extern int have_extern_spec;
6726   extern int used_extern_spec;
6727   tree attrlist;
6728
6729 #if 0
6730   /* See code below that used this.  */
6731   int init_written = initialized;
6732 #endif
6733
6734   /* This should only be done once on the top most decl.  */
6735   if (have_extern_spec && !used_extern_spec)
6736     {
6737       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6738                                   declspecs);
6739       used_extern_spec = 1;
6740     }
6741
6742   if (attributes || prefix_attributes)
6743     attrlist = build_tree_list (attributes, prefix_attributes);
6744   else
6745     attrlist = NULL_TREE;
6746
6747   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6748                          attrlist);
6749
6750   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6751     return NULL_TREE;
6752
6753   type = TREE_TYPE (decl);
6754
6755   if (type == error_mark_node)
6756     return NULL_TREE;
6757
6758   context = DECL_CONTEXT (decl);
6759
6760   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6761       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6762     {
6763       /* When parsing the initializer, lookup should use the object's
6764          namespace. */
6765       push_decl_namespace (context);
6766     }
6767
6768   /* We are only interested in class contexts, later. */
6769   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6770     context = NULL_TREE;
6771
6772   if (initialized)
6773     /* Is it valid for this decl to have an initializer at all?
6774        If not, set INITIALIZED to zero, which will indirectly
6775        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6776     switch (TREE_CODE (decl))
6777       {
6778       case TYPE_DECL:
6779         /* typedef foo = bar  means give foo the same type as bar.
6780            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6781            Any other case of an initialization in a TYPE_DECL is an error.  */
6782         if (pedantic || list_length (declspecs) > 1)
6783           {
6784             cp_error ("typedef `%D' is initialized", decl);
6785             initialized = 0;
6786           }
6787         break;
6788
6789       case FUNCTION_DECL:
6790         cp_error ("function `%#D' is initialized like a variable", decl);
6791         initialized = 0;
6792         break;
6793
6794       default:
6795         break;
6796       }
6797
6798   if (initialized)
6799     {
6800       if (! toplevel_bindings_p ()
6801           && DECL_EXTERNAL (decl))
6802         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6803                     decl);
6804       DECL_EXTERNAL (decl) = 0;
6805       if (toplevel_bindings_p ())
6806         TREE_STATIC (decl) = 1;
6807
6808       /* Tell `pushdecl' this is an initialized decl
6809          even though we don't yet have the initializer expression.
6810          Also tell `cp_finish_decl' it may store the real initializer.  */
6811       DECL_INITIAL (decl) = error_mark_node;
6812     }
6813
6814 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6815   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
6816 #endif
6817
6818   /* Set attributes here so if duplicate decl, will have proper attributes.  */
6819   cplus_decl_attributes (decl, attributes, prefix_attributes);
6820
6821   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6822     {
6823       push_nested_class (context, 2);
6824
6825       if (TREE_CODE (decl) == VAR_DECL)
6826         {
6827           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6828           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6829             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6830           else
6831             {
6832               if (DECL_CONTEXT (field) != context)
6833                 {
6834                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
6835                               DECL_CONTEXT (field), DECL_NAME (decl),
6836                               context, DECL_NAME (decl));
6837                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6838                 }
6839               /* Static data member are tricky; an in-class initialization
6840                  still doesn't provide a definition, so the in-class
6841                  declaration will have DECL_EXTERNAL set, but will have an
6842                  initialization.  Thus, duplicate_decls won't warn
6843                  about this situation, and so we check here.  */
6844               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6845                 cp_error ("duplicate initialization of %D", decl);
6846               if (duplicate_decls (decl, field))
6847                 decl = field;
6848             }
6849         }
6850       else
6851         {
6852           tree field = check_classfn (context, decl);
6853           if (field && duplicate_decls (decl, field))
6854             decl = field;
6855         }
6856
6857       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
6858       DECL_IN_AGGR_P (decl) = 0;
6859       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6860           || CLASSTYPE_USE_TEMPLATE (context))
6861         {
6862           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6863           /* [temp.expl.spec] An explicit specialization of a static data
6864              member of a template is a definition if the declaration
6865              includes an initializer; otherwise, it is a declaration.
6866
6867              We check for processing_specialization so this only applies
6868              to the new specialization syntax.  */
6869           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
6870             DECL_EXTERNAL (decl) = 1;
6871         }
6872
6873       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6874         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6875                     decl);
6876     }
6877
6878   /* Enter this declaration into the symbol table.  */
6879   tem = maybe_push_decl (decl);
6880
6881   if (processing_template_decl)
6882     tem = push_template_decl (tem);
6883
6884 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6885   /* Tell the back-end to use or not use .common as appropriate.  If we say
6886      -fconserve-space, we want this to save .data space, at the expense of
6887      wrong semantics.  If we say -fno-conserve-space, we want this to
6888      produce errors about redefs; to do this we force variables into the
6889      data segment.  */
6890   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6891 #endif
6892
6893   if (! processing_template_decl)
6894     start_decl_1 (tem);
6895
6896   return tem;
6897 }
6898
6899 void
6900 start_decl_1 (decl)
6901      tree decl;
6902 {
6903   tree type = TREE_TYPE (decl);
6904   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6905
6906   if (type == error_mark_node)
6907     return;
6908
6909   /* If this type of object needs a cleanup, but we're not allowed to
6910      add any more objects with cleanups to the current scope, create a
6911      new binding level.  */
6912   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6913       && current_binding_level->more_cleanups_ok == 0)
6914     {
6915       keep_next_level (2);
6916       pushlevel (1);
6917       clear_last_expr ();
6918       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6919     }
6920
6921   if (initialized)
6922     /* Is it valid for this decl to have an initializer at all?
6923        If not, set INITIALIZED to zero, which will indirectly
6924        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6925     {
6926       /* Don't allow initializations for incomplete types except for
6927          arrays which might be completed by the initialization.  */
6928       if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6929         ;                       /* A complete type is ok.  */
6930       else if (TREE_CODE (type) != ARRAY_TYPE)
6931         {
6932           cp_error ("variable `%#D' has initializer but incomplete type",
6933                     decl);
6934           initialized = 0;
6935           type = TREE_TYPE (decl) = error_mark_node;
6936         }
6937       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6938         {
6939           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6940             cp_error ("elements of array `%#D' have incomplete type", decl);
6941           /* else we already gave an error in start_decl.  */
6942           initialized = 0;
6943         }
6944     }
6945
6946   if (!initialized
6947       && TREE_CODE (decl) != TYPE_DECL
6948       && TREE_CODE (decl) != TEMPLATE_DECL
6949       && type != error_mark_node
6950       && IS_AGGR_TYPE (type)
6951       && ! DECL_EXTERNAL (decl))
6952     {
6953       if ((! processing_template_decl || ! uses_template_parms (type))
6954           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6955         {
6956           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6957                  decl);
6958           /* Change the type so that assemble_variable will give
6959              DECL an rtl we can live with: (mem (const_int 0)).  */
6960           type = TREE_TYPE (decl) = error_mark_node;
6961         }
6962       else
6963         {
6964           /* If any base type in the hierarchy of TYPE needs a constructor,
6965              then we set initialized to 1.  This way any nodes which are
6966              created for the purposes of initializing this aggregate
6967              will live as long as it does.  This is necessary for global
6968              aggregates which do not have their initializers processed until
6969              the end of the file.  */
6970           initialized = TYPE_NEEDS_CONSTRUCTING (type);
6971         }
6972     }
6973
6974   if (! initialized)
6975     DECL_INITIAL (decl) = NULL_TREE;
6976 }
6977
6978 /* Handle initialization of references.
6979    These three arguments are from `cp_finish_decl', and have the
6980    same meaning here that they do there.
6981
6982    Quotes on semantics can be found in ARM 8.4.3.  */
6983
6984 static void
6985 grok_reference_init (decl, type, init)
6986      tree decl, type, init;
6987 {
6988   tree tmp;
6989
6990   if (init == NULL_TREE)
6991     {
6992       if ((DECL_LANG_SPECIFIC (decl) == 0
6993            || DECL_IN_AGGR_P (decl) == 0)
6994           && ! DECL_THIS_EXTERN (decl))
6995         cp_error ("`%D' declared as reference but not initialized", decl);
6996       return;
6997     }
6998
6999   if (init == error_mark_node)
7000     return;
7001
7002   if (TREE_CODE (init) == CONSTRUCTOR)
7003     {
7004       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7005       return;
7006     }
7007
7008   if (TREE_CODE (init) == TREE_LIST)
7009     init = build_compound_expr (init);
7010
7011   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7012     init = convert_from_reference (init);
7013
7014   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7015       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7016     {
7017       /* Note: default conversion is only called in very special cases.  */
7018       init = default_conversion (init);
7019     }
7020
7021   /* Convert INIT to the reference type TYPE.  This may involve the
7022      creation of a temporary, whose lifetime must be the same as that
7023      of the reference.  If so, a DECL_STMT for the temporary will be
7024      added just after the DECL_STMT for DECL.  That's why we don't set
7025      DECL_INITIAL for local references (instead assigning to them
7026      explicitly); we need to allow the temporary to be initialized
7027      first.  */
7028   tmp = convert_to_reference
7029     (type, init, CONV_IMPLICIT,
7030      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
7031
7032   if (tmp == error_mark_node)
7033     return;
7034   else if (tmp != NULL_TREE)
7035     {
7036       init = tmp;
7037       tmp = save_expr (tmp);
7038       if (building_stmt_tree ())
7039         {
7040           /* Initialize the declaration.  */
7041           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7042           finish_expr_stmt (tmp);
7043         }
7044       else
7045         DECL_INITIAL (decl) = tmp;
7046     }
7047   else
7048     {
7049       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7050       return;
7051     }
7052
7053   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7054     {
7055       expand_static_init (decl, DECL_INITIAL (decl));
7056       DECL_INITIAL (decl) = NULL_TREE;
7057     }
7058   return;
7059 }
7060
7061 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7062    mucking with forces it does not comprehend (i.e. initialization with a
7063    constructor).  If we are at global scope and won't go into COMMON, fill
7064    it in with a dummy CONSTRUCTOR to force the variable into .data;
7065    otherwise we can use error_mark_node.  */
7066
7067 static tree
7068 obscure_complex_init (decl, init)
7069      tree decl, init;
7070 {
7071   if (! flag_no_inline && TREE_STATIC (decl))
7072     {
7073       if (extract_init (decl, init))
7074         return NULL_TREE;
7075     }
7076
7077 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7078   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7079     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7080                                  NULL_TREE);
7081   else
7082 #endif
7083     DECL_INITIAL (decl) = error_mark_node;
7084
7085   return init;
7086 }
7087
7088 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7089    array until we finish parsing the initializer.  If that's the
7090    situation we're in, update DECL accordingly.  */
7091
7092 static void
7093 maybe_deduce_size_from_array_init (decl, init)
7094      tree decl;
7095      tree init;
7096 {
7097   tree type = TREE_TYPE (decl);
7098
7099   if (TREE_CODE (type) == ARRAY_TYPE
7100       && TYPE_DOMAIN (type) == NULL_TREE
7101       && TREE_CODE (decl) != TYPE_DECL)
7102     {
7103       int do_default
7104         = (TREE_STATIC (decl)
7105            /* Even if pedantic, an external linkage array
7106               may have incomplete type at first.  */
7107            ? pedantic && ! DECL_EXTERNAL (decl)
7108            : !DECL_EXTERNAL (decl));
7109       tree initializer = init ? init : DECL_INITIAL (decl);
7110       int failure = complete_array_type (type, initializer, do_default);
7111
7112       if (failure == 1)
7113         cp_error ("initializer fails to determine size of `%D'", decl);
7114
7115       if (failure == 2)
7116         {
7117           if (do_default)
7118             cp_error ("array size missing in `%D'", decl);
7119           /* If a `static' var's size isn't known, make it extern as
7120              well as static, so it does not get allocated.  If it's not
7121              `static', then don't mark it extern; finish_incomplete_decl
7122              will give it a default size and it will get allocated.  */
7123           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7124             DECL_EXTERNAL (decl) = 1;
7125         }
7126
7127       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7128           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7129                               integer_zero_node))
7130         cp_error ("zero-size array `%D'", decl);
7131
7132       layout_decl (decl, 0);
7133     }
7134 }
7135
7136 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7137    any appropriate error messages regarding the layout.  */
7138
7139 static void
7140 layout_var_decl (decl)
7141      tree decl;
7142 {
7143   tree type = TREE_TYPE (decl);
7144 #if 0
7145   tree ttype = target_type (type);
7146 #endif
7147
7148   /* If we haven't already layed out this declaration, do so now.
7149      Note that we must not call complete type for an external object
7150      because it's type might involve templates that we are not
7151      supposed to isntantiate yet.  (And it's perfectly legal to say
7152      `extern X x' for some incomplete type `X'.)  */
7153   if (!DECL_EXTERNAL (decl))
7154     complete_type (type);
7155   if (!DECL_SIZE (decl) && TYPE_SIZE (type))
7156     layout_decl (decl, 0);
7157
7158   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7159     {
7160       /* An automatic variable with an incomplete type: that is an error.
7161          Don't talk about array types here, since we took care of that
7162          message in grokdeclarator.  */
7163       cp_error ("storage size of `%D' isn't known", decl);
7164       TREE_TYPE (decl) = error_mark_node;
7165     }
7166 #if 0
7167   /* Keep this code around in case we later want to control debug info
7168      based on whether a type is "used".  (jason 1999-11-11) */
7169
7170   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7171     /* Let debugger know it should output info for this type.  */
7172     note_debug_info_needed (ttype);
7173
7174   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7175     note_debug_info_needed (DECL_CONTEXT (decl));
7176 #endif
7177
7178   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7179       && DECL_SIZE (decl) != NULL_TREE
7180       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7181     {
7182       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7183         constant_expression_warning (DECL_SIZE (decl));
7184       else
7185         cp_error ("storage size of `%D' isn't constant", decl);
7186     }
7187 }
7188
7189 /* If a local static variable is declared in an inline function, or if
7190    we have a weak definition, we must endeavor to create only one
7191    instance of the variable at link-time.  */
7192
7193 static void
7194 maybe_commonize_var (decl)
7195      tree decl;
7196 {
7197   /* Static data in a function with comdat linkage also has comdat
7198      linkage.  */
7199   if (TREE_STATIC (decl)
7200       /* Don't mess with __FUNCTION__.  */
7201       && ! TREE_ASM_WRITTEN (decl)
7202       && current_function_decl
7203       && DECL_CONTEXT (decl) == current_function_decl
7204       && (DECL_THIS_INLINE (current_function_decl)
7205           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7206       && TREE_PUBLIC (current_function_decl))
7207     {
7208       /* Rather than try to get this right with inlining, we suppress
7209          inlining of such functions.  */
7210       current_function_cannot_inline
7211         = "function with static variable cannot be inline";
7212
7213       /* If flag_weak, we don't need to mess with this, as we can just
7214          make the function weak, and let it refer to its unique local
7215          copy.  This works because we don't allow the function to be
7216          inlined.  */
7217       if (! flag_weak)
7218         {
7219           if (DECL_INTERFACE_KNOWN (current_function_decl))
7220             {
7221               TREE_PUBLIC (decl) = 1;
7222               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7223             }
7224           else if (DECL_INITIAL (decl) == NULL_TREE
7225                    || DECL_INITIAL (decl) == error_mark_node)
7226             {
7227               TREE_PUBLIC (decl) = 1;
7228               DECL_COMMON (decl) = 1;
7229             }
7230           /* else we lose. We can only do this if we can use common,
7231              which we can't if it has been initialized.  */
7232
7233           if (TREE_PUBLIC (decl))
7234             DECL_ASSEMBLER_NAME (decl)
7235               = build_static_name (current_function_decl, DECL_NAME (decl));
7236           else if (! DECL_ARTIFICIAL (decl))
7237             {
7238               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7239               cp_warning_at ("  you can work around this by removing the initializer", decl);
7240             }
7241         }
7242     }
7243   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7244     /* Set it up again; we might have set DECL_INITIAL since the last
7245        time.  */
7246     comdat_linkage (decl);
7247 }
7248
7249 /* Issue an error message if DECL is an uninitialized const variable.  */
7250
7251 static void
7252 check_for_uninitialized_const_var (decl)
7253      tree decl;
7254 {
7255   tree type = TREE_TYPE (decl);
7256
7257   /* ``Unless explicitly declared extern, a const object does not have
7258      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7259      7.1.6 */
7260   if (TREE_CODE (decl) == VAR_DECL
7261       && TREE_CODE (type) != REFERENCE_TYPE
7262       && CP_TYPE_CONST_P (type)
7263       && !TYPE_NEEDS_CONSTRUCTING (type)
7264       && !DECL_INITIAL (decl))
7265     cp_error ("uninitialized const `%D'", decl);
7266 }
7267
7268 /* Verify INIT (the initializer for DECL), and record the
7269    initialization in DECL_INITIAL, if appropriate.  Returns a new
7270    value for INIT.  */
7271
7272 static tree
7273 check_initializer (decl, init)
7274      tree decl;
7275      tree init;
7276 {
7277   tree type;
7278
7279   if (TREE_CODE (decl) == FIELD_DECL)
7280     return init;
7281
7282   type = TREE_TYPE (decl);
7283
7284   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7285   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7286     init = NULL_TREE;
7287
7288   /* Check the initializer.  */
7289   if (init)
7290     {
7291       /* Things that are going to be initialized need to have complete
7292          type.  */
7293       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7294
7295       if (type == error_mark_node)
7296         /* We will have already complained.  */
7297         init = NULL_TREE;
7298       else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7299         {
7300           cp_error ("variable-sized object `%D' may not be initialized", decl);
7301           init = NULL_TREE;
7302         }
7303       else if (TREE_CODE (type) == ARRAY_TYPE
7304                && !TYPE_SIZE (TREE_TYPE (type)))
7305         {
7306           cp_error ("elements of array `%#D' have incomplete type", decl);
7307           init = NULL_TREE;
7308         }
7309       else if (!TYPE_SIZE (type))
7310         {
7311           cp_error ("`%D' has incomplete type", decl);
7312           TREE_TYPE (decl) = error_mark_node;
7313           init = NULL_TREE;
7314         }
7315     }
7316
7317   if (TREE_CODE (decl) == CONST_DECL)
7318     {
7319       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7320
7321       DECL_INITIAL (decl) = init;
7322
7323       /* This will keep us from needing to worry about our obstacks.  */
7324       my_friendly_assert (init != NULL_TREE, 149);
7325       init = NULL_TREE;
7326     }
7327   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7328     {
7329       if (TREE_STATIC (decl))
7330         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7331       grok_reference_init (decl, type, init);
7332       init = NULL_TREE;
7333     }
7334   else if (init)
7335     {
7336       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7337         {
7338           if (TREE_CODE (type) == ARRAY_TYPE)
7339             init = digest_init (type, init, (tree *) 0);
7340           else if (TREE_CODE (init) == CONSTRUCTOR
7341                    && TREE_HAS_CONSTRUCTOR (init))
7342             {
7343               if (TYPE_NON_AGGREGATE_CLASS (type))
7344                 {
7345                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7346                             decl);
7347                   init = error_mark_node;
7348                 }
7349               else
7350                 goto dont_use_constructor;
7351             }
7352         }
7353       else
7354         {
7355         dont_use_constructor:
7356           if (TREE_CODE (init) != TREE_VEC)
7357             init = store_init_value (decl, init);
7358         }
7359
7360       if (init)
7361         /* We must hide the initializer so that expand_decl
7362            won't try to do something it does not understand.  */
7363         init = obscure_complex_init (decl, init);
7364     }
7365   else if (DECL_EXTERNAL (decl))
7366     ;
7367   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7368            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7369     {
7370       tree core_type = strip_array_types (type);
7371
7372       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7373         {
7374           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7375             cp_error ("structure `%D' with uninitialized const members", decl);
7376           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7377             cp_error ("structure `%D' with uninitialized reference members",
7378                       decl);
7379         }
7380
7381       check_for_uninitialized_const_var (decl);
7382
7383       if (TYPE_SIZE (type) != NULL_TREE
7384           && TYPE_NEEDS_CONSTRUCTING (type))
7385         init = obscure_complex_init (decl, NULL_TREE);
7386
7387     }
7388   else
7389     check_for_uninitialized_const_var (decl);
7390
7391   return init;
7392 }
7393
7394 /* If DECL is not a local variable, give it RTL.  */
7395
7396 static void
7397 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7398      tree decl;
7399      tree init;
7400      const char *asmspec;
7401 {
7402   int toplev;
7403   tree type;
7404
7405   type = TREE_TYPE (decl);
7406   toplev = toplevel_bindings_p ();
7407
7408   /* Handle non-variables up front.  */
7409   if (TREE_CODE (decl) != VAR_DECL)
7410     {
7411       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7412       return;
7413     }
7414
7415   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7416   if (asmspec)
7417     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7418
7419   if (DECL_VIRTUAL_P (decl))
7420     make_decl_rtl (decl, NULL_PTR, toplev);
7421   else if (TREE_READONLY (decl)
7422            && DECL_INITIAL (decl) != NULL_TREE
7423            && DECL_INITIAL (decl) != error_mark_node
7424            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7425     {
7426       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7427
7428       if (toplev && ! TREE_PUBLIC (decl))
7429         {
7430           /* If this is a static const, change its apparent linkage
7431              if it belongs to a #pragma interface.  */
7432           if (!interface_unknown)
7433             {
7434               TREE_PUBLIC (decl) = 1;
7435               DECL_EXTERNAL (decl) = interface_only;
7436             }
7437           make_decl_rtl (decl, asmspec, toplev);
7438         }
7439       else if (toplev)
7440         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7441     }
7442   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7443     {
7444       my_friendly_assert (TREE_STATIC (decl), 19990828);
7445
7446       if (init == NULL_TREE
7447 #ifdef DEFAULT_STATIC_DEFS
7448           /* If this code is dead, then users must
7449              explicitly declare static member variables
7450              outside the class def'n as well.  */
7451           && TYPE_NEEDS_CONSTRUCTING (type)
7452 #endif
7453           )
7454         {
7455           DECL_EXTERNAL (decl) = 1;
7456           make_decl_rtl (decl, asmspec, 1);
7457         }
7458       else
7459         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7460     }
7461   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7462            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7463     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7464 }
7465
7466 /* Create RTL for the local static variable DECL.  */
7467
7468 void
7469 make_rtl_for_local_static (decl)
7470      tree decl;
7471 {
7472   const char *asmspec = NULL;
7473
7474   /* If we inlined this variable, we could see it's declaration
7475      again.  */
7476   if (DECL_RTL (decl))
7477     return;
7478
7479   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7480     {
7481       /* The only way this situaton can occur is if the
7482          user specified a name for this DECL using the
7483          `attribute' syntax.  */
7484       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7485       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7486     }
7487
7488   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7489 }
7490
7491 /* The old ARM scoping rules injected variables declared in the
7492    initialization statement of a for-statement into the surrounding
7493    scope.  We support this usage, in order to be backward-compatible.
7494    DECL is a just-declared VAR_DECL; if necessary inject its
7495    declaration into the surrounding scope.  */
7496
7497 void
7498 maybe_inject_for_scope_var (decl)
7499      tree decl;
7500 {
7501   if (current_binding_level->is_for_scope)
7502     {
7503       struct binding_level *outer
7504         = current_binding_level->level_chain;
7505
7506       /* Check to see if the same name is already bound at the outer
7507          level, either because it was directly declared, or because a
7508          dead for-decl got preserved.  In either case, the code would
7509          not have been valid under the ARM scope rules, so clear
7510          is_for_scope for the current_binding_level.
7511
7512          Otherwise, we need to preserve the temp slot for decl to last
7513          into the outer binding level.  */
7514
7515       tree outer_binding
7516         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7517
7518       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7519           && (TREE_CODE (BINDING_VALUE (outer_binding))
7520               == VAR_DECL)
7521           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7522         {
7523           BINDING_VALUE (outer_binding)
7524             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7525           current_binding_level->is_for_scope = 0;
7526         }
7527       else if (DECL_IN_MEMORY_P (decl))
7528         preserve_temp_slots (DECL_RTL (decl));
7529     }
7530 }
7531
7532 /* Generate code to initialize DECL (a local variable).  */
7533
7534 void
7535 initialize_local_var (decl, init, flags)
7536      tree decl;
7537      tree init;
7538      int flags;
7539 {
7540   tree type = TREE_TYPE (decl);
7541
7542   /* If the type is bogus, don't bother initializing the variable.  */
7543   if (type == error_mark_node)
7544     return;
7545
7546   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7547     {
7548       /* If we used it already as memory, it must stay in memory.  */
7549       DECL_INITIAL (decl) = NULL_TREE;
7550       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7551     }
7552
7553   /* Local statics are handled differently from ordinary automatic
7554      variables.  */
7555   if (TREE_STATIC (decl))
7556     {
7557       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7558           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7559         expand_static_init (decl, init);
7560       return;
7561     }
7562
7563   if (DECL_SIZE (decl) && type != error_mark_node)
7564     {
7565       int already_used;
7566
7567       /* Compute and store the initial value.  */
7568       already_used = TREE_USED (decl) || TREE_USED (type);
7569
7570       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7571         {
7572           int saved_stmts_are_full_exprs_p;
7573
7574           emit_line_note (DECL_SOURCE_FILE (decl),
7575                           DECL_SOURCE_LINE (decl));
7576           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7577           stmts_are_full_exprs_p = 1;
7578           finish_expr_stmt (build_aggr_init (decl, init, flags));
7579           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7580         }
7581
7582       /* Set this to 0 so we can tell whether an aggregate which was
7583          initialized was ever used.  Don't do this if it has a
7584          destructor, so we don't complain about the 'resource
7585          allocation is initialization' idiom.  Now set
7586          attribute((unused)) on types so decls of that type will be
7587          marked used. (see TREE_USED, above.)  */
7588       if (TYPE_NEEDS_CONSTRUCTING (type)
7589           && ! already_used
7590           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7591           && DECL_NAME (decl))
7592         TREE_USED (decl) = 0;
7593       else if (already_used)
7594         TREE_USED (decl) = 1;
7595     }
7596 }
7597
7598 /* Generate code to destroy DECL (a local variable).  */
7599
7600 static void
7601 destroy_local_var (decl)
7602      tree decl;
7603 {
7604   tree type = TREE_TYPE (decl);
7605   tree cleanup;
7606
7607   /* Only variables get cleaned up.  */
7608   if (TREE_CODE (decl) != VAR_DECL)
7609     return;
7610
7611   /* And only things with destructors need cleaning up.  */
7612   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7613     return;
7614
7615   if (TREE_CODE (decl) == VAR_DECL &&
7616       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7617     /* We don't clean up things that aren't defined in this
7618        translation unit, or that need a static cleanup.  The latter
7619        are handled by finish_file.  */
7620     return;
7621
7622   /* Compute the cleanup.  */
7623   cleanup = maybe_build_cleanup (decl);
7624
7625   /* Record the cleanup required for this declaration.  */
7626   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7627       && cleanup)
7628     finish_decl_cleanup (decl, cleanup);
7629 }
7630
7631 /* Let the back-end know about DECL.  */
7632
7633 void
7634 emit_local_var (decl)
7635      tree decl;
7636 {
7637   /* Create RTL for this variable.  */
7638   if (DECL_RTL (decl))
7639     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7640        All other local variables are assigned RTL in this function.  */
7641     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7642                         19990828);
7643   else
7644     {
7645       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7646         /* The user must have specified an assembler name for this
7647            variable.  Set that up now.  */
7648         rest_of_decl_compilation
7649           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7650            /*top_level=*/0, /*at_end=*/0);
7651       else
7652         expand_decl (decl);
7653     }
7654
7655   /* Actually do the initialization.  */
7656   expand_start_target_temps ();
7657   expand_decl_init (decl);
7658   expand_end_target_temps ();
7659 }
7660
7661 /* Finish processing of a declaration;
7662    install its line number and initial value.
7663    If the length of an array type is not known before,
7664    it must be determined now, from the initial value, or it is an error.
7665
7666    INIT0 holds the value of an initializer that should be allowed to escape
7667    the normal rules.
7668
7669    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7670    if the (init) syntax was used.
7671
7672    For functions that take default parameters, DECL points to its
7673    "maximal" instantiation.  `cp_finish_decl' must then also declared its
7674    subsequently lower and lower forms of instantiation, checking for
7675    ambiguity as it goes.  This can be sped up later.  */
7676
7677 void
7678 cp_finish_decl (decl, init, asmspec_tree, flags)
7679      tree decl, init;
7680      tree asmspec_tree;
7681      int flags;
7682 {
7683   register tree type;
7684   tree ttype = NULL_TREE;
7685   const char *asmspec = NULL;
7686   int was_readonly = 0;
7687
7688   if (! decl)
7689     {
7690       if (init)
7691         error ("assignment (not initialization) in declaration");
7692       return;
7693     }
7694
7695   /* If a name was specified, get the string.  */
7696   if (asmspec_tree)
7697       asmspec = TREE_STRING_POINTER (asmspec_tree);
7698
7699   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7700     {
7701       cp_error ("cannot initialize `%D' to namespace `%D'",
7702                 decl, init);
7703       init = NULL_TREE;
7704     }
7705
7706   if (current_class_type
7707       && CP_DECL_CONTEXT (decl) == current_class_type
7708       && TYPE_BEING_DEFINED (current_class_type)
7709       && (DECL_INITIAL (decl) || init))
7710     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7711
7712   if (TREE_CODE (decl) == VAR_DECL
7713       && DECL_CONTEXT (decl)
7714       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7715       && DECL_CONTEXT (decl) != current_namespace
7716       && init)
7717     {
7718       /* Leave the namespace of the object. */
7719       pop_decl_namespace ();
7720     }
7721
7722   type = TREE_TYPE (decl);
7723
7724   if (type == error_mark_node)
7725     return;
7726
7727   /* Add this declaration to the statement-tree.  */
7728   if (building_stmt_tree () && at_function_scope_p ())
7729     add_decl_stmt (decl);
7730
7731   if (TYPE_HAS_MUTABLE_P (type))
7732     TREE_READONLY (decl) = 0;
7733
7734   if (processing_template_decl)
7735     {
7736       if (init && DECL_INITIAL (decl))
7737         DECL_INITIAL (decl) = init;
7738       goto finish_end0;
7739     }
7740
7741   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7742   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7743
7744   /* Take care of TYPE_DECLs up front.  */
7745   if (TREE_CODE (decl) == TYPE_DECL)
7746     {
7747       if (init && DECL_INITIAL (decl))
7748         {
7749           /* typedef foo = bar; store the type of bar as the type of foo.  */
7750           TREE_TYPE (decl) = type = TREE_TYPE (init);
7751           DECL_INITIAL (decl) = init = NULL_TREE;
7752         }
7753       if (type != error_mark_node
7754           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7755         {
7756           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7757             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7758           set_identifier_type_value (DECL_NAME (decl), type);
7759           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7760         }
7761       GNU_xref_decl (current_function_decl, decl);
7762
7763       /* If we have installed this as the canonical typedef for this
7764          type, and that type has not been defined yet, delay emitting
7765          the debug information for it, as we will emit it later.  */
7766       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7767           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7768         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7769
7770       rest_of_decl_compilation (decl, NULL_PTR,
7771                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7772       goto finish_end;
7773     }
7774
7775   if (TREE_CODE (decl) != FUNCTION_DECL)
7776     ttype = target_type (type);
7777
7778   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7779       && TYPE_NEEDS_CONSTRUCTING (type))
7780     {
7781       /* Currently, GNU C++ puts constants in text space, making them
7782          impossible to initialize.  In the future, one would hope for
7783          an operating system which understood the difference between
7784          initialization and the running of a program.  */
7785       was_readonly = 1;
7786       TREE_READONLY (decl) = 0;
7787     }
7788
7789   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7790     {
7791       /* This must override the asm specifier which was placed by
7792          grokclassfn.  Lay this out fresh.  */
7793       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7794       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7795       make_decl_rtl (decl, asmspec, 0);
7796     }
7797
7798   /* Deduce size of array from initialization, if not already known.  */
7799   maybe_deduce_size_from_array_init (decl, init);
7800   init = check_initializer (decl, init);
7801
7802   GNU_xref_decl (current_function_decl, decl);
7803
7804   if (TREE_CODE (decl) == VAR_DECL)
7805     layout_var_decl (decl);
7806
7807   /* Output the assembler code and/or RTL code for variables and functions,
7808      unless the type is an undefined structure or union.
7809      If not, it will get done when the type is completed.  */
7810   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7811       || TREE_CODE (decl) == RESULT_DECL)
7812     {
7813       if (TREE_CODE (decl) == VAR_DECL)
7814         maybe_commonize_var (decl);
7815
7816       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7817
7818       if (TREE_CODE (type) == FUNCTION_TYPE
7819           || TREE_CODE (type) == METHOD_TYPE)
7820         abstract_virtuals_error (decl,
7821                                  strip_array_types (TREE_TYPE (type)));
7822       else
7823         abstract_virtuals_error (decl, strip_array_types (type));
7824
7825       if (TREE_CODE (decl) == FUNCTION_DECL)
7826         ;
7827       else if (DECL_EXTERNAL (decl)
7828                && ! (DECL_LANG_SPECIFIC (decl)
7829                      && DECL_NOT_REALLY_EXTERN (decl)))
7830         {
7831           if (init)
7832             DECL_INITIAL (decl) = init;
7833         }
7834       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
7835         {
7836           /* This is a local declaration.  */
7837           if (doing_semantic_analysis_p ())
7838             maybe_inject_for_scope_var (decl);
7839           /* Initialize the local variable.  But, if we're building a
7840              statement-tree, we'll do the initialization when we
7841              expand the tree.  */
7842           if (processing_template_decl)
7843             {
7844               if (init || DECL_INITIAL (decl) == error_mark_node)
7845                 DECL_INITIAL (decl) = init;
7846             }
7847           else
7848             {
7849               /* If we're not building RTL, then we need to do so
7850                  now.  */
7851               if (!building_stmt_tree ())
7852                 emit_local_var (decl);
7853               /* Initialize the variable.  */
7854               initialize_local_var (decl, init, flags);
7855               /* Clean up the variable.  */
7856               destroy_local_var (decl);
7857             }
7858         }
7859       else if (TREE_STATIC (decl) && type != error_mark_node)
7860         {
7861           /* Cleanups for static variables are handled by `finish_file'.  */
7862           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7863               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7864             expand_static_init (decl, init);
7865         }
7866     finish_end0:
7867
7868       /* Undo call to `pushclass' that was done in `start_decl'
7869          due to initialization of qualified member variable.
7870          I.e., Foo::x = 10;  */
7871       {
7872         tree context = CP_DECL_CONTEXT (decl);
7873         if (context
7874             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7875             && (TREE_CODE (decl) == VAR_DECL
7876                 /* We also have a pushclass done that we need to undo here
7877                    if we're at top level and declare a method.  */
7878                 || TREE_CODE (decl) == FUNCTION_DECL)
7879             /* If size hasn't been set, we're still defining it,
7880                and therefore inside the class body; don't pop
7881                the binding level..  */
7882             && TYPE_SIZE (context) != NULL_TREE
7883             && context == current_class_type)
7884           pop_nested_class ();
7885       }
7886     }
7887
7888  finish_end:
7889
7890   if (was_readonly)
7891     TREE_READONLY (decl) = 1;
7892 }
7893
7894 /* This is here for a midend callback from c-common.c */
7895
7896 void
7897 finish_decl (decl, init, asmspec_tree)
7898      tree decl, init;
7899      tree asmspec_tree;
7900 {
7901   cp_finish_decl (decl, init, asmspec_tree, 0);
7902 }
7903
7904 /* Returns a declaration for a VAR_DECL as if:
7905
7906      extern "C" TYPE NAME;
7907
7908    had been seen.  Used to create compiler-generated global
7909    variables.  */
7910
7911 tree
7912 declare_global_var (name, type)
7913      tree name;
7914      tree type;
7915 {
7916   tree decl;
7917
7918   push_to_top_level ();
7919   decl = build_decl (VAR_DECL, name, type);
7920   TREE_PUBLIC (decl) = 1;
7921   DECL_EXTERNAL (decl) = 1;
7922   DECL_ARTIFICIAL (decl) = 1;
7923   pushdecl (decl);
7924   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
7925   pop_from_top_level ();
7926
7927   return decl;
7928 }
7929
7930 /* Returns a pointer to the `atexit' function.  Note that if
7931    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
7932    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
7933
7934 static tree
7935 get_atexit_node ()
7936 {
7937   tree atexit_fndecl;
7938   tree arg_types;
7939   tree fn_type;
7940   tree fn_ptr_type;
7941   const char *name;
7942
7943   if (atexit_node)
7944     return atexit_node;
7945
7946   if (flag_use_cxa_atexit)
7947     {
7948       /* The declaration for `__cxa_atexit' is:
7949
7950            int __cxa_atexit (void (*)(void *), void *, void *)
7951
7952          We build up the argument types and then then function type
7953          itself.  */
7954
7955       /* First, build the pointer-to-function type for the first
7956          argument.  */
7957       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7958       fn_type = build_function_type (void_type_node, arg_types);
7959       fn_ptr_type = build_pointer_type (fn_type);
7960       /* Then, build the rest of the argument types.  */
7961       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7962       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
7963       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
7964       /* And the final __cxa_atexit type.  */
7965       fn_type = build_function_type (integer_type_node, arg_types);
7966       fn_ptr_type = build_pointer_type (fn_type);
7967       name = "__cxa_atexit";
7968     }
7969   else
7970     {
7971       /* The declaration for `atexit' is:
7972
7973            int atexit (void (*)());
7974
7975          We build up the argument types and then then function type
7976          itself.  */
7977       fn_type = build_function_type (void_type_node, void_list_node);
7978       fn_ptr_type = build_pointer_type (fn_type);
7979       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
7980       /* Build the final atexit type.  */
7981       fn_type = build_function_type (integer_type_node, arg_types);
7982       name = "atexit";
7983     }
7984
7985   /* Now, build the function declaration.  */
7986   push_lang_context (lang_name_c);
7987   atexit_fndecl = define_function (name, fn_type, /*pfn=*/0, NULL_PTR);
7988   mark_used (atexit_fndecl);
7989   pop_lang_context ();
7990   atexit_node = default_conversion (atexit_fndecl);
7991
7992   return atexit_node;
7993 }
7994
7995 /* Returns the __dso_handle VAR_DECL.  */
7996
7997 static tree
7998 get_dso_handle_node ()
7999 {
8000   if (dso_handle_node)
8001     return dso_handle_node;
8002
8003   /* Declare the variable.  */
8004   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8005                                         ptr_type_node);
8006
8007   return dso_handle_node;
8008 }
8009
8010 /* Begin a new function with internal linkage whose job will be simply
8011    to destroy some particular variable.  */
8012
8013 static tree
8014 start_cleanup_fn ()
8015 {
8016   static int counter = 0;
8017   int old_interface_unknown = interface_unknown;
8018   char name[32];
8019   tree parmtypes;
8020   tree fntype;
8021   tree fndecl;
8022
8023   push_to_top_level ();
8024
8025   /* No need to mangle this.  */
8026   push_lang_context (lang_name_c);
8027
8028   interface_unknown = 1;
8029
8030   /* Build the parameter-types.  */
8031   parmtypes = void_list_node;
8032   /* Functions passed to __cxa_atexit take an additional parameter.
8033      We'll just ignore it.  After we implement the new calling
8034      convention for destructors, we can eliminate the use of
8035      additional cleanup functions entirely in the -fnew-abi case.  */
8036   if (flag_use_cxa_atexit)
8037     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8038   /* Build the function type itself.  */
8039   fntype = build_function_type (void_type_node, parmtypes);
8040   /* Build the name of the function.  */
8041   sprintf (name, "__tcf_%d", counter++);
8042   /* Build the function declaration.  */
8043   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8044   /* It's a function with internal linkage, generated by the
8045      compiler.  */
8046   TREE_PUBLIC (fndecl) = 0;
8047   DECL_ARTIFICIAL (fndecl) = 1;
8048   /* Build the parameter.  */
8049   if (flag_use_cxa_atexit)
8050     {
8051       tree parmdecl;
8052
8053       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8054       DECL_CONTEXT (parmdecl) = fndecl;
8055       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8056       TREE_USED (parmdecl) = 1;
8057       DECL_ARGUMENTS (fndecl) = parmdecl;
8058     }
8059
8060   pushdecl (fndecl);
8061   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8062   do_pushlevel ();
8063
8064   interface_unknown = old_interface_unknown;
8065
8066   pop_lang_context ();
8067
8068   return current_function_decl;
8069 }
8070
8071 /* Finish the cleanup function begun by start_cleanup_fn.  */
8072
8073 static void
8074 end_cleanup_fn ()
8075 {
8076   do_poplevel ();
8077
8078   expand_body (finish_function (lineno, 0));
8079
8080   pop_from_top_level ();
8081 }
8082
8083 /* Generate code to handle the destruction of DECL, an object with
8084    static storage duration.  */
8085
8086 void
8087 register_dtor_fn (decl)
8088      tree decl;
8089 {
8090   tree cleanup;
8091   tree compound_stmt;
8092   tree args;
8093   tree fcall;
8094
8095   int saved_flag_access_control;
8096
8097   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8098     return;
8099
8100   /* Call build_cleanup before we enter the anonymous function so that
8101      any access checks will be done relative to the current scope,
8102      rather than the scope of the anonymous function.  */
8103   build_cleanup (decl);
8104
8105   /* Now start the function.  */
8106   cleanup = start_cleanup_fn ();
8107
8108   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8109      to the original function, rather than the anonymous one.  That
8110      will make the back-end think that nested functions are in use,
8111      which causes confusion.  */
8112   saved_flag_access_control = flag_access_control;
8113   flag_access_control = 0;
8114   fcall = build_cleanup (decl);
8115   flag_access_control = saved_flag_access_control;
8116
8117   /* Create the body of the anonymous function.  */
8118   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8119   finish_expr_stmt (fcall);
8120   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8121   end_cleanup_fn ();
8122
8123   /* Call atexit with the cleanup function.  */
8124   mark_addressable (cleanup);
8125   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8126   if (flag_use_cxa_atexit)
8127     {
8128       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8129       args = tree_cons (NULL_TREE, null_pointer_node, args);
8130       args = tree_cons (NULL_TREE, cleanup, args);
8131     }
8132   else
8133     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8134   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8135 }
8136
8137 void
8138 expand_static_init (decl, init)
8139      tree decl;
8140      tree init;
8141 {
8142   tree oldstatic = value_member (decl, static_aggregates);
8143
8144   if (oldstatic)
8145     {
8146       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8147         cp_error ("multiple initializations given for `%D'", decl);
8148     }
8149   else if (! toplevel_bindings_p ())
8150     {
8151       /* Emit code to perform this initialization but once.  */
8152       tree temp;
8153       tree if_stmt;
8154       tree then_clause;
8155       tree assignment;
8156       tree temp_init;
8157
8158       /* Emit code to perform this initialization but once.  This code
8159          looks like:
8160
8161            static int temp = 0;
8162            if (!temp) {
8163              // Do initialization.
8164              temp = 1;
8165              // Register variable for destruction at end of program.
8166            }
8167
8168          Note that the `temp' variable is only set to 1 *after* the
8169          initialization is complete.  This ensures that an exception,
8170          thrown during the construction, will cause the variable to
8171          reinitialized when we pass through this code again, as per:
8172
8173            [stmt.dcl]
8174
8175            If the initialization exits by throwing an exception, the
8176            initialization is not complete, so it will be tried again
8177            the next time control enters the declaration.
8178
8179          In theory, this process should be thread-safe, too; multiple
8180          threads should not be able to initialize the variable more
8181          than once.  We don't yet attempt to ensure thread-safety.  */
8182       temp = get_temp_name (integer_type_node, 1);
8183       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8184
8185       /* Begin the conditional initialization.  */
8186       if_stmt = begin_if_stmt ();
8187       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8188                                             integer_zero_node),
8189                            if_stmt);
8190       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8191
8192       /* Do the initialization itself.  */
8193       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8194           || (init && TREE_CODE (init) == TREE_LIST))
8195         assignment = build_aggr_init (decl, init, 0);
8196       else if (init)
8197         /* The initialization we're doing here is just a bitwise
8198            copy.  */
8199         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8200       else
8201         assignment = NULL_TREE;
8202
8203       /* Once the assignment is complete, set TEMP to 1.  Since the
8204          construction of the static object is complete at this point,
8205          we want to make sure TEMP is set to 1 even if a temporary
8206          constructed during the initialization throws an exception
8207          when it is destroyed.  So, we combine the initialization and
8208          the assignment to TEMP into a single expression, ensuring
8209          that when we call finish_expr_stmt the cleanups will not be
8210          run until after TEMP is set to 1.  */
8211       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8212       if (assignment)
8213         {
8214           assignment = tree_cons (NULL_TREE, assignment,
8215                                   build_tree_list (NULL_TREE,
8216                                                    temp_init));
8217           assignment = build_compound_expr (assignment);
8218         }
8219       else
8220         assignment = temp_init;
8221       finish_expr_stmt (assignment);
8222
8223       /* Use atexit to register a function for destroying this static
8224          variable.  */
8225       register_dtor_fn (decl);
8226
8227       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8228       finish_then_clause (if_stmt);
8229       finish_if_stmt ();
8230     }
8231   else
8232     static_aggregates = tree_cons (init, decl, static_aggregates);
8233 }
8234
8235 /* Finish the declaration of a catch-parameter.  */
8236
8237 tree
8238 start_handler_parms (declspecs, declarator)
8239      tree declspecs;
8240      tree declarator;
8241 {
8242   tree decl;
8243   if (declspecs)
8244     {
8245       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8246                              1, NULL_TREE);
8247       if (decl == NULL_TREE)
8248         error ("invalid catch parameter");
8249     }
8250   else
8251     decl = NULL_TREE;
8252
8253   return decl;
8254 }
8255
8256 \f
8257 /* Make TYPE a complete type based on INITIAL_VALUE.
8258    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8259    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8260
8261 int
8262 complete_array_type (type, initial_value, do_default)
8263      tree type, initial_value;
8264      int do_default;
8265 {
8266   register tree maxindex = NULL_TREE;
8267   int value = 0;
8268
8269   if (initial_value)
8270     {
8271       /* Note MAXINDEX  is really the maximum index,
8272          one less than the size.  */
8273       if (TREE_CODE (initial_value) == STRING_CST)
8274         {
8275           int eltsize
8276             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8277           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8278                                    / eltsize) - 1, 0);
8279         }
8280       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8281         {
8282           tree elts = CONSTRUCTOR_ELTS (initial_value);
8283
8284           maxindex = ssize_int (-1);
8285           for (; elts; elts = TREE_CHAIN (elts))
8286             {
8287               if (TREE_PURPOSE (elts))
8288                 maxindex = TREE_PURPOSE (elts);
8289               else
8290                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8291             }
8292           maxindex = copy_node (maxindex);
8293         }
8294       else
8295         {
8296           /* Make an error message unless that happened already.  */
8297           if (initial_value != error_mark_node)
8298             value = 1;
8299           else
8300             initial_value = NULL_TREE;
8301
8302           /* Prevent further error messages.  */
8303           maxindex = build_int_2 (0, 0);
8304         }
8305     }
8306
8307   if (!maxindex)
8308     {
8309       if (do_default)
8310         maxindex = build_int_2 (0, 0);
8311       value = 2;
8312     }
8313
8314   if (maxindex)
8315     {
8316       tree itype;
8317       tree domain;
8318
8319       domain = build_index_type (maxindex);
8320       TYPE_DOMAIN (type) = domain;
8321
8322       if (! TREE_TYPE (maxindex))
8323         TREE_TYPE (maxindex) = domain;
8324       if (initial_value)
8325         itype = TREE_TYPE (initial_value);
8326       else
8327         itype = NULL;
8328       if (itype && !TYPE_DOMAIN (itype))
8329         TYPE_DOMAIN (itype) = domain;
8330       /* The type of the main variant should never be used for arrays
8331          of different sizes.  It should only ever be completed with the
8332          size of the array.  */
8333       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8334         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8335     }
8336
8337   /* Lay out the type now that we can get the real answer.  */
8338
8339   layout_type (type);
8340
8341   return value;
8342 }
8343 \f
8344 /* Return zero if something is declared to be a member of type
8345    CTYPE when in the context of CUR_TYPE.  STRING is the error
8346    message to print in that case.  Otherwise, quietly return 1.  */
8347
8348 static int
8349 member_function_or_else (ctype, cur_type, flags)
8350      tree ctype, cur_type;
8351      enum overload_flags flags;
8352 {
8353   if (ctype && ctype != cur_type)
8354     {
8355       if (flags == DTOR_FLAG)
8356         error ("destructor for alien class `%s' cannot be a member",
8357                TYPE_NAME_STRING (ctype));
8358       else
8359         error ("constructor for alien class `%s' cannot be a member",
8360                TYPE_NAME_STRING (ctype));
8361       return 0;
8362     }
8363   return 1;
8364 }
8365 \f
8366 /* Subroutine of `grokdeclarator'.  */
8367
8368 /* Generate errors possibly applicable for a given set of specifiers.
8369    This is for ARM $7.1.2.  */
8370
8371 static void
8372 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8373      tree object;
8374      const char *type;
8375      int virtualp, quals, friendp, raises, inlinep;
8376 {
8377   if (virtualp)
8378     cp_error ("`%D' declared as a `virtual' %s", object, type);
8379   if (inlinep)
8380     cp_error ("`%D' declared as an `inline' %s", object, type);
8381   if (quals)
8382     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8383               object, type);
8384   if (friendp)
8385     cp_error_at ("`%D' declared as a friend", object);
8386   if (raises)
8387     cp_error_at ("`%D' declared with an exception specification", object);
8388 }
8389
8390 /* CTYPE is class type, or null if non-class.
8391    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8392    or METHOD_TYPE.
8393    DECLARATOR is the function's name.
8394    VIRTUALP is truthvalue of whether the function is virtual or not.
8395    FLAGS are to be passed through to `grokclassfn'.
8396    QUALS are qualifiers indicating whether the function is `const'
8397    or `volatile'.
8398    RAISES is a list of exceptions that this function can raise.
8399    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8400    not look, and -1 if we should not call `grokclassfn' at all.
8401
8402    Returns `NULL_TREE' if something goes wrong, after issuing
8403    applicable error messages.  */
8404
8405 static tree
8406 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8407             raises, check, friendp, publicp, inlinep, funcdef_flag,
8408             template_count, in_namespace)
8409      tree ctype, type;
8410      tree declarator;
8411      tree orig_declarator;
8412      int virtualp;
8413      enum overload_flags flags;
8414      tree quals, raises;
8415      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8416      tree in_namespace;
8417 {
8418   tree cname, decl;
8419   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8420   int has_default_arg = 0;
8421   tree t;
8422
8423   if (ctype)
8424     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8425       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8426   else
8427     cname = NULL_TREE;
8428
8429   if (raises)
8430     {
8431       type = build_exception_variant (type, raises);
8432     }
8433
8434   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8435   /* Propagate volatile out from type to decl. */
8436   if (TYPE_VOLATILE (type))
8437     TREE_THIS_VOLATILE (decl) = 1;
8438
8439   /* If this decl has namespace scope, set that up.  */
8440   if (in_namespace)
8441     set_decl_namespace (decl, in_namespace, friendp);
8442   else if (publicp && ! ctype)
8443     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8444
8445   /* `main' and builtins have implicit 'C' linkage.  */
8446   if ((MAIN_NAME_P (declarator)
8447        || (IDENTIFIER_LENGTH (declarator) > 10
8448            && IDENTIFIER_POINTER (declarator)[0] == '_'
8449            && IDENTIFIER_POINTER (declarator)[1] == '_'
8450            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8451       && current_lang_name == lang_name_cplusplus
8452       && ctype == NULL_TREE
8453       /* NULL_TREE means global namespace.  */
8454       && DECL_CONTEXT (decl) == NULL_TREE)
8455     DECL_LANGUAGE (decl) = lang_c;
8456
8457   /* Should probably propagate const out from type to decl I bet (mrs).  */
8458   if (staticp)
8459     {
8460       DECL_STATIC_FUNCTION_P (decl) = 1;
8461       DECL_CONTEXT (decl) = ctype;
8462     }
8463
8464   if (ctype)
8465     DECL_CONTEXT (decl) = ctype;
8466
8467   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8468     {
8469       if (processing_template_decl)
8470         error ("cannot declare `::main' to be a template");
8471       if (inlinep)
8472         error ("cannot declare `::main' to be inline");
8473       else if (! publicp)
8474         error ("cannot declare `::main' to be static");
8475       inlinep = 0;
8476       publicp = 1;
8477     }
8478
8479   /* Members of anonymous types and local classes have no linkage; make
8480      them internal.  */
8481   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8482                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8483     publicp = 0;
8484
8485   if (publicp)
8486     {
8487       /* [basic.link]: A name with no linkage (notably, the name of a class
8488          or enumeration declared in a local scope) shall not be used to
8489          declare an entity with linkage.
8490
8491          Only check this for public decls for now.  */
8492       t = no_linkage_check (TREE_TYPE (decl));
8493       if (t)
8494         {
8495           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8496             {
8497               if (DECL_LANGUAGE (decl) == lang_c)
8498                 /* Allow this; it's pretty common in C.  */;
8499               else
8500                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8501                             decl);
8502             }
8503           else
8504             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8505                         decl, t);
8506         }
8507     }
8508
8509   TREE_PUBLIC (decl) = publicp;
8510   if (! publicp)
8511     {
8512       DECL_INTERFACE_KNOWN (decl) = 1;
8513       DECL_NOT_REALLY_EXTERN (decl) = 1;
8514     }
8515
8516   if (inlinep)
8517     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8518
8519   DECL_EXTERNAL (decl) = 1;
8520   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8521     {
8522       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8523                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8524       quals = NULL_TREE;
8525     }
8526
8527   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8528     grok_op_properties (decl, virtualp, check < 0);
8529
8530   if (ctype && decl_function_context (decl))
8531     DECL_NO_STATIC_CHAIN (decl) = 1;
8532
8533   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8534     if (TREE_PURPOSE (t)
8535         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8536       {
8537         has_default_arg = 1;
8538         break;
8539       }
8540
8541   if (friendp
8542       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8543     {
8544       if (funcdef_flag)
8545         cp_error
8546           ("defining explicit specialization `%D' in friend declaration",
8547            orig_declarator);
8548       else
8549         {
8550           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8551             {
8552               /* Something like `template <class T> friend void f<T>()'.  */
8553               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8554                         orig_declarator);
8555               return NULL_TREE;
8556             }
8557
8558
8559           /* A friend declaration of the form friend void f<>().  Record
8560              the information in the TEMPLATE_ID_EXPR.  */
8561           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8562           DECL_TEMPLATE_INFO (decl)
8563             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8564                          TREE_OPERAND (orig_declarator, 1),
8565                          NULL_TREE);
8566
8567           if (has_default_arg)
8568             {
8569               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8570                         decl);
8571               return NULL_TREE;
8572             }
8573
8574           if (inlinep)
8575             {
8576               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8577                         decl);
8578               return NULL_TREE;
8579             }
8580         }
8581     }
8582
8583   if (has_default_arg)
8584     add_defarg_fn (decl);
8585
8586   /* Plain overloading: will not be grok'd by grokclassfn.  */
8587   if (! ctype && ! processing_template_decl
8588       && DECL_LANGUAGE (decl) != lang_c
8589       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8590     set_mangled_name_for_decl (decl);
8591
8592   if (funcdef_flag)
8593     /* Make the init_value nonzero so pushdecl knows this is not
8594        tentative.  error_mark_node is replaced later with the BLOCK.  */
8595     DECL_INITIAL (decl) = error_mark_node;
8596
8597   /* Caller will do the rest of this.  */
8598   if (check < 0)
8599     return decl;
8600
8601   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8602     {
8603       tree tmp;
8604       /* Just handle constructors here.  We could do this
8605          inside the following if stmt, but I think
8606          that the code is more legible by breaking this
8607          case out.  See comments below for what each of
8608          the following calls is supposed to do.  */
8609       DECL_CONSTRUCTOR_P (decl) = 1;
8610
8611       grokclassfn (ctype, decl, flags, quals);
8612
8613       decl = check_explicit_specialization (orig_declarator, decl,
8614                                             template_count,
8615                                             2 * (funcdef_flag != 0) +
8616                                             4 * (friendp != 0));
8617       if (decl == error_mark_node)
8618         return NULL_TREE;
8619
8620       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8621           && check)
8622         {
8623           tmp = check_classfn (ctype, decl);
8624
8625           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8626             tmp = DECL_TEMPLATE_RESULT(tmp);
8627
8628           if (tmp && DECL_ARTIFICIAL (tmp))
8629             cp_error ("definition of implicitly-declared `%D'", tmp);
8630           if (tmp && duplicate_decls (decl, tmp))
8631             return tmp;
8632         }
8633       if (! grok_ctor_properties (ctype, decl))
8634         return NULL_TREE;
8635     }
8636   else
8637     {
8638       tree tmp;
8639
8640       /* Function gets the ugly name, field gets the nice one.
8641          This call may change the type of the function (because
8642          of default parameters)!  */
8643       if (ctype != NULL_TREE)
8644         grokclassfn (ctype, decl, flags, quals);
8645
8646       decl = check_explicit_specialization (orig_declarator, decl,
8647                                             template_count,
8648                                             2 * (funcdef_flag != 0) +
8649                                             4 * (friendp != 0));
8650       if (decl == error_mark_node)
8651         return NULL_TREE;
8652
8653       if (ctype != NULL_TREE
8654           && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8655           && check)
8656         {
8657           tmp = check_classfn (ctype, decl);
8658
8659           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8660             tmp = DECL_TEMPLATE_RESULT (tmp);
8661
8662           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8663               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8664             {
8665               /* Remove the `this' parm added by grokclassfn.
8666                  XXX Isn't this done in start_function, too?  */
8667               revert_static_member_fn (&decl, NULL, NULL);
8668               last_function_parms = TREE_CHAIN (last_function_parms);
8669             }
8670           if (tmp && DECL_ARTIFICIAL (tmp))
8671             cp_error ("definition of implicitly-declared `%D'", tmp);
8672           if (tmp)
8673             {
8674               /* Attempt to merge the declarations.  This can fail, in
8675                  the case of some illegal specialization declarations.  */
8676               if (!duplicate_decls (decl, tmp))
8677                 cp_error ("no `%#D' member function declared in class `%T'",
8678                           decl, ctype);
8679               return tmp;
8680             }
8681         }
8682
8683       if (ctype == NULL_TREE || check)
8684         return decl;
8685
8686       if (virtualp)
8687         {
8688           DECL_VIRTUAL_P (decl) = 1;
8689           if (DECL_VINDEX (decl) == NULL_TREE)
8690             DECL_VINDEX (decl) = error_mark_node;
8691           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8692         }
8693     }
8694   return decl;
8695 }
8696
8697 static tree
8698 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8699      tree type;
8700      tree declarator;
8701      RID_BIT_TYPE *specbits_in;
8702      int initialized;
8703      int constp;
8704      tree in_namespace;
8705 {
8706   tree decl;
8707   RID_BIT_TYPE specbits;
8708
8709   specbits = *specbits_in;
8710
8711   if (TREE_CODE (type) == OFFSET_TYPE)
8712     {
8713       /* If you declare a static member so that it
8714          can be initialized, the code will reach here.  */
8715       tree basetype = TYPE_OFFSET_BASETYPE (type);
8716       type = TREE_TYPE (type);
8717       decl = build_lang_decl (VAR_DECL, declarator, type);
8718       DECL_CONTEXT (decl) = basetype;
8719       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8720     }
8721   else
8722     {
8723       tree context;
8724
8725       if (in_namespace)
8726         context = in_namespace;
8727       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8728         context = current_namespace;
8729       else
8730         context = NULL_TREE;
8731
8732       if (processing_template_decl)
8733         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8734            we can call push_template_decl.  */
8735         decl = build_lang_decl (VAR_DECL, declarator, type);
8736       else
8737         decl = build_decl (VAR_DECL, declarator, type);
8738
8739       if (context)
8740         set_decl_namespace (decl, context, 0);
8741
8742       context = DECL_CONTEXT (decl);
8743       if (declarator && context && current_lang_name != lang_name_c)
8744         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8745     }
8746
8747   if (in_namespace)
8748     set_decl_namespace (decl, in_namespace, 0);
8749
8750   if (RIDBIT_SETP (RID_EXTERN, specbits))
8751     {
8752       DECL_THIS_EXTERN (decl) = 1;
8753       DECL_EXTERNAL (decl) = !initialized;
8754     }
8755
8756   /* In class context, static means one per class,
8757      public access, and static storage.  */
8758   if (DECL_CLASS_SCOPE_P (decl))
8759     {
8760       TREE_PUBLIC (decl) = 1;
8761       TREE_STATIC (decl) = 1;
8762       DECL_EXTERNAL (decl) = 0;
8763     }
8764   /* At top level, either `static' or no s.c. makes a definition
8765      (perhaps tentative), and absence of `static' makes it public.  */
8766   else if (toplevel_bindings_p ())
8767     {
8768       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8769                             && (DECL_THIS_EXTERN (decl) || ! constp));
8770       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8771     }
8772   /* Not at top level, only `static' makes a static definition.  */
8773   else
8774     {
8775       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8776       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8777     }
8778
8779   if (TREE_PUBLIC (decl))
8780     {
8781       /* [basic.link]: A name with no linkage (notably, the name of a class
8782          or enumeration declared in a local scope) shall not be used to
8783          declare an entity with linkage.
8784
8785          Only check this for public decls for now.  */
8786       tree t = no_linkage_check (TREE_TYPE (decl));
8787       if (t)
8788         {
8789           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8790             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8791           else
8792             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8793                         decl, t);
8794         }
8795     }
8796
8797   return decl;
8798 }
8799
8800 /* Create and return a canonical pointer to member function type, for
8801    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8802
8803 tree
8804 build_ptrmemfunc_type (type)
8805      tree type;
8806 {
8807   tree fields[4];
8808   tree t;
8809   tree u;
8810   tree unqualified_variant = NULL_TREE;
8811
8812   /* If a canonical type already exists for this type, use it.  We use
8813      this method instead of type_hash_canon, because it only does a
8814      simple equality check on the list of field members.  */
8815
8816   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8817     return t;
8818
8819   /* Make sure that we always have the unqualified pointer-to-member
8820      type first.  */
8821   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8822     unqualified_variant
8823       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8824
8825   t = make_aggr_type (RECORD_TYPE);
8826   /* Let the front-end know this is a pointer to member function...  */
8827   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8828   /* ... and not really an aggregate.  */
8829   SET_IS_AGGR_TYPE (t, 0);
8830
8831   if (!flag_new_abi)
8832     {
8833       u = make_aggr_type (UNION_TYPE);
8834       SET_IS_AGGR_TYPE (u, 0);
8835       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8836       fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8837                                    delta_type_node);
8838       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8839       TYPE_NAME (u) = NULL_TREE;
8840
8841       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
8842                                    delta_type_node);
8843       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
8844                                    delta_type_node);
8845       fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8846       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8847     }
8848   else
8849     {
8850       fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8851       fields[1] = build_lang_decl (FIELD_DECL, delta_identifier,
8852                                    delta_type_node);
8853       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8854     }
8855
8856   /* Zap out the name so that the back-end will give us the debugging
8857      information for this anonymous RECORD_TYPE.  */
8858   TYPE_NAME (t) = NULL_TREE;
8859
8860   /* If this is not the unqualified form of this pointer-to-member
8861      type, set the TYPE_MAIN_VARIANT for this type to be the
8862      unqualified type.  Since they are actually RECORD_TYPEs that are
8863      not variants of each other, we must do this manually.  */
8864   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8865     {
8866       t = build_qualified_type (t, CP_TYPE_QUALS (type));
8867       TYPE_MAIN_VARIANT (t) = unqualified_variant;
8868       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
8869       TYPE_NEXT_VARIANT (unqualified_variant) = t;
8870     }
8871
8872   /* Cache this pointer-to-member type so that we can find it again
8873      later.  */
8874   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8875
8876   /* Seems to be wanted.  */
8877   CLASSTYPE_GOT_SEMICOLON (t) = 1;
8878
8879   return t;
8880 }
8881
8882 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8883    Check to see that the definition is valid.  Issue appropriate error
8884    messages.  Return 1 if the definition is particularly bad, or 0
8885    otherwise.  */
8886
8887 int
8888 check_static_variable_definition (decl, type)
8889      tree decl;
8890      tree type;
8891 {
8892   /* Motion 10 at San Diego: If a static const integral data member is
8893      initialized with an integral constant expression, the initializer
8894      may appear either in the declaration (within the class), or in
8895      the definition, but not both.  If it appears in the class, the
8896      member is a member constant.  The file-scope definition is always
8897      required.  */
8898   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8899     {
8900       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
8901                 type);
8902       /* If we just return the declaration, crashes will sometimes
8903          occur.  We therefore return void_type_node, as if this was a
8904          friend declaration, to cause callers to completely ignore
8905          this declaration.  */
8906       return 1;
8907     }
8908   else if (!CP_TYPE_CONST_P (type))
8909     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
8910               decl);
8911   else if (pedantic && !INTEGRAL_TYPE_P (type))
8912     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8913
8914   return 0;
8915 }
8916
8917 /* Given the SIZE (i.e., number of elements) in an array, compute an
8918    appropriate index type for the array.  If non-NULL, NAME is the
8919    name of the thing being declared.  */
8920
8921 tree
8922 compute_array_index_type (name, size)
8923      tree name;
8924      tree size;
8925 {
8926   tree itype;
8927
8928   /* The size might be the result of a cast. */
8929   STRIP_TYPE_NOPS (size);
8930
8931   /* It might be a const variable or enumeration constant.  */
8932   if (TREE_READONLY_DECL_P (size))
8933     size = decl_constant_value (size);
8934
8935   /* If this involves a template parameter, it will be a constant at
8936      instantiation time, but we don't know what the value is yet.
8937      Even if no template parameters are involved, we may an expression
8938      that is not a constant; we don't even simplify `1 + 2' when
8939      processing a template.  */
8940   if (processing_template_decl)
8941     {
8942       /* Resolve a qualified reference to an enumerator or static
8943          const data member of ours.  */
8944       if (TREE_CODE (size) == SCOPE_REF
8945           && TREE_OPERAND (size, 0) == current_class_type)
8946         {
8947           tree t = lookup_field (current_class_type,
8948                                  TREE_OPERAND (size, 1), 0, 0);
8949           if (t)
8950             size = t;
8951         }
8952
8953       return build_index_type (build_min (MINUS_EXPR, sizetype,
8954                                           size, integer_one_node));
8955     }
8956
8957   /* The array bound must be an integer type.  */
8958   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8959       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
8960       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
8961     {
8962       if (name)
8963         cp_error ("size of array `%D' has non-integer type", name);
8964       else
8965         cp_error ("size of array has non-integer type");
8966       size = integer_one_node;
8967     }
8968
8969   /* Normally, the array-bound will be a constant.  */
8970   if (TREE_CONSTANT (size))
8971     {
8972       /* Check to see if the array bound overflowed.  Make that an
8973          error, no matter how generous we're being.  */
8974       int old_flag_pedantic_errors = flag_pedantic_errors;
8975       int old_pedantic = pedantic;
8976       pedantic = flag_pedantic_errors = 1;
8977       constant_expression_warning (size);
8978       pedantic = old_pedantic;
8979       flag_pedantic_errors = old_flag_pedantic_errors;
8980
8981       /* An array must have a positive number of elements.  */
8982       if (INT_CST_LT (size, integer_zero_node))
8983         {
8984           if (name)
8985             cp_error ("size of array `%D' is negative", name);
8986           else
8987             cp_error ("size of array is negative");
8988           size = integer_one_node;
8989         }
8990       /* Except that an extension we allow zero-sized arrays.  We
8991          always allow them in system headers because glibc uses
8992          them.  */
8993       else if (integer_zerop (size) && pedantic && !in_system_header)
8994         {
8995           if (name)
8996             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
8997           else
8998             cp_pedwarn ("ISO C++ forbids zero-size array");
8999         }
9000     }
9001
9002   /* Compute the index of the largest element in the array.  It is
9003      one less than the number of elements in the array.  */
9004   itype
9005     = fold (build_binary_op (MINUS_EXPR,
9006                              cp_convert (ssizetype, size),
9007                              cp_convert (ssizetype,
9008                                          integer_one_node)));
9009
9010   /* Check for variable-sized arrays.  We allow such things as an
9011      extension, even though they are not allowed in ANSI/ISO C++.  */
9012   if (!TREE_CONSTANT (itype))
9013     {
9014       if (pedantic)
9015         {
9016           if (name)
9017             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9018                         name);
9019           else
9020             cp_pedwarn ("ISO C++ forbids variable-size array");
9021         }
9022
9023       /* Create a variable-sized array index type.  */
9024       itype = variable_size (itype);
9025     }
9026   /* Make sure that there was no overflow when creating to a signed
9027      index type.  (For example, on a 32-bit machine, an array with
9028      size 2^32 - 1 is too big.)  */
9029   else if (TREE_OVERFLOW (itype))
9030     {
9031       error ("overflow in array dimension");
9032       TREE_OVERFLOW (itype) = 0;
9033     }
9034
9035   /* Create and return the appropriate index type.  */
9036   return build_index_type (itype);
9037 }
9038
9039 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9040    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9041    with this type.  */
9042
9043 static tree
9044 create_array_type_for_decl (name, type, size)
9045      tree name;
9046      tree type;
9047      tree size;
9048 {
9049   tree itype = NULL_TREE;
9050   const char* error_msg;
9051
9052   /* If things have already gone awry, bail now.  */
9053   if (type == error_mark_node || size == error_mark_node)
9054     return error_mark_node;
9055
9056   /* Assume that everything will go OK.  */
9057   error_msg = NULL;
9058
9059   /* There are some types which cannot be array elements.  */
9060   switch (TREE_CODE (type))
9061     {
9062     case VOID_TYPE:
9063       error_msg = "array of void";
9064       break;
9065
9066     case FUNCTION_TYPE:
9067       error_msg = "array of functions";
9068       break;
9069
9070     case REFERENCE_TYPE:
9071       error_msg = "array of references";
9072       break;
9073
9074     case OFFSET_TYPE:
9075       error_msg = "array of data members";
9076       break;
9077
9078     case METHOD_TYPE:
9079       error_msg = "array of function members";
9080       break;
9081
9082     default:
9083       break;
9084     }
9085
9086   /* If something went wrong, issue an error-message and return.  */
9087   if (error_msg)
9088     {
9089       if (name)
9090         cp_error ("declaration of `%D' as %s", name, error_msg);
9091       else
9092         cp_error ("creating %s", error_msg);
9093
9094       return error_mark_node;
9095     }
9096
9097   /* [dcl.array]
9098
9099      The constant expressions that specify the bounds of the arrays
9100      can be omitted only for the first member of the sequence.  */
9101   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9102     {
9103       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9104                 name);
9105
9106       return error_mark_node;
9107     }
9108
9109   /* Figure out the index type for the array.  */
9110   if (size)
9111     itype = compute_array_index_type (name, size);
9112
9113   return build_cplus_array_type (type, itype);
9114 }
9115
9116 /* Given declspecs and a declarator,
9117    determine the name and type of the object declared
9118    and construct a ..._DECL node for it.
9119    (In one case we can return a ..._TYPE node instead.
9120     For invalid input we sometimes return 0.)
9121
9122    DECLSPECS is a chain of tree_list nodes whose value fields
9123     are the storage classes and type specifiers.
9124
9125    DECL_CONTEXT says which syntactic context this declaration is in:
9126      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9127      FUNCDEF for a function definition.  Like NORMAL but a few different
9128       error messages in each case.  Return value may be zero meaning
9129       this definition is too screwy to try to parse.
9130      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9131       handle member functions (which have FIELD context).
9132       Return value may be zero meaning this definition is too screwy to
9133       try to parse.
9134      PARM for a parameter declaration (either within a function prototype
9135       or before a function body).  Make a PARM_DECL, or return void_type_node.
9136      CATCHPARM for a parameter declaration before a catch clause.
9137      TYPENAME if for a typename (in a cast or sizeof).
9138       Don't make a DECL node; just return the ..._TYPE node.
9139      FIELD for a struct or union field; make a FIELD_DECL.
9140      BITFIELD for a field with specified width.
9141    INITIALIZED is 1 if the decl has an initializer.
9142
9143    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9144    normal attributes in TREE_PURPOSE, or NULL_TREE.
9145
9146    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9147    It may also be so in the PARM case, for a prototype where the
9148    argument type is specified but not the name.
9149
9150    This function is where the complicated C meanings of `static'
9151    and `extern' are interpreted.
9152
9153    For C++, if there is any monkey business to do, the function which
9154    calls this one must do it, i.e., prepending instance variables,
9155    renaming overloaded function names, etc.
9156
9157    Note that for this C++, it is an error to define a method within a class
9158    which does not belong to that class.
9159
9160    Except in the case where SCOPE_REFs are implicitly known (such as
9161    methods within a class being redundantly qualified),
9162    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9163    (class_name::decl_name).  The caller must also deal with this.
9164
9165    If a constructor or destructor is seen, and the context is FIELD,
9166    then the type gains the attribute TREE_HAS_x.  If such a declaration
9167    is erroneous, NULL_TREE is returned.
9168
9169    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9170    function, these are the qualifiers to give to the `this' pointer. We
9171    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9172
9173    May return void_type_node if the declarator turned out to be a friend.
9174    See grokfield for details.  */
9175
9176 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9177
9178 tree
9179 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9180      tree declspecs;
9181      tree declarator;
9182      enum decl_context decl_context;
9183      int initialized;
9184      tree attrlist;
9185 {
9186   RID_BIT_TYPE specbits;
9187   int nclasses = 0;
9188   tree spec;
9189   tree type = NULL_TREE;
9190   int longlong = 0;
9191   int constp;
9192   int restrictp;
9193   int volatilep;
9194   int type_quals;
9195   int virtualp, explicitp, friendp, inlinep, staticp;
9196   int explicit_int = 0;
9197   int explicit_char = 0;
9198   int defaulted_int = 0;
9199   tree typedef_decl = NULL_TREE;
9200   const char *name;
9201   tree typedef_type = NULL_TREE;
9202   int funcdef_flag = 0;
9203   enum tree_code innermost_code = ERROR_MARK;
9204   int bitfield = 0;
9205 #if 0
9206   /* See the code below that used this.  */
9207   tree decl_machine_attr = NULL_TREE;
9208 #endif
9209   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9210      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9211   tree init = NULL_TREE;
9212
9213   /* Keep track of what sort of function is being processed
9214      so that we can warn about default return values, or explicit
9215      return values which do not match prescribed defaults.  */
9216   enum return_types return_type = return_normal;
9217
9218   tree dname = NULL_TREE;
9219   tree ctype = current_class_type;
9220   tree ctor_return_type = NULL_TREE;
9221   enum overload_flags flags = NO_SPECIAL;
9222   tree quals = NULL_TREE;
9223   tree raises = NULL_TREE;
9224   int template_count = 0;
9225   tree in_namespace = NULL_TREE;
9226   tree inner_attrs;
9227   int ignore_attrs;
9228
9229   RIDBIT_RESET_ALL (specbits);
9230   if (decl_context == FUNCDEF)
9231     funcdef_flag = 1, decl_context = NORMAL;
9232   else if (decl_context == MEMFUNCDEF)
9233     funcdef_flag = -1, decl_context = FIELD;
9234   else if (decl_context == BITFIELD)
9235     bitfield = 1, decl_context = FIELD;
9236
9237   /* Look inside a declarator for the name being declared
9238      and get it as a string, for an error message.  */
9239   {
9240     tree *next = &declarator;
9241     register tree decl;
9242     name = NULL;
9243
9244     while (next && *next)
9245       {
9246         decl = *next;
9247         switch (TREE_CODE (decl))
9248           {
9249           case TREE_LIST:
9250             /* For attributes.  */
9251             next = &TREE_VALUE (decl);
9252             break;
9253
9254           case COND_EXPR:
9255             ctype = NULL_TREE;
9256             next = &TREE_OPERAND (decl, 0);
9257             break;
9258
9259           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9260             {
9261               tree name = TREE_OPERAND (decl, 0);
9262               tree rename = NULL_TREE;
9263
9264               my_friendly_assert (flags == NO_SPECIAL, 152);
9265               flags = DTOR_FLAG;
9266               return_type = return_dtor;
9267               if (TREE_CODE (name) == TYPE_DECL)
9268                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9269               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9270               if (ctype == NULL_TREE)
9271                 {
9272                   if (current_class_type == NULL_TREE)
9273                     {
9274                       error ("destructors must be member functions");
9275                       flags = NO_SPECIAL;
9276                     }
9277                   else
9278                     {
9279                       tree t = constructor_name (current_class_name);
9280                       if (t != name)
9281                         rename = t;
9282                     }
9283                 }
9284               else
9285                 {
9286                   tree t = constructor_name (ctype);
9287                   if (t != name)
9288                     rename = t;
9289                 }
9290
9291               if (rename)
9292                 {
9293                   cp_error ("destructor `%T' must match class name `%T'",
9294                             name, rename);
9295                   TREE_OPERAND (decl, 0) = rename;
9296                 }
9297               next = &name;
9298             }
9299             break;
9300
9301           case ADDR_EXPR:       /* C++ reference declaration */
9302             /* Fall through. */
9303           case ARRAY_REF:
9304           case INDIRECT_REF:
9305             ctype = NULL_TREE;
9306             innermost_code = TREE_CODE (decl);
9307             next = &TREE_OPERAND (decl, 0);
9308             break;
9309
9310           case CALL_EXPR:
9311             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9312               {
9313                 /* This is actually a variable declaration using
9314                    constructor syntax.  We need to call start_decl and
9315                    cp_finish_decl so we can get the variable
9316                    initialized...  */
9317
9318                 tree attributes, prefix_attributes;
9319
9320                 *next = TREE_OPERAND (decl, 0);
9321                 init = CALL_DECLARATOR_PARMS (decl);
9322
9323                 if (attrlist)
9324                   {
9325                     attributes = TREE_PURPOSE (attrlist);
9326                     prefix_attributes = TREE_VALUE (attrlist);
9327                   }
9328                 else
9329                   {
9330                     attributes = NULL_TREE;
9331                     prefix_attributes = NULL_TREE;
9332                   }
9333
9334                 decl = start_decl (declarator, declspecs, 1,
9335                                    attributes, prefix_attributes);
9336                 decl_type_access_control (decl);
9337                 if (decl)
9338                   {
9339                     /* Look for __unused__ attribute */
9340                     if (TREE_USED (TREE_TYPE (decl)))
9341                       TREE_USED (decl) = 1;
9342                     finish_decl (decl, init, NULL_TREE);
9343                   }
9344                 else
9345                   cp_error ("invalid declarator");
9346                 return 0;
9347               }
9348             innermost_code = TREE_CODE (decl);
9349             if (decl_context == FIELD && ctype == NULL_TREE)
9350               ctype = current_class_type;
9351             if (ctype
9352                 && TREE_OPERAND (decl, 0)
9353                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9354                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9355                          == constructor_name_full (ctype))
9356                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9357                             == constructor_name (ctype)))))
9358               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9359             next = &TREE_OPERAND (decl, 0);
9360             decl = *next;
9361             if (ctype != NULL_TREE
9362                 && decl != NULL_TREE && flags != DTOR_FLAG
9363                 && decl == constructor_name (ctype))
9364               {
9365                 return_type = return_ctor;
9366                 ctor_return_type = ctype;
9367               }
9368             ctype = NULL_TREE;
9369             break;
9370
9371           case TEMPLATE_ID_EXPR:
9372               {
9373                 tree fns = TREE_OPERAND (decl, 0);
9374
9375                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9376                   fns = TREE_OPERAND (fns, 0);
9377
9378                 dname = fns;
9379                 if (TREE_CODE (dname) == COMPONENT_REF)
9380                   dname = TREE_OPERAND (dname, 1);
9381                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9382                   {
9383                     my_friendly_assert (is_overloaded_fn (dname),
9384                                         19990331);
9385                     dname = DECL_NAME (get_first_fn (dname));
9386                   }
9387               }
9388           /* Fall through. */
9389
9390           case IDENTIFIER_NODE:
9391             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9392               dname = decl;
9393
9394             next = 0;
9395
9396             if (is_rid (dname))
9397               {
9398                 cp_error ("declarator-id missing; using reserved word `%D'",
9399                           dname);
9400                 name = IDENTIFIER_POINTER (dname);
9401               }
9402             if (! IDENTIFIER_OPNAME_P (dname)
9403                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9404                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9405               name = IDENTIFIER_POINTER (dname);
9406             else
9407               {
9408                 if (IDENTIFIER_TYPENAME_P (dname))
9409                   {
9410                     my_friendly_assert (flags == NO_SPECIAL, 154);
9411                     flags = TYPENAME_FLAG;
9412                     ctor_return_type = TREE_TYPE (dname);
9413                     return_type = return_conversion;
9414                   }
9415                 name = operator_name_string (dname);
9416               }
9417             break;
9418
9419             /* C++ extension */
9420           case SCOPE_REF:
9421             {
9422               /* Perform error checking, and decide on a ctype.  */
9423               tree cname = TREE_OPERAND (decl, 0);
9424               if (cname == NULL_TREE)
9425                 ctype = NULL_TREE;
9426               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9427                 {
9428                   ctype = NULL_TREE;
9429                   in_namespace = TREE_OPERAND (decl, 0);
9430                   TREE_OPERAND (decl, 0) = NULL_TREE;
9431                 }
9432               else if (! is_aggr_type (cname, 1))
9433                 TREE_OPERAND (decl, 0) = NULL_TREE;
9434               /* Must test TREE_OPERAND (decl, 1), in case user gives
9435                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9436               else if (TREE_OPERAND (decl, 1)
9437                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9438                 ctype = cname;
9439               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9440                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9441                 {
9442                   cp_error ("`%T::%D' is not a valid declarator", cname,
9443                             TREE_OPERAND (decl, 1));
9444                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9445                             cname, TREE_OPERAND (decl, 1));
9446                   return void_type_node;
9447                 }
9448               else if (ctype == NULL_TREE)
9449                 ctype = cname;
9450               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9451                 TREE_OPERAND (decl, 0) = ctype;
9452               else
9453                 {
9454                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9455                     {
9456                       cp_error ("type `%T' is not derived from type `%T'",
9457                                 cname, ctype);
9458                       TREE_OPERAND (decl, 0) = NULL_TREE;
9459                     }
9460                   else
9461                     ctype = cname;
9462                 }
9463
9464               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9465                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9466                        == constructor_name_full (ctype))
9467                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9468                           == constructor_name (ctype))))
9469                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9470               next = &TREE_OPERAND (decl, 1);
9471               decl = *next;
9472               if (ctype)
9473                 {
9474                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9475                       && constructor_name (ctype) == decl)
9476                     {
9477                       return_type = return_ctor;
9478                       ctor_return_type = ctype;
9479                     }
9480                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9481                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9482                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9483                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9484                     {
9485                       return_type = return_dtor;
9486                       ctor_return_type = ctype;
9487                       flags = DTOR_FLAG;
9488                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9489                       next = &TREE_OPERAND (decl, 0);
9490                     }
9491                 }
9492             }
9493             break;
9494
9495           case ERROR_MARK:
9496             next = 0;
9497             break;
9498
9499           case TYPE_DECL:
9500             /* Parse error puts this typespec where
9501                a declarator should go.  */
9502             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9503             if (TREE_TYPE (decl) == current_class_type)
9504               cp_error ("  perhaps you want `%T' for a constructor",
9505                         current_class_name);
9506             dname = DECL_NAME (decl);
9507             name = IDENTIFIER_POINTER (dname);
9508
9509             /* Avoid giving two errors for this.  */
9510             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9511
9512             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9513             *next = dname;
9514             next = 0;
9515             break;
9516
9517           default:
9518             cp_compiler_error ("`%D' as declarator", decl);
9519             return 0; /* We used to do a 155 abort here.  */
9520           }
9521       }
9522   }
9523
9524   /* A function definition's declarator must have the form of
9525      a function declarator.  */
9526
9527   if (funcdef_flag && innermost_code != CALL_EXPR)
9528     return 0;
9529
9530   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9531       && innermost_code != CALL_EXPR
9532       && ! (ctype && declspecs == NULL_TREE))
9533     {
9534       cp_error ("declaration of `%D' as non-function", dname);
9535       return void_type_node;
9536     }
9537
9538   /* Anything declared one level down from the top level
9539      must be one of the parameters of a function
9540      (because the body is at least two levels down).  */
9541
9542   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9543      by not allowing C++ class definitions to specify their parameters
9544      with xdecls (must be spec.d in the parmlist).
9545
9546      Since we now wait to push a class scope until we are sure that
9547      we are in a legitimate method context, we must set oldcname
9548      explicitly (since current_class_name is not yet alive).
9549
9550      We also want to avoid calling this a PARM if it is in a namespace.  */
9551
9552   if (decl_context == NORMAL && !toplevel_bindings_p ())
9553     {
9554       struct binding_level *b = current_binding_level;
9555       current_binding_level = b->level_chain;
9556       if (current_binding_level != 0 && toplevel_bindings_p ())
9557         decl_context = PARM;
9558       current_binding_level = b;
9559     }
9560
9561   if (name == NULL)
9562     name = decl_context == PARM ? "parameter" : "type name";
9563
9564   /* Look through the decl specs and record which ones appear.
9565      Some typespecs are defined as built-in typenames.
9566      Others, the ones that are modifiers of other types,
9567      are represented by bits in SPECBITS: set the bits for
9568      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9569
9570      If there is a typedef name or a type, store the type in TYPE.
9571      This includes builtin typedefs such as `int'.
9572
9573      Set EXPLICIT_INT if the type is `int' or `char' and did not
9574      come from a user typedef.
9575
9576      Set LONGLONG if `long' is mentioned twice.
9577
9578      For C++, constructors and destructors have their own fast treatment.  */
9579
9580   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9581     {
9582       register int i;
9583       register tree id;
9584
9585       /* Certain parse errors slip through.  For example,
9586          `int class;' is not caught by the parser. Try
9587          weakly to recover here.  */
9588       if (TREE_CODE (spec) != TREE_LIST)
9589         return 0;
9590
9591       id = TREE_VALUE (spec);
9592
9593       if (TREE_CODE (id) == IDENTIFIER_NODE)
9594         {
9595           if (id == ridpointers[(int) RID_INT]
9596               || id == ridpointers[(int) RID_CHAR]
9597               || id == ridpointers[(int) RID_BOOL]
9598               || id == ridpointers[(int) RID_WCHAR])
9599             {
9600               if (type)
9601                 {
9602                   if (id == ridpointers[(int) RID_BOOL])
9603                     error ("`bool' is now a keyword");
9604                   else
9605                     cp_error ("extraneous `%T' ignored", id);
9606                 }
9607               else
9608                 {
9609                   if (id == ridpointers[(int) RID_INT])
9610                     explicit_int = 1;
9611                   else if (id == ridpointers[(int) RID_CHAR])
9612                     explicit_char = 1;
9613                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9614                 }
9615               goto found;
9616             }
9617           /* C++ aggregate types.  */
9618           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9619             {
9620               if (type)
9621                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9622               else
9623                 type = IDENTIFIER_TYPE_VALUE (id);
9624               goto found;
9625             }
9626
9627           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9628             {
9629               if (ridpointers[i] == id)
9630                 {
9631                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9632                     {
9633                       if (pedantic && ! in_system_header && warn_long_long)
9634                         pedwarn ("ISO C++ does not support `long long'");
9635                       if (longlong)
9636                         error ("`long long long' is too long for GCC");
9637                       else
9638                         longlong = 1;
9639                     }
9640                   else if (RIDBIT_SETP (i, specbits))
9641                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9642                   RIDBIT_SET (i, specbits);
9643                   goto found;
9644                 }
9645             }
9646         }
9647       /* C++ aggregate types.  */
9648       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9649         {
9650           if (type)
9651             cp_error ("multiple declarations `%T' and `%T'", type,
9652                       TREE_TYPE (id));
9653           else
9654             {
9655               type = TREE_TYPE (id);
9656               TREE_VALUE (spec) = type;
9657             }
9658           goto found;
9659         }
9660       if (type)
9661         error ("two or more data types in declaration of `%s'", name);
9662       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9663         {
9664           register tree t = lookup_name (id, 1);
9665           if (!t || TREE_CODE (t) != TYPE_DECL)
9666             error ("`%s' fails to be a typedef or built in type",
9667                    IDENTIFIER_POINTER (id));
9668           else
9669             {
9670               type = TREE_TYPE (t);
9671 #if 0
9672               /* See the code below that used this.  */
9673               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9674 #endif
9675               typedef_decl = t;
9676             }
9677         }
9678       else if (id != error_mark_node)
9679         /* Can't change CLASS nodes into RECORD nodes here!  */
9680         type = id;
9681
9682     found: ;
9683     }
9684
9685   typedef_type = type;
9686
9687   /* No type at all: default to `int', and set DEFAULTED_INT
9688      because it was not a user-defined typedef.  */
9689
9690   if (type == NULL_TREE
9691       && (RIDBIT_SETP (RID_SIGNED, specbits)
9692           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9693           || RIDBIT_SETP (RID_LONG, specbits)
9694           || RIDBIT_SETP (RID_SHORT, specbits)))
9695     {
9696       /* These imply 'int'.  */
9697       type = integer_type_node;
9698       defaulted_int = 1;
9699     }
9700
9701   if (type == NULL_TREE)
9702     {
9703       explicit_int = -1;
9704       if (return_type == return_dtor)
9705         type = void_type_node;
9706       else if (return_type == return_ctor)
9707         type = build_pointer_type (ctor_return_type);
9708       else if (return_type == return_conversion)
9709         type = ctor_return_type;
9710       else
9711         {
9712           /* We handle `main' specially here, because 'main () { }' is so
9713              common.  With no options, it is allowed.  With -Wreturn-type,
9714              it is a warning.  It is only an error with -pedantic-errors.  */
9715           int is_main = (funcdef_flag
9716                          && MAIN_NAME_P (dname)
9717                          && ctype == NULL_TREE
9718                          && in_namespace == NULL_TREE
9719                          && current_namespace == global_namespace);
9720
9721           if (in_system_header || flag_ms_extensions)
9722             /* Allow it, sigh.  */;
9723           else if (pedantic || ! is_main)
9724             cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9725                         name);
9726           else if (warn_return_type)
9727             cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9728                         name);
9729
9730           type = integer_type_node;
9731         }
9732     }
9733   else if (return_type == return_dtor)
9734     {
9735       error ("return type specification for destructor invalid");
9736       type = void_type_node;
9737     }
9738   else if (return_type == return_ctor)
9739     {
9740       error ("return type specification for constructor invalid");
9741       type = build_pointer_type (ctor_return_type);
9742     }
9743   else if (return_type == return_conversion)
9744     {
9745       if (!same_type_p (type, ctor_return_type))
9746         cp_error ("operator `%T' declared to return `%T'",
9747                   ctor_return_type, type);
9748       else
9749         cp_pedwarn ("return type specified for `operator %T'",
9750                     ctor_return_type);
9751
9752       type = ctor_return_type;
9753     }
9754
9755   ctype = NULL_TREE;
9756
9757   /* Now process the modifiers that were specified
9758      and check for invalid combinations.  */
9759
9760   /* Long double is a special combination.  */
9761
9762   if (RIDBIT_SETP (RID_LONG, specbits)
9763       && TYPE_MAIN_VARIANT (type) == double_type_node)
9764     {
9765       RIDBIT_RESET (RID_LONG, specbits);
9766       type = build_qualified_type (long_double_type_node,
9767                                    CP_TYPE_QUALS (type));
9768     }
9769
9770   /* Check all other uses of type modifiers.  */
9771
9772   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9773       || RIDBIT_SETP (RID_SIGNED, specbits)
9774       || RIDBIT_SETP (RID_LONG, specbits)
9775       || RIDBIT_SETP (RID_SHORT, specbits))
9776     {
9777       int ok = 0;
9778
9779       if (TREE_CODE (type) == REAL_TYPE)
9780         error ("short, signed or unsigned invalid for `%s'", name);
9781       else if (TREE_CODE (type) != INTEGER_TYPE)
9782         error ("long, short, signed or unsigned invalid for `%s'", name);
9783       else if (RIDBIT_SETP (RID_LONG, specbits)
9784                && RIDBIT_SETP (RID_SHORT, specbits))
9785         error ("long and short specified together for `%s'", name);
9786       else if ((RIDBIT_SETP (RID_LONG, specbits)
9787                 || RIDBIT_SETP (RID_SHORT, specbits))
9788                && explicit_char)
9789         error ("long or short specified with char for `%s'", name);
9790       else if ((RIDBIT_SETP (RID_LONG, specbits)
9791                 || RIDBIT_SETP (RID_SHORT, specbits))
9792                && TREE_CODE (type) == REAL_TYPE)
9793         error ("long or short specified with floating type for `%s'", name);
9794       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9795                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9796         error ("signed and unsigned given together for `%s'", name);
9797       else
9798         {
9799           ok = 1;
9800           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9801             {
9802               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9803                        name);
9804               if (flag_pedantic_errors)
9805                 ok = 0;
9806             }
9807         }
9808
9809       /* Discard the type modifiers if they are invalid.  */
9810       if (! ok)
9811         {
9812           RIDBIT_RESET (RID_UNSIGNED, specbits);
9813           RIDBIT_RESET (RID_SIGNED, specbits);
9814           RIDBIT_RESET (RID_LONG, specbits);
9815           RIDBIT_RESET (RID_SHORT, specbits);
9816           longlong = 0;
9817         }
9818     }
9819
9820   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9821       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9822     {
9823       error ("complex invalid for `%s'", name);
9824       RIDBIT_RESET (RID_COMPLEX, specbits);
9825     }
9826
9827   /* Decide whether an integer type is signed or not.
9828      Optionally treat bitfields as signed by default.  */
9829   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9830       /* [class.bit]
9831
9832          It is implementation-defined whether a plain (neither
9833          explicitly signed or unsigned) char, short, int, or long
9834          bit-field is signed or unsigned.
9835
9836          Naturally, we extend this to long long as well.  Note that
9837          this does not include wchar_t.  */
9838       || (bitfield && !flag_signed_bitfields
9839           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
9840           /* A typedef for plain `int' without `signed' can be
9841              controlled just like plain `int', but a typedef for
9842              `signed int' cannot be so controlled.  */
9843           && !(typedef_decl
9844                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9845           && (TREE_CODE (type) == INTEGER_TYPE
9846               || TREE_CODE (type) == CHAR_TYPE)
9847           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9848     {
9849       if (longlong)
9850         type = long_long_unsigned_type_node;
9851       else if (RIDBIT_SETP (RID_LONG, specbits))
9852         type = long_unsigned_type_node;
9853       else if (RIDBIT_SETP (RID_SHORT, specbits))
9854         type = short_unsigned_type_node;
9855       else if (type == char_type_node)
9856         type = unsigned_char_type_node;
9857       else if (typedef_decl)
9858         type = unsigned_type (type);
9859       else
9860         type = unsigned_type_node;
9861     }
9862   else if (RIDBIT_SETP (RID_SIGNED, specbits)
9863            && type == char_type_node)
9864     type = signed_char_type_node;
9865   else if (longlong)
9866     type = long_long_integer_type_node;
9867   else if (RIDBIT_SETP (RID_LONG, specbits))
9868     type = long_integer_type_node;
9869   else if (RIDBIT_SETP (RID_SHORT, specbits))
9870     type = short_integer_type_node;
9871
9872   if (RIDBIT_SETP (RID_COMPLEX, specbits))
9873     {
9874       /* If we just have "complex", it is equivalent to
9875          "complex double", but if any modifiers at all are specified it is
9876          the complex form of TYPE.  E.g, "complex short" is
9877          "complex short int".  */
9878
9879       if (defaulted_int && ! longlong
9880           && ! (RIDBIT_SETP (RID_LONG, specbits)
9881                 || RIDBIT_SETP (RID_SHORT, specbits)
9882                 || RIDBIT_SETP (RID_SIGNED, specbits)
9883                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9884         type = complex_double_type_node;
9885       else if (type == integer_type_node)
9886         type = complex_integer_type_node;
9887       else if (type == float_type_node)
9888         type = complex_float_type_node;
9889       else if (type == double_type_node)
9890         type = complex_double_type_node;
9891       else if (type == long_double_type_node)
9892         type = complex_long_double_type_node;
9893       else
9894         type = build_complex_type (type);
9895     }
9896
9897   if (return_type == return_conversion
9898       && (RIDBIT_SETP (RID_CONST, specbits)
9899           || RIDBIT_SETP (RID_VOLATILE, specbits)
9900           || RIDBIT_SETP (RID_RESTRICT, specbits)))
9901     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9902               ctor_return_type);
9903
9904   /* Set CONSTP if this declaration is `const', whether by
9905      explicit specification or via a typedef.
9906      Likewise for VOLATILEP.  */
9907
9908   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9909   restrictp =
9910     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9911   volatilep =
9912     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9913   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9914                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9915                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9916   type = cp_build_qualified_type (type, type_quals);
9917   staticp = 0;
9918   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9919   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
9920   RIDBIT_RESET (RID_VIRTUAL, specbits);
9921   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9922   RIDBIT_RESET (RID_EXPLICIT, specbits);
9923
9924   if (RIDBIT_SETP (RID_STATIC, specbits))
9925     staticp = 1 + (decl_context == FIELD);
9926
9927   if (virtualp && staticp == 2)
9928     {
9929       cp_error ("member `%D' cannot be declared both virtual and static",
9930                 dname);
9931       staticp = 0;
9932     }
9933   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
9934   RIDBIT_RESET (RID_FRIEND, specbits);
9935
9936   /* Warn if two storage classes are given. Default to `auto'.  */
9937
9938   if (RIDBIT_ANY_SET (specbits))
9939     {
9940       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9941       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9942       if (decl_context == PARM && nclasses > 0)
9943         error ("storage class specifiers invalid in parameter declarations");
9944       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9945         {
9946           if (decl_context == PARM)
9947             error ("typedef declaration invalid in parameter declaration");
9948           nclasses++;
9949         }
9950       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9951       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9952     }
9953
9954   /* Give error if `virtual' is used outside of class declaration.  */
9955   if (virtualp
9956       && (current_class_name == NULL_TREE || decl_context != FIELD))
9957     {
9958       error ("virtual outside class declaration");
9959       virtualp = 0;
9960     }
9961
9962   /* Static anonymous unions are dealt with here.  */
9963   if (staticp && decl_context == TYPENAME
9964       && TREE_CODE (declspecs) == TREE_LIST
9965       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
9966     decl_context = FIELD;
9967
9968   /* Warn about storage classes that are invalid for certain
9969      kinds of declarations (parameters, typenames, etc.).  */
9970
9971   if (nclasses > 1)
9972     error ("multiple storage classes in declaration of `%s'", name);
9973   else if (decl_context != NORMAL && nclasses > 0)
9974     {
9975       if ((decl_context == PARM || decl_context == CATCHPARM)
9976           && (RIDBIT_SETP (RID_REGISTER, specbits)
9977               || RIDBIT_SETP (RID_AUTO, specbits)))
9978         ;
9979       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9980         ;
9981       else if (decl_context == FIELD
9982                /* C++ allows static class elements  */
9983                && RIDBIT_SETP (RID_STATIC, specbits))
9984         /* C++ also allows inlines and signed and unsigned elements,
9985            but in those cases we don't come in here.  */
9986         ;
9987       else
9988         {
9989           if (decl_context == FIELD)
9990             {
9991               tree tmp = NULL_TREE;
9992               register int op = 0;
9993
9994               if (declarator)
9995                 {
9996                   /* Avoid trying to get an operand off an identifier node.  */
9997                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9998                     tmp = declarator;
9999                   else
10000                     tmp = TREE_OPERAND (declarator, 0);
10001                   op = IDENTIFIER_OPNAME_P (tmp);
10002                 }
10003               error ("storage class specified for %s `%s'",
10004                      op ? "member operator" : "field",
10005                      op ? operator_name_string (tmp) : name);
10006             }
10007           else
10008             {
10009               if (decl_context == PARM || decl_context == CATCHPARM)
10010                 error ("storage class specified for parameter `%s'", name);
10011               else
10012                 error ("storage class specified for typename");
10013             }
10014           RIDBIT_RESET (RID_REGISTER, specbits);
10015           RIDBIT_RESET (RID_AUTO, specbits);
10016           RIDBIT_RESET (RID_EXTERN, specbits);
10017         }
10018     }
10019   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10020     {
10021       if (toplevel_bindings_p ())
10022         {
10023           /* It's common practice (and completely valid) to have a const
10024              be initialized and declared extern.  */
10025           if (!(type_quals & TYPE_QUAL_CONST))
10026             warning ("`%s' initialized and declared `extern'", name);
10027         }
10028       else
10029         error ("`%s' has both `extern' and initializer", name);
10030     }
10031   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10032            && ! toplevel_bindings_p ())
10033     error ("nested function `%s' declared `extern'", name);
10034   else if (toplevel_bindings_p ())
10035     {
10036       if (RIDBIT_SETP (RID_AUTO, specbits))
10037         error ("top-level declaration of `%s' specifies `auto'", name);
10038     }
10039
10040   if (nclasses > 0 && friendp)
10041     error ("storage class specifiers invalid in friend function declarations");
10042
10043   /* Now figure out the structure of the declarator proper.
10044      Descend through it, creating more complex types, until we reach
10045      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10046
10047   inner_attrs = NULL_TREE;
10048   ignore_attrs = 0;
10049
10050   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10051          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10052     {
10053       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10054          an INDIRECT_REF (for *...),
10055          a CALL_EXPR (for ...(...)),
10056          an identifier (for the name being declared)
10057          or a null pointer (for the place in an absolute declarator
10058          where the name was omitted).
10059          For the last two cases, we have just exited the loop.
10060
10061          For C++ it could also be
10062          a SCOPE_REF (for class :: ...).  In this case, we have converted
10063          sensible names to types, and those are the values we use to
10064          qualify the member name.
10065          an ADDR_EXPR (for &...),
10066          a BIT_NOT_EXPR (for destructors)
10067
10068          At this point, TYPE is the type of elements of an array,
10069          or for a function to return, or for a pointer to point to.
10070          After this sequence of ifs, TYPE is the type of the
10071          array or function or pointer, and DECLARATOR has had its
10072          outermost layer removed.  */
10073
10074       if (type == error_mark_node)
10075         {
10076           if (TREE_CODE (declarator) == SCOPE_REF)
10077             declarator = TREE_OPERAND (declarator, 1);
10078           else
10079             declarator = TREE_OPERAND (declarator, 0);
10080           continue;
10081         }
10082       if (quals != NULL_TREE
10083           && (declarator == NULL_TREE
10084               || TREE_CODE (declarator) != SCOPE_REF))
10085         {
10086           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10087             ctype = TYPE_METHOD_BASETYPE (type);
10088           if (ctype != NULL_TREE)
10089             {
10090               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10091               grok_method_quals (ctype, dummy, quals);
10092               type = TREE_TYPE (dummy);
10093               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10094               quals = NULL_TREE;
10095             }
10096         }
10097
10098       /* See the comment for the TREE_LIST case, below.  */
10099       if (ignore_attrs)
10100         ignore_attrs = 0;
10101       else if (inner_attrs)
10102         {
10103           decl_attributes (type, inner_attrs, NULL_TREE);
10104           inner_attrs = NULL_TREE;
10105         }
10106
10107       switch (TREE_CODE (declarator))
10108         {
10109         case TREE_LIST:
10110           {
10111             /* We encode a declarator with embedded attributes using
10112                a TREE_LIST.  The attributes apply to the declarator
10113                directly inside them, so we have to skip an iteration
10114                before applying them to the type.  If the declarator just
10115                inside is the declarator-id, we apply the attrs to the
10116                decl itself.  */
10117             inner_attrs = TREE_PURPOSE (declarator);
10118             ignore_attrs = 1;
10119             declarator = TREE_VALUE (declarator);
10120           }
10121           break;
10122
10123         case ARRAY_REF:
10124           {
10125             register tree size;
10126
10127             size = TREE_OPERAND (declarator, 1);
10128
10129             /* VC++ spells a zero-sized array with [].  */
10130             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10131                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10132               size = integer_zero_node;
10133
10134             declarator = TREE_OPERAND (declarator, 0);
10135
10136             type = create_array_type_for_decl (dname, type, size);
10137             ctype = NULL_TREE;
10138           }
10139           break;
10140
10141         case CALL_EXPR:
10142           {
10143             tree arg_types;
10144             int funcdecl_p;
10145             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10146             tree inner_decl = TREE_OPERAND (declarator, 0);
10147
10148             /* Declaring a function type.
10149                Make sure we have a valid type for the function to return.  */
10150
10151             /* We now know that the TYPE_QUALS don't apply to the
10152                decl, but to its return type.  */
10153             type_quals = TYPE_UNQUALIFIED;
10154
10155             /* Warn about some types functions can't return.  */
10156
10157             if (TREE_CODE (type) == FUNCTION_TYPE)
10158               {
10159                 error ("`%s' declared as function returning a function", name);
10160                 type = integer_type_node;
10161               }
10162             if (TREE_CODE (type) == ARRAY_TYPE)
10163               {
10164                 error ("`%s' declared as function returning an array", name);
10165                 type = integer_type_node;
10166               }
10167
10168             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10169               inner_decl = TREE_OPERAND (inner_decl, 1);
10170
10171             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10172               inner_decl = dname;
10173
10174             /* Pick up type qualifiers which should be applied to `this'.  */
10175             quals = CALL_DECLARATOR_QUALS (declarator);
10176
10177             /* Pick up the exception specifications.  */
10178             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10179
10180             /* Say it's a definition only for the CALL_EXPR
10181                closest to the identifier.  */
10182             funcdecl_p
10183               = inner_decl
10184               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10185                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10186                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10187
10188             if (ctype == NULL_TREE
10189                 && decl_context == FIELD
10190                 && funcdecl_p
10191                 && (friendp == 0 || dname == current_class_name))
10192               ctype = current_class_type;
10193
10194             if (ctype && return_type == return_conversion)
10195               TYPE_HAS_CONVERSION (ctype) = 1;
10196             if (ctype && constructor_name (ctype) == dname)
10197               {
10198                 /* We are within a class's scope. If our declarator name
10199                    is the same as the class name, and we are defining
10200                    a function, then it is a constructor/destructor, and
10201                    therefore returns a void type.  */
10202
10203                 if (flags == DTOR_FLAG)
10204                   {
10205                     /* ISO C++ 12.4/2.  A destructor may not be
10206                        declared const or volatile.  A destructor may
10207                        not be static.  */
10208                     if (staticp == 2)
10209                       error ("destructor cannot be static member function");
10210                     if (quals)
10211                       {
10212                         cp_error ("destructors may not be `%s'",
10213                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10214                         quals = NULL_TREE;
10215                       }
10216                     if (decl_context == FIELD)
10217                       {
10218                         if (! member_function_or_else (ctype,
10219                                                        current_class_type,
10220                                                        flags))
10221                           return void_type_node;
10222                       }
10223                   }
10224                 else            /* It's a constructor.  */
10225                   {
10226                     if (explicitp == 1)
10227                       explicitp = 2;
10228                     /* ISO C++ 12.1.  A constructor may not be
10229                        declared const or volatile.  A constructor may
10230                        not be virtual.  A constructor may not be
10231                        static.  */
10232                     if (staticp == 2)
10233                       error ("constructor cannot be static member function");
10234                     if (virtualp)
10235                       {
10236                         pedwarn ("constructors cannot be declared virtual");
10237                         virtualp = 0;
10238                       }
10239                     if (quals)
10240                       {
10241                         cp_error ("constructors may not be `%s'",
10242                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10243                         quals = NULL_TREE;
10244                       }
10245                     {
10246                       RID_BIT_TYPE tmp_bits;
10247                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10248                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10249                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10250                       if (RIDBIT_ANY_SET (tmp_bits))
10251                         error ("return value type specifier for constructor ignored");
10252                     }
10253                     type = build_pointer_type (ctype);
10254                     if (decl_context == FIELD)
10255                       {
10256                         if (! member_function_or_else (ctype,
10257                                                        current_class_type,
10258                                                        flags))
10259                           return void_type_node;
10260                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10261                         if (return_type != return_ctor)
10262                           return NULL_TREE;
10263                       }
10264                   }
10265                 if (decl_context == FIELD)
10266                   staticp = 0;
10267               }
10268             else if (friendp)
10269               {
10270                 if (initialized)
10271                   error ("can't initialize friend function `%s'", name);
10272                 if (virtualp)
10273                   {
10274                     /* Cannot be both friend and virtual.  */
10275                     error ("virtual functions cannot be friends");
10276                     RIDBIT_RESET (RID_FRIEND, specbits);
10277                     friendp = 0;
10278                   }
10279                 if (decl_context == NORMAL)
10280                   error ("friend declaration not in class definition");
10281                 if (current_function_decl && funcdef_flag)
10282                   cp_error ("can't define friend function `%s' in a local class definition",
10283                             name);
10284               }
10285
10286             /* Construct the function type and go to the next
10287                inner layer of declarator.  */
10288
10289             declarator = TREE_OPERAND (declarator, 0);
10290
10291             /* FIXME: This is where default args should be fully
10292                processed.  */
10293
10294             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10295
10296             if (declarator && flags == DTOR_FLAG)
10297               {
10298                 /* A destructor declared in the body of a class will
10299                    be represented as a BIT_NOT_EXPR.  But, we just
10300                    want the underlying IDENTIFIER.  */
10301                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10302                   declarator = TREE_OPERAND (declarator, 0);
10303
10304                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10305                   arg_types = void_list_node;
10306                 else if (arg_types == NULL_TREE
10307                          || arg_types != void_list_node)
10308                   {
10309                     cp_error ("destructors may not have parameters");
10310                     arg_types = void_list_node;
10311                     last_function_parms = NULL_TREE;
10312                   }
10313               }
10314
10315             /* ANSI says that `const int foo ();'
10316                does not make the function foo const.  */
10317             type = build_function_type (type, arg_types);
10318
10319             {
10320               tree t;
10321               for (t = arg_types; t; t = TREE_CHAIN (t))
10322                 if (TREE_PURPOSE (t)
10323                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10324                   {
10325                     add_defarg_fn (type);
10326                     break;
10327                   }
10328             }
10329           }
10330           break;
10331
10332         case ADDR_EXPR:
10333         case INDIRECT_REF:
10334           /* Filter out pointers-to-references and references-to-references.
10335              We can get these if a TYPE_DECL is used.  */
10336
10337           if (TREE_CODE (type) == REFERENCE_TYPE)
10338             {
10339               error ("cannot declare %s to references",
10340                      TREE_CODE (declarator) == ADDR_EXPR
10341                      ? "references" : "pointers");
10342               declarator = TREE_OPERAND (declarator, 0);
10343               continue;
10344             }
10345
10346           if (TREE_CODE (type) == OFFSET_TYPE
10347               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10348                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10349             {
10350               cp_error ("cannot declare pointer to `%#T' member",
10351                         TREE_TYPE (type));
10352               type = TREE_TYPE (type);
10353             }
10354
10355           /* Merge any constancy or volatility into the target type
10356              for the pointer.  */
10357
10358           /* We now know that the TYPE_QUALS don't apply to the decl,
10359              but to the target of the pointer.  */
10360           type_quals = TYPE_UNQUALIFIED;
10361
10362           if (TREE_CODE (declarator) == ADDR_EXPR)
10363             {
10364               if (TREE_CODE (type) == VOID_TYPE)
10365                 error ("invalid type: `void &'");
10366               else
10367                 type = build_reference_type (type);
10368             }
10369           else if (TREE_CODE (type) == METHOD_TYPE)
10370             type = build_ptrmemfunc_type (build_pointer_type (type));
10371           else
10372             type = build_pointer_type (type);
10373
10374           /* Process a list of type modifier keywords (such as
10375              const or volatile) that were given inside the `*' or `&'.  */
10376
10377           if (TREE_TYPE (declarator))
10378             {
10379               register tree typemodlist;
10380               int erred = 0;
10381
10382               constp = 0;
10383               volatilep = 0;
10384               restrictp = 0;
10385               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10386                    typemodlist = TREE_CHAIN (typemodlist))
10387                 {
10388                   tree qualifier = TREE_VALUE (typemodlist);
10389
10390                   if (qualifier == ridpointers[(int) RID_CONST])
10391                     constp++;
10392                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10393                     volatilep++;
10394                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10395                     restrictp++;
10396                   else if (!erred)
10397                     {
10398                       erred = 1;
10399                       error ("invalid type modifier within pointer declarator");
10400                     }
10401                 }
10402               if (constp > 1)
10403                 pedwarn ("duplicate `const'");
10404               if (volatilep > 1)
10405                 pedwarn ("duplicate `volatile'");
10406               if (restrictp > 1)
10407                 pedwarn ("duplicate `restrict'");
10408
10409               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10410                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10411                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10412               if (TREE_CODE (declarator) == ADDR_EXPR
10413                   && (constp || volatilep))
10414                 {
10415                   if (constp)
10416                     pedwarn ("discarding `const' applied to a reference");
10417                   if (volatilep)
10418                     pedwarn ("discarding `volatile' applied to a reference");
10419                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10420                 }
10421               type = cp_build_qualified_type (type, type_quals);
10422             }
10423           declarator = TREE_OPERAND (declarator, 0);
10424           ctype = NULL_TREE;
10425           break;
10426
10427         case SCOPE_REF:
10428           {
10429             /* We have converted type names to NULL_TREE if the
10430                name was bogus, or to a _TYPE node, if not.
10431
10432                The variable CTYPE holds the type we will ultimately
10433                resolve to.  The code here just needs to build
10434                up appropriate member types.  */
10435             tree sname = TREE_OPERAND (declarator, 1);
10436             tree t;
10437
10438             /* Destructors can have their visibilities changed as well.  */
10439             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10440               sname = TREE_OPERAND (sname, 0);
10441
10442             if (TREE_COMPLEXITY (declarator) == 0)
10443               /* This needs to be here, in case we are called
10444                  multiple times.  */ ;
10445             else if (TREE_COMPLEXITY (declarator) == -1)
10446               /* Namespace member. */
10447               pop_decl_namespace ();
10448             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10449               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10450             else if (! IS_AGGR_TYPE_CODE
10451                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10452               ;
10453             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10454               {
10455                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10456                    that refer to ctype.  They couldn't be resolved earlier
10457                    because we hadn't pushed into the class yet.
10458                    Example: resolve 'B<T>::type' in
10459                    'B<typename B<T>::type> B<T>::f () { }'.  */
10460                 if (current_template_parms
10461                     && uses_template_parms (type)
10462                     && uses_template_parms (current_class_type))
10463                   {
10464                     tree args = current_template_args ();
10465                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10466                   }
10467
10468                 /* This pop_nested_class corresponds to the
10469                    push_nested_class used to push into class scope for
10470                    parsing the argument list of a function decl, in
10471                    qualified_id.  */
10472                 pop_nested_class ();
10473                 TREE_COMPLEXITY (declarator) = current_class_depth;
10474               }
10475             else
10476               my_friendly_abort (16);
10477
10478             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10479               {
10480                 /* We had a reference to a global decl, or
10481                    perhaps we were given a non-aggregate typedef,
10482                    in which case we cleared this out, and should just
10483                    keep going as though it wasn't there.  */
10484                 declarator = sname;
10485                 continue;
10486               }
10487             ctype = TREE_OPERAND (declarator, 0);
10488
10489             t = ctype;
10490             while (t != NULL_TREE && CLASS_TYPE_P (t))
10491               {
10492                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10493                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10494                   template_count += 1;
10495                 t = TYPE_MAIN_DECL (t);
10496                 if (DECL_LANG_SPECIFIC (t))
10497                   t = DECL_CONTEXT (t);
10498                 else
10499                   t = NULL_TREE;
10500               }
10501
10502             if (sname == NULL_TREE)
10503               goto done_scoping;
10504
10505             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10506               {
10507                 /* This is the `standard' use of the scoping operator:
10508                    basetype :: member .  */
10509
10510                 if (ctype == current_class_type)
10511                   {
10512                     /* class A {
10513                          void A::f ();
10514                        };
10515
10516                        Is this ill-formed?  */
10517
10518                     if (pedantic)
10519                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10520                                   ctype, name);
10521                   }
10522                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10523                   {
10524                     if (current_class_type == NULL_TREE
10525                         || friendp)
10526                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10527                                                       TYPE_ARG_TYPES (type));
10528                     else
10529                       {
10530                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10531                                   ctype, name, current_class_type);
10532                         return void_type_node;
10533                       }
10534                   }
10535                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10536                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10537                   {
10538                     /* Have to move this code elsewhere in this function.
10539                        this code is used for i.e., typedef int A::M; M *pm;
10540
10541                        It is?  How? jason 10/2/94 */
10542
10543                     if (current_class_type)
10544                       {
10545                         cp_error ("cannot declare member `%T::%s' within `%T'",
10546                                   ctype, name, current_class_type);
10547                         return void_type_node;
10548                       }
10549                     type = build_offset_type (ctype, type);
10550                   }
10551                 else if (uses_template_parms (ctype))
10552                   {
10553                     if (TREE_CODE (type) == FUNCTION_TYPE)
10554                       type
10555                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10556                                                    TYPE_ARG_TYPES (type));
10557                   }
10558                 else
10559                   {
10560                     cp_error ("structure `%T' not yet defined", ctype);
10561                     return error_mark_node;
10562                   }
10563
10564                 declarator = sname;
10565               }
10566             else if (TREE_CODE (sname) == SCOPE_REF)
10567               my_friendly_abort (17);
10568             else
10569               {
10570               done_scoping:
10571                 declarator = TREE_OPERAND (declarator, 1);
10572                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10573                   /* In this case, we will deal with it later.  */
10574                   ;
10575                 else
10576                   {
10577                     if (TREE_CODE (type) == FUNCTION_TYPE)
10578                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10579                                                       TYPE_ARG_TYPES (type));
10580                     else
10581                       type = build_offset_type (ctype, type);
10582                   }
10583               }
10584           }
10585           break;
10586
10587         case BIT_NOT_EXPR:
10588           declarator = TREE_OPERAND (declarator, 0);
10589           break;
10590
10591         case RECORD_TYPE:
10592         case UNION_TYPE:
10593         case ENUMERAL_TYPE:
10594           declarator = NULL_TREE;
10595           break;
10596
10597         case ERROR_MARK:
10598           declarator = NULL_TREE;
10599           break;
10600
10601         default:
10602           my_friendly_abort (158);
10603         }
10604     }
10605
10606   /* See the comment for the TREE_LIST case, above.  */
10607   if (inner_attrs)
10608     {
10609       if (! ignore_attrs)
10610         decl_attributes (type, inner_attrs, NULL_TREE);
10611       else if (attrlist)
10612         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10613       else
10614         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10615     }
10616
10617   /* Now TYPE has the actual type.  */
10618
10619   if (explicitp == 1 || (explicitp && friendp))
10620     {
10621       /* [dcl.fct.spec] The explicit specifier shall only be used in
10622          declarations of constructors within a class definition.  */
10623       error ("only declarations of constructors can be `explicit'");
10624       explicitp = 0;
10625     }
10626
10627   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10628     {
10629       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10630         {
10631           error ("non-member `%s' cannot be declared `mutable'", name);
10632           RIDBIT_RESET (RID_MUTABLE, specbits);
10633         }
10634       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10635         {
10636           error ("non-object member `%s' cannot be declared `mutable'", name);
10637           RIDBIT_RESET (RID_MUTABLE, specbits);
10638         }
10639       else if (TREE_CODE (type) == FUNCTION_TYPE
10640                || TREE_CODE (type) == METHOD_TYPE)
10641         {
10642           error ("function `%s' cannot be declared `mutable'", name);
10643           RIDBIT_RESET (RID_MUTABLE, specbits);
10644         }
10645       else if (staticp)
10646         {
10647           error ("static `%s' cannot be declared `mutable'", name);
10648           RIDBIT_RESET (RID_MUTABLE, specbits);
10649         }
10650       else if (type_quals & TYPE_QUAL_CONST)
10651         {
10652           error ("const `%s' cannot be declared `mutable'", name);
10653           RIDBIT_RESET (RID_MUTABLE, specbits);
10654         }
10655     }
10656
10657   if (declarator == NULL_TREE
10658       || TREE_CODE (declarator) == IDENTIFIER_NODE
10659       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10660           && (TREE_CODE (type) == FUNCTION_TYPE
10661               || TREE_CODE (type) == METHOD_TYPE)))
10662     /* OK */;
10663   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10664     {
10665       cp_error ("template-id `%D' used as a declarator", declarator);
10666       declarator = dname;
10667     }
10668   else
10669     /* Unexpected declarator format.  */
10670     my_friendly_abort (990210);
10671
10672   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10673
10674   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10675     {
10676       tree decl;
10677
10678       /* Note that the grammar rejects storage classes
10679          in typenames, fields or parameters.  */
10680       if (current_lang_name == lang_name_java)
10681         TYPE_FOR_JAVA (type) = 1;
10682
10683       if (decl_context == FIELD)
10684         {
10685           if (declarator == constructor_name (current_class_type))
10686             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10687                         declarator);
10688           decl = build_lang_decl (TYPE_DECL, declarator, type);
10689         }
10690       else
10691         {
10692           /* Make sure this typedef lives as long as its type,
10693              since it might be used as a template parameter. */
10694           if (processing_template_decl)
10695             decl = build_lang_decl (TYPE_DECL, declarator, type);
10696           else
10697             decl = build_decl (TYPE_DECL, declarator, type);
10698         }
10699
10700       /* If the user declares "typedef struct {...} foo" then the
10701          struct will have an anonymous name.  Fill that name in now.
10702          Nothing can refer to it, so nothing needs know about the name
10703          change.  */
10704       if (type != error_mark_node
10705           && TYPE_NAME (type)
10706           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10707           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10708           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10709         {
10710           tree oldname = TYPE_NAME (type);
10711           tree t;
10712
10713           /* Replace the anonymous name with the real name everywhere.  */
10714           lookup_tag_reverse (type, declarator);
10715           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10716             if (TYPE_NAME (t) == oldname)
10717               TYPE_NAME (t) = decl;
10718
10719           if (TYPE_LANG_SPECIFIC (type))
10720             TYPE_WAS_ANONYMOUS (type) = 1;
10721
10722           /* If this is a typedef within a template class, the nested
10723              type is a (non-primary) template.  The name for the
10724              template needs updating as well.  */
10725           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10726             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10727               = TYPE_IDENTIFIER (type);
10728
10729           /* XXX Temporarily set the scope.
10730              When returning, start_decl expects it as NULL_TREE,
10731              and will then then set it using pushdecl. */
10732           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10733           if (current_class_type)
10734             DECL_CONTEXT (decl) = current_class_type;
10735           else
10736             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10737
10738           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10739           DECL_ASSEMBLER_NAME (decl)
10740             = get_identifier (build_overload_name (type, 1, 1));
10741           DECL_CONTEXT (decl) = NULL_TREE;
10742
10743           /* FIXME remangle member functions; member functions of a
10744              type with external linkage have external linkage.  */
10745         }
10746
10747       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10748         {
10749           cp_error_at ("typedef name may not be class-qualified", decl);
10750           return NULL_TREE;
10751         }
10752       else if (quals)
10753         {
10754           if (ctype == NULL_TREE)
10755             {
10756               if (TREE_CODE (type) != METHOD_TYPE)
10757                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10758               else
10759                 ctype = TYPE_METHOD_BASETYPE (type);
10760             }
10761           if (ctype != NULL_TREE)
10762             grok_method_quals (ctype, decl, quals);
10763         }
10764
10765       if (RIDBIT_SETP (RID_SIGNED, specbits)
10766           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10767         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10768
10769       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10770                       inlinep, friendp, raises != NULL_TREE);
10771
10772       if (initialized)
10773         error ("typedef declaration includes an initializer");
10774
10775       return decl;
10776     }
10777
10778   /* Detect the case of an array type of unspecified size
10779      which came, as such, direct from a typedef name.
10780      We must copy the type, so that each identifier gets
10781      a distinct type, so that each identifier's size can be
10782      controlled separately by its own initializer.  */
10783
10784   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10785       && TYPE_DOMAIN (type) == NULL_TREE)
10786     {
10787       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10788     }
10789
10790   /* If this is a type name (such as, in a cast or sizeof),
10791      compute the type and return it now.  */
10792
10793   if (decl_context == TYPENAME)
10794     {
10795       /* Note that the grammar rejects storage classes
10796          in typenames, fields or parameters.  */
10797       if (type_quals != TYPE_UNQUALIFIED)
10798         type_quals = TYPE_UNQUALIFIED;
10799
10800       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10801       if (friendp)
10802         {
10803           if (type_quals != TYPE_UNQUALIFIED)
10804             {
10805               cp_error ("type qualifiers specified for friend class declaration");
10806               type_quals = TYPE_UNQUALIFIED;
10807             }
10808           if (inlinep)
10809             {
10810               cp_error ("`inline' specified for friend class declaration");
10811               inlinep = 0;
10812             }
10813
10814           /* Only try to do this stuff if we didn't already give up.  */
10815           if (type != integer_type_node)
10816             {
10817               /* A friendly class?  */
10818               if (current_class_type)
10819                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10820               else
10821                 error ("trying to make class `%s' a friend of global scope",
10822                        TYPE_NAME_STRING (type));
10823               type = void_type_node;
10824             }
10825         }
10826       else if (quals)
10827         {
10828           if (ctype == NULL_TREE)
10829             {
10830               if (TREE_CODE (type) != METHOD_TYPE)
10831                 cp_error ("invalid qualifiers on non-member function type");
10832               else
10833                 ctype = TYPE_METHOD_BASETYPE (type);
10834             }
10835           if (ctype)
10836             {
10837               tree dummy = build_decl (TYPE_DECL, declarator, type);
10838               grok_method_quals (ctype, dummy, quals);
10839               type = TREE_TYPE (dummy);
10840             }
10841         }
10842
10843       return type;
10844     }
10845   else if (declarator == NULL_TREE && decl_context != PARM
10846            && decl_context != CATCHPARM
10847            && TREE_CODE (type) != UNION_TYPE
10848            && ! bitfield)
10849     {
10850       cp_error ("abstract declarator `%T' used as declaration", type);
10851       declarator = make_anon_name ();
10852     }
10853
10854   /* `void' at top level (not within pointer)
10855      is allowed only in typedefs or type names.
10856      We don't complain about parms either, but that is because
10857      a better error message can be made later.  */
10858
10859   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10860     {
10861       if (! declarator)
10862         error ("unnamed variable or field declared void");
10863       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10864         {
10865           if (IDENTIFIER_OPNAME_P (declarator))
10866             my_friendly_abort (356);
10867           else
10868             error ("variable or field `%s' declared void", name);
10869         }
10870       else
10871         error ("variable or field declared void");
10872       type = integer_type_node;
10873     }
10874
10875   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10876      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
10877
10878   if (decl_context == PARM || decl_context == CATCHPARM)
10879     {
10880       if (ctype || in_namespace)
10881         error ("cannot use `::' in parameter declaration");
10882
10883       /* A parameter declared as an array of T is really a pointer to T.
10884          One declared as a function is really a pointer to a function.
10885          One declared as a member is really a pointer to member.  */
10886
10887       if (TREE_CODE (type) == ARRAY_TYPE)
10888         {
10889           /* Transfer const-ness of array into that of type pointed to.  */
10890           type = build_pointer_type (TREE_TYPE (type));
10891           type_quals = TYPE_UNQUALIFIED;
10892         }
10893       else if (TREE_CODE (type) == FUNCTION_TYPE)
10894         type = build_pointer_type (type);
10895       else if (TREE_CODE (type) == OFFSET_TYPE)
10896         type = build_pointer_type (type);
10897       else if (TREE_CODE (type) == VOID_TYPE && declarator)
10898         {
10899           error ("declaration of `%s' as void", name);
10900           return NULL_TREE;
10901         }
10902     }
10903
10904   {
10905     register tree decl;
10906
10907     if (decl_context == PARM)
10908       {
10909         decl = build_decl (PARM_DECL, declarator, type);
10910
10911         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10912                         inlinep, friendp, raises != NULL_TREE);
10913
10914         /* Compute the type actually passed in the parmlist,
10915            for the case where there is no prototype.
10916            (For example, shorts and chars are passed as ints.)
10917            When there is a prototype, this is overridden later.  */
10918
10919         DECL_ARG_TYPE (decl) = type_promotes_to (type);
10920       }
10921     else if (decl_context == FIELD)
10922       {
10923         if (type == error_mark_node)
10924           {
10925             /* Happens when declaring arrays of sizes which
10926                are error_mark_node, for example.  */
10927             decl = NULL_TREE;
10928           }
10929         else if (in_namespace && !friendp)
10930           {
10931             /* Something like struct S { int N::j; };  */
10932             cp_error ("invalid use of `::'");
10933             decl = NULL_TREE;
10934           }
10935         else if (TREE_CODE (type) == FUNCTION_TYPE)
10936           {
10937             int publicp = 0;
10938             tree function_context;
10939
10940             /* We catch the others as conflicts with the builtin
10941                typedefs.  */
10942             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
10943               {
10944                 cp_error ("function `%D' cannot be declared friend",
10945                           declarator);
10946                 friendp = 0;
10947               }
10948
10949             if (friendp == 0)
10950               {
10951                 if (ctype == NULL_TREE)
10952                   ctype = current_class_type;
10953
10954                 if (ctype == NULL_TREE)
10955                   {
10956                     cp_error ("can't make `%D' into a method -- not in a class",
10957                               declarator);
10958                     return void_type_node;
10959                   }
10960
10961                 /* ``A union may [ ... ] not [ have ] virtual functions.''
10962                    ARM 9.5 */
10963                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10964                   {
10965                     cp_error ("function `%D' declared virtual inside a union",
10966                               declarator);
10967                     return void_type_node;
10968                   }
10969
10970                 if (declarator == ansi_opname[(int) NEW_EXPR]
10971                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
10972                     || declarator == ansi_opname[(int) DELETE_EXPR]
10973                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
10974                   {
10975                     if (virtualp)
10976                       {
10977                         cp_error ("`%D' cannot be declared virtual, since it is always static",
10978                                   declarator);
10979                         virtualp = 0;
10980                       }
10981                   }
10982                 else if (staticp < 2)
10983                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
10984                                                   TYPE_ARG_TYPES (type));
10985               }
10986
10987             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
10988             function_context = (ctype != NULL_TREE) ?
10989               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10990             publicp = (! friendp || ! staticp)
10991               && function_context == NULL_TREE;
10992             decl = grokfndecl (ctype, type,
10993                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
10994                                ? declarator : dname,
10995                                declarator,
10996                                virtualp, flags, quals, raises,
10997                                friendp ? -1 : 0, friendp, publicp, inlinep,
10998                                funcdef_flag, template_count, in_namespace);
10999             if (decl == NULL_TREE)
11000               return decl;
11001 #if 0
11002             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11003             /* The decl and setting of decl_machine_attr is also turned off.  */
11004             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11005 #endif
11006
11007             /* [class.conv.ctor]
11008
11009                A constructor declared without the function-specifier
11010                explicit that can be called with a single parameter
11011                specifies a conversion from the type of its first
11012                parameter to the type of its class.  Such a constructor
11013                is called a converting constructor.  */
11014             if (explicitp == 2)
11015               DECL_NONCONVERTING_P (decl) = 1;
11016             else if (DECL_CONSTRUCTOR_P (decl))
11017               {
11018                 /* The constructor can be called with exactly one
11019                    parameter if there is at least one parameter, and
11020                    any subsequent parameters have default arguments.
11021                    We don't look at the first parameter, which is
11022                    really just the `this' parameter for the new
11023                    object.  */
11024                 tree arg_types =
11025                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11026
11027                 /* Skip the `in_chrg' argument too, if present.  */
11028                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
11029                   arg_types = TREE_CHAIN (arg_types);
11030
11031                 if (arg_types == void_list_node
11032                     || (arg_types
11033                         && TREE_CHAIN (arg_types)
11034                         && TREE_CHAIN (arg_types) != void_list_node
11035                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11036                   DECL_NONCONVERTING_P (decl) = 1;
11037               }
11038           }
11039         else if (TREE_CODE (type) == METHOD_TYPE)
11040           {
11041             /* We only get here for friend declarations of
11042                members of other classes.  */
11043             /* All method decls are public, so tell grokfndecl to set
11044                TREE_PUBLIC, also.  */
11045             decl = grokfndecl (ctype, type, declarator, declarator,
11046                                virtualp, flags, quals, raises,
11047                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11048                                template_count, in_namespace);
11049             if (decl == NULL_TREE)
11050               return NULL_TREE;
11051           }
11052         else if (!staticp && ! processing_template_decl
11053                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
11054                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11055           {
11056             if (declarator)
11057               cp_error ("field `%D' has incomplete type", declarator);
11058             else
11059               cp_error ("name `%T' has incomplete type", type);
11060
11061             /* If we're instantiating a template, tell them which
11062                instantiation made the field's type be incomplete.  */
11063             if (current_class_type
11064                 && TYPE_NAME (current_class_type)
11065                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11066                 && declspecs && TREE_VALUE (declspecs)
11067                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11068               cp_error ("  in instantiation of template `%T'",
11069                         current_class_type);
11070
11071             type = error_mark_node;
11072             decl = NULL_TREE;
11073           }
11074         else
11075           {
11076             if (friendp)
11077               {
11078                 error ("`%s' is neither function nor member function; cannot be declared friend",
11079                        IDENTIFIER_POINTER (declarator));
11080                 friendp = 0;
11081               }
11082             decl = NULL_TREE;
11083           }
11084
11085         if (friendp)
11086           {
11087             /* Friends are treated specially.  */
11088             if (ctype == current_class_type)
11089               warning ("member functions are implicitly friends of their class");
11090             else
11091               {
11092                 tree t = NULL_TREE;
11093                 if (decl && DECL_NAME (decl))
11094                   {
11095                     if (template_class_depth (current_class_type) == 0)
11096                       {
11097                         decl
11098                           = check_explicit_specialization
11099                           (declarator, decl,
11100                            template_count, 2 * (funcdef_flag != 0) + 4);
11101                         if (decl == error_mark_node)
11102                           return error_mark_node;
11103                       }
11104
11105                     t = do_friend (ctype, declarator, decl,
11106                                    last_function_parms, attrlist, flags, quals,
11107                                    funcdef_flag);
11108                   }
11109                 if (t && funcdef_flag)
11110                   return t;
11111
11112                 return void_type_node;
11113               }
11114           }
11115
11116         /* Structure field.  It may not be a function, except for C++ */
11117
11118         if (decl == NULL_TREE)
11119           {
11120             if (initialized)
11121               {
11122                 if (!staticp)
11123                   {
11124                     /* An attempt is being made to initialize a non-static
11125                        member.  But, from [class.mem]:
11126
11127                        4 A member-declarator can contain a
11128                        constant-initializer only if it declares a static
11129                        member (_class.static_) of integral or enumeration
11130                        type, see _class.static.data_.
11131
11132                        This used to be relatively common practice, but
11133                        the rest of the compiler does not correctly
11134                        handle the initialization unless the member is
11135                        static so we make it static below.  */
11136                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11137                                 declarator);
11138                     cp_pedwarn ("making `%D' static", declarator);
11139                     staticp = 1;
11140                   }
11141
11142                 if (uses_template_parms (type))
11143                   /* We'll check at instantiation time.  */
11144                   ;
11145                 else if (check_static_variable_definition (declarator,
11146                                                            type))
11147                   /* If we just return the declaration, crashes
11148                      will sometimes occur.  We therefore return
11149                      void_type_node, as if this was a friend
11150                      declaration, to cause callers to completely
11151                      ignore this declaration.  */
11152                   return void_type_node;
11153               }
11154
11155             /* 9.2p13 [class.mem] */
11156             if (declarator == constructor_name (current_class_type)
11157                 /* Divergence from the standard:  In extern "C", we
11158                    allow non-static data members here, because C does
11159                    and /usr/include/netinet/in.h uses that.  */
11160                 && (staticp || ! in_system_header))
11161               cp_pedwarn ("ISO C++ forbids data member `%D' with same name as enclosing class",
11162                           declarator);
11163
11164             if (staticp)
11165               {
11166                 /* C++ allows static class members.  All other work
11167                    for this is done by grokfield.  */
11168                 decl = build_lang_decl (VAR_DECL, declarator, type);
11169                 TREE_STATIC (decl) = 1;
11170                 /* In class context, 'static' means public access.  */
11171                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11172               }
11173             else
11174               {
11175                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11176                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11177                   {
11178                     DECL_MUTABLE_P (decl) = 1;
11179                     RIDBIT_RESET (RID_MUTABLE, specbits);
11180                   }
11181               }
11182
11183             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11184                             inlinep, friendp, raises != NULL_TREE);
11185           }
11186       }
11187     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11188       {
11189         tree original_name;
11190         int publicp = 0;
11191
11192         if (! declarator)
11193           return NULL_TREE;
11194
11195         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11196           original_name = dname;
11197         else
11198           original_name = declarator;
11199
11200         if (RIDBIT_SETP (RID_AUTO, specbits))
11201           error ("storage class `auto' invalid for function `%s'", name);
11202         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11203           error ("storage class `register' invalid for function `%s'", name);
11204
11205         /* Function declaration not at top level.
11206            Storage classes other than `extern' are not allowed
11207            and `extern' makes no difference.  */
11208         if (! toplevel_bindings_p ()
11209             && (RIDBIT_SETP (RID_STATIC, specbits)
11210                 || RIDBIT_SETP (RID_INLINE, specbits))
11211             && pedantic)
11212           {
11213             if (RIDBIT_SETP (RID_STATIC, specbits))
11214               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11215             else
11216               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11217           }
11218
11219         if (ctype == NULL_TREE)
11220           {
11221             if (virtualp)
11222               {
11223                 error ("virtual non-class function `%s'", name);
11224                 virtualp = 0;
11225               }
11226           }
11227         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11228           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11229                                           TYPE_ARG_TYPES (type));
11230
11231         /* Record presence of `static'.  */
11232         publicp = (ctype != NULL_TREE
11233                    || RIDBIT_SETP (RID_EXTERN, specbits)
11234                    || !RIDBIT_SETP (RID_STATIC, specbits));
11235
11236         decl = grokfndecl (ctype, type, original_name, declarator,
11237                            virtualp, flags, quals, raises,
11238                            1, friendp,
11239                            publicp, inlinep, funcdef_flag,
11240                            template_count, in_namespace);
11241         if (decl == NULL_TREE)
11242           return NULL_TREE;
11243
11244         if (staticp == 1)
11245           {
11246             int illegal_static = 0;
11247
11248             /* Don't allow a static member function in a class, and forbid
11249                declaring main to be static.  */
11250             if (TREE_CODE (type) == METHOD_TYPE)
11251               {
11252                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11253                 illegal_static = 1;
11254               }
11255             else if (current_function_decl)
11256               {
11257                 /* FIXME need arm citation */
11258                 error ("cannot declare static function inside another function");
11259                 illegal_static = 1;
11260               }
11261
11262             if (illegal_static)
11263               {
11264                 staticp = 0;
11265                 RIDBIT_RESET (RID_STATIC, specbits);
11266               }
11267           }
11268       }
11269     else
11270       {
11271         /* It's a variable.  */
11272
11273         /* An uninitialized decl with `extern' is a reference.  */
11274         decl = grokvardecl (type, declarator, &specbits,
11275                             initialized,
11276                             (type_quals & TYPE_QUAL_CONST) != 0,
11277                             in_namespace);
11278         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11279                         inlinep, friendp, raises != NULL_TREE);
11280
11281         if (ctype)
11282           {
11283             DECL_CONTEXT (decl) = ctype;
11284             if (staticp == 1)
11285               {
11286                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11287                 staticp = 0;
11288                 RIDBIT_RESET (RID_STATIC, specbits);
11289               }
11290             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11291               {
11292                 cp_error ("static member `%D' declared `register'", decl);
11293                 RIDBIT_RESET (RID_REGISTER, specbits);
11294               }
11295             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11296               {
11297                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11298                             decl);
11299                 RIDBIT_RESET (RID_EXTERN, specbits);
11300               }
11301           }
11302       }
11303
11304     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11305
11306     /* Record `register' declaration for warnings on &
11307        and in case doing stupid register allocation.  */
11308
11309     if (RIDBIT_SETP (RID_REGISTER, specbits))
11310       DECL_REGISTER (decl) = 1;
11311
11312     if (RIDBIT_SETP (RID_EXTERN, specbits))
11313       DECL_THIS_EXTERN (decl) = 1;
11314
11315     if (RIDBIT_SETP (RID_STATIC, specbits))
11316       DECL_THIS_STATIC (decl) = 1;
11317
11318     /* Record constancy and volatility.  There's no need to do this
11319        when processing a template; we'll do this for the instantiated
11320        declaration based on the type of DECL.  */
11321     if (!processing_template_decl)
11322       c_apply_type_quals_to_decl (type_quals, decl);
11323
11324     return decl;
11325   }
11326 }
11327 \f
11328 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11329    An empty exprlist is a parmlist.  An exprlist which
11330    contains only identifiers at the global level
11331    is a parmlist.  Otherwise, it is an exprlist.  */
11332
11333 int
11334 parmlist_is_exprlist (exprs)
11335      tree exprs;
11336 {
11337   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11338     return 0;
11339
11340   if (toplevel_bindings_p ())
11341     {
11342       /* At the global level, if these are all identifiers,
11343          then it is a parmlist.  */
11344       while (exprs)
11345         {
11346           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11347             return 1;
11348           exprs = TREE_CHAIN (exprs);
11349         }
11350       return 0;
11351     }
11352   return 1;
11353 }
11354
11355 /* Subroutine of start_function.  Ensure that each of the parameter
11356    types (as listed in PARMS) is complete, as is required for a
11357    function definition.  */
11358
11359 static void
11360 require_complete_types_for_parms (parms)
11361      tree parms;
11362 {
11363   for (; parms; parms = TREE_CHAIN (parms))
11364     {
11365       tree type = TREE_TYPE (parms);
11366
11367       /* Try to complete the TYPE.  */
11368       type = complete_type (type);
11369
11370       if (type == error_mark_node)
11371         continue;
11372
11373       if (TYPE_SIZE (type) == NULL_TREE)
11374         {
11375           if (DECL_NAME (parms))
11376             error ("parameter `%s' has incomplete type",
11377                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11378           else
11379             error ("parameter has incomplete type");
11380           TREE_TYPE (parms) = error_mark_node;
11381         }
11382       else
11383         layout_decl (parms, 0);
11384     }
11385 }
11386
11387 /* Returns non-zero if T is a local variable.  */
11388
11389 int
11390 local_variable_p (t)
11391      tree t;
11392 {
11393   if ((TREE_CODE (t) == VAR_DECL
11394        /* A VAR_DECL with a context that is a _TYPE is a static data
11395           member.  */
11396        && !TYPE_P (CP_DECL_CONTEXT (t))
11397        /* Any other non-local variable must be at namespace scope.  */
11398        && !DECL_NAMESPACE_SCOPE_P (t))
11399       || (TREE_CODE (t) == PARM_DECL))
11400     return 1;
11401
11402   return 0;
11403 }
11404
11405 /* Returns non-zero if T is an automatic local variable or a label.
11406    (These are the declarations that need to be remapped when the code
11407    containing them is duplicated.)  */
11408
11409 int
11410 nonstatic_local_decl_p (t)
11411      tree t;
11412 {
11413   return ((local_variable_p (t) && !TREE_STATIC (t))
11414           || TREE_CODE (t) == LABEL_DECL
11415           || TREE_CODE (t) == RESULT_DECL);
11416 }
11417
11418 /* Like local_variable_p, but suitable for use as a tree-walking
11419    function.  */
11420
11421 static tree
11422 local_variable_p_walkfn (tp, walk_subtrees, data)
11423      tree *tp;
11424      int *walk_subtrees ATTRIBUTE_UNUSED;
11425      void *data ATTRIBUTE_UNUSED;
11426 {
11427   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11428           ? *tp : NULL_TREE);
11429 }
11430
11431 /* Check that ARG, which is a default-argument expression for a
11432    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11433    something goes wrong.  DECL may also be a _TYPE node, rather than a
11434    DECL, if there is no DECL available.  */
11435
11436 tree
11437 check_default_argument (decl, arg)
11438      tree decl;
11439      tree arg;
11440 {
11441   tree var;
11442   tree decl_type;
11443
11444   if (TREE_CODE (arg) == DEFAULT_ARG)
11445     /* We get a DEFAULT_ARG when looking at an in-class declaration
11446        with a default argument.  Ignore the argument for now; we'll
11447        deal with it after the class is complete.  */
11448     return arg;
11449
11450   if (processing_template_decl || uses_template_parms (arg))
11451     /* We don't do anything checking until instantiation-time.  Note
11452        that there may be uninstantiated arguments even for an
11453        instantiated function, since default arguments are not
11454        instantiated until they are needed.  */
11455     return arg;
11456
11457   if (TYPE_P (decl))
11458     {
11459       decl_type = decl;
11460       decl = NULL_TREE;
11461     }
11462   else
11463     decl_type = TREE_TYPE (decl);
11464
11465   if (arg == error_mark_node
11466       || decl == error_mark_node
11467       || TREE_TYPE (arg) == error_mark_node
11468       || decl_type == error_mark_node)
11469     /* Something already went wrong.  There's no need to check
11470        further.  */
11471     return error_mark_node;
11472
11473   /* [dcl.fct.default]
11474
11475      A default argument expression is implicitly converted to the
11476      parameter type.  */
11477   if (!TREE_TYPE (arg)
11478       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11479     {
11480       if (decl)
11481         cp_error ("default argument for `%#D' has type `%T'",
11482                   decl, TREE_TYPE (arg));
11483       else
11484         cp_error ("default argument for parameter of type `%T' has type `%T'",
11485                   decl_type, TREE_TYPE (arg));
11486
11487       return error_mark_node;
11488     }
11489
11490   /* [dcl.fct.default]
11491
11492      Local variables shall not be used in default argument
11493      expressions.
11494
11495      The keyword `this' shall not be used in a default argument of a
11496      member function.  */
11497   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11498   if (var)
11499     {
11500       cp_error ("default argument `%E' uses local variable `%D'",
11501                 arg, var);
11502       return error_mark_node;
11503     }
11504
11505   /* All is well.  */
11506   return arg;
11507 }
11508
11509 /* Decode the list of parameter types for a function type.
11510    Given the list of things declared inside the parens,
11511    return a list of types.
11512
11513    The list we receive can have three kinds of elements:
11514    an IDENTIFIER_NODE for names given without types,
11515    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11516    or void_type_node, to mark the end of an argument list
11517    when additional arguments are not permitted (... was not used).
11518
11519    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11520    a mere declaration.  A nonempty identifier-list gets an error message
11521    when FUNCDEF_FLAG is zero.
11522    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11523    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11524
11525    If all elements of the input list contain types,
11526    we return a list of the types.
11527    If all elements contain no type (except perhaps a void_type_node
11528    at the end), we return a null list.
11529    If some have types and some do not, it is an error, and we
11530    return a null list.
11531
11532    Also set last_function_parms to either
11533    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11534    A list of names is converted to a chain of PARM_DECLs
11535    by store_parm_decls so that ultimately it is always a chain of decls.
11536
11537    Note that in C++, parameters can take default values.  These default
11538    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11539    an error to specify default values which are followed by parameters
11540    that have no default values, or an ELLIPSES.  For simplicities sake,
11541    only parameters which are specified with their types can take on
11542    default values.  */
11543
11544 static tree
11545 grokparms (first_parm, funcdef_flag)
11546      tree first_parm;
11547      int funcdef_flag;
11548 {
11549   tree result = NULL_TREE;
11550   tree decls = NULL_TREE;
11551
11552   if (first_parm != NULL_TREE
11553       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11554     {
11555       if (! funcdef_flag)
11556         pedwarn ("parameter names (without types) in function declaration");
11557       last_function_parms = first_parm;
11558       return NULL_TREE;
11559     }
11560   else if (first_parm != NULL_TREE
11561            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11562            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11563     my_friendly_abort (145);
11564   else
11565     {
11566       /* Types were specified.  This is a list of declarators
11567          each represented as a TREE_LIST node.  */
11568       register tree parm, chain;
11569       int any_init = 0, any_error = 0;
11570
11571       if (first_parm != NULL_TREE)
11572         {
11573           tree last_result = NULL_TREE;
11574           tree last_decl = NULL_TREE;
11575
11576           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11577             {
11578               tree type = NULL_TREE, list_node = parm;
11579               register tree decl = TREE_VALUE (parm);
11580               tree init = TREE_PURPOSE (parm);
11581
11582               chain = TREE_CHAIN (parm);
11583               /* @@ weak defense against parse errors.  */
11584               if (TREE_CODE (decl) != VOID_TYPE
11585                   && TREE_CODE (decl) != TREE_LIST)
11586                 {
11587                   /* Give various messages as the need arises.  */
11588                   if (TREE_CODE (decl) == STRING_CST)
11589                     cp_error ("invalid string constant `%E'", decl);
11590                   else if (TREE_CODE (decl) == INTEGER_CST)
11591                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11592                   continue;
11593                 }
11594
11595               if (TREE_CODE (decl) != VOID_TYPE)
11596                 {
11597                   decl = grokdeclarator (TREE_VALUE (decl),
11598                                          TREE_PURPOSE (decl),
11599                                          PARM, init != NULL_TREE,
11600                                          NULL_TREE);
11601                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11602                     continue;
11603
11604                   /* Top-level qualifiers on the parameters are
11605                      ignored for function types.  */
11606                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11607
11608                   if (TREE_CODE (type) == VOID_TYPE)
11609                     decl = void_type_node;
11610                   else if (TREE_CODE (type) == METHOD_TYPE)
11611                     {
11612                       if (DECL_NAME (decl))
11613                         /* Cannot use the decl here because
11614                            we don't have DECL_CONTEXT set up yet.  */
11615                         cp_error ("parameter `%D' invalidly declared method type",
11616                                   DECL_NAME (decl));
11617                       else
11618                         error ("parameter invalidly declared method type");
11619                       type = build_pointer_type (type);
11620                       TREE_TYPE (decl) = type;
11621                     }
11622                   else if (TREE_CODE (type) == OFFSET_TYPE)
11623                     {
11624                       if (DECL_NAME (decl))
11625                         cp_error ("parameter `%D' invalidly declared offset type",
11626                                   DECL_NAME (decl));
11627                       else
11628                         error ("parameter invalidly declared offset type");
11629                       type = build_pointer_type (type);
11630                       TREE_TYPE (decl) = type;
11631                     }
11632                   else if (abstract_virtuals_error (decl, type))
11633                     any_error = 1;  /* Seems like a good idea. */
11634                   else if (POINTER_TYPE_P (type))
11635                     {
11636                       tree t = type;
11637                       while (POINTER_TYPE_P (t)
11638                              || (TREE_CODE (t) == ARRAY_TYPE
11639                                  && TYPE_DOMAIN (t) != NULL_TREE))
11640                         t = TREE_TYPE (t);
11641                       if (TREE_CODE (t) == ARRAY_TYPE)
11642                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11643                                   type,
11644                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11645                     }
11646                 }
11647
11648               if (TREE_CODE (decl) == VOID_TYPE)
11649                 {
11650                   if (result == NULL_TREE)
11651                     {
11652                       result = void_list_node;
11653                       last_result = result;
11654                     }
11655                   else
11656                     {
11657                       TREE_CHAIN (last_result) = void_list_node;
11658                       last_result = void_list_node;
11659                     }
11660                   if (chain
11661                       && (chain != void_list_node || TREE_CHAIN (chain)))
11662                     error ("`void' in parameter list must be entire list");
11663                   break;
11664                 }
11665
11666               /* Since there is a prototype, args are passed in their own types.  */
11667               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11668               if (PROMOTE_PROTOTYPES
11669                   && (TREE_CODE (type) == INTEGER_TYPE
11670                       || TREE_CODE (type) == ENUMERAL_TYPE)
11671                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11672                 DECL_ARG_TYPE (decl) = integer_type_node;
11673               if (!any_error && init)
11674                 {
11675                   any_init++;
11676                   init = check_default_argument (decl, init);
11677                 }
11678               else
11679                 init = NULL_TREE;
11680
11681               if (decls == NULL_TREE)
11682                 {
11683                   decls = decl;
11684                   last_decl = decls;
11685                 }
11686               else
11687                 {
11688                   TREE_CHAIN (last_decl) = decl;
11689                   last_decl = decl;
11690                 }
11691               list_node = tree_cons (init, type, NULL_TREE);
11692               if (result == NULL_TREE)
11693                 {
11694                   result = list_node;
11695                   last_result = result;
11696                 }
11697               else
11698                 {
11699                   TREE_CHAIN (last_result) = list_node;
11700                   last_result = list_node;
11701                 }
11702             }
11703           if (last_result)
11704             TREE_CHAIN (last_result) = NULL_TREE;
11705           /* If there are no parameters, and the function does not end
11706              with `...', then last_decl will be NULL_TREE.  */
11707           if (last_decl != NULL_TREE)
11708             TREE_CHAIN (last_decl) = NULL_TREE;
11709         }
11710     }
11711
11712   last_function_parms = decls;
11713
11714   return result;
11715 }
11716
11717 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11718    FUNCTION_TYPE with the newly parsed version of its default argument, which
11719    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11720
11721 void
11722 replace_defarg (arg, init)
11723      tree arg, init;
11724 {
11725   if (! processing_template_decl
11726       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11727     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11728                 TREE_TYPE (init), TREE_VALUE (arg));
11729   TREE_PURPOSE (arg) = init;
11730 }
11731 \f
11732 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11733    D's arguments allow it to be a copy constructor, or copy assignment
11734    operator.  */
11735
11736 int
11737 copy_args_p (d)
11738      tree d;
11739 {
11740   tree t;
11741
11742   if (!DECL_FUNCTION_MEMBER_P (d))
11743     return 0;
11744
11745   t = FUNCTION_ARG_CHAIN (d);
11746   if (DECL_CONSTRUCTOR_P (d)
11747       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11748     t = TREE_CHAIN (t);
11749   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11750       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11751           == DECL_CONTEXT (d))
11752       && (TREE_CHAIN (t) == NULL_TREE
11753           || TREE_CHAIN (t) == void_list_node
11754           || TREE_PURPOSE (TREE_CHAIN (t))))
11755     return 1;
11756   return 0;
11757 }
11758
11759 /* These memoizing functions keep track of special properties which
11760    a class may have.  `grok_ctor_properties' notices whether a class
11761    has a constructor of the form X(X&), and also complains
11762    if the class has a constructor of the form X(X).
11763    `grok_op_properties' takes notice of the various forms of
11764    operator= which are defined, as well as what sorts of type conversion
11765    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11766
11767 int
11768 grok_ctor_properties (ctype, decl)
11769      tree ctype, decl;
11770 {
11771   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11772   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11773
11774   /* When a type has virtual baseclasses, a magical first int argument is
11775      added to any ctor so we can tell if the class has been initialized
11776      yet.  This could screw things up in this function, so we deliberately
11777      ignore the leading int if we're in that situation.  */
11778   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11779     {
11780       my_friendly_assert (parmtypes
11781                           && TREE_VALUE (parmtypes) == integer_type_node,
11782                           980529);
11783       parmtypes = TREE_CHAIN (parmtypes);
11784       parmtype = TREE_VALUE (parmtypes);
11785     }
11786
11787   /* [class.copy]
11788
11789      A non-template constructor for class X is a copy constructor if
11790      its first parameter is of type X&, const X&, volatile X& or const
11791      volatile X&, and either there are no other parameters or else all
11792      other parameters have default arguments.  */
11793   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11794       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11795       && (TREE_CHAIN (parmtypes) == NULL_TREE
11796           || TREE_CHAIN (parmtypes) == void_list_node
11797           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11798       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11799            && is_member_template (DECL_TI_TEMPLATE (decl))))
11800     {
11801       TYPE_HAS_INIT_REF (ctype) = 1;
11802       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11803         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11804     }
11805   /* [class.copy]
11806
11807      A declaration of a constructor for a class X is ill-formed if its
11808      first parameter is of type (optionally cv-qualified) X and either
11809      there are no other parameters or else all other parameters have
11810      default arguments.
11811
11812      We *don't* complain about member template instantiations that
11813      have this form, though; they can occur as we try to decide what
11814      constructor to use during overload resolution.  Since overload
11815      resolution will never prefer such a constructor to the
11816      non-template copy constructor (which is either explicitly or
11817      implicitly defined), there's no need to worry about their
11818      existence.  Theoretically, they should never even be
11819      instantiated, but that's hard to forestall.  */
11820   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11821            && (TREE_CHAIN (parmtypes) == NULL_TREE
11822                || TREE_CHAIN (parmtypes) == void_list_node
11823                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11824            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11825                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11826     {
11827       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11828                 ctype, ctype);
11829       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11830       return 0;
11831     }
11832   else if (TREE_CODE (parmtype) == VOID_TYPE
11833            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11834     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11835
11836   return 1;
11837 }
11838
11839 /* An operator with this name can be either unary or binary.  */
11840
11841 static int
11842 ambi_op_p (name)
11843      tree name;
11844 {
11845   return (name == ansi_opname [(int) INDIRECT_REF]
11846           || name == ansi_opname [(int) ADDR_EXPR]
11847           || name == ansi_opname [(int) NEGATE_EXPR]
11848           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11849           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11850           || name == ansi_opname [(int) CONVERT_EXPR]);
11851 }
11852
11853 /* An operator with this name can only be unary.  */
11854
11855 static int
11856 unary_op_p (name)
11857      tree name;
11858 {
11859   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11860           || name == ansi_opname [(int) BIT_NOT_EXPR]
11861           || name == ansi_opname [(int) COMPONENT_REF]
11862           || IDENTIFIER_TYPENAME_P (name));
11863 }
11864
11865 /* Do a little sanity-checking on how they declared their operator.  */
11866
11867 void
11868 grok_op_properties (decl, virtualp, friendp)
11869      tree decl;
11870      int virtualp, friendp;
11871 {
11872   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11873   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11874   tree name = DECL_NAME (decl);
11875
11876   if (current_class_type == NULL_TREE)
11877     friendp = 1;
11878
11879   if (! friendp)
11880     {
11881       /* [class.copy]
11882
11883          A user-declared copy assignment operator X::operator= is a
11884          non-static non-template member function of class X with
11885          exactly one parameter of type X, X&, const X&, volatile X& or
11886          const volatile X&.  */
11887       if (name == ansi_opname[(int) MODIFY_EXPR]
11888           && !(DECL_TEMPLATE_INSTANTIATION (decl)
11889                && is_member_template (DECL_TI_TEMPLATE (decl))))
11890         ;
11891       else if (name == ansi_opname[(int) CALL_EXPR])
11892         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11893       else if (name == ansi_opname[(int) ARRAY_REF])
11894         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11895       else if (name == ansi_opname[(int) COMPONENT_REF]
11896                || name == ansi_opname[(int) MEMBER_REF])
11897         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11898       else if (name == ansi_opname[(int) NEW_EXPR])
11899         TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
11900       else if (name == ansi_opname[(int) DELETE_EXPR])
11901         TYPE_GETS_DELETE (current_class_type) |= 1;
11902       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11903         TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
11904       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11905         TYPE_GETS_DELETE (current_class_type) |= 2;
11906     }
11907
11908   if (name == ansi_opname[(int) NEW_EXPR]
11909       || name == ansi_opname[(int) VEC_NEW_EXPR])
11910     {
11911       /* When the compiler encounters the definition of A::operator new, it
11912          doesn't look at the class declaration to find out if it's static.  */
11913       if (methodp)
11914         revert_static_member_fn (&decl, NULL, NULL);
11915
11916       /* Take care of function decl if we had syntax errors.  */
11917       if (argtypes == NULL_TREE)
11918         TREE_TYPE (decl)
11919           = build_function_type (ptr_type_node,
11920                                  hash_tree_chain (integer_type_node,
11921                                                   void_list_node));
11922       else
11923         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11924     }
11925   else if (name == ansi_opname[(int) DELETE_EXPR]
11926            || name == ansi_opname[(int) VEC_DELETE_EXPR])
11927     {
11928       if (methodp)
11929         revert_static_member_fn (&decl, NULL, NULL);
11930
11931       if (argtypes == NULL_TREE)
11932         TREE_TYPE (decl)
11933           = build_function_type (void_type_node,
11934                                  hash_tree_chain (ptr_type_node,
11935                                                   void_list_node));
11936       else
11937         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11938     }
11939   else
11940     {
11941       /* An operator function must either be a non-static member function
11942          or have at least one parameter of a class, a reference to a class,
11943          an enumeration, or a reference to an enumeration.  13.4.0.6 */
11944       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11945         {
11946           if (IDENTIFIER_TYPENAME_P (name)
11947               || name == ansi_opname[(int) CALL_EXPR]
11948               || name == ansi_opname[(int) MODIFY_EXPR]
11949               || name == ansi_opname[(int) COMPONENT_REF]
11950               || name == ansi_opname[(int) ARRAY_REF])
11951             cp_error ("`%D' must be a nonstatic member function", decl);
11952           else
11953             {
11954               tree p = argtypes;
11955
11956               if (DECL_STATIC_FUNCTION_P (decl))
11957                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
11958
11959               if (p)
11960                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
11961                   {
11962                     tree arg = TREE_VALUE (p);
11963                     if (TREE_CODE (arg) == REFERENCE_TYPE)
11964                       arg = TREE_TYPE (arg);
11965
11966                     /* This lets bad template code slip through.  */
11967                     if (IS_AGGR_TYPE (arg)
11968                         || TREE_CODE (arg) == ENUMERAL_TYPE
11969                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
11970                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
11971                       goto foundaggr;
11972                   }
11973               cp_error
11974                 ("`%D' must have an argument of class or enumerated type",
11975                  decl);
11976             foundaggr:
11977               ;
11978             }
11979         }
11980
11981       if (name == ansi_opname[(int) CALL_EXPR])
11982         return;                 /* No restrictions on args. */
11983
11984       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
11985         {
11986           tree t = TREE_TYPE (name);
11987           if (! friendp)
11988             {
11989               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11990               const char *what = 0;
11991
11992               if (ref)
11993                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11994
11995               if (TREE_CODE (t) == VOID_TYPE)
11996                 what = "void";
11997               else if (t == current_class_type)
11998                 what = "the same type";
11999               /* Don't force t to be complete here.  */
12000               else if (IS_AGGR_TYPE (t)
12001                        && TYPE_SIZE (t)
12002                        && DERIVED_FROM_P (t, current_class_type))
12003                 what = "a base class";
12004
12005               if (what)
12006                 warning ("conversion to %s%s will never use a type conversion operator",
12007                          ref ? "a reference to " : "", what);
12008             }
12009         }
12010
12011       if (name == ansi_opname[(int) MODIFY_EXPR])
12012         {
12013           tree parmtype;
12014
12015           if (list_length (argtypes) != 3 && methodp)
12016             {
12017               cp_error ("`%D' must take exactly one argument", decl);
12018               return;
12019             }
12020           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12021
12022           if (copy_assignment_arg_p (parmtype, virtualp)
12023               && ! friendp)
12024             {
12025               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12026               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12027                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12028                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12029             }
12030         }
12031       else if (name == ansi_opname[(int) COND_EXPR])
12032         {
12033           /* 13.4.0.3 */
12034           cp_error ("ISO C++ prohibits overloading operator ?:");
12035         }
12036       else if (ambi_op_p (name))
12037         {
12038           if (list_length (argtypes) == 2)
12039             /* prefix */;
12040           else if (list_length (argtypes) == 3)
12041             {
12042               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12043                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12044                   && ! processing_template_decl
12045                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12046                 {
12047                   if (methodp)
12048                     cp_error ("postfix `%D' must take `int' as its argument",
12049                               decl);
12050                   else
12051                     cp_error
12052                       ("postfix `%D' must take `int' as its second argument",
12053                        decl);
12054                 }
12055             }
12056           else
12057             {
12058               if (methodp)
12059                 cp_error ("`%D' must take either zero or one argument", decl);
12060               else
12061                 cp_error ("`%D' must take either one or two arguments", decl);
12062             }
12063
12064           /* More Effective C++ rule 6.  */
12065           if (warn_ecpp
12066               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12067                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12068             {
12069               tree arg = TREE_VALUE (argtypes);
12070               tree ret = TREE_TYPE (TREE_TYPE (decl));
12071               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12072                 arg = TREE_TYPE (arg);
12073               arg = TYPE_MAIN_VARIANT (arg);
12074               if (list_length (argtypes) == 2)
12075                 {
12076                   if (TREE_CODE (ret) != REFERENCE_TYPE
12077                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12078                                        arg))
12079                     cp_warning ("prefix `%D' should return `%T'", decl,
12080                                 build_reference_type (arg));
12081                 }
12082               else
12083                 {
12084                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12085                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12086                 }
12087             }
12088         }
12089       else if (unary_op_p (name))
12090         {
12091           if (list_length (argtypes) != 2)
12092             {
12093               if (methodp)
12094                 cp_error ("`%D' must take `void'", decl);
12095               else
12096                 cp_error ("`%D' must take exactly one argument", decl);
12097             }
12098         }
12099       else /* if (binary_op_p (name)) */
12100         {
12101           if (list_length (argtypes) != 3)
12102             {
12103               if (methodp)
12104                 cp_error ("`%D' must take exactly one argument", decl);
12105               else
12106                 cp_error ("`%D' must take exactly two arguments", decl);
12107             }
12108
12109           /* More Effective C++ rule 7.  */
12110           if (warn_ecpp
12111               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12112                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12113                   || name == ansi_opname [COMPOUND_EXPR]))
12114             cp_warning ("user-defined `%D' always evaluates both arguments",
12115                         decl);
12116         }
12117
12118       /* Effective C++ rule 23.  */
12119       if (warn_ecpp
12120           && list_length (argtypes) == 3
12121           && (name == ansi_opname [PLUS_EXPR]
12122               || name == ansi_opname [MINUS_EXPR]
12123               || name == ansi_opname [TRUNC_DIV_EXPR]
12124               || name == ansi_opname [MULT_EXPR])
12125           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12126         cp_warning ("`%D' should return by value", decl);
12127
12128       /* 13.4.0.8 */
12129       if (argtypes)
12130         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12131           if (TREE_PURPOSE (argtypes))
12132             {
12133               TREE_PURPOSE (argtypes) = NULL_TREE;
12134               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12135                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12136                 {
12137                   if (pedantic)
12138                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12139                 }
12140               else
12141                 cp_error ("`%D' cannot have default arguments", decl);
12142             }
12143     }
12144 }
12145 \f
12146 static const char *
12147 tag_name (code)
12148      enum tag_types code;
12149 {
12150   switch (code)
12151     {
12152     case record_type:
12153       return "struct";
12154     case class_type:
12155       return "class";
12156     case union_type:
12157       return "union ";
12158     case enum_type:
12159       return "enum";
12160     default:
12161       my_friendly_abort (981122);
12162     }
12163 }
12164
12165 /* Get the struct, enum or union (CODE says which) with tag NAME.
12166    Define the tag as a forward-reference if it is not defined.
12167
12168    C++: If a class derivation is given, process it here, and report
12169    an error if multiple derivation declarations are not identical.
12170
12171    If this is a definition, come in through xref_tag and only look in
12172    the current frame for the name (since C++ allows new names in any
12173    scope.)  */
12174
12175 tree
12176 xref_tag (code_type_node, name, globalize)
12177      tree code_type_node;
12178      tree name;
12179      int globalize;
12180 {
12181   enum tag_types tag_code;
12182   enum tree_code code;
12183   register tree ref, t;
12184   struct binding_level *b = current_binding_level;
12185   int got_type = 0;
12186   tree attributes = NULL_TREE;
12187   tree context = NULL_TREE;
12188
12189   /* If we are called from the parser, code_type_node will sometimes be a
12190      TREE_LIST.  This indicates that the user wrote
12191      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12192      use them later.  */
12193   if (TREE_CODE (code_type_node) == TREE_LIST)
12194     {
12195       attributes = TREE_PURPOSE (code_type_node);
12196       code_type_node = TREE_VALUE (code_type_node);
12197     }
12198
12199   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12200   switch (tag_code)
12201     {
12202     case record_type:
12203     case class_type:
12204       code = RECORD_TYPE;
12205       break;
12206     case union_type:
12207       code = UNION_TYPE;
12208       break;
12209     case enum_type:
12210       code = ENUMERAL_TYPE;
12211       break;
12212     default:
12213       my_friendly_abort (18);
12214     }
12215
12216   /* If a cross reference is requested, look up the type
12217      already defined for this tag and return it.  */
12218   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12219     {
12220       t = name;
12221       name = TYPE_IDENTIFIER (t);
12222       got_type = 1;
12223     }
12224   else
12225     t = IDENTIFIER_TYPE_VALUE (name);
12226
12227   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12228       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12229     t = NULL_TREE;
12230
12231   if (! globalize)
12232     {
12233       /* If we know we are defining this tag, only look it up in
12234          this scope and don't try to find it as a type.  */
12235       ref = lookup_tag (code, name, b, 1);
12236     }
12237   else
12238     {
12239       if (t)
12240         {
12241           /* [dcl.type.elab] If the identifier resolves to a
12242              typedef-name or a template type-parameter, the
12243              elaborated-type-specifier is ill-formed.  */
12244           if (t != TYPE_MAIN_VARIANT (t)
12245               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12246             cp_pedwarn ("using typedef-name `%D' after `%s'",
12247                         TYPE_NAME (t), tag_name (tag_code));
12248           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12249             cp_error ("using template type parameter `%T' after `%s'",
12250                       t, tag_name (tag_code));
12251
12252           ref = t;
12253         }
12254       else
12255         ref = lookup_tag (code, name, b, 0);
12256
12257       if (! ref)
12258         {
12259           /* Try finding it as a type declaration.  If that wins,
12260              use it.  */
12261           ref = lookup_name (name, 1);
12262
12263           if (ref != NULL_TREE
12264               && processing_template_decl
12265               && DECL_CLASS_TEMPLATE_P (ref)
12266               && template_class_depth (current_class_type) == 0)
12267             /* Since GLOBALIZE is true, we're declaring a global
12268                template, so we want this type.  */
12269             ref = DECL_RESULT (ref);
12270
12271           if (ref && TREE_CODE (ref) == TYPE_DECL
12272               && TREE_CODE (TREE_TYPE (ref)) == code)
12273             ref = TREE_TYPE (ref);
12274           else
12275             ref = NULL_TREE;
12276         }
12277
12278       if (ref && current_class_type
12279           && template_class_depth (current_class_type)
12280           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12281         {
12282           /* Since GLOBALIZE is non-zero, we are not looking at a
12283              definition of this tag.  Since, in addition, we are currently
12284              processing a (member) template declaration of a template
12285              class, we must be very careful; consider:
12286
12287                template <class X>
12288                struct S1
12289
12290                template <class U>
12291                struct S2
12292                { template <class V>
12293                friend struct S1; };
12294
12295              Here, the S2::S1 declaration should not be confused with the
12296              outer declaration.  In particular, the inner version should
12297              have a template parameter of level 2, not level 1.  This
12298              would be particularly important if the member declaration
12299              were instead:
12300
12301                template <class V = U> friend struct S1;
12302
12303              say, when we should tsubst into `U' when instantiating
12304              S2.  On the other hand, when presented with:
12305
12306                  template <class T>
12307                  struct S1 {
12308                    template <class U>
12309                    struct S2 {};
12310                    template <class U>
12311                    friend struct S2;
12312                  };
12313
12314               we must find the inner binding eventually.  We
12315               accomplish this by making sure that the new type we
12316               create to represent this declaration has the right
12317               TYPE_CONTEXT.  */
12318           context = TYPE_CONTEXT (ref);
12319           ref = NULL_TREE;
12320         }
12321     }
12322
12323   if (! ref)
12324     {
12325       /* If no such tag is yet defined, create a forward-reference node
12326          and record it as the "definition".
12327          When a real declaration of this type is found,
12328          the forward-reference will be altered into a real type.  */
12329       if (code == ENUMERAL_TYPE)
12330         {
12331           cp_error ("use of enum `%#D' without previous declaration", name);
12332
12333           ref = make_node (ENUMERAL_TYPE);
12334
12335           /* Give the type a default layout like unsigned int
12336              to avoid crashing if it does not get defined.  */
12337           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12338           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12339           TREE_UNSIGNED (ref) = 1;
12340           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12341           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12342           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12343
12344           /* Enable us to recognize when a type is created in class context.
12345              To do nested classes correctly, this should probably be cleared
12346              out when we leave this classes scope.  Currently this in only
12347              done in `start_enum'.  */
12348
12349           pushtag (name, ref, globalize);
12350         }
12351       else
12352         {
12353           struct binding_level *old_b = class_binding_level;
12354
12355           ref = make_aggr_type (code);
12356           TYPE_CONTEXT (ref) = context;
12357
12358 #ifdef NONNESTED_CLASSES
12359           /* Class types don't nest the way enums do.  */
12360           class_binding_level = (struct binding_level *)0;
12361 #endif
12362           pushtag (name, ref, globalize);
12363           class_binding_level = old_b;
12364         }
12365     }
12366   else
12367     {
12368       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12369         redeclare_class_template (ref, current_template_parms);
12370     }
12371
12372   /* Until the type is defined, tentatively accept whatever
12373      structure tag the user hands us.  */
12374   if (TYPE_SIZE (ref) == NULL_TREE
12375       && ref != current_class_type
12376       /* Have to check this, in case we have contradictory tag info.  */
12377       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12378     {
12379       if (tag_code == class_type)
12380         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12381       else if (tag_code == record_type)
12382         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12383     }
12384
12385   TREE_TYPE (ref) = attributes;
12386
12387   return ref;
12388 }
12389
12390 tree
12391 xref_tag_from_type (old, id, globalize)
12392      tree old, id;
12393      int globalize;
12394 {
12395   tree code_type_node;
12396
12397   if (TREE_CODE (old) == RECORD_TYPE)
12398     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12399                       ? class_type_node : record_type_node);
12400   else
12401     code_type_node = union_type_node;
12402
12403   if (id == NULL_TREE)
12404     id = TYPE_IDENTIFIER (old);
12405
12406   return xref_tag (code_type_node, id, globalize);
12407 }
12408
12409 /* REF is a type (named NAME), for which we have just seen some
12410    baseclasses.  BINFO is a list of those baseclasses; the
12411    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12412    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12413    struct, or union.  */
12414
12415 void
12416 xref_basetypes (code_type_node, name, ref, binfo)
12417      tree code_type_node;
12418      tree name, ref;
12419      tree binfo;
12420 {
12421   /* In the declaration `A : X, Y, ... Z' we mark all the types
12422      (A, X, Y, ..., Z) so we can check for duplicates.  */
12423   tree binfos;
12424   tree base;
12425
12426   int i, len;
12427   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12428
12429   if (tag_code == union_type)
12430     {
12431       cp_error ("derived union `%T' invalid", ref);
12432       return;
12433     }
12434
12435   len = list_length (binfo);
12436
12437   /* First, make sure that any templates in base-classes are
12438      instantiated.  This ensures that if we call ourselves recursively
12439      we do not get confused about which classes are marked and which
12440      are not.  */
12441   for (base = binfo; base; base = TREE_CHAIN (base))
12442     complete_type (TREE_VALUE (base));
12443
12444   SET_CLASSTYPE_MARKED (ref);
12445   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12446
12447   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12448     {
12449       /* The base of a derived struct is public by default.  */
12450       int via_public
12451         = (TREE_PURPOSE (binfo) == access_public_node
12452            || TREE_PURPOSE (binfo) == access_public_virtual_node
12453            || (tag_code != class_type
12454                && (TREE_PURPOSE (binfo) == access_default_node
12455                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12456       int via_protected
12457         = (TREE_PURPOSE (binfo) == access_protected_node
12458            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12459       int via_virtual
12460         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12461            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12462            || TREE_PURPOSE (binfo) == access_public_virtual_node
12463            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12464       tree basetype = TREE_VALUE (binfo);
12465       tree base_binfo;
12466
12467       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12468         basetype = TREE_TYPE (basetype);
12469       if (!basetype
12470           || (TREE_CODE (basetype) != RECORD_TYPE
12471               && TREE_CODE (basetype) != TYPENAME_TYPE
12472               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12473               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12474         {
12475           cp_error ("base type `%T' fails to be a struct or class type",
12476                     TREE_VALUE (binfo));
12477           continue;
12478         }
12479
12480       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12481
12482       /* This code replaces similar code in layout_basetypes.
12483          We put the complete_type first for implicit `typename'.  */
12484       if (TYPE_SIZE (basetype) == NULL_TREE
12485           && ! (current_template_parms && uses_template_parms (basetype)))
12486         {
12487           cp_error ("base class `%T' has incomplete type", basetype);
12488           continue;
12489         }
12490       else
12491         {
12492           if (CLASSTYPE_MARKED (basetype))
12493             {
12494               if (basetype == ref)
12495                 cp_error ("recursive type `%T' undefined", basetype);
12496               else
12497                 cp_error ("duplicate base type `%T' invalid", basetype);
12498               continue;
12499             }
12500
12501           if (TYPE_FOR_JAVA (basetype)
12502               && (current_lang_stack
12503                   == &VARRAY_TREE (current_lang_base, 0)))
12504             TYPE_FOR_JAVA (ref) = 1;
12505
12506           /* Note that the BINFO records which describe individual
12507              inheritances are *not* shared in the lattice!  They
12508              cannot be shared because a given baseclass may be
12509              inherited with different `accessibility' by different
12510              derived classes.  (Each BINFO record describing an
12511              individual inheritance contains flags which say what
12512              the `accessibility' of that particular inheritance is.)  */
12513
12514           base_binfo
12515             = make_binfo (size_zero_node, basetype,
12516                           CLASS_TYPE_P (basetype)
12517                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12518                           CLASS_TYPE_P (basetype)
12519                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12520
12521           TREE_VEC_ELT (binfos, i) = base_binfo;
12522           TREE_VIA_PUBLIC (base_binfo) = via_public;
12523           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12524           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12525           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12526
12527           /* We need to unshare the binfos now so that lookups during class
12528              definition work.  */
12529           unshare_base_binfos (base_binfo);
12530
12531           SET_CLASSTYPE_MARKED (basetype);
12532
12533           /* We are free to modify these bits because they are meaningless
12534              at top level, and BASETYPE is a top-level type.  */
12535           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12536             {
12537               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12538               /* Converting to a virtual base class requires looking
12539                  up the offset of the virtual base.  */
12540               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12541             }
12542
12543           if (CLASS_TYPE_P (basetype))
12544             {
12545               TYPE_HAS_NEW_OPERATOR (ref)
12546                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12547               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12548                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12549               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12550               /* If the base-class uses multiple inheritance, so do we.  */
12551               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12552                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12553               /* Likewise, if converting to a base of the base may require
12554                  code, then we may need to generate code to convert to a
12555                  base as well.  */
12556               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12557                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12558             }
12559
12560           i += 1;
12561         }
12562     }
12563   if (i)
12564     TREE_VEC_LENGTH (binfos) = i;
12565   else
12566     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12567
12568   if (i > 1)
12569     {
12570       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12571       /* If there is more than one non-empty they cannot be at the same
12572          address.  */
12573       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12574     }
12575
12576   /* Unmark all the types.  */
12577   while (--i >= 0)
12578     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12579   CLEAR_CLASSTYPE_MARKED (ref);
12580
12581   /* Now that we know all the base-classes, set up the list of virtual
12582      bases.  */
12583   get_vbase_types (ref);
12584 }
12585
12586 \f
12587 /* Begin compiling the definition of an enumeration type.
12588    NAME is its name (or null if anonymous).
12589    Returns the type object, as yet incomplete.
12590    Also records info about it so that build_enumerator
12591    may be used to declare the individual values as they are read.  */
12592
12593 tree
12594 start_enum (name)
12595      tree name;
12596 {
12597   register tree enumtype = NULL_TREE;
12598   struct binding_level *b = current_binding_level;
12599
12600   /* If this is the real definition for a previous forward reference,
12601      fill in the contents in the same object that used to be the
12602      forward reference.  */
12603
12604   if (name != NULL_TREE)
12605     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12606
12607   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12608     {
12609       cp_error ("multiple definition of `%#T'", enumtype);
12610       cp_error_at ("previous definition here", enumtype);
12611       /* Clear out TYPE_VALUES, and start again.  */
12612       TYPE_VALUES (enumtype) = NULL_TREE;
12613     }
12614   else
12615     {
12616       enumtype = make_node (ENUMERAL_TYPE);
12617       pushtag (name, enumtype, 0);
12618     }
12619
12620   if (current_class_type)
12621     TREE_ADDRESSABLE (b->tags) = 1;
12622
12623   GNU_xref_decl (current_function_decl, enumtype);
12624   return enumtype;
12625 }
12626
12627 /* After processing and defining all the values of an enumeration type,
12628    install their decls in the enumeration type and finish it off.
12629    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12630    Returns ENUMTYPE.  */
12631
12632 tree
12633 finish_enum (enumtype)
12634      tree enumtype;
12635 {
12636   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12637   /* Calculate the maximum value of any enumerator in this type.  */
12638
12639   tree values = TYPE_VALUES (enumtype);
12640   if (values)
12641     {
12642       tree pair;
12643
12644       for (pair = values; pair; pair = TREE_CHAIN (pair))
12645         {
12646           tree decl;
12647           tree value;
12648
12649           /* The TREE_VALUE is a CONST_DECL for this enumeration
12650              constant.  */
12651           decl = TREE_VALUE (pair);
12652
12653           /* [dcl.enum]
12654
12655              Following the closing brace of an enum-specifier, each
12656              enumerator has the type of its enumeration.  Prior to the
12657              closing brace, the type of each enumerator is the type of
12658              its initializing value.  */
12659           TREE_TYPE (decl) = enumtype;
12660
12661           /* The DECL_INITIAL will be NULL if we are processing a
12662              template declaration and this enumeration constant had no
12663              explicit initializer.  */
12664           value = DECL_INITIAL (decl);
12665           if (value && !processing_template_decl)
12666             {
12667               /* Set the TREE_TYPE for the VALUE as well.  That's so
12668                  that when we call decl_constant_value we get an
12669                  entity of the right type (but with the constant
12670                  value).  Since we shouldn't ever call
12671                  decl_constant_value on a template type, there's no
12672                  reason to do that when processing_template_decl.
12673                  And, if the expression is something like a
12674                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12675                  wreak havoc on the intended type of the expression.
12676
12677                  Of course, there's also no point in trying to compute
12678                  minimum or maximum values if we're in a template.  */
12679               TREE_TYPE (value) = enumtype;
12680
12681               if (!minnode)
12682                 minnode = maxnode = value;
12683               else if (tree_int_cst_lt (maxnode, value))
12684                 maxnode = value;
12685               else if (tree_int_cst_lt (value, minnode))
12686                 minnode = value;
12687             }
12688
12689           if (processing_template_decl)
12690             /* If this is just a template, leave the CONST_DECL
12691                alone.  That way tsubst_copy will find CONST_DECLs for
12692                CONST_DECLs, and not INTEGER_CSTs.  */
12693             ;
12694           else
12695             /* In the list we're building up, we want the enumeration
12696                values, not the CONST_DECLs.  */
12697             TREE_VALUE (pair) = value;
12698         }
12699     }
12700   else
12701     maxnode = minnode = integer_zero_node;
12702
12703   TYPE_VALUES (enumtype) = nreverse (values);
12704
12705   if (processing_template_decl)
12706     {
12707       tree scope = current_scope ();
12708       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12709         add_tree (build_min (TAG_DEFN, enumtype));
12710     }
12711   else
12712     {
12713       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12714       int lowprec = min_precision (minnode, unsignedp);
12715       int highprec = min_precision (maxnode, unsignedp);
12716       int precision = MAX (lowprec, highprec);
12717       tree tem;
12718
12719       TYPE_SIZE (enumtype) = NULL_TREE;
12720
12721       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12722
12723       TYPE_PRECISION (enumtype) = precision;
12724       if (unsignedp)
12725         fixup_unsigned_type (enumtype);
12726       else
12727         fixup_signed_type (enumtype);
12728
12729       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12730         /* Use the width of the narrowest normal C type which is wide
12731            enough.  */
12732         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12733                                                     (precision, 1));
12734       else
12735         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12736
12737       TYPE_SIZE (enumtype) = 0;
12738       layout_type (enumtype);
12739
12740       /* Fix up all variant types of this enum type.  */
12741       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12742            tem = TYPE_NEXT_VARIANT (tem))
12743         {
12744           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12745           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12746           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12747           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12748           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12749           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12750           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12751           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12752           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12753         }
12754
12755       /* Finish debugging output for this type.  */
12756       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12757     }
12758
12759   return enumtype;
12760 }
12761
12762 /* Build and install a CONST_DECL for an enumeration constant of the
12763    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12764    Assignment of sequential values by default is handled here.  */
12765
12766 void
12767 build_enumerator (name, value, enumtype)
12768      tree name;
12769      tree value;
12770      tree enumtype;
12771 {
12772   tree decl;
12773   tree context;
12774   tree type;
12775   tree values;
12776
12777   /* Remove no-op casts from the value.  */
12778   if (value)
12779     STRIP_TYPE_NOPS (value);
12780
12781   if (! processing_template_decl)
12782     {
12783       /* Validate and default VALUE.  */
12784       if (value != NULL_TREE)
12785         {
12786           if (TREE_READONLY_DECL_P (value))
12787             value = decl_constant_value (value);
12788
12789           if (TREE_CODE (value) == INTEGER_CST)
12790             {
12791               value = default_conversion (value);
12792               constant_expression_warning (value);
12793             }
12794           else
12795             {
12796               cp_error ("enumerator value for `%D' not integer constant", name);
12797               value = NULL_TREE;
12798             }
12799         }
12800
12801       /* Default based on previous value.  */
12802       if (value == NULL_TREE && ! processing_template_decl)
12803         {
12804           tree prev_value;
12805
12806           if (TYPE_VALUES (enumtype))
12807             {
12808               /* The next value is the previous value ... */
12809               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12810               /* ... plus one.  */
12811               value = build_binary_op (PLUS_EXPR,
12812                                        prev_value,
12813                                        integer_one_node);
12814
12815               if (tree_int_cst_lt (value, prev_value))
12816                 cp_error ("overflow in enumeration values at `%D'", name);
12817             }
12818           else
12819             value = integer_zero_node;
12820         }
12821
12822       /* Remove no-op casts from the value.  */
12823       if (value)
12824         STRIP_TYPE_NOPS (value);
12825 #if 0
12826       /* To fix MAX_VAL enum consts. (bkoz)  */
12827       TREE_TYPE (value) = integer_type_node;
12828 #endif
12829     }
12830
12831   /* We always have to copy here; not all INTEGER_CSTs are unshared.
12832      Even in other cases, we will later (in finish_enum) be setting
12833      the type of VALUE.  But, we don't need to make a copy if this
12834      VALUE is one of the enumeration constants for this same
12835      enumeration type.  */
12836   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12837     if (TREE_VALUE (values) == value)
12838       break;
12839   /* If we didn't break out of the loop, then we do need a copy.  */
12840   if (!values && value)
12841     value = copy_node (value);
12842
12843   /* C++ associates enums with global, function, or class declarations.  */
12844   context = current_scope ();
12845
12846   /* Build the actual enumeration constant.  Note that the enumeration
12847     constants have the type of their initializers until the
12848     enumeration is complete:
12849
12850       [ dcl.enum ]
12851
12852       Following the closing brace of an enum-specifier, each enumer-
12853       ator has the type of its enumeration.  Prior to the closing
12854       brace, the type of each enumerator is the type of its
12855       initializing value.
12856
12857     In finish_enum we will reset the type.  Of course, if we're
12858     processing a template, there may be no value.   */
12859   type = value ? TREE_TYPE (value) : NULL_TREE;
12860
12861   if (context && context == current_class_type)
12862     /* This enum declaration is local to the class.  We need the full
12863       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
12864     decl = build_lang_decl (CONST_DECL, name, type);
12865   else
12866     /* It's a global enum, or it's local to a function.  (Note local to
12867       a function could mean local to a class method.  */
12868     decl = build_decl (CONST_DECL, name, type);
12869
12870   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12871   DECL_INITIAL (decl) = value;
12872   TREE_READONLY (decl) = 1;
12873
12874   if (context && context == current_class_type)
12875     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12876       on the TYPE_FIELDS list for `S'.  (That's so that you can say
12877       things like `S::i' later.)  */
12878     finish_member_declaration (decl);
12879   else
12880     {
12881       pushdecl (decl);
12882       GNU_xref_decl (current_function_decl, decl);
12883     }
12884
12885   /* Add this enumeration constant to the list for this type.  */
12886   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12887 }
12888
12889 \f
12890 static int function_depth;
12891
12892 /* We're defining DECL.  Make sure that it's type is OK.  */
12893
12894 static void
12895 check_function_type (decl)
12896      tree decl;
12897 {
12898   tree fntype = TREE_TYPE (decl);
12899
12900   /* In a function definition, arg types must be complete.  */
12901   require_complete_types_for_parms (current_function_parms);
12902
12903   if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12904     {
12905       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
12906
12907       /* Make it return void instead, but don't change the
12908          type of the DECL_RESULT, in case we have a named return value.  */
12909       if (TREE_CODE (fntype) == METHOD_TYPE)
12910         {
12911           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
12912           TREE_TYPE (decl)
12913             = build_cplus_method_type (ctype,
12914                                        void_type_node,
12915                                        FUNCTION_ARG_CHAIN (decl));
12916         }
12917       else
12918         TREE_TYPE (decl)
12919           = build_function_type (void_type_node,
12920                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
12921       TREE_TYPE (decl)
12922         = build_exception_variant (fntype,
12923                                    TYPE_RAISES_EXCEPTIONS (fntype));
12924     }
12925   else
12926     abstract_virtuals_error (decl, TREE_TYPE (fntype));
12927 }
12928
12929 /* Create the FUNCTION_DECL for a function definition.
12930    DECLSPECS and DECLARATOR are the parts of the declaration;
12931    they describe the function's name and the type it returns,
12932    but twisted together in a fashion that parallels the syntax of C.
12933
12934    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12935    DECLARATOR is really the DECL for the function we are about to
12936    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12937    indicating that the function is an inline defined in-class, and
12938    SF_EXPAND indicating that we should generate RTL for this
12939    function.
12940
12941    This function creates a binding context for the function body
12942    as well as setting up the FUNCTION_DECL in current_function_decl.
12943
12944    Returns 1 on success.  If the DECLARATOR is not suitable for a function
12945    (it defines a datum instead), we return 0, which tells
12946    yyparse to report a parse error.
12947
12948    For C++, we must first check whether that datum makes any sense.
12949    For example, "class A local_a(1,2);" means that variable local_a
12950    is an aggregate of type A, which should have a constructor
12951    applied to it with the argument list [1, 2].  */
12952
12953 int
12954 start_function (declspecs, declarator, attrs, flags)
12955      tree declspecs, declarator, attrs;
12956      int flags;
12957 {
12958   tree decl1;
12959   tree ctype = NULL_TREE;
12960   tree fntype;
12961   tree restype;
12962   extern int have_extern_spec;
12963   extern int used_extern_spec;
12964   int doing_friend = 0;
12965   struct binding_level *bl;
12966
12967   /* Sanity check.  */
12968   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
12969   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
12970
12971   /* This should only be done once on the top most decl.  */
12972   if (have_extern_spec && !used_extern_spec)
12973     {
12974       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
12975       used_extern_spec = 1;
12976     }
12977
12978   if (flags & SF_PRE_PARSED)
12979     {
12980       decl1 = declarator;
12981
12982       fntype = TREE_TYPE (decl1);
12983       if (TREE_CODE (fntype) == METHOD_TYPE)
12984         ctype = TYPE_METHOD_BASETYPE (fntype);
12985
12986       /* ISO C++ 11.4/5.  A friend function defined in a class is in
12987          the (lexical) scope of the class in which it is defined.  */
12988       if (!ctype && DECL_FRIEND_P (decl1))
12989         {
12990           ctype = DECL_FRIEND_CONTEXT (decl1);
12991
12992           /* CTYPE could be null here if we're dealing with a template;
12993              for example, `inline friend float foo()' inside a template
12994              will have no CTYPE set.  */
12995           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12996             ctype = NULL_TREE;
12997           else
12998             doing_friend = 1;
12999         }
13000
13001       last_function_parms = DECL_ARGUMENTS (decl1);
13002       last_function_parm_tags = NULL_TREE;
13003     }
13004   else
13005     {
13006       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13007       /* If the declarator is not suitable for a function definition,
13008          cause a syntax error.  */
13009       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13010
13011       fntype = TREE_TYPE (decl1);
13012
13013       restype = TREE_TYPE (fntype);
13014       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13015         {
13016           cp_error ("semicolon missing after declaration of `%#T'", restype);
13017           shadow_tag (build_tree_list (NULL_TREE, restype));
13018           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13019           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13020             fntype = build_function_type (integer_type_node,
13021                                           TYPE_ARG_TYPES (fntype));
13022           else
13023             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13024                                               integer_type_node,
13025                                               TYPE_ARG_TYPES (fntype));
13026           TREE_TYPE (decl1) = fntype;
13027         }
13028
13029       if (TREE_CODE (fntype) == METHOD_TYPE)
13030         ctype = TYPE_METHOD_BASETYPE (fntype);
13031       else if (DECL_MAIN_P (decl1))
13032         {
13033           /* If this doesn't return integer_type, complain.  */
13034           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13035             {
13036               if (pedantic || warn_return_type)
13037                 pedwarn ("return type for `main' changed to `int'");
13038               TREE_TYPE (decl1) = fntype = default_function_type;
13039             }
13040         }
13041     }
13042
13043   /* Sometimes we don't notice that a function is a static member, and
13044      build a METHOD_TYPE for it.  Fix that up now.  */
13045   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13046       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13047     {
13048       revert_static_member_fn (&decl1, NULL, NULL);
13049       last_function_parms = TREE_CHAIN (last_function_parms);
13050       ctype = NULL_TREE;
13051     }
13052
13053   /* Warn if function was previously implicitly declared
13054      (but not if we warned then).  */
13055   if (! warn_implicit
13056       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13057     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13058
13059   /* Set up current_class_type, and enter the scope of the class, if
13060      appropriate.  */
13061   if (ctype)
13062     push_nested_class (ctype, 1);
13063   else if (DECL_STATIC_FUNCTION_P (decl1))
13064     push_nested_class (DECL_CONTEXT (decl1), 2);
13065
13066   /* Now that we have entered the scope of the class, we must restore
13067      the bindings for any template parameters surrounding DECL1, if it
13068      is an inline member template.  (Order is important; consider the
13069      case where a template parameter has the same name as a field of
13070      the class.)  It is not until after this point that
13071      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13072   if (flags & SF_INCLASS_INLINE)
13073     maybe_begin_member_template_processing (decl1);
13074
13075   /* Effective C++ rule 15.  See also c_expand_return.  */
13076   if (warn_ecpp
13077       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13078       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13079     cp_warning ("`operator=' should return a reference to `*this'");
13080
13081   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13082      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13083   if (!DECL_INITIAL (decl1))
13084     DECL_INITIAL (decl1) = error_mark_node;
13085
13086 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13087   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13088 #endif
13089
13090   /* This function exists in static storage.
13091      (This does not mean `static' in the C sense!)  */
13092   TREE_STATIC (decl1) = 1;
13093
13094   /* We must call push_template_decl after current_class_type is set
13095      up.  (If we are processing inline definitions after exiting a
13096      class scope, current_class_type will be NULL_TREE until set above
13097      by push_nested_class.)  */
13098   if (processing_template_decl)
13099     decl1 = push_template_decl (decl1);
13100
13101   /* We are now in the scope of the function being defined.  */
13102   current_function_decl = decl1;
13103
13104   /* Save the parm names or decls from this function's declarator
13105      where store_parm_decls will find them.  */
13106   current_function_parms = last_function_parms;
13107   current_function_parm_tags = last_function_parm_tags;
13108
13109   /* Make sure the parameter and return types are reasonable.  When
13110      you declare a function, these types can be incomplete, but they
13111      must be complete when you define the function.  */
13112   if (! processing_template_decl)
13113     check_function_type (decl1);
13114
13115   /* Build the return declaration for the function.  */
13116   restype = TREE_TYPE (fntype);
13117   if (!processing_template_decl)
13118     {
13119       if (!DECL_RESULT (decl1))
13120         {
13121           DECL_RESULT (decl1)
13122             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13123           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13124                                       DECL_RESULT (decl1));
13125         }
13126     }
13127   else
13128     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13129     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13130
13131   /* Initialize RTL machinery.  We cannot do this until
13132      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13133      even when processing a template; this is how we get
13134      CFUN set up, and our per-function variables initialized.  */
13135   bl = current_binding_level;
13136   init_function_start (decl1, input_filename, lineno);
13137   current_binding_level = bl;
13138   expanding_p = (flags & SF_EXPAND) != 0;
13139
13140   /* Even though we're inside a function body, we still don't want to
13141      call expand_expr to calculate the size of a variable-sized array.
13142      We haven't necessarily assigned RTL to all variables yet, so it's
13143      not safe to try to expand expressions involving them.  */
13144   immediate_size_expand = 0;
13145   cfun->x_dont_save_pending_sizes_p = 1;
13146
13147   /* If we're building a statement-tree, start the tree now.  */
13148   if (processing_template_decl || !expanding_p)
13149     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13150
13151   /* Let the user know we're compiling this function.  */
13152   if (processing_template_decl || !building_stmt_tree ())
13153     announce_function (decl1);
13154
13155   /* Record the decl so that the function name is defined.
13156      If we already have a decl for this name, and it is a FUNCTION_DECL,
13157      use the old decl.  */
13158   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13159     {
13160       /* A specialization is not used to guide overload resolution.  */
13161       if ((flag_guiding_decls
13162            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13163           && ! DECL_FUNCTION_MEMBER_P (decl1))
13164         decl1 = pushdecl (decl1);
13165       else
13166         {
13167           /* We need to set the DECL_CONTEXT. */
13168           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13169             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13170           /* And make sure we have enough default args.  */
13171           check_default_args (decl1);
13172         }
13173       DECL_MAIN_VARIANT (decl1) = decl1;
13174       fntype = TREE_TYPE (decl1);
13175     }
13176
13177   /* Reset these in case the call to pushdecl changed them.  */
13178   current_function_decl = decl1;
13179   cfun->decl = decl1;
13180
13181   /* Initialize the per-function data.  */
13182   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13183     {
13184       /* If we already parsed this function, and we're just expanding it
13185          now, restore saved state.  */
13186       struct binding_level *bl = current_binding_level;
13187       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13188       current_binding_level = bl;
13189
13190       /* This function is being processed in whole-function mode; we
13191          already did semantic analysis.  */
13192       cfun->x_whole_function_mode_p = 1;
13193
13194       /* If we decided that we didn't want to inline this function,
13195          make sure the back-end knows that.  */
13196       if (!current_function_cannot_inline)
13197         current_function_cannot_inline = cp_function_chain->cannot_inline;
13198
13199       /* We don't need the saved data anymore.  */
13200       free (DECL_SAVED_FUNCTION_DATA (decl1));
13201       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13202     }
13203   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13204     {
13205       /* We know that this was set up by `grokclassfn'.  We do not
13206          wait until `store_parm_decls', since evil parse errors may
13207          never get us to that point.  Here we keep the consistency
13208          between `current_class_type' and `current_class_ptr'.  */
13209       tree t = DECL_ARGUMENTS (decl1);
13210
13211       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13212                           162);
13213       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13214                           19990811);
13215
13216       cp_function_chain->x_current_class_ref
13217         = build_indirect_ref (t, NULL_PTR);
13218       cp_function_chain->x_current_class_ptr = t;
13219
13220       /* Constructors and destructors need to know whether they're "in
13221          charge" of initializing virtual base classes.  */
13222       if (DECL_DESTRUCTOR_P (decl1))
13223         current_in_charge_parm = TREE_CHAIN (t);
13224       else if (DECL_CONSTRUCTOR_P (decl1)
13225                && TREE_CHAIN (t)
13226                && DECL_ARTIFICIAL (TREE_CHAIN (t))
13227                && (DECL_NAME (TREE_CHAIN (t))
13228                    == in_charge_identifier))
13229         current_in_charge_parm = TREE_CHAIN (t);
13230     }
13231
13232   if (DECL_INTERFACE_KNOWN (decl1))
13233     {
13234       tree ctx = decl_function_context (decl1);
13235
13236       if (DECL_NOT_REALLY_EXTERN (decl1))
13237         DECL_EXTERNAL (decl1) = 0;
13238
13239       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13240           && TREE_PUBLIC (ctx))
13241         /* This is a function in a local class in an extern inline
13242            function.  */
13243         comdat_linkage (decl1);
13244     }
13245   /* If this function belongs to an interface, it is public.
13246      If it belongs to someone else's interface, it is also external.
13247      This only affects inlines and template instantiations.  */
13248   else if (interface_unknown == 0
13249            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13250                || flag_alt_external_templates))
13251     {
13252       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13253           || processing_template_decl)
13254         {
13255           DECL_EXTERNAL (decl1)
13256             = (interface_only
13257                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13258                    && !DECL_VINDEX (decl1)));
13259
13260           /* For WIN32 we also want to put these in linkonce sections.  */
13261           maybe_make_one_only (decl1);
13262         }
13263       else
13264         DECL_EXTERNAL (decl1) = 0;
13265       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13266       DECL_INTERFACE_KNOWN (decl1) = 1;
13267     }
13268   else if (interface_unknown && interface_only
13269            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13270                || flag_alt_external_templates))
13271     {
13272       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13273          interface, we will have interface_only set but not
13274          interface_known.  In that case, we don't want to use the normal
13275          heuristics because someone will supply a #pragma implementation
13276          elsewhere, and deducing it here would produce a conflict.  */
13277       comdat_linkage (decl1);
13278       DECL_EXTERNAL (decl1) = 0;
13279       DECL_INTERFACE_KNOWN (decl1) = 1;
13280       DECL_DEFER_OUTPUT (decl1) = 1;
13281     }
13282   else
13283     {
13284       /* This is a definition, not a reference.
13285          So clear DECL_EXTERNAL.  */
13286       DECL_EXTERNAL (decl1) = 0;
13287
13288       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13289           && ! DECL_INTERFACE_KNOWN (decl1)
13290           /* Don't try to defer nested functions for now.  */
13291           && ! decl_function_context (decl1))
13292         DECL_DEFER_OUTPUT (decl1) = 1;
13293       else
13294         DECL_INTERFACE_KNOWN (decl1) = 1;
13295     }
13296
13297   if (doing_semantic_analysis_p ())
13298     {
13299       pushlevel (0);
13300       current_binding_level->parm_flag = 1;
13301     }
13302
13303   if (attrs)
13304     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13305
13306   if (!building_stmt_tree ())
13307     {
13308       GNU_xref_function (decl1, current_function_parms);
13309       make_function_rtl (decl1);
13310     }
13311
13312   /* Promote the value to int before returning it.  */
13313   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13314     restype = type_promotes_to (restype);
13315
13316   /* If this fcn was already referenced via a block-scope `extern' decl
13317      (or an implicit decl), propagate certain information about the usage.  */
13318   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13319     TREE_ADDRESSABLE (decl1) = 1;
13320
13321   if (DECL_RESULT (decl1) == NULL_TREE)
13322     {
13323       DECL_RESULT (decl1)
13324         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13325       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13326       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13327     }
13328
13329   ++function_depth;
13330
13331   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13332       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13333     {
13334       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13335       DECL_CONTEXT (dtor_label) = current_function_decl;
13336     }
13337   else if (DECL_CONSTRUCTOR_P (decl1))
13338     {
13339       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13340       DECL_CONTEXT (ctor_label) = current_function_decl;
13341     }
13342
13343   return 1;
13344 }
13345 \f
13346 /* Called after store_parm_decls for a function-try-block.  */
13347
13348 void
13349 expand_start_early_try_stmts ()
13350 {
13351   expand_start_try_stmts ();
13352 }
13353
13354 /* Store the parameter declarations into the current function declaration.
13355    This is called after parsing the parameter declarations, before
13356    digesting the body of the function.
13357
13358    Also install to binding contour return value identifier, if any.  */
13359
13360 void
13361 store_parm_decls ()
13362 {
13363   register tree fndecl = current_function_decl;
13364   register tree parm;
13365   int parms_have_cleanups = 0;
13366   tree cleanups = NULL_TREE;
13367
13368   /* This is a list of types declared among parms in a prototype.  */
13369   tree parmtags = current_function_parm_tags;
13370
13371   /* This is a chain of any other decls that came in among the parm
13372      declarations.  If a parm is declared with  enum {foo, bar} x;
13373      then CONST_DECLs for foo and bar are put here.  */
13374   tree nonparms = NULL_TREE;
13375
13376   /* Create a binding level for the parms.  */
13377   if (!building_stmt_tree ())
13378     expand_start_bindings (2);
13379
13380   if (current_function_parms)
13381     {
13382       /* This case is when the function was defined with an ANSI prototype.
13383          The parms already have decls, so we need not do anything here
13384          except record them as in effect
13385          and complain if any redundant old-style parm decls were written.  */
13386
13387       tree specparms = current_function_parms;
13388       tree next;
13389
13390       if (doing_semantic_analysis_p ())
13391         {
13392           /* Must clear this because it might contain TYPE_DECLs declared
13393              at class level.  */
13394           storedecls (NULL_TREE);
13395
13396           /* If we're doing semantic analysis, then we'll call pushdecl
13397              for each of these.  We must do them in reverse order so that
13398              they end in the correct forward order.  */
13399           specparms = nreverse (specparms);
13400         }
13401
13402       for (parm = specparms; parm; parm = next)
13403         {
13404           next = TREE_CHAIN (parm);
13405           if (TREE_CODE (parm) == PARM_DECL)
13406             {
13407               tree type = TREE_TYPE (parm);
13408
13409               if (doing_semantic_analysis_p ())
13410                 {
13411                   tree cleanup;
13412
13413                   if (DECL_NAME (parm) == NULL_TREE
13414                       || TREE_CODE (parm) != VOID_TYPE)
13415                     pushdecl (parm);
13416                   else
13417                     cp_error ("parameter `%D' declared void", parm);
13418
13419                   cleanup = (processing_template_decl
13420                              ? NULL_TREE
13421                              : maybe_build_cleanup (parm));
13422
13423                   if (cleanup)
13424                     cleanups = tree_cons (parm, cleanup, cleanups);
13425                 }
13426               else if (type != error_mark_node
13427                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13428                 parms_have_cleanups = 1;
13429             }
13430           else
13431             {
13432               /* If we find an enum constant or a type tag,
13433                  put it aside for the moment.  */
13434               TREE_CHAIN (parm) = NULL_TREE;
13435               nonparms = chainon (nonparms, parm);
13436             }
13437         }
13438
13439       if (doing_semantic_analysis_p ())
13440         {
13441           /* Get the decls in their original chain order
13442              and record in the function.  This is all and only the
13443              PARM_DECLs that were pushed into scope by the loop above.  */
13444           DECL_ARGUMENTS (fndecl) = getdecls ();
13445           storetags (chainon (parmtags, gettags ()));
13446         }
13447     }
13448   else
13449     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13450
13451   /* Now store the final chain of decls for the arguments
13452      as the decl-chain of the current lexical scope.
13453      Put the enumerators in as well, at the front so that
13454      DECL_ARGUMENTS is not modified.  */
13455   if (doing_semantic_analysis_p ())
13456     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13457
13458   /* Initialize the RTL code for the function.  */
13459   DECL_SAVED_INSNS (fndecl) = 0;
13460   if (! building_stmt_tree ())
13461     expand_function_start (fndecl, parms_have_cleanups);
13462
13463   current_function_parms_stored = 1;
13464
13465   /* If this function is `main', emit a call to `__main'
13466      to run global initializers, etc.  */
13467   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13468     expand_main_function ();
13469
13470   /* Now that we have initialized the parms, we can start their
13471      cleanups.  We cannot do this before, since expand_decl_cleanup
13472      should not be called before the parm can be used.  */
13473   while (cleanups)
13474     {
13475       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13476                            TREE_VALUE (cleanups));
13477       cleanups = TREE_CHAIN (cleanups);
13478     }
13479
13480   /* Create a binding contour which can be used to catch
13481      cleanup-generated temporaries.  Also, if the return value needs or
13482      has initialization, deal with that now.  */
13483   if (parms_have_cleanups)
13484     {
13485       pushlevel (0);
13486       if (!building_stmt_tree ())
13487         expand_start_bindings (2);
13488     }
13489
13490   /* Do the starting of the exception specifications, if we have any.  */
13491   if (flag_exceptions && !processing_template_decl
13492       && building_stmt_tree ()
13493       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13494     current_eh_spec_try_block = expand_start_eh_spec ();
13495 }
13496
13497 /* Bind a name and initialization to the return value of
13498    the current function.  */
13499
13500 void
13501 store_return_init (decl)
13502      tree decl;
13503 {
13504   /* If this named return value comes in a register, put it in a
13505      pseudo-register.  */
13506   if (DECL_REGISTER (decl))
13507     {
13508       original_result_rtx = DECL_RTL (decl);
13509       /* Note that the mode of the old DECL_RTL may be wider than the
13510          mode of DECL_RESULT, depending on the calling conventions for
13511          the processor.  For example, on the Alpha, a 32-bit integer
13512          is returned in a DImode register -- the DECL_RESULT has
13513          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13514          here, we use the mode the back-end has already assigned for
13515          the return value.  */
13516       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13517     }
13518 }
13519
13520 \f
13521 /* We have finished doing semantic analysis on DECL, but have not yet
13522    generated RTL for its body.  Save away our current state, so that
13523    when we want to generate RTL later we know what to do.  */
13524
13525 static void
13526 save_function_data (decl)
13527      tree decl;
13528 {
13529   struct language_function *f;
13530
13531   /* Save the language-specific per-function data so that we can
13532      get it back when we really expand this function.  */
13533   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13534                       19990908);
13535
13536   /* Make a copy.  */
13537   f = ((struct language_function *)
13538        xmalloc (sizeof (struct language_function)));
13539   bcopy ((char *) cp_function_chain, (char *) f,
13540          sizeof (struct language_function));
13541   DECL_SAVED_FUNCTION_DATA (decl) = f;
13542
13543   /* Clear out the bits we don't need.  */
13544   f->x_base_init_list = NULL_TREE;
13545   f->x_member_init_list = NULL_TREE;
13546   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13547   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13548   f->x_result_rtx = NULL_RTX;
13549   f->x_named_label_uses = NULL;
13550   f->bindings = NULL;
13551
13552   /* When we get back here again, we will be expanding.  */
13553   f->x_expanding_p = 1;
13554
13555   /* If we've already decided that we cannot inline this function, we
13556      must remember that fact when we actually go to expand the
13557      function.  */
13558   f->cannot_inline = current_function_cannot_inline;
13559 }
13560
13561 /* At the end of every constructor we generate to code to return
13562    `this'.  Do that now.  */
13563
13564 static void
13565 finish_constructor_body ()
13566 {
13567   /* Any return from a constructor will end up here.  */
13568   add_tree (build_min_nt (LABEL_STMT, ctor_label));
13569
13570   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13571      generate the return, rather than a goto to CTOR_LABEL.  */
13572   ctor_label = NULL_TREE;
13573   /* In check_return_expr we translate an empty return from a
13574      constructor to a return of `this'.  */
13575   finish_return_stmt (NULL_TREE);
13576   /* Mark the end of the constructor.  */
13577   add_tree (build_min_nt (CTOR_STMT));
13578 }
13579
13580 /* At the end of every destructor we generate code to restore virtual
13581    function tables to the values desired by base classes and to call
13582    to base class destructors.  Do that now.  */
13583
13584 static void
13585 finish_destructor_body ()
13586 {
13587   tree compound_stmt;
13588   tree in_charge;
13589   tree virtual_size;
13590   tree exprstmt;
13591
13592   /* Create a block to contain all the extra code.  */
13593   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13594
13595   /* Any return from a destructor will end up here.  */
13596   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13597
13598   /* Generate the code to call destructor on base class.  If this
13599      destructor belongs to a class with virtual functions, then set
13600      the virtual function table pointer to represent the type of our
13601      base class.  */
13602
13603   /* This side-effect makes call to `build_delete' generate the code
13604      we have to have at the end of this destructor.  `build_delete'
13605      will set the flag again.  */
13606   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13607
13608   /* These are two cases where we cannot delegate deletion.  */
13609   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13610       || TYPE_GETS_REG_DELETE (current_class_type))
13611     in_charge = integer_zero_node;
13612   else
13613     in_charge = current_in_charge_parm;
13614
13615   exprstmt = build_delete (current_class_type,
13616                            current_class_ref,
13617                            in_charge,
13618                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13619                            0);
13620
13621   if (exprstmt != error_mark_node
13622       && (TREE_CODE (exprstmt) != NOP_EXPR
13623           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13624           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13625     {
13626       if (exprstmt != void_zero_node)
13627         /* Don't call `expand_expr_stmt' if we're not going to do
13628            anything, since -Wall will give a diagnostic.  */
13629         finish_expr_stmt (exprstmt);
13630
13631       /* Run destructors for all virtual baseclasses.  */
13632       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13633         {
13634           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13635           tree if_stmt = begin_if_stmt ();
13636           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13637                                       current_in_charge_parm,
13638                                       integer_two_node),
13639                                if_stmt);
13640
13641           while (vbases)
13642             {
13643               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbases)))
13644                 {
13645                   tree vb = get_vbase
13646                     (BINFO_TYPE (vbases),
13647                      TYPE_BINFO (current_class_type));
13648                   finish_expr_stmt
13649                     (build_scoped_method_call
13650                      (current_class_ref, vb, dtor_identifier,
13651                       build_tree_list (NULL_TREE, integer_zero_node)));
13652                 }
13653               vbases = TREE_CHAIN (vbases);
13654             }
13655
13656           finish_then_clause (if_stmt);
13657           finish_if_stmt ();
13658         }
13659     }
13660
13661   virtual_size = c_sizeof (current_class_type);
13662
13663   /* At the end, call delete if that's what's requested.  */
13664
13665   /* FDIS sez: At the point of definition of a virtual destructor
13666      (including an implicit definition), non-placement operator delete
13667      shall be looked up in the scope of the destructor's class and if
13668      found shall be accessible and unambiguous.
13669
13670      This is somewhat unclear, but I take it to mean that if the class
13671      only defines placement deletes we don't do anything here.  So we
13672      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13673      they ever try to delete one of these.  */
13674   if (TYPE_GETS_REG_DELETE (current_class_type)
13675       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13676     {
13677       tree if_stmt;
13678
13679       exprstmt = build_op_delete_call
13680         (DELETE_EXPR, current_class_ptr, virtual_size,
13681          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13682
13683       if_stmt = begin_if_stmt ();
13684       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13685                                   current_in_charge_parm,
13686                                   integer_one_node),
13687                            if_stmt);
13688       finish_expr_stmt (exprstmt);
13689       finish_then_clause (if_stmt);
13690       finish_if_stmt ();
13691     }
13692
13693   /* Close the block we started above.  */
13694   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13695 }
13696
13697 /* Finish up a function declaration and compile that function
13698    all the way to assembler language output.  The free the storage
13699    for the function definition.
13700
13701    This is called after parsing the body of the function definition.
13702    LINENO is the current line number.
13703
13704    FLAGS is a bitwise or of the following values:
13705      1 - CALL_POPLEVEL
13706        An extra call to poplevel (and expand_end_bindings) must be
13707        made to take care of the binding contour for the base
13708        initializers.  This is only relevant for constructors.
13709      2 - INCLASS_INLINE
13710        We just finished processing the body of an in-class inline
13711        function definition.  (This processing will have taken place
13712        after the class definition is complete.)  */
13713
13714 tree
13715 finish_function (lineno, flags)
13716      int lineno;
13717      int flags;
13718 {
13719   register tree fndecl = current_function_decl;
13720   tree fntype, ctype = NULL_TREE;
13721   /* Label to use if this function is supposed to return a value.  */
13722   tree no_return_label = NULL_TREE;
13723   int call_poplevel = (flags & 1) != 0;
13724   int inclass_inline = (flags & 2) != 0;
13725   int expand_p;
13726   int nested;
13727
13728   /* When we get some parse errors, we can end up without a
13729      current_function_decl, so cope.  */
13730   if (fndecl == NULL_TREE)
13731     return error_mark_node;
13732
13733   nested = function_depth > 1;
13734   fntype = TREE_TYPE (fndecl);
13735
13736   /*  TREE_READONLY (fndecl) = 1;
13737       This caused &foo to be of type ptr-to-const-function
13738       which then got a warning when stored in a ptr-to-function variable.  */
13739
13740   /* This happens on strange parse errors.  */
13741   if (! current_function_parms_stored)
13742     {
13743       call_poplevel = 0;
13744       store_parm_decls ();
13745     }
13746
13747   if (building_stmt_tree ())
13748     {
13749       if (DECL_CONSTRUCTOR_P (fndecl))
13750         {
13751           finish_constructor_body ();
13752           if (call_poplevel)
13753             do_poplevel ();
13754         }
13755       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13756         finish_destructor_body ();
13757       else if (DECL_MAIN_P (fndecl))
13758         {
13759           /* Make it so that `main' always returns 0 by default.  */
13760 #ifdef VMS
13761           finish_return_stmt (integer_one_node);
13762 #else
13763           finish_return_stmt (integer_zero_node);
13764 #endif
13765         }
13766
13767       /* Finish dealing with exception specifiers.  */
13768       if (flag_exceptions && !processing_template_decl
13769           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13770         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13771                             (TREE_TYPE (current_function_decl)),
13772                             current_eh_spec_try_block);
13773     }
13774   else
13775     {
13776 #if 0
13777       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13778         {
13779           /* Keep this code around in case we later want to control debug info
13780              based on whether a type is "used".  (jason 1999-11-11) */
13781
13782           tree ttype = target_type (fntype);
13783           tree parmdecl;
13784
13785           if (IS_AGGR_TYPE (ttype))
13786             /* Let debugger know it should output info for this type.  */
13787             note_debug_info_needed (ttype);
13788
13789           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13790             {
13791               ttype = target_type (TREE_TYPE (parmdecl));
13792               if (IS_AGGR_TYPE (ttype))
13793                 /* Let debugger know it should output info for this type.  */
13794                 note_debug_info_needed (ttype);
13795             }
13796         }
13797 #endif
13798
13799       /* Clean house because we will need to reorder insns here.  */
13800       do_pending_stack_adjust ();
13801
13802       if (dtor_label)
13803         ;
13804       else if (DECL_CONSTRUCTOR_P (fndecl))
13805         {
13806           if (call_poplevel)
13807             do_poplevel ();
13808         }
13809       else if (return_label != NULL_RTX
13810                && flag_this_is_variable <= 0
13811                && current_function_return_value == NULL_TREE
13812                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13813         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13814
13815       if (flag_exceptions)
13816         expand_exception_blocks ();
13817
13818       /* If this function is supposed to return a value, ensure that
13819          we do not fall into the cleanups by mistake.  The end of our
13820          function will look like this:
13821
13822          user code (may have return stmt somewhere)
13823          goto no_return_label
13824          cleanup_label:
13825          cleanups
13826          goto return_label
13827          no_return_label:
13828          NOTE_INSN_FUNCTION_END
13829          return_label:
13830          things for return
13831
13832          If the user omits a return stmt in the USER CODE section, we
13833          will have a control path which reaches NOTE_INSN_FUNCTION_END.
13834          Otherwise, we won't.  */
13835       if (no_return_label)
13836         {
13837           DECL_CONTEXT (no_return_label) = fndecl;
13838           DECL_INITIAL (no_return_label) = error_mark_node;
13839           DECL_SOURCE_FILE (no_return_label) = input_filename;
13840           DECL_SOURCE_LINE (no_return_label) = lineno;
13841           expand_goto (no_return_label);
13842         }
13843
13844       if (cleanup_label)
13845         {
13846           /* Remove the binding contour which is used
13847              to catch cleanup-generated temporaries.  */
13848           expand_end_bindings (0, 0, 0);
13849           poplevel (0, 0, 0);
13850
13851           /* Emit label at beginning of cleanup code for parameters.  */
13852           emit_label (cleanup_label);
13853         }
13854
13855       /* Get return value into register if that's where it's supposed
13856          to be.  */
13857       if (original_result_rtx)
13858         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
13859
13860       /* Finish building code that will trigger warnings if users forget
13861          to make their functions return values.  */
13862       if (no_return_label || cleanup_label)
13863         emit_jump (return_label);
13864       if (no_return_label)
13865         {
13866           /* We don't need to call `expand_*_return' here because we
13867              don't need any cleanups here--this path of code is only
13868              for error checking purposes.  */
13869           expand_label (no_return_label);
13870         }
13871
13872       /* We hard-wired immediate_size_expand to zero in
13873          start_function.  Expand_function_end will decrement this
13874          variable.  So, we set the variable to one here, so that after
13875          the decrement it will remain zero.  */
13876       immediate_size_expand = 1;
13877
13878       /* Generate rtl for function exit.  */
13879       expand_function_end (input_filename, lineno, 1);
13880     }
13881
13882   /* We have to save this value here in case
13883      maybe_end_member_template_processing decides to pop all the
13884      template parameters.  */
13885   expand_p = !building_stmt_tree ();
13886
13887   /* If we're saving up tree structure, tie off the function now.  */
13888   if (!expand_p)
13889     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13890
13891   /* This must come after expand_function_end because cleanups might
13892      have declarations (from inline functions) that need to go into
13893      this function's blocks.  */
13894   if (doing_semantic_analysis_p ())
13895     {
13896       if (current_binding_level->parm_flag != 1)
13897         my_friendly_abort (122);
13898       poplevel (1, 0, 1);
13899     }
13900
13901   /* Remember that we were in class scope.  */
13902   if (current_class_name)
13903     ctype = current_class_type;
13904
13905   /* Must mark the RESULT_DECL as being in this function.  */
13906   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13907
13908   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13909      to the FUNCTION_DECL node itself.  */
13910   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13911
13912   /* Save away current state, if appropriate.  */
13913   if (!expanding_p && !processing_template_decl)
13914     save_function_data (fndecl);
13915
13916   /* If this function calls `setjmp' it cannot be inlined.  When
13917      `longjmp' is called it is not guaranteed to restore the value of
13918      local variables that have been modified since the call to
13919      `setjmp'.  So, if were to inline this function into some caller
13920      `c', then when we `longjmp', we might not restore all variables
13921      in `c'.  (It might seem, at first blush, that there's no way for
13922      this function to modify local variables in `c', but their
13923      addresses may have been stored somewhere accessible to this
13924      function.)  */
13925   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
13926     DECL_UNINLINABLE (fndecl) = 1;
13927
13928   if (expand_p)
13929     {
13930       int returns_null;
13931       int returns_value;
13932
13933       /* So we can tell if jump_optimize sets it to 1.  */
13934       can_reach_end = 0;
13935
13936       /* Before we call rest_of_compilation (which will pop the
13937          CURRENT_FUNCTION), we must save these values.  */
13938       returns_null = current_function_returns_null;
13939       returns_value = current_function_returns_value;
13940
13941       /* If this is a nested function (like a template instantiation
13942          that we're compiling in the midst of compiling something
13943          else), push a new GC context.  That will keep local variables
13944          on the stack from being collected while we're doing the
13945          compilation of this function.  */
13946       if (function_depth > 1)
13947         ggc_push_context ();
13948
13949       /* Run the optimizers and output the assembler code for this
13950          function.  */
13951       if (DECL_ARTIFICIAL (fndecl))
13952         {
13953           /* Do we really *want* to inline this synthesized method?  */
13954
13955           int save_fif = flag_inline_functions;
13956           flag_inline_functions = 1;
13957
13958           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13959              will check our size.  */
13960           DECL_INLINE (fndecl) = 0;
13961
13962           rest_of_compilation (fndecl);
13963           flag_inline_functions = save_fif;
13964         }
13965       else
13966         rest_of_compilation (fndecl);
13967
13968       /* Undo the call to ggc_push_context above.  */
13969       if (function_depth > 1)
13970         ggc_pop_context ();
13971
13972       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
13973         {
13974           /* Set DECL_EXTERNAL so that assemble_external will be called as
13975              necessary.  We'll clear it again in finish_file.  */
13976           if (! DECL_EXTERNAL (fndecl))
13977             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
13978           DECL_EXTERNAL (fndecl) = 1;
13979           mark_inline_for_output (fndecl);
13980         }
13981
13982 #if 0
13983       /* Keep this code around in case we later want to control debug info
13984          based on whether a type is "used".  (jason 1999-11-11) */
13985
13986       if (ctype && TREE_ASM_WRITTEN (fndecl))
13987         note_debug_info_needed (ctype);
13988 #endif
13989
13990       returns_null |= can_reach_end;
13991
13992       /* Since we don't normally go through c_expand_return for constructors,
13993          this normally gets the wrong value.
13994          Also, named return values have their return codes emitted after
13995          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
13996       if (DECL_CONSTRUCTOR_P (fndecl)
13997           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
13998         returns_null = 0;
13999
14000       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14001         cp_warning ("`noreturn' function `%D' does return", fndecl);
14002       else if ((warn_return_type || pedantic)
14003                && returns_null
14004                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14005         {
14006           /* If this function returns non-void and control can drop through,
14007              complain.  */
14008           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14009         }
14010       /* With just -W, complain only if function returns both with
14011          and without a value.  */
14012       else if (extra_warnings && returns_value && returns_null)
14013         warning ("this function may return with or without a value");
14014     }
14015   else
14016     {
14017       /* Clear out memory we no longer need.  */
14018       free_after_parsing (cfun);
14019       /* Since we never call rest_of_compilation, we never clear
14020          CFUN.  Do so explicitly.  */
14021       free_after_compilation (cfun);
14022       cfun = NULL;
14023     }
14024
14025   /* If this is a in-class inline definition, we may have to pop the
14026      bindings for the template parameters that we added in
14027      maybe_begin_member_template_processing when start_function was
14028      called.  */
14029   if (inclass_inline)
14030     maybe_end_member_template_processing ();
14031
14032   /* Leave the scope of the class.  */
14033   if (ctype)
14034     pop_nested_class ();
14035
14036   --function_depth;
14037
14038   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14039       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14040     {
14041       tree t;
14042
14043       /* Stop pointing to the local nodes about to be freed.  */
14044       /* But DECL_INITIAL must remain nonzero so we know this
14045          was an actual function definition.  */
14046       DECL_INITIAL (fndecl) = error_mark_node;
14047       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14048         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14049     }
14050
14051   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14052     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14053   if (DECL_STATIC_DESTRUCTOR (fndecl))
14054     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14055
14056   /* Clean up.  */
14057   if (! nested)
14058     {
14059       /* Let the error reporting routines know that we're outside a
14060          function.  For a nested function, this value is used in
14061          pop_cp_function_context and then reset via pop_function_context.  */
14062       current_function_decl = NULL_TREE;
14063       /* We don't really care about obstacks, but the middle-end
14064          sometimes cares on what obstck things are located.  */
14065       permanent_allocation (1);
14066     }
14067
14068   return fndecl;
14069 }
14070 \f
14071 /* Create the FUNCTION_DECL for a function definition.
14072    DECLSPECS and DECLARATOR are the parts of the declaration;
14073    they describe the return type and the name of the function,
14074    but twisted together in a fashion that parallels the syntax of C.
14075
14076    This function creates a binding context for the function body
14077    as well as setting up the FUNCTION_DECL in current_function_decl.
14078
14079    Returns a FUNCTION_DECL on success.
14080
14081    If the DECLARATOR is not suitable for a function (it defines a datum
14082    instead), we return 0, which tells yyparse to report a parse error.
14083
14084    May return void_type_node indicating that this method is actually
14085    a friend.  See grokfield for more details.
14086
14087    Came here with a `.pushlevel' .
14088
14089    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14090    CHANGES TO CODE IN `grokfield'.  */
14091
14092 tree
14093 start_method (declspecs, declarator, attrlist)
14094      tree declarator, declspecs, attrlist;
14095 {
14096   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14097                                 attrlist);
14098
14099   /* Something too ugly to handle.  */
14100   if (fndecl == NULL_TREE)
14101     return NULL_TREE;
14102
14103   /* Pass friends other than inline friend functions back.  */
14104   if (fndecl == void_type_node)
14105     return fndecl;
14106
14107   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14108     /* Not a function, tell parser to report parse error.  */
14109     return NULL_TREE;
14110
14111   if (DECL_IN_AGGR_P (fndecl))
14112     {
14113       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14114         {
14115           if (DECL_CONTEXT (fndecl)
14116               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14117             cp_error ("`%D' is already defined in class %s", fndecl,
14118                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14119         }
14120       return void_type_node;
14121     }
14122
14123   check_template_shadow (fndecl);
14124
14125   DECL_THIS_INLINE (fndecl) = 1;
14126
14127   if (flag_default_inline)
14128     DECL_INLINE (fndecl) = 1;
14129
14130   /* We process method specializations in finish_struct_1.  */
14131   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14132     fndecl = push_template_decl (fndecl);
14133
14134   /* We read in the parameters on the maybepermanent_obstack,
14135      but we won't be getting back to them until after we
14136      may have clobbered them.  So the call to preserve_data
14137      will keep them safe.  */
14138   preserve_data ();
14139
14140   if (! DECL_FRIEND_P (fndecl))
14141     {
14142       if (TREE_CHAIN (fndecl))
14143         {
14144           fndecl = copy_node (fndecl);
14145           TREE_CHAIN (fndecl) = NULL_TREE;
14146         }
14147
14148       if (DECL_CONSTRUCTOR_P (fndecl))
14149         {
14150           if (! grok_ctor_properties (current_class_type, fndecl))
14151             return void_type_node;
14152         }
14153       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14154         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14155     }
14156
14157   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14158
14159   /* Make a place for the parms */
14160   pushlevel (0);
14161   current_binding_level->parm_flag = 1;
14162
14163   DECL_IN_AGGR_P (fndecl) = 1;
14164   return fndecl;
14165 }
14166
14167 /* Go through the motions of finishing a function definition.
14168    We don't compile this method until after the whole class has
14169    been processed.
14170
14171    FINISH_METHOD must return something that looks as though it
14172    came from GROKFIELD (since we are defining a method, after all).
14173
14174    This is called after parsing the body of the function definition.
14175    STMTS is the chain of statements that makes up the function body.
14176
14177    DECL is the ..._DECL that `start_method' provided.  */
14178
14179 tree
14180 finish_method (decl)
14181      tree decl;
14182 {
14183   register tree fndecl = decl;
14184   tree old_initial;
14185
14186   register tree link;
14187
14188   if (decl == void_type_node)
14189     return decl;
14190
14191   old_initial = DECL_INITIAL (fndecl);
14192
14193   /* Undo the level for the parms (from start_method).
14194      This is like poplevel, but it causes nothing to be
14195      saved.  Saving information here confuses symbol-table
14196      output routines.  Besides, this information will
14197      be correctly output when this method is actually
14198      compiled.  */
14199
14200   /* Clear out the meanings of the local variables of this level;
14201      also record in each decl which block it belongs to.  */
14202
14203   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14204     {
14205       if (DECL_NAME (link) != NULL_TREE)
14206         pop_binding (DECL_NAME (link), link);
14207       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14208       DECL_CONTEXT (link) = NULL_TREE;
14209     }
14210
14211   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14212                       (HOST_WIDE_INT) current_binding_level->level_chain,
14213                       current_binding_level->parm_flag,
14214                       current_binding_level->keep);
14215
14216   poplevel (0, 0, 0);
14217
14218   DECL_INITIAL (fndecl) = old_initial;
14219
14220   /* We used to check if the context of FNDECL was different from
14221      current_class_type as another way to get inside here.  This didn't work
14222      for String.cc in libg++.  */
14223   if (DECL_FRIEND_P (fndecl))
14224     {
14225       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14226         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14227       decl = void_type_node;
14228     }
14229
14230   return decl;
14231 }
14232 \f
14233 /* Called when a new struct TYPE is defined.
14234    If this structure or union completes the type of any previous
14235    variable declaration, lay it out and output its rtl.  */
14236
14237 void
14238 hack_incomplete_structures (type)
14239      tree type;
14240 {
14241   tree *list;
14242   struct binding_level *level;
14243
14244   if (!type) /* Don't do this for class templates.  */
14245     return;
14246
14247   if (namespace_bindings_p ())
14248     {
14249       level = 0;
14250       list = &namespace_scope_incomplete;
14251     }
14252   else
14253     {
14254       level = innermost_nonclass_level ();
14255       list = &level->incomplete;
14256     }
14257
14258   while (1)
14259     {
14260       while (*list)
14261         {
14262           tree decl = TREE_VALUE (*list);
14263           if ((decl && TREE_TYPE (decl) == type)
14264               || (TREE_TYPE (decl)
14265                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14266                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14267             {
14268               int toplevel = toplevel_bindings_p ();
14269               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14270                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14271                 layout_type (TREE_TYPE (decl));
14272               layout_decl (decl, 0);
14273               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14274               if (! toplevel)
14275                 {
14276                   tree cleanup;
14277                   expand_decl (decl);
14278                   cleanup = maybe_build_cleanup (decl);
14279                   expand_decl_init (decl);
14280                   if (! expand_decl_cleanup (decl, cleanup))
14281                     cp_error ("parser lost in parsing declaration of `%D'",
14282                               decl);
14283                 }
14284               *list = TREE_CHAIN (*list);
14285             }
14286           else
14287             list = &TREE_CHAIN (*list);
14288         }
14289
14290       /* Keep looking through artificial binding levels generated
14291          for local variables.  */
14292       if (level && level->keep == 2)
14293         {
14294           level = level->level_chain;
14295           list = &level->incomplete;
14296         }
14297       else
14298         break;
14299     }
14300 }
14301
14302 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14303    See build_delete for information about AUTO_DELETE.
14304
14305    Don't build these on the momentary obstack; they must live
14306    the life of the binding contour.  */
14307
14308 static tree
14309 maybe_build_cleanup_1 (decl, auto_delete)
14310      tree decl, auto_delete;
14311 {
14312   tree type = TREE_TYPE (decl);
14313   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14314     {
14315       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14316       tree rval;
14317
14318       if (TREE_CODE (type) == ARRAY_TYPE)
14319         rval = decl;
14320       else
14321         {
14322           mark_addressable (decl);
14323           rval = build_unary_op (ADDR_EXPR, decl, 0);
14324         }
14325
14326       /* Optimize for space over speed here.  */
14327       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14328           || flag_expensive_optimizations)
14329         flags |= LOOKUP_NONVIRTUAL;
14330
14331       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14332
14333       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14334           && ! TYPE_HAS_DESTRUCTOR (type))
14335         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14336                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14337
14338       return rval;
14339     }
14340   return 0;
14341 }
14342
14343 /* If DECL is of a type which needs a cleanup, build that cleanup
14344    here.  The cleanup does free the storage with a call to delete.  */
14345
14346 tree
14347 maybe_build_cleanup_and_delete (decl)
14348      tree decl;
14349 {
14350   return maybe_build_cleanup_1 (decl, integer_three_node);
14351 }
14352
14353 /* If DECL is of a type which needs a cleanup, build that cleanup
14354    here.  The cleanup does not free the storage with a call a delete.  */
14355
14356 tree
14357 maybe_build_cleanup (decl)
14358      tree decl;
14359 {
14360   return maybe_build_cleanup_1 (decl, integer_two_node);
14361 }
14362 \f
14363 /* Expand a C++ expression at the statement level.
14364    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14365    The C++ type checker should get all of these out when
14366    expressions are combined with other, type-providing, expressions,
14367    leaving only orphan expressions, such as:
14368
14369    &class::bar;         / / takes its address, but does nothing with it.  */
14370
14371 void
14372 cplus_expand_expr_stmt (exp)
14373      tree exp;
14374 {
14375   if (stmts_are_full_exprs_p)
14376     exp = convert_to_void (exp, "statement");
14377
14378 #if 0
14379   /* We should do this eventually, but right now this causes regex.o from
14380      libg++ to miscompile, and tString to core dump.  */
14381   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14382 #endif
14383
14384   /* If we don't do this, we end up down inside expand_expr
14385      trying to do TYPE_MODE on the ERROR_MARK, and really
14386      go outside the bounds of the type.  */
14387   if (exp != error_mark_node)
14388     expand_expr_stmt (exp);
14389 }
14390
14391 /* When a stmt has been parsed, this function is called.  */
14392
14393 void
14394 finish_stmt ()
14395 {
14396   /* Always assume this statement was not an expression statement.  If
14397      it actually was an expression statement, its our callers
14398      responsibility to fix this up.  */
14399   last_expr_type = NULL_TREE;
14400 }
14401
14402 /* Change a static member function definition into a FUNCTION_TYPE, instead
14403    of the METHOD_TYPE that we create when it's originally parsed.
14404
14405    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14406    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14407    other decls.  Either pass the addresses of local variables or NULL.  */
14408
14409 void
14410 revert_static_member_fn (decl, fn, argtypes)
14411      tree *decl, *fn, *argtypes;
14412 {
14413   tree tmp;
14414   tree function = fn ? *fn : TREE_TYPE (*decl);
14415   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14416
14417   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14418       != TYPE_UNQUALIFIED)
14419     cp_error ("static member function `%#D' declared with type qualifiers",
14420               *decl);
14421
14422   args = TREE_CHAIN (args);
14423   tmp = build_function_type (TREE_TYPE (function), args);
14424   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14425   tmp = build_exception_variant (tmp,
14426                                  TYPE_RAISES_EXCEPTIONS (function));
14427   TREE_TYPE (*decl) = tmp;
14428   if (DECL_ARGUMENTS (*decl))
14429     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14430   DECL_STATIC_FUNCTION_P (*decl) = 1;
14431   if (fn)
14432     *fn = tmp;
14433   if (argtypes)
14434     *argtypes = args;
14435 }
14436
14437 /* Initialize the variables used during compilation of a C++
14438    function.  */
14439
14440 static void
14441 push_cp_function_context (f)
14442      struct function *f;
14443 {
14444   struct language_function *p
14445     = ((struct language_function *)
14446        xcalloc (1, sizeof (struct language_function)));
14447   f->language = p;
14448
14449   /* It takes an explicit call to expand_body to generate RTL for a
14450      function.  */
14451   expanding_p = 0;
14452
14453   /* Whenever we start a new function, we destroy temporaries in the
14454      usual way.  */
14455   stmts_are_full_exprs_p = 1;
14456 }
14457
14458 /* Free the language-specific parts of F, now that we've finished
14459    compiling the function.  */
14460
14461 static void
14462 pop_cp_function_context (f)
14463      struct function *f;
14464 {
14465   if (f->language)
14466     free (f->language);
14467   f->language = 0;
14468 }
14469
14470 /* Mark P for GC.  */
14471
14472 static void
14473 mark_lang_function (p)
14474      struct language_function *p;
14475 {
14476   if (!p)
14477     return;
14478
14479   ggc_mark_tree (p->x_named_labels);
14480   ggc_mark_tree (p->x_ctor_label);
14481   ggc_mark_tree (p->x_dtor_label);
14482   ggc_mark_tree (p->x_base_init_list);
14483   ggc_mark_tree (p->x_member_init_list);
14484   ggc_mark_tree (p->x_current_class_ptr);
14485   ggc_mark_tree (p->x_current_class_ref);
14486   ggc_mark_tree (p->x_eh_spec_try_block);
14487   ggc_mark_tree (p->x_scope_stmt_stack);
14488
14489   ggc_mark_rtx (p->x_result_rtx);
14490
14491   mark_stmt_tree (&p->x_stmt_tree);
14492   mark_binding_level (&p->bindings);
14493 }
14494
14495 /* Mark the language-specific data in F for GC.  */
14496
14497 static void
14498 mark_cp_function_context (f)
14499      struct function *f;
14500 {
14501   mark_lang_function (f->language);
14502 }
14503
14504 int
14505 in_function_p ()
14506 {
14507   return function_depth != 0;
14508 }
14509
14510
14511 void
14512 lang_mark_false_label_stack (l)
14513      struct label_node *l;
14514 {
14515   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14516   my_friendly_assert (l == NULL, 19990904);
14517 }
14518
14519 void
14520 lang_mark_tree (t)
14521      tree t;
14522 {
14523   enum tree_code code = TREE_CODE (t);
14524   if (code == IDENTIFIER_NODE)
14525     {
14526       struct lang_identifier *li = (struct lang_identifier *) t;
14527       struct lang_id2 *li2 = li->x;
14528       ggc_mark_tree (li->namespace_bindings);
14529       ggc_mark_tree (li->bindings);
14530       ggc_mark_tree (li->class_value);
14531       ggc_mark_tree (li->class_template_info);
14532
14533       if (li2)
14534         {
14535           ggc_mark_tree (li2->label_value);
14536           ggc_mark_tree (li2->implicit_decl);
14537           ggc_mark_tree (li2->error_locus);
14538         }
14539     }
14540   else if (code == CPLUS_BINDING)
14541     {
14542       if (BINDING_HAS_LEVEL_P (t))
14543         mark_binding_level (&BINDING_LEVEL (t));
14544       else
14545         ggc_mark_tree (BINDING_SCOPE (t));
14546       ggc_mark_tree (BINDING_VALUE (t));
14547     }
14548   else if (code == OVERLOAD)
14549     ggc_mark_tree (OVL_FUNCTION (t));
14550   else if (code == TEMPLATE_PARM_INDEX)
14551     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14552   else if (TREE_CODE_CLASS (code) == 'd')
14553     {
14554       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14555
14556       if (ld)
14557         {
14558           ggc_mark (ld);
14559           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14560             ggc_mark_tree (ld->decl_flags.u2.access);
14561           ggc_mark_tree (ld->decl_flags.context);
14562           if (TREE_CODE (t) != NAMESPACE_DECL)
14563             ggc_mark_tree (ld->decl_flags.u.template_info);
14564           else
14565             mark_binding_level (&NAMESPACE_LEVEL (t));
14566           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14567             {
14568               ggc_mark_tree (ld->main_decl_variant);
14569               ggc_mark_tree (ld->befriending_classes);
14570               ggc_mark_tree (ld->saved_tree);
14571               if (TREE_CODE (t) == TYPE_DECL)
14572                 ggc_mark_tree (ld->u.sorted_fields);
14573               else if (TREE_CODE (t) == FUNCTION_DECL
14574                        && !DECL_PENDING_INLINE_P (t))
14575                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14576             }
14577         }
14578     }
14579   else if (TREE_CODE_CLASS (code) == 't')
14580     {
14581       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14582
14583       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14584                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14585         {
14586           ggc_mark (lt);
14587           ggc_mark_tree (lt->vfields);
14588           ggc_mark_tree (lt->vbases);
14589           ggc_mark_tree (lt->tags);
14590           ggc_mark_tree (lt->search_slot);
14591           ggc_mark_tree (lt->size);
14592           ggc_mark_tree (lt->pure_virtuals);
14593           ggc_mark_tree (lt->friend_classes);
14594           ggc_mark_tree (lt->rtti);
14595           ggc_mark_tree (lt->methods);
14596           ggc_mark_tree (lt->template_info);
14597           ggc_mark_tree (lt->befriending_classes);
14598         }
14599       else if (lt)
14600         /* In the case of pointer-to-member function types, the
14601            TYPE_LANG_SPECIFIC is really just a tree.  */
14602         ggc_mark_tree ((tree) lt);
14603     }
14604 }