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    2001, 2002  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "tree-inline.h"
  39 #include "decl.h"
  40 #include "lex.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "ggc.h"
  46 #include "tm_p.h"
  47 #include "target.h"
  48 #include "c-common.h"
  49 #include "c-pragma.h"
  50 #include "diagnostic.h"
  51
  52 extern const struct attribute_spec *lang_attribute_table;
  53
  54 static tree grokparms                           PARAMS ((tree));
  55 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  56
  57 static void push_binding_level PARAMS ((struct binding_level *, int,
  58                                       int));
  59 static void pop_binding_level PARAMS ((void));
  60 static void suspend_binding_level PARAMS ((void));
  61 static void resume_binding_level PARAMS ((struct binding_level *));
  62 static struct binding_level *make_binding_level PARAMS ((void));
  63 static void declare_namespace_level PARAMS ((void));
  64 static int decl_jump_unsafe PARAMS ((tree));
  65 static void storedecls PARAMS ((tree));
  66 static void require_complete_types_for_parms PARAMS ((tree));
  67 static int ambi_op_p PARAMS ((enum tree_code));
  68 static int unary_op_p PARAMS ((enum tree_code));
  69 static tree store_bindings PARAMS ((tree, tree));
  70 static tree lookup_tag_reverse PARAMS ((tree, tree));
  71 static tree obscure_complex_init PARAMS ((tree, tree));
  72 static tree lookup_name_real PARAMS ((tree, int, int, int));
  73 static void push_local_name PARAMS ((tree));
  74 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  75 static tree grok_reference_init PARAMS ((tree, tree, tree));
  76 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  77                               enum overload_flags, tree,
  78                               tree, int, int, int, int, int, int, tree));
  79 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  80 static tree follow_tag_typedef PARAMS ((tree));
  81 static tree lookup_tag PARAMS ((enum tree_code, tree,
  82                               struct binding_level *, int));
  83 static void set_identifier_type_value_with_scope
  84         PARAMS ((tree, tree, struct binding_level *));
  85 static void record_unknown_type PARAMS ((tree, const char *));
  86 static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
  87                                       enum built_in_class, const char *));
  88 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  89 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  90 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  91                                   int));
  92 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  93 static void check_for_uninitialized_const_var PARAMS ((tree));
  94 static unsigned long typename_hash PARAMS ((hash_table_key));
  95 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  96 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  97 static int add_binding PARAMS ((tree, tree));
  98 static void pop_binding PARAMS ((tree, tree));
  99 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 100 static tree find_binding PARAMS ((tree, tree));
 101 static tree select_decl PARAMS ((tree, int));
 102 static int lookup_flags PARAMS ((int, int));
 103 static tree qualify_lookup PARAMS ((tree, int));
 104 static tree record_builtin_java_type PARAMS ((const char *, int));
 105 static const char *tag_name PARAMS ((enum tag_types code));
 106 static void find_class_binding_level PARAMS ((void));
 107 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 108 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 109 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 110 static int walk_globals_r PARAMS ((tree, void *));
 111 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 112 static tree make_label_decl PARAMS ((tree, int));
 113 static void use_label PARAMS ((tree));
 114 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 115                                            const char *, int));
 116 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 117 static void check_switch_goto PARAMS ((struct binding_level *));
 118 static void check_previous_gotos PARAMS ((tree));
 119 static void pop_label PARAMS ((tree, tree));
 120 static void pop_labels PARAMS ((tree));
 121 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 122 static void layout_var_decl PARAMS ((tree));
 123 static void maybe_commonize_var PARAMS ((tree));
 124 static tree check_initializer PARAMS ((tree, tree));
 125 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 126 static void push_cp_function_context PARAMS ((struct function *));
 127 static void pop_cp_function_context PARAMS ((struct function *));
 128 static void mark_binding_level PARAMS ((void *));
 129 static void mark_named_label_lists PARAMS ((void *, void *));
 130 static void mark_cp_function_context PARAMS ((struct function *));
 131 static void mark_saved_scope PARAMS ((void *));
 132 static void mark_lang_function PARAMS ((struct cp_language_function *));
 133 static void save_function_data PARAMS ((tree));
 134 static void check_function_type PARAMS ((tree, tree));
 135 static void destroy_local_var PARAMS ((tree));
 136 static void begin_constructor_body PARAMS ((void));
 137 static void finish_constructor_body PARAMS ((void));
 138 static void begin_destructor_body PARAMS ((void));
 139 static void finish_destructor_body PARAMS ((void));
 140 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 141 static tree get_atexit_node PARAMS ((void));
 142 static tree get_dso_handle_node PARAMS ((void));
 143 static tree start_cleanup_fn PARAMS ((void));
 144 static void end_cleanup_fn PARAMS ((void));
 145 static tree cp_make_fname_decl PARAMS ((tree, int));
 146 static void initialize_predefined_identifiers PARAMS ((void));
 147 static tree check_special_function_return_type
 148   PARAMS ((special_function_kind, tree, tree));
 149 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 150 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 151 static void store_parm_decls PARAMS ((tree));
 152 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 153
 154 #if defined (DEBUG_CP_BINDING_LEVELS)
 155 static void indent PARAMS ((void));
 156 #endif
 157
 158 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 159 tree error_mark_list;
 160
 161 /* The following symbols are subsumed in the cp_global_trees array, and
 162    listed here individually for documentation purposes.
 163
 164    C++ extensions
 165         tree wchar_decl_node;
 166
 167         tree vtable_entry_type;
 168         tree delta_type_node;
 169         tree __t_desc_type_node;
 170         tree ti_desc_type_node;
 171         tree bltn_desc_type_node, ptr_desc_type_node;
 172         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 173         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 174         tree ptm_desc_type_node;
 175         tree base_desc_type_node;
 176
 177         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 178         tree unknown_type_node;
 179
 180    Array type `vtable_entry_type[]'
 181
 182         tree vtbl_type_node;
 183         tree vtbl_ptr_type_node;
 184
 185    Namespaces,
 186
 187         tree std_node;
 188         tree abi_node;
 189
 190    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 191    one that the user will declare, but sufficient to be called
 192    by routines that want to abort the program.
 193
 194         tree abort_fndecl;
 195
 196    The FUNCTION_DECL for the default `::operator delete'.
 197
 198         tree global_delete_fndecl;
 199
 200    Used by RTTI
 201         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 202         tree tinfo_var_id;
 203
 204 */
 205
 206 tree cp_global_trees[CPTI_MAX];
 207
 208 /* Indicates that there is a type value in some namespace, although
 209    that is not necessarily in scope at the moment.  */
 210
 211 static tree global_type_node;
 212
 213 /* Expect only namespace names now. */
 214 static int only_namespace_names;
 215
 216 /* Used only for jumps to as-yet undefined labels, since jumps to
 217    defined labels can have their validity checked immediately.  */
 218
 219 struct named_label_use_list
 220 {
 221   struct binding_level *binding_level;
 222   tree names_in_scope;
 223   tree label_decl;
 224   const char *filename_o_goto;
 225   int lineno_o_goto;
 226   struct named_label_use_list *next;
 227 };
 228
 229 #define named_label_uses cp_function_chain->x_named_label_uses
 230
 231 #define local_names cp_function_chain->x_local_names
 232
 233 /* A list of objects which have constructors or destructors
 234    which reside in the global scope.  The decl is stored in
 235    the TREE_VALUE slot and the initializer is stored
 236    in the TREE_PURPOSE slot.  */
 237 tree static_aggregates;
 238
 239 /* -- end of C++ */
 240
 241 /* A node for the integer constants 2, and 3.  */
 242
 243 tree integer_two_node, integer_three_node;
 244
 245 /* Similar, for last_function_parm_tags.  */
 246 tree last_function_parms;
 247
 248 /* A list of all LABEL_DECLs in the function that have names.  Here so
 249    we can clear out their names' definitions at the end of the
 250    function, and so we can check the validity of jumps to these labels.  */
 251
 252 struct named_label_list
 253 {
 254   struct binding_level *binding_level;
 255   tree names_in_scope;
 256   tree old_value;
 257   tree label_decl;
 258   tree bad_decls;
 259   struct named_label_list *next;
 260   unsigned int in_try_scope : 1;
 261   unsigned int in_catch_scope : 1;
 262 };
 263
 264 #define named_labels cp_function_chain->x_named_labels
 265
 266 /* Nonzero means use the ISO C94 dialect of C.  */
 267
 268 int flag_isoc94;
 269
 270 /* Nonzero means use the ISO C99 dialect of C.  */
 271
 272 int flag_isoc99;
 273
 274 /* Nonzero means we are a hosted implementation for code shared with C.  */
 275
 276 int flag_hosted = 1;
 277
 278 /* Nonzero means add default format_arg attributes for functions not
 279    in ISO C.  */
 280
 281 int flag_noniso_default_format_attributes = 1;
 282
 283 /* Nonzero if we want to conserve space in the .o files.  We do this
 284    by putting uninitialized data and runtime initialized data into
 285    .common instead of .data at the expense of not flagging multiple
 286    definitions.  */
 287 extern int flag_conserve_space;
 288 \f
 289 /* C and C++ flags are in decl2.c.  */
 290
 291 /* A expression of value 0 with the same precision as a sizetype
 292    node, but signed.  */
 293 tree signed_size_zero_node;
 294
 295 /* The name of the anonymous namespace, throughout this translation
 296    unit.  */
 297 tree anonymous_namespace_name;
 298
 299 /* The number of function bodies which we are currently processing.
 300    (Zero if we are at namespace scope, one inside the body of a
 301    function, two inside the body of a function in a local class, etc.)  */
 302 int function_depth;
 303
 304 /* States indicating how grokdeclarator() should handle declspecs marked
 305    with __attribute__((deprecated)).  An object declared as
 306    __attribute__((deprecated)) suppresses warnings of uses of other
 307    deprecated items.  */
 308
 309 enum deprecated_states {
 310   DEPRECATED_NORMAL,
 311   DEPRECATED_SUPPRESS
 312 };
 313
 314 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 315
 316 /* Set by add_implicitly_declared_members() to keep those members from
 317    being flagged as deprecated or reported as using deprecated
 318    types.  */
 319 int adding_implicit_members = 0;
 320 \f
 321 /* For each binding contour we allocate a binding_level structure
 322    which records the names defined in that contour.
 323    Contours include:
 324     0) the global one
 325     1) one for each function definition,
 326        where internal declarations of the parameters appear.
 327     2) one for each compound statement,
 328        to record its declarations.
 329
 330    The current meaning of a name can be found by searching the levels
 331    from the current one out to the global one.
 332
 333    Off to the side, may be the class_binding_level.  This exists only
 334    to catch class-local declarations.  It is otherwise nonexistent.
 335
 336    Also there may be binding levels that catch cleanups that must be
 337    run when exceptions occur.  Thus, to see whether a name is bound in
 338    the current scope, it is not enough to look in the
 339    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 340    instead.  */
 341
 342 /* Note that the information in the `names' component of the global contour
 343    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 344
 345 struct binding_level
 346   {
 347     /* A chain of _DECL nodes for all variables, constants, functions,
 348        and typedef types.  These are in the reverse of the order
 349        supplied.  There may be OVERLOADs on this list, too, but they
 350        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 351     tree names;
 352
 353     /* A list of structure, union and enum definitions, for looking up
 354        tag names.
 355        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 356        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 357        or ENUMERAL_TYPE node.
 358
 359        C++: the TREE_VALUE nodes can be simple types for
 360        component_bindings.  */
 361     tree tags;
 362
 363     /* A list of USING_DECL nodes. */
 364     tree usings;
 365
 366     /* A list of used namespaces. PURPOSE is the namespace,
 367        VALUE the common ancestor with this binding_level's namespace. */
 368     tree using_directives;
 369
 370     /* If this binding level is the binding level for a class, then
 371        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 372        is the name of an entity bound in the class.  The TREE_TYPE is
 373        the DECL bound by this name in the class.  */
 374     tree class_shadowed;
 375
 376     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 377        is used for all binding levels. In addition the TREE_VALUE is the
 378        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 379     tree type_shadowed;
 380
 381     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 382        label in this scope.  The TREE_PURPOSE is the previous value of
 383        the IDENTIFIER_LABEL VALUE.  */
 384     tree shadowed_labels;
 385
 386     /* For each level (except not the global one),
 387        a chain of BLOCK nodes for all the levels
 388        that were entered and exited one level down.  */
 389     tree blocks;
 390
 391     /* The _TYPE node for this level, if parm_flag == 2.  */
 392     tree this_class;
 393
 394     /* The binding level which this one is contained in (inherits from).  */
 395     struct binding_level *level_chain;
 396
 397     /* List of VAR_DECLS saved from a previous for statement.
 398        These would be dead in ISO-conforming code, but might
 399        be referenced in ARM-era code.  These are stored in a
 400        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 401     tree dead_vars_from_for;
 402
 403     /* 1 for the level that holds the parameters of a function.
 404        2 for the level that holds a class declaration.  */
 405     unsigned parm_flag : 2;
 406
 407     /* 1 means make a BLOCK for this level regardless of all else.
 408        2 for temporary binding contours created by the compiler.  */
 409     unsigned keep : 2;
 410
 411     /* Nonzero if this level "doesn't exist" for tags.  */
 412     unsigned tag_transparent : 1;
 413
 414     /* Nonzero if this level can safely have additional
 415        cleanup-needing variables added to it.  */
 416     unsigned more_cleanups_ok : 1;
 417     unsigned have_cleanups : 1;
 418
 419     /* Nonzero if this scope is for storing the decls for template
 420        parameters and generic decls; these decls will be discarded and
 421        replaced with a TEMPLATE_DECL.  */
 422     unsigned template_parms_p : 1;
 423
 424     /* Nonzero if this scope corresponds to the `<>' in a
 425        `template <>' clause.  Whenever this flag is set,
 426        TEMPLATE_PARMS_P will be set as well.  */
 427     unsigned template_spec_p : 1;
 428
 429     /* This is set for a namespace binding level.  */
 430     unsigned namespace_p : 1;
 431
 432     /* True if this level is that of a for-statement where we need to
 433        worry about ambiguous (ARM or ISO) scope rules.  */
 434     unsigned is_for_scope : 1;
 435
 436     /* True if this level corresponds to a TRY block.  Currently this
 437        information is only available while building the tree structure.  */
 438     unsigned is_try_scope : 1;
 439
 440     /* True if this level corresponds to a CATCH block.  Currently this
 441        information is only available while building the tree structure.  */
 442     unsigned is_catch_scope : 1;
 443
 444     /* Three bits left for this word.  */
 445
 446 #if defined(DEBUG_CP_BINDING_LEVELS)
 447     /* Binding depth at which this level began.  */
 448     unsigned binding_depth;
 449 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 450   };
 451
 452 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 453
 454 /* The binding level currently in effect.  */
 455
 456 #define current_binding_level                   \
 457   (cfun && cp_function_chain->bindings          \
 458    ? cp_function_chain->bindings                \
 459    : scope_chain->bindings)
 460
 461 /* The binding level of the current class, if any.  */
 462
 463 #define class_binding_level scope_chain->class_bindings
 464
 465 /* A chain of binding_level structures awaiting reuse.  */
 466
 467 static struct binding_level *free_binding_level;
 468
 469 /* The outermost binding level, for names of file scope.
 470    This is created when the compiler is started and exists
 471    through the entire run.  */
 472
 473 static struct binding_level *global_binding_level;
 474
 475 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 476
 477 static int keep_next_level_flag;
 478
 479 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 480    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 481    time the VAR_DECL was declared, the type was incomplete.  */
 482
 483 static tree incomplete_vars;
 484
 485 #if defined(DEBUG_CP_BINDING_LEVELS)
 486 static int binding_depth = 0;
 487 static int is_class_level = 0;
 488
 489 static void
 490 indent ()
 491 {
 492   register unsigned i;
 493
 494   for (i = 0; i < binding_depth*2; i++)
 495     putc (' ', stderr);
 496 }
 497 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 498
 499 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 500
 501 static void
 502 push_binding_level (newlevel, tag_transparent, keep)
 503      struct binding_level *newlevel;
 504      int tag_transparent, keep;
 505 {
 506   /* Add this level to the front of the chain (stack) of levels that
 507      are active.  */
 508   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 509   newlevel->level_chain = current_binding_level;
 510   current_binding_level = newlevel;
 511   newlevel->tag_transparent = tag_transparent;
 512   newlevel->more_cleanups_ok = 1;
 513
 514   newlevel->keep = keep;
 515 #if defined(DEBUG_CP_BINDING_LEVELS)
 516   newlevel->binding_depth = binding_depth;
 517   indent ();
 518   fprintf (stderr, "push %s level 0x%08x line %d\n",
 519            (is_class_level) ? "class" : "block", newlevel, lineno);
 520   is_class_level = 0;
 521   binding_depth++;
 522 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 523 }
 524
 525 /* Find the innermost enclosing class scope, and reset
 526    CLASS_BINDING_LEVEL appropriately.  */
 527
 528 static void
 529 find_class_binding_level ()
 530 {
 531   struct binding_level *level = current_binding_level;
 532
 533   while (level && level->parm_flag != 2)
 534     level = level->level_chain;
 535   if (level && level->parm_flag == 2)
 536     class_binding_level = level;
 537   else
 538     class_binding_level = 0;
 539 }
 540
 541 static void
 542 pop_binding_level ()
 543 {
 544   if (global_binding_level)
 545     {
 546       /* Cannot pop a level, if there are none left to pop.  */
 547       if (current_binding_level == global_binding_level)
 548         abort ();
 549     }
 550   /* Pop the current level, and free the structure for reuse.  */
 551 #if defined(DEBUG_CP_BINDING_LEVELS)
 552   binding_depth--;
 553   indent ();
 554   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 555           (is_class_level) ? "class" : "block",
 556           current_binding_level, lineno);
 557   if (is_class_level != (current_binding_level == class_binding_level))
 558     {
 559       indent ();
 560       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 561     }
 562   is_class_level = 0;
 563 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 564   {
 565     register struct binding_level *level = current_binding_level;
 566     current_binding_level = current_binding_level->level_chain;
 567     level->level_chain = free_binding_level;
 568 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 569     if (level->binding_depth != binding_depth)
 570       abort ();
 571 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 572     free_binding_level = level;
 573     find_class_binding_level ();
 574   }
 575 }
 576
 577 static void
 578 suspend_binding_level ()
 579 {
 580   if (class_binding_level)
 581     current_binding_level = class_binding_level;
 582
 583   if (global_binding_level)
 584     {
 585       /* Cannot suspend a level, if there are none left to suspend.  */
 586       if (current_binding_level == global_binding_level)
 587         abort ();
 588     }
 589   /* Suspend the current level.  */
 590 #if defined(DEBUG_CP_BINDING_LEVELS)
 591   binding_depth--;
 592   indent ();
 593   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 594           (is_class_level) ? "class" : "block",
 595           current_binding_level, lineno);
 596   if (is_class_level != (current_binding_level == class_binding_level))
 597     {
 598       indent ();
 599       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 600     }
 601   is_class_level = 0;
 602 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 603   current_binding_level = current_binding_level->level_chain;
 604   find_class_binding_level ();
 605 }
 606
 607 static void
 608 resume_binding_level (b)
 609      struct binding_level *b;
 610 {
 611   /* Resuming binding levels is meant only for namespaces,
 612      and those cannot nest into classes. */
 613   my_friendly_assert(!class_binding_level, 386);
 614   /* Also, resuming a non-directly nested namespace is a no-no.  */
 615   my_friendly_assert(b->level_chain == current_binding_level, 386);
 616   current_binding_level = b;
 617 #if defined(DEBUG_CP_BINDING_LEVELS)
 618   b->binding_depth = binding_depth;
 619   indent ();
 620   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 621            (is_class_level) ? "class" : "block", b, lineno);
 622   is_class_level = 0;
 623   binding_depth++;
 624 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 625 }
 626 \f
 627 /* Create a new `struct binding_level'.  */
 628
 629 static
 630 struct binding_level *
 631 make_binding_level ()
 632 {
 633   /* NOSTRICT */
 634   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 635 }
 636
 637 /* Nonzero if we are currently in the global binding level.  */
 638
 639 int
 640 global_bindings_p ()
 641 {
 642   return current_binding_level == global_binding_level;
 643 }
 644
 645 /* Return the innermost binding level that is not for a class scope.  */
 646
 647 static struct binding_level *
 648 innermost_nonclass_level ()
 649 {
 650   struct binding_level *b;
 651
 652   b = current_binding_level;
 653   while (b->parm_flag == 2)
 654     b = b->level_chain;
 655
 656   return b;
 657 }
 658
 659 /* Nonzero if we are currently in a toplevel binding level.  This
 660    means either the global binding level or a namespace in a toplevel
 661    binding level.  Since there are no non-toplevel namespace levels,
 662    this really means any namespace or template parameter level.  We
 663    also include a class whose context is toplevel.  */
 664
 665 int
 666 toplevel_bindings_p ()
 667 {
 668   struct binding_level *b = innermost_nonclass_level ();
 669
 670   return b->namespace_p || b->template_parms_p;
 671 }
 672
 673 /* Nonzero if this is a namespace scope, or if we are defining a class
 674    which is itself at namespace scope, or whose enclosing class is
 675    such a class, etc.  */
 676
 677 int
 678 namespace_bindings_p ()
 679 {
 680   struct binding_level *b = innermost_nonclass_level ();
 681
 682   return b->namespace_p;
 683 }
 684
 685 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 686    unconditionally.  Otherwise, use the normal logic to decide whether
 687    or not to create a BLOCK.  */
 688
 689 void
 690 keep_next_level (keep)
 691      int keep;
 692 {
 693   keep_next_level_flag = keep;
 694 }
 695
 696 /* Nonzero if the current level needs to have a BLOCK made.  */
 697
 698 int
 699 kept_level_p ()
 700 {
 701   return (current_binding_level->blocks != NULL_TREE
 702           || current_binding_level->keep
 703           || current_binding_level->names != NULL_TREE
 704           || (current_binding_level->tags != NULL_TREE
 705               && !current_binding_level->tag_transparent));
 706 }
 707
 708 static void
 709 declare_namespace_level ()
 710 {
 711   current_binding_level->namespace_p = 1;
 712 }
 713
 714 /* Returns non-zero if this scope was created to store template
 715    parameters.  */
 716
 717 int
 718 template_parm_scope_p ()
 719 {
 720   return current_binding_level->template_parms_p;
 721 }
 722
 723 /* Returns the kind of template specialization we are currently
 724    processing, given that it's declaration contained N_CLASS_SCOPES
 725    explicit scope qualifications.  */
 726
 727 tmpl_spec_kind
 728 current_tmpl_spec_kind (n_class_scopes)
 729      int n_class_scopes;
 730 {
 731   int n_template_parm_scopes = 0;
 732   int seen_specialization_p = 0;
 733   int innermost_specialization_p = 0;
 734   struct binding_level *b;
 735
 736   /* Scan through the template parameter scopes.  */
 737   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 738     {
 739       /* If we see a specialization scope inside a parameter scope,
 740          then something is wrong.  That corresponds to a declaration
 741          like:
 742
 743             template <class T> template <> ...
 744
 745          which is always illegal since [temp.expl.spec] forbids the
 746          specialization of a class member template if the enclosing
 747          class templates are not explicitly specialized as well.  */
 748       if (b->template_spec_p)
 749         {
 750           if (n_template_parm_scopes == 0)
 751             innermost_specialization_p = 1;
 752           else
 753             seen_specialization_p = 1;
 754         }
 755       else if (seen_specialization_p == 1)
 756         return tsk_invalid_member_spec;
 757
 758       ++n_template_parm_scopes;
 759     }
 760
 761   /* Handle explicit instantiations.  */
 762   if (processing_explicit_instantiation)
 763     {
 764       if (n_template_parm_scopes != 0)
 765         /* We've seen a template parameter list during an explicit
 766            instantiation.  For example:
 767
 768              template <class T> template void f(int);
 769
 770            This is erroneous.  */
 771         return tsk_invalid_expl_inst;
 772       else
 773         return tsk_expl_inst;
 774     }
 775
 776   if (n_template_parm_scopes < n_class_scopes)
 777     /* We've not seen enough template headers to match all the
 778        specialized classes present.  For example:
 779
 780          template <class T> void R<T>::S<T>::f(int);
 781
 782        This is illegal; there needs to be one set of template
 783        parameters for each class.  */
 784     return tsk_insufficient_parms;
 785   else if (n_template_parm_scopes == n_class_scopes)
 786     /* We're processing a non-template declaration (even though it may
 787        be a member of a template class.)  For example:
 788
 789          template <class T> void S<T>::f(int);
 790
 791        The `class T' maches the `S<T>', leaving no template headers
 792        corresponding to the `f'.  */
 793     return tsk_none;
 794   else if (n_template_parm_scopes > n_class_scopes + 1)
 795     /* We've got too many template headers.  For example:
 796
 797          template <> template <class T> void f (T);
 798
 799        There need to be more enclosing classes.  */
 800     return tsk_excessive_parms;
 801   else
 802     /* This must be a template.  It's of the form:
 803
 804          template <class T> template <class U> void S<T>::f(U);
 805
 806        This is a specialization if the innermost level was a
 807        specialization; otherwise it's just a definition of the
 808        template.  */
 809     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 810 }
 811
 812 void
 813 set_class_shadows (shadows)
 814      tree shadows;
 815 {
 816   class_binding_level->class_shadowed = shadows;
 817 }
 818
 819 /* Enter a new binding level.
 820    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 821    not for that of tags.  */
 822
 823 void
 824 pushlevel (tag_transparent)
 825      int tag_transparent;
 826 {
 827   struct binding_level *newlevel;
 828
 829   if (cfun && !doing_semantic_analysis_p ())
 830     return;
 831
 832   /* Reuse or create a struct for this binding level.  */
 833 #if defined(DEBUG_CP_BINDING_LEVELS)
 834   if (0)
 835 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 836   if (free_binding_level)
 837 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 838     {
 839       newlevel = free_binding_level;
 840       free_binding_level = free_binding_level->level_chain;
 841     }
 842   else
 843     newlevel = make_binding_level ();
 844
 845   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 846   keep_next_level_flag = 0;
 847 }
 848
 849 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 850    we're not allowed to add any more objects with cleanups to the current
 851    scope, create a new binding level.  */
 852
 853 void
 854 maybe_push_cleanup_level (type)
 855      tree type;
 856 {
 857   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 858       && current_binding_level->more_cleanups_ok == 0)
 859     {
 860       keep_next_level (2);
 861       pushlevel (1);
 862       clear_last_expr ();
 863       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 864     }
 865 }
 866
 867 /* Enter a new scope.  The KIND indicates what kind of scope is being
 868    created.  */
 869
 870 void
 871 begin_scope (sk)
 872      scope_kind sk;
 873 {
 874   pushlevel (0);
 875
 876   switch (sk)
 877     {
 878     case sk_template_spec:
 879       current_binding_level->template_spec_p = 1;
 880       /* Fall through.  */
 881
 882     case sk_template_parms:
 883       current_binding_level->template_parms_p = 1;
 884       break;
 885
 886     default:
 887       abort ();
 888     }
 889 }
 890
 891 /* Exit the current scope.  */
 892
 893 void
 894 finish_scope ()
 895 {
 896   poplevel (0, 0, 0);
 897 }
 898
 899 void
 900 note_level_for_for ()
 901 {
 902   current_binding_level->is_for_scope = 1;
 903 }
 904
 905 /* Record that the current binding level represents a try block.  */
 906
 907 void
 908 note_level_for_try ()
 909 {
 910   current_binding_level->is_try_scope = 1;
 911 }
 912
 913 /* Record that the current binding level represents a catch block.  */
 914
 915 void
 916 note_level_for_catch ()
 917 {
 918   current_binding_level->is_catch_scope = 1;
 919 }
 920
 921 /* For a binding between a name and an entity at a block scope,
 922    this is the `struct binding_level' for the block.  */
 923 #define BINDING_LEVEL(NODE) \
 924   (((struct tree_binding*)(NODE))->scope.level)
 925
 926 /* A free list of CPLUS_BINDING nodes, connected by their
 927    TREE_CHAINs.  */
 928
 929 static tree free_bindings;
 930
 931 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 932    level at which this declaration is being bound.  */
 933
 934 static void
 935 push_binding (id, decl, level)
 936      tree id;
 937      tree decl;
 938      struct binding_level* level;
 939 {
 940   tree binding;
 941
 942   if (free_bindings)
 943     {
 944       binding = free_bindings;
 945       free_bindings = TREE_CHAIN (binding);
 946     }
 947   else
 948     binding = make_node (CPLUS_BINDING);
 949
 950   /* Now, fill in the binding information.  */
 951   BINDING_VALUE (binding) = decl;
 952   BINDING_TYPE (binding) = NULL_TREE;
 953   BINDING_LEVEL (binding) = level;
 954   INHERITED_VALUE_BINDING_P (binding) = 0;
 955   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 956   BINDING_HAS_LEVEL_P (binding) = 1;
 957
 958   /* And put it on the front of the list of bindings for ID.  */
 959   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 960   IDENTIFIER_BINDING (id) = binding;
 961 }
 962
 963 /* ID is already bound in the current scope.  But, DECL is an
 964    additional binding for ID in the same scope.  This is the `struct
 965    stat' hack whereby a non-typedef class-name or enum-name can be
 966    bound at the same level as some other kind of entity.  It's the
 967    responsibility of the caller to check that inserting this name is
 968    legal here.  Returns nonzero if the new binding was successful.  */
 969 static int
 970 add_binding (id, decl)
 971      tree id;
 972      tree decl;
 973 {
 974   tree binding = IDENTIFIER_BINDING (id);
 975   int ok = 1;
 976
 977   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 978     /* The new name is the type name.  */
 979     BINDING_TYPE (binding) = decl;
 980   else if (!BINDING_VALUE (binding))
 981     /* This situation arises when push_class_level_binding moves an
 982        inherited type-binding out of the way to make room for a new
 983        value binding.  */
 984     BINDING_VALUE (binding) = decl;
 985   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 986            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 987     {
 988       /* The old binding was a type name.  It was placed in
 989          BINDING_VALUE because it was thought, at the point it was
 990          declared, to be the only entity with such a name.  Move the
 991          type name into the type slot; it is now hidden by the new
 992          binding.  */
 993       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 994       BINDING_VALUE (binding) = decl;
 995       INHERITED_VALUE_BINDING_P (binding) = 0;
 996     }
 997   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 998            && TREE_CODE (decl) == TYPE_DECL
 999            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1000            && (same_type_p (TREE_TYPE (decl),
1001                             TREE_TYPE (BINDING_VALUE (binding)))
1002                /* If either type involves template parameters, we must
1003                   wait until instantiation.  */
1004                || uses_template_parms (TREE_TYPE (decl))
1005                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
1006     /* We have two typedef-names, both naming the same type to have
1007        the same name.  This is OK because of:
1008
1009          [dcl.typedef]
1010
1011          In a given scope, a typedef specifier can be used to redefine
1012          the name of any type declared in that scope to refer to the
1013          type to which it already refers.  */
1014     ok = 0;
1015   /* There can be two block-scope declarations of the same variable,
1016      so long as they are `extern' declarations.  */
1017   else if (TREE_CODE (decl) == VAR_DECL
1018            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1019            && DECL_EXTERNAL (decl)
1020            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1021     {
1022       duplicate_decls (decl, BINDING_VALUE (binding));
1023       ok = 0;
1024     }
1025   else
1026     {
1027       error ("declaration of `%#D'", decl);
1028       cp_error_at ("conflicts with previous declaration `%#D'",
1029                    BINDING_VALUE (binding));
1030       ok = 0;
1031     }
1032
1033   return ok;
1034 }
1035
1036 /* Add DECL to the list of things declared in B.  */
1037
1038 static void
1039 add_decl_to_level (decl, b)
1040      tree decl;
1041      struct binding_level *b;
1042 {
1043   /* We build up the list in reverse order, and reverse it later if
1044      necessary.  */
1045   TREE_CHAIN (decl) = b->names;
1046   b->names = decl;
1047 }
1048
1049 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1050    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1051    doesn't really belong to this binding level, that it got here
1052    through a using-declaration.  */
1053
1054 void
1055 push_local_binding (id, decl, flags)
1056      tree id;
1057      tree decl;
1058      int flags;
1059 {
1060   struct binding_level *b;
1061
1062   /* Skip over any local classes.  This makes sense if we call
1063      push_local_binding with a friend decl of a local class.  */
1064   b = current_binding_level;
1065   while (b->parm_flag == 2)
1066     b = b->level_chain;
1067
1068   if (lookup_name_current_level (id))
1069     {
1070       /* Supplement the existing binding.  */
1071       if (!add_binding (id, decl))
1072         /* It didn't work.  Something else must be bound at this
1073            level.  Do not add DECL to the list of things to pop
1074            later.  */
1075         return;
1076     }
1077   else
1078     /* Create a new binding.  */
1079     push_binding (id, decl, b);
1080
1081   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1082     /* We must put the OVERLOAD into a TREE_LIST since the
1083        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1084        decls that got here through a using-declaration.  */
1085     decl = build_tree_list (NULL_TREE, decl);
1086
1087   /* And put DECL on the list of things declared by the current
1088      binding level.  */
1089   add_decl_to_level (decl, b);
1090 }
1091
1092 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1093    binding was successful.  */
1094
1095 int
1096 push_class_binding (id, decl)
1097      tree id;
1098      tree decl;
1099 {
1100   int result = 1;
1101   tree binding = IDENTIFIER_BINDING (id);
1102   tree context;
1103
1104   /* Note that we declared this value so that we can issue an error if
1105      this an illegal redeclaration of a name already used for some
1106      other purpose.  */
1107   note_name_declared_in_class (id, decl);
1108
1109   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1110     /* Supplement the existing binding.  */
1111     result = add_binding (id, decl);
1112   else
1113     /* Create a new binding.  */
1114     push_binding (id, decl, class_binding_level);
1115
1116   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1117      class-level declaration.  Note that we do not use DECL here
1118      because of the possibility of the `struct stat' hack; if DECL is
1119      a class-name or enum-name we might prefer a field-name, or some
1120      such.  */
1121   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1122
1123   /* If this is a binding from a base class, mark it as such.  */
1124   binding = IDENTIFIER_BINDING (id);
1125   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1126     {
1127       /* Any implicit typename must be from a base-class.  The
1128          context for an implicit typename declaration is always
1129          the derived class in which the lookup was done, so the checks
1130          based on the context of DECL below will not trigger.  */
1131       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1132         INHERITED_VALUE_BINDING_P (binding) = 1;
1133       else
1134         {
1135           if (TREE_CODE (decl) == OVERLOAD)
1136             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1137           else
1138             {
1139               my_friendly_assert (DECL_P (decl), 0);
1140               context = context_for_name_lookup (decl);
1141             }
1142
1143           if (is_properly_derived_from (current_class_type, context))
1144             INHERITED_VALUE_BINDING_P (binding) = 1;
1145           else
1146             INHERITED_VALUE_BINDING_P (binding) = 0;
1147         }
1148     }
1149   else if (BINDING_VALUE (binding) == decl)
1150     /* We only encounter a TREE_LIST when push_class_decls detects an
1151        ambiguity.  Such an ambiguity can be overridden by a definition
1152        in this class.  */
1153     INHERITED_VALUE_BINDING_P (binding) = 1;
1154
1155   return result;
1156 }
1157
1158 /* Remove the binding for DECL which should be the innermost binding
1159    for ID.  */
1160
1161 static void
1162 pop_binding (id, decl)
1163      tree id;
1164      tree decl;
1165 {
1166   tree binding;
1167
1168   if (id == NULL_TREE)
1169     /* It's easiest to write the loops that call this function without
1170        checking whether or not the entities involved have names.  We
1171        get here for such an entity.  */
1172     return;
1173
1174   /* Get the innermost binding for ID.  */
1175   binding = IDENTIFIER_BINDING (id);
1176
1177   /* The name should be bound.  */
1178   my_friendly_assert (binding != NULL_TREE, 0);
1179
1180   /* The DECL will be either the ordinary binding or the type
1181      binding for this identifier.  Remove that binding.  */
1182   if (BINDING_VALUE (binding) == decl)
1183     BINDING_VALUE (binding) = NULL_TREE;
1184   else if (BINDING_TYPE (binding) == decl)
1185     BINDING_TYPE (binding) = NULL_TREE;
1186   else
1187     abort ();
1188
1189   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1190     {
1191       /* We're completely done with the innermost binding for this
1192          identifier.  Unhook it from the list of bindings.  */
1193       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1194
1195       /* Add it to the free list.  */
1196       TREE_CHAIN (binding) = free_bindings;
1197       free_bindings = binding;
1198
1199       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1200          it.  */
1201       BINDING_LEVEL (binding) = NULL;
1202     }
1203 }
1204
1205 /* When a label goes out of scope, check to see if that label was used
1206    in a valid manner, and issue any appropriate warnings or errors.  */
1207
1208 static void
1209 pop_label (label, old_value)
1210      tree label;
1211      tree old_value;
1212 {
1213   if (!processing_template_decl && doing_semantic_analysis_p ())
1214     {
1215       if (DECL_INITIAL (label) == NULL_TREE)
1216         {
1217           cp_error_at ("label `%D' used but not defined", label);
1218           /* Avoid crashing later.  */
1219           define_label (input_filename, 1, DECL_NAME (label));
1220         }
1221       else if (warn_unused_label && !TREE_USED (label))
1222         cp_warning_at ("label `%D' defined but not used", label);
1223     }
1224
1225   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1226 }
1227
1228 /* At the end of a function, all labels declared within the function
1229    go out of scope.  BLOCK is the top-level block for the
1230    function.  */
1231
1232 static void
1233 pop_labels (block)
1234      tree block;
1235 {
1236   struct named_label_list *link;
1237
1238   /* Clear out the definitions of all label names, since their scopes
1239      end here.  */
1240   for (link = named_labels; link; link = link->next)
1241     {
1242       pop_label (link->label_decl, link->old_value);
1243       /* Put the labels into the "variables" of the top-level block,
1244          so debugger can see them.  */
1245       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1246       BLOCK_VARS (block) = link->label_decl;
1247     }
1248
1249   named_labels = NULL;
1250 }
1251
1252 /* Exit a binding level.
1253    Pop the level off, and restore the state of the identifier-decl mappings
1254    that were in effect when this level was entered.
1255
1256    If KEEP == 1, this level had explicit declarations, so
1257    and create a "block" (a BLOCK node) for the level
1258    to record its declarations and subblocks for symbol table output.
1259
1260    If FUNCTIONBODY is nonzero, this level is the body of a function,
1261    so create a block as if KEEP were set and also clear out all
1262    label names.
1263
1264    If REVERSE is nonzero, reverse the order of decls before putting
1265    them into the BLOCK.  */
1266
1267 tree
1268 poplevel (keep, reverse, functionbody)
1269      int keep;
1270      int reverse;
1271      int functionbody;
1272 {
1273   register tree link;
1274   /* The chain of decls was accumulated in reverse order.
1275      Put it into forward order, just for cleanliness.  */
1276   tree decls;
1277   int tmp = functionbody;
1278   int real_functionbody;
1279   tree tags;
1280   tree subblocks;
1281   tree block = NULL_TREE;
1282   tree decl;
1283   int leaving_for_scope;
1284
1285   if (cfun && !doing_semantic_analysis_p ())
1286     return NULL_TREE;
1287
1288   my_friendly_assert (current_binding_level->parm_flag != 2,
1289                       19990916);
1290
1291   real_functionbody = (current_binding_level->keep == 2
1292                        ? ((functionbody = 0), tmp) : functionbody);
1293   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1294   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1295
1296   my_friendly_assert (!current_binding_level->class_shadowed,
1297                       19990414);
1298
1299   /* We used to use KEEP == 2 to indicate that the new block should go
1300      at the beginning of the list of blocks at this binding level,
1301      rather than the end.  This hack is no longer used.  */
1302   my_friendly_assert (keep == 0 || keep == 1, 0);
1303
1304   if (current_binding_level->keep == 1)
1305     keep = 1;
1306
1307   /* Any uses of undefined labels, and any defined labels, now operate
1308      under constraints of next binding contour.  */
1309   if (cfun && !functionbody)
1310     {
1311       struct binding_level *level_chain;
1312       level_chain = current_binding_level->level_chain;
1313       if (level_chain)
1314         {
1315           struct named_label_use_list *uses;
1316           struct named_label_list *labels;
1317           for (labels = named_labels; labels; labels = labels->next)
1318             if (labels->binding_level == current_binding_level)
1319               {
1320                 tree decl;
1321                 if (current_binding_level->is_try_scope)
1322                   labels->in_try_scope = 1;
1323                 if (current_binding_level->is_catch_scope)
1324                   labels->in_catch_scope = 1;
1325                 for (decl = labels->names_in_scope; decl;
1326                      decl = TREE_CHAIN (decl))
1327                   if (decl_jump_unsafe (decl))
1328                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1329                                                    labels->bad_decls);
1330                 labels->binding_level = level_chain;
1331                 labels->names_in_scope = level_chain->names;
1332               }
1333
1334           for (uses = named_label_uses; uses; uses = uses->next)
1335             if (uses->binding_level == current_binding_level)
1336               {
1337                 uses->binding_level = level_chain;
1338                 uses->names_in_scope = level_chain->names;
1339               }
1340         }
1341     }
1342
1343   /* Get the decls in the order they were written.
1344      Usually current_binding_level->names is in reverse order.
1345      But parameter decls were previously put in forward order.  */
1346
1347   if (reverse)
1348     current_binding_level->names
1349       = decls = nreverse (current_binding_level->names);
1350   else
1351     decls = current_binding_level->names;
1352
1353   /* Output any nested inline functions within this block
1354      if they weren't already output.  */
1355   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1356     if (TREE_CODE (decl) == FUNCTION_DECL
1357         && ! TREE_ASM_WRITTEN (decl)
1358         && DECL_INITIAL (decl) != NULL_TREE
1359         && TREE_ADDRESSABLE (decl)
1360         && decl_function_context (decl) == current_function_decl)
1361       {
1362         /* If this decl was copied from a file-scope decl
1363            on account of a block-scope extern decl,
1364            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1365         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1366           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1367         else
1368           {
1369             push_function_context ();
1370             output_inline_function (decl);
1371             pop_function_context ();
1372           }
1373       }
1374
1375   /* When not in function-at-a-time mode, expand_end_bindings will
1376      warn about unused variables.  But, in function-at-a-time mode
1377      expand_end_bindings is not passed the list of variables in the
1378      current scope, and therefore no warning is emitted.  So, we
1379      explicitly warn here.  */
1380   if (!processing_template_decl)
1381     warn_about_unused_variables (getdecls ());
1382
1383   /* If there were any declarations or structure tags in that level,
1384      or if this level is a function body,
1385      create a BLOCK to record them for the life of this function.  */
1386   block = NULL_TREE;
1387   if (keep == 1 || functionbody)
1388     block = make_node (BLOCK);
1389   if (block != NULL_TREE)
1390     {
1391       BLOCK_VARS (block) = decls;
1392       BLOCK_SUBBLOCKS (block) = subblocks;
1393     }
1394
1395   /* In each subblock, record that this is its superior.  */
1396   if (keep >= 0)
1397     for (link = subblocks; link; link = TREE_CHAIN (link))
1398       BLOCK_SUPERCONTEXT (link) = block;
1399
1400   /* We still support the old for-scope rules, whereby the variables
1401      in a for-init statement were in scope after the for-statement
1402      ended.  We only use the new rules in flag_new_for_scope is
1403      nonzero.  */
1404   leaving_for_scope
1405     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1406
1407   /* Remove declarations for all the DECLs in this level.  */
1408   for (link = decls; link; link = TREE_CHAIN (link))
1409     {
1410       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1411           && DECL_NAME (link))
1412         {
1413           tree outer_binding
1414             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1415           tree ns_binding;
1416
1417           if (!outer_binding)
1418             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1419           else
1420             ns_binding = NULL_TREE;
1421
1422           if (outer_binding
1423               && (BINDING_LEVEL (outer_binding)
1424                   == current_binding_level->level_chain))
1425             /* We have something like:
1426
1427                  int i;
1428                  for (int i; ;);
1429
1430                and we are leaving the `for' scope.  There's no reason to
1431                keep the binding of the inner `i' in this case.  */
1432             pop_binding (DECL_NAME (link), link);
1433           else if ((outer_binding
1434                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1435                         == TYPE_DECL))
1436                    || (ns_binding
1437                        && TREE_CODE (ns_binding) == TYPE_DECL))
1438             /* Here, we have something like:
1439
1440                  typedef int I;
1441
1442                  void f () {
1443                    for (int I; ;);
1444                  }
1445
1446                We must pop the for-scope binding so we know what's a
1447                type and what isn't.  */
1448             pop_binding (DECL_NAME (link), link);
1449           else
1450             {
1451               /* Mark this VAR_DECL as dead so that we can tell we left it
1452                  there only for backward compatibility.  */
1453               DECL_DEAD_FOR_LOCAL (link) = 1;
1454
1455               /* Keep track of what should of have happenned when we
1456                  popped the binding.  */
1457               if (outer_binding && BINDING_VALUE (outer_binding))
1458                 DECL_SHADOWED_FOR_VAR (link)
1459                   = BINDING_VALUE (outer_binding);
1460
1461               /* Add it to the list of dead variables in the next
1462                  outermost binding to that we can remove these when we
1463                  leave that binding.  */
1464               current_binding_level->level_chain->dead_vars_from_for
1465                 = tree_cons (NULL_TREE, link,
1466                              current_binding_level->level_chain->
1467                              dead_vars_from_for);
1468
1469               /* Although we don't pop the CPLUS_BINDING, we do clear
1470                  its BINDING_LEVEL since the level is going away now.  */
1471               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1472                 = 0;
1473             }
1474         }
1475       else
1476         {
1477           /* Remove the binding.  */
1478           decl = link;
1479           if (TREE_CODE (decl) == TREE_LIST)
1480             decl = TREE_VALUE (decl);
1481           if (DECL_P (decl))
1482             pop_binding (DECL_NAME (decl), decl);
1483           else if (TREE_CODE (decl) == OVERLOAD)
1484             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1485           else
1486             abort ();
1487         }
1488     }
1489
1490   /* Remove declarations for any `for' variables from inner scopes
1491      that we kept around.  */
1492   for (link = current_binding_level->dead_vars_from_for;
1493        link; link = TREE_CHAIN (link))
1494     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1495
1496   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1497   for (link = current_binding_level->type_shadowed;
1498        link; link = TREE_CHAIN (link))
1499     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1500
1501   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1502   for (link = current_binding_level->shadowed_labels;
1503        link;
1504        link = TREE_CHAIN (link))
1505     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1506
1507   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1508      list if a `using' declaration put them there.  The debugging
1509      back-ends won't understand OVERLOAD, so we remove them here.
1510      Because the BLOCK_VARS are (temporarily) shared with
1511      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1512      popped all the bindings.  */
1513   if (block)
1514     {
1515       tree* d;
1516
1517       for (d = &BLOCK_VARS (block); *d; )
1518         {
1519           if (TREE_CODE (*d) == TREE_LIST)
1520             *d = TREE_CHAIN (*d);
1521           else
1522             d = &TREE_CHAIN (*d);
1523         }
1524     }
1525
1526   /* If the level being exited is the top level of a function,
1527      check over all the labels.  */
1528   if (functionbody)
1529     {
1530       /* Since this is the top level block of a function, the vars are
1531          the function's parameters.  Don't leave them in the BLOCK
1532          because they are found in the FUNCTION_DECL instead.  */
1533       BLOCK_VARS (block) = 0;
1534       pop_labels (block);
1535     }
1536
1537   tmp = current_binding_level->keep;
1538
1539   pop_binding_level ();
1540   if (functionbody)
1541     DECL_INITIAL (current_function_decl) = block;
1542   else if (block)
1543     current_binding_level->blocks
1544       = chainon (current_binding_level->blocks, block);
1545
1546   /* If we did not make a block for the level just exited,
1547      any blocks made for inner levels
1548      (since they cannot be recorded as subblocks in that level)
1549      must be carried forward so they will later become subblocks
1550      of something else.  */
1551   else if (subblocks)
1552     current_binding_level->blocks
1553       = chainon (current_binding_level->blocks, subblocks);
1554
1555   /* Each and every BLOCK node created here in `poplevel' is important
1556      (e.g. for proper debugging information) so if we created one
1557      earlier, mark it as "used".  */
1558   if (block)
1559     TREE_USED (block) = 1;
1560
1561   /* Take care of compiler's internal binding structures.  */
1562   if (tmp == 2)
1563     {
1564       tree scope_stmts;
1565
1566       scope_stmts
1567         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1568       if (block)
1569         {
1570           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1571           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1572         }
1573
1574       block = poplevel (keep, reverse, functionbody);
1575     }
1576
1577   return block;
1578 }
1579
1580 /* Delete the node BLOCK from the current binding level.
1581    This is used for the block inside a stmt expr ({...})
1582    so that the block can be reinserted where appropriate.  */
1583
1584 void
1585 delete_block (block)
1586      tree block;
1587 {
1588   tree t;
1589   if (current_binding_level->blocks == block)
1590     current_binding_level->blocks = TREE_CHAIN (block);
1591   for (t = current_binding_level->blocks; t;)
1592     {
1593       if (TREE_CHAIN (t) == block)
1594         TREE_CHAIN (t) = TREE_CHAIN (block);
1595       else
1596         t = TREE_CHAIN (t);
1597     }
1598   TREE_CHAIN (block) = NULL_TREE;
1599   /* Clear TREE_USED which is always set by poplevel.
1600      The flag is set again if insert_block is called.  */
1601   TREE_USED (block) = 0;
1602 }
1603
1604 /* Insert BLOCK at the end of the list of subblocks of the
1605    current binding level.  This is used when a BIND_EXPR is expanded,
1606    to handle the BLOCK node inside the BIND_EXPR.  */
1607
1608 void
1609 insert_block (block)
1610      tree block;
1611 {
1612   TREE_USED (block) = 1;
1613   current_binding_level->blocks
1614     = chainon (current_binding_level->blocks, block);
1615 }
1616
1617 /* Set the BLOCK node for the innermost scope
1618    (the one we are currently in).  */
1619
1620 void
1621 set_block (block)
1622     tree block ATTRIBUTE_UNUSED;
1623 {
1624   /* The RTL expansion machinery requires us to provide this callback,
1625      but it is not applicable in function-at-a-time mode.  */
1626   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1627 }
1628
1629 /* Do a pushlevel for class declarations.  */
1630
1631 void
1632 pushlevel_class ()
1633 {
1634   register struct binding_level *newlevel;
1635
1636   /* Reuse or create a struct for this binding level.  */
1637 #if defined(DEBUG_CP_BINDING_LEVELS)
1638   if (0)
1639 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1640   if (free_binding_level)
1641 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1642     {
1643       newlevel = free_binding_level;
1644       free_binding_level = free_binding_level->level_chain;
1645     }
1646   else
1647     newlevel = make_binding_level ();
1648
1649 #if defined(DEBUG_CP_BINDING_LEVELS)
1650   is_class_level = 1;
1651 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1652
1653   push_binding_level (newlevel, 0, 0);
1654
1655   class_binding_level = current_binding_level;
1656   class_binding_level->parm_flag = 2;
1657   class_binding_level->this_class = current_class_type;
1658 }
1659
1660 /* ...and a poplevel for class declarations.  */
1661
1662 void
1663 poplevel_class ()
1664 {
1665   register struct binding_level *level = class_binding_level;
1666   tree shadowed;
1667
1668   my_friendly_assert (level != 0, 354);
1669
1670   /* If we're leaving a toplevel class, don't bother to do the setting
1671      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1672      shouldn't even be used when current_class_type isn't set, and second,
1673      if we don't touch it here, we're able to use the cache effect if the
1674      next time we're entering a class scope, it is the same class.  */
1675   if (current_class_depth != 1)
1676     {
1677       struct binding_level* b;
1678
1679       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1680       for (shadowed = level->class_shadowed;
1681            shadowed;
1682            shadowed = TREE_CHAIN (shadowed))
1683         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1684
1685       /* Find the next enclosing class, and recreate
1686          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1687       b = level->level_chain;
1688       while (b && b->parm_flag != 2)
1689         b = b->level_chain;
1690
1691       if (b)
1692         for (shadowed = b->class_shadowed;
1693              shadowed;
1694              shadowed = TREE_CHAIN (shadowed))
1695           {
1696             tree t;
1697
1698             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1699             while (t && BINDING_LEVEL (t) != b)
1700               t = TREE_CHAIN (t);
1701
1702             if (t)
1703               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1704                 = BINDING_VALUE (t);
1705           }
1706     }
1707   else
1708     /* Remember to save what IDENTIFIER's were bound in this scope so we
1709        can recover from cache misses.  */
1710     {
1711       previous_class_type = current_class_type;
1712       previous_class_values = class_binding_level->class_shadowed;
1713     }
1714   for (shadowed = level->type_shadowed;
1715        shadowed;
1716        shadowed = TREE_CHAIN (shadowed))
1717     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1718
1719   /* Remove the bindings for all of the class-level declarations.  */
1720   for (shadowed = level->class_shadowed;
1721        shadowed;
1722        shadowed = TREE_CHAIN (shadowed))
1723     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1724
1725   /* Now, pop out of the binding level which we created up in the
1726      `pushlevel_class' routine.  */
1727 #if defined(DEBUG_CP_BINDING_LEVELS)
1728   is_class_level = 1;
1729 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1730
1731   pop_binding_level ();
1732 }
1733
1734 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1735    for any names in enclosing classes.  */
1736
1737 void
1738 clear_identifier_class_values ()
1739 {
1740   tree t;
1741
1742   if (!class_binding_level)
1743     return;
1744
1745   for (t = class_binding_level->class_shadowed;
1746        t;
1747        t = TREE_CHAIN (t))
1748     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1749 }
1750
1751 /* Returns non-zero if T is a virtual function table.  */
1752
1753 int
1754 vtable_decl_p (t, data)
1755      tree t;
1756      void *data ATTRIBUTE_UNUSED;
1757 {
1758   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1759 }
1760
1761 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1762    functions.  */
1763
1764 int
1765 vtype_decl_p (t, data)
1766      tree t;
1767      void *data ATTRIBUTE_UNUSED;
1768 {
1769   return (TREE_CODE (t) == TYPE_DECL
1770           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1771           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1772 }
1773
1774 /* Return the declarations that are members of the namespace NS.  */
1775
1776 tree
1777 cp_namespace_decls (ns)
1778      tree ns;
1779 {
1780   return NAMESPACE_LEVEL (ns)->names;
1781 }
1782
1783 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1784    itself, calling F for each.  The DATA is passed to F as well.  */
1785
1786 static int
1787 walk_namespaces_r (namespace, f, data)
1788      tree namespace;
1789      walk_namespaces_fn f;
1790      void *data;
1791 {
1792   tree current;
1793   int result = 0;
1794
1795   result |= (*f) (namespace, data);
1796
1797   for (current = cp_namespace_decls (namespace);
1798        current;
1799        current = TREE_CHAIN (current))
1800     {
1801       if (TREE_CODE (current) != NAMESPACE_DECL
1802           || DECL_NAMESPACE_ALIAS (current))
1803         continue;
1804
1805       /* We found a namespace.  */
1806       result |= walk_namespaces_r (current, f, data);
1807     }
1808
1809   return result;
1810 }
1811
1812 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1813    F as well.  */
1814
1815 int
1816 walk_namespaces (f, data)
1817      walk_namespaces_fn f;
1818      void *data;
1819 {
1820   return walk_namespaces_r (global_namespace, f, data);
1821 }
1822
1823 struct walk_globals_data {
1824   walk_globals_pred p;
1825   walk_globals_fn f;
1826   void *data;
1827 };
1828
1829 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1830    for which P returns non-zero, call F with its address.  If any call
1831    to F returns a non-zero value, return a non-zero value.  */
1832
1833 static int
1834 walk_globals_r (namespace, data)
1835      tree namespace;
1836      void *data;
1837 {
1838   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1839   walk_globals_pred p = wgd->p;
1840   walk_globals_fn f = wgd->f;
1841   void *d = wgd->data;
1842   tree *t;
1843   int result = 0;
1844
1845   t = &NAMESPACE_LEVEL (namespace)->names;
1846
1847   while (*t)
1848     {
1849       tree glbl = *t;
1850
1851       if ((*p) (glbl, d))
1852         result |= (*f) (t, d);
1853
1854       /* If F changed *T, then *T still points at the next item to
1855          examine.  */
1856       if (*t == glbl)
1857         t = &TREE_CHAIN (*t);
1858     }
1859
1860   return result;
1861 }
1862
1863 /* Walk the global declarations.  Whenever one is found for which P
1864    returns non-zero, call F with its address.  If any call to F
1865    returns a non-zero value, return a non-zero value.  */
1866
1867 int
1868 walk_globals (p, f, data)
1869      walk_globals_pred p;
1870      walk_globals_fn f;
1871      void *data;
1872 {
1873   struct walk_globals_data wgd;
1874   wgd.p = p;
1875   wgd.f = f;
1876   wgd.data = data;
1877
1878   return walk_namespaces (walk_globals_r, &wgd);
1879 }
1880
1881 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1882    DATA is non-NULL, this is the last time we will call
1883    wrapup_global_declarations for this NAMESPACE.  */
1884
1885 int
1886 wrapup_globals_for_namespace (namespace, data)
1887      tree namespace;
1888      void *data;
1889 {
1890   tree globals = cp_namespace_decls (namespace);
1891   int len = list_length (globals);
1892   tree *vec = (tree *) alloca (sizeof (tree) * len);
1893   int i;
1894   int result;
1895   tree decl;
1896   int last_time = (data != 0);
1897
1898   if (last_time && namespace == global_namespace)
1899     /* Let compile_file handle the global namespace.  */
1900     return 0;
1901
1902   /* Process the decls in reverse order--earliest first.
1903      Put them into VEC from back to front, then take out from front.  */
1904   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1905     vec[len - i - 1] = decl;
1906
1907   if (last_time)
1908     {
1909       check_global_declarations (vec, len);
1910       return 0;
1911     }
1912
1913   /* Temporarily mark vtables as external.  That prevents
1914      wrapup_global_declarations from writing them out; we must process
1915      them ourselves in finish_vtable_vardecl.  */
1916   for (i = 0; i < len; ++i)
1917     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1918       {
1919         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1920         DECL_EXTERNAL (vec[i]) = 1;
1921       }
1922
1923   /* Write out any globals that need to be output.  */
1924   result = wrapup_global_declarations (vec, len);
1925
1926   /* Undo the hack to DECL_EXTERNAL above.  */
1927   for (i = 0; i < len; ++i)
1928     if (vtable_decl_p (vec[i], /*data=*/0)
1929         && DECL_NOT_REALLY_EXTERN (vec[i]))
1930       {
1931         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1932         DECL_EXTERNAL (vec[i]) = 0;
1933       }
1934
1935   return result;
1936 }
1937
1938 \f
1939 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1940
1941 static void
1942 mark_binding_level (arg)
1943      void *arg;
1944 {
1945   struct binding_level *lvl = *(struct binding_level **)arg;
1946
1947   for (; lvl; lvl = lvl->level_chain)
1948     {
1949       ggc_mark_tree (lvl->names);
1950       ggc_mark_tree (lvl->tags);
1951       ggc_mark_tree (lvl->usings);
1952       ggc_mark_tree (lvl->using_directives);
1953       ggc_mark_tree (lvl->class_shadowed);
1954       ggc_mark_tree (lvl->type_shadowed);
1955       ggc_mark_tree (lvl->shadowed_labels);
1956       ggc_mark_tree (lvl->blocks);
1957       ggc_mark_tree (lvl->this_class);
1958       ggc_mark_tree (lvl->dead_vars_from_for);
1959     }
1960 }
1961
1962 static void
1963 mark_named_label_lists (labs, uses)
1964      void *labs;
1965      void *uses;
1966 {
1967   struct named_label_list *l = *(struct named_label_list **)labs;
1968   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1969
1970   for (; l; l = l->next)
1971     {
1972       ggc_mark (l);
1973       mark_binding_level (&l->binding_level);
1974       ggc_mark_tree (l->old_value);
1975       ggc_mark_tree (l->label_decl);
1976       ggc_mark_tree (l->bad_decls);
1977     }
1978
1979   for (; u; u = u->next)
1980     ggc_mark (u);
1981 }
1982 \f
1983 /* For debugging.  */
1984 static int no_print_functions = 0;
1985 static int no_print_builtins = 0;
1986
1987 void
1988 print_binding_level (lvl)
1989      struct binding_level *lvl;
1990 {
1991   tree t;
1992   int i = 0, len;
1993   fprintf (stderr, " blocks=");
1994   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1995   if (lvl->tag_transparent)
1996     fprintf (stderr, " tag-transparent");
1997   if (lvl->more_cleanups_ok)
1998     fprintf (stderr, " more-cleanups-ok");
1999   if (lvl->have_cleanups)
2000     fprintf (stderr, " have-cleanups");
2001   fprintf (stderr, "\n");
2002   if (lvl->names)
2003     {
2004       fprintf (stderr, " names:\t");
2005       /* We can probably fit 3 names to a line?  */
2006       for (t = lvl->names; t; t = TREE_CHAIN (t))
2007         {
2008           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2009             continue;
2010           if (no_print_builtins
2011               && (TREE_CODE (t) == TYPE_DECL)
2012               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2013             continue;
2014
2015           /* Function decls tend to have longer names.  */
2016           if (TREE_CODE (t) == FUNCTION_DECL)
2017             len = 3;
2018           else
2019             len = 2;
2020           i += len;
2021           if (i > 6)
2022             {
2023               fprintf (stderr, "\n\t");
2024               i = len;
2025             }
2026           print_node_brief (stderr, "", t, 0);
2027           if (t == error_mark_node)
2028             break;
2029         }
2030       if (i)
2031         fprintf (stderr, "\n");
2032     }
2033   if (lvl->tags)
2034     {
2035       fprintf (stderr, " tags:\t");
2036       i = 0;
2037       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2038         {
2039           if (TREE_PURPOSE (t) == NULL_TREE)
2040             len = 3;
2041           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2042             len = 2;
2043           else
2044             len = 4;
2045           i += len;
2046           if (i > 5)
2047             {
2048               fprintf (stderr, "\n\t");
2049               i = len;
2050             }
2051           if (TREE_PURPOSE (t) == NULL_TREE)
2052             {
2053               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2054               fprintf (stderr, ">");
2055             }
2056           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2057             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2058           else
2059             {
2060               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2061               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2062               fprintf (stderr, ">");
2063             }
2064         }
2065       if (i)
2066         fprintf (stderr, "\n");
2067     }
2068   if (lvl->class_shadowed)
2069     {
2070       fprintf (stderr, " class-shadowed:");
2071       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2072         {
2073           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2074         }
2075       fprintf (stderr, "\n");
2076     }
2077   if (lvl->type_shadowed)
2078     {
2079       fprintf (stderr, " type-shadowed:");
2080       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2081         {
2082           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2083         }
2084       fprintf (stderr, "\n");
2085     }
2086 }
2087
2088 void
2089 print_other_binding_stack (stack)
2090      struct binding_level *stack;
2091 {
2092   struct binding_level *level;
2093   for (level = stack; level != global_binding_level; level = level->level_chain)
2094     {
2095       fprintf (stderr, "binding level ");
2096       fprintf (stderr, HOST_PTR_PRINTF, level);
2097       fprintf (stderr, "\n");
2098       print_binding_level (level);
2099     }
2100 }
2101
2102 void
2103 print_binding_stack ()
2104 {
2105   struct binding_level *b;
2106   fprintf (stderr, "current_binding_level=");
2107   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2108   fprintf (stderr, "\nclass_binding_level=");
2109   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2110   fprintf (stderr, "\nglobal_binding_level=");
2111   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2112   fprintf (stderr, "\n");
2113   if (class_binding_level)
2114     {
2115       for (b = class_binding_level; b; b = b->level_chain)
2116         if (b == current_binding_level)
2117           break;
2118       if (b)
2119         b = class_binding_level;
2120       else
2121         b = current_binding_level;
2122     }
2123   else
2124     b = current_binding_level;
2125   print_other_binding_stack (b);
2126   fprintf (stderr, "global:\n");
2127   print_binding_level (global_binding_level);
2128 }
2129
2130 /* Namespace binding access routines: The namespace_bindings field of
2131    the identifier is polymorphic, with three possible values:
2132    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2133    indicating the BINDING_VALUE of global_namespace. */
2134
2135 /* Check whether the a binding for the name to scope is known.
2136    Assumes that the bindings of the name are already a list
2137    of bindings. Returns the binding found, or NULL_TREE. */
2138
2139 static tree
2140 find_binding (name, scope)
2141      tree name;
2142      tree scope;
2143 {
2144   tree iter, prev = NULL_TREE;
2145
2146   scope = ORIGINAL_NAMESPACE (scope);
2147
2148   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2149        iter = TREE_CHAIN (iter))
2150     {
2151       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2152       if (BINDING_SCOPE (iter) == scope)
2153         {
2154           /* Move binding found to the front of the list, so
2155              subsequent lookups will find it faster. */
2156           if (prev)
2157             {
2158               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2159               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2160               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2161             }
2162           return iter;
2163         }
2164       prev = iter;
2165     }
2166   return NULL_TREE;
2167 }
2168
2169 /* Always returns a binding for name in scope. If the
2170    namespace_bindings is not a list, convert it to one first.
2171    If no binding is found, make a new one. */
2172
2173 tree
2174 binding_for_name (name, scope)
2175      tree name;
2176      tree scope;
2177 {
2178   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2179   tree result;
2180
2181   scope = ORIGINAL_NAMESPACE (scope);
2182
2183   if (b && TREE_CODE (b) != CPLUS_BINDING)
2184     {
2185       /* Get rid of optimization for global scope. */
2186       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2187       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2188       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2189     }
2190   if (b && (result = find_binding (name, scope)))
2191     return result;
2192   /* Not found, make a new one. */
2193   result = make_node (CPLUS_BINDING);
2194   TREE_CHAIN (result) = b;
2195   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2196   BINDING_SCOPE (result) = scope;
2197   BINDING_TYPE (result) = NULL_TREE;
2198   BINDING_VALUE (result) = NULL_TREE;
2199   return result;
2200 }
2201
2202 /* Return the binding value for name in scope, considering that
2203    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2204
2205 tree
2206 namespace_binding (name, scope)
2207      tree name;
2208      tree scope;
2209 {
2210   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2211   if (b == NULL_TREE)
2212     return NULL_TREE;
2213   if (scope == NULL_TREE)
2214     scope = global_namespace;
2215   if (TREE_CODE (b) != CPLUS_BINDING)
2216     return (scope == global_namespace) ? b : NULL_TREE;
2217   name = find_binding (name,scope);
2218   if (name == NULL_TREE)
2219     return name;
2220   return BINDING_VALUE (name);
2221 }
2222
2223 /* Set the binding value for name in scope. If modifying the binding
2224    of global_namespace is attempted, try to optimize it. */
2225
2226 void
2227 set_namespace_binding (name, scope, val)
2228      tree name;
2229      tree scope;
2230      tree val;
2231 {
2232   tree b;
2233
2234   if (scope == NULL_TREE)
2235     scope = global_namespace;
2236
2237   if (scope == global_namespace)
2238     {
2239       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2240       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2241         {
2242           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2243           return;
2244         }
2245     }
2246   b = binding_for_name (name, scope);
2247   BINDING_VALUE (b) = val;
2248 }
2249
2250 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2251    select a name that is unique to this compilation unit.  */
2252
2253 void
2254 push_namespace (name)
2255      tree name;
2256 {
2257   tree d = NULL_TREE;
2258   int need_new = 1;
2259   int implicit_use = 0;
2260   int global = 0;
2261   if (!global_namespace)
2262     {
2263       /* This must be ::. */
2264       my_friendly_assert (name == get_identifier ("::"), 377);
2265       global = 1;
2266     }
2267   else if (!name)
2268     {
2269       /* The name of anonymous namespace is unique for the translation
2270          unit.  */
2271       if (!anonymous_namespace_name)
2272         anonymous_namespace_name = get_file_function_name ('N');
2273       name = anonymous_namespace_name;
2274       d = IDENTIFIER_NAMESPACE_VALUE (name);
2275       if (d)
2276         /* Reopening anonymous namespace.  */
2277         need_new = 0;
2278       implicit_use = 1;
2279     }
2280   else
2281     {
2282       /* Check whether this is an extended namespace definition. */
2283       d = IDENTIFIER_NAMESPACE_VALUE (name);
2284       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2285         {
2286           need_new = 0;
2287           if (DECL_NAMESPACE_ALIAS (d))
2288             {
2289               error ("namespace alias `%D' not allowed here, assuming `%D'",
2290                         d, DECL_NAMESPACE_ALIAS (d));
2291               d = DECL_NAMESPACE_ALIAS (d);
2292             }
2293         }
2294     }
2295
2296   if (need_new)
2297     {
2298       /* Make a new namespace, binding the name to it. */
2299       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2300       /* The global namespace is not pushed, and the global binding
2301          level is set elsewhere.  */
2302       if (!global)
2303         {
2304           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2305           d = pushdecl (d);
2306           pushlevel (0);
2307           declare_namespace_level ();
2308           NAMESPACE_LEVEL (d) = current_binding_level;
2309         }
2310     }
2311   else
2312     resume_binding_level (NAMESPACE_LEVEL (d));
2313
2314   if (implicit_use)
2315     do_using_directive (d);
2316   /* Enter the name space. */
2317   current_namespace = d;
2318 }
2319
2320 /* Pop from the scope of the current namespace.  */
2321
2322 void
2323 pop_namespace ()
2324 {
2325   my_friendly_assert (current_namespace != global_namespace, 20010801);
2326   current_namespace = CP_DECL_CONTEXT (current_namespace);
2327   /* The binding level is not popped, as it might be re-opened later.  */
2328   suspend_binding_level ();
2329 }
2330
2331 /* Push into the scope of the namespace NS, even if it is deeply
2332    nested within another namespace.  */
2333
2334 void
2335 push_nested_namespace (ns)
2336      tree ns;
2337 {
2338   if (ns == global_namespace)
2339     push_to_top_level ();
2340   else
2341     {
2342       push_nested_namespace (CP_DECL_CONTEXT (ns));
2343       push_namespace (DECL_NAME (ns));
2344     }
2345 }
2346
2347 /* Pop back from the scope of the namespace NS, which was previously
2348    entered with push_nested_namespace.  */
2349
2350 void
2351 pop_nested_namespace (ns)
2352      tree ns;
2353 {
2354   while (ns != global_namespace)
2355     {
2356       pop_namespace ();
2357       ns = CP_DECL_CONTEXT (ns);
2358     }
2359
2360   pop_from_top_level ();
2361 }
2362
2363 \f
2364 /* Subroutines for reverting temporarily to top-level for instantiation
2365    of templates and such.  We actually need to clear out the class- and
2366    local-value slots of all identifiers, so that only the global values
2367    are at all visible.  Simply setting current_binding_level to the global
2368    scope isn't enough, because more binding levels may be pushed.  */
2369 struct saved_scope *scope_chain;
2370
2371 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2372
2373 static void
2374 mark_saved_scope (arg)
2375      void *arg;
2376 {
2377   struct saved_scope *t = *(struct saved_scope **)arg;
2378   while (t)
2379     {
2380       mark_binding_level (&t->class_bindings);
2381       ggc_mark_tree (t->old_bindings);
2382       ggc_mark_tree (t->old_namespace);
2383       ggc_mark_tree (t->decl_ns_list);
2384       ggc_mark_tree (t->class_name);
2385       ggc_mark_tree (t->class_type);
2386       ggc_mark_tree (t->access_specifier);
2387       ggc_mark_tree (t->function_decl);
2388       if (t->lang_base)
2389         ggc_mark_tree_varray (t->lang_base);
2390       ggc_mark_tree (t->lang_name);
2391       ggc_mark_tree (t->template_parms);
2392       ggc_mark_tree (t->x_previous_class_type);
2393       ggc_mark_tree (t->x_previous_class_values);
2394       ggc_mark_tree (t->x_saved_tree);
2395       ggc_mark_tree (t->lookups);
2396
2397       mark_stmt_tree (&t->x_stmt_tree);
2398       mark_binding_level (&t->bindings);
2399       t = t->prev;
2400     }
2401 }
2402
2403 static tree
2404 store_bindings (names, old_bindings)
2405      tree names, old_bindings;
2406 {
2407   tree t;
2408   tree search_bindings = old_bindings;
2409
2410   for (t = names; t; t = TREE_CHAIN (t))
2411     {
2412       tree binding, t1, id;
2413
2414       if (TREE_CODE (t) == TREE_LIST)
2415         id = TREE_PURPOSE (t);
2416       else
2417         id = DECL_NAME (t);
2418
2419       if (!id
2420           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2421              we have no IDENTIFIER_BINDING if we have left the class
2422              scope, but cached the class-level declarations.  */
2423           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2424         continue;
2425
2426       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2427         if (TREE_VEC_ELT (t1, 0) == id)
2428           goto skip_it;
2429
2430       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2431       binding = make_tree_vec (4);
2432       TREE_VEC_ELT (binding, 0) = id;
2433       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2434       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2435       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2436       IDENTIFIER_BINDING (id) = NULL_TREE;
2437       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2438       TREE_CHAIN (binding) = old_bindings;
2439       old_bindings = binding;
2440     skip_it:
2441       ;
2442     }
2443   return old_bindings;
2444 }
2445
2446 void
2447 maybe_push_to_top_level (pseudo)
2448      int pseudo;
2449 {
2450   struct saved_scope *s;
2451   struct binding_level *b;
2452   tree old_bindings;
2453   int need_pop;
2454
2455   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2456
2457   b = scope_chain ? current_binding_level : 0;
2458
2459   /* If we're in the middle of some function, save our state.  */
2460   if (cfun)
2461     {
2462       need_pop = 1;
2463       push_function_context_to (NULL_TREE);
2464     }
2465   else
2466     need_pop = 0;
2467
2468   old_bindings = NULL_TREE;
2469   if (scope_chain && previous_class_type)
2470     old_bindings = store_bindings (previous_class_values, old_bindings);
2471
2472   /* Have to include global_binding_level, because class-level decls
2473      aren't listed anywhere useful.  */
2474   for (; b; b = b->level_chain)
2475     {
2476       tree t;
2477
2478       /* Template IDs are inserted into the global level. If they were
2479          inserted into namespace level, finish_file wouldn't find them
2480          when doing pending instantiations. Therefore, don't stop at
2481          namespace level, but continue until :: .  */
2482       if (b == global_binding_level || (pseudo && b->template_parms_p))
2483         break;
2484
2485       old_bindings = store_bindings (b->names, old_bindings);
2486       /* We also need to check class_shadowed to save class-level type
2487          bindings, since pushclass doesn't fill in b->names.  */
2488       if (b->parm_flag == 2)
2489         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2490
2491       /* Unwind type-value slots back to top level.  */
2492       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2493         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2494     }
2495   s->prev = scope_chain;
2496   s->old_bindings = old_bindings;
2497   s->bindings = b;
2498   s->need_pop_function_context = need_pop;
2499   s->function_decl = current_function_decl;
2500   s->last_parms = last_function_parms;
2501
2502   scope_chain = s;
2503   current_function_decl = NULL_TREE;
2504   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2505   current_lang_name = lang_name_cplusplus;
2506   current_namespace = global_namespace;
2507 }
2508
2509 void
2510 push_to_top_level ()
2511 {
2512   maybe_push_to_top_level (0);
2513 }
2514
2515 void
2516 pop_from_top_level ()
2517 {
2518   struct saved_scope *s = scope_chain;
2519   tree t;
2520
2521   /* Clear out class-level bindings cache.  */
2522   if (previous_class_type)
2523     invalidate_class_lookup_cache ();
2524
2525   VARRAY_FREE (current_lang_base);
2526
2527   scope_chain = s->prev;
2528   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2529     {
2530       tree id = TREE_VEC_ELT (t, 0);
2531
2532       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2533       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2534       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2535     }
2536
2537   /* If we were in the middle of compiling a function, restore our
2538      state.  */
2539   if (s->need_pop_function_context)
2540     pop_function_context_from (NULL_TREE);
2541   current_function_decl = s->function_decl;
2542   last_function_parms = s->last_parms;
2543
2544   free (s);
2545 }
2546 \f
2547 /* Push a definition of struct, union or enum tag "name".
2548    into binding_level "b".   "type" should be the type node,
2549    We assume that the tag "name" is not already defined.
2550
2551    Note that the definition may really be just a forward reference.
2552    In that case, the TYPE_SIZE will be a NULL_TREE.
2553
2554    C++ gratuitously puts all these tags in the name space.  */
2555
2556 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2557    record the shadowed value for this binding contour.  TYPE is
2558    the type that ID maps to.  */
2559
2560 static void
2561 set_identifier_type_value_with_scope (id, type, b)
2562      tree id;
2563      tree type;
2564      struct binding_level *b;
2565 {
2566   if (!b->namespace_p)
2567     {
2568       /* Shadow the marker, not the real thing, so that the marker
2569          gets restored later. */
2570       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2571       b->type_shadowed
2572         = tree_cons (id, old_type_value, b->type_shadowed);
2573     }
2574   else
2575     {
2576       tree binding = binding_for_name (id, current_namespace);
2577       BINDING_TYPE (binding) = type;
2578       /* Store marker instead of real type. */
2579       type = global_type_node;
2580     }
2581   SET_IDENTIFIER_TYPE_VALUE (id, type);
2582 }
2583
2584 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2585
2586 void
2587 set_identifier_type_value (id, type)
2588      tree id;
2589      tree type;
2590 {
2591   set_identifier_type_value_with_scope (id, type, current_binding_level);
2592 }
2593
2594 /* Return the type associated with id. */
2595
2596 tree
2597 identifier_type_value (id)
2598      tree id;
2599 {
2600   /* There is no type with that name, anywhere. */
2601   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2602     return NULL_TREE;
2603   /* This is not the type marker, but the real thing. */
2604   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2605     return REAL_IDENTIFIER_TYPE_VALUE (id);
2606   /* Have to search for it. It must be on the global level, now.
2607      Ask lookup_name not to return non-types. */
2608   id = lookup_name_real (id, 2, 1, 0);
2609   if (id)
2610     return TREE_TYPE (id);
2611   return NULL_TREE;
2612 }
2613
2614 /* Pop off extraneous binding levels left over due to syntax errors.
2615
2616    We don't pop past namespaces, as they might be valid.  */
2617
2618 void
2619 pop_everything ()
2620 {
2621 #ifdef DEBUG_CP_BINDING_LEVELS
2622   fprintf (stderr, "XXX entering pop_everything ()\n");
2623 #endif
2624   while (!toplevel_bindings_p ())
2625     {
2626       if (current_binding_level->parm_flag == 2)
2627         pop_nested_class ();
2628       else
2629         poplevel (0, 0, 0);
2630     }
2631 #ifdef DEBUG_CP_BINDING_LEVELS
2632   fprintf (stderr, "XXX leaving pop_everything ()\n");
2633 #endif
2634 }
2635
2636 /* The type TYPE is being declared.  If it is a class template, or a
2637    specialization of a class template, do any processing required and
2638    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2639    being declared a friend.  B is the binding level at which this TYPE
2640    should be bound.
2641
2642    Returns the TYPE_DECL for TYPE, which may have been altered by this
2643    processing.  */
2644
2645 static tree
2646 maybe_process_template_type_declaration (type, globalize, b)
2647      tree type;
2648      int globalize;
2649      struct binding_level* b;
2650 {
2651   tree decl = TYPE_NAME (type);
2652
2653   if (processing_template_parmlist)
2654     /* You can't declare a new template type in a template parameter
2655        list.  But, you can declare a non-template type:
2656
2657          template <class A*> struct S;
2658
2659        is a forward-declaration of `A'.  */
2660     ;
2661   else
2662     {
2663       maybe_check_template_type (type);
2664
2665       my_friendly_assert (IS_AGGR_TYPE (type)
2666                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2667
2668
2669       if (processing_template_decl)
2670         {
2671           /* This may change after the call to
2672              push_template_decl_real, but we want the original value.  */
2673           tree name = DECL_NAME (decl);
2674
2675           decl = push_template_decl_real (decl, globalize);
2676           /* If the current binding level is the binding level for the
2677              template parameters (see the comment in
2678              begin_template_parm_list) and the enclosing level is a class
2679              scope, and we're not looking at a friend, push the
2680              declaration of the member class into the class scope.  In the
2681              friend case, push_template_decl will already have put the
2682              friend into global scope, if appropriate.  */
2683           if (TREE_CODE (type) != ENUMERAL_TYPE
2684               && !globalize && b->template_parms_p
2685               && b->level_chain->parm_flag == 2)
2686             {
2687               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2688               /* Put this tag on the list of tags for the class, since
2689                  that won't happen below because B is not the class
2690                  binding level, but is instead the pseudo-global level.  */
2691               b->level_chain->tags =
2692                 tree_cons (name, type, b->level_chain->tags);
2693               if (!COMPLETE_TYPE_P (current_class_type))
2694                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2695             }
2696         }
2697     }
2698
2699   return decl;
2700 }
2701
2702 /* In C++, you don't have to write `struct S' to refer to `S'; you
2703    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2704    if the user had written `typedef struct S S'.  Create and return
2705    the TYPE_DECL for TYPE.  */
2706
2707 tree
2708 create_implicit_typedef (name, type)
2709      tree name;
2710      tree type;
2711 {
2712   tree decl;
2713
2714   decl = build_decl (TYPE_DECL, name, type);
2715   DECL_ARTIFICIAL (decl) = 1;
2716   /* There are other implicit type declarations, like the one *within*
2717      a class that allows you to write `S::S'.  We must distinguish
2718      amongst these.  */
2719   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2720   TYPE_NAME (type) = decl;
2721
2722   return decl;
2723 }
2724
2725 /* Remember a local name for name-mangling purposes.  */
2726
2727 static void
2728 push_local_name (decl)
2729      tree decl;
2730 {
2731   size_t i, nelts;
2732   tree t, name;
2733
2734   if (!local_names)
2735     VARRAY_TREE_INIT (local_names, 8, "local_names");
2736
2737   name = DECL_NAME (decl);
2738
2739   nelts = VARRAY_ACTIVE_SIZE (local_names);
2740   for (i = 0; i < nelts; i++)
2741     {
2742       t = VARRAY_TREE (local_names, i);
2743       if (DECL_NAME (t) == name)
2744         {
2745           if (!DECL_LANG_SPECIFIC (decl))
2746             retrofit_lang_decl (decl);
2747           if (DECL_LANG_SPECIFIC (t))
2748             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2749           else
2750             DECL_DISCRIMINATOR (decl) = 1;
2751
2752           VARRAY_TREE (local_names, i) = decl;
2753           return;
2754         }
2755     }
2756
2757   VARRAY_PUSH_TREE (local_names, decl);
2758 }
2759
2760 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2761    Normally put it into the inner-most non-tag-transparent scope,
2762    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2763    The latter is needed for implicit declarations.  */
2764
2765 void
2766 pushtag (name, type, globalize)
2767      tree name, type;
2768      int globalize;
2769 {
2770   register struct binding_level *b;
2771
2772   b = current_binding_level;
2773   while (b->tag_transparent
2774          || (b->parm_flag == 2
2775              && (globalize
2776                  /* We may be defining a new type in the initializer
2777                     of a static member variable. We allow this when
2778                     not pedantic, and it is particularly useful for
2779                     type punning via an anonymous union. */
2780                  || COMPLETE_TYPE_P (b->this_class))))
2781     b = b->level_chain;
2782
2783   b->tags = tree_cons (name, type, b->tags);
2784
2785   if (name)
2786     {
2787       /* Do C++ gratuitous typedefing.  */
2788       if (IDENTIFIER_TYPE_VALUE (name) != type)
2789         {
2790           register tree d = NULL_TREE;
2791           int in_class = 0;
2792           tree context = TYPE_CONTEXT (type);
2793
2794           if (! context)
2795             {
2796               tree cs = current_scope ();
2797
2798               if (! globalize)
2799                 context = cs;
2800               else if (cs != NULL_TREE && TYPE_P (cs))
2801                 /* When declaring a friend class of a local class, we want
2802                    to inject the newly named class into the scope
2803                    containing the local class, not the namespace scope.  */
2804                 context = decl_function_context (get_type_decl (cs));
2805             }
2806           if (!context)
2807             context = current_namespace;
2808
2809           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2810               || b->parm_flag == 2)
2811             in_class = 1;
2812
2813           if (current_lang_name == lang_name_java)
2814             TYPE_FOR_JAVA (type) = 1;
2815
2816           d = create_implicit_typedef (name, type);
2817           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2818           if (! in_class)
2819             set_identifier_type_value_with_scope (name, type, b);
2820
2821           d = maybe_process_template_type_declaration (type,
2822                                                        globalize, b);
2823
2824           if (b->parm_flag == 2)
2825             {
2826               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2827                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2828                    class.  But if it's a member template class, we
2829                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2830                    is done later.  */
2831                 finish_member_declaration (d);
2832               else
2833                 pushdecl_class_level (d);
2834             }
2835           else
2836             d = pushdecl_with_scope (d, b);
2837
2838           /* FIXME what if it gets a name from typedef?  */
2839           if (ANON_AGGRNAME_P (name))
2840             DECL_IGNORED_P (d) = 1;
2841
2842           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2843
2844           /* If this is a local class, keep track of it.  We need this
2845              information for name-mangling, and so that it is possible to find
2846              all function definitions in a translation unit in a convenient
2847              way.  (It's otherwise tricky to find a member function definition
2848              it's only pointed to from within a local class.)  */
2849           if (TYPE_CONTEXT (type)
2850               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2851               && !processing_template_decl)
2852             VARRAY_PUSH_TREE (local_classes, type);
2853         }
2854       if (b->parm_flag == 2)
2855         {
2856           if (!COMPLETE_TYPE_P (current_class_type))
2857             CLASSTYPE_TAGS (current_class_type) = b->tags;
2858         }
2859     }
2860
2861   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2862     /* Use the canonical TYPE_DECL for this node.  */
2863     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2864   else
2865     {
2866       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2867          will be the tagged type we just added to the current
2868          binding level.  This fake NULL-named TYPE_DECL node helps
2869          dwarfout.c to know when it needs to output a
2870          representation of a tagged type, and it also gives us a
2871          convenient place to record the "scope start" address for
2872          the tagged type.  */
2873
2874       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2875       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2876     }
2877 }
2878
2879 /* Counter used to create anonymous type names.  */
2880
2881 static int anon_cnt = 0;
2882
2883 /* Return an IDENTIFIER which can be used as a name for
2884    anonymous structs and unions.  */
2885
2886 tree
2887 make_anon_name ()
2888 {
2889   char buf[32];
2890
2891   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2892   return get_identifier (buf);
2893 }
2894
2895 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2896    This keeps dbxout from getting confused.  */
2897
2898 void
2899 clear_anon_tags ()
2900 {
2901   register struct binding_level *b;
2902   register tree tags;
2903   static int last_cnt = 0;
2904
2905   /* Fast out if no new anon names were declared.  */
2906   if (last_cnt == anon_cnt)
2907     return;
2908
2909   b = current_binding_level;
2910   while (b->tag_transparent)
2911     b = b->level_chain;
2912   tags = b->tags;
2913   while (tags)
2914     {
2915       /* A NULL purpose means we have already processed all tags
2916          from here to the end of the list.  */
2917       if (TREE_PURPOSE (tags) == NULL_TREE)
2918         break;
2919       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2920         TREE_PURPOSE (tags) = NULL_TREE;
2921       tags = TREE_CHAIN (tags);
2922     }
2923   last_cnt = anon_cnt;
2924 }
2925 \f
2926 /* Subroutine of duplicate_decls: return truthvalue of whether
2927    or not types of these decls match.
2928
2929    For C++, we must compare the parameter list so that `int' can match
2930    `int&' in a parameter position, but `int&' is not confused with
2931    `const int&'.  */
2932
2933 int
2934 decls_match (newdecl, olddecl)
2935      tree newdecl, olddecl;
2936 {
2937   int types_match;
2938
2939   if (newdecl == olddecl)
2940     return 1;
2941
2942   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2943     /* If the two DECLs are not even the same kind of thing, we're not
2944        interested in their types.  */
2945     return 0;
2946
2947   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2948     {
2949       tree f1 = TREE_TYPE (newdecl);
2950       tree f2 = TREE_TYPE (olddecl);
2951       tree p1 = TYPE_ARG_TYPES (f1);
2952       tree p2 = TYPE_ARG_TYPES (f2);
2953
2954       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2955           && ! (DECL_EXTERN_C_P (newdecl)
2956                 && DECL_EXTERN_C_P (olddecl)))
2957         return 0;
2958
2959       if (TREE_CODE (f1) != TREE_CODE (f2))
2960         return 0;
2961
2962       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2963         {
2964           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2965               && (DECL_BUILT_IN (olddecl)
2966 #ifndef NO_IMPLICIT_EXTERN_C
2967                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2968                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2969 #endif
2970               ))
2971             {
2972               types_match = self_promoting_args_p (p1);
2973               if (p1 == void_list_node)
2974                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2975             }
2976 #ifndef NO_IMPLICIT_EXTERN_C
2977           else if (p1 == NULL_TREE
2978                    && (DECL_EXTERN_C_P (olddecl)
2979                        && DECL_IN_SYSTEM_HEADER (olddecl)
2980                        && !DECL_CLASS_SCOPE_P (olddecl))
2981                    && (DECL_EXTERN_C_P (newdecl)
2982                        && DECL_IN_SYSTEM_HEADER (newdecl)
2983                        && !DECL_CLASS_SCOPE_P (newdecl)))
2984             {
2985               types_match = self_promoting_args_p (p2);
2986               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2987             }
2988 #endif
2989           else
2990             types_match = compparms (p1, p2);
2991         }
2992       else
2993         types_match = 0;
2994     }
2995   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2996     {
2997       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2998                                 DECL_TEMPLATE_PARMS (olddecl)))
2999         return 0;
3000
3001       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3002           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3003         return 0;
3004
3005       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3006         types_match = 1;
3007       else
3008         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3009                                    DECL_TEMPLATE_RESULT (newdecl));
3010     }
3011   else
3012     {
3013       if (TREE_TYPE (newdecl) == error_mark_node)
3014         types_match = TREE_TYPE (olddecl) == error_mark_node;
3015       else if (TREE_TYPE (olddecl) == NULL_TREE)
3016         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3017       else if (TREE_TYPE (newdecl) == NULL_TREE)
3018         types_match = 0;
3019       else
3020         types_match = comptypes (TREE_TYPE (newdecl),
3021                                  TREE_TYPE (olddecl),
3022                                  COMPARE_REDECLARATION);
3023     }
3024
3025   return types_match;
3026 }
3027
3028 /* If NEWDECL is `static' and an `extern' was seen previously,
3029    warn about it.  OLDDECL is the previous declaration.
3030
3031    Note that this does not apply to the C++ case of declaring
3032    a variable `extern const' and then later `const'.
3033
3034    Don't complain about built-in functions, since they are beyond
3035    the user's control.  */
3036
3037 static void
3038 warn_extern_redeclared_static (newdecl, olddecl)
3039      tree newdecl, olddecl;
3040 {
3041   static const char *const explicit_extern_static_warning
3042     = "`%D' was declared `extern' and later `static'";
3043   static const char *const implicit_extern_static_warning
3044     = "`%D' was declared implicitly `extern' and later `static'";
3045
3046   tree name;
3047
3048   if (TREE_CODE (newdecl) == TYPE_DECL
3049       || TREE_CODE (newdecl) == TEMPLATE_DECL
3050       || TREE_CODE (newdecl) == CONST_DECL)
3051     return;
3052
3053   /* Don't get confused by static member functions; that's a different
3054      use of `static'.  */
3055   if (TREE_CODE (newdecl) == FUNCTION_DECL
3056       && DECL_STATIC_FUNCTION_P (newdecl))
3057     return;
3058
3059   /* If the old declaration was `static', or the new one isn't, then
3060      then everything is OK.  */
3061   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3062     return;
3063
3064   /* It's OK to declare a builtin function as `static'.  */
3065   if (TREE_CODE (olddecl) == FUNCTION_DECL
3066       && DECL_ARTIFICIAL (olddecl))
3067     return;
3068
3069   name = DECL_ASSEMBLER_NAME (newdecl);
3070   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3071               ? implicit_extern_static_warning
3072               : explicit_extern_static_warning, newdecl);
3073   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3074 }
3075
3076 /* Handle when a new declaration NEWDECL has the same name as an old
3077    one OLDDECL in the same binding contour.  Prints an error message
3078    if appropriate.
3079
3080    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3081    Otherwise, return 0.  */
3082
3083 int
3084 duplicate_decls (newdecl, olddecl)
3085      tree newdecl, olddecl;
3086 {
3087   unsigned olddecl_uid = DECL_UID (olddecl);
3088   int olddecl_friend = 0, types_match = 0;
3089   int new_defines_function = 0;
3090
3091   if (newdecl == olddecl)
3092     return 1;
3093
3094   types_match = decls_match (newdecl, olddecl);
3095
3096   /* If either the type of the new decl or the type of the old decl is an
3097      error_mark_node, then that implies that we have already issued an
3098      error (earlier) for some bogus type specification, and in that case,
3099      it is rather pointless to harass the user with yet more error message
3100      about the same declaration, so just pretend the types match here.  */
3101   if (TREE_TYPE (newdecl) == error_mark_node
3102       || TREE_TYPE (olddecl) == error_mark_node)
3103     types_match = 1;
3104
3105   if (DECL_P (olddecl)
3106       && TREE_CODE (newdecl) == FUNCTION_DECL
3107       && TREE_CODE (olddecl) == FUNCTION_DECL
3108       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3109     {
3110       if (DECL_DECLARED_INLINE_P (newdecl)
3111           && DECL_UNINLINABLE (newdecl)
3112           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3113         /* Already warned elsewhere.  */;
3114       else if (DECL_DECLARED_INLINE_P (olddecl)
3115                && DECL_UNINLINABLE (olddecl)
3116                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3117         /* Already warned.  */;
3118       else if (DECL_DECLARED_INLINE_P (newdecl)
3119                && DECL_UNINLINABLE (olddecl)
3120                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3121         {
3122           warning_with_decl (newdecl,
3123                              "function `%s' redeclared as inline");
3124           warning_with_decl (olddecl,
3125                              "previous declaration of function `%s' with attribute noinline");
3126         }
3127       else if (DECL_DECLARED_INLINE_P (olddecl)
3128                && DECL_UNINLINABLE (newdecl)
3129                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3130         {
3131           warning_with_decl (newdecl,
3132                              "function `%s' redeclared with attribute noinline");
3133           warning_with_decl (olddecl,
3134                              "previous declaration of function `%s' was inline");
3135         }
3136     }
3137
3138   /* Check for redeclaration and other discrepancies. */
3139   if (TREE_CODE (olddecl) == FUNCTION_DECL
3140       && DECL_ARTIFICIAL (olddecl))
3141     {
3142       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3143         {
3144           /* Avoid warnings redeclaring anticipated built-ins.  */
3145           if (DECL_ANTICIPATED (olddecl))
3146             return 0;
3147
3148           /* If you declare a built-in or predefined function name as static,
3149              the old definition is overridden, but optionally warn this was a
3150              bad choice of name.  */
3151           if (! TREE_PUBLIC (newdecl))
3152             {
3153               if (warn_shadow)
3154                 warning ("shadowing %s function `%#D'",
3155                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3156                             olddecl);
3157               /* Discard the old built-in function.  */
3158               return 0;
3159             }
3160           /* If the built-in is not ansi, then programs can override
3161              it even globally without an error.  */
3162           else if (! DECL_BUILT_IN (olddecl))
3163             warning ("library function `%#D' redeclared as non-function `%#D'",
3164                         olddecl, newdecl);
3165           else
3166             {
3167               error ("declaration of `%#D'", newdecl);
3168               error ("conflicts with built-in declaration `%#D'",
3169                         olddecl);
3170             }
3171           return 0;
3172         }
3173       else if (!types_match)
3174         {
3175           /* Avoid warnings redeclaring anticipated built-ins.  */
3176           if (DECL_ANTICIPATED (olddecl))
3177             ;  /* Do nothing yet.  */
3178           else if ((DECL_EXTERN_C_P (newdecl)
3179                && DECL_EXTERN_C_P (olddecl))
3180               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3181                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3182             {
3183               /* A near match; override the builtin.  */
3184
3185               if (TREE_PUBLIC (newdecl))
3186                 {
3187                   warning ("new declaration `%#D'", newdecl);
3188                   warning ("ambiguates built-in declaration `%#D'",
3189                               olddecl);
3190                 }
3191               else if (warn_shadow)
3192                 warning ("shadowing %s function `%#D'",
3193                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3194                             olddecl);
3195             }
3196           else
3197             /* Discard the old built-in function.  */
3198             return 0;
3199
3200           /* Replace the old RTL to avoid problems with inlining.  */
3201           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3202         }
3203
3204       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3205         {
3206           /* If a builtin function is redeclared as `static', merge
3207              the declarations, but make the original one static.  */
3208           DECL_THIS_STATIC (olddecl) = 1;
3209           TREE_PUBLIC (olddecl) = 0;
3210
3211           /* Make the old declaration consistent with the new one so
3212              that all remnants of the builtin-ness of this function
3213              will be banished.  */
3214           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3215           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3216         }
3217     }
3218   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3219     {
3220       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3221            && TREE_CODE (newdecl) != TYPE_DECL
3222            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3223                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3224           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3225               && TREE_CODE (olddecl) != TYPE_DECL
3226               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3227                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3228                         == TYPE_DECL))))
3229         {
3230           /* We do nothing special here, because C++ does such nasty
3231              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3232              get shadowed, and know that if we need to find a TYPE_DECL
3233              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3234              slot of the identifier.  */
3235           return 0;
3236         }
3237
3238       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3239            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3240           || (TREE_CODE (olddecl) == FUNCTION_DECL
3241               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3242         return 0;
3243
3244       error ("`%#D' redeclared as different kind of symbol", newdecl);
3245       if (TREE_CODE (olddecl) == TREE_LIST)
3246         olddecl = TREE_VALUE (olddecl);
3247       cp_error_at ("previous declaration of `%#D'", olddecl);
3248
3249       /* New decl is completely inconsistent with the old one =>
3250          tell caller to replace the old one.  */
3251
3252       return 0;
3253     }
3254   else if (!types_match)
3255     {
3256       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3257         /* These are certainly not duplicate declarations; they're
3258            from different scopes.  */
3259         return 0;
3260
3261       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3262         {
3263           /* The name of a class template may not be declared to refer to
3264              any other template, class, function, object, namespace, value,
3265              or type in the same scope.  */
3266           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3267               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3268             {
3269               error ("declaration of template `%#D'", newdecl);
3270               cp_error_at ("conflicts with previous declaration `%#D'",
3271                            olddecl);
3272             }
3273           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3274                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3275                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3276                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3277                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3278                                            DECL_TEMPLATE_PARMS (olddecl)))
3279             {
3280               error ("new declaration `%#D'", newdecl);
3281               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3282             }
3283           return 0;
3284         }
3285       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3286         {
3287           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3288             {
3289               error ("declaration of C function `%#D' conflicts with",
3290                         newdecl);
3291               cp_error_at ("previous declaration `%#D' here", olddecl);
3292             }
3293           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3294                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3295             {
3296               error ("new declaration `%#D'", newdecl);
3297               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3298             }
3299           else
3300             return 0;
3301         }
3302
3303       /* Already complained about this, so don't do so again.  */
3304       else if (current_class_type == NULL_TREE
3305           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3306         {
3307           error ("conflicting types for `%#D'", newdecl);
3308           cp_error_at ("previous declaration as `%#D'", olddecl);
3309         }
3310     }
3311   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3312             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3313                  && (!DECL_TEMPLATE_INFO (newdecl)
3314                      || (DECL_TI_TEMPLATE (newdecl)
3315                          != DECL_TI_TEMPLATE (olddecl))))
3316                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3317                     && (!DECL_TEMPLATE_INFO (olddecl)
3318                         || (DECL_TI_TEMPLATE (olddecl)
3319                             != DECL_TI_TEMPLATE (newdecl))))))
3320     /* It's OK to have a template specialization and a non-template
3321        with the same type, or to have specializations of two
3322        different templates with the same type.  Note that if one is a
3323        specialization, and the other is an instantiation of the same
3324        template, that we do not exit at this point.  That situation
3325        can occur if we instantiate a template class, and then
3326        specialize one of its methods.  This situation is legal, but
3327        the declarations must be merged in the usual way.  */
3328     return 0;
3329   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3330            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3331                 && !DECL_USE_TEMPLATE (newdecl))
3332                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3333                    && !DECL_USE_TEMPLATE (olddecl))))
3334     /* One of the declarations is a template instantiation, and the
3335        other is not a template at all.  That's OK.  */
3336     return 0;
3337   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3338            && DECL_NAMESPACE_ALIAS (newdecl)
3339            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3340     /* Redeclaration of namespace alias, ignore it. */
3341     return 1;
3342   else
3343     {
3344       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3345       if (errmsg)
3346         {
3347           error (errmsg, newdecl);
3348           if (DECL_NAME (olddecl) != NULL_TREE)
3349             cp_error_at ((DECL_INITIAL (olddecl)
3350                           && namespace_bindings_p ())
3351                          ? "`%#D' previously defined here"
3352                          : "`%#D' previously declared here", olddecl);
3353           return 0;
3354         }
3355       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3356                && DECL_INITIAL (olddecl) != NULL_TREE
3357                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3358                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3359         {
3360           /* Prototype decl follows defn w/o prototype.  */
3361           cp_warning_at ("prototype for `%#D'", newdecl);
3362           cp_warning_at ("follows non-prototype definition here", olddecl);
3363         }
3364       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3365                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3366         {
3367           /* extern "C" int foo ();
3368              int foo () { bar (); }
3369              is OK.  */
3370           if (current_lang_depth () == 0)
3371             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3372           else
3373             {
3374               cp_error_at ("previous declaration of `%#D' with %L linkage",
3375                            olddecl, DECL_LANGUAGE (olddecl));
3376               error ("conflicts with new declaration with %L linkage",
3377                         DECL_LANGUAGE (newdecl));
3378             }
3379         }
3380
3381       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3382         ;
3383       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3384         {
3385           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3386           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3387           int i = 1;
3388
3389           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3390             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3391
3392           for (; t1 && t1 != void_list_node;
3393                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3394             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3395               {
3396                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3397                                            TREE_PURPOSE (t2)))
3398                   {
3399                     pedwarn ("default argument given for parameter %d of `%#D'",
3400                              i, newdecl);
3401                     cp_pedwarn_at ("after previous specification in `%#D'",
3402                                    olddecl);
3403                   }
3404                 else
3405                   {
3406                     error ("default argument given for parameter %d of `%#D'",
3407                               i, newdecl);
3408                     cp_error_at ("after previous specification in `%#D'",
3409                                  olddecl);
3410                   }
3411               }
3412
3413           if (DECL_DECLARED_INLINE_P (newdecl)
3414               && ! DECL_DECLARED_INLINE_P (olddecl)
3415               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3416             {
3417               warning ("`%#D' was used before it was declared inline",
3418                           newdecl);
3419               cp_warning_at ("previous non-inline declaration here",
3420                              olddecl);
3421             }
3422         }
3423     }
3424
3425   /* Do not merge an implicit typedef with an explicit one.  In:
3426
3427        class A;
3428        ...
3429        typedef class A A __attribute__ ((foo));
3430
3431      the attribute should apply only to the typedef.  */
3432   if (TREE_CODE (olddecl) == TYPE_DECL
3433       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3434           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3435     return 0;
3436
3437   /* If new decl is `static' and an `extern' was seen previously,
3438      warn about it.  */
3439   warn_extern_redeclared_static (newdecl, olddecl);
3440
3441   /* We have committed to returning 1 at this point.  */
3442   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3443     {
3444       /* Now that functions must hold information normally held
3445          by field decls, there is extra work to do so that
3446          declaration information does not get destroyed during
3447          definition.  */
3448       if (DECL_VINDEX (olddecl))
3449         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3450       if (DECL_VIRTUAL_CONTEXT (olddecl))
3451         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3452       if (DECL_CONTEXT (olddecl))
3453         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3454       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3455         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3456       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3457       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3458       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3459       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3460       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3461       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3462       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3463         SET_OVERLOADED_OPERATOR_CODE
3464           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3465       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3466
3467       /* Optionally warn about more than one declaration for the same
3468          name, but don't warn about a function declaration followed by a
3469          definition.  */
3470       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3471           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3472           /* Don't warn about extern decl followed by definition. */
3473           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3474           /* Don't warn about friends, let add_friend take care of it. */
3475           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3476         {
3477           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3478           cp_warning_at ("previous declaration of `%D'", olddecl);
3479         }
3480     }
3481
3482   /* Deal with C++: must preserve virtual function table size.  */
3483   if (TREE_CODE (olddecl) == TYPE_DECL)
3484     {
3485       register tree newtype = TREE_TYPE (newdecl);
3486       register tree oldtype = TREE_TYPE (olddecl);
3487
3488       if (newtype != error_mark_node && oldtype != error_mark_node
3489           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3490         {
3491           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3492           CLASSTYPE_FRIEND_CLASSES (newtype)
3493             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3494         }
3495
3496       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3497     }
3498
3499   /* Copy all the DECL_... slots specified in the new decl
3500      except for any that we copy here from the old type.  */
3501   DECL_ATTRIBUTES (newdecl)
3502     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3503
3504   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3505     {
3506       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3507       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3508         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3509                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3510
3511       /* If the new declaration is a definition, update the file and
3512          line information on the declaration.  */
3513       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3514           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3515         {
3516           DECL_SOURCE_LINE (olddecl)
3517             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3518             = DECL_SOURCE_LINE (newdecl);
3519           DECL_SOURCE_FILE (olddecl)
3520             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3521             = DECL_SOURCE_FILE (newdecl);
3522         }
3523
3524       return 1;
3525     }
3526
3527   if (types_match)
3528     {
3529       /* Automatically handles default parameters.  */
3530       tree oldtype = TREE_TYPE (olddecl);
3531       tree newtype;
3532
3533       /* Merge the data types specified in the two decls.  */
3534       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3535
3536       /* If merge_types produces a non-typedef type, just use the old type.  */
3537       if (TREE_CODE (newdecl) == TYPE_DECL
3538           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3539         newtype = oldtype;
3540
3541       if (TREE_CODE (newdecl) == VAR_DECL)
3542         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3543       /* Do this after calling `merge_types' so that default
3544          parameters don't confuse us.  */
3545       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3546           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3547               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3548         {
3549           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3550                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3551           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3552                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3553
3554           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3555               && DECL_SOURCE_LINE (olddecl) != 0
3556               && flag_exceptions
3557               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3558                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3559             {
3560               error ("declaration of `%F' throws different exceptions",
3561                         newdecl);
3562               cp_error_at ("than previous declaration `%F'", olddecl);
3563             }
3564         }
3565       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3566
3567       /* Lay the type out, unless already done.  */
3568       if (! same_type_p (newtype, oldtype)
3569           && TREE_TYPE (newdecl) != error_mark_node
3570           && !(processing_template_decl && uses_template_parms (newdecl)))
3571         layout_type (TREE_TYPE (newdecl));
3572
3573       if ((TREE_CODE (newdecl) == VAR_DECL
3574            || TREE_CODE (newdecl) == PARM_DECL
3575            || TREE_CODE (newdecl) == RESULT_DECL
3576            || TREE_CODE (newdecl) == FIELD_DECL
3577            || TREE_CODE (newdecl) == TYPE_DECL)
3578           && !(processing_template_decl && uses_template_parms (newdecl)))
3579         layout_decl (newdecl, 0);
3580
3581       /* Merge the type qualifiers.  */
3582       if (TREE_READONLY (newdecl))
3583         TREE_READONLY (olddecl) = 1;
3584       if (TREE_THIS_VOLATILE (newdecl))
3585         TREE_THIS_VOLATILE (olddecl) = 1;
3586
3587       /* Merge the initialization information.  */
3588       if (DECL_INITIAL (newdecl) == NULL_TREE
3589           && DECL_INITIAL (olddecl) != NULL_TREE)
3590         {
3591           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3592           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3593           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3594           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3595               && DECL_LANG_SPECIFIC (newdecl)
3596               && DECL_LANG_SPECIFIC (olddecl))
3597             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3598         }
3599
3600       /* Merge the section attribute.
3601          We want to issue an error if the sections conflict but that must be
3602          done later in decl_attributes since we are called before attributes
3603          are assigned.  */
3604       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3605         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3606
3607       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3608         {
3609           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3610             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3611           DECL_NO_LIMIT_STACK (newdecl)
3612             |= DECL_NO_LIMIT_STACK (olddecl);
3613           /* Keep the old RTL.  */
3614           COPY_DECL_RTL (olddecl, newdecl);
3615         }
3616       else if (TREE_CODE (newdecl) == VAR_DECL
3617                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3618         {
3619           /* Keep the old RTL.  We cannot keep the old RTL if the old
3620              declaration was for an incomplete object and the new
3621              declaration is not since many attributes of the RTL will
3622              change.  */
3623           COPY_DECL_RTL (olddecl, newdecl);
3624         }
3625     }
3626   /* If cannot merge, then use the new type and qualifiers,
3627      and don't preserve the old rtl.  */
3628   else
3629     {
3630       /* Clean out any memory we had of the old declaration.  */
3631       tree oldstatic = value_member (olddecl, static_aggregates);
3632       if (oldstatic)
3633         TREE_VALUE (oldstatic) = error_mark_node;
3634
3635       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3636       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3637       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3638       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3639     }
3640
3641   /* Merge the storage class information.  */
3642   merge_weak (newdecl, olddecl);
3643
3644   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3645   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3646   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3647   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3648   if (! DECL_EXTERNAL (olddecl))
3649     DECL_EXTERNAL (newdecl) = 0;
3650
3651   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3652     {
3653       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3654       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3655       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3656       DECL_TEMPLATE_INSTANTIATED (newdecl)
3657         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3658       /* Don't really know how much of the language-specific
3659          values we should copy from old to new.  */
3660       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3661       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3662       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3663       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3664       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3665         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3666       olddecl_friend = DECL_FRIEND_P (olddecl);
3667
3668       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3669       if (TREE_CODE (newdecl) == FUNCTION_DECL
3670           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3671         DECL_BEFRIENDING_CLASSES (newdecl)
3672           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3673                      DECL_BEFRIENDING_CLASSES (olddecl));
3674     }
3675
3676   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3677     {
3678       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3679           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3680         {
3681           /* If newdecl is not a specialization, then it is not a
3682              template-related function at all.  And that means that we
3683              shoud have exited above, returning 0.  */
3684           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3685                               0);
3686
3687           if (TREE_USED (olddecl))
3688             /* From [temp.expl.spec]:
3689
3690                If a template, a member template or the member of a class
3691                template is explicitly specialized then that
3692                specialization shall be declared before the first use of
3693                that specialization that would cause an implicit
3694                instantiation to take place, in every translation unit in
3695                which such a use occurs.  */
3696             error ("explicit specialization of %D after first use",
3697                       olddecl);
3698
3699           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3700         }
3701       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3702
3703       /* If either decl says `inline', this fn is inline, unless its
3704          definition was passed already.  */
3705       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3706         DECL_INLINE (olddecl) = 1;
3707       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3708
3709       DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3710         = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3711
3712       /* Preserve abstractness on cloned [cd]tors.  */
3713       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3714
3715       if (! types_match)
3716         {
3717           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3718           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3719           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3720         }
3721       if (! types_match || new_defines_function)
3722         {
3723           /* These need to be copied so that the names are available.
3724              Note that if the types do match, we'll preserve inline
3725              info and other bits, but if not, we won't.  */
3726           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3727           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3728         }
3729       if (new_defines_function)
3730         /* If defining a function declared with other language
3731            linkage, use the previously declared language linkage.  */
3732         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3733       else if (types_match)
3734         {
3735           /* If redeclaring a builtin function, and not a definition,
3736              it stays built in.  */
3737           if (DECL_BUILT_IN (olddecl))
3738             {
3739               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3740               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3741               /* If we're keeping the built-in definition, keep the rtl,
3742                  regardless of declaration matches.  */
3743               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3744             }
3745           else
3746             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3747
3748           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3749           /* Don't clear out the arguments if we're redefining a function.  */
3750           if (DECL_ARGUMENTS (olddecl))
3751             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3752         }
3753     }
3754   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3755     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3756
3757   /* Now preserve various other info from the definition.  */
3758   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3759   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3760   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3761   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3762
3763   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3764     {
3765       int function_size;
3766
3767       function_size = sizeof (struct tree_decl);
3768
3769       memcpy ((char *) olddecl + sizeof (struct tree_common),
3770               (char *) newdecl + sizeof (struct tree_common),
3771               function_size - sizeof (struct tree_common));
3772
3773       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3774         {
3775           /* If newdecl is a template instantiation, it is possible that
3776              the following sequence of events has occurred:
3777
3778              o A friend function was declared in a class template.  The
3779              class template was instantiated.
3780
3781              o The instantiation of the friend declaration was
3782              recorded on the instantiation list, and is newdecl.
3783
3784              o Later, however, instantiate_class_template called pushdecl
3785              on the newdecl to perform name injection.  But, pushdecl in
3786              turn called duplicate_decls when it discovered that another
3787              declaration of a global function with the same name already
3788              existed.
3789
3790              o Here, in duplicate_decls, we decided to clobber newdecl.
3791
3792              If we're going to do that, we'd better make sure that
3793              olddecl, and not newdecl, is on the list of
3794              instantiations so that if we try to do the instantiation
3795              again we won't get the clobbered declaration.  */
3796
3797           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3798           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3799
3800           for (; decls; decls = TREE_CHAIN (decls))
3801             if (TREE_VALUE (decls) == newdecl)
3802               TREE_VALUE (decls) = olddecl;
3803         }
3804     }
3805   else
3806     {
3807       memcpy ((char *) olddecl + sizeof (struct tree_common),
3808               (char *) newdecl + sizeof (struct tree_common),
3809               sizeof (struct tree_decl) - sizeof (struct tree_common)
3810               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3811     }
3812
3813   DECL_UID (olddecl) = olddecl_uid;
3814   if (olddecl_friend)
3815     DECL_FRIEND_P (olddecl) = 1;
3816
3817   /* NEWDECL contains the merged attribute lists.
3818      Update OLDDECL to be the same.  */
3819   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3820
3821   return 1;
3822 }
3823
3824 /* Record a decl-node X as belonging to the current lexical scope.
3825    Check for errors (such as an incompatible declaration for the same
3826    name already seen in the same scope).
3827
3828    Returns either X or an old decl for the same name.
3829    If an old decl is returned, it may have been smashed
3830    to agree with what X says.  */
3831
3832 tree
3833 pushdecl (x)
3834      tree x;
3835 {
3836   register tree t;
3837   register tree name;
3838   int need_new_binding;
3839
3840   /* We shouldn't be calling pushdecl when we're generating RTL for a
3841      function that we already did semantic analysis on previously.  */
3842   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3843                       19990913);
3844
3845   need_new_binding = 1;
3846
3847   if (DECL_TEMPLATE_PARM_P (x))
3848     /* Template parameters have no context; they are not X::T even
3849        when declared within a class or namespace.  */
3850     ;
3851   else
3852     {
3853       if (current_function_decl && x != current_function_decl
3854           /* A local declaration for a function doesn't constitute
3855              nesting.  */
3856           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3857           /* A local declaration for an `extern' variable is in the
3858              scope of the current namespace, not the current
3859              function.  */
3860           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3861           && !DECL_CONTEXT (x))
3862         DECL_CONTEXT (x) = current_function_decl;
3863
3864       /* If this is the declaration for a namespace-scope function,
3865          but the declaration itself is in a local scope, mark the
3866          declaration.  */
3867       if (TREE_CODE (x) == FUNCTION_DECL
3868           && DECL_NAMESPACE_SCOPE_P (x)
3869           && current_function_decl
3870           && x != current_function_decl)
3871         DECL_LOCAL_FUNCTION_P (x) = 1;
3872     }
3873
3874   name = DECL_NAME (x);
3875   if (name)
3876     {
3877       int different_binding_level = 0;
3878
3879       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3880         name = TREE_OPERAND (name, 0);
3881
3882       /* In case this decl was explicitly namespace-qualified, look it
3883          up in its namespace context.  */
3884       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3885           && namespace_bindings_p ())
3886         t = namespace_binding (name, DECL_CONTEXT (x));
3887       else
3888         t = lookup_name_current_level (name);
3889
3890       /* [basic.link] If there is a visible declaration of an entity
3891          with linkage having the same name and type, ignoring entities
3892          declared outside the innermost enclosing namespace scope, the
3893          block scope declaration declares that same entity and
3894          receives the linkage of the previous declaration.  */
3895       if (! t && current_function_decl && x != current_function_decl
3896           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3897           && DECL_EXTERNAL (x))
3898         {
3899           /* Look in block scope.  */
3900           t = IDENTIFIER_VALUE (name);
3901           /* Or in the innermost namespace.  */
3902           if (! t)
3903             t = namespace_binding (name, DECL_CONTEXT (x));
3904           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3905              OVERLOAD, which is OK.  */
3906           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3907             t = NULL_TREE;
3908           if (t)
3909             different_binding_level = 1;
3910         }
3911
3912       /* If we are declaring a function, and the result of name-lookup
3913          was an OVERLOAD, look for an overloaded instance that is
3914          actually the same as the function we are declaring.  (If
3915          there is one, we have to merge our declaration with the
3916          previous declaration.)  */
3917       if (t && TREE_CODE (t) == OVERLOAD)
3918         {
3919           tree match;
3920
3921           if (TREE_CODE (x) == FUNCTION_DECL)
3922             for (match = t; match; match = OVL_NEXT (match))
3923               {
3924                 if (decls_match (OVL_CURRENT (match), x))
3925                   break;
3926               }
3927           else
3928             /* Just choose one.  */
3929             match = t;
3930
3931           if (match)
3932             t = OVL_CURRENT (match);
3933           else
3934             t = NULL_TREE;
3935         }
3936
3937       if (t == error_mark_node)
3938         {
3939           /* error_mark_node is 0 for a while during initialization!  */
3940           t = NULL_TREE;
3941           cp_error_at ("`%#D' used prior to declaration", x);
3942         }
3943       else if (t != NULL_TREE)
3944         {
3945           if (different_binding_level)
3946             {
3947               if (decls_match (x, t))
3948                 /* The standard only says that the local extern
3949                    inherits linkage from the previous decl; in
3950                    particular, default args are not shared.  It would
3951                    be nice to propagate inlining info, though.  FIXME.  */
3952                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3953             }
3954           else if (TREE_CODE (t) == PARM_DECL)
3955             {
3956               if (DECL_CONTEXT (t) == NULL_TREE)
3957                 /* This is probaby caused by too many errors, but calling
3958                    abort will say that if errors have occurred.  */
3959                 abort ();
3960
3961               /* Check for duplicate params.  */
3962               if (duplicate_decls (x, t))
3963                 return t;
3964             }
3965           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3966                     || DECL_FUNCTION_TEMPLATE_P (x))
3967                    && is_overloaded_fn (t))
3968             /* Don't do anything just yet. */;
3969           else if (t == wchar_decl_node)
3970             {
3971               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3972                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3973                             TREE_TYPE (x));
3974
3975               /* Throw away the redeclaration.  */
3976               return t;
3977             }
3978           else if (TREE_CODE (t) != TREE_CODE (x))
3979             {
3980               if (duplicate_decls (x, t))
3981                 return t;
3982             }
3983           else if (duplicate_decls (x, t))
3984             {
3985               if (TREE_CODE (t) == TYPE_DECL)
3986                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3987               else if (TREE_CODE (t) == FUNCTION_DECL)
3988                 check_default_args (t);
3989
3990               return t;
3991             }
3992           else if (DECL_MAIN_P (x))
3993             {
3994               /* A redeclaration of main, but not a duplicate of the
3995                  previous one.
3996
3997                  [basic.start.main]
3998
3999                  This function shall not be overloaded.  */
4000               cp_error_at ("invalid redeclaration of `%D'", t);
4001               error ("as `%D'", x);
4002               /* We don't try to push this declaration since that
4003                  causes a crash.  */
4004               return x;
4005             }
4006         }
4007
4008       check_template_shadow (x);
4009
4010       /* If this is a function conjured up by the backend, massage it
4011          so it looks friendly.  */
4012       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
4013         {
4014           retrofit_lang_decl (x);
4015           SET_DECL_LANGUAGE (x, lang_c);
4016         }
4017
4018       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4019         {
4020           t = push_overloaded_decl (x, PUSH_LOCAL);
4021           if (t != x)
4022             return t;
4023           if (!namespace_bindings_p ())
4024             /* We do not need to create a binding for this name;
4025                push_overloaded_decl will have already done so if
4026                necessary.  */
4027             need_new_binding = 0;
4028         }
4029       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4030         {
4031           t = push_overloaded_decl (x, PUSH_GLOBAL);
4032           if (t == x)
4033             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4034           return t;
4035         }
4036
4037       /* If declaring a type as a typedef, copy the type (unless we're
4038          at line 0), and install this TYPE_DECL as the new type's typedef
4039          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4040       if (TREE_CODE (x) == TYPE_DECL)
4041         {
4042           tree type = TREE_TYPE (x);
4043           if (DECL_SOURCE_LINE (x) == 0)
4044             {
4045               if (TYPE_NAME (type) == 0)
4046                 TYPE_NAME (type) = x;
4047             }
4048           else if (type != error_mark_node && TYPE_NAME (type) != x
4049                    /* We don't want to copy the type when all we're
4050                       doing is making a TYPE_DECL for the purposes of
4051                       inlining.  */
4052                    && (!TYPE_NAME (type)
4053                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4054             {
4055               DECL_ORIGINAL_TYPE (x) = type;
4056               type = build_type_copy (type);
4057               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4058               TYPE_NAME (type) = x;
4059               TREE_TYPE (x) = type;
4060             }
4061
4062           if (type != error_mark_node
4063               && TYPE_NAME (type)
4064               && TYPE_IDENTIFIER (type))
4065             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4066                                                   current_binding_level);
4067
4068         }
4069
4070       /* Multiple external decls of the same identifier ought to match.
4071
4072          We get warnings about inline functions where they are defined.
4073          We get warnings about other functions from push_overloaded_decl.
4074
4075          Avoid duplicate warnings where they are used.  */
4076       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4077         {
4078           tree decl;
4079
4080           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4081           if (decl && TREE_CODE (decl) == OVERLOAD)
4082             decl = OVL_FUNCTION (decl);
4083
4084           if (decl && decl != error_mark_node
4085               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4086               /* If different sort of thing, we already gave an error.  */
4087               && TREE_CODE (decl) == TREE_CODE (x)
4088               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4089             {
4090               pedwarn ("type mismatch with previous external decl", x);
4091               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4092             }
4093         }
4094
4095       /* This name is new in its binding level.
4096          Install the new declaration and return it.  */
4097       if (namespace_bindings_p ())
4098         {
4099           /* Install a global value.  */
4100
4101           /* If the first global decl has external linkage,
4102              warn if we later see static one.  */
4103           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4104             TREE_PUBLIC (name) = 1;
4105
4106           /* Bind the name for the entity.  */
4107           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4108                 && t != NULL_TREE)
4109               && (TREE_CODE (x) == TYPE_DECL
4110                   || TREE_CODE (x) == VAR_DECL
4111                   || TREE_CODE (x) == NAMESPACE_DECL
4112                   || TREE_CODE (x) == CONST_DECL
4113                   || TREE_CODE (x) == TEMPLATE_DECL))
4114             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4115
4116           /* Don't forget if the function was used via an implicit decl.  */
4117           if (IDENTIFIER_IMPLICIT_DECL (name)
4118               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4119             TREE_USED (x) = 1;
4120
4121           /* Don't forget if its address was taken in that way.  */
4122           if (IDENTIFIER_IMPLICIT_DECL (name)
4123               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4124             TREE_ADDRESSABLE (x) = 1;
4125
4126           /* Warn about mismatches against previous implicit decl.  */
4127           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4128               /* If this real decl matches the implicit, don't complain.  */
4129               && ! (TREE_CODE (x) == FUNCTION_DECL
4130                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4131             warning
4132               ("`%D' was previously implicitly declared to return `int'", x);
4133
4134           /* If new decl is `static' and an `extern' was seen previously,
4135              warn about it.  */
4136           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4137             warn_extern_redeclared_static (x, t);
4138         }
4139       else
4140         {
4141           /* Here to install a non-global value.  */
4142           tree oldlocal = IDENTIFIER_VALUE (name);
4143           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4144
4145           if (need_new_binding)
4146             {
4147               push_local_binding (name, x, 0);
4148               /* Because push_local_binding will hook X on to the
4149                  current_binding_level's name list, we don't want to
4150                  do that again below.  */
4151               need_new_binding = 0;
4152             }
4153
4154           /* If this is a TYPE_DECL, push it into the type value slot.  */
4155           if (TREE_CODE (x) == TYPE_DECL)
4156             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4157                                                   current_binding_level);
4158
4159           /* Clear out any TYPE_DECL shadowed by a namespace so that
4160              we won't think this is a type.  The C struct hack doesn't
4161              go through namespaces.  */
4162           if (TREE_CODE (x) == NAMESPACE_DECL)
4163             set_identifier_type_value_with_scope (name, NULL_TREE,
4164                                                   current_binding_level);
4165
4166           if (oldlocal)
4167             {
4168               tree d = oldlocal;
4169
4170               while (oldlocal
4171                      && TREE_CODE (oldlocal) == VAR_DECL
4172                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4173                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4174
4175               if (oldlocal == NULL_TREE)
4176                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4177             }
4178
4179           /* If this is an extern function declaration, see if we
4180              have a global definition or declaration for the function.  */
4181           if (oldlocal == NULL_TREE
4182               && DECL_EXTERNAL (x)
4183               && oldglobal != NULL_TREE
4184               && TREE_CODE (x) == FUNCTION_DECL
4185               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4186             {
4187               /* We have one.  Their types must agree.  */
4188               if (decls_match (x, oldglobal))
4189                 /* OK */;
4190               else
4191                 {
4192                   warning ("extern declaration of `%#D' doesn't match", x);
4193                   cp_warning_at ("global declaration `%#D'", oldglobal);
4194                 }
4195             }
4196           /* If we have a local external declaration,
4197              and no file-scope declaration has yet been seen,
4198              then if we later have a file-scope decl it must not be static.  */
4199           if (oldlocal == NULL_TREE
4200               && oldglobal == NULL_TREE
4201               && DECL_EXTERNAL (x)
4202               && TREE_PUBLIC (x))
4203             TREE_PUBLIC (name) = 1;
4204
4205           /* Warn if shadowing an argument at the top level of the body.  */
4206           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4207               /* Inline decls shadow nothing.  */
4208               && !DECL_FROM_INLINE (x)
4209               && TREE_CODE (oldlocal) == PARM_DECL)
4210             {
4211               bool err = false;
4212
4213               /* Don't complain if it's from an enclosing function.  */
4214               if (DECL_CONTEXT (oldlocal) == current_function_decl
4215                   && TREE_CODE (x) != PARM_DECL)
4216                 {
4217                   /* Go to where the parms should be and see if we find
4218                      them there.  */
4219                   struct binding_level *b = current_binding_level->level_chain;
4220
4221                   /* ARM $8.3 */
4222                   if (b->parm_flag == 1)
4223                     {
4224                       error ("declaration of `%#D' shadows a parameter",
4225                                 name);
4226                       err = true;
4227                     }
4228                 }
4229
4230               if (warn_shadow && !err)
4231                 shadow_warning ("a parameter", name, oldlocal);
4232             }
4233
4234           /* Maybe warn if shadowing something else.  */
4235           else if (warn_shadow && !DECL_EXTERNAL (x)
4236               /* No shadow warnings for internally generated vars.  */
4237               && ! DECL_ARTIFICIAL (x)
4238               /* No shadow warnings for vars made for inlining.  */
4239               && ! DECL_FROM_INLINE (x))
4240             {
4241               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4242                        && current_class_ptr
4243                        && !TREE_STATIC (name))
4244                 warning ("declaration of `%s' shadows a member of `this'",
4245                             IDENTIFIER_POINTER (name));
4246               else if (oldlocal != NULL_TREE
4247                        && TREE_CODE (oldlocal) == VAR_DECL)
4248                 shadow_warning ("a previous local", name, oldlocal);
4249               else if (oldglobal != NULL_TREE
4250                        && TREE_CODE (oldglobal) == VAR_DECL)
4251                 /* XXX shadow warnings in outer-more namespaces */
4252                 shadow_warning ("a global declaration", name, oldglobal);
4253             }
4254         }
4255
4256       if (TREE_CODE (x) == FUNCTION_DECL)
4257         check_default_args (x);
4258
4259       if (TREE_CODE (x) == VAR_DECL)
4260         maybe_register_incomplete_var (x);
4261     }
4262
4263   if (need_new_binding)
4264     add_decl_to_level (x,
4265                        DECL_NAMESPACE_SCOPE_P (x)
4266                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4267                        : current_binding_level);
4268
4269   return x;
4270 }
4271
4272 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4273    caller to set DECL_CONTEXT properly.  */
4274
4275 static tree
4276 pushdecl_with_scope (x, level)
4277      tree x;
4278      struct binding_level *level;
4279 {
4280   register struct binding_level *b;
4281   tree function_decl = current_function_decl;
4282
4283   current_function_decl = NULL_TREE;
4284   if (level->parm_flag == 2)
4285     {
4286       b = class_binding_level;
4287       class_binding_level = level;
4288       pushdecl_class_level (x);
4289       class_binding_level = b;
4290     }
4291   else
4292     {
4293       b = current_binding_level;
4294       current_binding_level = level;
4295       x = pushdecl (x);
4296       current_binding_level = b;
4297     }
4298   current_function_decl = function_decl;
4299   return x;
4300 }
4301
4302 /* Like pushdecl, only it places X in the current namespace,
4303    if appropriate.  */
4304
4305 tree
4306 pushdecl_namespace_level (x)
4307      tree x;
4308 {
4309   register struct binding_level *b = current_binding_level;
4310   register tree t;
4311
4312   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4313
4314   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4315      what we want.  */
4316   if (TREE_CODE (x) == TYPE_DECL)
4317     {
4318       tree name = DECL_NAME (x);
4319       tree newval;
4320       tree *ptr = (tree *)0;
4321       for (; b != global_binding_level; b = b->level_chain)
4322         {
4323           tree shadowed = b->type_shadowed;
4324           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4325             if (TREE_PURPOSE (shadowed) == name)
4326               {
4327                 ptr = &TREE_VALUE (shadowed);
4328                 /* Can't break out of the loop here because sometimes
4329                    a binding level will have duplicate bindings for
4330                    PT names.  It's gross, but I haven't time to fix it.  */
4331               }
4332         }
4333       newval = TREE_TYPE (x);
4334       if (ptr == (tree *)0)
4335         {
4336           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4337              up here if this is changed to an assertion.  --KR  */
4338           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4339         }
4340       else
4341         {
4342           *ptr = newval;
4343         }
4344     }
4345   return t;
4346 }
4347
4348 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4349    if appropriate.  */
4350
4351 tree
4352 pushdecl_top_level (x)
4353      tree x;
4354 {
4355   push_to_top_level ();
4356   x = pushdecl_namespace_level (x);
4357   pop_from_top_level ();
4358   return x;
4359 }
4360
4361 /* Make the declaration of X appear in CLASS scope.  */
4362
4363 void
4364 pushdecl_class_level (x)
4365      tree x;
4366 {
4367   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4368      scope looks for the pre-mangled name.  */
4369   register tree name;
4370
4371   if (TREE_CODE (x) == OVERLOAD)
4372     x = OVL_CURRENT (x);
4373   name = DECL_NAME (x);
4374
4375   if (name)
4376     {
4377       push_class_level_binding (name, x);
4378       if (TREE_CODE (x) == TYPE_DECL)
4379         set_identifier_type_value (name, TREE_TYPE (x));
4380     }
4381   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4382     {
4383       tree f;
4384
4385       for (f = TYPE_FIELDS (TREE_TYPE (x));
4386            f;
4387            f = TREE_CHAIN (f))
4388         pushdecl_class_level (f);
4389     }
4390 }
4391
4392 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4393    DECL, or a modified version thereof.  */
4394
4395 tree
4396 maybe_push_decl (decl)
4397      tree decl;
4398 {
4399   tree type = TREE_TYPE (decl);
4400
4401   /* Add this decl to the current binding level, but not if it comes
4402      from another scope, e.g. a static member variable.  TEM may equal
4403      DECL or it may be a previous decl of the same name.  */
4404   if (decl == error_mark_node
4405       || (TREE_CODE (decl) != PARM_DECL
4406           && DECL_CONTEXT (decl) != NULL_TREE
4407           /* Definitions of namespace members outside their namespace are
4408              possible. */
4409           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4410       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4411       || TREE_CODE (type) == UNKNOWN_TYPE
4412       /* The declaration of a template specialization does not affect
4413          the functions available for overload resolution, so we do not
4414          call pushdecl.  */
4415       || (TREE_CODE (decl) == FUNCTION_DECL
4416           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4417     return decl;
4418   else
4419     return pushdecl (decl);
4420 }
4421
4422 /* Make the declaration(s) of X appear in CLASS scope
4423    under the name NAME.  */
4424
4425 void
4426 push_class_level_binding (name, x)
4427      tree name;
4428      tree x;
4429 {
4430   tree binding;
4431   /* The class_binding_level will be NULL if x is a template
4432      parameter name in a member template.  */
4433   if (!class_binding_level)
4434     return;
4435
4436   /* Make sure that this new member does not have the same name
4437      as a template parameter.  */
4438   if (TYPE_BEING_DEFINED (current_class_type))
4439     check_template_shadow (x);
4440
4441   /* If this declaration shadows a declaration from an enclosing
4442      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4443      we leave this class.  Record the shadowed declaration here.  */
4444   binding = IDENTIFIER_BINDING (name);
4445   if (binding
4446       && ((TREE_CODE (x) == OVERLOAD
4447            && BINDING_VALUE (binding)
4448            && is_overloaded_fn (BINDING_VALUE (binding)))
4449           || INHERITED_VALUE_BINDING_P (binding)))
4450     {
4451       tree shadow;
4452       tree old_decl;
4453
4454       /* If the old binding was from a base class, and was for a tag
4455          name, slide it over to make room for the new binding.  The
4456          old binding is still visible if explicitly qualified with a
4457          class-key.  */
4458       if (INHERITED_VALUE_BINDING_P (binding)
4459           && BINDING_VALUE (binding)
4460           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4461           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4462           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4463         {
4464           old_decl = BINDING_TYPE (binding);
4465           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4466           BINDING_VALUE (binding) = NULL_TREE;
4467           INHERITED_VALUE_BINDING_P (binding) = 0;
4468         }
4469       else
4470         old_decl = BINDING_VALUE (binding);
4471
4472       /* Find the previous binding of name on the class-shadowed
4473          list, and update it.  */
4474       for (shadow = class_binding_level->class_shadowed;
4475            shadow;
4476            shadow = TREE_CHAIN (shadow))
4477         if (TREE_PURPOSE (shadow) == name
4478             && TREE_TYPE (shadow) == old_decl)
4479           {
4480             BINDING_VALUE (binding) = x;
4481             INHERITED_VALUE_BINDING_P (binding) = 0;
4482             TREE_TYPE (shadow) = x;
4483             IDENTIFIER_CLASS_VALUE (name) = x;
4484             return;
4485           }
4486     }
4487
4488   /* If we didn't replace an existing binding, put the binding on the
4489      stack of bindings for the identifier, and update the shadowed list.  */
4490   if (push_class_binding (name, x))
4491     {
4492       class_binding_level->class_shadowed
4493         = tree_cons (name, NULL,
4494                      class_binding_level->class_shadowed);
4495       /* Record the value we are binding NAME to so that we can know
4496          what to pop later.  */
4497       TREE_TYPE (class_binding_level->class_shadowed) = x;
4498     }
4499 }
4500
4501 /* Insert another USING_DECL into the current binding level, returning
4502    this declaration. If this is a redeclaration, do nothing, and
4503    return NULL_TREE if this not in namespace scope (in namespace
4504    scope, a using decl might extend any previous bindings).  */
4505
4506 tree
4507 push_using_decl (scope, name)
4508      tree scope;
4509      tree name;
4510 {
4511   tree decl;
4512
4513   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4514   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4515   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4516     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4517       break;
4518   if (decl)
4519     return namespace_bindings_p () ? decl : NULL_TREE;
4520   decl = build_lang_decl (USING_DECL, name, void_type_node);
4521   DECL_INITIAL (decl) = scope;
4522   TREE_CHAIN (decl) = current_binding_level->usings;
4523   current_binding_level->usings = decl;
4524   return decl;
4525 }
4526
4527 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4528    changed (i.e. there was already a directive), or the fresh
4529    TREE_LIST otherwise.  */
4530
4531 tree
4532 push_using_directive (used)
4533      tree used;
4534 {
4535   tree ud = current_binding_level->using_directives;
4536   tree iter, ancestor;
4537
4538   /* Check if we already have this. */
4539   if (purpose_member (used, ud) != NULL_TREE)
4540     return NULL_TREE;
4541
4542   /* Recursively add all namespaces used. */
4543   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4544     push_using_directive (TREE_PURPOSE (iter));
4545
4546   ancestor = namespace_ancestor (current_decl_namespace (), used);
4547   ud = current_binding_level->using_directives;
4548   ud = tree_cons (used, ancestor, ud);
4549   current_binding_level->using_directives = ud;
4550   return ud;
4551 }
4552
4553 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4554    other definitions already in place.  We get around this by making
4555    the value of the identifier point to a list of all the things that
4556    want to be referenced by that name.  It is then up to the users of
4557    that name to decide what to do with that list.
4558
4559    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4560    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4561
4562    FLAGS is a bitwise-or of the following values:
4563      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4564                  namespace scope.
4565      PUSH_USING: DECL is being pushed as the result of a using
4566                  declaration.
4567
4568    The value returned may be a previous declaration if we guessed wrong
4569    about what language DECL should belong to (C or C++).  Otherwise,
4570    it's always DECL (and never something that's not a _DECL).  */
4571
4572 tree
4573 push_overloaded_decl (decl, flags)
4574      tree decl;
4575      int flags;
4576 {
4577   tree name = DECL_NAME (decl);
4578   tree old;
4579   tree new_binding;
4580   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4581
4582   if (doing_global)
4583     old = namespace_binding (name, DECL_CONTEXT (decl));
4584   else
4585     old = lookup_name_current_level (name);
4586
4587   if (old)
4588     {
4589       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4590         {
4591           tree t = TREE_TYPE (old);
4592           if (IS_AGGR_TYPE (t) && warn_shadow
4593               && (! DECL_IN_SYSTEM_HEADER (decl)
4594                   || ! DECL_IN_SYSTEM_HEADER (old)))
4595             warning ("`%#D' hides constructor for `%#T'", decl, t);
4596           old = NULL_TREE;
4597         }
4598       else if (is_overloaded_fn (old))
4599         {
4600           tree tmp;
4601
4602           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4603             {
4604               tree fn = OVL_CURRENT (tmp);
4605
4606               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4607                   && !(flags & PUSH_USING)
4608                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4609                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4610                 error ("`%#D' conflicts with previous using declaration `%#D'",
4611                           decl, fn);
4612
4613               if (duplicate_decls (decl, fn))
4614                 return fn;
4615             }
4616         }
4617       else if (old == error_mark_node)
4618         /* Ignore the undefined symbol marker.  */
4619         old = NULL_TREE;
4620       else
4621         {
4622           cp_error_at ("previous non-function declaration `%#D'", old);
4623           error ("conflicts with function declaration `%#D'", decl);
4624           return decl;
4625         }
4626     }
4627
4628   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4629     {
4630       if (old && TREE_CODE (old) != OVERLOAD)
4631         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4632       else
4633         new_binding = ovl_cons (decl, old);
4634       if (flags & PUSH_USING)
4635         OVL_USED (new_binding) = 1;
4636     }
4637   else
4638     /* NAME is not ambiguous.  */
4639     new_binding = decl;
4640
4641   if (doing_global)
4642     set_namespace_binding (name, current_namespace, new_binding);
4643   else
4644     {
4645       /* We only create an OVERLOAD if there was a previous binding at
4646          this level, or if decl is a template. In the former case, we
4647          need to remove the old binding and replace it with the new
4648          binding.  We must also run through the NAMES on the binding
4649          level where the name was bound to update the chain.  */
4650
4651       if (TREE_CODE (new_binding) == OVERLOAD && old)
4652         {
4653           tree *d;
4654
4655           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4656                *d;
4657                d = &TREE_CHAIN (*d))
4658             if (*d == old
4659                 || (TREE_CODE (*d) == TREE_LIST
4660                     && TREE_VALUE (*d) == old))
4661               {
4662                 if (TREE_CODE (*d) == TREE_LIST)
4663                   /* Just replace the old binding with the new.  */
4664                   TREE_VALUE (*d) = new_binding;
4665                 else
4666                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4667                   *d = tree_cons (NULL_TREE, new_binding,
4668                                   TREE_CHAIN (*d));
4669
4670                 /* And update the CPLUS_BINDING node.  */
4671                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4672                   = new_binding;
4673                 return decl;
4674               }
4675
4676           /* We should always find a previous binding in this case.  */
4677           abort ();
4678         }
4679
4680       /* Install the new binding.  */
4681       push_local_binding (name, new_binding, flags);
4682     }
4683
4684   return decl;
4685 }
4686 \f
4687 /* Generate an implicit declaration for identifier FUNCTIONID
4688    as a function of type int ().  Print a warning if appropriate.  */
4689
4690 tree
4691 implicitly_declare (functionid)
4692      tree functionid;
4693 {
4694   register tree decl;
4695
4696   /* We used to reuse an old implicit decl here,
4697      but this loses with inline functions because it can clobber
4698      the saved decl chains.  */
4699   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4700
4701   DECL_EXTERNAL (decl) = 1;
4702   TREE_PUBLIC (decl) = 1;
4703
4704   /* ISO standard says implicit declarations are in the innermost block.
4705      So we record the decl in the standard fashion.  */
4706   pushdecl (decl);
4707   rest_of_decl_compilation (decl, NULL, 0, 0);
4708
4709   if (warn_implicit
4710       /* Only one warning per identifier.  */
4711       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4712     {
4713       pedwarn ("implicit declaration of function `%#D'", decl);
4714     }
4715
4716   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4717
4718   return decl;
4719 }
4720
4721 /* Return zero if the declaration NEWDECL is valid
4722    when the declaration OLDDECL (assumed to be for the same name)
4723    has already been seen.
4724    Otherwise return an error message format string with a %s
4725    where the identifier should go.  */
4726
4727 static const char *
4728 redeclaration_error_message (newdecl, olddecl)
4729      tree newdecl, olddecl;
4730 {
4731   if (TREE_CODE (newdecl) == TYPE_DECL)
4732     {
4733       /* Because C++ can put things into name space for free,
4734          constructs like "typedef struct foo { ... } foo"
4735          would look like an erroneous redeclaration.  */
4736       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4737         return 0;
4738       else
4739         return "redefinition of `%#D'";
4740     }
4741   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4742     {
4743       /* If this is a pure function, its olddecl will actually be
4744          the original initialization to `0' (which we force to call
4745          abort()).  Don't complain about redefinition in this case.  */
4746       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4747         return 0;
4748
4749       /* If both functions come from different namespaces, this is not
4750          a redeclaration - this is a conflict with a used function. */
4751       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4752           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4753         return "`%D' conflicts with used function";
4754
4755       /* We'll complain about linkage mismatches in
4756          warn_extern_redeclared_static.  */
4757
4758       /* Defining the same name twice is no good.  */
4759       if (DECL_INITIAL (olddecl) != NULL_TREE
4760           && DECL_INITIAL (newdecl) != NULL_TREE)
4761         {
4762           if (DECL_NAME (olddecl) == NULL_TREE)
4763             return "`%#D' not declared in class";
4764           else
4765             return "redefinition of `%#D'";
4766         }
4767       return 0;
4768     }
4769   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4770     {
4771       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4772            && (DECL_TEMPLATE_RESULT (newdecl)
4773                != DECL_TEMPLATE_RESULT (olddecl))
4774            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4775            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4776           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4777               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4778               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4779         return "redefinition of `%#D'";
4780       return 0;
4781     }
4782   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4783     {
4784       /* Objects declared at top level:  */
4785       /* If at least one is a reference, it's ok.  */
4786       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4787         return 0;
4788       /* Reject two definitions.  */
4789       return "redefinition of `%#D'";
4790     }
4791   else
4792     {
4793       /* Objects declared with block scope:  */
4794       /* Reject two definitions, and reject a definition
4795          together with an external reference.  */
4796       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4797         return "redeclaration of `%#D'";
4798       return 0;
4799     }
4800 }
4801 \f
4802 /* Create a new label, named ID.  */
4803
4804 static tree
4805 make_label_decl (id, local_p)
4806      tree id;
4807      int local_p;
4808 {
4809   tree decl;
4810
4811   decl = build_decl (LABEL_DECL, id, void_type_node);
4812   if (expanding_p)
4813     /* Make sure every label has an rtx.  */
4814     label_rtx (decl);
4815
4816   DECL_CONTEXT (decl) = current_function_decl;
4817   DECL_MODE (decl) = VOIDmode;
4818   C_DECLARED_LABEL_FLAG (decl) = local_p;
4819
4820   /* Say where one reference is to the label, for the sake of the
4821      error if it is not defined.  */
4822   DECL_SOURCE_LINE (decl) = lineno;
4823   DECL_SOURCE_FILE (decl) = input_filename;
4824
4825   /* Record the fact that this identifier is bound to this label.  */
4826   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4827
4828   return decl;
4829 }
4830
4831 /* Record this label on the list of used labels so that we can check
4832    at the end of the function to see whether or not the label was
4833    actually defined, and so we can check when the label is defined whether
4834    this use is valid.  */
4835
4836 static void
4837 use_label (decl)
4838      tree decl;
4839 {
4840   if (named_label_uses == NULL
4841       || named_label_uses->names_in_scope != current_binding_level->names
4842       || named_label_uses->label_decl != decl)
4843     {
4844       struct named_label_use_list *new_ent;
4845       new_ent = ((struct named_label_use_list *)
4846                  ggc_alloc (sizeof (struct named_label_use_list)));
4847       new_ent->label_decl = decl;
4848       new_ent->names_in_scope = current_binding_level->names;
4849       new_ent->binding_level = current_binding_level;
4850       new_ent->lineno_o_goto = lineno;
4851       new_ent->filename_o_goto = input_filename;
4852       new_ent->next = named_label_uses;
4853       named_label_uses = new_ent;
4854     }
4855 }
4856
4857 /* Look for a label named ID in the current function.  If one cannot
4858    be found, create one.  (We keep track of used, but undefined,
4859    labels, and complain about them at the end of a function.)  */
4860
4861 tree
4862 lookup_label (id)
4863      tree id;
4864 {
4865   tree decl;
4866   struct named_label_list *ent;
4867
4868   /* You can't use labels at global scope.  */
4869   if (current_function_decl == NULL_TREE)
4870     {
4871       error ("label `%s' referenced outside of any function",
4872              IDENTIFIER_POINTER (id));
4873       return NULL_TREE;
4874     }
4875
4876   /* See if we've already got this label.  */
4877   decl = IDENTIFIER_LABEL_VALUE (id);
4878   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4879     return decl;
4880
4881   /* Record this label on the list of labels used in this function.
4882      We do this before calling make_label_decl so that we get the
4883      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4884   ent = ((struct named_label_list *)
4885          ggc_alloc_cleared (sizeof (struct named_label_list)));
4886   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4887   ent->next = named_labels;
4888   named_labels = ent;
4889
4890   /* We need a new label.  */
4891   decl = make_label_decl (id, /*local_p=*/0);
4892
4893   /* Now fill in the information we didn't have before.  */
4894   ent->label_decl = decl;
4895
4896   return decl;
4897 }
4898
4899 /* Declare a local label named ID.  */
4900
4901 tree
4902 declare_local_label (id)
4903      tree id;
4904 {
4905   tree decl;
4906
4907   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4908      this scope we can restore the old value of
4909      IDENTIFIER_TYPE_VALUE.  */
4910   current_binding_level->shadowed_labels
4911     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4912                  current_binding_level->shadowed_labels);
4913   /* Look for the label.  */
4914   decl = make_label_decl (id, /*local_p=*/1);
4915   /* Now fill in the information we didn't have before.  */
4916   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4917
4918   return decl;
4919 }
4920
4921 /* Returns nonzero if it is ill-formed to jump past the declaration of
4922    DECL.  Returns 2 if it's also a real problem.  */
4923
4924 static int
4925 decl_jump_unsafe (decl)
4926      tree decl;
4927 {
4928   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4929     return 0;
4930
4931   if (DECL_INITIAL (decl) == NULL_TREE
4932       && pod_type_p (TREE_TYPE (decl)))
4933     return 0;
4934
4935   /* This is really only important if we're crossing an initialization.
4936      The POD stuff is just pedantry; why should it matter if the class
4937      contains a field of pointer to member type?  */
4938   if (DECL_INITIAL (decl)
4939       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4940     return 2;
4941   return 1;
4942 }
4943
4944 /* Check that a single previously seen jump to a newly defined label
4945    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4946    the jump context; NAMES are the names in scope in LEVEL at the jump
4947    context; FILE and LINE are the source position of the jump or 0.  */
4948
4949 static void
4950 check_previous_goto_1 (decl, level, names, file, line)
4951      tree decl;
4952      struct binding_level *level;
4953      tree names;
4954      const char *file;
4955      int line;
4956 {
4957   int identified = 0;
4958   int saw_eh = 0;
4959   struct binding_level *b = current_binding_level;
4960   for (; b; b = b->level_chain)
4961     {
4962       tree new_decls = b->names;
4963       tree old_decls = (b == level ? names : NULL_TREE);
4964       for (; new_decls != old_decls;
4965            new_decls = TREE_CHAIN (new_decls))
4966         {
4967           int problem = decl_jump_unsafe (new_decls);
4968           if (! problem)
4969             continue;
4970
4971           if (! identified)
4972             {
4973               if (decl)
4974                 pedwarn ("jump to label `%D'", decl);
4975               else
4976                 pedwarn ("jump to case label");
4977
4978               if (file)
4979                 pedwarn_with_file_and_line (file, line, "  from here");
4980               identified = 1;
4981             }
4982
4983           if (problem > 1)
4984             cp_error_at ("  crosses initialization of `%#D'",
4985                          new_decls);
4986           else
4987             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4988                            new_decls);
4989         }
4990
4991       if (b == level)
4992         break;
4993       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4994         {
4995           if (! identified)
4996             {
4997               if (decl)
4998                 pedwarn ("jump to label `%D'", decl);
4999               else
5000                 pedwarn ("jump to case label");
5001
5002               if (file)
5003                 pedwarn_with_file_and_line (file, line, "  from here");
5004               identified = 1;
5005             }
5006           if (b->is_try_scope)
5007             error ("  enters try block");
5008           else
5009             error ("  enters catch block");
5010           saw_eh = 1;
5011         }
5012     }
5013 }
5014
5015 static void
5016 check_previous_goto (use)
5017      struct named_label_use_list *use;
5018 {
5019   check_previous_goto_1 (use->label_decl, use->binding_level,
5020                          use->names_in_scope, use->filename_o_goto,
5021                          use->lineno_o_goto);
5022 }
5023
5024 static void
5025 check_switch_goto (level)
5026      struct binding_level *level;
5027 {
5028   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5029 }
5030
5031 /* Check that any previously seen jumps to a newly defined label DECL
5032    are OK.  Called by define_label.  */
5033
5034 static void
5035 check_previous_gotos (decl)
5036      tree decl;
5037 {
5038   struct named_label_use_list **usep;
5039
5040   if (! TREE_USED (decl))
5041     return;
5042
5043   for (usep = &named_label_uses; *usep; )
5044     {
5045       struct named_label_use_list *use = *usep;
5046       if (use->label_decl == decl)
5047         {
5048           check_previous_goto (use);
5049           *usep = use->next;
5050         }
5051       else
5052         usep = &(use->next);
5053     }
5054 }
5055
5056 /* Check that a new jump to a label DECL is OK.  Called by
5057    finish_goto_stmt.  */
5058
5059 void
5060 check_goto (decl)
5061      tree decl;
5062 {
5063   int identified = 0;
5064   tree bad;
5065   struct named_label_list *lab;
5066
5067   /* We can't know where a computed goto is jumping.  So we assume
5068      that it's OK.  */
5069   if (! DECL_P (decl))
5070     return;
5071
5072   /* If the label hasn't been defined yet, defer checking.  */
5073   if (! DECL_INITIAL (decl))
5074     {
5075       use_label (decl);
5076       return;
5077     }
5078
5079   for (lab = named_labels; lab; lab = lab->next)
5080     if (decl == lab->label_decl)
5081       break;
5082
5083   /* If the label is not on named_labels it's a gcc local label, so
5084      it must be in an outer scope, so jumping to it is always OK.  */
5085   if (lab == 0)
5086     return;
5087
5088   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5089       && !identified)
5090     {
5091       cp_pedwarn_at ("jump to label `%D'", decl);
5092       pedwarn ("  from here");
5093       identified = 1;
5094     }
5095
5096   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5097     {
5098       tree b = TREE_VALUE (bad);
5099       int u = decl_jump_unsafe (b);
5100
5101       if (u > 1 && DECL_ARTIFICIAL (b))
5102         /* Can't skip init of __exception_info.  */
5103         cp_error_at ("  enters catch block", b);
5104       else if (u > 1)
5105         cp_error_at ("  skips initialization of `%#D'", b);
5106       else
5107         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5108     }
5109
5110   if (lab->in_try_scope)
5111     error ("  enters try block");
5112   else if (lab->in_catch_scope)
5113     error ("  enters catch block");
5114 }
5115
5116 /* Define a label, specifying the location in the source file.
5117    Return the LABEL_DECL node for the label, if the definition is valid.
5118    Otherwise return 0.  */
5119
5120 tree
5121 define_label (filename, line, name)
5122      const char *filename;
5123      int line;
5124      tree name;
5125 {
5126   tree decl = lookup_label (name);
5127   struct named_label_list *ent;
5128   register struct binding_level *p;
5129
5130   for (ent = named_labels; ent; ent = ent->next)
5131     if (ent->label_decl == decl)
5132       break;
5133
5134   /* After labels, make any new cleanups in the function go into their
5135      own new (temporary) binding contour.  */
5136   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5137     p->more_cleanups_ok = 0;
5138
5139   if (name == get_identifier ("wchar_t"))
5140     pedwarn ("label named wchar_t");
5141
5142   if (DECL_INITIAL (decl) != NULL_TREE)
5143     {
5144       error ("duplicate label `%D'", decl);
5145       return 0;
5146     }
5147   else
5148     {
5149       /* Mark label as having been defined.  */
5150       DECL_INITIAL (decl) = error_mark_node;
5151       /* Say where in the source.  */
5152       DECL_SOURCE_FILE (decl) = filename;
5153       DECL_SOURCE_LINE (decl) = line;
5154       if (ent)
5155         {
5156           ent->names_in_scope = current_binding_level->names;
5157           ent->binding_level = current_binding_level;
5158         }
5159       check_previous_gotos (decl);
5160       return decl;
5161     }
5162 }
5163
5164 struct cp_switch
5165 {
5166   struct binding_level *level;
5167   struct cp_switch *next;
5168   /* The SWITCH_STMT being built.  */
5169   tree switch_stmt;
5170   /* A splay-tree mapping the low element of a case range to the high
5171      element, or NULL_TREE if there is no high element.  Used to
5172      determine whether or not a new case label duplicates an old case
5173      label.  We need a tree, rather than simply a hash table, because
5174      of the GNU case range extension.  */
5175   splay_tree cases;
5176 };
5177
5178 /* A stack of the currently active switch statements.  The innermost
5179    switch statement is on the top of the stack.  There is no need to
5180    mark the stack for garbage collection because it is only active
5181    during the processing of the body of a function, and we never
5182    collect at that point.  */
5183
5184 static struct cp_switch *switch_stack;
5185
5186 /* Called right after a switch-statement condition is parsed.
5187    SWITCH_STMT is the switch statement being parsed.  */
5188
5189 void
5190 push_switch (switch_stmt)
5191      tree switch_stmt;
5192 {
5193   struct cp_switch *p
5194     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5195   p->level = current_binding_level;
5196   p->next = switch_stack;
5197   p->switch_stmt = switch_stmt;
5198   p->cases = splay_tree_new (case_compare, NULL, NULL);
5199   switch_stack = p;
5200 }
5201
5202 void
5203 pop_switch ()
5204 {
5205   struct cp_switch *cs;
5206
5207   cs = switch_stack;
5208   splay_tree_delete (cs->cases);
5209   switch_stack = switch_stack->next;
5210   free (cs);
5211 }
5212
5213 /* Note that we've seen a definition of a case label, and complain if this
5214    is a bad place for one.  */
5215
5216 tree
5217 finish_case_label (low_value, high_value)
5218      tree low_value;
5219      tree high_value;
5220 {
5221   tree cond, r;
5222   register struct binding_level *p;
5223
5224   if (! switch_stack)
5225     {
5226       if (high_value)
5227         error ("case label not within a switch statement");
5228       else if (low_value)
5229         error ("case label `%E' not within a switch statement",
5230                   low_value);
5231       else
5232         error ("`default' label not within a switch statement");
5233       return NULL_TREE;
5234     }
5235
5236   if (processing_template_decl)
5237     {
5238       tree label;
5239
5240       /* For templates, just add the case label; we'll do semantic
5241          analysis at instantiation-time.  */
5242       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5243       return add_stmt (build_case_label (low_value, high_value, label));
5244     }
5245
5246   /* Find the condition on which this switch statement depends.  */
5247   cond = SWITCH_COND (switch_stack->switch_stmt);
5248   if (cond && TREE_CODE (cond) == TREE_LIST)
5249     cond = TREE_VALUE (cond);
5250
5251   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5252   if (r == error_mark_node)
5253     r = NULL_TREE;
5254
5255   check_switch_goto (switch_stack->level);
5256
5257   /* After labels, make any new cleanups in the function go into their
5258      own new (temporary) binding contour.  */
5259   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5260     p->more_cleanups_ok = 0;
5261
5262   return r;
5263 }
5264 \f
5265 /* Return the list of declarations of the current level.
5266    Note that this list is in reverse order unless/until
5267    you nreverse it; and when you do nreverse it, you must
5268    store the result back using `storedecls' or you will lose.  */
5269
5270 tree
5271 getdecls ()
5272 {
5273   return current_binding_level->names;
5274 }
5275
5276 /* Return the list of type-tags (for structs, etc) of the current level.  */
5277
5278 tree
5279 gettags ()
5280 {
5281   return current_binding_level->tags;
5282 }
5283
5284 /* Store the list of declarations of the current level.
5285    This is done for the parameter declarations of a function being defined,
5286    after they are modified in the light of any missing parameters.  */
5287
5288 static void
5289 storedecls (decls)
5290      tree decls;
5291 {
5292   current_binding_level->names = decls;
5293 }
5294
5295 /* Similarly, store the list of tags of the current level.  */
5296
5297 void
5298 storetags (tags)
5299      tree tags;
5300 {
5301   current_binding_level->tags = tags;
5302 }
5303 \f
5304 /* Return the type that should be used when TYPE's name is preceded
5305    by a tag such as 'struct' or 'union', or null if the name cannot
5306    be used in this way.
5307
5308    For example, when processing the third line of:
5309
5310         struct A;
5311         typedef struct A A;
5312         struct A;
5313
5314    lookup of A will find the typedef.  Given A's typedef, this function
5315    will return the type associated with "struct A".  For the tag to be
5316    anything other than TYPE, TYPE must be a typedef whose original type
5317    has the same name and context as TYPE itself.
5318
5319    It is not valid for a typedef of an anonymous type to be used with
5320    an explicit tag:
5321
5322        typedef struct { ... } B;
5323        struct B;
5324
5325    Return null for this case.  */
5326
5327 static tree
5328 follow_tag_typedef (type)
5329      tree type;
5330 {
5331   tree original;
5332
5333   original = original_type (type);
5334   if (! TYPE_NAME (original))
5335     return NULL_TREE;
5336   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5337       && (CP_DECL_CONTEXT (TYPE_NAME (original))
5338           == CP_DECL_CONTEXT (TYPE_NAME (type)))
5339       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5340     return original;
5341   else
5342     return NULL_TREE;
5343 }
5344
5345 /* Given NAME, an IDENTIFIER_NODE,
5346    return the structure (or union or enum) definition for that name.
5347    Searches binding levels from BINDING_LEVEL up to the global level.
5348    If THISLEVEL_ONLY is nonzero, searches only the specified context
5349    (but skips any tag-transparent contexts to find one that is
5350    meaningful for tags).
5351    FORM says which kind of type the caller wants;
5352    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5353    If the wrong kind of type is found, and it's not a template, an error is
5354    reported.  */
5355
5356 static tree
5357 lookup_tag (form, name, binding_level, thislevel_only)
5358      enum tree_code form;
5359      tree name;
5360      struct binding_level *binding_level;
5361      int thislevel_only;
5362 {
5363   register struct binding_level *level;
5364   /* Non-zero if, we should look past a template parameter level, even
5365      if THISLEVEL_ONLY.  */
5366   int allow_template_parms_p = 1;
5367
5368   for (level = binding_level; level; level = level->level_chain)
5369     {
5370       register tree tail;
5371       if (ANON_AGGRNAME_P (name))
5372         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5373           {
5374             /* There's no need for error checking here, because
5375                anon names are unique throughout the compilation.  */
5376             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5377               return TREE_VALUE (tail);
5378           }
5379       else if (level->namespace_p)
5380         /* Do namespace lookup. */
5381         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5382           {
5383             tree old = binding_for_name (name, tail);
5384
5385             /* If we just skipped past a template parameter level,
5386                even though THISLEVEL_ONLY, and we find a template
5387                class declaration, then we use the _TYPE node for the
5388                template.  See the example below.  */
5389             if (thislevel_only && !allow_template_parms_p
5390                 && old && BINDING_VALUE (old)
5391                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5392               old = TREE_TYPE (BINDING_VALUE (old));
5393             else
5394               old = BINDING_TYPE (old);
5395
5396             if (old)
5397               {
5398                 /* We've found something at this binding level.  If it is
5399                    a typedef, extract the tag it refers to.  Lookup fails
5400                    if the typedef doesn't refer to a taggable type.  */
5401                 old = follow_tag_typedef (old);
5402                 if (!old)
5403                   return NULL_TREE;
5404                 if (TREE_CODE (old) != form
5405                     && (form == ENUMERAL_TYPE
5406                         || TREE_CODE (old) == ENUMERAL_TYPE))
5407                   {
5408                     error ("`%#D' redeclared as %C", old, form);
5409                     return NULL_TREE;
5410                   }
5411                 return old;
5412               }
5413             if (thislevel_only || tail == global_namespace)
5414               return NULL_TREE;
5415           }
5416       else
5417         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5418           {
5419             if (TREE_PURPOSE (tail) == name)
5420               {
5421                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5422
5423                 if (code != form
5424                     && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5425                   {
5426                     /* Definition isn't the kind we were looking for.  */
5427                     error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5428                     return NULL_TREE;
5429                   }
5430                 return TREE_VALUE (tail);
5431               }
5432           }
5433       if (thislevel_only && ! level->tag_transparent)
5434         {
5435           if (level->template_parms_p && allow_template_parms_p)
5436             {
5437               /* We must deal with cases like this:
5438
5439                    template <class T> struct S;
5440                    template <class T> struct S {};
5441
5442                  When looking up `S', for the second declaration, we
5443                  would like to find the first declaration.  But, we
5444                  are in the pseudo-global level created for the
5445                  template parameters, rather than the (surrounding)
5446                  namespace level.  Thus, we keep going one more level,
5447                  even though THISLEVEL_ONLY is non-zero.  */
5448               allow_template_parms_p = 0;
5449               continue;
5450             }
5451           else
5452             return NULL_TREE;
5453         }
5454     }
5455   return NULL_TREE;
5456 }
5457
5458 #if 0
5459 void
5460 set_current_level_tags_transparency (tags_transparent)
5461      int tags_transparent;
5462 {
5463   current_binding_level->tag_transparent = tags_transparent;
5464 }
5465 #endif
5466
5467 /* Given a type, find the tag that was defined for it and return the tag name.
5468    Otherwise return 0.  However, the value can never be 0
5469    in the cases in which this is used.
5470
5471    C++: If NAME is non-zero, this is the new name to install.  This is
5472    done when replacing anonymous tags with real tag names.  */
5473
5474 static tree
5475 lookup_tag_reverse (type, name)
5476      tree type;
5477      tree name;
5478 {
5479   register struct binding_level *level;
5480
5481   for (level = current_binding_level; level; level = level->level_chain)
5482     {
5483       register tree tail;
5484       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5485         {
5486           if (TREE_VALUE (tail) == type)
5487             {
5488               if (name)
5489                 TREE_PURPOSE (tail) = name;
5490               return TREE_PURPOSE (tail);
5491             }
5492         }
5493     }
5494   return NULL_TREE;
5495 }
5496 \f
5497 /* Look up NAME in the NAMESPACE.  */
5498
5499 tree
5500 lookup_namespace_name (namespace, name)
5501      tree namespace, name;
5502 {
5503   tree val;
5504   tree template_id = NULL_TREE;
5505
5506   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5507
5508   if (TREE_CODE (name) == NAMESPACE_DECL)
5509     /* This happens for A::B<int> when B is a namespace. */
5510     return name;
5511   else if (TREE_CODE (name) == TEMPLATE_DECL)
5512     {
5513       /* This happens for A::B where B is a template, and there are no
5514          template arguments.  */
5515       error ("invalid use of `%D'", name);
5516       return error_mark_node;
5517     }
5518
5519   namespace = ORIGINAL_NAMESPACE (namespace);
5520
5521   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5522     {
5523       template_id = name;
5524       name = TREE_OPERAND (name, 0);
5525       if (TREE_CODE (name) == OVERLOAD)
5526         name = DECL_NAME (OVL_CURRENT (name));
5527       else if (DECL_P (name))
5528         name = DECL_NAME (name);
5529     }
5530
5531   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5532
5533   val = make_node (CPLUS_BINDING);
5534   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5535     return error_mark_node;
5536
5537   if (BINDING_VALUE (val))
5538     {
5539       val = BINDING_VALUE (val);
5540
5541       if (template_id)
5542         {
5543           if (DECL_CLASS_TEMPLATE_P (val))
5544             val = lookup_template_class (val,
5545                                          TREE_OPERAND (template_id, 1),
5546                                          /*in_decl=*/NULL_TREE,
5547                                          /*context=*/NULL_TREE,
5548                                          /*entering_scope=*/0,
5549                                          tf_error | tf_warning);
5550           else if (DECL_FUNCTION_TEMPLATE_P (val)
5551                    || TREE_CODE (val) == OVERLOAD)
5552             val = lookup_template_function (val,
5553                                             TREE_OPERAND (template_id, 1));
5554           else
5555             {
5556               error ("`%D::%D' is not a template",
5557                         namespace, name);
5558               return error_mark_node;
5559             }
5560         }
5561
5562       /* If we have a single function from a using decl, pull it out.  */
5563       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5564         val = OVL_FUNCTION (val);
5565
5566       /* Ignore built-in functions that haven't been prototyped yet.  */
5567       if (!val || !DECL_P(val)
5568           || !DECL_LANG_SPECIFIC(val)
5569           || !DECL_ANTICIPATED (val))
5570         return val;
5571     }
5572
5573   error ("`%D' undeclared in namespace `%D'", name, namespace);
5574   return error_mark_node;
5575 }
5576
5577 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5578
5579 static unsigned long
5580 typename_hash (k)
5581      hash_table_key k;
5582 {
5583   unsigned long hash;
5584   tree t;
5585
5586   t = (tree) k;
5587   hash = (((unsigned long) TYPE_CONTEXT (t))
5588           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5589
5590   return hash;
5591 }
5592
5593 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5594
5595 static bool
5596 typename_compare (k1, k2)
5597      hash_table_key k1;
5598      hash_table_key k2;
5599 {
5600   tree t1;
5601   tree t2;
5602   tree d1;
5603   tree d2;
5604
5605   t1 = (tree) k1;
5606   t2 = (tree) k2;
5607   d1 = TYPE_NAME (t1);
5608   d2 = TYPE_NAME (t2);
5609
5610   return (DECL_NAME (d1) == DECL_NAME (d2)
5611           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5612           && ((TREE_TYPE (t1) != NULL_TREE)
5613               == (TREE_TYPE (t2) != NULL_TREE))
5614           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5615           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5616 }
5617
5618 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5619    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5620    is non-NULL, this type is being created by the implicit typename
5621    extension, and BASE_TYPE is a type named `t' in some base class of
5622    `T' which depends on template parameters.
5623
5624    Returns the new TYPENAME_TYPE.  */
5625
5626 tree
5627 build_typename_type (context, name, fullname, base_type)
5628      tree context;
5629      tree name;
5630      tree fullname;
5631      tree base_type;
5632 {
5633   tree t;
5634   tree d;
5635   struct hash_entry *e;
5636
5637   static struct hash_table ht;
5638
5639   if (!ht.table)
5640     {
5641       static struct hash_table *h = &ht;
5642
5643       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5644       ggc_add_tree_hash_table_root (&h, 1);
5645     }
5646
5647   /* Build the TYPENAME_TYPE.  */
5648   t = make_aggr_type (TYPENAME_TYPE);
5649   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5650   TYPENAME_TYPE_FULLNAME (t) = fullname;
5651   TREE_TYPE (t) = base_type;
5652
5653   /* Build the corresponding TYPE_DECL.  */
5654   d = build_decl (TYPE_DECL, name, t);
5655   TYPE_NAME (TREE_TYPE (d)) = d;
5656   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5657   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5658   DECL_ARTIFICIAL (d) = 1;
5659
5660   /* See if we already have this type.  */
5661   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5662   if (e)
5663     t = (tree) e->key;
5664   else
5665     /* Insert the type into the table.  */
5666     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5667
5668   return t;
5669 }
5670
5671 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5672    unless an error occurs, in which case error_mark_node is returned.
5673    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5674    set, we return that, rather than the _TYPE it corresponds to, in
5675    other cases we look through the type decl.  If TF_ERROR is set,
5676    complain about errors, otherwise be quiet.  */
5677
5678 tree
5679 make_typename_type (context, name, complain)
5680      tree context, name;
5681      tsubst_flags_t complain;
5682 {
5683   tree fullname;
5684
5685   if (TYPE_P (name))
5686     {
5687       if (!(TYPE_LANG_SPECIFIC (name)
5688             && (CLASSTYPE_IS_TEMPLATE (name)
5689                 || CLASSTYPE_USE_TEMPLATE (name))))
5690         name = TYPE_IDENTIFIER (name);
5691       else
5692         /* Create a TEMPLATE_ID_EXPR for the type.  */
5693         name = build_nt (TEMPLATE_ID_EXPR,
5694                          CLASSTYPE_TI_TEMPLATE (name),
5695                          CLASSTYPE_TI_ARGS (name));
5696     }
5697   else if (TREE_CODE (name) == TYPE_DECL)
5698     name = DECL_NAME (name);
5699
5700   fullname = name;
5701
5702   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5703     {
5704       name = TREE_OPERAND (name, 0);
5705       if (TREE_CODE (name) == TEMPLATE_DECL)
5706         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5707     }
5708   if (TREE_CODE (name) == TEMPLATE_DECL)
5709     {
5710       error ("`%D' used without template parameters", name);
5711       return error_mark_node;
5712     }
5713   if (TREE_CODE (name) != IDENTIFIER_NODE)
5714     abort ();
5715
5716   if (TREE_CODE (context) == NAMESPACE_DECL)
5717     {
5718       /* We can get here from typename_sub0 in the explicit_template_type
5719          expansion.  Just fail.  */
5720       if (complain & tf_error)
5721         error ("no class template named `%#T' in `%#T'",
5722                   name, context);
5723       return error_mark_node;
5724     }
5725
5726   if (! uses_template_parms (context)
5727       || currently_open_class (context))
5728     {
5729       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5730         {
5731           tree tmpl = NULL_TREE;
5732           if (IS_AGGR_TYPE (context))
5733             tmpl = lookup_field (context, name, 0, 0);
5734           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5735             {
5736               if (complain & tf_error)
5737                 error ("no class template named `%#T' in `%#T'",
5738                           name, context);
5739               return error_mark_node;
5740             }
5741
5742           return lookup_template_class (tmpl,
5743                                         TREE_OPERAND (fullname, 1),
5744                                         NULL_TREE, context,
5745                                         /*entering_scope=*/0,
5746                                         tf_error | tf_warning);
5747         }
5748       else
5749         {
5750           tree t;
5751
5752           if (!IS_AGGR_TYPE (context))
5753             {
5754               if (complain & tf_error)
5755                 error ("no type named `%#T' in `%#T'", name, context);
5756               return error_mark_node;
5757             }
5758
5759           t = lookup_field (context, name, 0, 1);
5760           if (t)
5761             {
5762               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5763                 t = TREE_TYPE (t);
5764               if (IMPLICIT_TYPENAME_P (t))
5765                 {
5766                   /* Lookup found an implicit typename that we had
5767                      injected into the current scope. Doing things
5768                      properly would have located the exact same type,
5769                      so there is no error here.  We must remove the
5770                      implicitness so that we do not warn about it.  */
5771                   t = copy_node (t);
5772                   TREE_TYPE (t) = NULL_TREE;
5773                 }
5774
5775               return t;
5776             }
5777         }
5778     }
5779
5780   /* If the CONTEXT is not a template type, then either the field is
5781      there now or its never going to be.  */
5782   if (!uses_template_parms (context))
5783     {
5784       if (complain & tf_error)
5785         error ("no type named `%#T' in `%#T'", name, context);
5786       return error_mark_node;
5787     }
5788
5789
5790   return build_typename_type (context, name, fullname,  NULL_TREE);
5791 }
5792
5793 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5794    unless an error occurs, in which case error_mark_node is returned.
5795    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5796    corresponds to.  If COMPLAIN zero, don't complain about any errors
5797    that occur.  */
5798
5799 tree
5800 make_unbound_class_template (context, name, complain)
5801      tree context, name;
5802      int complain;
5803 {
5804   tree t;
5805   tree d;
5806
5807   if (TYPE_P (name))
5808     name = TYPE_IDENTIFIER (name);
5809   else if (DECL_P (name))
5810     name = DECL_NAME (name);
5811   if (TREE_CODE (name) != IDENTIFIER_NODE)
5812     abort ();
5813
5814   if (!uses_template_parms (context)
5815       || currently_open_class (context))
5816     {
5817       tree tmpl = NULL_TREE;
5818
5819       if (IS_AGGR_TYPE (context))
5820         tmpl = lookup_field (context, name, 0, 0);
5821
5822       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5823         {
5824           if (complain)
5825             error ("no class template named `%#T' in `%#T'", name, context);
5826           return error_mark_node;
5827         }
5828
5829       if (!enforce_access (context, tmpl))
5830         return error_mark_node;
5831
5832       return tmpl;
5833     }
5834
5835   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5836   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5837   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5838   TREE_TYPE (t) = NULL_TREE;
5839
5840   /* Build the corresponding TEMPLATE_DECL.  */
5841   d = build_decl (TEMPLATE_DECL, name, t);
5842   TYPE_NAME (TREE_TYPE (d)) = d;
5843   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5844   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5845   DECL_ARTIFICIAL (d) = 1;
5846
5847   return t;
5848 }
5849
5850 /* Select the right _DECL from multiple choices. */
5851
5852 static tree
5853 select_decl (binding, flags)
5854      tree binding;
5855      int flags;
5856 {
5857   tree val;
5858   val = BINDING_VALUE (binding);
5859
5860   if (LOOKUP_NAMESPACES_ONLY (flags))
5861     {
5862       /* We are not interested in types. */
5863       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5864         return val;
5865       return NULL_TREE;
5866     }
5867
5868   /* If we could have a type and
5869      we have nothing or we need a type and have none.  */
5870   if (BINDING_TYPE (binding)
5871       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5872                    && TREE_CODE (val) != TYPE_DECL)))
5873     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5874   /* Don't return non-types if we really prefer types. */
5875   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5876            && (TREE_CODE (val) != TEMPLATE_DECL
5877                || !DECL_CLASS_TEMPLATE_P (val)))
5878     val = NULL_TREE;
5879
5880   return val;
5881 }
5882
5883 /* Unscoped lookup of a global: iterate over current namespaces,
5884    considering using-directives.  If SPACESP is non-NULL, store a list
5885    of the namespaces we've considered in it.  */
5886
5887 tree
5888 unqualified_namespace_lookup (name, flags, spacesp)
5889      tree name;
5890      int flags;
5891      tree *spacesp;
5892 {
5893   tree b = make_node (CPLUS_BINDING);
5894   tree initial = current_decl_namespace ();
5895   tree scope = initial;
5896   tree siter;
5897   struct binding_level *level;
5898   tree val = NULL_TREE;
5899
5900   if (spacesp)
5901     *spacesp = NULL_TREE;
5902
5903   for (; !val; scope = CP_DECL_CONTEXT (scope))
5904     {
5905       if (spacesp)
5906         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5907       val = binding_for_name (name, scope);
5908
5909       /* Ignore anticipated built-in functions.  */
5910       if (val && BINDING_VALUE (val)
5911           && DECL_P (BINDING_VALUE (val))
5912           && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5913           && DECL_ANTICIPATED (BINDING_VALUE (val)))
5914         {
5915           BINDING_VALUE (b) = NULL_TREE;
5916           BINDING_TYPE (b) = NULL_TREE;
5917         }
5918       else
5919         {
5920           /* Initialize binding for this context. */
5921           BINDING_VALUE (b) = BINDING_VALUE (val);
5922           BINDING_TYPE (b) = BINDING_TYPE (val);
5923         }
5924
5925       /* Add all _DECLs seen through local using-directives. */
5926       for (level = current_binding_level;
5927            !level->namespace_p;
5928            level = level->level_chain)
5929         if (!lookup_using_namespace (name, b, level->using_directives,
5930                                      scope, flags, spacesp))
5931           /* Give up because of error. */
5932           return error_mark_node;
5933
5934       /* Add all _DECLs seen through global using-directives. */
5935       /* XXX local and global using lists should work equally. */
5936       siter = initial;
5937       while (1)
5938         {
5939           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5940                                        scope, flags, spacesp))
5941             /* Give up because of error. */
5942             return error_mark_node;
5943           if (siter == scope) break;
5944           siter = CP_DECL_CONTEXT (siter);
5945         }
5946
5947       val = select_decl (b, flags);
5948       if (scope == global_namespace)
5949         break;
5950     }
5951   return val;
5952 }
5953
5954 /* Combine prefer_type and namespaces_only into flags.  */
5955
5956 static int
5957 lookup_flags (prefer_type, namespaces_only)
5958   int prefer_type, namespaces_only;
5959 {
5960   if (namespaces_only)
5961     return LOOKUP_PREFER_NAMESPACES;
5962   if (prefer_type > 1)
5963     return LOOKUP_PREFER_TYPES;
5964   if (prefer_type > 0)
5965     return LOOKUP_PREFER_BOTH;
5966   return 0;
5967 }
5968
5969 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5970    ignore it or not.  Subroutine of lookup_name_real.  */
5971
5972 static tree
5973 qualify_lookup (val, flags)
5974      tree val;
5975      int flags;
5976 {
5977   if (val == NULL_TREE)
5978     return val;
5979   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5980     return val;
5981   if ((flags & LOOKUP_PREFER_TYPES)
5982       && (TREE_CODE (val) == TYPE_DECL
5983           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5984               && DECL_CLASS_TEMPLATE_P (val))))
5985     return val;
5986   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5987     return NULL_TREE;
5988   return val;
5989 }
5990
5991 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5992    that.  */
5993
5994 static void
5995 warn_about_implicit_typename_lookup (typename, binding)
5996      tree typename;
5997      tree binding;
5998 {
5999   tree subtype = TREE_TYPE (TREE_TYPE (typename));
6000   tree name = DECL_NAME (typename);
6001
6002   if (! (TREE_CODE (binding) == TEMPLATE_DECL
6003          && CLASSTYPE_TEMPLATE_INFO (subtype)
6004          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
6005       && ! (TREE_CODE (binding) == TYPE_DECL
6006             && same_type_p (TREE_TYPE (binding), subtype)))
6007     {
6008       warning ("lookup of `%D' finds `%#D'",
6009                   name, binding);
6010       warning ("  instead of `%D' from dependent base class",
6011                   typename);
6012       warning ("  (use `typename %T::%D' if that's what you meant)",
6013                   constructor_name (current_class_type), name);
6014     }
6015 }
6016
6017 /* Look up NAME in the current binding level and its superiors in the
6018    namespace of variables, functions and typedefs.  Return a ..._DECL
6019    node of some kind representing its definition if there is only one
6020    such declaration, or return a TREE_LIST with all the overloaded
6021    definitions if there are many, or return 0 if it is undefined.
6022
6023    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6024    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6025    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
6026    Otherwise we prefer non-TYPE_DECLs.
6027
6028    If NONCLASS is non-zero, we don't look for the NAME in class scope,
6029    using IDENTIFIER_CLASS_VALUE.  */
6030
6031 static tree
6032 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
6033      tree name;
6034      int prefer_type, nonclass, namespaces_only;
6035 {
6036   tree t;
6037   tree val = NULL_TREE;
6038   int yylex = 0;
6039   tree from_obj = NULL_TREE;
6040   int flags;
6041   int val_is_implicit_typename = 0;
6042
6043   /* Hack: copy flag set by parser, if set. */
6044   if (only_namespace_names)
6045     namespaces_only = 1;
6046
6047   if (prefer_type == -2)
6048     {
6049       extern int looking_for_typename;
6050       tree type = NULL_TREE;
6051
6052       yylex = 1;
6053       prefer_type = looking_for_typename;
6054
6055       flags = lookup_flags (prefer_type, namespaces_only);
6056       /* If the next thing is '<', class templates are types. */
6057       if (looking_for_template)
6058         flags |= LOOKUP_TEMPLATES_EXPECTED;
6059
6060       if (got_scope)
6061         type = got_scope;
6062       else if (got_object != error_mark_node)
6063         type = got_object;
6064
6065       if (type)
6066         {
6067           if (type == error_mark_node)
6068             return error_mark_node;
6069           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6070             type = TREE_TYPE (type);
6071
6072           if (TYPE_P (type))
6073             type = complete_type (type);
6074
6075           if (TREE_CODE (type) == VOID_TYPE)
6076             type = global_namespace;
6077           if (TREE_CODE (type) == NAMESPACE_DECL)
6078             {
6079               val = make_node (CPLUS_BINDING);
6080               flags |= LOOKUP_COMPLAIN;
6081               if (!qualified_lookup_using_namespace (name, type, val, flags))
6082                 return NULL_TREE;
6083               val = select_decl (val, flags);
6084             }
6085           else if (! IS_AGGR_TYPE (type)
6086                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6087                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6088                    || TREE_CODE (type) == TYPENAME_TYPE)
6089             /* Someone else will give an error about this if needed.  */
6090             val = NULL_TREE;
6091           else if (type == current_class_type)
6092             val = IDENTIFIER_CLASS_VALUE (name);
6093           else
6094             {
6095               val = lookup_member (type, name, 0, prefer_type);
6096               type_access_control (type, val);
6097
6098               /* Restore the containing TYPENAME_TYPE if we looked
6099                  through it before.  */
6100               if (got_scope && got_scope != type
6101                   && val && TREE_CODE (val) == TYPE_DECL
6102                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6103                 {
6104                   val = TREE_TYPE (val);
6105                   val = build_typename_type (got_scope, name,
6106                                              TYPENAME_TYPE_FULLNAME (val),
6107                                              TREE_TYPE (val));
6108                   val = TYPE_STUB_DECL (val);
6109                 }
6110             }
6111         }
6112       else
6113         val = NULL_TREE;
6114
6115       if (got_scope)
6116         goto done;
6117       else if (got_object && val)
6118         {
6119           from_obj = val;
6120           val = NULL_TREE;
6121         }
6122     }
6123   else
6124     {
6125       flags = lookup_flags (prefer_type, namespaces_only);
6126       /* If we're not parsing, we need to complain. */
6127       flags |= LOOKUP_COMPLAIN;
6128     }
6129
6130   /* First, look in non-namespace scopes.  */
6131
6132   if (current_class_type == NULL_TREE)
6133     nonclass = 1;
6134
6135   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6136     {
6137       tree binding;
6138
6139       if (!LOCAL_BINDING_P (t) && nonclass)
6140         /* We're not looking for class-scoped bindings, so keep going.  */
6141         continue;
6142
6143       /* If this is the kind of thing we're looking for, we're done.  */
6144       if (qualify_lookup (BINDING_VALUE (t), flags))
6145         binding = BINDING_VALUE (t);
6146       else if ((flags & LOOKUP_PREFER_TYPES)
6147                && qualify_lookup (BINDING_TYPE (t), flags))
6148         binding = BINDING_TYPE (t);
6149       else
6150         binding = NULL_TREE;
6151
6152       /* Handle access control on types from enclosing or base classes.  */
6153       if (binding && ! yylex
6154           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6155         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6156
6157       if (binding
6158           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6159         {
6160           if (val_is_implicit_typename && !yylex)
6161             warn_about_implicit_typename_lookup (val, binding);
6162           val = binding;
6163           val_is_implicit_typename
6164             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6165           if (!val_is_implicit_typename)
6166             break;
6167         }
6168     }
6169
6170   /* Now lookup in namespace scopes.  */
6171   if (!val || val_is_implicit_typename)
6172     {
6173       t = unqualified_namespace_lookup (name, flags, 0);
6174       if (t)
6175         {
6176           if (val_is_implicit_typename && !yylex)
6177             warn_about_implicit_typename_lookup (val, t);
6178           val = t;
6179         }
6180     }
6181
6182  done:
6183   if (val)
6184     {
6185       /* This should only warn about types used in qualified-ids.  */
6186       if (from_obj && from_obj != val)
6187         {
6188           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6189               && TREE_CODE (val) == TYPE_DECL
6190               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6191             pedwarn ("\
6192 lookup of `%D' in the scope of `%#T' (`%#D') \
6193 does not match lookup in the current scope (`%#D')",
6194                         name, got_object, from_obj, val);
6195
6196           /* We don't change val to from_obj if got_object depends on
6197              template parms because that breaks implicit typename for
6198              destructor calls.  */
6199           if (! uses_template_parms (got_object))
6200             val = from_obj;
6201         }
6202
6203       /* If we have a single function from a using decl, pull it out.  */
6204       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6205         val = OVL_FUNCTION (val);
6206     }
6207   else if (from_obj)
6208     val = from_obj;
6209
6210   return val;
6211 }
6212
6213 tree
6214 lookup_name_nonclass (name)
6215      tree name;
6216 {
6217   return lookup_name_real (name, 0, 1, 0);
6218 }
6219
6220 tree
6221 lookup_function_nonclass (name, args)
6222      tree name;
6223      tree args;
6224 {
6225   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6226 }
6227
6228 tree
6229 lookup_name_namespace_only (name)
6230      tree name;
6231 {
6232   /* type-or-namespace, nonclass, namespace_only */
6233   return lookup_name_real (name, 1, 1, 1);
6234 }
6235
6236 tree
6237 lookup_name (name, prefer_type)
6238      tree name;
6239      int prefer_type;
6240 {
6241   return lookup_name_real (name, prefer_type, 0, 0);
6242 }
6243
6244 /* Similar to `lookup_name' but look only in the innermost non-class
6245    binding level.  */
6246
6247 tree
6248 lookup_name_current_level (name)
6249      tree name;
6250 {
6251   struct binding_level *b;
6252   tree t = NULL_TREE;
6253
6254   b = current_binding_level;
6255   while (b->parm_flag == 2)
6256     b = b->level_chain;
6257
6258   if (b->namespace_p)
6259     {
6260       t = IDENTIFIER_NAMESPACE_VALUE (name);
6261
6262       /* extern "C" function() */
6263       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6264         t = TREE_VALUE (t);
6265     }
6266   else if (IDENTIFIER_BINDING (name)
6267            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6268     {
6269       while (1)
6270         {
6271           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6272             return IDENTIFIER_VALUE (name);
6273
6274           if (b->keep == 2)
6275             b = b->level_chain;
6276           else
6277             break;
6278         }
6279     }
6280
6281   return t;
6282 }
6283
6284 /* Like lookup_name_current_level, but for types.  */
6285
6286 tree
6287 lookup_type_current_level (name)
6288      tree name;
6289 {
6290   register tree t = NULL_TREE;
6291
6292   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6293
6294   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6295       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6296     {
6297       struct binding_level *b = current_binding_level;
6298       while (1)
6299         {
6300           if (purpose_member (name, b->type_shadowed))
6301             return REAL_IDENTIFIER_TYPE_VALUE (name);
6302           if (b->keep == 2)
6303             b = b->level_chain;
6304           else
6305             break;
6306         }
6307     }
6308
6309   return t;
6310 }
6311
6312 void
6313 begin_only_namespace_names ()
6314 {
6315   only_namespace_names = 1;
6316 }
6317
6318 void
6319 end_only_namespace_names ()
6320 {
6321   only_namespace_names = 0;
6322 }
6323 \f
6324 /* Push the declarations of builtin types into the namespace.
6325    RID_INDEX is the index of the builtin type
6326    in the array RID_POINTERS.  NAME is the name used when looking
6327    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6328
6329 void
6330 record_builtin_type (rid_index, name, type)
6331      enum rid rid_index;
6332      const char *name;
6333      tree type;
6334 {
6335   tree rname = NULL_TREE, tname = NULL_TREE;
6336   tree tdecl = NULL_TREE;
6337
6338   if ((int) rid_index < (int) RID_MAX)
6339     rname = ridpointers[(int) rid_index];
6340   if (name)
6341     tname = get_identifier (name);
6342
6343   TYPE_BUILT_IN (type) = 1;
6344
6345   if (tname)
6346     {
6347       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6348       set_identifier_type_value (tname, NULL_TREE);
6349       if ((int) rid_index < (int) RID_MAX)
6350         /* Built-in types live in the global namespace. */
6351         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6352     }
6353   if (rname != NULL_TREE)
6354     {
6355       if (tname != NULL_TREE)
6356         {
6357           set_identifier_type_value (rname, NULL_TREE);
6358           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6359         }
6360       else
6361         {
6362           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6363           set_identifier_type_value (rname, NULL_TREE);
6364         }
6365     }
6366 }
6367
6368 /* Record one of the standard Java types.
6369  * Declare it as having the given NAME.
6370  * If SIZE > 0, it is the size of one of the integral types;
6371  * otherwise it is the negative of the size of one of the other types.  */
6372
6373 static tree
6374 record_builtin_java_type (name, size)
6375      const char *name;
6376      int size;
6377 {
6378   tree type, decl;
6379   if (size > 0)
6380     type = make_signed_type (size);
6381   else if (size > -32)
6382     { /* "__java_char" or ""__java_boolean". */
6383       type = make_unsigned_type (-size);
6384       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6385     }
6386   else
6387     { /* "__java_float" or ""__java_double". */
6388       type = make_node (REAL_TYPE);
6389       TYPE_PRECISION (type) = - size;
6390       layout_type (type);
6391     }
6392   record_builtin_type (RID_MAX, name, type);
6393   decl = TYPE_NAME (type);
6394
6395   /* Suppress generate debug symbol entries for these types,
6396      since for normal C++ they are just clutter.
6397      However, push_lang_context undoes this if extern "Java" is seen. */
6398   DECL_IGNORED_P (decl) = 1;
6399
6400   TYPE_FOR_JAVA (type) = 1;
6401   return type;
6402 }
6403
6404 /* Push a type into the namespace so that the back-ends ignore it. */
6405
6406 static void
6407 record_unknown_type (type, name)
6408      tree type;
6409      const char *name;
6410 {
6411   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6412   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6413   DECL_IGNORED_P (decl) = 1;
6414   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6415   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6416   TYPE_ALIGN (type) = 1;
6417   TYPE_USER_ALIGN (type) = 0;
6418   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6419 }
6420
6421 /* An string for which we should create an IDENTIFIER_NODE at
6422    startup.  */
6423
6424 typedef struct predefined_identifier
6425 {
6426   /* The name of the identifier.  */
6427   const char *const name;
6428   /* The place where the IDENTIFIER_NODE should be stored.  */
6429   tree *const node;
6430   /* Non-zero if this is the name of a constructor or destructor.  */
6431   const int ctor_or_dtor_p;
6432 } predefined_identifier;
6433
6434 /* Create all the predefined identifiers.  */
6435
6436 static void
6437 initialize_predefined_identifiers ()
6438 {
6439   const predefined_identifier *pid;
6440
6441   /* A table of identifiers to create at startup.  */
6442   static const predefined_identifier predefined_identifiers[] = {
6443     { "C++", &lang_name_cplusplus, 0 },
6444     { "C", &lang_name_c, 0 },
6445     { "Java", &lang_name_java, 0 },
6446     { CTOR_NAME, &ctor_identifier, 1 },
6447     { "__base_ctor", &base_ctor_identifier, 1 },
6448     { "__comp_ctor", &complete_ctor_identifier, 1 },
6449     { DTOR_NAME, &dtor_identifier, 1 },
6450     { "__comp_dtor", &complete_dtor_identifier, 1 },
6451     { "__base_dtor", &base_dtor_identifier, 1 },
6452     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6453     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6454     { "nelts", &nelts_identifier, 0 },
6455     { THIS_NAME, &this_identifier, 0 },
6456     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6457     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6458     { "_vptr", &vptr_identifier, 0 },
6459     { "__vtt_parm", &vtt_parm_identifier, 0 },
6460     { "std", &std_identifier, 0 },
6461     { NULL, NULL, 0 }
6462   };
6463
6464   for (pid = predefined_identifiers; pid->name; ++pid)
6465     {
6466       *pid->node = get_identifier (pid->name);
6467       if (pid->ctor_or_dtor_p)
6468         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6469     }
6470 }
6471
6472 /* Create the predefined scalar types of C,
6473    and some nodes representing standard constants (0, 1, (void *)0).
6474    Initialize the global binding level.
6475    Make definitions for built-in primitive functions.  */
6476
6477 void
6478 cxx_init_decl_processing ()
6479 {
6480   tree void_ftype;
6481   tree void_ftype_ptr;
6482
6483   /* Create all the identifiers we need.  */
6484   initialize_predefined_identifiers ();
6485
6486   /* Fill in back-end hooks.  */
6487   init_lang_status = &push_cp_function_context;
6488   free_lang_status = &pop_cp_function_context;
6489   mark_lang_status = &mark_cp_function_context;
6490   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6491
6492   cp_parse_init ();
6493   init_decl2 ();
6494   init_pt ();
6495
6496   /* Create the global variables.  */
6497   push_to_top_level ();
6498
6499   /* Enter the global namespace. */
6500   my_friendly_assert (global_namespace == NULL_TREE, 375);
6501   push_namespace (get_identifier ("::"));
6502   global_namespace = current_namespace;
6503   current_lang_name = NULL_TREE;
6504
6505   /* Adjust various flags based on command-line settings.  */
6506   if (! flag_permissive && ! pedantic)
6507     flag_pedantic_errors = 1;
6508   if (!flag_no_inline)
6509     {
6510       flag_inline_trees = 1;
6511       flag_no_inline = 1;
6512     }
6513   if (flag_inline_functions)
6514     {
6515       flag_inline_trees = 2;
6516       flag_inline_functions = 0;
6517     }
6518
6519   /* Force minimum function alignment if using the least significant
6520      bit of function pointers to store the virtual bit.  */
6521   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6522       && force_align_functions_log < 1)
6523     force_align_functions_log = 1;
6524
6525   /* Initially, C.  */
6526   current_lang_name = lang_name_c;
6527
6528   current_function_decl = NULL_TREE;
6529   current_binding_level = NULL_BINDING_LEVEL;
6530   free_binding_level = NULL_BINDING_LEVEL;
6531
6532   build_common_tree_nodes (flag_signed_char);
6533
6534   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6535   TREE_TYPE (error_mark_list) = error_mark_node;
6536
6537   /* Make the binding_level structure for global names.  */
6538   pushlevel (0);
6539   global_binding_level = current_binding_level;
6540   /* The global level is the namespace level of ::.  */
6541   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6542   declare_namespace_level ();
6543
6544   /* Create the `std' namespace.  */
6545   push_namespace (std_identifier);
6546   std_node = current_namespace;
6547   pop_namespace ();
6548
6549   lang_attribute_table = cp_attribute_table;
6550
6551   c_common_nodes_and_builtins ();
6552
6553   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6554   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6555   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6556   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6557   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6558   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6559   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6560   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6561
6562   integer_two_node = build_int_2 (2, 0);
6563   TREE_TYPE (integer_two_node) = integer_type_node;
6564   integer_three_node = build_int_2 (3, 0);
6565   TREE_TYPE (integer_three_node) = integer_type_node;
6566
6567   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6568   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6569   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6570   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6571   TYPE_PRECISION (boolean_type_node) = 1;
6572   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6573   boolean_false_node = build_int_2 (0, 0);
6574   TREE_TYPE (boolean_false_node) = boolean_type_node;
6575   boolean_true_node = build_int_2 (1, 0);
6576   TREE_TYPE (boolean_true_node) = boolean_type_node;
6577
6578   signed_size_zero_node = build_int_2 (0, 0);
6579   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6580
6581   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6582
6583 #if 0
6584   record_builtin_type (RID_MAX, NULL, string_type_node);
6585 #endif
6586
6587   delta_type_node = ptrdiff_type_node;
6588   vtable_index_type = ptrdiff_type_node;
6589
6590   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6591   lang_type_promotes_to = convert_type_from_ellipsis;
6592
6593   void_ftype = build_function_type (void_type_node, void_list_node);
6594   void_ftype_ptr = build_function_type (void_type_node,
6595                                         tree_cons (NULL_TREE,
6596                                                    ptr_type_node,
6597                                                    void_list_node));
6598   void_ftype_ptr
6599     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6600
6601   /* C++ extensions */
6602
6603   unknown_type_node = make_node (UNKNOWN_TYPE);
6604   record_unknown_type (unknown_type_node, "unknown type");
6605
6606   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6607   TREE_TYPE (unknown_type_node) = unknown_type_node;
6608
6609   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6610      result.  */
6611   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6612   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6613
6614   {
6615     /* Make sure we get a unique function type, so we can give
6616        its pointer type a name.  (This wins for gdb.) */
6617     tree vfunc_type = make_node (FUNCTION_TYPE);
6618     TREE_TYPE (vfunc_type) = integer_type_node;
6619     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6620     layout_type (vfunc_type);
6621
6622     vtable_entry_type = build_pointer_type (vfunc_type);
6623   }
6624   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6625
6626   vtbl_type_node
6627     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6628   layout_type (vtbl_type_node);
6629   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6630   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6631   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6632   layout_type (vtbl_ptr_type_node);
6633   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6634
6635   push_namespace (get_identifier ("__cxxabiv1"));
6636   abi_node = current_namespace;
6637   pop_namespace ();
6638
6639   global_type_node = make_node (LANG_TYPE);
6640   record_unknown_type (global_type_node, "global type");
6641
6642   /* Now, C++.  */
6643   current_lang_name = lang_name_cplusplus;
6644
6645   {
6646     tree bad_alloc_type_node, newtype, deltype;
6647     tree ptr_ftype_sizetype;
6648
6649     push_namespace (std_identifier);
6650     bad_alloc_type_node = xref_tag
6651       (class_type_node, get_identifier ("bad_alloc"), 1);
6652     pop_namespace ();
6653     ptr_ftype_sizetype
6654       = build_function_type (ptr_type_node,
6655                              tree_cons (NULL_TREE,
6656                                         c_size_type_node,
6657                                         void_list_node));
6658     newtype = build_exception_variant
6659       (ptr_ftype_sizetype, add_exception_specifier
6660        (NULL_TREE, bad_alloc_type_node, -1));
6661     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6662     push_cp_library_fn (NEW_EXPR, newtype);
6663     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6664     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6665     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6666   }
6667
6668   abort_fndecl
6669     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6670
6671   /* Perform other language dependent initializations.  */
6672   init_class_processing ();
6673   init_init_processing ();
6674   init_search_processing ();
6675   init_rtti_processing ();
6676
6677   if (flag_exceptions)
6678     init_exception_processing ();
6679
6680   if (! supports_one_only ())
6681     flag_weak = 0;
6682
6683   make_fname_decl = cp_make_fname_decl;
6684   start_fname_decls ();
6685
6686   /* Show we use EH for cleanups.  */
6687   using_eh_for_cleanups ();
6688
6689   /* Maintain consistency.  Perhaps we should just complain if they
6690      say -fwritable-strings?  */
6691   if (flag_writable_strings)
6692     flag_const_strings = 0;
6693
6694   /* Add GC roots for all of our global variables.  */
6695   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6696   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6697   ggc_add_tree_root (&integer_three_node, 1);
6698   ggc_add_tree_root (&integer_two_node, 1);
6699   ggc_add_tree_root (&signed_size_zero_node, 1);
6700   ggc_add_tree_root (&size_one_node, 1);
6701   ggc_add_tree_root (&size_zero_node, 1);
6702   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6703                 mark_binding_level);
6704   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6705   ggc_add_tree_root (&static_ctors, 1);
6706   ggc_add_tree_root (&static_dtors, 1);
6707   ggc_add_tree_root (&lastiddecl, 1);
6708
6709   ggc_add_tree_root (&last_function_parms, 1);
6710   ggc_add_tree_root (&error_mark_list, 1);
6711
6712   ggc_add_tree_root (&global_namespace, 1);
6713   ggc_add_tree_root (&global_type_node, 1);
6714   ggc_add_tree_root (&anonymous_namespace_name, 1);
6715
6716   ggc_add_tree_root (&got_object, 1);
6717   ggc_add_tree_root (&got_scope, 1);
6718
6719   ggc_add_tree_root (&current_lang_name, 1);
6720   ggc_add_tree_root (&static_aggregates, 1);
6721   ggc_add_tree_root (&free_bindings, 1);
6722   ggc_add_tree_root (&incomplete_vars, 1);
6723 }
6724
6725 /* Generate an initializer for a function naming variable from
6726    NAME. NAME may be NULL, in which case we generate a special
6727    ERROR_MARK node which should be replaced later. */
6728
6729 tree
6730 cp_fname_init (name)
6731      const char *name;
6732 {
6733   tree domain = NULL_TREE;
6734   tree type;
6735   tree init = NULL_TREE;
6736   size_t length = 0;
6737
6738   if (name)
6739     {
6740       length = strlen (name);
6741       domain = build_index_type (size_int (length));
6742       init = build_string (length + 1, name);
6743     }
6744
6745   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6746   type = build_cplus_array_type (type, domain);
6747
6748   if (init)
6749     TREE_TYPE (init) = type;
6750   else
6751     /* We don't know the value until instantiation time. Make
6752        something which will be digested now, but replaced later. */
6753     init = build (ERROR_MARK, type);
6754
6755   return init;
6756 }
6757
6758 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6759    decl, NAME is the initialization string and TYPE_DEP indicates whether
6760    NAME depended on the type of the function. We make use of that to detect
6761    __PRETTY_FUNCTION__ inside a template fn. This is being done
6762    lazily at the point of first use, so we musn't push the decl now.  */
6763
6764 static tree
6765 cp_make_fname_decl (id, type_dep)
6766      tree id;
6767      int type_dep;
6768 {
6769   const char *const name = (type_dep && processing_template_decl
6770                       ? NULL : fname_as_string (type_dep));
6771   tree init = cp_fname_init (name);
6772   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6773
6774   /* As we don't push the decl here, we must set the context. */
6775   DECL_CONTEXT (decl) = current_function_decl;
6776   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6777
6778   TREE_STATIC (decl) = 1;
6779   TREE_READONLY (decl) = 1;
6780   DECL_ARTIFICIAL (decl) = 1;
6781   DECL_INITIAL (decl) = init;
6782
6783   TREE_USED (decl) = 1;
6784
6785   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6786
6787   return decl;
6788 }
6789
6790 /* Make a definition for a builtin function named NAME in the current
6791    namespace, whose data type is TYPE and whose context is CONTEXT.
6792    TYPE should be a function type with argument types.
6793
6794    CLASS and CODE tell later passes how to compile calls to this function.
6795    See tree.h for possible values.
6796
6797    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6798    the name to be called if we can't opencode the function.  */
6799
6800 static tree
6801 builtin_function_1 (name, type, context, code, class, libname)
6802      const char *name;
6803      tree type;
6804      tree context;
6805      int code;
6806      enum built_in_class class;
6807      const char *libname;
6808 {
6809   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6810   DECL_BUILT_IN_CLASS (decl) = class;
6811   DECL_FUNCTION_CODE (decl) = code;
6812   DECL_CONTEXT (decl) = context;
6813
6814   /* The return builtins leave the current function.  */
6815   if (code == BUILT_IN_RETURN || code == BUILT_IN_EH_RETURN)
6816     TREE_THIS_VOLATILE (decl) = 1;
6817
6818   pushdecl (decl);
6819
6820   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6821      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6822      function in the namespace.  */
6823   if (libname)
6824     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6825   make_decl_rtl (decl, NULL);
6826
6827   /* Warn if a function in the namespace for users
6828      is used without an occasion to consider it declared.  */
6829   if (name[0] != '_' || name[1] != '_')
6830     DECL_ANTICIPATED (decl) = 1;
6831
6832   /* Possibly apply some default attributes to this built-in function.  */
6833   decl_attributes (&decl, NULL_TREE, 0);
6834
6835   return decl;
6836 }
6837
6838 /* Entry point for the benefit of c_common_nodes_and_builtins.
6839
6840    Make a defintion for a builtin function named NAME and whose data type
6841    is TYPE.  TYPE should be a function type with argument types.  This
6842    function places the anticipated declaration in the global namespace
6843    and additionally in the std namespace if appropriate.
6844
6845    CLASS and CODE tell later passes how to compile calls to this function.
6846    See tree.h for possible values.
6847
6848    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6849    the name to be called if we can't opencode the function.  */
6850
6851 tree
6852 builtin_function (name, type, code, class, libname)
6853      const char *name;
6854      tree type;
6855      int code;
6856      enum built_in_class class;
6857      const char *libname;
6858 {
6859   /* All builtins that don't begin with an '_' should additionally
6860      go in the 'std' namespace.  */
6861   if (name[0] != '_')
6862     {
6863       push_namespace (std_identifier);
6864       builtin_function_1 (name, type, std_node, code, class, libname);
6865       pop_namespace ();
6866     }
6867
6868   return builtin_function_1 (name, type, NULL_TREE, code, class, libname);
6869 }
6870
6871 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6872    function.  Not called directly.  */
6873
6874 static tree
6875 build_library_fn_1 (name, operator_code, type)
6876      tree name;
6877      enum tree_code operator_code;
6878      tree type;
6879 {
6880   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6881   DECL_EXTERNAL (fn) = 1;
6882   TREE_PUBLIC (fn) = 1;
6883   DECL_ARTIFICIAL (fn) = 1;
6884   TREE_NOTHROW (fn) = 1;
6885   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6886   SET_DECL_LANGUAGE (fn, lang_c);
6887   return fn;
6888 }
6889
6890 /* Returns the _DECL for a library function with C linkage.
6891    We assume that such functions never throw; if this is incorrect,
6892    callers should unset TREE_NOTHROW.  */
6893
6894 tree
6895 build_library_fn (name, type)
6896      tree name;
6897      tree type;
6898 {
6899   return build_library_fn_1 (name, ERROR_MARK, type);
6900 }
6901
6902 /* Returns the _DECL for a library function with C++ linkage.  */
6903
6904 static tree
6905 build_cp_library_fn (name, operator_code, type)
6906      tree name;
6907      enum tree_code operator_code;
6908      tree type;
6909 {
6910   tree fn = build_library_fn_1 (name, operator_code, type);
6911   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6912   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6913   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6914   set_mangled_name_for_decl (fn);
6915   return fn;
6916 }
6917
6918 /* Like build_library_fn, but takes a C string instead of an
6919    IDENTIFIER_NODE.  */
6920
6921 tree
6922 build_library_fn_ptr (name, type)
6923      const char *name;
6924      tree type;
6925 {
6926   return build_library_fn (get_identifier (name), type);
6927 }
6928
6929 /* Like build_cp_library_fn, but takes a C string instead of an
6930    IDENTIFIER_NODE.  */
6931
6932 tree
6933 build_cp_library_fn_ptr (name, type)
6934      const char *name;
6935      tree type;
6936 {
6937   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6938 }
6939
6940 /* Like build_library_fn, but also pushes the function so that we will
6941    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6942
6943 tree
6944 push_library_fn (name, type)
6945      tree name, type;
6946 {
6947   tree fn = build_library_fn (name, type);
6948   pushdecl_top_level (fn);
6949   return fn;
6950 }
6951
6952 /* Like build_cp_library_fn, but also pushes the function so that it
6953    will be found by normal lookup.  */
6954
6955 static tree
6956 push_cp_library_fn (operator_code, type)
6957      enum tree_code operator_code;
6958      tree type;
6959 {
6960   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6961                                  operator_code,
6962                                  type);
6963   pushdecl (fn);
6964   return fn;
6965 }
6966
6967 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6968    a FUNCTION_TYPE.  */
6969
6970 tree
6971 push_void_library_fn (name, parmtypes)
6972      tree name, parmtypes;
6973 {
6974   tree type = build_function_type (void_type_node, parmtypes);
6975   return push_library_fn (name, type);
6976 }
6977
6978 /* Like push_library_fn, but also note that this function throws
6979    and does not return.  Used for __throw_foo and the like.  */
6980
6981 tree
6982 push_throw_library_fn (name, type)
6983      tree name, type;
6984 {
6985   tree fn = push_library_fn (name, type);
6986   TREE_THIS_VOLATILE (fn) = 1;
6987   TREE_NOTHROW (fn) = 0;
6988   return fn;
6989 }
6990
6991 /* Apply default attributes to a function, if a system function with default
6992    attributes.  */
6993
6994 void
6995 insert_default_attributes (decl)
6996      tree decl;
6997 {
6998   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6999     return;
7000   if (!TREE_PUBLIC (decl))
7001     return;
7002   c_common_insert_default_attributes (decl);
7003 }
7004 \f
7005 /* When we call finish_struct for an anonymous union, we create
7006    default copy constructors and such.  But, an anonymous union
7007    shouldn't have such things; this function undoes the damage to the
7008    anonymous union type T.
7009
7010    (The reason that we create the synthesized methods is that we don't
7011    distinguish `union { int i; }' from `typedef union { int i; } U'.
7012    The first is an anonymous union; the second is just an ordinary
7013    union type.)  */
7014
7015 void
7016 fixup_anonymous_aggr (t)
7017      tree t;
7018 {
7019   tree *q;
7020
7021   /* Wipe out memory of synthesized methods */
7022   TYPE_HAS_CONSTRUCTOR (t) = 0;
7023   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
7024   TYPE_HAS_INIT_REF (t) = 0;
7025   TYPE_HAS_CONST_INIT_REF (t) = 0;
7026   TYPE_HAS_ASSIGN_REF (t) = 0;
7027   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
7028
7029   /* Splice the implicitly generated functions out of the TYPE_METHODS
7030      list.  */
7031   q = &TYPE_METHODS (t);
7032   while (*q)
7033     {
7034       if (DECL_ARTIFICIAL (*q))
7035         *q = TREE_CHAIN (*q);
7036       else
7037         q = &TREE_CHAIN (*q);
7038     }
7039
7040   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
7041   if (TYPE_METHODS (t))
7042     cp_error_at ("an anonymous union cannot have function members", t);
7043
7044   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
7045      assignment operators (because they cannot have these methods themselves).
7046      For anonymous unions this is already checked because they are not allowed
7047      in any union, otherwise we have to check it.  */
7048   if (TREE_CODE (t) != UNION_TYPE)
7049     {
7050       tree field, type;
7051
7052       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
7053         if (TREE_CODE (field) == FIELD_DECL)
7054           {
7055             type = TREE_TYPE (field);
7056             if (CLASS_TYPE_P (type))
7057               {
7058                 if (TYPE_NEEDS_CONSTRUCTING (type))
7059                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
7060                                field);
7061                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7062                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
7063                                field);
7064                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
7065                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
7066                                field);
7067               }
7068           }
7069     }
7070 }
7071
7072 /* Make sure that a declaration with no declarator is well-formed, i.e.
7073    just defines a tagged type or anonymous union.
7074
7075    Returns the type defined, if any.  */
7076
7077 tree
7078 check_tag_decl (declspecs)
7079      tree declspecs;
7080 {
7081   int found_type = 0;
7082   int saw_friend = 0;
7083   int saw_typedef = 0;
7084   tree ob_modifier = NULL_TREE;
7085   register tree link;
7086   register tree t = NULL_TREE;
7087
7088   for (link = declspecs; link; link = TREE_CHAIN (link))
7089     {
7090       register tree value = TREE_VALUE (link);
7091
7092       if (TYPE_P (value)
7093           || TREE_CODE (value) == TYPE_DECL
7094           || (TREE_CODE (value) == IDENTIFIER_NODE
7095               && IDENTIFIER_GLOBAL_VALUE (value)
7096               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
7097         {
7098           ++found_type;
7099
7100           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7101             {
7102               if (! in_system_header)
7103                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7104               return NULL_TREE;
7105             }
7106
7107           if (TYPE_P (value)
7108               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7109                   || TREE_CODE (value) == ENUMERAL_TYPE))
7110             {
7111               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7112               t = value;
7113             }
7114         }
7115       else if (value == ridpointers[(int) RID_TYPEDEF])
7116         saw_typedef = 1;
7117       else if (value == ridpointers[(int) RID_FRIEND])
7118         {
7119           if (current_class_type == NULL_TREE
7120               || current_scope () != current_class_type)
7121             ob_modifier = value;
7122           else
7123             saw_friend = 1;
7124         }
7125       else if (value == ridpointers[(int) RID_STATIC]
7126                || value == ridpointers[(int) RID_EXTERN]
7127                || value == ridpointers[(int) RID_AUTO]
7128                || value == ridpointers[(int) RID_REGISTER]
7129                || value == ridpointers[(int) RID_INLINE]
7130                || value == ridpointers[(int) RID_VIRTUAL]
7131                || value == ridpointers[(int) RID_CONST]
7132                || value == ridpointers[(int) RID_VOLATILE]
7133                || value == ridpointers[(int) RID_EXPLICIT])
7134         ob_modifier = value;
7135     }
7136
7137   if (found_type > 1)
7138     error ("multiple types in one declaration");
7139
7140   if (t == NULL_TREE && ! saw_friend)
7141     pedwarn ("declaration does not declare anything");
7142
7143   /* Check for an anonymous union.  */
7144   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7145            && TYPE_ANONYMOUS_P (t))
7146     {
7147       /* 7/3 In a simple-declaration, the optional init-declarator-list
7148          can be omitted only when declaring a class (clause 9) or
7149          enumeration (7.2), that is, when the decl-specifier-seq contains
7150          either a class-specifier, an elaborated-type-specifier with
7151          a class-key (9.1), or an enum-specifier.  In these cases and
7152          whenever a class-specifier or enum-specifier is present in the
7153          decl-specifier-seq, the identifiers in these specifiers are among
7154          the names being declared by the declaration (as class-name,
7155          enum-names, or enumerators, depending on the syntax).  In such
7156          cases, and except for the declaration of an unnamed bit-field (9.6),
7157          the decl-specifier-seq shall introduce one or more names into the
7158          program, or shall redeclare a name introduced by a previous
7159          declaration.  [Example:
7160              enum { };            // ill-formed
7161              typedef class { };   // ill-formed
7162          --end example]  */
7163       if (saw_typedef)
7164         {
7165           error ("missing type-name in typedef-declaration");
7166           return NULL_TREE;
7167         }
7168       /* Anonymous unions are objects, so they can have specifiers.  */;
7169       SET_ANON_AGGR_TYPE_P (t);
7170
7171       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7172         pedwarn ("ISO C++ prohibits anonymous structs");
7173     }
7174
7175   else if (ob_modifier)
7176     {
7177       if (ob_modifier == ridpointers[(int) RID_INLINE]
7178           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7179         error ("`%D' can only be specified for functions", ob_modifier);
7180       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7181         error ("`%D' can only be specified inside a class", ob_modifier);
7182       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7183         error ("`%D' can only be specified for constructors",
7184                   ob_modifier);
7185       else
7186         error ("`%D' can only be specified for objects and functions",
7187                   ob_modifier);
7188     }
7189
7190   return t;
7191 }
7192
7193 /* Called when a declaration is seen that contains no names to declare.
7194    If its type is a reference to a structure, union or enum inherited
7195    from a containing scope, shadow that tag name for the current scope
7196    with a forward reference.
7197    If its type defines a new named structure or union
7198    or defines an enum, it is valid but we need not do anything here.
7199    Otherwise, it is an error.
7200
7201    C++: may have to grok the declspecs to learn about static,
7202    complain for anonymous unions.  */
7203
7204 void
7205 shadow_tag (declspecs)
7206      tree declspecs;
7207 {
7208   tree t = check_tag_decl (declspecs);
7209
7210   if (t)
7211     maybe_process_partial_specialization (t);
7212
7213   /* This is where the variables in an anonymous union are
7214      declared.  An anonymous union declaration looks like:
7215      union { ... } ;
7216      because there is no declarator after the union, the parser
7217      sends that declaration here.  */
7218   if (t && ANON_AGGR_TYPE_P (t))
7219     {
7220       fixup_anonymous_aggr (t);
7221
7222       if (TYPE_FIELDS (t))
7223         {
7224           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7225                                       NULL);
7226           finish_anon_union (decl);
7227         }
7228     }
7229 }
7230 \f
7231 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7232
7233 tree
7234 groktypename (typename)
7235      tree typename;
7236 {
7237   tree specs, attrs;
7238   tree type;
7239   if (TREE_CODE (typename) != TREE_LIST)
7240     return typename;
7241   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7242   type = grokdeclarator (TREE_VALUE (typename), specs,
7243                          TYPENAME, 0, &attrs);
7244   if (attrs)
7245     cplus_decl_attributes (&type, attrs, 0);
7246   return type;
7247 }
7248
7249 /* Decode a declarator in an ordinary declaration or data definition.
7250    This is called as soon as the type information and variable name
7251    have been parsed, before parsing the initializer if any.
7252    Here we create the ..._DECL node, fill in its type,
7253    and put it on the list of decls for the current context.
7254    The ..._DECL node is returned as the value.
7255
7256    Exception: for arrays where the length is not specified,
7257    the type is left null, to be filled in by `cp_finish_decl'.
7258
7259    Function definitions do not come here; they go to start_function
7260    instead.  However, external and forward declarations of functions
7261    do go through here.  Structure field declarations are done by
7262    grokfield and not through here.  */
7263
7264 tree
7265 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7266      tree declarator, declspecs;
7267      int initialized;
7268      tree attributes, prefix_attributes;
7269 {
7270   tree decl;
7271   register tree type, tem;
7272   tree context;
7273   extern int have_extern_spec;
7274   extern int used_extern_spec;
7275
7276 #if 0
7277   /* See code below that used this.  */
7278   int init_written = initialized;
7279 #endif
7280
7281   /* This should only be done once on the top most decl.  */
7282   if (have_extern_spec && !used_extern_spec)
7283     {
7284       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7285                              declspecs);
7286       used_extern_spec = 1;
7287     }
7288
7289   /* An object declared as __attribute__((deprecated)) suppresses
7290      warnings of uses of other deprecated items.  */
7291   if (lookup_attribute ("deprecated", attributes))
7292     deprecated_state = DEPRECATED_SUPPRESS;
7293
7294   attributes = chainon (attributes, prefix_attributes);
7295
7296   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7297                          &attributes);
7298
7299   deprecated_state = DEPRECATED_NORMAL;
7300
7301   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7302     return NULL_TREE;
7303
7304   type = TREE_TYPE (decl);
7305
7306   if (type == error_mark_node)
7307     return NULL_TREE;
7308
7309   context = DECL_CONTEXT (decl);
7310
7311   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7312       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7313     {
7314       /* When parsing the initializer, lookup should use the object's
7315          namespace. */
7316       push_decl_namespace (context);
7317     }
7318
7319   /* We are only interested in class contexts, later. */
7320   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7321     context = NULL_TREE;
7322
7323   if (initialized)
7324     /* Is it valid for this decl to have an initializer at all?
7325        If not, set INITIALIZED to zero, which will indirectly
7326        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7327     switch (TREE_CODE (decl))
7328       {
7329       case TYPE_DECL:
7330         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7331         initialized = 0;
7332         break;
7333
7334       case FUNCTION_DECL:
7335         error ("function `%#D' is initialized like a variable", decl);
7336         initialized = 0;
7337         break;
7338
7339       default:
7340         break;
7341       }
7342
7343   if (initialized)
7344     {
7345       if (! toplevel_bindings_p ()
7346           && DECL_EXTERNAL (decl))
7347         warning ("declaration of `%#D' has `extern' and is initialized",
7348                     decl);
7349       DECL_EXTERNAL (decl) = 0;
7350       if (toplevel_bindings_p ())
7351         TREE_STATIC (decl) = 1;
7352
7353       /* Tell `pushdecl' this is an initialized decl
7354          even though we don't yet have the initializer expression.
7355          Also tell `cp_finish_decl' it may store the real initializer.  */
7356       DECL_INITIAL (decl) = error_mark_node;
7357     }
7358
7359   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7360   cplus_decl_attributes (&decl, attributes, 0);
7361
7362   /* If #pragma weak was used, mark the decl weak now.  */
7363   if (current_binding_level == global_binding_level)
7364     maybe_apply_pragma_weak (decl);
7365
7366   if (TREE_CODE (decl) == FUNCTION_DECL
7367       && DECL_DECLARED_INLINE_P (decl)
7368       && DECL_UNINLINABLE (decl)
7369       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7370     warning_with_decl (decl,
7371                        "inline function `%s' given attribute noinline");
7372
7373   if (context && COMPLETE_TYPE_P (complete_type (context)))
7374     {
7375       push_nested_class (context, 2);
7376
7377       if (TREE_CODE (decl) == VAR_DECL)
7378         {
7379           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7380           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7381             error ("`%#D' is not a static member of `%#T'", decl, context);
7382           else
7383             {
7384               if (DECL_CONTEXT (field) != context)
7385                 {
7386                   pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7387                               DECL_CONTEXT (field), DECL_NAME (decl),
7388                               context, DECL_NAME (decl));
7389                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7390                 }
7391               /* Static data member are tricky; an in-class initialization
7392                  still doesn't provide a definition, so the in-class
7393                  declaration will have DECL_EXTERNAL set, but will have an
7394                  initialization.  Thus, duplicate_decls won't warn
7395                  about this situation, and so we check here.  */
7396               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7397                 error ("duplicate initialization of %D", decl);
7398               if (duplicate_decls (decl, field))
7399                 decl = field;
7400             }
7401         }
7402       else
7403         {
7404           tree field = check_classfn (context, decl);
7405           if (field && duplicate_decls (decl, field))
7406             decl = field;
7407         }
7408
7409       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7410       DECL_IN_AGGR_P (decl) = 0;
7411       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7412           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7413         {
7414           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7415           /* [temp.expl.spec] An explicit specialization of a static data
7416              member of a template is a definition if the declaration
7417              includes an initializer; otherwise, it is a declaration.
7418
7419              We check for processing_specialization so this only applies
7420              to the new specialization syntax.  */
7421           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7422             DECL_EXTERNAL (decl) = 1;
7423         }
7424
7425       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7426         pedwarn ("declaration of `%#D' outside of class is not definition",
7427                     decl);
7428     }
7429
7430   /* Enter this declaration into the symbol table.  */
7431   tem = maybe_push_decl (decl);
7432
7433   if (processing_template_decl)
7434     tem = push_template_decl (tem);
7435
7436 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7437   /* Tell the back-end to use or not use .common as appropriate.  If we say
7438      -fconserve-space, we want this to save .data space, at the expense of
7439      wrong semantics.  If we say -fno-conserve-space, we want this to
7440      produce errors about redefs; to do this we force variables into the
7441      data segment.  */
7442   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7443 #endif
7444
7445   if (! processing_template_decl)
7446     start_decl_1 (tem);
7447
7448   return tem;
7449 }
7450
7451 void
7452 start_decl_1 (decl)
7453      tree decl;
7454 {
7455   tree type = TREE_TYPE (decl);
7456   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7457
7458   if (type == error_mark_node)
7459     return;
7460
7461   maybe_push_cleanup_level (type);
7462
7463   if (initialized)
7464     /* Is it valid for this decl to have an initializer at all?
7465        If not, set INITIALIZED to zero, which will indirectly
7466        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7467     {
7468       /* Don't allow initializations for incomplete types except for
7469          arrays which might be completed by the initialization.  */
7470       if (COMPLETE_TYPE_P (complete_type (type)))
7471         ;                       /* A complete type is ok.  */
7472       else if (TREE_CODE (type) != ARRAY_TYPE)
7473         {
7474           error ("variable `%#D' has initializer but incomplete type",
7475                     decl);
7476           initialized = 0;
7477           type = TREE_TYPE (decl) = error_mark_node;
7478         }
7479       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7480         {
7481           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7482             error ("elements of array `%#D' have incomplete type", decl);
7483           /* else we already gave an error in start_decl.  */
7484           initialized = 0;
7485         }
7486     }
7487
7488   if (!initialized
7489       && TREE_CODE (decl) != TYPE_DECL
7490       && TREE_CODE (decl) != TEMPLATE_DECL
7491       && type != error_mark_node
7492       && IS_AGGR_TYPE (type)
7493       && ! DECL_EXTERNAL (decl))
7494     {
7495       if ((! processing_template_decl || ! uses_template_parms (type))
7496           && !COMPLETE_TYPE_P (complete_type (type)))
7497         {
7498           error ("aggregate `%#D' has incomplete type and cannot be defined",
7499                  decl);
7500           /* Change the type so that assemble_variable will give
7501              DECL an rtl we can live with: (mem (const_int 0)).  */
7502           type = TREE_TYPE (decl) = error_mark_node;
7503         }
7504       else
7505         {
7506           /* If any base type in the hierarchy of TYPE needs a constructor,
7507              then we set initialized to 1.  This way any nodes which are
7508              created for the purposes of initializing this aggregate
7509              will live as long as it does.  This is necessary for global
7510              aggregates which do not have their initializers processed until
7511              the end of the file.  */
7512           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7513         }
7514     }
7515
7516   if (! initialized)
7517     DECL_INITIAL (decl) = NULL_TREE;
7518 }
7519
7520 /* Handle initialization of references.
7521    These three arguments are from `cp_finish_decl', and have the
7522    same meaning here that they do there.
7523
7524    Quotes on semantics can be found in ARM 8.4.3.  */
7525
7526 static tree
7527 grok_reference_init (decl, type, init)
7528      tree decl, type, init;
7529 {
7530   tree tmp;
7531
7532   if (init == NULL_TREE)
7533     {
7534       if ((DECL_LANG_SPECIFIC (decl) == 0
7535            || DECL_IN_AGGR_P (decl) == 0)
7536           && ! DECL_THIS_EXTERN (decl))
7537         error ("`%D' declared as reference but not initialized", decl);
7538       return NULL_TREE;
7539     }
7540
7541   if (init == error_mark_node)
7542     return NULL_TREE;
7543
7544   if (TREE_CODE (init) == CONSTRUCTOR)
7545     {
7546       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7547       return NULL_TREE;
7548     }
7549
7550   if (TREE_CODE (init) == TREE_LIST)
7551     init = build_compound_expr (init);
7552
7553   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7554     init = convert_from_reference (init);
7555
7556   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7557       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7558     {
7559       /* Note: default conversion is only called in very special cases.  */
7560       init = default_conversion (init);
7561     }
7562
7563   /* Convert INIT to the reference type TYPE.  This may involve the
7564      creation of a temporary, whose lifetime must be the same as that
7565      of the reference.  If so, a DECL_STMT for the temporary will be
7566      added just after the DECL_STMT for DECL.  That's why we don't set
7567      DECL_INITIAL for local references (instead assigning to them
7568      explicitly); we need to allow the temporary to be initialized
7569      first.  */
7570   tmp = convert_to_reference
7571     (type, init, CONV_IMPLICIT,
7572      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7573      decl);
7574
7575   if (tmp == error_mark_node)
7576     return NULL_TREE;
7577   else if (tmp == NULL_TREE)
7578     {
7579       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7580       return NULL_TREE;
7581     }
7582
7583   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7584     return tmp;
7585
7586   DECL_INITIAL (decl) = tmp;
7587
7588   return NULL_TREE;
7589 }
7590
7591 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7592    mucking with forces it does not comprehend (i.e. initialization with a
7593    constructor).  If we are at global scope and won't go into COMMON, fill
7594    it in with a dummy CONSTRUCTOR to force the variable into .data;
7595    otherwise we can use error_mark_node.  */
7596
7597 static tree
7598 obscure_complex_init (decl, init)
7599      tree decl, init;
7600 {
7601   if (! flag_no_inline && TREE_STATIC (decl))
7602     {
7603       if (extract_init (decl, init))
7604         return NULL_TREE;
7605     }
7606
7607 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7608   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7609     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7610                                  NULL_TREE);
7611   else
7612 #endif
7613     {
7614       if (zero_init_p (TREE_TYPE (decl)))
7615         DECL_INITIAL (decl) = error_mark_node;
7616       /* Otherwise, force_store_init_value will have already stored a
7617          zero-init initializer in DECL_INITIAL, that should be
7618          retained.  */
7619     }
7620
7621   return init;
7622 }
7623
7624 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7625    array until we finish parsing the initializer.  If that's the
7626    situation we're in, update DECL accordingly.  */
7627
7628 static void
7629 maybe_deduce_size_from_array_init (decl, init)
7630      tree decl;
7631      tree init;
7632 {
7633   tree type = TREE_TYPE (decl);
7634
7635   if (TREE_CODE (type) == ARRAY_TYPE
7636       && TYPE_DOMAIN (type) == NULL_TREE
7637       && TREE_CODE (decl) != TYPE_DECL)
7638     {
7639       /* do_default is really a C-ism to deal with tentative definitions.
7640          But let's leave it here to ease the eventual merge.  */
7641       int do_default = !DECL_EXTERNAL (decl);
7642       tree initializer = init ? init : DECL_INITIAL (decl);
7643       int failure = complete_array_type (type, initializer, do_default);
7644
7645       if (failure == 1)
7646         error ("initializer fails to determine size of `%D'", decl);
7647
7648       if (failure == 2)
7649         {
7650           if (do_default)
7651             error ("array size missing in `%D'", decl);
7652           /* If a `static' var's size isn't known, make it extern as
7653              well as static, so it does not get allocated.  If it's not
7654              `static', then don't mark it extern; finish_incomplete_decl
7655              will give it a default size and it will get allocated.  */
7656           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7657             DECL_EXTERNAL (decl) = 1;
7658         }
7659
7660       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7661           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7662                               integer_zero_node))
7663         error ("zero-size array `%D'", decl);
7664
7665       layout_decl (decl, 0);
7666     }
7667 }
7668
7669 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7670    any appropriate error messages regarding the layout.  */
7671
7672 static void
7673 layout_var_decl (decl)
7674      tree decl;
7675 {
7676   tree type = TREE_TYPE (decl);
7677 #if 0
7678   tree ttype = target_type (type);
7679 #endif
7680
7681   /* If we haven't already layed out this declaration, do so now.
7682      Note that we must not call complete type for an external object
7683      because it's type might involve templates that we are not
7684      supposed to isntantiate yet.  (And it's perfectly legal to say
7685      `extern X x' for some incomplete type `X'.)  */
7686   if (!DECL_EXTERNAL (decl))
7687     complete_type (type);
7688   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7689     layout_decl (decl, 0);
7690
7691   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7692     {
7693       /* An automatic variable with an incomplete type: that is an error.
7694          Don't talk about array types here, since we took care of that
7695          message in grokdeclarator.  */
7696       error ("storage size of `%D' isn't known", decl);
7697       TREE_TYPE (decl) = error_mark_node;
7698     }
7699 #if 0
7700   /* Keep this code around in case we later want to control debug info
7701      based on whether a type is "used".  (jason 1999-11-11) */
7702
7703   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7704     /* Let debugger know it should output info for this type.  */
7705     note_debug_info_needed (ttype);
7706
7707   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7708     note_debug_info_needed (DECL_CONTEXT (decl));
7709 #endif
7710
7711   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7712       && DECL_SIZE (decl) != NULL_TREE
7713       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7714     {
7715       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7716         constant_expression_warning (DECL_SIZE (decl));
7717       else
7718         error ("storage size of `%D' isn't constant", decl);
7719     }
7720
7721   if (TREE_STATIC (decl)
7722       && !DECL_ARTIFICIAL (decl)
7723       && current_function_decl
7724       && DECL_CONTEXT (decl) == current_function_decl)
7725     push_local_name (decl);
7726 }
7727
7728 /* If a local static variable is declared in an inline function, or if
7729    we have a weak definition, we must endeavor to create only one
7730    instance of the variable at link-time.  */
7731
7732 static void
7733 maybe_commonize_var (decl)
7734      tree decl;
7735 {
7736   /* Static data in a function with comdat linkage also has comdat
7737      linkage.  */
7738   if (TREE_STATIC (decl)
7739       /* Don't mess with __FUNCTION__.  */
7740       && ! DECL_ARTIFICIAL (decl)
7741       && current_function_decl
7742       && DECL_CONTEXT (decl) == current_function_decl
7743       && (DECL_DECLARED_INLINE_P (current_function_decl)
7744           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7745       && TREE_PUBLIC (current_function_decl))
7746     {
7747       /* If flag_weak, we don't need to mess with this, as we can just
7748          make the function weak, and let it refer to its unique local
7749          copy.  This works because we don't allow the function to be
7750          inlined.  */
7751       if (! flag_weak)
7752         {
7753           if (DECL_INTERFACE_KNOWN (current_function_decl))
7754             {
7755               TREE_PUBLIC (decl) = 1;
7756               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7757             }
7758           else if (DECL_INITIAL (decl) == NULL_TREE
7759                    || DECL_INITIAL (decl) == error_mark_node)
7760             {
7761               TREE_PUBLIC (decl) = 1;
7762               DECL_COMMON (decl) = 1;
7763             }
7764           /* else we lose. We can only do this if we can use common,
7765              which we can't if it has been initialized.  */
7766
7767           if (!TREE_PUBLIC (decl))
7768             {
7769               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7770               cp_warning_at ("  you can work around this by removing the initializer", decl);
7771             }
7772         }
7773       else
7774         comdat_linkage (decl);
7775     }
7776   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7777     /* Set it up again; we might have set DECL_INITIAL since the last
7778        time.  */
7779     comdat_linkage (decl);
7780 }
7781
7782 /* Issue an error message if DECL is an uninitialized const variable.  */
7783
7784 static void
7785 check_for_uninitialized_const_var (decl)
7786      tree decl;
7787 {
7788   tree type = TREE_TYPE (decl);
7789
7790   /* ``Unless explicitly declared extern, a const object does not have
7791      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7792      7.1.6 */
7793   if (TREE_CODE (decl) == VAR_DECL
7794       && TREE_CODE (type) != REFERENCE_TYPE
7795       && CP_TYPE_CONST_P (type)
7796       && !TYPE_NEEDS_CONSTRUCTING (type)
7797       && !DECL_INITIAL (decl))
7798     error ("uninitialized const `%D'", decl);
7799 }
7800
7801 /* Verify INIT (the initializer for DECL), and record the
7802    initialization in DECL_INITIAL, if appropriate.  Returns a new
7803    value for INIT.  */
7804
7805 static tree
7806 check_initializer (decl, init)
7807      tree decl;
7808      tree init;
7809 {
7810   tree type;
7811
7812   if (TREE_CODE (decl) == FIELD_DECL)
7813     return init;
7814
7815   type = TREE_TYPE (decl);
7816
7817   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7818   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7819     init = NULL_TREE;
7820
7821   /* Check the initializer.  */
7822   if (init)
7823     {
7824       /* Things that are going to be initialized need to have complete
7825          type.  */
7826       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7827
7828       if (type == error_mark_node)
7829         /* We will have already complained.  */
7830         init = NULL_TREE;
7831       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7832         {
7833           error ("variable-sized object `%D' may not be initialized", decl);
7834           init = NULL_TREE;
7835         }
7836       else if (TREE_CODE (type) == ARRAY_TYPE
7837                && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7838         {
7839           error ("elements of array `%#D' have incomplete type", decl);
7840           init = NULL_TREE;
7841         }
7842       else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7843         {
7844           error ("`%D' has incomplete type", decl);
7845           TREE_TYPE (decl) = error_mark_node;
7846           init = NULL_TREE;
7847         }
7848     }
7849
7850   if (TREE_CODE (decl) == CONST_DECL)
7851     {
7852       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7853
7854       DECL_INITIAL (decl) = init;
7855
7856       my_friendly_assert (init != NULL_TREE, 149);
7857       init = NULL_TREE;
7858     }
7859   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7860     {
7861       init = grok_reference_init (decl, type, init);
7862       if (init)
7863         init = obscure_complex_init (decl, init);
7864     }
7865   else if (!DECL_EXTERNAL (decl) && !zero_init_p (type))
7866     {
7867       force_store_init_value (decl, build_forced_zero_init (type));
7868
7869       if (init)
7870         goto process_init;
7871     }
7872   else if (init)
7873     {
7874     process_init:
7875       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7876         {
7877           if (TREE_CODE (type) == ARRAY_TYPE)
7878             init = digest_init (type, init, (tree *) 0);
7879           else if (TREE_CODE (init) == CONSTRUCTOR
7880                    && TREE_HAS_CONSTRUCTOR (init))
7881             {
7882               if (TYPE_NON_AGGREGATE_CLASS (type))
7883                 {
7884                   error ("`%D' must be initialized by constructor, not by `{...}'",
7885                             decl);
7886                   init = error_mark_node;
7887                 }
7888               else
7889                 goto dont_use_constructor;
7890             }
7891         }
7892       else
7893         {
7894         dont_use_constructor:
7895           if (TREE_CODE (init) != TREE_VEC)
7896             init = store_init_value (decl, init);
7897         }
7898
7899       if (init)
7900         /* We must hide the initializer so that expand_decl
7901            won't try to do something it does not understand.  */
7902         init = obscure_complex_init (decl, init);
7903     }
7904   else if (DECL_EXTERNAL (decl))
7905     ;
7906   else if (TYPE_P (type)
7907            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7908     {
7909       tree core_type = strip_array_types (type);
7910
7911       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7912         {
7913           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7914             error ("structure `%D' with uninitialized const members", decl);
7915           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7916             error ("structure `%D' with uninitialized reference members",
7917                       decl);
7918         }
7919
7920       check_for_uninitialized_const_var (decl);
7921
7922       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7923         init = obscure_complex_init (decl, NULL_TREE);
7924
7925     }
7926   else
7927     check_for_uninitialized_const_var (decl);
7928
7929   return init;
7930 }
7931
7932 /* If DECL is not a local variable, give it RTL.  */
7933
7934 static void
7935 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7936      tree decl;
7937      tree init;
7938      const char *asmspec;
7939 {
7940   int toplev = toplevel_bindings_p ();
7941   int defer_p;
7942
7943   /* Handle non-variables up front.  */
7944   if (TREE_CODE (decl) != VAR_DECL)
7945     {
7946       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7947       return;
7948     }
7949
7950   /* If we see a class member here, it should be a static data
7951      member.  */
7952   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7953     {
7954       my_friendly_assert (TREE_STATIC (decl), 19990828);
7955       /* An in-class declaration of a static data member should be
7956          external; it is only a declaration, and not a definition.  */
7957       if (init == NULL_TREE)
7958         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7959     }
7960
7961   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7962   if (asmspec)
7963     {
7964       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7965       /* The `register' keyword, when used together with an
7966          asm-specification, indicates that the variable should be
7967          placed in a particular register.  */
7968       if (DECL_REGISTER (decl))
7969         DECL_C_HARD_REGISTER (decl) = 1;
7970     }
7971
7972   /* We don't create any RTL for local variables.  */
7973   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7974     return;
7975
7976   /* We defer emission of local statics until the corresponding
7977      DECL_STMT is expanded.  */
7978   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7979
7980   /* We try to defer namespace-scope static constants so that they are
7981      not emitted into the object file unnecessarily.  */
7982   if (!DECL_VIRTUAL_P (decl)
7983       && TREE_READONLY (decl)
7984       && DECL_INITIAL (decl) != NULL_TREE
7985       && DECL_INITIAL (decl) != error_mark_node
7986       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7987       && toplev
7988       && !TREE_PUBLIC (decl))
7989     {
7990       /* Fool with the linkage of static consts according to #pragma
7991          interface.  */
7992       if (!interface_unknown && !TREE_PUBLIC (decl))
7993         {
7994           TREE_PUBLIC (decl) = 1;
7995           DECL_EXTERNAL (decl) = interface_only;
7996         }
7997
7998       defer_p = 1;
7999     }
8000   /* Likewise for template instantiations.  */
8001   else if (DECL_COMDAT (decl))
8002     defer_p = 1;
8003
8004   /* If we're deferring the variable, we only need to make RTL if
8005      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
8006      we need it.  (There's no way to lazily create RTL for things that
8007      have assembly specs because the information about the specifier
8008      isn't stored in the tree, yet)  */
8009   if (defer_p && asmspec)
8010     make_decl_rtl (decl, asmspec);
8011   /* If we're not deferring, go ahead and assemble the variable.  */
8012   else if (!defer_p)
8013     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8014 }
8015
8016 /* The old ARM scoping rules injected variables declared in the
8017    initialization statement of a for-statement into the surrounding
8018    scope.  We support this usage, in order to be backward-compatible.
8019    DECL is a just-declared VAR_DECL; if necessary inject its
8020    declaration into the surrounding scope.  */
8021
8022 void
8023 maybe_inject_for_scope_var (decl)
8024      tree decl;
8025 {
8026   if (!DECL_NAME (decl))
8027     return;
8028
8029   /* Declarations of __FUNCTION__ and its ilk appear magically when
8030      the variable is first used.  If that happens to be inside a
8031      for-loop, we don't want to do anything special.  */
8032   if (DECL_PRETTY_FUNCTION_P (decl))
8033     return;
8034
8035   if (current_binding_level->is_for_scope)
8036     {
8037       struct binding_level *outer
8038         = current_binding_level->level_chain;
8039
8040       /* Check to see if the same name is already bound at the outer
8041          level, either because it was directly declared, or because a
8042          dead for-decl got preserved.  In either case, the code would
8043          not have been valid under the ARM scope rules, so clear
8044          is_for_scope for the current_binding_level.
8045
8046          Otherwise, we need to preserve the temp slot for decl to last
8047          into the outer binding level.  */
8048
8049       tree outer_binding
8050         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8051
8052       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8053           && (TREE_CODE (BINDING_VALUE (outer_binding))
8054               == VAR_DECL)
8055           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8056         {
8057           BINDING_VALUE (outer_binding)
8058             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8059           current_binding_level->is_for_scope = 0;
8060         }
8061       else if (DECL_IN_MEMORY_P (decl))
8062         preserve_temp_slots (DECL_RTL (decl));
8063     }
8064 }
8065
8066 /* Generate code to initialize DECL (a local variable).  */
8067
8068 void
8069 initialize_local_var (decl, init, flags)
8070      tree decl;
8071      tree init;
8072      int flags;
8073 {
8074   tree type = TREE_TYPE (decl);
8075
8076   /* If the type is bogus, don't bother initializing the variable.  */
8077   if (type == error_mark_node)
8078     return;
8079
8080   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
8081     {
8082       /* If we used it already as memory, it must stay in memory.  */
8083       DECL_INITIAL (decl) = NULL_TREE;
8084       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8085     }
8086
8087   /* Local statics are handled differently from ordinary automatic
8088      variables.  */
8089   if (TREE_STATIC (decl))
8090     {
8091       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8092           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8093         expand_static_init (decl, init);
8094       return;
8095     }
8096
8097   if (DECL_SIZE (decl) && type != error_mark_node)
8098     {
8099       int already_used;
8100
8101       /* Compute and store the initial value.  */
8102       already_used = TREE_USED (decl) || TREE_USED (type);
8103
8104       if (init || TYPE_NEEDS_CONSTRUCTING (type))
8105         {
8106           int saved_stmts_are_full_exprs_p;
8107
8108           my_friendly_assert (building_stmt_tree (), 20000906);
8109           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8110           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8111           finish_expr_stmt (build_aggr_init (decl, init, flags));
8112           current_stmt_tree ()->stmts_are_full_exprs_p =
8113             saved_stmts_are_full_exprs_p;
8114         }
8115
8116       /* Set this to 0 so we can tell whether an aggregate which was
8117          initialized was ever used.  Don't do this if it has a
8118          destructor, so we don't complain about the 'resource
8119          allocation is initialization' idiom.  Now set
8120          attribute((unused)) on types so decls of that type will be
8121          marked used. (see TREE_USED, above.)  */
8122       if (TYPE_NEEDS_CONSTRUCTING (type)
8123           && ! already_used
8124           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8125           && DECL_NAME (decl))
8126         TREE_USED (decl) = 0;
8127       else if (already_used)
8128         TREE_USED (decl) = 1;
8129     }
8130 }
8131
8132 /* Generate code to destroy DECL (a local variable).  */
8133
8134 static void
8135 destroy_local_var (decl)
8136      tree decl;
8137 {
8138   tree type = TREE_TYPE (decl);
8139   tree cleanup;
8140
8141   /* Only variables get cleaned up.  */
8142   if (TREE_CODE (decl) != VAR_DECL)
8143     return;
8144
8145   /* And only things with destructors need cleaning up.  */
8146   if (type == error_mark_node
8147       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8148     return;
8149
8150   if (TREE_CODE (decl) == VAR_DECL &&
8151       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8152     /* We don't clean up things that aren't defined in this
8153        translation unit, or that need a static cleanup.  The latter
8154        are handled by finish_file.  */
8155     return;
8156
8157   /* Compute the cleanup.  */
8158   cleanup = maybe_build_cleanup (decl);
8159
8160   /* Record the cleanup required for this declaration.  */
8161   if (DECL_SIZE (decl) && cleanup)
8162     finish_decl_cleanup (decl, cleanup);
8163 }
8164
8165 /* Finish processing of a declaration;
8166    install its line number and initial value.
8167    If the length of an array type is not known before,
8168    it must be determined now, from the initial value, or it is an error.
8169
8170    INIT holds the value of an initializer that should be allowed to escape
8171    the normal rules.
8172
8173    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8174    if the (init) syntax was used.  */
8175
8176 void
8177 cp_finish_decl (decl, init, asmspec_tree, flags)
8178      tree decl, init;
8179      tree asmspec_tree;
8180      int flags;
8181 {
8182   register tree type;
8183   tree ttype = NULL_TREE;
8184   const char *asmspec = NULL;
8185   int was_readonly = 0;
8186
8187   if (! decl)
8188     {
8189       if (init)
8190         error ("assignment (not initialization) in declaration");
8191       return;
8192     }
8193
8194   /* If a name was specified, get the string.  */
8195   if (current_binding_level == global_binding_level)
8196     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8197   if (asmspec_tree)
8198     asmspec = TREE_STRING_POINTER (asmspec_tree);
8199
8200   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8201     {
8202       error ("cannot initialize `%D' to namespace `%D'",
8203                 decl, init);
8204       init = NULL_TREE;
8205     }
8206
8207   if (current_class_type
8208       && CP_DECL_CONTEXT (decl) == current_class_type
8209       && TYPE_BEING_DEFINED (current_class_type)
8210       && (DECL_INITIAL (decl) || init))
8211     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8212
8213   if (TREE_CODE (decl) == VAR_DECL
8214       && DECL_CONTEXT (decl)
8215       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8216       && DECL_CONTEXT (decl) != current_namespace
8217       && init)
8218     {
8219       /* Leave the namespace of the object. */
8220       pop_decl_namespace ();
8221     }
8222
8223   type = TREE_TYPE (decl);
8224
8225   if (type == error_mark_node)
8226     return;
8227
8228   if (TYPE_HAS_MUTABLE_P (type))
8229     TREE_READONLY (decl) = 0;
8230
8231   if (processing_template_decl)
8232     {
8233       /* Add this declaration to the statement-tree.  */
8234       if (at_function_scope_p ()
8235           && TREE_CODE (decl) != RESULT_DECL)
8236         add_decl_stmt (decl);
8237
8238       if (init && DECL_INITIAL (decl))
8239         DECL_INITIAL (decl) = init;
8240       goto finish_end0;
8241     }
8242
8243   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8244   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8245
8246   /* Take care of TYPE_DECLs up front.  */
8247   if (TREE_CODE (decl) == TYPE_DECL)
8248     {
8249       if (type != error_mark_node
8250           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8251         {
8252           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8253             warning ("shadowing previous type declaration of `%#D'", decl);
8254           set_identifier_type_value (DECL_NAME (decl), type);
8255           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8256         }
8257
8258       /* If we have installed this as the canonical typedef for this
8259          type, and that type has not been defined yet, delay emitting
8260          the debug information for it, as we will emit it later.  */
8261       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8262           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8263         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8264
8265       rest_of_decl_compilation (decl, NULL,
8266                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8267       goto finish_end;
8268     }
8269
8270   if (TREE_CODE (decl) != FUNCTION_DECL)
8271     ttype = target_type (type);
8272
8273   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8274       && TYPE_NEEDS_CONSTRUCTING (type))
8275     {
8276       /* Currently, GNU C++ puts constants in text space, making them
8277          impossible to initialize.  In the future, one would hope for
8278          an operating system which understood the difference between
8279          initialization and the running of a program.  */
8280       was_readonly = 1;
8281       TREE_READONLY (decl) = 0;
8282     }
8283
8284   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8285     {
8286       /* This must override the asm specifier which was placed by
8287          grokclassfn.  Lay this out fresh.  */
8288       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8289       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8290       make_decl_rtl (decl, asmspec);
8291     }
8292
8293   /* Deduce size of array from initialization, if not already known.  */
8294   init = check_initializer (decl, init);
8295   maybe_deduce_size_from_array_init (decl, init);
8296
8297   /* Add this declaration to the statement-tree.  This needs to happen
8298      after the call to check_initializer so that the DECL_STMT for a
8299      reference temp is added before the DECL_STMT for the reference itself.  */
8300   if (building_stmt_tree ()
8301       && at_function_scope_p ()
8302       && TREE_CODE (decl) != RESULT_DECL)
8303     add_decl_stmt (decl);
8304
8305   if (TREE_CODE (decl) == VAR_DECL)
8306     layout_var_decl (decl);
8307
8308   /* Output the assembler code and/or RTL code for variables and functions,
8309      unless the type is an undefined structure or union.
8310      If not, it will get done when the type is completed.  */
8311   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8312       || TREE_CODE (decl) == RESULT_DECL)
8313     {
8314       if (TREE_CODE (decl) == VAR_DECL)
8315         maybe_commonize_var (decl);
8316
8317       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8318
8319       if (TREE_CODE (type) == FUNCTION_TYPE
8320           || TREE_CODE (type) == METHOD_TYPE)
8321         abstract_virtuals_error (decl,
8322                                  strip_array_types (TREE_TYPE (type)));
8323       else
8324         abstract_virtuals_error (decl, strip_array_types (type));
8325
8326       if (TREE_CODE (decl) == FUNCTION_DECL)
8327         ;
8328       else if (DECL_EXTERNAL (decl)
8329                && ! (DECL_LANG_SPECIFIC (decl)
8330                      && DECL_NOT_REALLY_EXTERN (decl)))
8331         {
8332           if (init)
8333             DECL_INITIAL (decl) = init;
8334         }
8335       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8336         {
8337           /* This is a local declaration.  */
8338           if (doing_semantic_analysis_p ())
8339             maybe_inject_for_scope_var (decl);
8340           /* Initialize the local variable.  But, if we're building a
8341              statement-tree, we'll do the initialization when we
8342              expand the tree.  */
8343           if (processing_template_decl)
8344             {
8345               if (init || DECL_INITIAL (decl) == error_mark_node)
8346                 DECL_INITIAL (decl) = init;
8347             }
8348           else
8349             {
8350               /* If we're not building RTL, then we need to do so
8351                  now.  */
8352               my_friendly_assert (building_stmt_tree (), 20000906);
8353               /* Initialize the variable.  */
8354               initialize_local_var (decl, init, flags);
8355               /* Clean up the variable.  */
8356               destroy_local_var (decl);
8357             }
8358         }
8359       else if (TREE_STATIC (decl) && type != error_mark_node)
8360         {
8361           /* Cleanups for static variables are handled by `finish_file'.  */
8362           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8363               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8364             expand_static_init (decl, init);
8365         }
8366     finish_end0:
8367
8368       /* Undo call to `pushclass' that was done in `start_decl'
8369          due to initialization of qualified member variable.
8370          I.e., Foo::x = 10;  */
8371       {
8372         tree context = CP_DECL_CONTEXT (decl);
8373         if (context
8374             && TYPE_P (context)
8375             && (TREE_CODE (decl) == VAR_DECL
8376                 /* We also have a pushclass done that we need to undo here
8377                    if we're at top level and declare a method.  */
8378                 || TREE_CODE (decl) == FUNCTION_DECL)
8379             /* If size hasn't been set, we're still defining it,
8380                and therefore inside the class body; don't pop
8381                the binding level..  */
8382             && COMPLETE_TYPE_P (context)
8383             && context == current_class_type)
8384           pop_nested_class ();
8385       }
8386     }
8387
8388  finish_end:
8389
8390   if (was_readonly)
8391     TREE_READONLY (decl) = 1;
8392 }
8393
8394 /* This is here for a midend callback from c-common.c */
8395
8396 void
8397 finish_decl (decl, init, asmspec_tree)
8398      tree decl, init;
8399      tree asmspec_tree;
8400 {
8401   cp_finish_decl (decl, init, asmspec_tree, 0);
8402 }
8403
8404 /* Returns a declaration for a VAR_DECL as if:
8405
8406      extern "C" TYPE NAME;
8407
8408    had been seen.  Used to create compiler-generated global
8409    variables.  */
8410
8411 tree
8412 declare_global_var (name, type)
8413      tree name;
8414      tree type;
8415 {
8416   tree decl;
8417
8418   push_to_top_level ();
8419   decl = build_decl (VAR_DECL, name, type);
8420   TREE_PUBLIC (decl) = 1;
8421   DECL_EXTERNAL (decl) = 1;
8422   DECL_ARTIFICIAL (decl) = 1;
8423   pushdecl (decl);
8424   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8425   pop_from_top_level ();
8426
8427   return decl;
8428 }
8429
8430 /* Returns a pointer to the `atexit' function.  Note that if
8431    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8432    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8433
8434 static tree
8435 get_atexit_node ()
8436 {
8437   tree atexit_fndecl;
8438   tree arg_types;
8439   tree fn_type;
8440   tree fn_ptr_type;
8441   const char *name;
8442
8443   if (atexit_node)
8444     return atexit_node;
8445
8446   if (flag_use_cxa_atexit)
8447     {
8448       /* The declaration for `__cxa_atexit' is:
8449
8450            int __cxa_atexit (void (*)(void *), void *, void *)
8451
8452          We build up the argument types and then then function type
8453          itself.  */
8454
8455       /* First, build the pointer-to-function type for the first
8456          argument.  */
8457       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8458       fn_type = build_function_type (void_type_node, arg_types);
8459       fn_ptr_type = build_pointer_type (fn_type);
8460       /* Then, build the rest of the argument types.  */
8461       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8462       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8463       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8464       /* And the final __cxa_atexit type.  */
8465       fn_type = build_function_type (integer_type_node, arg_types);
8466       fn_ptr_type = build_pointer_type (fn_type);
8467       name = "__cxa_atexit";
8468     }
8469   else
8470     {
8471       /* The declaration for `atexit' is:
8472
8473            int atexit (void (*)());
8474
8475          We build up the argument types and then then function type
8476          itself.  */
8477       fn_type = build_function_type (void_type_node, void_list_node);
8478       fn_ptr_type = build_pointer_type (fn_type);
8479       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8480       /* Build the final atexit type.  */
8481       fn_type = build_function_type (integer_type_node, arg_types);
8482       name = "atexit";
8483     }
8484
8485   /* Now, build the function declaration.  */
8486   push_lang_context (lang_name_c);
8487   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8488   mark_used (atexit_fndecl);
8489   pop_lang_context ();
8490   atexit_node = default_conversion (atexit_fndecl);
8491
8492   return atexit_node;
8493 }
8494
8495 /* Returns the __dso_handle VAR_DECL.  */
8496
8497 static tree
8498 get_dso_handle_node ()
8499 {
8500   if (dso_handle_node)
8501     return dso_handle_node;
8502
8503   /* Declare the variable.  */
8504   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8505                                         ptr_type_node);
8506
8507   return dso_handle_node;
8508 }
8509
8510 /* Begin a new function with internal linkage whose job will be simply
8511    to destroy some particular variable.  */
8512
8513 static tree
8514 start_cleanup_fn ()
8515 {
8516   static int counter = 0;
8517   int old_interface_only = interface_only;
8518   int old_interface_unknown = interface_unknown;
8519   char name[32];
8520   tree parmtypes;
8521   tree fntype;
8522   tree fndecl;
8523
8524   push_to_top_level ();
8525
8526   /* No need to mangle this.  */
8527   push_lang_context (lang_name_c);
8528
8529   interface_only = 0;
8530   interface_unknown = 1;
8531
8532   /* Build the parameter-types.  */
8533   parmtypes = void_list_node;
8534   /* Functions passed to __cxa_atexit take an additional parameter.
8535      We'll just ignore it.  After we implement the new calling
8536      convention for destructors, we can eliminate the use of
8537      additional cleanup functions entirely in the -fnew-abi case.  */
8538   if (flag_use_cxa_atexit)
8539     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8540   /* Build the function type itself.  */
8541   fntype = build_function_type (void_type_node, parmtypes);
8542   /* Build the name of the function.  */
8543   sprintf (name, "__tcf_%d", counter++);
8544   /* Build the function declaration.  */
8545   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8546   /* It's a function with internal linkage, generated by the
8547      compiler.  */
8548   TREE_PUBLIC (fndecl) = 0;
8549   DECL_ARTIFICIAL (fndecl) = 1;
8550   /* Make the function `inline' so that it is only emitted if it is
8551      actually needed.  It is unlikely that it will be inlined, since
8552      it is only called via a function pointer, but we avoid unnecessary
8553      emissions this way.  */
8554   DECL_INLINE (fndecl) = 1;
8555   /* Build the parameter.  */
8556   if (flag_use_cxa_atexit)
8557     {
8558       tree parmdecl;
8559
8560       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8561       DECL_CONTEXT (parmdecl) = fndecl;
8562       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8563       TREE_USED (parmdecl) = 1;
8564       DECL_ARGUMENTS (fndecl) = parmdecl;
8565     }
8566
8567   pushdecl (fndecl);
8568   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8569
8570   interface_unknown = old_interface_unknown;
8571   interface_only = old_interface_only;
8572
8573   pop_lang_context ();
8574
8575   return current_function_decl;
8576 }
8577
8578 /* Finish the cleanup function begun by start_cleanup_fn.  */
8579
8580 static void
8581 end_cleanup_fn ()
8582 {
8583   expand_body (finish_function (0));
8584
8585   pop_from_top_level ();
8586 }
8587
8588 /* Generate code to handle the destruction of DECL, an object with
8589    static storage duration.  */
8590
8591 void
8592 register_dtor_fn (decl)
8593      tree decl;
8594 {
8595   tree cleanup;
8596   tree compound_stmt;
8597   tree args;
8598   tree fcall;
8599
8600   int saved_flag_access_control;
8601
8602   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8603     return;
8604
8605   /* Call build_cleanup before we enter the anonymous function so that
8606      any access checks will be done relative to the current scope,
8607      rather than the scope of the anonymous function.  */
8608   build_cleanup (decl);
8609
8610   /* Now start the function.  */
8611   cleanup = start_cleanup_fn ();
8612
8613   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8614      to the original function, rather than the anonymous one.  That
8615      will make the back-end think that nested functions are in use,
8616      which causes confusion.  */
8617   saved_flag_access_control = flag_access_control;
8618   flag_access_control = 0;
8619   fcall = build_cleanup (decl);
8620   flag_access_control = saved_flag_access_control;
8621
8622   /* Create the body of the anonymous function.  */
8623   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8624   finish_expr_stmt (fcall);
8625   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8626   end_cleanup_fn ();
8627
8628   /* Call atexit with the cleanup function.  */
8629   mark_addressable (cleanup);
8630   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8631   if (flag_use_cxa_atexit)
8632     {
8633       args = tree_cons (NULL_TREE,
8634                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8635                         NULL_TREE);
8636       args = tree_cons (NULL_TREE, null_pointer_node, args);
8637       args = tree_cons (NULL_TREE, cleanup, args);
8638     }
8639   else
8640     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8641   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8642 }
8643
8644 void
8645 expand_static_init (decl, init)
8646      tree decl;
8647      tree init;
8648 {
8649   tree oldstatic = value_member (decl, static_aggregates);
8650
8651   if (oldstatic)
8652     {
8653       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8654         error ("multiple initializations given for `%D'", decl);
8655     }
8656   else if (! toplevel_bindings_p ())
8657     {
8658       /* Emit code to perform this initialization but once.  */
8659       tree if_stmt;
8660       tree then_clause;
8661       tree assignment;
8662       tree guard;
8663       tree guard_init;
8664
8665       /* Emit code to perform this initialization but once.  This code
8666          looks like:
8667
8668            static int guard = 0;
8669            if (!guard) {
8670              // Do initialization.
8671              guard = 1;
8672              // Register variable for destruction at end of program.
8673            }
8674
8675          Note that the `temp' variable is only set to 1 *after* the
8676          initialization is complete.  This ensures that an exception,
8677          thrown during the construction, will cause the variable to
8678          reinitialized when we pass through this code again, as per:
8679
8680            [stmt.dcl]
8681
8682            If the initialization exits by throwing an exception, the
8683            initialization is not complete, so it will be tried again
8684            the next time control enters the declaration.
8685
8686          In theory, this process should be thread-safe, too; multiple
8687          threads should not be able to initialize the variable more
8688          than once.  We don't yet attempt to ensure thread-safety.  */
8689
8690       /* Create the guard variable.  */
8691       guard = get_guard (decl);
8692
8693       /* Begin the conditional initialization.  */
8694       if_stmt = begin_if_stmt ();
8695       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8696       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8697
8698       /* Do the initialization itself.  */
8699       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8700           || (init && TREE_CODE (init) == TREE_LIST))
8701         assignment = build_aggr_init (decl, init, 0);
8702       else if (init)
8703         /* The initialization we're doing here is just a bitwise
8704            copy.  */
8705         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8706       else
8707         assignment = NULL_TREE;
8708
8709       /* Once the assignment is complete, set TEMP to 1.  Since the
8710          construction of the static object is complete at this point,
8711          we want to make sure TEMP is set to 1 even if a temporary
8712          constructed during the initialization throws an exception
8713          when it is destroyed.  So, we combine the initialization and
8714          the assignment to TEMP into a single expression, ensuring
8715          that when we call finish_expr_stmt the cleanups will not be
8716          run until after TEMP is set to 1.  */
8717       guard_init = set_guard (guard);
8718       if (assignment)
8719         {
8720           assignment = tree_cons (NULL_TREE, assignment,
8721                                   build_tree_list (NULL_TREE,
8722                                                    guard_init));
8723           assignment = build_compound_expr (assignment);
8724         }
8725       else
8726         assignment = guard_init;
8727       finish_expr_stmt (assignment);
8728
8729       /* Use atexit to register a function for destroying this static
8730          variable.  */
8731       register_dtor_fn (decl);
8732
8733       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8734       finish_then_clause (if_stmt);
8735       finish_if_stmt ();
8736     }
8737   else
8738     static_aggregates = tree_cons (init, decl, static_aggregates);
8739 }
8740
8741 /* Finish the declaration of a catch-parameter.  */
8742
8743 tree
8744 start_handler_parms (declspecs, declarator)
8745      tree declspecs;
8746      tree declarator;
8747 {
8748   tree decl;
8749   if (declspecs)
8750     {
8751       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8752                              1, NULL);
8753       if (decl == NULL_TREE)
8754         error ("invalid catch parameter");
8755     }
8756   else
8757     decl = NULL_TREE;
8758
8759   return decl;
8760 }
8761
8762 \f
8763 /* Make TYPE a complete type based on INITIAL_VALUE.
8764    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8765    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8766
8767 int
8768 complete_array_type (type, initial_value, do_default)
8769      tree type, initial_value;
8770      int do_default;
8771 {
8772   register tree maxindex = NULL_TREE;
8773   int value = 0;
8774
8775   if (initial_value)
8776     {
8777       /* An array of character type can be initialized from a
8778          brace-enclosed string constant.  */
8779       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8780           && TREE_CODE (initial_value) == CONSTRUCTOR
8781           && CONSTRUCTOR_ELTS (initial_value)
8782           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8783               == STRING_CST)
8784           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8785         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8786
8787       /* Note MAXINDEX is really the maximum index, one less than the
8788          size.  */
8789       if (TREE_CODE (initial_value) == STRING_CST)
8790         {
8791           int eltsize
8792             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8793           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8794                                    / eltsize) - 1, 0);
8795         }
8796       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8797         {
8798           tree elts = CONSTRUCTOR_ELTS (initial_value);
8799
8800           maxindex = ssize_int (-1);
8801           for (; elts; elts = TREE_CHAIN (elts))
8802             {
8803               if (TREE_PURPOSE (elts))
8804                 maxindex = TREE_PURPOSE (elts);
8805               else
8806                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8807             }
8808           maxindex = copy_node (maxindex);
8809         }
8810       else
8811         {
8812           /* Make an error message unless that happened already.  */
8813           if (initial_value != error_mark_node)
8814             value = 1;
8815           else
8816             initial_value = NULL_TREE;
8817
8818           /* Prevent further error messages.  */
8819           maxindex = build_int_2 (0, 0);
8820         }
8821     }
8822
8823   if (!maxindex)
8824     {
8825       if (do_default)
8826         maxindex = build_int_2 (0, 0);
8827       value = 2;
8828     }
8829
8830   if (maxindex)
8831     {
8832       tree itype;
8833       tree domain;
8834
8835       domain = build_index_type (maxindex);
8836       TYPE_DOMAIN (type) = domain;
8837
8838       if (! TREE_TYPE (maxindex))
8839         TREE_TYPE (maxindex) = domain;
8840       if (initial_value)
8841         itype = TREE_TYPE (initial_value);
8842       else
8843         itype = NULL;
8844       if (itype && !TYPE_DOMAIN (itype))
8845         TYPE_DOMAIN (itype) = domain;
8846       /* The type of the main variant should never be used for arrays
8847          of different sizes.  It should only ever be completed with the
8848          size of the array.  */
8849       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8850         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8851     }
8852
8853   /* Lay out the type now that we can get the real answer.  */
8854
8855   layout_type (type);
8856
8857   return value;
8858 }
8859 \f
8860 /* Return zero if something is declared to be a member of type
8861    CTYPE when in the context of CUR_TYPE.  STRING is the error
8862    message to print in that case.  Otherwise, quietly return 1.  */
8863
8864 static int
8865 member_function_or_else (ctype, cur_type, flags)
8866      tree ctype, cur_type;
8867      enum overload_flags flags;
8868 {
8869   if (ctype && ctype != cur_type)
8870     {
8871       if (flags == DTOR_FLAG)
8872         error ("destructor for alien class `%T' cannot be a member",
8873                   ctype);
8874       else
8875         error ("constructor for alien class `%T' cannot be a member",
8876                   ctype);
8877       return 0;
8878     }
8879   return 1;
8880 }
8881 \f
8882 /* Subroutine of `grokdeclarator'.  */
8883
8884 /* Generate errors possibly applicable for a given set of specifiers.
8885    This is for ARM $7.1.2.  */
8886
8887 static void
8888 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8889      tree object;
8890      const char *type;
8891      int virtualp, quals, friendp, raises, inlinep;
8892 {
8893   if (virtualp)
8894     error ("`%D' declared as a `virtual' %s", object, type);
8895   if (inlinep)
8896     error ("`%D' declared as an `inline' %s", object, type);
8897   if (quals)
8898     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8899               object, type);
8900   if (friendp)
8901     cp_error_at ("`%D' declared as a friend", object);
8902   if (raises
8903       && (TREE_CODE (object) == TYPE_DECL
8904           || (!TYPE_PTRFN_P (TREE_TYPE (object))
8905               && !TYPE_REFFN_P (TREE_TYPE (object))
8906               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8907     cp_error_at ("`%D' declared with an exception specification", object);
8908 }
8909
8910 /* CTYPE is class type, or null if non-class.
8911    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8912    or METHOD_TYPE.
8913    DECLARATOR is the function's name.
8914    VIRTUALP is truthvalue of whether the function is virtual or not.
8915    FLAGS are to be passed through to `grokclassfn'.
8916    QUALS are qualifiers indicating whether the function is `const'
8917    or `volatile'.
8918    RAISES is a list of exceptions that this function can raise.
8919    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8920    not look, and -1 if we should not call `grokclassfn' at all.
8921
8922    Returns `NULL_TREE' if something goes wrong, after issuing
8923    applicable error messages.  */
8924
8925 static tree
8926 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8927             raises, check, friendp, publicp, inlinep, funcdef_flag,
8928             template_count, in_namespace)
8929      tree ctype, type;
8930      tree declarator;
8931      tree orig_declarator;
8932      int virtualp;
8933      enum overload_flags flags;
8934      tree quals, raises;
8935      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8936      tree in_namespace;
8937 {
8938   tree decl;
8939   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8940   int has_default_arg = 0;
8941   tree t;
8942
8943   if (raises)
8944     type = build_exception_variant (type, raises);
8945
8946   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8947   /* Propagate volatile out from type to decl. */
8948   if (TYPE_VOLATILE (type))
8949     TREE_THIS_VOLATILE (decl) = 1;
8950
8951   /* If this decl has namespace scope, set that up.  */
8952   if (in_namespace)
8953     set_decl_namespace (decl, in_namespace, friendp);
8954   else if (!ctype)
8955     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8956
8957   /* `main' and builtins have implicit 'C' linkage.  */
8958   if ((MAIN_NAME_P (declarator)
8959        || (IDENTIFIER_LENGTH (declarator) > 10
8960            && IDENTIFIER_POINTER (declarator)[0] == '_'
8961            && IDENTIFIER_POINTER (declarator)[1] == '_'
8962            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8963       && current_lang_name == lang_name_cplusplus
8964       && ctype == NULL_TREE
8965       /* NULL_TREE means global namespace.  */
8966       && DECL_CONTEXT (decl) == NULL_TREE)
8967     SET_DECL_LANGUAGE (decl, lang_c);
8968
8969   /* Should probably propagate const out from type to decl I bet (mrs).  */
8970   if (staticp)
8971     {
8972       DECL_STATIC_FUNCTION_P (decl) = 1;
8973       DECL_CONTEXT (decl) = ctype;
8974     }
8975
8976   if (ctype)
8977     DECL_CONTEXT (decl) = ctype;
8978
8979   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8980     {
8981       if (processing_template_decl)
8982         error ("cannot declare `::main' to be a template");
8983       if (inlinep)
8984         error ("cannot declare `::main' to be inline");
8985       if (!publicp)
8986         error ("cannot declare `::main' to be static");
8987       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8988                         integer_type_node))
8989         error ("`main' must return `int'");
8990       inlinep = 0;
8991       publicp = 1;
8992     }
8993
8994   /* Members of anonymous types and local classes have no linkage; make
8995      them internal.  */
8996   /* FIXME what if it gets a name from typedef?  */
8997   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8998                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8999     publicp = 0;
9000
9001   if (publicp)
9002     {
9003       /* [basic.link]: A name with no linkage (notably, the name of a class
9004          or enumeration declared in a local scope) shall not be used to
9005          declare an entity with linkage.
9006
9007          Only check this for public decls for now.  */
9008       t = no_linkage_check (TREE_TYPE (decl));
9009       if (t)
9010         {
9011           if (TYPE_ANONYMOUS_P (t))
9012             {
9013               if (DECL_EXTERN_C_P (decl))
9014                 /* Allow this; it's pretty common in C.  */;
9015               else
9016                 {
9017                   pedwarn ("non-local function `%#D' uses anonymous type",
9018                               decl);
9019                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
9020                     cp_pedwarn_at ("\
9021 `%#D' does not refer to the unqualified type, so it is not used for linkage",
9022                                 TYPE_NAME (t));
9023                 }
9024             }
9025           else
9026             pedwarn ("non-local function `%#D' uses local type `%T'",
9027                         decl, t);
9028         }
9029     }
9030
9031   TREE_PUBLIC (decl) = publicp;
9032   if (! publicp)
9033     {
9034       DECL_INTERFACE_KNOWN (decl) = 1;
9035       DECL_NOT_REALLY_EXTERN (decl) = 1;
9036     }
9037
9038   /* If the declaration was declared inline, mark it as such.  */
9039   if (inlinep)
9040     DECL_DECLARED_INLINE_P (decl) = 1;
9041   /* We inline functions that are explicitly declared inline, or, when
9042      the user explicitly asks us to, all functions.  */
9043   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
9044     DECL_INLINE (decl) = 1;
9045
9046   DECL_EXTERNAL (decl) = 1;
9047   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9048     {
9049       error ("%smember function `%D' cannot have `%T' method qualifier",
9050                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9051       quals = NULL_TREE;
9052     }
9053
9054   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9055     grok_op_properties (decl, friendp);
9056
9057   if (ctype && decl_function_context (decl))
9058     DECL_NO_STATIC_CHAIN (decl) = 1;
9059
9060   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9061     if (TREE_PURPOSE (t)
9062         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9063       {
9064         has_default_arg = 1;
9065         break;
9066       }
9067
9068   if (friendp
9069       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9070     {
9071       if (funcdef_flag)
9072         error
9073           ("defining explicit specialization `%D' in friend declaration",
9074            orig_declarator);
9075       else
9076         {
9077           tree fns = TREE_OPERAND (orig_declarator, 0);
9078           tree args = TREE_OPERAND (orig_declarator, 1);
9079
9080           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9081             {
9082               /* Something like `template <class T> friend void f<T>()'.  */
9083               error ("invalid use of template-id `%D' in declaration of primary template",
9084                         orig_declarator);
9085               return NULL_TREE;
9086             }
9087
9088
9089           /* A friend declaration of the form friend void f<>().  Record
9090              the information in the TEMPLATE_ID_EXPR.  */
9091           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9092
9093           if (TREE_CODE (fns) == COMPONENT_REF)
9094             {
9095               /* Due to bison parser ickiness, we will have already looked
9096                  up an operator_name or PFUNCNAME within the current class
9097                  (see template_id in parse.y). If the current class contains
9098                  such a name, we'll get a COMPONENT_REF here. Undo that. */
9099
9100               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9101                                   == current_class_type, 20001120);
9102               fns = TREE_OPERAND (fns, 1);
9103             }
9104           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9105                               || TREE_CODE (fns) == LOOKUP_EXPR
9106                               || TREE_CODE (fns) == OVERLOAD, 20001120);
9107           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9108
9109           if (has_default_arg)
9110             {
9111               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9112                         decl);
9113               return NULL_TREE;
9114             }
9115
9116           if (inlinep)
9117             {
9118               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9119                         decl);
9120               return NULL_TREE;
9121             }
9122         }
9123     }
9124
9125   if (has_default_arg)
9126     add_defarg_fn (decl);
9127
9128   if (funcdef_flag)
9129     /* Make the init_value nonzero so pushdecl knows this is not
9130        tentative.  error_mark_node is replaced later with the BLOCK.  */
9131     DECL_INITIAL (decl) = error_mark_node;
9132
9133   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9134     TREE_NOTHROW (decl) = 1;
9135
9136   /* Caller will do the rest of this.  */
9137   if (check < 0)
9138     return decl;
9139
9140   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
9141     DECL_CONSTRUCTOR_P (decl) = 1;
9142
9143   /* Function gets the ugly name, field gets the nice one.  This call
9144      may change the type of the function (because of default
9145      parameters)!  */
9146   if (ctype != NULL_TREE)
9147     grokclassfn (ctype, decl, flags, quals);
9148
9149   decl = check_explicit_specialization (orig_declarator, decl,
9150                                         template_count,
9151                                         2 * (funcdef_flag != 0) +
9152                                         4 * (friendp != 0));
9153   if (decl == error_mark_node)
9154     return NULL_TREE;
9155
9156   if (ctype != NULL_TREE
9157       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9158       && check)
9159     {
9160       tree old_decl;
9161
9162       old_decl = check_classfn (ctype, decl);
9163
9164       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9165         /* Because grokfndecl is always supposed to return a
9166            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9167            here.  We depend on our callers to figure out that its
9168            really a template that's being returned.  */
9169         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9170
9171       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9172           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9173         {
9174           /* Remove the `this' parm added by grokclassfn.
9175              XXX Isn't this done in start_function, too?  */
9176           revert_static_member_fn (decl);
9177           last_function_parms = TREE_CHAIN (last_function_parms);
9178         }
9179       if (old_decl && DECL_ARTIFICIAL (old_decl))
9180         error ("definition of implicitly-declared `%D'", old_decl);
9181
9182       if (old_decl)
9183         {
9184           /* Since we've smashed OLD_DECL to its
9185              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9186           if (TREE_CODE (decl) == TEMPLATE_DECL)
9187             decl = DECL_TEMPLATE_RESULT (decl);
9188
9189           /* Attempt to merge the declarations.  This can fail, in
9190              the case of some illegal specialization declarations.  */
9191           if (!duplicate_decls (decl, old_decl))
9192             error ("no `%#D' member function declared in class `%T'",
9193                       decl, ctype);
9194           return old_decl;
9195         }
9196     }
9197
9198   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9199     return NULL_TREE;
9200
9201   if (ctype == NULL_TREE || check)
9202     return decl;
9203
9204   if (virtualp)
9205     DECL_VIRTUAL_P (decl) = 1;
9206
9207   return decl;
9208 }
9209
9210 static tree
9211 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9212      tree type;
9213      tree declarator;
9214      RID_BIT_TYPE *specbits_in;
9215      int initialized;
9216      int constp;
9217      tree in_namespace;
9218 {
9219   tree decl;
9220   RID_BIT_TYPE specbits;
9221
9222   specbits = *specbits_in;
9223
9224   if (TREE_CODE (type) == OFFSET_TYPE)
9225     {
9226       /* If you declare a static member so that it
9227          can be initialized, the code will reach here.  */
9228       tree basetype = TYPE_OFFSET_BASETYPE (type);
9229       type = TREE_TYPE (type);
9230       decl = build_lang_decl (VAR_DECL, declarator, type);
9231       DECL_CONTEXT (decl) = basetype;
9232     }
9233   else
9234     {
9235       tree context;
9236
9237       if (in_namespace)
9238         context = in_namespace;
9239       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9240         context = current_namespace;
9241       else
9242         context = NULL_TREE;
9243
9244       /* For namespace-scope variables, declared in a template, we
9245          need the full lang_decl.  The same is true for
9246          namespace-scope variables that do not have C++ language
9247          linkage.  */
9248       if (context
9249           && (processing_template_decl
9250               || current_lang_name != lang_name_cplusplus))
9251         decl = build_lang_decl (VAR_DECL, declarator, type);
9252       else
9253         decl = build_decl (VAR_DECL, declarator, type);
9254
9255       if (context)
9256         set_decl_namespace (decl, context, 0);
9257
9258       context = DECL_CONTEXT (decl);
9259       if (declarator && context && current_lang_name != lang_name_c)
9260         /* We can't mangle lazily here because we don't have any
9261            way to recover whether or not a variable was `extern
9262            "C"' later.  */
9263         mangle_decl (decl);
9264     }
9265
9266   if (in_namespace)
9267     set_decl_namespace (decl, in_namespace, 0);
9268
9269   if (RIDBIT_SETP (RID_EXTERN, specbits))
9270     {
9271       DECL_THIS_EXTERN (decl) = 1;
9272       DECL_EXTERNAL (decl) = !initialized;
9273     }
9274
9275   /* In class context, static means one per class,
9276      public access, and static storage.  */
9277   if (DECL_CLASS_SCOPE_P (decl))
9278     {
9279       TREE_PUBLIC (decl) = 1;
9280       TREE_STATIC (decl) = 1;
9281       DECL_EXTERNAL (decl) = 0;
9282     }
9283   /* At top level, either `static' or no s.c. makes a definition
9284      (perhaps tentative), and absence of `static' makes it public.  */
9285   else if (toplevel_bindings_p ())
9286     {
9287       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9288                             && (DECL_THIS_EXTERN (decl) || ! constp));
9289       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9290     }
9291   /* Not at top level, only `static' makes a static definition.  */
9292   else
9293     {
9294       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9295       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9296     }
9297
9298   if (TREE_PUBLIC (decl))
9299     {
9300       /* [basic.link]: A name with no linkage (notably, the name of a class
9301          or enumeration declared in a local scope) shall not be used to
9302          declare an entity with linkage.
9303
9304          Only check this for public decls for now.  */
9305       tree t = no_linkage_check (TREE_TYPE (decl));
9306       if (t)
9307         {
9308           if (TYPE_ANONYMOUS_P (t))
9309             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9310           else
9311             pedwarn ("non-local variable `%#D' uses local type `%T'",
9312                         decl, t);
9313         }
9314     }
9315
9316   return decl;
9317 }
9318
9319 /* Create and return a canonical pointer to member function type, for
9320    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9321
9322 tree
9323 build_ptrmemfunc_type (type)
9324      tree type;
9325 {
9326   tree fields[4];
9327   tree t;
9328   tree unqualified_variant = NULL_TREE;
9329
9330   if (type == error_mark_node)
9331     return type;
9332
9333   /* If a canonical type already exists for this type, use it.  We use
9334      this method instead of type_hash_canon, because it only does a
9335      simple equality check on the list of field members.  */
9336
9337   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9338     return t;
9339
9340   /* Make sure that we always have the unqualified pointer-to-member
9341      type first.  */
9342   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9343     unqualified_variant
9344       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9345
9346   t = make_aggr_type (RECORD_TYPE);
9347   /* Let the front-end know this is a pointer to member function...  */
9348   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9349   /* ... and not really an aggregate.  */
9350   SET_IS_AGGR_TYPE (t, 0);
9351
9352   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9353   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9354                           delta_type_node);
9355   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9356
9357   /* Zap out the name so that the back-end will give us the debugging
9358      information for this anonymous RECORD_TYPE.  */
9359   TYPE_NAME (t) = NULL_TREE;
9360
9361   /* If this is not the unqualified form of this pointer-to-member
9362      type, set the TYPE_MAIN_VARIANT for this type to be the
9363      unqualified type.  Since they are actually RECORD_TYPEs that are
9364      not variants of each other, we must do this manually.  */
9365   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9366     {
9367       t = build_qualified_type (t, cp_type_quals (type));
9368       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9369       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9370       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9371     }
9372
9373   /* Cache this pointer-to-member type so that we can find it again
9374      later.  */
9375   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9376
9377   /* Seems to be wanted.  */
9378   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9379
9380   return t;
9381 }
9382
9383 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9384    Check to see that the definition is valid.  Issue appropriate error
9385    messages.  Return 1 if the definition is particularly bad, or 0
9386    otherwise.  */
9387
9388 int
9389 check_static_variable_definition (decl, type)
9390      tree decl;
9391      tree type;
9392 {
9393   /* Motion 10 at San Diego: If a static const integral data member is
9394      initialized with an integral constant expression, the initializer
9395      may appear either in the declaration (within the class), or in
9396      the definition, but not both.  If it appears in the class, the
9397      member is a member constant.  The file-scope definition is always
9398      required.  */
9399   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9400     {
9401       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9402                 type);
9403       /* If we just return the declaration, crashes will sometimes
9404          occur.  We therefore return void_type_node, as if this was a
9405          friend declaration, to cause callers to completely ignore
9406          this declaration.  */
9407       return 1;
9408     }
9409   else if (!CP_TYPE_CONST_P (type))
9410     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9411               decl);
9412   else if (pedantic && !INTEGRAL_TYPE_P (type))
9413     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9414
9415   return 0;
9416 }
9417
9418 /* Given the SIZE (i.e., number of elements) in an array, compute an
9419    appropriate index type for the array.  If non-NULL, NAME is the
9420    name of the thing being declared.  */
9421
9422 tree
9423 compute_array_index_type (name, size)
9424      tree name;
9425      tree size;
9426 {
9427   tree itype;
9428
9429   /* If this involves a template parameter, it will be a constant at
9430      instantiation time, but we don't know what the value is yet.
9431      Even if no template parameters are involved, we may an expression
9432      that is not a constant; we don't even simplify `1 + 2' when
9433      processing a template.  */
9434   if (processing_template_decl)
9435     {
9436       /* Resolve a qualified reference to an enumerator or static
9437          const data member of ours.  */
9438       if (TREE_CODE (size) == SCOPE_REF
9439           && TREE_OPERAND (size, 0) == current_class_type)
9440         {
9441           tree t = lookup_field (current_class_type,
9442                                  TREE_OPERAND (size, 1), 0, 0);
9443           if (t)
9444             size = t;
9445         }
9446
9447       return build_index_type (build_min (MINUS_EXPR, sizetype,
9448                                           size, integer_one_node));
9449     }
9450
9451   /* The size might be the result of a cast. */
9452   STRIP_TYPE_NOPS (size);
9453
9454   /* It might be a const variable or enumeration constant.  */
9455   size = decl_constant_value (size);
9456
9457   /* The array bound must be an integer type.  */
9458   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9459       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9460       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9461     {
9462       if (name)
9463         error ("size of array `%D' has non-integer type", name);
9464       else
9465         error ("size of array has non-integer type");
9466       size = integer_one_node;
9467     }
9468
9469   /* Normally, the array-bound will be a constant.  */
9470   if (TREE_CODE (size) == INTEGER_CST)
9471     {
9472       /* Check to see if the array bound overflowed.  Make that an
9473          error, no matter how generous we're being.  */
9474       int old_flag_pedantic_errors = flag_pedantic_errors;
9475       int old_pedantic = pedantic;
9476       pedantic = flag_pedantic_errors = 1;
9477       constant_expression_warning (size);
9478       pedantic = old_pedantic;
9479       flag_pedantic_errors = old_flag_pedantic_errors;
9480
9481       /* An array must have a positive number of elements.  */
9482       if (INT_CST_LT (size, integer_zero_node))
9483         {
9484           if (name)
9485             error ("size of array `%D' is negative", name);
9486           else
9487             error ("size of array is negative");
9488           size = integer_one_node;
9489         }
9490       /* Except that an extension we allow zero-sized arrays.  We
9491          always allow them in system headers because glibc uses
9492          them.  */
9493       else if (integer_zerop (size) && pedantic && !in_system_header)
9494         {
9495           if (name)
9496             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9497           else
9498             pedwarn ("ISO C++ forbids zero-size array");
9499         }
9500     }
9501   else if (TREE_CONSTANT (size))
9502     {
9503       /* `(int) &fn' is not a valid array bound.  */
9504       if (name)
9505         error ("size of array `%D' is not an integral constant-expression",
9506                   name);
9507       else
9508         error ("size of array is not an integral constant-expression");
9509     }
9510
9511   /* Compute the index of the largest element in the array.  It is
9512      one less than the number of elements in the array.  */
9513   itype
9514     = fold (cp_build_binary_op (MINUS_EXPR,
9515                                 cp_convert (ssizetype, size),
9516                                 cp_convert (ssizetype,
9517                                             integer_one_node)));
9518
9519   /* Check for variable-sized arrays.  We allow such things as an
9520      extension, even though they are not allowed in ANSI/ISO C++.  */
9521   if (!TREE_CONSTANT (itype))
9522     {
9523       if (pedantic)
9524         {
9525           if (name)
9526             pedwarn ("ISO C++ forbids variable-size array `%D'",
9527                         name);
9528           else
9529             pedwarn ("ISO C++ forbids variable-size array");
9530         }
9531
9532       /* Create a variable-sized array index type.  */
9533       itype = variable_size (itype);
9534     }
9535   /* Make sure that there was no overflow when creating to a signed
9536      index type.  (For example, on a 32-bit machine, an array with
9537      size 2^32 - 1 is too big.)  */
9538   else if (TREE_OVERFLOW (itype))
9539     {
9540       error ("overflow in array dimension");
9541       TREE_OVERFLOW (itype) = 0;
9542     }
9543
9544   /* Create and return the appropriate index type.  */
9545   return build_index_type (itype);
9546 }
9547
9548 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9549    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9550    with this type.  */
9551
9552 static tree
9553 create_array_type_for_decl (name, type, size)
9554      tree name;
9555      tree type;
9556      tree size;
9557 {
9558   tree itype = NULL_TREE;
9559   const char* error_msg;
9560
9561   /* If things have already gone awry, bail now.  */
9562   if (type == error_mark_node || size == error_mark_node)
9563     return error_mark_node;
9564
9565   /* Assume that everything will go OK.  */
9566   error_msg = NULL;
9567
9568   /* There are some types which cannot be array elements.  */
9569   switch (TREE_CODE (type))
9570     {
9571     case VOID_TYPE:
9572       error_msg = "array of void";
9573       break;
9574
9575     case FUNCTION_TYPE:
9576       error_msg = "array of functions";
9577       break;
9578
9579     case REFERENCE_TYPE:
9580       error_msg = "array of references";
9581       break;
9582
9583     case OFFSET_TYPE:
9584       error_msg = "array of data members";
9585       break;
9586
9587     case METHOD_TYPE:
9588       error_msg = "array of function members";
9589       break;
9590
9591     default:
9592       break;
9593     }
9594
9595   /* If something went wrong, issue an error-message and return.  */
9596   if (error_msg)
9597     {
9598       if (name)
9599         error ("declaration of `%D' as %s", name, error_msg);
9600       else
9601         error ("creating %s", error_msg);
9602
9603       return error_mark_node;
9604     }
9605
9606   /* [dcl.array]
9607
9608      The constant expressions that specify the bounds of the arrays
9609      can be omitted only for the first member of the sequence.  */
9610   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9611     {
9612       if (name)
9613         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9614                   name);
9615       else
9616         error ("multidimensional array must have bounds for all dimensions except the first");
9617
9618       return error_mark_node;
9619     }
9620
9621   /* Figure out the index type for the array.  */
9622   if (size)
9623     itype = compute_array_index_type (name, size);
9624
9625   return build_cplus_array_type (type, itype);
9626 }
9627
9628 /* Check that it's OK to declare a function with the indicated TYPE.
9629    SFK indicates the kind of special function (if any) that this
9630    function is.  OPTYPE is the type given in a conversion operator
9631    declaration.  Returns the actual return type of the function; that
9632    may be different than TYPE if an error occurs, or for certain
9633    special functions.  */
9634
9635 static tree
9636 check_special_function_return_type (sfk, type, optype)
9637      special_function_kind sfk;
9638      tree type;
9639      tree optype;
9640 {
9641   switch (sfk)
9642     {
9643     case sfk_constructor:
9644       if (type)
9645         error ("return type specification for constructor invalid");
9646
9647       type = void_type_node;
9648       break;
9649
9650     case sfk_destructor:
9651       if (type)
9652         error ("return type specification for destructor invalid");
9653       type = void_type_node;
9654       break;
9655
9656     case sfk_conversion:
9657       if (type && !same_type_p (type, optype))
9658         error ("operator `%T' declared to return `%T'", optype, type);
9659       else if (type)
9660         pedwarn ("return type specified for `operator %T'",  optype);
9661       type = optype;
9662       break;
9663
9664     default:
9665       abort ();
9666       break;
9667     }
9668
9669   return type;
9670 }
9671
9672 /* Given declspecs and a declarator,
9673    determine the name and type of the object declared
9674    and construct a ..._DECL node for it.
9675    (In one case we can return a ..._TYPE node instead.
9676     For invalid input we sometimes return 0.)
9677
9678    DECLSPECS is a chain of tree_list nodes whose value fields
9679     are the storage classes and type specifiers.
9680
9681    DECL_CONTEXT says which syntactic context this declaration is in:
9682      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9683      FUNCDEF for a function definition.  Like NORMAL but a few different
9684       error messages in each case.  Return value may be zero meaning
9685       this definition is too screwy to try to parse.
9686      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9687       handle member functions (which have FIELD context).
9688       Return value may be zero meaning this definition is too screwy to
9689       try to parse.
9690      PARM for a parameter declaration (either within a function prototype
9691       or before a function body).  Make a PARM_DECL, or return void_type_node.
9692      CATCHPARM for a parameter declaration before a catch clause.
9693      TYPENAME if for a typename (in a cast or sizeof).
9694       Don't make a DECL node; just return the ..._TYPE node.
9695      FIELD for a struct or union field; make a FIELD_DECL.
9696      BITFIELD for a field with specified width.
9697    INITIALIZED is 1 if the decl has an initializer.
9698
9699    ATTRLIST is a pointer to the list of attributes, which may be NULL
9700    if there are none; *ATTRLIST may be modified if attributes from inside
9701    the declarator should be applied to the declaration.
9702
9703    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9704    It may also be so in the PARM case, for a prototype where the
9705    argument type is specified but not the name.
9706
9707    This function is where the complicated C meanings of `static'
9708    and `extern' are interpreted.
9709
9710    For C++, if there is any monkey business to do, the function which
9711    calls this one must do it, i.e., prepending instance variables,
9712    renaming overloaded function names, etc.
9713
9714    Note that for this C++, it is an error to define a method within a class
9715    which does not belong to that class.
9716
9717    Except in the case where SCOPE_REFs are implicitly known (such as
9718    methods within a class being redundantly qualified),
9719    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9720    (class_name::decl_name).  The caller must also deal with this.
9721
9722    If a constructor or destructor is seen, and the context is FIELD,
9723    then the type gains the attribute TREE_HAS_x.  If such a declaration
9724    is erroneous, NULL_TREE is returned.
9725
9726    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9727    function, these are the qualifiers to give to the `this' pointer. We
9728    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9729
9730    May return void_type_node if the declarator turned out to be a friend.
9731    See grokfield for details.  */
9732
9733 tree
9734 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9735      tree declspecs;
9736      tree declarator;
9737      enum decl_context decl_context;
9738      int initialized;
9739      tree *attrlist;
9740 {
9741   RID_BIT_TYPE specbits;
9742   int nclasses = 0;
9743   tree spec;
9744   tree type = NULL_TREE;
9745   int longlong = 0;
9746   int type_quals;
9747   int virtualp, explicitp, friendp, inlinep, staticp;
9748   int explicit_int = 0;
9749   int explicit_char = 0;
9750   int defaulted_int = 0;
9751   int extern_langp = 0;
9752   tree dependant_name = NULL_TREE;
9753
9754   tree typedef_decl = NULL_TREE;
9755   const char *name;
9756   tree typedef_type = NULL_TREE;
9757   int funcdef_flag = 0;
9758   enum tree_code innermost_code = ERROR_MARK;
9759   int bitfield = 0;
9760 #if 0
9761   /* See the code below that used this.  */
9762   tree decl_attr = NULL_TREE;
9763 #endif
9764   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9765      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9766   tree init = NULL_TREE;
9767
9768   /* Keep track of what sort of function is being processed
9769      so that we can warn about default return values, or explicit
9770      return values which do not match prescribed defaults.  */
9771   special_function_kind sfk = sfk_none;
9772
9773   tree dname = NULL_TREE;
9774   tree ctype = current_class_type;
9775   tree ctor_return_type = NULL_TREE;
9776   enum overload_flags flags = NO_SPECIAL;
9777   tree quals = NULL_TREE;
9778   tree raises = NULL_TREE;
9779   int template_count = 0;
9780   tree in_namespace = NULL_TREE;
9781   tree returned_attrs = NULL_TREE;
9782
9783   RIDBIT_RESET_ALL (specbits);
9784   if (decl_context == FUNCDEF)
9785     funcdef_flag = 1, decl_context = NORMAL;
9786   else if (decl_context == MEMFUNCDEF)
9787     funcdef_flag = -1, decl_context = FIELD;
9788   else if (decl_context == BITFIELD)
9789     bitfield = 1, decl_context = FIELD;
9790
9791   /* Look inside a declarator for the name being declared
9792      and get it as a string, for an error message.  */
9793   {
9794     tree *next = &declarator;
9795     register tree decl;
9796     name = NULL;
9797
9798     while (next && *next)
9799       {
9800         decl = *next;
9801         switch (TREE_CODE (decl))
9802           {
9803           case TREE_LIST:
9804             /* For attributes.  */
9805             next = &TREE_VALUE (decl);
9806             break;
9807
9808           case COND_EXPR:
9809             ctype = NULL_TREE;
9810             next = &TREE_OPERAND (decl, 0);
9811             break;
9812
9813           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9814             {
9815               tree name = TREE_OPERAND (decl, 0);
9816               tree rename = NULL_TREE;
9817
9818               my_friendly_assert (flags == NO_SPECIAL, 152);
9819               flags = DTOR_FLAG;
9820               sfk = sfk_destructor;
9821               if (TREE_CODE (name) == TYPE_DECL)
9822                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9823               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9824               if (ctype == NULL_TREE)
9825                 {
9826                   if (current_class_type == NULL_TREE)
9827                     {
9828                       error ("destructors must be member functions");
9829                       flags = NO_SPECIAL;
9830                     }
9831                   else
9832                     {
9833                       tree t = constructor_name (current_class_name);
9834                       if (t != name)
9835                         rename = t;
9836                     }
9837                 }
9838               else
9839                 {
9840                   tree t = constructor_name (ctype);
9841                   if (t != name)
9842                     rename = t;
9843                 }
9844
9845               if (rename)
9846                 {
9847                   error ("destructor `%T' must match class name `%T'",
9848                             name, rename);
9849                   TREE_OPERAND (decl, 0) = rename;
9850                 }
9851               next = &name;
9852             }
9853             break;
9854
9855           case ADDR_EXPR:       /* C++ reference declaration */
9856             /* Fall through. */
9857           case ARRAY_REF:
9858           case INDIRECT_REF:
9859             ctype = NULL_TREE;
9860             innermost_code = TREE_CODE (decl);
9861             next = &TREE_OPERAND (decl, 0);
9862             break;
9863
9864           case CALL_EXPR:
9865             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9866               {
9867                 /* This is actually a variable declaration using
9868                    constructor syntax.  We need to call start_decl and
9869                    cp_finish_decl so we can get the variable
9870                    initialized...  */
9871
9872                 tree attributes;
9873
9874                 *next = TREE_OPERAND (decl, 0);
9875                 init = CALL_DECLARATOR_PARMS (decl);
9876
9877                 if (attrlist)
9878                   {
9879                     attributes = *attrlist;
9880                   }
9881                 else
9882                   {
9883                     attributes = NULL_TREE;
9884                   }
9885
9886                 decl = start_decl (declarator, declspecs, 1,
9887                                    attributes, NULL_TREE);
9888                 decl_type_access_control (decl);
9889                 if (decl)
9890                   {
9891                     /* Look for __unused__ attribute */
9892                     if (TREE_USED (TREE_TYPE (decl)))
9893                       TREE_USED (decl) = 1;
9894                     finish_decl (decl, init, NULL_TREE);
9895                   }
9896                 else
9897                   error ("invalid declarator");
9898                 return 0;
9899               }
9900             innermost_code = TREE_CODE (decl);
9901             if (decl_context == FIELD && ctype == NULL_TREE)
9902               ctype = current_class_type;
9903             if (ctype
9904                 && TREE_OPERAND (decl, 0)
9905                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9906                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9907                          == constructor_name_full (ctype))
9908                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9909                             == constructor_name (ctype)))))
9910               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9911             next = &TREE_OPERAND (decl, 0);
9912             decl = *next;
9913             if (ctype != NULL_TREE
9914                 && decl != NULL_TREE && flags != DTOR_FLAG
9915                 && decl == constructor_name (ctype))
9916               {
9917                 sfk = sfk_constructor;
9918                 ctor_return_type = ctype;
9919               }
9920             ctype = NULL_TREE;
9921             break;
9922
9923           case TEMPLATE_ID_EXPR:
9924               {
9925                 tree fns = TREE_OPERAND (decl, 0);
9926
9927                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9928                   fns = TREE_OPERAND (fns, 0);
9929
9930                 dname = fns;
9931                 if (TREE_CODE (dname) == COMPONENT_REF)
9932                   dname = TREE_OPERAND (dname, 1);
9933                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9934                   {
9935                     my_friendly_assert (is_overloaded_fn (dname),
9936                                         19990331);
9937                     dname = DECL_NAME (get_first_fn (dname));
9938                   }
9939               }
9940           /* Fall through. */
9941
9942           case IDENTIFIER_NODE:
9943             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9944               dname = decl;
9945
9946             next = 0;
9947
9948             if (C_IS_RESERVED_WORD (dname))
9949               {
9950                 error ("declarator-id missing; using reserved word `%D'",
9951                           dname);
9952                 name = IDENTIFIER_POINTER (dname);
9953               }
9954             else if (!IDENTIFIER_TYPENAME_P (dname))
9955               name = IDENTIFIER_POINTER (dname);
9956             else
9957               {
9958                 my_friendly_assert (flags == NO_SPECIAL, 154);
9959                 flags = TYPENAME_FLAG;
9960                 ctor_return_type = TREE_TYPE (dname);
9961                 sfk = sfk_conversion;
9962                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9963                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9964                         == TYPE_DECL))
9965                   name = IDENTIFIER_POINTER (dname);
9966                 else
9967                   name = "<invalid operator>";
9968               }
9969             break;
9970
9971             /* C++ extension */
9972           case SCOPE_REF:
9973             {
9974               /* Perform error checking, and decide on a ctype.  */
9975               tree cname = TREE_OPERAND (decl, 0);
9976               if (cname == NULL_TREE)
9977                 ctype = NULL_TREE;
9978               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9979                 {
9980                   ctype = NULL_TREE;
9981                   in_namespace = TREE_OPERAND (decl, 0);
9982                   TREE_OPERAND (decl, 0) = NULL_TREE;
9983                 }
9984               else if (! is_aggr_type (cname, 1))
9985                 TREE_OPERAND (decl, 0) = NULL_TREE;
9986               /* Must test TREE_OPERAND (decl, 1), in case user gives
9987                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9988               else if (TREE_OPERAND (decl, 1)
9989                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9990                 ctype = cname;
9991               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9992                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9993                 {
9994                   /* This might be declaring a member of a template
9995                      parm to be a friend.  */
9996                   ctype = cname;
9997                   dependant_name = TREE_OPERAND (decl, 1);
9998                 }
9999               else if (ctype == NULL_TREE)
10000                 ctype = cname;
10001               else if (TREE_COMPLEXITY (decl) == current_class_depth)
10002                 TREE_OPERAND (decl, 0) = ctype;
10003               else
10004                 {
10005                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
10006                     {
10007                       error ("type `%T' is not derived from type `%T'",
10008                                 cname, ctype);
10009                       TREE_OPERAND (decl, 0) = NULL_TREE;
10010                     }
10011                   else
10012                     ctype = cname;
10013                 }
10014
10015               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
10016                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
10017                        == constructor_name_full (ctype))
10018                       || (DECL_NAME (TREE_OPERAND (decl, 1))
10019                           == constructor_name (ctype))))
10020                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
10021               next = &TREE_OPERAND (decl, 1);
10022               decl = *next;
10023               if (ctype)
10024                 {
10025                   if (TREE_CODE (decl) == IDENTIFIER_NODE
10026                       && constructor_name (ctype) == decl)
10027                     {
10028                       sfk = sfk_constructor;
10029                       ctor_return_type = ctype;
10030                     }
10031                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
10032                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
10033                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
10034                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
10035                     {
10036                       sfk = sfk_destructor;
10037                       ctor_return_type = ctype;
10038                       flags = DTOR_FLAG;
10039                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
10040                       next = &TREE_OPERAND (decl, 0);
10041                     }
10042                 }
10043             }
10044             break;
10045
10046           case ERROR_MARK:
10047             next = 0;
10048             break;
10049
10050           case TYPE_DECL:
10051             /* Parse error puts this typespec where
10052                a declarator should go.  */
10053             error ("`%T' specified as declarator-id", DECL_NAME (decl));
10054             if (TREE_TYPE (decl) == current_class_type)
10055               error ("  perhaps you want `%T' for a constructor",
10056                         current_class_name);
10057             dname = DECL_NAME (decl);
10058             name = IDENTIFIER_POINTER (dname);
10059
10060             /* Avoid giving two errors for this.  */
10061             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10062
10063             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10064             *next = dname;
10065             next = 0;
10066             break;
10067
10068           case TEMPLATE_DECL:
10069             /* Sometimes, we see a template-name used as part of a
10070                decl-specifier like in
10071                      std::allocator alloc;
10072                Handle that gracefully.  */
10073             error ("invalid use of template-name '%E' in a declarator",
10074                    decl);
10075             return error_mark_node;
10076             break;
10077
10078           default:
10079             internal_error ("`%D' as declarator", decl);
10080           }
10081       }
10082   }
10083
10084   /* A function definition's declarator must have the form of
10085      a function declarator.  */
10086
10087   if (funcdef_flag && innermost_code != CALL_EXPR)
10088     return 0;
10089
10090   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10091       && innermost_code != CALL_EXPR
10092       && ! (ctype && declspecs == NULL_TREE))
10093     {
10094       error ("declaration of `%D' as non-function", dname);
10095       return void_type_node;
10096     }
10097
10098   /* Anything declared one level down from the top level
10099      must be one of the parameters of a function
10100      (because the body is at least two levels down).  */
10101
10102   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10103      by not allowing C++ class definitions to specify their parameters
10104      with xdecls (must be spec.d in the parmlist).
10105
10106      Since we now wait to push a class scope until we are sure that
10107      we are in a legitimate method context, we must set oldcname
10108      explicitly (since current_class_name is not yet alive).
10109
10110      We also want to avoid calling this a PARM if it is in a namespace.  */
10111
10112   if (decl_context == NORMAL && !toplevel_bindings_p ())
10113     {
10114       struct binding_level *b = current_binding_level;
10115       current_binding_level = b->level_chain;
10116       if (current_binding_level != 0 && toplevel_bindings_p ())
10117         decl_context = PARM;
10118       current_binding_level = b;
10119     }
10120
10121   if (name == NULL)
10122     name = decl_context == PARM ? "parameter" : "type name";
10123
10124   /* Look through the decl specs and record which ones appear.
10125      Some typespecs are defined as built-in typenames.
10126      Others, the ones that are modifiers of other types,
10127      are represented by bits in SPECBITS: set the bits for
10128      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10129
10130      If there is a typedef name or a type, store the type in TYPE.
10131      This includes builtin typedefs such as `int'.
10132
10133      Set EXPLICIT_INT if the type is `int' or `char' and did not
10134      come from a user typedef.
10135
10136      Set LONGLONG if `long' is mentioned twice.
10137
10138      For C++, constructors and destructors have their own fast treatment.  */
10139
10140   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10141     {
10142       register int i;
10143       register tree id;
10144
10145       /* Certain parse errors slip through.  For example,
10146          `int class;' is not caught by the parser. Try
10147          weakly to recover here.  */
10148       if (TREE_CODE (spec) != TREE_LIST)
10149         return 0;
10150
10151       id = TREE_VALUE (spec);
10152
10153       /* If the entire declaration is itself tagged as deprecated then
10154          suppress reports of deprecated items.  */
10155       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10156         {
10157           if (deprecated_state != DEPRECATED_SUPPRESS)
10158             warn_deprecated_use (id);
10159         }
10160
10161       if (TREE_CODE (id) == IDENTIFIER_NODE)
10162         {
10163           if (id == ridpointers[(int) RID_INT]
10164               || id == ridpointers[(int) RID_CHAR]
10165               || id == ridpointers[(int) RID_BOOL]
10166               || id == ridpointers[(int) RID_WCHAR])
10167             {
10168               if (type)
10169                 {
10170                   if (id == ridpointers[(int) RID_BOOL])
10171                     error ("`bool' is now a keyword");
10172                   else
10173                     error ("extraneous `%T' ignored", id);
10174                 }
10175               else
10176                 {
10177                   if (id == ridpointers[(int) RID_INT])
10178                     explicit_int = 1;
10179                   else if (id == ridpointers[(int) RID_CHAR])
10180                     explicit_char = 1;
10181                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10182                 }
10183               goto found;
10184             }
10185           /* C++ aggregate types.  */
10186           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10187             {
10188               if (type)
10189                 error ("multiple declarations `%T' and `%T'", type, id);
10190               else
10191                 type = IDENTIFIER_TYPE_VALUE (id);
10192               goto found;
10193             }
10194
10195           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10196             {
10197               if (ridpointers[i] == id)
10198                 {
10199                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10200                     {
10201                       if (pedantic && ! in_system_header && warn_long_long)
10202                         pedwarn ("ISO C++ does not support `long long'");
10203                       if (longlong)
10204                         error ("`long long long' is too long for GCC");
10205                       else
10206                         longlong = 1;
10207                     }
10208                   else if (RIDBIT_SETP (i, specbits))
10209                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10210                   if (i == (int)RID_EXTERN
10211                       && TREE_PURPOSE (spec) == error_mark_node)
10212                     /* This extern was part of a language linkage.  */
10213                     extern_langp = 1;
10214                   RIDBIT_SET (i, specbits);
10215                   goto found;
10216                 }
10217             }
10218         }
10219       else if (TREE_CODE (id) == TYPE_DECL)
10220         {
10221           if (type)
10222             error ("multiple declarations `%T' and `%T'", type,
10223                       TREE_TYPE (id));
10224           else
10225             {
10226               type = TREE_TYPE (id);
10227               TREE_VALUE (spec) = type;
10228               typedef_decl = id;
10229             }
10230           goto found;
10231         }
10232       if (type)
10233         error ("two or more data types in declaration of `%s'", name);
10234       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10235         {
10236           register tree t = lookup_name (id, 1);
10237           if (!t || TREE_CODE (t) != TYPE_DECL)
10238             error ("`%s' fails to be a typedef or built in type",
10239                    IDENTIFIER_POINTER (id));
10240           else
10241             {
10242               type = TREE_TYPE (t);
10243               typedef_decl = t;
10244             }
10245         }
10246       else if (id != error_mark_node)
10247         /* Can't change CLASS nodes into RECORD nodes here!  */
10248         type = id;
10249
10250     found: ;
10251     }
10252
10253 #if 0
10254   /* See the code below that used this.  */
10255   if (typedef_decl)
10256     decl_attr = DECL_ATTRIBUTES (typedef_decl);
10257 #endif
10258   typedef_type = type;
10259
10260   /* No type at all: default to `int', and set DEFAULTED_INT
10261      because it was not a user-defined typedef.  */
10262
10263   if (type == NULL_TREE
10264       && (RIDBIT_SETP (RID_SIGNED, specbits)
10265           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10266           || RIDBIT_SETP (RID_LONG, specbits)
10267           || RIDBIT_SETP (RID_SHORT, specbits)))
10268     {
10269       /* These imply 'int'.  */
10270       type = integer_type_node;
10271       defaulted_int = 1;
10272     }
10273
10274   if (sfk != sfk_none)
10275     type = check_special_function_return_type (sfk, type,
10276                                                ctor_return_type);
10277   else if (type == NULL_TREE)
10278     {
10279       int is_main;
10280
10281       explicit_int = -1;
10282
10283       /* We handle `main' specially here, because 'main () { }' is so
10284          common.  With no options, it is allowed.  With -Wreturn-type,
10285          it is a warning.  It is only an error with -pedantic-errors.  */
10286       is_main = (funcdef_flag
10287                  && dname && MAIN_NAME_P (dname)
10288                  && ctype == NULL_TREE
10289                  && in_namespace == NULL_TREE
10290                  && current_namespace == global_namespace);
10291
10292       if (in_system_header || flag_ms_extensions)
10293         /* Allow it, sigh.  */;
10294       else if (pedantic || ! is_main)
10295         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10296                     name);
10297       else if (warn_return_type)
10298         warning ("ISO C++ forbids declaration of `%s' with no type",
10299                     name);
10300
10301       type = integer_type_node;
10302     }
10303
10304   if (type && IMPLICIT_TYPENAME_P (type))
10305     {
10306       /* The implicit typename extension is deprecated and will be
10307          removed.  Warn about its use now.  */
10308       warning ("`%T' is implicitly a typename", type);
10309       cp_deprecated ("implicit typename");
10310
10311       /* Now remove its implicitness, so that we don't warn again.
10312          For instance this might be a typedef, and we do not want to
10313          warn on uses of the typedef itself.  Simply clearing the
10314          TREE_TYPE is insufficient.  */
10315       type = copy_node (type);
10316       TREE_TYPE (type) = NULL_TREE;
10317     }
10318
10319   ctype = NULL_TREE;
10320
10321   /* Now process the modifiers that were specified
10322      and check for invalid combinations.  */
10323
10324   /* Long double is a special combination.  */
10325
10326   if (RIDBIT_SETP (RID_LONG, specbits)
10327       && TYPE_MAIN_VARIANT (type) == double_type_node)
10328     {
10329       RIDBIT_RESET (RID_LONG, specbits);
10330       type = build_qualified_type (long_double_type_node,
10331                                    cp_type_quals (type));
10332     }
10333
10334   /* Check all other uses of type modifiers.  */
10335
10336   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10337       || RIDBIT_SETP (RID_SIGNED, specbits)
10338       || RIDBIT_SETP (RID_LONG, specbits)
10339       || RIDBIT_SETP (RID_SHORT, specbits))
10340     {
10341       int ok = 0;
10342
10343       if (TREE_CODE (type) == REAL_TYPE)
10344         error ("short, signed or unsigned invalid for `%s'", name);
10345       else if (TREE_CODE (type) != INTEGER_TYPE)
10346         error ("long, short, signed or unsigned invalid for `%s'", name);
10347       else if (RIDBIT_SETP (RID_LONG, specbits)
10348                && RIDBIT_SETP (RID_SHORT, specbits))
10349         error ("long and short specified together for `%s'", name);
10350       else if ((RIDBIT_SETP (RID_LONG, specbits)
10351                 || RIDBIT_SETP (RID_SHORT, specbits))
10352                && explicit_char)
10353         error ("long or short specified with char for `%s'", name);
10354       else if ((RIDBIT_SETP (RID_LONG, specbits)
10355                 || RIDBIT_SETP (RID_SHORT, specbits))
10356                && TREE_CODE (type) == REAL_TYPE)
10357         error ("long or short specified with floating type for `%s'", name);
10358       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10359                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10360         error ("signed and unsigned given together for `%s'", name);
10361       else
10362         {
10363           ok = 1;
10364           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10365             {
10366               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10367                        name);
10368               if (flag_pedantic_errors)
10369                 ok = 0;
10370             }
10371         }
10372
10373       /* Discard the type modifiers if they are invalid.  */
10374       if (! ok)
10375         {
10376           RIDBIT_RESET (RID_UNSIGNED, specbits);
10377           RIDBIT_RESET (RID_SIGNED, specbits);
10378           RIDBIT_RESET (RID_LONG, specbits);
10379           RIDBIT_RESET (RID_SHORT, specbits);
10380           longlong = 0;
10381         }
10382     }
10383
10384   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10385       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10386     {
10387       error ("complex invalid for `%s'", name);
10388       RIDBIT_RESET (RID_COMPLEX, specbits);
10389     }
10390
10391   /* Decide whether an integer type is signed or not.
10392      Optionally treat bitfields as signed by default.  */
10393   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10394       /* [class.bit]
10395
10396          It is implementation-defined whether a plain (neither
10397          explicitly signed or unsigned) char, short, int, or long
10398          bit-field is signed or unsigned.
10399
10400          Naturally, we extend this to long long as well.  Note that
10401          this does not include wchar_t.  */
10402       || (bitfield && !flag_signed_bitfields
10403           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10404           /* A typedef for plain `int' without `signed' can be
10405              controlled just like plain `int', but a typedef for
10406              `signed int' cannot be so controlled.  */
10407           && !(typedef_decl
10408                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10409           && (TREE_CODE (type) == INTEGER_TYPE
10410               || TREE_CODE (type) == CHAR_TYPE)
10411           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10412     {
10413       if (longlong)
10414         type = long_long_unsigned_type_node;
10415       else if (RIDBIT_SETP (RID_LONG, specbits))
10416         type = long_unsigned_type_node;
10417       else if (RIDBIT_SETP (RID_SHORT, specbits))
10418         type = short_unsigned_type_node;
10419       else if (type == char_type_node)
10420         type = unsigned_char_type_node;
10421       else if (typedef_decl)
10422         type = unsigned_type (type);
10423       else
10424         type = unsigned_type_node;
10425     }
10426   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10427            && type == char_type_node)
10428     type = signed_char_type_node;
10429   else if (longlong)
10430     type = long_long_integer_type_node;
10431   else if (RIDBIT_SETP (RID_LONG, specbits))
10432     type = long_integer_type_node;
10433   else if (RIDBIT_SETP (RID_SHORT, specbits))
10434     type = short_integer_type_node;
10435
10436   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10437     {
10438       /* If we just have "complex", it is equivalent to
10439          "complex double", but if any modifiers at all are specified it is
10440          the complex form of TYPE.  E.g, "complex short" is
10441          "complex short int".  */
10442
10443       if (defaulted_int && ! longlong
10444           && ! (RIDBIT_SETP (RID_LONG, specbits)
10445                 || RIDBIT_SETP (RID_SHORT, specbits)
10446                 || RIDBIT_SETP (RID_SIGNED, specbits)
10447                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10448         type = complex_double_type_node;
10449       else if (type == integer_type_node)
10450         type = complex_integer_type_node;
10451       else if (type == float_type_node)
10452         type = complex_float_type_node;
10453       else if (type == double_type_node)
10454         type = complex_double_type_node;
10455       else if (type == long_double_type_node)
10456         type = complex_long_double_type_node;
10457       else
10458         type = build_complex_type (type);
10459     }
10460
10461   type_quals = TYPE_UNQUALIFIED;
10462   if (RIDBIT_SETP (RID_CONST, specbits))
10463     type_quals |= TYPE_QUAL_CONST;
10464   if (RIDBIT_SETP (RID_VOLATILE, specbits))
10465     type_quals |= TYPE_QUAL_VOLATILE;
10466   if (RIDBIT_SETP (RID_RESTRICT, specbits))
10467     type_quals |= TYPE_QUAL_RESTRICT;
10468   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10469     error ("qualifiers are not allowed on declaration of `operator %T'",
10470               ctor_return_type);
10471
10472   type_quals |= cp_type_quals (type);
10473   type = cp_build_qualified_type_real
10474     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10475                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10476   /* We might have ignored or rejected some of the qualifiers.  */
10477   type_quals = cp_type_quals (type);
10478
10479   staticp = 0;
10480   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10481   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10482   RIDBIT_RESET (RID_VIRTUAL, specbits);
10483   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10484   RIDBIT_RESET (RID_EXPLICIT, specbits);
10485
10486   if (RIDBIT_SETP (RID_STATIC, specbits))
10487     staticp = 1 + (decl_context == FIELD);
10488
10489   if (virtualp && staticp == 2)
10490     {
10491       error ("member `%D' cannot be declared both virtual and static",
10492                 dname);
10493       staticp = 0;
10494     }
10495   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10496   RIDBIT_RESET (RID_FRIEND, specbits);
10497
10498   if (dependant_name && !friendp)
10499     {
10500       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10501       return void_type_node;
10502     }
10503
10504   /* Warn if two storage classes are given. Default to `auto'.  */
10505
10506   if (RIDBIT_ANY_SET (specbits))
10507     {
10508       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10509       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10510       if (decl_context == PARM && nclasses > 0)
10511         error ("storage class specifiers invalid in parameter declarations");
10512       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10513         {
10514           if (decl_context == PARM)
10515             error ("typedef declaration invalid in parameter declaration");
10516           nclasses++;
10517         }
10518       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10519       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10520       if (!nclasses && !friendp && extern_langp)
10521         nclasses++;
10522     }
10523
10524   /* Give error if `virtual' is used outside of class declaration.  */
10525   if (virtualp
10526       && (current_class_name == NULL_TREE || decl_context != FIELD))
10527     {
10528       error ("virtual outside class declaration");
10529       virtualp = 0;
10530     }
10531
10532   /* Static anonymous unions are dealt with here.  */
10533   if (staticp && decl_context == TYPENAME
10534       && TREE_CODE (declspecs) == TREE_LIST
10535       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10536     decl_context = FIELD;
10537
10538   /* Warn about storage classes that are invalid for certain
10539      kinds of declarations (parameters, typenames, etc.).  */
10540
10541   if (nclasses > 1)
10542     error ("multiple storage classes in declaration of `%s'", name);
10543   else if (decl_context != NORMAL && nclasses > 0)
10544     {
10545       if ((decl_context == PARM || decl_context == CATCHPARM)
10546           && (RIDBIT_SETP (RID_REGISTER, specbits)
10547               || RIDBIT_SETP (RID_AUTO, specbits)))
10548         ;
10549       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10550         ;
10551       else if (decl_context == FIELD
10552                /* C++ allows static class elements  */
10553                && RIDBIT_SETP (RID_STATIC, specbits))
10554         /* C++ also allows inlines and signed and unsigned elements,
10555            but in those cases we don't come in here.  */
10556         ;
10557       else
10558         {
10559           if (decl_context == FIELD)
10560             {
10561               tree tmp = NULL_TREE;
10562               register int op = 0;
10563
10564               if (declarator)
10565                 {
10566                   /* Avoid trying to get an operand off an identifier node.  */
10567                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10568                     tmp = declarator;
10569                   else
10570                     tmp = TREE_OPERAND (declarator, 0);
10571                   op = IDENTIFIER_OPNAME_P (tmp);
10572                   if (IDENTIFIER_TYPENAME_P (tmp))
10573                     {
10574                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10575                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10576                               == TYPE_DECL))
10577                         name = IDENTIFIER_POINTER (tmp);
10578                       else
10579                         name = "<invalid operator>";
10580                     }
10581                 }
10582               error ("storage class specified for %s `%s'",
10583                      op ? "member operator" : "field",
10584                      name);
10585             }
10586           else
10587             {
10588               if (decl_context == PARM || decl_context == CATCHPARM)
10589                 error ("storage class specified for parameter `%s'", name);
10590               else
10591                 error ("storage class specified for typename");
10592             }
10593           RIDBIT_RESET (RID_REGISTER, specbits);
10594           RIDBIT_RESET (RID_AUTO, specbits);
10595           RIDBIT_RESET (RID_EXTERN, specbits);
10596         }
10597     }
10598   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10599     {
10600       if (toplevel_bindings_p ())
10601         {
10602           /* It's common practice (and completely valid) to have a const
10603              be initialized and declared extern.  */
10604           if (!(type_quals & TYPE_QUAL_CONST))
10605             warning ("`%s' initialized and declared `extern'", name);
10606         }
10607       else
10608         error ("`%s' has both `extern' and initializer", name);
10609     }
10610   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10611            && ! toplevel_bindings_p ())
10612     error ("nested function `%s' declared `extern'", name);
10613   else if (toplevel_bindings_p ())
10614     {
10615       if (RIDBIT_SETP (RID_AUTO, specbits))
10616         error ("top-level declaration of `%s' specifies `auto'", name);
10617     }
10618
10619   if (nclasses > 0 && friendp)
10620     error ("storage class specifiers invalid in friend function declarations");
10621
10622   /* Now figure out the structure of the declarator proper.
10623      Descend through it, creating more complex types, until we reach
10624      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10625
10626   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10627          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10628     {
10629       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10630          an INDIRECT_REF (for *...),
10631          a CALL_EXPR (for ...(...)),
10632          an identifier (for the name being declared)
10633          or a null pointer (for the place in an absolute declarator
10634          where the name was omitted).
10635          For the last two cases, we have just exited the loop.
10636
10637          For C++ it could also be
10638          a SCOPE_REF (for class :: ...).  In this case, we have converted
10639          sensible names to types, and those are the values we use to
10640          qualify the member name.
10641          an ADDR_EXPR (for &...),
10642          a BIT_NOT_EXPR (for destructors)
10643
10644          At this point, TYPE is the type of elements of an array,
10645          or for a function to return, or for a pointer to point to.
10646          After this sequence of ifs, TYPE is the type of the
10647          array or function or pointer, and DECLARATOR has had its
10648          outermost layer removed.  */
10649
10650       if (type == error_mark_node)
10651         {
10652           if (TREE_CODE (declarator) == SCOPE_REF)
10653             declarator = TREE_OPERAND (declarator, 1);
10654           else
10655             declarator = TREE_OPERAND (declarator, 0);
10656           continue;
10657         }
10658       if (quals != NULL_TREE
10659           && (declarator == NULL_TREE
10660               || TREE_CODE (declarator) != SCOPE_REF))
10661         {
10662           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10663             ctype = TYPE_METHOD_BASETYPE (type);
10664           if (ctype != NULL_TREE)
10665             {
10666               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10667               grok_method_quals (ctype, dummy, quals);
10668               type = TREE_TYPE (dummy);
10669               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10670               quals = NULL_TREE;
10671             }
10672         }
10673
10674       switch (TREE_CODE (declarator))
10675         {
10676         case TREE_LIST:
10677           {
10678             /* We encode a declarator with embedded attributes using
10679                a TREE_LIST.  */
10680             tree attrs = TREE_PURPOSE (declarator);
10681             tree inner_decl;
10682             int attr_flags;
10683
10684             declarator = TREE_VALUE (declarator);
10685             inner_decl = declarator;
10686             while (inner_decl != NULL_TREE
10687                    && TREE_CODE (inner_decl) == TREE_LIST)
10688               inner_decl = TREE_VALUE (inner_decl);
10689             attr_flags = 0;
10690             if (inner_decl == NULL_TREE
10691                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10692               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10693             if (TREE_CODE (inner_decl) == CALL_EXPR)
10694               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10695             if (TREE_CODE (inner_decl) == ARRAY_REF)
10696               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10697             returned_attrs = decl_attributes (&type,
10698                                               chainon (returned_attrs, attrs),
10699                                               attr_flags);
10700           }
10701           break;
10702
10703         case ARRAY_REF:
10704           {
10705             register tree size;
10706
10707             size = TREE_OPERAND (declarator, 1);
10708
10709             /* VC++ spells a zero-sized array with [].  */
10710             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10711                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10712               size = integer_zero_node;
10713
10714             declarator = TREE_OPERAND (declarator, 0);
10715
10716             type = create_array_type_for_decl (dname, type, size);
10717
10718             ctype = NULL_TREE;
10719           }
10720           break;
10721
10722         case CALL_EXPR:
10723           {
10724             tree arg_types;
10725             int funcdecl_p;
10726             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10727             tree inner_decl = TREE_OPERAND (declarator, 0);
10728
10729             /* Declaring a function type.
10730                Make sure we have a valid type for the function to return.  */
10731
10732             /* We now know that the TYPE_QUALS don't apply to the
10733                decl, but to its return type.  */
10734             type_quals = TYPE_UNQUALIFIED;
10735
10736             /* Warn about some types functions can't return.  */
10737
10738             if (TREE_CODE (type) == FUNCTION_TYPE)
10739               {
10740                 error ("`%s' declared as function returning a function", name);
10741                 type = integer_type_node;
10742               }
10743             if (TREE_CODE (type) == ARRAY_TYPE)
10744               {
10745                 error ("`%s' declared as function returning an array", name);
10746                 type = integer_type_node;
10747               }
10748
10749             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10750               inner_decl = TREE_OPERAND (inner_decl, 1);
10751
10752             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10753               inner_decl = dname;
10754
10755             /* Pick up type qualifiers which should be applied to `this'.  */
10756             quals = CALL_DECLARATOR_QUALS (declarator);
10757
10758             /* Pick up the exception specifications.  */
10759             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10760
10761             /* Say it's a definition only for the CALL_EXPR
10762                closest to the identifier.  */
10763             funcdecl_p
10764               = inner_decl
10765               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10766                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10767                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10768
10769             if (ctype == NULL_TREE
10770                 && decl_context == FIELD
10771                 && funcdecl_p
10772                 && (friendp == 0 || dname == current_class_name))
10773               ctype = current_class_type;
10774
10775             if (ctype && sfk == sfk_conversion)
10776               TYPE_HAS_CONVERSION (ctype) = 1;
10777             if (ctype && constructor_name (ctype) == dname)
10778               {
10779                 /* We are within a class's scope. If our declarator name
10780                    is the same as the class name, and we are defining
10781                    a function, then it is a constructor/destructor, and
10782                    therefore returns a void type.  */
10783
10784                 if (flags == DTOR_FLAG)
10785                   {
10786                     /* ISO C++ 12.4/2.  A destructor may not be
10787                        declared const or volatile.  A destructor may
10788                        not be static.  */
10789                     if (staticp == 2)
10790                       error ("destructor cannot be static member function");
10791                     if (quals)
10792                       {
10793                         error ("destructors may not be `%s'",
10794                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10795                         quals = NULL_TREE;
10796                       }
10797                     if (decl_context == FIELD)
10798                       {
10799                         if (! member_function_or_else (ctype,
10800                                                        current_class_type,
10801                                                        flags))
10802                           return void_type_node;
10803                       }
10804                   }
10805                 else            /* It's a constructor.  */
10806                   {
10807                     if (explicitp == 1)
10808                       explicitp = 2;
10809                     /* ISO C++ 12.1.  A constructor may not be
10810                        declared const or volatile.  A constructor may
10811                        not be virtual.  A constructor may not be
10812                        static.  */
10813                     if (staticp == 2)
10814                       error ("constructor cannot be static member function");
10815                     if (virtualp)
10816                       {
10817                         pedwarn ("constructors cannot be declared virtual");
10818                         virtualp = 0;
10819                       }
10820                     if (quals)
10821                       {
10822                         error ("constructors may not be `%s'",
10823                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10824                         quals = NULL_TREE;
10825                       }
10826                     {
10827                       RID_BIT_TYPE tmp_bits;
10828                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10829                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10830                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10831                       if (RIDBIT_ANY_SET (tmp_bits))
10832                         error ("return value type specifier for constructor ignored");
10833                     }
10834                     if (decl_context == FIELD)
10835                       {
10836                         if (! member_function_or_else (ctype,
10837                                                        current_class_type,
10838                                                        flags))
10839                           return void_type_node;
10840                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10841                         if (sfk != sfk_constructor)
10842                           return NULL_TREE;
10843                       }
10844                   }
10845                 if (decl_context == FIELD)
10846                   staticp = 0;
10847               }
10848             else if (friendp)
10849               {
10850                 if (initialized)
10851                   error ("can't initialize friend function `%s'", name);
10852                 if (virtualp)
10853                   {
10854                     /* Cannot be both friend and virtual.  */
10855                     error ("virtual functions cannot be friends");
10856                     RIDBIT_RESET (RID_FRIEND, specbits);
10857                     friendp = 0;
10858                   }
10859                 if (decl_context == NORMAL)
10860                   error ("friend declaration not in class definition");
10861                 if (current_function_decl && funcdef_flag)
10862                   error ("can't define friend function `%s' in a local class definition",
10863                             name);
10864               }
10865
10866             /* Construct the function type and go to the next
10867                inner layer of declarator.  */
10868
10869             declarator = TREE_OPERAND (declarator, 0);
10870
10871             /* FIXME: This is where default args should be fully
10872                processed.  */
10873
10874             arg_types = grokparms (inner_parms);
10875
10876             if (declarator && flags == DTOR_FLAG)
10877               {
10878                 /* A destructor declared in the body of a class will
10879                    be represented as a BIT_NOT_EXPR.  But, we just
10880                    want the underlying IDENTIFIER.  */
10881                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10882                   declarator = TREE_OPERAND (declarator, 0);
10883
10884                 if (arg_types != void_list_node)
10885                   {
10886                     error ("destructors may not have parameters");
10887                     arg_types = void_list_node;
10888                     last_function_parms = NULL_TREE;
10889                   }
10890               }
10891
10892             /* ANSI says that `const int foo ();'
10893                does not make the function foo const.  */
10894             type = build_function_type (type, arg_types);
10895
10896             {
10897               tree t;
10898               for (t = arg_types; t; t = TREE_CHAIN (t))
10899                 if (TREE_PURPOSE (t)
10900                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10901                   {
10902                     add_defarg_fn (type);
10903                     break;
10904                   }
10905             }
10906           }
10907           break;
10908
10909         case ADDR_EXPR:
10910         case INDIRECT_REF:
10911           /* Filter out pointers-to-references and references-to-references.
10912              We can get these if a TYPE_DECL is used.  */
10913
10914           if (TREE_CODE (type) == REFERENCE_TYPE)
10915             {
10916               error ("cannot declare %s to references",
10917                      TREE_CODE (declarator) == ADDR_EXPR
10918                      ? "references" : "pointers");
10919               declarator = TREE_OPERAND (declarator, 0);
10920               continue;
10921             }
10922
10923           if (TREE_CODE (type) == OFFSET_TYPE
10924               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10925                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10926             {
10927               error ("cannot declare pointer to `%#T' member",
10928                         TREE_TYPE (type));
10929               type = TREE_TYPE (type);
10930             }
10931
10932           /* Merge any constancy or volatility into the target type
10933              for the pointer.  */
10934
10935           /* We now know that the TYPE_QUALS don't apply to the decl,
10936              but to the target of the pointer.  */
10937           type_quals = TYPE_UNQUALIFIED;
10938
10939           if (TREE_CODE (declarator) == ADDR_EXPR)
10940             {
10941               if (TREE_CODE (type) == VOID_TYPE)
10942                 error ("invalid type: `void &'");
10943               else
10944                 type = build_reference_type (type);
10945             }
10946           else if (TREE_CODE (type) == METHOD_TYPE)
10947             type = build_ptrmemfunc_type (build_pointer_type (type));
10948           else
10949             type = build_pointer_type (type);
10950
10951           /* Process a list of type modifier keywords (such as
10952              const or volatile) that were given inside the `*' or `&'.  */
10953
10954           if (TREE_TYPE (declarator))
10955             {
10956               register tree typemodlist;
10957               int erred = 0;
10958               int constp = 0;
10959               int volatilep = 0;
10960               int restrictp = 0;
10961
10962               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10963                    typemodlist = TREE_CHAIN (typemodlist))
10964                 {
10965                   tree qualifier = TREE_VALUE (typemodlist);
10966
10967                   if (qualifier == ridpointers[(int) RID_CONST])
10968                     {
10969                       constp++;
10970                       type_quals |= TYPE_QUAL_CONST;
10971                     }
10972                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10973                     {
10974                       volatilep++;
10975                       type_quals |= TYPE_QUAL_VOLATILE;
10976                     }
10977                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10978                     {
10979                       restrictp++;
10980                       type_quals |= TYPE_QUAL_RESTRICT;
10981                     }
10982                   else if (!erred)
10983                     {
10984                       erred = 1;
10985                       error ("invalid type modifier within pointer declarator");
10986                     }
10987                 }
10988               if (constp > 1)
10989                 pedwarn ("duplicate `const'");
10990               if (volatilep > 1)
10991                 pedwarn ("duplicate `volatile'");
10992               if (restrictp > 1)
10993                 pedwarn ("duplicate `restrict'");
10994               type = cp_build_qualified_type (type, type_quals);
10995               type_quals = cp_type_quals (type);
10996             }
10997           declarator = TREE_OPERAND (declarator, 0);
10998           ctype = NULL_TREE;
10999           break;
11000
11001         case SCOPE_REF:
11002           {
11003             /* We have converted type names to NULL_TREE if the
11004                name was bogus, or to a _TYPE node, if not.
11005
11006                The variable CTYPE holds the type we will ultimately
11007                resolve to.  The code here just needs to build
11008                up appropriate member types.  */
11009             tree sname = TREE_OPERAND (declarator, 1);
11010             tree t;
11011
11012             /* Destructors can have their visibilities changed as well.  */
11013             if (TREE_CODE (sname) == BIT_NOT_EXPR)
11014               sname = TREE_OPERAND (sname, 0);
11015
11016             if (TREE_COMPLEXITY (declarator) == 0)
11017               /* This needs to be here, in case we are called
11018                  multiple times.  */ ;
11019             else if (TREE_COMPLEXITY (declarator) == -1)
11020               /* Namespace member. */
11021               pop_decl_namespace ();
11022             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
11023               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
11024             else if (!TREE_OPERAND (declarator, 0)
11025                      || !IS_AGGR_TYPE_CODE
11026                           (TREE_CODE (TREE_OPERAND (declarator, 0))))
11027               ;
11028             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
11029               {
11030                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
11031                    that refer to ctype.  They couldn't be resolved earlier
11032                    because we hadn't pushed into the class yet.
11033                    Example: resolve 'B<T>::type' in
11034                    'B<typename B<T>::type> B<T>::f () { }'.  */
11035                 if (current_template_parms
11036                     && uses_template_parms (type)
11037                     && uses_template_parms (current_class_type))
11038                   {
11039                     tree args = current_template_args ();
11040                     type = tsubst (type, args, tf_error | tf_warning,
11041                                    NULL_TREE);
11042                   }
11043
11044                 /* This pop_nested_class corresponds to the
11045                    push_nested_class used to push into class scope for
11046                    parsing the argument list of a function decl, in
11047                    qualified_id.  */
11048                 pop_nested_class ();
11049                 TREE_COMPLEXITY (declarator) = current_class_depth;
11050               }
11051             else
11052               abort ();
11053
11054             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11055               {
11056                 /* We had a reference to a global decl, or
11057                    perhaps we were given a non-aggregate typedef,
11058                    in which case we cleared this out, and should just
11059                    keep going as though it wasn't there.  */
11060                 declarator = sname;
11061                 continue;
11062               }
11063             ctype = TREE_OPERAND (declarator, 0);
11064
11065             t = ctype;
11066             while (t != NULL_TREE && CLASS_TYPE_P (t))
11067               {
11068                 /* You're supposed to have one `template <...>'
11069                    for every template class, but you don't need one
11070                    for a full specialization.  For example:
11071
11072                      template <class T> struct S{};
11073                      template <> struct S<int> { void f(); };
11074                      void S<int>::f () {}
11075
11076                    is correct; there shouldn't be a `template <>' for
11077                    the definition of `S<int>::f'.  */
11078                 if (CLASSTYPE_TEMPLATE_INFO (t)
11079                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11080                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11081                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11082                   template_count += 1;
11083
11084                 t = TYPE_MAIN_DECL (t);
11085                 t = DECL_CONTEXT (t);
11086               }
11087
11088             if (sname == NULL_TREE)
11089               goto done_scoping;
11090
11091             if (TREE_CODE (sname) == IDENTIFIER_NODE)
11092               {
11093                 /* This is the `standard' use of the scoping operator:
11094                    basetype :: member .  */
11095
11096                 if (ctype == current_class_type)
11097                   {
11098                     /* class A {
11099                          void A::f ();
11100                        };
11101
11102                        Is this ill-formed?  */
11103
11104                     if (pedantic)
11105                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
11106                                   ctype, name);
11107                   }
11108                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11109                   {
11110                     if (current_class_type == NULL_TREE || friendp)
11111                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11112                                                       TYPE_ARG_TYPES (type));
11113                     else
11114                       {
11115                         error ("cannot declare member function `%T::%s' within `%T'",
11116                                   ctype, name, current_class_type);
11117                         return void_type_node;
11118                       }
11119                   }
11120                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11121                          || COMPLETE_TYPE_P (complete_type (ctype)))
11122                   {
11123                     /* Have to move this code elsewhere in this function.
11124                        this code is used for i.e., typedef int A::M; M *pm;
11125
11126                        It is?  How? jason 10/2/94 */
11127
11128                     if (current_class_type)
11129                       {
11130                         error ("cannot declare member `%T::%s' within `%T'",
11131                                   ctype, name, current_class_type);
11132                         return void_type_node;
11133                       }
11134                     type = build_offset_type (ctype, type);
11135                   }
11136                 else
11137                   {
11138                     incomplete_type_error (NULL_TREE, ctype);
11139                     return error_mark_node;
11140                   }
11141
11142                 declarator = sname;
11143               }
11144             else if (TREE_CODE (sname) == SCOPE_REF)
11145               abort ();
11146             else
11147               {
11148               done_scoping:
11149                 declarator = TREE_OPERAND (declarator, 1);
11150                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11151                   /* In this case, we will deal with it later.  */
11152                   ;
11153                 else
11154                   {
11155                     if (TREE_CODE (type) == FUNCTION_TYPE)
11156                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11157                                                       TYPE_ARG_TYPES (type));
11158                     else
11159                       type = build_offset_type (ctype, type);
11160                   }
11161               }
11162           }
11163           break;
11164
11165         case BIT_NOT_EXPR:
11166           declarator = TREE_OPERAND (declarator, 0);
11167           break;
11168
11169         case RECORD_TYPE:
11170         case UNION_TYPE:
11171         case ENUMERAL_TYPE:
11172           declarator = NULL_TREE;
11173           break;
11174
11175         case ERROR_MARK:
11176           declarator = NULL_TREE;
11177           break;
11178
11179         default:
11180           abort ();
11181         }
11182     }
11183
11184   if (returned_attrs)
11185     {
11186       if (attrlist)
11187         *attrlist = chainon (returned_attrs, *attrlist);
11188       else
11189         attrlist = &returned_attrs;
11190     }
11191
11192   /* Now TYPE has the actual type.  */
11193
11194   /* Did array size calculations overflow?  */
11195
11196   if (TREE_CODE (type) == ARRAY_TYPE
11197       && COMPLETE_TYPE_P (type)
11198       && TREE_OVERFLOW (TYPE_SIZE (type)))
11199     {
11200       error ("size of array `%s' is too large", name);
11201       /* If we proceed with the array type as it is, we'll eventually
11202          crash in tree_low_cst().  */
11203       type = error_mark_node;
11204     }
11205
11206   if (decl_context == FIELD
11207       && !processing_template_decl
11208       && variably_modified_type_p (type))
11209     {
11210       error ("data member may not have variably modified type `%T'", type);
11211       type = error_mark_node;
11212     }
11213
11214   if (explicitp == 1 || (explicitp && friendp))
11215     {
11216       /* [dcl.fct.spec] The explicit specifier shall only be used in
11217          declarations of constructors within a class definition.  */
11218       error ("only declarations of constructors can be `explicit'");
11219       explicitp = 0;
11220     }
11221
11222   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11223     {
11224       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11225         {
11226           error ("non-member `%s' cannot be declared `mutable'", name);
11227           RIDBIT_RESET (RID_MUTABLE, specbits);
11228         }
11229       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11230         {
11231           error ("non-object member `%s' cannot be declared `mutable'", name);
11232           RIDBIT_RESET (RID_MUTABLE, specbits);
11233         }
11234       else if (TREE_CODE (type) == FUNCTION_TYPE
11235                || TREE_CODE (type) == METHOD_TYPE)
11236         {
11237           error ("function `%s' cannot be declared `mutable'", name);
11238           RIDBIT_RESET (RID_MUTABLE, specbits);
11239         }
11240       else if (staticp)
11241         {
11242           error ("static `%s' cannot be declared `mutable'", name);
11243           RIDBIT_RESET (RID_MUTABLE, specbits);
11244         }
11245       else if (type_quals & TYPE_QUAL_CONST)
11246         {
11247           error ("const `%s' cannot be declared `mutable'", name);
11248           RIDBIT_RESET (RID_MUTABLE, specbits);
11249         }
11250     }
11251
11252   if (declarator == NULL_TREE
11253       || TREE_CODE (declarator) == IDENTIFIER_NODE
11254       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11255           && (TREE_CODE (type) == FUNCTION_TYPE
11256               || TREE_CODE (type) == METHOD_TYPE)))
11257     /* OK */;
11258   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11259     {
11260       error ("template-id `%D' used as a declarator", declarator);
11261       declarator = dname;
11262     }
11263   else
11264     /* Unexpected declarator format.  */
11265     abort ();
11266
11267   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11268
11269   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11270     {
11271       tree decl;
11272
11273       /* Note that the grammar rejects storage classes
11274          in typenames, fields or parameters.  */
11275       if (current_lang_name == lang_name_java)
11276         TYPE_FOR_JAVA (type) = 1;
11277
11278       if (decl_context == FIELD)
11279         {
11280           if (declarator == constructor_name (current_class_type))
11281             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11282                         declarator);
11283           decl = build_lang_decl (TYPE_DECL, declarator, type);
11284         }
11285       else
11286         {
11287           decl = build_decl (TYPE_DECL, declarator, type);
11288           if (!current_function_decl)
11289             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11290         }
11291
11292       /* If the user declares "typedef struct {...} foo" then the
11293          struct will have an anonymous name.  Fill that name in now.
11294          Nothing can refer to it, so nothing needs know about the name
11295          change.  */
11296       if (type != error_mark_node
11297           && declarator
11298           && TYPE_NAME (type)
11299           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11300           && TYPE_ANONYMOUS_P (type)
11301           /* Don't do this if there are attributes.  */
11302           && (!attrlist || !*attrlist)
11303           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11304         {
11305           tree oldname = TYPE_NAME (type);
11306           tree t;
11307
11308           /* Replace the anonymous name with the real name everywhere.  */
11309           lookup_tag_reverse (type, declarator);
11310           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11311             if (TYPE_NAME (t) == oldname)
11312               TYPE_NAME (t) = decl;
11313
11314           if (TYPE_LANG_SPECIFIC (type))
11315             TYPE_WAS_ANONYMOUS (type) = 1;
11316
11317           /* If this is a typedef within a template class, the nested
11318              type is a (non-primary) template.  The name for the
11319              template needs updating as well.  */
11320           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11321             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11322               = TYPE_IDENTIFIER (type);
11323
11324           /* FIXME remangle member functions; member functions of a
11325              type with external linkage have external linkage.  */
11326         }
11327
11328       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11329         {
11330           cp_error_at ("typedef name may not be class-qualified", decl);
11331           return NULL_TREE;
11332         }
11333       else if (quals)
11334         {
11335           if (ctype == NULL_TREE)
11336             {
11337               if (TREE_CODE (type) != METHOD_TYPE)
11338                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11339               else
11340                 ctype = TYPE_METHOD_BASETYPE (type);
11341             }
11342           if (ctype != NULL_TREE)
11343             grok_method_quals (ctype, decl, quals);
11344         }
11345
11346       if (RIDBIT_SETP (RID_SIGNED, specbits)
11347           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11348         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11349
11350       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11351                       inlinep, friendp, raises != NULL_TREE);
11352
11353       return decl;
11354     }
11355
11356   /* Detect the case of an array type of unspecified size
11357      which came, as such, direct from a typedef name.
11358      We must copy the type, so that the array's domain can be
11359      individually set by the object's initializer.  */
11360
11361   if (type && typedef_type
11362       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11363       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11364     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11365
11366   /* Detect where we're using a typedef of function type to declare a
11367      function. last_function_parms will not be set, so we must create
11368      it now.  */
11369
11370   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11371     {
11372       tree decls = NULL_TREE;
11373       tree args;
11374
11375       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11376         {
11377           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11378
11379           TREE_CHAIN (decl) = decls;
11380           decls = decl;
11381         }
11382
11383       last_function_parms = nreverse (decls);
11384     }
11385
11386   /* If this is a type name (such as, in a cast or sizeof),
11387      compute the type and return it now.  */
11388
11389   if (decl_context == TYPENAME)
11390     {
11391       /* Note that the grammar rejects storage classes
11392          in typenames, fields or parameters.  */
11393       if (type_quals != TYPE_UNQUALIFIED)
11394         type_quals = TYPE_UNQUALIFIED;
11395
11396       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11397       if (friendp)
11398         {
11399           if (type_quals != TYPE_UNQUALIFIED)
11400             {
11401               error ("type qualifiers specified for friend class declaration");
11402               type_quals = TYPE_UNQUALIFIED;
11403             }
11404           if (inlinep)
11405             {
11406               error ("`inline' specified for friend class declaration");
11407               inlinep = 0;
11408             }
11409
11410           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11411              But don't allow implicit typenames except with a class-key.  */
11412           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11413                                 || IMPLICIT_TYPENAME_P (type)))
11414             {
11415               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11416                 pedwarn ("template parameters cannot be friends");
11417               else if (TREE_CODE (type) == TYPENAME_TYPE)
11418                 pedwarn ("\
11419 friend declaration requires class-key, i.e. `friend class %T::%T'",
11420                             constructor_name (current_class_type),
11421                             TYPE_IDENTIFIER (type));
11422               else
11423                 pedwarn ("\
11424 friend declaration requires class-key, i.e. `friend %#T'",
11425                             type);
11426             }
11427
11428           /* Only try to do this stuff if we didn't already give up.  */
11429           if (type != integer_type_node)
11430             {
11431               decl_type_access_control (TYPE_NAME (type));
11432
11433               /* A friendly class?  */
11434               if (current_class_type)
11435                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11436               else
11437                 error ("trying to make class `%T' a friend of global scope",
11438                           type);
11439
11440               type = void_type_node;
11441             }
11442         }
11443       else if (quals)
11444         {
11445           if (ctype == NULL_TREE)
11446             {
11447               if (TREE_CODE (type) != METHOD_TYPE)
11448                 error ("invalid qualifiers on non-member function type");
11449               else
11450                 ctype = TYPE_METHOD_BASETYPE (type);
11451             }
11452           if (ctype)
11453             {
11454               tree dummy = build_decl (TYPE_DECL, declarator, type);
11455               grok_method_quals (ctype, dummy, quals);
11456               type = TREE_TYPE (dummy);
11457             }
11458         }
11459
11460       return type;
11461     }
11462   else if (declarator == NULL_TREE && decl_context != PARM
11463            && decl_context != CATCHPARM
11464            && TREE_CODE (type) != UNION_TYPE
11465            && ! bitfield)
11466     {
11467       error ("abstract declarator `%T' used as declaration", type);
11468       declarator = make_anon_name ();
11469     }
11470
11471   /* `void' at top level (not within pointer)
11472      is allowed only in typedefs or type names.
11473      We don't complain about parms either, but that is because
11474      a better error message can be made later.  */
11475
11476   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11477     {
11478       if (! declarator)
11479         error ("unnamed variable or field declared void");
11480       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11481         {
11482           if (IDENTIFIER_OPNAME_P (declarator))
11483             abort ();
11484           else
11485             error ("variable or field `%s' declared void", name);
11486         }
11487       else
11488         error ("variable or field declared void");
11489       type = integer_type_node;
11490     }
11491
11492   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11493      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11494
11495   if (decl_context == PARM || decl_context == CATCHPARM)
11496     {
11497       if (ctype || in_namespace)
11498         error ("cannot use `::' in parameter declaration");
11499
11500       /* A parameter declared as an array of T is really a pointer to T.
11501          One declared as a function is really a pointer to a function.
11502          One declared as a member is really a pointer to member.  */
11503
11504       if (TREE_CODE (type) == ARRAY_TYPE)
11505         {
11506           /* Transfer const-ness of array into that of type pointed to.  */
11507           type = build_pointer_type (TREE_TYPE (type));
11508           type_quals = TYPE_UNQUALIFIED;
11509         }
11510       else if (TREE_CODE (type) == FUNCTION_TYPE)
11511         type = build_pointer_type (type);
11512       else if (TREE_CODE (type) == OFFSET_TYPE)
11513         type = build_pointer_type (type);
11514     }
11515
11516   {
11517     register tree decl;
11518
11519     if (decl_context == PARM)
11520       {
11521         decl = build_decl (PARM_DECL, declarator, type);
11522
11523         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11524                         inlinep, friendp, raises != NULL_TREE);
11525
11526         /* Compute the type actually passed in the parmlist,
11527            for the case where there is no prototype.
11528            (For example, shorts and chars are passed as ints.)
11529            When there is a prototype, this is overridden later.  */
11530
11531         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11532       }
11533     else if (decl_context == FIELD)
11534       {
11535         if (type == error_mark_node)
11536           {
11537             /* Happens when declaring arrays of sizes which
11538                are error_mark_node, for example.  */
11539             decl = NULL_TREE;
11540           }
11541         else if (in_namespace && !friendp)
11542           {
11543             /* Something like struct S { int N::j; };  */
11544             error ("invalid use of `::'");
11545             decl = NULL_TREE;
11546           }
11547         else if (TREE_CODE (type) == FUNCTION_TYPE)
11548           {
11549             int publicp = 0;
11550             tree function_context;
11551
11552             /* We catch the others as conflicts with the builtin
11553                typedefs.  */
11554             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11555               {
11556                 error ("function `%D' cannot be declared friend",
11557                           declarator);
11558                 friendp = 0;
11559               }
11560
11561             if (friendp == 0)
11562               {
11563                 if (ctype == NULL_TREE)
11564                   ctype = current_class_type;
11565
11566                 if (ctype == NULL_TREE)
11567                   {
11568                     error ("can't make `%D' into a method -- not in a class",
11569                               declarator);
11570                     return void_type_node;
11571                   }
11572
11573                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11574                    ARM 9.5 */
11575                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11576                   {
11577                     error ("function `%D' declared virtual inside a union",
11578                               declarator);
11579                     return void_type_node;
11580                   }
11581
11582                 if (declarator == ansi_opname (NEW_EXPR)
11583                     || declarator == ansi_opname (VEC_NEW_EXPR)
11584                     || declarator == ansi_opname (DELETE_EXPR)
11585                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11586                   {
11587                     if (virtualp)
11588                       {
11589                         error ("`%D' cannot be declared virtual, since it is always static",
11590                                   declarator);
11591                         virtualp = 0;
11592                       }
11593                   }
11594                 else if (staticp < 2)
11595                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11596                                                   TYPE_ARG_TYPES (type));
11597               }
11598
11599             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11600             function_context = (ctype != NULL_TREE) ?
11601               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11602             publicp = (! friendp || ! staticp)
11603               && function_context == NULL_TREE;
11604             decl = grokfndecl (ctype, type,
11605                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11606                                ? declarator : dname,
11607                                declarator,
11608                                virtualp, flags, quals, raises,
11609                                friendp ? -1 : 0, friendp, publicp, inlinep,
11610                                funcdef_flag, template_count, in_namespace);
11611             if (decl == NULL_TREE)
11612               return decl;
11613 #if 0
11614             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11615             /* The decl and setting of decl_attr is also turned off.  */
11616             decl = build_decl_attribute_variant (decl, decl_attr);
11617 #endif
11618
11619             /* [class.conv.ctor]
11620
11621                A constructor declared without the function-specifier
11622                explicit that can be called with a single parameter
11623                specifies a conversion from the type of its first
11624                parameter to the type of its class.  Such a constructor
11625                is called a converting constructor.  */
11626             if (explicitp == 2)
11627               DECL_NONCONVERTING_P (decl) = 1;
11628             else if (DECL_CONSTRUCTOR_P (decl))
11629               {
11630                 /* The constructor can be called with exactly one
11631                    parameter if there is at least one parameter, and
11632                    any subsequent parameters have default arguments.
11633                    Ignore any compiler-added parms.  */
11634                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11635
11636                 if (arg_types == void_list_node
11637                     || (arg_types
11638                         && TREE_CHAIN (arg_types)
11639                         && TREE_CHAIN (arg_types) != void_list_node
11640                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11641                   DECL_NONCONVERTING_P (decl) = 1;
11642               }
11643           }
11644         else if (TREE_CODE (type) == METHOD_TYPE)
11645           {
11646             /* We only get here for friend declarations of
11647                members of other classes.  */
11648             /* All method decls are public, so tell grokfndecl to set
11649                TREE_PUBLIC, also.  */
11650             decl = grokfndecl (ctype, type, declarator, declarator,
11651                                virtualp, flags, quals, raises,
11652                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11653                                template_count, in_namespace);
11654             if (decl == NULL_TREE)
11655               return NULL_TREE;
11656           }
11657         else if (!staticp && ! processing_template_decl
11658                  && !COMPLETE_TYPE_P (complete_type (type))
11659                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11660           {
11661             if (declarator)
11662               error ("field `%D' has incomplete type", declarator);
11663             else
11664               error ("name `%T' has incomplete type", type);
11665
11666             /* If we're instantiating a template, tell them which
11667                instantiation made the field's type be incomplete.  */
11668             if (current_class_type
11669                 && TYPE_NAME (current_class_type)
11670                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11671                 && declspecs && TREE_VALUE (declspecs)
11672                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11673               error ("  in instantiation of template `%T'",
11674                         current_class_type);
11675
11676             type = error_mark_node;
11677             decl = NULL_TREE;
11678           }
11679         else
11680           {
11681             if (friendp)
11682               {
11683                 error ("`%s' is neither function nor member function; cannot be declared friend",
11684                        IDENTIFIER_POINTER (declarator));
11685                 friendp = 0;
11686               }
11687             decl = NULL_TREE;
11688           }
11689
11690         if (friendp)
11691           {
11692             /* Friends are treated specially.  */
11693             if (ctype == current_class_type)
11694               warning ("member functions are implicitly friends of their class");
11695             else
11696               {
11697                 tree t = NULL_TREE;
11698                 if (decl && DECL_NAME (decl))
11699                   {
11700                     if (template_class_depth (current_class_type) == 0)
11701                       {
11702                         decl
11703                           = check_explicit_specialization
11704                           (declarator, decl,
11705                            template_count, 2 * (funcdef_flag != 0) + 4);
11706                         if (decl == error_mark_node)
11707                           return error_mark_node;
11708                       }
11709
11710                     t = do_friend (ctype, declarator, decl,
11711                                    last_function_parms, *attrlist,
11712                                    flags, quals, funcdef_flag);
11713                   }
11714                 if (t && funcdef_flag)
11715                   return t;
11716
11717                 return void_type_node;
11718               }
11719           }
11720
11721         /* Structure field.  It may not be a function, except for C++ */
11722
11723         if (decl == NULL_TREE)
11724           {
11725             if (initialized)
11726               {
11727                 if (!staticp)
11728                   {
11729                     /* An attempt is being made to initialize a non-static
11730                        member.  But, from [class.mem]:
11731
11732                        4 A member-declarator can contain a
11733                        constant-initializer only if it declares a static
11734                        member (_class.static_) of integral or enumeration
11735                        type, see _class.static.data_.
11736
11737                        This used to be relatively common practice, but
11738                        the rest of the compiler does not correctly
11739                        handle the initialization unless the member is
11740                        static so we make it static below.  */
11741                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11742                                 declarator);
11743                     pedwarn ("making `%D' static", declarator);
11744                     staticp = 1;
11745                   }
11746
11747                 if (uses_template_parms (type))
11748                   /* We'll check at instantiation time.  */
11749                   ;
11750                 else if (check_static_variable_definition (declarator,
11751                                                            type))
11752                   /* If we just return the declaration, crashes
11753                      will sometimes occur.  We therefore return
11754                      void_type_node, as if this was a friend
11755                      declaration, to cause callers to completely
11756                      ignore this declaration.  */
11757                   return void_type_node;
11758               }
11759
11760             /* 9.2p13 [class.mem] */
11761             if (declarator == constructor_name (current_class_type)
11762                 /* The standard does not allow non-static data members
11763                    here either, but we agreed at the 10/99 meeting
11764                    to change that in TC 1 so that they are allowed in
11765                    classes with no user-defined constructors.  */
11766                 && staticp)
11767               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11768                           declarator);
11769
11770             if (staticp)
11771               {
11772                 /* C++ allows static class members.  All other work
11773                    for this is done by grokfield.  */
11774                 decl = build_lang_decl (VAR_DECL, declarator, type);
11775                 TREE_STATIC (decl) = 1;
11776                 /* In class context, 'static' means public access.  */
11777                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11778               }
11779             else
11780               {
11781                 decl = build_decl (FIELD_DECL, declarator, type);
11782                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11783                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11784                   {
11785                     DECL_MUTABLE_P (decl) = 1;
11786                     RIDBIT_RESET (RID_MUTABLE, specbits);
11787                   }
11788               }
11789
11790             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11791                             inlinep, friendp, raises != NULL_TREE);
11792           }
11793       }
11794     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11795       {
11796         tree original_name;
11797         int publicp = 0;
11798
11799         if (! declarator)
11800           return NULL_TREE;
11801
11802         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11803           original_name = dname;
11804         else
11805           original_name = declarator;
11806
11807         if (RIDBIT_SETP (RID_AUTO, specbits))
11808           error ("storage class `auto' invalid for function `%s'", name);
11809         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11810           error ("storage class `register' invalid for function `%s'", name);
11811
11812         /* Function declaration not at top level.
11813            Storage classes other than `extern' are not allowed
11814            and `extern' makes no difference.  */
11815         if (! toplevel_bindings_p ()
11816             && (RIDBIT_SETP (RID_STATIC, specbits)
11817                 || RIDBIT_SETP (RID_INLINE, specbits))
11818             && pedantic)
11819           {
11820             if (RIDBIT_SETP (RID_STATIC, specbits))
11821               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11822             else
11823               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11824           }
11825
11826         if (ctype == NULL_TREE)
11827           {
11828             if (virtualp)
11829               {
11830                 error ("virtual non-class function `%s'", name);
11831                 virtualp = 0;
11832               }
11833           }
11834         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11835           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11836                                           TYPE_ARG_TYPES (type));
11837
11838         /* Record presence of `static'.  */
11839         publicp = (ctype != NULL_TREE
11840                    || RIDBIT_SETP (RID_EXTERN, specbits)
11841                    || !RIDBIT_SETP (RID_STATIC, specbits));
11842
11843         decl = grokfndecl (ctype, type, original_name, declarator,
11844                            virtualp, flags, quals, raises,
11845                            1, friendp,
11846                            publicp, inlinep, funcdef_flag,
11847                            template_count, in_namespace);
11848         if (decl == NULL_TREE)
11849           return NULL_TREE;
11850
11851         if (staticp == 1)
11852           {
11853             int illegal_static = 0;
11854
11855             /* Don't allow a static member function in a class, and forbid
11856                declaring main to be static.  */
11857             if (TREE_CODE (type) == METHOD_TYPE)
11858               {
11859                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11860                 illegal_static = 1;
11861               }
11862             else if (current_function_decl)
11863               {
11864                 /* FIXME need arm citation */
11865                 error ("cannot declare static function inside another function");
11866                 illegal_static = 1;
11867               }
11868
11869             if (illegal_static)
11870               {
11871                 staticp = 0;
11872                 RIDBIT_RESET (RID_STATIC, specbits);
11873               }
11874           }
11875       }
11876     else
11877       {
11878         /* It's a variable.  */
11879
11880         /* An uninitialized decl with `extern' is a reference.  */
11881         decl = grokvardecl (type, declarator, &specbits,
11882                             initialized,
11883                             (type_quals & TYPE_QUAL_CONST) != 0,
11884                             in_namespace);
11885         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11886                         inlinep, friendp, raises != NULL_TREE);
11887
11888         if (ctype)
11889           {
11890             DECL_CONTEXT (decl) = ctype;
11891             if (staticp == 1)
11892               {
11893                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11894                 staticp = 0;
11895                 RIDBIT_RESET (RID_STATIC, specbits);
11896               }
11897             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11898               {
11899                 error ("static member `%D' declared `register'", decl);
11900                 RIDBIT_RESET (RID_REGISTER, specbits);
11901               }
11902             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11903               {
11904                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11905                             decl);
11906                 RIDBIT_RESET (RID_EXTERN, specbits);
11907               }
11908           }
11909       }
11910
11911     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11912
11913     /* Record `register' declaration for warnings on &
11914        and in case doing stupid register allocation.  */
11915
11916     if (RIDBIT_SETP (RID_REGISTER, specbits))
11917       DECL_REGISTER (decl) = 1;
11918
11919     if (RIDBIT_SETP (RID_EXTERN, specbits))
11920       DECL_THIS_EXTERN (decl) = 1;
11921
11922     if (RIDBIT_SETP (RID_STATIC, specbits))
11923       DECL_THIS_STATIC (decl) = 1;
11924
11925     /* Record constancy and volatility.  There's no need to do this
11926        when processing a template; we'll do this for the instantiated
11927        declaration based on the type of DECL.  */
11928     if (!processing_template_decl)
11929       c_apply_type_quals_to_decl (type_quals, decl);
11930
11931     return decl;
11932   }
11933 }
11934 \f
11935 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11936    An empty exprlist is a parmlist.  An exprlist which
11937    contains only identifiers at the global level
11938    is a parmlist.  Otherwise, it is an exprlist.  */
11939
11940 int
11941 parmlist_is_exprlist (exprs)
11942      tree exprs;
11943 {
11944   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11945     return 0;
11946
11947   if (toplevel_bindings_p ())
11948     {
11949       /* At the global level, if these are all identifiers,
11950          then it is a parmlist.  */
11951       while (exprs)
11952         {
11953           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11954             return 1;
11955           exprs = TREE_CHAIN (exprs);
11956         }
11957       return 0;
11958     }
11959   return 1;
11960 }
11961
11962 /* Subroutine of start_function.  Ensure that each of the parameter
11963    types (as listed in PARMS) is complete, as is required for a
11964    function definition.  */
11965
11966 static void
11967 require_complete_types_for_parms (parms)
11968      tree parms;
11969 {
11970   for (; parms; parms = TREE_CHAIN (parms))
11971     {
11972       if (VOID_TYPE_P (TREE_TYPE (parms)))
11973         /* grokparms will have already issued an error */
11974         TREE_TYPE (parms) = error_mark_node;
11975       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11976         layout_decl (parms, 0);
11977       else
11978         TREE_TYPE (parms) = error_mark_node;
11979     }
11980 }
11981
11982 /* Returns non-zero if T is a local variable.  */
11983
11984 int
11985 local_variable_p (t)
11986      tree t;
11987 {
11988   if ((TREE_CODE (t) == VAR_DECL
11989        /* A VAR_DECL with a context that is a _TYPE is a static data
11990           member.  */
11991        && !TYPE_P (CP_DECL_CONTEXT (t))
11992        /* Any other non-local variable must be at namespace scope.  */
11993        && !DECL_NAMESPACE_SCOPE_P (t))
11994       || (TREE_CODE (t) == PARM_DECL))
11995     return 1;
11996
11997   return 0;
11998 }
11999
12000 /* Returns non-zero if T is an automatic local variable or a label.
12001    (These are the declarations that need to be remapped when the code
12002    containing them is duplicated.)  */
12003
12004 int
12005 nonstatic_local_decl_p (t)
12006      tree t;
12007 {
12008   return ((local_variable_p (t) && !TREE_STATIC (t))
12009           || TREE_CODE (t) == LABEL_DECL
12010           || TREE_CODE (t) == RESULT_DECL);
12011 }
12012
12013 /* Like local_variable_p, but suitable for use as a tree-walking
12014    function.  */
12015
12016 static tree
12017 local_variable_p_walkfn (tp, walk_subtrees, data)
12018      tree *tp;
12019      int *walk_subtrees ATTRIBUTE_UNUSED;
12020      void *data ATTRIBUTE_UNUSED;
12021 {
12022   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
12023           ? *tp : NULL_TREE);
12024 }
12025
12026 /* Check that ARG, which is a default-argument expression for a
12027    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
12028    something goes wrong.  DECL may also be a _TYPE node, rather than a
12029    DECL, if there is no DECL available.  */
12030
12031 tree
12032 check_default_argument (decl, arg)
12033      tree decl;
12034      tree arg;
12035 {
12036   tree var;
12037   tree decl_type;
12038
12039   if (TREE_CODE (arg) == DEFAULT_ARG)
12040     /* We get a DEFAULT_ARG when looking at an in-class declaration
12041        with a default argument.  Ignore the argument for now; we'll
12042        deal with it after the class is complete.  */
12043     return arg;
12044
12045   if (processing_template_decl || uses_template_parms (arg))
12046     /* We don't do anything checking until instantiation-time.  Note
12047        that there may be uninstantiated arguments even for an
12048        instantiated function, since default arguments are not
12049        instantiated until they are needed.  */
12050     return arg;
12051
12052   if (TYPE_P (decl))
12053     {
12054       decl_type = decl;
12055       decl = NULL_TREE;
12056     }
12057   else
12058     decl_type = TREE_TYPE (decl);
12059
12060   if (arg == error_mark_node
12061       || decl == error_mark_node
12062       || TREE_TYPE (arg) == error_mark_node
12063       || decl_type == error_mark_node)
12064     /* Something already went wrong.  There's no need to check
12065        further.  */
12066     return error_mark_node;
12067
12068   /* [dcl.fct.default]
12069
12070      A default argument expression is implicitly converted to the
12071      parameter type.  */
12072   if (!TREE_TYPE (arg)
12073       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12074     {
12075       if (decl)
12076         error ("default argument for `%#D' has type `%T'",
12077                   decl, TREE_TYPE (arg));
12078       else
12079         error ("default argument for parameter of type `%T' has type `%T'",
12080                   decl_type, TREE_TYPE (arg));
12081
12082       return error_mark_node;
12083     }
12084
12085   /* [dcl.fct.default]
12086
12087      Local variables shall not be used in default argument
12088      expressions.
12089
12090      The keyword `this' shall not be used in a default argument of a
12091      member function.  */
12092   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12093                                       NULL);
12094   if (var)
12095     {
12096       error ("default argument `%E' uses local variable `%D'",
12097                 arg, var);
12098       return error_mark_node;
12099     }
12100
12101   /* All is well.  */
12102   return arg;
12103 }
12104
12105 /* Decode the list of parameter types for a function type.
12106    Given the list of things declared inside the parens,
12107    return a list of types.
12108
12109    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
12110    flag. If unset, we append void_list_node. A parmlist declared
12111    as `(void)' is accepted as the empty parmlist.
12112
12113    Also set last_function_parms to the chain of PARM_DECLs.  */
12114
12115 static tree
12116 grokparms (first_parm)
12117      tree first_parm;
12118 {
12119   tree result = NULL_TREE;
12120   tree decls = NULL_TREE;
12121   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12122   tree parm, chain;
12123   int any_error = 0;
12124
12125   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12126
12127   for (parm = first_parm; parm != NULL_TREE; parm = chain)
12128     {
12129       tree type = NULL_TREE;
12130       tree decl = TREE_VALUE (parm);
12131       tree init = TREE_PURPOSE (parm);
12132       tree specs, attrs;
12133
12134       chain = TREE_CHAIN (parm);
12135       /* @@ weak defense against parse errors.  */
12136       if (TREE_CODE (decl) != VOID_TYPE
12137           && TREE_CODE (decl) != TREE_LIST)
12138         {
12139           /* Give various messages as the need arises.  */
12140           if (TREE_CODE (decl) == STRING_CST)
12141             error ("invalid string constant `%E'", decl);
12142           else if (TREE_CODE (decl) == INTEGER_CST)
12143             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12144           continue;
12145         }
12146
12147       if (parm == void_list_node)
12148         break;
12149
12150       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12151       decl = grokdeclarator (TREE_VALUE (decl), specs,
12152                              PARM, init != NULL_TREE, &attrs);
12153       if (! decl || TREE_TYPE (decl) == error_mark_node)
12154         continue;
12155
12156       if (attrs)
12157         cplus_decl_attributes (&decl, attrs, 0);
12158
12159       type = TREE_TYPE (decl);
12160       if (VOID_TYPE_P (type))
12161         {
12162           if (same_type_p (type, void_type_node)
12163               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12164             /* this is a parmlist of `(void)', which is ok.  */
12165             break;
12166           incomplete_type_error (decl, type);
12167           /* It's not a good idea to actually create parameters of
12168              type `void'; other parts of the compiler assume that a
12169              void type terminates the parameter list.  */
12170           type = error_mark_node;
12171           TREE_TYPE (decl) = error_mark_node;
12172         }
12173
12174       if (type != error_mark_node)
12175         {
12176           /* Top-level qualifiers on the parameters are
12177              ignored for function types.  */
12178           type = TYPE_MAIN_VARIANT (type);
12179           if (TREE_CODE (type) == METHOD_TYPE)
12180             {
12181               error ("parameter `%D' invalidly declared method type", decl);
12182               type = build_pointer_type (type);
12183               TREE_TYPE (decl) = type;
12184             }
12185           else if (TREE_CODE (type) == OFFSET_TYPE)
12186             {
12187               error ("parameter `%D' invalidly declared offset type", decl);
12188               type = build_pointer_type (type);
12189               TREE_TYPE (decl) = type;
12190             }
12191           else if (abstract_virtuals_error (decl, type))
12192             any_error = 1;  /* Seems like a good idea. */
12193           else if (POINTER_TYPE_P (type))
12194             {
12195               /* [dcl.fct]/6, parameter types cannot contain pointers
12196                  (references) to arrays of unknown bound.  */
12197               tree t = TREE_TYPE (type);
12198               int ptr = TYPE_PTR_P (type);
12199
12200               while (1)
12201                 {
12202                   if (TYPE_PTR_P (t))
12203                     ptr = 1;
12204                   else if (TREE_CODE (t) != ARRAY_TYPE)
12205                     break;
12206                   else if (!TYPE_DOMAIN (t))
12207                     break;
12208                   t = TREE_TYPE (t);
12209                 }
12210               if (TREE_CODE (t) == ARRAY_TYPE)
12211                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12212                           decl, ptr ? "pointer" : "reference", t);
12213             }
12214
12215           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12216           if (PROMOTE_PROTOTYPES
12217               && INTEGRAL_TYPE_P (type)
12218               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12219             DECL_ARG_TYPE (decl) = integer_type_node;
12220           if (!any_error && init)
12221             init = check_default_argument (decl, init);
12222           else
12223             init = NULL_TREE;
12224         }
12225
12226       TREE_CHAIN (decl) = decls;
12227       decls = decl;
12228       result = tree_cons (init, type, result);
12229     }
12230   decls = nreverse (decls);
12231   result = nreverse (result);
12232   if (!ellipsis)
12233     result = chainon (result, void_list_node);
12234   last_function_parms = decls;
12235
12236   return result;
12237 }
12238
12239 \f
12240 /* D is a constructor or overloaded `operator='.
12241
12242    Let T be the class in which D is declared. Then, this function
12243    returns:
12244
12245    -1 if D's is an ill-formed constructor or copy assignment operator
12246       whose first parameter is of type `T'.
12247    0  if D is not a copy constructor or copy assignment
12248       operator.
12249    1  if D is a copy constructor or copy assignment operator whose
12250       first parameter is a reference to const qualified T.
12251    2  if D is a copy constructor or copy assignment operator whose
12252       first parameter is a reference to non-const qualified T.
12253
12254    This function can be used as a predicate. Positive values indicate
12255    a copy constructor and non-zero values indicate a copy assignment
12256    operator.  */
12257
12258 int
12259 copy_fn_p (d)
12260      tree d;
12261 {
12262   tree args;
12263   tree arg_type;
12264   int result = 1;
12265
12266   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12267
12268   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12269     /* Instantiations of template member functions are never copy
12270        functions.  Note that member functions of templated classes are
12271        represented as template functions internally, and we must
12272        accept those as copy functions.  */
12273     return 0;
12274
12275   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12276   if (!args)
12277     return 0;
12278
12279   arg_type = TREE_VALUE (args);
12280
12281   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12282     {
12283       /* Pass by value copy assignment operator.  */
12284       result = -1;
12285     }
12286   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12287            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12288     {
12289       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12290         result = 2;
12291     }
12292   else
12293     return 0;
12294
12295   args = TREE_CHAIN (args);
12296
12297   if (args && args != void_list_node && !TREE_PURPOSE (args))
12298     /* There are more non-optional args.  */
12299     return 0;
12300
12301   return result;
12302 }
12303
12304 /* Remember any special properties of member function DECL.  */
12305
12306 void grok_special_member_properties (decl)
12307      tree decl;
12308 {
12309   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12310     ; /* Not special.  */
12311   else if (DECL_CONSTRUCTOR_P (decl))
12312     {
12313       int ctor = copy_fn_p (decl);
12314
12315       if (ctor > 0)
12316         {
12317           /* [class.copy]
12318
12319              A non-template constructor for class X is a copy
12320              constructor if its first parameter is of type X&, const
12321              X&, volatile X& or const volatile X&, and either there
12322              are no other parameters or else all other parameters have
12323              default arguments.  */
12324           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12325           if (ctor > 1)
12326             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12327         }
12328       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12329         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12330     }
12331   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12332     {
12333       /* [class.copy]
12334
12335          A non-template assignment operator for class X is a copy
12336          assignment operator if its parameter is of type X, X&, const
12337          X&, volatile X& or const volatile X&.  */
12338
12339       int assop = copy_fn_p (decl);
12340
12341       if (assop)
12342         {
12343           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12344           if (assop != 1)
12345             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12346           if (DECL_PURE_VIRTUAL_P (decl))
12347             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12348         }
12349     }
12350 }
12351
12352 /* Check a constructor DECL has the correct form.  Complains
12353    if the class has a constructor of the form X(X).  */
12354
12355 int
12356 grok_ctor_properties (ctype, decl)
12357      tree ctype, decl;
12358 {
12359   int ctor_parm = copy_fn_p (decl);
12360
12361   if (ctor_parm < 0)
12362     {
12363       /* [class.copy]
12364
12365          A declaration of a constructor for a class X is ill-formed if
12366          its first parameter is of type (optionally cv-qualified) X
12367          and either there are no other parameters or else all other
12368          parameters have default arguments.
12369
12370          We *don't* complain about member template instantiations that
12371          have this form, though; they can occur as we try to decide
12372          what constructor to use during overload resolution.  Since
12373          overload resolution will never prefer such a constructor to
12374          the non-template copy constructor (which is either explicitly
12375          or implicitly defined), there's no need to worry about their
12376          existence.  Theoretically, they should never even be
12377          instantiated, but that's hard to forestall.  */
12378       error ("invalid constructor; you probably meant `%T (const %T&)'",
12379                 ctype, ctype);
12380       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12381       return 0;
12382     }
12383
12384   return 1;
12385 }
12386
12387 /* An operator with this code is unary, but can also be binary.  */
12388
12389 static int
12390 ambi_op_p (code)
12391      enum tree_code code;
12392 {
12393   return (code == INDIRECT_REF
12394           || code == ADDR_EXPR
12395           || code == CONVERT_EXPR
12396           || code == NEGATE_EXPR
12397           || code == PREINCREMENT_EXPR
12398           || code == PREDECREMENT_EXPR);
12399 }
12400
12401 /* An operator with this name can only be unary.  */
12402
12403 static int
12404 unary_op_p (code)
12405      enum tree_code code;
12406 {
12407   return (code == TRUTH_NOT_EXPR
12408           || code == BIT_NOT_EXPR
12409           || code == COMPONENT_REF
12410           || code == TYPE_EXPR);
12411 }
12412
12413 /* Do a little sanity-checking on how they declared their operator.  */
12414
12415 void
12416 grok_op_properties (decl, friendp)
12417      tree decl;
12418      int friendp;
12419 {
12420   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12421   tree argtype;
12422   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12423   tree name = DECL_NAME (decl);
12424   enum tree_code operator_code;
12425   int arity;
12426
12427   /* Count the number of arguments.  */
12428   for (argtype = argtypes, arity = 0;
12429        argtype && argtype != void_list_node;
12430        argtype = TREE_CHAIN (argtype))
12431     ++arity;
12432
12433   if (current_class_type == NULL_TREE)
12434     friendp = 1;
12435
12436   if (DECL_CONV_FN_P (decl))
12437     operator_code = TYPE_EXPR;
12438   else
12439     do
12440       {
12441 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12442         if (ansi_opname (CODE) == name)                         \
12443           {                                                     \
12444             operator_code = (CODE);                             \
12445             break;                                              \
12446           }                                                     \
12447         else if (ansi_assopname (CODE) == name)                 \
12448           {                                                     \
12449             operator_code = (CODE);                             \
12450             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12451             break;                                              \
12452           }
12453
12454 #include "operators.def"
12455 #undef DEF_OPERATOR
12456
12457         abort ();
12458       }
12459     while (0);
12460   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12461   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12462
12463   if (! friendp)
12464     {
12465       switch (operator_code)
12466         {
12467         case CALL_EXPR:
12468           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12469           break;
12470
12471         case ARRAY_REF:
12472           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12473           break;
12474
12475         case COMPONENT_REF:
12476         case MEMBER_REF:
12477           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12478           break;
12479
12480         case NEW_EXPR:
12481           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12482           break;
12483
12484         case DELETE_EXPR:
12485           TYPE_GETS_DELETE (current_class_type) |= 1;
12486           break;
12487
12488         case VEC_NEW_EXPR:
12489           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12490           break;
12491
12492         case VEC_DELETE_EXPR:
12493           TYPE_GETS_DELETE (current_class_type) |= 2;
12494           break;
12495
12496         default:
12497           break;
12498         }
12499     }
12500
12501   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12502     {
12503       /* When the compiler encounters the definition of A::operator new, it
12504          doesn't look at the class declaration to find out if it's static.  */
12505       if (methodp)
12506         revert_static_member_fn (decl);
12507
12508       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12509     }
12510   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12511     {
12512       if (methodp)
12513         revert_static_member_fn (decl);
12514
12515       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12516     }
12517   else
12518     {
12519       /* An operator function must either be a non-static member function
12520          or have at least one parameter of a class, a reference to a class,
12521          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12522       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12523         {
12524           if (operator_code == TYPE_EXPR
12525               || operator_code == CALL_EXPR
12526               || operator_code == COMPONENT_REF
12527               || operator_code == ARRAY_REF
12528               || operator_code == NOP_EXPR)
12529             error ("`%D' must be a nonstatic member function", decl);
12530           else
12531             {
12532               tree p = argtypes;
12533
12534               if (DECL_STATIC_FUNCTION_P (decl))
12535                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12536
12537               if (p)
12538                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12539                   {
12540                     tree arg = TREE_VALUE (p);
12541                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12542                       arg = TREE_TYPE (arg);
12543
12544                     /* This lets bad template code slip through.  */
12545                     if (IS_AGGR_TYPE (arg)
12546                         || TREE_CODE (arg) == ENUMERAL_TYPE
12547                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12548                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12549                       goto foundaggr;
12550                   }
12551               error
12552                 ("`%D' must have an argument of class or enumerated type",
12553                  decl);
12554             foundaggr:
12555               ;
12556             }
12557         }
12558
12559       if (operator_code == CALL_EXPR)
12560         return;                 /* No restrictions on args. */
12561
12562       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12563         {
12564           tree t = TREE_TYPE (name);
12565           if (! friendp)
12566             {
12567               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12568               const char *what = 0;
12569
12570               if (ref)
12571                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12572
12573               if (TREE_CODE (t) == VOID_TYPE)
12574                 what = "void";
12575               else if (t == current_class_type)
12576                 what = "the same type";
12577               /* Don't force t to be complete here.  */
12578               else if (IS_AGGR_TYPE (t)
12579                        && COMPLETE_TYPE_P (t)
12580                        && DERIVED_FROM_P (t, current_class_type))
12581                 what = "a base class";
12582
12583               if (what)
12584                 warning ("conversion to %s%s will never use a type conversion operator",
12585                          ref ? "a reference to " : "", what);
12586             }
12587         }
12588       if (operator_code == COND_EXPR)
12589         {
12590           /* 13.4.0.3 */
12591           error ("ISO C++ prohibits overloading operator ?:");
12592         }
12593       else if (ambi_op_p (operator_code))
12594         {
12595           if (arity == 1)
12596             /* We pick the one-argument operator codes by default, so
12597                we don't have to change anything.  */
12598             ;
12599           else if (arity == 2)
12600             {
12601               /* If we thought this was a unary operator, we now know
12602                  it to be a binary operator.  */
12603               switch (operator_code)
12604                 {
12605                 case INDIRECT_REF:
12606                   operator_code = MULT_EXPR;
12607                   break;
12608
12609                 case ADDR_EXPR:
12610                   operator_code = BIT_AND_EXPR;
12611                   break;
12612
12613                 case CONVERT_EXPR:
12614                   operator_code = PLUS_EXPR;
12615                   break;
12616
12617                 case NEGATE_EXPR:
12618                   operator_code = MINUS_EXPR;
12619                   break;
12620
12621                 case PREINCREMENT_EXPR:
12622                   operator_code = POSTINCREMENT_EXPR;
12623                   break;
12624
12625                 case PREDECREMENT_EXPR:
12626                   operator_code = POSTDECREMENT_EXPR;
12627                   break;
12628
12629                 default:
12630                   abort ();
12631                 }
12632
12633               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12634
12635               if ((operator_code == POSTINCREMENT_EXPR
12636                    || operator_code == POSTDECREMENT_EXPR)
12637                   && ! processing_template_decl
12638                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12639                 {
12640                   if (methodp)
12641                     error ("postfix `%D' must take `int' as its argument",
12642                               decl);
12643                   else
12644                     error
12645                       ("postfix `%D' must take `int' as its second argument",
12646                        decl);
12647                 }
12648             }
12649           else
12650             {
12651               if (methodp)
12652                 error ("`%D' must take either zero or one argument", decl);
12653               else
12654                 error ("`%D' must take either one or two arguments", decl);
12655             }
12656
12657           /* More Effective C++ rule 6.  */
12658           if (warn_ecpp
12659               && (operator_code == POSTINCREMENT_EXPR
12660                   || operator_code == POSTDECREMENT_EXPR
12661                   || operator_code == PREINCREMENT_EXPR
12662                   || operator_code == PREDECREMENT_EXPR))
12663             {
12664               tree arg = TREE_VALUE (argtypes);
12665               tree ret = TREE_TYPE (TREE_TYPE (decl));
12666               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12667                 arg = TREE_TYPE (arg);
12668               arg = TYPE_MAIN_VARIANT (arg);
12669               if (operator_code == PREINCREMENT_EXPR
12670                   || operator_code == PREDECREMENT_EXPR)
12671                 {
12672                   if (TREE_CODE (ret) != REFERENCE_TYPE
12673                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12674                                        arg))
12675                     warning ("prefix `%D' should return `%T'", decl,
12676                                 build_reference_type (arg));
12677                 }
12678               else
12679                 {
12680                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12681                     warning ("postfix `%D' should return `%T'", decl, arg);
12682                 }
12683             }
12684         }
12685       else if (unary_op_p (operator_code))
12686         {
12687           if (arity != 1)
12688             {
12689               if (methodp)
12690                 error ("`%D' must take `void'", decl);
12691               else
12692                 error ("`%D' must take exactly one argument", decl);
12693             }
12694         }
12695       else /* if (binary_op_p (operator_code)) */
12696         {
12697           if (arity != 2)
12698             {
12699               if (methodp)
12700                 error ("`%D' must take exactly one argument", decl);
12701               else
12702                 error ("`%D' must take exactly two arguments", decl);
12703             }
12704
12705           /* More Effective C++ rule 7.  */
12706           if (warn_ecpp
12707               && (operator_code == TRUTH_ANDIF_EXPR
12708                   || operator_code == TRUTH_ORIF_EXPR
12709                   || operator_code == COMPOUND_EXPR))
12710             warning ("user-defined `%D' always evaluates both arguments",
12711                         decl);
12712         }
12713
12714       /* Effective C++ rule 23.  */
12715       if (warn_ecpp
12716           && arity == 2
12717           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12718           && (operator_code == PLUS_EXPR
12719               || operator_code == MINUS_EXPR
12720               || operator_code == TRUNC_DIV_EXPR
12721               || operator_code == MULT_EXPR
12722               || operator_code == TRUNC_MOD_EXPR)
12723           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12724         warning ("`%D' should return by value", decl);
12725
12726       /* [over.oper]/8 */
12727       for (; argtypes && argtypes != void_list_node;
12728           argtypes = TREE_CHAIN (argtypes))
12729         if (TREE_PURPOSE (argtypes))
12730           {
12731             TREE_PURPOSE (argtypes) = NULL_TREE;
12732             if (operator_code == POSTINCREMENT_EXPR
12733                 || operator_code == POSTDECREMENT_EXPR)
12734               {
12735                 if (pedantic)
12736                   pedwarn ("`%D' cannot have default arguments", decl);
12737               }
12738             else
12739               error ("`%D' cannot have default arguments", decl);
12740           }
12741
12742     }
12743 }
12744 \f
12745 static const char *
12746 tag_name (code)
12747      enum tag_types code;
12748 {
12749   switch (code)
12750     {
12751     case record_type:
12752       return "struct";
12753     case class_type:
12754       return "class";
12755     case union_type:
12756       return "union ";
12757     case enum_type:
12758       return "enum";
12759     default:
12760       abort ();
12761     }
12762 }
12763
12764 /* Get the struct, enum or union (CODE says which) with tag NAME.
12765    Define the tag as a forward-reference if it is not defined.
12766
12767    C++: If a class derivation is given, process it here, and report
12768    an error if multiple derivation declarations are not identical.
12769
12770    If this is a definition, come in through xref_tag and only look in
12771    the current frame for the name (since C++ allows new names in any
12772    scope.)  */
12773
12774 tree
12775 xref_tag (code_type_node, name, globalize)
12776      tree code_type_node;
12777      tree name;
12778      int globalize;
12779 {
12780   enum tag_types tag_code;
12781   enum tree_code code;
12782   register tree ref, t;
12783   struct binding_level *b = current_binding_level;
12784   tree attributes = NULL_TREE;
12785   tree context = NULL_TREE;
12786
12787   /* If we are called from the parser, code_type_node will sometimes be a
12788      TREE_LIST.  This indicates that the user wrote
12789      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12790      use them later.  */
12791   if (TREE_CODE (code_type_node) == TREE_LIST)
12792     {
12793       attributes = TREE_PURPOSE (code_type_node);
12794       code_type_node = TREE_VALUE (code_type_node);
12795     }
12796
12797   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12798   switch (tag_code)
12799     {
12800     case record_type:
12801     case class_type:
12802       code = RECORD_TYPE;
12803       break;
12804     case union_type:
12805       code = UNION_TYPE;
12806       break;
12807     case enum_type:
12808       code = ENUMERAL_TYPE;
12809       break;
12810     default:
12811       abort ();
12812     }
12813
12814   /* If a cross reference is requested, look up the type
12815      already defined for this tag and return it.  */
12816   if (TYPE_P (name))
12817     {
12818       t = name;
12819       name = TYPE_IDENTIFIER (t);
12820     }
12821   else
12822     t = IDENTIFIER_TYPE_VALUE (name);
12823
12824   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12825   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12826     {
12827       static int explained;
12828       tree shadowed;
12829
12830       warning ("`%s %T' declares a new type at namespace scope",
12831                   tag_name (tag_code), name);
12832       if (!explained++)
12833         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12834                     tag_name (tag_code),
12835                     constructor_name (current_class_type),
12836                     TYPE_IDENTIFIER (t));
12837
12838       /* We need to remove the class scope binding for the
12839          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12840       for (shadowed = b->class_shadowed;
12841            shadowed;
12842            shadowed = TREE_CHAIN (shadowed))
12843         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12844           {
12845             TREE_PURPOSE (shadowed) = NULL_TREE;
12846             break;
12847           }
12848     }
12849
12850   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12851       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12852     t = NULL_TREE;
12853
12854   if (! globalize)
12855     {
12856       /* If we know we are defining this tag, only look it up in
12857          this scope and don't try to find it as a type.  */
12858       ref = lookup_tag (code, name, b, 1);
12859     }
12860   else
12861     {
12862       if (t)
12863         {
12864           ref = follow_tag_typedef (t);
12865
12866           /* [dcl.type.elab] If the identifier resolves to a
12867              typedef-name or a template type-parameter, the
12868              elaborated-type-specifier is ill-formed.  */
12869           if (!ref)
12870             {
12871               pedwarn ("using typedef-name `%D' after `%s'",
12872                        TYPE_NAME (t), tag_name (tag_code));
12873               ref = t;
12874             }
12875           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12876             error ("using template type parameter `%T' after `%s'",
12877                    t, tag_name (tag_code));
12878         }
12879       else
12880         ref = lookup_tag (code, name, b, 0);
12881
12882       if (! ref)
12883         {
12884           /* Try finding it as a type declaration.  If that wins,
12885              use it.  */
12886           ref = lookup_name (name, 1);
12887
12888           if (ref != NULL_TREE
12889               && processing_template_decl
12890               && DECL_CLASS_TEMPLATE_P (ref)
12891               && template_class_depth (current_class_type) == 0)
12892             /* Since GLOBALIZE is true, we're declaring a global
12893                template, so we want this type.  */
12894             ref = DECL_TEMPLATE_RESULT (ref);
12895
12896           if (ref && TREE_CODE (ref) == TYPE_DECL
12897               && TREE_CODE (TREE_TYPE (ref)) == code)
12898             ref = TREE_TYPE (ref);
12899           else
12900             ref = NULL_TREE;
12901         }
12902
12903       if (ref && current_class_type
12904           && template_class_depth (current_class_type)
12905           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12906         {
12907           /* Since GLOBALIZE is non-zero, we are not looking at a
12908              definition of this tag.  Since, in addition, we are currently
12909              processing a (member) template declaration of a template
12910              class, we must be very careful; consider:
12911
12912                template <class X>
12913                struct S1
12914
12915                template <class U>
12916                struct S2
12917                { template <class V>
12918                friend struct S1; };
12919
12920              Here, the S2::S1 declaration should not be confused with the
12921              outer declaration.  In particular, the inner version should
12922              have a template parameter of level 2, not level 1.  This
12923              would be particularly important if the member declaration
12924              were instead:
12925
12926                template <class V = U> friend struct S1;
12927
12928              say, when we should tsubst into `U' when instantiating
12929              S2.  On the other hand, when presented with:
12930
12931                  template <class T>
12932                  struct S1 {
12933                    template <class U>
12934                    struct S2 {};
12935                    template <class U>
12936                    friend struct S2;
12937                  };
12938
12939               we must find the inner binding eventually.  We
12940               accomplish this by making sure that the new type we
12941               create to represent this declaration has the right
12942               TYPE_CONTEXT.  */
12943           context = TYPE_CONTEXT (ref);
12944           ref = NULL_TREE;
12945         }
12946     }
12947
12948   if (! ref)
12949     {
12950       /* If no such tag is yet defined, create a forward-reference node
12951          and record it as the "definition".
12952          When a real declaration of this type is found,
12953          the forward-reference will be altered into a real type.  */
12954       if (code == ENUMERAL_TYPE)
12955         {
12956           error ("use of enum `%#D' without previous declaration", name);
12957
12958           ref = make_node (ENUMERAL_TYPE);
12959
12960           /* Give the type a default layout like unsigned int
12961              to avoid crashing if it does not get defined.  */
12962           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12963           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12964           TYPE_USER_ALIGN (ref) = 0;
12965           TREE_UNSIGNED (ref) = 1;
12966           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12967           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12968           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12969
12970           /* Enable us to recognize when a type is created in class context.
12971              To do nested classes correctly, this should probably be cleared
12972              out when we leave this classes scope.  Currently this in only
12973              done in `start_enum'.  */
12974
12975           pushtag (name, ref, globalize);
12976         }
12977       else
12978         {
12979           struct binding_level *old_b = class_binding_level;
12980
12981           ref = make_aggr_type (code);
12982           TYPE_CONTEXT (ref) = context;
12983
12984 #ifdef NONNESTED_CLASSES
12985           /* Class types don't nest the way enums do.  */
12986           class_binding_level = (struct binding_level *)0;
12987 #endif
12988           pushtag (name, ref, globalize);
12989           class_binding_level = old_b;
12990         }
12991     }
12992   else
12993     {
12994       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12995         redeclare_class_template (ref, current_template_parms);
12996     }
12997
12998   TYPE_ATTRIBUTES (ref) = attributes;
12999
13000   return ref;
13001 }
13002
13003 tree
13004 xref_tag_from_type (old, id, globalize)
13005      tree old, id;
13006      int globalize;
13007 {
13008   tree code_type_node;
13009
13010   if (TREE_CODE (old) == RECORD_TYPE)
13011     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
13012                       ? class_type_node : record_type_node);
13013   else
13014     code_type_node = union_type_node;
13015
13016   if (id == NULL_TREE)
13017     id = TYPE_IDENTIFIER (old);
13018
13019   return xref_tag (code_type_node, id, globalize);
13020 }
13021
13022 /* REF is a type (named NAME), for which we have just seen some
13023    baseclasses.  BINFO is a list of those baseclasses; the
13024    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13025    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13026    struct, or union.  */
13027
13028 void
13029 xref_basetypes (code_type_node, name, ref, binfo)
13030      tree code_type_node;
13031      tree name ATTRIBUTE_UNUSED;
13032      tree ref;
13033      tree binfo;
13034 {
13035   /* In the declaration `A : X, Y, ... Z' we mark all the types
13036      (A, X, Y, ..., Z) so we can check for duplicates.  */
13037   tree binfos;
13038   tree base;
13039
13040   int i, len;
13041   enum tag_types tag_code;
13042
13043   /* If we are called from the parser, code_type_node will sometimes be a
13044      TREE_LIST.  This indicates that the user wrote
13045      "class __attribute__ ((foo)) bar".  Extract the attributes so that
13046      tree_low_cst doesn't crash.  */
13047   if (TREE_CODE (code_type_node) == TREE_LIST)
13048     code_type_node = TREE_VALUE (code_type_node);
13049
13050   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
13051
13052   if (tag_code == union_type)
13053     {
13054       error ("derived union `%T' invalid", ref);
13055       return;
13056     }
13057
13058   len = list_length (binfo);
13059
13060   /* First, make sure that any templates in base-classes are
13061      instantiated.  This ensures that if we call ourselves recursively
13062      we do not get confused about which classes are marked and which
13063      are not.  */
13064   for (base = binfo; base; base = TREE_CHAIN (base))
13065     complete_type (TREE_VALUE (base));
13066
13067   SET_CLASSTYPE_MARKED (ref);
13068   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13069
13070   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13071     {
13072       /* The base of a derived struct is public by default.  */
13073       int via_public
13074         = (TREE_PURPOSE (binfo) == access_public_node
13075            || TREE_PURPOSE (binfo) == access_public_virtual_node
13076            || (tag_code != class_type
13077                && (TREE_PURPOSE (binfo) == access_default_node
13078                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13079       int via_protected
13080         = (TREE_PURPOSE (binfo) == access_protected_node
13081            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13082       int via_virtual
13083         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13084            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13085            || TREE_PURPOSE (binfo) == access_public_virtual_node
13086            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13087       tree basetype = TREE_VALUE (binfo);
13088       tree base_binfo;
13089
13090       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13091         basetype = TREE_TYPE (basetype);
13092       if (!basetype
13093           || (TREE_CODE (basetype) != RECORD_TYPE
13094               && TREE_CODE (basetype) != TYPENAME_TYPE
13095               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13096               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13097         {
13098           error ("base type `%T' fails to be a struct or class type",
13099                     TREE_VALUE (binfo));
13100           continue;
13101         }
13102
13103       /* This code replaces similar code in layout_basetypes.
13104          We put the complete_type first for implicit `typename'.  */
13105       if (!COMPLETE_TYPE_P (basetype)
13106           && ! (current_template_parms && uses_template_parms (basetype)))
13107         {
13108           error ("base class `%T' has incomplete type", basetype);
13109           continue;
13110         }
13111       else
13112         {
13113           if (CLASSTYPE_MARKED (basetype))
13114             {
13115               if (basetype == ref)
13116                 error ("recursive type `%T' undefined", basetype);
13117               else
13118                 error ("duplicate base type `%T' invalid", basetype);
13119               continue;
13120             }
13121
13122           if (TYPE_FOR_JAVA (basetype)
13123               && (current_lang_depth () == 0))
13124             TYPE_FOR_JAVA (ref) = 1;
13125
13126           /* Note that the BINFO records which describe individual
13127              inheritances are *not* shared in the lattice!  They
13128              cannot be shared because a given baseclass may be
13129              inherited with different `accessibility' by different
13130              derived classes.  (Each BINFO record describing an
13131              individual inheritance contains flags which say what
13132              the `accessibility' of that particular inheritance is.)  */
13133
13134           base_binfo
13135             = make_binfo (size_zero_node, basetype,
13136                           CLASS_TYPE_P (basetype)
13137                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13138                           CLASS_TYPE_P (basetype)
13139                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13140
13141           TREE_VEC_ELT (binfos, i) = base_binfo;
13142           TREE_VIA_PUBLIC (base_binfo) = via_public;
13143           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13144           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13145           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13146
13147           /* We need to unshare the binfos now so that lookups during class
13148              definition work.  */
13149           unshare_base_binfos (base_binfo);
13150
13151           SET_CLASSTYPE_MARKED (basetype);
13152
13153           /* We are free to modify these bits because they are meaningless
13154              at top level, and BASETYPE is a top-level type.  */
13155           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13156             {
13157               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13158               /* Converting to a virtual base class requires looking
13159                  up the offset of the virtual base.  */
13160               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13161             }
13162
13163           if (CLASS_TYPE_P (basetype))
13164             {
13165               TYPE_HAS_NEW_OPERATOR (ref)
13166                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13167               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13168                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13169               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13170               /* If the base-class uses multiple inheritance, so do we.  */
13171               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13172                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13173               /* Likewise, if converting to a base of the base may require
13174                  code, then we may need to generate code to convert to a
13175                  base as well.  */
13176               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13177                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13178             }
13179
13180           i += 1;
13181         }
13182     }
13183   if (i)
13184     TREE_VEC_LENGTH (binfos) = i;
13185   else
13186     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13187
13188   if (i > 1)
13189     {
13190       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13191       /* If there is more than one non-empty they cannot be at the same
13192          address.  */
13193       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13194     }
13195
13196   /* Unmark all the types.  */
13197   while (--i >= 0)
13198     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13199   CLEAR_CLASSTYPE_MARKED (ref);
13200
13201   /* Now that we know all the base-classes, set up the list of virtual
13202      bases.  */
13203   get_vbase_types (ref);
13204 }
13205
13206 \f
13207 /* Begin compiling the definition of an enumeration type.
13208    NAME is its name (or null if anonymous).
13209    Returns the type object, as yet incomplete.
13210    Also records info about it so that build_enumerator
13211    may be used to declare the individual values as they are read.  */
13212
13213 tree
13214 start_enum (name)
13215      tree name;
13216 {
13217   register tree enumtype = NULL_TREE;
13218   struct binding_level *b = current_binding_level;
13219
13220   /* If this is the real definition for a previous forward reference,
13221      fill in the contents in the same object that used to be the
13222      forward reference.  */
13223
13224   if (name != NULL_TREE)
13225     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13226
13227   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13228     {
13229       error ("multiple definition of `%#T'", enumtype);
13230       cp_error_at ("previous definition here", enumtype);
13231       /* Clear out TYPE_VALUES, and start again.  */
13232       TYPE_VALUES (enumtype) = NULL_TREE;
13233     }
13234   else
13235     {
13236       enumtype = make_node (ENUMERAL_TYPE);
13237       pushtag (name, enumtype, 0);
13238     }
13239
13240   return enumtype;
13241 }
13242
13243 /* After processing and defining all the values of an enumeration type,
13244    install their decls in the enumeration type and finish it off.
13245    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13246
13247 void
13248 finish_enum (enumtype)
13249      tree enumtype;
13250 {
13251   tree pair;
13252   tree minnode;
13253   tree maxnode;
13254   tree t;
13255   bool unsignedp;
13256   int lowprec;
13257   int highprec;
13258   int precision;
13259
13260   /* We built up the VALUES in reverse order.  */
13261   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13262
13263   /* [dcl.enum]
13264
13265      Following the closing brace of an enum-specifier, each
13266      enumerator has the type of its enumeration.  Prior to the
13267      closing brace, the type of each enumerator is the type of
13268      its initializing value.  */
13269   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13270     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13271
13272   /* For a enum defined in a template, all further processing is
13273      postponed until the template is instantiated.  */
13274   if (processing_template_decl)
13275     {
13276       tree scope = current_scope ();
13277       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13278         add_stmt (build_min (TAG_DEFN, enumtype));
13279
13280
13281       return;
13282     }
13283
13284   /* Figure out what the minimum and maximum values of the enumerators
13285      are.  */
13286   if (TYPE_VALUES (enumtype))
13287     {
13288       minnode = maxnode = NULL_TREE;
13289
13290       for (pair = TYPE_VALUES (enumtype);
13291            pair;
13292            pair = TREE_CHAIN (pair))
13293         {
13294           tree value;
13295
13296           value = DECL_INITIAL (TREE_VALUE (pair));
13297
13298           if (!minnode)
13299             minnode = maxnode = value;
13300           else if (tree_int_cst_lt (maxnode, value))
13301             maxnode = value;
13302           else if (tree_int_cst_lt (value, minnode))
13303             minnode = value;
13304         }
13305     }
13306   else
13307     minnode = maxnode = integer_zero_node;
13308
13309   /* Compute the number of bits require to represent all values of the
13310      enumeration.  We must do this before the type of MINNODE and
13311      MAXNODE are transformed, since min_precision relies on the
13312      TREE_TYPE of the value it is passed.  */
13313   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13314   lowprec = min_precision (minnode, unsignedp);
13315   highprec = min_precision (maxnode, unsignedp);
13316   precision = MAX (lowprec, highprec);
13317
13318   /* Set the TREE_TYPE for the values as well.  That's so that when we
13319      call decl_constant_value we get an entity of the right type (but
13320      with the constant value).  In addition, transform the TYPE_VALUES
13321      list to contain the values, rather than the CONST_DECLs for them.  */
13322   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13323     {
13324       tree value = DECL_INITIAL (TREE_VALUE (pair));
13325
13326       TREE_TYPE (value) = enumtype;
13327       TREE_VALUE (pair) = value;
13328     }
13329
13330   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13331   TYPE_SIZE (enumtype) = NULL_TREE;
13332   TYPE_PRECISION (enumtype) = precision;
13333   if (unsignedp)
13334     fixup_unsigned_type (enumtype);
13335   else
13336     fixup_signed_type (enumtype);
13337
13338   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13339     /* Use the width of the narrowest normal C type which is wide
13340        enough.  */
13341     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13342                                                 (precision, 1));
13343   else
13344     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13345
13346   TYPE_SIZE (enumtype) = NULL_TREE;
13347   layout_type (enumtype);
13348
13349   /* Fix up all variant types of this enum type.  */
13350   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13351     {
13352       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13353       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13354       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13355       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13356       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13357       TYPE_MODE (t) = TYPE_MODE (enumtype);
13358       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13359       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13360       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13361       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13362     }
13363
13364   /* Finish debugging output for this type.  */
13365   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13366 }
13367
13368 /* Build and install a CONST_DECL for an enumeration constant of the
13369    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13370    Assignment of sequential values by default is handled here.  */
13371
13372 void
13373 build_enumerator (name, value, enumtype)
13374      tree name;
13375      tree value;
13376      tree enumtype;
13377 {
13378   tree decl;
13379   tree context;
13380   tree type;
13381   tree values;
13382
13383   /* Remove no-op casts from the value.  */
13384   if (value)
13385     STRIP_TYPE_NOPS (value);
13386
13387   if (! processing_template_decl)
13388     {
13389       /* Validate and default VALUE.  */
13390       if (value != NULL_TREE)
13391         {
13392           value = decl_constant_value (value);
13393
13394           if (TREE_CODE (value) == INTEGER_CST)
13395             {
13396               value = default_conversion (value);
13397               constant_expression_warning (value);
13398             }
13399           else
13400             {
13401               error ("enumerator value for `%D' not integer constant", name);
13402               value = NULL_TREE;
13403             }
13404         }
13405
13406       /* Default based on previous value.  */
13407       if (value == NULL_TREE && ! processing_template_decl)
13408         {
13409           tree prev_value;
13410
13411           if (TYPE_VALUES (enumtype))
13412             {
13413               /* The next value is the previous value ... */
13414               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13415               /* ... plus one.  */
13416               value = cp_build_binary_op (PLUS_EXPR,
13417                                           prev_value,
13418                                           integer_one_node);
13419
13420               if (tree_int_cst_lt (value, prev_value))
13421                 error ("overflow in enumeration values at `%D'", name);
13422             }
13423           else
13424             value = integer_zero_node;
13425         }
13426
13427       /* Remove no-op casts from the value.  */
13428       if (value)
13429         STRIP_TYPE_NOPS (value);
13430 #if 0
13431       /* To fix MAX_VAL enum consts. (bkoz)  */
13432       TREE_TYPE (value) = integer_type_node;
13433 #endif
13434     }
13435
13436   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13437      Even in other cases, we will later (in finish_enum) be setting
13438      the type of VALUE.  But, we don't need to make a copy if this
13439      VALUE is one of the enumeration constants for this same
13440      enumeration type.  */
13441   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13442     if (TREE_VALUE (values) == value)
13443       break;
13444   /* If we didn't break out of the loop, then we do need a copy.  */
13445   if (!values && value)
13446     value = copy_node (value);
13447
13448   /* C++ associates enums with global, function, or class declarations.  */
13449   context = current_scope ();
13450
13451   /* Build the actual enumeration constant.  Note that the enumeration
13452     constants have the type of their initializers until the
13453     enumeration is complete:
13454
13455       [ dcl.enum ]
13456
13457       Following the closing brace of an enum-specifier, each enumer-
13458       ator has the type of its enumeration.  Prior to the closing
13459       brace, the type of each enumerator is the type of its
13460       initializing value.
13461
13462     In finish_enum we will reset the type.  Of course, if we're
13463     processing a template, there may be no value.   */
13464   type = value ? TREE_TYPE (value) : NULL_TREE;
13465
13466   if (context && context == current_class_type)
13467     /* This enum declaration is local to the class.  We need the full
13468        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13469     decl = build_lang_decl (CONST_DECL, name, type);
13470   else
13471     /* It's a global enum, or it's local to a function.  (Note local to
13472       a function could mean local to a class method.  */
13473     decl = build_decl (CONST_DECL, name, type);
13474
13475   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13476   DECL_INITIAL (decl) = value;
13477   TREE_READONLY (decl) = 1;
13478
13479   if (context && context == current_class_type)
13480     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13481       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13482       things like `S::i' later.)  */
13483     finish_member_declaration (decl);
13484   else
13485     pushdecl (decl);
13486
13487   /* Add this enumeration constant to the list for this type.  */
13488   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13489 }
13490
13491 \f
13492 /* We're defining DECL.  Make sure that it's type is OK.  */
13493
13494 static void
13495 check_function_type (decl, current_function_parms)
13496      tree decl;
13497      tree current_function_parms;
13498 {
13499   tree fntype = TREE_TYPE (decl);
13500   tree return_type = complete_type (TREE_TYPE (fntype));
13501
13502   /* In a function definition, arg types must be complete.  */
13503   require_complete_types_for_parms (current_function_parms);
13504
13505   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13506     {
13507       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13508
13509       /* Make it return void instead, but don't change the
13510          type of the DECL_RESULT, in case we have a named return value.  */
13511       if (TREE_CODE (fntype) == METHOD_TYPE)
13512         {
13513           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13514           TREE_TYPE (decl)
13515             = build_cplus_method_type (ctype,
13516                                        void_type_node,
13517                                        FUNCTION_ARG_CHAIN (decl));
13518         }
13519       else
13520         TREE_TYPE (decl)
13521           = build_function_type (void_type_node,
13522                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13523       TREE_TYPE (decl)
13524         = build_exception_variant (fntype,
13525                                    TYPE_RAISES_EXCEPTIONS (fntype));
13526     }
13527   else
13528     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13529 }
13530
13531 /* Create the FUNCTION_DECL for a function definition.
13532    DECLSPECS and DECLARATOR are the parts of the declaration;
13533    they describe the function's name and the type it returns,
13534    but twisted together in a fashion that parallels the syntax of C.
13535
13536    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13537    DECLARATOR is really the DECL for the function we are about to
13538    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13539    indicating that the function is an inline defined in-class.
13540
13541    This function creates a binding context for the function body
13542    as well as setting up the FUNCTION_DECL in current_function_decl.
13543
13544    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13545    (it defines a datum instead), we return 0, which tells
13546    yyparse to report a parse error.
13547
13548    For C++, we must first check whether that datum makes any sense.
13549    For example, "class A local_a(1,2);" means that variable local_a
13550    is an aggregate of type A, which should have a constructor
13551    applied to it with the argument list [1, 2].  */
13552
13553 int
13554 start_function (declspecs, declarator, attrs, flags)
13555      tree declspecs, declarator, attrs;
13556      int flags;
13557 {
13558   tree decl1;
13559   tree ctype = NULL_TREE;
13560   tree fntype;
13561   tree restype;
13562   extern int have_extern_spec;
13563   extern int used_extern_spec;
13564   int doing_friend = 0;
13565   struct binding_level *bl;
13566   tree current_function_parms;
13567
13568   /* Sanity check.  */
13569   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13570   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13571
13572   /* This should only be done once on the top most decl.  */
13573   if (have_extern_spec && !used_extern_spec)
13574     {
13575       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13576       used_extern_spec = 1;
13577     }
13578
13579   if (flags & SF_PRE_PARSED)
13580     {
13581       decl1 = declarator;
13582
13583       fntype = TREE_TYPE (decl1);
13584       if (TREE_CODE (fntype) == METHOD_TYPE)
13585         ctype = TYPE_METHOD_BASETYPE (fntype);
13586
13587       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13588          the (lexical) scope of the class in which it is defined.  */
13589       if (!ctype && DECL_FRIEND_P (decl1))
13590         {
13591           ctype = DECL_FRIEND_CONTEXT (decl1);
13592
13593           /* CTYPE could be null here if we're dealing with a template;
13594              for example, `inline friend float foo()' inside a template
13595              will have no CTYPE set.  */
13596           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13597             ctype = NULL_TREE;
13598           else
13599             doing_friend = 1;
13600         }
13601
13602       last_function_parms = DECL_ARGUMENTS (decl1);
13603     }
13604   else
13605     {
13606       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13607       /* If the declarator is not suitable for a function definition,
13608          cause a syntax error.  */
13609       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13610         return 0;
13611
13612       cplus_decl_attributes (&decl1, attrs, 0);
13613
13614       /* If #pragma weak was used, mark the decl weak now.  */
13615       if (current_binding_level == global_binding_level)
13616         maybe_apply_pragma_weak (decl1);
13617
13618       fntype = TREE_TYPE (decl1);
13619
13620       restype = TREE_TYPE (fntype);
13621       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13622         {
13623           error ("semicolon missing after declaration of `%#T'", restype);
13624           shadow_tag (build_tree_list (NULL_TREE, restype));
13625           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13626           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13627             fntype = build_function_type (integer_type_node,
13628                                           TYPE_ARG_TYPES (fntype));
13629           else
13630             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13631                                               integer_type_node,
13632                                               TYPE_ARG_TYPES (fntype));
13633           TREE_TYPE (decl1) = fntype;
13634         }
13635
13636       if (TREE_CODE (fntype) == METHOD_TYPE)
13637         ctype = TYPE_METHOD_BASETYPE (fntype);
13638       else if (DECL_MAIN_P (decl1))
13639         {
13640           /* If this doesn't return integer_type, complain.  */
13641           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13642             {
13643               if (pedantic || warn_return_type)
13644                 pedwarn ("return type for `main' changed to `int'");
13645               TREE_TYPE (decl1) = fntype = default_function_type;
13646             }
13647         }
13648     }
13649
13650   if (DECL_DECLARED_INLINE_P (decl1)
13651       && lookup_attribute ("noinline", attrs))
13652     warning_with_decl (decl1,
13653                        "inline function `%s' given attribute noinline");
13654
13655   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13656     /* This is a constructor, we must ensure that any default args
13657        introduced by this definition are propagated to the clones
13658        now. The clones are used directly in overload resolution.  */
13659     adjust_clone_args (decl1);
13660
13661   /* Sometimes we don't notice that a function is a static member, and
13662      build a METHOD_TYPE for it.  Fix that up now.  */
13663   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13664       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13665     {
13666       revert_static_member_fn (decl1);
13667       last_function_parms = TREE_CHAIN (last_function_parms);
13668       ctype = NULL_TREE;
13669     }
13670
13671   /* Warn if function was previously implicitly declared
13672      (but not if we warned then).  */
13673   if (! warn_implicit
13674       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13675     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13676
13677   /* Set up current_class_type, and enter the scope of the class, if
13678      appropriate.  */
13679   if (ctype)
13680     push_nested_class (ctype, 1);
13681   else if (DECL_STATIC_FUNCTION_P (decl1))
13682     push_nested_class (DECL_CONTEXT (decl1), 2);
13683
13684   /* Now that we have entered the scope of the class, we must restore
13685      the bindings for any template parameters surrounding DECL1, if it
13686      is an inline member template.  (Order is important; consider the
13687      case where a template parameter has the same name as a field of
13688      the class.)  It is not until after this point that
13689      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13690   if (flags & SF_INCLASS_INLINE)
13691     maybe_begin_member_template_processing (decl1);
13692
13693   /* Effective C++ rule 15.  */
13694   if (warn_ecpp
13695       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13696       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13697     warning ("`operator=' should return a reference to `*this'");
13698
13699   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13700      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13701   if (!DECL_INITIAL (decl1))
13702     DECL_INITIAL (decl1) = error_mark_node;
13703
13704   /* This function exists in static storage.
13705      (This does not mean `static' in the C sense!)  */
13706   TREE_STATIC (decl1) = 1;
13707
13708   /* We must call push_template_decl after current_class_type is set
13709      up.  (If we are processing inline definitions after exiting a
13710      class scope, current_class_type will be NULL_TREE until set above
13711      by push_nested_class.)  */
13712   if (processing_template_decl)
13713     decl1 = push_template_decl (decl1);
13714
13715   /* We are now in the scope of the function being defined.  */
13716   current_function_decl = decl1;
13717
13718   /* Save the parm names or decls from this function's declarator
13719      where store_parm_decls will find them.  */
13720   current_function_parms = last_function_parms;
13721
13722   /* Make sure the parameter and return types are reasonable.  When
13723      you declare a function, these types can be incomplete, but they
13724      must be complete when you define the function.  */
13725   if (! processing_template_decl)
13726     check_function_type (decl1, current_function_parms);
13727
13728   /* Build the return declaration for the function.  */
13729   restype = TREE_TYPE (fntype);
13730   /* Promote the value to int before returning it.  */
13731   if (c_promoting_integer_type_p (restype))
13732     restype = type_promotes_to (restype);
13733   if (DECL_RESULT (decl1) == NULL_TREE)
13734     {
13735       DECL_RESULT (decl1)
13736         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13737       c_apply_type_quals_to_decl (cp_type_quals (restype),
13738                                   DECL_RESULT (decl1));
13739     }
13740
13741   /* Initialize RTL machinery.  We cannot do this until
13742      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13743      even when processing a template; this is how we get
13744      CFUN set up, and our per-function variables initialized.
13745      FIXME factor out the non-RTL stuff.  */
13746   bl = current_binding_level;
13747   init_function_start (decl1, input_filename, lineno);
13748   current_binding_level = bl;
13749
13750   /* Even though we're inside a function body, we still don't want to
13751      call expand_expr to calculate the size of a variable-sized array.
13752      We haven't necessarily assigned RTL to all variables yet, so it's
13753      not safe to try to expand expressions involving them.  */
13754   immediate_size_expand = 0;
13755   cfun->x_dont_save_pending_sizes_p = 1;
13756
13757   /* Start the statement-tree, start the tree now.  */
13758   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13759
13760   /* Let the user know we're compiling this function.  */
13761   announce_function (decl1);
13762
13763   /* Record the decl so that the function name is defined.
13764      If we already have a decl for this name, and it is a FUNCTION_DECL,
13765      use the old decl.  */
13766   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13767     {
13768       /* A specialization is not used to guide overload resolution.  */
13769       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13770           && ! DECL_FUNCTION_MEMBER_P (decl1))
13771         decl1 = pushdecl (decl1);
13772       else
13773         {
13774           /* We need to set the DECL_CONTEXT. */
13775           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13776             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13777           /* And make sure we have enough default args.  */
13778           check_default_args (decl1);
13779         }
13780       fntype = TREE_TYPE (decl1);
13781     }
13782
13783   /* Reset these in case the call to pushdecl changed them.  */
13784   current_function_decl = decl1;
13785   cfun->decl = decl1;
13786
13787   /* If we are (erroneously) defining a function that we have already
13788      defined before, wipe out what we knew before.  */
13789   if (!DECL_PENDING_INLINE_P (decl1)
13790       && DECL_SAVED_FUNCTION_DATA (decl1))
13791     {
13792       free (DECL_SAVED_FUNCTION_DATA (decl1));
13793       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13794     }
13795
13796   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13797     {
13798       /* We know that this was set up by `grokclassfn'.  We do not
13799          wait until `store_parm_decls', since evil parse errors may
13800          never get us to that point.  Here we keep the consistency
13801          between `current_class_type' and `current_class_ptr'.  */
13802       tree t = DECL_ARGUMENTS (decl1);
13803
13804       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13805                           162);
13806       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13807                           19990811);
13808
13809       cp_function_chain->x_current_class_ref
13810         = build_indirect_ref (t, NULL);
13811       cp_function_chain->x_current_class_ptr = t;
13812
13813       /* Constructors and destructors need to know whether they're "in
13814          charge" of initializing virtual base classes.  */
13815       t = TREE_CHAIN (t);
13816       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13817         {
13818           current_in_charge_parm = t;
13819           t = TREE_CHAIN (t);
13820         }
13821       if (DECL_HAS_VTT_PARM_P (decl1))
13822         {
13823           if (DECL_NAME (t) != vtt_parm_identifier)
13824             abort ();
13825           current_vtt_parm = t;
13826         }
13827     }
13828
13829   if (DECL_INTERFACE_KNOWN (decl1))
13830     {
13831       tree ctx = decl_function_context (decl1);
13832
13833       if (DECL_NOT_REALLY_EXTERN (decl1))
13834         DECL_EXTERNAL (decl1) = 0;
13835
13836       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13837           && TREE_PUBLIC (ctx))
13838         /* This is a function in a local class in an extern inline
13839            function.  */
13840         comdat_linkage (decl1);
13841     }
13842   /* If this function belongs to an interface, it is public.
13843      If it belongs to someone else's interface, it is also external.
13844      This only affects inlines and template instantiations.  */
13845   else if (interface_unknown == 0
13846            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13847                || flag_alt_external_templates))
13848     {
13849       if (DECL_DECLARED_INLINE_P (decl1)
13850           || DECL_TEMPLATE_INSTANTIATION (decl1)
13851           || processing_template_decl)
13852         {
13853           DECL_EXTERNAL (decl1)
13854             = (interface_only
13855                || (DECL_DECLARED_INLINE_P (decl1)
13856                    && ! flag_implement_inlines
13857                    && !DECL_VINDEX (decl1)));
13858
13859           /* For WIN32 we also want to put these in linkonce sections.  */
13860           maybe_make_one_only (decl1);
13861         }
13862       else
13863         DECL_EXTERNAL (decl1) = 0;
13864       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13865       DECL_INTERFACE_KNOWN (decl1) = 1;
13866     }
13867   else if (interface_unknown && interface_only
13868            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13869                || flag_alt_external_templates))
13870     {
13871       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13872          interface, we will have interface_only set but not
13873          interface_known.  In that case, we don't want to use the normal
13874          heuristics because someone will supply a #pragma implementation
13875          elsewhere, and deducing it here would produce a conflict.  */
13876       comdat_linkage (decl1);
13877       DECL_EXTERNAL (decl1) = 0;
13878       DECL_INTERFACE_KNOWN (decl1) = 1;
13879       DECL_DEFER_OUTPUT (decl1) = 1;
13880     }
13881   else
13882     {
13883       /* This is a definition, not a reference.
13884          So clear DECL_EXTERNAL.  */
13885       DECL_EXTERNAL (decl1) = 0;
13886
13887       if ((DECL_DECLARED_INLINE_P (decl1)
13888            || DECL_TEMPLATE_INSTANTIATION (decl1))
13889           && ! DECL_INTERFACE_KNOWN (decl1)
13890           /* Don't try to defer nested functions for now.  */
13891           && ! decl_function_context (decl1))
13892         DECL_DEFER_OUTPUT (decl1) = 1;
13893       else
13894         DECL_INTERFACE_KNOWN (decl1) = 1;
13895     }
13896
13897   pushlevel (0);
13898   current_binding_level->parm_flag = 1;
13899
13900   ++function_depth;
13901
13902   if (DECL_DESTRUCTOR_P (decl1))
13903     {
13904       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13905       DECL_CONTEXT (dtor_label) = current_function_decl;
13906     }
13907
13908   start_fname_decls ();
13909
13910   store_parm_decls (current_function_parms);
13911
13912   return 1;
13913 }
13914 \f
13915 /* Store the parameter declarations into the current function declaration.
13916    This is called after parsing the parameter declarations, before
13917    digesting the body of the function.
13918
13919    Also install to binding contour return value identifier, if any.  */
13920
13921 static void
13922 store_parm_decls (current_function_parms)
13923      tree current_function_parms;
13924 {
13925   register tree fndecl = current_function_decl;
13926   register tree parm;
13927
13928   /* This is a chain of any other decls that came in among the parm
13929      declarations.  If a parm is declared with  enum {foo, bar} x;
13930      then CONST_DECLs for foo and bar are put here.  */
13931   tree nonparms = NULL_TREE;
13932
13933   if (current_function_parms)
13934     {
13935       /* This case is when the function was defined with an ANSI prototype.
13936          The parms already have decls, so we need not do anything here
13937          except record them as in effect
13938          and complain if any redundant old-style parm decls were written.  */
13939
13940       tree specparms = current_function_parms;
13941       tree next;
13942
13943       /* Must clear this because it might contain TYPE_DECLs declared
13944              at class level.  */
13945       storedecls (NULL_TREE);
13946
13947       /* If we're doing semantic analysis, then we'll call pushdecl
13948              for each of these.  We must do them in reverse order so that
13949              they end in the correct forward order.  */
13950       specparms = nreverse (specparms);
13951
13952       for (parm = specparms; parm; parm = next)
13953         {
13954           next = TREE_CHAIN (parm);
13955           if (TREE_CODE (parm) == PARM_DECL)
13956             {
13957               if (DECL_NAME (parm) == NULL_TREE
13958                   || TREE_CODE (parm) != VOID_TYPE)
13959                 pushdecl (parm);
13960               else
13961                 error ("parameter `%D' declared void", parm);
13962             }
13963           else
13964             {
13965               /* If we find an enum constant or a type tag,
13966                  put it aside for the moment.  */
13967               TREE_CHAIN (parm) = NULL_TREE;
13968               nonparms = chainon (nonparms, parm);
13969             }
13970         }
13971
13972       /* Get the decls in their original chain order and record in the
13973          function.  This is all and only the PARM_DECLs that were
13974          pushed into scope by the loop above.  */
13975       DECL_ARGUMENTS (fndecl) = getdecls ();
13976       storetags (gettags ());
13977     }
13978   else
13979     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13980
13981   /* Now store the final chain of decls for the arguments
13982      as the decl-chain of the current lexical scope.
13983      Put the enumerators in as well, at the front so that
13984      DECL_ARGUMENTS is not modified.  */
13985   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13986
13987   /* Do the starting of the exception specifications, if we have any.  */
13988   if (flag_exceptions && !processing_template_decl
13989       && flag_enforce_eh_specs
13990       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13991     current_eh_spec_block = begin_eh_spec_block ();
13992 }
13993
13994 \f
13995 /* We have finished doing semantic analysis on DECL, but have not yet
13996    generated RTL for its body.  Save away our current state, so that
13997    when we want to generate RTL later we know what to do.  */
13998
13999 static void
14000 save_function_data (decl)
14001      tree decl;
14002 {
14003   struct cp_language_function *f;
14004
14005   /* Save the language-specific per-function data so that we can
14006      get it back when we really expand this function.  */
14007   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14008                       19990908);
14009
14010   /* Make a copy.  */
14011   f = ((struct cp_language_function *)
14012        xmalloc (sizeof (struct cp_language_function)));
14013   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
14014   DECL_SAVED_FUNCTION_DATA (decl) = f;
14015
14016   /* Clear out the bits we don't need.  */
14017   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14018   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14019   f->x_named_label_uses = NULL;
14020   f->bindings = NULL;
14021   f->x_local_names = NULL;
14022
14023   /* When we get back here again, we will be expanding.  */
14024   f->x_expanding_p = 1;
14025
14026   /* If we've already decided that we cannot inline this function, we
14027      must remember that fact when we actually go to expand the
14028      function.  */
14029   if (current_function_cannot_inline)
14030     {
14031       f->cannot_inline = current_function_cannot_inline;
14032       DECL_INLINE (decl) = 0;
14033     }
14034 }
14035
14036 /* Add a note to mark the beginning of the main body of the constructor.
14037    This is used to set up the data structures for the cleanup regions for
14038    fully-constructed bases and members.  */
14039
14040 static void
14041 begin_constructor_body ()
14042 {
14043   tree ctor_stmt = build_stmt (CTOR_STMT);
14044   CTOR_BEGIN_P (ctor_stmt) = 1;
14045   add_stmt (ctor_stmt);
14046 }
14047
14048 /* Add a note to mark the end of the main body of the constructor.  This is
14049    used to end the cleanup regions for fully-constructed bases and
14050    members.  */
14051
14052 static void
14053 finish_constructor_body ()
14054 {
14055   /* Mark the end of the cleanups for a partially constructed object.
14056
14057      ??? These should really be handled automatically by closing the block,
14058      as with the destructor cleanups; the only difference is that these are
14059      only run if an exception is thrown.  */
14060   add_stmt (build_stmt (CTOR_STMT));
14061 }
14062
14063 /* Do all the processing for the beginning of a destructor; set up the
14064    vtable pointers and cleanups for bases and members.  */
14065
14066 static void
14067 begin_destructor_body ()
14068 {
14069   tree if_stmt;
14070   tree compound_stmt;
14071
14072   /* If the dtor is empty, and we know there is not any possible
14073      way we could use any vtable entries, before they are possibly
14074      set by a base class dtor, we don't have to setup the vtables,
14075      as we know that any base class dtor will set up any vtables
14076      it needs.  We avoid MI, because one base class dtor can do a
14077      virtual dispatch to an overridden function that would need to
14078      have a non-related vtable set up, we cannot avoid setting up
14079      vtables in that case.  We could change this to see if there
14080      is just one vtable.
14081
14082      ??? In the destructor for a class, the vtables are set
14083      appropriately for that class.  There will be no non-related
14084      vtables.  jason 2001-12-11.  */
14085   if_stmt = begin_if_stmt ();
14086
14087   /* If it is not safe to avoid setting up the vtables, then
14088      someone will change the condition to be boolean_true_node.
14089      (Actually, for now, we do not have code to set the condition
14090      appropriately, so we just assume that we always need to
14091      initialize the vtables.)  */
14092   finish_if_stmt_cond (boolean_true_node, if_stmt);
14093   current_vcalls_possible_p = &IF_COND (if_stmt);
14094
14095   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14096
14097   /* Make all virtual function table pointers in non-virtual base
14098      classes point to CURRENT_CLASS_TYPE's virtual function
14099      tables.  */
14100   initialize_vtbl_ptrs (current_class_ptr);
14101
14102   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14103   finish_then_clause (if_stmt);
14104   finish_if_stmt ();
14105 }
14106
14107 /* At the end of every destructor we generate code to delete the object if
14108    necessary.  Do that now.  */
14109
14110 static void
14111 finish_destructor_body ()
14112 {
14113   tree exprstmt;
14114
14115   /* Any return from a destructor will end up here; that way all base
14116      and member cleanups will be run when the function returns.  */
14117   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14118
14119   /* And perform cleanups for our bases and members.  */
14120   perform_base_cleanups ();
14121
14122   /* In a virtual destructor, we must call delete.  */
14123   if (DECL_VIRTUAL_P (current_function_decl))
14124     {
14125       tree if_stmt;
14126       tree virtual_size = c_sizeof (current_class_type);
14127
14128       /* [class.dtor]
14129
14130       At the point of definition of a virtual destructor (including
14131       an implicit definition), non-placement operator delete shall
14132       be looked up in the scope of the destructor's class and if
14133       found shall be accessible and unambiguous.  */
14134       exprstmt = build_op_delete_call
14135         (DELETE_EXPR, current_class_ptr, virtual_size,
14136          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14137
14138       if_stmt = begin_if_stmt ();
14139       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14140                                   current_in_charge_parm,
14141                                   integer_one_node),
14142                            if_stmt);
14143       finish_expr_stmt (exprstmt);
14144       finish_then_clause (if_stmt);
14145       finish_if_stmt ();
14146     }
14147 }
14148
14149 /* Do the necessary processing for the beginning of a function body, which
14150    in this case includes member-initializers, but not the catch clauses of
14151    a function-try-block.  Currently, this means opening a binding level
14152    for the member-initializers (in a ctor) and member cleanups (in a dtor).
14153    In other functions, this isn't necessary, but it doesn't hurt.  */
14154
14155 tree
14156 begin_function_body ()
14157 {
14158   tree stmt;
14159
14160   if (processing_template_decl)
14161     /* Do nothing now.  */;
14162   else
14163     /* Always keep the BLOCK node associated with the outermost pair of
14164        curly braces of a function.  These are needed for correct
14165        operation of dwarfout.c.  */
14166     keep_next_level (1);
14167
14168   stmt = begin_compound_stmt (0);
14169   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14170
14171   if (processing_template_decl)
14172     /* Do nothing now.  */;
14173   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14174     begin_constructor_body ();
14175   else if (DECL_DESTRUCTOR_P (current_function_decl))
14176     begin_destructor_body ();
14177
14178   return stmt;
14179 }
14180
14181 /* Do the processing for the end of a function body.  Currently, this means
14182    closing out the cleanups for fully-constructed bases and members, and in
14183    the case of the destructor, deleting the object if desired.  Again, this
14184    is only meaningful for [cd]tors, since they are the only functions where
14185    there is a significant distinction between the main body and any
14186    function catch clauses.  Handling, say, main() return semantics here
14187    would be wrong, as flowing off the end of a function catch clause for
14188    main() would also need to return 0.  */
14189
14190 void
14191 finish_function_body (compstmt)
14192      tree compstmt;
14193 {
14194   /* Close the block.  */
14195   finish_compound_stmt (0, compstmt);
14196
14197   if (processing_template_decl)
14198     /* Do nothing now.  */;
14199   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14200     finish_constructor_body ();
14201   else if (DECL_DESTRUCTOR_P (current_function_decl))
14202     finish_destructor_body ();
14203 }
14204
14205 /* Finish up a function declaration and compile that function
14206    all the way to assembler language output.  The free the storage
14207    for the function definition.
14208
14209    FLAGS is a bitwise or of the following values:
14210      2 - INCLASS_INLINE
14211        We just finished processing the body of an in-class inline
14212        function definition.  (This processing will have taken place
14213        after the class definition is complete.)  */
14214
14215 tree
14216 finish_function (flags)
14217      int flags;
14218 {
14219   register tree fndecl = current_function_decl;
14220   tree fntype, ctype = NULL_TREE;
14221   int inclass_inline = (flags & 2) != 0;
14222   int nested;
14223
14224   /* When we get some parse errors, we can end up without a
14225      current_function_decl, so cope.  */
14226   if (fndecl == NULL_TREE)
14227     return error_mark_node;
14228
14229   nested = function_depth > 1;
14230   fntype = TREE_TYPE (fndecl);
14231
14232   /*  TREE_READONLY (fndecl) = 1;
14233       This caused &foo to be of type ptr-to-const-function
14234       which then got a warning when stored in a ptr-to-function variable.  */
14235
14236   my_friendly_assert (building_stmt_tree (), 20000911);
14237
14238   finish_fname_decls ();
14239
14240   /* For a cloned function, we've already got all the code we need;
14241      there's no need to add any extra bits.  */
14242   if (!DECL_CLONED_FUNCTION_P (fndecl))
14243     {
14244       if (DECL_MAIN_P (current_function_decl))
14245         {
14246           /* Make it so that `main' always returns 0 by default.  */
14247 #if VMS_TARGET
14248           finish_return_stmt (integer_one_node);
14249 #else
14250           finish_return_stmt (integer_zero_node);
14251 #endif
14252         }
14253
14254       /* Finish dealing with exception specifiers.  */
14255       if (flag_exceptions && !processing_template_decl
14256           && flag_enforce_eh_specs
14257           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14258         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14259                               (TREE_TYPE (current_function_decl)),
14260                               current_eh_spec_block);
14261     }
14262
14263   /* If we're saving up tree structure, tie off the function now.  */
14264   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14265
14266   /* This must come after expand_function_end because cleanups might
14267      have declarations (from inline functions) that need to go into
14268      this function's blocks.  */
14269
14270   /* If the current binding level isn't the outermost binding level
14271      for this function, either there is a bug, or we have experienced
14272      syntax errors and the statement tree is malformed.  */
14273   if (current_binding_level->parm_flag != 1)
14274     {
14275       /* Make sure we have already experienced errors.  */
14276       if (errorcount == 0)
14277         abort ();
14278
14279       /* Throw away the broken statement tree and extra binding
14280          levels.  */
14281       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14282
14283       while (current_binding_level->parm_flag != 1)
14284         {
14285           if (current_binding_level->parm_flag == 2)
14286             pop_nested_class ();
14287           else
14288             poplevel (0, 0, 0);
14289         }
14290     }
14291   poplevel (1, 0, 1);
14292
14293   /* Set up the named return value optimization, if we can.  Here, we
14294      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14295      for the nrv.  genrtl_start_function and declare_return_variable
14296      handle making the nrv and RESULT_DECL share space.  */
14297   if (current_function_return_value)
14298     {
14299       tree r = current_function_return_value;
14300       /* This is only worth doing for fns that return in memory--and
14301          simpler, since we don't have to worry about promoted modes.  */
14302       if (r != error_mark_node
14303           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14304         {
14305           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14306           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14307                                         nullify_returns_r, r);
14308         }
14309       else
14310         /* Clear it so genrtl_start_function and declare_return_variable
14311            know we're not optimizing.  */
14312         current_function_return_value = NULL_TREE;
14313     }
14314
14315   /* Remember that we were in class scope.  */
14316   if (current_class_name)
14317     ctype = current_class_type;
14318
14319   /* Must mark the RESULT_DECL as being in this function.  */
14320   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14321
14322   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14323      to the FUNCTION_DECL node itself.  */
14324   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14325
14326   /* Save away current state, if appropriate.  */
14327   if (!processing_template_decl)
14328     save_function_data (fndecl);
14329
14330   /* If this function calls `setjmp' it cannot be inlined.  When
14331      `longjmp' is called it is not guaranteed to restore the value of
14332      local variables that have been modified since the call to
14333      `setjmp'.  So, if were to inline this function into some caller
14334      `c', then when we `longjmp', we might not restore all variables
14335      in `c'.  (It might seem, at first blush, that there's no way for
14336      this function to modify local variables in `c', but their
14337      addresses may have been stored somewhere accessible to this
14338      function.)  */
14339   if (!processing_template_decl && calls_setjmp_p (fndecl))
14340     DECL_UNINLINABLE (fndecl) = 1;
14341
14342   /* Complain if there's just no return statement.  */
14343   if (warn_return_type
14344       && !processing_template_decl
14345       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14346       && !current_function_returns_value && !current_function_returns_null
14347       /* Don't complain if we abort or throw.  */
14348       && !current_function_returns_abnormally
14349       && !DECL_NAME (DECL_RESULT (fndecl))
14350       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
14351          inline function, as we might never be compiled separately.  */
14352       && DECL_INLINE (fndecl))
14353     warning ("no return statement in function returning non-void");
14354
14355   /* Clear out memory we no longer need.  */
14356   free_after_parsing (cfun);
14357   /* Since we never call rest_of_compilation, we never clear
14358      CFUN.  Do so explicitly.  */
14359   free_after_compilation (cfun);
14360   cfun = NULL;
14361
14362   /* If this is a in-class inline definition, we may have to pop the
14363      bindings for the template parameters that we added in
14364      maybe_begin_member_template_processing when start_function was
14365      called.  */
14366   if (inclass_inline)
14367     maybe_end_member_template_processing ();
14368
14369   /* Leave the scope of the class.  */
14370   if (ctype)
14371     pop_nested_class ();
14372
14373   --function_depth;
14374
14375   /* Clean up.  */
14376   if (! nested)
14377     /* Let the error reporting routines know that we're outside a
14378        function.  For a nested function, this value is used in
14379        pop_cp_function_context and then reset via pop_function_context.  */
14380     current_function_decl = NULL_TREE;
14381
14382   return fndecl;
14383 }
14384 \f
14385 /* Create the FUNCTION_DECL for a function definition.
14386    DECLSPECS and DECLARATOR are the parts of the declaration;
14387    they describe the return type and the name of the function,
14388    but twisted together in a fashion that parallels the syntax of C.
14389
14390    This function creates a binding context for the function body
14391    as well as setting up the FUNCTION_DECL in current_function_decl.
14392
14393    Returns a FUNCTION_DECL on success.
14394
14395    If the DECLARATOR is not suitable for a function (it defines a datum
14396    instead), we return 0, which tells yyparse to report a parse error.
14397
14398    May return void_type_node indicating that this method is actually
14399    a friend.  See grokfield for more details.
14400
14401    Came here with a `.pushlevel' .
14402
14403    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14404    CHANGES TO CODE IN `grokfield'.  */
14405
14406 tree
14407 start_method (declspecs, declarator, attrlist)
14408      tree declarator, declspecs, attrlist;
14409 {
14410   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14411                                 &attrlist);
14412
14413   /* Something too ugly to handle.  */
14414   if (fndecl == NULL_TREE)
14415     return NULL_TREE;
14416
14417   if (attrlist)
14418     cplus_decl_attributes (&fndecl, attrlist, 0);
14419
14420   /* Pass friends other than inline friend functions back.  */
14421   if (fndecl == void_type_node)
14422     return fndecl;
14423
14424   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14425     /* Not a function, tell parser to report parse error.  */
14426     return NULL_TREE;
14427
14428   if (DECL_IN_AGGR_P (fndecl))
14429     {
14430       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14431         {
14432           if (DECL_CONTEXT (fndecl)
14433               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14434             error ("`%D' is already defined in class `%T'", fndecl,
14435                       DECL_CONTEXT (fndecl));
14436         }
14437       return void_type_node;
14438     }
14439
14440   check_template_shadow (fndecl);
14441
14442   DECL_DECLARED_INLINE_P (fndecl) = 1;
14443
14444   if (flag_default_inline)
14445     DECL_INLINE (fndecl) = 1;
14446
14447   /* We process method specializations in finish_struct_1.  */
14448   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14449     fndecl = push_template_decl (fndecl);
14450
14451   if (! DECL_FRIEND_P (fndecl))
14452     {
14453       if (TREE_CHAIN (fndecl))
14454         {
14455           fndecl = copy_node (fndecl);
14456           TREE_CHAIN (fndecl) = NULL_TREE;
14457         }
14458       grok_special_member_properties (fndecl);
14459     }
14460
14461   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14462
14463   /* Make a place for the parms */
14464   pushlevel (0);
14465   current_binding_level->parm_flag = 1;
14466
14467   DECL_IN_AGGR_P (fndecl) = 1;
14468   return fndecl;
14469 }
14470
14471 /* Go through the motions of finishing a function definition.
14472    We don't compile this method until after the whole class has
14473    been processed.
14474
14475    FINISH_METHOD must return something that looks as though it
14476    came from GROKFIELD (since we are defining a method, after all).
14477
14478    This is called after parsing the body of the function definition.
14479    STMTS is the chain of statements that makes up the function body.
14480
14481    DECL is the ..._DECL that `start_method' provided.  */
14482
14483 tree
14484 finish_method (decl)
14485      tree decl;
14486 {
14487   register tree fndecl = decl;
14488   tree old_initial;
14489
14490   register tree link;
14491
14492   if (decl == void_type_node)
14493     return decl;
14494
14495   old_initial = DECL_INITIAL (fndecl);
14496
14497   /* Undo the level for the parms (from start_method).
14498      This is like poplevel, but it causes nothing to be
14499      saved.  Saving information here confuses symbol-table
14500      output routines.  Besides, this information will
14501      be correctly output when this method is actually
14502      compiled.  */
14503
14504   /* Clear out the meanings of the local variables of this level;
14505      also record in each decl which block it belongs to.  */
14506
14507   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14508     {
14509       if (DECL_NAME (link) != NULL_TREE)
14510         pop_binding (DECL_NAME (link), link);
14511       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14512       DECL_CONTEXT (link) = NULL_TREE;
14513     }
14514
14515   poplevel (0, 0, 0);
14516
14517   DECL_INITIAL (fndecl) = old_initial;
14518
14519   /* We used to check if the context of FNDECL was different from
14520      current_class_type as another way to get inside here.  This didn't work
14521      for String.cc in libg++.  */
14522   if (DECL_FRIEND_P (fndecl))
14523     {
14524       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14525         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14526       decl = void_type_node;
14527     }
14528
14529   return decl;
14530 }
14531 \f
14532
14533 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
14534    we can lay it out later, when and if its type becomes complete.  */
14535
14536 void
14537 maybe_register_incomplete_var (var)
14538      tree var;
14539 {
14540   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14541
14542   /* Keep track of variables with incomplete types.  */
14543   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14544       && DECL_EXTERNAL (var))
14545     {
14546       tree inner_type = TREE_TYPE (var);
14547
14548       while (TREE_CODE (inner_type) == ARRAY_TYPE)
14549         inner_type = TREE_TYPE (inner_type);
14550       inner_type = TYPE_MAIN_VARIANT (inner_type);
14551
14552       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14553           /* RTTI TD entries are created while defining the type_info.  */
14554           || (TYPE_LANG_SPECIFIC (inner_type)
14555               && TYPE_BEING_DEFINED (inner_type)))
14556         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14557     }
14558 }
14559
14560 /* Called when a class type (given by TYPE) is defined.  If there are
14561    any existing VAR_DECLs whose type hsa been completed by this
14562    declaration, update them now.  */
14563
14564 void
14565 complete_vars (type)
14566      tree type;
14567 {
14568   tree *list = &incomplete_vars;
14569
14570   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14571   while (*list)
14572     {
14573       if (same_type_p (type, TREE_PURPOSE (*list)))
14574         {
14575           tree var = TREE_VALUE (*list);
14576           /* Complete the type of the variable.  The VAR_DECL itself
14577              will be laid out in expand_expr.  */
14578           complete_type (TREE_TYPE (var));
14579           /* Remove this entry from the list.  */
14580           *list = TREE_CHAIN (*list);
14581         }
14582       else
14583         list = &TREE_CHAIN (*list);
14584     }
14585 }
14586
14587 /* If DECL is of a type which needs a cleanup, build that cleanup
14588    here.  */
14589
14590 tree
14591 maybe_build_cleanup (decl)
14592      tree decl;
14593 {
14594   tree type = TREE_TYPE (decl);
14595
14596   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14597     {
14598       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14599       tree rval;
14600
14601       if (TREE_CODE (type) == ARRAY_TYPE)
14602         rval = decl;
14603       else
14604         {
14605           mark_addressable (decl);
14606           rval = build_unary_op (ADDR_EXPR, decl, 0);
14607         }
14608
14609       /* Optimize for space over speed here.  */
14610       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14611           || flag_expensive_optimizations)
14612         flags |= LOOKUP_NONVIRTUAL;
14613
14614       rval = build_delete (TREE_TYPE (rval), rval,
14615                            sfk_complete_destructor, flags, 0);
14616
14617       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14618           && ! TYPE_HAS_DESTRUCTOR (type))
14619         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14620                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14621
14622       return rval;
14623     }
14624   return NULL_TREE;
14625 }
14626 \f
14627 /* When a stmt has been parsed, this function is called.  */
14628
14629 void
14630 finish_stmt ()
14631 {
14632   /* Always assume this statement was not an expression statement.  If
14633      it actually was an expression statement, its our callers
14634      responsibility to fix this up.  */
14635   last_expr_type = NULL_TREE;
14636 }
14637
14638 /* DECL was originally constructed as a non-static member function,
14639    but turned out to be static.  Update it accordingly.  */
14640
14641 void
14642 revert_static_member_fn (decl)
14643      tree decl;
14644 {
14645   tree tmp;
14646   tree function = TREE_TYPE (decl);
14647   tree args = TYPE_ARG_TYPES (function);
14648
14649   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14650       != TYPE_UNQUALIFIED)
14651     error ("static member function `%#D' declared with type qualifiers",
14652               decl);
14653
14654   args = TREE_CHAIN (args);
14655   tmp = build_function_type (TREE_TYPE (function), args);
14656   tmp = build_qualified_type (tmp, cp_type_quals (function));
14657   tmp = build_exception_variant (tmp,
14658                                  TYPE_RAISES_EXCEPTIONS (function));
14659   TREE_TYPE (decl) = tmp;
14660   if (DECL_ARGUMENTS (decl))
14661     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14662   DECL_STATIC_FUNCTION_P (decl) = 1;
14663 }
14664
14665 /* Initialize the variables used during compilation of a C++
14666    function.  */
14667
14668 static void
14669 push_cp_function_context (f)
14670      struct function *f;
14671 {
14672   struct cp_language_function *p
14673     = ((struct cp_language_function *)
14674        xcalloc (1, sizeof (struct cp_language_function)));
14675   f->language = (struct language_function *) p;
14676
14677   /* It takes an explicit call to expand_body to generate RTL for a
14678      function.  */
14679   expanding_p = 0;
14680
14681   /* Whenever we start a new function, we destroy temporaries in the
14682      usual way.  */
14683   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14684 }
14685
14686 /* Free the language-specific parts of F, now that we've finished
14687    compiling the function.  */
14688
14689 static void
14690 pop_cp_function_context (f)
14691      struct function *f;
14692 {
14693   if (f->language)
14694     {
14695       struct cp_language_function *cp =
14696         (struct cp_language_function *) f->language;
14697       if (cp->x_local_names)
14698         VARRAY_FREE (cp->x_local_names);
14699       free (f->language);
14700     }
14701   f->language = 0;
14702 }
14703
14704 /* Mark P for GC.  */
14705
14706 static void
14707 mark_lang_function (p)
14708      struct cp_language_function *p;
14709 {
14710   if (!p)
14711     return;
14712
14713   mark_c_language_function (&p->base);
14714
14715   ggc_mark_tree (p->x_dtor_label);
14716   ggc_mark_tree (p->x_current_class_ptr);
14717   ggc_mark_tree (p->x_current_class_ref);
14718   ggc_mark_tree (p->x_eh_spec_block);
14719   ggc_mark_tree_varray (p->x_local_names);
14720
14721   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14722   mark_binding_level (&p->bindings);
14723   mark_pending_inlines (&p->unparsed_inlines);
14724 }
14725
14726 /* Mark the language-specific data in F for GC.  */
14727
14728 static void
14729 mark_cp_function_context (f)
14730      struct function *f;
14731 {
14732   mark_lang_function ((struct cp_language_function *) f->language);
14733 }
14734
14735 void
14736 lang_mark_tree (t)
14737      tree t;
14738 {
14739   enum tree_code code = TREE_CODE (t);
14740   if (code == IDENTIFIER_NODE)
14741     {
14742       struct lang_identifier *li = (struct lang_identifier *) t;
14743       struct lang_id2 *li2 = li->x;
14744       ggc_mark_tree (li->namespace_bindings);
14745       ggc_mark_tree (li->bindings);
14746       ggc_mark_tree (li->class_value);
14747       ggc_mark_tree (li->class_template_info);
14748
14749       if (li2)
14750         {
14751           ggc_mark_tree (li2->label_value);
14752           ggc_mark_tree (li2->implicit_decl);
14753           ggc_mark_tree (li2->error_locus);
14754         }
14755     }
14756   else if (code == CPLUS_BINDING)
14757     {
14758       if (BINDING_HAS_LEVEL_P (t))
14759         mark_binding_level (&BINDING_LEVEL (t));
14760       else
14761         ggc_mark_tree (BINDING_SCOPE (t));
14762       ggc_mark_tree (BINDING_VALUE (t));
14763     }
14764   else if (code == OVERLOAD)
14765     ggc_mark_tree (OVL_FUNCTION (t));
14766   else if (code == TEMPLATE_PARM_INDEX)
14767     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14768   else if (TREE_CODE_CLASS (code) == 'd')
14769     {
14770       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14771
14772       if (ld)
14773         {
14774           ggc_mark (ld);
14775           c_mark_lang_decl (&ld->decl_flags.base);
14776           if (!DECL_GLOBAL_CTOR_P (t)
14777               && !DECL_GLOBAL_DTOR_P (t)
14778               && !DECL_THUNK_P (t)
14779               && !DECL_DISCRIMINATOR_P (t))
14780             ggc_mark_tree (ld->decl_flags.u2.access);
14781           else if (DECL_THUNK_P (t))
14782             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14783           if (TREE_CODE (t) != NAMESPACE_DECL)
14784             ggc_mark_tree (ld->decl_flags.u.template_info);
14785           else
14786             mark_binding_level (&NAMESPACE_LEVEL (t));
14787           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14788             {
14789               ggc_mark_tree (ld->befriending_classes);
14790               ggc_mark_tree (ld->context);
14791               ggc_mark_tree (ld->cloned_function);
14792               if (TREE_CODE (t) == TYPE_DECL)
14793                 ggc_mark_tree (ld->u.sorted_fields);
14794               else if (TREE_CODE (t) == FUNCTION_DECL
14795                        && !DECL_PENDING_INLINE_P (t))
14796                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14797             }
14798         }
14799     }
14800   else if (TREE_CODE_CLASS (code) == 't')
14801     {
14802       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14803
14804       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14805                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14806         {
14807           ggc_mark (lt);
14808           ggc_mark_tree (lt->primary_base);
14809           ggc_mark_tree (lt->vfields);
14810           ggc_mark_tree (lt->vbases);
14811           ggc_mark_tree (lt->tags);
14812           ggc_mark_tree (lt->size);
14813           ggc_mark_tree (lt->pure_virtuals);
14814           ggc_mark_tree (lt->friend_classes);
14815           ggc_mark_tree (lt->rtti);
14816           ggc_mark_tree (lt->methods);
14817           ggc_mark_tree (lt->template_info);
14818           ggc_mark_tree (lt->befriending_classes);
14819         }
14820       else if (lt)
14821         /* In the case of pointer-to-member function types, the
14822            TYPE_LANG_SPECIFIC is really just a tree.  */
14823         ggc_mark_tree ((tree) lt);
14824     }
14825 }
14826
14827 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14828    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14829
14830 tree
14831 identifier_global_value (t)
14832      tree t;
14833 {
14834   return IDENTIFIER_GLOBAL_VALUE (t);
14835 }
14836
14837 /* Build the void_list_node (void_type_node having been created).  */
14838 tree
14839 build_void_list_node ()
14840 {
14841   tree t = build_tree_list (NULL_TREE, void_type_node);
14842   TREE_PARMLIST (t) = 1;
14843   return t;
14844 }
14845
14846 static int
14847 cp_missing_noreturn_ok_p (decl)
14848      tree decl;
14849 {
14850   /* A missing noreturn is ok for the `main' function.  */
14851   return DECL_MAIN_P (decl);
14852 }