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 GCC.
   7
   8 GCC 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 GCC 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 GCC; 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 "coretypes.h"
  34 #include "tm.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "expr.h"
  38 #include "flags.h"
  39 #include "cp-tree.h"
  40 #include "tree-inline.h"
  41 #include "decl.h"
  42 #include "lex.h"
  43 #include "output.h"
  44 #include "except.h"
  45 #include "toplev.h"
  46 #include "hashtab.h"
  47 #include "ggc.h"
  48 #include "tm_p.h"
  49 #include "target.h"
  50 #include "c-common.h"
  51 #include "c-pragma.h"
  52 #include "diagnostic.h"
  53 #include "debug.h"
  54
  55 static tree grokparms                           PARAMS ((tree));
  56 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  57
  58 static void push_binding_level PARAMS ((struct cp_binding_level *, int,
  59                                       int));
  60 static void pop_binding_level PARAMS ((void));
  61 static void suspend_binding_level PARAMS ((void));
  62 static void resume_binding_level PARAMS ((struct cp_binding_level *));
  63 static struct cp_binding_level *make_binding_level PARAMS ((void));
  64 static void declare_namespace_level PARAMS ((void));
  65 static int decl_jump_unsafe PARAMS ((tree));
  66 static void storedecls PARAMS ((tree));
  67 static void require_complete_types_for_parms PARAMS ((tree));
  68 static int ambi_op_p PARAMS ((enum tree_code));
  69 static int unary_op_p PARAMS ((enum tree_code));
  70 static tree store_bindings PARAMS ((tree, tree));
  71 static tree lookup_tag_reverse PARAMS ((tree, tree));
  72 static void push_local_name PARAMS ((tree));
  73 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  74 static tree grok_reference_init PARAMS ((tree, tree, tree));
  75 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  76                               enum overload_flags, tree,
  77                               tree, int, int, int, int, int, int, tree));
  78 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  79 static tree follow_tag_typedef PARAMS ((tree));
  80 static tree lookup_tag PARAMS ((enum tree_code, tree,
  81                               struct cp_binding_level *, int));
  82 static void set_identifier_type_value_with_scope
  83         PARAMS ((tree, tree, struct cp_binding_level *));
  84 static void record_unknown_type PARAMS ((tree, const char *));
  85 static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
  86                                       enum built_in_class, const char *,
  87                                       tree));
  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 cp_binding_level*));
  93 static void check_for_uninitialized_const_var PARAMS ((tree));
  94 static hashval_t typename_hash PARAMS ((const void *));
  95 static int typename_compare PARAMS ((const void *, const void *));
  96 static void push_binding PARAMS ((tree, tree, struct cp_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 cp_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 int walk_vtables_r PARAMS ((tree, void*));
 112 static void add_decl_to_level PARAMS ((tree, struct cp_binding_level *));
 113 static tree make_label_decl PARAMS ((tree, int));
 114 static void use_label PARAMS ((tree));
 115 static void check_previous_goto_1 PARAMS ((tree, struct cp_binding_level *, tree,
 116                                            const char *, int));
 117 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 118 static void check_switch_goto PARAMS ((struct cp_binding_level *));
 119 static void check_previous_gotos PARAMS ((tree));
 120 static void pop_label PARAMS ((tree, tree));
 121 static void pop_labels PARAMS ((tree));
 122 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 123 static void layout_var_decl PARAMS ((tree));
 124 static void maybe_commonize_var PARAMS ((tree));
 125 static tree check_initializer (tree, tree, int);
 126 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 127 static void save_function_data PARAMS ((tree));
 128 static void check_function_type PARAMS ((tree, tree));
 129 static void begin_constructor_body PARAMS ((void));
 130 static void finish_constructor_body PARAMS ((void));
 131 static void begin_destructor_body PARAMS ((void));
 132 static void finish_destructor_body PARAMS ((void));
 133 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 134 static tree get_atexit_node PARAMS ((void));
 135 static tree get_dso_handle_node PARAMS ((void));
 136 static tree start_cleanup_fn PARAMS ((void));
 137 static void end_cleanup_fn PARAMS ((void));
 138 static tree cp_make_fname_decl PARAMS ((tree, int));
 139 static void initialize_predefined_identifiers PARAMS ((void));
 140 static tree check_special_function_return_type
 141   PARAMS ((special_function_kind, tree, tree));
 142 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 143 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 144 static void store_parm_decls PARAMS ((tree));
 145 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 146 static void initialize_local_var (tree, tree);
 147 static void expand_static_init (tree, tree);
 148 static tree next_initializable_field (tree);
 149 static tree reshape_init (tree, tree *);
 150
 151 #if defined (DEBUG_BINDING_LEVELS)
 152 static void indent PARAMS ((void));
 153 #endif
 154
 155 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 156 tree error_mark_list;
 157
 158 /* The following symbols are subsumed in the cp_global_trees array, and
 159    listed here individually for documentation purposes.
 160
 161    C++ extensions
 162         tree wchar_decl_node;
 163
 164         tree vtable_entry_type;
 165         tree delta_type_node;
 166         tree __t_desc_type_node;
 167         tree ti_desc_type_node;
 168         tree bltn_desc_type_node, ptr_desc_type_node;
 169         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 170         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 171         tree ptm_desc_type_node;
 172         tree base_desc_type_node;
 173
 174         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 175         tree unknown_type_node;
 176
 177    Array type `vtable_entry_type[]'
 178
 179         tree vtbl_type_node;
 180         tree vtbl_ptr_type_node;
 181
 182    Namespaces,
 183
 184         tree std_node;
 185         tree abi_node;
 186
 187    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 188    one that the user will declare, but sufficient to be called
 189    by routines that want to abort the program.
 190
 191         tree abort_fndecl;
 192
 193    The FUNCTION_DECL for the default `::operator delete'.
 194
 195         tree global_delete_fndecl;
 196
 197    Used by RTTI
 198         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 199         tree tinfo_var_id;
 200
 201 */
 202
 203 tree cp_global_trees[CPTI_MAX];
 204
 205 /* Indicates that there is a type value in some namespace, although
 206    that is not necessarily in scope at the moment.  */
 207
 208 static GTY(()) tree global_type_node;
 209
 210 /* Used only for jumps to as-yet undefined labels, since jumps to
 211    defined labels can have their validity checked immediately.  */
 212
 213 struct named_label_use_list GTY(())
 214 {
 215   struct cp_binding_level *binding_level;
 216   tree names_in_scope;
 217   tree label_decl;
 218   const char *filename_o_goto;
 219   int lineno_o_goto;
 220   struct named_label_use_list *next;
 221 };
 222
 223 #define named_label_uses cp_function_chain->x_named_label_uses
 224
 225 #define local_names cp_function_chain->x_local_names
 226
 227 /* A list of objects which have constructors or destructors
 228    which reside in the global scope.  The decl is stored in
 229    the TREE_VALUE slot and the initializer is stored
 230    in the TREE_PURPOSE slot.  */
 231 tree static_aggregates;
 232
 233 /* -- end of C++ */
 234
 235 /* A node for the integer constants 2, and 3.  */
 236
 237 tree integer_two_node, integer_three_node;
 238
 239 /* Similar, for last_function_parm_tags.  */
 240 tree last_function_parms;
 241
 242 /* A list of all LABEL_DECLs in the function that have names.  Here so
 243    we can clear out their names' definitions at the end of the
 244    function, and so we can check the validity of jumps to these labels.  */
 245
 246 struct named_label_list GTY(())
 247 {
 248   struct cp_binding_level *binding_level;
 249   tree names_in_scope;
 250   tree old_value;
 251   tree label_decl;
 252   tree bad_decls;
 253   struct named_label_list *next;
 254   unsigned int in_try_scope : 1;
 255   unsigned int in_catch_scope : 1;
 256 };
 257
 258 #define named_labels cp_function_chain->x_named_labels
 259 \f
 260 /* The name of the anonymous namespace, throughout this translation
 261    unit.  */
 262 tree anonymous_namespace_name;
 263
 264 /* The number of function bodies which we are currently processing.
 265    (Zero if we are at namespace scope, one inside the body of a
 266    function, two inside the body of a function in a local class, etc.)  */
 267 int function_depth;
 268
 269 /* States indicating how grokdeclarator() should handle declspecs marked
 270    with __attribute__((deprecated)).  An object declared as
 271    __attribute__((deprecated)) suppresses warnings of uses of other
 272    deprecated items.  */
 273
 274 enum deprecated_states {
 275   DEPRECATED_NORMAL,
 276   DEPRECATED_SUPPRESS
 277 };
 278
 279 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 280
 281 /* Set by add_implicitly_declared_members() to keep those members from
 282    being flagged as deprecated or reported as using deprecated
 283    types.  */
 284 int adding_implicit_members = 0;
 285
 286 /* True if a declaration with an `extern' linkage specifier is being
 287    processed.  */
 288 bool have_extern_spec;
 289
 290 \f
 291 /* For each binding contour we allocate a binding_level structure
 292    which records the names defined in that contour.
 293    Contours include:
 294     0) the global one
 295     1) one for each function definition,
 296        where internal declarations of the parameters appear.
 297     2) one for each compound statement,
 298        to record its declarations.
 299
 300    The current meaning of a name can be found by searching the levels
 301    from the current one out to the global one.
 302
 303    Off to the side, may be the class_binding_level.  This exists only
 304    to catch class-local declarations.  It is otherwise nonexistent.
 305
 306    Also there may be binding levels that catch cleanups that must be
 307    run when exceptions occur.  Thus, to see whether a name is bound in
 308    the current scope, it is not enough to look in the
 309    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 310    instead.  */
 311
 312 /* Note that the information in the `names' component of the global contour
 313    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 314
 315 struct cp_binding_level GTY(())
 316   {
 317     /* A chain of _DECL nodes for all variables, constants, functions,
 318        and typedef types.  These are in the reverse of the order
 319        supplied.  There may be OVERLOADs on this list, too, but they
 320        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 321     tree names;
 322
 323     /* Count of elements in names chain.  */
 324     size_t names_size;
 325
 326     /* A chain of NAMESPACE_DECL nodes.  */
 327     tree namespaces;
 328
 329     /* A chain of VTABLE_DECL nodes.  */
 330     tree vtables;
 331
 332     /* A list of structure, union and enum definitions, for looking up
 333        tag names.
 334        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 335        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 336        or ENUMERAL_TYPE node.
 337
 338        C++: the TREE_VALUE nodes can be simple types for
 339        component_bindings.  */
 340     tree tags;
 341
 342     /* A list of USING_DECL nodes.  */
 343     tree usings;
 344
 345     /* A list of used namespaces. PURPOSE is the namespace,
 346        VALUE the common ancestor with this binding_level's namespace.  */
 347     tree using_directives;
 348
 349     /* If this binding level is the binding level for a class, then
 350        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 351        is the name of an entity bound in the class.  The TREE_TYPE is
 352        the DECL bound by this name in the class.  */
 353     tree class_shadowed;
 354
 355     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 356        is used for all binding levels. In addition the TREE_VALUE is the
 357        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 358     tree type_shadowed;
 359
 360     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 361        label in this scope.  The TREE_PURPOSE is the previous value of
 362        the IDENTIFIER_LABEL VALUE.  */
 363     tree shadowed_labels;
 364
 365     /* For each level (except not the global one),
 366        a chain of BLOCK nodes for all the levels
 367        that were entered and exited one level down.  */
 368     tree blocks;
 369
 370     /* The _TYPE node for this level, if parm_flag == 2.  */
 371     tree this_class;
 372
 373     /* The binding level which this one is contained in (inherits from).  */
 374     struct cp_binding_level *level_chain;
 375
 376     /* List of VAR_DECLS saved from a previous for statement.
 377        These would be dead in ISO-conforming code, but might
 378        be referenced in ARM-era code.  These are stored in a
 379        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 380     tree dead_vars_from_for;
 381
 382     /* 1 for the level that holds the parameters of a function.
 383        2 for the level that holds a class declaration.  */
 384     unsigned parm_flag : 2;
 385
 386     /* 1 means make a BLOCK for this level regardless of all else.
 387        2 for temporary binding contours created by the compiler.  */
 388     unsigned keep : 2;
 389
 390     /* Nonzero if this level "doesn't exist" for tags.  */
 391     unsigned tag_transparent : 1;
 392
 393     /* Nonzero if this level can safely have additional
 394        cleanup-needing variables added to it.  */
 395     unsigned more_cleanups_ok : 1;
 396     unsigned have_cleanups : 1;
 397
 398     /* Nonzero if this scope is for storing the decls for template
 399        parameters and generic decls; these decls will be discarded and
 400        replaced with a TEMPLATE_DECL.  */
 401     unsigned template_parms_p : 1;
 402
 403     /* Nonzero if this scope corresponds to the `<>' in a
 404        `template <>' clause.  Whenever this flag is set,
 405        TEMPLATE_PARMS_P will be set as well.  */
 406     unsigned template_spec_p : 1;
 407
 408     /* This is set for a namespace binding level.  */
 409     unsigned namespace_p : 1;
 410
 411     /* True if this level is that of a for-statement where we need to
 412        worry about ambiguous (ARM or ISO) scope rules.  */
 413     unsigned is_for_scope : 1;
 414
 415     /* True if this level corresponds to a TRY block.  Currently this
 416        information is only available while building the tree structure.  */
 417     unsigned is_try_scope : 1;
 418
 419     /* True if this level corresponds to a CATCH block.  Currently this
 420        information is only available while building the tree structure.  */
 421     unsigned is_catch_scope : 1;
 422
 423     /* Three bits left for this word.  */
 424
 425     /* Binding depth at which this level began.  */
 426     unsigned binding_depth;
 427   };
 428
 429 #define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)
 430
 431 /* The binding level currently in effect.  */
 432
 433 #define current_binding_level                   \
 434   (cfun && cp_function_chain->bindings          \
 435    ? cp_function_chain->bindings                \
 436    : scope_chain->bindings)
 437
 438 /* The binding level of the current class, if any.  */
 439
 440 #define class_binding_level scope_chain->class_bindings
 441
 442 /* A chain of binding_level structures awaiting reuse.  */
 443
 444 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
 445
 446 /* The outermost binding level, for names of file scope.
 447    This is created when the compiler is started and exists
 448    through the entire run.  */
 449
 450 static GTY(()) struct cp_binding_level *global_binding_level;
 451
 452 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 453
 454 static int keep_next_level_flag;
 455
 456 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 457    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 458    time the VAR_DECL was declared, the type was incomplete.  */
 459
 460 static GTY(()) tree incomplete_vars;
 461
 462 #if defined(DEBUG_BINDING_LEVELS)
 463 static int binding_depth = 0;
 464 static int is_class_level = 0;
 465
 466 static void
 467 indent ()
 468 {
 469   register unsigned i;
 470
 471   for (i = 0; i < binding_depth*2; i++)
 472     putc (' ', stderr);
 473 }
 474 #endif /* defined(DEBUG_BINDING_LEVELS) */
 475
 476 static tree pushdecl_with_scope PARAMS ((tree, struct cp_binding_level *));
 477
 478 static void
 479 push_binding_level (newlevel, tag_transparent, keep)
 480      struct cp_binding_level *newlevel;
 481      int tag_transparent, keep;
 482 {
 483   /* Add this level to the front of the chain (stack) of levels that
 484      are active.  */
 485   memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
 486   newlevel->level_chain = current_binding_level;
 487   current_binding_level = newlevel;
 488   newlevel->tag_transparent = tag_transparent;
 489   newlevel->more_cleanups_ok = 1;
 490
 491   newlevel->keep = keep;
 492 #if defined(DEBUG_BINDING_LEVELS)
 493   newlevel->binding_depth = binding_depth;
 494   indent ();
 495   fprintf (stderr, "push %s level 0x%08x line %d\n",
 496            (is_class_level) ? "class" : "block", newlevel, lineno);
 497   is_class_level = 0;
 498   binding_depth++;
 499 #endif /* defined(DEBUG_BINDING_LEVELS) */
 500 }
 501
 502 /* Find the innermost enclosing class scope, and reset
 503    CLASS_BINDING_LEVEL appropriately.  */
 504
 505 static void
 506 find_class_binding_level ()
 507 {
 508   struct cp_binding_level *level = current_binding_level;
 509
 510   while (level && level->parm_flag != 2)
 511     level = level->level_chain;
 512   if (level && level->parm_flag == 2)
 513     class_binding_level = level;
 514   else
 515     class_binding_level = 0;
 516 }
 517
 518 static void
 519 pop_binding_level ()
 520 {
 521   if (global_binding_level)
 522     {
 523       /* Cannot pop a level, if there are none left to pop.  */
 524       if (current_binding_level == global_binding_level)
 525         abort ();
 526     }
 527   /* Pop the current level, and free the structure for reuse.  */
 528 #if defined(DEBUG_BINDING_LEVELS)
 529   binding_depth--;
 530   indent ();
 531   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 532           (is_class_level) ? "class" : "block",
 533           current_binding_level, lineno);
 534   if (is_class_level != (current_binding_level == class_binding_level))
 535     {
 536       indent ();
 537       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 538     }
 539   is_class_level = 0;
 540 #endif /* defined(DEBUG_BINDING_LEVELS) */
 541   {
 542     register struct cp_binding_level *level = current_binding_level;
 543     current_binding_level = current_binding_level->level_chain;
 544     level->level_chain = free_binding_level;
 545 #if 0 /* defined(DEBUG_BINDING_LEVELS) */
 546     if (level->binding_depth != binding_depth)
 547       abort ();
 548 #endif /* defined(DEBUG_BINDING_LEVELS) */
 549     free_binding_level = level;
 550     find_class_binding_level ();
 551   }
 552 }
 553
 554 static void
 555 suspend_binding_level ()
 556 {
 557   if (class_binding_level)
 558     current_binding_level = class_binding_level;
 559
 560   if (global_binding_level)
 561     {
 562       /* Cannot suspend a level, if there are none left to suspend.  */
 563       if (current_binding_level == global_binding_level)
 564         abort ();
 565     }
 566   /* Suspend the current level.  */
 567 #if defined(DEBUG_BINDING_LEVELS)
 568   binding_depth--;
 569   indent ();
 570   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 571           (is_class_level) ? "class" : "block",
 572           current_binding_level, lineno);
 573   if (is_class_level != (current_binding_level == class_binding_level))
 574     {
 575       indent ();
 576       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 577     }
 578   is_class_level = 0;
 579 #endif /* defined(DEBUG_BINDING_LEVELS) */
 580   current_binding_level = current_binding_level->level_chain;
 581   find_class_binding_level ();
 582 }
 583
 584 static void
 585 resume_binding_level (b)
 586      struct cp_binding_level *b;
 587 {
 588   /* Resuming binding levels is meant only for namespaces,
 589      and those cannot nest into classes.  */
 590   my_friendly_assert(!class_binding_level, 386);
 591   /* Also, resuming a non-directly nested namespace is a no-no.  */
 592   my_friendly_assert(b->level_chain == current_binding_level, 386);
 593   current_binding_level = b;
 594 #if defined(DEBUG_BINDING_LEVELS)
 595   b->binding_depth = binding_depth;
 596   indent ();
 597   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 598            (is_class_level) ? "class" : "block", b, lineno);
 599   is_class_level = 0;
 600   binding_depth++;
 601 #endif /* defined(DEBUG_BINDING_LEVELS) */
 602 }
 603 \f
 604 /* Create a new `struct cp_binding_level'.  */
 605
 606 static
 607 struct cp_binding_level *
 608 make_binding_level ()
 609 {
 610   /* NOSTRICT */
 611   return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_binding_level));
 612 }
 613
 614 /* Nonzero if we are currently in the global binding level.  */
 615
 616 int
 617 global_bindings_p ()
 618 {
 619   return current_binding_level == global_binding_level;
 620 }
 621
 622 /* Return the innermost binding level that is not for a class scope.  */
 623
 624 static struct cp_binding_level *
 625 innermost_nonclass_level ()
 626 {
 627   struct cp_binding_level *b;
 628
 629   b = current_binding_level;
 630   while (b->parm_flag == 2)
 631     b = b->level_chain;
 632
 633   return b;
 634 }
 635
 636 /* Nonzero if we are currently in a toplevel binding level.  This
 637    means either the global binding level or a namespace in a toplevel
 638    binding level.  Since there are no non-toplevel namespace levels,
 639    this really means any namespace or template parameter level.  We
 640    also include a class whose context is toplevel.  */
 641
 642 int
 643 toplevel_bindings_p ()
 644 {
 645   struct cp_binding_level *b = innermost_nonclass_level ();
 646
 647   return b->namespace_p || b->template_parms_p;
 648 }
 649
 650 /* Nonzero if this is a namespace scope, or if we are defining a class
 651    which is itself at namespace scope, or whose enclosing class is
 652    such a class, etc.  */
 653
 654 int
 655 namespace_bindings_p ()
 656 {
 657   struct cp_binding_level *b = innermost_nonclass_level ();
 658
 659   return b->namespace_p;
 660 }
 661
 662 /* If KEEP is nonzero, make a BLOCK node for the next binding level,
 663    unconditionally.  Otherwise, use the normal logic to decide whether
 664    or not to create a BLOCK.  */
 665
 666 void
 667 keep_next_level (keep)
 668      int keep;
 669 {
 670   keep_next_level_flag = keep;
 671 }
 672
 673 /* Nonzero if the current level needs to have a BLOCK made.  */
 674
 675 int
 676 kept_level_p ()
 677 {
 678   return (current_binding_level->blocks != NULL_TREE
 679           || current_binding_level->keep
 680           || current_binding_level->names != NULL_TREE
 681           || (current_binding_level->tags != NULL_TREE
 682               && !current_binding_level->tag_transparent));
 683 }
 684
 685 static void
 686 declare_namespace_level ()
 687 {
 688   current_binding_level->namespace_p = 1;
 689 }
 690
 691 /* Returns nonzero if this scope was created to store template
 692    parameters.  */
 693
 694 int
 695 template_parm_scope_p ()
 696 {
 697   return current_binding_level->template_parms_p;
 698 }
 699
 700 /* Returns the kind of template specialization we are currently
 701    processing, given that it's declaration contained N_CLASS_SCOPES
 702    explicit scope qualifications.  */
 703
 704 tmpl_spec_kind
 705 current_tmpl_spec_kind (n_class_scopes)
 706      int n_class_scopes;
 707 {
 708   int n_template_parm_scopes = 0;
 709   int seen_specialization_p = 0;
 710   int innermost_specialization_p = 0;
 711   struct cp_binding_level *b;
 712
 713   /* Scan through the template parameter scopes.  */
 714   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 715     {
 716       /* If we see a specialization scope inside a parameter scope,
 717          then something is wrong.  That corresponds to a declaration
 718          like:
 719
 720             template <class T> template <> ...
 721
 722          which is always invalid since [temp.expl.spec] forbids the
 723          specialization of a class member template if the enclosing
 724          class templates are not explicitly specialized as well.  */
 725       if (b->template_spec_p)
 726         {
 727           if (n_template_parm_scopes == 0)
 728             innermost_specialization_p = 1;
 729           else
 730             seen_specialization_p = 1;
 731         }
 732       else if (seen_specialization_p == 1)
 733         return tsk_invalid_member_spec;
 734
 735       ++n_template_parm_scopes;
 736     }
 737
 738   /* Handle explicit instantiations.  */
 739   if (processing_explicit_instantiation)
 740     {
 741       if (n_template_parm_scopes != 0)
 742         /* We've seen a template parameter list during an explicit
 743            instantiation.  For example:
 744
 745              template <class T> template void f(int);
 746
 747            This is erroneous.  */
 748         return tsk_invalid_expl_inst;
 749       else
 750         return tsk_expl_inst;
 751     }
 752
 753   if (n_template_parm_scopes < n_class_scopes)
 754     /* We've not seen enough template headers to match all the
 755        specialized classes present.  For example:
 756
 757          template <class T> void R<T>::S<T>::f(int);
 758
 759        This is invalid; there needs to be one set of template
 760        parameters for each class.  */
 761     return tsk_insufficient_parms;
 762   else if (n_template_parm_scopes == n_class_scopes)
 763     /* We're processing a non-template declaration (even though it may
 764        be a member of a template class.)  For example:
 765
 766          template <class T> void S<T>::f(int);
 767
 768        The `class T' maches the `S<T>', leaving no template headers
 769        corresponding to the `f'.  */
 770     return tsk_none;
 771   else if (n_template_parm_scopes > n_class_scopes + 1)
 772     /* We've got too many template headers.  For example:
 773
 774          template <> template <class T> void f (T);
 775
 776        There need to be more enclosing classes.  */
 777     return tsk_excessive_parms;
 778   else
 779     /* This must be a template.  It's of the form:
 780
 781          template <class T> template <class U> void S<T>::f(U);
 782
 783        This is a specialization if the innermost level was a
 784        specialization; otherwise it's just a definition of the
 785        template.  */
 786     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 787 }
 788
 789 void
 790 set_class_shadows (shadows)
 791      tree shadows;
 792 {
 793   class_binding_level->class_shadowed = shadows;
 794 }
 795
 796 /* Enter a new binding level.
 797    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 798    not for that of tags.  */
 799
 800 void
 801 pushlevel (tag_transparent)
 802      int tag_transparent;
 803 {
 804   struct cp_binding_level *newlevel;
 805
 806   if (cfun && !doing_semantic_analysis_p ())
 807     return;
 808
 809   /* Reuse or create a struct for this binding level.  */
 810 #if defined(DEBUG_BINDING_LEVELS)
 811   if (0)
 812 #else /* !defined(DEBUG_BINDING_LEVELS) */
 813   if (free_binding_level)
 814 #endif /* !defined(DEBUG_BINDING_LEVELS) */
 815     {
 816       newlevel = free_binding_level;
 817       free_binding_level = free_binding_level->level_chain;
 818     }
 819   else
 820     newlevel = make_binding_level ();
 821
 822   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 823   keep_next_level_flag = 0;
 824 }
 825
 826 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 827    we're not allowed to add any more objects with cleanups to the current
 828    scope, create a new binding level.  */
 829
 830 void
 831 maybe_push_cleanup_level (type)
 832      tree type;
 833 {
 834   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 835       && current_binding_level->more_cleanups_ok == 0)
 836     {
 837       keep_next_level (2);
 838       pushlevel (1);
 839       clear_last_expr ();
 840       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 841     }
 842 }
 843
 844 /* Enter a new scope.  The KIND indicates what kind of scope is being
 845    created.  */
 846
 847 void
 848 begin_scope (sk)
 849      scope_kind sk;
 850 {
 851   pushlevel (0);
 852
 853   switch (sk)
 854     {
 855     case sk_block:
 856       break;
 857
 858     case sk_try:
 859       current_binding_level->is_try_scope = 1;
 860       break;
 861
 862     case sk_catch:
 863       current_binding_level->is_catch_scope = 1;
 864       break;
 865
 866     case sk_for:
 867       current_binding_level->is_for_scope = 1;
 868       break;
 869
 870     case sk_template_spec:
 871       current_binding_level->template_spec_p = 1;
 872       /* Fall through.  */
 873
 874     case sk_template_parms:
 875       current_binding_level->template_parms_p = 1;
 876       break;
 877
 878     default:
 879       abort ();
 880     }
 881 }
 882
 883 /* Exit the current scope.  */
 884
 885 void
 886 finish_scope ()
 887 {
 888   poplevel (0, 0, 0);
 889 }
 890
 891 /* For a binding between a name and an entity at a block scope,
 892    this is the `struct cp_binding_level' for the block.  */
 893 #define BINDING_LEVEL(NODE) \
 894   (((struct tree_binding*)(NODE))->scope.level)
 895
 896 /* A free list of CPLUS_BINDING nodes, connected by their
 897    TREE_CHAINs.  */
 898
 899 static GTY((deletable (""))) tree free_bindings;
 900
 901 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 902    level at which this declaration is being bound.  */
 903
 904 static void
 905 push_binding (id, decl, level)
 906      tree id;
 907      tree decl;
 908      struct cp_binding_level* level;
 909 {
 910   tree binding;
 911
 912   if (free_bindings)
 913     {
 914       binding = free_bindings;
 915       free_bindings = TREE_CHAIN (binding);
 916     }
 917   else
 918     binding = make_node (CPLUS_BINDING);
 919
 920   /* Now, fill in the binding information.  */
 921   BINDING_VALUE (binding) = decl;
 922   BINDING_TYPE (binding) = NULL_TREE;
 923   BINDING_LEVEL (binding) = level;
 924   INHERITED_VALUE_BINDING_P (binding) = 0;
 925   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 926   BINDING_HAS_LEVEL_P (binding) = 1;
 927
 928   /* And put it on the front of the list of bindings for ID.  */
 929   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 930   IDENTIFIER_BINDING (id) = binding;
 931 }
 932
 933 /* ID is already bound in the current scope.  But, DECL is an
 934    additional binding for ID in the same scope.  This is the `struct
 935    stat' hack whereby a non-typedef class-name or enum-name can be
 936    bound at the same level as some other kind of entity.  It's the
 937    responsibility of the caller to check that inserting this name is
 938    valid here.  Returns nonzero if the new binding was successful.  */
 939 static int
 940 add_binding (id, decl)
 941      tree id;
 942      tree decl;
 943 {
 944   tree binding = IDENTIFIER_BINDING (id);
 945   int ok = 1;
 946
 947   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 948     /* The new name is the type name.  */
 949     BINDING_TYPE (binding) = decl;
 950   else if (!BINDING_VALUE (binding))
 951     /* This situation arises when push_class_level_binding moves an
 952        inherited type-binding out of the way to make room for a new
 953        value binding.  */
 954     BINDING_VALUE (binding) = decl;
 955   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 956            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 957     {
 958       /* The old binding was a type name.  It was placed in
 959          BINDING_VALUE because it was thought, at the point it was
 960          declared, to be the only entity with such a name.  Move the
 961          type name into the type slot; it is now hidden by the new
 962          binding.  */
 963       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 964       BINDING_VALUE (binding) = decl;
 965       INHERITED_VALUE_BINDING_P (binding) = 0;
 966     }
 967   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 968            && TREE_CODE (decl) == TYPE_DECL
 969            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 970            && (same_type_p (TREE_TYPE (decl),
 971                             TREE_TYPE (BINDING_VALUE (binding)))
 972                /* If either type involves template parameters, we must
 973                   wait until instantiation.  */
 974                || uses_template_parms (TREE_TYPE (decl))
 975                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
 976     /* We have two typedef-names, both naming the same type to have
 977        the same name.  This is OK because of:
 978
 979          [dcl.typedef]
 980
 981          In a given scope, a typedef specifier can be used to redefine
 982          the name of any type declared in that scope to refer to the
 983          type to which it already refers.  */
 984     ok = 0;
 985   /* There can be two block-scope declarations of the same variable,
 986      so long as they are `extern' declarations.  */
 987   else if (TREE_CODE (decl) == VAR_DECL
 988            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
 989            && DECL_EXTERNAL (decl)
 990            && DECL_EXTERNAL (BINDING_VALUE (binding)))
 991     {
 992       duplicate_decls (decl, BINDING_VALUE (binding));
 993       ok = 0;
 994     }
 995   else
 996     {
 997       error ("declaration of `%#D'", decl);
 998       cp_error_at ("conflicts with previous declaration `%#D'",
 999                    BINDING_VALUE (binding));
1000       ok = 0;
1001     }
1002
1003   return ok;
1004 }
1005
1006 /* Add DECL to the list of things declared in B.  */
1007
1008 static void
1009 add_decl_to_level (decl, b)
1010      tree decl;
1011      struct cp_binding_level *b;
1012 {
1013   if (TREE_CODE (decl) == NAMESPACE_DECL
1014       && !DECL_NAMESPACE_ALIAS (decl))
1015     {
1016       TREE_CHAIN (decl) = b->namespaces;
1017       b->namespaces = decl;
1018     }
1019   else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
1020     {
1021       TREE_CHAIN (decl) = b->vtables;
1022       b->vtables = decl;
1023     }
1024   else
1025     {
1026       /* We build up the list in reverse order, and reverse it later if
1027          necessary.  */
1028       TREE_CHAIN (decl) = b->names;
1029       b->names = decl;
1030       b->names_size++;
1031     }
1032 }
1033
1034 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1035    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1036    doesn't really belong to this binding level, that it got here
1037    through a using-declaration.  */
1038
1039 void
1040 push_local_binding (id, decl, flags)
1041      tree id;
1042      tree decl;
1043      int flags;
1044 {
1045   struct cp_binding_level *b;
1046
1047   /* Skip over any local classes.  This makes sense if we call
1048      push_local_binding with a friend decl of a local class.  */
1049   b = current_binding_level;
1050   while (b->parm_flag == 2)
1051     b = b->level_chain;
1052
1053   if (lookup_name_current_level (id))
1054     {
1055       /* Supplement the existing binding.  */
1056       if (!add_binding (id, decl))
1057         /* It didn't work.  Something else must be bound at this
1058            level.  Do not add DECL to the list of things to pop
1059            later.  */
1060         return;
1061     }
1062   else
1063     /* Create a new binding.  */
1064     push_binding (id, decl, b);
1065
1066   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1067     /* We must put the OVERLOAD into a TREE_LIST since the
1068        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1069        decls that got here through a using-declaration.  */
1070     decl = build_tree_list (NULL_TREE, decl);
1071
1072   /* And put DECL on the list of things declared by the current
1073      binding level.  */
1074   add_decl_to_level (decl, b);
1075 }
1076
1077 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1078    binding was successful.  */
1079
1080 int
1081 push_class_binding (id, decl)
1082      tree id;
1083      tree decl;
1084 {
1085   int result = 1;
1086   tree binding = IDENTIFIER_BINDING (id);
1087   tree context;
1088
1089   /* Note that we declared this value so that we can issue an error if
1090      this is an invalid redeclaration of a name already used for some
1091      other purpose.  */
1092   note_name_declared_in_class (id, decl);
1093
1094   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1095     /* Supplement the existing binding.  */
1096     result = add_binding (id, decl);
1097   else
1098     /* Create a new binding.  */
1099     push_binding (id, decl, class_binding_level);
1100
1101   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1102      class-level declaration.  Note that we do not use DECL here
1103      because of the possibility of the `struct stat' hack; if DECL is
1104      a class-name or enum-name we might prefer a field-name, or some
1105      such.  */
1106   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1107
1108   /* If this is a binding from a base class, mark it as such.  */
1109   binding = IDENTIFIER_BINDING (id);
1110   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1111     {
1112       /* Any implicit typename must be from a base-class.  The
1113          context for an implicit typename declaration is always
1114          the derived class in which the lookup was done, so the checks
1115          based on the context of DECL below will not trigger.  */
1116       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1117         INHERITED_VALUE_BINDING_P (binding) = 1;
1118       else
1119         {
1120           if (TREE_CODE (decl) == OVERLOAD)
1121             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1122           else
1123             {
1124               my_friendly_assert (DECL_P (decl), 0);
1125               context = context_for_name_lookup (decl);
1126             }
1127
1128           if (is_properly_derived_from (current_class_type, context))
1129             INHERITED_VALUE_BINDING_P (binding) = 1;
1130           else
1131             INHERITED_VALUE_BINDING_P (binding) = 0;
1132         }
1133     }
1134   else if (BINDING_VALUE (binding) == decl)
1135     /* We only encounter a TREE_LIST when push_class_decls detects an
1136        ambiguity.  Such an ambiguity can be overridden by a definition
1137        in this class.  */
1138     INHERITED_VALUE_BINDING_P (binding) = 1;
1139
1140   return result;
1141 }
1142
1143 /* Remove the binding for DECL which should be the innermost binding
1144    for ID.  */
1145
1146 static void
1147 pop_binding (id, decl)
1148      tree id;
1149      tree decl;
1150 {
1151   tree binding;
1152
1153   if (id == NULL_TREE)
1154     /* It's easiest to write the loops that call this function without
1155        checking whether or not the entities involved have names.  We
1156        get here for such an entity.  */
1157     return;
1158
1159   /* Get the innermost binding for ID.  */
1160   binding = IDENTIFIER_BINDING (id);
1161
1162   /* The name should be bound.  */
1163   my_friendly_assert (binding != NULL_TREE, 0);
1164
1165   /* The DECL will be either the ordinary binding or the type
1166      binding for this identifier.  Remove that binding.  */
1167   if (BINDING_VALUE (binding) == decl)
1168     BINDING_VALUE (binding) = NULL_TREE;
1169   else if (BINDING_TYPE (binding) == decl)
1170     BINDING_TYPE (binding) = NULL_TREE;
1171   else
1172     abort ();
1173
1174   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1175     {
1176       /* We're completely done with the innermost binding for this
1177          identifier.  Unhook it from the list of bindings.  */
1178       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1179
1180       /* Add it to the free list.  */
1181       TREE_CHAIN (binding) = free_bindings;
1182       free_bindings = binding;
1183
1184       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1185          it.  */
1186       BINDING_LEVEL (binding) = NULL;
1187     }
1188 }
1189
1190 /* When a label goes out of scope, check to see if that label was used
1191    in a valid manner, and issue any appropriate warnings or errors.  */
1192
1193 static void
1194 pop_label (label, old_value)
1195      tree label;
1196      tree old_value;
1197 {
1198   if (!processing_template_decl && doing_semantic_analysis_p ())
1199     {
1200       if (DECL_INITIAL (label) == NULL_TREE)
1201         {
1202           cp_error_at ("label `%D' used but not defined", label);
1203           /* Avoid crashing later.  */
1204           define_label (input_filename, 1, DECL_NAME (label));
1205         }
1206       else if (warn_unused_label && !TREE_USED (label))
1207         cp_warning_at ("label `%D' defined but not used", label);
1208     }
1209
1210   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1211 }
1212
1213 /* At the end of a function, all labels declared within the function
1214    go out of scope.  BLOCK is the top-level block for the
1215    function.  */
1216
1217 static void
1218 pop_labels (block)
1219      tree block;
1220 {
1221   struct named_label_list *link;
1222
1223   /* Clear out the definitions of all label names, since their scopes
1224      end here.  */
1225   for (link = named_labels; link; link = link->next)
1226     {
1227       pop_label (link->label_decl, link->old_value);
1228       /* Put the labels into the "variables" of the top-level block,
1229          so debugger can see them.  */
1230       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1231       BLOCK_VARS (block) = link->label_decl;
1232     }
1233
1234   named_labels = NULL;
1235 }
1236
1237 /* Exit a binding level.
1238    Pop the level off, and restore the state of the identifier-decl mappings
1239    that were in effect when this level was entered.
1240
1241    If KEEP == 1, this level had explicit declarations, so
1242    and create a "block" (a BLOCK node) for the level
1243    to record its declarations and subblocks for symbol table output.
1244
1245    If FUNCTIONBODY is nonzero, this level is the body of a function,
1246    so create a block as if KEEP were set and also clear out all
1247    label names.
1248
1249    If REVERSE is nonzero, reverse the order of decls before putting
1250    them into the BLOCK.  */
1251
1252 tree
1253 poplevel (keep, reverse, functionbody)
1254      int keep;
1255      int reverse;
1256      int functionbody;
1257 {
1258   register tree link;
1259   /* The chain of decls was accumulated in reverse order.
1260      Put it into forward order, just for cleanliness.  */
1261   tree decls;
1262   int tmp = functionbody;
1263   int real_functionbody;
1264   tree tags;
1265   tree subblocks;
1266   tree block = NULL_TREE;
1267   tree decl;
1268   int leaving_for_scope;
1269
1270   if (cfun && !doing_semantic_analysis_p ())
1271     return NULL_TREE;
1272
1273   my_friendly_assert (current_binding_level->parm_flag != 2,
1274                       19990916);
1275
1276   real_functionbody = (current_binding_level->keep == 2
1277                        ? ((functionbody = 0), tmp) : functionbody);
1278   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1279   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1280
1281   my_friendly_assert (!current_binding_level->class_shadowed,
1282                       19990414);
1283
1284   /* We used to use KEEP == 2 to indicate that the new block should go
1285      at the beginning of the list of blocks at this binding level,
1286      rather than the end.  This hack is no longer used.  */
1287   my_friendly_assert (keep == 0 || keep == 1, 0);
1288
1289   if (current_binding_level->keep == 1)
1290     keep = 1;
1291
1292   /* Any uses of undefined labels, and any defined labels, now operate
1293      under constraints of next binding contour.  */
1294   if (cfun && !functionbody)
1295     {
1296       struct cp_binding_level *level_chain;
1297       level_chain = current_binding_level->level_chain;
1298       if (level_chain)
1299         {
1300           struct named_label_use_list *uses;
1301           struct named_label_list *labels;
1302           for (labels = named_labels; labels; labels = labels->next)
1303             if (labels->binding_level == current_binding_level)
1304               {
1305                 tree decl;
1306                 if (current_binding_level->is_try_scope)
1307                   labels->in_try_scope = 1;
1308                 if (current_binding_level->is_catch_scope)
1309                   labels->in_catch_scope = 1;
1310                 for (decl = labels->names_in_scope; decl;
1311                      decl = TREE_CHAIN (decl))
1312                   if (decl_jump_unsafe (decl))
1313                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1314                                                    labels->bad_decls);
1315                 labels->binding_level = level_chain;
1316                 labels->names_in_scope = level_chain->names;
1317               }
1318
1319           for (uses = named_label_uses; uses; uses = uses->next)
1320             if (uses->binding_level == current_binding_level)
1321               {
1322                 uses->binding_level = level_chain;
1323                 uses->names_in_scope = level_chain->names;
1324               }
1325         }
1326     }
1327
1328   /* Get the decls in the order they were written.
1329      Usually current_binding_level->names is in reverse order.
1330      But parameter decls were previously put in forward order.  */
1331
1332   if (reverse)
1333     current_binding_level->names
1334       = decls = nreverse (current_binding_level->names);
1335   else
1336     decls = current_binding_level->names;
1337
1338   /* Output any nested inline functions within this block
1339      if they weren't already output.  */
1340   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1341     if (TREE_CODE (decl) == FUNCTION_DECL
1342         && ! TREE_ASM_WRITTEN (decl)
1343         && DECL_INITIAL (decl) != NULL_TREE
1344         && TREE_ADDRESSABLE (decl)
1345         && decl_function_context (decl) == current_function_decl)
1346       {
1347         /* If this decl was copied from a file-scope decl
1348            on account of a block-scope extern decl,
1349            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1350         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1351           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1352         else
1353           {
1354             push_function_context ();
1355             output_inline_function (decl);
1356             pop_function_context ();
1357           }
1358       }
1359
1360   /* When not in function-at-a-time mode, expand_end_bindings will
1361      warn about unused variables.  But, in function-at-a-time mode
1362      expand_end_bindings is not passed the list of variables in the
1363      current scope, and therefore no warning is emitted.  So, we
1364      explicitly warn here.  */
1365   if (!processing_template_decl)
1366     warn_about_unused_variables (getdecls ());
1367
1368   /* If there were any declarations or structure tags in that level,
1369      or if this level is a function body,
1370      create a BLOCK to record them for the life of this function.  */
1371   block = NULL_TREE;
1372   if (keep == 1 || functionbody)
1373     block = make_node (BLOCK);
1374   if (block != NULL_TREE)
1375     {
1376       BLOCK_VARS (block) = decls;
1377       BLOCK_SUBBLOCKS (block) = subblocks;
1378     }
1379
1380   /* In each subblock, record that this is its superior.  */
1381   if (keep >= 0)
1382     for (link = subblocks; link; link = TREE_CHAIN (link))
1383       BLOCK_SUPERCONTEXT (link) = block;
1384
1385   /* We still support the old for-scope rules, whereby the variables
1386      in a for-init statement were in scope after the for-statement
1387      ended.  We only use the new rules if flag_new_for_scope is
1388      nonzero.  */
1389   leaving_for_scope
1390     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1391
1392   /* Remove declarations for all the DECLs in this level.  */
1393   for (link = decls; link; link = TREE_CHAIN (link))
1394     {
1395       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1396           && DECL_NAME (link))
1397         {
1398           tree outer_binding
1399             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1400           tree ns_binding;
1401
1402           if (!outer_binding)
1403             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1404           else
1405             ns_binding = NULL_TREE;
1406
1407           if (outer_binding
1408               && (BINDING_LEVEL (outer_binding)
1409                   == current_binding_level->level_chain))
1410             /* We have something like:
1411
1412                  int i;
1413                  for (int i; ;);
1414
1415                and we are leaving the `for' scope.  There's no reason to
1416                keep the binding of the inner `i' in this case.  */
1417             pop_binding (DECL_NAME (link), link);
1418           else if ((outer_binding
1419                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1420                         == TYPE_DECL))
1421                    || (ns_binding
1422                        && TREE_CODE (ns_binding) == TYPE_DECL))
1423             /* Here, we have something like:
1424
1425                  typedef int I;
1426
1427                  void f () {
1428                    for (int I; ;);
1429                  }
1430
1431                We must pop the for-scope binding so we know what's a
1432                type and what isn't.  */
1433             pop_binding (DECL_NAME (link), link);
1434           else
1435             {
1436               /* Mark this VAR_DECL as dead so that we can tell we left it
1437                  there only for backward compatibility.  */
1438               DECL_DEAD_FOR_LOCAL (link) = 1;
1439
1440               /* Keep track of what should of have happenned when we
1441                  popped the binding.  */
1442               if (outer_binding && BINDING_VALUE (outer_binding))
1443                 DECL_SHADOWED_FOR_VAR (link)
1444                   = BINDING_VALUE (outer_binding);
1445
1446               /* Add it to the list of dead variables in the next
1447                  outermost binding to that we can remove these when we
1448                  leave that binding.  */
1449               current_binding_level->level_chain->dead_vars_from_for
1450                 = tree_cons (NULL_TREE, link,
1451                              current_binding_level->level_chain->
1452                              dead_vars_from_for);
1453
1454               /* Although we don't pop the CPLUS_BINDING, we do clear
1455                  its BINDING_LEVEL since the level is going away now.  */
1456               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1457                 = 0;
1458             }
1459         }
1460       else
1461         {
1462           /* Remove the binding.  */
1463           decl = link;
1464           if (TREE_CODE (decl) == TREE_LIST)
1465             decl = TREE_VALUE (decl);
1466           if (DECL_P (decl))
1467             pop_binding (DECL_NAME (decl), decl);
1468           else if (TREE_CODE (decl) == OVERLOAD)
1469             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1470           else
1471             abort ();
1472         }
1473     }
1474
1475   /* Remove declarations for any `for' variables from inner scopes
1476      that we kept around.  */
1477   for (link = current_binding_level->dead_vars_from_for;
1478        link; link = TREE_CHAIN (link))
1479     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1480
1481   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1482   for (link = current_binding_level->type_shadowed;
1483        link; link = TREE_CHAIN (link))
1484     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1485
1486   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1487   for (link = current_binding_level->shadowed_labels;
1488        link;
1489        link = TREE_CHAIN (link))
1490     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1491
1492   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1493      list if a `using' declaration put them there.  The debugging
1494      back-ends won't understand OVERLOAD, so we remove them here.
1495      Because the BLOCK_VARS are (temporarily) shared with
1496      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1497      popped all the bindings.  */
1498   if (block)
1499     {
1500       tree* d;
1501
1502       for (d = &BLOCK_VARS (block); *d; )
1503         {
1504           if (TREE_CODE (*d) == TREE_LIST)
1505             *d = TREE_CHAIN (*d);
1506           else
1507             d = &TREE_CHAIN (*d);
1508         }
1509     }
1510
1511   /* If the level being exited is the top level of a function,
1512      check over all the labels.  */
1513   if (functionbody)
1514     {
1515       /* Since this is the top level block of a function, the vars are
1516          the function's parameters.  Don't leave them in the BLOCK
1517          because they are found in the FUNCTION_DECL instead.  */
1518       BLOCK_VARS (block) = 0;
1519       pop_labels (block);
1520     }
1521
1522   tmp = current_binding_level->keep;
1523
1524   pop_binding_level ();
1525   if (functionbody)
1526     DECL_INITIAL (current_function_decl) = block;
1527   else if (block)
1528     current_binding_level->blocks
1529       = chainon (current_binding_level->blocks, block);
1530
1531   /* If we did not make a block for the level just exited,
1532      any blocks made for inner levels
1533      (since they cannot be recorded as subblocks in that level)
1534      must be carried forward so they will later become subblocks
1535      of something else.  */
1536   else if (subblocks)
1537     current_binding_level->blocks
1538       = chainon (current_binding_level->blocks, subblocks);
1539
1540   /* Each and every BLOCK node created here in `poplevel' is important
1541      (e.g. for proper debugging information) so if we created one
1542      earlier, mark it as "used".  */
1543   if (block)
1544     TREE_USED (block) = 1;
1545
1546   /* Take care of compiler's internal binding structures.  */
1547   if (tmp == 2)
1548     {
1549       tree scope_stmts;
1550
1551       scope_stmts
1552         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1553       if (block)
1554         {
1555           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1556           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1557         }
1558
1559       block = poplevel (keep, reverse, functionbody);
1560     }
1561
1562   return block;
1563 }
1564
1565 /* Delete the node BLOCK from the current binding level.
1566    This is used for the block inside a stmt expr ({...})
1567    so that the block can be reinserted where appropriate.  */
1568
1569 void
1570 delete_block (block)
1571      tree block;
1572 {
1573   tree t;
1574   if (current_binding_level->blocks == block)
1575     current_binding_level->blocks = TREE_CHAIN (block);
1576   for (t = current_binding_level->blocks; t;)
1577     {
1578       if (TREE_CHAIN (t) == block)
1579         TREE_CHAIN (t) = TREE_CHAIN (block);
1580       else
1581         t = TREE_CHAIN (t);
1582     }
1583   TREE_CHAIN (block) = NULL_TREE;
1584   /* Clear TREE_USED which is always set by poplevel.
1585      The flag is set again if insert_block is called.  */
1586   TREE_USED (block) = 0;
1587 }
1588
1589 /* Insert BLOCK at the end of the list of subblocks of the
1590    current binding level.  This is used when a BIND_EXPR is expanded,
1591    to handle the BLOCK node inside the BIND_EXPR.  */
1592
1593 void
1594 insert_block (block)
1595      tree block;
1596 {
1597   TREE_USED (block) = 1;
1598   current_binding_level->blocks
1599     = chainon (current_binding_level->blocks, block);
1600 }
1601
1602 /* Set the BLOCK node for the innermost scope
1603    (the one we are currently in).  */
1604
1605 void
1606 set_block (block)
1607     tree block ATTRIBUTE_UNUSED;
1608 {
1609   /* The RTL expansion machinery requires us to provide this callback,
1610      but it is not applicable in function-at-a-time mode.  */
1611   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1612 }
1613
1614 /* Do a pushlevel for class declarations.  */
1615
1616 void
1617 pushlevel_class ()
1618 {
1619   register struct cp_binding_level *newlevel;
1620
1621   /* Reuse or create a struct for this binding level.  */
1622 #if defined(DEBUG_BINDING_LEVELS)
1623   if (0)
1624 #else /* !defined(DEBUG_BINDING_LEVELS) */
1625   if (free_binding_level)
1626 #endif /* !defined(DEBUG_BINDING_LEVELS) */
1627     {
1628       newlevel = free_binding_level;
1629       free_binding_level = free_binding_level->level_chain;
1630     }
1631   else
1632     newlevel = make_binding_level ();
1633
1634 #if defined(DEBUG_BINDING_LEVELS)
1635   is_class_level = 1;
1636 #endif /* defined(DEBUG_BINDING_LEVELS) */
1637
1638   push_binding_level (newlevel, 0, 0);
1639
1640   class_binding_level = current_binding_level;
1641   class_binding_level->parm_flag = 2;
1642   class_binding_level->this_class = current_class_type;
1643 }
1644
1645 /* ...and a poplevel for class declarations.  */
1646
1647 void
1648 poplevel_class ()
1649 {
1650   register struct cp_binding_level *level = class_binding_level;
1651   tree shadowed;
1652
1653   my_friendly_assert (level != 0, 354);
1654
1655   /* If we're leaving a toplevel class, don't bother to do the setting
1656      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1657      shouldn't even be used when current_class_type isn't set, and second,
1658      if we don't touch it here, we're able to use the cache effect if the
1659      next time we're entering a class scope, it is the same class.  */
1660   if (current_class_depth != 1)
1661     {
1662       struct cp_binding_level* b;
1663
1664       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1665       for (shadowed = level->class_shadowed;
1666            shadowed;
1667            shadowed = TREE_CHAIN (shadowed))
1668         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1669
1670       /* Find the next enclosing class, and recreate
1671          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1672       b = level->level_chain;
1673       while (b && b->parm_flag != 2)
1674         b = b->level_chain;
1675
1676       if (b)
1677         for (shadowed = b->class_shadowed;
1678              shadowed;
1679              shadowed = TREE_CHAIN (shadowed))
1680           {
1681             tree t;
1682
1683             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1684             while (t && BINDING_LEVEL (t) != b)
1685               t = TREE_CHAIN (t);
1686
1687             if (t)
1688               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1689                 = BINDING_VALUE (t);
1690           }
1691     }
1692   else
1693     /* Remember to save what IDENTIFIER's were bound in this scope so we
1694        can recover from cache misses.  */
1695     {
1696       previous_class_type = current_class_type;
1697       previous_class_values = class_binding_level->class_shadowed;
1698     }
1699   for (shadowed = level->type_shadowed;
1700        shadowed;
1701        shadowed = TREE_CHAIN (shadowed))
1702     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1703
1704   /* Remove the bindings for all of the class-level declarations.  */
1705   for (shadowed = level->class_shadowed;
1706        shadowed;
1707        shadowed = TREE_CHAIN (shadowed))
1708     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1709
1710   /* Now, pop out of the binding level which we created up in the
1711      `pushlevel_class' routine.  */
1712 #if defined(DEBUG_BINDING_LEVELS)
1713   is_class_level = 1;
1714 #endif /* defined(DEBUG_BINDING_LEVELS) */
1715
1716   pop_binding_level ();
1717 }
1718
1719 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1720    for any names in enclosing classes.  */
1721
1722 void
1723 clear_identifier_class_values ()
1724 {
1725   tree t;
1726
1727   if (!class_binding_level)
1728     return;
1729
1730   for (t = class_binding_level->class_shadowed;
1731        t;
1732        t = TREE_CHAIN (t))
1733     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1734 }
1735
1736 /* Returns nonzero if T is a virtual function table.  */
1737
1738 int
1739 vtable_decl_p (t, data)
1740      tree t;
1741      void *data ATTRIBUTE_UNUSED;
1742 {
1743   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1744 }
1745
1746 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
1747    functions.  */
1748
1749 int
1750 vtype_decl_p (t, data)
1751      tree t;
1752      void *data ATTRIBUTE_UNUSED;
1753 {
1754   return (TREE_CODE (t) == TYPE_DECL
1755           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1756           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1757 }
1758
1759 /* Return the declarations that are members of the namespace NS.  */
1760
1761 tree
1762 cp_namespace_decls (ns)
1763      tree ns;
1764 {
1765   return NAMESPACE_LEVEL (ns)->names;
1766 }
1767
1768 struct walk_globals_data {
1769   walk_globals_pred p;
1770   walk_globals_fn f;
1771   void *data;
1772 };
1773
1774 /* Walk the vtable declarations in NAMESPACE.  Whenever one is found
1775    for which P returns nonzero, call F with its address.  If any call
1776    to F returns a nonzero value, return a nonzero value.  */
1777
1778 static int
1779 walk_vtables_r (namespace, data)
1780      tree namespace;
1781      void *data;
1782 {
1783   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1784   walk_globals_fn f = wgd->f;
1785   void *d = wgd->data;
1786   tree decl = NAMESPACE_LEVEL (namespace)->vtables;
1787   int result = 0;
1788
1789   for (; decl ; decl = TREE_CHAIN (decl))
1790     result |= (*f) (&decl, d);
1791
1792   return result;
1793 }
1794
1795 /* Walk the vtable declarations.  Whenever one is found for which P
1796    returns nonzero, call F with its address.  If any call to F
1797    returns a nonzero value, return a nonzero value.  */
1798 bool
1799 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
1800 {
1801   struct walk_globals_data wgd;
1802   wgd.p = p;
1803   wgd.f = f;
1804   wgd.data = data;
1805
1806   return walk_namespaces (walk_vtables_r, &wgd);
1807 }
1808
1809 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1810    itself, calling F for each.  The DATA is passed to F as well.  */
1811
1812 static int
1813 walk_namespaces_r (namespace, f, data)
1814      tree namespace;
1815      walk_namespaces_fn f;
1816      void *data;
1817 {
1818   int result = 0;
1819   tree current = NAMESPACE_LEVEL (namespace)->namespaces;
1820
1821   result |= (*f) (namespace, data);
1822
1823   for (; current; current = TREE_CHAIN (current))
1824     result |= walk_namespaces_r (current, f, data);
1825
1826   return result;
1827 }
1828
1829 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1830    F as well.  */
1831
1832 int
1833 walk_namespaces (f, data)
1834      walk_namespaces_fn f;
1835      void *data;
1836 {
1837   return walk_namespaces_r (global_namespace, f, data);
1838 }
1839
1840 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1841    for which P returns nonzero, call F with its address.  If any call
1842    to F returns a nonzero value, return a nonzero value.  */
1843
1844 static int
1845 walk_globals_r (namespace, data)
1846      tree namespace;
1847      void *data;
1848 {
1849   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1850   walk_globals_pred p = wgd->p;
1851   walk_globals_fn f = wgd->f;
1852   void *d = wgd->data;
1853   tree *t;
1854   int result = 0;
1855
1856   t = &NAMESPACE_LEVEL (namespace)->names;
1857
1858   while (*t)
1859     {
1860       tree glbl = *t;
1861
1862       if ((*p) (glbl, d))
1863         result |= (*f) (t, d);
1864
1865       /* If F changed *T, then *T still points at the next item to
1866          examine.  */
1867       if (*t == glbl)
1868         t = &TREE_CHAIN (*t);
1869     }
1870
1871   return result;
1872 }
1873
1874 /* Walk the global declarations.  Whenever one is found for which P
1875    returns true, call F with its address.  If any call to F
1876    returns true, return true.  */
1877
1878 bool
1879 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
1880 {
1881   struct walk_globals_data wgd;
1882   wgd.p = p;
1883   wgd.f = f;
1884   wgd.data = data;
1885
1886   return walk_namespaces (walk_globals_r, &wgd);
1887 }
1888
1889 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1890    DATA is non-NULL, this is the last time we will call
1891    wrapup_global_declarations for this NAMESPACE.  */
1892
1893 int
1894 wrapup_globals_for_namespace (namespace, data)
1895      tree namespace;
1896      void *data;
1897 {
1898   tree globals = cp_namespace_decls (namespace);
1899   int len = NAMESPACE_LEVEL (namespace)->names_size;
1900   tree *vec = (tree *) alloca (sizeof (tree) * len);
1901   int i;
1902   int result;
1903   tree decl;
1904   int last_time = (data != 0);
1905
1906   if (last_time && namespace == global_namespace)
1907     /* Let compile_file handle the global namespace.  */
1908     return 0;
1909
1910   /* Process the decls in reverse order--earliest first.
1911      Put them into VEC from back to front, then take out from front.  */
1912   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1913     vec[len - i - 1] = decl;
1914
1915   if (last_time)
1916     {
1917       check_global_declarations (vec, len);
1918       return 0;
1919     }
1920
1921   /* Write out any globals that need to be output.  */
1922   result = wrapup_global_declarations (vec, len);
1923
1924   return result;
1925 }
1926
1927 \f
1928 /* For debugging.  */
1929 static int no_print_functions = 0;
1930 static int no_print_builtins = 0;
1931
1932 void
1933 print_binding_level (lvl)
1934      struct cp_binding_level *lvl;
1935 {
1936   tree t;
1937   int i = 0, len;
1938   fprintf (stderr, " blocks=");
1939   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1940   if (lvl->tag_transparent)
1941     fprintf (stderr, " tag-transparent");
1942   if (lvl->more_cleanups_ok)
1943     fprintf (stderr, " more-cleanups-ok");
1944   if (lvl->have_cleanups)
1945     fprintf (stderr, " have-cleanups");
1946   fprintf (stderr, "\n");
1947   if (lvl->names)
1948     {
1949       fprintf (stderr, " names:\t");
1950       /* We can probably fit 3 names to a line?  */
1951       for (t = lvl->names; t; t = TREE_CHAIN (t))
1952         {
1953           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1954             continue;
1955           if (no_print_builtins
1956               && (TREE_CODE (t) == TYPE_DECL)
1957               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1958             continue;
1959
1960           /* Function decls tend to have longer names.  */
1961           if (TREE_CODE (t) == FUNCTION_DECL)
1962             len = 3;
1963           else
1964             len = 2;
1965           i += len;
1966           if (i > 6)
1967             {
1968               fprintf (stderr, "\n\t");
1969               i = len;
1970             }
1971           print_node_brief (stderr, "", t, 0);
1972           if (t == error_mark_node)
1973             break;
1974         }
1975       if (i)
1976         fprintf (stderr, "\n");
1977     }
1978   if (lvl->tags)
1979     {
1980       fprintf (stderr, " tags:\t");
1981       i = 0;
1982       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1983         {
1984           if (TREE_PURPOSE (t) == NULL_TREE)
1985             len = 3;
1986           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1987             len = 2;
1988           else
1989             len = 4;
1990           i += len;
1991           if (i > 5)
1992             {
1993               fprintf (stderr, "\n\t");
1994               i = len;
1995             }
1996           if (TREE_PURPOSE (t) == NULL_TREE)
1997             {
1998               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1999               fprintf (stderr, ">");
2000             }
2001           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2002             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2003           else
2004             {
2005               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2006               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2007               fprintf (stderr, ">");
2008             }
2009         }
2010       if (i)
2011         fprintf (stderr, "\n");
2012     }
2013   if (lvl->class_shadowed)
2014     {
2015       fprintf (stderr, " class-shadowed:");
2016       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2017         {
2018           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2019         }
2020       fprintf (stderr, "\n");
2021     }
2022   if (lvl->type_shadowed)
2023     {
2024       fprintf (stderr, " type-shadowed:");
2025       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2026         {
2027           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2028         }
2029       fprintf (stderr, "\n");
2030     }
2031 }
2032
2033 void
2034 print_other_binding_stack (stack)
2035      struct cp_binding_level *stack;
2036 {
2037   struct cp_binding_level *level;
2038   for (level = stack; level != global_binding_level; level = level->level_chain)
2039     {
2040       fprintf (stderr, "binding level ");
2041       fprintf (stderr, HOST_PTR_PRINTF, level);
2042       fprintf (stderr, "\n");
2043       print_binding_level (level);
2044     }
2045 }
2046
2047 void
2048 print_binding_stack ()
2049 {
2050   struct cp_binding_level *b;
2051   fprintf (stderr, "current_binding_level=");
2052   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2053   fprintf (stderr, "\nclass_binding_level=");
2054   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2055   fprintf (stderr, "\nglobal_binding_level=");
2056   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2057   fprintf (stderr, "\n");
2058   if (class_binding_level)
2059     {
2060       for (b = class_binding_level; b; b = b->level_chain)
2061         if (b == current_binding_level)
2062           break;
2063       if (b)
2064         b = class_binding_level;
2065       else
2066         b = current_binding_level;
2067     }
2068   else
2069     b = current_binding_level;
2070   print_other_binding_stack (b);
2071   fprintf (stderr, "global:\n");
2072   print_binding_level (global_binding_level);
2073 }
2074
2075 /* Namespace binding access routines: The namespace_bindings field of
2076    the identifier is polymorphic, with three possible values:
2077    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2078    indicating the BINDING_VALUE of global_namespace.  */
2079
2080 /* Check whether the a binding for the name to scope is known.
2081    Assumes that the bindings of the name are already a list
2082    of bindings. Returns the binding found, or NULL_TREE.  */
2083
2084 static tree
2085 find_binding (name, scope)
2086      tree name;
2087      tree scope;
2088 {
2089   tree iter, prev = NULL_TREE;
2090
2091   scope = ORIGINAL_NAMESPACE (scope);
2092
2093   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2094        iter = TREE_CHAIN (iter))
2095     {
2096       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2097       if (BINDING_SCOPE (iter) == scope)
2098         {
2099           /* Move binding found to the front of the list, so
2100              subsequent lookups will find it faster.  */
2101           if (prev)
2102             {
2103               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2104               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2105               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2106             }
2107           return iter;
2108         }
2109       prev = iter;
2110     }
2111   return NULL_TREE;
2112 }
2113
2114 /* Always returns a binding for name in scope. If the
2115    namespace_bindings is not a list, convert it to one first.
2116    If no binding is found, make a new one.  */
2117
2118 tree
2119 binding_for_name (name, scope)
2120      tree name;
2121      tree scope;
2122 {
2123   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2124   tree result;
2125
2126   scope = ORIGINAL_NAMESPACE (scope);
2127
2128   if (b && TREE_CODE (b) != CPLUS_BINDING)
2129     {
2130       /* Get rid of optimization for global scope.  */
2131       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2132       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2133       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2134     }
2135   if (b && (result = find_binding (name, scope)))
2136     return result;
2137   /* Not found, make a new one.  */
2138   result = make_node (CPLUS_BINDING);
2139   TREE_CHAIN (result) = b;
2140   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2141   BINDING_SCOPE (result) = scope;
2142   BINDING_TYPE (result) = NULL_TREE;
2143   BINDING_VALUE (result) = NULL_TREE;
2144   return result;
2145 }
2146
2147 /* Return the binding value for name in scope, considering that
2148    namespace_binding may or may not be a list of CPLUS_BINDINGS.  */
2149
2150 tree
2151 namespace_binding (name, scope)
2152      tree name;
2153      tree scope;
2154 {
2155   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2156   if (b == NULL_TREE)
2157     return NULL_TREE;
2158   if (scope == NULL_TREE)
2159     scope = global_namespace;
2160   if (TREE_CODE (b) != CPLUS_BINDING)
2161     return (scope == global_namespace) ? b : NULL_TREE;
2162   name = find_binding (name,scope);
2163   if (name == NULL_TREE)
2164     return name;
2165   return BINDING_VALUE (name);
2166 }
2167
2168 /* Set the binding value for name in scope. If modifying the binding
2169    of global_namespace is attempted, try to optimize it.  */
2170
2171 void
2172 set_namespace_binding (name, scope, val)
2173      tree name;
2174      tree scope;
2175      tree val;
2176 {
2177   tree b;
2178
2179   if (scope == NULL_TREE)
2180     scope = global_namespace;
2181
2182   if (scope == global_namespace)
2183     {
2184       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2185       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2186         {
2187           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2188           return;
2189         }
2190     }
2191   b = binding_for_name (name, scope);
2192   BINDING_VALUE (b) = val;
2193 }
2194
2195 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2196    select a name that is unique to this compilation unit.  */
2197
2198 void
2199 push_namespace (name)
2200      tree name;
2201 {
2202   tree d = NULL_TREE;
2203   int need_new = 1;
2204   int implicit_use = 0;
2205   int global = 0;
2206   if (!global_namespace)
2207     {
2208       /* This must be ::.  */
2209       my_friendly_assert (name == get_identifier ("::"), 377);
2210       global = 1;
2211     }
2212   else if (!name)
2213     {
2214       /* The name of anonymous namespace is unique for the translation
2215          unit.  */
2216       if (!anonymous_namespace_name)
2217         anonymous_namespace_name = get_file_function_name ('N');
2218       name = anonymous_namespace_name;
2219       d = IDENTIFIER_NAMESPACE_VALUE (name);
2220       if (d)
2221         /* Reopening anonymous namespace.  */
2222         need_new = 0;
2223       implicit_use = 1;
2224     }
2225   else
2226     {
2227       /* Check whether this is an extended namespace definition.  */
2228       d = IDENTIFIER_NAMESPACE_VALUE (name);
2229       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2230         {
2231           need_new = 0;
2232           if (DECL_NAMESPACE_ALIAS (d))
2233             {
2234               error ("namespace alias `%D' not allowed here, assuming `%D'",
2235                         d, DECL_NAMESPACE_ALIAS (d));
2236               d = DECL_NAMESPACE_ALIAS (d);
2237             }
2238         }
2239     }
2240
2241   if (need_new)
2242     {
2243       /* Make a new namespace, binding the name to it.  */
2244       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2245       /* The global namespace is not pushed, and the global binding
2246          level is set elsewhere.  */
2247       if (!global)
2248         {
2249           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2250           d = pushdecl (d);
2251           pushlevel (0);
2252           declare_namespace_level ();
2253           NAMESPACE_LEVEL (d) = current_binding_level;
2254         }
2255     }
2256   else
2257     resume_binding_level (NAMESPACE_LEVEL (d));
2258
2259   if (implicit_use)
2260     do_using_directive (d);
2261   /* Enter the name space.  */
2262   current_namespace = d;
2263 }
2264
2265 /* Pop from the scope of the current namespace.  */
2266
2267 void
2268 pop_namespace ()
2269 {
2270   my_friendly_assert (current_namespace != global_namespace, 20010801);
2271   current_namespace = CP_DECL_CONTEXT (current_namespace);
2272   /* The binding level is not popped, as it might be re-opened later.  */
2273   suspend_binding_level ();
2274 }
2275
2276 /* Push into the scope of the namespace NS, even if it is deeply
2277    nested within another namespace.  */
2278
2279 void
2280 push_nested_namespace (ns)
2281      tree ns;
2282 {
2283   if (ns == global_namespace)
2284     push_to_top_level ();
2285   else
2286     {
2287       push_nested_namespace (CP_DECL_CONTEXT (ns));
2288       push_namespace (DECL_NAME (ns));
2289     }
2290 }
2291
2292 /* Pop back from the scope of the namespace NS, which was previously
2293    entered with push_nested_namespace.  */
2294
2295 void
2296 pop_nested_namespace (ns)
2297      tree ns;
2298 {
2299   while (ns != global_namespace)
2300     {
2301       pop_namespace ();
2302       ns = CP_DECL_CONTEXT (ns);
2303     }
2304
2305   pop_from_top_level ();
2306 }
2307
2308 \f
2309 /* Subroutines for reverting temporarily to top-level for instantiation
2310    of templates and such.  We actually need to clear out the class- and
2311    local-value slots of all identifiers, so that only the global values
2312    are at all visible.  Simply setting current_binding_level to the global
2313    scope isn't enough, because more binding levels may be pushed.  */
2314 struct saved_scope *scope_chain;
2315
2316 static tree
2317 store_bindings (names, old_bindings)
2318      tree names, old_bindings;
2319 {
2320   tree t;
2321   tree search_bindings = old_bindings;
2322
2323   for (t = names; t; t = TREE_CHAIN (t))
2324     {
2325       tree binding, t1, id;
2326
2327       if (TREE_CODE (t) == TREE_LIST)
2328         id = TREE_PURPOSE (t);
2329       else
2330         id = DECL_NAME (t);
2331
2332       if (!id
2333           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2334              we have no IDENTIFIER_BINDING if we have left the class
2335              scope, but cached the class-level declarations.  */
2336           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2337         continue;
2338
2339       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2340         if (TREE_VEC_ELT (t1, 0) == id)
2341           goto skip_it;
2342
2343       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2344       binding = make_tree_vec (4);
2345       TREE_VEC_ELT (binding, 0) = id;
2346       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2347       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2348       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2349       IDENTIFIER_BINDING (id) = NULL_TREE;
2350       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2351       TREE_CHAIN (binding) = old_bindings;
2352       old_bindings = binding;
2353     skip_it:
2354       ;
2355     }
2356   return old_bindings;
2357 }
2358
2359 void
2360 maybe_push_to_top_level (pseudo)
2361      int pseudo;
2362 {
2363   struct saved_scope *s;
2364   struct cp_binding_level *b;
2365   tree old_bindings;
2366   int need_pop;
2367
2368   s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));
2369
2370   b = scope_chain ? current_binding_level : 0;
2371
2372   /* If we're in the middle of some function, save our state.  */
2373   if (cfun)
2374     {
2375       need_pop = 1;
2376       push_function_context_to (NULL_TREE);
2377     }
2378   else
2379     need_pop = 0;
2380
2381   old_bindings = NULL_TREE;
2382   if (scope_chain && previous_class_type)
2383     old_bindings = store_bindings (previous_class_values, old_bindings);
2384
2385   /* Have to include global_binding_level, because class-level decls
2386      aren't listed anywhere useful.  */
2387   for (; b; b = b->level_chain)
2388     {
2389       tree t;
2390
2391       /* Template IDs are inserted into the global level. If they were
2392          inserted into namespace level, finish_file wouldn't find them
2393          when doing pending instantiations. Therefore, don't stop at
2394          namespace level, but continue until :: .  */
2395       if (b == global_binding_level || (pseudo && b->template_parms_p))
2396         break;
2397
2398       old_bindings = store_bindings (b->names, old_bindings);
2399       /* We also need to check class_shadowed to save class-level type
2400          bindings, since pushclass doesn't fill in b->names.  */
2401       if (b->parm_flag == 2)
2402         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2403
2404       /* Unwind type-value slots back to top level.  */
2405       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2406         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2407     }
2408   s->prev = scope_chain;
2409   s->old_bindings = old_bindings;
2410   s->bindings = b;
2411   s->need_pop_function_context = need_pop;
2412   s->function_decl = current_function_decl;
2413   s->last_parms = last_function_parms;
2414   s->check_access = flag_access_control;
2415
2416   scope_chain = s;
2417   current_function_decl = NULL_TREE;
2418   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2419   current_lang_name = lang_name_cplusplus;
2420   current_namespace = global_namespace;
2421 }
2422
2423 void
2424 push_to_top_level ()
2425 {
2426   maybe_push_to_top_level (0);
2427 }
2428
2429 void
2430 pop_from_top_level ()
2431 {
2432   struct saved_scope *s = scope_chain;
2433   tree t;
2434
2435   /* Clear out class-level bindings cache.  */
2436   if (previous_class_type)
2437     invalidate_class_lookup_cache ();
2438
2439   current_lang_base = 0;
2440
2441   scope_chain = s->prev;
2442   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2443     {
2444       tree id = TREE_VEC_ELT (t, 0);
2445
2446       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2447       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2448       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2449     }
2450
2451   /* If we were in the middle of compiling a function, restore our
2452      state.  */
2453   if (s->need_pop_function_context)
2454     pop_function_context_from (NULL_TREE);
2455   current_function_decl = s->function_decl;
2456   last_function_parms = s->last_parms;
2457 }
2458 \f
2459 /* Push a definition of struct, union or enum tag "name".
2460    into binding_level "b".   "type" should be the type node,
2461    We assume that the tag "name" is not already defined.
2462
2463    Note that the definition may really be just a forward reference.
2464    In that case, the TYPE_SIZE will be a NULL_TREE.
2465
2466    C++ gratuitously puts all these tags in the name space.  */
2467
2468 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2469    record the shadowed value for this binding contour.  TYPE is
2470    the type that ID maps to.  */
2471
2472 static void
2473 set_identifier_type_value_with_scope (id, type, b)
2474      tree id;
2475      tree type;
2476      struct cp_binding_level *b;
2477 {
2478   if (!b->namespace_p)
2479     {
2480       /* Shadow the marker, not the real thing, so that the marker
2481          gets restored later.  */
2482       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2483       b->type_shadowed
2484         = tree_cons (id, old_type_value, b->type_shadowed);
2485     }
2486   else
2487     {
2488       tree binding = binding_for_name (id, current_namespace);
2489       BINDING_TYPE (binding) = type;
2490       /* Store marker instead of real type.  */
2491       type = global_type_node;
2492     }
2493   SET_IDENTIFIER_TYPE_VALUE (id, type);
2494 }
2495
2496 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2497
2498 void
2499 set_identifier_type_value (id, type)
2500      tree id;
2501      tree type;
2502 {
2503   set_identifier_type_value_with_scope (id, type, current_binding_level);
2504 }
2505
2506 /* Return the type associated with id.  */
2507
2508 tree
2509 identifier_type_value (id)
2510      tree id;
2511 {
2512   /* There is no type with that name, anywhere.  */
2513   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2514     return NULL_TREE;
2515   /* This is not the type marker, but the real thing.  */
2516   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2517     return REAL_IDENTIFIER_TYPE_VALUE (id);
2518   /* Have to search for it. It must be on the global level, now.
2519      Ask lookup_name not to return non-types. */
2520   id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
2521   if (id)
2522     return TREE_TYPE (id);
2523   return NULL_TREE;
2524 }
2525
2526 /* Pop off extraneous binding levels left over due to syntax errors.
2527
2528    We don't pop past namespaces, as they might be valid.  */
2529
2530 void
2531 pop_everything ()
2532 {
2533 #ifdef DEBUG_BINDING_LEVELS
2534   fprintf (stderr, "XXX entering pop_everything ()\n");
2535 #endif
2536   while (!toplevel_bindings_p ())
2537     {
2538       if (current_binding_level->parm_flag == 2)
2539         pop_nested_class ();
2540       else
2541         poplevel (0, 0, 0);
2542     }
2543 #ifdef DEBUG_BINDING_LEVELS
2544   fprintf (stderr, "XXX leaving pop_everything ()\n");
2545 #endif
2546 }
2547
2548 /* The type TYPE is being declared.  If it is a class template, or a
2549    specialization of a class template, do any processing required and
2550    perform error-checking.  If IS_FRIEND is nonzero, this TYPE is
2551    being declared a friend.  B is the binding level at which this TYPE
2552    should be bound.
2553
2554    Returns the TYPE_DECL for TYPE, which may have been altered by this
2555    processing.  */
2556
2557 static tree
2558 maybe_process_template_type_declaration (type, globalize, b)
2559      tree type;
2560      int globalize;
2561      struct cp_binding_level* b;
2562 {
2563   tree decl = TYPE_NAME (type);
2564
2565   if (processing_template_parmlist)
2566     /* You can't declare a new template type in a template parameter
2567        list.  But, you can declare a non-template type:
2568
2569          template <class A*> struct S;
2570
2571        is a forward-declaration of `A'.  */
2572     ;
2573   else
2574     {
2575       maybe_check_template_type (type);
2576
2577       my_friendly_assert (IS_AGGR_TYPE (type)
2578                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2579
2580
2581       if (processing_template_decl)
2582         {
2583           /* This may change after the call to
2584              push_template_decl_real, but we want the original value.  */
2585           tree name = DECL_NAME (decl);
2586
2587           decl = push_template_decl_real (decl, globalize);
2588           /* If the current binding level is the binding level for the
2589              template parameters (see the comment in
2590              begin_template_parm_list) and the enclosing level is a class
2591              scope, and we're not looking at a friend, push the
2592              declaration of the member class into the class scope.  In the
2593              friend case, push_template_decl will already have put the
2594              friend into global scope, if appropriate.  */
2595           if (TREE_CODE (type) != ENUMERAL_TYPE
2596               && !globalize && b->template_parms_p
2597               && b->level_chain->parm_flag == 2)
2598             {
2599               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2600               /* Put this tag on the list of tags for the class, since
2601                  that won't happen below because B is not the class
2602                  binding level, but is instead the pseudo-global level.  */
2603               b->level_chain->tags =
2604                 tree_cons (name, type, b->level_chain->tags);
2605               if (!COMPLETE_TYPE_P (current_class_type))
2606                 {
2607                   maybe_add_class_template_decl_list (current_class_type,
2608                                                       type, /*friend_p=*/0);
2609                   CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2610                 }
2611             }
2612         }
2613     }
2614
2615   return decl;
2616 }
2617
2618 /* In C++, you don't have to write `struct S' to refer to `S'; you
2619    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2620    if the user had written `typedef struct S S'.  Create and return
2621    the TYPE_DECL for TYPE.  */
2622
2623 tree
2624 create_implicit_typedef (name, type)
2625      tree name;
2626      tree type;
2627 {
2628   tree decl;
2629
2630   decl = build_decl (TYPE_DECL, name, type);
2631   DECL_ARTIFICIAL (decl) = 1;
2632   /* There are other implicit type declarations, like the one *within*
2633      a class that allows you to write `S::S'.  We must distinguish
2634      amongst these.  */
2635   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2636   TYPE_NAME (type) = decl;
2637
2638   return decl;
2639 }
2640
2641 /* Remember a local name for name-mangling purposes.  */
2642
2643 static void
2644 push_local_name (decl)
2645      tree decl;
2646 {
2647   size_t i, nelts;
2648   tree t, name;
2649
2650   if (!local_names)
2651     VARRAY_TREE_INIT (local_names, 8, "local_names");
2652
2653   name = DECL_NAME (decl);
2654
2655   nelts = VARRAY_ACTIVE_SIZE (local_names);
2656   for (i = 0; i < nelts; i++)
2657     {
2658       t = VARRAY_TREE (local_names, i);
2659       if (DECL_NAME (t) == name)
2660         {
2661           if (!DECL_LANG_SPECIFIC (decl))
2662             retrofit_lang_decl (decl);
2663           DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
2664           if (DECL_LANG_SPECIFIC (t))
2665             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2666           else
2667             DECL_DISCRIMINATOR (decl) = 1;
2668
2669           VARRAY_TREE (local_names, i) = decl;
2670           return;
2671         }
2672     }
2673
2674   VARRAY_PUSH_TREE (local_names, decl);
2675 }
2676
2677 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2678    Normally put it into the inner-most non-tag-transparent scope,
2679    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2680    The latter is needed for implicit declarations.  */
2681
2682 void
2683 pushtag (name, type, globalize)
2684      tree name, type;
2685      int globalize;
2686 {
2687   register struct cp_binding_level *b;
2688
2689   b = current_binding_level;
2690   while (b->tag_transparent
2691          || (b->parm_flag == 2
2692              && (globalize
2693                  /* We may be defining a new type in the initializer
2694                     of a static member variable. We allow this when
2695                     not pedantic, and it is particularly useful for
2696                     type punning via an anonymous union.  */
2697                  || COMPLETE_TYPE_P (b->this_class))))
2698     b = b->level_chain;
2699
2700   b->tags = tree_cons (name, type, b->tags);
2701
2702   if (name)
2703     {
2704       /* Do C++ gratuitous typedefing.  */
2705       if (IDENTIFIER_TYPE_VALUE (name) != type)
2706         {
2707           register tree d = NULL_TREE;
2708           int in_class = 0;
2709           tree context = TYPE_CONTEXT (type);
2710
2711           if (! context)
2712             {
2713               tree cs = current_scope ();
2714
2715               if (! globalize)
2716                 context = cs;
2717               else if (cs != NULL_TREE && TYPE_P (cs))
2718                 /* When declaring a friend class of a local class, we want
2719                    to inject the newly named class into the scope
2720                    containing the local class, not the namespace scope.  */
2721                 context = decl_function_context (get_type_decl (cs));
2722             }
2723           if (!context)
2724             context = current_namespace;
2725
2726           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2727               || b->parm_flag == 2)
2728             in_class = 1;
2729
2730           if (current_lang_name == lang_name_java)
2731             TYPE_FOR_JAVA (type) = 1;
2732
2733           d = create_implicit_typedef (name, type);
2734           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2735           if (! in_class)
2736             set_identifier_type_value_with_scope (name, type, b);
2737
2738           d = maybe_process_template_type_declaration (type,
2739                                                        globalize, b);
2740
2741           if (b->parm_flag == 2)
2742             {
2743               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2744                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2745                    class.  But if it's a member template class, we
2746                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2747                    is done later.  */
2748                 finish_member_declaration (d);
2749               else
2750                 pushdecl_class_level (d);
2751             }
2752           else
2753             d = pushdecl_with_scope (d, b);
2754
2755           /* FIXME what if it gets a name from typedef?  */
2756           if (ANON_AGGRNAME_P (name))
2757             DECL_IGNORED_P (d) = 1;
2758
2759           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2760
2761           /* If this is a local class, keep track of it.  We need this
2762              information for name-mangling, and so that it is possible to find
2763              all function definitions in a translation unit in a convenient
2764              way.  (It's otherwise tricky to find a member function definition
2765              it's only pointed to from within a local class.)  */
2766           if (TYPE_CONTEXT (type)
2767               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2768               && !processing_template_decl)
2769             VARRAY_PUSH_TREE (local_classes, type);
2770         }
2771       if (b->parm_flag == 2)
2772         {
2773           if (!COMPLETE_TYPE_P (current_class_type))
2774             {
2775               maybe_add_class_template_decl_list (current_class_type,
2776                                                   type, /*friend_p=*/0);
2777               CLASSTYPE_TAGS (current_class_type) = b->tags;
2778             }
2779         }
2780     }
2781
2782   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2783     /* Use the canonical TYPE_DECL for this node.  */
2784     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2785   else
2786     {
2787       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2788          will be the tagged type we just added to the current
2789          binding level.  This fake NULL-named TYPE_DECL node helps
2790          dwarfout.c to know when it needs to output a
2791          representation of a tagged type, and it also gives us a
2792          convenient place to record the "scope start" address for
2793          the tagged type.  */
2794
2795       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2796       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2797     }
2798 }
2799
2800 /* Counter used to create anonymous type names.  */
2801
2802 static int anon_cnt = 0;
2803
2804 /* Return an IDENTIFIER which can be used as a name for
2805    anonymous structs and unions.  */
2806
2807 tree
2808 make_anon_name ()
2809 {
2810   char buf[32];
2811
2812   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2813   return get_identifier (buf);
2814 }
2815
2816 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2817    This keeps dbxout from getting confused.  */
2818
2819 void
2820 clear_anon_tags ()
2821 {
2822   register struct cp_binding_level *b;
2823   register tree tags;
2824   static int last_cnt = 0;
2825
2826   /* Fast out if no new anon names were declared.  */
2827   if (last_cnt == anon_cnt)
2828     return;
2829
2830   b = current_binding_level;
2831   while (b->tag_transparent)
2832     b = b->level_chain;
2833   tags = b->tags;
2834   while (tags)
2835     {
2836       /* A NULL purpose means we have already processed all tags
2837          from here to the end of the list.  */
2838       if (TREE_PURPOSE (tags) == NULL_TREE)
2839         break;
2840       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2841         TREE_PURPOSE (tags) = NULL_TREE;
2842       tags = TREE_CHAIN (tags);
2843     }
2844   last_cnt = anon_cnt;
2845 }
2846 \f
2847 /* Subroutine of duplicate_decls: return truthvalue of whether
2848    or not types of these decls match.
2849
2850    For C++, we must compare the parameter list so that `int' can match
2851    `int&' in a parameter position, but `int&' is not confused with
2852    `const int&'.  */
2853
2854 int
2855 decls_match (newdecl, olddecl)
2856      tree newdecl, olddecl;
2857 {
2858   int types_match;
2859
2860   if (newdecl == olddecl)
2861     return 1;
2862
2863   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2864     /* If the two DECLs are not even the same kind of thing, we're not
2865        interested in their types.  */
2866     return 0;
2867
2868   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2869     {
2870       tree f1 = TREE_TYPE (newdecl);
2871       tree f2 = TREE_TYPE (olddecl);
2872       tree p1 = TYPE_ARG_TYPES (f1);
2873       tree p2 = TYPE_ARG_TYPES (f2);
2874
2875       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2876           && ! (DECL_EXTERN_C_P (newdecl)
2877                 && DECL_EXTERN_C_P (olddecl)))
2878         return 0;
2879
2880       if (TREE_CODE (f1) != TREE_CODE (f2))
2881         return 0;
2882
2883       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2884         {
2885           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2886               && (DECL_BUILT_IN (olddecl)
2887 #ifndef NO_IMPLICIT_EXTERN_C
2888                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2889                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2890 #endif
2891               ))
2892             {
2893               types_match = self_promoting_args_p (p1);
2894               if (p1 == void_list_node)
2895                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2896             }
2897 #ifndef NO_IMPLICIT_EXTERN_C
2898           else if (p1 == NULL_TREE
2899                    && (DECL_EXTERN_C_P (olddecl)
2900                        && DECL_IN_SYSTEM_HEADER (olddecl)
2901                        && !DECL_CLASS_SCOPE_P (olddecl))
2902                    && (DECL_EXTERN_C_P (newdecl)
2903                        && DECL_IN_SYSTEM_HEADER (newdecl)
2904                        && !DECL_CLASS_SCOPE_P (newdecl)))
2905             {
2906               types_match = self_promoting_args_p (p2);
2907               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2908             }
2909 #endif
2910           else
2911             types_match = compparms (p1, p2);
2912         }
2913       else
2914         types_match = 0;
2915     }
2916   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2917     {
2918       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2919                                 DECL_TEMPLATE_PARMS (olddecl)))
2920         return 0;
2921
2922       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2923           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2924         return 0;
2925
2926       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2927         types_match = 1;
2928       else
2929         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2930                                    DECL_TEMPLATE_RESULT (newdecl));
2931     }
2932   else
2933     {
2934       if (TREE_TYPE (newdecl) == error_mark_node)
2935         types_match = TREE_TYPE (olddecl) == error_mark_node;
2936       else if (TREE_TYPE (olddecl) == NULL_TREE)
2937         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2938       else if (TREE_TYPE (newdecl) == NULL_TREE)
2939         types_match = 0;
2940       else
2941         types_match = comptypes (TREE_TYPE (newdecl),
2942                                  TREE_TYPE (olddecl),
2943                                  COMPARE_REDECLARATION);
2944     }
2945
2946   return types_match;
2947 }
2948
2949 /* If NEWDECL is `static' and an `extern' was seen previously,
2950    warn about it.  OLDDECL is the previous declaration.
2951
2952    Note that this does not apply to the C++ case of declaring
2953    a variable `extern const' and then later `const'.
2954
2955    Don't complain about built-in functions, since they are beyond
2956    the user's control.  */
2957
2958 static void
2959 warn_extern_redeclared_static (newdecl, olddecl)
2960      tree newdecl, olddecl;
2961 {
2962   static const char *const explicit_extern_static_warning
2963     = "`%D' was declared `extern' and later `static'";
2964   static const char *const implicit_extern_static_warning
2965     = "`%D' was declared implicitly `extern' and later `static'";
2966
2967   tree name;
2968
2969   if (TREE_CODE (newdecl) == TYPE_DECL
2970       || TREE_CODE (newdecl) == TEMPLATE_DECL
2971       || TREE_CODE (newdecl) == CONST_DECL)
2972     return;
2973
2974   /* Don't get confused by static member functions; that's a different
2975      use of `static'.  */
2976   if (TREE_CODE (newdecl) == FUNCTION_DECL
2977       && DECL_STATIC_FUNCTION_P (newdecl))
2978     return;
2979
2980   /* If the old declaration was `static', or the new one isn't, then
2981      then everything is OK.  */
2982   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2983     return;
2984
2985   /* It's OK to declare a builtin function as `static'.  */
2986   if (TREE_CODE (olddecl) == FUNCTION_DECL
2987       && DECL_ARTIFICIAL (olddecl))
2988     return;
2989
2990   name = DECL_ASSEMBLER_NAME (newdecl);
2991   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2992               ? implicit_extern_static_warning
2993               : explicit_extern_static_warning, newdecl);
2994   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2995 }
2996
2997 /* Handle when a new declaration NEWDECL has the same name as an old
2998    one OLDDECL in the same binding contour.  Prints an error message
2999    if appropriate.
3000
3001    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3002    Otherwise, return 0.  */
3003
3004 int
3005 duplicate_decls (newdecl, olddecl)
3006      tree newdecl, olddecl;
3007 {
3008   unsigned olddecl_uid = DECL_UID (olddecl);
3009   int olddecl_friend = 0, types_match = 0;
3010   int new_defines_function = 0;
3011
3012   if (newdecl == olddecl)
3013     return 1;
3014
3015   types_match = decls_match (newdecl, olddecl);
3016
3017   /* If either the type of the new decl or the type of the old decl is an
3018      error_mark_node, then that implies that we have already issued an
3019      error (earlier) for some bogus type specification, and in that case,
3020      it is rather pointless to harass the user with yet more error message
3021      about the same declaration, so just pretend the types match here.  */
3022   if (TREE_TYPE (newdecl) == error_mark_node
3023       || TREE_TYPE (olddecl) == error_mark_node)
3024     types_match = 1;
3025
3026   if (DECL_P (olddecl)
3027       && TREE_CODE (newdecl) == FUNCTION_DECL
3028       && TREE_CODE (olddecl) == FUNCTION_DECL
3029       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3030     {
3031       if (DECL_DECLARED_INLINE_P (newdecl)
3032           && DECL_UNINLINABLE (newdecl)
3033           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3034         /* Already warned elsewhere.  */;
3035       else if (DECL_DECLARED_INLINE_P (olddecl)
3036                && DECL_UNINLINABLE (olddecl)
3037                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3038         /* Already warned.  */;
3039       else if (DECL_DECLARED_INLINE_P (newdecl)
3040                && DECL_UNINLINABLE (olddecl)
3041                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3042         {
3043           warning_with_decl (newdecl,
3044                              "function `%s' redeclared as inline");
3045           warning_with_decl (olddecl,
3046                              "previous declaration of function `%s' with attribute noinline");
3047         }
3048       else if (DECL_DECLARED_INLINE_P (olddecl)
3049                && DECL_UNINLINABLE (newdecl)
3050                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3051         {
3052           warning_with_decl (newdecl,
3053                              "function `%s' redeclared with attribute noinline");
3054           warning_with_decl (olddecl,
3055                              "previous declaration of function `%s' was inline");
3056         }
3057     }
3058
3059   /* Check for redeclaration and other discrepancies.  */
3060   if (TREE_CODE (olddecl) == FUNCTION_DECL
3061       && DECL_ARTIFICIAL (olddecl))
3062     {
3063       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3064         {
3065           /* Avoid warnings redeclaring anticipated built-ins.  */
3066           if (DECL_ANTICIPATED (olddecl))
3067             return 0;
3068
3069           /* If you declare a built-in or predefined function name as static,
3070              the old definition is overridden, but optionally warn this was a
3071              bad choice of name.  */
3072           if (! TREE_PUBLIC (newdecl))
3073             {
3074               if (warn_shadow)
3075                 warning ("shadowing %s function `%#D'",
3076                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3077                             olddecl);
3078               /* Discard the old built-in function.  */
3079               return 0;
3080             }
3081           /* If the built-in is not ansi, then programs can override
3082              it even globally without an error.  */
3083           else if (! DECL_BUILT_IN (olddecl))
3084             warning ("library function `%#D' redeclared as non-function `%#D'",
3085                         olddecl, newdecl);
3086           else
3087             {
3088               error ("declaration of `%#D'", newdecl);
3089               error ("conflicts with built-in declaration `%#D'",
3090                         olddecl);
3091             }
3092           return 0;
3093         }
3094       else if (!types_match)
3095         {
3096           /* Avoid warnings redeclaring anticipated built-ins.  */
3097           if (DECL_ANTICIPATED (olddecl))
3098             ;  /* Do nothing yet.  */
3099           else if ((DECL_EXTERN_C_P (newdecl)
3100                && DECL_EXTERN_C_P (olddecl))
3101               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3102                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3103             {
3104               /* A near match; override the builtin.  */
3105
3106               if (TREE_PUBLIC (newdecl))
3107                 {
3108                   warning ("new declaration `%#D'", newdecl);
3109                   warning ("ambiguates built-in declaration `%#D'",
3110                               olddecl);
3111                 }
3112               else if (warn_shadow)
3113                 warning ("shadowing %s function `%#D'",
3114                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3115                             olddecl);
3116             }
3117           else
3118             /* Discard the old built-in function.  */
3119             return 0;
3120
3121           /* Replace the old RTL to avoid problems with inlining.  */
3122           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3123         }
3124
3125       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3126         {
3127           /* If a builtin function is redeclared as `static', merge
3128              the declarations, but make the original one static.  */
3129           DECL_THIS_STATIC (olddecl) = 1;
3130           TREE_PUBLIC (olddecl) = 0;
3131
3132           /* Make the old declaration consistent with the new one so
3133              that all remnants of the builtin-ness of this function
3134              will be banished.  */
3135           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3136           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3137         }
3138     }
3139   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3140     {
3141       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3142            && TREE_CODE (newdecl) != TYPE_DECL
3143            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3144                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3145           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3146               && TREE_CODE (olddecl) != TYPE_DECL
3147               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3148                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3149                         == TYPE_DECL))))
3150         {
3151           /* We do nothing special here, because C++ does such nasty
3152              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3153              get shadowed, and know that if we need to find a TYPE_DECL
3154              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3155              slot of the identifier.  */
3156           return 0;
3157         }
3158
3159       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3160            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3161           || (TREE_CODE (olddecl) == FUNCTION_DECL
3162               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3163         return 0;
3164
3165       error ("`%#D' redeclared as different kind of symbol", newdecl);
3166       if (TREE_CODE (olddecl) == TREE_LIST)
3167         olddecl = TREE_VALUE (olddecl);
3168       cp_error_at ("previous declaration of `%#D'", olddecl);
3169
3170       /* New decl is completely inconsistent with the old one =>
3171          tell caller to replace the old one.  */
3172
3173       return 0;
3174     }
3175   else if (!types_match)
3176     {
3177       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3178         /* These are certainly not duplicate declarations; they're
3179            from different scopes.  */
3180         return 0;
3181
3182       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3183         {
3184           /* The name of a class template may not be declared to refer to
3185              any other template, class, function, object, namespace, value,
3186              or type in the same scope.  */
3187           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3188               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3189             {
3190               error ("declaration of template `%#D'", newdecl);
3191               cp_error_at ("conflicts with previous declaration `%#D'",
3192                            olddecl);
3193             }
3194           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3195                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3196                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3197                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3198                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3199                                            DECL_TEMPLATE_PARMS (olddecl))
3200                    /* Template functions can be disambiguated by
3201                       return type.  */
3202                    && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
3203                                    TREE_TYPE (TREE_TYPE (olddecl))))
3204             {
3205               error ("new declaration `%#D'", newdecl);
3206               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3207             }
3208           return 0;
3209         }
3210       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3211         {
3212           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3213             {
3214               error ("declaration of C function `%#D' conflicts with",
3215                         newdecl);
3216               cp_error_at ("previous declaration `%#D' here", olddecl);
3217             }
3218           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3219                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3220             {
3221               error ("new declaration `%#D'", newdecl);
3222               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3223             }
3224           else
3225             return 0;
3226         }
3227
3228       /* Already complained about this, so don't do so again.  */
3229       else if (current_class_type == NULL_TREE
3230           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3231         {
3232           error ("conflicting types for `%#D'", newdecl);
3233           cp_error_at ("previous declaration as `%#D'", olddecl);
3234         }
3235     }
3236   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3237             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3238                  && (!DECL_TEMPLATE_INFO (newdecl)
3239                      || (DECL_TI_TEMPLATE (newdecl)
3240                          != DECL_TI_TEMPLATE (olddecl))))
3241                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3242                     && (!DECL_TEMPLATE_INFO (olddecl)
3243                         || (DECL_TI_TEMPLATE (olddecl)
3244                             != DECL_TI_TEMPLATE (newdecl))))))
3245     /* It's OK to have a template specialization and a non-template
3246        with the same type, or to have specializations of two
3247        different templates with the same type.  Note that if one is a
3248        specialization, and the other is an instantiation of the same
3249        template, that we do not exit at this point.  That situation
3250        can occur if we instantiate a template class, and then
3251        specialize one of its methods.  This situation is valid, but
3252        the declarations must be merged in the usual way.  */
3253     return 0;
3254   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3255            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3256                 && !DECL_USE_TEMPLATE (newdecl))
3257                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3258                    && !DECL_USE_TEMPLATE (olddecl))))
3259     /* One of the declarations is a template instantiation, and the
3260        other is not a template at all.  That's OK.  */
3261     return 0;
3262   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3263            && DECL_NAMESPACE_ALIAS (newdecl)
3264            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3265     /* Redeclaration of namespace alias, ignore it.  */
3266     return 1;
3267   else
3268     {
3269       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3270       if (errmsg)
3271         {
3272           error (errmsg, newdecl);
3273           if (DECL_NAME (olddecl) != NULL_TREE)
3274             cp_error_at ((DECL_INITIAL (olddecl)
3275                           && namespace_bindings_p ())
3276                          ? "`%#D' previously defined here"
3277                          : "`%#D' previously declared here", olddecl);
3278           return 0;
3279         }
3280       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3281                && DECL_INITIAL (olddecl) != NULL_TREE
3282                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3283                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3284         {
3285           /* Prototype decl follows defn w/o prototype.  */
3286           cp_warning_at ("prototype for `%#D'", newdecl);
3287           cp_warning_at ("follows non-prototype definition here", olddecl);
3288         }
3289       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3290                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3291         {
3292           /* extern "C" int foo ();
3293              int foo () { bar (); }
3294              is OK.  */
3295           if (current_lang_depth () == 0)
3296             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3297           else
3298             {
3299               cp_error_at ("previous declaration of `%#D' with %L linkage",
3300                            olddecl, DECL_LANGUAGE (olddecl));
3301               error ("conflicts with new declaration with %L linkage",
3302                         DECL_LANGUAGE (newdecl));
3303             }
3304         }
3305
3306       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3307         ;
3308       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3309         {
3310           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3311           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3312           int i = 1;
3313
3314           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3315             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3316
3317           for (; t1 && t1 != void_list_node;
3318                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3319             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3320               {
3321                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3322                                            TREE_PURPOSE (t2)))
3323                   {
3324                     pedwarn ("default argument given for parameter %d of `%#D'",
3325                              i, newdecl);
3326                     cp_pedwarn_at ("after previous specification in `%#D'",
3327                                    olddecl);
3328                   }
3329                 else
3330                   {
3331                     error ("default argument given for parameter %d of `%#D'",
3332                               i, newdecl);
3333                     cp_error_at ("after previous specification in `%#D'",
3334                                  olddecl);
3335                   }
3336               }
3337
3338           if (DECL_DECLARED_INLINE_P (newdecl)
3339               && ! DECL_DECLARED_INLINE_P (olddecl)
3340               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3341             {
3342               warning ("`%#D' was used before it was declared inline",
3343                           newdecl);
3344               cp_warning_at ("previous non-inline declaration here",
3345                              olddecl);
3346             }
3347         }
3348     }
3349
3350   /* Do not merge an implicit typedef with an explicit one.  In:
3351
3352        class A;
3353        ...
3354        typedef class A A __attribute__ ((foo));
3355
3356      the attribute should apply only to the typedef.  */
3357   if (TREE_CODE (olddecl) == TYPE_DECL
3358       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3359           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3360     return 0;
3361
3362   /* If new decl is `static' and an `extern' was seen previously,
3363      warn about it.  */
3364   warn_extern_redeclared_static (newdecl, olddecl);
3365
3366   /* We have committed to returning 1 at this point.  */
3367   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3368     {
3369       /* Now that functions must hold information normally held
3370          by field decls, there is extra work to do so that
3371          declaration information does not get destroyed during
3372          definition.  */
3373       if (DECL_VINDEX (olddecl))
3374         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3375       if (DECL_CONTEXT (olddecl))
3376         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3377       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3378       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3379       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3380       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3381       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3382       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3383       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3384         SET_OVERLOADED_OPERATOR_CODE
3385           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3386       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3387
3388       /* Optionally warn about more than one declaration for the same
3389          name, but don't warn about a function declaration followed by a
3390          definition.  */
3391       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3392           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3393           /* Don't warn about extern decl followed by definition.  */
3394           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3395           /* Don't warn about friends, let add_friend take care of it.  */
3396           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3397         {
3398           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3399           cp_warning_at ("previous declaration of `%D'", olddecl);
3400         }
3401     }
3402
3403   /* Deal with C++: must preserve virtual function table size.  */
3404   if (TREE_CODE (olddecl) == TYPE_DECL)
3405     {
3406       register tree newtype = TREE_TYPE (newdecl);
3407       register tree oldtype = TREE_TYPE (olddecl);
3408
3409       if (newtype != error_mark_node && oldtype != error_mark_node
3410           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3411         CLASSTYPE_FRIEND_CLASSES (newtype)
3412           = CLASSTYPE_FRIEND_CLASSES (oldtype);
3413 \
3414       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3415     }
3416
3417   /* Copy all the DECL_... slots specified in the new decl
3418      except for any that we copy here from the old type.  */
3419   DECL_ATTRIBUTES (newdecl)
3420     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3421
3422   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3423     {
3424       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3425       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3426         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3427                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3428
3429       /* If the new declaration is a definition, update the file and
3430          line information on the declaration.  */
3431       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3432           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3433         {
3434           DECL_SOURCE_LOCATION (olddecl)
3435             = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
3436             = DECL_SOURCE_LOCATION (newdecl);
3437         }
3438
3439       return 1;
3440     }
3441
3442   if (types_match)
3443     {
3444       /* Automatically handles default parameters.  */
3445       tree oldtype = TREE_TYPE (olddecl);
3446       tree newtype;
3447
3448       /* Merge the data types specified in the two decls.  */
3449       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3450
3451       /* If merge_types produces a non-typedef type, just use the old type.  */
3452       if (TREE_CODE (newdecl) == TYPE_DECL
3453           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3454         newtype = oldtype;
3455
3456       if (TREE_CODE (newdecl) == VAR_DECL)
3457         {
3458           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3459           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
3460         }
3461
3462       /* Do this after calling `merge_types' so that default
3463          parameters don't confuse us.  */
3464       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3465           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3466               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3467         {
3468           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3469                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3470           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3471                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3472
3473           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3474               && DECL_SOURCE_LINE (olddecl) != 0
3475               && flag_exceptions
3476               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3477                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3478             {
3479               error ("declaration of `%F' throws different exceptions",
3480                         newdecl);
3481               cp_error_at ("than previous declaration `%F'", olddecl);
3482             }
3483         }
3484       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3485
3486       /* Lay the type out, unless already done.  */
3487       if (! same_type_p (newtype, oldtype)
3488           && TREE_TYPE (newdecl) != error_mark_node
3489           && !(processing_template_decl && uses_template_parms (newdecl)))
3490         layout_type (TREE_TYPE (newdecl));
3491
3492       if ((TREE_CODE (newdecl) == VAR_DECL
3493            || TREE_CODE (newdecl) == PARM_DECL
3494            || TREE_CODE (newdecl) == RESULT_DECL
3495            || TREE_CODE (newdecl) == FIELD_DECL
3496            || TREE_CODE (newdecl) == TYPE_DECL)
3497           && !(processing_template_decl && uses_template_parms (newdecl)))
3498         layout_decl (newdecl, 0);
3499
3500       /* Merge the type qualifiers.  */
3501       if (TREE_READONLY (newdecl))
3502         TREE_READONLY (olddecl) = 1;
3503       if (TREE_THIS_VOLATILE (newdecl))
3504         TREE_THIS_VOLATILE (olddecl) = 1;
3505
3506       /* Merge the initialization information.  */
3507       if (DECL_INITIAL (newdecl) == NULL_TREE
3508           && DECL_INITIAL (olddecl) != NULL_TREE)
3509         {
3510           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3511           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
3512           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3513               && DECL_LANG_SPECIFIC (newdecl)
3514               && DECL_LANG_SPECIFIC (olddecl))
3515             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3516         }
3517
3518       /* Merge the section attribute.
3519          We want to issue an error if the sections conflict but that must be
3520          done later in decl_attributes since we are called before attributes
3521          are assigned.  */
3522       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3523         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3524
3525       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3526         {
3527           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3528             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3529           DECL_NO_LIMIT_STACK (newdecl)
3530             |= DECL_NO_LIMIT_STACK (olddecl);
3531           /* Keep the old RTL.  */
3532           COPY_DECL_RTL (olddecl, newdecl);
3533         }
3534       else if (TREE_CODE (newdecl) == VAR_DECL
3535                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3536         {
3537           /* Keep the old RTL.  We cannot keep the old RTL if the old
3538              declaration was for an incomplete object and the new
3539              declaration is not since many attributes of the RTL will
3540              change.  */
3541           COPY_DECL_RTL (olddecl, newdecl);
3542         }
3543     }
3544   /* If cannot merge, then use the new type and qualifiers,
3545      and don't preserve the old rtl.  */
3546   else
3547     {
3548       /* Clean out any memory we had of the old declaration.  */
3549       tree oldstatic = value_member (olddecl, static_aggregates);
3550       if (oldstatic)
3551         TREE_VALUE (oldstatic) = error_mark_node;
3552
3553       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3554       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3555       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3556       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3557     }
3558
3559   /* Merge the storage class information.  */
3560   merge_weak (newdecl, olddecl);
3561
3562   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3563   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3564   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3565   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3566   if (! DECL_EXTERNAL (olddecl))
3567     DECL_EXTERNAL (newdecl) = 0;
3568
3569   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3570     {
3571       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3572       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3573       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3574       DECL_TEMPLATE_INSTANTIATED (newdecl)
3575         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3576       /* Don't really know how much of the language-specific
3577          values we should copy from old to new.  */
3578       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3579       DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
3580         DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
3581       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3582       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3583       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3584         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3585       olddecl_friend = DECL_FRIEND_P (olddecl);
3586
3587       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3588       if (TREE_CODE (newdecl) == FUNCTION_DECL
3589           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3590         {
3591           DECL_BEFRIENDING_CLASSES (newdecl)
3592             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3593                        DECL_BEFRIENDING_CLASSES (olddecl));
3594           DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
3595         }
3596     }
3597
3598   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3599     {
3600       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3601           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3602         {
3603           /* If newdecl is not a specialization, then it is not a
3604              template-related function at all.  And that means that we
3605              shoud have exited above, returning 0.  */
3606           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3607                               0);
3608
3609           if (TREE_USED (olddecl))
3610             /* From [temp.expl.spec]:
3611
3612                If a template, a member template or the member of a class
3613                template is explicitly specialized then that
3614                specialization shall be declared before the first use of
3615                that specialization that would cause an implicit
3616                instantiation to take place, in every translation unit in
3617                which such a use occurs.  */
3618             error ("explicit specialization of %D after first use",
3619                       olddecl);
3620
3621           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3622
3623           /* [temp.expl.spec/14] We don't inline explicit specialization
3624              just because the primary template says so.  */
3625         }
3626       else
3627         {
3628           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3629             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3630
3631           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3632
3633           /* If either decl says `inline', this fn is inline, unless
3634              its definition was passed already.  */
3635           if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3636             DECL_INLINE (olddecl) = 1;
3637           DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3638
3639           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3640             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3641         }
3642
3643       /* Preserve abstractness on cloned [cd]tors.  */
3644       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3645
3646       if (! types_match)
3647         {
3648           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3649           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3650           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3651         }
3652       if (! types_match || new_defines_function)
3653         {
3654           /* These need to be copied so that the names are available.
3655              Note that if the types do match, we'll preserve inline
3656              info and other bits, but if not, we won't.  */
3657           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3658           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3659         }
3660       if (new_defines_function)
3661         /* If defining a function declared with other language
3662            linkage, use the previously declared language linkage.  */
3663         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3664       else if (types_match)
3665         {
3666           /* If redeclaring a builtin function, and not a definition,
3667              it stays built in.  */
3668           if (DECL_BUILT_IN (olddecl))
3669             {
3670               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3671               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3672               /* If we're keeping the built-in definition, keep the rtl,
3673                  regardless of declaration matches.  */
3674               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3675             }
3676           else
3677             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3678
3679           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3680           /* Don't clear out the arguments if we're redefining a function.  */
3681           if (DECL_ARGUMENTS (olddecl))
3682             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3683         }
3684     }
3685   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3686     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3687
3688   /* Now preserve various other info from the definition.  */
3689   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3690   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3691   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3692   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3693
3694   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3695     {
3696       int function_size;
3697
3698       function_size = sizeof (struct tree_decl);
3699
3700       memcpy ((char *) olddecl + sizeof (struct tree_common),
3701               (char *) newdecl + sizeof (struct tree_common),
3702               function_size - sizeof (struct tree_common));
3703
3704       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3705         {
3706           /* If newdecl is a template instantiation, it is possible that
3707              the following sequence of events has occurred:
3708
3709              o A friend function was declared in a class template.  The
3710              class template was instantiated.
3711
3712              o The instantiation of the friend declaration was
3713              recorded on the instantiation list, and is newdecl.
3714
3715              o Later, however, instantiate_class_template called pushdecl
3716              on the newdecl to perform name injection.  But, pushdecl in
3717              turn called duplicate_decls when it discovered that another
3718              declaration of a global function with the same name already
3719              existed.
3720
3721              o Here, in duplicate_decls, we decided to clobber newdecl.
3722
3723              If we're going to do that, we'd better make sure that
3724              olddecl, and not newdecl, is on the list of
3725              instantiations so that if we try to do the instantiation
3726              again we won't get the clobbered declaration.  */
3727
3728           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3729           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3730
3731           for (; decls; decls = TREE_CHAIN (decls))
3732             if (TREE_VALUE (decls) == newdecl)
3733               TREE_VALUE (decls) = olddecl;
3734         }
3735     }
3736   else
3737     {
3738       memcpy ((char *) olddecl + sizeof (struct tree_common),
3739               (char *) newdecl + sizeof (struct tree_common),
3740               sizeof (struct tree_decl) - sizeof (struct tree_common)
3741               + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
3742     }
3743
3744   DECL_UID (olddecl) = olddecl_uid;
3745   if (olddecl_friend)
3746     DECL_FRIEND_P (olddecl) = 1;
3747
3748   /* NEWDECL contains the merged attribute lists.
3749      Update OLDDECL to be the same.  */
3750   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3751
3752   return 1;
3753 }
3754
3755 /* Record a decl-node X as belonging to the current lexical scope.
3756    Check for errors (such as an incompatible declaration for the same
3757    name already seen in the same scope).
3758
3759    Returns either X or an old decl for the same name.
3760    If an old decl is returned, it may have been smashed
3761    to agree with what X says.  */
3762
3763 tree
3764 pushdecl (x)
3765      tree x;
3766 {
3767   register tree t;
3768   register tree name;
3769   int need_new_binding;
3770
3771   /* We shouldn't be calling pushdecl when we're generating RTL for a
3772      function that we already did semantic analysis on previously.  */
3773   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3774                       19990913);
3775
3776   need_new_binding = 1;
3777
3778   if (DECL_TEMPLATE_PARM_P (x))
3779     /* Template parameters have no context; they are not X::T even
3780        when declared within a class or namespace.  */
3781     ;
3782   else
3783     {
3784       if (current_function_decl && x != current_function_decl
3785           /* A local declaration for a function doesn't constitute
3786              nesting.  */
3787           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3788           /* A local declaration for an `extern' variable is in the
3789              scope of the current namespace, not the current
3790              function.  */
3791           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3792           && !DECL_CONTEXT (x))
3793         DECL_CONTEXT (x) = current_function_decl;
3794
3795       /* If this is the declaration for a namespace-scope function,
3796          but the declaration itself is in a local scope, mark the
3797          declaration.  */
3798       if (TREE_CODE (x) == FUNCTION_DECL
3799           && DECL_NAMESPACE_SCOPE_P (x)
3800           && current_function_decl
3801           && x != current_function_decl)
3802         DECL_LOCAL_FUNCTION_P (x) = 1;
3803     }
3804
3805   name = DECL_NAME (x);
3806   if (name)
3807     {
3808       int different_binding_level = 0;
3809
3810       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3811         name = TREE_OPERAND (name, 0);
3812
3813       /* In case this decl was explicitly namespace-qualified, look it
3814          up in its namespace context.  */
3815       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3816           && namespace_bindings_p ())
3817         t = namespace_binding (name, DECL_CONTEXT (x));
3818       else
3819         t = lookup_name_current_level (name);
3820
3821       /* [basic.link] If there is a visible declaration of an entity
3822          with linkage having the same name and type, ignoring entities
3823          declared outside the innermost enclosing namespace scope, the
3824          block scope declaration declares that same entity and
3825          receives the linkage of the previous declaration.  */
3826       if (! t && current_function_decl && x != current_function_decl
3827           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3828           && DECL_EXTERNAL (x))
3829         {
3830           /* Look in block scope.  */
3831           t = IDENTIFIER_VALUE (name);
3832           /* Or in the innermost namespace.  */
3833           if (! t)
3834             t = namespace_binding (name, DECL_CONTEXT (x));
3835           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3836              OVERLOAD, which is OK.  */
3837           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3838             t = NULL_TREE;
3839           if (t)
3840             different_binding_level = 1;
3841         }
3842
3843       /* If we are declaring a function, and the result of name-lookup
3844          was an OVERLOAD, look for an overloaded instance that is
3845          actually the same as the function we are declaring.  (If
3846          there is one, we have to merge our declaration with the
3847          previous declaration.)  */
3848       if (t && TREE_CODE (t) == OVERLOAD)
3849         {
3850           tree match;
3851
3852           if (TREE_CODE (x) == FUNCTION_DECL)
3853             for (match = t; match; match = OVL_NEXT (match))
3854               {
3855                 if (decls_match (OVL_CURRENT (match), x))
3856                   break;
3857               }
3858           else
3859             /* Just choose one.  */
3860             match = t;
3861
3862           if (match)
3863             t = OVL_CURRENT (match);
3864           else
3865             t = NULL_TREE;
3866         }
3867
3868       if (t == error_mark_node)
3869         {
3870           /* error_mark_node is 0 for a while during initialization!  */
3871           t = NULL_TREE;
3872           cp_error_at ("`%#D' used prior to declaration", x);
3873         }
3874       else if (t != NULL_TREE)
3875         {
3876           if (different_binding_level)
3877             {
3878               if (decls_match (x, t))
3879                 /* The standard only says that the local extern
3880                    inherits linkage from the previous decl; in
3881                    particular, default args are not shared.  It would
3882                    be nice to propagate inlining info, though.  FIXME.  */
3883                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3884             }
3885           else if (TREE_CODE (t) == PARM_DECL)
3886             {
3887               if (DECL_CONTEXT (t) == NULL_TREE)
3888                 /* This is probaby caused by too many errors, but calling
3889                    abort will say that if errors have occurred.  */
3890                 abort ();
3891
3892               /* Check for duplicate params.  */
3893               if (duplicate_decls (x, t))
3894                 return t;
3895             }
3896           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3897                     || DECL_FUNCTION_TEMPLATE_P (x))
3898                    && is_overloaded_fn (t))
3899             /* Don't do anything just yet.  */;
3900           else if (t == wchar_decl_node)
3901             {
3902               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3903                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3904                             TREE_TYPE (x));
3905
3906               /* Throw away the redeclaration.  */
3907               return t;
3908             }
3909           else if (TREE_CODE (t) != TREE_CODE (x))
3910             {
3911               if (duplicate_decls (x, t))
3912                 return t;
3913             }
3914           else if (duplicate_decls (x, t))
3915             {
3916               if (TREE_CODE (t) == TYPE_DECL)
3917                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3918               else if (TREE_CODE (t) == FUNCTION_DECL)
3919                 check_default_args (t);
3920
3921               return t;
3922             }
3923           else if (DECL_MAIN_P (x))
3924             {
3925               /* A redeclaration of main, but not a duplicate of the
3926                  previous one.
3927
3928                  [basic.start.main]
3929
3930                  This function shall not be overloaded.  */
3931               cp_error_at ("invalid redeclaration of `%D'", t);
3932               error ("as `%D'", x);
3933               /* We don't try to push this declaration since that
3934                  causes a crash.  */
3935               return x;
3936             }
3937         }
3938
3939       check_template_shadow (x);
3940
3941       /* If this is a function conjured up by the backend, massage it
3942          so it looks friendly.  */
3943       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3944         {
3945           retrofit_lang_decl (x);
3946           SET_DECL_LANGUAGE (x, lang_c);
3947         }
3948
3949       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3950         {
3951           t = push_overloaded_decl (x, PUSH_LOCAL);
3952           if (t != x)
3953             return t;
3954           if (!namespace_bindings_p ())
3955             /* We do not need to create a binding for this name;
3956                push_overloaded_decl will have already done so if
3957                necessary.  */
3958             need_new_binding = 0;
3959         }
3960       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3961         {
3962           t = push_overloaded_decl (x, PUSH_GLOBAL);
3963           if (t == x)
3964             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3965           return t;
3966         }
3967
3968       /* If declaring a type as a typedef, copy the type (unless we're
3969          at line 0), and install this TYPE_DECL as the new type's typedef
3970          name.  See the extensive comment in ../c-decl.c (pushdecl).  */
3971       if (TREE_CODE (x) == TYPE_DECL)
3972         {
3973           tree type = TREE_TYPE (x);
3974           if (DECL_SOURCE_LINE (x) == 0)
3975             {
3976               if (TYPE_NAME (type) == 0)
3977                 TYPE_NAME (type) = x;
3978             }
3979           else if (type != error_mark_node && TYPE_NAME (type) != x
3980                    /* We don't want to copy the type when all we're
3981                       doing is making a TYPE_DECL for the purposes of
3982                       inlining.  */
3983                    && (!TYPE_NAME (type)
3984                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3985             {
3986               DECL_ORIGINAL_TYPE (x) = type;
3987               type = build_type_copy (type);
3988               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3989               TYPE_NAME (type) = x;
3990               TREE_TYPE (x) = type;
3991             }
3992
3993           if (type != error_mark_node
3994               && TYPE_NAME (type)
3995               && TYPE_IDENTIFIER (type))
3996             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3997                                                   current_binding_level);
3998
3999         }
4000
4001       /* Multiple external decls of the same identifier ought to match.
4002
4003          We get warnings about inline functions where they are defined.
4004          We get warnings about other functions from push_overloaded_decl.
4005
4006          Avoid duplicate warnings where they are used.  */
4007       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4008         {
4009           tree decl;
4010
4011           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4012           if (decl && TREE_CODE (decl) == OVERLOAD)
4013             decl = OVL_FUNCTION (decl);
4014
4015           if (decl && decl != error_mark_node
4016               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4017               /* If different sort of thing, we already gave an error.  */
4018               && TREE_CODE (decl) == TREE_CODE (x)
4019               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4020             {
4021               pedwarn ("type mismatch with previous external decl", x);
4022               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4023             }
4024         }
4025
4026       /* This name is new in its binding level.
4027          Install the new declaration and return it.  */
4028       if (namespace_bindings_p ())
4029         {
4030           /* Install a global value.  */
4031
4032           /* If the first global decl has external linkage,
4033              warn if we later see static one.  */
4034           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4035             TREE_PUBLIC (name) = 1;
4036
4037           /* Bind the name for the entity.  */
4038           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4039                 && t != NULL_TREE)
4040               && (TREE_CODE (x) == TYPE_DECL
4041                   || TREE_CODE (x) == VAR_DECL
4042                   || TREE_CODE (x) == ALIAS_DECL
4043                   || TREE_CODE (x) == NAMESPACE_DECL
4044                   || TREE_CODE (x) == CONST_DECL
4045                   || TREE_CODE (x) == TEMPLATE_DECL))
4046             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4047
4048           /* Don't forget if the function was used via an implicit decl.  */
4049           if (IDENTIFIER_IMPLICIT_DECL (name)
4050               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4051             TREE_USED (x) = 1;
4052
4053           /* Don't forget if its address was taken in that way.  */
4054           if (IDENTIFIER_IMPLICIT_DECL (name)
4055               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4056             TREE_ADDRESSABLE (x) = 1;
4057
4058           /* Warn about mismatches against previous implicit decl.  */
4059           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4060               /* If this real decl matches the implicit, don't complain.  */
4061               && ! (TREE_CODE (x) == FUNCTION_DECL
4062                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4063             warning
4064               ("`%D' was previously implicitly declared to return `int'", x);
4065
4066           /* If new decl is `static' and an `extern' was seen previously,
4067              warn about it.  */
4068           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4069             warn_extern_redeclared_static (x, t);
4070         }
4071       else
4072         {
4073           /* Here to install a non-global value.  */
4074           tree oldlocal = IDENTIFIER_VALUE (name);
4075           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4076
4077           if (need_new_binding)
4078             {
4079               push_local_binding (name, x, 0);
4080               /* Because push_local_binding will hook X on to the
4081                  current_binding_level's name list, we don't want to
4082                  do that again below.  */
4083               need_new_binding = 0;
4084             }
4085
4086           /* If this is a TYPE_DECL, push it into the type value slot.  */
4087           if (TREE_CODE (x) == TYPE_DECL)
4088             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4089                                                   current_binding_level);
4090
4091           /* Clear out any TYPE_DECL shadowed by a namespace so that
4092              we won't think this is a type.  The C struct hack doesn't
4093              go through namespaces.  */
4094           if (TREE_CODE (x) == NAMESPACE_DECL)
4095             set_identifier_type_value_with_scope (name, NULL_TREE,
4096                                                   current_binding_level);
4097
4098           if (oldlocal)
4099             {
4100               tree d = oldlocal;
4101
4102               while (oldlocal
4103                      && TREE_CODE (oldlocal) == VAR_DECL
4104                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4105                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4106
4107               if (oldlocal == NULL_TREE)
4108                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4109             }
4110
4111           /* If this is an extern function declaration, see if we
4112              have a global definition or declaration for the function.  */
4113           if (oldlocal == NULL_TREE
4114               && DECL_EXTERNAL (x)
4115               && oldglobal != NULL_TREE
4116               && TREE_CODE (x) == FUNCTION_DECL
4117               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4118             {
4119               /* We have one.  Their types must agree.  */
4120               if (decls_match (x, oldglobal))
4121                 /* OK */;
4122               else
4123                 {
4124                   warning ("extern declaration of `%#D' doesn't match", x);
4125                   cp_warning_at ("global declaration `%#D'", oldglobal);
4126                 }
4127             }
4128           /* If we have a local external declaration,
4129              and no file-scope declaration has yet been seen,
4130              then if we later have a file-scope decl it must not be static.  */
4131           if (oldlocal == NULL_TREE
4132               && oldglobal == NULL_TREE
4133               && DECL_EXTERNAL (x)
4134               && TREE_PUBLIC (x))
4135             TREE_PUBLIC (name) = 1;
4136
4137           /* Warn if shadowing an argument at the top level of the body.  */
4138           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4139               /* Inline decls shadow nothing.  */
4140               && !DECL_FROM_INLINE (x)
4141               && TREE_CODE (oldlocal) == PARM_DECL)
4142             {
4143               bool err = false;
4144
4145               /* Don't complain if it's from an enclosing function.  */
4146               if (DECL_CONTEXT (oldlocal) == current_function_decl
4147                   && TREE_CODE (x) != PARM_DECL)
4148                 {
4149                   /* Go to where the parms should be and see if we find
4150                      them there.  */
4151                   struct cp_binding_level *b = current_binding_level->level_chain;
4152
4153                   /* Skip the ctor/dtor cleanup level.  */
4154                   b = b->level_chain;
4155
4156                   /* ARM $8.3 */
4157                   if (b->parm_flag == 1)
4158                     {
4159                       error ("declaration of `%#D' shadows a parameter",
4160                                 name);
4161                       err = true;
4162                     }
4163                 }
4164
4165               if (warn_shadow && !err)
4166                 shadow_warning ("a parameter", name, oldlocal);
4167             }
4168
4169           /* Maybe warn if shadowing something else.  */
4170           else if (warn_shadow && !DECL_EXTERNAL (x)
4171               /* No shadow warnings for internally generated vars.  */
4172               && ! DECL_ARTIFICIAL (x)
4173               /* No shadow warnings for vars made for inlining.  */
4174               && ! DECL_FROM_INLINE (x))
4175             {
4176               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4177                        && current_class_ptr
4178                        && !TREE_STATIC (name))
4179                 warning ("declaration of `%s' shadows a member of `this'",
4180                             IDENTIFIER_POINTER (name));
4181               else if (oldlocal != NULL_TREE
4182                        && TREE_CODE (oldlocal) == VAR_DECL)
4183                 shadow_warning ("a previous local", name, oldlocal);
4184               else if (oldglobal != NULL_TREE
4185                        && TREE_CODE (oldglobal) == VAR_DECL)
4186                 /* XXX shadow warnings in outer-more namespaces */
4187                 shadow_warning ("a global declaration", name, oldglobal);
4188             }
4189         }
4190
4191       if (TREE_CODE (x) == FUNCTION_DECL)
4192         check_default_args (x);
4193
4194       if (TREE_CODE (x) == VAR_DECL)
4195         maybe_register_incomplete_var (x);
4196     }
4197
4198   if (need_new_binding)
4199     add_decl_to_level (x,
4200                        DECL_NAMESPACE_SCOPE_P (x)
4201                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4202                        : current_binding_level);
4203
4204   return x;
4205 }
4206
4207 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4208    caller to set DECL_CONTEXT properly.  */
4209
4210 static tree
4211 pushdecl_with_scope (x, level)
4212      tree x;
4213      struct cp_binding_level *level;
4214 {
4215   register struct cp_binding_level *b;
4216   tree function_decl = current_function_decl;
4217
4218   current_function_decl = NULL_TREE;
4219   if (level->parm_flag == 2)
4220     {
4221       b = class_binding_level;
4222       class_binding_level = level;
4223       pushdecl_class_level (x);
4224       class_binding_level = b;
4225     }
4226   else
4227     {
4228       b = current_binding_level;
4229       current_binding_level = level;
4230       x = pushdecl (x);
4231       current_binding_level = b;
4232     }
4233   current_function_decl = function_decl;
4234   return x;
4235 }
4236
4237 /* Like pushdecl, only it places X in the current namespace,
4238    if appropriate.  */
4239
4240 tree
4241 pushdecl_namespace_level (x)
4242      tree x;
4243 {
4244   register struct cp_binding_level *b = current_binding_level;
4245   register tree t;
4246
4247   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4248
4249   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4250      what we want.  */
4251   if (TREE_CODE (x) == TYPE_DECL)
4252     {
4253       tree name = DECL_NAME (x);
4254       tree newval;
4255       tree *ptr = (tree *)0;
4256       for (; b != global_binding_level; b = b->level_chain)
4257         {
4258           tree shadowed = b->type_shadowed;
4259           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4260             if (TREE_PURPOSE (shadowed) == name)
4261               {
4262                 ptr = &TREE_VALUE (shadowed);
4263                 /* Can't break out of the loop here because sometimes
4264                    a binding level will have duplicate bindings for
4265                    PT names.  It's gross, but I haven't time to fix it.  */
4266               }
4267         }
4268       newval = TREE_TYPE (x);
4269       if (ptr == (tree *)0)
4270         {
4271           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4272              up here if this is changed to an assertion.  --KR  */
4273           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4274         }
4275       else
4276         {
4277           *ptr = newval;
4278         }
4279     }
4280   return t;
4281 }
4282
4283 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4284    if appropriate.  */
4285
4286 tree
4287 pushdecl_top_level (x)
4288      tree x;
4289 {
4290   push_to_top_level ();
4291   x = pushdecl_namespace_level (x);
4292   pop_from_top_level ();
4293   return x;
4294 }
4295
4296 /* Make the declaration of X appear in CLASS scope.  */
4297
4298 void
4299 pushdecl_class_level (x)
4300      tree x;
4301 {
4302   tree name;
4303
4304   /* Get the name of X.  */
4305   if (TREE_CODE (x) == OVERLOAD)
4306     name = DECL_NAME (get_first_fn (x));
4307   else
4308     name = DECL_NAME (x);
4309
4310   if (name)
4311     {
4312       push_class_level_binding (name, x);
4313       if (TREE_CODE (x) == TYPE_DECL)
4314         set_identifier_type_value (name, TREE_TYPE (x));
4315     }
4316   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4317     {
4318       /* If X is an anonymous aggregate, all of its members are
4319          treated as if they were members of the class containing the
4320          aggregate, for naming purposes.  */
4321       tree f;
4322
4323       for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
4324         pushdecl_class_level (f);
4325     }
4326 }
4327
4328 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4329    DECL, or a modified version thereof.  */
4330
4331 tree
4332 maybe_push_decl (decl)
4333      tree decl;
4334 {
4335   tree type = TREE_TYPE (decl);
4336
4337   /* Add this decl to the current binding level, but not if it comes
4338      from another scope, e.g. a static member variable.  TEM may equal
4339      DECL or it may be a previous decl of the same name.  */
4340   if (decl == error_mark_node
4341       || (TREE_CODE (decl) != PARM_DECL
4342           && DECL_CONTEXT (decl) != NULL_TREE
4343           /* Definitions of namespace members outside their namespace are
4344              possible.  */
4345           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4346       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4347       || TREE_CODE (type) == UNKNOWN_TYPE
4348       /* The declaration of a template specialization does not affect
4349          the functions available for overload resolution, so we do not
4350          call pushdecl.  */
4351       || (TREE_CODE (decl) == FUNCTION_DECL
4352           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4353     return decl;
4354   else
4355     return pushdecl (decl);
4356 }
4357
4358 /* Make the declaration(s) of X appear in CLASS scope
4359    under the name NAME.  */
4360
4361 void
4362 push_class_level_binding (name, x)
4363      tree name;
4364      tree x;
4365 {
4366   tree binding;
4367   /* The class_binding_level will be NULL if x is a template
4368      parameter name in a member template.  */
4369   if (!class_binding_level)
4370     return;
4371
4372   /* Make sure that this new member does not have the same name
4373      as a template parameter.  */
4374   if (TYPE_BEING_DEFINED (current_class_type))
4375     check_template_shadow (x);
4376
4377   /* If this declaration shadows a declaration from an enclosing
4378      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4379      we leave this class.  Record the shadowed declaration here.  */
4380   binding = IDENTIFIER_BINDING (name);
4381   if (binding
4382       && ((TREE_CODE (x) == OVERLOAD
4383            && BINDING_VALUE (binding)
4384            && is_overloaded_fn (BINDING_VALUE (binding)))
4385           || INHERITED_VALUE_BINDING_P (binding)))
4386     {
4387       tree shadow;
4388       tree old_decl;
4389
4390       /* If the old binding was from a base class, and was for a tag
4391          name, slide it over to make room for the new binding.  The
4392          old binding is still visible if explicitly qualified with a
4393          class-key.  */
4394       if (INHERITED_VALUE_BINDING_P (binding)
4395           && BINDING_VALUE (binding)
4396           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4397           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4398           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4399         {
4400           old_decl = BINDING_TYPE (binding);
4401           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4402           BINDING_VALUE (binding) = NULL_TREE;
4403           INHERITED_VALUE_BINDING_P (binding) = 0;
4404         }
4405       else
4406         old_decl = BINDING_VALUE (binding);
4407
4408       /* Find the previous binding of name on the class-shadowed
4409          list, and update it.  */
4410       for (shadow = class_binding_level->class_shadowed;
4411            shadow;
4412            shadow = TREE_CHAIN (shadow))
4413         if (TREE_PURPOSE (shadow) == name
4414             && TREE_TYPE (shadow) == old_decl)
4415           {
4416             BINDING_VALUE (binding) = x;
4417             INHERITED_VALUE_BINDING_P (binding) = 0;
4418             TREE_TYPE (shadow) = x;
4419             IDENTIFIER_CLASS_VALUE (name) = x;
4420             return;
4421           }
4422     }
4423
4424   /* If we didn't replace an existing binding, put the binding on the
4425      stack of bindings for the identifier, and update the shadowed list.  */
4426   if (push_class_binding (name, x))
4427     {
4428       class_binding_level->class_shadowed
4429         = tree_cons (name, NULL,
4430                      class_binding_level->class_shadowed);
4431       /* Record the value we are binding NAME to so that we can know
4432          what to pop later.  */
4433       TREE_TYPE (class_binding_level->class_shadowed) = x;
4434     }
4435 }
4436
4437 /* Insert another USING_DECL into the current binding level, returning
4438    this declaration. If this is a redeclaration, do nothing, and
4439    return NULL_TREE if this not in namespace scope (in namespace
4440    scope, a using decl might extend any previous bindings).  */
4441
4442 tree
4443 push_using_decl (scope, name)
4444      tree scope;
4445      tree name;
4446 {
4447   tree decl;
4448
4449   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4450   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4451   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4452     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4453       break;
4454   if (decl)
4455     return namespace_bindings_p () ? decl : NULL_TREE;
4456   decl = build_lang_decl (USING_DECL, name, void_type_node);
4457   DECL_INITIAL (decl) = scope;
4458   TREE_CHAIN (decl) = current_binding_level->usings;
4459   current_binding_level->usings = decl;
4460   return decl;
4461 }
4462
4463 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4464    changed (i.e. there was already a directive), or the fresh
4465    TREE_LIST otherwise.  */
4466
4467 tree
4468 push_using_directive (used)
4469      tree used;
4470 {
4471   tree ud = current_binding_level->using_directives;
4472   tree iter, ancestor;
4473
4474   /* Check if we already have this.  */
4475   if (purpose_member (used, ud) != NULL_TREE)
4476     return NULL_TREE;
4477
4478   /* Recursively add all namespaces used.  */
4479   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4480     push_using_directive (TREE_PURPOSE (iter));
4481
4482   ancestor = namespace_ancestor (current_decl_namespace (), used);
4483   ud = current_binding_level->using_directives;
4484   ud = tree_cons (used, ancestor, ud);
4485   current_binding_level->using_directives = ud;
4486   return ud;
4487 }
4488
4489 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4490    other definitions already in place.  We get around this by making
4491    the value of the identifier point to a list of all the things that
4492    want to be referenced by that name.  It is then up to the users of
4493    that name to decide what to do with that list.
4494
4495    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4496    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4497
4498    FLAGS is a bitwise-or of the following values:
4499      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4500                  namespace scope.
4501      PUSH_USING: DECL is being pushed as the result of a using
4502                  declaration.
4503
4504    The value returned may be a previous declaration if we guessed wrong
4505    about what language DECL should belong to (C or C++).  Otherwise,
4506    it's always DECL (and never something that's not a _DECL).  */
4507
4508 tree
4509 push_overloaded_decl (decl, flags)
4510      tree decl;
4511      int flags;
4512 {
4513   tree name = DECL_NAME (decl);
4514   tree old;
4515   tree new_binding;
4516   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4517
4518   if (doing_global)
4519     old = namespace_binding (name, DECL_CONTEXT (decl));
4520   else
4521     old = lookup_name_current_level (name);
4522
4523   if (old)
4524     {
4525       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4526         {
4527           tree t = TREE_TYPE (old);
4528           if (IS_AGGR_TYPE (t) && warn_shadow
4529               && (! DECL_IN_SYSTEM_HEADER (decl)
4530                   || ! DECL_IN_SYSTEM_HEADER (old)))
4531             warning ("`%#D' hides constructor for `%#T'", decl, t);
4532           old = NULL_TREE;
4533         }
4534       else if (is_overloaded_fn (old))
4535         {
4536           tree tmp;
4537
4538           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4539             {
4540               tree fn = OVL_CURRENT (tmp);
4541
4542               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4543                   && !(flags & PUSH_USING)
4544                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4545                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4546                 error ("`%#D' conflicts with previous using declaration `%#D'",
4547                           decl, fn);
4548
4549               if (duplicate_decls (decl, fn))
4550                 return fn;
4551             }
4552         }
4553       else if (old == error_mark_node)
4554         /* Ignore the undefined symbol marker.  */
4555         old = NULL_TREE;
4556       else
4557         {
4558           cp_error_at ("previous non-function declaration `%#D'", old);
4559           error ("conflicts with function declaration `%#D'", decl);
4560           return decl;
4561         }
4562     }
4563
4564   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4565     {
4566       if (old && TREE_CODE (old) != OVERLOAD)
4567         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4568       else
4569         new_binding = ovl_cons (decl, old);
4570       if (flags & PUSH_USING)
4571         OVL_USED (new_binding) = 1;
4572     }
4573   else
4574     /* NAME is not ambiguous.  */
4575     new_binding = decl;
4576
4577   if (doing_global)
4578     set_namespace_binding (name, current_namespace, new_binding);
4579   else
4580     {
4581       /* We only create an OVERLOAD if there was a previous binding at
4582          this level, or if decl is a template. In the former case, we
4583          need to remove the old binding and replace it with the new
4584          binding.  We must also run through the NAMES on the binding
4585          level where the name was bound to update the chain.  */
4586
4587       if (TREE_CODE (new_binding) == OVERLOAD && old)
4588         {
4589           tree *d;
4590
4591           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4592                *d;
4593                d = &TREE_CHAIN (*d))
4594             if (*d == old
4595                 || (TREE_CODE (*d) == TREE_LIST
4596                     && TREE_VALUE (*d) == old))
4597               {
4598                 if (TREE_CODE (*d) == TREE_LIST)
4599                   /* Just replace the old binding with the new.  */
4600                   TREE_VALUE (*d) = new_binding;
4601                 else
4602                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4603                   *d = tree_cons (NULL_TREE, new_binding,
4604                                   TREE_CHAIN (*d));
4605
4606                 /* And update the CPLUS_BINDING node.  */
4607                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4608                   = new_binding;
4609                 return decl;
4610               }
4611
4612           /* We should always find a previous binding in this case.  */
4613           abort ();
4614         }
4615
4616       /* Install the new binding.  */
4617       push_local_binding (name, new_binding, flags);
4618     }
4619
4620   return decl;
4621 }
4622 \f
4623 /* Generate an implicit declaration for identifier FUNCTIONID
4624    as a function of type int ().  Print a warning if appropriate.  */
4625
4626 tree
4627 implicitly_declare (functionid)
4628      tree functionid;
4629 {
4630   register tree decl;
4631
4632   /* We used to reuse an old implicit decl here,
4633      but this loses with inline functions because it can clobber
4634      the saved decl chains.  */
4635   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4636
4637   DECL_EXTERNAL (decl) = 1;
4638   TREE_PUBLIC (decl) = 1;
4639
4640   /* ISO standard says implicit declarations are in the innermost block.
4641      So we record the decl in the standard fashion.  */
4642   pushdecl (decl);
4643   rest_of_decl_compilation (decl, NULL, 0, 0);
4644
4645   if (warn_implicit
4646       /* Only one warning per identifier.  */
4647       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4648     {
4649       pedwarn ("implicit declaration of function `%#D'", decl);
4650     }
4651
4652   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4653
4654   return decl;
4655 }
4656
4657 /* Return zero if the declaration NEWDECL is valid
4658    when the declaration OLDDECL (assumed to be for the same name)
4659    has already been seen.
4660    Otherwise return an error message format string with a %s
4661    where the identifier should go.  */
4662
4663 static const char *
4664 redeclaration_error_message (newdecl, olddecl)
4665      tree newdecl, olddecl;
4666 {
4667   if (TREE_CODE (newdecl) == TYPE_DECL)
4668     {
4669       /* Because C++ can put things into name space for free,
4670          constructs like "typedef struct foo { ... } foo"
4671          would look like an erroneous redeclaration.  */
4672       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4673         return 0;
4674       else
4675         return "redefinition of `%#D'";
4676     }
4677   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4678     {
4679       /* If this is a pure function, its olddecl will actually be
4680          the original initialization to `0' (which we force to call
4681          abort()).  Don't complain about redefinition in this case.  */
4682       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4683         return 0;
4684
4685       /* If both functions come from different namespaces, this is not
4686          a redeclaration - this is a conflict with a used function.  */
4687       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4688           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4689         return "`%D' conflicts with used function";
4690
4691       /* We'll complain about linkage mismatches in
4692          warn_extern_redeclared_static.  */
4693
4694       /* Defining the same name twice is no good.  */
4695       if (DECL_INITIAL (olddecl) != NULL_TREE
4696           && DECL_INITIAL (newdecl) != NULL_TREE)
4697         {
4698           if (DECL_NAME (olddecl) == NULL_TREE)
4699             return "`%#D' not declared in class";
4700           else
4701             return "redefinition of `%#D'";
4702         }
4703       return 0;
4704     }
4705   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4706     {
4707       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4708            && (DECL_TEMPLATE_RESULT (newdecl)
4709                != DECL_TEMPLATE_RESULT (olddecl))
4710            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4711            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4712           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4713               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4714               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4715         return "redefinition of `%#D'";
4716       return 0;
4717     }
4718   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4719     {
4720       /* Objects declared at top level:  */
4721       /* If at least one is a reference, it's ok.  */
4722       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4723         return 0;
4724       /* Reject two definitions.  */
4725       return "redefinition of `%#D'";
4726     }
4727   else
4728     {
4729       /* Objects declared with block scope:  */
4730       /* Reject two definitions, and reject a definition
4731          together with an external reference.  */
4732       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4733         return "redeclaration of `%#D'";
4734       return 0;
4735     }
4736 }
4737 \f
4738 /* Create a new label, named ID.  */
4739
4740 static tree
4741 make_label_decl (id, local_p)
4742      tree id;
4743      int local_p;
4744 {
4745   tree decl;
4746
4747   decl = build_decl (LABEL_DECL, id, void_type_node);
4748   if (expanding_p)
4749     /* Make sure every label has an rtx.  */
4750     label_rtx (decl);
4751
4752   DECL_CONTEXT (decl) = current_function_decl;
4753   DECL_MODE (decl) = VOIDmode;
4754   C_DECLARED_LABEL_FLAG (decl) = local_p;
4755
4756   /* Say where one reference is to the label, for the sake of the
4757      error if it is not defined.  */
4758   DECL_SOURCE_LINE (decl) = lineno;
4759   DECL_SOURCE_FILE (decl) = input_filename;
4760
4761   /* Record the fact that this identifier is bound to this label.  */
4762   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4763
4764   return decl;
4765 }
4766
4767 /* Record this label on the list of used labels so that we can check
4768    at the end of the function to see whether or not the label was
4769    actually defined, and so we can check when the label is defined whether
4770    this use is valid.  */
4771
4772 static void
4773 use_label (decl)
4774      tree decl;
4775 {
4776   if (named_label_uses == NULL
4777       || named_label_uses->names_in_scope != current_binding_level->names
4778       || named_label_uses->label_decl != decl)
4779     {
4780       struct named_label_use_list *new_ent;
4781       new_ent = ((struct named_label_use_list *)
4782                  ggc_alloc (sizeof (struct named_label_use_list)));
4783       new_ent->label_decl = decl;
4784       new_ent->names_in_scope = current_binding_level->names;
4785       new_ent->binding_level = current_binding_level;
4786       new_ent->lineno_o_goto = lineno;
4787       new_ent->filename_o_goto = input_filename;
4788       new_ent->next = named_label_uses;
4789       named_label_uses = new_ent;
4790     }
4791 }
4792
4793 /* Look for a label named ID in the current function.  If one cannot
4794    be found, create one.  (We keep track of used, but undefined,
4795    labels, and complain about them at the end of a function.)  */
4796
4797 tree
4798 lookup_label (id)
4799      tree id;
4800 {
4801   tree decl;
4802   struct named_label_list *ent;
4803
4804   /* You can't use labels at global scope.  */
4805   if (current_function_decl == NULL_TREE)
4806     {
4807       error ("label `%s' referenced outside of any function",
4808              IDENTIFIER_POINTER (id));
4809       return NULL_TREE;
4810     }
4811
4812   /* See if we've already got this label.  */
4813   decl = IDENTIFIER_LABEL_VALUE (id);
4814   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4815     return decl;
4816
4817   /* Record this label on the list of labels used in this function.
4818      We do this before calling make_label_decl so that we get the
4819      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4820   ent = ((struct named_label_list *)
4821          ggc_alloc_cleared (sizeof (struct named_label_list)));
4822   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4823   ent->next = named_labels;
4824   named_labels = ent;
4825
4826   /* We need a new label.  */
4827   decl = make_label_decl (id, /*local_p=*/0);
4828
4829   /* Now fill in the information we didn't have before.  */
4830   ent->label_decl = decl;
4831
4832   return decl;
4833 }
4834
4835 /* Declare a local label named ID.  */
4836
4837 tree
4838 declare_local_label (id)
4839      tree id;
4840 {
4841   tree decl;
4842
4843   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4844      this scope we can restore the old value of
4845      IDENTIFIER_TYPE_VALUE.  */
4846   current_binding_level->shadowed_labels
4847     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4848                  current_binding_level->shadowed_labels);
4849   /* Look for the label.  */
4850   decl = make_label_decl (id, /*local_p=*/1);
4851   /* Now fill in the information we didn't have before.  */
4852   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4853
4854   return decl;
4855 }
4856
4857 /* Returns nonzero if it is ill-formed to jump past the declaration of
4858    DECL.  Returns 2 if it's also a real problem.  */
4859
4860 static int
4861 decl_jump_unsafe (decl)
4862      tree decl;
4863 {
4864   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4865     return 0;
4866
4867   if (DECL_INITIAL (decl) == NULL_TREE
4868       && pod_type_p (TREE_TYPE (decl)))
4869     return 0;
4870
4871   /* This is really only important if we're crossing an initialization.
4872      The POD stuff is just pedantry; why should it matter if the class
4873      contains a field of pointer to member type?  */
4874   if (DECL_INITIAL (decl)
4875       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4876     return 2;
4877   return 1;
4878 }
4879
4880 /* Check that a single previously seen jump to a newly defined label
4881    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4882    the jump context; NAMES are the names in scope in LEVEL at the jump
4883    context; FILE and LINE are the source position of the jump or 0.  */
4884
4885 static void
4886 check_previous_goto_1 (decl, level, names, file, line)
4887      tree decl;
4888      struct cp_binding_level *level;
4889      tree names;
4890      const char *file;
4891      int line;
4892 {
4893   int identified = 0;
4894   int saw_eh = 0;
4895   struct cp_binding_level *b = current_binding_level;
4896   for (; b; b = b->level_chain)
4897     {
4898       tree new_decls = b->names;
4899       tree old_decls = (b == level ? names : NULL_TREE);
4900       for (; new_decls != old_decls;
4901            new_decls = TREE_CHAIN (new_decls))
4902         {
4903           int problem = decl_jump_unsafe (new_decls);
4904           if (! problem)
4905             continue;
4906
4907           if (! identified)
4908             {
4909               if (decl)
4910                 pedwarn ("jump to label `%D'", decl);
4911               else
4912                 pedwarn ("jump to case label");
4913
4914               if (file)
4915                 pedwarn_with_file_and_line (file, line, "  from here");
4916               identified = 1;
4917             }
4918
4919           if (problem > 1)
4920             cp_error_at ("  crosses initialization of `%#D'",
4921                          new_decls);
4922           else
4923             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4924                            new_decls);
4925         }
4926
4927       if (b == level)
4928         break;
4929       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4930         {
4931           if (! identified)
4932             {
4933               if (decl)
4934                 pedwarn ("jump to label `%D'", decl);
4935               else
4936                 pedwarn ("jump to case label");
4937
4938               if (file)
4939                 pedwarn_with_file_and_line (file, line, "  from here");
4940               identified = 1;
4941             }
4942           if (b->is_try_scope)
4943             error ("  enters try block");
4944           else
4945             error ("  enters catch block");
4946           saw_eh = 1;
4947         }
4948     }
4949 }
4950
4951 static void
4952 check_previous_goto (use)
4953      struct named_label_use_list *use;
4954 {
4955   check_previous_goto_1 (use->label_decl, use->binding_level,
4956                          use->names_in_scope, use->filename_o_goto,
4957                          use->lineno_o_goto);
4958 }
4959
4960 static void
4961 check_switch_goto (level)
4962      struct cp_binding_level *level;
4963 {
4964   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4965 }
4966
4967 /* Check that any previously seen jumps to a newly defined label DECL
4968    are OK.  Called by define_label.  */
4969
4970 static void
4971 check_previous_gotos (decl)
4972      tree decl;
4973 {
4974   struct named_label_use_list **usep;
4975
4976   if (! TREE_USED (decl))
4977     return;
4978
4979   for (usep = &named_label_uses; *usep; )
4980     {
4981       struct named_label_use_list *use = *usep;
4982       if (use->label_decl == decl)
4983         {
4984           check_previous_goto (use);
4985           *usep = use->next;
4986         }
4987       else
4988         usep = &(use->next);
4989     }
4990 }
4991
4992 /* Check that a new jump to a label DECL is OK.  Called by
4993    finish_goto_stmt.  */
4994
4995 void
4996 check_goto (decl)
4997      tree decl;
4998 {
4999   int identified = 0;
5000   tree bad;
5001   struct named_label_list *lab;
5002
5003   /* We can't know where a computed goto is jumping.  So we assume
5004      that it's OK.  */
5005   if (! DECL_P (decl))
5006     return;
5007
5008   /* If the label hasn't been defined yet, defer checking.  */
5009   if (! DECL_INITIAL (decl))
5010     {
5011       use_label (decl);
5012       return;
5013     }
5014
5015   for (lab = named_labels; lab; lab = lab->next)
5016     if (decl == lab->label_decl)
5017       break;
5018
5019   /* If the label is not on named_labels it's a gcc local label, so
5020      it must be in an outer scope, so jumping to it is always OK.  */
5021   if (lab == 0)
5022     return;
5023
5024   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5025       && !identified)
5026     {
5027       cp_pedwarn_at ("jump to label `%D'", decl);
5028       pedwarn ("  from here");
5029       identified = 1;
5030     }
5031
5032   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5033     {
5034       tree b = TREE_VALUE (bad);
5035       int u = decl_jump_unsafe (b);
5036
5037       if (u > 1 && DECL_ARTIFICIAL (b))
5038         /* Can't skip init of __exception_info.  */
5039         cp_error_at ("  enters catch block", b);
5040       else if (u > 1)
5041         cp_error_at ("  skips initialization of `%#D'", b);
5042       else
5043         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5044     }
5045
5046   if (lab->in_try_scope)
5047     error ("  enters try block");
5048   else if (lab->in_catch_scope)
5049     error ("  enters catch block");
5050 }
5051
5052 /* Define a label, specifying the location in the source file.
5053    Return the LABEL_DECL node for the label, if the definition is valid.
5054    Otherwise return 0.  */
5055
5056 tree
5057 define_label (filename, line, name)
5058      const char *filename;
5059      int line;
5060      tree name;
5061 {
5062   tree decl = lookup_label (name);
5063   struct named_label_list *ent;
5064   register struct cp_binding_level *p;
5065
5066   for (ent = named_labels; ent; ent = ent->next)
5067     if (ent->label_decl == decl)
5068       break;
5069
5070   /* After labels, make any new cleanups in the function go into their
5071      own new (temporary) binding contour.  */
5072   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5073     p->more_cleanups_ok = 0;
5074
5075   if (name == get_identifier ("wchar_t"))
5076     pedwarn ("label named wchar_t");
5077
5078   if (DECL_INITIAL (decl) != NULL_TREE)
5079     {
5080       error ("duplicate label `%D'", decl);
5081       return 0;
5082     }
5083   else
5084     {
5085       /* Mark label as having been defined.  */
5086       DECL_INITIAL (decl) = error_mark_node;
5087       /* Say where in the source.  */
5088       DECL_SOURCE_FILE (decl) = filename;
5089       DECL_SOURCE_LINE (decl) = line;
5090       if (ent)
5091         {
5092           ent->names_in_scope = current_binding_level->names;
5093           ent->binding_level = current_binding_level;
5094         }
5095       check_previous_gotos (decl);
5096       return decl;
5097     }
5098 }
5099
5100 struct cp_switch
5101 {
5102   struct cp_binding_level *level;
5103   struct cp_switch *next;
5104   /* The SWITCH_STMT being built.  */
5105   tree switch_stmt;
5106   /* A splay-tree mapping the low element of a case range to the high
5107      element, or NULL_TREE if there is no high element.  Used to
5108      determine whether or not a new case label duplicates an old case
5109      label.  We need a tree, rather than simply a hash table, because
5110      of the GNU case range extension.  */
5111   splay_tree cases;
5112 };
5113
5114 /* A stack of the currently active switch statements.  The innermost
5115    switch statement is on the top of the stack.  There is no need to
5116    mark the stack for garbage collection because it is only active
5117    during the processing of the body of a function, and we never
5118    collect at that point.  */
5119
5120 static struct cp_switch *switch_stack;
5121
5122 /* Called right after a switch-statement condition is parsed.
5123    SWITCH_STMT is the switch statement being parsed.  */
5124
5125 void
5126 push_switch (switch_stmt)
5127      tree switch_stmt;
5128 {
5129   struct cp_switch *p
5130     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5131   p->level = current_binding_level;
5132   p->next = switch_stack;
5133   p->switch_stmt = switch_stmt;
5134   p->cases = splay_tree_new (case_compare, NULL, NULL);
5135   switch_stack = p;
5136 }
5137
5138 void
5139 pop_switch ()
5140 {
5141   struct cp_switch *cs;
5142
5143   cs = switch_stack;
5144   splay_tree_delete (cs->cases);
5145   switch_stack = switch_stack->next;
5146   free (cs);
5147 }
5148
5149 /* Note that we've seen a definition of a case label, and complain if this
5150    is a bad place for one.  */
5151
5152 tree
5153 finish_case_label (low_value, high_value)
5154      tree low_value;
5155      tree high_value;
5156 {
5157   tree cond, r;
5158   register struct cp_binding_level *p;
5159
5160   if (! switch_stack)
5161     {
5162       if (high_value)
5163         error ("case label not within a switch statement");
5164       else if (low_value)
5165         error ("case label `%E' not within a switch statement",
5166                   low_value);
5167       else
5168         error ("`default' label not within a switch statement");
5169       return NULL_TREE;
5170     }
5171
5172   if (processing_template_decl)
5173     {
5174       tree label;
5175
5176       /* For templates, just add the case label; we'll do semantic
5177          analysis at instantiation-time.  */
5178       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5179       return add_stmt (build_case_label (low_value, high_value, label));
5180     }
5181
5182   /* Find the condition on which this switch statement depends.  */
5183   cond = SWITCH_COND (switch_stack->switch_stmt);
5184   if (cond && TREE_CODE (cond) == TREE_LIST)
5185     cond = TREE_VALUE (cond);
5186
5187   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5188   if (r == error_mark_node)
5189     r = NULL_TREE;
5190
5191   check_switch_goto (switch_stack->level);
5192
5193   /* After labels, make any new cleanups in the function go into their
5194      own new (temporary) binding contour.  */
5195   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5196     p->more_cleanups_ok = 0;
5197
5198   return r;
5199 }
5200 \f
5201 /* Return the list of declarations of the current level.
5202    Note that this list is in reverse order unless/until
5203    you nreverse it; and when you do nreverse it, you must
5204    store the result back using `storedecls' or you will lose.  */
5205
5206 tree
5207 getdecls ()
5208 {
5209   return current_binding_level->names;
5210 }
5211
5212 /* Return the list of type-tags (for structs, etc) of the current level.  */
5213
5214 tree
5215 gettags ()
5216 {
5217   return current_binding_level->tags;
5218 }
5219
5220 /* Store the list of declarations of the current level.
5221    This is done for the parameter declarations of a function being defined,
5222    after they are modified in the light of any missing parameters.  */
5223
5224 static void
5225 storedecls (decls)
5226      tree decls;
5227 {
5228   current_binding_level->names = decls;
5229 }
5230
5231 /* Similarly, store the list of tags of the current level.  */
5232
5233 void
5234 storetags (tags)
5235      tree tags;
5236 {
5237   current_binding_level->tags = tags;
5238 }
5239 \f
5240 /* Return the type that should be used when TYPE's name is preceded
5241    by a tag such as 'struct' or 'union', or null if the name cannot
5242    be used in this way.
5243
5244    For example, when processing the third line of:
5245
5246         struct A;
5247         typedef struct A A;
5248         struct A;
5249
5250    lookup of A will find the typedef.  Given A's typedef, this function
5251    will return the type associated with "struct A".  For the tag to be
5252    anything other than TYPE, TYPE must be a typedef whose original type
5253    has the same name and context as TYPE itself.
5254
5255    It is not valid for a typedef of an anonymous type to be used with
5256    an explicit tag:
5257
5258        typedef struct { ... } B;
5259        struct B;
5260
5261    Return null for this case.  */
5262
5263 static tree
5264 follow_tag_typedef (type)
5265      tree type;
5266 {
5267   tree original;
5268
5269   original = original_type (type);
5270   if (! TYPE_NAME (original))
5271     return NULL_TREE;
5272   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5273       && (CP_DECL_CONTEXT (TYPE_NAME (original))
5274           == CP_DECL_CONTEXT (TYPE_NAME (type)))
5275       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5276     return original;
5277   else
5278     return NULL_TREE;
5279 }
5280
5281 /* Given NAME, an IDENTIFIER_NODE,
5282    return the structure (or union or enum) definition for that name.
5283    Searches binding levels from BINDING_LEVEL up to the global level.
5284    If THISLEVEL_ONLY is nonzero, searches only the specified context
5285    (but skips any tag-transparent contexts to find one that is
5286    meaningful for tags).
5287    FORM says which kind of type the caller wants;
5288    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5289    If the wrong kind of type is found, and it's not a template, an error is
5290    reported.  */
5291
5292 static tree
5293 lookup_tag (form, name, binding_level, thislevel_only)
5294      enum tree_code form;
5295      tree name;
5296      struct cp_binding_level *binding_level;
5297      int thislevel_only;
5298 {
5299   register struct cp_binding_level *level;
5300   /* Nonzero if, we should look past a template parameter level, even
5301      if THISLEVEL_ONLY.  */
5302   int allow_template_parms_p = 1;
5303
5304   for (level = binding_level; level; level = level->level_chain)
5305     {
5306       register tree tail;
5307       if (ANON_AGGRNAME_P (name))
5308         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5309           {
5310             /* There's no need for error checking here, because
5311                anon names are unique throughout the compilation.  */
5312             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5313               return TREE_VALUE (tail);
5314           }
5315       else if (level->namespace_p)
5316         /* Do namespace lookup.  */
5317         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5318           {
5319             tree old = binding_for_name (name, tail);
5320
5321             /* If we just skipped past a template parameter level,
5322                even though THISLEVEL_ONLY, and we find a template
5323                class declaration, then we use the _TYPE node for the
5324                template.  See the example below.  */
5325             if (thislevel_only && !allow_template_parms_p
5326                 && old && BINDING_VALUE (old)
5327                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5328               old = TREE_TYPE (BINDING_VALUE (old));
5329             else
5330               old = BINDING_TYPE (old);
5331
5332             if (old)
5333               {
5334                 /* We've found something at this binding level.  If it is
5335                    a typedef, extract the tag it refers to.  Lookup fails
5336                    if the typedef doesn't refer to a taggable type.  */
5337                 old = follow_tag_typedef (old);
5338                 if (!old)
5339                   return NULL_TREE;
5340                 if (TREE_CODE (old) != form
5341                     && (form == ENUMERAL_TYPE
5342                         || TREE_CODE (old) == ENUMERAL_TYPE))
5343                   {
5344                     error ("`%#D' redeclared as %C", old, form);
5345                     return NULL_TREE;
5346                   }
5347                 return old;
5348               }
5349             if (thislevel_only || tail == global_namespace)
5350               return NULL_TREE;
5351           }
5352       else
5353         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5354           {
5355             if (TREE_PURPOSE (tail) == name)
5356               {
5357                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5358
5359                 if (code != form
5360                     && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5361                   {
5362                     /* Definition isn't the kind we were looking for.  */
5363                     error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5364                     return NULL_TREE;
5365                   }
5366                 return TREE_VALUE (tail);
5367               }
5368           }
5369       if (thislevel_only && ! level->tag_transparent)
5370         {
5371           if (level->template_parms_p && allow_template_parms_p)
5372             {
5373               /* We must deal with cases like this:
5374
5375                    template <class T> struct S;
5376                    template <class T> struct S {};
5377
5378                  When looking up `S', for the second declaration, we
5379                  would like to find the first declaration.  But, we
5380                  are in the pseudo-global level created for the
5381                  template parameters, rather than the (surrounding)
5382                  namespace level.  Thus, we keep going one more level,
5383                  even though THISLEVEL_ONLY is nonzero.  */
5384               allow_template_parms_p = 0;
5385               continue;
5386             }
5387           else
5388             return NULL_TREE;
5389         }
5390     }
5391   return NULL_TREE;
5392 }
5393
5394 #if 0
5395 void
5396 set_current_level_tags_transparency (tags_transparent)
5397      int tags_transparent;
5398 {
5399   current_binding_level->tag_transparent = tags_transparent;
5400 }
5401 #endif
5402
5403 /* Given a type, find the tag that was defined for it and return the tag name.
5404    Otherwise return 0.  However, the value can never be 0
5405    in the cases in which this is used.
5406
5407    C++: If NAME is nonzero, this is the new name to install.  This is
5408    done when replacing anonymous tags with real tag names.  */
5409
5410 static tree
5411 lookup_tag_reverse (type, name)
5412      tree type;
5413      tree name;
5414 {
5415   register struct cp_binding_level *level;
5416
5417   for (level = current_binding_level; level; level = level->level_chain)
5418     {
5419       register tree tail;
5420       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5421         {
5422           if (TREE_VALUE (tail) == type)
5423             {
5424               if (name)
5425                 TREE_PURPOSE (tail) = name;
5426               return TREE_PURPOSE (tail);
5427             }
5428         }
5429     }
5430   return NULL_TREE;
5431 }
5432 \f
5433 /* Look up NAME in the NAMESPACE.  */
5434
5435 tree
5436 lookup_namespace_name (namespace, name)
5437      tree namespace, name;
5438 {
5439   tree val;
5440   tree template_id = NULL_TREE;
5441
5442   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5443
5444   if (TREE_CODE (name) == NAMESPACE_DECL)
5445     /* This happens for A::B<int> when B is a namespace.  */
5446     return name;
5447   else if (TREE_CODE (name) == TEMPLATE_DECL)
5448     {
5449       /* This happens for A::B where B is a template, and there are no
5450          template arguments.  */
5451       error ("invalid use of `%D'", name);
5452       return error_mark_node;
5453     }
5454
5455   namespace = ORIGINAL_NAMESPACE (namespace);
5456
5457   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5458     {
5459       template_id = name;
5460       name = TREE_OPERAND (name, 0);
5461       if (TREE_CODE (name) == OVERLOAD)
5462         name = DECL_NAME (OVL_CURRENT (name));
5463       else if (DECL_P (name))
5464         name = DECL_NAME (name);
5465     }
5466
5467   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5468
5469   val = make_node (CPLUS_BINDING);
5470   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5471     return error_mark_node;
5472
5473   if (BINDING_VALUE (val))
5474     {
5475       val = BINDING_VALUE (val);
5476
5477       if (template_id)
5478         {
5479           if (DECL_CLASS_TEMPLATE_P (val))
5480             val = lookup_template_class (val,
5481                                          TREE_OPERAND (template_id, 1),
5482                                          /*in_decl=*/NULL_TREE,
5483                                          /*context=*/NULL_TREE,
5484                                          /*entering_scope=*/0,
5485                                          tf_error | tf_warning);
5486           else if (DECL_FUNCTION_TEMPLATE_P (val)
5487                    || TREE_CODE (val) == OVERLOAD)
5488             val = lookup_template_function (val,
5489                                             TREE_OPERAND (template_id, 1));
5490           else
5491             {
5492               error ("`%D::%D' is not a template",
5493                         namespace, name);
5494               return error_mark_node;
5495             }
5496         }
5497
5498       /* If we have a single function from a using decl, pull it out.  */
5499       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5500         val = OVL_FUNCTION (val);
5501
5502       /* Ignore built-in functions that haven't been prototyped yet.  */
5503       if (!val || !DECL_P(val)
5504           || !DECL_LANG_SPECIFIC(val)
5505           || !DECL_ANTICIPATED (val))
5506         return val;
5507     }
5508
5509   error ("`%D' undeclared in namespace `%D'", name, namespace);
5510   return error_mark_node;
5511 }
5512
5513 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5514
5515 static hashval_t
5516 typename_hash (k)
5517      const void * k;
5518 {
5519   hashval_t hash;
5520   tree t = (tree) k;
5521
5522   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
5523           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
5524
5525   return hash;
5526 }
5527
5528 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5529
5530 static int
5531 typename_compare (k1, k2)
5532      const void * k1;
5533      const void * k2;
5534 {
5535   tree t1;
5536   tree t2;
5537   tree d1;
5538   tree d2;
5539
5540   t1 = (tree) k1;
5541   t2 = (tree) k2;
5542   d1 = TYPE_NAME (t1);
5543   d2 = TYPE_NAME (t2);
5544
5545   return (DECL_NAME (d1) == DECL_NAME (d2)
5546           && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
5547           && ((TREE_TYPE (t1) != NULL_TREE)
5548               == (TREE_TYPE (t2) != NULL_TREE))
5549           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5550           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5551 }
5552
5553 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5554    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5555    is non-NULL, this type is being created by the implicit typename
5556    extension, and BASE_TYPE is a type named `t' in some base class of
5557    `T' which depends on template parameters.
5558
5559    Returns the new TYPENAME_TYPE.  */
5560
5561 static GTY ((param_is (union tree_node))) htab_t typename_htab;
5562
5563 tree
5564 build_typename_type (context, name, fullname, base_type)
5565      tree context;
5566      tree name;
5567      tree fullname;
5568      tree base_type;
5569 {
5570   tree t;
5571   tree d;
5572   PTR *e;
5573
5574   if (typename_htab == NULL)
5575     {
5576       typename_htab = htab_create_ggc (61, &typename_hash,
5577                                        &typename_compare, NULL);
5578     }
5579
5580   /* Build the TYPENAME_TYPE.  */
5581   t = make_aggr_type (TYPENAME_TYPE);
5582   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5583   TYPENAME_TYPE_FULLNAME (t) = fullname;
5584   TREE_TYPE (t) = base_type;
5585
5586   /* Build the corresponding TYPE_DECL.  */
5587   d = build_decl (TYPE_DECL, name, t);
5588   TYPE_NAME (TREE_TYPE (d)) = d;
5589   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5590   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5591   DECL_ARTIFICIAL (d) = 1;
5592
5593   /* See if we already have this type.  */
5594   e = htab_find_slot (typename_htab, t, INSERT);
5595   if (*e)
5596     t = (tree) *e;
5597   else
5598     *e = t;
5599
5600   return t;
5601 }
5602
5603 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5604    unless an error occurs, in which case error_mark_node is returned.
5605    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5606    set, we return that, rather than the _TYPE it corresponds to, in
5607    other cases we look through the type decl.  If TF_ERROR is set,
5608    complain about errors, otherwise be quiet.  */
5609
5610 tree
5611 make_typename_type (context, name, complain)
5612      tree context, name;
5613      tsubst_flags_t complain;
5614 {
5615   tree fullname;
5616
5617   if (TYPE_P (name))
5618     {
5619       if (!(TYPE_LANG_SPECIFIC (name)
5620             && (CLASSTYPE_IS_TEMPLATE (name)
5621                 || CLASSTYPE_USE_TEMPLATE (name))))
5622         name = TYPE_IDENTIFIER (name);
5623       else
5624         /* Create a TEMPLATE_ID_EXPR for the type.  */
5625         name = build_nt (TEMPLATE_ID_EXPR,
5626                          CLASSTYPE_TI_TEMPLATE (name),
5627                          CLASSTYPE_TI_ARGS (name));
5628     }
5629   else if (TREE_CODE (name) == TYPE_DECL)
5630     name = DECL_NAME (name);
5631
5632   fullname = name;
5633
5634   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5635     {
5636       name = TREE_OPERAND (name, 0);
5637       if (TREE_CODE (name) == TEMPLATE_DECL)
5638         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5639     }
5640   if (TREE_CODE (name) == TEMPLATE_DECL)
5641     {
5642       error ("`%D' used without template parameters", name);
5643       return error_mark_node;
5644     }
5645   if (TREE_CODE (name) != IDENTIFIER_NODE)
5646     abort ();
5647
5648   if (TREE_CODE (context) == NAMESPACE_DECL)
5649     {
5650       /* We can get here from typename_sub0 in the explicit_template_type
5651          expansion.  Just fail.  */
5652       if (complain & tf_error)
5653         error ("no class template named `%#T' in `%#T'",
5654                   name, context);
5655       return error_mark_node;
5656     }
5657
5658   if (! uses_template_parms (context)
5659       || currently_open_class (context))
5660     {
5661       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5662         {
5663           tree tmpl = NULL_TREE;
5664           if (IS_AGGR_TYPE (context))
5665             tmpl = lookup_field (context, name, 0, 0);
5666           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5667             {
5668               if (complain & tf_error)
5669                 error ("no class template named `%#T' in `%#T'",
5670                           name, context);
5671               return error_mark_node;
5672             }
5673
5674           if (complain & tf_parsing)
5675             type_access_control (context, tmpl);
5676           else
5677             enforce_access (context, tmpl);
5678
5679           return lookup_template_class (tmpl,
5680                                         TREE_OPERAND (fullname, 1),
5681                                         NULL_TREE, context,
5682                                         /*entering_scope=*/0,
5683                                         tf_error | tf_warning);
5684         }
5685       else
5686         {
5687           tree t;
5688
5689           if (!IS_AGGR_TYPE (context))
5690             {
5691               if (complain & tf_error)
5692                 error ("no type named `%#T' in `%#T'", name, context);
5693               return error_mark_node;
5694             }
5695
5696           t = lookup_field (context, name, 0, 1);
5697           if (t)
5698             {
5699               if (TREE_CODE (t) != TYPE_DECL)
5700                 {
5701                   if (complain & tf_error)
5702                     error ("no type named `%#T' in `%#T'", name, context);
5703                   return error_mark_node;
5704                 }
5705
5706               if (complain & tf_parsing)
5707                 type_access_control (context, t);
5708               else
5709                 enforce_access (context, t);
5710
5711               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5712                 t = TREE_TYPE (t);
5713               if (IMPLICIT_TYPENAME_P (t))
5714                 {
5715                   /* Lookup found an implicit typename that we had
5716                      injected into the current scope. Doing things
5717                      properly would have located the exact same type,
5718                      so there is no error here.  We must remove the
5719                      implicitness so that we do not warn about it.  */
5720                   t = copy_node (t);
5721                   TREE_TYPE (t) = NULL_TREE;
5722                 }
5723
5724               return t;
5725             }
5726         }
5727     }
5728
5729   /* If the CONTEXT is not a template type, then either the field is
5730      there now or its never going to be.  */
5731   if (!uses_template_parms (context))
5732     {
5733       if (complain & tf_error)
5734         error ("no type named `%#T' in `%#T'", name, context);
5735       return error_mark_node;
5736     }
5737
5738   return build_typename_type (context, name, fullname,  NULL_TREE);
5739 }
5740
5741 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5742    unless an error occurs, in which case error_mark_node is returned.
5743    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5744    corresponds to.  If COMPLAIN zero, don't complain about any errors
5745    that occur.  */
5746
5747 tree
5748 make_unbound_class_template (context, name, complain)
5749      tree context, name;
5750      tsubst_flags_t complain;
5751 {
5752   tree t;
5753   tree d;
5754
5755   if (TYPE_P (name))
5756     name = TYPE_IDENTIFIER (name);
5757   else if (DECL_P (name))
5758     name = DECL_NAME (name);
5759   if (TREE_CODE (name) != IDENTIFIER_NODE)
5760     abort ();
5761
5762   if (!uses_template_parms (context)
5763       || currently_open_class (context))
5764     {
5765       tree tmpl = NULL_TREE;
5766
5767       if (IS_AGGR_TYPE (context))
5768         tmpl = lookup_field (context, name, 0, 0);
5769
5770       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5771         {
5772           if (complain & tf_error)
5773             error ("no class template named `%#T' in `%#T'", name, context);
5774           return error_mark_node;
5775         }
5776
5777       if (complain & tf_parsing)
5778         type_access_control (context, tmpl);
5779       else
5780         enforce_access (context, tmpl);
5781
5782       return tmpl;
5783     }
5784
5785   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5786   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5787   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5788   TREE_TYPE (t) = NULL_TREE;
5789
5790   /* Build the corresponding TEMPLATE_DECL.  */
5791   d = build_decl (TEMPLATE_DECL, name, t);
5792   TYPE_NAME (TREE_TYPE (d)) = d;
5793   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5794   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5795   DECL_ARTIFICIAL (d) = 1;
5796
5797   return t;
5798 }
5799
5800 /* Select the right _DECL from multiple choices.  */
5801
5802 static tree
5803 select_decl (binding, flags)
5804      tree binding;
5805      int flags;
5806 {
5807   tree val;
5808   val = BINDING_VALUE (binding);
5809
5810   if (LOOKUP_NAMESPACES_ONLY (flags))
5811     {
5812       /* We are not interested in types.  */
5813       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5814         return val;
5815       return NULL_TREE;
5816     }
5817
5818   /* If we could have a type and
5819      we have nothing or we need a type and have none.  */
5820   if (BINDING_TYPE (binding)
5821       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5822                    && TREE_CODE (val) != TYPE_DECL)))
5823     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5824   /* Don't return non-types if we really prefer types.  */
5825   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5826            && (TREE_CODE (val) != TEMPLATE_DECL
5827                || !DECL_CLASS_TEMPLATE_P (val)))
5828     val = NULL_TREE;
5829
5830   return val;
5831 }
5832
5833 /* Unscoped lookup of a global: iterate over current namespaces,
5834    considering using-directives.  If SPACESP is non-NULL, store a list
5835    of the namespaces we've considered in it.  */
5836
5837 tree
5838 unqualified_namespace_lookup (name, flags, spacesp)
5839      tree name;
5840      int flags;
5841      tree *spacesp;
5842 {
5843   tree b = make_node (CPLUS_BINDING);
5844   tree initial = current_decl_namespace ();
5845   tree scope = initial;
5846   tree siter;
5847   struct cp_binding_level *level;
5848   tree val = NULL_TREE;
5849
5850   if (spacesp)
5851     *spacesp = NULL_TREE;
5852
5853   for (; !val; scope = CP_DECL_CONTEXT (scope))
5854     {
5855       if (spacesp)
5856         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5857       val = binding_for_name (name, scope);
5858
5859       /* Ignore anticipated built-in functions.  */
5860       if (val && BINDING_VALUE (val)
5861           && DECL_P (BINDING_VALUE (val))
5862           && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5863           && DECL_ANTICIPATED (BINDING_VALUE (val)))
5864         {
5865           BINDING_VALUE (b) = NULL_TREE;
5866           BINDING_TYPE (b) = NULL_TREE;
5867         }
5868       else
5869         {
5870           /* Initialize binding for this context.  */
5871           BINDING_VALUE (b) = BINDING_VALUE (val);
5872           BINDING_TYPE (b) = BINDING_TYPE (val);
5873         }
5874
5875       /* Add all _DECLs seen through local using-directives.  */
5876       for (level = current_binding_level;
5877            !level->namespace_p;
5878            level = level->level_chain)
5879         if (!lookup_using_namespace (name, b, level->using_directives,
5880                                      scope, flags, spacesp))
5881           /* Give up because of error.  */
5882           return error_mark_node;
5883
5884       /* Add all _DECLs seen through global using-directives.  */
5885       /* XXX local and global using lists should work equally.  */
5886       siter = initial;
5887       while (1)
5888         {
5889           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5890                                        scope, flags, spacesp))
5891             /* Give up because of error.  */
5892             return error_mark_node;
5893           if (siter == scope) break;
5894           siter = CP_DECL_CONTEXT (siter);
5895         }
5896
5897       val = select_decl (b, flags);
5898       if (scope == global_namespace)
5899         break;
5900     }
5901   return val;
5902 }
5903
5904 /* Combine prefer_type and namespaces_only into flags.  */
5905
5906 static int
5907 lookup_flags (prefer_type, namespaces_only)
5908   int prefer_type, namespaces_only;
5909 {
5910   if (namespaces_only)
5911     return LOOKUP_PREFER_NAMESPACES;
5912   if (prefer_type > 1)
5913     return LOOKUP_PREFER_TYPES;
5914   if (prefer_type > 0)
5915     return LOOKUP_PREFER_BOTH;
5916   return 0;
5917 }
5918
5919 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5920    ignore it or not.  Subroutine of lookup_name_real.  */
5921
5922 static tree
5923 qualify_lookup (val, flags)
5924      tree val;
5925      int flags;
5926 {
5927   if (val == NULL_TREE)
5928     return val;
5929   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5930     return val;
5931   if ((flags & LOOKUP_PREFER_TYPES) && TREE_CODE (val) == TYPE_DECL)
5932     return val;
5933   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5934     return NULL_TREE;
5935   return val;
5936 }
5937
5938 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5939    that.  */
5940
5941 static void
5942 warn_about_implicit_typename_lookup (typename, binding)
5943      tree typename;
5944      tree binding;
5945 {
5946   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5947   tree name = DECL_NAME (typename);
5948
5949   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5950          && CLASSTYPE_TEMPLATE_INFO (subtype)
5951          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5952       && ! (TREE_CODE (binding) == TYPE_DECL
5953             && same_type_p (TREE_TYPE (binding), subtype)))
5954     {
5955       warning ("lookup of `%D' finds `%#D'",
5956                   name, binding);
5957       warning ("  instead of `%D' from dependent base class",
5958                   typename);
5959       warning ("  (use `typename %T::%D' if that's what you meant)",
5960                   constructor_name (current_class_type), name);
5961     }
5962 }
5963
5964 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5965    or a class TYPE).  If IS_TYPE_P is TRUE, then ignore non-type
5966    bindings.
5967
5968    Returns a DECL (or OVERLOAD, or BASELINK) representing the
5969    declaration found.  */
5970
5971 tree
5972 lookup_qualified_name (tree scope, tree name, bool is_type_p, int flags)
5973 {
5974   if (TREE_CODE (scope) == NAMESPACE_DECL)
5975     {
5976       tree val;
5977
5978       val = make_node (CPLUS_BINDING);
5979       flags |= LOOKUP_COMPLAIN;
5980       if (is_type_p)
5981         flags |= LOOKUP_PREFER_TYPES;
5982       if (!qualified_lookup_using_namespace (name, scope, val, flags))
5983         return NULL_TREE;
5984       return select_decl (val, flags);
5985     }
5986   else
5987     return lookup_member (scope, name, 0, is_type_p);
5988 }
5989
5990 /* Check to see whether or not DECL is a variable that would have been
5991    in scope under the ARM, but is not in scope under the ANSI/ISO
5992    standard.  If so, issue an error message.  If name lookup would
5993    work in both cases, but return a different result, this function
5994    returns the result of ANSI/ISO lookup.  Otherwise, it returns
5995    DECL.  */
5996
5997 tree
5998 check_for_out_of_scope_variable (tree decl)
5999 {
6000   tree shadowed;
6001
6002   /* We only care about out of scope variables.  */
6003   if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
6004     return decl;
6005
6006   shadowed = DECL_SHADOWED_FOR_VAR (decl);
6007   while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
6008          && DECL_DEAD_FOR_LOCAL (shadowed))
6009     shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
6010   if (!shadowed)
6011     shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
6012   if (shadowed)
6013     {
6014       if (!DECL_ERROR_REPORTED (decl))
6015         {
6016           warning ("name lookup of `%D' changed",
6017                       DECL_NAME (decl));
6018           cp_warning_at ("  matches this `%D' under ISO standard rules",
6019                          shadowed);
6020           cp_warning_at ("  matches this `%D' under old rules", decl);
6021           DECL_ERROR_REPORTED (decl) = 1;
6022         }
6023       return shadowed;
6024     }
6025
6026   /* If we have already complained about this declaration, there's no
6027      need to do it again.  */
6028   if (DECL_ERROR_REPORTED (decl))
6029     return decl;
6030
6031   DECL_ERROR_REPORTED (decl) = 1;
6032   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6033     {
6034       error ("name lookup of `%D' changed for new ISO `for' scoping",
6035              DECL_NAME (decl));
6036       cp_error_at ("  cannot use obsolete binding at `%D' because it has a destructor", decl);
6037       return error_mark_node;
6038     }
6039   else
6040     {
6041       pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
6042                DECL_NAME (decl));
6043       cp_pedwarn_at ("  using obsolete binding at `%D'", decl);
6044     }
6045
6046   return decl;
6047 }
6048
6049 /* Look up NAME in the current binding level and its superiors in the
6050    namespace of variables, functions and typedefs.  Return a ..._DECL
6051    node of some kind representing its definition if there is only one
6052    such declaration, or return a TREE_LIST with all the overloaded
6053    definitions if there are many, or return 0 if it is undefined.
6054
6055    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6056    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6057    Otherwise we prefer non-TYPE_DECLs.
6058
6059    If NONCLASS is nonzero, we don't look for the NAME in class scope,
6060    using IDENTIFIER_CLASS_VALUE.  */
6061
6062 tree
6063 lookup_name_real (tree name,
6064                   int prefer_type,
6065                   int nonclass,
6066                   int namespaces_only,
6067                   int flags)
6068 {
6069   tree t;
6070   tree val = NULL_TREE;
6071   int val_is_implicit_typename = 0;
6072
6073   /* Conversion operators are handled specially because ordinary
6074      unqualified name lookup will not find template conversion
6075      operators.  */
6076   if (IDENTIFIER_TYPENAME_P (name))
6077     {
6078       struct cp_binding_level *level;
6079
6080       for (level = current_binding_level;
6081            level && !level->namespace_p;
6082            level = level->level_chain)
6083         {
6084           tree class_type;
6085           tree operators;
6086
6087           /* A conversion operator can only be declared in a class
6088              scope.  */
6089           if (level->parm_flag != 2)
6090             continue;
6091
6092           /* Lookup the conversion operator in the class.  */
6093           class_type = level->this_class;
6094           operators = lookup_fnfields (class_type, name, /*protect=*/0);
6095           if (operators)
6096             return operators;
6097         }
6098
6099       return NULL_TREE;
6100     }
6101
6102   flags |= lookup_flags (prefer_type, namespaces_only);
6103
6104   /* First, look in non-namespace scopes.  */
6105
6106   if (current_class_type == NULL_TREE)
6107     nonclass = 1;
6108
6109   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6110     {
6111       tree binding;
6112
6113       if (!LOCAL_BINDING_P (t) && nonclass)
6114         /* We're not looking for class-scoped bindings, so keep going.  */
6115         continue;
6116
6117       /* If this is the kind of thing we're looking for, we're done.  */
6118       if (qualify_lookup (BINDING_VALUE (t), flags))
6119         binding = BINDING_VALUE (t);
6120       else if ((flags & LOOKUP_PREFER_TYPES)
6121                && qualify_lookup (BINDING_TYPE (t), flags))
6122         binding = BINDING_TYPE (t);
6123       else
6124         binding = NULL_TREE;
6125
6126       if (binding
6127           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6128         {
6129           if (val_is_implicit_typename)
6130             warn_about_implicit_typename_lookup (val, binding);
6131           val = binding;
6132           val_is_implicit_typename
6133             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6134           if (!val_is_implicit_typename)
6135             break;
6136         }
6137     }
6138
6139   /* Now lookup in namespace scopes.  */
6140   if (!val || val_is_implicit_typename)
6141     {
6142       t = unqualified_namespace_lookup (name, flags, 0);
6143       if (t)
6144         {
6145           if (val_is_implicit_typename)
6146             warn_about_implicit_typename_lookup (val, t);
6147           val = t;
6148         }
6149     }
6150
6151   if (val)
6152     {
6153       /* If we have a single function from a using decl, pull it out.  */
6154       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6155         val = OVL_FUNCTION (val);
6156     }
6157
6158   return val;
6159 }
6160
6161 tree
6162 lookup_name_nonclass (name)
6163      tree name;
6164 {
6165   return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
6166 }
6167
6168 tree
6169 lookup_function_nonclass (name, args)
6170      tree name;
6171      tree args;
6172 {
6173   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6174 }
6175
6176 tree
6177 lookup_name (name, prefer_type)
6178      tree name;
6179      int prefer_type;
6180 {
6181   return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
6182 }
6183
6184 /* Similar to `lookup_name' but look only in the innermost non-class
6185    binding level.  */
6186
6187 tree
6188 lookup_name_current_level (name)
6189      tree name;
6190 {
6191   struct cp_binding_level *b;
6192   tree t = NULL_TREE;
6193
6194   b = current_binding_level;
6195   while (b->parm_flag == 2)
6196     b = b->level_chain;
6197
6198   if (b->namespace_p)
6199     {
6200       t = IDENTIFIER_NAMESPACE_VALUE (name);
6201
6202       /* extern "C" function() */
6203       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6204         t = TREE_VALUE (t);
6205     }
6206   else if (IDENTIFIER_BINDING (name)
6207            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6208     {
6209       while (1)
6210         {
6211           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6212             return IDENTIFIER_VALUE (name);
6213
6214           if (b->keep == 2)
6215             b = b->level_chain;
6216           else
6217             break;
6218         }
6219     }
6220
6221   return t;
6222 }
6223
6224 /* Like lookup_name_current_level, but for types.  */
6225
6226 tree
6227 lookup_type_current_level (name)
6228      tree name;
6229 {
6230   register tree t = NULL_TREE;
6231
6232   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6233
6234   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6235       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6236     {
6237       struct cp_binding_level *b = current_binding_level;
6238       while (1)
6239         {
6240           if (purpose_member (name, b->type_shadowed))
6241             return REAL_IDENTIFIER_TYPE_VALUE (name);
6242           if (b->keep == 2)
6243             b = b->level_chain;
6244           else
6245             break;
6246         }
6247     }
6248
6249   return t;
6250 }
6251
6252 \f
6253 /* Push the declarations of builtin types into the namespace.
6254    RID_INDEX is the index of the builtin type
6255    in the array RID_POINTERS.  NAME is the name used when looking
6256    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6257
6258 void
6259 record_builtin_type (rid_index, name, type)
6260      enum rid rid_index;
6261      const char *name;
6262      tree type;
6263 {
6264   tree rname = NULL_TREE, tname = NULL_TREE;
6265   tree tdecl = NULL_TREE;
6266
6267   if ((int) rid_index < (int) RID_MAX)
6268     rname = ridpointers[(int) rid_index];
6269   if (name)
6270     tname = get_identifier (name);
6271
6272   TYPE_BUILT_IN (type) = 1;
6273
6274   if (tname)
6275     {
6276       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6277       set_identifier_type_value (tname, NULL_TREE);
6278       if ((int) rid_index < (int) RID_MAX)
6279         /* Built-in types live in the global namespace.  */
6280         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6281     }
6282   if (rname != NULL_TREE)
6283     {
6284       if (tname != NULL_TREE)
6285         {
6286           set_identifier_type_value (rname, NULL_TREE);
6287           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6288         }
6289       else
6290         {
6291           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6292           set_identifier_type_value (rname, NULL_TREE);
6293         }
6294     }
6295 }
6296
6297 /* Record one of the standard Java types.
6298  * Declare it as having the given NAME.
6299  * If SIZE > 0, it is the size of one of the integral types;
6300  * otherwise it is the negative of the size of one of the other types.  */
6301
6302 static tree
6303 record_builtin_java_type (name, size)
6304      const char *name;
6305      int size;
6306 {
6307   tree type, decl;
6308   if (size > 0)
6309     type = make_signed_type (size);
6310   else if (size > -32)
6311     { /* "__java_char" or ""__java_boolean".  */
6312       type = make_unsigned_type (-size);
6313       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6314     }
6315   else
6316     { /* "__java_float" or ""__java_double".  */
6317       type = make_node (REAL_TYPE);
6318       TYPE_PRECISION (type) = - size;
6319       layout_type (type);
6320     }
6321   record_builtin_type (RID_MAX, name, type);
6322   decl = TYPE_NAME (type);
6323
6324   /* Suppress generate debug symbol entries for these types,
6325      since for normal C++ they are just clutter.
6326      However, push_lang_context undoes this if extern "Java" is seen.  */
6327   DECL_IGNORED_P (decl) = 1;
6328
6329   TYPE_FOR_JAVA (type) = 1;
6330   return type;
6331 }
6332
6333 /* Push a type into the namespace so that the back-ends ignore it.  */
6334
6335 static void
6336 record_unknown_type (type, name)
6337      tree type;
6338      const char *name;
6339 {
6340   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6341   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6342   DECL_IGNORED_P (decl) = 1;
6343   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6344   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6345   TYPE_ALIGN (type) = 1;
6346   TYPE_USER_ALIGN (type) = 0;
6347   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6348 }
6349
6350 /* An string for which we should create an IDENTIFIER_NODE at
6351    startup.  */
6352
6353 typedef struct predefined_identifier
6354 {
6355   /* The name of the identifier.  */
6356   const char *const name;
6357   /* The place where the IDENTIFIER_NODE should be stored.  */
6358   tree *const node;
6359   /* Nonzero if this is the name of a constructor or destructor.  */
6360   const int ctor_or_dtor_p;
6361 } predefined_identifier;
6362
6363 /* Create all the predefined identifiers.  */
6364
6365 static void
6366 initialize_predefined_identifiers ()
6367 {
6368   const predefined_identifier *pid;
6369
6370   /* A table of identifiers to create at startup.  */
6371   static const predefined_identifier predefined_identifiers[] = {
6372     { "C++", &lang_name_cplusplus, 0 },
6373     { "C", &lang_name_c, 0 },
6374     { "Java", &lang_name_java, 0 },
6375     { CTOR_NAME, &ctor_identifier, 1 },
6376     { "__base_ctor", &base_ctor_identifier, 1 },
6377     { "__comp_ctor", &complete_ctor_identifier, 1 },
6378     { DTOR_NAME, &dtor_identifier, 1 },
6379     { "__comp_dtor", &complete_dtor_identifier, 1 },
6380     { "__base_dtor", &base_dtor_identifier, 1 },
6381     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6382     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6383     { "nelts", &nelts_identifier, 0 },
6384     { THIS_NAME, &this_identifier, 0 },
6385     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6386     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6387     { "_vptr", &vptr_identifier, 0 },
6388     { "__vtt_parm", &vtt_parm_identifier, 0 },
6389     { "std", &std_identifier, 0 },
6390     { NULL, NULL, 0 }
6391   };
6392
6393   for (pid = predefined_identifiers; pid->name; ++pid)
6394     {
6395       *pid->node = get_identifier (pid->name);
6396       if (pid->ctor_or_dtor_p)
6397         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6398     }
6399 }
6400
6401 /* Create the predefined scalar types of C,
6402    and some nodes representing standard constants (0, 1, (void *)0).
6403    Initialize the global binding level.
6404    Make definitions for built-in primitive functions.  */
6405
6406 void
6407 cxx_init_decl_processing ()
6408 {
6409   tree void_ftype;
6410   tree void_ftype_ptr;
6411
6412   /* Create all the identifiers we need.  */
6413   initialize_predefined_identifiers ();
6414
6415   /* Fill in back-end hooks.  */
6416   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6417
6418   /* Create the global variables.  */
6419   push_to_top_level ();
6420
6421   /* Enter the global namespace.  */
6422   my_friendly_assert (global_namespace == NULL_TREE, 375);
6423   push_namespace (get_identifier ("::"));
6424   global_namespace = current_namespace;
6425   current_lang_name = NULL_TREE;
6426
6427   /* Adjust various flags based on command-line settings.  */
6428   if (! flag_permissive && ! pedantic)
6429     flag_pedantic_errors = 1;
6430   if (!flag_no_inline)
6431     {
6432       flag_inline_trees = 1;
6433       flag_no_inline = 1;
6434     }
6435   if (flag_inline_functions)
6436     {
6437       flag_inline_trees = 2;
6438       flag_inline_functions = 0;
6439     }
6440
6441   /* Force minimum function alignment if using the least significant
6442      bit of function pointers to store the virtual bit.  */
6443   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6444       && force_align_functions_log < 1)
6445     force_align_functions_log = 1;
6446
6447   /* Initially, C.  */
6448   current_lang_name = lang_name_c;
6449
6450   current_function_decl = NULL_TREE;
6451   current_binding_level = NULL_BINDING_LEVEL;
6452   free_binding_level = NULL_BINDING_LEVEL;
6453
6454   build_common_tree_nodes (flag_signed_char);
6455
6456   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6457   TREE_TYPE (error_mark_list) = error_mark_node;
6458
6459   /* Make the binding_level structure for global names.  */
6460   pushlevel (0);
6461   global_binding_level = current_binding_level;
6462   /* The global level is the namespace level of ::.  */
6463   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6464   declare_namespace_level ();
6465
6466   /* Create the `std' namespace.  */
6467   push_namespace (std_identifier);
6468   std_node = current_namespace;
6469   pop_namespace ();
6470
6471   c_common_nodes_and_builtins ();
6472
6473   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6474   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6475   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6476   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6477   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6478   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6479   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6480   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6481
6482   integer_two_node = build_int_2 (2, 0);
6483   TREE_TYPE (integer_two_node) = integer_type_node;
6484   integer_three_node = build_int_2 (3, 0);
6485   TREE_TYPE (integer_three_node) = integer_type_node;
6486
6487   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6488   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6489   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6490   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6491   TYPE_PRECISION (boolean_type_node) = 1;
6492   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6493   boolean_false_node = build_int_2 (0, 0);
6494   TREE_TYPE (boolean_false_node) = boolean_type_node;
6495   boolean_true_node = build_int_2 (1, 0);
6496   TREE_TYPE (boolean_true_node) = boolean_type_node;
6497
6498   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6499
6500 #if 0
6501   record_builtin_type (RID_MAX, NULL, string_type_node);
6502 #endif
6503
6504   delta_type_node = ptrdiff_type_node;
6505   vtable_index_type = ptrdiff_type_node;
6506
6507   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6508   void_ftype = build_function_type (void_type_node, void_list_node);
6509   void_ftype_ptr = build_function_type (void_type_node,
6510                                         tree_cons (NULL_TREE,
6511                                                    ptr_type_node,
6512                                                    void_list_node));
6513   void_ftype_ptr
6514     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6515
6516   /* C++ extensions */
6517
6518   unknown_type_node = make_node (UNKNOWN_TYPE);
6519   record_unknown_type (unknown_type_node, "unknown type");
6520
6521   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6522   TREE_TYPE (unknown_type_node) = unknown_type_node;
6523
6524   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6525      result.  */
6526   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6527   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6528
6529   {
6530     /* Make sure we get a unique function type, so we can give
6531        its pointer type a name.  (This wins for gdb.) */
6532     tree vfunc_type = make_node (FUNCTION_TYPE);
6533     TREE_TYPE (vfunc_type) = integer_type_node;
6534     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6535     layout_type (vfunc_type);
6536
6537     vtable_entry_type = build_pointer_type (vfunc_type);
6538   }
6539   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6540
6541   vtbl_type_node
6542     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6543   layout_type (vtbl_type_node);
6544   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6545   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6546   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6547   layout_type (vtbl_ptr_type_node);
6548   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6549
6550   push_namespace (get_identifier ("__cxxabiv1"));
6551   abi_node = current_namespace;
6552   pop_namespace ();
6553
6554   global_type_node = make_node (LANG_TYPE);
6555   record_unknown_type (global_type_node, "global type");
6556
6557   /* Now, C++.  */
6558   current_lang_name = lang_name_cplusplus;
6559
6560   {
6561     tree bad_alloc_type_node, newtype, deltype;
6562     tree ptr_ftype_sizetype;
6563
6564     push_namespace (std_identifier);
6565     bad_alloc_type_node
6566       = xref_tag (class_type, get_identifier ("bad_alloc"),
6567                   /*attributes=*/NULL_TREE, 1);
6568     pop_namespace ();
6569     ptr_ftype_sizetype
6570       = build_function_type (ptr_type_node,
6571                              tree_cons (NULL_TREE,
6572                                         size_type_node,
6573                                         void_list_node));
6574     newtype = build_exception_variant
6575       (ptr_ftype_sizetype, add_exception_specifier
6576        (NULL_TREE, bad_alloc_type_node, -1));
6577     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6578     push_cp_library_fn (NEW_EXPR, newtype);
6579     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6580     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6581     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6582   }
6583
6584   abort_fndecl
6585     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6586
6587   /* Perform other language dependent initializations.  */
6588   init_class_processing ();
6589   init_search_processing ();
6590   init_rtti_processing ();
6591
6592   if (flag_exceptions)
6593     init_exception_processing ();
6594
6595   if (! supports_one_only ())
6596     flag_weak = 0;
6597
6598   make_fname_decl = cp_make_fname_decl;
6599   start_fname_decls ();
6600
6601   /* Show we use EH for cleanups.  */
6602   using_eh_for_cleanups ();
6603
6604   /* Maintain consistency.  Perhaps we should just complain if they
6605      say -fwritable-strings?  */
6606   if (flag_writable_strings)
6607     flag_const_strings = 0;
6608 }
6609
6610 /* Generate an initializer for a function naming variable from
6611    NAME. NAME may be NULL, in which case we generate a special
6612    ERROR_MARK node which should be replaced later.  */
6613
6614 tree
6615 cp_fname_init (name)
6616      const char *name;
6617 {
6618   tree domain = NULL_TREE;
6619   tree type;
6620   tree init = NULL_TREE;
6621   size_t length = 0;
6622
6623   if (name)
6624     {
6625       length = strlen (name);
6626       domain = build_index_type (size_int (length));
6627       init = build_string (length + 1, name);
6628     }
6629
6630   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6631   type = build_cplus_array_type (type, domain);
6632
6633   if (init)
6634     TREE_TYPE (init) = type;
6635   else
6636     /* We don't know the value until instantiation time. Make
6637        something which will be digested now, but replaced later.  */
6638     init = build (ERROR_MARK, type);
6639
6640   return init;
6641 }
6642
6643 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6644    decl, NAME is the initialization string and TYPE_DEP indicates whether
6645    NAME depended on the type of the function. We make use of that to detect
6646    __PRETTY_FUNCTION__ inside a template fn. This is being done
6647    lazily at the point of first use, so we musn't push the decl now.  */
6648
6649 static tree
6650 cp_make_fname_decl (id, type_dep)
6651      tree id;
6652      int type_dep;
6653 {
6654   const char *const name = (type_dep && processing_template_decl
6655                       ? NULL : fname_as_string (type_dep));
6656   tree init = cp_fname_init (name);
6657   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6658
6659   /* As we're using pushdecl_with_scope, we must set the context.  */
6660   DECL_CONTEXT (decl) = current_function_decl;
6661   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6662
6663   TREE_STATIC (decl) = 1;
6664   TREE_READONLY (decl) = 1;
6665   DECL_ARTIFICIAL (decl) = 1;
6666   DECL_INITIAL (decl) = init;
6667
6668   TREE_USED (decl) = 1;
6669
6670   if (current_function_decl)
6671     {
6672       struct cp_binding_level *b = current_binding_level;
6673       while (b->level_chain->parm_flag == 0)
6674         b = b->level_chain;
6675       pushdecl_with_scope (decl, b);
6676     }
6677
6678   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6679
6680   return decl;
6681 }
6682
6683 /* Make a definition for a builtin function named NAME in the current
6684    namespace, whose data type is TYPE and whose context is CONTEXT.
6685    TYPE should be a function type with argument types.
6686
6687    CLASS and CODE tell later passes how to compile calls to this function.
6688    See tree.h for possible values.
6689
6690    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6691    the name to be called if we can't opencode the function.
6692    If ATTRS is nonzero, use that for the function's attribute
6693    list.  */
6694
6695 static tree
6696 builtin_function_1 (name, type, context, code, class, libname, attrs)
6697      const char *name;
6698      tree type;
6699      tree context;
6700      int code;
6701      enum built_in_class class;
6702      const char *libname;
6703      tree attrs;
6704 {
6705   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6706   DECL_BUILT_IN_CLASS (decl) = class;
6707   DECL_FUNCTION_CODE (decl) = code;
6708   DECL_CONTEXT (decl) = context;
6709
6710   pushdecl (decl);
6711
6712   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6713      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6714      function in the namespace.  */
6715   if (libname)
6716     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6717   make_decl_rtl (decl, NULL);
6718
6719   /* Warn if a function in the namespace for users
6720      is used without an occasion to consider it declared.  */
6721   if (name[0] != '_' || name[1] != '_')
6722     DECL_ANTICIPATED (decl) = 1;
6723
6724   /* Possibly apply some default attributes to this built-in function.  */
6725   if (attrs)
6726     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
6727   else
6728     decl_attributes (&decl, NULL_TREE, 0);
6729
6730   return decl;
6731 }
6732
6733 /* Entry point for the benefit of c_common_nodes_and_builtins.
6734
6735    Make a defintion for a builtin function named NAME and whose data type
6736    is TYPE.  TYPE should be a function type with argument types.  This
6737    function places the anticipated declaration in the global namespace
6738    and additionally in the std namespace if appropriate.
6739
6740    CLASS and CODE tell later passes how to compile calls to this function.
6741    See tree.h for possible values.
6742
6743    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6744    the name to be called if we can't opencode the function.
6745
6746    If ATTRS is nonzero, use that for the function's attribute
6747    list.  */
6748
6749 tree
6750 builtin_function (name, type, code, class, libname, attrs)
6751      const char *name;
6752      tree type;
6753      int code;
6754      enum built_in_class class;
6755      const char *libname;
6756      tree attrs;
6757 {
6758   /* All builtins that don't begin with an '_' should additionally
6759      go in the 'std' namespace.  */
6760   if (name[0] != '_')
6761     {
6762       push_namespace (std_identifier);
6763       builtin_function_1 (name, type, std_node, code, class, libname, attrs);
6764       pop_namespace ();
6765     }
6766
6767   return builtin_function_1 (name, type, NULL_TREE, code,
6768                              class, libname, attrs);
6769 }
6770
6771 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6772    function.  Not called directly.  */
6773
6774 static tree
6775 build_library_fn_1 (name, operator_code, type)
6776      tree name;
6777      enum tree_code operator_code;
6778      tree type;
6779 {
6780   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6781   DECL_EXTERNAL (fn) = 1;
6782   TREE_PUBLIC (fn) = 1;
6783   DECL_ARTIFICIAL (fn) = 1;
6784   TREE_NOTHROW (fn) = 1;
6785   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6786   SET_DECL_LANGUAGE (fn, lang_c);
6787   return fn;
6788 }
6789
6790 /* Returns the _DECL for a library function with C linkage.
6791    We assume that such functions never throw; if this is incorrect,
6792    callers should unset TREE_NOTHROW.  */
6793
6794 tree
6795 build_library_fn (name, type)
6796      tree name;
6797      tree type;
6798 {
6799   return build_library_fn_1 (name, ERROR_MARK, type);
6800 }
6801
6802 /* Returns the _DECL for a library function with C++ linkage.  */
6803
6804 static tree
6805 build_cp_library_fn (name, operator_code, type)
6806      tree name;
6807      enum tree_code operator_code;
6808      tree type;
6809 {
6810   tree fn = build_library_fn_1 (name, operator_code, type);
6811   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6812   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6813   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6814   set_mangled_name_for_decl (fn);
6815   return fn;
6816 }
6817
6818 /* Like build_library_fn, but takes a C string instead of an
6819    IDENTIFIER_NODE.  */
6820
6821 tree
6822 build_library_fn_ptr (name, type)
6823      const char *name;
6824      tree type;
6825 {
6826   return build_library_fn (get_identifier (name), type);
6827 }
6828
6829 /* Like build_cp_library_fn, but takes a C string instead of an
6830    IDENTIFIER_NODE.  */
6831
6832 tree
6833 build_cp_library_fn_ptr (name, type)
6834      const char *name;
6835      tree type;
6836 {
6837   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6838 }
6839
6840 /* Like build_library_fn, but also pushes the function so that we will
6841    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6842
6843 tree
6844 push_library_fn (name, type)
6845      tree name, type;
6846 {
6847   tree fn = build_library_fn (name, type);
6848   pushdecl_top_level (fn);
6849   return fn;
6850 }
6851
6852 /* Like build_cp_library_fn, but also pushes the function so that it
6853    will be found by normal lookup.  */
6854
6855 static tree
6856 push_cp_library_fn (operator_code, type)
6857      enum tree_code operator_code;
6858      tree type;
6859 {
6860   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6861                                  operator_code,
6862                                  type);
6863   pushdecl (fn);
6864   return fn;
6865 }
6866
6867 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6868    a FUNCTION_TYPE.  */
6869
6870 tree
6871 push_void_library_fn (name, parmtypes)
6872      tree name, parmtypes;
6873 {
6874   tree type = build_function_type (void_type_node, parmtypes);
6875   return push_library_fn (name, type);
6876 }
6877
6878 /* Like push_library_fn, but also note that this function throws
6879    and does not return.  Used for __throw_foo and the like.  */
6880
6881 tree
6882 push_throw_library_fn (name, type)
6883      tree name, type;
6884 {
6885   tree fn = push_library_fn (name, type);
6886   TREE_THIS_VOLATILE (fn) = 1;
6887   TREE_NOTHROW (fn) = 0;
6888   return fn;
6889 }
6890
6891 /* Apply default attributes to a function, if a system function with default
6892    attributes.  */
6893
6894 void
6895 cxx_insert_default_attributes (decl)
6896      tree decl;
6897 {
6898   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6899     return;
6900   if (!TREE_PUBLIC (decl))
6901     return;
6902   c_common_insert_default_attributes (decl);
6903 }
6904 \f
6905 /* When we call finish_struct for an anonymous union, we create
6906    default copy constructors and such.  But, an anonymous union
6907    shouldn't have such things; this function undoes the damage to the
6908    anonymous union type T.
6909
6910    (The reason that we create the synthesized methods is that we don't
6911    distinguish `union { int i; }' from `typedef union { int i; } U'.
6912    The first is an anonymous union; the second is just an ordinary
6913    union type.)  */
6914
6915 void
6916 fixup_anonymous_aggr (t)
6917      tree t;
6918 {
6919   tree *q;
6920
6921   /* Wipe out memory of synthesized methods */
6922   TYPE_HAS_CONSTRUCTOR (t) = 0;
6923   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6924   TYPE_HAS_INIT_REF (t) = 0;
6925   TYPE_HAS_CONST_INIT_REF (t) = 0;
6926   TYPE_HAS_ASSIGN_REF (t) = 0;
6927   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6928
6929   /* Splice the implicitly generated functions out of the TYPE_METHODS
6930      list.  */
6931   q = &TYPE_METHODS (t);
6932   while (*q)
6933     {
6934       if (DECL_ARTIFICIAL (*q))
6935         *q = TREE_CHAIN (*q);
6936       else
6937         q = &TREE_CHAIN (*q);
6938     }
6939
6940   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6941   if (TYPE_METHODS (t))
6942     cp_error_at ("an anonymous union cannot have function members", t);
6943
6944   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6945      assignment operators (because they cannot have these methods themselves).
6946      For anonymous unions this is already checked because they are not allowed
6947      in any union, otherwise we have to check it.  */
6948   if (TREE_CODE (t) != UNION_TYPE)
6949     {
6950       tree field, type;
6951
6952       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6953         if (TREE_CODE (field) == FIELD_DECL)
6954           {
6955             type = TREE_TYPE (field);
6956             if (CLASS_TYPE_P (type))
6957               {
6958                 if (TYPE_NEEDS_CONSTRUCTING (type))
6959                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6960                                field);
6961                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6962                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6963                                field);
6964                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6965                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6966                                field);
6967               }
6968           }
6969     }
6970 }
6971
6972 /* Make sure that a declaration with no declarator is well-formed, i.e.
6973    just declares a tagged type or anonymous union.
6974
6975    Returns the type declared; or NULL_TREE if none.  */
6976
6977 tree
6978 check_tag_decl (declspecs)
6979      tree declspecs;
6980 {
6981   int found_type = 0;
6982   int saw_friend = 0;
6983   int saw_typedef = 0;
6984   tree ob_modifier = NULL_TREE;
6985   register tree link;
6986   /* If a class, struct, or enum type is declared by the DECLSPECS
6987      (i.e, if a class-specifier, enum-specifier, or non-typename
6988      elaborated-type-specifier appears in the DECLSPECS),
6989      DECLARED_TYPE is set to the corresponding type.  */
6990   tree declared_type = NULL_TREE;
6991   bool error_p = false;
6992
6993   for (link = declspecs; link; link = TREE_CHAIN (link))
6994     {
6995       tree value = TREE_VALUE (link);
6996
6997       if (TYPE_P (value)
6998           || TREE_CODE (value) == TYPE_DECL
6999           || (TREE_CODE (value) == IDENTIFIER_NODE
7000               && IDENTIFIER_GLOBAL_VALUE (value)
7001               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
7002         {
7003           ++found_type;
7004
7005           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7006             {
7007               if (! in_system_header)
7008                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7009               return NULL_TREE;
7010             }
7011
7012           if (TYPE_P (value)
7013               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7014                   || TREE_CODE (value) == ENUMERAL_TYPE))
7015             {
7016               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7017               declared_type = value;
7018             }
7019         }
7020       else if (value == ridpointers[(int) RID_TYPEDEF])
7021         saw_typedef = 1;
7022       else if (value == ridpointers[(int) RID_FRIEND])
7023         {
7024           if (current_class_type == NULL_TREE
7025               || current_scope () != current_class_type)
7026             ob_modifier = value;
7027           else
7028             saw_friend = 1;
7029         }
7030       else if (value == ridpointers[(int) RID_STATIC]
7031                || value == ridpointers[(int) RID_EXTERN]
7032                || value == ridpointers[(int) RID_AUTO]
7033                || value == ridpointers[(int) RID_REGISTER]
7034                || value == ridpointers[(int) RID_INLINE]
7035                || value == ridpointers[(int) RID_VIRTUAL]
7036                || value == ridpointers[(int) RID_CONST]
7037                || value == ridpointers[(int) RID_VOLATILE]
7038                || value == ridpointers[(int) RID_EXPLICIT]
7039                || value == ridpointers[(int) RID_THREAD])
7040         ob_modifier = value;
7041       else if (value == error_mark_node)
7042         error_p = true;
7043     }
7044
7045   if (found_type > 1)
7046     error ("multiple types in one declaration");
7047
7048   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
7049     pedwarn ("declaration does not declare anything");
7050   /* Check for an anonymous union.  */
7051   else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
7052            && TYPE_ANONYMOUS_P (declared_type))
7053     {
7054       /* 7/3 In a simple-declaration, the optional init-declarator-list
7055          can be omitted only when declaring a class (clause 9) or
7056          enumeration (7.2), that is, when the decl-specifier-seq contains
7057          either a class-specifier, an elaborated-type-specifier with
7058          a class-key (9.1), or an enum-specifier.  In these cases and
7059          whenever a class-specifier or enum-specifier is present in the
7060          decl-specifier-seq, the identifiers in these specifiers are among
7061          the names being declared by the declaration (as class-name,
7062          enum-names, or enumerators, depending on the syntax).  In such
7063          cases, and except for the declaration of an unnamed bit-field (9.6),
7064          the decl-specifier-seq shall introduce one or more names into the
7065          program, or shall redeclare a name introduced by a previous
7066          declaration.  [Example:
7067              enum { };            // ill-formed
7068              typedef class { };   // ill-formed
7069          --end example]  */
7070       if (saw_typedef)
7071         {
7072           error ("missing type-name in typedef-declaration");
7073           return NULL_TREE;
7074         }
7075       /* Anonymous unions are objects, so they can have specifiers.  */;
7076       SET_ANON_AGGR_TYPE_P (declared_type);
7077
7078       if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
7079           && !in_system_header)
7080         pedwarn ("ISO C++ prohibits anonymous structs");
7081     }
7082
7083   else if (ob_modifier)
7084     {
7085       if (ob_modifier == ridpointers[(int) RID_INLINE]
7086           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7087         error ("`%D' can only be specified for functions", ob_modifier);
7088       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7089         error ("`%D' can only be specified inside a class", ob_modifier);
7090       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7091         error ("`%D' can only be specified for constructors",
7092                   ob_modifier);
7093       else
7094         error ("`%D' can only be specified for objects and functions",
7095                   ob_modifier);
7096     }
7097
7098   return declared_type;
7099 }
7100
7101 /* Called when a declaration is seen that contains no names to declare.
7102    If its type is a reference to a structure, union or enum inherited
7103    from a containing scope, shadow that tag name for the current scope
7104    with a forward reference.
7105    If its type defines a new named structure or union
7106    or defines an enum, it is valid but we need not do anything here.
7107    Otherwise, it is an error.
7108
7109    C++: may have to grok the declspecs to learn about static,
7110    complain for anonymous unions.
7111
7112    Returns the TYPE declared -- or NULL_TREE if none.  */
7113
7114 tree
7115 shadow_tag (declspecs)
7116      tree declspecs;
7117 {
7118   tree t = check_tag_decl (declspecs);
7119
7120   if (!t)
7121     return NULL_TREE;
7122
7123   maybe_process_partial_specialization (t);
7124
7125   /* This is where the variables in an anonymous union are
7126      declared.  An anonymous union declaration looks like:
7127      union { ... } ;
7128      because there is no declarator after the union, the parser
7129      sends that declaration here.  */
7130   if (ANON_AGGR_TYPE_P (t))
7131     {
7132       fixup_anonymous_aggr (t);
7133
7134       if (TYPE_FIELDS (t))
7135         {
7136           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7137                                       NULL);
7138           finish_anon_union (decl);
7139         }
7140     }
7141
7142   return t;
7143 }
7144 \f
7145 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7146
7147 tree
7148 groktypename (typename)
7149      tree typename;
7150 {
7151   tree specs, attrs;
7152   tree type;
7153   if (TREE_CODE (typename) != TREE_LIST)
7154     return typename;
7155   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7156   type = grokdeclarator (TREE_VALUE (typename), specs,
7157                          TYPENAME, 0, &attrs);
7158   if (attrs)
7159     cplus_decl_attributes (&type, attrs, 0);
7160   return type;
7161 }
7162
7163 /* Decode a declarator in an ordinary declaration or data definition.
7164    This is called as soon as the type information and variable name
7165    have been parsed, before parsing the initializer if any.
7166    Here we create the ..._DECL node, fill in its type,
7167    and put it on the list of decls for the current context.
7168    The ..._DECL node is returned as the value.
7169
7170    Exception: for arrays where the length is not specified,
7171    the type is left null, to be filled in by `cp_finish_decl'.
7172
7173    Function definitions do not come here; they go to start_function
7174    instead.  However, external and forward declarations of functions
7175    do go through here.  Structure field declarations are done by
7176    grokfield and not through here.  */
7177
7178 tree
7179 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7180      tree declarator, declspecs;
7181      int initialized;
7182      tree attributes, prefix_attributes;
7183 {
7184   tree decl;
7185   register tree type, tem;
7186   tree context;
7187
7188 #if 0
7189   /* See code below that used this.  */
7190   int init_written = initialized;
7191 #endif
7192
7193   /* This should only be done once on the top most decl.  */
7194   if (have_extern_spec)
7195     {
7196       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7197                              declspecs);
7198       have_extern_spec = false;
7199     }
7200
7201   /* An object declared as __attribute__((deprecated)) suppresses
7202      warnings of uses of other deprecated items.  */
7203   if (lookup_attribute ("deprecated", attributes))
7204     deprecated_state = DEPRECATED_SUPPRESS;
7205
7206   attributes = chainon (attributes, prefix_attributes);
7207
7208   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7209                          &attributes);
7210
7211   deprecated_state = DEPRECATED_NORMAL;
7212
7213   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7214     return NULL_TREE;
7215
7216   type = TREE_TYPE (decl);
7217
7218   if (type == error_mark_node)
7219     return NULL_TREE;
7220
7221   context = DECL_CONTEXT (decl);
7222
7223   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7224       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7225     {
7226       /* When parsing the initializer, lookup should use the object's
7227          namespace.  */
7228       push_decl_namespace (context);
7229     }
7230
7231   /* We are only interested in class contexts, later.  */
7232   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7233     context = NULL_TREE;
7234
7235   if (initialized)
7236     /* Is it valid for this decl to have an initializer at all?
7237        If not, set INITIALIZED to zero, which will indirectly
7238        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7239     switch (TREE_CODE (decl))
7240       {
7241       case TYPE_DECL:
7242         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7243         initialized = 0;
7244         break;
7245
7246       case FUNCTION_DECL:
7247         error ("function `%#D' is initialized like a variable", decl);
7248         initialized = 0;
7249         break;
7250
7251       default:
7252         break;
7253       }
7254
7255   if (initialized)
7256     {
7257       if (! toplevel_bindings_p ()
7258           && DECL_EXTERNAL (decl))
7259         warning ("declaration of `%#D' has `extern' and is initialized",
7260                     decl);
7261       DECL_EXTERNAL (decl) = 0;
7262       if (toplevel_bindings_p ())
7263         TREE_STATIC (decl) = 1;
7264
7265       /* Tell `pushdecl' this is an initialized decl
7266          even though we don't yet have the initializer expression.
7267          Also tell `cp_finish_decl' it may store the real initializer.  */
7268       DECL_INITIAL (decl) = error_mark_node;
7269     }
7270
7271   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7272   cplus_decl_attributes (&decl, attributes, 0);
7273
7274   /* If #pragma weak was used, mark the decl weak now.  */
7275   if (current_binding_level == global_binding_level)
7276     maybe_apply_pragma_weak (decl);
7277
7278   if (TREE_CODE (decl) == FUNCTION_DECL
7279       && DECL_DECLARED_INLINE_P (decl)
7280       && DECL_UNINLINABLE (decl)
7281       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7282     warning_with_decl (decl,
7283                        "inline function `%s' given attribute noinline");
7284
7285   if (context && COMPLETE_TYPE_P (complete_type (context)))
7286     {
7287       push_nested_class (context, 2);
7288
7289       if (TREE_CODE (decl) == VAR_DECL)
7290         {
7291           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7292           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7293             error ("`%#D' is not a static member of `%#T'", decl, context);
7294           else
7295             {
7296               if (DECL_CONTEXT (field) != context)
7297                 {
7298                   if (!same_type_p (DECL_CONTEXT (field), context))
7299                     pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7300                              DECL_CONTEXT (field), DECL_NAME (decl),
7301                              context, DECL_NAME (decl));
7302                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7303                 }
7304               /* Static data member are tricky; an in-class initialization
7305                  still doesn't provide a definition, so the in-class
7306                  declaration will have DECL_EXTERNAL set, but will have an
7307                  initialization.  Thus, duplicate_decls won't warn
7308                  about this situation, and so we check here.  */
7309               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7310                 error ("duplicate initialization of %D", decl);
7311               if (duplicate_decls (decl, field))
7312                 decl = field;
7313             }
7314         }
7315       else
7316         {
7317           tree field = check_classfn (context, decl);
7318           if (field && duplicate_decls (decl, field))
7319             decl = field;
7320         }
7321
7322       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7323       DECL_IN_AGGR_P (decl) = 0;
7324       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7325           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7326         {
7327           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7328           /* [temp.expl.spec] An explicit specialization of a static data
7329              member of a template is a definition if the declaration
7330              includes an initializer; otherwise, it is a declaration.
7331
7332              We check for processing_specialization so this only applies
7333              to the new specialization syntax.  */
7334           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7335             DECL_EXTERNAL (decl) = 1;
7336         }
7337
7338       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7339         pedwarn ("declaration of `%#D' outside of class is not definition",
7340                     decl);
7341     }
7342
7343   /* Enter this declaration into the symbol table.  */
7344   tem = maybe_push_decl (decl);
7345
7346   if (processing_template_decl)
7347     tem = push_template_decl (tem);
7348
7349 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7350   /* Tell the back-end to use or not use .common as appropriate.  If we say
7351      -fconserve-space, we want this to save .data space, at the expense of
7352      wrong semantics.  If we say -fno-conserve-space, we want this to
7353      produce errors about redefs; to do this we force variables into the
7354      data segment.  */
7355   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7356 #endif
7357
7358   if (! processing_template_decl)
7359     start_decl_1 (tem);
7360
7361   return tem;
7362 }
7363
7364 void
7365 start_decl_1 (decl)
7366      tree decl;
7367 {
7368   tree type = TREE_TYPE (decl);
7369   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7370
7371   if (type == error_mark_node)
7372     return;
7373
7374   maybe_push_cleanup_level (type);
7375
7376   if (initialized)
7377     /* Is it valid for this decl to have an initializer at all?
7378        If not, set INITIALIZED to zero, which will indirectly
7379        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7380     {
7381       /* Don't allow initializations for incomplete types except for
7382          arrays which might be completed by the initialization.  */
7383       if (COMPLETE_TYPE_P (complete_type (type)))
7384         ;                       /* A complete type is ok.  */
7385       else if (TREE_CODE (type) != ARRAY_TYPE)
7386         {
7387           error ("variable `%#D' has initializer but incomplete type",
7388                     decl);
7389           initialized = 0;
7390           type = TREE_TYPE (decl) = error_mark_node;
7391         }
7392       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7393         {
7394           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7395             error ("elements of array `%#D' have incomplete type", decl);
7396           /* else we already gave an error in start_decl.  */
7397           initialized = 0;
7398         }
7399     }
7400
7401   if (!initialized
7402       && TREE_CODE (decl) != TYPE_DECL
7403       && TREE_CODE (decl) != TEMPLATE_DECL
7404       && type != error_mark_node
7405       && IS_AGGR_TYPE (type)
7406       && ! DECL_EXTERNAL (decl))
7407     {
7408       if ((! processing_template_decl || ! uses_template_parms (type))
7409           && !COMPLETE_TYPE_P (complete_type (type)))
7410         {
7411           error ("aggregate `%#D' has incomplete type and cannot be defined",
7412                  decl);
7413           /* Change the type so that assemble_variable will give
7414              DECL an rtl we can live with: (mem (const_int 0)).  */
7415           type = TREE_TYPE (decl) = error_mark_node;
7416         }
7417       else
7418         {
7419           /* If any base type in the hierarchy of TYPE needs a constructor,
7420              then we set initialized to 1.  This way any nodes which are
7421              created for the purposes of initializing this aggregate
7422              will live as long as it does.  This is necessary for global
7423              aggregates which do not have their initializers processed until
7424              the end of the file.  */
7425           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7426         }
7427     }
7428
7429   if (! initialized)
7430     DECL_INITIAL (decl) = NULL_TREE;
7431 }
7432
7433 /* Handle initialization of references.
7434    These three arguments are from `cp_finish_decl', and have the
7435    same meaning here that they do there.
7436
7437    Quotes on semantics can be found in ARM 8.4.3.  */
7438
7439 static tree
7440 grok_reference_init (decl, type, init)
7441      tree decl, type, init;
7442 {
7443   tree tmp;
7444
7445   if (init == NULL_TREE)
7446     {
7447       if ((DECL_LANG_SPECIFIC (decl) == 0
7448            || DECL_IN_AGGR_P (decl) == 0)
7449           && ! DECL_THIS_EXTERN (decl))
7450         error ("`%D' declared as reference but not initialized", decl);
7451       return NULL_TREE;
7452     }
7453
7454   if (TREE_CODE (init) == CONSTRUCTOR)
7455     {
7456       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7457       return NULL_TREE;
7458     }
7459
7460   if (TREE_CODE (init) == TREE_LIST)
7461     init = build_compound_expr (init);
7462
7463   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7464     init = convert_from_reference (init);
7465
7466   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7467       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7468     {
7469       /* Note: default conversion is only called in very special cases.  */
7470       init = default_conversion (init);
7471     }
7472
7473   /* Convert INIT to the reference type TYPE.  This may involve the
7474      creation of a temporary, whose lifetime must be the same as that
7475      of the reference.  If so, a DECL_STMT for the temporary will be
7476      added just after the DECL_STMT for DECL.  That's why we don't set
7477      DECL_INITIAL for local references (instead assigning to them
7478      explicitly); we need to allow the temporary to be initialized
7479      first.  */
7480   tmp = convert_to_reference
7481     (type, init, CONV_IMPLICIT,
7482      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7483      decl);
7484
7485   if (tmp == error_mark_node)
7486     return NULL_TREE;
7487   else if (tmp == NULL_TREE)
7488     {
7489       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7490       return NULL_TREE;
7491     }
7492
7493   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7494     return tmp;
7495
7496   DECL_INITIAL (decl) = tmp;
7497
7498   return NULL_TREE;
7499 }
7500
7501 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7502    array until we finish parsing the initializer.  If that's the
7503    situation we're in, update DECL accordingly.  */
7504
7505 static void
7506 maybe_deduce_size_from_array_init (decl, init)
7507      tree decl;
7508      tree init;
7509 {
7510   tree type = TREE_TYPE (decl);
7511
7512   if (TREE_CODE (type) == ARRAY_TYPE
7513       && TYPE_DOMAIN (type) == NULL_TREE
7514       && TREE_CODE (decl) != TYPE_DECL)
7515     {
7516       /* do_default is really a C-ism to deal with tentative definitions.
7517          But let's leave it here to ease the eventual merge.  */
7518       int do_default = !DECL_EXTERNAL (decl);
7519       tree initializer = init ? init : DECL_INITIAL (decl);
7520       int failure = complete_array_type (type, initializer, do_default);
7521
7522       if (failure == 1)
7523         error ("initializer fails to determine size of `%D'", decl);
7524
7525       if (failure == 2)
7526         {
7527           if (do_default)
7528             error ("array size missing in `%D'", decl);
7529           /* If a `static' var's size isn't known, make it extern as
7530              well as static, so it does not get allocated.  If it's not
7531              `static', then don't mark it extern; finish_incomplete_decl
7532              will give it a default size and it will get allocated.  */
7533           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7534             DECL_EXTERNAL (decl) = 1;
7535         }
7536
7537       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7538           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7539                               integer_zero_node))
7540         error ("zero-size array `%D'", decl);
7541
7542       layout_decl (decl, 0);
7543     }
7544 }
7545
7546 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7547    any appropriate error messages regarding the layout.  */
7548
7549 static void
7550 layout_var_decl (decl)
7551      tree decl;
7552 {
7553   tree type = TREE_TYPE (decl);
7554 #if 0
7555   tree ttype = target_type (type);
7556 #endif
7557
7558   /* If we haven't already layed out this declaration, do so now.
7559      Note that we must not call complete type for an external object
7560      because it's type might involve templates that we are not
7561      supposed to isntantiate yet.  (And it's perfectly valid to say
7562      `extern X x' for some incomplete type `X'.)  */
7563   if (!DECL_EXTERNAL (decl))
7564     complete_type (type);
7565   if (!DECL_SIZE (decl)
7566       && TREE_TYPE (decl) != error_mark_node
7567       && (COMPLETE_TYPE_P (type)
7568           || (TREE_CODE (type) == ARRAY_TYPE
7569               && !TYPE_DOMAIN (type)
7570               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
7571     layout_decl (decl, 0);
7572
7573   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7574     {
7575       /* An automatic variable with an incomplete type: that is an error.
7576          Don't talk about array types here, since we took care of that
7577          message in grokdeclarator.  */
7578       error ("storage size of `%D' isn't known", decl);
7579       TREE_TYPE (decl) = error_mark_node;
7580     }
7581 #if 0
7582   /* Keep this code around in case we later want to control debug info
7583      based on whether a type is "used".  (jason 1999-11-11) */
7584
7585   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7586     /* Let debugger know it should output info for this type.  */
7587     note_debug_info_needed (ttype);
7588
7589   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7590     note_debug_info_needed (DECL_CONTEXT (decl));
7591 #endif
7592
7593   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7594       && DECL_SIZE (decl) != NULL_TREE
7595       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7596     {
7597       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7598         constant_expression_warning (DECL_SIZE (decl));
7599       else
7600         error ("storage size of `%D' isn't constant", decl);
7601     }
7602
7603   if (TREE_STATIC (decl)
7604       && !DECL_ARTIFICIAL (decl)
7605       && current_function_decl
7606       && DECL_CONTEXT (decl) == current_function_decl)
7607     push_local_name (decl);
7608 }
7609
7610 /* If a local static variable is declared in an inline function, or if
7611    we have a weak definition, we must endeavor to create only one
7612    instance of the variable at link-time.  */
7613
7614 static void
7615 maybe_commonize_var (decl)
7616      tree decl;
7617 {
7618   /* Static data in a function with comdat linkage also has comdat
7619      linkage.  */
7620   if (TREE_STATIC (decl)
7621       /* Don't mess with __FUNCTION__.  */
7622       && ! DECL_ARTIFICIAL (decl)
7623       && current_function_decl
7624       && DECL_CONTEXT (decl) == current_function_decl
7625       && (DECL_DECLARED_INLINE_P (current_function_decl)
7626           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7627       && TREE_PUBLIC (current_function_decl))
7628     {
7629       /* If flag_weak, we don't need to mess with this, as we can just
7630          make the function weak, and let it refer to its unique local
7631          copy.  This works because we don't allow the function to be
7632          inlined.  */
7633       if (! flag_weak)
7634         {
7635           if (DECL_INTERFACE_KNOWN (current_function_decl))
7636             {
7637               TREE_PUBLIC (decl) = 1;
7638               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7639             }
7640           else if (DECL_INITIAL (decl) == NULL_TREE
7641                    || DECL_INITIAL (decl) == error_mark_node)
7642             {
7643               TREE_PUBLIC (decl) = 1;
7644               DECL_COMMON (decl) = 1;
7645             }
7646           /* else we lose. We can only do this if we can use common,
7647              which we can't if it has been initialized.  */
7648
7649           if (!TREE_PUBLIC (decl))
7650             {
7651               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7652               cp_warning_at ("  you can work around this by removing the initializer", decl);
7653             }
7654         }
7655       else
7656         comdat_linkage (decl);
7657     }
7658   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7659     /* Set it up again; we might have set DECL_INITIAL since the last
7660        time.  */
7661     comdat_linkage (decl);
7662 }
7663
7664 /* Issue an error message if DECL is an uninitialized const variable.  */
7665
7666 static void
7667 check_for_uninitialized_const_var (decl)
7668      tree decl;
7669 {
7670   tree type = TREE_TYPE (decl);
7671
7672   /* ``Unless explicitly declared extern, a const object does not have
7673      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7674      7.1.6 */
7675   if (TREE_CODE (decl) == VAR_DECL
7676       && TREE_CODE (type) != REFERENCE_TYPE
7677       && CP_TYPE_CONST_P (type)
7678       && !TYPE_NEEDS_CONSTRUCTING (type)
7679       && !DECL_INITIAL (decl))
7680     error ("uninitialized const `%D'", decl);
7681 }
7682
7683 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
7684    returned is the next FIELD_DECL (possibly FIELD itself) that can be
7685    initialized.  If there are no more such fields, the return value
7686    will be NULL.  */
7687
7688 static tree
7689 next_initializable_field (tree field)
7690 {
7691   while (field
7692          && (TREE_CODE (field) != FIELD_DECL
7693              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
7694              || DECL_ARTIFICIAL (field)))
7695     field = TREE_CHAIN (field);
7696
7697   return field;
7698 }
7699
7700 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7701    brace-enclosed aggregate initializer.
7702
7703    *INITP is one of a list of initializers describing a brace-enclosed
7704    initializer for an entity of the indicated aggregate TYPE.  It may
7705    not presently match the shape of the TYPE; for example:
7706
7707      struct S { int a; int b; };
7708      struct S a[] = { 1, 2, 3, 4 };
7709
7710    Here *INITP will point to TREE_LIST of four elements, rather than a
7711    list of two elements, each itself a list of two elements.  This
7712    routine transforms INIT from the former form into the latter.  The
7713    revised initializer is returned.  */
7714
7715 static tree
7716 reshape_init (tree type, tree *initp)
7717 {
7718   tree inits;
7719   tree old_init;
7720   tree old_init_value;
7721   tree new_init;
7722   bool brace_enclosed_p;
7723
7724   old_init = *initp;
7725   old_init_value = (TREE_CODE (*initp) == TREE_LIST
7726                     ? TREE_VALUE (*initp) : old_init);
7727
7728   /* For some parse errors, OLD_INIT_VALUE may be NULL.  */
7729   if (!old_init_value)
7730     {
7731       my_friendly_assert (TREE_CODE (old_init) == TREE_LIST, 20021202);
7732       TREE_VALUE (old_init) = error_mark_node;
7733       return old_init;
7734     }
7735
7736   /* If the initializer is brace-enclosed, pull initializers from the
7737      enclosed elements.  Advance past the brace-enclosed initializer
7738      now.  */
7739   if (TREE_CODE (old_init_value) == CONSTRUCTOR
7740       && TREE_HAS_CONSTRUCTOR (old_init_value))
7741     {
7742       *initp = TREE_CHAIN (old_init);
7743       TREE_CHAIN (old_init) = NULL_TREE;
7744       inits = CONSTRUCTOR_ELTS (old_init_value);
7745       initp = &inits;
7746       brace_enclosed_p = true;
7747     }
7748   else
7749     {
7750       inits = NULL_TREE;
7751       brace_enclosed_p = false;
7752     }
7753
7754   /* A non-aggregate type is always initialized with a single
7755      initializer.  */
7756   if (!CP_AGGREGATE_TYPE_P (type))
7757       {
7758         *initp = TREE_CHAIN (old_init);
7759         TREE_CHAIN (old_init) = NULL_TREE;
7760         /* It is invalid to initialize a non-aggregate type with a
7761            brace-enclosed initializer.  */
7762         if (brace_enclosed_p)
7763           {
7764             error ("brace-enclosed initializer used to initialize `%T'",
7765                    type);
7766             if (TREE_CODE (old_init) == TREE_LIST)
7767               TREE_VALUE (old_init) = error_mark_node;
7768             else
7769               old_init = error_mark_node;
7770           }
7771
7772         return old_init;
7773       }
7774
7775   /* [dcl.init.aggr]
7776
7777      All implicit type conversions (clause _conv_) are considered when
7778      initializing the aggregate member with an initializer from an
7779      initializer-list.  If the initializer can initialize a member,
7780      the member is initialized.  Otherwise, if the member is itself a
7781      non-empty subaggregate, brace elision is assumed and the
7782      initializer is considered for the initialization of the first
7783      member of the subaggregate.  */
7784   if (CLASS_TYPE_P (type)
7785       && !brace_enclosed_p
7786       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
7787     {
7788       *initp = TREE_CHAIN (old_init);
7789       TREE_CHAIN (old_init) = NULL_TREE;
7790       return old_init;
7791     }
7792
7793   if (TREE_CODE (old_init_value) == STRING_CST
7794       && TREE_CODE (type) == ARRAY_TYPE
7795       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
7796     {
7797       /* [dcl.init.string]
7798
7799          A char array (whether plain char, signed char, or unsigned char)
7800          can be initialized by a string-literal (optionally enclosed in
7801          braces); a wchar_t array can be initialized by a wide
7802          string-literal (optionally enclosed in braces).  */
7803       new_init = old_init;
7804       /* Move past the initializer.  */
7805       *initp = TREE_CHAIN (old_init);
7806       TREE_CHAIN (old_init) = NULL_TREE;
7807     }
7808   else
7809     {
7810       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
7811       new_init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
7812       TREE_HAS_CONSTRUCTOR (new_init) = 1;
7813
7814       if (CLASS_TYPE_P (type))
7815         {
7816           tree field;
7817
7818           field = next_initializable_field (TYPE_FIELDS (type));
7819
7820           if (!field)
7821             {
7822               /* [dcl.init.aggr]
7823
7824                  An initializer for an aggregate member that is an
7825                  empty class shall have the form of an empty
7826                  initializer-list {}.  */
7827               if (!brace_enclosed_p)
7828                 error ("initializer for `%T' must be brace-enclosed",
7829                        type);
7830             }
7831           else
7832             {
7833               /* Loop through the initializable fields, gathering
7834                  initializers.  */
7835               while (*initp && field)
7836                 {
7837                   tree field_init;
7838
7839                   field_init = reshape_init (TREE_TYPE (field), initp);
7840                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
7841                   CONSTRUCTOR_ELTS (new_init) = field_init;
7842                   /* [dcl.init.aggr]
7843
7844                      When a union  is  initialized with a brace-enclosed
7845                      initializer, the braces shall only contain an
7846                      initializer for the first member of the union.  */
7847                   if (TREE_CODE (type) == UNION_TYPE)
7848                     break;
7849                   if (TREE_PURPOSE (field_init))
7850                     field = TREE_PURPOSE (field_init);
7851                   field = next_initializable_field (TREE_CHAIN (field));
7852                 }
7853             }
7854         }
7855       else if (TREE_CODE (type) == ARRAY_TYPE)
7856         {
7857           tree index;
7858           tree max_index;
7859
7860           /* If the bound of the array is known, take no more initializers
7861              than are allowed.  */
7862           max_index = (TYPE_DOMAIN (type)
7863                        ? array_type_nelts (type) : NULL_TREE);
7864           /* Loop through the array elements, gathering initializers.  */
7865           for (index = size_zero_node;
7866                *initp && (!max_index || !tree_int_cst_lt (max_index, index));
7867                index = size_binop (PLUS_EXPR, index, size_one_node))
7868             {
7869               tree element_init;
7870
7871               element_init = reshape_init (TREE_TYPE (type), initp);
7872               TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
7873               CONSTRUCTOR_ELTS (new_init) = element_init;
7874               if (TREE_PURPOSE (element_init))
7875                 index = TREE_PURPOSE (element_init);
7876             }
7877         }
7878       else
7879         abort ();
7880
7881       /* The initializers were placed in reverse order in the
7882          CONSTRUCTOR.  */
7883       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
7884
7885       if (TREE_CODE (old_init) == TREE_LIST)
7886         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
7887     }
7888
7889   /* If this was a brace-enclosed initializer and all of the
7890      initializers were not used up, there is a problem.  */
7891   if (brace_enclosed_p && *initp)
7892     error ("too many initializers for `%T'", type);
7893
7894   return new_init;
7895 }
7896
7897 /* Verify INIT (the initializer for DECL), and record the
7898    initialization in DECL_INITIAL, if appropriate.
7899
7900    If the return value is non-NULL, it is an expression that must be
7901    evaluated dynamically to initialize DECL.  */
7902
7903 static tree
7904 check_initializer (tree decl, tree init, int flags)
7905 {
7906   tree type = TREE_TYPE (decl);
7907
7908   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7909   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7910     init = NULL_TREE;
7911
7912   /* If an initializer is present, DECL_INITIAL has been
7913      error_mark_node, to indicate that an as-of-yet unevaluated
7914      initialization will occur.  From now on, DECL_INITIAL reflects
7915      the static initialization -- if any -- of DECL.  */
7916   DECL_INITIAL (decl) = NULL_TREE;
7917
7918   /* Things that are going to be initialized need to have complete
7919      type.  */
7920   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7921
7922   if (type == error_mark_node)
7923     /* We will have already complained.  */
7924     init = NULL_TREE;
7925   else if (init && COMPLETE_TYPE_P (type)
7926            && !TREE_CONSTANT (TYPE_SIZE (type)))
7927     {
7928       error ("variable-sized object `%D' may not be initialized", decl);
7929       init = NULL_TREE;
7930     }
7931   else if (TREE_CODE (type) == ARRAY_TYPE
7932            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7933     {
7934       error ("elements of array `%#D' have incomplete type", decl);
7935       init = NULL_TREE;
7936     }
7937   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7938     {
7939       error ("`%D' has incomplete type", decl);
7940       TREE_TYPE (decl) = error_mark_node;
7941       init = NULL_TREE;
7942     }
7943
7944   if (TREE_CODE (decl) == CONST_DECL)
7945     {
7946       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7947
7948       DECL_INITIAL (decl) = init;
7949
7950       my_friendly_assert (init != NULL_TREE, 149);
7951       init = NULL_TREE;
7952     }
7953   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7954     init = grok_reference_init (decl, type, init);
7955   else if (init)
7956     {
7957       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7958         {
7959           /* [dcl.init] paragraph 13,
7960              If T is a scalar type, then a declaration of the form
7961              T x = { a };
7962              is equivalent to
7963              T x = a;
7964
7965              reshape_init will complain about the extra braces,
7966              and doesn't do anything useful in the case where TYPE is
7967              scalar, so just don't call it.  */
7968           if (CP_AGGREGATE_TYPE_P (type))
7969             init = reshape_init (type, &init);
7970         }
7971
7972       /* If DECL has an array type without a specific bound, deduce the
7973          array size from the initializer.  */
7974       maybe_deduce_size_from_array_init (decl, init);
7975       type = TREE_TYPE (decl);
7976       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7977         TREE_TYPE (init) = type;
7978
7979       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7980         {
7981           if (TREE_CODE (type) == ARRAY_TYPE)
7982             goto initialize_aggr;
7983           else if (TREE_CODE (init) == CONSTRUCTOR
7984                    && TREE_HAS_CONSTRUCTOR (init))
7985             {
7986               if (TYPE_NON_AGGREGATE_CLASS (type))
7987                 {
7988                   error ("`%D' must be initialized by constructor, not by `{...}'",
7989                          decl);
7990                   init = error_mark_node;
7991                 }
7992               else
7993                 goto dont_use_constructor;
7994             }
7995           else
7996             {
7997               int saved_stmts_are_full_exprs_p;
7998
7999             initialize_aggr:
8000               saved_stmts_are_full_exprs_p = 0;
8001               if (building_stmt_tree ())
8002                 {
8003                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8004                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8005                 }
8006               init = build_aggr_init (decl, init, flags);
8007               if (building_stmt_tree ())
8008                 current_stmt_tree ()->stmts_are_full_exprs_p =
8009                   saved_stmts_are_full_exprs_p;
8010               return init;
8011             }
8012         }
8013       else
8014         {
8015         dont_use_constructor:
8016           if (TREE_CODE (init) != TREE_VEC)
8017             init = store_init_value (decl, init);
8018         }
8019     }
8020   else if (DECL_EXTERNAL (decl))
8021     ;
8022   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
8023     goto initialize_aggr;
8024   else if (IS_AGGR_TYPE (type))
8025     {
8026       tree core_type = strip_array_types (type);
8027
8028       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
8029         error ("structure `%D' with uninitialized const members", decl);
8030       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
8031         error ("structure `%D' with uninitialized reference members",
8032                decl);
8033
8034       check_for_uninitialized_const_var (decl);
8035     }
8036   else
8037     check_for_uninitialized_const_var (decl);
8038
8039   if (init && init != error_mark_node)
8040     init = build (INIT_EXPR, type, decl, init);
8041
8042   return init;
8043 }
8044
8045 /* If DECL is not a local variable, give it RTL.  */
8046
8047 static void
8048 make_rtl_for_nonlocal_decl (decl, init, asmspec)
8049      tree decl;
8050      tree init;
8051      const char *asmspec;
8052 {
8053   int toplev = toplevel_bindings_p ();
8054   int defer_p;
8055
8056   /* Handle non-variables up front.  */
8057   if (TREE_CODE (decl) != VAR_DECL)
8058     {
8059       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8060       return;
8061     }
8062
8063   /* If we see a class member here, it should be a static data
8064      member.  */
8065   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
8066     {
8067       my_friendly_assert (TREE_STATIC (decl), 19990828);
8068       /* An in-class declaration of a static data member should be
8069          external; it is only a declaration, and not a definition.  */
8070       if (init == NULL_TREE)
8071         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
8072     }
8073
8074   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
8075   if (asmspec)
8076     {
8077       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8078       /* The `register' keyword, when used together with an
8079          asm-specification, indicates that the variable should be
8080          placed in a particular register.  */
8081       if (DECL_REGISTER (decl))
8082         DECL_C_HARD_REGISTER (decl) = 1;
8083     }
8084
8085   /* We don't create any RTL for local variables.  */
8086   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
8087     return;
8088
8089   /* We defer emission of local statics until the corresponding
8090      DECL_STMT is expanded.  */
8091   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
8092
8093   /* We try to defer namespace-scope static constants so that they are
8094      not emitted into the object file unnecessarily.  */
8095   if (!DECL_VIRTUAL_P (decl)
8096       && TREE_READONLY (decl)
8097       && DECL_INITIAL (decl) != NULL_TREE
8098       && DECL_INITIAL (decl) != error_mark_node
8099       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
8100       && toplev
8101       && !TREE_PUBLIC (decl))
8102     {
8103       /* Fool with the linkage of static consts according to #pragma
8104          interface.  */
8105       if (!interface_unknown && !TREE_PUBLIC (decl))
8106         {
8107           TREE_PUBLIC (decl) = 1;
8108           DECL_EXTERNAL (decl) = interface_only;
8109         }
8110
8111       defer_p = 1;
8112     }
8113   /* Likewise for template instantiations.  */
8114   else if (DECL_COMDAT (decl))
8115     defer_p = 1;
8116
8117   /* If we're deferring the variable, we only need to make RTL if
8118      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
8119      we need it.  (There's no way to lazily create RTL for things that
8120      have assembly specs because the information about the specifier
8121      isn't stored in the tree, yet)  */
8122   if (defer_p && asmspec)
8123     make_decl_rtl (decl, asmspec);
8124   /* If we're not deferring, go ahead and assemble the variable.  */
8125   else if (!defer_p)
8126     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8127 }
8128
8129 /* The old ARM scoping rules injected variables declared in the
8130    initialization statement of a for-statement into the surrounding
8131    scope.  We support this usage, in order to be backward-compatible.
8132    DECL is a just-declared VAR_DECL; if necessary inject its
8133    declaration into the surrounding scope.  */
8134
8135 void
8136 maybe_inject_for_scope_var (decl)
8137      tree decl;
8138 {
8139   if (!DECL_NAME (decl))
8140     return;
8141
8142   /* Declarations of __FUNCTION__ and its ilk appear magically when
8143      the variable is first used.  If that happens to be inside a
8144      for-loop, we don't want to do anything special.  */
8145   if (DECL_PRETTY_FUNCTION_P (decl))
8146     return;
8147
8148   if (current_binding_level->is_for_scope)
8149     {
8150       struct cp_binding_level *outer
8151         = current_binding_level->level_chain;
8152
8153       /* Check to see if the same name is already bound at the outer
8154          level, either because it was directly declared, or because a
8155          dead for-decl got preserved.  In either case, the code would
8156          not have been valid under the ARM scope rules, so clear
8157          is_for_scope for the current_binding_level.
8158
8159          Otherwise, we need to preserve the temp slot for decl to last
8160          into the outer binding level.  */
8161
8162       tree outer_binding
8163         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8164
8165       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8166           && (TREE_CODE (BINDING_VALUE (outer_binding))
8167               == VAR_DECL)
8168           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8169         {
8170           BINDING_VALUE (outer_binding)
8171             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8172           current_binding_level->is_for_scope = 0;
8173         }
8174     }
8175 }
8176
8177 /* Generate code to initialize DECL (a local variable).  */
8178
8179 static void
8180 initialize_local_var (decl, init)
8181      tree decl;
8182      tree init;
8183 {
8184   tree type = TREE_TYPE (decl);
8185
8186   my_friendly_assert (TREE_CODE (decl) == VAR_DECL
8187                       || TREE_CODE (decl) == RESULT_DECL,
8188                       20021010);
8189   my_friendly_assert (!TREE_STATIC (decl), 20021010);
8190
8191   if (DECL_SIZE (decl) == NULL_TREE)
8192     {
8193       /* If we used it already as memory, it must stay in memory.  */
8194       DECL_INITIAL (decl) = NULL_TREE;
8195       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8196     }
8197
8198   if (DECL_SIZE (decl) && type != error_mark_node)
8199     {
8200       int already_used;
8201
8202       /* Compute and store the initial value.  */
8203       already_used = TREE_USED (decl) || TREE_USED (type);
8204
8205       /* Perform the initialization.  */
8206       if (init)
8207         {
8208           int saved_stmts_are_full_exprs_p;
8209
8210           my_friendly_assert (building_stmt_tree (), 20000906);
8211           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8212           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8213           finish_expr_stmt (init);
8214           current_stmt_tree ()->stmts_are_full_exprs_p =
8215             saved_stmts_are_full_exprs_p;
8216         }
8217
8218       /* Set this to 0 so we can tell whether an aggregate which was
8219          initialized was ever used.  Don't do this if it has a
8220          destructor, so we don't complain about the 'resource
8221          allocation is initialization' idiom.  Now set
8222          attribute((unused)) on types so decls of that type will be
8223          marked used. (see TREE_USED, above.)  */
8224       if (TYPE_NEEDS_CONSTRUCTING (type)
8225           && ! already_used
8226           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8227           && DECL_NAME (decl))
8228         TREE_USED (decl) = 0;
8229       else if (already_used)
8230         TREE_USED (decl) = 1;
8231     }
8232
8233   /* Generate a cleanup, if necessary.  */
8234   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8235     {
8236       tree cleanup;
8237
8238       /* Compute the cleanup.  */
8239       cleanup = cxx_maybe_build_cleanup (decl);
8240
8241       /* Record the cleanup required for this declaration.  */
8242       if (DECL_SIZE (decl) && cleanup)
8243         finish_decl_cleanup (decl, cleanup);
8244     }
8245 }
8246
8247 /* Finish processing of a declaration;
8248    install its line number and initial value.
8249    If the length of an array type is not known before,
8250    it must be determined now, from the initial value, or it is an error.
8251
8252    INIT holds the value of an initializer that should be allowed to escape
8253    the normal rules.
8254
8255    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8256    if the (init) syntax was used.  */
8257
8258 void
8259 cp_finish_decl (decl, init, asmspec_tree, flags)
8260      tree decl, init;
8261      tree asmspec_tree;
8262      int flags;
8263 {
8264   register tree type;
8265   tree ttype = NULL_TREE;
8266   const char *asmspec = NULL;
8267   int was_readonly = 0;
8268
8269   if (! decl)
8270     {
8271       if (init)
8272         error ("assignment (not initialization) in declaration");
8273       return;
8274     }
8275
8276   /* If a name was specified, get the string.  */
8277   if (current_binding_level == global_binding_level)
8278     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8279   if (asmspec_tree)
8280     asmspec = TREE_STRING_POINTER (asmspec_tree);
8281
8282   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8283     {
8284       error ("cannot initialize `%D' to namespace `%D'",
8285                 decl, init);
8286       init = NULL_TREE;
8287     }
8288
8289   if (current_class_type
8290       && CP_DECL_CONTEXT (decl) == current_class_type
8291       && TYPE_BEING_DEFINED (current_class_type)
8292       && (DECL_INITIAL (decl) || init))
8293     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8294
8295   if (TREE_CODE (decl) == VAR_DECL
8296       && DECL_CONTEXT (decl)
8297       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8298       && DECL_CONTEXT (decl) != current_namespace
8299       && init)
8300     {
8301       /* Leave the namespace of the object.  */
8302       pop_decl_namespace ();
8303     }
8304
8305   type = TREE_TYPE (decl);
8306
8307   if (type == error_mark_node)
8308     return;
8309
8310   if (TYPE_HAS_MUTABLE_P (type))
8311     TREE_READONLY (decl) = 0;
8312
8313   if (processing_template_decl)
8314     {
8315       /* Add this declaration to the statement-tree.  */
8316       if (at_function_scope_p ()
8317           && TREE_CODE (decl) != RESULT_DECL)
8318         add_decl_stmt (decl);
8319
8320       if (init && DECL_INITIAL (decl))
8321         DECL_INITIAL (decl) = init;
8322       goto finish_end0;
8323     }
8324
8325   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8326   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8327
8328   /* Take care of TYPE_DECLs up front.  */
8329   if (TREE_CODE (decl) == TYPE_DECL)
8330     {
8331       if (type != error_mark_node
8332           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8333         {
8334           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8335             warning ("shadowing previous type declaration of `%#D'", decl);
8336           set_identifier_type_value (DECL_NAME (decl), type);
8337           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8338         }
8339
8340       /* If we have installed this as the canonical typedef for this
8341          type, and that type has not been defined yet, delay emitting
8342          the debug information for it, as we will emit it later.  */
8343       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8344           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8345         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8346
8347       rest_of_decl_compilation (decl, NULL,
8348                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8349       goto finish_end;
8350     }
8351
8352   if (TREE_CODE (decl) != FUNCTION_DECL)
8353     ttype = target_type (type);
8354
8355   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8356       && TYPE_NEEDS_CONSTRUCTING (type))
8357     {
8358       /* Currently, GNU C++ puts constants in text space, making them
8359          impossible to initialize.  In the future, one would hope for
8360          an operating system which understood the difference between
8361          initialization and the running of a program.  */
8362       was_readonly = 1;
8363       TREE_READONLY (decl) = 0;
8364     }
8365
8366   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8367     {
8368       /* This must override the asm specifier which was placed by
8369          grokclassfn.  Lay this out fresh.  */
8370       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8371       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8372       make_decl_rtl (decl, asmspec);
8373     }
8374   else if (TREE_CODE (decl) == RESULT_DECL)
8375     init = check_initializer (decl, init, flags);
8376   else if (TREE_CODE (decl) == VAR_DECL)
8377     {
8378       /* Only PODs can have thread-local storage.  Other types may require
8379          various kinds of non-trivial initialization.  */
8380       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
8381         error ("`%D' cannot be thread-local because it has non-POD type `%T'",
8382                decl, TREE_TYPE (decl));
8383       /* Convert the initializer to the type of DECL, if we have not
8384          already initialized DECL.  */
8385       if (!DECL_INITIALIZED_P (decl)
8386           /* If !DECL_EXTERNAL then DECL is being defined.  In the
8387              case of a static data member initialized inside the
8388              class-specifier, there can be an initializer even if DECL
8389              is *not* defined.  */
8390           && (!DECL_EXTERNAL (decl) || init))
8391         {
8392           init = check_initializer (decl, init, flags);
8393           /* Thread-local storage cannot be dynamically initialized.  */
8394           if (DECL_THREAD_LOCAL (decl) && init)
8395             {
8396               error ("`%D' is thread-local and so cannot be dynamically "
8397                      "initialized", decl);
8398               init = NULL_TREE;
8399             }
8400           /* Handle:
8401
8402              [dcl.init]
8403
8404              The memory occupied by any object of static storage
8405              duration is zero-initialized at program startup before
8406              any other initialization takes place.
8407
8408              We cannot create an appropriate initializer until after
8409              the type of DECL is finalized.  If DECL_INITIAL is set,
8410              then the DECL is statically initialized, and any
8411              necessary zero-initialization has already been performed.  */
8412           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
8413             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
8414                                                    /*static_storage_p=*/true);
8415           /* Remember that the initialization for this variable has
8416              taken place.  */
8417           DECL_INITIALIZED_P (decl) = 1;
8418         }
8419       /* If the variable has an array type, lay out the type, even if
8420          there is no initializer.  It is valid to index through the
8421          array, and we must get TYPE_ALIGN set correctly on the array
8422          type.  */
8423       else if (TREE_CODE (type) == ARRAY_TYPE)
8424         layout_type (type);
8425     }
8426
8427   /* Add this declaration to the statement-tree.  This needs to happen
8428      after the call to check_initializer so that the DECL_STMT for a
8429      reference temp is added before the DECL_STMT for the reference itself.  */
8430   if (building_stmt_tree ()
8431       && at_function_scope_p ()
8432       && TREE_CODE (decl) != RESULT_DECL)
8433     add_decl_stmt (decl);
8434
8435   if (TREE_CODE (decl) == VAR_DECL)
8436     layout_var_decl (decl);
8437
8438   /* Output the assembler code and/or RTL code for variables and functions,
8439      unless the type is an undefined structure or union.
8440      If not, it will get done when the type is completed.  */
8441   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8442       || TREE_CODE (decl) == RESULT_DECL)
8443     {
8444       if (TREE_CODE (decl) == VAR_DECL)
8445         maybe_commonize_var (decl);
8446
8447       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8448
8449       if (TREE_CODE (type) == FUNCTION_TYPE
8450           || TREE_CODE (type) == METHOD_TYPE)
8451         abstract_virtuals_error (decl,
8452                                  strip_array_types (TREE_TYPE (type)));
8453       else
8454         abstract_virtuals_error (decl, strip_array_types (type));
8455
8456       if (TREE_CODE (decl) == FUNCTION_DECL
8457           || TREE_TYPE (decl) == error_mark_node)
8458         /* No initialization required.  */
8459         ;
8460       else if (DECL_EXTERNAL (decl)
8461                && ! (DECL_LANG_SPECIFIC (decl)
8462                      && DECL_NOT_REALLY_EXTERN (decl)))
8463         {
8464           if (init)
8465             DECL_INITIAL (decl) = init;
8466         }
8467       else
8468         {
8469           /* A variable definition.  */
8470           if (DECL_FUNCTION_SCOPE_P (decl))
8471             {
8472               /* This is a local declaration.  */
8473               if (doing_semantic_analysis_p ())
8474                 maybe_inject_for_scope_var (decl);
8475               /* Initialize the local variable.  */
8476               if (processing_template_decl)
8477                 {
8478                   if (init || DECL_INITIAL (decl) == error_mark_node)
8479                     DECL_INITIAL (decl) = init;
8480                 }
8481               else if (!TREE_STATIC (decl))
8482                 initialize_local_var (decl, init);
8483             }
8484
8485           if (TREE_STATIC (decl))
8486             expand_static_init (decl, init);
8487         }
8488     finish_end0:
8489
8490       /* Undo call to `pushclass' that was done in `start_decl'
8491          due to initialization of qualified member variable.
8492          I.e., Foo::x = 10;  */
8493       {
8494         tree context = CP_DECL_CONTEXT (decl);
8495         if (context
8496             && TYPE_P (context)
8497             && (TREE_CODE (decl) == VAR_DECL
8498                 /* We also have a pushclass done that we need to undo here
8499                    if we're at top level and declare a method.  */
8500                 || TREE_CODE (decl) == FUNCTION_DECL)
8501             /* If size hasn't been set, we're still defining it,
8502                and therefore inside the class body; don't pop
8503                the binding level..  */
8504             && COMPLETE_TYPE_P (context)
8505             && context == current_class_type)
8506           pop_nested_class ();
8507       }
8508     }
8509
8510  finish_end:
8511
8512   if (was_readonly)
8513     TREE_READONLY (decl) = 1;
8514 }
8515
8516 /* This is here for a midend callback from c-common.c */
8517
8518 void
8519 finish_decl (decl, init, asmspec_tree)
8520      tree decl, init;
8521      tree asmspec_tree;
8522 {
8523   cp_finish_decl (decl, init, asmspec_tree, 0);
8524 }
8525
8526 /* Returns a declaration for a VAR_DECL as if:
8527
8528      extern "C" TYPE NAME;
8529
8530    had been seen.  Used to create compiler-generated global
8531    variables.  */
8532
8533 tree
8534 declare_global_var (name, type)
8535      tree name;
8536      tree type;
8537 {
8538   tree decl;
8539
8540   push_to_top_level ();
8541   decl = build_decl (VAR_DECL, name, type);
8542   TREE_PUBLIC (decl) = 1;
8543   DECL_EXTERNAL (decl) = 1;
8544   DECL_ARTIFICIAL (decl) = 1;
8545   pushdecl (decl);
8546   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8547   pop_from_top_level ();
8548
8549   return decl;
8550 }
8551
8552 /* Returns a pointer to the `atexit' function.  Note that if
8553    FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8554    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8555
8556 static tree
8557 get_atexit_node ()
8558 {
8559   tree atexit_fndecl;
8560   tree arg_types;
8561   tree fn_type;
8562   tree fn_ptr_type;
8563   const char *name;
8564
8565   if (atexit_node)
8566     return atexit_node;
8567
8568   if (flag_use_cxa_atexit)
8569     {
8570       /* The declaration for `__cxa_atexit' is:
8571
8572            int __cxa_atexit (void (*)(void *), void *, void *)
8573
8574          We build up the argument types and then then function type
8575          itself.  */
8576
8577       /* First, build the pointer-to-function type for the first
8578          argument.  */
8579       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8580       fn_type = build_function_type (void_type_node, arg_types);
8581       fn_ptr_type = build_pointer_type (fn_type);
8582       /* Then, build the rest of the argument types.  */
8583       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8584       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8585       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8586       /* And the final __cxa_atexit type.  */
8587       fn_type = build_function_type (integer_type_node, arg_types);
8588       fn_ptr_type = build_pointer_type (fn_type);
8589       name = "__cxa_atexit";
8590     }
8591   else
8592     {
8593       /* The declaration for `atexit' is:
8594
8595            int atexit (void (*)());
8596
8597          We build up the argument types and then then function type
8598          itself.  */
8599       fn_type = build_function_type (void_type_node, void_list_node);
8600       fn_ptr_type = build_pointer_type (fn_type);
8601       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8602       /* Build the final atexit type.  */
8603       fn_type = build_function_type (integer_type_node, arg_types);
8604       name = "atexit";
8605     }
8606
8607   /* Now, build the function declaration.  */
8608   push_lang_context (lang_name_c);
8609   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8610   mark_used (atexit_fndecl);
8611   pop_lang_context ();
8612   atexit_node = default_conversion (atexit_fndecl);
8613
8614   return atexit_node;
8615 }
8616
8617 /* Returns the __dso_handle VAR_DECL.  */
8618
8619 static tree
8620 get_dso_handle_node ()
8621 {
8622   if (dso_handle_node)
8623     return dso_handle_node;
8624
8625   /* Declare the variable.  */
8626   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8627                                         ptr_type_node);
8628
8629   return dso_handle_node;
8630 }
8631
8632 /* Begin a new function with internal linkage whose job will be simply
8633    to destroy some particular variable.  */
8634
8635 static tree
8636 start_cleanup_fn ()
8637 {
8638   static int counter = 0;
8639   int old_interface_only = interface_only;
8640   int old_interface_unknown = interface_unknown;
8641   char name[32];
8642   tree parmtypes;
8643   tree fntype;
8644   tree fndecl;
8645
8646   push_to_top_level ();
8647
8648   /* No need to mangle this.  */
8649   push_lang_context (lang_name_c);
8650
8651   interface_only = 0;
8652   interface_unknown = 1;
8653
8654   /* Build the parameter-types.  */
8655   parmtypes = void_list_node;
8656   /* Functions passed to __cxa_atexit take an additional parameter.
8657      We'll just ignore it.  After we implement the new calling
8658      convention for destructors, we can eliminate the use of
8659      additional cleanup functions entirely in the -fnew-abi case.  */
8660   if (flag_use_cxa_atexit)
8661     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8662   /* Build the function type itself.  */
8663   fntype = build_function_type (void_type_node, parmtypes);
8664   /* Build the name of the function.  */
8665   sprintf (name, "__tcf_%d", counter++);
8666   /* Build the function declaration.  */
8667   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8668   /* It's a function with internal linkage, generated by the
8669      compiler.  */
8670   TREE_PUBLIC (fndecl) = 0;
8671   DECL_ARTIFICIAL (fndecl) = 1;
8672   /* Make the function `inline' so that it is only emitted if it is
8673      actually needed.  It is unlikely that it will be inlined, since
8674      it is only called via a function pointer, but we avoid unnecessary
8675      emissions this way.  */
8676   DECL_INLINE (fndecl) = 1;
8677   /* Build the parameter.  */
8678   if (flag_use_cxa_atexit)
8679     {
8680       tree parmdecl;
8681
8682       parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
8683       DECL_CONTEXT (parmdecl) = fndecl;
8684       TREE_USED (parmdecl) = 1;
8685       DECL_ARGUMENTS (fndecl) = parmdecl;
8686     }
8687
8688   pushdecl (fndecl);
8689   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8690
8691   interface_unknown = old_interface_unknown;
8692   interface_only = old_interface_only;
8693
8694   pop_lang_context ();
8695
8696   return current_function_decl;
8697 }
8698
8699 /* Finish the cleanup function begun by start_cleanup_fn.  */
8700
8701 static void
8702 end_cleanup_fn ()
8703 {
8704   expand_body (finish_function (0));
8705
8706   pop_from_top_level ();
8707 }
8708
8709 /* Generate code to handle the destruction of DECL, an object with
8710    static storage duration.  */
8711
8712 void
8713 register_dtor_fn (decl)
8714      tree decl;
8715 {
8716   tree cleanup;
8717   tree compound_stmt;
8718   tree args;
8719   tree fcall;
8720   int saved_flag_access_control;
8721
8722   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8723     return;
8724
8725   /* Call build_cleanup before we enter the anonymous function so that
8726      any access checks will be done relative to the current scope,
8727      rather than the scope of the anonymous function.  */
8728   build_cleanup (decl);
8729
8730   /* Now start the function.  */
8731   cleanup = start_cleanup_fn ();
8732
8733   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8734      to the original function, rather than the anonymous one.  That
8735      will make the back-end think that nested functions are in use,
8736      which causes confusion.  */
8737   saved_flag_access_control = flag_access_control;
8738   scope_chain->check_access = flag_access_control = 0;
8739   fcall = build_cleanup (decl);
8740   scope_chain->check_access = flag_access_control = saved_flag_access_control;
8741
8742   /* Create the body of the anonymous function.  */
8743   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8744   finish_expr_stmt (fcall);
8745   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8746   end_cleanup_fn ();
8747
8748   /* Call atexit with the cleanup function.  */
8749   cxx_mark_addressable (cleanup);
8750   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8751   if (flag_use_cxa_atexit)
8752     {
8753       args = tree_cons (NULL_TREE,
8754                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8755                         NULL_TREE);
8756       args = tree_cons (NULL_TREE, null_pointer_node, args);
8757       args = tree_cons (NULL_TREE, cleanup, args);
8758     }
8759   else
8760     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8761   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8762 }
8763
8764 /* DECL is a VAR_DECL with static storage duration.  INIT, if present,
8765    is its initializer.  Generate code to handle the construction
8766    and destruction of DECL.  */
8767
8768 static void
8769 expand_static_init (decl, init)
8770      tree decl;
8771      tree init;
8772 {
8773   tree oldstatic;
8774
8775   my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
8776   my_friendly_assert (TREE_STATIC (decl), 20021010);
8777
8778   /* Some variables require no initialization.  */
8779   if (!init
8780       && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8781       && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8782     return;
8783
8784   oldstatic = value_member (decl, static_aggregates);
8785
8786   if (oldstatic)
8787     {
8788       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8789         error ("multiple initializations given for `%D'", decl);
8790     }
8791   else if (! toplevel_bindings_p ())
8792     {
8793       /* Emit code to perform this initialization but once.  */
8794       tree if_stmt;
8795       tree then_clause;
8796       tree assignment;
8797       tree guard;
8798       tree guard_init;
8799
8800       /* Emit code to perform this initialization but once.  This code
8801          looks like:
8802
8803            static int guard = 0;
8804            if (!guard) {
8805              // Do initialization.
8806              guard = 1;
8807              // Register variable for destruction at end of program.
8808            }
8809
8810          Note that the `temp' variable is only set to 1 *after* the
8811          initialization is complete.  This ensures that an exception,
8812          thrown during the construction, will cause the variable to
8813          reinitialized when we pass through this code again, as per:
8814
8815            [stmt.dcl]
8816
8817            If the initialization exits by throwing an exception, the
8818            initialization is not complete, so it will be tried again
8819            the next time control enters the declaration.
8820
8821          In theory, this process should be thread-safe, too; multiple
8822          threads should not be able to initialize the variable more
8823          than once.  We don't yet attempt to ensure thread-safety.  */
8824
8825       /* Create the guard variable.  */
8826       guard = get_guard (decl);
8827
8828       /* Begin the conditional initialization.  */
8829       if_stmt = begin_if_stmt ();
8830       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8831       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8832
8833       /* Do the initialization itself.  */
8834       assignment = init ? init : NULL_TREE;
8835
8836       /* Once the assignment is complete, set TEMP to 1.  Since the
8837          construction of the static object is complete at this point,
8838          we want to make sure TEMP is set to 1 even if a temporary
8839          constructed during the initialization throws an exception
8840          when it is destroyed.  So, we combine the initialization and
8841          the assignment to TEMP into a single expression, ensuring
8842          that when we call finish_expr_stmt the cleanups will not be
8843          run until after TEMP is set to 1.  */
8844       guard_init = set_guard (guard);
8845       if (assignment)
8846         {
8847           assignment = tree_cons (NULL_TREE, assignment,
8848                                   build_tree_list (NULL_TREE,
8849                                                    guard_init));
8850           assignment = build_compound_expr (assignment);
8851         }
8852       else
8853         assignment = guard_init;
8854       finish_expr_stmt (assignment);
8855
8856       /* Use atexit to register a function for destroying this static
8857          variable.  */
8858       register_dtor_fn (decl);
8859
8860       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8861       finish_then_clause (if_stmt);
8862       finish_if_stmt ();
8863     }
8864   else
8865     static_aggregates = tree_cons (init, decl, static_aggregates);
8866 }
8867
8868 /* Finish the declaration of a catch-parameter.  */
8869
8870 tree
8871 start_handler_parms (declspecs, declarator)
8872      tree declspecs;
8873      tree declarator;
8874 {
8875   tree decl;
8876   if (declspecs)
8877     {
8878       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8879                              1, NULL);
8880       if (decl == NULL_TREE)
8881         error ("invalid catch parameter");
8882     }
8883   else
8884     decl = NULL_TREE;
8885
8886   return decl;
8887 }
8888
8889 \f
8890 /* Make TYPE a complete type based on INITIAL_VALUE.
8891    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8892    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8893
8894 int
8895 complete_array_type (type, initial_value, do_default)
8896      tree type, initial_value;
8897      int do_default;
8898 {
8899   register tree maxindex = NULL_TREE;
8900   int value = 0;
8901
8902   if (initial_value)
8903     {
8904       /* An array of character type can be initialized from a
8905          brace-enclosed string constant.  */
8906       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8907           && TREE_CODE (initial_value) == CONSTRUCTOR
8908           && CONSTRUCTOR_ELTS (initial_value)
8909           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8910               == STRING_CST)
8911           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8912         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8913
8914       /* Note MAXINDEX is really the maximum index, one less than the
8915          size.  */
8916       if (TREE_CODE (initial_value) == STRING_CST)
8917         {
8918           int eltsize
8919             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8920           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8921                                    / eltsize) - 1, 0);
8922         }
8923       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8924         {
8925           tree elts = CONSTRUCTOR_ELTS (initial_value);
8926
8927           maxindex = ssize_int (-1);
8928           for (; elts; elts = TREE_CHAIN (elts))
8929             {
8930               if (TREE_PURPOSE (elts))
8931                 maxindex = TREE_PURPOSE (elts);
8932               else
8933                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8934             }
8935           maxindex = copy_node (maxindex);
8936         }
8937       else
8938         {
8939           /* Make an error message unless that happened already.  */
8940           if (initial_value != error_mark_node)
8941             value = 1;
8942           else
8943             initial_value = NULL_TREE;
8944
8945           /* Prevent further error messages.  */
8946           maxindex = build_int_2 (0, 0);
8947         }
8948     }
8949
8950   if (!maxindex)
8951     {
8952       if (do_default)
8953         maxindex = build_int_2 (0, 0);
8954       value = 2;
8955     }
8956
8957   if (maxindex)
8958     {
8959       tree itype;
8960       tree domain;
8961
8962       domain = build_index_type (maxindex);
8963       TYPE_DOMAIN (type) = domain;
8964
8965       if (! TREE_TYPE (maxindex))
8966         TREE_TYPE (maxindex) = domain;
8967       if (initial_value)
8968         itype = TREE_TYPE (initial_value);
8969       else
8970         itype = NULL;
8971       if (itype && !TYPE_DOMAIN (itype))
8972         TYPE_DOMAIN (itype) = domain;
8973       /* The type of the main variant should never be used for arrays
8974          of different sizes.  It should only ever be completed with the
8975          size of the array.  */
8976       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8977         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8978     }
8979
8980   /* Lay out the type now that we can get the real answer.  */
8981
8982   layout_type (type);
8983
8984   return value;
8985 }
8986 \f
8987 /* Return zero if something is declared to be a member of type
8988    CTYPE when in the context of CUR_TYPE.  STRING is the error
8989    message to print in that case.  Otherwise, quietly return 1.  */
8990
8991 static int
8992 member_function_or_else (ctype, cur_type, flags)
8993      tree ctype, cur_type;
8994      enum overload_flags flags;
8995 {
8996   if (ctype && ctype != cur_type)
8997     {
8998       if (flags == DTOR_FLAG)
8999         error ("destructor for alien class `%T' cannot be a member",
9000                   ctype);
9001       else
9002         error ("constructor for alien class `%T' cannot be a member",
9003                   ctype);
9004       return 0;
9005     }
9006   return 1;
9007 }
9008 \f
9009 /* Subroutine of `grokdeclarator'.  */
9010
9011 /* Generate errors possibly applicable for a given set of specifiers.
9012    This is for ARM $7.1.2.  */
9013
9014 static void
9015 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
9016      tree object;
9017      const char *type;
9018      int virtualp, quals, friendp, raises, inlinep;
9019 {
9020   if (virtualp)
9021     error ("`%D' declared as a `virtual' %s", object, type);
9022   if (inlinep)
9023     error ("`%D' declared as an `inline' %s", object, type);
9024   if (quals)
9025     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
9026               object, type);
9027   if (friendp)
9028     cp_error_at ("`%D' declared as a friend", object);
9029   if (raises
9030       && (TREE_CODE (object) == TYPE_DECL
9031           || (!TYPE_PTRFN_P (TREE_TYPE (object))
9032               && !TYPE_REFFN_P (TREE_TYPE (object))
9033               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
9034     cp_error_at ("`%D' declared with an exception specification", object);
9035 }
9036
9037 /* CTYPE is class type, or null if non-class.
9038    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
9039    or METHOD_TYPE.
9040    DECLARATOR is the function's name.
9041    VIRTUALP is truthvalue of whether the function is virtual or not.
9042    FLAGS are to be passed through to `grokclassfn'.
9043    QUALS are qualifiers indicating whether the function is `const'
9044    or `volatile'.
9045    RAISES is a list of exceptions that this function can raise.
9046    CHECK is 1 if we must find this method in CTYPE, 0 if we should
9047    not look, and -1 if we should not call `grokclassfn' at all.
9048
9049    Returns `NULL_TREE' if something goes wrong, after issuing
9050    applicable error messages.  */
9051
9052 static tree
9053 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
9054             raises, check, friendp, publicp, inlinep, funcdef_flag,
9055             template_count, in_namespace)
9056      tree ctype, type;
9057      tree declarator;
9058      tree orig_declarator;
9059      int virtualp;
9060      enum overload_flags flags;
9061      tree quals, raises;
9062      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
9063      tree in_namespace;
9064 {
9065   tree decl;
9066   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
9067   int has_default_arg = 0;
9068   tree t;
9069
9070   if (raises)
9071     type = build_exception_variant (type, raises);
9072
9073   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
9074   /* Propagate volatile out from type to decl.  */
9075   if (TYPE_VOLATILE (type))
9076     TREE_THIS_VOLATILE (decl) = 1;
9077
9078   /* If this decl has namespace scope, set that up.  */
9079   if (in_namespace)
9080     set_decl_namespace (decl, in_namespace, friendp);
9081   else if (!ctype)
9082     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
9083
9084   /* `main' and builtins have implicit 'C' linkage.  */
9085   if ((MAIN_NAME_P (declarator)
9086        || (IDENTIFIER_LENGTH (declarator) > 10
9087            && IDENTIFIER_POINTER (declarator)[0] == '_'
9088            && IDENTIFIER_POINTER (declarator)[1] == '_'
9089            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
9090       && current_lang_name == lang_name_cplusplus
9091       && ctype == NULL_TREE
9092       /* NULL_TREE means global namespace.  */
9093       && DECL_CONTEXT (decl) == NULL_TREE)
9094     SET_DECL_LANGUAGE (decl, lang_c);
9095
9096   /* Should probably propagate const out from type to decl I bet (mrs).  */
9097   if (staticp)
9098     {
9099       DECL_STATIC_FUNCTION_P (decl) = 1;
9100       DECL_CONTEXT (decl) = ctype;
9101     }
9102
9103   if (ctype)
9104     DECL_CONTEXT (decl) = ctype;
9105
9106   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
9107     {
9108       if (processing_template_decl)
9109         error ("cannot declare `::main' to be a template");
9110       if (inlinep)
9111         error ("cannot declare `::main' to be inline");
9112       if (!publicp)
9113         error ("cannot declare `::main' to be static");
9114       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
9115                         integer_type_node))
9116         error ("`main' must return `int'");
9117       inlinep = 0;
9118       publicp = 1;
9119     }
9120
9121   /* Members of anonymous types and local classes have no linkage; make
9122      them internal.  */
9123   /* FIXME what if it gets a name from typedef?  */
9124   if (ctype && (TYPE_ANONYMOUS_P (ctype)
9125                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
9126     publicp = 0;
9127
9128   if (publicp)
9129     {
9130       /* [basic.link]: A name with no linkage (notably, the name of a class
9131          or enumeration declared in a local scope) shall not be used to
9132          declare an entity with linkage.
9133
9134          Only check this for public decls for now.  */
9135       t = no_linkage_check (TREE_TYPE (decl));
9136       if (t)
9137         {
9138           if (TYPE_ANONYMOUS_P (t))
9139             {
9140               if (DECL_EXTERN_C_P (decl))
9141                 /* Allow this; it's pretty common in C.  */;
9142               else
9143                 {
9144                   pedwarn ("non-local function `%#D' uses anonymous type",
9145                               decl);
9146                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
9147                     cp_pedwarn_at ("\
9148 `%#D' does not refer to the unqualified type, so it is not used for linkage",
9149                                 TYPE_NAME (t));
9150                 }
9151             }
9152           else
9153             pedwarn ("non-local function `%#D' uses local type `%T'",
9154                         decl, t);
9155         }
9156     }
9157
9158   TREE_PUBLIC (decl) = publicp;
9159   if (! publicp)
9160     {
9161       DECL_INTERFACE_KNOWN (decl) = 1;
9162       DECL_NOT_REALLY_EXTERN (decl) = 1;
9163     }
9164
9165   /* If the declaration was declared inline, mark it as such.  */
9166   if (inlinep)
9167     DECL_DECLARED_INLINE_P (decl) = 1;
9168   /* We inline functions that are explicitly declared inline, or, when
9169      the user explicitly asks us to, all functions.  */
9170   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
9171     DECL_INLINE (decl) = 1;
9172
9173   DECL_EXTERNAL (decl) = 1;
9174   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9175     {
9176       error ("%smember function `%D' cannot have `%T' method qualifier",
9177                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9178       quals = NULL_TREE;
9179     }
9180
9181   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9182     grok_op_properties (decl, friendp);
9183
9184   if (ctype && decl_function_context (decl))
9185     DECL_NO_STATIC_CHAIN (decl) = 1;
9186
9187   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9188     if (TREE_PURPOSE (t)
9189         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9190       {
9191         has_default_arg = 1;
9192         break;
9193       }
9194
9195   if (friendp
9196       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9197     {
9198       if (funcdef_flag)
9199         error
9200           ("defining explicit specialization `%D' in friend declaration",
9201            orig_declarator);
9202       else
9203         {
9204           tree fns = TREE_OPERAND (orig_declarator, 0);
9205           tree args = TREE_OPERAND (orig_declarator, 1);
9206
9207           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9208             {
9209               /* Something like `template <class T> friend void f<T>()'.  */
9210               error ("invalid use of template-id `%D' in declaration of primary template",
9211                         orig_declarator);
9212               return NULL_TREE;
9213             }
9214
9215
9216           /* A friend declaration of the form friend void f<>().  Record
9217              the information in the TEMPLATE_ID_EXPR.  */
9218           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9219
9220           if (TREE_CODE (fns) == COMPONENT_REF)
9221             {
9222               /* Due to bison parser ickiness, we will have already looked
9223                  up an operator_name or PFUNCNAME within the current class
9224                  (see template_id in parse.y). If the current class contains
9225                  such a name, we'll get a COMPONENT_REF here. Undo that.  */
9226
9227               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9228                                   == current_class_type, 20001120);
9229               fns = TREE_OPERAND (fns, 1);
9230             }
9231           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9232                               || TREE_CODE (fns) == LOOKUP_EXPR
9233                               || TREE_CODE (fns) == OVERLOAD, 20001120);
9234           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9235
9236           if (has_default_arg)
9237             {
9238               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9239                         decl);
9240               return NULL_TREE;
9241             }
9242
9243           if (inlinep)
9244             {
9245               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9246                         decl);
9247               return NULL_TREE;
9248             }
9249         }
9250     }
9251
9252   if (funcdef_flag)
9253     /* Make the init_value nonzero so pushdecl knows this is not
9254        tentative.  error_mark_node is replaced later with the BLOCK.  */
9255     DECL_INITIAL (decl) = error_mark_node;
9256
9257   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9258     TREE_NOTHROW (decl) = 1;
9259
9260   /* Caller will do the rest of this.  */
9261   if (check < 0)
9262     return decl;
9263
9264   if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
9265     DECL_CONSTRUCTOR_P (decl) = 1;
9266
9267   /* Function gets the ugly name, field gets the nice one.  This call
9268      may change the type of the function (because of default
9269      parameters)!  */
9270   if (ctype != NULL_TREE)
9271     grokclassfn (ctype, decl, flags, quals);
9272
9273   decl = check_explicit_specialization (orig_declarator, decl,
9274                                         template_count,
9275                                         2 * (funcdef_flag != 0) +
9276                                         4 * (friendp != 0));
9277   if (decl == error_mark_node)
9278     return NULL_TREE;
9279
9280   if (ctype != NULL_TREE
9281       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9282       && check)
9283     {
9284       tree old_decl;
9285
9286       old_decl = check_classfn (ctype, decl);
9287
9288       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9289         /* Because grokfndecl is always supposed to return a
9290            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9291            here.  We depend on our callers to figure out that its
9292            really a template that's being returned.  */
9293         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9294
9295       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9296           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9297         {
9298           /* Remove the `this' parm added by grokclassfn.
9299              XXX Isn't this done in start_function, too?  */
9300           revert_static_member_fn (decl);
9301           last_function_parms = TREE_CHAIN (last_function_parms);
9302         }
9303       if (old_decl && DECL_ARTIFICIAL (old_decl))
9304         error ("definition of implicitly-declared `%D'", old_decl);
9305
9306       if (old_decl)
9307         {
9308           /* Since we've smashed OLD_DECL to its
9309              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9310           if (TREE_CODE (decl) == TEMPLATE_DECL)
9311             decl = DECL_TEMPLATE_RESULT (decl);
9312
9313           /* Attempt to merge the declarations.  This can fail, in
9314              the case of some invalid specialization declarations.  */
9315           if (!duplicate_decls (decl, old_decl))
9316             error ("no `%#D' member function declared in class `%T'",
9317                       decl, ctype);
9318           return old_decl;
9319         }
9320     }
9321
9322   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9323     return NULL_TREE;
9324
9325   if (ctype == NULL_TREE || check)
9326     return decl;
9327
9328   if (virtualp)
9329     DECL_VIRTUAL_P (decl) = 1;
9330
9331   return decl;
9332 }
9333
9334 /* Create a VAR_DECL named NAME with the indicated TYPE.
9335
9336    If SCOPE is non-NULL, it is the class type or namespace containing
9337    the variable.  If SCOPE is NULL, the variable should is created in
9338    the innermost enclosings scope.  */
9339
9340 static tree
9341 grokvardecl (type, name, specbits_in, initialized, constp, scope)
9342      tree type;
9343      tree name;
9344      RID_BIT_TYPE *specbits_in;
9345      int initialized;
9346      int constp;
9347      tree scope;
9348 {
9349   tree decl;
9350   RID_BIT_TYPE specbits;
9351
9352   my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
9353                       20020808);
9354
9355   specbits = *specbits_in;
9356
9357   /* Compute the scope in which to place the variable.  */
9358   if (!scope)
9359     {
9360       /* An explicit "extern" specifier indicates a namespace-scope
9361          variable.  */
9362       if (RIDBIT_SETP (RID_EXTERN, specbits))
9363         scope = current_namespace;
9364       else if (!at_function_scope_p ())
9365         {
9366           scope = current_scope ();
9367           if (!scope)
9368             scope = current_namespace;
9369         }
9370     }
9371
9372   if (scope
9373       && (/* If the variable is a namespace-scope variable declared in a
9374              template, we need DECL_LANG_SPECIFIC.  */
9375           (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
9376           /* Similarly for namespace-scope variables with language linkage
9377              other than C++.  */
9378           || (TREE_CODE (scope) == NAMESPACE_DECL
9379               && current_lang_name != lang_name_cplusplus)
9380           /* Similarly for static data members.  */
9381           || TYPE_P (scope)))
9382     decl = build_lang_decl (VAR_DECL, name, type);
9383   else
9384     decl = build_decl (VAR_DECL, name, type);
9385
9386   if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9387     set_decl_namespace (decl, scope, 0);
9388   else
9389     DECL_CONTEXT (decl) = scope;
9390
9391   if (name && scope && current_lang_name != lang_name_c)
9392     /* We can't mangle lazily here because we don't have any
9393        way to recover whether or not a variable was `extern
9394        "C"' later.  */
9395     mangle_decl (decl);
9396
9397   if (RIDBIT_SETP (RID_EXTERN, specbits))
9398     {
9399       DECL_THIS_EXTERN (decl) = 1;
9400       DECL_EXTERNAL (decl) = !initialized;
9401     }
9402
9403   /* In class context, static means one per class,
9404      public access, and static storage.  */
9405   if (DECL_CLASS_SCOPE_P (decl))
9406     {
9407       TREE_PUBLIC (decl) = 1;
9408       TREE_STATIC (decl) = 1;
9409       DECL_EXTERNAL (decl) = 0;
9410     }
9411   /* At top level, either `static' or no s.c. makes a definition
9412      (perhaps tentative), and absence of `static' makes it public.  */
9413   else if (toplevel_bindings_p ())
9414     {
9415       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9416                             && (DECL_THIS_EXTERN (decl) || ! constp));
9417       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9418     }
9419   /* Not at top level, only `static' makes a static definition.  */
9420   else
9421     {
9422       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9423       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9424     }
9425
9426   if (RIDBIT_SETP (RID_THREAD, specbits))
9427     {
9428       if (targetm.have_tls)
9429         DECL_THREAD_LOCAL (decl) = 1;
9430       else
9431         /* A mere warning is sure to result in improper semantics
9432            at runtime.  Don't bother to allow this to compile.  */
9433         error ("thread-local storage not supported for this target");
9434     }
9435
9436   if (TREE_PUBLIC (decl))
9437     {
9438       /* [basic.link]: A name with no linkage (notably, the name of a class
9439          or enumeration declared in a local scope) shall not be used to
9440          declare an entity with linkage.
9441
9442          Only check this for public decls for now.  */
9443       tree t = no_linkage_check (TREE_TYPE (decl));
9444       if (t)
9445         {
9446           if (TYPE_ANONYMOUS_P (t))
9447             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9448           else
9449             pedwarn ("non-local variable `%#D' uses local type `%T'",
9450                         decl, t);
9451         }
9452     }
9453
9454   return decl;
9455 }
9456
9457 /* Create and return a canonical pointer to member function type, for
9458    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9459
9460 tree
9461 build_ptrmemfunc_type (type)
9462      tree type;
9463 {
9464   tree field, fields;
9465   tree t;
9466   tree unqualified_variant = NULL_TREE;
9467
9468   if (type == error_mark_node)
9469     return type;
9470
9471   /* If a canonical type already exists for this type, use it.  We use
9472      this method instead of type_hash_canon, because it only does a
9473      simple equality check on the list of field members.  */
9474
9475   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9476     return t;
9477
9478   /* Make sure that we always have the unqualified pointer-to-member
9479      type first.  */
9480   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9481     unqualified_variant
9482       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9483
9484   t = make_aggr_type (RECORD_TYPE);
9485   /* Let the front-end know this is a pointer to member function...  */
9486   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9487   /* ... and not really an aggregate.  */
9488   SET_IS_AGGR_TYPE (t, 0);
9489
9490   field = build_decl (FIELD_DECL, pfn_identifier, type);
9491   fields = field;
9492
9493   field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
9494   TREE_CHAIN (field) = fields;
9495   fields = field;
9496
9497   finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
9498
9499   /* Zap out the name so that the back-end will give us the debugging
9500      information for this anonymous RECORD_TYPE.  */
9501   TYPE_NAME (t) = NULL_TREE;
9502
9503   /* If this is not the unqualified form of this pointer-to-member
9504      type, set the TYPE_MAIN_VARIANT for this type to be the
9505      unqualified type.  Since they are actually RECORD_TYPEs that are
9506      not variants of each other, we must do this manually.  */
9507   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9508     {
9509       t = build_qualified_type (t, cp_type_quals (type));
9510       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9511       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9512       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9513     }
9514
9515   /* Cache this pointer-to-member type so that we can find it again
9516      later.  */
9517   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9518
9519   /* Seems to be wanted.  */
9520   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9521
9522   return t;
9523 }
9524
9525 /* Create and return a pointer to data member type.  */
9526
9527 tree
9528 build_ptrmem_type (tree class_type, tree member_type)
9529 {
9530   return build_pointer_type (build_offset_type (class_type, member_type));
9531 }
9532
9533 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9534    Check to see that the definition is valid.  Issue appropriate error
9535    messages.  Return 1 if the definition is particularly bad, or 0
9536    otherwise.  */
9537
9538 int
9539 check_static_variable_definition (decl, type)
9540      tree decl;
9541      tree type;
9542 {
9543   /* Motion 10 at San Diego: If a static const integral data member is
9544      initialized with an integral constant expression, the initializer
9545      may appear either in the declaration (within the class), or in
9546      the definition, but not both.  If it appears in the class, the
9547      member is a member constant.  The file-scope definition is always
9548      required.  */
9549   if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
9550     {
9551       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9552              type);
9553       /* If we just return the declaration, crashes will sometimes
9554          occur.  We therefore return void_type_node, as if this was a
9555          friend declaration, to cause callers to completely ignore
9556          this declaration.  */
9557       return 1;
9558     }
9559   else if (!CP_TYPE_CONST_P (type))
9560     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9561               decl);
9562   else if (pedantic && !INTEGRAL_TYPE_P (type))
9563     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9564
9565   return 0;
9566 }
9567
9568 /* Given the SIZE (i.e., number of elements) in an array, compute an
9569    appropriate index type for the array.  If non-NULL, NAME is the
9570    name of the thing being declared.  */
9571
9572 tree
9573 compute_array_index_type (name, size)
9574      tree name;
9575      tree size;
9576 {
9577   tree itype;
9578
9579   /* If this involves a template parameter, it will be a constant at
9580      instantiation time, but we don't know what the value is yet.
9581      Even if no template parameters are involved, we may an expression
9582      that is not a constant; we don't even simplify `1 + 2' when
9583      processing a template.  */
9584   if (processing_template_decl)
9585     {
9586       /* Resolve a qualified reference to an enumerator or static
9587          const data member of ours.  */
9588       if (TREE_CODE (size) == SCOPE_REF
9589           && TREE_OPERAND (size, 0) == current_class_type)
9590         {
9591           tree t = lookup_field (current_class_type,
9592                                  TREE_OPERAND (size, 1), 0, 0);
9593           if (t)
9594             size = t;
9595         }
9596
9597       return build_index_type (build_min (MINUS_EXPR, sizetype,
9598                                           size, integer_one_node));
9599     }
9600
9601   /* The size might be the result of a cast.  */
9602   STRIP_TYPE_NOPS (size);
9603
9604   /* It might be a const variable or enumeration constant.  */
9605   size = decl_constant_value (size);
9606
9607   /* The array bound must be an integer type.  */
9608   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9609       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9610       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9611     {
9612       if (name)
9613         error ("size of array `%D' has non-integer type", name);
9614       else
9615         error ("size of array has non-integer type");
9616       size = integer_one_node;
9617     }
9618
9619   /* Normally, the array-bound will be a constant.  */
9620   if (TREE_CODE (size) == INTEGER_CST)
9621     {
9622       /* Check to see if the array bound overflowed.  Make that an
9623          error, no matter how generous we're being.  */
9624       int old_flag_pedantic_errors = flag_pedantic_errors;
9625       int old_pedantic = pedantic;
9626       pedantic = flag_pedantic_errors = 1;
9627       constant_expression_warning (size);
9628       pedantic = old_pedantic;
9629       flag_pedantic_errors = old_flag_pedantic_errors;
9630
9631       /* An array must have a positive number of elements.  */
9632       if (INT_CST_LT (size, integer_zero_node))
9633         {
9634           if (name)
9635             error ("size of array `%D' is negative", name);
9636           else
9637             error ("size of array is negative");
9638           size = integer_one_node;
9639         }
9640       /* Except that an extension we allow zero-sized arrays.  We
9641          always allow them in system headers because glibc uses
9642          them.  */
9643       else if (integer_zerop (size) && pedantic && !in_system_header)
9644         {
9645           if (name)
9646             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9647           else
9648             pedwarn ("ISO C++ forbids zero-size array");
9649         }
9650     }
9651   else if (TREE_CONSTANT (size))
9652     {
9653       /* `(int) &fn' is not a valid array bound.  */
9654       if (name)
9655         error ("size of array `%D' is not an integral constant-expression",
9656                   name);
9657       else
9658         error ("size of array is not an integral constant-expression");
9659     }
9660
9661   /* Compute the index of the largest element in the array.  It is
9662      one less than the number of elements in the array.  */
9663   itype
9664     = fold (cp_build_binary_op (MINUS_EXPR,
9665                                 cp_convert (ssizetype, size),
9666                                 cp_convert (ssizetype,
9667                                             integer_one_node)));
9668
9669   /* Check for variable-sized arrays.  We allow such things as an
9670      extension, even though they are not allowed in ANSI/ISO C++.  */
9671   if (!TREE_CONSTANT (itype))
9672     {
9673       if (pedantic)
9674         {
9675           if (name)
9676             pedwarn ("ISO C++ forbids variable-size array `%D'",
9677                         name);
9678           else
9679             pedwarn ("ISO C++ forbids variable-size array");
9680         }
9681
9682       /* Create a variable-sized array index type.  */
9683       itype = variable_size (itype);
9684     }
9685   /* Make sure that there was no overflow when creating to a signed
9686      index type.  (For example, on a 32-bit machine, an array with
9687      size 2^32 - 1 is too big.)  */
9688   else if (TREE_OVERFLOW (itype))
9689     {
9690       error ("overflow in array dimension");
9691       TREE_OVERFLOW (itype) = 0;
9692     }
9693
9694   /* Create and return the appropriate index type.  */
9695   return build_index_type (itype);
9696 }
9697
9698 /* Returns the scope (if any) in which the entity declared by
9699    DECLARATOR will be located.  If the entity was declared with an
9700    unqualified name, NULL_TREE is returned.  */
9701
9702 tree
9703 get_scope_of_declarator (declarator)
9704      tree declarator;
9705 {
9706   if (!declarator)
9707     return NULL_TREE;
9708
9709   switch (TREE_CODE (declarator))
9710     {
9711     case CALL_EXPR:
9712     case ARRAY_REF:
9713     case INDIRECT_REF:
9714     case ADDR_EXPR:
9715       /* For any of these, the main declarator is the first operand.  */
9716       return get_scope_of_declarator (TREE_OPERAND
9717                                       (declarator, 0));
9718
9719     case SCOPE_REF:
9720       /* For a pointer-to-member, continue descending.  */
9721       if (TREE_CODE (TREE_OPERAND (declarator, 1))
9722           == INDIRECT_REF)
9723         return get_scope_of_declarator (TREE_OPERAND
9724                                         (declarator, 1));
9725       /* Otherwise, if the declarator-id is a SCOPE_REF, the scope in
9726          which the declaration occurs is the first operand.  */
9727       return TREE_OPERAND (declarator, 0);
9728
9729     case TREE_LIST:
9730       /* Attributes to be applied. The declarator is TREE_VALUE.  */
9731       return get_scope_of_declarator (TREE_VALUE (declarator));
9732
9733     default:
9734       /* Otherwise, we have a declarator-id which is not a qualified
9735          name; the entity will be declared in the current scope.  */
9736       return NULL_TREE;
9737     }
9738 }
9739
9740 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9741    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9742    with this type.  */
9743
9744 static tree
9745 create_array_type_for_decl (name, type, size)
9746      tree name;
9747      tree type;
9748      tree size;
9749 {
9750   tree itype = NULL_TREE;
9751   const char* error_msg;
9752
9753   /* If things have already gone awry, bail now.  */
9754   if (type == error_mark_node || size == error_mark_node)
9755     return error_mark_node;
9756
9757   /* Assume that everything will go OK.  */
9758   error_msg = NULL;
9759
9760   /* There are some types which cannot be array elements.  */
9761   switch (TREE_CODE (type))
9762     {
9763     case VOID_TYPE:
9764       error_msg = "array of void";
9765       break;
9766
9767     case FUNCTION_TYPE:
9768       error_msg = "array of functions";
9769       break;
9770
9771     case REFERENCE_TYPE:
9772       error_msg = "array of references";
9773       break;
9774
9775     case OFFSET_TYPE:
9776       error_msg = "array of data members";
9777       break;
9778
9779     case METHOD_TYPE:
9780       error_msg = "array of function members";
9781       break;
9782
9783     default:
9784       break;
9785     }
9786
9787   /* If something went wrong, issue an error-message and return.  */
9788   if (error_msg)
9789     {
9790       if (name)
9791         error ("declaration of `%D' as %s", name, error_msg);
9792       else
9793         error ("creating %s", error_msg);
9794
9795       return error_mark_node;
9796     }
9797
9798   /* [dcl.array]
9799
9800      The constant expressions that specify the bounds of the arrays
9801      can be omitted only for the first member of the sequence.  */
9802   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9803     {
9804       if (name)
9805         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9806                   name);
9807       else
9808         error ("multidimensional array must have bounds for all dimensions except the first");
9809
9810       return error_mark_node;
9811     }
9812
9813   /* Figure out the index type for the array.  */
9814   if (size)
9815     itype = compute_array_index_type (name, size);
9816
9817   return build_cplus_array_type (type, itype);
9818 }
9819
9820 /* Check that it's OK to declare a function with the indicated TYPE.
9821    SFK indicates the kind of special function (if any) that this
9822    function is.  OPTYPE is the type given in a conversion operator
9823    declaration.  Returns the actual return type of the function; that
9824    may be different than TYPE if an error occurs, or for certain
9825    special functions.  */
9826
9827 static tree
9828 check_special_function_return_type (sfk, type, optype)
9829      special_function_kind sfk;
9830      tree type;
9831      tree optype;
9832 {
9833   switch (sfk)
9834     {
9835     case sfk_constructor:
9836       if (type)
9837         error ("return type specification for constructor invalid");
9838
9839       type = void_type_node;
9840       break;
9841
9842     case sfk_destructor:
9843       if (type)
9844         error ("return type specification for destructor invalid");
9845       type = void_type_node;
9846       break;
9847
9848     case sfk_conversion:
9849       if (type && !same_type_p (type, optype))
9850         error ("operator `%T' declared to return `%T'", optype, type);
9851       else if (type)
9852         pedwarn ("return type specified for `operator %T'",  optype);
9853       type = optype;
9854       break;
9855
9856     default:
9857       abort ();
9858       break;
9859     }
9860
9861   return type;
9862 }
9863
9864 /* Given declspecs and a declarator (abstract or otherwise), determine
9865    the name and type of the object declared and construct a DECL node
9866    for it.
9867
9868    DECLSPECS is a chain of tree_list nodes whose value fields
9869     are the storage classes and type specifiers.
9870
9871    DECL_CONTEXT says which syntactic context this declaration is in:
9872      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9873      FUNCDEF for a function definition.  Like NORMAL but a few different
9874       error messages in each case.  Return value may be zero meaning
9875       this definition is too screwy to try to parse.
9876      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9877       handle member functions (which have FIELD context).
9878       Return value may be zero meaning this definition is too screwy to
9879       try to parse.
9880      PARM for a parameter declaration (either within a function prototype
9881       or before a function body).  Make a PARM_DECL, or return void_type_node.
9882      CATCHPARM for a parameter declaration before a catch clause.
9883      TYPENAME if for a typename (in a cast or sizeof).
9884       Don't make a DECL node; just return the ..._TYPE node.
9885      FIELD for a struct or union field; make a FIELD_DECL.
9886      BITFIELD for a field with specified width.
9887    INITIALIZED is 1 if the decl has an initializer.
9888
9889    ATTRLIST is a pointer to the list of attributes, which may be NULL
9890    if there are none; *ATTRLIST may be modified if attributes from inside
9891    the declarator should be applied to the declaration.
9892
9893    When this function is called, scoping variables (such as
9894    CURRENT_CLASS_TYPE) should reflect the scope in which the
9895    declaration occurs, not the scope in which the new declaration will
9896    be placed.  For example, on:
9897
9898      void S::f() { ... }
9899
9900    when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9901    should not be `S'.  */
9902
9903 tree
9904 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9905      tree declspecs;
9906      tree declarator;
9907      enum decl_context decl_context;
9908      int initialized;
9909      tree *attrlist;
9910 {
9911   RID_BIT_TYPE specbits;
9912   int nclasses = 0;
9913   tree spec;
9914   tree type = NULL_TREE;
9915   int longlong = 0;
9916   int type_quals;
9917   int virtualp, explicitp, friendp, inlinep, staticp;
9918   int explicit_int = 0;
9919   int explicit_char = 0;
9920   int defaulted_int = 0;
9921   int extern_langp = 0;
9922   tree dependant_name = NULL_TREE;
9923
9924   tree typedef_decl = NULL_TREE;
9925   const char *name;
9926   tree typedef_type = NULL_TREE;
9927   int funcdef_flag = 0;
9928   enum tree_code innermost_code = ERROR_MARK;
9929   int bitfield = 0;
9930 #if 0
9931   /* See the code below that used this.  */
9932   tree decl_attr = NULL_TREE;
9933 #endif
9934   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9935      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9936   tree init = NULL_TREE;
9937
9938   /* Keep track of what sort of function is being processed
9939      so that we can warn about default return values, or explicit
9940      return values which do not match prescribed defaults.  */
9941   special_function_kind sfk = sfk_none;
9942
9943   tree dname = NULL_TREE;
9944   tree ctype = current_class_type;
9945   tree ctor_return_type = NULL_TREE;
9946   enum overload_flags flags = NO_SPECIAL;
9947   tree quals = NULL_TREE;
9948   tree raises = NULL_TREE;
9949   int template_count = 0;
9950   tree in_namespace = NULL_TREE;
9951   tree returned_attrs = NULL_TREE;
9952   tree scope = NULL_TREE;
9953
9954   RIDBIT_RESET_ALL (specbits);
9955   if (decl_context == FUNCDEF)
9956     funcdef_flag = 1, decl_context = NORMAL;
9957   else if (decl_context == MEMFUNCDEF)
9958     funcdef_flag = -1, decl_context = FIELD;
9959   else if (decl_context == BITFIELD)
9960     bitfield = 1, decl_context = FIELD;
9961
9962   /* Look inside a declarator for the name being declared
9963      and get it as a string, for an error message.  */
9964   {
9965     tree *next = &declarator;
9966     register tree decl;
9967     name = NULL;
9968
9969     while (next && *next)
9970       {
9971         decl = *next;
9972         switch (TREE_CODE (decl))
9973           {
9974           case TREE_LIST:
9975             /* For attributes.  */
9976             next = &TREE_VALUE (decl);
9977             break;
9978
9979           case COND_EXPR:
9980             ctype = NULL_TREE;
9981             next = &TREE_OPERAND (decl, 0);
9982             break;
9983
9984           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9985             {
9986               tree name = TREE_OPERAND (decl, 0);
9987               tree rename = NULL_TREE;
9988
9989               my_friendly_assert (flags == NO_SPECIAL, 152);
9990               flags = DTOR_FLAG;
9991               sfk = sfk_destructor;
9992               if (TYPE_P (name))
9993                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9994               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9995               if (ctype == NULL_TREE)
9996                 {
9997                   if (current_class_type == NULL_TREE)
9998                     {
9999                       error ("destructors must be member functions");
10000                       flags = NO_SPECIAL;
10001                     }
10002                   else
10003                     {
10004                       tree t = constructor_name (current_class_type);
10005                       if (t != name)
10006                         rename = t;
10007                     }
10008                 }
10009               else
10010                 {
10011                   tree t = constructor_name (ctype);
10012                   if (t != name)
10013                     rename = t;
10014                 }
10015
10016               if (rename)
10017                 {
10018                   error ("destructor `%T' must match class name `%T'",
10019                             name, rename);
10020                   TREE_OPERAND (decl, 0) = rename;
10021                 }
10022               next = &name;
10023             }
10024             break;
10025
10026           case ADDR_EXPR:       /* C++ reference declaration */
10027             /* Fall through.  */
10028           case ARRAY_REF:
10029           case INDIRECT_REF:
10030             ctype = NULL_TREE;
10031             innermost_code = TREE_CODE (decl);
10032             next = &TREE_OPERAND (decl, 0);
10033             break;
10034
10035           case CALL_EXPR:
10036             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
10037               {
10038                 /* This is actually a variable declaration using
10039                    constructor syntax.  We need to call start_decl and
10040                    cp_finish_decl so we can get the variable
10041                    initialized...  */
10042
10043                 tree attributes;
10044
10045                 if (decl_context != NORMAL)
10046                   {
10047                     error ("variable declaration is not allowed here");
10048                     return error_mark_node;
10049                   }
10050
10051                 *next = TREE_OPERAND (decl, 0);
10052                 init = CALL_DECLARATOR_PARMS (decl);
10053
10054                 if (attrlist)
10055                   {
10056                     attributes = *attrlist;
10057                   }
10058                 else
10059                   {
10060                     attributes = NULL_TREE;
10061                   }
10062
10063                 decl = start_decl (declarator, declspecs, 1,
10064                                    attributes, NULL_TREE);
10065                 decl_type_access_control (decl);
10066                 if (decl)
10067                   {
10068                     /* Look for __unused__ attribute */
10069                     if (TREE_USED (TREE_TYPE (decl)))
10070                       TREE_USED (decl) = 1;
10071                     finish_decl (decl, init, NULL_TREE);
10072                   }
10073                 else
10074                   error ("invalid declarator");
10075                 return NULL_TREE;
10076               }
10077             innermost_code = TREE_CODE (decl);
10078             if (decl_context == FIELD && ctype == NULL_TREE)
10079               ctype = current_class_type;
10080             if (ctype
10081                 && TREE_OPERAND (decl, 0)
10082                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
10083                     && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
10084                                            ctype)))
10085               TREE_OPERAND (decl, 0) = constructor_name (ctype);
10086             next = &TREE_OPERAND (decl, 0);
10087             decl = *next;
10088             if (ctype != NULL_TREE
10089                 && decl != NULL_TREE && flags != DTOR_FLAG
10090                 && constructor_name_p (decl, ctype))
10091               {
10092                 sfk = sfk_constructor;
10093                 ctor_return_type = ctype;
10094               }
10095             ctype = NULL_TREE;
10096             break;
10097
10098           case TEMPLATE_ID_EXPR:
10099               {
10100                 tree fns = TREE_OPERAND (decl, 0);
10101
10102                 if (TREE_CODE (fns) == LOOKUP_EXPR)
10103                   fns = TREE_OPERAND (fns, 0);
10104
10105                 dname = fns;
10106                 if (TREE_CODE (dname) == COMPONENT_REF)
10107                   dname = TREE_OPERAND (dname, 1);
10108                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
10109                   {
10110                     my_friendly_assert (is_overloaded_fn (dname),
10111                                         19990331);
10112                     dname = DECL_NAME (get_first_fn (dname));
10113                   }
10114               }
10115           /* Fall through.  */
10116
10117           case IDENTIFIER_NODE:
10118             if (TREE_CODE (decl) == IDENTIFIER_NODE)
10119               dname = decl;
10120
10121             next = 0;
10122
10123             if (C_IS_RESERVED_WORD (dname))
10124               {
10125                 error ("declarator-id missing; using reserved word `%D'",
10126                           dname);
10127                 name = IDENTIFIER_POINTER (dname);
10128               }
10129             else if (!IDENTIFIER_TYPENAME_P (dname))
10130               name = IDENTIFIER_POINTER (dname);
10131             else
10132               {
10133                 my_friendly_assert (flags == NO_SPECIAL, 154);
10134                 flags = TYPENAME_FLAG;
10135                 ctor_return_type = TREE_TYPE (dname);
10136                 sfk = sfk_conversion;
10137                 if (IDENTIFIER_GLOBAL_VALUE (dname)
10138                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
10139                         == TYPE_DECL))
10140                   name = IDENTIFIER_POINTER (dname);
10141                 else
10142                   name = "<invalid operator>";
10143               }
10144             break;
10145
10146             /* C++ extension */
10147           case SCOPE_REF:
10148             {
10149               /* Perform error checking, and decide on a ctype.  */
10150               tree cname = TREE_OPERAND (decl, 0);
10151               if (cname == NULL_TREE)
10152                 ctype = NULL_TREE;
10153               else if (TREE_CODE (cname) == NAMESPACE_DECL)
10154                 {
10155                   ctype = NULL_TREE;
10156                   in_namespace = TREE_OPERAND (decl, 0);
10157                 }
10158               else if (! is_aggr_type (cname, 1))
10159                 ctype = NULL_TREE;
10160               /* Must test TREE_OPERAND (decl, 1), in case user gives
10161                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
10162               else if (TREE_OPERAND (decl, 1)
10163                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
10164                 ctype = cname;
10165               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
10166                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
10167                 {
10168                   /* This might be declaring a member of a template
10169                      parm to be a friend.  */
10170                   ctype = cname;
10171                   dependant_name = TREE_OPERAND (decl, 1);
10172                 }
10173               else if (ctype == NULL_TREE)
10174                 ctype = cname;
10175               else if (TREE_COMPLEXITY (decl) == current_class_depth)
10176                 ;
10177               else
10178                 {
10179                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
10180                     {
10181                       error ("type `%T' is not derived from type `%T'",
10182                                 cname, ctype);
10183                       ctype = NULL_TREE;
10184                     }
10185                   else
10186                     ctype = cname;
10187                 }
10188
10189               /* It is valid to write:
10190
10191                    class C { void f(); };
10192                    typedef C D;
10193                    void D::f();
10194
10195                  The standard is not clear about whether `typedef const C D' is
10196                  legal; as of 2002-09-15 the committee is considering
10197                  that question.  EDG 3.0 allows that syntax.
10198                  Therefore, we do as well.  */
10199               if (ctype)
10200                 ctype = TYPE_MAIN_VARIANT (ctype);
10201               /* Update the declarator so that when we process it
10202                  again the correct type is present.  */
10203               TREE_OPERAND (decl, 0) = ctype;
10204
10205               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
10206                   && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
10207                                          ctype))
10208                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
10209               next = &TREE_OPERAND (decl, 1);
10210               decl = *next;
10211               if (ctype)
10212                 {
10213                   if (TREE_CODE (decl) == IDENTIFIER_NODE
10214                       && constructor_name_p (decl, ctype))
10215                     {
10216                       sfk = sfk_constructor;
10217                       ctor_return_type = ctype;
10218                     }
10219                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
10220                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
10221                            && constructor_name_p (TREE_OPERAND (decl, 0),
10222                                                   ctype))
10223                     {
10224                       sfk = sfk_destructor;
10225                       ctor_return_type = ctype;
10226                       flags = DTOR_FLAG;
10227                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
10228                       next = &TREE_OPERAND (decl, 0);
10229                     }
10230                 }
10231             }
10232             break;
10233
10234           case ERROR_MARK:
10235             next = 0;
10236             break;
10237
10238           case TYPE_DECL:
10239             /* Parse error puts this typespec where
10240                a declarator should go.  */
10241             error ("`%T' specified as declarator-id", DECL_NAME (decl));
10242             if (TREE_TYPE (decl) == current_class_type)
10243               error ("  perhaps you want `%T' for a constructor",
10244                         current_class_name);
10245             dname = DECL_NAME (decl);
10246             name = IDENTIFIER_POINTER (dname);
10247
10248             /* Avoid giving two errors for this.  */
10249             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10250
10251             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10252             *next = dname;
10253             next = 0;
10254             break;
10255
10256           case BASELINK:
10257             next = &BASELINK_FUNCTIONS (decl);
10258             break;
10259
10260           case TEMPLATE_DECL:
10261             /* Sometimes, we see a template-name used as part of a
10262                decl-specifier like in
10263                   std::allocator alloc;
10264                Handle that gracefully.  */
10265             error ("invalid use of template-name '%E' in a declarator", decl);
10266             return error_mark_node;
10267             break;
10268
10269           default:
10270             my_friendly_assert (0, 20020917);
10271           }
10272       }
10273   }
10274
10275   /* A function definition's declarator must have the form of
10276      a function declarator.  */
10277
10278   if (funcdef_flag && innermost_code != CALL_EXPR)
10279     return 0;
10280
10281   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10282       && innermost_code != CALL_EXPR
10283       && ! (ctype && declspecs == NULL_TREE))
10284     {
10285       error ("declaration of `%D' as non-function", dname);
10286       return void_type_node;
10287     }
10288
10289   /* Anything declared one level down from the top level
10290      must be one of the parameters of a function
10291      (because the body is at least two levels down).  */
10292
10293   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10294      by not allowing C++ class definitions to specify their parameters
10295      with xdecls (must be spec.d in the parmlist).
10296
10297      Since we now wait to push a class scope until we are sure that
10298      we are in a legitimate method context, we must set oldcname
10299      explicitly (since current_class_name is not yet alive).
10300
10301      We also want to avoid calling this a PARM if it is in a namespace.  */
10302
10303   if (decl_context == NORMAL && !toplevel_bindings_p ())
10304     {
10305       struct cp_binding_level *b = current_binding_level;
10306       current_binding_level = b->level_chain;
10307       if (current_binding_level != 0 && toplevel_bindings_p ())
10308         decl_context = PARM;
10309       current_binding_level = b;
10310     }
10311
10312   if (name == NULL)
10313     name = decl_context == PARM ? "parameter" : "type name";
10314
10315   /* Look through the decl specs and record which ones appear.
10316      Some typespecs are defined as built-in typenames.
10317      Others, the ones that are modifiers of other types,
10318      are represented by bits in SPECBITS: set the bits for
10319      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10320
10321      If there is a typedef name or a type, store the type in TYPE.
10322      This includes builtin typedefs such as `int'.
10323
10324      Set EXPLICIT_INT if the type is `int' or `char' and did not
10325      come from a user typedef.
10326
10327      Set LONGLONG if `long' is mentioned twice.
10328
10329      For C++, constructors and destructors have their own fast treatment.  */
10330
10331   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10332     {
10333       register int i;
10334       register tree id;
10335
10336       /* Certain parse errors slip through.  For example,
10337          `int class;' is not caught by the parser. Try
10338          weakly to recover here.  */
10339       if (TREE_CODE (spec) != TREE_LIST)
10340         return 0;
10341
10342       id = TREE_VALUE (spec);
10343
10344       /* If the entire declaration is itself tagged as deprecated then
10345          suppress reports of deprecated items.  */
10346       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10347         {
10348           if (deprecated_state != DEPRECATED_SUPPRESS)
10349             warn_deprecated_use (id);
10350         }
10351
10352       if (TREE_CODE (id) == IDENTIFIER_NODE)
10353         {
10354           if (id == ridpointers[(int) RID_INT]
10355               || id == ridpointers[(int) RID_CHAR]
10356               || id == ridpointers[(int) RID_BOOL]
10357               || id == ridpointers[(int) RID_WCHAR])
10358             {
10359               if (type)
10360                 {
10361                   if (id == ridpointers[(int) RID_BOOL])
10362                     error ("`bool' is now a keyword");
10363                   else
10364                     error ("extraneous `%T' ignored", id);
10365                 }
10366               else
10367                 {
10368                   if (id == ridpointers[(int) RID_INT])
10369                     explicit_int = 1;
10370                   else if (id == ridpointers[(int) RID_CHAR])
10371                     explicit_char = 1;
10372                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10373                 }
10374               goto found;
10375             }
10376           /* C++ aggregate types.  */
10377           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10378             {
10379               if (type)
10380                 error ("multiple declarations `%T' and `%T'", type, id);
10381               else
10382                 type = IDENTIFIER_TYPE_VALUE (id);
10383               goto found;
10384             }
10385
10386           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10387             {
10388               if (ridpointers[i] == id)
10389                 {
10390                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10391                     {
10392                       if (pedantic && ! in_system_header && warn_long_long)
10393                         pedwarn ("ISO C++ does not support `long long'");
10394                       if (longlong)
10395                         error ("`long long long' is too long for GCC");
10396                       else
10397                         longlong = 1;
10398                     }
10399                   else if (RIDBIT_SETP (i, specbits))
10400                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10401
10402                   /* Diagnose "__thread extern" or "__thread static".  */
10403                   if (RIDBIT_SETP (RID_THREAD, specbits))
10404                     {
10405                       if (i == (int)RID_EXTERN)
10406                         error ("`__thread' before `extern'");
10407                       else if (i == (int)RID_STATIC)
10408                         error ("`__thread' before `static'");
10409                     }
10410
10411                   if (i == (int)RID_EXTERN
10412                       && TREE_PURPOSE (spec) == error_mark_node)
10413                     /* This extern was part of a language linkage.  */
10414                     extern_langp = 1;
10415
10416                   RIDBIT_SET (i, specbits);
10417                   goto found;
10418                 }
10419             }
10420         }
10421       else if (TREE_CODE (id) == TYPE_DECL)
10422         {
10423           if (type)
10424             error ("multiple declarations `%T' and `%T'", type,
10425                       TREE_TYPE (id));
10426           else
10427             {
10428               type = TREE_TYPE (id);
10429               TREE_VALUE (spec) = type;
10430               typedef_decl = id;
10431             }
10432           goto found;
10433         }
10434       if (type)
10435         error ("two or more data types in declaration of `%s'", name);
10436       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10437         {
10438           register tree t = lookup_name (id, 1);
10439           if (!t || TREE_CODE (t) != TYPE_DECL)
10440             error ("`%s' fails to be a typedef or built in type",
10441                    IDENTIFIER_POINTER (id));
10442           else
10443             {
10444               type = TREE_TYPE (t);
10445               typedef_decl = t;
10446             }
10447         }
10448       else if (id != error_mark_node)
10449         /* Can't change CLASS nodes into RECORD nodes here!  */
10450         type = id;
10451
10452     found: ;
10453     }
10454
10455 #if 0
10456   /* See the code below that used this.  */
10457   if (typedef_decl)
10458     decl_attr = DECL_ATTRIBUTES (typedef_decl);
10459 #endif
10460   typedef_type = type;
10461
10462   /* No type at all: default to `int', and set DEFAULTED_INT
10463      because it was not a user-defined typedef.  */
10464
10465   if (type == NULL_TREE
10466       && (RIDBIT_SETP (RID_SIGNED, specbits)
10467           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10468           || RIDBIT_SETP (RID_LONG, specbits)
10469           || RIDBIT_SETP (RID_SHORT, specbits)))
10470     {
10471       /* These imply 'int'.  */
10472       type = integer_type_node;
10473       defaulted_int = 1;
10474     }
10475
10476   if (sfk != sfk_none)
10477     type = check_special_function_return_type (sfk, type,
10478                                                ctor_return_type);
10479   else if (type == NULL_TREE)
10480     {
10481       int is_main;
10482
10483       explicit_int = -1;
10484
10485       /* We handle `main' specially here, because 'main () { }' is so
10486          common.  With no options, it is allowed.  With -Wreturn-type,
10487          it is a warning.  It is only an error with -pedantic-errors.  */
10488       is_main = (funcdef_flag
10489                  && dname && MAIN_NAME_P (dname)
10490                  && ctype == NULL_TREE
10491                  && in_namespace == NULL_TREE
10492                  && current_namespace == global_namespace);
10493
10494       if (in_system_header || flag_ms_extensions)
10495         /* Allow it, sigh.  */;
10496       else if (pedantic || ! is_main)
10497         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10498                     name);
10499       else if (warn_return_type)
10500         warning ("ISO C++ forbids declaration of `%s' with no type",
10501                     name);
10502
10503       type = integer_type_node;
10504     }
10505
10506   if (type && IMPLICIT_TYPENAME_P (type))
10507     {
10508       /* The implicit typename extension is deprecated and will be
10509          removed.  Warn about its use now.  */
10510       warning ("`%T' is implicitly a typename", type);
10511       cp_deprecated ("implicit typename");
10512
10513       /* Now remove its implicitness, so that we don't warn again.
10514          For instance this might be a typedef, and we do not want to
10515          warn on uses of the typedef itself.  Simply clearing the
10516          TREE_TYPE is insufficient.  */
10517       type = copy_node (type);
10518       TREE_TYPE (type) = NULL_TREE;
10519     }
10520
10521   ctype = NULL_TREE;
10522
10523   /* Now process the modifiers that were specified
10524      and check for invalid combinations.  */
10525
10526   /* Long double is a special combination.  */
10527
10528   if (RIDBIT_SETP (RID_LONG, specbits)
10529       && TYPE_MAIN_VARIANT (type) == double_type_node)
10530     {
10531       RIDBIT_RESET (RID_LONG, specbits);
10532       type = build_qualified_type (long_double_type_node,
10533                                    cp_type_quals (type));
10534     }
10535
10536   /* Check all other uses of type modifiers.  */
10537
10538   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10539       || RIDBIT_SETP (RID_SIGNED, specbits)
10540       || RIDBIT_SETP (RID_LONG, specbits)
10541       || RIDBIT_SETP (RID_SHORT, specbits))
10542     {
10543       int ok = 0;
10544
10545       if (TREE_CODE (type) == REAL_TYPE)
10546         error ("short, signed or unsigned invalid for `%s'", name);
10547       else if (TREE_CODE (type) != INTEGER_TYPE)
10548         error ("long, short, signed or unsigned invalid for `%s'", name);
10549       else if (RIDBIT_SETP (RID_LONG, specbits)
10550                && RIDBIT_SETP (RID_SHORT, specbits))
10551         error ("long and short specified together for `%s'", name);
10552       else if ((RIDBIT_SETP (RID_LONG, specbits)
10553                 || RIDBIT_SETP (RID_SHORT, specbits))
10554                && explicit_char)
10555         error ("long or short specified with char for `%s'", name);
10556       else if ((RIDBIT_SETP (RID_LONG, specbits)
10557                 || RIDBIT_SETP (RID_SHORT, specbits))
10558                && TREE_CODE (type) == REAL_TYPE)
10559         error ("long or short specified with floating type for `%s'", name);
10560       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10561                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10562         error ("signed and unsigned given together for `%s'", name);
10563       else
10564         {
10565           ok = 1;
10566           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10567             {
10568               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10569                        name);
10570               if (flag_pedantic_errors)
10571                 ok = 0;
10572             }
10573         }
10574
10575       /* Discard the type modifiers if they are invalid.  */
10576       if (! ok)
10577         {
10578           RIDBIT_RESET (RID_UNSIGNED, specbits);
10579           RIDBIT_RESET (RID_SIGNED, specbits);
10580           RIDBIT_RESET (RID_LONG, specbits);
10581           RIDBIT_RESET (RID_SHORT, specbits);
10582           longlong = 0;
10583         }
10584     }
10585
10586   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10587       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10588     {
10589       error ("complex invalid for `%s'", name);
10590       RIDBIT_RESET (RID_COMPLEX, specbits);
10591     }
10592
10593   /* Decide whether an integer type is signed or not.
10594      Optionally treat bitfields as signed by default.  */
10595   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10596       /* [class.bit]
10597
10598          It is implementation-defined whether a plain (neither
10599          explicitly signed or unsigned) char, short, int, or long
10600          bit-field is signed or unsigned.
10601
10602          Naturally, we extend this to long long as well.  Note that
10603          this does not include wchar_t.  */
10604       || (bitfield && !flag_signed_bitfields
10605           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10606           /* A typedef for plain `int' without `signed' can be
10607              controlled just like plain `int', but a typedef for
10608              `signed int' cannot be so controlled.  */
10609           && !(typedef_decl
10610                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10611           && (TREE_CODE (type) == INTEGER_TYPE
10612               || TREE_CODE (type) == CHAR_TYPE)
10613           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10614     {
10615       if (longlong)
10616         type = long_long_unsigned_type_node;
10617       else if (RIDBIT_SETP (RID_LONG, specbits))
10618         type = long_unsigned_type_node;
10619       else if (RIDBIT_SETP (RID_SHORT, specbits))
10620         type = short_unsigned_type_node;
10621       else if (type == char_type_node)
10622         type = unsigned_char_type_node;
10623       else if (typedef_decl)
10624         type = c_common_unsigned_type (type);
10625       else
10626         type = unsigned_type_node;
10627     }
10628   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10629            && type == char_type_node)
10630     type = signed_char_type_node;
10631   else if (longlong)
10632     type = long_long_integer_type_node;
10633   else if (RIDBIT_SETP (RID_LONG, specbits))
10634     type = long_integer_type_node;
10635   else if (RIDBIT_SETP (RID_SHORT, specbits))
10636     type = short_integer_type_node;
10637
10638   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10639     {
10640       /* If we just have "complex", it is equivalent to
10641          "complex double", but if any modifiers at all are specified it is
10642          the complex form of TYPE.  E.g, "complex short" is
10643          "complex short int".  */
10644
10645       if (defaulted_int && ! longlong
10646           && ! (RIDBIT_SETP (RID_LONG, specbits)
10647                 || RIDBIT_SETP (RID_SHORT, specbits)
10648                 || RIDBIT_SETP (RID_SIGNED, specbits)
10649                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10650         type = complex_double_type_node;
10651       else if (type == integer_type_node)
10652         type = complex_integer_type_node;
10653       else if (type == float_type_node)
10654         type = complex_float_type_node;
10655       else if (type == double_type_node)
10656         type = complex_double_type_node;
10657       else if (type == long_double_type_node)
10658         type = complex_long_double_type_node;
10659       else
10660         type = build_complex_type (type);
10661     }
10662
10663   type_quals = TYPE_UNQUALIFIED;
10664   if (RIDBIT_SETP (RID_CONST, specbits))
10665     type_quals |= TYPE_QUAL_CONST;
10666   if (RIDBIT_SETP (RID_VOLATILE, specbits))
10667     type_quals |= TYPE_QUAL_VOLATILE;
10668   if (RIDBIT_SETP (RID_RESTRICT, specbits))
10669     type_quals |= TYPE_QUAL_RESTRICT;
10670   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10671     error ("qualifiers are not allowed on declaration of `operator %T'",
10672               ctor_return_type);
10673
10674   type_quals |= cp_type_quals (type);
10675   type = cp_build_qualified_type_real
10676     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10677                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10678   /* We might have ignored or rejected some of the qualifiers.  */
10679   type_quals = cp_type_quals (type);
10680
10681   staticp = 0;
10682   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10683   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10684   RIDBIT_RESET (RID_VIRTUAL, specbits);
10685   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10686   RIDBIT_RESET (RID_EXPLICIT, specbits);
10687
10688   if (RIDBIT_SETP (RID_STATIC, specbits))
10689     staticp = 1 + (decl_context == FIELD);
10690
10691   if (virtualp && staticp == 2)
10692     {
10693       error ("member `%D' cannot be declared both virtual and static",
10694                 dname);
10695       staticp = 0;
10696     }
10697   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10698   RIDBIT_RESET (RID_FRIEND, specbits);
10699
10700   if (dependant_name && !friendp)
10701     {
10702       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10703       return void_type_node;
10704     }
10705
10706   /* Warn if two storage classes are given. Default to `auto'.  */
10707
10708   if (RIDBIT_ANY_SET (specbits))
10709     {
10710       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10711       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10712       if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
10713       if (decl_context == PARM && nclasses > 0)
10714         error ("storage class specifiers invalid in parameter declarations");
10715       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10716         {
10717           if (decl_context == PARM)
10718             error ("typedef declaration invalid in parameter declaration");
10719           nclasses++;
10720         }
10721       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10722       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10723       if (!nclasses && !friendp && extern_langp)
10724         nclasses++;
10725     }
10726
10727   /* Give error if `virtual' is used outside of class declaration.  */
10728   if (virtualp
10729       && (current_class_name == NULL_TREE || decl_context != FIELD))
10730     {
10731       error ("virtual outside class declaration");
10732       virtualp = 0;
10733     }
10734
10735   /* Static anonymous unions are dealt with here.  */
10736   if (staticp && decl_context == TYPENAME
10737       && TREE_CODE (declspecs) == TREE_LIST
10738       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10739     decl_context = FIELD;
10740
10741   /* Warn about storage classes that are invalid for certain
10742      kinds of declarations (parameters, typenames, etc.).  */
10743
10744   /* "static __thread" and "extern __thread" are allowed.  */
10745   if (nclasses == 2
10746       && RIDBIT_SETP (RID_THREAD, specbits)
10747       && (RIDBIT_SETP (RID_EXTERN, specbits)
10748           || RIDBIT_SETP (RID_STATIC, specbits)))
10749     nclasses = 1;
10750
10751   if (nclasses > 1)
10752     error ("multiple storage classes in declaration of `%s'", name);
10753   else if (decl_context != NORMAL && nclasses > 0)
10754     {
10755       if ((decl_context == PARM || decl_context == CATCHPARM)
10756           && (RIDBIT_SETP (RID_REGISTER, specbits)
10757               || RIDBIT_SETP (RID_AUTO, specbits)))
10758         ;
10759       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10760         ;
10761       else if (decl_context == FIELD
10762                /* C++ allows static class elements  */
10763                && RIDBIT_SETP (RID_STATIC, specbits))
10764         /* C++ also allows inlines and signed and unsigned elements,
10765            but in those cases we don't come in here.  */
10766         ;
10767       else
10768         {
10769           if (decl_context == FIELD)
10770             {
10771               tree tmp = NULL_TREE;
10772               register int op = 0;
10773
10774               if (declarator)
10775                 {
10776                   /* Avoid trying to get an operand off an identifier node.  */
10777                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10778                     tmp = declarator;
10779                   else
10780                     tmp = TREE_OPERAND (declarator, 0);
10781                   op = IDENTIFIER_OPNAME_P (tmp);
10782                   if (IDENTIFIER_TYPENAME_P (tmp))
10783                     {
10784                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10785                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10786                               == TYPE_DECL))
10787                         name = IDENTIFIER_POINTER (tmp);
10788                       else
10789                         name = "<invalid operator>";
10790                     }
10791                 }
10792               error ("storage class specified for %s `%s'",
10793                      op ? "member operator" : "field",
10794                      name);
10795             }
10796           else
10797             {
10798               if (decl_context == PARM || decl_context == CATCHPARM)
10799                 error ("storage class specified for parameter `%s'", name);
10800               else
10801                 error ("storage class specified for typename");
10802             }
10803           RIDBIT_RESET (RID_REGISTER, specbits);
10804           RIDBIT_RESET (RID_AUTO, specbits);
10805           RIDBIT_RESET (RID_EXTERN, specbits);
10806           RIDBIT_RESET (RID_THREAD, specbits);
10807         }
10808     }
10809   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10810     {
10811       if (toplevel_bindings_p ())
10812         {
10813           /* It's common practice (and completely valid) to have a const
10814              be initialized and declared extern.  */
10815           if (!(type_quals & TYPE_QUAL_CONST))
10816             warning ("`%s' initialized and declared `extern'", name);
10817         }
10818       else
10819         error ("`%s' has both `extern' and initializer", name);
10820     }
10821   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10822            && ! toplevel_bindings_p ())
10823     error ("nested function `%s' declared `extern'", name);
10824   else if (toplevel_bindings_p ())
10825     {
10826       if (RIDBIT_SETP (RID_AUTO, specbits))
10827         error ("top-level declaration of `%s' specifies `auto'", name);
10828     }
10829   else if (RIDBIT_SETP (RID_THREAD, specbits)
10830            && !RIDBIT_SETP (RID_EXTERN, specbits)
10831            && !RIDBIT_SETP (RID_STATIC, specbits))
10832     {
10833       error ("function-scope `%s' implicitly auto and declared `__thread'",
10834              name);
10835       RIDBIT_RESET (RID_THREAD, specbits);
10836     }
10837
10838   if (nclasses > 0 && friendp)
10839     error ("storage class specifiers invalid in friend function declarations");
10840
10841   scope = get_scope_of_declarator (declarator);
10842
10843   /* Now figure out the structure of the declarator proper.
10844      Descend through it, creating more complex types, until we reach
10845      the declared identifier (or NULL_TREE, in an abstract declarator).  */
10846
10847   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10848          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10849     {
10850       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10851          an INDIRECT_REF (for *...),
10852          a CALL_EXPR (for ...(...)),
10853          an identifier (for the name being declared)
10854          or a null pointer (for the place in an absolute declarator
10855          where the name was omitted).
10856          For the last two cases, we have just exited the loop.
10857
10858          For C++ it could also be
10859          a SCOPE_REF (for class :: ...).  In this case, we have converted
10860          sensible names to types, and those are the values we use to
10861          qualify the member name.
10862          an ADDR_EXPR (for &...),
10863          a BIT_NOT_EXPR (for destructors)
10864
10865          At this point, TYPE is the type of elements of an array,
10866          or for a function to return, or for a pointer to point to.
10867          After this sequence of ifs, TYPE is the type of the
10868          array or function or pointer, and DECLARATOR has had its
10869          outermost layer removed.  */
10870
10871       if (type == error_mark_node)
10872         {
10873           if (TREE_CODE (declarator) == SCOPE_REF)
10874             declarator = TREE_OPERAND (declarator, 1);
10875           else
10876             declarator = TREE_OPERAND (declarator, 0);
10877           continue;
10878         }
10879       if (quals != NULL_TREE
10880           && (declarator == NULL_TREE
10881               || TREE_CODE (declarator) != SCOPE_REF))
10882         {
10883           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10884             ctype = TYPE_METHOD_BASETYPE (type);
10885           if (ctype != NULL_TREE)
10886             {
10887               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10888               grok_method_quals (ctype, dummy, quals);
10889               type = TREE_TYPE (dummy);
10890               quals = NULL_TREE;
10891             }
10892         }
10893
10894       switch (TREE_CODE (declarator))
10895         {
10896         case TREE_LIST:
10897           {
10898             /* We encode a declarator with embedded attributes using
10899                a TREE_LIST.  */
10900             tree attrs = TREE_PURPOSE (declarator);
10901             tree inner_decl;
10902             int attr_flags;
10903
10904             declarator = TREE_VALUE (declarator);
10905             inner_decl = declarator;
10906             while (inner_decl != NULL_TREE
10907                    && TREE_CODE (inner_decl) == TREE_LIST)
10908               inner_decl = TREE_VALUE (inner_decl);
10909             attr_flags = 0;
10910             if (inner_decl == NULL_TREE
10911                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10912               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10913             if (TREE_CODE (inner_decl) == CALL_EXPR)
10914               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10915             if (TREE_CODE (inner_decl) == ARRAY_REF)
10916               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10917             returned_attrs = decl_attributes (&type,
10918                                               chainon (returned_attrs, attrs),
10919                                               attr_flags);
10920           }
10921           break;
10922
10923         case ARRAY_REF:
10924           {
10925             register tree size;
10926
10927             size = TREE_OPERAND (declarator, 1);
10928
10929             /* VC++ spells a zero-sized array with [].  */
10930             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10931                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10932               size = integer_zero_node;
10933
10934             declarator = TREE_OPERAND (declarator, 0);
10935
10936             type = create_array_type_for_decl (dname, type, size);
10937
10938             ctype = NULL_TREE;
10939           }
10940           break;
10941
10942         case CALL_EXPR:
10943           {
10944             tree arg_types;
10945             int funcdecl_p;
10946             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10947             tree inner_decl = TREE_OPERAND (declarator, 0);
10948
10949             /* Declaring a function type.
10950                Make sure we have a valid type for the function to return.  */
10951
10952             /* We now know that the TYPE_QUALS don't apply to the
10953                decl, but to its return type.  */
10954             type_quals = TYPE_UNQUALIFIED;
10955
10956             /* Warn about some types functions can't return.  */
10957
10958             if (TREE_CODE (type) == FUNCTION_TYPE)
10959               {
10960                 error ("`%s' declared as function returning a function", name);
10961                 type = integer_type_node;
10962               }
10963             if (TREE_CODE (type) == ARRAY_TYPE)
10964               {
10965                 error ("`%s' declared as function returning an array", name);
10966                 type = integer_type_node;
10967               }
10968
10969             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10970               inner_decl = TREE_OPERAND (inner_decl, 1);
10971
10972             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10973               inner_decl = dname;
10974
10975             /* Pick up type qualifiers which should be applied to `this'.  */
10976             quals = CALL_DECLARATOR_QUALS (declarator);
10977
10978             /* Pick up the exception specifications.  */
10979             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10980
10981             /* Say it's a definition only for the CALL_EXPR
10982                closest to the identifier.  */
10983             funcdecl_p
10984               = inner_decl
10985               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10986                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10987                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10988
10989             if (ctype == NULL_TREE
10990                 && decl_context == FIELD
10991                 && funcdecl_p
10992                 && (friendp == 0 || dname == current_class_name))
10993               ctype = current_class_type;
10994
10995             if (ctype && sfk == sfk_conversion)
10996               TYPE_HAS_CONVERSION (ctype) = 1;
10997             if (ctype && constructor_name_p (dname, ctype))
10998               {
10999                 /* We are within a class's scope. If our declarator name
11000                    is the same as the class name, and we are defining
11001                    a function, then it is a constructor/destructor, and
11002                    therefore returns a void type.  */
11003
11004                 if (flags == DTOR_FLAG)
11005                   {
11006                     /* ISO C++ 12.4/2.  A destructor may not be
11007                        declared const or volatile.  A destructor may
11008                        not be static.  */
11009                     if (staticp == 2)
11010                       error ("destructor cannot be static member function");
11011                     if (quals)
11012                       {
11013                         error ("destructors may not be `%s'",
11014                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
11015                         quals = NULL_TREE;
11016                       }
11017                     if (decl_context == FIELD)
11018                       {
11019                         if (! member_function_or_else (ctype,
11020                                                        current_class_type,
11021                                                        flags))
11022                           return void_type_node;
11023                       }
11024                   }
11025                 else            /* It's a constructor.  */
11026                   {
11027                     if (explicitp == 1)
11028                       explicitp = 2;
11029                     /* ISO C++ 12.1.  A constructor may not be
11030                        declared const or volatile.  A constructor may
11031                        not be virtual.  A constructor may not be
11032                        static.  */
11033                     if (staticp == 2)
11034                       error ("constructor cannot be static member function");
11035                     if (virtualp)
11036                       {
11037                         pedwarn ("constructors cannot be declared virtual");
11038                         virtualp = 0;
11039                       }
11040                     if (quals)
11041                       {
11042                         error ("constructors may not be `%s'",
11043                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
11044                         quals = NULL_TREE;
11045                       }
11046                     {
11047                       RID_BIT_TYPE tmp_bits;
11048                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
11049                       RIDBIT_RESET (RID_INLINE, tmp_bits);
11050                       RIDBIT_RESET (RID_STATIC, tmp_bits);
11051                       if (RIDBIT_ANY_SET (tmp_bits))
11052                         error ("return value type specifier for constructor ignored");
11053                     }
11054                     if (decl_context == FIELD)
11055                       {
11056                         if (! member_function_or_else (ctype,
11057                                                        current_class_type,
11058                                                        flags))
11059                           return void_type_node;
11060                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
11061                         if (sfk != sfk_constructor)
11062                           return NULL_TREE;
11063                       }
11064                   }
11065                 if (decl_context == FIELD)
11066                   staticp = 0;
11067               }
11068             else if (friendp)
11069               {
11070                 if (initialized)
11071                   error ("can't initialize friend function `%s'", name);
11072                 if (virtualp)
11073                   {
11074                     /* Cannot be both friend and virtual.  */
11075                     error ("virtual functions cannot be friends");
11076                     RIDBIT_RESET (RID_FRIEND, specbits);
11077                     friendp = 0;
11078                   }
11079                 if (decl_context == NORMAL)
11080                   error ("friend declaration not in class definition");
11081                 if (current_function_decl && funcdef_flag)
11082                   error ("can't define friend function `%s' in a local class definition",
11083                             name);
11084               }
11085
11086             /* Construct the function type and go to the next
11087                inner layer of declarator.  */
11088
11089             declarator = TREE_OPERAND (declarator, 0);
11090
11091             /* FIXME: This is where default args should be fully
11092                processed.  */
11093
11094             arg_types = grokparms (inner_parms);
11095
11096             if (declarator && flags == DTOR_FLAG)
11097               {
11098                 /* A destructor declared in the body of a class will
11099                    be represented as a BIT_NOT_EXPR.  But, we just
11100                    want the underlying IDENTIFIER.  */
11101                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
11102                   declarator = TREE_OPERAND (declarator, 0);
11103
11104                 if (arg_types != void_list_node)
11105                   {
11106                     error ("destructors may not have parameters");
11107                     arg_types = void_list_node;
11108                     last_function_parms = NULL_TREE;
11109                   }
11110               }
11111
11112             /* ANSI says that `const int foo ();'
11113                does not make the function foo const.  */
11114             type = build_function_type (type, arg_types);
11115           }
11116           break;
11117
11118         case ADDR_EXPR:
11119         case INDIRECT_REF:
11120           /* Filter out pointers-to-references and references-to-references.
11121              We can get these if a TYPE_DECL is used.  */
11122
11123           if (TREE_CODE (type) == REFERENCE_TYPE)
11124             {
11125               error (TREE_CODE (declarator) == ADDR_EXPR
11126                      ? "cannot declare reference to `%#T'"
11127                      : "cannot declare pointer to `%#T'", type);
11128               type = TREE_TYPE (type);
11129             }
11130           else if (VOID_TYPE_P (type)
11131                    && (ctype || TREE_CODE (declarator) == ADDR_EXPR))
11132             error (ctype ? "cannot declare pointer to `%#T' member"
11133                      : "cannot declare reference to `%#T'", type);
11134
11135           /* Merge any constancy or volatility into the target type
11136              for the pointer.  */
11137
11138           /* We now know that the TYPE_QUALS don't apply to the decl,
11139              but to the target of the pointer.  */
11140           type_quals = TYPE_UNQUALIFIED;
11141
11142           if (TREE_CODE (declarator) == ADDR_EXPR)
11143             {
11144               if (!VOID_TYPE_P (type))
11145                 type = build_reference_type (type);
11146             }
11147           else if (TREE_CODE (type) == METHOD_TYPE)
11148             type = build_ptrmemfunc_type (build_pointer_type (type));
11149           else if (ctype)
11150             type = build_ptrmem_type (ctype, type);
11151           else
11152             type = build_pointer_type (type);
11153
11154           /* Process a list of type modifier keywords (such as
11155              const or volatile) that were given inside the `*' or `&'.  */
11156
11157           if (TREE_TYPE (declarator))
11158             {
11159               register tree typemodlist;
11160               int erred = 0;
11161               int constp = 0;
11162               int volatilep = 0;
11163               int restrictp = 0;
11164
11165               for (typemodlist = TREE_TYPE (declarator); typemodlist;
11166                    typemodlist = TREE_CHAIN (typemodlist))
11167                 {
11168                   tree qualifier = TREE_VALUE (typemodlist);
11169
11170                   if (qualifier == ridpointers[(int) RID_CONST])
11171                     {
11172                       constp++;
11173                       type_quals |= TYPE_QUAL_CONST;
11174                     }
11175                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
11176                     {
11177                       volatilep++;
11178                       type_quals |= TYPE_QUAL_VOLATILE;
11179                     }
11180                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
11181                     {
11182                       restrictp++;
11183                       type_quals |= TYPE_QUAL_RESTRICT;
11184                     }
11185                   else if (!erred)
11186                     {
11187                       erred = 1;
11188                       error ("invalid type modifier within pointer declarator");
11189                     }
11190                 }
11191               if (constp > 1)
11192                 pedwarn ("duplicate `const'");
11193               if (volatilep > 1)
11194                 pedwarn ("duplicate `volatile'");
11195               if (restrictp > 1)
11196                 pedwarn ("duplicate `restrict'");
11197               type = cp_build_qualified_type (type, type_quals);
11198               type_quals = cp_type_quals (type);
11199             }
11200           declarator = TREE_OPERAND (declarator, 0);
11201           ctype = NULL_TREE;
11202           break;
11203
11204         case SCOPE_REF:
11205           {
11206             /* We have converted type names to NULL_TREE if the
11207                name was bogus, or to a _TYPE node, if not.
11208
11209                The variable CTYPE holds the type we will ultimately
11210                resolve to.  The code here just needs to build
11211                up appropriate member types.  */
11212             tree sname = TREE_OPERAND (declarator, 1);
11213             tree t;
11214
11215             /* Destructors can have their visibilities changed as well.  */
11216             if (TREE_CODE (sname) == BIT_NOT_EXPR)
11217               sname = TREE_OPERAND (sname, 0);
11218
11219             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11220               {
11221                 /* We had a reference to a global decl, or
11222                    perhaps we were given a non-aggregate typedef,
11223                    in which case we cleared this out, and should just
11224                    keep going as though it wasn't there.  */
11225                 declarator = sname;
11226                 continue;
11227               }
11228             ctype = TREE_OPERAND (declarator, 0);
11229
11230             t = ctype;
11231             while (t != NULL_TREE && CLASS_TYPE_P (t))
11232               {
11233                 /* You're supposed to have one `template <...>'
11234                    for every template class, but you don't need one
11235                    for a full specialization.  For example:
11236
11237                      template <class T> struct S{};
11238                      template <> struct S<int> { void f(); };
11239                      void S<int>::f () {}
11240
11241                    is correct; there shouldn't be a `template <>' for
11242                    the definition of `S<int>::f'.  */
11243                 if (CLASSTYPE_TEMPLATE_INFO (t)
11244                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11245                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11246                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11247                   template_count += 1;
11248
11249                 t = TYPE_MAIN_DECL (t);
11250                 t = DECL_CONTEXT (t);
11251               }
11252
11253             if (sname == NULL_TREE)
11254               goto done_scoping;
11255
11256             if (TREE_CODE (sname) == IDENTIFIER_NODE)
11257               {
11258                 /* This is the `standard' use of the scoping operator:
11259                    basetype :: member .  */
11260
11261                 if (ctype == current_class_type)
11262                   {
11263                     /* class A {
11264                          void A::f ();
11265                        };
11266
11267                        Is this ill-formed?  */
11268
11269                     if (pedantic)
11270                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
11271                                   ctype, name);
11272                   }
11273                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11274                   {
11275                     if (current_class_type == NULL_TREE || friendp)
11276                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11277                                                       TYPE_ARG_TYPES (type));
11278                     else
11279                       {
11280                         error ("cannot declare member function `%T::%s' within `%T'",
11281                                   ctype, name, current_class_type);
11282                         return error_mark_node;
11283                       }
11284                   }
11285                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11286                          || COMPLETE_TYPE_P (complete_type (ctype)))
11287                   {
11288                     /* Have to move this code elsewhere in this function.
11289                        this code is used for i.e., typedef int A::M; M *pm;
11290
11291                        It is?  How? jason 10/2/94 */
11292
11293                     if (current_class_type)
11294                       {
11295                         error ("cannot declare member `%T::%s' within `%T'",
11296                                   ctype, name, current_class_type);
11297                         return void_type_node;
11298                       }
11299                   }
11300                 else
11301                   {
11302                     cxx_incomplete_type_error (NULL_TREE, ctype);
11303                     return error_mark_node;
11304                   }
11305
11306                 declarator = sname;
11307               }
11308             else if (TREE_CODE (sname) == SCOPE_REF)
11309               abort ();
11310             else
11311               {
11312               done_scoping:
11313                 declarator = TREE_OPERAND (declarator, 1);
11314                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11315                   /* In this case, we will deal with it later.  */
11316                   ;
11317                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11318                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11319                                                   TYPE_ARG_TYPES (type));
11320               }
11321           }
11322           break;
11323
11324         case BIT_NOT_EXPR:
11325           declarator = TREE_OPERAND (declarator, 0);
11326           break;
11327
11328         case BASELINK:
11329           declarator = BASELINK_FUNCTIONS (declarator);
11330           break;
11331
11332         case RECORD_TYPE:
11333         case UNION_TYPE:
11334         case ENUMERAL_TYPE:
11335           declarator = NULL_TREE;
11336           break;
11337
11338         case ERROR_MARK:
11339           declarator = NULL_TREE;
11340           break;
11341
11342         default:
11343           abort ();
11344         }
11345     }
11346
11347   if (returned_attrs)
11348     {
11349       if (attrlist)
11350         *attrlist = chainon (returned_attrs, *attrlist);
11351       else
11352         attrlist = &returned_attrs;
11353     }
11354
11355   /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq that refer
11356      to ctype.  They couldn't be resolved earlier because we hadn't
11357      pushed into the class yet.
11358
11359      For example, consider:
11360
11361        template <typename T>
11362        struct S {
11363          typedef T X;
11364          X f();
11365        };
11366
11367        template <typename T>
11368        typename S<T>::X f() {}
11369
11370        When parsing the decl-specifier-seq for the definition of `f',
11371        we construct a TYPENAME_TYPE for `S<T>::X'.  By substituting
11372        here, we resolve it to the correct type.  */
11373   if (scope && CLASS_TYPE_P (scope)
11374       && current_template_parms
11375       && uses_template_parms (scope))
11376     {
11377       tree args = current_template_args ();
11378       push_scope (scope);
11379       type = tsubst (type, args, tf_error | tf_warning,
11380                      NULL_TREE);
11381       pop_scope (scope);
11382     }
11383
11384   /* Now TYPE has the actual type.  */
11385
11386   /* Did array size calculations overflow?  */
11387
11388   if (TREE_CODE (type) == ARRAY_TYPE
11389       && COMPLETE_TYPE_P (type)
11390       && TREE_OVERFLOW (TYPE_SIZE (type)))
11391     {
11392       error ("size of array `%s' is too large", name);
11393       /* If we proceed with the array type as it is, we'll eventually
11394          crash in tree_low_cst().  */
11395       type = error_mark_node;
11396     }
11397
11398   if (decl_context == FIELD
11399       && !processing_template_decl
11400       && variably_modified_type_p (type))
11401     {
11402       error ("data member may not have variably modified type `%T'", type);
11403       type = error_mark_node;
11404     }
11405
11406   if (explicitp == 1 || (explicitp && friendp))
11407     {
11408       /* [dcl.fct.spec] The explicit specifier shall only be used in
11409          declarations of constructors within a class definition.  */
11410       error ("only declarations of constructors can be `explicit'");
11411       explicitp = 0;
11412     }
11413
11414   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11415     {
11416       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11417         {
11418           error ("non-member `%s' cannot be declared `mutable'", name);
11419           RIDBIT_RESET (RID_MUTABLE, specbits);
11420         }
11421       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11422         {
11423           error ("non-object member `%s' cannot be declared `mutable'", name);
11424           RIDBIT_RESET (RID_MUTABLE, specbits);
11425         }
11426       else if (TREE_CODE (type) == FUNCTION_TYPE
11427                || TREE_CODE (type) == METHOD_TYPE)
11428         {
11429           error ("function `%s' cannot be declared `mutable'", name);
11430           RIDBIT_RESET (RID_MUTABLE, specbits);
11431         }
11432       else if (staticp)
11433         {
11434           error ("static `%s' cannot be declared `mutable'", name);
11435           RIDBIT_RESET (RID_MUTABLE, specbits);
11436         }
11437       else if (type_quals & TYPE_QUAL_CONST)
11438         {
11439           error ("const `%s' cannot be declared `mutable'", name);
11440           RIDBIT_RESET (RID_MUTABLE, specbits);
11441         }
11442     }
11443
11444   if (declarator == NULL_TREE
11445       || TREE_CODE (declarator) == IDENTIFIER_NODE
11446       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11447           && (TREE_CODE (type) == FUNCTION_TYPE
11448               || TREE_CODE (type) == METHOD_TYPE)))
11449     /* OK */;
11450   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11451     {
11452       error ("template-id `%D' used as a declarator", declarator);
11453       declarator = dname;
11454     }
11455   else
11456     /* Unexpected declarator format.  */
11457     abort ();
11458
11459   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11460
11461   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11462     {
11463       tree decl;
11464
11465       /* Note that the grammar rejects storage classes
11466          in typenames, fields or parameters.  */
11467       if (current_lang_name == lang_name_java)
11468         TYPE_FOR_JAVA (type) = 1;
11469
11470       if (decl_context == FIELD)
11471         {
11472           if (constructor_name_p (declarator, current_class_type))
11473             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11474                         declarator);
11475           decl = build_lang_decl (TYPE_DECL, declarator, type);
11476         }
11477       else
11478         {
11479           decl = build_decl (TYPE_DECL, declarator, type);
11480           if (in_namespace || ctype)
11481             cp_error_at ("typedef name may not be a nested-name-specifier",
11482                          decl);
11483           if (!current_function_decl)
11484             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11485         }
11486
11487       /* If the user declares "typedef struct {...} foo" then the
11488          struct will have an anonymous name.  Fill that name in now.
11489          Nothing can refer to it, so nothing needs know about the name
11490          change.  */
11491       if (type != error_mark_node
11492           && declarator
11493           && TYPE_NAME (type)
11494           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11495           && TYPE_ANONYMOUS_P (type)
11496           /* Don't do this if there are attributes.  */
11497           && (!attrlist || !*attrlist)
11498           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11499         {
11500           tree oldname = TYPE_NAME (type);
11501           tree t;
11502
11503           /* Replace the anonymous name with the real name everywhere.  */
11504           lookup_tag_reverse (type, declarator);
11505           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11506             if (TYPE_NAME (t) == oldname)
11507               TYPE_NAME (t) = decl;
11508
11509           if (TYPE_LANG_SPECIFIC (type))
11510             TYPE_WAS_ANONYMOUS (type) = 1;
11511
11512           /* If this is a typedef within a template class, the nested
11513              type is a (non-primary) template.  The name for the
11514              template needs updating as well.  */
11515           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11516             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11517               = TYPE_IDENTIFIER (type);
11518
11519           /* FIXME remangle member functions; member functions of a
11520              type with external linkage have external linkage.  */
11521         }
11522
11523       if (quals)
11524         {
11525           if (ctype == NULL_TREE)
11526             {
11527               if (TREE_CODE (type) != METHOD_TYPE)
11528                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11529               else
11530                 ctype = TYPE_METHOD_BASETYPE (type);
11531             }
11532           if (ctype != NULL_TREE)
11533             grok_method_quals (ctype, decl, quals);
11534         }
11535
11536       if (RIDBIT_SETP (RID_SIGNED, specbits)
11537           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11538         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11539
11540       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11541                       inlinep, friendp, raises != NULL_TREE);
11542
11543       return decl;
11544     }
11545
11546   /* Detect the case of an array type of unspecified size
11547      which came, as such, direct from a typedef name.
11548      We must copy the type, so that the array's domain can be
11549      individually set by the object's initializer.  */
11550
11551   if (type && typedef_type
11552       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11553       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11554     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11555
11556   /* Detect where we're using a typedef of function type to declare a
11557      function. last_function_parms will not be set, so we must create
11558      it now.  */
11559
11560   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11561     {
11562       tree decls = NULL_TREE;
11563       tree args;
11564
11565       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11566         {
11567           tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
11568
11569           TREE_CHAIN (decl) = decls;
11570           decls = decl;
11571         }
11572
11573       last_function_parms = nreverse (decls);
11574     }
11575
11576   /* If this is a type name (such as, in a cast or sizeof),
11577      compute the type and return it now.  */
11578
11579   if (decl_context == TYPENAME)
11580     {
11581       /* Note that the grammar rejects storage classes
11582          in typenames, fields or parameters.  */
11583       if (type_quals != TYPE_UNQUALIFIED)
11584         type_quals = TYPE_UNQUALIFIED;
11585
11586       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11587       if (friendp)
11588         {
11589           if (type_quals != TYPE_UNQUALIFIED)
11590             {
11591               error ("type qualifiers specified for friend class declaration");
11592               type_quals = TYPE_UNQUALIFIED;
11593             }
11594           if (inlinep)
11595             {
11596               error ("`inline' specified for friend class declaration");
11597               inlinep = 0;
11598             }
11599
11600           if (!current_aggr)
11601             {
11602               /* Don't allow friend declaration without a class-key.  */
11603               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11604                 pedwarn ("template parameters cannot be friends");
11605               else if (TREE_CODE (type) == TYPENAME_TYPE)
11606                 pedwarn ("friend declaration requires class-key, "
11607                          "i.e. `friend class %T::%D'",
11608                          TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
11609               else
11610                 pedwarn ("friend declaration requires class-key, "
11611                          "i.e. `friend %#T'",
11612                          type);
11613             }
11614
11615           /* Only try to do this stuff if we didn't already give up.  */
11616           if (type != integer_type_node)
11617             {
11618               decl_type_access_control (TYPE_NAME (type));
11619
11620               /* A friendly class?  */
11621               if (current_class_type)
11622                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11623               else
11624                 error ("trying to make class `%T' a friend of global scope",
11625                           type);
11626
11627               type = void_type_node;
11628             }
11629         }
11630       else if (quals)
11631         {
11632           if (ctype == NULL_TREE)
11633             {
11634               if (TREE_CODE (type) != METHOD_TYPE)
11635                 error ("invalid qualifiers on non-member function type");
11636               else
11637                 ctype = TYPE_METHOD_BASETYPE (type);
11638             }
11639           if (ctype)
11640             {
11641               tree dummy = build_decl (TYPE_DECL, declarator, type);
11642               grok_method_quals (ctype, dummy, quals);
11643               type = TREE_TYPE (dummy);
11644             }
11645         }
11646
11647       return type;
11648     }
11649   else if (declarator == NULL_TREE && decl_context != PARM
11650            && decl_context != CATCHPARM
11651            && TREE_CODE (type) != UNION_TYPE
11652            && ! bitfield)
11653     {
11654       error ("abstract declarator `%T' used as declaration", type);
11655       declarator = make_anon_name ();
11656     }
11657
11658   /* `void' at top level (not within pointer)
11659      is allowed only in typedefs or type names.
11660      We don't complain about parms either, but that is because
11661      a better error message can be made later.  */
11662
11663   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11664     {
11665       if (! declarator)
11666         error ("unnamed variable or field declared void");
11667       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11668         {
11669           if (IDENTIFIER_OPNAME_P (declarator))
11670             abort ();
11671           else
11672             error ("variable or field `%s' declared void", name);
11673         }
11674       else
11675         error ("variable or field declared void");
11676       type = integer_type_node;
11677     }
11678
11679   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11680      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11681
11682   if (decl_context == PARM || decl_context == CATCHPARM)
11683     {
11684       if (ctype || in_namespace)
11685         error ("cannot use `::' in parameter declaration");
11686
11687       /* A parameter declared as an array of T is really a pointer to T.
11688          One declared as a function is really a pointer to a function.
11689          One declared as a member is really a pointer to member.  */
11690
11691       if (TREE_CODE (type) == ARRAY_TYPE)
11692         {
11693           /* Transfer const-ness of array into that of type pointed to.  */
11694           type = build_pointer_type (TREE_TYPE (type));
11695           type_quals = TYPE_UNQUALIFIED;
11696         }
11697       else if (TREE_CODE (type) == FUNCTION_TYPE)
11698         type = build_pointer_type (type);
11699       else if (TREE_CODE (type) == OFFSET_TYPE)
11700         type = build_pointer_type (type);
11701     }
11702
11703   {
11704     register tree decl;
11705
11706     if (decl_context == PARM)
11707       {
11708         decl = cp_build_parm_decl (declarator, type);
11709
11710         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11711                         inlinep, friendp, raises != NULL_TREE);
11712       }
11713     else if (decl_context == FIELD)
11714       {
11715         if (type == error_mark_node)
11716           {
11717             /* Happens when declaring arrays of sizes which
11718                are error_mark_node, for example.  */
11719             decl = NULL_TREE;
11720           }
11721         else if (in_namespace && !friendp)
11722           {
11723             /* Something like struct S { int N::j; };  */
11724             error ("invalid use of `::'");
11725             decl = NULL_TREE;
11726           }
11727         else if (TREE_CODE (type) == FUNCTION_TYPE)
11728           {
11729             int publicp = 0;
11730             tree function_context;
11731
11732             /* We catch the others as conflicts with the builtin
11733                typedefs.  */
11734             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11735               {
11736                 error ("function `%D' cannot be declared friend",
11737                           declarator);
11738                 friendp = 0;
11739               }
11740
11741             if (friendp == 0)
11742               {
11743                 if (ctype == NULL_TREE)
11744                   ctype = current_class_type;
11745
11746                 if (ctype == NULL_TREE)
11747                   {
11748                     error ("can't make `%D' into a method -- not in a class",
11749                               declarator);
11750                     return void_type_node;
11751                   }
11752
11753                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11754                    ARM 9.5 */
11755                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11756                   {
11757                     error ("function `%D' declared virtual inside a union",
11758                               declarator);
11759                     return void_type_node;
11760                   }
11761
11762                 if (declarator == ansi_opname (NEW_EXPR)
11763                     || declarator == ansi_opname (VEC_NEW_EXPR)
11764                     || declarator == ansi_opname (DELETE_EXPR)
11765                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11766                   {
11767                     if (virtualp)
11768                       {
11769                         error ("`%D' cannot be declared virtual, since it is always static",
11770                                   declarator);
11771                         virtualp = 0;
11772                       }
11773                   }
11774                 else if (staticp < 2)
11775                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11776                                                   TYPE_ARG_TYPES (type));
11777               }
11778
11779             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11780             function_context = (ctype != NULL_TREE) ?
11781               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11782             publicp = (! friendp || ! staticp)
11783               && function_context == NULL_TREE;
11784             decl = grokfndecl (ctype, type,
11785                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11786                                ? declarator : dname,
11787                                declarator,
11788                                virtualp, flags, quals, raises,
11789                                friendp ? -1 : 0, friendp, publicp, inlinep,
11790                                funcdef_flag, template_count, in_namespace);
11791             if (decl == NULL_TREE)
11792               return decl;
11793 #if 0
11794             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11795             /* The decl and setting of decl_attr is also turned off.  */
11796             decl = build_decl_attribute_variant (decl, decl_attr);
11797 #endif
11798
11799             /* [class.conv.ctor]
11800
11801                A constructor declared without the function-specifier
11802                explicit that can be called with a single parameter
11803                specifies a conversion from the type of its first
11804                parameter to the type of its class.  Such a constructor
11805                is called a converting constructor.  */
11806             if (explicitp == 2)
11807               DECL_NONCONVERTING_P (decl) = 1;
11808             else if (DECL_CONSTRUCTOR_P (decl))
11809               {
11810                 /* The constructor can be called with exactly one
11811                    parameter if there is at least one parameter, and
11812                    any subsequent parameters have default arguments.
11813                    Ignore any compiler-added parms.  */
11814                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11815
11816                 if (arg_types == void_list_node
11817                     || (arg_types
11818                         && TREE_CHAIN (arg_types)
11819                         && TREE_CHAIN (arg_types) != void_list_node
11820                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11821                   DECL_NONCONVERTING_P (decl) = 1;
11822               }
11823           }
11824         else if (TREE_CODE (type) == METHOD_TYPE)
11825           {
11826             /* We only get here for friend declarations of
11827                members of other classes.  */
11828             /* All method decls are public, so tell grokfndecl to set
11829                TREE_PUBLIC, also.  */
11830             decl = grokfndecl (ctype, type, declarator, declarator,
11831                                virtualp, flags, quals, raises,
11832                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11833                                template_count, in_namespace);
11834             if (decl == NULL_TREE)
11835               return NULL_TREE;
11836           }
11837         else if (!staticp && ! processing_template_decl
11838                  && !COMPLETE_TYPE_P (complete_type (type))
11839                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11840           {
11841             if (declarator)
11842               error ("field `%D' has incomplete type", declarator);
11843             else
11844               error ("name `%T' has incomplete type", type);
11845
11846             /* If we're instantiating a template, tell them which
11847                instantiation made the field's type be incomplete.  */
11848             if (current_class_type
11849                 && TYPE_NAME (current_class_type)
11850                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11851                 && declspecs && TREE_VALUE (declspecs)
11852                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11853               error ("  in instantiation of template `%T'",
11854                         current_class_type);
11855
11856             type = error_mark_node;
11857             decl = NULL_TREE;
11858           }
11859         else
11860           {
11861             if (friendp)
11862               {
11863                 error ("`%s' is neither function nor member function; cannot be declared friend",
11864                        IDENTIFIER_POINTER (declarator));
11865                 friendp = 0;
11866               }
11867             decl = NULL_TREE;
11868           }
11869
11870         if (friendp)
11871           {
11872             /* Friends are treated specially.  */
11873             if (ctype == current_class_type)
11874               warning ("member functions are implicitly friends of their class");
11875             else
11876               {
11877                 tree t = NULL_TREE;
11878                 if (decl && DECL_NAME (decl))
11879                   {
11880                     if (template_class_depth (current_class_type) == 0)
11881                       {
11882                         decl
11883                           = check_explicit_specialization
11884                           (declarator, decl,
11885                            template_count, 2 * (funcdef_flag != 0) + 4);
11886                         if (decl == error_mark_node)
11887                           return error_mark_node;
11888                       }
11889
11890                     t = do_friend (ctype, declarator, decl,
11891                                    last_function_parms, *attrlist,
11892                                    flags, quals, funcdef_flag);
11893                   }
11894                 if (t && funcdef_flag)
11895                   return t;
11896
11897                 return void_type_node;
11898               }
11899           }
11900
11901         /* Structure field.  It may not be a function, except for C++ */
11902
11903         if (decl == NULL_TREE)
11904           {
11905             if (initialized)
11906               {
11907                 if (!staticp)
11908                   {
11909                     /* An attempt is being made to initialize a non-static
11910                        member.  But, from [class.mem]:
11911
11912                        4 A member-declarator can contain a
11913                        constant-initializer only if it declares a static
11914                        member (_class.static_) of integral or enumeration
11915                        type, see _class.static.data_.
11916
11917                        This used to be relatively common practice, but
11918                        the rest of the compiler does not correctly
11919                        handle the initialization unless the member is
11920                        static so we make it static below.  */
11921                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11922                                 declarator);
11923                     pedwarn ("making `%D' static", declarator);
11924                     staticp = 1;
11925                   }
11926
11927                 if (uses_template_parms (type))
11928                   /* We'll check at instantiation time.  */
11929                   ;
11930                 else if (check_static_variable_definition (declarator,
11931                                                            type))
11932                   /* If we just return the declaration, crashes
11933                      will sometimes occur.  We therefore return
11934                      void_type_node, as if this was a friend
11935                      declaration, to cause callers to completely
11936                      ignore this declaration.  */
11937                   return void_type_node;
11938               }
11939
11940             /* 9.2p13 [class.mem] */
11941             if (constructor_name_p (declarator, current_class_type)
11942                 /* The standard does not allow non-static data members
11943                    here either, but we agreed at the 10/99 meeting
11944                    to change that in TC 1 so that they are allowed in
11945                    classes with no user-defined constructors.  */
11946                 && staticp)
11947               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11948                           declarator);
11949
11950             if (staticp)
11951               {
11952                 /* C++ allows static class members.  All other work
11953                    for this is done by grokfield.  */
11954                 decl = build_lang_decl (VAR_DECL, declarator, type);
11955                 TREE_STATIC (decl) = 1;
11956                 /* In class context, 'static' means public access.  */
11957                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11958               }
11959             else
11960               {
11961                 decl = build_decl (FIELD_DECL, declarator, type);
11962                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11963                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11964                   {
11965                     DECL_MUTABLE_P (decl) = 1;
11966                     RIDBIT_RESET (RID_MUTABLE, specbits);
11967                   }
11968               }
11969
11970             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11971                             inlinep, friendp, raises != NULL_TREE);
11972           }
11973       }
11974     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11975       {
11976         tree original_name;
11977         int publicp = 0;
11978
11979         if (! declarator)
11980           return NULL_TREE;
11981
11982         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11983           original_name = dname;
11984         else
11985           original_name = declarator;
11986
11987         if (RIDBIT_SETP (RID_AUTO, specbits))
11988           error ("storage class `auto' invalid for function `%s'", name);
11989         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11990           error ("storage class `register' invalid for function `%s'", name);
11991         else if (RIDBIT_SETP (RID_THREAD, specbits))
11992           error ("storage class `__thread' invalid for function `%s'", name);
11993
11994         /* Function declaration not at top level.
11995            Storage classes other than `extern' are not allowed
11996            and `extern' makes no difference.  */
11997         if (! toplevel_bindings_p ()
11998             && (RIDBIT_SETP (RID_STATIC, specbits)
11999                 || RIDBIT_SETP (RID_INLINE, specbits))
12000             && pedantic)
12001           {
12002             if (RIDBIT_SETP (RID_STATIC, specbits))
12003               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
12004             else
12005               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
12006           }
12007
12008         if (ctype == NULL_TREE)
12009           {
12010             if (virtualp)
12011               {
12012                 error ("virtual non-class function `%s'", name);
12013                 virtualp = 0;
12014               }
12015           }
12016         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
12017           type = build_cplus_method_type (ctype, TREE_TYPE (type),
12018                                           TYPE_ARG_TYPES (type));
12019
12020         /* Record presence of `static'.  */
12021         publicp = (ctype != NULL_TREE
12022                    || RIDBIT_SETP (RID_EXTERN, specbits)
12023                    || !RIDBIT_SETP (RID_STATIC, specbits));
12024
12025         decl = grokfndecl (ctype, type, original_name, declarator,
12026                            virtualp, flags, quals, raises,
12027                            1, friendp,
12028                            publicp, inlinep, funcdef_flag,
12029                            template_count, in_namespace);
12030         if (decl == NULL_TREE)
12031           return NULL_TREE;
12032
12033         if (staticp == 1)
12034           {
12035             int invalid_static = 0;
12036
12037             /* Don't allow a static member function in a class, and forbid
12038                declaring main to be static.  */
12039             if (TREE_CODE (type) == METHOD_TYPE)
12040               {
12041                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
12042                 invalid_static = 1;
12043               }
12044             else if (current_function_decl)
12045               {
12046                 /* FIXME need arm citation */
12047                 error ("cannot declare static function inside another function");
12048                 invalid_static = 1;
12049               }
12050
12051             if (invalid_static)
12052               {
12053                 staticp = 0;
12054                 RIDBIT_RESET (RID_STATIC, specbits);
12055               }
12056           }
12057       }
12058     else
12059       {
12060         /* It's a variable.  */
12061
12062         /* An uninitialized decl with `extern' is a reference.  */
12063         decl = grokvardecl (type, declarator, &specbits,
12064                             initialized,
12065                             (type_quals & TYPE_QUAL_CONST) != 0,
12066                             ctype ? ctype : in_namespace);
12067         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
12068                         inlinep, friendp, raises != NULL_TREE);
12069
12070         if (ctype)
12071           {
12072             DECL_CONTEXT (decl) = ctype;
12073             if (staticp == 1)
12074               {
12075                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
12076                 staticp = 0;
12077                 RIDBIT_RESET (RID_STATIC, specbits);
12078               }
12079             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
12080               {
12081                 error ("static member `%D' declared `register'", decl);
12082                 RIDBIT_RESET (RID_REGISTER, specbits);
12083               }
12084             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
12085               {
12086                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
12087                             decl);
12088                 RIDBIT_RESET (RID_EXTERN, specbits);
12089               }
12090           }
12091       }
12092
12093     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
12094
12095     /* Record `register' declaration for warnings on &
12096        and in case doing stupid register allocation.  */
12097
12098     if (RIDBIT_SETP (RID_REGISTER, specbits))
12099       DECL_REGISTER (decl) = 1;
12100
12101     if (RIDBIT_SETP (RID_EXTERN, specbits))
12102       DECL_THIS_EXTERN (decl) = 1;
12103
12104     if (RIDBIT_SETP (RID_STATIC, specbits))
12105       DECL_THIS_STATIC (decl) = 1;
12106
12107     /* Record constancy and volatility.  There's no need to do this
12108        when processing a template; we'll do this for the instantiated
12109        declaration based on the type of DECL.  */
12110     if (!processing_template_decl)
12111       c_apply_type_quals_to_decl (type_quals, decl);
12112
12113     return decl;
12114   }
12115 }
12116 \f
12117 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
12118    An empty exprlist is a parmlist.  An exprlist which
12119    contains only identifiers at the global level
12120    is a parmlist.  Otherwise, it is an exprlist.  */
12121
12122 int
12123 parmlist_is_exprlist (exprs)
12124      tree exprs;
12125 {
12126   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
12127     return 0;
12128
12129   if (toplevel_bindings_p ())
12130     {
12131       /* At the global level, if these are all identifiers,
12132          then it is a parmlist.  */
12133       while (exprs)
12134         {
12135           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
12136             return 1;
12137           exprs = TREE_CHAIN (exprs);
12138         }
12139       return 0;
12140     }
12141   return 1;
12142 }
12143
12144 /* Subroutine of start_function.  Ensure that each of the parameter
12145    types (as listed in PARMS) is complete, as is required for a
12146    function definition.  */
12147
12148 static void
12149 require_complete_types_for_parms (parms)
12150      tree parms;
12151 {
12152   for (; parms; parms = TREE_CHAIN (parms))
12153     {
12154       if (VOID_TYPE_P (TREE_TYPE (parms)))
12155         /* grokparms will have already issued an error */
12156         TREE_TYPE (parms) = error_mark_node;
12157       else if (complete_type_or_else (TREE_TYPE (parms), parms))
12158         layout_decl (parms, 0);
12159       else
12160         TREE_TYPE (parms) = error_mark_node;
12161     }
12162 }
12163
12164 /* Returns nonzero if T is a local variable.  */
12165
12166 int
12167 local_variable_p (t)
12168      tree t;
12169 {
12170   if ((TREE_CODE (t) == VAR_DECL
12171        /* A VAR_DECL with a context that is a _TYPE is a static data
12172           member.  */
12173        && !TYPE_P (CP_DECL_CONTEXT (t))
12174        /* Any other non-local variable must be at namespace scope.  */
12175        && !DECL_NAMESPACE_SCOPE_P (t))
12176       || (TREE_CODE (t) == PARM_DECL))
12177     return 1;
12178
12179   return 0;
12180 }
12181
12182 /* Returns nonzero if T is an automatic local variable or a label.
12183    (These are the declarations that need to be remapped when the code
12184    containing them is duplicated.)  */
12185
12186 int
12187 nonstatic_local_decl_p (t)
12188      tree t;
12189 {
12190   return ((local_variable_p (t) && !TREE_STATIC (t))
12191           || TREE_CODE (t) == LABEL_DECL
12192           || TREE_CODE (t) == RESULT_DECL);
12193 }
12194
12195 /* Like local_variable_p, but suitable for use as a tree-walking
12196    function.  */
12197
12198 static tree
12199 local_variable_p_walkfn (tp, walk_subtrees, data)
12200      tree *tp;
12201      int *walk_subtrees ATTRIBUTE_UNUSED;
12202      void *data ATTRIBUTE_UNUSED;
12203 {
12204   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
12205           ? *tp : NULL_TREE);
12206 }
12207
12208 /* Check that ARG, which is a default-argument expression for a
12209    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
12210    something goes wrong.  DECL may also be a _TYPE node, rather than a
12211    DECL, if there is no DECL available.  */
12212
12213 tree
12214 check_default_argument (decl, arg)
12215      tree decl;
12216      tree arg;
12217 {
12218   tree var;
12219   tree decl_type;
12220
12221   if (TREE_CODE (arg) == DEFAULT_ARG)
12222     /* We get a DEFAULT_ARG when looking at an in-class declaration
12223        with a default argument.  Ignore the argument for now; we'll
12224        deal with it after the class is complete.  */
12225     return arg;
12226
12227   if (processing_template_decl || uses_template_parms (arg))
12228     /* We don't do anything checking until instantiation-time.  Note
12229        that there may be uninstantiated arguments even for an
12230        instantiated function, since default arguments are not
12231        instantiated until they are needed.  */
12232     return arg;
12233
12234   if (TYPE_P (decl))
12235     {
12236       decl_type = decl;
12237       decl = NULL_TREE;
12238     }
12239   else
12240     decl_type = TREE_TYPE (decl);
12241
12242   if (arg == error_mark_node
12243       || decl == error_mark_node
12244       || TREE_TYPE (arg) == error_mark_node
12245       || decl_type == error_mark_node)
12246     /* Something already went wrong.  There's no need to check
12247        further.  */
12248     return error_mark_node;
12249
12250   /* [dcl.fct.default]
12251
12252      A default argument expression is implicitly converted to the
12253      parameter type.  */
12254   if (!TREE_TYPE (arg)
12255       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12256     {
12257       if (decl)
12258         error ("default argument for `%#D' has type `%T'",
12259                   decl, TREE_TYPE (arg));
12260       else
12261         error ("default argument for parameter of type `%T' has type `%T'",
12262                   decl_type, TREE_TYPE (arg));
12263
12264       return error_mark_node;
12265     }
12266
12267   /* [dcl.fct.default]
12268
12269      Local variables shall not be used in default argument
12270      expressions.
12271
12272      The keyword `this' shall not be used in a default argument of a
12273      member function.  */
12274   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12275                                       NULL);
12276   if (var)
12277     {
12278       error ("default argument `%E' uses local variable `%D'",
12279                 arg, var);
12280       return error_mark_node;
12281     }
12282
12283   /* All is well.  */
12284   return arg;
12285 }
12286
12287 /* Decode the list of parameter types for a function type.
12288    Given the list of things declared inside the parens,
12289    return a list of types.
12290
12291    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
12292    flag. If unset, we append void_list_node. A parmlist declared
12293    as `(void)' is accepted as the empty parmlist.
12294
12295    Also set last_function_parms to the chain of PARM_DECLs.  */
12296
12297 static tree
12298 grokparms (first_parm)
12299      tree first_parm;
12300 {
12301   tree result = NULL_TREE;
12302   tree decls = NULL_TREE;
12303   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12304   tree parm, chain;
12305   int any_error = 0;
12306
12307   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12308
12309   for (parm = first_parm; parm != NULL_TREE; parm = chain)
12310     {
12311       tree type = NULL_TREE;
12312       tree decl = TREE_VALUE (parm);
12313       tree init = TREE_PURPOSE (parm);
12314       tree specs, attrs;
12315
12316       chain = TREE_CHAIN (parm);
12317       /* @@ weak defense against parse errors.  */
12318       if (TREE_CODE (decl) != VOID_TYPE
12319           && TREE_CODE (decl) != TREE_LIST)
12320         {
12321           /* Give various messages as the need arises.  */
12322           if (TREE_CODE (decl) == STRING_CST)
12323             error ("invalid string constant `%E'", decl);
12324           else if (TREE_CODE (decl) == INTEGER_CST)
12325             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12326           continue;
12327         }
12328
12329       if (parm == void_list_node)
12330         break;
12331
12332       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12333       decl = grokdeclarator (TREE_VALUE (decl), specs,
12334                              PARM, init != NULL_TREE, &attrs);
12335       if (! decl || TREE_TYPE (decl) == error_mark_node)
12336         continue;
12337
12338       if (attrs)
12339         cplus_decl_attributes (&decl, attrs, 0);
12340
12341       type = TREE_TYPE (decl);
12342       if (VOID_TYPE_P (type))
12343         {
12344           if (same_type_p (type, void_type_node)
12345               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12346             /* this is a parmlist of `(void)', which is ok.  */
12347             break;
12348           cxx_incomplete_type_error (decl, type);
12349           /* It's not a good idea to actually create parameters of
12350              type `void'; other parts of the compiler assume that a
12351              void type terminates the parameter list.  */
12352           type = error_mark_node;
12353           TREE_TYPE (decl) = error_mark_node;
12354         }
12355
12356       if (type != error_mark_node)
12357         {
12358           /* Top-level qualifiers on the parameters are
12359              ignored for function types.  */
12360           type = TYPE_MAIN_VARIANT (type);
12361           if (TREE_CODE (type) == METHOD_TYPE)
12362             {
12363               error ("parameter `%D' invalidly declared method type", decl);
12364               type = build_pointer_type (type);
12365               TREE_TYPE (decl) = type;
12366             }
12367           else if (TREE_CODE (type) == OFFSET_TYPE)
12368             {
12369               error ("parameter `%D' invalidly declared offset type", decl);
12370               type = build_pointer_type (type);
12371               TREE_TYPE (decl) = type;
12372             }
12373           else if (abstract_virtuals_error (decl, type))
12374             any_error = 1;  /* Seems like a good idea.  */
12375           else if (POINTER_TYPE_P (type))
12376             {
12377               /* [dcl.fct]/6, parameter types cannot contain pointers
12378                  (references) to arrays of unknown bound.  */
12379               tree t = TREE_TYPE (type);
12380               int ptr = TYPE_PTR_P (type);
12381
12382               while (1)
12383                 {
12384                   if (TYPE_PTR_P (t))
12385                     ptr = 1;
12386                   else if (TREE_CODE (t) != ARRAY_TYPE)
12387                     break;
12388                   else if (!TYPE_DOMAIN (t))
12389                     break;
12390                   t = TREE_TYPE (t);
12391                 }
12392               if (TREE_CODE (t) == ARRAY_TYPE)
12393                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12394                           decl, ptr ? "pointer" : "reference", t);
12395             }
12396
12397           if (!any_error && init)
12398             init = check_default_argument (decl, init);
12399           else
12400             init = NULL_TREE;
12401         }
12402
12403       TREE_CHAIN (decl) = decls;
12404       decls = decl;
12405       result = tree_cons (init, type, result);
12406     }
12407   decls = nreverse (decls);
12408   result = nreverse (result);
12409   if (!ellipsis)
12410     result = chainon (result, void_list_node);
12411   last_function_parms = decls;
12412
12413   return result;
12414 }
12415
12416 \f
12417 /* D is a constructor or overloaded `operator='.
12418
12419    Let T be the class in which D is declared. Then, this function
12420    returns:
12421
12422    -1 if D's is an ill-formed constructor or copy assignment operator
12423       whose first parameter is of type `T'.
12424    0  if D is not a copy constructor or copy assignment
12425       operator.
12426    1  if D is a copy constructor or copy assignment operator whose
12427       first parameter is a reference to const qualified T.
12428    2  if D is a copy constructor or copy assignment operator whose
12429       first parameter is a reference to non-const qualified T.
12430
12431    This function can be used as a predicate. Positive values indicate
12432    a copy constructor and nonzero values indicate a copy assignment
12433    operator.  */
12434
12435 int
12436 copy_fn_p (d)
12437      tree d;
12438 {
12439   tree args;
12440   tree arg_type;
12441   int result = 1;
12442
12443   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12444
12445   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12446     /* Instantiations of template member functions are never copy
12447        functions.  Note that member functions of templated classes are
12448        represented as template functions internally, and we must
12449        accept those as copy functions.  */
12450     return 0;
12451
12452   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12453   if (!args)
12454     return 0;
12455
12456   arg_type = TREE_VALUE (args);
12457
12458   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12459     {
12460       /* Pass by value copy assignment operator.  */
12461       result = -1;
12462     }
12463   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12464            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12465     {
12466       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12467         result = 2;
12468     }
12469   else
12470     return 0;
12471
12472   args = TREE_CHAIN (args);
12473
12474   if (args && args != void_list_node && !TREE_PURPOSE (args))
12475     /* There are more non-optional args.  */
12476     return 0;
12477
12478   return result;
12479 }
12480
12481 /* Remember any special properties of member function DECL.  */
12482
12483 void grok_special_member_properties (decl)
12484      tree decl;
12485 {
12486   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12487     ; /* Not special.  */
12488   else if (DECL_CONSTRUCTOR_P (decl))
12489     {
12490       int ctor = copy_fn_p (decl);
12491
12492       if (ctor > 0)
12493         {
12494           /* [class.copy]
12495
12496              A non-template constructor for class X is a copy
12497              constructor if its first parameter is of type X&, const
12498              X&, volatile X& or const volatile X&, and either there
12499              are no other parameters or else all other parameters have
12500              default arguments.  */
12501           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12502           if (ctor > 1)
12503             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12504         }
12505       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12506         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12507     }
12508   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12509     {
12510       /* [class.copy]
12511
12512          A non-template assignment operator for class X is a copy
12513          assignment operator if its parameter is of type X, X&, const
12514          X&, volatile X& or const volatile X&.  */
12515
12516       int assop = copy_fn_p (decl);
12517
12518       if (assop)
12519         {
12520           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12521           if (assop != 1)
12522             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12523           if (DECL_PURE_VIRTUAL_P (decl))
12524             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12525         }
12526     }
12527 }
12528
12529 /* Check a constructor DECL has the correct form.  Complains
12530    if the class has a constructor of the form X(X).  */
12531
12532 int
12533 grok_ctor_properties (ctype, decl)
12534      tree ctype, decl;
12535 {
12536   int ctor_parm = copy_fn_p (decl);
12537
12538   if (ctor_parm < 0)
12539     {
12540       /* [class.copy]
12541
12542          A declaration of a constructor for a class X is ill-formed if
12543          its first parameter is of type (optionally cv-qualified) X
12544          and either there are no other parameters or else all other
12545          parameters have default arguments.
12546
12547          We *don't* complain about member template instantiations that
12548          have this form, though; they can occur as we try to decide
12549          what constructor to use during overload resolution.  Since
12550          overload resolution will never prefer such a constructor to
12551          the non-template copy constructor (which is either explicitly
12552          or implicitly defined), there's no need to worry about their
12553          existence.  Theoretically, they should never even be
12554          instantiated, but that's hard to forestall.  */
12555       error ("invalid constructor; you probably meant `%T (const %T&)'",
12556                 ctype, ctype);
12557       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12558       return 0;
12559     }
12560
12561   return 1;
12562 }
12563
12564 /* An operator with this code is unary, but can also be binary.  */
12565
12566 static int
12567 ambi_op_p (code)
12568      enum tree_code code;
12569 {
12570   return (code == INDIRECT_REF
12571           || code == ADDR_EXPR
12572           || code == CONVERT_EXPR
12573           || code == NEGATE_EXPR
12574           || code == PREINCREMENT_EXPR
12575           || code == PREDECREMENT_EXPR);
12576 }
12577
12578 /* An operator with this name can only be unary.  */
12579
12580 static int
12581 unary_op_p (code)
12582      enum tree_code code;
12583 {
12584   return (code == TRUTH_NOT_EXPR
12585           || code == BIT_NOT_EXPR
12586           || code == COMPONENT_REF
12587           || code == TYPE_EXPR);
12588 }
12589
12590 /* Do a little sanity-checking on how they declared their operator.  */
12591
12592 void
12593 grok_op_properties (decl, friendp)
12594      tree decl;
12595      int friendp;
12596 {
12597   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12598   tree argtype;
12599   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12600   tree name = DECL_NAME (decl);
12601   enum tree_code operator_code;
12602   int arity;
12603
12604   /* Count the number of arguments.  */
12605   for (argtype = argtypes, arity = 0;
12606        argtype && argtype != void_list_node;
12607        argtype = TREE_CHAIN (argtype))
12608     ++arity;
12609
12610   if (current_class_type == NULL_TREE)
12611     friendp = 1;
12612
12613   if (DECL_CONV_FN_P (decl))
12614     operator_code = TYPE_EXPR;
12615   else
12616     do
12617       {
12618 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12619         if (ansi_opname (CODE) == name)                         \
12620           {                                                     \
12621             operator_code = (CODE);                             \
12622             break;                                              \
12623           }                                                     \
12624         else if (ansi_assopname (CODE) == name)                 \
12625           {                                                     \
12626             operator_code = (CODE);                             \
12627             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12628             break;                                              \
12629           }
12630
12631 #include "operators.def"
12632 #undef DEF_OPERATOR
12633
12634         abort ();
12635       }
12636     while (0);
12637   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12638   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12639
12640   if (! friendp)
12641     {
12642       switch (operator_code)
12643         {
12644         case CALL_EXPR:
12645           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12646           break;
12647
12648         case ARRAY_REF:
12649           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12650           break;
12651
12652         case COMPONENT_REF:
12653         case MEMBER_REF:
12654           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12655           break;
12656
12657         case NEW_EXPR:
12658           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12659           break;
12660
12661         case DELETE_EXPR:
12662           TYPE_GETS_DELETE (current_class_type) |= 1;
12663           break;
12664
12665         case VEC_NEW_EXPR:
12666           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12667           break;
12668
12669         case VEC_DELETE_EXPR:
12670           TYPE_GETS_DELETE (current_class_type) |= 2;
12671           break;
12672
12673         default:
12674           break;
12675         }
12676     }
12677
12678   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12679     {
12680       /* When the compiler encounters the definition of A::operator new, it
12681          doesn't look at the class declaration to find out if it's static.  */
12682       if (methodp)
12683         revert_static_member_fn (decl);
12684
12685       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12686     }
12687   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12688     {
12689       if (methodp)
12690         revert_static_member_fn (decl);
12691
12692       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12693     }
12694   else
12695     {
12696       /* An operator function must either be a non-static member function
12697          or have at least one parameter of a class, a reference to a class,
12698          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12699       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12700         {
12701           if (operator_code == TYPE_EXPR
12702               || operator_code == CALL_EXPR
12703               || operator_code == COMPONENT_REF
12704               || operator_code == ARRAY_REF
12705               || operator_code == NOP_EXPR)
12706             error ("`%D' must be a nonstatic member function", decl);
12707           else
12708             {
12709               tree p = argtypes;
12710
12711               if (DECL_STATIC_FUNCTION_P (decl))
12712                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12713
12714               if (p)
12715                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12716                   {
12717                     tree arg = TREE_VALUE (p);
12718                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12719                       arg = TREE_TYPE (arg);
12720
12721                     /* This lets bad template code slip through.  */
12722                     if (IS_AGGR_TYPE (arg)
12723                         || TREE_CODE (arg) == ENUMERAL_TYPE
12724                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12725                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12726                       goto foundaggr;
12727                   }
12728               error
12729                 ("`%D' must have an argument of class or enumerated type",
12730                  decl);
12731             foundaggr:
12732               ;
12733             }
12734         }
12735
12736       if (operator_code == CALL_EXPR)
12737         return;                 /* No restrictions on args.  */
12738
12739       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12740         {
12741           tree t = TREE_TYPE (name);
12742           if (! friendp)
12743             {
12744               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12745               const char *what = 0;
12746
12747               if (ref)
12748                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12749
12750               if (TREE_CODE (t) == VOID_TYPE)
12751                 what = "void";
12752               else if (t == current_class_type)
12753                 what = "the same type";
12754               /* Don't force t to be complete here.  */
12755               else if (IS_AGGR_TYPE (t)
12756                        && COMPLETE_TYPE_P (t)
12757                        && DERIVED_FROM_P (t, current_class_type))
12758                 what = "a base class";
12759
12760               if (what)
12761                 warning ("conversion to %s%s will never use a type conversion operator",
12762                          ref ? "a reference to " : "", what);
12763             }
12764         }
12765       if (operator_code == COND_EXPR)
12766         {
12767           /* 13.4.0.3 */
12768           error ("ISO C++ prohibits overloading operator ?:");
12769         }
12770       else if (ambi_op_p (operator_code))
12771         {
12772           if (arity == 1)
12773             /* We pick the one-argument operator codes by default, so
12774                we don't have to change anything.  */
12775             ;
12776           else if (arity == 2)
12777             {
12778               /* If we thought this was a unary operator, we now know
12779                  it to be a binary operator.  */
12780               switch (operator_code)
12781                 {
12782                 case INDIRECT_REF:
12783                   operator_code = MULT_EXPR;
12784                   break;
12785
12786                 case ADDR_EXPR:
12787                   operator_code = BIT_AND_EXPR;
12788                   break;
12789
12790                 case CONVERT_EXPR:
12791                   operator_code = PLUS_EXPR;
12792                   break;
12793
12794                 case NEGATE_EXPR:
12795                   operator_code = MINUS_EXPR;
12796                   break;
12797
12798                 case PREINCREMENT_EXPR:
12799                   operator_code = POSTINCREMENT_EXPR;
12800                   break;
12801
12802                 case PREDECREMENT_EXPR:
12803                   operator_code = POSTDECREMENT_EXPR;
12804                   break;
12805
12806                 default:
12807                   abort ();
12808                 }
12809
12810               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12811
12812               if ((operator_code == POSTINCREMENT_EXPR
12813                    || operator_code == POSTDECREMENT_EXPR)
12814                   && ! processing_template_decl
12815                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12816                 {
12817                   if (methodp)
12818                     error ("postfix `%D' must take `int' as its argument",
12819                               decl);
12820                   else
12821                     error
12822                       ("postfix `%D' must take `int' as its second argument",
12823                        decl);
12824                 }
12825             }
12826           else
12827             {
12828               if (methodp)
12829                 error ("`%D' must take either zero or one argument", decl);
12830               else
12831                 error ("`%D' must take either one or two arguments", decl);
12832             }
12833
12834           /* More Effective C++ rule 6.  */
12835           if (warn_ecpp
12836               && (operator_code == POSTINCREMENT_EXPR
12837                   || operator_code == POSTDECREMENT_EXPR
12838                   || operator_code == PREINCREMENT_EXPR
12839                   || operator_code == PREDECREMENT_EXPR))
12840             {
12841               tree arg = TREE_VALUE (argtypes);
12842               tree ret = TREE_TYPE (TREE_TYPE (decl));
12843               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12844                 arg = TREE_TYPE (arg);
12845               arg = TYPE_MAIN_VARIANT (arg);
12846               if (operator_code == PREINCREMENT_EXPR
12847                   || operator_code == PREDECREMENT_EXPR)
12848                 {
12849                   if (TREE_CODE (ret) != REFERENCE_TYPE
12850                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12851                                        arg))
12852                     warning ("prefix `%D' should return `%T'", decl,
12853                                 build_reference_type (arg));
12854                 }
12855               else
12856                 {
12857                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12858                     warning ("postfix `%D' should return `%T'", decl, arg);
12859                 }
12860             }
12861         }
12862       else if (unary_op_p (operator_code))
12863         {
12864           if (arity != 1)
12865             {
12866               if (methodp)
12867                 error ("`%D' must take `void'", decl);
12868               else
12869                 error ("`%D' must take exactly one argument", decl);
12870             }
12871         }
12872       else /* if (binary_op_p (operator_code)) */
12873         {
12874           if (arity != 2)
12875             {
12876               if (methodp)
12877                 error ("`%D' must take exactly one argument", decl);
12878               else
12879                 error ("`%D' must take exactly two arguments", decl);
12880             }
12881
12882           /* More Effective C++ rule 7.  */
12883           if (warn_ecpp
12884               && (operator_code == TRUTH_ANDIF_EXPR
12885                   || operator_code == TRUTH_ORIF_EXPR
12886                   || operator_code == COMPOUND_EXPR))
12887             warning ("user-defined `%D' always evaluates both arguments",
12888                         decl);
12889         }
12890
12891       /* Effective C++ rule 23.  */
12892       if (warn_ecpp
12893           && arity == 2
12894           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12895           && (operator_code == PLUS_EXPR
12896               || operator_code == MINUS_EXPR
12897               || operator_code == TRUNC_DIV_EXPR
12898               || operator_code == MULT_EXPR
12899               || operator_code == TRUNC_MOD_EXPR)
12900           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12901         warning ("`%D' should return by value", decl);
12902
12903       /* [over.oper]/8 */
12904       for (; argtypes && argtypes != void_list_node;
12905           argtypes = TREE_CHAIN (argtypes))
12906         if (TREE_PURPOSE (argtypes))
12907           {
12908             TREE_PURPOSE (argtypes) = NULL_TREE;
12909             if (operator_code == POSTINCREMENT_EXPR
12910                 || operator_code == POSTDECREMENT_EXPR)
12911               {
12912                 if (pedantic)
12913                   pedwarn ("`%D' cannot have default arguments", decl);
12914               }
12915             else
12916               error ("`%D' cannot have default arguments", decl);
12917           }
12918
12919     }
12920 }
12921 \f
12922 static const char *
12923 tag_name (code)
12924      enum tag_types code;
12925 {
12926   switch (code)
12927     {
12928     case record_type:
12929       return "struct";
12930     case class_type:
12931       return "class";
12932     case union_type:
12933       return "union ";
12934     case enum_type:
12935       return "enum";
12936     default:
12937       abort ();
12938     }
12939 }
12940
12941 /* Get the struct, enum or union (CODE says which) with tag NAME.
12942    Define the tag as a forward-reference if it is not defined.
12943
12944    C++: If a class derivation is given, process it here, and report
12945    an error if multiple derivation declarations are not identical.
12946
12947    If this is a definition, come in through xref_tag and only look in
12948    the current frame for the name (since C++ allows new names in any
12949    scope.)  */
12950
12951 tree
12952 xref_tag (enum tag_types tag_code, tree name, tree attributes,
12953           bool globalize)
12954 {
12955   enum tree_code code;
12956   register tree ref, t;
12957   struct cp_binding_level *b = current_binding_level;
12958   tree context = NULL_TREE;
12959
12960   switch (tag_code)
12961     {
12962     case record_type:
12963     case class_type:
12964       code = RECORD_TYPE;
12965       break;
12966     case union_type:
12967       code = UNION_TYPE;
12968       break;
12969     case enum_type:
12970       code = ENUMERAL_TYPE;
12971       break;
12972     default:
12973       abort ();
12974     }
12975
12976   /* If a cross reference is requested, look up the type
12977      already defined for this tag and return it.  */
12978   if (TYPE_P (name))
12979     {
12980       t = name;
12981       name = TYPE_IDENTIFIER (t);
12982     }
12983   else
12984     t = IDENTIFIER_TYPE_VALUE (name);
12985
12986   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12987   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12988     {
12989       static int explained;
12990       tree shadowed;
12991
12992       warning ("`%s %T' declares a new type at namespace scope",
12993                   tag_name (tag_code), name);
12994       if (!explained++)
12995         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12996                     tag_name (tag_code),
12997                     constructor_name (current_class_type),
12998                     TYPE_IDENTIFIER (t));
12999
13000       /* We need to remove the class scope binding for the
13001          TYPENAME_TYPE as otherwise poplevel_class gets confused.  */
13002       for (shadowed = b->class_shadowed;
13003            shadowed;
13004            shadowed = TREE_CHAIN (shadowed))
13005         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
13006           {
13007             TREE_PURPOSE (shadowed) = NULL_TREE;
13008             break;
13009           }
13010     }
13011
13012   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
13013       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
13014     t = NULL_TREE;
13015
13016   if (! globalize)
13017     {
13018       /* If we know we are defining this tag, only look it up in
13019          this scope and don't try to find it as a type.  */
13020       ref = lookup_tag (code, name, b, 1);
13021     }
13022   else
13023     {
13024       if (t)
13025         {
13026           ref = follow_tag_typedef (t);
13027
13028           /* [dcl.type.elab] If the identifier resolves to a
13029              typedef-name or a template type-parameter, the
13030              elaborated-type-specifier is ill-formed.  */
13031           if (!ref)
13032             {
13033               pedwarn ("using typedef-name `%D' after `%s'",
13034                        TYPE_NAME (t), tag_name (tag_code));
13035               ref = t;
13036             }
13037           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
13038             error ("using template type parameter `%T' after `%s'",
13039                    t, tag_name (tag_code));
13040         }
13041       else
13042         ref = lookup_tag (code, name, b, 0);
13043
13044       if (! ref)
13045         {
13046           /* Try finding it as a type declaration.  If that wins,
13047              use it.  */
13048           ref = lookup_name (name, 1);
13049
13050           if (ref != NULL_TREE
13051               && processing_template_decl
13052               && DECL_CLASS_TEMPLATE_P (ref)
13053               && template_class_depth (current_class_type) == 0)
13054             /* Since GLOBALIZE is true, we're declaring a global
13055                template, so we want this type.  */
13056             ref = DECL_TEMPLATE_RESULT (ref);
13057
13058           if (ref && TREE_CODE (ref) == TYPE_DECL
13059               && TREE_CODE (TREE_TYPE (ref)) == code)
13060             ref = TREE_TYPE (ref);
13061           else
13062             ref = NULL_TREE;
13063         }
13064
13065       if (ref && current_class_type
13066           && template_class_depth (current_class_type)
13067           && PROCESSING_REAL_TEMPLATE_DECL_P ())
13068         {
13069           /* Since GLOBALIZE is nonzero, we are not looking at a
13070              definition of this tag.  Since, in addition, we are currently
13071              processing a (member) template declaration of a template
13072              class, we must be very careful; consider:
13073
13074                template <class X>
13075                struct S1
13076
13077                template <class U>
13078                struct S2
13079                { template <class V>
13080                friend struct S1; };
13081
13082              Here, the S2::S1 declaration should not be confused with the
13083              outer declaration.  In particular, the inner version should
13084              have a template parameter of level 2, not level 1.  This
13085              would be particularly important if the member declaration
13086              were instead:
13087
13088                template <class V = U> friend struct S1;
13089
13090              say, when we should tsubst into `U' when instantiating
13091              S2.  On the other hand, when presented with:
13092
13093                  template <class T>
13094                  struct S1 {
13095                    template <class U>
13096                    struct S2 {};
13097                    template <class U>
13098                    friend struct S2;
13099                  };
13100
13101               we must find the inner binding eventually.  We
13102               accomplish this by making sure that the new type we
13103               create to represent this declaration has the right
13104               TYPE_CONTEXT.  */
13105           context = TYPE_CONTEXT (ref);
13106           ref = NULL_TREE;
13107         }
13108     }
13109
13110   if (! ref)
13111     {
13112       /* If no such tag is yet defined, create a forward-reference node
13113          and record it as the "definition".
13114          When a real declaration of this type is found,
13115          the forward-reference will be altered into a real type.  */
13116       if (code == ENUMERAL_TYPE)
13117         {
13118           error ("use of enum `%#D' without previous declaration", name);
13119
13120           ref = make_node (ENUMERAL_TYPE);
13121
13122           /* Give the type a default layout like unsigned int
13123              to avoid crashing if it does not get defined.  */
13124           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
13125           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
13126           TYPE_USER_ALIGN (ref) = 0;
13127           TREE_UNSIGNED (ref) = 1;
13128           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
13129           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
13130           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
13131
13132           /* Enable us to recognize when a type is created in class context.
13133              To do nested classes correctly, this should probably be cleared
13134              out when we leave this classes scope.  Currently this in only
13135              done in `start_enum'.  */
13136
13137           pushtag (name, ref, globalize);
13138         }
13139       else
13140         {
13141           struct cp_binding_level *old_b = class_binding_level;
13142
13143           ref = make_aggr_type (code);
13144           TYPE_CONTEXT (ref) = context;
13145
13146 #ifdef NONNESTED_CLASSES
13147           /* Class types don't nest the way enums do.  */
13148           class_binding_level = (struct cp_binding_level *)0;
13149 #endif
13150           pushtag (name, ref, globalize);
13151           class_binding_level = old_b;
13152         }
13153     }
13154   else
13155     {
13156       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
13157         redeclare_class_template (ref, current_template_parms);
13158     }
13159
13160   TYPE_ATTRIBUTES (ref) = attributes;
13161
13162   return ref;
13163 }
13164
13165 tree
13166 xref_tag_from_type (old, id, globalize)
13167      tree old, id;
13168      int globalize;
13169 {
13170   enum tag_types tag_kind;
13171
13172   if (TREE_CODE (old) == RECORD_TYPE)
13173     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
13174   else
13175     tag_kind  = union_type;
13176
13177   if (id == NULL_TREE)
13178     id = TYPE_IDENTIFIER (old);
13179
13180   return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize);
13181 }
13182
13183 /* REF is a type (named NAME), for which we have just seen some
13184    baseclasses.  BINFO is a list of those baseclasses; the
13185    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13186    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13187    struct, or union.  */
13188
13189 void
13190 xref_basetypes (ref, binfo)
13191      tree ref;
13192      tree binfo;
13193 {
13194   /* In the declaration `A : X, Y, ... Z' we mark all the types
13195      (A, X, Y, ..., Z) so we can check for duplicates.  */
13196   tree binfos;
13197   tree base;
13198
13199   int i, len;
13200   enum tag_types tag_code;
13201
13202   if (TREE_CODE (ref) == UNION_TYPE)
13203     {
13204       error ("derived union `%T' invalid", ref);
13205       return;
13206     }
13207
13208   tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
13209
13210   len = list_length (binfo);
13211
13212   /* First, make sure that any templates in base-classes are
13213      instantiated.  This ensures that if we call ourselves recursively
13214      we do not get confused about which classes are marked and which
13215      are not.  */
13216   for (base = binfo; base; base = TREE_CHAIN (base))
13217     complete_type (TREE_VALUE (base));
13218
13219   SET_CLASSTYPE_MARKED (ref);
13220   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13221
13222   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13223     {
13224       /* The base of a derived struct is public by default.  */
13225       int via_public
13226         = (TREE_PURPOSE (binfo) == access_public_node
13227            || TREE_PURPOSE (binfo) == access_public_virtual_node
13228            || (tag_code != class_type
13229                && (TREE_PURPOSE (binfo) == access_default_node
13230                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13231       int via_protected
13232         = (TREE_PURPOSE (binfo) == access_protected_node
13233            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13234       int via_virtual
13235         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13236            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13237            || TREE_PURPOSE (binfo) == access_public_virtual_node
13238            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13239       tree basetype = TREE_VALUE (binfo);
13240       tree base_binfo;
13241
13242       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13243         basetype = TREE_TYPE (basetype);
13244       if (!basetype
13245           || (TREE_CODE (basetype) != RECORD_TYPE
13246               && TREE_CODE (basetype) != TYPENAME_TYPE
13247               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13248               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13249         {
13250           error ("base type `%T' fails to be a struct or class type",
13251                     TREE_VALUE (binfo));
13252           continue;
13253         }
13254
13255       /* This code replaces similar code in layout_basetypes.
13256          We put the complete_type first for implicit `typename'.  */
13257       if (!COMPLETE_TYPE_P (basetype)
13258           && ! (current_template_parms && uses_template_parms (basetype)))
13259         {
13260           error ("base class `%T' has incomplete type", basetype);
13261           continue;
13262         }
13263       else
13264         {
13265           if (CLASSTYPE_MARKED (basetype))
13266             {
13267               if (basetype == ref)
13268                 error ("recursive type `%T' undefined", basetype);
13269               else
13270                 error ("duplicate base type `%T' invalid", basetype);
13271               continue;
13272             }
13273
13274           if (TYPE_FOR_JAVA (basetype)
13275               && (current_lang_depth () == 0))
13276             TYPE_FOR_JAVA (ref) = 1;
13277
13278           /* Note that the BINFO records which describe individual
13279              inheritances are *not* shared in the lattice!  They
13280              cannot be shared because a given baseclass may be
13281              inherited with different `accessibility' by different
13282              derived classes.  (Each BINFO record describing an
13283              individual inheritance contains flags which say what
13284              the `accessibility' of that particular inheritance is.)  */
13285
13286           base_binfo
13287             = make_binfo (size_zero_node, basetype,
13288                           CLASS_TYPE_P (basetype)
13289                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13290                           CLASS_TYPE_P (basetype)
13291                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13292
13293           TREE_VEC_ELT (binfos, i) = base_binfo;
13294           TREE_VIA_PUBLIC (base_binfo) = via_public;
13295           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13296           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13297           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13298
13299           /* We need to unshare the binfos now so that lookups during class
13300              definition work.  */
13301           unshare_base_binfos (base_binfo);
13302
13303           SET_CLASSTYPE_MARKED (basetype);
13304
13305           /* We are free to modify these bits because they are meaningless
13306              at top level, and BASETYPE is a top-level type.  */
13307           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13308             {
13309               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13310               /* Converting to a virtual base class requires looking
13311                  up the offset of the virtual base.  */
13312               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13313             }
13314
13315           if (CLASS_TYPE_P (basetype))
13316             {
13317               TYPE_HAS_NEW_OPERATOR (ref)
13318                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13319               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13320                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13321               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13322               /* If the base-class uses multiple inheritance, so do we.  */
13323               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13324                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13325               /* Likewise, if converting to a base of the base may require
13326                  code, then we may need to generate code to convert to a
13327                  base as well.  */
13328               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13329                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13330             }
13331
13332           i += 1;
13333         }
13334     }
13335   if (i)
13336     TREE_VEC_LENGTH (binfos) = i;
13337   else
13338     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13339
13340   if (i > 1)
13341     {
13342       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13343       /* If there is more than one non-empty they cannot be at the same
13344          address.  */
13345       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13346     }
13347
13348   /* Unmark all the types.  */
13349   while (--i >= 0)
13350     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13351   CLEAR_CLASSTYPE_MARKED (ref);
13352
13353   /* Now that we know all the base-classes, set up the list of virtual
13354      bases.  */
13355   get_vbase_types (ref);
13356 }
13357
13358 \f
13359 /* Begin compiling the definition of an enumeration type.
13360    NAME is its name (or null if anonymous).
13361    Returns the type object, as yet incomplete.
13362    Also records info about it so that build_enumerator
13363    may be used to declare the individual values as they are read.  */
13364
13365 tree
13366 start_enum (name)
13367      tree name;
13368 {
13369   register tree enumtype = NULL_TREE;
13370   struct cp_binding_level *b = current_binding_level;
13371
13372   /* If this is the real definition for a previous forward reference,
13373      fill in the contents in the same object that used to be the
13374      forward reference.  */
13375
13376   if (name != NULL_TREE)
13377     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13378
13379   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13380     {
13381       error ("multiple definition of `%#T'", enumtype);
13382       cp_error_at ("previous definition here", enumtype);
13383       /* Clear out TYPE_VALUES, and start again.  */
13384       TYPE_VALUES (enumtype) = NULL_TREE;
13385     }
13386   else
13387     {
13388       enumtype = make_node (ENUMERAL_TYPE);
13389       pushtag (name, enumtype, 0);
13390     }
13391
13392   return enumtype;
13393 }
13394
13395 /* After processing and defining all the values of an enumeration type,
13396    install their decls in the enumeration type and finish it off.
13397    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13398
13399 void
13400 finish_enum (enumtype)
13401      tree enumtype;
13402 {
13403   tree pair;
13404   tree minnode;
13405   tree maxnode;
13406   tree t;
13407   bool unsignedp;
13408   int lowprec;
13409   int highprec;
13410   int precision;
13411
13412   /* We built up the VALUES in reverse order.  */
13413   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13414
13415   /* [dcl.enum]
13416
13417      Following the closing brace of an enum-specifier, each
13418      enumerator has the type of its enumeration.  Prior to the
13419      closing brace, the type of each enumerator is the type of
13420      its initializing value.  */
13421   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13422     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13423
13424   /* For an enum defined in a template, all further processing is
13425      postponed until the template is instantiated.  */
13426   if (processing_template_decl)
13427     {
13428       if (at_function_scope_p ())
13429         add_stmt (build_min (TAG_DEFN, enumtype));
13430       return;
13431     }
13432
13433   /* Figure out what the minimum and maximum values of the enumerators
13434      are.  */
13435   if (TYPE_VALUES (enumtype))
13436     {
13437       minnode = maxnode = NULL_TREE;
13438
13439       for (pair = TYPE_VALUES (enumtype);
13440            pair;
13441            pair = TREE_CHAIN (pair))
13442         {
13443           tree value;
13444
13445           value = DECL_INITIAL (TREE_VALUE (pair));
13446
13447           if (!minnode)
13448             minnode = maxnode = value;
13449           else if (tree_int_cst_lt (maxnode, value))
13450             maxnode = value;
13451           else if (tree_int_cst_lt (value, minnode))
13452             minnode = value;
13453         }
13454     }
13455   else
13456     minnode = maxnode = integer_zero_node;
13457
13458   /* Compute the number of bits require to represent all values of the
13459      enumeration.  We must do this before the type of MINNODE and
13460      MAXNODE are transformed, since min_precision relies on the
13461      TREE_TYPE of the value it is passed.  */
13462   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13463   lowprec = min_precision (minnode, unsignedp);
13464   highprec = min_precision (maxnode, unsignedp);
13465   precision = MAX (lowprec, highprec);
13466
13467   /* Set the TREE_TYPE for the values as well.  That's so that when we
13468      call decl_constant_value we get an entity of the right type (but
13469      with the constant value).  In addition, transform the TYPE_VALUES
13470      list to contain the values, rather than the CONST_DECLs for them.  */
13471   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13472     {
13473       tree value = DECL_INITIAL (TREE_VALUE (pair));
13474
13475       TREE_TYPE (value) = enumtype;
13476       TREE_VALUE (pair) = value;
13477     }
13478
13479   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13480   TYPE_SIZE (enumtype) = NULL_TREE;
13481   TYPE_PRECISION (enumtype) = precision;
13482   if (unsignedp)
13483     fixup_unsigned_type (enumtype);
13484   else
13485     fixup_signed_type (enumtype);
13486
13487   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13488     /* Use the width of the narrowest normal C type which is wide
13489        enough.  */
13490     TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size
13491                                                 (precision, 1));
13492   else
13493     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13494
13495   TYPE_SIZE (enumtype) = NULL_TREE;
13496   layout_type (enumtype);
13497
13498   /* Fix up all variant types of this enum type.  */
13499   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13500     {
13501       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13502       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13503       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13504       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13505       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13506       TYPE_MODE (t) = TYPE_MODE (enumtype);
13507       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13508       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13509       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13510       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13511     }
13512
13513   /* Finish debugging output for this type.  */
13514   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13515 }
13516
13517 /* Build and install a CONST_DECL for an enumeration constant of the
13518    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13519    Assignment of sequential values by default is handled here.  */
13520
13521 void
13522 build_enumerator (name, value, enumtype)
13523      tree name;
13524      tree value;
13525      tree enumtype;
13526 {
13527   tree decl;
13528   tree context;
13529   tree type;
13530   tree values;
13531
13532   /* Remove no-op casts from the value.  */
13533   if (value)
13534     STRIP_TYPE_NOPS (value);
13535
13536   if (! processing_template_decl)
13537     {
13538       /* Validate and default VALUE.  */
13539       if (value != NULL_TREE)
13540         {
13541           value = decl_constant_value (value);
13542
13543           if (TREE_CODE (value) == INTEGER_CST)
13544             {
13545               value = default_conversion (value);
13546               constant_expression_warning (value);
13547             }
13548           else
13549             {
13550               error ("enumerator value for `%D' not integer constant", name);
13551               value = NULL_TREE;
13552             }
13553         }
13554
13555       /* Default based on previous value.  */
13556       if (value == NULL_TREE && ! processing_template_decl)
13557         {
13558           tree prev_value;
13559
13560           if (TYPE_VALUES (enumtype))
13561             {
13562               /* The next value is the previous value ...  */
13563               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13564               /* ... plus one.  */
13565               value = cp_build_binary_op (PLUS_EXPR,
13566                                           prev_value,
13567                                           integer_one_node);
13568
13569               if (tree_int_cst_lt (value, prev_value))
13570                 error ("overflow in enumeration values at `%D'", name);
13571             }
13572           else
13573             value = integer_zero_node;
13574         }
13575
13576       /* Remove no-op casts from the value.  */
13577       if (value)
13578         STRIP_TYPE_NOPS (value);
13579 #if 0
13580       /* To fix MAX_VAL enum consts. (bkoz)  */
13581       TREE_TYPE (value) = integer_type_node;
13582 #endif
13583     }
13584
13585   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13586      Even in other cases, we will later (in finish_enum) be setting
13587      the type of VALUE.  But, we don't need to make a copy if this
13588      VALUE is one of the enumeration constants for this same
13589      enumeration type.  */
13590   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13591     if (TREE_VALUE (values) == value)
13592       break;
13593   /* If we didn't break out of the loop, then we do need a copy.  */
13594   if (!values && value)
13595     value = copy_node (value);
13596
13597   /* C++ associates enums with global, function, or class declarations.  */
13598   context = current_scope ();
13599
13600   /* Build the actual enumeration constant.  Note that the enumeration
13601     constants have the type of their initializers until the
13602     enumeration is complete:
13603
13604       [ dcl.enum ]
13605
13606       Following the closing brace of an enum-specifier, each enumer-
13607       ator has the type of its enumeration.  Prior to the closing
13608       brace, the type of each enumerator is the type of its
13609       initializing value.
13610
13611     In finish_enum we will reset the type.  Of course, if we're
13612     processing a template, there may be no value.  */
13613   type = value ? TREE_TYPE (value) : NULL_TREE;
13614
13615   if (context && context == current_class_type)
13616     /* This enum declaration is local to the class.  We need the full
13617        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13618     decl = build_lang_decl (CONST_DECL, name, type);
13619   else
13620     /* It's a global enum, or it's local to a function.  (Note local to
13621       a function could mean local to a class method.  */
13622     decl = build_decl (CONST_DECL, name, type);
13623
13624   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13625   DECL_INITIAL (decl) = value;
13626   TREE_READONLY (decl) = 1;
13627
13628   if (context && context == current_class_type)
13629     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13630       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13631       things like `S::i' later.)  */
13632     finish_member_declaration (decl);
13633   else
13634     pushdecl (decl);
13635
13636   /* Add this enumeration constant to the list for this type.  */
13637   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13638 }
13639
13640 \f
13641 /* We're defining DECL.  Make sure that it's type is OK.  */
13642
13643 static void
13644 check_function_type (decl, current_function_parms)
13645      tree decl;
13646      tree current_function_parms;
13647 {
13648   tree fntype = TREE_TYPE (decl);
13649   tree return_type = complete_type (TREE_TYPE (fntype));
13650
13651   /* In a function definition, arg types must be complete.  */
13652   require_complete_types_for_parms (current_function_parms);
13653
13654   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13655     {
13656       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13657
13658       /* Make it return void instead, but don't change the
13659          type of the DECL_RESULT, in case we have a named return value.  */
13660       if (TREE_CODE (fntype) == METHOD_TYPE)
13661         {
13662           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13663           TREE_TYPE (decl)
13664             = build_cplus_method_type (ctype,
13665                                        void_type_node,
13666                                        FUNCTION_ARG_CHAIN (decl));
13667         }
13668       else
13669         TREE_TYPE (decl)
13670           = build_function_type (void_type_node,
13671                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13672       TREE_TYPE (decl)
13673         = build_exception_variant (fntype,
13674                                    TYPE_RAISES_EXCEPTIONS (fntype));
13675     }
13676   else
13677     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13678 }
13679
13680 /* Create the FUNCTION_DECL for a function definition.
13681    DECLSPECS and DECLARATOR are the parts of the declaration;
13682    they describe the function's name and the type it returns,
13683    but twisted together in a fashion that parallels the syntax of C.
13684
13685    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13686    DECLARATOR is really the DECL for the function we are about to
13687    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13688    indicating that the function is an inline defined in-class.
13689
13690    This function creates a binding context for the function body
13691    as well as setting up the FUNCTION_DECL in current_function_decl.
13692
13693    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13694    (it defines a datum instead), we return 0, which tells
13695    yyparse to report a parse error.
13696
13697    For C++, we must first check whether that datum makes any sense.
13698    For example, "class A local_a(1,2);" means that variable local_a
13699    is an aggregate of type A, which should have a constructor
13700    applied to it with the argument list [1, 2].  */
13701
13702 int
13703 start_function (declspecs, declarator, attrs, flags)
13704      tree declspecs, declarator, attrs;
13705      int flags;
13706 {
13707   tree decl1;
13708   tree ctype = NULL_TREE;
13709   tree fntype;
13710   tree restype;
13711   int doing_friend = 0;
13712   struct cp_binding_level *bl;
13713   tree current_function_parms;
13714
13715   /* Sanity check.  */
13716   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13717   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13718
13719   /* This should only be done once on the top most decl.  */
13720   if (have_extern_spec)
13721     {
13722       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13723       have_extern_spec = false;
13724     }
13725
13726   if (flags & SF_PRE_PARSED)
13727     {
13728       decl1 = declarator;
13729
13730       fntype = TREE_TYPE (decl1);
13731       if (TREE_CODE (fntype) == METHOD_TYPE)
13732         ctype = TYPE_METHOD_BASETYPE (fntype);
13733
13734       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13735          the (lexical) scope of the class in which it is defined.  */
13736       if (!ctype && DECL_FRIEND_P (decl1))
13737         {
13738           ctype = DECL_FRIEND_CONTEXT (decl1);
13739
13740           /* CTYPE could be null here if we're dealing with a template;
13741              for example, `inline friend float foo()' inside a template
13742              will have no CTYPE set.  */
13743           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13744             ctype = NULL_TREE;
13745           else
13746             doing_friend = 1;
13747         }
13748
13749       last_function_parms = DECL_ARGUMENTS (decl1);
13750     }
13751   else
13752     {
13753       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13754       /* If the declarator is not suitable for a function definition,
13755          cause a syntax error.  */
13756       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13757         return 0;
13758
13759       cplus_decl_attributes (&decl1, attrs, 0);
13760
13761       /* If #pragma weak was used, mark the decl weak now.  */
13762       if (current_binding_level == global_binding_level)
13763         maybe_apply_pragma_weak (decl1);
13764
13765       fntype = TREE_TYPE (decl1);
13766
13767       restype = TREE_TYPE (fntype);
13768       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13769         {
13770           error ("semicolon missing after declaration of `%#T'", restype);
13771           shadow_tag (build_tree_list (NULL_TREE, restype));
13772           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13773           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13774             fntype = build_function_type (integer_type_node,
13775                                           TYPE_ARG_TYPES (fntype));
13776           else
13777             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13778                                               integer_type_node,
13779                                               TYPE_ARG_TYPES (fntype));
13780           TREE_TYPE (decl1) = fntype;
13781         }
13782
13783       if (TREE_CODE (fntype) == METHOD_TYPE)
13784         ctype = TYPE_METHOD_BASETYPE (fntype);
13785       else if (DECL_MAIN_P (decl1))
13786         {
13787           /* If this doesn't return integer_type, complain.  */
13788           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13789             {
13790               if (pedantic || warn_return_type)
13791                 pedwarn ("return type for `main' changed to `int'");
13792               TREE_TYPE (decl1) = fntype = default_function_type;
13793             }
13794         }
13795     }
13796
13797   if (DECL_DECLARED_INLINE_P (decl1)
13798       && lookup_attribute ("noinline", attrs))
13799     warning_with_decl (decl1,
13800                        "inline function `%s' given attribute noinline");
13801
13802   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13803     /* This is a constructor, we must ensure that any default args
13804        introduced by this definition are propagated to the clones
13805        now. The clones are used directly in overload resolution.  */
13806     adjust_clone_args (decl1);
13807
13808   /* Sometimes we don't notice that a function is a static member, and
13809      build a METHOD_TYPE for it.  Fix that up now.  */
13810   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13811       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13812     {
13813       revert_static_member_fn (decl1);
13814       last_function_parms = TREE_CHAIN (last_function_parms);
13815       ctype = NULL_TREE;
13816     }
13817
13818   /* Warn if function was previously implicitly declared
13819      (but not if we warned then).  */
13820   if (! warn_implicit
13821       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13822     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13823
13824   /* Set up current_class_type, and enter the scope of the class, if
13825      appropriate.  */
13826   if (ctype)
13827     push_nested_class (ctype, 1);
13828   else if (DECL_STATIC_FUNCTION_P (decl1))
13829     push_nested_class (DECL_CONTEXT (decl1), 2);
13830
13831   /* Now that we have entered the scope of the class, we must restore
13832      the bindings for any template parameters surrounding DECL1, if it
13833      is an inline member template.  (Order is important; consider the
13834      case where a template parameter has the same name as a field of
13835      the class.)  It is not until after this point that
13836      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13837   if (flags & SF_INCLASS_INLINE)
13838     maybe_begin_member_template_processing (decl1);
13839
13840   /* Effective C++ rule 15.  */
13841   if (warn_ecpp
13842       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13843       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13844     warning ("`operator=' should return a reference to `*this'");
13845
13846   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13847      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13848   if (!DECL_INITIAL (decl1))
13849     DECL_INITIAL (decl1) = error_mark_node;
13850
13851   /* This function exists in static storage.
13852      (This does not mean `static' in the C sense!)  */
13853   TREE_STATIC (decl1) = 1;
13854
13855   /* We must call push_template_decl after current_class_type is set
13856      up.  (If we are processing inline definitions after exiting a
13857      class scope, current_class_type will be NULL_TREE until set above
13858      by push_nested_class.)  */
13859   if (processing_template_decl)
13860     decl1 = push_template_decl (decl1);
13861
13862   /* We are now in the scope of the function being defined.  */
13863   current_function_decl = decl1;
13864
13865   /* Save the parm names or decls from this function's declarator
13866      where store_parm_decls will find them.  */
13867   current_function_parms = last_function_parms;
13868
13869   /* Make sure the parameter and return types are reasonable.  When
13870      you declare a function, these types can be incomplete, but they
13871      must be complete when you define the function.  */
13872   if (! processing_template_decl)
13873     check_function_type (decl1, current_function_parms);
13874
13875   /* Build the return declaration for the function.  */
13876   restype = TREE_TYPE (fntype);
13877   /* Promote the value to int before returning it.  */
13878   if (c_promoting_integer_type_p (restype))
13879     restype = type_promotes_to (restype);
13880   if (DECL_RESULT (decl1) == NULL_TREE)
13881     {
13882       DECL_RESULT (decl1)
13883         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13884       c_apply_type_quals_to_decl (cp_type_quals (restype),
13885                                   DECL_RESULT (decl1));
13886     }
13887
13888   /* Initialize RTL machinery.  We cannot do this until
13889      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13890      even when processing a template; this is how we get
13891      CFUN set up, and our per-function variables initialized.
13892      FIXME factor out the non-RTL stuff.  */
13893   bl = current_binding_level;
13894   init_function_start (decl1, input_filename, lineno);
13895   current_binding_level = bl;
13896
13897   /* Even though we're inside a function body, we still don't want to
13898      call expand_expr to calculate the size of a variable-sized array.
13899      We haven't necessarily assigned RTL to all variables yet, so it's
13900      not safe to try to expand expressions involving them.  */
13901   immediate_size_expand = 0;
13902   cfun->x_dont_save_pending_sizes_p = 1;
13903
13904   /* Start the statement-tree, start the tree now.  */
13905   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13906
13907   /* Let the user know we're compiling this function.  */
13908   announce_function (decl1);
13909
13910   /* Record the decl so that the function name is defined.
13911      If we already have a decl for this name, and it is a FUNCTION_DECL,
13912      use the old decl.  */
13913   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13914     {
13915       /* A specialization is not used to guide overload resolution.  */
13916       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13917           && ! DECL_FUNCTION_MEMBER_P (decl1))
13918         decl1 = pushdecl (decl1);
13919       else
13920         {
13921           /* We need to set the DECL_CONTEXT.  */
13922           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13923             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13924           /* And make sure we have enough default args.  */
13925           check_default_args (decl1);
13926         }
13927       fntype = TREE_TYPE (decl1);
13928     }
13929
13930   /* Reset these in case the call to pushdecl changed them.  */
13931   current_function_decl = decl1;
13932   cfun->decl = decl1;
13933
13934   /* If we are (erroneously) defining a function that we have already
13935      defined before, wipe out what we knew before.  */
13936   if (!DECL_PENDING_INLINE_P (decl1))
13937     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13938
13939   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13940     {
13941       /* We know that this was set up by `grokclassfn'.  We do not
13942          wait until `store_parm_decls', since evil parse errors may
13943          never get us to that point.  Here we keep the consistency
13944          between `current_class_type' and `current_class_ptr'.  */
13945       tree t = DECL_ARGUMENTS (decl1);
13946
13947       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13948                           162);
13949       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13950                           19990811);
13951
13952       cp_function_chain->x_current_class_ref
13953         = build_indirect_ref (t, NULL);
13954       cp_function_chain->x_current_class_ptr = t;
13955
13956       /* Constructors and destructors need to know whether they're "in
13957          charge" of initializing virtual base classes.  */
13958       t = TREE_CHAIN (t);
13959       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13960         {
13961           current_in_charge_parm = t;
13962           t = TREE_CHAIN (t);
13963         }
13964       if (DECL_HAS_VTT_PARM_P (decl1))
13965         {
13966           if (DECL_NAME (t) != vtt_parm_identifier)
13967             abort ();
13968           current_vtt_parm = t;
13969         }
13970     }
13971
13972   if (DECL_INTERFACE_KNOWN (decl1))
13973     {
13974       tree ctx = decl_function_context (decl1);
13975
13976       if (DECL_NOT_REALLY_EXTERN (decl1))
13977         DECL_EXTERNAL (decl1) = 0;
13978
13979       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13980           && TREE_PUBLIC (ctx))
13981         /* This is a function in a local class in an extern inline
13982            function.  */
13983         comdat_linkage (decl1);
13984     }
13985   /* If this function belongs to an interface, it is public.
13986      If it belongs to someone else's interface, it is also external.
13987      This only affects inlines and template instantiations.  */
13988   else if (interface_unknown == 0
13989            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13990                || flag_alt_external_templates))
13991     {
13992       if (DECL_DECLARED_INLINE_P (decl1)
13993           || DECL_TEMPLATE_INSTANTIATION (decl1)
13994           || processing_template_decl)
13995         {
13996           DECL_EXTERNAL (decl1)
13997             = (interface_only
13998                || (DECL_DECLARED_INLINE_P (decl1)
13999                    && ! flag_implement_inlines
14000                    && !DECL_VINDEX (decl1)));
14001
14002           /* For WIN32 we also want to put these in linkonce sections.  */
14003           maybe_make_one_only (decl1);
14004         }
14005       else
14006         DECL_EXTERNAL (decl1) = 0;
14007       DECL_NOT_REALLY_EXTERN (decl1) = 0;
14008       DECL_INTERFACE_KNOWN (decl1) = 1;
14009     }
14010   else if (interface_unknown && interface_only
14011            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
14012                || flag_alt_external_templates))
14013     {
14014       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14015          interface, we will have interface_only set but not
14016          interface_known.  In that case, we don't want to use the normal
14017          heuristics because someone will supply a #pragma implementation
14018          elsewhere, and deducing it here would produce a conflict.  */
14019       comdat_linkage (decl1);
14020       DECL_EXTERNAL (decl1) = 0;
14021       DECL_INTERFACE_KNOWN (decl1) = 1;
14022       DECL_DEFER_OUTPUT (decl1) = 1;
14023     }
14024   else
14025     {
14026       /* This is a definition, not a reference.
14027          So clear DECL_EXTERNAL.  */
14028       DECL_EXTERNAL (decl1) = 0;
14029
14030       if ((DECL_DECLARED_INLINE_P (decl1)
14031            || DECL_TEMPLATE_INSTANTIATION (decl1))
14032           && ! DECL_INTERFACE_KNOWN (decl1)
14033           /* Don't try to defer nested functions for now.  */
14034           && ! decl_function_context (decl1))
14035         DECL_DEFER_OUTPUT (decl1) = 1;
14036       else
14037         DECL_INTERFACE_KNOWN (decl1) = 1;
14038     }
14039
14040   pushlevel (0);
14041   current_binding_level->parm_flag = 1;
14042
14043   ++function_depth;
14044
14045   if (DECL_DESTRUCTOR_P (decl1))
14046     {
14047       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14048       DECL_CONTEXT (dtor_label) = current_function_decl;
14049     }
14050
14051   start_fname_decls ();
14052
14053   store_parm_decls (current_function_parms);
14054
14055   return 1;
14056 }
14057 \f
14058 /* Store the parameter declarations into the current function declaration.
14059    This is called after parsing the parameter declarations, before
14060    digesting the body of the function.
14061
14062    Also install to binding contour return value identifier, if any.  */
14063
14064 static void
14065 store_parm_decls (current_function_parms)
14066      tree current_function_parms;
14067 {
14068   register tree fndecl = current_function_decl;
14069   register tree parm;
14070
14071   /* This is a chain of any other decls that came in among the parm
14072      declarations.  If a parm is declared with  enum {foo, bar} x;
14073      then CONST_DECLs for foo and bar are put here.  */
14074   tree nonparms = NULL_TREE;
14075
14076   if (current_function_parms)
14077     {
14078       /* This case is when the function was defined with an ANSI prototype.
14079          The parms already have decls, so we need not do anything here
14080          except record them as in effect
14081          and complain if any redundant old-style parm decls were written.  */
14082
14083       tree specparms = current_function_parms;
14084       tree next;
14085
14086       /* Must clear this because it might contain TYPE_DECLs declared
14087              at class level.  */
14088       storedecls (NULL_TREE);
14089
14090       /* If we're doing semantic analysis, then we'll call pushdecl
14091              for each of these.  We must do them in reverse order so that
14092              they end in the correct forward order.  */
14093       specparms = nreverse (specparms);
14094
14095       for (parm = specparms; parm; parm = next)
14096         {
14097           next = TREE_CHAIN (parm);
14098           if (TREE_CODE (parm) == PARM_DECL)
14099             {
14100               if (DECL_NAME (parm) == NULL_TREE
14101                   || TREE_CODE (parm) != VOID_TYPE)
14102                 pushdecl (parm);
14103               else
14104                 error ("parameter `%D' declared void", parm);
14105             }
14106           else
14107             {
14108               /* If we find an enum constant or a type tag,
14109                  put it aside for the moment.  */
14110               TREE_CHAIN (parm) = NULL_TREE;
14111               nonparms = chainon (nonparms, parm);
14112             }
14113         }
14114
14115       /* Get the decls in their original chain order and record in the
14116          function.  This is all and only the PARM_DECLs that were
14117          pushed into scope by the loop above.  */
14118       DECL_ARGUMENTS (fndecl) = getdecls ();
14119       storetags (gettags ());
14120     }
14121   else
14122     DECL_ARGUMENTS (fndecl) = NULL_TREE;
14123
14124   /* Now store the final chain of decls for the arguments
14125      as the decl-chain of the current lexical scope.
14126      Put the enumerators in as well, at the front so that
14127      DECL_ARGUMENTS is not modified.  */
14128   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14129
14130   /* Do the starting of the exception specifications, if we have any.  */
14131   if (flag_exceptions && !processing_template_decl
14132       && flag_enforce_eh_specs
14133       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14134     current_eh_spec_block = begin_eh_spec_block ();
14135 }
14136
14137 \f
14138 /* We have finished doing semantic analysis on DECL, but have not yet
14139    generated RTL for its body.  Save away our current state, so that
14140    when we want to generate RTL later we know what to do.  */
14141
14142 static void
14143 save_function_data (decl)
14144      tree decl;
14145 {
14146   struct language_function *f;
14147
14148   /* Save the language-specific per-function data so that we can
14149      get it back when we really expand this function.  */
14150   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14151                       19990908);
14152
14153   /* Make a copy.  */
14154   f = ((struct language_function *)
14155        ggc_alloc (sizeof (struct language_function)));
14156   memcpy (f, cp_function_chain, sizeof (struct language_function));
14157   DECL_SAVED_FUNCTION_DATA (decl) = f;
14158
14159   /* Clear out the bits we don't need.  */
14160   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14161   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14162   f->x_named_label_uses = NULL;
14163   f->bindings = NULL;
14164   f->x_local_names = NULL;
14165
14166   /* When we get back here again, we will be expanding.  */
14167   f->x_expanding_p = 1;
14168
14169   /* If we've already decided that we cannot inline this function, we
14170      must remember that fact when we actually go to expand the
14171      function.  */
14172   if (current_function_cannot_inline)
14173     {
14174       f->cannot_inline = current_function_cannot_inline;
14175       DECL_INLINE (decl) = 0;
14176     }
14177 }
14178
14179 /* Add a note to mark the beginning of the main body of the constructor.
14180    This is used to set up the data structures for the cleanup regions for
14181    fully-constructed bases and members.  */
14182
14183 static void
14184 begin_constructor_body ()
14185 {
14186 }
14187
14188 /* Add a note to mark the end of the main body of the constructor.  This is
14189    used to end the cleanup regions for fully-constructed bases and
14190    members.  */
14191
14192 static void
14193 finish_constructor_body ()
14194 {
14195 }
14196
14197 /* Do all the processing for the beginning of a destructor; set up the
14198    vtable pointers and cleanups for bases and members.  */
14199
14200 static void
14201 begin_destructor_body ()
14202 {
14203   tree if_stmt;
14204   tree compound_stmt;
14205
14206   /* If the dtor is empty, and we know there is not any possible
14207      way we could use any vtable entries, before they are possibly
14208      set by a base class dtor, we don't have to setup the vtables,
14209      as we know that any base class dtor will set up any vtables
14210      it needs.  We avoid MI, because one base class dtor can do a
14211      virtual dispatch to an overridden function that would need to
14212      have a non-related vtable set up, we cannot avoid setting up
14213      vtables in that case.  We could change this to see if there
14214      is just one vtable.
14215
14216      ??? In the destructor for a class, the vtables are set
14217      appropriately for that class.  There will be no non-related
14218      vtables.  jason 2001-12-11.  */
14219   if_stmt = begin_if_stmt ();
14220
14221   /* If it is not safe to avoid setting up the vtables, then
14222      someone will change the condition to be boolean_true_node.
14223      (Actually, for now, we do not have code to set the condition
14224      appropriately, so we just assume that we always need to
14225      initialize the vtables.)  */
14226   finish_if_stmt_cond (boolean_true_node, if_stmt);
14227
14228   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14229
14230   /* Make all virtual function table pointers in non-virtual base
14231      classes point to CURRENT_CLASS_TYPE's virtual function
14232      tables.  */
14233   initialize_vtbl_ptrs (current_class_ptr);
14234
14235   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14236   finish_then_clause (if_stmt);
14237   finish_if_stmt ();
14238
14239   /* And insert cleanups for our bases and members so that they
14240      will be properly destroyed if we throw.  */
14241   push_base_cleanups ();
14242 }
14243
14244 /* At the end of every destructor we generate code to delete the object if
14245    necessary.  Do that now.  */
14246
14247 static void
14248 finish_destructor_body ()
14249 {
14250   tree exprstmt;
14251
14252   /* Any return from a destructor will end up here; that way all base
14253      and member cleanups will be run when the function returns.  */
14254   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14255
14256   /* In a virtual destructor, we must call delete.  */
14257   if (DECL_VIRTUAL_P (current_function_decl))
14258     {
14259       tree if_stmt;
14260       tree virtual_size = cxx_sizeof (current_class_type);
14261
14262       /* [class.dtor]
14263
14264       At the point of definition of a virtual destructor (including
14265       an implicit definition), non-placement operator delete shall
14266       be looked up in the scope of the destructor's class and if
14267       found shall be accessible and unambiguous.  */
14268       exprstmt = build_op_delete_call
14269         (DELETE_EXPR, current_class_ptr, virtual_size,
14270          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14271
14272       if_stmt = begin_if_stmt ();
14273       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14274                                   current_in_charge_parm,
14275                                   integer_one_node),
14276                            if_stmt);
14277       finish_expr_stmt (exprstmt);
14278       finish_then_clause (if_stmt);
14279       finish_if_stmt ();
14280     }
14281 }
14282
14283 /* Do the necessary processing for the beginning of a function body, which
14284    in this case includes member-initializers, but not the catch clauses of
14285    a function-try-block.  Currently, this means opening a binding level
14286    for the member-initializers (in a ctor) and member cleanups (in a dtor).
14287    In other functions, this isn't necessary, but it doesn't hurt.  */
14288
14289 tree
14290 begin_function_body ()
14291 {
14292   tree stmt;
14293
14294   if (processing_template_decl)
14295     /* Do nothing now.  */;
14296   else
14297     /* Always keep the BLOCK node associated with the outermost pair of
14298        curly braces of a function.  These are needed for correct
14299        operation of dwarfout.c.  */
14300     keep_next_level (1);
14301
14302   stmt = begin_compound_stmt (0);
14303   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14304
14305   if (processing_template_decl)
14306     /* Do nothing now.  */;
14307   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14308     begin_constructor_body ();
14309   else if (DECL_DESTRUCTOR_P (current_function_decl))
14310     begin_destructor_body ();
14311
14312   return stmt;
14313 }
14314
14315 /* Do the processing for the end of a function body.  Currently, this means
14316    closing out the cleanups for fully-constructed bases and members, and in
14317    the case of the destructor, deleting the object if desired.  Again, this
14318    is only meaningful for [cd]tors, since they are the only functions where
14319    there is a significant distinction between the main body and any
14320    function catch clauses.  Handling, say, main() return semantics here
14321    would be wrong, as flowing off the end of a function catch clause for
14322    main() would also need to return 0.  */
14323
14324 void
14325 finish_function_body (compstmt)
14326      tree compstmt;
14327 {
14328   /* Close the block.  */
14329   finish_compound_stmt (0, compstmt);
14330
14331   if (processing_template_decl)
14332     /* Do nothing now.  */;
14333   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14334     finish_constructor_body ();
14335   else if (DECL_DESTRUCTOR_P (current_function_decl))
14336     finish_destructor_body ();
14337 }
14338
14339 /* Finish up a function declaration and compile that function
14340    all the way to assembler language output.  The free the storage
14341    for the function definition.
14342
14343    FLAGS is a bitwise or of the following values:
14344      2 - INCLASS_INLINE
14345        We just finished processing the body of an in-class inline
14346        function definition.  (This processing will have taken place
14347        after the class definition is complete.)  */
14348
14349 tree
14350 finish_function (flags)
14351      int flags;
14352 {
14353   register tree fndecl = current_function_decl;
14354   tree fntype, ctype = NULL_TREE;
14355   int inclass_inline = (flags & 2) != 0;
14356   int nested;
14357
14358   /* When we get some parse errors, we can end up without a
14359      current_function_decl, so cope.  */
14360   if (fndecl == NULL_TREE)
14361     return error_mark_node;
14362
14363   nested = function_depth > 1;
14364   fntype = TREE_TYPE (fndecl);
14365
14366   /*  TREE_READONLY (fndecl) = 1;
14367       This caused &foo to be of type ptr-to-const-function
14368       which then got a warning when stored in a ptr-to-function variable.  */
14369
14370   my_friendly_assert (building_stmt_tree (), 20000911);
14371
14372   finish_fname_decls ();
14373
14374   /* For a cloned function, we've already got all the code we need;
14375      there's no need to add any extra bits.  */
14376   if (!DECL_CLONED_FUNCTION_P (fndecl))
14377     {
14378       if (DECL_MAIN_P (current_function_decl))
14379         {
14380           /* Make it so that `main' always returns 0 by default.  */
14381 #if VMS_TARGET
14382           finish_return_stmt (integer_one_node);
14383 #else
14384           finish_return_stmt (integer_zero_node);
14385 #endif
14386         }
14387
14388       /* Finish dealing with exception specifiers.  */
14389       if (flag_exceptions && !processing_template_decl
14390           && flag_enforce_eh_specs
14391           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14392         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14393                               (TREE_TYPE (current_function_decl)),
14394                               current_eh_spec_block);
14395     }
14396
14397   /* If we're saving up tree structure, tie off the function now.  */
14398   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14399
14400   /* This must come after expand_function_end because cleanups might
14401      have declarations (from inline functions) that need to go into
14402      this function's blocks.  */
14403
14404   /* If the current binding level isn't the outermost binding level
14405      for this function, either there is a bug, or we have experienced
14406      syntax errors and the statement tree is malformed.  */
14407   if (current_binding_level->parm_flag != 1)
14408     {
14409       /* Make sure we have already experienced errors.  */
14410       if (errorcount == 0)
14411         abort ();
14412
14413       /* Throw away the broken statement tree and extra binding
14414          levels.  */
14415       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14416
14417       while (current_binding_level->parm_flag != 1)
14418         {
14419           if (current_binding_level->parm_flag == 2)
14420             pop_nested_class ();
14421           else
14422             poplevel (0, 0, 0);
14423         }
14424     }
14425   poplevel (1, 0, 1);
14426
14427   /* Set up the named return value optimization, if we can.  Here, we
14428      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14429      for the nrv.  genrtl_start_function and declare_return_variable
14430      handle making the nrv and RESULT_DECL share space.  */
14431   if (current_function_return_value)
14432     {
14433       tree r = current_function_return_value;
14434       /* This is only worth doing for fns that return in memory--and
14435          simpler, since we don't have to worry about promoted modes.  */
14436       if (r != error_mark_node
14437           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14438         {
14439           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14440           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14441                                         nullify_returns_r, r);
14442         }
14443       else
14444         /* Clear it so genrtl_start_function and declare_return_variable
14445            know we're not optimizing.  */
14446         current_function_return_value = NULL_TREE;
14447     }
14448
14449   /* Remember that we were in class scope.  */
14450   if (current_class_name)
14451     ctype = current_class_type;
14452
14453   /* Must mark the RESULT_DECL as being in this function.  */
14454   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14455
14456   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14457      to the FUNCTION_DECL node itself.  */
14458   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14459
14460   /* Save away current state, if appropriate.  */
14461   if (!processing_template_decl)
14462     save_function_data (fndecl);
14463
14464   /* If this function calls `setjmp' it cannot be inlined.  When
14465      `longjmp' is called it is not guaranteed to restore the value of
14466      local variables that have been modified since the call to
14467      `setjmp'.  So, if were to inline this function into some caller
14468      `c', then when we `longjmp', we might not restore all variables
14469      in `c'.  (It might seem, at first blush, that there's no way for
14470      this function to modify local variables in `c', but their
14471      addresses may have been stored somewhere accessible to this
14472      function.)  */
14473   if (!processing_template_decl && calls_setjmp_p (fndecl))
14474     DECL_UNINLINABLE (fndecl) = 1;
14475
14476   /* Complain if there's just no return statement.  */
14477   if (warn_return_type
14478       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14479       && !current_function_returns_value && !current_function_returns_null
14480       /* Don't complain if we abort or throw.  */
14481       && !current_function_returns_abnormally
14482       && !DECL_NAME (DECL_RESULT (fndecl))
14483       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
14484          inline function, as we might never be compiled separately.  */
14485       && (DECL_INLINE (fndecl) || processing_template_decl))
14486     warning ("no return statement in function returning non-void");
14487
14488   /* Clear out memory we no longer need.  */
14489   free_after_parsing (cfun);
14490   /* Since we never call rest_of_compilation, we never clear
14491      CFUN.  Do so explicitly.  */
14492   free_after_compilation (cfun);
14493   cfun = NULL;
14494
14495   /* If this is an in-class inline definition, we may have to pop the
14496      bindings for the template parameters that we added in
14497      maybe_begin_member_template_processing when start_function was
14498      called.  */
14499   if (inclass_inline)
14500     maybe_end_member_template_processing ();
14501
14502   /* Leave the scope of the class.  */
14503   if (ctype)
14504     pop_nested_class ();
14505
14506   --function_depth;
14507
14508   /* Clean up.  */
14509   if (! nested)
14510     /* Let the error reporting routines know that we're outside a
14511        function.  For a nested function, this value is used in
14512        cxx_pop_function_context and then reset via pop_function_context.  */
14513     current_function_decl = NULL_TREE;
14514
14515   return fndecl;
14516 }
14517 \f
14518 /* Create the FUNCTION_DECL for a function definition.
14519    DECLSPECS and DECLARATOR are the parts of the declaration;
14520    they describe the return type and the name of the function,
14521    but twisted together in a fashion that parallels the syntax of C.
14522
14523    This function creates a binding context for the function body
14524    as well as setting up the FUNCTION_DECL in current_function_decl.
14525
14526    Returns a FUNCTION_DECL on success.
14527
14528    If the DECLARATOR is not suitable for a function (it defines a datum
14529    instead), we return 0, which tells yyparse to report a parse error.
14530
14531    May return void_type_node indicating that this method is actually
14532    a friend.  See grokfield for more details.
14533
14534    Came here with a `.pushlevel' .
14535
14536    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14537    CHANGES TO CODE IN `grokfield'.  */
14538
14539 tree
14540 start_method (declspecs, declarator, attrlist)
14541      tree declarator, declspecs, attrlist;
14542 {
14543   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14544                                 &attrlist);
14545
14546   if (fndecl == error_mark_node)
14547     return error_mark_node;
14548
14549   if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14550     {
14551       error ("invalid member function declaration");
14552       return error_mark_node;
14553     }
14554
14555   if (attrlist)
14556     cplus_decl_attributes (&fndecl, attrlist, 0);
14557
14558   /* Pass friends other than inline friend functions back.  */
14559   if (fndecl == void_type_node)
14560     return fndecl;
14561
14562   if (DECL_IN_AGGR_P (fndecl))
14563     {
14564       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14565         {
14566           if (DECL_CONTEXT (fndecl)
14567               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14568             error ("`%D' is already defined in class `%T'", fndecl,
14569                       DECL_CONTEXT (fndecl));
14570         }
14571       return void_type_node;
14572     }
14573
14574   check_template_shadow (fndecl);
14575
14576   DECL_DECLARED_INLINE_P (fndecl) = 1;
14577
14578   if (flag_default_inline)
14579     DECL_INLINE (fndecl) = 1;
14580
14581   /* We process method specializations in finish_struct_1.  */
14582   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14583     fndecl = push_template_decl (fndecl);
14584
14585   if (! DECL_FRIEND_P (fndecl))
14586     {
14587       if (TREE_CHAIN (fndecl))
14588         {
14589           fndecl = copy_node (fndecl);
14590           TREE_CHAIN (fndecl) = NULL_TREE;
14591         }
14592       grok_special_member_properties (fndecl);
14593     }
14594
14595   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14596
14597   /* Make a place for the parms */
14598   pushlevel (0);
14599   current_binding_level->parm_flag = 1;
14600
14601   DECL_IN_AGGR_P (fndecl) = 1;
14602   return fndecl;
14603 }
14604
14605 /* Go through the motions of finishing a function definition.
14606    We don't compile this method until after the whole class has
14607    been processed.
14608
14609    FINISH_METHOD must return something that looks as though it
14610    came from GROKFIELD (since we are defining a method, after all).
14611
14612    This is called after parsing the body of the function definition.
14613    STMTS is the chain of statements that makes up the function body.
14614
14615    DECL is the ..._DECL that `start_method' provided.  */
14616
14617 tree
14618 finish_method (decl)
14619      tree decl;
14620 {
14621   register tree fndecl = decl;
14622   tree old_initial;
14623
14624   register tree link;
14625
14626   if (decl == void_type_node)
14627     return decl;
14628
14629   old_initial = DECL_INITIAL (fndecl);
14630
14631   /* Undo the level for the parms (from start_method).
14632      This is like poplevel, but it causes nothing to be
14633      saved.  Saving information here confuses symbol-table
14634      output routines.  Besides, this information will
14635      be correctly output when this method is actually
14636      compiled.  */
14637
14638   /* Clear out the meanings of the local variables of this level;
14639      also record in each decl which block it belongs to.  */
14640
14641   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14642     {
14643       if (DECL_NAME (link) != NULL_TREE)
14644         pop_binding (DECL_NAME (link), link);
14645       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14646       DECL_CONTEXT (link) = NULL_TREE;
14647     }
14648
14649   poplevel (0, 0, 0);
14650
14651   DECL_INITIAL (fndecl) = old_initial;
14652
14653   /* We used to check if the context of FNDECL was different from
14654      current_class_type as another way to get inside here.  This didn't work
14655      for String.cc in libg++.  */
14656   if (DECL_FRIEND_P (fndecl))
14657     {
14658       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14659         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14660       decl = void_type_node;
14661     }
14662
14663   return decl;
14664 }
14665 \f
14666
14667 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
14668    we can lay it out later, when and if its type becomes complete.  */
14669
14670 void
14671 maybe_register_incomplete_var (var)
14672      tree var;
14673 {
14674   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14675
14676   /* Keep track of variables with incomplete types.  */
14677   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14678       && DECL_EXTERNAL (var))
14679     {
14680       tree inner_type = TREE_TYPE (var);
14681
14682       while (TREE_CODE (inner_type) == ARRAY_TYPE)
14683         inner_type = TREE_TYPE (inner_type);
14684       inner_type = TYPE_MAIN_VARIANT (inner_type);
14685
14686       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14687           /* RTTI TD entries are created while defining the type_info.  */
14688           || (TYPE_LANG_SPECIFIC (inner_type)
14689               && TYPE_BEING_DEFINED (inner_type)))
14690         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14691     }
14692 }
14693
14694 /* Called when a class type (given by TYPE) is defined.  If there are
14695    any existing VAR_DECLs whose type hsa been completed by this
14696    declaration, update them now.  */
14697
14698 void
14699 complete_vars (type)
14700      tree type;
14701 {
14702   tree *list = &incomplete_vars;
14703
14704   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14705   while (*list)
14706     {
14707       if (same_type_p (type, TREE_PURPOSE (*list)))
14708         {
14709           tree var = TREE_VALUE (*list);
14710           /* Complete the type of the variable.  The VAR_DECL itself
14711              will be laid out in expand_expr.  */
14712           complete_type (TREE_TYPE (var));
14713           /* Remove this entry from the list.  */
14714           *list = TREE_CHAIN (*list);
14715         }
14716       else
14717         list = &TREE_CHAIN (*list);
14718     }
14719 }
14720
14721 /* If DECL is of a type which needs a cleanup, build that cleanup
14722    here.  */
14723
14724 tree
14725 cxx_maybe_build_cleanup (decl)
14726      tree decl;
14727 {
14728   tree type = TREE_TYPE (decl);
14729
14730   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14731     {
14732       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14733       tree rval;
14734
14735       if (TREE_CODE (type) == ARRAY_TYPE)
14736         rval = decl;
14737       else
14738         {
14739           cxx_mark_addressable (decl);
14740           rval = build_unary_op (ADDR_EXPR, decl, 0);
14741         }
14742
14743       /* Optimize for space over speed here.  */
14744       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14745           || flag_expensive_optimizations)
14746         flags |= LOOKUP_NONVIRTUAL;
14747
14748       rval = build_delete (TREE_TYPE (rval), rval,
14749                            sfk_complete_destructor, flags, 0);
14750
14751       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14752           && ! TYPE_HAS_DESTRUCTOR (type))
14753         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14754                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14755
14756       return rval;
14757     }
14758   return NULL_TREE;
14759 }
14760 \f
14761 /* When a stmt has been parsed, this function is called.  */
14762
14763 void
14764 finish_stmt ()
14765 {
14766   /* Always assume this statement was not an expression statement.  If
14767      it actually was an expression statement, its our callers
14768      responsibility to fix this up.  */
14769   last_expr_type = NULL_TREE;
14770 }
14771
14772 /* DECL was originally constructed as a non-static member function,
14773    but turned out to be static.  Update it accordingly.  */
14774
14775 void
14776 revert_static_member_fn (decl)
14777      tree decl;
14778 {
14779   tree tmp;
14780   tree function = TREE_TYPE (decl);
14781   tree args = TYPE_ARG_TYPES (function);
14782
14783   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14784       != TYPE_UNQUALIFIED)
14785     error ("static member function `%#D' declared with type qualifiers",
14786               decl);
14787
14788   args = TREE_CHAIN (args);
14789   tmp = build_function_type (TREE_TYPE (function), args);
14790   tmp = build_qualified_type (tmp, cp_type_quals (function));
14791   tmp = build_exception_variant (tmp,
14792                                  TYPE_RAISES_EXCEPTIONS (function));
14793   TREE_TYPE (decl) = tmp;
14794   if (DECL_ARGUMENTS (decl))
14795     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14796   DECL_STATIC_FUNCTION_P (decl) = 1;
14797 }
14798
14799 /* Initialize the variables used during compilation of a C++
14800    function.  */
14801
14802 void
14803 cxx_push_function_context (f)
14804      struct function *f;
14805 {
14806   struct language_function *p
14807     = ((struct language_function *)
14808        ggc_alloc_cleared (sizeof (struct language_function)));
14809   f->language = p;
14810
14811   /* It takes an explicit call to expand_body to generate RTL for a
14812      function.  */
14813   expanding_p = 0;
14814
14815   /* Whenever we start a new function, we destroy temporaries in the
14816      usual way.  */
14817   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14818 }
14819
14820 /* Free the language-specific parts of F, now that we've finished
14821    compiling the function.  */
14822
14823 void
14824 cxx_pop_function_context (f)
14825      struct function *f;
14826 {
14827   f->language = 0;
14828 }
14829
14830 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14831    one of the language-independent trees.  */
14832
14833 enum cp_tree_node_structure_enum
14834 cp_tree_node_structure (t)
14835      union lang_tree_node *t;
14836 {
14837   switch (TREE_CODE (&t->generic))
14838     {
14839     case DEFAULT_ARG:           return TS_CP_DEFAULT_ARG;
14840     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
14841     case CPLUS_BINDING:         return TS_CP_BINDING;
14842     case OVERLOAD:              return TS_CP_OVERLOAD;
14843     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
14844     case PTRMEM_CST:            return TS_CP_PTRMEM;
14845     case WRAPPER:               return TS_CP_WRAPPER;
14846     case SRCLOC:                return TS_CP_SRCLOC;
14847     default:                    return TS_CP_GENERIC;
14848     }
14849 }
14850
14851 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14852    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14853
14854 tree
14855 identifier_global_value (t)
14856      tree t;
14857 {
14858   return IDENTIFIER_GLOBAL_VALUE (t);
14859 }
14860
14861 /* Build the void_list_node (void_type_node having been created).  */
14862 tree
14863 build_void_list_node ()
14864 {
14865   tree t = build_tree_list (NULL_TREE, void_type_node);
14866   TREE_PARMLIST (t) = 1;
14867   return t;
14868 }
14869
14870 static int
14871 cp_missing_noreturn_ok_p (decl)
14872      tree decl;
14873 {
14874   /* A missing noreturn is ok for the `main' function.  */
14875   return DECL_MAIN_P (decl);
14876 }
14877
14878 #include "gt-cp-decl.h"
14879 #include "gtype-cp.h"