gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "tree-inline.h"
  39 #include "decl.h"
  40 #include "lex.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "ggc.h"
  46 #include "tm_p.h"
  47 #include "target.h"
  48 #include "c-common.h"
  49 #include "c-pragma.h"
  50 #include "diagnostic.h"
  51
  52 extern const struct attribute_spec *lang_attribute_table;
  53
  54 static tree grokparms                           PARAMS ((tree));
  55 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  56
  57 static void push_binding_level PARAMS ((struct binding_level *, int,
  58                                       int));
  59 static void pop_binding_level PARAMS ((void));
  60 static void suspend_binding_level PARAMS ((void));
  61 static void resume_binding_level PARAMS ((struct binding_level *));
  62 static struct binding_level *make_binding_level PARAMS ((void));
  63 static void declare_namespace_level PARAMS ((void));
  64 static int decl_jump_unsafe PARAMS ((tree));
  65 static void storedecls PARAMS ((tree));
  66 static void require_complete_types_for_parms PARAMS ((tree));
  67 static int ambi_op_p PARAMS ((enum tree_code));
  68 static int unary_op_p PARAMS ((enum tree_code));
  69 static tree store_bindings PARAMS ((tree, tree));
  70 static tree lookup_tag_reverse PARAMS ((tree, tree));
  71 static tree obscure_complex_init PARAMS ((tree, tree));
  72 static tree lookup_name_real PARAMS ((tree, int, int, int));
  73 static void push_local_name PARAMS ((tree));
  74 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  75 static tree grok_reference_init PARAMS ((tree, tree, tree));
  76 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  77                               enum overload_flags, tree,
  78                               tree, int, int, int, int, int, int, tree));
  79 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  80 static tree follow_tag_typedef PARAMS ((tree));
  81 static tree lookup_tag PARAMS ((enum tree_code, tree,
  82                               struct binding_level *, int));
  83 static void set_identifier_type_value_with_scope
  84         PARAMS ((tree, tree, struct binding_level *));
  85 static void record_unknown_type PARAMS ((tree, const char *));
  86 static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
  87                                       enum built_in_class, const char *));
  88 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  89 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  90 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  91                                   int));
  92 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  93 static void check_for_uninitialized_const_var PARAMS ((tree));
  94 static unsigned long typename_hash PARAMS ((hash_table_key));
  95 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  96 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  97 static int add_binding PARAMS ((tree, tree));
  98 static void pop_binding PARAMS ((tree, tree));
  99 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 100 static tree find_binding PARAMS ((tree, tree));
 101 static tree select_decl PARAMS ((tree, int));
 102 static int lookup_flags PARAMS ((int, int));
 103 static tree qualify_lookup PARAMS ((tree, int));
 104 static tree record_builtin_java_type PARAMS ((const char *, int));
 105 static const char *tag_name PARAMS ((enum tag_types code));
 106 static void find_class_binding_level PARAMS ((void));
 107 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 108 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 109 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 110 static int walk_globals_r PARAMS ((tree, void *));
 111 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 112 static tree make_label_decl PARAMS ((tree, int));
 113 static void use_label PARAMS ((tree));
 114 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 115                                            const char *, int));
 116 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 117 static void check_switch_goto PARAMS ((struct binding_level *));
 118 static void check_previous_gotos PARAMS ((tree));
 119 static void pop_label PARAMS ((tree, tree));
 120 static void pop_labels PARAMS ((tree));
 121 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 122 static void layout_var_decl PARAMS ((tree));
 123 static void maybe_commonize_var PARAMS ((tree));
 124 static tree check_initializer PARAMS ((tree, tree));
 125 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 126 static void push_cp_function_context PARAMS ((struct function *));
 127 static void pop_cp_function_context PARAMS ((struct function *));
 128 static void mark_binding_level PARAMS ((void *));
 129 static void mark_named_label_lists PARAMS ((void *, void *));
 130 static void mark_cp_function_context PARAMS ((struct function *));
 131 static void mark_saved_scope PARAMS ((void *));
 132 static void mark_lang_function PARAMS ((struct cp_language_function *));
 133 static void save_function_data PARAMS ((tree));
 134 static void check_function_type PARAMS ((tree, tree));
 135 static void destroy_local_var PARAMS ((tree));
 136 static void begin_constructor_body PARAMS ((void));
 137 static void finish_constructor_body PARAMS ((void));
 138 static void begin_destructor_body PARAMS ((void));
 139 static void finish_destructor_body PARAMS ((void));
 140 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 141 static tree get_atexit_node PARAMS ((void));
 142 static tree get_dso_handle_node PARAMS ((void));
 143 static tree start_cleanup_fn PARAMS ((void));
 144 static void end_cleanup_fn PARAMS ((void));
 145 static tree cp_make_fname_decl PARAMS ((tree, int));
 146 static void initialize_predefined_identifiers PARAMS ((void));
 147 static tree check_special_function_return_type
 148   PARAMS ((special_function_kind, tree, tree));
 149 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 150 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 151 static void store_parm_decls PARAMS ((tree));
 152 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 153
 154 #if defined (DEBUG_CP_BINDING_LEVELS)
 155 static void indent PARAMS ((void));
 156 #endif
 157
 158 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 159 tree error_mark_list;
 160
 161 /* The following symbols are subsumed in the cp_global_trees array, and
 162    listed here individually for documentation purposes.
 163
 164    C++ extensions
 165         tree wchar_decl_node;
 166
 167         tree vtable_entry_type;
 168         tree delta_type_node;
 169         tree __t_desc_type_node;
 170         tree ti_desc_type_node;
 171         tree bltn_desc_type_node, ptr_desc_type_node;
 172         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 173         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 174         tree ptm_desc_type_node;
 175         tree base_desc_type_node;
 176
 177         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 178         tree unknown_type_node;
 179
 180    Array type `vtable_entry_type[]'
 181
 182         tree vtbl_type_node;
 183         tree vtbl_ptr_type_node;
 184
 185    Namespaces,
 186
 187         tree std_node;
 188         tree abi_node;
 189
 190    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 191    one that the user will declare, but sufficient to be called
 192    by routines that want to abort the program.
 193
 194         tree abort_fndecl;
 195
 196    The FUNCTION_DECL for the default `::operator delete'.
 197
 198         tree global_delete_fndecl;
 199
 200    Used by RTTI
 201         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 202         tree tinfo_var_id;
 203
 204 */
 205
 206 tree cp_global_trees[CPTI_MAX];
 207
 208 /* Indicates that there is a type value in some namespace, although
 209    that is not necessarily in scope at the moment.  */
 210
 211 static tree global_type_node;
 212
 213 /* Expect only namespace names now. */
 214 static int only_namespace_names;
 215
 216 /* Used only for jumps to as-yet undefined labels, since jumps to
 217    defined labels can have their validity checked immediately.  */
 218
 219 struct named_label_use_list
 220 {
 221   struct binding_level *binding_level;
 222   tree names_in_scope;
 223   tree label_decl;
 224   const char *filename_o_goto;
 225   int lineno_o_goto;
 226   struct named_label_use_list *next;
 227 };
 228
 229 #define named_label_uses cp_function_chain->x_named_label_uses
 230
 231 #define local_names cp_function_chain->x_local_names
 232
 233 /* A list of objects which have constructors or destructors
 234    which reside in the global scope.  The decl is stored in
 235    the TREE_VALUE slot and the initializer is stored
 236    in the TREE_PURPOSE slot.  */
 237 tree static_aggregates;
 238
 239 /* -- end of C++ */
 240
 241 /* A node for the integer constants 2, and 3.  */
 242
 243 tree integer_two_node, integer_three_node;
 244
 245 /* Similar, for last_function_parm_tags.  */
 246 tree last_function_parms;
 247
 248 /* A list of all LABEL_DECLs in the function that have names.  Here so
 249    we can clear out their names' definitions at the end of the
 250    function, and so we can check the validity of jumps to these labels.  */
 251
 252 struct named_label_list
 253 {
 254   struct binding_level *binding_level;
 255   tree names_in_scope;
 256   tree old_value;
 257   tree label_decl;
 258   tree bad_decls;
 259   struct named_label_list *next;
 260   unsigned int in_try_scope : 1;
 261   unsigned int in_catch_scope : 1;
 262 };
 263
 264 #define named_labels cp_function_chain->x_named_labels
 265
 266 /* Nonzero means use the ISO C94 dialect of C.  */
 267
 268 int flag_isoc94;
 269
 270 /* Nonzero means use the ISO C99 dialect of C.  */
 271
 272 int flag_isoc99;
 273
 274 /* Nonzero means we are a hosted implementation for code shared with C.  */
 275
 276 int flag_hosted = 1;
 277
 278 /* Nonzero means add default format_arg attributes for functions not
 279    in ISO C.  */
 280
 281 int flag_noniso_default_format_attributes = 1;
 282
 283 /* Nonzero if we want to conserve space in the .o files.  We do this
 284    by putting uninitialized data and runtime initialized data into
 285    .common instead of .data at the expense of not flagging multiple
 286    definitions.  */
 287 extern int flag_conserve_space;
 288 \f
 289 /* C and C++ flags are in decl2.c.  */
 290
 291 /* A expression of value 0 with the same precision as a sizetype
 292    node, but signed.  */
 293 tree signed_size_zero_node;
 294
 295 /* The name of the anonymous namespace, throughout this translation
 296    unit.  */
 297 tree anonymous_namespace_name;
 298
 299 /* The number of function bodies which we are currently processing.
 300    (Zero if we are at namespace scope, one inside the body of a
 301    function, two inside the body of a function in a local class, etc.)  */
 302 int function_depth;
 303
 304 /* States indicating how grokdeclarator() should handle declspecs marked
 305    with __attribute__((deprecated)).  An object declared as
 306    __attribute__((deprecated)) suppresses warnings of uses of other
 307    deprecated items.  */
 308
 309 enum deprecated_states {
 310   DEPRECATED_NORMAL,
 311   DEPRECATED_SUPPRESS
 312 };
 313
 314 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 315
 316 /* Set by add_implicitly_declared_members() to keep those members from
 317    being flagged as deprecated or reported as using deprecated
 318    types.  */
 319 int adding_implicit_members = 0;
 320 \f
 321 /* For each binding contour we allocate a binding_level structure
 322    which records the names defined in that contour.
 323    Contours include:
 324     0) the global one
 325     1) one for each function definition,
 326        where internal declarations of the parameters appear.
 327     2) one for each compound statement,
 328        to record its declarations.
 329
 330    The current meaning of a name can be found by searching the levels
 331    from the current one out to the global one.
 332
 333    Off to the side, may be the class_binding_level.  This exists only
 334    to catch class-local declarations.  It is otherwise nonexistent.
 335
 336    Also there may be binding levels that catch cleanups that must be
 337    run when exceptions occur.  Thus, to see whether a name is bound in
 338    the current scope, it is not enough to look in the
 339    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 340    instead.  */
 341
 342 /* Note that the information in the `names' component of the global contour
 343    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 344
 345 struct binding_level
 346   {
 347     /* A chain of _DECL nodes for all variables, constants, functions,
 348        and typedef types.  These are in the reverse of the order
 349        supplied.  There may be OVERLOADs on this list, too, but they
 350        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 351     tree names;
 352
 353     /* A list of structure, union and enum definitions, for looking up
 354        tag names.
 355        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 356        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 357        or ENUMERAL_TYPE node.
 358
 359        C++: the TREE_VALUE nodes can be simple types for
 360        component_bindings.  */
 361     tree tags;
 362
 363     /* A list of USING_DECL nodes. */
 364     tree usings;
 365
 366     /* A list of used namespaces. PURPOSE is the namespace,
 367        VALUE the common ancestor with this binding_level's namespace. */
 368     tree using_directives;
 369
 370     /* If this binding level is the binding level for a class, then
 371        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 372        is the name of an entity bound in the class.  The TREE_TYPE is
 373        the DECL bound by this name in the class.  */
 374     tree class_shadowed;
 375
 376     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 377        is used for all binding levels. In addition the TREE_VALUE is the
 378        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 379     tree type_shadowed;
 380
 381     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 382        label in this scope.  The TREE_PURPOSE is the previous value of
 383        the IDENTIFIER_LABEL VALUE.  */
 384     tree shadowed_labels;
 385
 386     /* For each level (except not the global one),
 387        a chain of BLOCK nodes for all the levels
 388        that were entered and exited one level down.  */
 389     tree blocks;
 390
 391     /* The _TYPE node for this level, if parm_flag == 2.  */
 392     tree this_class;
 393
 394     /* The binding level which this one is contained in (inherits from).  */
 395     struct binding_level *level_chain;
 396
 397     /* List of VAR_DECLS saved from a previous for statement.
 398        These would be dead in ISO-conforming code, but might
 399        be referenced in ARM-era code.  These are stored in a
 400        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 401     tree dead_vars_from_for;
 402
 403     /* 1 for the level that holds the parameters of a function.
 404        2 for the level that holds a class declaration.  */
 405     unsigned parm_flag : 2;
 406
 407     /* 1 means make a BLOCK for this level regardless of all else.
 408        2 for temporary binding contours created by the compiler.  */
 409     unsigned keep : 2;
 410
 411     /* Nonzero if this level "doesn't exist" for tags.  */
 412     unsigned tag_transparent : 1;
 413
 414     /* Nonzero if this level can safely have additional
 415        cleanup-needing variables added to it.  */
 416     unsigned more_cleanups_ok : 1;
 417     unsigned have_cleanups : 1;
 418
 419     /* Nonzero if this scope is for storing the decls for template
 420        parameters and generic decls; these decls will be discarded and
 421        replaced with a TEMPLATE_DECL.  */
 422     unsigned template_parms_p : 1;
 423
 424     /* Nonzero if this scope corresponds to the `<>' in a
 425        `template <>' clause.  Whenever this flag is set,
 426        TEMPLATE_PARMS_P will be set as well.  */
 427     unsigned template_spec_p : 1;
 428
 429     /* This is set for a namespace binding level.  */
 430     unsigned namespace_p : 1;
 431
 432     /* True if this level is that of a for-statement where we need to
 433        worry about ambiguous (ARM or ISO) scope rules.  */
 434     unsigned is_for_scope : 1;
 435
 436     /* True if this level corresponds to a TRY block.  Currently this
 437        information is only available while building the tree structure.  */
 438     unsigned is_try_scope : 1;
 439
 440     /* True if this level corresponds to a CATCH block.  Currently this
 441        information is only available while building the tree structure.  */
 442     unsigned is_catch_scope : 1;
 443
 444     /* Three bits left for this word.  */
 445
 446 #if defined(DEBUG_CP_BINDING_LEVELS)
 447     /* Binding depth at which this level began.  */
 448     unsigned binding_depth;
 449 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 450   };
 451
 452 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 453
 454 /* The binding level currently in effect.  */
 455
 456 #define current_binding_level                   \
 457   (cfun && cp_function_chain->bindings          \
 458    ? cp_function_chain->bindings                \
 459    : scope_chain->bindings)
 460
 461 /* The binding level of the current class, if any.  */
 462
 463 #define class_binding_level scope_chain->class_bindings
 464
 465 /* A chain of binding_level structures awaiting reuse.  */
 466
 467 static struct binding_level *free_binding_level;
 468
 469 /* The outermost binding level, for names of file scope.
 470    This is created when the compiler is started and exists
 471    through the entire run.  */
 472
 473 static struct binding_level *global_binding_level;
 474
 475 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 476
 477 static int keep_next_level_flag;
 478
 479 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 480    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 481    time the VAR_DECL was declared, the type was incomplete.  */
 482
 483 static tree incomplete_vars;
 484
 485 #if defined(DEBUG_CP_BINDING_LEVELS)
 486 static int binding_depth = 0;
 487 static int is_class_level = 0;
 488
 489 static void
 490 indent ()
 491 {
 492   register unsigned i;
 493
 494   for (i = 0; i < binding_depth*2; i++)
 495     putc (' ', stderr);
 496 }
 497 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 498
 499 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 500
 501 static void
 502 push_binding_level (newlevel, tag_transparent, keep)
 503      struct binding_level *newlevel;
 504      int tag_transparent, keep;
 505 {
 506   /* Add this level to the front of the chain (stack) of levels that
 507      are active.  */
 508   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 509   newlevel->level_chain = current_binding_level;
 510   current_binding_level = newlevel;
 511   newlevel->tag_transparent = tag_transparent;
 512   newlevel->more_cleanups_ok = 1;
 513
 514   newlevel->keep = keep;
 515 #if defined(DEBUG_CP_BINDING_LEVELS)
 516   newlevel->binding_depth = binding_depth;
 517   indent ();
 518   fprintf (stderr, "push %s level 0x%08x line %d\n",
 519            (is_class_level) ? "class" : "block", newlevel, lineno);
 520   is_class_level = 0;
 521   binding_depth++;
 522 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 523 }
 524
 525 /* Find the innermost enclosing class scope, and reset
 526    CLASS_BINDING_LEVEL appropriately.  */
 527
 528 static void
 529 find_class_binding_level ()
 530 {
 531   struct binding_level *level = current_binding_level;
 532
 533   while (level && level->parm_flag != 2)
 534     level = level->level_chain;
 535   if (level && level->parm_flag == 2)
 536     class_binding_level = level;
 537   else
 538     class_binding_level = 0;
 539 }
 540
 541 static void
 542 pop_binding_level ()
 543 {
 544   if (global_binding_level)
 545     {
 546       /* Cannot pop a level, if there are none left to pop.  */
 547       if (current_binding_level == global_binding_level)
 548         abort ();
 549     }
 550   /* Pop the current level, and free the structure for reuse.  */
 551 #if defined(DEBUG_CP_BINDING_LEVELS)
 552   binding_depth--;
 553   indent ();
 554   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 555           (is_class_level) ? "class" : "block",
 556           current_binding_level, lineno);
 557   if (is_class_level != (current_binding_level == class_binding_level))
 558     {
 559       indent ();
 560       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 561     }
 562   is_class_level = 0;
 563 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 564   {
 565     register struct binding_level *level = current_binding_level;
 566     current_binding_level = current_binding_level->level_chain;
 567     level->level_chain = free_binding_level;
 568 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 569     if (level->binding_depth != binding_depth)
 570       abort ();
 571 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 572     free_binding_level = level;
 573     find_class_binding_level ();
 574   }
 575 }
 576
 577 static void
 578 suspend_binding_level ()
 579 {
 580   if (class_binding_level)
 581     current_binding_level = class_binding_level;
 582
 583   if (global_binding_level)
 584     {
 585       /* Cannot suspend a level, if there are none left to suspend.  */
 586       if (current_binding_level == global_binding_level)
 587         abort ();
 588     }
 589   /* Suspend the current level.  */
 590 #if defined(DEBUG_CP_BINDING_LEVELS)
 591   binding_depth--;
 592   indent ();
 593   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 594           (is_class_level) ? "class" : "block",
 595           current_binding_level, lineno);
 596   if (is_class_level != (current_binding_level == class_binding_level))
 597     {
 598       indent ();
 599       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 600     }
 601   is_class_level = 0;
 602 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 603   current_binding_level = current_binding_level->level_chain;
 604   find_class_binding_level ();
 605 }
 606
 607 static void
 608 resume_binding_level (b)
 609      struct binding_level *b;
 610 {
 611   /* Resuming binding levels is meant only for namespaces,
 612      and those cannot nest into classes. */
 613   my_friendly_assert(!class_binding_level, 386);
 614   /* Also, resuming a non-directly nested namespace is a no-no.  */
 615   my_friendly_assert(b->level_chain == current_binding_level, 386);
 616   current_binding_level = b;
 617 #if defined(DEBUG_CP_BINDING_LEVELS)
 618   b->binding_depth = binding_depth;
 619   indent ();
 620   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 621            (is_class_level) ? "class" : "block", b, lineno);
 622   is_class_level = 0;
 623   binding_depth++;
 624 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 625 }
 626 \f
 627 /* Create a new `struct binding_level'.  */
 628
 629 static
 630 struct binding_level *
 631 make_binding_level ()
 632 {
 633   /* NOSTRICT */
 634   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 635 }
 636
 637 /* Nonzero if we are currently in the global binding level.  */
 638
 639 int
 640 global_bindings_p ()
 641 {
 642   return current_binding_level == global_binding_level;
 643 }
 644
 645 /* Return the innermost binding level that is not for a class scope.  */
 646
 647 static struct binding_level *
 648 innermost_nonclass_level ()
 649 {
 650   struct binding_level *b;
 651
 652   b = current_binding_level;
 653   while (b->parm_flag == 2)
 654     b = b->level_chain;
 655
 656   return b;
 657 }
 658
 659 /* Nonzero if we are currently in a toplevel binding level.  This
 660    means either the global binding level or a namespace in a toplevel
 661    binding level.  Since there are no non-toplevel namespace levels,
 662    this really means any namespace or template parameter level.  We
 663    also include a class whose context is toplevel.  */
 664
 665 int
 666 toplevel_bindings_p ()
 667 {
 668   struct binding_level *b = innermost_nonclass_level ();
 669
 670   return b->namespace_p || b->template_parms_p;
 671 }
 672
 673 /* Nonzero if this is a namespace scope, or if we are defining a class
 674    which is itself at namespace scope, or whose enclosing class is
 675    such a class, etc.  */
 676
 677 int
 678 namespace_bindings_p ()
 679 {
 680   struct binding_level *b = innermost_nonclass_level ();
 681
 682   return b->namespace_p;
 683 }
 684
 685 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 686    unconditionally.  Otherwise, use the normal logic to decide whether
 687    or not to create a BLOCK.  */
 688
 689 void
 690 keep_next_level (keep)
 691      int keep;
 692 {
 693   keep_next_level_flag = keep;
 694 }
 695
 696 /* Nonzero if the current level needs to have a BLOCK made.  */
 697
 698 int
 699 kept_level_p ()
 700 {
 701   return (current_binding_level->blocks != NULL_TREE
 702           || current_binding_level->keep
 703           || current_binding_level->names != NULL_TREE
 704           || (current_binding_level->tags != NULL_TREE
 705               && !current_binding_level->tag_transparent));
 706 }
 707
 708 static void
 709 declare_namespace_level ()
 710 {
 711   current_binding_level->namespace_p = 1;
 712 }
 713
 714 /* Returns non-zero if this scope was created to store template
 715    parameters.  */
 716
 717 int
 718 template_parm_scope_p ()
 719 {
 720   return current_binding_level->template_parms_p;
 721 }
 722
 723 /* Returns the kind of template specialization we are currently
 724    processing, given that it's declaration contained N_CLASS_SCOPES
 725    explicit scope qualifications.  */
 726
 727 tmpl_spec_kind
 728 current_tmpl_spec_kind (n_class_scopes)
 729      int n_class_scopes;
 730 {
 731   int n_template_parm_scopes = 0;
 732   int seen_specialization_p = 0;
 733   int innermost_specialization_p = 0;
 734   struct binding_level *b;
 735
 736   /* Scan through the template parameter scopes.  */
 737   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 738     {
 739       /* If we see a specialization scope inside a parameter scope,
 740          then something is wrong.  That corresponds to a declaration
 741          like:
 742
 743             template <class T> template <> ...
 744
 745          which is always illegal since [temp.expl.spec] forbids the
 746          specialization of a class member template if the enclosing
 747          class templates are not explicitly specialized as well.  */
 748       if (b->template_spec_p)
 749         {
 750           if (n_template_parm_scopes == 0)
 751             innermost_specialization_p = 1;
 752           else
 753             seen_specialization_p = 1;
 754         }
 755       else if (seen_specialization_p == 1)
 756         return tsk_invalid_member_spec;
 757
 758       ++n_template_parm_scopes;
 759     }
 760
 761   /* Handle explicit instantiations.  */
 762   if (processing_explicit_instantiation)
 763     {
 764       if (n_template_parm_scopes != 0)
 765         /* We've seen a template parameter list during an explicit
 766            instantiation.  For example:
 767
 768              template <class T> template void f(int);
 769
 770            This is erroneous.  */
 771         return tsk_invalid_expl_inst;
 772       else
 773         return tsk_expl_inst;
 774     }
 775
 776   if (n_template_parm_scopes < n_class_scopes)
 777     /* We've not seen enough template headers to match all the
 778        specialized classes present.  For example:
 779
 780          template <class T> void R<T>::S<T>::f(int);
 781
 782        This is illegal; there needs to be one set of template
 783        parameters for each class.  */
 784     return tsk_insufficient_parms;
 785   else if (n_template_parm_scopes == n_class_scopes)
 786     /* We're processing a non-template declaration (even though it may
 787        be a member of a template class.)  For example:
 788
 789          template <class T> void S<T>::f(int);
 790
 791        The `class T' maches the `S<T>', leaving no template headers
 792        corresponding to the `f'.  */
 793     return tsk_none;
 794   else if (n_template_parm_scopes > n_class_scopes + 1)
 795     /* We've got too many template headers.  For example:
 796
 797          template <> template <class T> void f (T);
 798
 799        There need to be more enclosing classes.  */
 800     return tsk_excessive_parms;
 801   else
 802     /* This must be a template.  It's of the form:
 803
 804          template <class T> template <class U> void S<T>::f(U);
 805
 806        This is a specialization if the innermost level was a
 807        specialization; otherwise it's just a definition of the
 808        template.  */
 809     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 810 }
 811
 812 void
 813 set_class_shadows (shadows)
 814      tree shadows;
 815 {
 816   class_binding_level->class_shadowed = shadows;
 817 }
 818
 819 /* Enter a new binding level.
 820    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 821    not for that of tags.  */
 822
 823 void
 824 pushlevel (tag_transparent)
 825      int tag_transparent;
 826 {
 827   struct binding_level *newlevel;
 828
 829   if (cfun && !doing_semantic_analysis_p ())
 830     return;
 831
 832   /* Reuse or create a struct for this binding level.  */
 833 #if defined(DEBUG_CP_BINDING_LEVELS)
 834   if (0)
 835 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 836   if (free_binding_level)
 837 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 838     {
 839       newlevel = free_binding_level;
 840       free_binding_level = free_binding_level->level_chain;
 841     }
 842   else
 843     newlevel = make_binding_level ();
 844
 845   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 846   keep_next_level_flag = 0;
 847 }
 848
 849 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 850    we're not allowed to add any more objects with cleanups to the current
 851    scope, create a new binding level.  */
 852
 853 void
 854 maybe_push_cleanup_level (type)
 855      tree type;
 856 {
 857   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 858       && current_binding_level->more_cleanups_ok == 0)
 859     {
 860       keep_next_level (2);
 861       pushlevel (1);
 862       clear_last_expr ();
 863       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 864     }
 865 }
 866
 867 /* Enter a new scope.  The KIND indicates what kind of scope is being
 868    created.  */
 869
 870 void
 871 begin_scope (sk)
 872      scope_kind sk;
 873 {
 874   pushlevel (0);
 875
 876   switch (sk)
 877     {
 878     case sk_template_spec:
 879       current_binding_level->template_spec_p = 1;
 880       /* Fall through.  */
 881
 882     case sk_template_parms:
 883       current_binding_level->template_parms_p = 1;
 884       break;
 885
 886     default:
 887       abort ();
 888     }
 889 }
 890
 891 /* Exit the current scope.  */
 892
 893 void
 894 finish_scope ()
 895 {
 896   poplevel (0, 0, 0);
 897 }
 898
 899 void
 900 note_level_for_for ()
 901 {
 902   current_binding_level->is_for_scope = 1;
 903 }
 904
 905 /* Record that the current binding level represents a try block.  */
 906
 907 void
 908 note_level_for_try ()
 909 {
 910   current_binding_level->is_try_scope = 1;
 911 }
 912
 913 /* Record that the current binding level represents a catch block.  */
 914
 915 void
 916 note_level_for_catch ()
 917 {
 918   current_binding_level->is_catch_scope = 1;
 919 }
 920
 921 /* For a binding between a name and an entity at a block scope,
 922    this is the `struct binding_level' for the block.  */
 923 #define BINDING_LEVEL(NODE) \
 924   (((struct tree_binding*)(NODE))->scope.level)
 925
 926 /* A free list of CPLUS_BINDING nodes, connected by their
 927    TREE_CHAINs.  */
 928
 929 static tree free_bindings;
 930
 931 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 932    level at which this declaration is being bound.  */
 933
 934 static void
 935 push_binding (id, decl, level)
 936      tree id;
 937      tree decl;
 938      struct binding_level* level;
 939 {
 940   tree binding;
 941
 942   if (free_bindings)
 943     {
 944       binding = free_bindings;
 945       free_bindings = TREE_CHAIN (binding);
 946     }
 947   else
 948     binding = make_node (CPLUS_BINDING);
 949
 950   /* Now, fill in the binding information.  */
 951   BINDING_VALUE (binding) = decl;
 952   BINDING_TYPE (binding) = NULL_TREE;
 953   BINDING_LEVEL (binding) = level;
 954   INHERITED_VALUE_BINDING_P (binding) = 0;
 955   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 956   BINDING_HAS_LEVEL_P (binding) = 1;
 957
 958   /* And put it on the front of the list of bindings for ID.  */
 959   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 960   IDENTIFIER_BINDING (id) = binding;
 961 }
 962
 963 /* ID is already bound in the current scope.  But, DECL is an
 964    additional binding for ID in the same scope.  This is the `struct
 965    stat' hack whereby a non-typedef class-name or enum-name can be
 966    bound at the same level as some other kind of entity.  It's the
 967    responsibility of the caller to check that inserting this name is
 968    legal here.  Returns nonzero if the new binding was successful.  */
 969 static int
 970 add_binding (id, decl)
 971      tree id;
 972      tree decl;
 973 {
 974   tree binding = IDENTIFIER_BINDING (id);
 975   int ok = 1;
 976
 977   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 978     /* The new name is the type name.  */
 979     BINDING_TYPE (binding) = decl;
 980   else if (!BINDING_VALUE (binding))
 981     /* This situation arises when push_class_level_binding moves an
 982        inherited type-binding out of the way to make room for a new
 983        value binding.  */
 984     BINDING_VALUE (binding) = decl;
 985   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 986            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 987     {
 988       /* The old binding was a type name.  It was placed in
 989          BINDING_VALUE because it was thought, at the point it was
 990          declared, to be the only entity with such a name.  Move the
 991          type name into the type slot; it is now hidden by the new
 992          binding.  */
 993       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 994       BINDING_VALUE (binding) = decl;
 995       INHERITED_VALUE_BINDING_P (binding) = 0;
 996     }
 997   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 998            && TREE_CODE (decl) == TYPE_DECL
 999            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1000            && (same_type_p (TREE_TYPE (decl),
1001                             TREE_TYPE (BINDING_VALUE (binding)))
1002                /* If either type involves template parameters, we must
1003                   wait until instantiation.  */
1004                || uses_template_parms (TREE_TYPE (decl))
1005                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
1006     /* We have two typedef-names, both naming the same type to have
1007        the same name.  This is OK because of:
1008
1009          [dcl.typedef]
1010
1011          In a given scope, a typedef specifier can be used to redefine
1012          the name of any type declared in that scope to refer to the
1013          type to which it already refers.  */
1014     ok = 0;
1015   /* There can be two block-scope declarations of the same variable,
1016      so long as they are `extern' declarations.  */
1017   else if (TREE_CODE (decl) == VAR_DECL
1018            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1019            && DECL_EXTERNAL (decl)
1020            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1021     {
1022       duplicate_decls (decl, BINDING_VALUE (binding));
1023       ok = 0;
1024     }
1025   else
1026     {
1027       error ("declaration of `%#D'", decl);
1028       cp_error_at ("conflicts with previous declaration `%#D'",
1029                    BINDING_VALUE (binding));
1030       ok = 0;
1031     }
1032
1033   return ok;
1034 }
1035
1036 /* Add DECL to the list of things declared in B.  */
1037
1038 static void
1039 add_decl_to_level (decl, b)
1040      tree decl;
1041      struct binding_level *b;
1042 {
1043   /* We build up the list in reverse order, and reverse it later if
1044      necessary.  */
1045   TREE_CHAIN (decl) = b->names;
1046   b->names = decl;
1047 }
1048
1049 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1050    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1051    doesn't really belong to this binding level, that it got here
1052    through a using-declaration.  */
1053
1054 void
1055 push_local_binding (id, decl, flags)
1056      tree id;
1057      tree decl;
1058      int flags;
1059 {
1060   struct binding_level *b;
1061
1062   /* Skip over any local classes.  This makes sense if we call
1063      push_local_binding with a friend decl of a local class.  */
1064   b = current_binding_level;
1065   while (b->parm_flag == 2)
1066     b = b->level_chain;
1067
1068   if (lookup_name_current_level (id))
1069     {
1070       /* Supplement the existing binding.  */
1071       if (!add_binding (id, decl))
1072         /* It didn't work.  Something else must be bound at this
1073            level.  Do not add DECL to the list of things to pop
1074            later.  */
1075         return;
1076     }
1077   else
1078     /* Create a new binding.  */
1079     push_binding (id, decl, b);
1080
1081   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1082     /* We must put the OVERLOAD into a TREE_LIST since the
1083        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1084        decls that got here through a using-declaration.  */
1085     decl = build_tree_list (NULL_TREE, decl);
1086
1087   /* And put DECL on the list of things declared by the current
1088      binding level.  */
1089   add_decl_to_level (decl, b);
1090 }
1091
1092 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1093    binding was successful.  */
1094
1095 int
1096 push_class_binding (id, decl)
1097      tree id;
1098      tree decl;
1099 {
1100   int result = 1;
1101   tree binding = IDENTIFIER_BINDING (id);
1102   tree context;
1103
1104   /* Note that we declared this value so that we can issue an error if
1105      this an illegal redeclaration of a name already used for some
1106      other purpose.  */
1107   note_name_declared_in_class (id, decl);
1108
1109   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1110     /* Supplement the existing binding.  */
1111     result = add_binding (id, decl);
1112   else
1113     /* Create a new binding.  */
1114     push_binding (id, decl, class_binding_level);
1115
1116   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1117      class-level declaration.  Note that we do not use DECL here
1118      because of the possibility of the `struct stat' hack; if DECL is
1119      a class-name or enum-name we might prefer a field-name, or some
1120      such.  */
1121   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1122
1123   /* If this is a binding from a base class, mark it as such.  */
1124   binding = IDENTIFIER_BINDING (id);
1125   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1126     {
1127       /* Any implicit typename must be from a base-class.  The
1128          context for an implicit typename declaration is always
1129          the derived class in which the lookup was done, so the checks
1130          based on the context of DECL below will not trigger.  */
1131       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1132         INHERITED_VALUE_BINDING_P (binding) = 1;
1133       else
1134         {
1135           if (TREE_CODE (decl) == OVERLOAD)
1136             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1137           else
1138             {
1139               my_friendly_assert (DECL_P (decl), 0);
1140               context = context_for_name_lookup (decl);
1141             }
1142
1143           if (is_properly_derived_from (current_class_type, context))
1144             INHERITED_VALUE_BINDING_P (binding) = 1;
1145           else
1146             INHERITED_VALUE_BINDING_P (binding) = 0;
1147         }
1148     }
1149   else if (BINDING_VALUE (binding) == decl)
1150     /* We only encounter a TREE_LIST when push_class_decls detects an
1151        ambiguity.  Such an ambiguity can be overridden by a definition
1152        in this class.  */
1153     INHERITED_VALUE_BINDING_P (binding) = 1;
1154
1155   return result;
1156 }
1157
1158 /* Remove the binding for DECL which should be the innermost binding
1159    for ID.  */
1160
1161 static void
1162 pop_binding (id, decl)
1163      tree id;
1164      tree decl;
1165 {
1166   tree binding;
1167
1168   if (id == NULL_TREE)
1169     /* It's easiest to write the loops that call this function without
1170        checking whether or not the entities involved have names.  We
1171        get here for such an entity.  */
1172     return;
1173
1174   /* Get the innermost binding for ID.  */
1175   binding = IDENTIFIER_BINDING (id);
1176
1177   /* The name should be bound.  */
1178   my_friendly_assert (binding != NULL_TREE, 0);
1179
1180   /* The DECL will be either the ordinary binding or the type
1181      binding for this identifier.  Remove that binding.  */
1182   if (BINDING_VALUE (binding) == decl)
1183     BINDING_VALUE (binding) = NULL_TREE;
1184   else if (BINDING_TYPE (binding) == decl)
1185     BINDING_TYPE (binding) = NULL_TREE;
1186   else
1187     abort ();
1188
1189   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1190     {
1191       /* We're completely done with the innermost binding for this
1192          identifier.  Unhook it from the list of bindings.  */
1193       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1194
1195       /* Add it to the free list.  */
1196       TREE_CHAIN (binding) = free_bindings;
1197       free_bindings = binding;
1198
1199       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1200          it.  */
1201       BINDING_LEVEL (binding) = NULL;
1202     }
1203 }
1204
1205 /* When a label goes out of scope, check to see if that label was used
1206    in a valid manner, and issue any appropriate warnings or errors.  */
1207
1208 static void
1209 pop_label (label, old_value)
1210      tree label;
1211      tree old_value;
1212 {
1213   if (!processing_template_decl && doing_semantic_analysis_p ())
1214     {
1215       if (DECL_INITIAL (label) == NULL_TREE)
1216         {
1217           cp_error_at ("label `%D' used but not defined", label);
1218           /* Avoid crashing later.  */
1219           define_label (input_filename, 1, DECL_NAME (label));
1220         }
1221       else if (warn_unused_label && !TREE_USED (label))
1222         cp_warning_at ("label `%D' defined but not used", label);
1223     }
1224
1225   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1226 }
1227
1228 /* At the end of a function, all labels declared within the function
1229    go out of scope.  BLOCK is the top-level block for the
1230    function.  */
1231
1232 static void
1233 pop_labels (block)
1234      tree block;
1235 {
1236   struct named_label_list *link;
1237
1238   /* Clear out the definitions of all label names, since their scopes
1239      end here.  */
1240   for (link = named_labels; link; link = link->next)
1241     {
1242       pop_label (link->label_decl, link->old_value);
1243       /* Put the labels into the "variables" of the top-level block,
1244          so debugger can see them.  */
1245       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1246       BLOCK_VARS (block) = link->label_decl;
1247     }
1248
1249   named_labels = NULL;
1250 }
1251
1252 /* Exit a binding level.
1253    Pop the level off, and restore the state of the identifier-decl mappings
1254    that were in effect when this level was entered.
1255
1256    If KEEP == 1, this level had explicit declarations, so
1257    and create a "block" (a BLOCK node) for the level
1258    to record its declarations and subblocks for symbol table output.
1259
1260    If FUNCTIONBODY is nonzero, this level is the body of a function,
1261    so create a block as if KEEP were set and also clear out all
1262    label names.
1263
1264    If REVERSE is nonzero, reverse the order of decls before putting
1265    them into the BLOCK.  */
1266
1267 tree
1268 poplevel (keep, reverse, functionbody)
1269      int keep;
1270      int reverse;
1271      int functionbody;
1272 {
1273   register tree link;
1274   /* The chain of decls was accumulated in reverse order.
1275      Put it into forward order, just for cleanliness.  */
1276   tree decls;
1277   int tmp = functionbody;
1278   int real_functionbody;
1279   tree tags;
1280   tree subblocks;
1281   tree block = NULL_TREE;
1282   tree decl;
1283   int leaving_for_scope;
1284
1285   if (cfun && !doing_semantic_analysis_p ())
1286     return NULL_TREE;
1287
1288   my_friendly_assert (current_binding_level->parm_flag != 2,
1289                       19990916);
1290
1291   real_functionbody = (current_binding_level->keep == 2
1292                        ? ((functionbody = 0), tmp) : functionbody);
1293   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1294   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1295
1296   my_friendly_assert (!current_binding_level->class_shadowed,
1297                       19990414);
1298
1299   /* We used to use KEEP == 2 to indicate that the new block should go
1300      at the beginning of the list of blocks at this binding level,
1301      rather than the end.  This hack is no longer used.  */
1302   my_friendly_assert (keep == 0 || keep == 1, 0);
1303
1304   if (current_binding_level->keep == 1)
1305     keep = 1;
1306
1307   /* Any uses of undefined labels, and any defined labels, now operate
1308      under constraints of next binding contour.  */
1309   if (cfun && !functionbody)
1310     {
1311       struct binding_level *level_chain;
1312       level_chain = current_binding_level->level_chain;
1313       if (level_chain)
1314         {
1315           struct named_label_use_list *uses;
1316           struct named_label_list *labels;
1317           for (labels = named_labels; labels; labels = labels->next)
1318             if (labels->binding_level == current_binding_level)
1319               {
1320                 tree decl;
1321                 if (current_binding_level->is_try_scope)
1322                   labels->in_try_scope = 1;
1323                 if (current_binding_level->is_catch_scope)
1324                   labels->in_catch_scope = 1;
1325                 for (decl = labels->names_in_scope; decl;
1326                      decl = TREE_CHAIN (decl))
1327                   if (decl_jump_unsafe (decl))
1328                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1329                                                    labels->bad_decls);
1330                 labels->binding_level = level_chain;
1331                 labels->names_in_scope = level_chain->names;
1332               }
1333
1334           for (uses = named_label_uses; uses; uses = uses->next)
1335             if (uses->binding_level == current_binding_level)
1336               {
1337                 uses->binding_level = level_chain;
1338                 uses->names_in_scope = level_chain->names;
1339               }
1340         }
1341     }
1342
1343   /* Get the decls in the order they were written.
1344      Usually current_binding_level->names is in reverse order.
1345      But parameter decls were previously put in forward order.  */
1346
1347   if (reverse)
1348     current_binding_level->names
1349       = decls = nreverse (current_binding_level->names);
1350   else
1351     decls = current_binding_level->names;
1352
1353   /* Output any nested inline functions within this block
1354      if they weren't already output.  */
1355   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1356     if (TREE_CODE (decl) == FUNCTION_DECL
1357         && ! TREE_ASM_WRITTEN (decl)
1358         && DECL_INITIAL (decl) != NULL_TREE
1359         && TREE_ADDRESSABLE (decl)
1360         && decl_function_context (decl) == current_function_decl)
1361       {
1362         /* If this decl was copied from a file-scope decl
1363            on account of a block-scope extern decl,
1364            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1365         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1366           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1367         else
1368           {
1369             push_function_context ();
1370             output_inline_function (decl);
1371             pop_function_context ();
1372           }
1373       }
1374
1375   /* When not in function-at-a-time mode, expand_end_bindings will
1376      warn about unused variables.  But, in function-at-a-time mode
1377      expand_end_bindings is not passed the list of variables in the
1378      current scope, and therefore no warning is emitted.  So, we
1379      explicitly warn here.  */
1380   if (!processing_template_decl)
1381     warn_about_unused_variables (getdecls ());
1382
1383   /* If there were any declarations or structure tags in that level,
1384      or if this level is a function body,
1385      create a BLOCK to record them for the life of this function.  */
1386   block = NULL_TREE;
1387   if (keep == 1 || functionbody)
1388     block = make_node (BLOCK);
1389   if (block != NULL_TREE)
1390     {
1391       BLOCK_VARS (block) = decls;
1392       BLOCK_SUBBLOCKS (block) = subblocks;
1393     }
1394
1395   /* In each subblock, record that this is its superior.  */
1396   if (keep >= 0)
1397     for (link = subblocks; link; link = TREE_CHAIN (link))
1398       BLOCK_SUPERCONTEXT (link) = block;
1399
1400   /* We still support the old for-scope rules, whereby the variables
1401      in a for-init statement were in scope after the for-statement
1402      ended.  We only use the new rules in flag_new_for_scope is
1403      nonzero.  */
1404   leaving_for_scope
1405     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1406
1407   /* Remove declarations for all the DECLs in this level.  */
1408   for (link = decls; link; link = TREE_CHAIN (link))
1409     {
1410       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1411           && DECL_NAME (link))
1412         {
1413           tree outer_binding
1414             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1415           tree ns_binding;
1416
1417           if (!outer_binding)
1418             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1419           else
1420             ns_binding = NULL_TREE;
1421
1422           if (outer_binding
1423               && (BINDING_LEVEL (outer_binding)
1424                   == current_binding_level->level_chain))
1425             /* We have something like:
1426
1427                  int i;
1428                  for (int i; ;);
1429
1430                and we are leaving the `for' scope.  There's no reason to
1431                keep the binding of the inner `i' in this case.  */
1432             pop_binding (DECL_NAME (link), link);
1433           else if ((outer_binding
1434                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1435                         == TYPE_DECL))
1436                    || (ns_binding
1437                        && TREE_CODE (ns_binding) == TYPE_DECL))
1438             /* Here, we have something like:
1439
1440                  typedef int I;
1441
1442                  void f () {
1443                    for (int I; ;);
1444                  }
1445
1446                We must pop the for-scope binding so we know what's a
1447                type and what isn't.  */
1448             pop_binding (DECL_NAME (link), link);
1449           else
1450             {
1451               /* Mark this VAR_DECL as dead so that we can tell we left it
1452                  there only for backward compatibility.  */
1453               DECL_DEAD_FOR_LOCAL (link) = 1;
1454
1455               /* Keep track of what should of have happenned when we
1456                  popped the binding.  */
1457               if (outer_binding && BINDING_VALUE (outer_binding))
1458                 DECL_SHADOWED_FOR_VAR (link)
1459                   = BINDING_VALUE (outer_binding);
1460
1461               /* Add it to the list of dead variables in the next
1462                  outermost binding to that we can remove these when we
1463                  leave that binding.  */
1464               current_binding_level->level_chain->dead_vars_from_for
1465                 = tree_cons (NULL_TREE, link,
1466                              current_binding_level->level_chain->
1467                              dead_vars_from_for);
1468
1469               /* Although we don't pop the CPLUS_BINDING, we do clear
1470                  its BINDING_LEVEL since the level is going away now.  */
1471               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1472                 = 0;
1473             }
1474         }
1475       else
1476         {
1477           /* Remove the binding.  */
1478           decl = link;
1479           if (TREE_CODE (decl) == TREE_LIST)
1480             decl = TREE_VALUE (decl);
1481           if (DECL_P (decl))
1482             pop_binding (DECL_NAME (decl), decl);
1483           else if (TREE_CODE (decl) == OVERLOAD)
1484             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1485           else
1486             abort ();
1487         }
1488     }
1489
1490   /* Remove declarations for any `for' variables from inner scopes
1491      that we kept around.  */
1492   for (link = current_binding_level->dead_vars_from_for;
1493        link; link = TREE_CHAIN (link))
1494     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1495
1496   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1497   for (link = current_binding_level->type_shadowed;
1498        link; link = TREE_CHAIN (link))
1499     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1500
1501   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1502   for (link = current_binding_level->shadowed_labels;
1503        link;
1504        link = TREE_CHAIN (link))
1505     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1506
1507   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1508      list if a `using' declaration put them there.  The debugging
1509      back-ends won't understand OVERLOAD, so we remove them here.
1510      Because the BLOCK_VARS are (temporarily) shared with
1511      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1512      popped all the bindings.  */
1513   if (block)
1514     {
1515       tree* d;
1516
1517       for (d = &BLOCK_VARS (block); *d; )
1518         {
1519           if (TREE_CODE (*d) == TREE_LIST)
1520             *d = TREE_CHAIN (*d);
1521           else
1522             d = &TREE_CHAIN (*d);
1523         }
1524     }
1525
1526   /* If the level being exited is the top level of a function,
1527      check over all the labels.  */
1528   if (functionbody)
1529     {
1530       /* Since this is the top level block of a function, the vars are
1531          the function's parameters.  Don't leave them in the BLOCK
1532          because they are found in the FUNCTION_DECL instead.  */
1533       BLOCK_VARS (block) = 0;
1534       pop_labels (block);
1535     }
1536
1537   tmp = current_binding_level->keep;
1538
1539   pop_binding_level ();
1540   if (functionbody)
1541     DECL_INITIAL (current_function_decl) = block;
1542   else if (block)
1543     current_binding_level->blocks
1544       = chainon (current_binding_level->blocks, block);
1545
1546   /* If we did not make a block for the level just exited,
1547      any blocks made for inner levels
1548      (since they cannot be recorded as subblocks in that level)
1549      must be carried forward so they will later become subblocks
1550      of something else.  */
1551   else if (subblocks)
1552     current_binding_level->blocks
1553       = chainon (current_binding_level->blocks, subblocks);
1554
1555   /* Each and every BLOCK node created here in `poplevel' is important
1556      (e.g. for proper debugging information) so if we created one
1557      earlier, mark it as "used".  */
1558   if (block)
1559     TREE_USED (block) = 1;
1560
1561   /* Take care of compiler's internal binding structures.  */
1562   if (tmp == 2)
1563     {
1564       tree scope_stmts;
1565
1566       scope_stmts
1567         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1568       if (block)
1569         {
1570           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1571           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1572         }
1573
1574       block = poplevel (keep, reverse, functionbody);
1575     }
1576
1577   return block;
1578 }
1579
1580 /* Delete the node BLOCK from the current binding level.
1581    This is used for the block inside a stmt expr ({...})
1582    so that the block can be reinserted where appropriate.  */
1583
1584 void
1585 delete_block (block)
1586      tree block;
1587 {
1588   tree t;
1589   if (current_binding_level->blocks == block)
1590     current_binding_level->blocks = TREE_CHAIN (block);
1591   for (t = current_binding_level->blocks; t;)
1592     {
1593       if (TREE_CHAIN (t) == block)
1594         TREE_CHAIN (t) = TREE_CHAIN (block);
1595       else
1596         t = TREE_CHAIN (t);
1597     }
1598   TREE_CHAIN (block) = NULL_TREE;
1599   /* Clear TREE_USED which is always set by poplevel.
1600      The flag is set again if insert_block is called.  */
1601   TREE_USED (block) = 0;
1602 }
1603
1604 /* Insert BLOCK at the end of the list of subblocks of the
1605    current binding level.  This is used when a BIND_EXPR is expanded,
1606    to handle the BLOCK node inside the BIND_EXPR.  */
1607
1608 void
1609 insert_block (block)
1610      tree block;
1611 {
1612   TREE_USED (block) = 1;
1613   current_binding_level->blocks
1614     = chainon (current_binding_level->blocks, block);
1615 }
1616
1617 /* Set the BLOCK node for the innermost scope
1618    (the one we are currently in).  */
1619
1620 void
1621 set_block (block)
1622     tree block ATTRIBUTE_UNUSED;
1623 {
1624   /* The RTL expansion machinery requires us to provide this callback,
1625      but it is not applicable in function-at-a-time mode.  */
1626   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1627 }
1628
1629 /* Do a pushlevel for class declarations.  */
1630
1631 void
1632 pushlevel_class ()
1633 {
1634   register struct binding_level *newlevel;
1635
1636   /* Reuse or create a struct for this binding level.  */
1637 #if defined(DEBUG_CP_BINDING_LEVELS)
1638   if (0)
1639 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1640   if (free_binding_level)
1641 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1642     {
1643       newlevel = free_binding_level;
1644       free_binding_level = free_binding_level->level_chain;
1645     }
1646   else
1647     newlevel = make_binding_level ();
1648
1649 #if defined(DEBUG_CP_BINDING_LEVELS)
1650   is_class_level = 1;
1651 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1652
1653   push_binding_level (newlevel, 0, 0);
1654
1655   class_binding_level = current_binding_level;
1656   class_binding_level->parm_flag = 2;
1657   class_binding_level->this_class = current_class_type;
1658 }
1659
1660 /* ...and a poplevel for class declarations.  */
1661
1662 void
1663 poplevel_class ()
1664 {
1665   register struct binding_level *level = class_binding_level;
1666   tree shadowed;
1667
1668   my_friendly_assert (level != 0, 354);
1669
1670   /* If we're leaving a toplevel class, don't bother to do the setting
1671      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1672      shouldn't even be used when current_class_type isn't set, and second,
1673      if we don't touch it here, we're able to use the cache effect if the
1674      next time we're entering a class scope, it is the same class.  */
1675   if (current_class_depth != 1)
1676     {
1677       struct binding_level* b;
1678
1679       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1680       for (shadowed = level->class_shadowed;
1681            shadowed;
1682            shadowed = TREE_CHAIN (shadowed))
1683         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1684
1685       /* Find the next enclosing class, and recreate
1686          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1687       b = level->level_chain;
1688       while (b && b->parm_flag != 2)
1689         b = b->level_chain;
1690
1691       if (b)
1692         for (shadowed = b->class_shadowed;
1693              shadowed;
1694              shadowed = TREE_CHAIN (shadowed))
1695           {
1696             tree t;
1697
1698             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1699             while (t && BINDING_LEVEL (t) != b)
1700               t = TREE_CHAIN (t);
1701
1702             if (t)
1703               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1704                 = BINDING_VALUE (t);
1705           }
1706     }
1707   else
1708     /* Remember to save what IDENTIFIER's were bound in this scope so we
1709        can recover from cache misses.  */
1710     {
1711       previous_class_type = current_class_type;
1712       previous_class_values = class_binding_level->class_shadowed;
1713     }
1714   for (shadowed = level->type_shadowed;
1715        shadowed;
1716        shadowed = TREE_CHAIN (shadowed))
1717     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1718
1719   /* Remove the bindings for all of the class-level declarations.  */
1720   for (shadowed = level->class_shadowed;
1721        shadowed;
1722        shadowed = TREE_CHAIN (shadowed))
1723     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1724
1725   /* Now, pop out of the binding level which we created up in the
1726      `pushlevel_class' routine.  */
1727 #if defined(DEBUG_CP_BINDING_LEVELS)
1728   is_class_level = 1;
1729 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1730
1731   pop_binding_level ();
1732 }
1733
1734 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1735    for any names in enclosing classes.  */
1736
1737 void
1738 clear_identifier_class_values ()
1739 {
1740   tree t;
1741
1742   if (!class_binding_level)
1743     return;
1744
1745   for (t = class_binding_level->class_shadowed;
1746        t;
1747        t = TREE_CHAIN (t))
1748     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1749 }
1750
1751 /* Returns non-zero if T is a virtual function table.  */
1752
1753 int
1754 vtable_decl_p (t, data)
1755      tree t;
1756      void *data ATTRIBUTE_UNUSED;
1757 {
1758   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1759 }
1760
1761 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1762    functions.  */
1763
1764 int
1765 vtype_decl_p (t, data)
1766      tree t;
1767      void *data ATTRIBUTE_UNUSED;
1768 {
1769   return (TREE_CODE (t) == TYPE_DECL
1770           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1771           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1772 }
1773
1774 /* Return the declarations that are members of the namespace NS.  */
1775
1776 tree
1777 cp_namespace_decls (ns)
1778      tree ns;
1779 {
1780   return NAMESPACE_LEVEL (ns)->names;
1781 }
1782
1783 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1784    itself, calling F for each.  The DATA is passed to F as well.  */
1785
1786 static int
1787 walk_namespaces_r (namespace, f, data)
1788      tree namespace;
1789      walk_namespaces_fn f;
1790      void *data;
1791 {
1792   tree current;
1793   int result = 0;
1794
1795   result |= (*f) (namespace, data);
1796
1797   for (current = cp_namespace_decls (namespace);
1798        current;
1799        current = TREE_CHAIN (current))
1800     {
1801       if (TREE_CODE (current) != NAMESPACE_DECL
1802           || DECL_NAMESPACE_ALIAS (current))
1803         continue;
1804
1805       /* We found a namespace.  */
1806       result |= walk_namespaces_r (current, f, data);
1807     }
1808
1809   return result;
1810 }
1811
1812 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1813    F as well.  */
1814
1815 int
1816 walk_namespaces (f, data)
1817      walk_namespaces_fn f;
1818      void *data;
1819 {
1820   return walk_namespaces_r (global_namespace, f, data);
1821 }
1822
1823 struct walk_globals_data {
1824   walk_globals_pred p;
1825   walk_globals_fn f;
1826   void *data;
1827 };
1828
1829 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1830    for which P returns non-zero, call F with its address.  If any call
1831    to F returns a non-zero value, return a non-zero value.  */
1832
1833 static int
1834 walk_globals_r (namespace, data)
1835      tree namespace;
1836      void *data;
1837 {
1838   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1839   walk_globals_pred p = wgd->p;
1840   walk_globals_fn f = wgd->f;
1841   void *d = wgd->data;
1842   tree *t;
1843   int result = 0;
1844
1845   t = &NAMESPACE_LEVEL (namespace)->names;
1846
1847   while (*t)
1848     {
1849       tree glbl = *t;
1850
1851       if ((*p) (glbl, d))
1852         result |= (*f) (t, d);
1853
1854       /* If F changed *T, then *T still points at the next item to
1855          examine.  */
1856       if (*t == glbl)
1857         t = &TREE_CHAIN (*t);
1858     }
1859
1860   return result;
1861 }
1862
1863 /* Walk the global declarations.  Whenever one is found for which P
1864    returns non-zero, call F with its address.  If any call to F
1865    returns a non-zero value, return a non-zero value.  */
1866
1867 int
1868 walk_globals (p, f, data)
1869      walk_globals_pred p;
1870      walk_globals_fn f;
1871      void *data;
1872 {
1873   struct walk_globals_data wgd;
1874   wgd.p = p;
1875   wgd.f = f;
1876   wgd.data = data;
1877
1878   return walk_namespaces (walk_globals_r, &wgd);
1879 }
1880
1881 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1882    DATA is non-NULL, this is the last time we will call
1883    wrapup_global_declarations for this NAMESPACE.  */
1884
1885 int
1886 wrapup_globals_for_namespace (namespace, data)
1887      tree namespace;
1888      void *data;
1889 {
1890   tree globals = cp_namespace_decls (namespace);
1891   int len = list_length (globals);
1892   tree *vec = (tree *) alloca (sizeof (tree) * len);
1893   int i;
1894   int result;
1895   tree decl;
1896   int last_time = (data != 0);
1897
1898   if (last_time && namespace == global_namespace)
1899     /* Let compile_file handle the global namespace.  */
1900     return 0;
1901
1902   /* Process the decls in reverse order--earliest first.
1903      Put them into VEC from back to front, then take out from front.  */
1904   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1905     vec[len - i - 1] = decl;
1906
1907   if (last_time)
1908     {
1909       check_global_declarations (vec, len);
1910       return 0;
1911     }
1912
1913   /* Temporarily mark vtables as external.  That prevents
1914      wrapup_global_declarations from writing them out; we must process
1915      them ourselves in finish_vtable_vardecl.  */
1916   for (i = 0; i < len; ++i)
1917     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1918       {
1919         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1920         DECL_EXTERNAL (vec[i]) = 1;
1921       }
1922
1923   /* Write out any globals that need to be output.  */
1924   result = wrapup_global_declarations (vec, len);
1925
1926   /* Undo the hack to DECL_EXTERNAL above.  */
1927   for (i = 0; i < len; ++i)
1928     if (vtable_decl_p (vec[i], /*data=*/0)
1929         && DECL_NOT_REALLY_EXTERN (vec[i]))
1930       {
1931         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1932         DECL_EXTERNAL (vec[i]) = 0;
1933       }
1934
1935   return result;
1936 }
1937
1938 \f
1939 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1940
1941 static void
1942 mark_binding_level (arg)
1943      void *arg;
1944 {
1945   struct binding_level *lvl = *(struct binding_level **)arg;
1946
1947   for (; lvl; lvl = lvl->level_chain)
1948     {
1949       ggc_mark_tree (lvl->names);
1950       ggc_mark_tree (lvl->tags);
1951       ggc_mark_tree (lvl->usings);
1952       ggc_mark_tree (lvl->using_directives);
1953       ggc_mark_tree (lvl->class_shadowed);
1954       ggc_mark_tree (lvl->type_shadowed);
1955       ggc_mark_tree (lvl->shadowed_labels);
1956       ggc_mark_tree (lvl->blocks);
1957       ggc_mark_tree (lvl->this_class);
1958       ggc_mark_tree (lvl->dead_vars_from_for);
1959     }
1960 }
1961
1962 static void
1963 mark_named_label_lists (labs, uses)
1964      void *labs;
1965      void *uses;
1966 {
1967   struct named_label_list *l = *(struct named_label_list **)labs;
1968   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1969
1970   for (; l; l = l->next)
1971     {
1972       ggc_mark (l);
1973       mark_binding_level (&l->binding_level);
1974       ggc_mark_tree (l->old_value);
1975       ggc_mark_tree (l->label_decl);
1976       ggc_mark_tree (l->bad_decls);
1977     }
1978
1979   for (; u; u = u->next)
1980     ggc_mark (u);
1981 }
1982 \f
1983 /* For debugging.  */
1984 static int no_print_functions = 0;
1985 static int no_print_builtins = 0;
1986
1987 void
1988 print_binding_level (lvl)
1989      struct binding_level *lvl;
1990 {
1991   tree t;
1992   int i = 0, len;
1993   fprintf (stderr, " blocks=");
1994   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1995   if (lvl->tag_transparent)
1996     fprintf (stderr, " tag-transparent");
1997   if (lvl->more_cleanups_ok)
1998     fprintf (stderr, " more-cleanups-ok");
1999   if (lvl->have_cleanups)
2000     fprintf (stderr, " have-cleanups");
2001   fprintf (stderr, "\n");
2002   if (lvl->names)
2003     {
2004       fprintf (stderr, " names:\t");
2005       /* We can probably fit 3 names to a line?  */
2006       for (t = lvl->names; t; t = TREE_CHAIN (t))
2007         {
2008           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2009             continue;
2010           if (no_print_builtins
2011               && (TREE_CODE (t) == TYPE_DECL)
2012               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2013             continue;
2014
2015           /* Function decls tend to have longer names.  */
2016           if (TREE_CODE (t) == FUNCTION_DECL)
2017             len = 3;
2018           else
2019             len = 2;
2020           i += len;
2021           if (i > 6)
2022             {
2023               fprintf (stderr, "\n\t");
2024               i = len;
2025             }
2026           print_node_brief (stderr, "", t, 0);
2027           if (t == error_mark_node)
2028             break;
2029         }
2030       if (i)
2031         fprintf (stderr, "\n");
2032     }
2033   if (lvl->tags)
2034     {
2035       fprintf (stderr, " tags:\t");
2036       i = 0;
2037       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2038         {
2039           if (TREE_PURPOSE (t) == NULL_TREE)
2040             len = 3;
2041           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2042             len = 2;
2043           else
2044             len = 4;
2045           i += len;
2046           if (i > 5)
2047             {
2048               fprintf (stderr, "\n\t");
2049               i = len;
2050             }
2051           if (TREE_PURPOSE (t) == NULL_TREE)
2052             {
2053               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2054               fprintf (stderr, ">");
2055             }
2056           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2057             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2058           else
2059             {
2060               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2061               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2062               fprintf (stderr, ">");
2063             }
2064         }
2065       if (i)
2066         fprintf (stderr, "\n");
2067     }
2068   if (lvl->class_shadowed)
2069     {
2070       fprintf (stderr, " class-shadowed:");
2071       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2072         {
2073           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2074         }
2075       fprintf (stderr, "\n");
2076     }
2077   if (lvl->type_shadowed)
2078     {
2079       fprintf (stderr, " type-shadowed:");
2080       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2081         {
2082           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2083         }
2084       fprintf (stderr, "\n");
2085     }
2086 }
2087
2088 void
2089 print_other_binding_stack (stack)
2090      struct binding_level *stack;
2091 {
2092   struct binding_level *level;
2093   for (level = stack; level != global_binding_level; level = level->level_chain)
2094     {
2095       fprintf (stderr, "binding level ");
2096       fprintf (stderr, HOST_PTR_PRINTF, level);
2097       fprintf (stderr, "\n");
2098       print_binding_level (level);
2099     }
2100 }
2101
2102 void
2103 print_binding_stack ()
2104 {
2105   struct binding_level *b;
2106   fprintf (stderr, "current_binding_level=");
2107   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2108   fprintf (stderr, "\nclass_binding_level=");
2109   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2110   fprintf (stderr, "\nglobal_binding_level=");
2111   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2112   fprintf (stderr, "\n");
2113   if (class_binding_level)
2114     {
2115       for (b = class_binding_level; b; b = b->level_chain)
2116         if (b == current_binding_level)
2117           break;
2118       if (b)
2119         b = class_binding_level;
2120       else
2121         b = current_binding_level;
2122     }
2123   else
2124     b = current_binding_level;
2125   print_other_binding_stack (b);
2126   fprintf (stderr, "global:\n");
2127   print_binding_level (global_binding_level);
2128 }
2129
2130 /* Namespace binding access routines: The namespace_bindings field of
2131    the identifier is polymorphic, with three possible values:
2132    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2133    indicating the BINDING_VALUE of global_namespace. */
2134
2135 /* Check whether the a binding for the name to scope is known.
2136    Assumes that the bindings of the name are already a list
2137    of bindings. Returns the binding found, or NULL_TREE. */
2138
2139 static tree
2140 find_binding (name, scope)
2141      tree name;
2142      tree scope;
2143 {
2144   tree iter, prev = NULL_TREE;
2145
2146   scope = ORIGINAL_NAMESPACE (scope);
2147
2148   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2149        iter = TREE_CHAIN (iter))
2150     {
2151       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2152       if (BINDING_SCOPE (iter) == scope)
2153         {
2154           /* Move binding found to the front of the list, so
2155              subsequent lookups will find it faster. */
2156           if (prev)
2157             {
2158               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2159               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2160               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2161             }
2162           return iter;
2163         }
2164       prev = iter;
2165     }
2166   return NULL_TREE;
2167 }
2168
2169 /* Always returns a binding for name in scope. If the
2170    namespace_bindings is not a list, convert it to one first.
2171    If no binding is found, make a new one. */
2172
2173 tree
2174 binding_for_name (name, scope)
2175      tree name;
2176      tree scope;
2177 {
2178   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2179   tree result;
2180
2181   scope = ORIGINAL_NAMESPACE (scope);
2182
2183   if (b && TREE_CODE (b) != CPLUS_BINDING)
2184     {
2185       /* Get rid of optimization for global scope. */
2186       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2187       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2188       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2189     }
2190   if (b && (result = find_binding (name, scope)))
2191     return result;
2192   /* Not found, make a new one. */
2193   result = make_node (CPLUS_BINDING);
2194   TREE_CHAIN (result) = b;
2195   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2196   BINDING_SCOPE (result) = scope;
2197   BINDING_TYPE (result) = NULL_TREE;
2198   BINDING_VALUE (result) = NULL_TREE;
2199   return result;
2200 }
2201
2202 /* Return the binding value for name in scope, considering that
2203    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2204
2205 tree
2206 namespace_binding (name, scope)
2207      tree name;
2208      tree scope;
2209 {
2210   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2211   if (b == NULL_TREE)
2212     return NULL_TREE;
2213   if (scope == NULL_TREE)
2214     scope = global_namespace;
2215   if (TREE_CODE (b) != CPLUS_BINDING)
2216     return (scope == global_namespace) ? b : NULL_TREE;
2217   name = find_binding (name,scope);
2218   if (name == NULL_TREE)
2219     return name;
2220   return BINDING_VALUE (name);
2221 }
2222
2223 /* Set the binding value for name in scope. If modifying the binding
2224    of global_namespace is attempted, try to optimize it. */
2225
2226 void
2227 set_namespace_binding (name, scope, val)
2228      tree name;
2229      tree scope;
2230      tree val;
2231 {
2232   tree b;
2233
2234   if (scope == NULL_TREE)
2235     scope = global_namespace;
2236
2237   if (scope == global_namespace)
2238     {
2239       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2240       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2241         {
2242           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2243           return;
2244         }
2245     }
2246   b = binding_for_name (name, scope);
2247   BINDING_VALUE (b) = val;
2248 }
2249
2250 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2251    select a name that is unique to this compilation unit.  */
2252
2253 void
2254 push_namespace (name)
2255      tree name;
2256 {
2257   tree d = NULL_TREE;
2258   int need_new = 1;
2259   int implicit_use = 0;
2260   int global = 0;
2261   if (!global_namespace)
2262     {
2263       /* This must be ::. */
2264       my_friendly_assert (name == get_identifier ("::"), 377);
2265       global = 1;
2266     }
2267   else if (!name)
2268     {
2269       /* The name of anonymous namespace is unique for the translation
2270          unit.  */
2271       if (!anonymous_namespace_name)
2272         anonymous_namespace_name = get_file_function_name ('N');
2273       name = anonymous_namespace_name;
2274       d = IDENTIFIER_NAMESPACE_VALUE (name);
2275       if (d)
2276         /* Reopening anonymous namespace.  */
2277         need_new = 0;
2278       implicit_use = 1;
2279     }
2280   else
2281     {
2282       /* Check whether this is an extended namespace definition. */
2283       d = IDENTIFIER_NAMESPACE_VALUE (name);
2284       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2285         {
2286           need_new = 0;
2287           if (DECL_NAMESPACE_ALIAS (d))
2288             {
2289               error ("namespace alias `%D' not allowed here, assuming `%D'",
2290                         d, DECL_NAMESPACE_ALIAS (d));
2291               d = DECL_NAMESPACE_ALIAS (d);
2292             }
2293         }
2294     }
2295
2296   if (need_new)
2297     {
2298       /* Make a new namespace, binding the name to it. */
2299       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2300       /* The global namespace is not pushed, and the global binding
2301          level is set elsewhere.  */
2302       if (!global)
2303         {
2304           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2305           d = pushdecl (d);
2306           pushlevel (0);
2307           declare_namespace_level ();
2308           NAMESPACE_LEVEL (d) = current_binding_level;
2309         }
2310     }
2311   else
2312     resume_binding_level (NAMESPACE_LEVEL (d));
2313
2314   if (implicit_use)
2315     do_using_directive (d);
2316   /* Enter the name space. */
2317   current_namespace = d;
2318 }
2319
2320 /* Pop from the scope of the current namespace.  */
2321
2322 void
2323 pop_namespace ()
2324 {
2325   my_friendly_assert (current_namespace != global_namespace, 20010801);
2326   current_namespace = CP_DECL_CONTEXT (current_namespace);
2327   /* The binding level is not popped, as it might be re-opened later.  */
2328   suspend_binding_level ();
2329 }
2330
2331 /* Push into the scope of the namespace NS, even if it is deeply
2332    nested within another namespace.  */
2333
2334 void
2335 push_nested_namespace (ns)
2336      tree ns;
2337 {
2338   if (ns == global_namespace)
2339     push_to_top_level ();
2340   else
2341     {
2342       push_nested_namespace (CP_DECL_CONTEXT (ns));
2343       push_namespace (DECL_NAME (ns));
2344     }
2345 }
2346
2347 /* Pop back from the scope of the namespace NS, which was previously
2348    entered with push_nested_namespace.  */
2349
2350 void
2351 pop_nested_namespace (ns)
2352      tree ns;
2353 {
2354   while (ns != global_namespace)
2355     {
2356       pop_namespace ();
2357       ns = CP_DECL_CONTEXT (ns);
2358     }
2359
2360   pop_from_top_level ();
2361 }
2362
2363 \f
2364 /* Subroutines for reverting temporarily to top-level for instantiation
2365    of templates and such.  We actually need to clear out the class- and
2366    local-value slots of all identifiers, so that only the global values
2367    are at all visible.  Simply setting current_binding_level to the global
2368    scope isn't enough, because more binding levels may be pushed.  */
2369 struct saved_scope *scope_chain;
2370
2371 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2372
2373 static void
2374 mark_saved_scope (arg)
2375      void *arg;
2376 {
2377   struct saved_scope *t = *(struct saved_scope **)arg;
2378   while (t)
2379     {
2380       mark_binding_level (&t->class_bindings);
2381       ggc_mark_tree (t->old_bindings);
2382       ggc_mark_tree (t->old_namespace);
2383       ggc_mark_tree (t->decl_ns_list);
2384       ggc_mark_tree (t->class_name);
2385       ggc_mark_tree (t->class_type);
2386       ggc_mark_tree (t->access_specifier);
2387       ggc_mark_tree (t->function_decl);
2388       if (t->lang_base)
2389         ggc_mark_tree_varray (t->lang_base);
2390       ggc_mark_tree (t->lang_name);
2391       ggc_mark_tree (t->template_parms);
2392       ggc_mark_tree (t->x_previous_class_type);
2393       ggc_mark_tree (t->x_previous_class_values);
2394       ggc_mark_tree (t->x_saved_tree);
2395       ggc_mark_tree (t->lookups);
2396
2397       mark_stmt_tree (&t->x_stmt_tree);
2398       mark_binding_level (&t->bindings);
2399       t = t->prev;
2400     }
2401 }
2402
2403 static tree
2404 store_bindings (names, old_bindings)
2405      tree names, old_bindings;
2406 {
2407   tree t;
2408   tree search_bindings = old_bindings;
2409
2410   for (t = names; t; t = TREE_CHAIN (t))
2411     {
2412       tree binding, t1, id;
2413
2414       if (TREE_CODE (t) == TREE_LIST)
2415         id = TREE_PURPOSE (t);
2416       else
2417         id = DECL_NAME (t);
2418
2419       if (!id
2420           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2421              we have no IDENTIFIER_BINDING if we have left the class
2422              scope, but cached the class-level declarations.  */
2423           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2424         continue;
2425
2426       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2427         if (TREE_VEC_ELT (t1, 0) == id)
2428           goto skip_it;
2429
2430       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2431       binding = make_tree_vec (4);
2432       TREE_VEC_ELT (binding, 0) = id;
2433       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2434       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2435       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2436       IDENTIFIER_BINDING (id) = NULL_TREE;
2437       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2438       TREE_CHAIN (binding) = old_bindings;
2439       old_bindings = binding;
2440     skip_it:
2441       ;
2442     }
2443   return old_bindings;
2444 }
2445
2446 void
2447 maybe_push_to_top_level (pseudo)
2448      int pseudo;
2449 {
2450   struct saved_scope *s;
2451   struct binding_level *b;
2452   tree old_bindings;
2453   int need_pop;
2454
2455   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2456
2457   b = scope_chain ? current_binding_level : 0;
2458
2459   /* If we're in the middle of some function, save our state.  */
2460   if (cfun)
2461     {
2462       need_pop = 1;
2463       push_function_context_to (NULL_TREE);
2464     }
2465   else
2466     need_pop = 0;
2467
2468   old_bindings = NULL_TREE;
2469   if (scope_chain && previous_class_type)
2470     old_bindings = store_bindings (previous_class_values, old_bindings);
2471
2472   /* Have to include global_binding_level, because class-level decls
2473      aren't listed anywhere useful.  */
2474   for (; b; b = b->level_chain)
2475     {
2476       tree t;
2477
2478       /* Template IDs are inserted into the global level. If they were
2479          inserted into namespace level, finish_file wouldn't find them
2480          when doing pending instantiations. Therefore, don't stop at
2481          namespace level, but continue until :: .  */
2482       if (b == global_binding_level || (pseudo && b->template_parms_p))
2483         break;
2484
2485       old_bindings = store_bindings (b->names, old_bindings);
2486       /* We also need to check class_shadowed to save class-level type
2487          bindings, since pushclass doesn't fill in b->names.  */
2488       if (b->parm_flag == 2)
2489         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2490
2491       /* Unwind type-value slots back to top level.  */
2492       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2493         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2494     }
2495   s->prev = scope_chain;
2496   s->old_bindings = old_bindings;
2497   s->bindings = b;
2498   s->need_pop_function_context = need_pop;
2499   s->function_decl = current_function_decl;
2500   s->last_parms = last_function_parms;
2501
2502   scope_chain = s;
2503   current_function_decl = NULL_TREE;
2504   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2505   current_lang_name = lang_name_cplusplus;
2506   current_namespace = global_namespace;
2507 }
2508
2509 void
2510 push_to_top_level ()
2511 {
2512   maybe_push_to_top_level (0);
2513 }
2514
2515 void
2516 pop_from_top_level ()
2517 {
2518   struct saved_scope *s = scope_chain;
2519   tree t;
2520
2521   /* Clear out class-level bindings cache.  */
2522   if (previous_class_type)
2523     invalidate_class_lookup_cache ();
2524
2525   VARRAY_FREE (current_lang_base);
2526
2527   scope_chain = s->prev;
2528   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2529     {
2530       tree id = TREE_VEC_ELT (t, 0);
2531
2532       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2533       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2534       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2535     }
2536
2537   /* If we were in the middle of compiling a function, restore our
2538      state.  */
2539   if (s->need_pop_function_context)
2540     pop_function_context_from (NULL_TREE);
2541   current_function_decl = s->function_decl;
2542   last_function_parms = s->last_parms;
2543
2544   free (s);
2545 }
2546 \f
2547 /* Push a definition of struct, union or enum tag "name".
2548    into binding_level "b".   "type" should be the type node,
2549    We assume that the tag "name" is not already defined.
2550
2551    Note that the definition may really be just a forward reference.
2552    In that case, the TYPE_SIZE will be a NULL_TREE.
2553
2554    C++ gratuitously puts all these tags in the name space.  */
2555
2556 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2557    record the shadowed value for this binding contour.  TYPE is
2558    the type that ID maps to.  */
2559
2560 static void
2561 set_identifier_type_value_with_scope (id, type, b)
2562      tree id;
2563      tree type;
2564      struct binding_level *b;
2565 {
2566   if (!b->namespace_p)
2567     {
2568       /* Shadow the marker, not the real thing, so that the marker
2569          gets restored later. */
2570       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2571       b->type_shadowed
2572         = tree_cons (id, old_type_value, b->type_shadowed);
2573     }
2574   else
2575     {
2576       tree binding = binding_for_name (id, current_namespace);
2577       BINDING_TYPE (binding) = type;
2578       /* Store marker instead of real type. */
2579       type = global_type_node;
2580     }
2581   SET_IDENTIFIER_TYPE_VALUE (id, type);
2582 }
2583
2584 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2585
2586 void
2587 set_identifier_type_value (id, type)
2588      tree id;
2589      tree type;
2590 {
2591   set_identifier_type_value_with_scope (id, type, current_binding_level);
2592 }
2593
2594 /* Return the type associated with id. */
2595
2596 tree
2597 identifier_type_value (id)
2598      tree id;
2599 {
2600   /* There is no type with that name, anywhere. */
2601   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2602     return NULL_TREE;
2603   /* This is not the type marker, but the real thing. */
2604   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2605     return REAL_IDENTIFIER_TYPE_VALUE (id);
2606   /* Have to search for it. It must be on the global level, now.
2607      Ask lookup_name not to return non-types. */
2608   id = lookup_name_real (id, 2, 1, 0);
2609   if (id)
2610     return TREE_TYPE (id);
2611   return NULL_TREE;
2612 }
2613
2614 /* Pop off extraneous binding levels left over due to syntax errors.
2615
2616    We don't pop past namespaces, as they might be valid.  */
2617
2618 void
2619 pop_everything ()
2620 {
2621 #ifdef DEBUG_CP_BINDING_LEVELS
2622   fprintf (stderr, "XXX entering pop_everything ()\n");
2623 #endif
2624   while (!toplevel_bindings_p ())
2625     {
2626       if (current_binding_level->parm_flag == 2)
2627         pop_nested_class ();
2628       else
2629         poplevel (0, 0, 0);
2630     }
2631 #ifdef DEBUG_CP_BINDING_LEVELS
2632   fprintf (stderr, "XXX leaving pop_everything ()\n");
2633 #endif
2634 }
2635
2636 /* The type TYPE is being declared.  If it is a class template, or a
2637    specialization of a class template, do any processing required and
2638    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2639    being declared a friend.  B is the binding level at which this TYPE
2640    should be bound.
2641
2642    Returns the TYPE_DECL for TYPE, which may have been altered by this
2643    processing.  */
2644
2645 static tree
2646 maybe_process_template_type_declaration (type, globalize, b)
2647      tree type;
2648      int globalize;
2649      struct binding_level* b;
2650 {
2651   tree decl = TYPE_NAME (type);
2652
2653   if (processing_template_parmlist)
2654     /* You can't declare a new template type in a template parameter
2655        list.  But, you can declare a non-template type:
2656
2657          template <class A*> struct S;
2658
2659        is a forward-declaration of `A'.  */
2660     ;
2661   else
2662     {
2663       maybe_check_template_type (type);
2664
2665       my_friendly_assert (IS_AGGR_TYPE (type)
2666                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2667
2668
2669       if (processing_template_decl)
2670         {
2671           /* This may change after the call to
2672              push_template_decl_real, but we want the original value.  */
2673           tree name = DECL_NAME (decl);
2674
2675           decl = push_template_decl_real (decl, globalize);
2676           /* If the current binding level is the binding level for the
2677              template parameters (see the comment in
2678              begin_template_parm_list) and the enclosing level is a class
2679              scope, and we're not looking at a friend, push the
2680              declaration of the member class into the class scope.  In the
2681              friend case, push_template_decl will already have put the
2682              friend into global scope, if appropriate.  */
2683           if (TREE_CODE (type) != ENUMERAL_TYPE
2684               && !globalize && b->template_parms_p
2685               && b->level_chain->parm_flag == 2)
2686             {
2687               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2688               /* Put this tag on the list of tags for the class, since
2689                  that won't happen below because B is not the class
2690                  binding level, but is instead the pseudo-global level.  */
2691               b->level_chain->tags =
2692                 tree_cons (name, type, b->level_chain->tags);
2693               if (!COMPLETE_TYPE_P (current_class_type))
2694                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2695             }
2696         }
2697     }
2698
2699   return decl;
2700 }
2701
2702 /* In C++, you don't have to write `struct S' to refer to `S'; you
2703    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2704    if the user had written `typedef struct S S'.  Create and return
2705    the TYPE_DECL for TYPE.  */
2706
2707 tree
2708 create_implicit_typedef (name, type)
2709      tree name;
2710      tree type;
2711 {
2712   tree decl;
2713
2714   decl = build_decl (TYPE_DECL, name, type);
2715   DECL_ARTIFICIAL (decl) = 1;
2716   /* There are other implicit type declarations, like the one *within*
2717      a class that allows you to write `S::S'.  We must distinguish
2718      amongst these.  */
2719   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2720   TYPE_NAME (type) = decl;
2721
2722   return decl;
2723 }
2724
2725 /* Remember a local name for name-mangling purposes.  */
2726
2727 static void
2728 push_local_name (decl)
2729      tree decl;
2730 {
2731   size_t i, nelts;
2732   tree t, name;
2733
2734   if (!local_names)
2735     VARRAY_TREE_INIT (local_names, 8, "local_names");
2736
2737   name = DECL_NAME (decl);
2738
2739   nelts = VARRAY_ACTIVE_SIZE (local_names);
2740   for (i = 0; i < nelts; i++)
2741     {
2742       t = VARRAY_TREE (local_names, i);
2743       if (DECL_NAME (t) == name)
2744         {
2745           if (!DECL_LANG_SPECIFIC (decl))
2746             retrofit_lang_decl (decl);
2747           if (DECL_LANG_SPECIFIC (t))
2748             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2749           else
2750             DECL_DISCRIMINATOR (decl) = 1;
2751
2752           VARRAY_TREE (local_names, i) = decl;
2753           return;
2754         }
2755     }
2756
2757   VARRAY_PUSH_TREE (local_names, decl);
2758 }
2759
2760 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2761    Normally put it into the inner-most non-tag-transparent scope,
2762    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2763    The latter is needed for implicit declarations.  */
2764
2765 void
2766 pushtag (name, type, globalize)
2767      tree name, type;
2768      int globalize;
2769 {
2770   register struct binding_level *b;
2771
2772   b = current_binding_level;
2773   while (b->tag_transparent
2774          || (b->parm_flag == 2
2775              && (globalize
2776                  /* We may be defining a new type in the initializer
2777                     of a static member variable. We allow this when
2778                     not pedantic, and it is particularly useful for
2779                     type punning via an anonymous union. */
2780                  || COMPLETE_TYPE_P (b->this_class))))
2781     b = b->level_chain;
2782
2783   b->tags = tree_cons (name, type, b->tags);
2784
2785   if (name)
2786     {
2787       /* Do C++ gratuitous typedefing.  */
2788       if (IDENTIFIER_TYPE_VALUE (name) != type)
2789         {
2790           register tree d = NULL_TREE;
2791           int in_class = 0;
2792           tree context = TYPE_CONTEXT (type);
2793
2794           if (! context)
2795             {
2796               tree cs = current_scope ();
2797
2798               if (! globalize)
2799                 context = cs;
2800               else if (cs != NULL_TREE && TYPE_P (cs))
2801                 /* When declaring a friend class of a local class, we want
2802                    to inject the newly named class into the scope
2803                    containing the local class, not the namespace scope.  */
2804                 context = decl_function_context (get_type_decl (cs));
2805             }
2806           if (!context)
2807             context = current_namespace;
2808
2809           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2810               || b->parm_flag == 2)
2811             in_class = 1;
2812
2813           if (current_lang_name == lang_name_java)
2814             TYPE_FOR_JAVA (type) = 1;
2815
2816           d = create_implicit_typedef (name, type);
2817           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2818           if (! in_class)
2819             set_identifier_type_value_with_scope (name, type, b);
2820
2821           d = maybe_process_template_type_declaration (type,
2822                                                        globalize, b);
2823
2824           if (b->parm_flag == 2)
2825             {
2826               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2827                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2828                    class.  But if it's a member template class, we
2829                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2830                    is done later.  */
2831                 finish_member_declaration (d);
2832               else
2833                 pushdecl_class_level (d);
2834             }
2835           else
2836             d = pushdecl_with_scope (d, b);
2837
2838           /* FIXME what if it gets a name from typedef?  */
2839           if (ANON_AGGRNAME_P (name))
2840             DECL_IGNORED_P (d) = 1;
2841
2842           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2843
2844           /* If this is a local class, keep track of it.  We need this
2845              information for name-mangling, and so that it is possible to find
2846              all function definitions in a translation unit in a convenient
2847              way.  (It's otherwise tricky to find a member function definition
2848              it's only pointed to from within a local class.)  */
2849           if (TYPE_CONTEXT (type)
2850               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2851               && !processing_template_decl)
2852             VARRAY_PUSH_TREE (local_classes, type);
2853         }
2854       if (b->parm_flag == 2)
2855         {
2856           if (!COMPLETE_TYPE_P (current_class_type))
2857             CLASSTYPE_TAGS (current_class_type) = b->tags;
2858         }
2859     }
2860
2861   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2862     /* Use the canonical TYPE_DECL for this node.  */
2863     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2864   else
2865     {
2866       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2867          will be the tagged type we just added to the current
2868          binding level.  This fake NULL-named TYPE_DECL node helps
2869          dwarfout.c to know when it needs to output a
2870          representation of a tagged type, and it also gives us a
2871          convenient place to record the "scope start" address for
2872          the tagged type.  */
2873
2874       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2875       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2876     }
2877 }
2878
2879 /* Counter used to create anonymous type names.  */
2880
2881 static int anon_cnt = 0;
2882
2883 /* Return an IDENTIFIER which can be used as a name for
2884    anonymous structs and unions.  */
2885
2886 tree
2887 make_anon_name ()
2888 {
2889   char buf[32];
2890
2891   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2892   return get_identifier (buf);
2893 }
2894
2895 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2896    This keeps dbxout from getting confused.  */
2897
2898 void
2899 clear_anon_tags ()
2900 {
2901   register struct binding_level *b;
2902   register tree tags;
2903   static int last_cnt = 0;
2904
2905   /* Fast out if no new anon names were declared.  */
2906   if (last_cnt == anon_cnt)
2907     return;
2908
2909   b = current_binding_level;
2910   while (b->tag_transparent)
2911     b = b->level_chain;
2912   tags = b->tags;
2913   while (tags)
2914     {
2915       /* A NULL purpose means we have already processed all tags
2916          from here to the end of the list.  */
2917       if (TREE_PURPOSE (tags) == NULL_TREE)
2918         break;
2919       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2920         TREE_PURPOSE (tags) = NULL_TREE;
2921       tags = TREE_CHAIN (tags);
2922     }
2923   last_cnt = anon_cnt;
2924 }
2925 \f
2926 /* Subroutine of duplicate_decls: return truthvalue of whether
2927    or not types of these decls match.
2928
2929    For C++, we must compare the parameter list so that `int' can match
2930    `int&' in a parameter position, but `int&' is not confused with
2931    `const int&'.  */
2932
2933 int
2934 decls_match (newdecl, olddecl)
2935      tree newdecl, olddecl;
2936 {
2937   int types_match;
2938
2939   if (newdecl == olddecl)
2940     return 1;
2941
2942   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2943     /* If the two DECLs are not even the same kind of thing, we're not
2944        interested in their types.  */
2945     return 0;
2946
2947   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2948     {
2949       tree f1 = TREE_TYPE (newdecl);
2950       tree f2 = TREE_TYPE (olddecl);
2951       tree p1 = TYPE_ARG_TYPES (f1);
2952       tree p2 = TYPE_ARG_TYPES (f2);
2953
2954       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2955           && ! (DECL_EXTERN_C_P (newdecl)
2956                 && DECL_EXTERN_C_P (olddecl)))
2957         return 0;
2958
2959       if (TREE_CODE (f1) != TREE_CODE (f2))
2960         return 0;
2961
2962       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2963         {
2964           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2965               && (DECL_BUILT_IN (olddecl)
2966 #ifndef NO_IMPLICIT_EXTERN_C
2967                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2968                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2969 #endif
2970               ))
2971             {
2972               types_match = self_promoting_args_p (p1);
2973               if (p1 == void_list_node)
2974                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2975             }
2976 #ifndef NO_IMPLICIT_EXTERN_C
2977           else if (p1 == NULL_TREE
2978                    && (DECL_EXTERN_C_P (olddecl)
2979                        && DECL_IN_SYSTEM_HEADER (olddecl)
2980                        && !DECL_CLASS_SCOPE_P (olddecl))
2981                    && (DECL_EXTERN_C_P (newdecl)
2982                        && DECL_IN_SYSTEM_HEADER (newdecl)
2983                        && !DECL_CLASS_SCOPE_P (newdecl)))
2984             {
2985               types_match = self_promoting_args_p (p2);
2986               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2987             }
2988 #endif
2989           else
2990             types_match = compparms (p1, p2);
2991         }
2992       else
2993         types_match = 0;
2994     }
2995   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2996     {
2997       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2998                                 DECL_TEMPLATE_PARMS (olddecl)))
2999         return 0;
3000
3001       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3002           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3003         return 0;
3004
3005       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3006         types_match = 1;
3007       else
3008         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3009                                    DECL_TEMPLATE_RESULT (newdecl));
3010     }
3011   else
3012     {
3013       if (TREE_TYPE (newdecl) == error_mark_node)
3014         types_match = TREE_TYPE (olddecl) == error_mark_node;
3015       else if (TREE_TYPE (olddecl) == NULL_TREE)
3016         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3017       else if (TREE_TYPE (newdecl) == NULL_TREE)
3018         types_match = 0;
3019       else
3020         types_match = comptypes (TREE_TYPE (newdecl),
3021                                  TREE_TYPE (olddecl),
3022                                  COMPARE_REDECLARATION);
3023     }
3024
3025   return types_match;
3026 }
3027
3028 /* If NEWDECL is `static' and an `extern' was seen previously,
3029    warn about it.  OLDDECL is the previous declaration.
3030
3031    Note that this does not apply to the C++ case of declaring
3032    a variable `extern const' and then later `const'.
3033
3034    Don't complain about built-in functions, since they are beyond
3035    the user's control.  */
3036
3037 static void
3038 warn_extern_redeclared_static (newdecl, olddecl)
3039      tree newdecl, olddecl;
3040 {
3041   static const char *const explicit_extern_static_warning
3042     = "`%D' was declared `extern' and later `static'";
3043   static const char *const implicit_extern_static_warning
3044     = "`%D' was declared implicitly `extern' and later `static'";
3045
3046   tree name;
3047
3048   if (TREE_CODE (newdecl) == TYPE_DECL
3049       || TREE_CODE (newdecl) == TEMPLATE_DECL
3050       || TREE_CODE (newdecl) == CONST_DECL)
3051     return;
3052
3053   /* Don't get confused by static member functions; that's a different
3054      use of `static'.  */
3055   if (TREE_CODE (newdecl) == FUNCTION_DECL
3056       && DECL_STATIC_FUNCTION_P (newdecl))
3057     return;
3058
3059   /* If the old declaration was `static', or the new one isn't, then
3060      then everything is OK.  */
3061   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3062     return;
3063
3064   /* It's OK to declare a builtin function as `static'.  */
3065   if (TREE_CODE (olddecl) == FUNCTION_DECL
3066       && DECL_ARTIFICIAL (olddecl))
3067     return;
3068
3069   name = DECL_ASSEMBLER_NAME (newdecl);
3070   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3071               ? implicit_extern_static_warning
3072               : explicit_extern_static_warning, newdecl);
3073   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3074 }
3075
3076 /* Handle when a new declaration NEWDECL has the same name as an old
3077    one OLDDECL in the same binding contour.  Prints an error message
3078    if appropriate.
3079
3080    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3081    Otherwise, return 0.  */
3082
3083 int
3084 duplicate_decls (newdecl, olddecl)
3085      tree newdecl, olddecl;
3086 {
3087   unsigned olddecl_uid = DECL_UID (olddecl);
3088   int olddecl_friend = 0, types_match = 0;
3089   int new_defines_function = 0;
3090
3091   if (newdecl == olddecl)
3092     return 1;
3093
3094   types_match = decls_match (newdecl, olddecl);
3095
3096   /* If either the type of the new decl or the type of the old decl is an
3097      error_mark_node, then that implies that we have already issued an
3098      error (earlier) for some bogus type specification, and in that case,
3099      it is rather pointless to harass the user with yet more error message
3100      about the same declaration, so just pretend the types match here.  */
3101   if (TREE_TYPE (newdecl) == error_mark_node
3102       || TREE_TYPE (olddecl) == error_mark_node)
3103     types_match = 1;
3104
3105   if (DECL_P (olddecl)
3106       && TREE_CODE (newdecl) == FUNCTION_DECL
3107       && TREE_CODE (olddecl) == FUNCTION_DECL
3108       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3109     {
3110       if (DECL_DECLARED_INLINE_P (newdecl)
3111           && DECL_UNINLINABLE (newdecl)
3112           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3113         /* Already warned elsewhere.  */;
3114       else if (DECL_DECLARED_INLINE_P (olddecl)
3115                && DECL_UNINLINABLE (olddecl)
3116                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3117         /* Already warned.  */;
3118       else if (DECL_DECLARED_INLINE_P (newdecl)
3119                && DECL_UNINLINABLE (olddecl)
3120                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3121         {
3122           warning_with_decl (newdecl,
3123                              "function `%s' redeclared as inline");
3124           warning_with_decl (olddecl,
3125                              "previous declaration of function `%s' with attribute noinline");
3126         }
3127       else if (DECL_DECLARED_INLINE_P (olddecl)
3128                && DECL_UNINLINABLE (newdecl)
3129                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3130         {
3131           warning_with_decl (newdecl,
3132                              "function `%s' redeclared with attribute noinline");
3133           warning_with_decl (olddecl,
3134                              "previous declaration of function `%s' was inline");
3135         }
3136     }
3137
3138   /* Check for redeclaration and other discrepancies. */
3139   if (TREE_CODE (olddecl) == FUNCTION_DECL
3140       && DECL_ARTIFICIAL (olddecl))
3141     {
3142       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3143         {
3144           /* Avoid warnings redeclaring anticipated built-ins.  */
3145           if (DECL_ANTICIPATED (olddecl))
3146             return 0;
3147
3148           /* If you declare a built-in or predefined function name as static,
3149              the old definition is overridden, but optionally warn this was a
3150              bad choice of name.  */
3151           if (! TREE_PUBLIC (newdecl))
3152             {
3153               if (warn_shadow)
3154                 warning ("shadowing %s function `%#D'",
3155                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3156                             olddecl);
3157               /* Discard the old built-in function.  */
3158               return 0;
3159             }
3160           /* If the built-in is not ansi, then programs can override
3161              it even globally without an error.  */
3162           else if (! DECL_BUILT_IN (olddecl))
3163             warning ("library function `%#D' redeclared as non-function `%#D'",
3164                         olddecl, newdecl);
3165           else
3166             {
3167               error ("declaration of `%#D'", newdecl);
3168               error ("conflicts with built-in declaration `%#D'",
3169                         olddecl);
3170             }
3171           return 0;
3172         }
3173       else if (!types_match)
3174         {
3175           /* Avoid warnings redeclaring anticipated built-ins.  */
3176           if (DECL_ANTICIPATED (olddecl))
3177             ;  /* Do nothing yet.  */
3178           else if ((DECL_EXTERN_C_P (newdecl)
3179                && DECL_EXTERN_C_P (olddecl))
3180               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3181                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3182             {
3183               /* A near match; override the builtin.  */
3184
3185               if (TREE_PUBLIC (newdecl))
3186                 {
3187                   warning ("new declaration `%#D'", newdecl);
3188                   warning ("ambiguates built-in declaration `%#D'",
3189                               olddecl);
3190                 }
3191               else if (warn_shadow)
3192                 warning ("shadowing %s function `%#D'",
3193                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3194                             olddecl);
3195             }
3196           else
3197             /* Discard the old built-in function.  */
3198             return 0;
3199
3200           /* Replace the old RTL to avoid problems with inlining.  */
3201           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3202         }
3203
3204       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3205         {
3206           /* If a builtin function is redeclared as `static', merge
3207              the declarations, but make the original one static.  */
3208           DECL_THIS_STATIC (olddecl) = 1;
3209           TREE_PUBLIC (olddecl) = 0;
3210
3211           /* Make the old declaration consistent with the new one so
3212              that all remnants of the builtin-ness of this function
3213              will be banished.  */
3214           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3215           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3216         }
3217     }
3218   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3219     {
3220       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3221            && TREE_CODE (newdecl) != TYPE_DECL
3222            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3223                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3224           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3225               && TREE_CODE (olddecl) != TYPE_DECL
3226               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3227                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3228                         == TYPE_DECL))))
3229         {
3230           /* We do nothing special here, because C++ does such nasty
3231              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3232              get shadowed, and know that if we need to find a TYPE_DECL
3233              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3234              slot of the identifier.  */
3235           return 0;
3236         }
3237
3238       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3239            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3240           || (TREE_CODE (olddecl) == FUNCTION_DECL
3241               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3242         return 0;
3243
3244       error ("`%#D' redeclared as different kind of symbol", newdecl);
3245       if (TREE_CODE (olddecl) == TREE_LIST)
3246         olddecl = TREE_VALUE (olddecl);
3247       cp_error_at ("previous declaration of `%#D'", olddecl);
3248
3249       /* New decl is completely inconsistent with the old one =>
3250          tell caller to replace the old one.  */
3251
3252       return 0;
3253     }
3254   else if (!types_match)
3255     {
3256       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3257         /* These are certainly not duplicate declarations; they're
3258            from different scopes.  */
3259         return 0;
3260
3261       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3262         {
3263           /* The name of a class template may not be declared to refer to
3264              any other template, class, function, object, namespace, value,
3265              or type in the same scope.  */
3266           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3267               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3268             {
3269               error ("declaration of template `%#D'", newdecl);
3270               cp_error_at ("conflicts with previous declaration `%#D'",
3271                            olddecl);
3272             }
3273           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3274                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3275                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3276                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3277                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3278                                            DECL_TEMPLATE_PARMS (olddecl)))
3279             {
3280               error ("new declaration `%#D'", newdecl);
3281               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3282             }
3283           return 0;
3284         }
3285       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3286         {
3287           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3288             {
3289               error ("declaration of C function `%#D' conflicts with",
3290                         newdecl);
3291               cp_error_at ("previous declaration `%#D' here", olddecl);
3292             }
3293           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3294                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3295             {
3296               error ("new declaration `%#D'", newdecl);
3297               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3298             }
3299           else
3300             return 0;
3301         }
3302
3303       /* Already complained about this, so don't do so again.  */
3304       else if (current_class_type == NULL_TREE
3305           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3306         {
3307           error ("conflicting types for `%#D'", newdecl);
3308           cp_error_at ("previous declaration as `%#D'", olddecl);
3309         }
3310     }
3311   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3312             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3313                  && (!DECL_TEMPLATE_INFO (newdecl)
3314                      || (DECL_TI_TEMPLATE (newdecl)
3315                          != DECL_TI_TEMPLATE (olddecl))))
3316                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3317                     && (!DECL_TEMPLATE_INFO (olddecl)
3318                         || (DECL_TI_TEMPLATE (olddecl)
3319                             != DECL_TI_TEMPLATE (newdecl))))))
3320     /* It's OK to have a template specialization and a non-template
3321        with the same type, or to have specializations of two
3322        different templates with the same type.  Note that if one is a
3323        specialization, and the other is an instantiation of the same
3324        template, that we do not exit at this point.  That situation
3325        can occur if we instantiate a template class, and then
3326        specialize one of its methods.  This situation is legal, but
3327        the declarations must be merged in the usual way.  */
3328     return 0;
3329   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3330            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3331                 && !DECL_USE_TEMPLATE (newdecl))
3332                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3333                    && !DECL_USE_TEMPLATE (olddecl))))
3334     /* One of the declarations is a template instantiation, and the
3335        other is not a template at all.  That's OK.  */
3336     return 0;
3337   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3338            && DECL_NAMESPACE_ALIAS (newdecl)
3339            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3340     /* Redeclaration of namespace alias, ignore it. */
3341     return 1;
3342   else
3343     {
3344       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3345       if (errmsg)
3346         {
3347           error (errmsg, newdecl);
3348           if (DECL_NAME (olddecl) != NULL_TREE)
3349             cp_error_at ((DECL_INITIAL (olddecl)
3350                           && namespace_bindings_p ())
3351                          ? "`%#D' previously defined here"
3352                          : "`%#D' previously declared here", olddecl);
3353           return 0;
3354         }
3355       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3356                && DECL_INITIAL (olddecl) != NULL_TREE
3357                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3358                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3359         {
3360           /* Prototype decl follows defn w/o prototype.  */
3361           cp_warning_at ("prototype for `%#D'", newdecl);
3362           cp_warning_at ("follows non-prototype definition here", olddecl);
3363         }
3364       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3365                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3366         {
3367           /* extern "C" int foo ();
3368              int foo () { bar (); }
3369              is OK.  */
3370           if (current_lang_depth () == 0)
3371             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3372           else
3373             {
3374               cp_error_at ("previous declaration of `%#D' with %L linkage",
3375                            olddecl, DECL_LANGUAGE (olddecl));
3376               error ("conflicts with new declaration with %L linkage",
3377                         DECL_LANGUAGE (newdecl));
3378             }
3379         }
3380
3381       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3382         ;
3383       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3384         {
3385           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3386           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3387           int i = 1;
3388
3389           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3390             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3391
3392           for (; t1 && t1 != void_list_node;
3393                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3394             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3395               {
3396                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3397                                            TREE_PURPOSE (t2)))
3398                   {
3399                     pedwarn ("default argument given for parameter %d of `%#D'",
3400                              i, newdecl);
3401                     cp_pedwarn_at ("after previous specification in `%#D'",
3402                                    olddecl);
3403                   }
3404                 else
3405                   {
3406                     error ("default argument given for parameter %d of `%#D'",
3407                               i, newdecl);
3408                     cp_error_at ("after previous specification in `%#D'",
3409                                  olddecl);
3410                   }
3411               }
3412
3413           if (DECL_DECLARED_INLINE_P (newdecl)
3414               && ! DECL_DECLARED_INLINE_P (olddecl)
3415               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3416             {
3417               warning ("`%#D' was used before it was declared inline",
3418                           newdecl);
3419               cp_warning_at ("previous non-inline declaration here",
3420                              olddecl);
3421             }
3422         }
3423     }
3424
3425   /* Do not merge an implicit typedef with an explicit one.  In:
3426
3427        class A;
3428        ...
3429        typedef class A A __attribute__ ((foo));
3430
3431      the attribute should apply only to the typedef.  */
3432   if (TREE_CODE (olddecl) == TYPE_DECL
3433       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3434           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3435     return 0;
3436
3437   /* If new decl is `static' and an `extern' was seen previously,
3438      warn about it.  */
3439   warn_extern_redeclared_static (newdecl, olddecl);
3440
3441   /* We have committed to returning 1 at this point.  */
3442   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3443     {
3444       /* Now that functions must hold information normally held
3445          by field decls, there is extra work to do so that
3446          declaration information does not get destroyed during
3447          definition.  */
3448       if (DECL_VINDEX (olddecl))
3449         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3450       if (DECL_VIRTUAL_CONTEXT (olddecl))
3451         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3452       if (DECL_CONTEXT (olddecl))
3453         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3454       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3455         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3456       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3457       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3458       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3459       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3460       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3461       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3462       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3463         SET_OVERLOADED_OPERATOR_CODE
3464           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3465       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3466
3467       /* Optionally warn about more than one declaration for the same
3468          name, but don't warn about a function declaration followed by a
3469          definition.  */
3470       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3471           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3472           /* Don't warn about extern decl followed by definition. */
3473           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3474           /* Don't warn about friends, let add_friend take care of it. */
3475           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3476         {
3477           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3478           cp_warning_at ("previous declaration of `%D'", olddecl);
3479         }
3480     }
3481
3482   /* Deal with C++: must preserve virtual function table size.  */
3483   if (TREE_CODE (olddecl) == TYPE_DECL)
3484     {
3485       register tree newtype = TREE_TYPE (newdecl);
3486       register tree oldtype = TREE_TYPE (olddecl);
3487
3488       if (newtype != error_mark_node && oldtype != error_mark_node
3489           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3490         {
3491           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3492           CLASSTYPE_FRIEND_CLASSES (newtype)
3493             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3494         }
3495
3496       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3497     }
3498
3499   /* Copy all the DECL_... slots specified in the new decl
3500      except for any that we copy here from the old type.  */
3501   DECL_ATTRIBUTES (newdecl)
3502     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3503   decl_attributes (&newdecl, DECL_ATTRIBUTES (newdecl), 0);
3504
3505   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3506     {
3507       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3508       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3509         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3510                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3511
3512       /* If the new declaration is a definition, update the file and
3513          line information on the declaration.  */
3514       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3515           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3516         {
3517           DECL_SOURCE_LINE (olddecl)
3518             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3519             = DECL_SOURCE_LINE (newdecl);
3520           DECL_SOURCE_FILE (olddecl)
3521             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3522             = DECL_SOURCE_FILE (newdecl);
3523         }
3524
3525       return 1;
3526     }
3527
3528   if (types_match)
3529     {
3530       /* Automatically handles default parameters.  */
3531       tree oldtype = TREE_TYPE (olddecl);
3532       tree newtype;
3533
3534       /* Merge the data types specified in the two decls.  */
3535       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3536
3537       /* If merge_types produces a non-typedef type, just use the old type.  */
3538       if (TREE_CODE (newdecl) == TYPE_DECL
3539           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3540         newtype = oldtype;
3541
3542       if (TREE_CODE (newdecl) == VAR_DECL)
3543         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3544       /* Do this after calling `merge_types' so that default
3545          parameters don't confuse us.  */
3546       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3547           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3548               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3549         {
3550           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3551                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3552           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3553                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3554
3555           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3556               && DECL_SOURCE_LINE (olddecl) != 0
3557               && flag_exceptions
3558               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3559                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3560             {
3561               error ("declaration of `%F' throws different exceptions",
3562                         newdecl);
3563               cp_error_at ("than previous declaration `%F'", olddecl);
3564             }
3565         }
3566       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3567
3568       /* Lay the type out, unless already done.  */
3569       if (! same_type_p (newtype, oldtype)
3570           && TREE_TYPE (newdecl) != error_mark_node
3571           && !(processing_template_decl && uses_template_parms (newdecl)))
3572         layout_type (TREE_TYPE (newdecl));
3573
3574       if ((TREE_CODE (newdecl) == VAR_DECL
3575            || TREE_CODE (newdecl) == PARM_DECL
3576            || TREE_CODE (newdecl) == RESULT_DECL
3577            || TREE_CODE (newdecl) == FIELD_DECL
3578            || TREE_CODE (newdecl) == TYPE_DECL)
3579           && !(processing_template_decl && uses_template_parms (newdecl)))
3580         layout_decl (newdecl, 0);
3581
3582       /* Merge the type qualifiers.  */
3583       if (TREE_READONLY (newdecl))
3584         TREE_READONLY (olddecl) = 1;
3585       if (TREE_THIS_VOLATILE (newdecl))
3586         TREE_THIS_VOLATILE (olddecl) = 1;
3587
3588       /* Merge the initialization information.  */
3589       if (DECL_INITIAL (newdecl) == NULL_TREE
3590           && DECL_INITIAL (olddecl) != NULL_TREE)
3591         {
3592           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3593           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3594           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3595           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3596               && DECL_LANG_SPECIFIC (newdecl)
3597               && DECL_LANG_SPECIFIC (olddecl))
3598             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3599         }
3600
3601       /* Merge the section attribute.
3602          We want to issue an error if the sections conflict but that must be
3603          done later in decl_attributes since we are called before attributes
3604          are assigned.  */
3605       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3606         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3607
3608       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3609         {
3610           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3611             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3612           DECL_NO_LIMIT_STACK (newdecl)
3613             |= DECL_NO_LIMIT_STACK (olddecl);
3614           /* Keep the old RTL.  */
3615           COPY_DECL_RTL (olddecl, newdecl);
3616         }
3617       else if (TREE_CODE (newdecl) == VAR_DECL
3618                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3619         {
3620           /* Keep the old RTL.  We cannot keep the old RTL if the old
3621              declaration was for an incomplete object and the new
3622              declaration is not since many attributes of the RTL will
3623              change.  */
3624           COPY_DECL_RTL (olddecl, newdecl);
3625         }
3626     }
3627   /* If cannot merge, then use the new type and qualifiers,
3628      and don't preserve the old rtl.  */
3629   else
3630     {
3631       /* Clean out any memory we had of the old declaration.  */
3632       tree oldstatic = value_member (olddecl, static_aggregates);
3633       if (oldstatic)
3634         TREE_VALUE (oldstatic) = error_mark_node;
3635
3636       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3637       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3638       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3639       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3640     }
3641
3642   /* Merge the storage class information.  */
3643   merge_weak (newdecl, olddecl);
3644
3645   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3646   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3647   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3648   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3649   if (! DECL_EXTERNAL (olddecl))
3650     DECL_EXTERNAL (newdecl) = 0;
3651
3652   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3653     {
3654       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3655       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3656       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3657       DECL_TEMPLATE_INSTANTIATED (newdecl)
3658         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3659       /* Don't really know how much of the language-specific
3660          values we should copy from old to new.  */
3661       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3662       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3663       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3664       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3665       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3666         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3667       olddecl_friend = DECL_FRIEND_P (olddecl);
3668
3669       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3670       if (TREE_CODE (newdecl) == FUNCTION_DECL
3671           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3672         DECL_BEFRIENDING_CLASSES (newdecl)
3673           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3674                      DECL_BEFRIENDING_CLASSES (olddecl));
3675     }
3676
3677   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3678     {
3679       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3680           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3681         {
3682           /* If newdecl is not a specialization, then it is not a
3683              template-related function at all.  And that means that we
3684              shoud have exited above, returning 0.  */
3685           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3686                               0);
3687
3688           if (TREE_USED (olddecl))
3689             /* From [temp.expl.spec]:
3690
3691                If a template, a member template or the member of a class
3692                template is explicitly specialized then that
3693                specialization shall be declared before the first use of
3694                that specialization that would cause an implicit
3695                instantiation to take place, in every translation unit in
3696                which such a use occurs.  */
3697             error ("explicit specialization of %D after first use",
3698                       olddecl);
3699
3700           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3701         }
3702       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3703
3704       /* If either decl says `inline', this fn is inline, unless its
3705          definition was passed already.  */
3706       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3707         DECL_INLINE (olddecl) = 1;
3708       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3709
3710       DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3711         = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3712
3713       /* Preserve abstractness on cloned [cd]tors.  */
3714       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3715
3716       if (! types_match)
3717         {
3718           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3719           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3720           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3721         }
3722       if (! types_match || new_defines_function)
3723         {
3724           /* These need to be copied so that the names are available.
3725              Note that if the types do match, we'll preserve inline
3726              info and other bits, but if not, we won't.  */
3727           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3728           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3729         }
3730       if (new_defines_function)
3731         /* If defining a function declared with other language
3732            linkage, use the previously declared language linkage.  */
3733         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3734       else if (types_match)
3735         {
3736           /* If redeclaring a builtin function, and not a definition,
3737              it stays built in.  */
3738           if (DECL_BUILT_IN (olddecl))
3739             {
3740               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3741               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3742               /* If we're keeping the built-in definition, keep the rtl,
3743                  regardless of declaration matches.  */
3744               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3745             }
3746           else
3747             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3748
3749           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3750           /* Don't clear out the arguments if we're redefining a function.  */
3751           if (DECL_ARGUMENTS (olddecl))
3752             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3753         }
3754     }
3755   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3756     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3757
3758   /* Now preserve various other info from the definition.  */
3759   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3760   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3761   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3762   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3763
3764   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3765     {
3766       int function_size;
3767
3768       function_size = sizeof (struct tree_decl);
3769
3770       memcpy ((char *) olddecl + sizeof (struct tree_common),
3771               (char *) newdecl + sizeof (struct tree_common),
3772               function_size - sizeof (struct tree_common));
3773
3774       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3775         {
3776           /* If newdecl is a template instantiation, it is possible that
3777              the following sequence of events has occurred:
3778
3779              o A friend function was declared in a class template.  The
3780              class template was instantiated.
3781
3782              o The instantiation of the friend declaration was
3783              recorded on the instantiation list, and is newdecl.
3784
3785              o Later, however, instantiate_class_template called pushdecl
3786              on the newdecl to perform name injection.  But, pushdecl in
3787              turn called duplicate_decls when it discovered that another
3788              declaration of a global function with the same name already
3789              existed.
3790
3791              o Here, in duplicate_decls, we decided to clobber newdecl.
3792
3793              If we're going to do that, we'd better make sure that
3794              olddecl, and not newdecl, is on the list of
3795              instantiations so that if we try to do the instantiation
3796              again we won't get the clobbered declaration.  */
3797
3798           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3799           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3800
3801           for (; decls; decls = TREE_CHAIN (decls))
3802             if (TREE_VALUE (decls) == newdecl)
3803               TREE_VALUE (decls) = olddecl;
3804         }
3805     }
3806   else
3807     {
3808       memcpy ((char *) olddecl + sizeof (struct tree_common),
3809               (char *) newdecl + sizeof (struct tree_common),
3810               sizeof (struct tree_decl) - sizeof (struct tree_common)
3811               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3812     }
3813
3814   DECL_UID (olddecl) = olddecl_uid;
3815   if (olddecl_friend)
3816     DECL_FRIEND_P (olddecl) = 1;
3817
3818   /* NEWDECL contains the merged attribute lists.
3819      Update OLDDECL to be the same.  */
3820   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3821
3822   return 1;
3823 }
3824
3825 /* Record a decl-node X as belonging to the current lexical scope.
3826    Check for errors (such as an incompatible declaration for the same
3827    name already seen in the same scope).
3828
3829    Returns either X or an old decl for the same name.
3830    If an old decl is returned, it may have been smashed
3831    to agree with what X says.  */
3832
3833 tree
3834 pushdecl (x)
3835      tree x;
3836 {
3837   register tree t;
3838   register tree name;
3839   int need_new_binding;
3840
3841   /* We shouldn't be calling pushdecl when we're generating RTL for a
3842      function that we already did semantic analysis on previously.  */
3843   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3844                       19990913);
3845
3846   need_new_binding = 1;
3847
3848   if (DECL_TEMPLATE_PARM_P (x))
3849     /* Template parameters have no context; they are not X::T even
3850        when declared within a class or namespace.  */
3851     ;
3852   else
3853     {
3854       if (current_function_decl && x != current_function_decl
3855           /* A local declaration for a function doesn't constitute
3856              nesting.  */
3857           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3858           /* A local declaration for an `extern' variable is in the
3859              scope of the current namespace, not the current
3860              function.  */
3861           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3862           && !DECL_CONTEXT (x))
3863         DECL_CONTEXT (x) = current_function_decl;
3864
3865       /* If this is the declaration for a namespace-scope function,
3866          but the declaration itself is in a local scope, mark the
3867          declaration.  */
3868       if (TREE_CODE (x) == FUNCTION_DECL
3869           && DECL_NAMESPACE_SCOPE_P (x)
3870           && current_function_decl
3871           && x != current_function_decl)
3872         DECL_LOCAL_FUNCTION_P (x) = 1;
3873     }
3874
3875   name = DECL_NAME (x);
3876   if (name)
3877     {
3878       int different_binding_level = 0;
3879
3880       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3881         name = TREE_OPERAND (name, 0);
3882
3883       /* In case this decl was explicitly namespace-qualified, look it
3884          up in its namespace context.  */
3885       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3886           && namespace_bindings_p ())
3887         t = namespace_binding (name, DECL_CONTEXT (x));
3888       else
3889         t = lookup_name_current_level (name);
3890
3891       /* [basic.link] If there is a visible declaration of an entity
3892          with linkage having the same name and type, ignoring entities
3893          declared outside the innermost enclosing namespace scope, the
3894          block scope declaration declares that same entity and
3895          receives the linkage of the previous declaration.  */
3896       if (! t && current_function_decl && x != current_function_decl
3897           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3898           && DECL_EXTERNAL (x))
3899         {
3900           /* Look in block scope.  */
3901           t = IDENTIFIER_VALUE (name);
3902           /* Or in the innermost namespace.  */
3903           if (! t)
3904             t = namespace_binding (name, DECL_CONTEXT (x));
3905           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3906              OVERLOAD, which is OK.  */
3907           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3908             t = NULL_TREE;
3909           if (t)
3910             different_binding_level = 1;
3911         }
3912
3913       /* If we are declaring a function, and the result of name-lookup
3914          was an OVERLOAD, look for an overloaded instance that is
3915          actually the same as the function we are declaring.  (If
3916          there is one, we have to merge our declaration with the
3917          previous declaration.)  */
3918       if (t && TREE_CODE (t) == OVERLOAD)
3919         {
3920           tree match;
3921
3922           if (TREE_CODE (x) == FUNCTION_DECL)
3923             for (match = t; match; match = OVL_NEXT (match))
3924               {
3925                 if (decls_match (OVL_CURRENT (match), x))
3926                   break;
3927               }
3928           else
3929             /* Just choose one.  */
3930             match = t;
3931
3932           if (match)
3933             t = OVL_CURRENT (match);
3934           else
3935             t = NULL_TREE;
3936         }
3937
3938       if (t == error_mark_node)
3939         {
3940           /* error_mark_node is 0 for a while during initialization!  */
3941           t = NULL_TREE;
3942           cp_error_at ("`%#D' used prior to declaration", x);
3943         }
3944       else if (t != NULL_TREE)
3945         {
3946           if (different_binding_level)
3947             {
3948               if (decls_match (x, t))
3949                 /* The standard only says that the local extern
3950                    inherits linkage from the previous decl; in
3951                    particular, default args are not shared.  It would
3952                    be nice to propagate inlining info, though.  FIXME.  */
3953                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3954             }
3955           else if (TREE_CODE (t) == PARM_DECL)
3956             {
3957               if (DECL_CONTEXT (t) == NULL_TREE)
3958                 /* This is probaby caused by too many errors, but calling
3959                    abort will say that if errors have occurred.  */
3960                 abort ();
3961
3962               /* Check for duplicate params.  */
3963               if (duplicate_decls (x, t))
3964                 return t;
3965             }
3966           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3967                     || DECL_FUNCTION_TEMPLATE_P (x))
3968                    && is_overloaded_fn (t))
3969             /* Don't do anything just yet. */;
3970           else if (t == wchar_decl_node)
3971             {
3972               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3973                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3974                             TREE_TYPE (x));
3975
3976               /* Throw away the redeclaration.  */
3977               return t;
3978             }
3979           else if (TREE_CODE (t) != TREE_CODE (x))
3980             {
3981               if (duplicate_decls (x, t))
3982                 return t;
3983             }
3984           else if (duplicate_decls (x, t))
3985             {
3986               if (TREE_CODE (t) == TYPE_DECL)
3987                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3988               else if (TREE_CODE (t) == FUNCTION_DECL)
3989                 check_default_args (t);
3990
3991               return t;
3992             }
3993           else if (DECL_MAIN_P (x))
3994             {
3995               /* A redeclaration of main, but not a duplicate of the
3996                  previous one.
3997
3998                  [basic.start.main]
3999
4000                  This function shall not be overloaded.  */
4001               cp_error_at ("invalid redeclaration of `%D'", t);
4002               error ("as `%D'", x);
4003               /* We don't try to push this declaration since that
4004                  causes a crash.  */
4005               return x;
4006             }
4007         }
4008
4009       check_template_shadow (x);
4010
4011       /* If this is a function conjured up by the backend, massage it
4012          so it looks friendly.  */
4013       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
4014         {
4015           retrofit_lang_decl (x);
4016           SET_DECL_LANGUAGE (x, lang_c);
4017         }
4018
4019       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4020         {
4021           t = push_overloaded_decl (x, PUSH_LOCAL);
4022           if (t != x)
4023             return t;
4024           if (!namespace_bindings_p ())
4025             /* We do not need to create a binding for this name;
4026                push_overloaded_decl will have already done so if
4027                necessary.  */
4028             need_new_binding = 0;
4029         }
4030       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4031         {
4032           t = push_overloaded_decl (x, PUSH_GLOBAL);
4033           if (t == x)
4034             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4035           return t;
4036         }
4037
4038       /* If declaring a type as a typedef, copy the type (unless we're
4039          at line 0), and install this TYPE_DECL as the new type's typedef
4040          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4041       if (TREE_CODE (x) == TYPE_DECL)
4042         {
4043           tree type = TREE_TYPE (x);
4044           if (DECL_SOURCE_LINE (x) == 0)
4045             {
4046               if (TYPE_NAME (type) == 0)
4047                 TYPE_NAME (type) = x;
4048             }
4049           else if (type != error_mark_node && TYPE_NAME (type) != x
4050                    /* We don't want to copy the type when all we're
4051                       doing is making a TYPE_DECL for the purposes of
4052                       inlining.  */
4053                    && (!TYPE_NAME (type)
4054                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4055             {
4056               DECL_ORIGINAL_TYPE (x) = type;
4057               type = build_type_copy (type);
4058               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4059               TYPE_NAME (type) = x;
4060               TREE_TYPE (x) = type;
4061             }
4062
4063           if (type != error_mark_node
4064               && TYPE_NAME (type)
4065               && TYPE_IDENTIFIER (type))
4066             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4067                                                   current_binding_level);
4068
4069         }
4070
4071       /* Multiple external decls of the same identifier ought to match.
4072
4073          We get warnings about inline functions where they are defined.
4074          We get warnings about other functions from push_overloaded_decl.
4075
4076          Avoid duplicate warnings where they are used.  */
4077       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4078         {
4079           tree decl;
4080
4081           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4082           if (decl && TREE_CODE (decl) == OVERLOAD)
4083             decl = OVL_FUNCTION (decl);
4084
4085           if (decl && decl != error_mark_node
4086               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4087               /* If different sort of thing, we already gave an error.  */
4088               && TREE_CODE (decl) == TREE_CODE (x)
4089               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4090             {
4091               pedwarn ("type mismatch with previous external decl", x);
4092               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4093             }
4094         }
4095
4096       /* This name is new in its binding level.
4097          Install the new declaration and return it.  */
4098       if (namespace_bindings_p ())
4099         {
4100           /* Install a global value.  */
4101
4102           /* If the first global decl has external linkage,
4103              warn if we later see static one.  */
4104           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4105             TREE_PUBLIC (name) = 1;
4106
4107           /* Bind the name for the entity.  */
4108           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4109                 && t != NULL_TREE)
4110               && (TREE_CODE (x) == TYPE_DECL
4111                   || TREE_CODE (x) == VAR_DECL
4112                   || TREE_CODE (x) == NAMESPACE_DECL
4113                   || TREE_CODE (x) == CONST_DECL
4114                   || TREE_CODE (x) == TEMPLATE_DECL))
4115             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4116
4117           /* Don't forget if the function was used via an implicit decl.  */
4118           if (IDENTIFIER_IMPLICIT_DECL (name)
4119               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4120             TREE_USED (x) = 1;
4121
4122           /* Don't forget if its address was taken in that way.  */
4123           if (IDENTIFIER_IMPLICIT_DECL (name)
4124               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4125             TREE_ADDRESSABLE (x) = 1;
4126
4127           /* Warn about mismatches against previous implicit decl.  */
4128           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4129               /* If this real decl matches the implicit, don't complain.  */
4130               && ! (TREE_CODE (x) == FUNCTION_DECL
4131                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4132             warning
4133               ("`%D' was previously implicitly declared to return `int'", x);
4134
4135           /* If new decl is `static' and an `extern' was seen previously,
4136              warn about it.  */
4137           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4138             warn_extern_redeclared_static (x, t);
4139         }
4140       else
4141         {
4142           /* Here to install a non-global value.  */
4143           tree oldlocal = IDENTIFIER_VALUE (name);
4144           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4145
4146           if (need_new_binding)
4147             {
4148               push_local_binding (name, x, 0);
4149               /* Because push_local_binding will hook X on to the
4150                  current_binding_level's name list, we don't want to
4151                  do that again below.  */
4152               need_new_binding = 0;
4153             }
4154
4155           /* If this is a TYPE_DECL, push it into the type value slot.  */
4156           if (TREE_CODE (x) == TYPE_DECL)
4157             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4158                                                   current_binding_level);
4159
4160           /* Clear out any TYPE_DECL shadowed by a namespace so that
4161              we won't think this is a type.  The C struct hack doesn't
4162              go through namespaces.  */
4163           if (TREE_CODE (x) == NAMESPACE_DECL)
4164             set_identifier_type_value_with_scope (name, NULL_TREE,
4165                                                   current_binding_level);
4166
4167           if (oldlocal)
4168             {
4169               tree d = oldlocal;
4170
4171               while (oldlocal
4172                      && TREE_CODE (oldlocal) == VAR_DECL
4173                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4174                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4175
4176               if (oldlocal == NULL_TREE)
4177                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4178             }
4179
4180           /* If this is an extern function declaration, see if we
4181              have a global definition or declaration for the function.  */
4182           if (oldlocal == NULL_TREE
4183               && DECL_EXTERNAL (x)
4184               && oldglobal != NULL_TREE
4185               && TREE_CODE (x) == FUNCTION_DECL
4186               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4187             {
4188               /* We have one.  Their types must agree.  */
4189               if (decls_match (x, oldglobal))
4190                 /* OK */;
4191               else
4192                 {
4193                   warning ("extern declaration of `%#D' doesn't match", x);
4194                   cp_warning_at ("global declaration `%#D'", oldglobal);
4195                 }
4196             }
4197           /* If we have a local external declaration,
4198              and no file-scope declaration has yet been seen,
4199              then if we later have a file-scope decl it must not be static.  */
4200           if (oldlocal == NULL_TREE
4201               && oldglobal == NULL_TREE
4202               && DECL_EXTERNAL (x)
4203               && TREE_PUBLIC (x))
4204             TREE_PUBLIC (name) = 1;
4205
4206           /* Warn if shadowing an argument at the top level of the body.  */
4207           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4208               /* Inline decls shadow nothing.  */
4209               && !DECL_FROM_INLINE (x)
4210               && TREE_CODE (oldlocal) == PARM_DECL)
4211             {
4212               bool err = false;
4213
4214               /* Don't complain if it's from an enclosing function.  */
4215               if (DECL_CONTEXT (oldlocal) == current_function_decl
4216                   && TREE_CODE (x) != PARM_DECL)
4217                 {
4218                   /* Go to where the parms should be and see if we find
4219                      them there.  */
4220                   struct binding_level *b = current_binding_level->level_chain;
4221
4222                   /* ARM $8.3 */
4223                   if (b->parm_flag == 1)
4224                     {
4225                       error ("declaration of `%#D' shadows a parameter",
4226                                 name);
4227                       err = true;
4228                     }
4229                 }
4230
4231               if (warn_shadow && !err)
4232                 shadow_warning ("a parameter", name, oldlocal);
4233             }
4234
4235           /* Maybe warn if shadowing something else.  */
4236           else if (warn_shadow && !DECL_EXTERNAL (x)
4237               /* No shadow warnings for internally generated vars.  */
4238               && ! DECL_ARTIFICIAL (x)
4239               /* No shadow warnings for vars made for inlining.  */
4240               && ! DECL_FROM_INLINE (x))
4241             {
4242               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4243                        && current_class_ptr
4244                        && !TREE_STATIC (name))
4245                 warning ("declaration of `%s' shadows a member of `this'",
4246                             IDENTIFIER_POINTER (name));
4247               else if (oldlocal != NULL_TREE
4248                        && TREE_CODE (oldlocal) == VAR_DECL)
4249                 shadow_warning ("a previous local", name, oldlocal);
4250               else if (oldglobal != NULL_TREE
4251                        && TREE_CODE (oldglobal) == VAR_DECL)
4252                 /* XXX shadow warnings in outer-more namespaces */
4253                 shadow_warning ("a global declaration", name, oldglobal);
4254             }
4255         }
4256
4257       if (TREE_CODE (x) == FUNCTION_DECL)
4258         check_default_args (x);
4259
4260       if (TREE_CODE (x) == VAR_DECL)
4261         maybe_register_incomplete_var (x);
4262     }
4263
4264   if (need_new_binding)
4265     add_decl_to_level (x,
4266                        DECL_NAMESPACE_SCOPE_P (x)
4267                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4268                        : current_binding_level);
4269
4270   return x;
4271 }
4272
4273 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4274    caller to set DECL_CONTEXT properly.  */
4275
4276 static tree
4277 pushdecl_with_scope (x, level)
4278      tree x;
4279      struct binding_level *level;
4280 {
4281   register struct binding_level *b;
4282   tree function_decl = current_function_decl;
4283
4284   current_function_decl = NULL_TREE;
4285   if (level->parm_flag == 2)
4286     {
4287       b = class_binding_level;
4288       class_binding_level = level;
4289       pushdecl_class_level (x);
4290       class_binding_level = b;
4291     }
4292   else
4293     {
4294       b = current_binding_level;
4295       current_binding_level = level;
4296       x = pushdecl (x);
4297       current_binding_level = b;
4298     }
4299   current_function_decl = function_decl;
4300   return x;
4301 }
4302
4303 /* Like pushdecl, only it places X in the current namespace,
4304    if appropriate.  */
4305
4306 tree
4307 pushdecl_namespace_level (x)
4308      tree x;
4309 {
4310   register struct binding_level *b = current_binding_level;
4311   register tree t;
4312
4313   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4314
4315   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4316      what we want.  */
4317   if (TREE_CODE (x) == TYPE_DECL)
4318     {
4319       tree name = DECL_NAME (x);
4320       tree newval;
4321       tree *ptr = (tree *)0;
4322       for (; b != global_binding_level; b = b->level_chain)
4323         {
4324           tree shadowed = b->type_shadowed;
4325           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4326             if (TREE_PURPOSE (shadowed) == name)
4327               {
4328                 ptr = &TREE_VALUE (shadowed);
4329                 /* Can't break out of the loop here because sometimes
4330                    a binding level will have duplicate bindings for
4331                    PT names.  It's gross, but I haven't time to fix it.  */
4332               }
4333         }
4334       newval = TREE_TYPE (x);
4335       if (ptr == (tree *)0)
4336         {
4337           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4338              up here if this is changed to an assertion.  --KR  */
4339           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4340         }
4341       else
4342         {
4343           *ptr = newval;
4344         }
4345     }
4346   return t;
4347 }
4348
4349 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4350    if appropriate.  */
4351
4352 tree
4353 pushdecl_top_level (x)
4354      tree x;
4355 {
4356   push_to_top_level ();
4357   x = pushdecl_namespace_level (x);
4358   pop_from_top_level ();
4359   return x;
4360 }
4361
4362 /* Make the declaration of X appear in CLASS scope.  */
4363
4364 void
4365 pushdecl_class_level (x)
4366      tree x;
4367 {
4368   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4369      scope looks for the pre-mangled name.  */
4370   register tree name;
4371
4372   if (TREE_CODE (x) == OVERLOAD)
4373     x = OVL_CURRENT (x);
4374   name = DECL_NAME (x);
4375
4376   if (name)
4377     {
4378       push_class_level_binding (name, x);
4379       if (TREE_CODE (x) == TYPE_DECL)
4380         set_identifier_type_value (name, TREE_TYPE (x));
4381     }
4382   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4383     {
4384       tree f;
4385
4386       for (f = TYPE_FIELDS (TREE_TYPE (x));
4387            f;
4388            f = TREE_CHAIN (f))
4389         pushdecl_class_level (f);
4390     }
4391 }
4392
4393 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4394    DECL, or a modified version thereof.  */
4395
4396 tree
4397 maybe_push_decl (decl)
4398      tree decl;
4399 {
4400   tree type = TREE_TYPE (decl);
4401
4402   /* Add this decl to the current binding level, but not if it comes
4403      from another scope, e.g. a static member variable.  TEM may equal
4404      DECL or it may be a previous decl of the same name.  */
4405   if (decl == error_mark_node
4406       || (TREE_CODE (decl) != PARM_DECL
4407           && DECL_CONTEXT (decl) != NULL_TREE
4408           /* Definitions of namespace members outside their namespace are
4409              possible. */
4410           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4411       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4412       || TREE_CODE (type) == UNKNOWN_TYPE
4413       /* The declaration of a template specialization does not affect
4414          the functions available for overload resolution, so we do not
4415          call pushdecl.  */
4416       || (TREE_CODE (decl) == FUNCTION_DECL
4417           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4418     return decl;
4419   else
4420     return pushdecl (decl);
4421 }
4422
4423 /* Make the declaration(s) of X appear in CLASS scope
4424    under the name NAME.  */
4425
4426 void
4427 push_class_level_binding (name, x)
4428      tree name;
4429      tree x;
4430 {
4431   tree binding;
4432   /* The class_binding_level will be NULL if x is a template
4433      parameter name in a member template.  */
4434   if (!class_binding_level)
4435     return;
4436
4437   /* Make sure that this new member does not have the same name
4438      as a template parameter.  */
4439   if (TYPE_BEING_DEFINED (current_class_type))
4440     check_template_shadow (x);
4441
4442   /* If this declaration shadows a declaration from an enclosing
4443      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4444      we leave this class.  Record the shadowed declaration here.  */
4445   binding = IDENTIFIER_BINDING (name);
4446   if (binding
4447       && ((TREE_CODE (x) == OVERLOAD
4448            && BINDING_VALUE (binding)
4449            && is_overloaded_fn (BINDING_VALUE (binding)))
4450           || INHERITED_VALUE_BINDING_P (binding)))
4451     {
4452       tree shadow;
4453       tree old_decl;
4454
4455       /* If the old binding was from a base class, and was for a tag
4456          name, slide it over to make room for the new binding.  The
4457          old binding is still visible if explicitly qualified with a
4458          class-key.  */
4459       if (INHERITED_VALUE_BINDING_P (binding)
4460           && BINDING_VALUE (binding)
4461           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4462           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4463           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4464         {
4465           old_decl = BINDING_TYPE (binding);
4466           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4467           BINDING_VALUE (binding) = NULL_TREE;
4468           INHERITED_VALUE_BINDING_P (binding) = 0;
4469         }
4470       else
4471         old_decl = BINDING_VALUE (binding);
4472
4473       /* Find the previous binding of name on the class-shadowed
4474          list, and update it.  */
4475       for (shadow = class_binding_level->class_shadowed;
4476            shadow;
4477            shadow = TREE_CHAIN (shadow))
4478         if (TREE_PURPOSE (shadow) == name
4479             && TREE_TYPE (shadow) == old_decl)
4480           {
4481             BINDING_VALUE (binding) = x;
4482             INHERITED_VALUE_BINDING_P (binding) = 0;
4483             TREE_TYPE (shadow) = x;
4484             IDENTIFIER_CLASS_VALUE (name) = x;
4485             return;
4486           }
4487     }
4488
4489   /* If we didn't replace an existing binding, put the binding on the
4490      stack of bindings for the identifier, and update the shadowed list.  */
4491   if (push_class_binding (name, x))
4492     {
4493       class_binding_level->class_shadowed
4494         = tree_cons (name, NULL,
4495                      class_binding_level->class_shadowed);
4496       /* Record the value we are binding NAME to so that we can know
4497          what to pop later.  */
4498       TREE_TYPE (class_binding_level->class_shadowed) = x;
4499     }
4500 }
4501
4502 /* Insert another USING_DECL into the current binding level, returning
4503    this declaration. If this is a redeclaration, do nothing, and
4504    return NULL_TREE if this not in namespace scope (in namespace
4505    scope, a using decl might extend any previous bindings).  */
4506
4507 tree
4508 push_using_decl (scope, name)
4509      tree scope;
4510      tree name;
4511 {
4512   tree decl;
4513
4514   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4515   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4516   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4517     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4518       break;
4519   if (decl)
4520     return namespace_bindings_p () ? decl : NULL_TREE;
4521   decl = build_lang_decl (USING_DECL, name, void_type_node);
4522   DECL_INITIAL (decl) = scope;
4523   TREE_CHAIN (decl) = current_binding_level->usings;
4524   current_binding_level->usings = decl;
4525   return decl;
4526 }
4527
4528 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4529    changed (i.e. there was already a directive), or the fresh
4530    TREE_LIST otherwise.  */
4531
4532 tree
4533 push_using_directive (used)
4534      tree used;
4535 {
4536   tree ud = current_binding_level->using_directives;
4537   tree iter, ancestor;
4538
4539   /* Check if we already have this. */
4540   if (purpose_member (used, ud) != NULL_TREE)
4541     return NULL_TREE;
4542
4543   /* Recursively add all namespaces used. */
4544   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4545     push_using_directive (TREE_PURPOSE (iter));
4546
4547   ancestor = namespace_ancestor (current_decl_namespace (), used);
4548   ud = current_binding_level->using_directives;
4549   ud = tree_cons (used, ancestor, ud);
4550   current_binding_level->using_directives = ud;
4551   return ud;
4552 }
4553
4554 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4555    other definitions already in place.  We get around this by making
4556    the value of the identifier point to a list of all the things that
4557    want to be referenced by that name.  It is then up to the users of
4558    that name to decide what to do with that list.
4559
4560    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4561    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4562
4563    FLAGS is a bitwise-or of the following values:
4564      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4565                  namespace scope.
4566      PUSH_USING: DECL is being pushed as the result of a using
4567                  declaration.
4568
4569    The value returned may be a previous declaration if we guessed wrong
4570    about what language DECL should belong to (C or C++).  Otherwise,
4571    it's always DECL (and never something that's not a _DECL).  */
4572
4573 tree
4574 push_overloaded_decl (decl, flags)
4575      tree decl;
4576      int flags;
4577 {
4578   tree name = DECL_NAME (decl);
4579   tree old;
4580   tree new_binding;
4581   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4582
4583   if (doing_global)
4584     old = namespace_binding (name, DECL_CONTEXT (decl));
4585   else
4586     old = lookup_name_current_level (name);
4587
4588   if (old)
4589     {
4590       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4591         {
4592           tree t = TREE_TYPE (old);
4593           if (IS_AGGR_TYPE (t) && warn_shadow
4594               && (! DECL_IN_SYSTEM_HEADER (decl)
4595                   || ! DECL_IN_SYSTEM_HEADER (old)))
4596             warning ("`%#D' hides constructor for `%#T'", decl, t);
4597           old = NULL_TREE;
4598         }
4599       else if (is_overloaded_fn (old))
4600         {
4601           tree tmp;
4602
4603           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4604             {
4605               tree fn = OVL_CURRENT (tmp);
4606
4607               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4608                   && !(flags & PUSH_USING)
4609                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4610                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4611                 error ("`%#D' conflicts with previous using declaration `%#D'",
4612                           decl, fn);
4613
4614               if (duplicate_decls (decl, fn))
4615                 return fn;
4616             }
4617         }
4618       else if (old == error_mark_node)
4619         /* Ignore the undefined symbol marker.  */
4620         old = NULL_TREE;
4621       else
4622         {
4623           cp_error_at ("previous non-function declaration `%#D'", old);
4624           error ("conflicts with function declaration `%#D'", decl);
4625           return decl;
4626         }
4627     }
4628
4629   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4630     {
4631       if (old && TREE_CODE (old) != OVERLOAD)
4632         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4633       else
4634         new_binding = ovl_cons (decl, old);
4635       if (flags & PUSH_USING)
4636         OVL_USED (new_binding) = 1;
4637     }
4638   else
4639     /* NAME is not ambiguous.  */
4640     new_binding = decl;
4641
4642   if (doing_global)
4643     set_namespace_binding (name, current_namespace, new_binding);
4644   else
4645     {
4646       /* We only create an OVERLOAD if there was a previous binding at
4647          this level, or if decl is a template. In the former case, we
4648          need to remove the old binding and replace it with the new
4649          binding.  We must also run through the NAMES on the binding
4650          level where the name was bound to update the chain.  */
4651
4652       if (TREE_CODE (new_binding) == OVERLOAD && old)
4653         {
4654           tree *d;
4655
4656           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4657                *d;
4658                d = &TREE_CHAIN (*d))
4659             if (*d == old
4660                 || (TREE_CODE (*d) == TREE_LIST
4661                     && TREE_VALUE (*d) == old))
4662               {
4663                 if (TREE_CODE (*d) == TREE_LIST)
4664                   /* Just replace the old binding with the new.  */
4665                   TREE_VALUE (*d) = new_binding;
4666                 else
4667                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4668                   *d = tree_cons (NULL_TREE, new_binding,
4669                                   TREE_CHAIN (*d));
4670
4671                 /* And update the CPLUS_BINDING node.  */
4672                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4673                   = new_binding;
4674                 return decl;
4675               }
4676
4677           /* We should always find a previous binding in this case.  */
4678           abort ();
4679         }
4680
4681       /* Install the new binding.  */
4682       push_local_binding (name, new_binding, flags);
4683     }
4684
4685   return decl;
4686 }
4687 \f
4688 /* Generate an implicit declaration for identifier FUNCTIONID
4689    as a function of type int ().  Print a warning if appropriate.  */
4690
4691 tree
4692 implicitly_declare (functionid)
4693      tree functionid;
4694 {
4695   register tree decl;
4696
4697   /* We used to reuse an old implicit decl here,
4698      but this loses with inline functions because it can clobber
4699      the saved decl chains.  */
4700   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4701
4702   DECL_EXTERNAL (decl) = 1;
4703   TREE_PUBLIC (decl) = 1;
4704
4705   /* ISO standard says implicit declarations are in the innermost block.
4706      So we record the decl in the standard fashion.  */
4707   pushdecl (decl);
4708   rest_of_decl_compilation (decl, NULL, 0, 0);
4709
4710   if (warn_implicit
4711       /* Only one warning per identifier.  */
4712       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4713     {
4714       pedwarn ("implicit declaration of function `%#D'", decl);
4715     }
4716
4717   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4718
4719   return decl;
4720 }
4721
4722 /* Return zero if the declaration NEWDECL is valid
4723    when the declaration OLDDECL (assumed to be for the same name)
4724    has already been seen.
4725    Otherwise return an error message format string with a %s
4726    where the identifier should go.  */
4727
4728 static const char *
4729 redeclaration_error_message (newdecl, olddecl)
4730      tree newdecl, olddecl;
4731 {
4732   if (TREE_CODE (newdecl) == TYPE_DECL)
4733     {
4734       /* Because C++ can put things into name space for free,
4735          constructs like "typedef struct foo { ... } foo"
4736          would look like an erroneous redeclaration.  */
4737       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4738         return 0;
4739       else
4740         return "redefinition of `%#D'";
4741     }
4742   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4743     {
4744       /* If this is a pure function, its olddecl will actually be
4745          the original initialization to `0' (which we force to call
4746          abort()).  Don't complain about redefinition in this case.  */
4747       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4748         return 0;
4749
4750       /* If both functions come from different namespaces, this is not
4751          a redeclaration - this is a conflict with a used function. */
4752       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4753           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4754         return "`%D' conflicts with used function";
4755
4756       /* We'll complain about linkage mismatches in
4757          warn_extern_redeclared_static.  */
4758
4759       /* Defining the same name twice is no good.  */
4760       if (DECL_INITIAL (olddecl) != NULL_TREE
4761           && DECL_INITIAL (newdecl) != NULL_TREE)
4762         {
4763           if (DECL_NAME (olddecl) == NULL_TREE)
4764             return "`%#D' not declared in class";
4765           else
4766             return "redefinition of `%#D'";
4767         }
4768       return 0;
4769     }
4770   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4771     {
4772       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4773            && (DECL_TEMPLATE_RESULT (newdecl)
4774                != DECL_TEMPLATE_RESULT (olddecl))
4775            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4776            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4777           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4778               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4779               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4780         return "redefinition of `%#D'";
4781       return 0;
4782     }
4783   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4784     {
4785       /* Objects declared at top level:  */
4786       /* If at least one is a reference, it's ok.  */
4787       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4788         return 0;
4789       /* Reject two definitions.  */
4790       return "redefinition of `%#D'";
4791     }
4792   else
4793     {
4794       /* Objects declared with block scope:  */
4795       /* Reject two definitions, and reject a definition
4796          together with an external reference.  */
4797       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4798         return "redeclaration of `%#D'";
4799       return 0;
4800     }
4801 }
4802 \f
4803 /* Create a new label, named ID.  */
4804
4805 static tree
4806 make_label_decl (id, local_p)
4807      tree id;
4808      int local_p;
4809 {
4810   tree decl;
4811
4812   decl = build_decl (LABEL_DECL, id, void_type_node);
4813   if (expanding_p)
4814     /* Make sure every label has an rtx.  */
4815     label_rtx (decl);
4816
4817   DECL_CONTEXT (decl) = current_function_decl;
4818   DECL_MODE (decl) = VOIDmode;
4819   C_DECLARED_LABEL_FLAG (decl) = local_p;
4820
4821   /* Say where one reference is to the label, for the sake of the
4822      error if it is not defined.  */
4823   DECL_SOURCE_LINE (decl) = lineno;
4824   DECL_SOURCE_FILE (decl) = input_filename;
4825
4826   /* Record the fact that this identifier is bound to this label.  */
4827   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4828
4829   return decl;
4830 }
4831
4832 /* Record this label on the list of used labels so that we can check
4833    at the end of the function to see whether or not the label was
4834    actually defined, and so we can check when the label is defined whether
4835    this use is valid.  */
4836
4837 static void
4838 use_label (decl)
4839      tree decl;
4840 {
4841   if (named_label_uses == NULL
4842       || named_label_uses->names_in_scope != current_binding_level->names
4843       || named_label_uses->label_decl != decl)
4844     {
4845       struct named_label_use_list *new_ent;
4846       new_ent = ((struct named_label_use_list *)
4847                  ggc_alloc (sizeof (struct named_label_use_list)));
4848       new_ent->label_decl = decl;
4849       new_ent->names_in_scope = current_binding_level->names;
4850       new_ent->binding_level = current_binding_level;
4851       new_ent->lineno_o_goto = lineno;
4852       new_ent->filename_o_goto = input_filename;
4853       new_ent->next = named_label_uses;
4854       named_label_uses = new_ent;
4855     }
4856 }
4857
4858 /* Look for a label named ID in the current function.  If one cannot
4859    be found, create one.  (We keep track of used, but undefined,
4860    labels, and complain about them at the end of a function.)  */
4861
4862 tree
4863 lookup_label (id)
4864      tree id;
4865 {
4866   tree decl;
4867   struct named_label_list *ent;
4868
4869   /* You can't use labels at global scope.  */
4870   if (current_function_decl == NULL_TREE)
4871     {
4872       error ("label `%s' referenced outside of any function",
4873              IDENTIFIER_POINTER (id));
4874       return NULL_TREE;
4875     }
4876
4877   /* See if we've already got this label.  */
4878   decl = IDENTIFIER_LABEL_VALUE (id);
4879   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4880     return decl;
4881
4882   /* Record this label on the list of labels used in this function.
4883      We do this before calling make_label_decl so that we get the
4884      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4885   ent = ((struct named_label_list *)
4886          ggc_alloc_cleared (sizeof (struct named_label_list)));
4887   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4888   ent->next = named_labels;
4889   named_labels = ent;
4890
4891   /* We need a new label.  */
4892   decl = make_label_decl (id, /*local_p=*/0);
4893
4894   /* Now fill in the information we didn't have before.  */
4895   ent->label_decl = decl;
4896
4897   return decl;
4898 }
4899
4900 /* Declare a local label named ID.  */
4901
4902 tree
4903 declare_local_label (id)
4904      tree id;
4905 {
4906   tree decl;
4907
4908   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4909      this scope we can restore the old value of
4910      IDENTIFIER_TYPE_VALUE.  */
4911   current_binding_level->shadowed_labels
4912     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4913                  current_binding_level->shadowed_labels);
4914   /* Look for the label.  */
4915   decl = make_label_decl (id, /*local_p=*/1);
4916   /* Now fill in the information we didn't have before.  */
4917   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4918
4919   return decl;
4920 }
4921
4922 /* Returns nonzero if it is ill-formed to jump past the declaration of
4923    DECL.  Returns 2 if it's also a real problem.  */
4924
4925 static int
4926 decl_jump_unsafe (decl)
4927      tree decl;
4928 {
4929   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4930     return 0;
4931
4932   if (DECL_INITIAL (decl) == NULL_TREE
4933       && pod_type_p (TREE_TYPE (decl)))
4934     return 0;
4935
4936   /* This is really only important if we're crossing an initialization.
4937      The POD stuff is just pedantry; why should it matter if the class
4938      contains a field of pointer to member type?  */
4939   if (DECL_INITIAL (decl)
4940       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4941     return 2;
4942   return 1;
4943 }
4944
4945 /* Check that a single previously seen jump to a newly defined label
4946    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4947    the jump context; NAMES are the names in scope in LEVEL at the jump
4948    context; FILE and LINE are the source position of the jump or 0.  */
4949
4950 static void
4951 check_previous_goto_1 (decl, level, names, file, line)
4952      tree decl;
4953      struct binding_level *level;
4954      tree names;
4955      const char *file;
4956      int line;
4957 {
4958   int identified = 0;
4959   int saw_eh = 0;
4960   struct binding_level *b = current_binding_level;
4961   for (; b; b = b->level_chain)
4962     {
4963       tree new_decls = b->names;
4964       tree old_decls = (b == level ? names : NULL_TREE);
4965       for (; new_decls != old_decls;
4966            new_decls = TREE_CHAIN (new_decls))
4967         {
4968           int problem = decl_jump_unsafe (new_decls);
4969           if (! problem)
4970             continue;
4971
4972           if (! identified)
4973             {
4974               if (decl)
4975                 pedwarn ("jump to label `%D'", decl);
4976               else
4977                 pedwarn ("jump to case label");
4978
4979               if (file)
4980                 pedwarn_with_file_and_line (file, line, "  from here");
4981               identified = 1;
4982             }
4983
4984           if (problem > 1)
4985             cp_error_at ("  crosses initialization of `%#D'",
4986                          new_decls);
4987           else
4988             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4989                            new_decls);
4990         }
4991
4992       if (b == level)
4993         break;
4994       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4995         {
4996           if (! identified)
4997             {
4998               if (decl)
4999                 pedwarn ("jump to label `%D'", decl);
5000               else
5001                 pedwarn ("jump to case label");
5002
5003               if (file)
5004                 pedwarn_with_file_and_line (file, line, "  from here");
5005               identified = 1;
5006             }
5007           if (b->is_try_scope)
5008             error ("  enters try block");
5009           else
5010             error ("  enters catch block");
5011           saw_eh = 1;
5012         }
5013     }
5014 }
5015
5016 static void
5017 check_previous_goto (use)
5018      struct named_label_use_list *use;
5019 {
5020   check_previous_goto_1 (use->label_decl, use->binding_level,
5021                          use->names_in_scope, use->filename_o_goto,
5022                          use->lineno_o_goto);
5023 }
5024
5025 static void
5026 check_switch_goto (level)
5027      struct binding_level *level;
5028 {
5029   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5030 }
5031
5032 /* Check that any previously seen jumps to a newly defined label DECL
5033    are OK.  Called by define_label.  */
5034
5035 static void
5036 check_previous_gotos (decl)
5037      tree decl;
5038 {
5039   struct named_label_use_list **usep;
5040
5041   if (! TREE_USED (decl))
5042     return;
5043
5044   for (usep = &named_label_uses; *usep; )
5045     {
5046       struct named_label_use_list *use = *usep;
5047       if (use->label_decl == decl)
5048         {
5049           check_previous_goto (use);
5050           *usep = use->next;
5051         }
5052       else
5053         usep = &(use->next);
5054     }
5055 }
5056
5057 /* Check that a new jump to a label DECL is OK.  Called by
5058    finish_goto_stmt.  */
5059
5060 void
5061 check_goto (decl)
5062      tree decl;
5063 {
5064   int identified = 0;
5065   tree bad;
5066   struct named_label_list *lab;
5067
5068   /* We can't know where a computed goto is jumping.  So we assume
5069      that it's OK.  */
5070   if (! DECL_P (decl))
5071     return;
5072
5073   /* If the label hasn't been defined yet, defer checking.  */
5074   if (! DECL_INITIAL (decl))
5075     {
5076       use_label (decl);
5077       return;
5078     }
5079
5080   for (lab = named_labels; lab; lab = lab->next)
5081     if (decl == lab->label_decl)
5082       break;
5083
5084   /* If the label is not on named_labels it's a gcc local label, so
5085      it must be in an outer scope, so jumping to it is always OK.  */
5086   if (lab == 0)
5087     return;
5088
5089   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5090       && !identified)
5091     {
5092       cp_pedwarn_at ("jump to label `%D'", decl);
5093       pedwarn ("  from here");
5094       identified = 1;
5095     }
5096
5097   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5098     {
5099       tree b = TREE_VALUE (bad);
5100       int u = decl_jump_unsafe (b);
5101
5102       if (u > 1 && DECL_ARTIFICIAL (b))
5103         /* Can't skip init of __exception_info.  */
5104         cp_error_at ("  enters catch block", b);
5105       else if (u > 1)
5106         cp_error_at ("  skips initialization of `%#D'", b);
5107       else
5108         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5109     }
5110
5111   if (lab->in_try_scope)
5112     error ("  enters try block");
5113   else if (lab->in_catch_scope)
5114     error ("  enters catch block");
5115 }
5116
5117 /* Define a label, specifying the location in the source file.
5118    Return the LABEL_DECL node for the label, if the definition is valid.
5119    Otherwise return 0.  */
5120
5121 tree
5122 define_label (filename, line, name)
5123      const char *filename;
5124      int line;
5125      tree name;
5126 {
5127   tree decl = lookup_label (name);
5128   struct named_label_list *ent;
5129   register struct binding_level *p;
5130
5131   for (ent = named_labels; ent; ent = ent->next)
5132     if (ent->label_decl == decl)
5133       break;
5134
5135   /* After labels, make any new cleanups in the function go into their
5136      own new (temporary) binding contour.  */
5137   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5138     p->more_cleanups_ok = 0;
5139
5140   if (name == get_identifier ("wchar_t"))
5141     pedwarn ("label named wchar_t");
5142
5143   if (DECL_INITIAL (decl) != NULL_TREE)
5144     {
5145       error ("duplicate label `%D'", decl);
5146       return 0;
5147     }
5148   else
5149     {
5150       /* Mark label as having been defined.  */
5151       DECL_INITIAL (decl) = error_mark_node;
5152       /* Say where in the source.  */
5153       DECL_SOURCE_FILE (decl) = filename;
5154       DECL_SOURCE_LINE (decl) = line;
5155       if (ent)
5156         {
5157           ent->names_in_scope = current_binding_level->names;
5158           ent->binding_level = current_binding_level;
5159         }
5160       check_previous_gotos (decl);
5161       return decl;
5162     }
5163 }
5164
5165 struct cp_switch
5166 {
5167   struct binding_level *level;
5168   struct cp_switch *next;
5169   /* The SWITCH_STMT being built.  */
5170   tree switch_stmt;
5171   /* A splay-tree mapping the low element of a case range to the high
5172      element, or NULL_TREE if there is no high element.  Used to
5173      determine whether or not a new case label duplicates an old case
5174      label.  We need a tree, rather than simply a hash table, because
5175      of the GNU case range extension.  */
5176   splay_tree cases;
5177 };
5178
5179 /* A stack of the currently active switch statements.  The innermost
5180    switch statement is on the top of the stack.  There is no need to
5181    mark the stack for garbage collection because it is only active
5182    during the processing of the body of a function, and we never
5183    collect at that point.  */
5184
5185 static struct cp_switch *switch_stack;
5186
5187 /* Called right after a switch-statement condition is parsed.
5188    SWITCH_STMT is the switch statement being parsed.  */
5189
5190 void
5191 push_switch (switch_stmt)
5192      tree switch_stmt;
5193 {
5194   struct cp_switch *p
5195     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5196   p->level = current_binding_level;
5197   p->next = switch_stack;
5198   p->switch_stmt = switch_stmt;
5199   p->cases = splay_tree_new (case_compare, NULL, NULL);
5200   switch_stack = p;
5201 }
5202
5203 void
5204 pop_switch ()
5205 {
5206   struct cp_switch *cs;
5207
5208   cs = switch_stack;
5209   splay_tree_delete (cs->cases);
5210   switch_stack = switch_stack->next;
5211   free (cs);
5212 }
5213
5214 /* Note that we've seen a definition of a case label, and complain if this
5215    is a bad place for one.  */
5216
5217 tree
5218 finish_case_label (low_value, high_value)
5219      tree low_value;
5220      tree high_value;
5221 {
5222   tree cond, r;
5223   register struct binding_level *p;
5224
5225   if (! switch_stack)
5226     {
5227       if (high_value)
5228         error ("case label not within a switch statement");
5229       else if (low_value)
5230         error ("case label `%E' not within a switch statement",
5231                   low_value);
5232       else
5233         error ("`default' label not within a switch statement");
5234       return NULL_TREE;
5235     }
5236
5237   if (processing_template_decl)
5238     {
5239       tree label;
5240
5241       /* For templates, just add the case label; we'll do semantic
5242          analysis at instantiation-time.  */
5243       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5244       return add_stmt (build_case_label (low_value, high_value, label));
5245     }
5246
5247   /* Find the condition on which this switch statement depends.  */
5248   cond = SWITCH_COND (switch_stack->switch_stmt);
5249   if (cond && TREE_CODE (cond) == TREE_LIST)
5250     cond = TREE_VALUE (cond);
5251
5252   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5253   if (r == error_mark_node)
5254     r = NULL_TREE;
5255
5256   check_switch_goto (switch_stack->level);
5257
5258   /* After labels, make any new cleanups in the function go into their
5259      own new (temporary) binding contour.  */
5260   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5261     p->more_cleanups_ok = 0;
5262
5263   return r;
5264 }
5265 \f
5266 /* Return the list of declarations of the current level.
5267    Note that this list is in reverse order unless/until
5268    you nreverse it; and when you do nreverse it, you must
5269    store the result back using `storedecls' or you will lose.  */
5270
5271 tree
5272 getdecls ()
5273 {
5274   return current_binding_level->names;
5275 }
5276
5277 /* Return the list of type-tags (for structs, etc) of the current level.  */
5278
5279 tree
5280 gettags ()
5281 {
5282   return current_binding_level->tags;
5283 }
5284
5285 /* Store the list of declarations of the current level.
5286    This is done for the parameter declarations of a function being defined,
5287    after they are modified in the light of any missing parameters.  */
5288
5289 static void
5290 storedecls (decls)
5291      tree decls;
5292 {
5293   current_binding_level->names = decls;
5294 }
5295
5296 /* Similarly, store the list of tags of the current level.  */
5297
5298 void
5299 storetags (tags)
5300      tree tags;
5301 {
5302   current_binding_level->tags = tags;
5303 }
5304 \f
5305 /* Return the type that should be used when TYPE's name is preceded
5306    by a tag such as 'struct' or 'union', or null if the name cannot
5307    be used in this way.
5308
5309    For example, when processing the third line of:
5310
5311         struct A;
5312         typedef struct A A;
5313         struct A;
5314
5315    lookup of A will find the typedef.  Given A's typedef, this function
5316    will return the type associated with "struct A".  For the tag to be
5317    anything other than TYPE, TYPE must be a typedef whose original type
5318    has the same name and context as TYPE itself.
5319
5320    It is not valid for a typedef of an anonymous type to be used with
5321    an explicit tag:
5322
5323        typedef struct { ... } B;
5324        struct B;
5325
5326    Return null for this case.  */
5327
5328 static tree
5329 follow_tag_typedef (type)
5330      tree type;
5331 {
5332   tree original;
5333
5334   original = original_type (type);
5335   if (! TYPE_NAME (original))
5336     return NULL_TREE;
5337   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5338       && (CP_DECL_CONTEXT (TYPE_NAME (original))
5339           == CP_DECL_CONTEXT (TYPE_NAME (type)))
5340       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5341     return original;
5342   else
5343     return NULL_TREE;
5344 }
5345
5346 /* Given NAME, an IDENTIFIER_NODE,
5347    return the structure (or union or enum) definition for that name.
5348    Searches binding levels from BINDING_LEVEL up to the global level.
5349    If THISLEVEL_ONLY is nonzero, searches only the specified context
5350    (but skips any tag-transparent contexts to find one that is
5351    meaningful for tags).
5352    FORM says which kind of type the caller wants;
5353    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5354    If the wrong kind of type is found, and it's not a template, an error is
5355    reported.  */
5356
5357 static tree
5358 lookup_tag (form, name, binding_level, thislevel_only)
5359      enum tree_code form;
5360      tree name;
5361      struct binding_level *binding_level;
5362      int thislevel_only;
5363 {
5364   register struct binding_level *level;
5365   /* Non-zero if, we should look past a template parameter level, even
5366      if THISLEVEL_ONLY.  */
5367   int allow_template_parms_p = 1;
5368
5369   for (level = binding_level; level; level = level->level_chain)
5370     {
5371       register tree tail;
5372       if (ANON_AGGRNAME_P (name))
5373         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5374           {
5375             /* There's no need for error checking here, because
5376                anon names are unique throughout the compilation.  */
5377             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5378               return TREE_VALUE (tail);
5379           }
5380       else if (level->namespace_p)
5381         /* Do namespace lookup. */
5382         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5383           {
5384             tree old = binding_for_name (name, tail);
5385
5386             /* If we just skipped past a template parameter level,
5387                even though THISLEVEL_ONLY, and we find a template
5388                class declaration, then we use the _TYPE node for the
5389                template.  See the example below.  */
5390             if (thislevel_only && !allow_template_parms_p
5391                 && old && BINDING_VALUE (old)
5392                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5393               old = TREE_TYPE (BINDING_VALUE (old));
5394             else
5395               old = BINDING_TYPE (old);
5396
5397             if (old)
5398               {
5399                 /* We've found something at this binding level.  If it is
5400                    a typedef, extract the tag it refers to.  Lookup fails
5401                    if the typedef doesn't refer to a taggable type.  */
5402                 old = follow_tag_typedef (old);
5403                 if (!old)
5404                   return NULL_TREE;
5405                 if (TREE_CODE (old) != form
5406                     && (form == ENUMERAL_TYPE
5407                         || TREE_CODE (old) == ENUMERAL_TYPE))
5408                   {
5409                     error ("`%#D' redeclared as %C", old, form);
5410                     return NULL_TREE;
5411                   }
5412                 return old;
5413               }
5414             if (thislevel_only || tail == global_namespace)
5415               return NULL_TREE;
5416           }
5417       else
5418         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5419           {
5420             if (TREE_PURPOSE (tail) == name)
5421               {
5422                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5423
5424                 if (code != form
5425                     && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5426                   {
5427                     /* Definition isn't the kind we were looking for.  */
5428                     error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5429                     return NULL_TREE;
5430                   }
5431                 return TREE_VALUE (tail);
5432               }
5433           }
5434       if (thislevel_only && ! level->tag_transparent)
5435         {
5436           if (level->template_parms_p && allow_template_parms_p)
5437             {
5438               /* We must deal with cases like this:
5439
5440                    template <class T> struct S;
5441                    template <class T> struct S {};
5442
5443                  When looking up `S', for the second declaration, we
5444                  would like to find the first declaration.  But, we
5445                  are in the pseudo-global level created for the
5446                  template parameters, rather than the (surrounding)
5447                  namespace level.  Thus, we keep going one more level,
5448                  even though THISLEVEL_ONLY is non-zero.  */
5449               allow_template_parms_p = 0;
5450               continue;
5451             }
5452           else
5453             return NULL_TREE;
5454         }
5455     }
5456   return NULL_TREE;
5457 }
5458
5459 #if 0
5460 void
5461 set_current_level_tags_transparency (tags_transparent)
5462      int tags_transparent;
5463 {
5464   current_binding_level->tag_transparent = tags_transparent;
5465 }
5466 #endif
5467
5468 /* Given a type, find the tag that was defined for it and return the tag name.
5469    Otherwise return 0.  However, the value can never be 0
5470    in the cases in which this is used.
5471
5472    C++: If NAME is non-zero, this is the new name to install.  This is
5473    done when replacing anonymous tags with real tag names.  */
5474
5475 static tree
5476 lookup_tag_reverse (type, name)
5477      tree type;
5478      tree name;
5479 {
5480   register struct binding_level *level;
5481
5482   for (level = current_binding_level; level; level = level->level_chain)
5483     {
5484       register tree tail;
5485       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5486         {
5487           if (TREE_VALUE (tail) == type)
5488             {
5489               if (name)
5490                 TREE_PURPOSE (tail) = name;
5491               return TREE_PURPOSE (tail);
5492             }
5493         }
5494     }
5495   return NULL_TREE;
5496 }
5497 \f
5498 /* Look up NAME in the NAMESPACE.  */
5499
5500 tree
5501 lookup_namespace_name (namespace, name)
5502      tree namespace, name;
5503 {
5504   tree val;
5505   tree template_id = NULL_TREE;
5506
5507   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5508
5509   if (TREE_CODE (name) == NAMESPACE_DECL)
5510     /* This happens for A::B<int> when B is a namespace. */
5511     return name;
5512   else if (TREE_CODE (name) == TEMPLATE_DECL)
5513     {
5514       /* This happens for A::B where B is a template, and there are no
5515          template arguments.  */
5516       error ("invalid use of `%D'", name);
5517       return error_mark_node;
5518     }
5519
5520   namespace = ORIGINAL_NAMESPACE (namespace);
5521
5522   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5523     {
5524       template_id = name;
5525       name = TREE_OPERAND (name, 0);
5526       if (TREE_CODE (name) == OVERLOAD)
5527         name = DECL_NAME (OVL_CURRENT (name));
5528       else if (DECL_P (name))
5529         name = DECL_NAME (name);
5530     }
5531
5532   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5533
5534   val = make_node (CPLUS_BINDING);
5535   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5536     return error_mark_node;
5537
5538   if (BINDING_VALUE (val))
5539     {
5540       val = BINDING_VALUE (val);
5541
5542       if (template_id)
5543         {
5544           if (DECL_CLASS_TEMPLATE_P (val))
5545             val = lookup_template_class (val,
5546                                          TREE_OPERAND (template_id, 1),
5547                                          /*in_decl=*/NULL_TREE,
5548                                          /*context=*/NULL_TREE,
5549                                          /*entering_scope=*/0,
5550                                          tf_error | tf_warning);
5551           else if (DECL_FUNCTION_TEMPLATE_P (val)
5552                    || TREE_CODE (val) == OVERLOAD)
5553             val = lookup_template_function (val,
5554                                             TREE_OPERAND (template_id, 1));
5555           else
5556             {
5557               error ("`%D::%D' is not a template",
5558                         namespace, name);
5559               return error_mark_node;
5560             }
5561         }
5562
5563       /* If we have a single function from a using decl, pull it out.  */
5564       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5565         val = OVL_FUNCTION (val);
5566
5567       /* Ignore built-in functions that haven't been prototyped yet.  */
5568       if (!val || !DECL_P(val)
5569           || !DECL_LANG_SPECIFIC(val)
5570           || !DECL_ANTICIPATED (val))
5571         return val;
5572     }
5573
5574   error ("`%D' undeclared in namespace `%D'", name, namespace);
5575   return error_mark_node;
5576 }
5577
5578 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5579
5580 static unsigned long
5581 typename_hash (k)
5582      hash_table_key k;
5583 {
5584   unsigned long hash;
5585   tree t;
5586
5587   t = (tree) k;
5588   hash = (((unsigned long) TYPE_CONTEXT (t))
5589           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5590
5591   return hash;
5592 }
5593
5594 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5595
5596 static bool
5597 typename_compare (k1, k2)
5598      hash_table_key k1;
5599      hash_table_key k2;
5600 {
5601   tree t1;
5602   tree t2;
5603   tree d1;
5604   tree d2;
5605
5606   t1 = (tree) k1;
5607   t2 = (tree) k2;
5608   d1 = TYPE_NAME (t1);
5609   d2 = TYPE_NAME (t2);
5610
5611   return (DECL_NAME (d1) == DECL_NAME (d2)
5612           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5613           && ((TREE_TYPE (t1) != NULL_TREE)
5614               == (TREE_TYPE (t2) != NULL_TREE))
5615           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5616           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5617 }
5618
5619 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5620    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5621    is non-NULL, this type is being created by the implicit typename
5622    extension, and BASE_TYPE is a type named `t' in some base class of
5623    `T' which depends on template parameters.
5624
5625    Returns the new TYPENAME_TYPE.  */
5626
5627 tree
5628 build_typename_type (context, name, fullname, base_type)
5629      tree context;
5630      tree name;
5631      tree fullname;
5632      tree base_type;
5633 {
5634   tree t;
5635   tree d;
5636   struct hash_entry *e;
5637
5638   static struct hash_table ht;
5639
5640   if (!ht.table)
5641     {
5642       static struct hash_table *h = &ht;
5643
5644       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5645       ggc_add_tree_hash_table_root (&h, 1);
5646     }
5647
5648   /* Build the TYPENAME_TYPE.  */
5649   t = make_aggr_type (TYPENAME_TYPE);
5650   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5651   TYPENAME_TYPE_FULLNAME (t) = fullname;
5652   TREE_TYPE (t) = base_type;
5653
5654   /* Build the corresponding TYPE_DECL.  */
5655   d = build_decl (TYPE_DECL, name, t);
5656   TYPE_NAME (TREE_TYPE (d)) = d;
5657   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5658   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5659   DECL_ARTIFICIAL (d) = 1;
5660
5661   /* See if we already have this type.  */
5662   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5663   if (e)
5664     t = (tree) e->key;
5665   else
5666     /* Insert the type into the table.  */
5667     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5668
5669   return t;
5670 }
5671
5672 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5673    unless an error occurs, in which case error_mark_node is returned.
5674    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5675    set, we return that, rather than the _TYPE it corresponds to, in
5676    other cases we look through the type decl.  If TF_ERROR is set,
5677    complain about errors, otherwise be quiet.  */
5678
5679 tree
5680 make_typename_type (context, name, complain)
5681      tree context, name;
5682      tsubst_flags_t complain;
5683 {
5684   tree fullname;
5685
5686   if (TYPE_P (name))
5687     {
5688       if (!(TYPE_LANG_SPECIFIC (name)
5689             && (CLASSTYPE_IS_TEMPLATE (name)
5690                 || CLASSTYPE_USE_TEMPLATE (name))))
5691         name = TYPE_IDENTIFIER (name);
5692       else
5693         /* Create a TEMPLATE_ID_EXPR for the type.  */
5694         name = build_nt (TEMPLATE_ID_EXPR,
5695                          CLASSTYPE_TI_TEMPLATE (name),
5696                          CLASSTYPE_TI_ARGS (name));
5697     }
5698   else if (TREE_CODE (name) == TYPE_DECL)
5699     name = DECL_NAME (name);
5700
5701   fullname = name;
5702
5703   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5704     {
5705       name = TREE_OPERAND (name, 0);
5706       if (TREE_CODE (name) == TEMPLATE_DECL)
5707         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5708     }
5709   if (TREE_CODE (name) == TEMPLATE_DECL)
5710     {
5711       error ("`%D' used without template parameters", name);
5712       return error_mark_node;
5713     }
5714   if (TREE_CODE (name) != IDENTIFIER_NODE)
5715     abort ();
5716
5717   if (TREE_CODE (context) == NAMESPACE_DECL)
5718     {
5719       /* We can get here from typename_sub0 in the explicit_template_type
5720          expansion.  Just fail.  */
5721       if (complain & tf_error)
5722         error ("no class template named `%#T' in `%#T'",
5723                   name, context);
5724       return error_mark_node;
5725     }
5726
5727   if (! uses_template_parms (context)
5728       || currently_open_class (context))
5729     {
5730       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5731         {
5732           tree tmpl = NULL_TREE;
5733           if (IS_AGGR_TYPE (context))
5734             tmpl = lookup_field (context, name, 0, 0);
5735           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5736             {
5737               if (complain & tf_error)
5738                 error ("no class template named `%#T' in `%#T'",
5739                           name, context);
5740               return error_mark_node;
5741             }
5742
5743           return lookup_template_class (tmpl,
5744                                         TREE_OPERAND (fullname, 1),
5745                                         NULL_TREE, context,
5746                                         /*entering_scope=*/0,
5747                                         tf_error | tf_warning);
5748         }
5749       else
5750         {
5751           tree t;
5752
5753           if (!IS_AGGR_TYPE (context))
5754             {
5755               if (complain & tf_error)
5756                 error ("no type named `%#T' in `%#T'", name, context);
5757               return error_mark_node;
5758             }
5759
5760           t = lookup_field (context, name, 0, 1);
5761           if (t)
5762             {
5763               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5764                 t = TREE_TYPE (t);
5765               if (IMPLICIT_TYPENAME_P (t))
5766                 {
5767                   /* Lookup found an implicit typename that we had
5768                      injected into the current scope. Doing things
5769                      properly would have located the exact same type,
5770                      so there is no error here.  We must remove the
5771                      implicitness so that we do not warn about it.  */
5772                   t = copy_node (t);
5773                   TREE_TYPE (t) = NULL_TREE;
5774                 }
5775
5776               return t;
5777             }
5778         }
5779     }
5780
5781   /* If the CONTEXT is not a template type, then either the field is
5782      there now or its never going to be.  */
5783   if (!uses_template_parms (context))
5784     {
5785       if (complain & tf_error)
5786         error ("no type named `%#T' in `%#T'", name, context);
5787       return error_mark_node;
5788     }
5789
5790
5791   return build_typename_type (context, name, fullname,  NULL_TREE);
5792 }
5793
5794 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5795    unless an error occurs, in which case error_mark_node is returned.
5796    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5797    corresponds to.  If COMPLAIN zero, don't complain about any errors
5798    that occur.  */
5799
5800 tree
5801 make_unbound_class_template (context, name, complain)
5802      tree context, name;
5803      int complain;
5804 {
5805   tree t;
5806   tree d;
5807
5808   if (TYPE_P (name))
5809     name = TYPE_IDENTIFIER (name);
5810   else if (DECL_P (name))
5811     name = DECL_NAME (name);
5812   if (TREE_CODE (name) != IDENTIFIER_NODE)
5813     abort ();
5814
5815   if (!uses_template_parms (context)
5816       || currently_open_class (context))
5817     {
5818       tree tmpl = NULL_TREE;
5819
5820       if (IS_AGGR_TYPE (context))
5821         tmpl = lookup_field (context, name, 0, 0);
5822
5823       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5824         {
5825           if (complain)
5826             error ("no class template named `%#T' in `%#T'", name, context);
5827           return error_mark_node;
5828         }
5829
5830       if (!enforce_access (context, tmpl))
5831         return error_mark_node;
5832
5833       return tmpl;
5834     }
5835
5836   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5837   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5838   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5839   TREE_TYPE (t) = NULL_TREE;
5840
5841   /* Build the corresponding TEMPLATE_DECL.  */
5842   d = build_decl (TEMPLATE_DECL, name, t);
5843   TYPE_NAME (TREE_TYPE (d)) = d;
5844   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5845   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5846   DECL_ARTIFICIAL (d) = 1;
5847
5848   return t;
5849 }
5850
5851 /* Select the right _DECL from multiple choices. */
5852
5853 static tree
5854 select_decl (binding, flags)
5855      tree binding;
5856      int flags;
5857 {
5858   tree val;
5859   val = BINDING_VALUE (binding);
5860
5861   if (LOOKUP_NAMESPACES_ONLY (flags))
5862     {
5863       /* We are not interested in types. */
5864       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5865         return val;
5866       return NULL_TREE;
5867     }
5868
5869   /* If we could have a type and
5870      we have nothing or we need a type and have none.  */
5871   if (BINDING_TYPE (binding)
5872       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5873                    && TREE_CODE (val) != TYPE_DECL)))
5874     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5875   /* Don't return non-types if we really prefer types. */
5876   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5877            && (TREE_CODE (val) != TEMPLATE_DECL
5878                || !DECL_CLASS_TEMPLATE_P (val)))
5879     val = NULL_TREE;
5880
5881   return val;
5882 }
5883
5884 /* Unscoped lookup of a global: iterate over current namespaces,
5885    considering using-directives.  If SPACESP is non-NULL, store a list
5886    of the namespaces we've considered in it.  */
5887
5888 tree
5889 unqualified_namespace_lookup (name, flags, spacesp)
5890      tree name;
5891      int flags;
5892      tree *spacesp;
5893 {
5894   tree b = make_node (CPLUS_BINDING);
5895   tree initial = current_decl_namespace ();
5896   tree scope = initial;
5897   tree siter;
5898   struct binding_level *level;
5899   tree val = NULL_TREE;
5900
5901   if (spacesp)
5902     *spacesp = NULL_TREE;
5903
5904   for (; !val; scope = CP_DECL_CONTEXT (scope))
5905     {
5906       if (spacesp)
5907         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5908       val = binding_for_name (name, scope);
5909
5910       /* Ignore anticipated built-in functions.  */
5911       if (val && BINDING_VALUE (val)
5912           && DECL_P (BINDING_VALUE (val))
5913           && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5914           && DECL_ANTICIPATED (BINDING_VALUE (val)))
5915         {
5916           BINDING_VALUE (b) = NULL_TREE;
5917           BINDING_TYPE (b) = NULL_TREE;
5918         }
5919       else
5920         {
5921           /* Initialize binding for this context. */
5922           BINDING_VALUE (b) = BINDING_VALUE (val);
5923           BINDING_TYPE (b) = BINDING_TYPE (val);
5924         }
5925
5926       /* Add all _DECLs seen through local using-directives. */
5927       for (level = current_binding_level;
5928            !level->namespace_p;
5929            level = level->level_chain)
5930         if (!lookup_using_namespace (name, b, level->using_directives,
5931                                      scope, flags, spacesp))
5932           /* Give up because of error. */
5933           return error_mark_node;
5934
5935       /* Add all _DECLs seen through global using-directives. */
5936       /* XXX local and global using lists should work equally. */
5937       siter = initial;
5938       while (1)
5939         {
5940           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5941                                        scope, flags, spacesp))
5942             /* Give up because of error. */
5943             return error_mark_node;
5944           if (siter == scope) break;
5945           siter = CP_DECL_CONTEXT (siter);
5946         }
5947
5948       val = select_decl (b, flags);
5949       if (scope == global_namespace)
5950         break;
5951     }
5952   return val;
5953 }
5954
5955 /* Combine prefer_type and namespaces_only into flags.  */
5956
5957 static int
5958 lookup_flags (prefer_type, namespaces_only)
5959   int prefer_type, namespaces_only;
5960 {
5961   if (namespaces_only)
5962     return LOOKUP_PREFER_NAMESPACES;
5963   if (prefer_type > 1)
5964     return LOOKUP_PREFER_TYPES;
5965   if (prefer_type > 0)
5966     return LOOKUP_PREFER_BOTH;
5967   return 0;
5968 }
5969
5970 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5971    ignore it or not.  Subroutine of lookup_name_real.  */
5972
5973 static tree
5974 qualify_lookup (val, flags)
5975      tree val;
5976      int flags;
5977 {
5978   if (val == NULL_TREE)
5979     return val;
5980   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5981     return val;
5982   if ((flags & LOOKUP_PREFER_TYPES)
5983       && (TREE_CODE (val) == TYPE_DECL
5984           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5985               && DECL_CLASS_TEMPLATE_P (val))))
5986     return val;
5987   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5988     return NULL_TREE;
5989   return val;
5990 }
5991
5992 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5993    that.  */
5994
5995 static void
5996 warn_about_implicit_typename_lookup (typename, binding)
5997      tree typename;
5998      tree binding;
5999 {
6000   tree subtype = TREE_TYPE (TREE_TYPE (typename));
6001   tree name = DECL_NAME (typename);
6002
6003   if (! (TREE_CODE (binding) == TEMPLATE_DECL
6004          && CLASSTYPE_TEMPLATE_INFO (subtype)
6005          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
6006       && ! (TREE_CODE (binding) == TYPE_DECL
6007             && same_type_p (TREE_TYPE (binding), subtype)))
6008     {
6009       warning ("lookup of `%D' finds `%#D'",
6010                   name, binding);
6011       warning ("  instead of `%D' from dependent base class",
6012                   typename);
6013       warning ("  (use `typename %T::%D' if that's what you meant)",
6014                   constructor_name (current_class_type), name);
6015     }
6016 }
6017
6018 /* Look up NAME in the current binding level and its superiors in the
6019    namespace of variables, functions and typedefs.  Return a ..._DECL
6020    node of some kind representing its definition if there is only one
6021    such declaration, or return a TREE_LIST with all the overloaded
6022    definitions if there are many, or return 0 if it is undefined.
6023
6024    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6025    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6026    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
6027    Otherwise we prefer non-TYPE_DECLs.
6028
6029    If NONCLASS is non-zero, we don't look for the NAME in class scope,
6030    using IDENTIFIER_CLASS_VALUE.  */
6031
6032 static tree
6033 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
6034      tree name;
6035      int prefer_type, nonclass, namespaces_only;
6036 {
6037   tree t;
6038   tree val = NULL_TREE;
6039   int yylex = 0;
6040   tree from_obj = NULL_TREE;
6041   int flags;
6042   int val_is_implicit_typename = 0;
6043
6044   /* Hack: copy flag set by parser, if set. */
6045   if (only_namespace_names)
6046     namespaces_only = 1;
6047
6048   if (prefer_type == -2)
6049     {
6050       extern int looking_for_typename;
6051       tree type = NULL_TREE;
6052
6053       yylex = 1;
6054       prefer_type = looking_for_typename;
6055
6056       flags = lookup_flags (prefer_type, namespaces_only);
6057       /* If the next thing is '<', class templates are types. */
6058       if (looking_for_template)
6059         flags |= LOOKUP_TEMPLATES_EXPECTED;
6060
6061       if (got_scope)
6062         type = got_scope;
6063       else if (got_object != error_mark_node)
6064         type = got_object;
6065
6066       if (type)
6067         {
6068           if (type == error_mark_node)
6069             return error_mark_node;
6070           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6071             type = TREE_TYPE (type);
6072
6073           if (TYPE_P (type))
6074             type = complete_type (type);
6075
6076           if (TREE_CODE (type) == VOID_TYPE)
6077             type = global_namespace;
6078           if (TREE_CODE (type) == NAMESPACE_DECL)
6079             {
6080               val = make_node (CPLUS_BINDING);
6081               flags |= LOOKUP_COMPLAIN;
6082               if (!qualified_lookup_using_namespace (name, type, val, flags))
6083                 return NULL_TREE;
6084               val = select_decl (val, flags);
6085             }
6086           else if (! IS_AGGR_TYPE (type)
6087                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6088                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6089                    || TREE_CODE (type) == TYPENAME_TYPE)
6090             /* Someone else will give an error about this if needed.  */
6091             val = NULL_TREE;
6092           else if (type == current_class_type)
6093             val = IDENTIFIER_CLASS_VALUE (name);
6094           else
6095             {
6096               val = lookup_member (type, name, 0, prefer_type);
6097               type_access_control (type, val);
6098
6099               /* Restore the containing TYPENAME_TYPE if we looked
6100                  through it before.  */
6101               if (got_scope && got_scope != type
6102                   && val && TREE_CODE (val) == TYPE_DECL
6103                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6104                 {
6105                   val = TREE_TYPE (val);
6106                   val = build_typename_type (got_scope, name,
6107                                              TYPENAME_TYPE_FULLNAME (val),
6108                                              TREE_TYPE (val));
6109                   val = TYPE_STUB_DECL (val);
6110                 }
6111             }
6112         }
6113       else
6114         val = NULL_TREE;
6115
6116       if (got_scope)
6117         goto done;
6118       else if (got_object && val)
6119         {
6120           from_obj = val;
6121           val = NULL_TREE;
6122         }
6123     }
6124   else
6125     {
6126       flags = lookup_flags (prefer_type, namespaces_only);
6127       /* If we're not parsing, we need to complain. */
6128       flags |= LOOKUP_COMPLAIN;
6129     }
6130
6131   /* First, look in non-namespace scopes.  */
6132
6133   if (current_class_type == NULL_TREE)
6134     nonclass = 1;
6135
6136   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6137     {
6138       tree binding;
6139
6140       if (!LOCAL_BINDING_P (t) && nonclass)
6141         /* We're not looking for class-scoped bindings, so keep going.  */
6142         continue;
6143
6144       /* If this is the kind of thing we're looking for, we're done.  */
6145       if (qualify_lookup (BINDING_VALUE (t), flags))
6146         binding = BINDING_VALUE (t);
6147       else if ((flags & LOOKUP_PREFER_TYPES)
6148                && qualify_lookup (BINDING_TYPE (t), flags))
6149         binding = BINDING_TYPE (t);
6150       else
6151         binding = NULL_TREE;
6152
6153       /* Handle access control on types from enclosing or base classes.  */
6154       if (binding && ! yylex
6155           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6156         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6157
6158       if (binding
6159           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6160         {
6161           if (val_is_implicit_typename && !yylex)
6162             warn_about_implicit_typename_lookup (val, binding);
6163           val = binding;
6164           val_is_implicit_typename
6165             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6166           if (!val_is_implicit_typename)
6167             break;
6168         }
6169     }
6170
6171   /* Now lookup in namespace scopes.  */
6172   if (!val || val_is_implicit_typename)
6173     {
6174       t = unqualified_namespace_lookup (name, flags, 0);
6175       if (t)
6176         {
6177           if (val_is_implicit_typename && !yylex)
6178             warn_about_implicit_typename_lookup (val, t);
6179           val = t;
6180         }
6181     }
6182
6183  done:
6184   if (val)
6185     {
6186       /* This should only warn about types used in qualified-ids.  */
6187       if (from_obj && from_obj != val)
6188         {
6189           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6190               && TREE_CODE (val) == TYPE_DECL
6191               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6192             pedwarn ("\
6193 lookup of `%D' in the scope of `%#T' (`%#D') \
6194 does not match lookup in the current scope (`%#D')",
6195                         name, got_object, from_obj, val);
6196
6197           /* We don't change val to from_obj if got_object depends on
6198              template parms because that breaks implicit typename for
6199              destructor calls.  */
6200           if (! uses_template_parms (got_object))
6201             val = from_obj;
6202         }
6203
6204       /* If we have a single function from a using decl, pull it out.  */
6205       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6206         val = OVL_FUNCTION (val);
6207     }
6208   else if (from_obj)
6209     val = from_obj;
6210
6211   return val;
6212 }
6213
6214 tree
6215 lookup_name_nonclass (name)
6216      tree name;
6217 {
6218   return lookup_name_real (name, 0, 1, 0);
6219 }
6220
6221 tree
6222 lookup_function_nonclass (name, args)
6223      tree name;
6224      tree args;
6225 {
6226   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6227 }
6228
6229 tree
6230 lookup_name_namespace_only (name)
6231      tree name;
6232 {
6233   /* type-or-namespace, nonclass, namespace_only */
6234   return lookup_name_real (name, 1, 1, 1);
6235 }
6236
6237 tree
6238 lookup_name (name, prefer_type)
6239      tree name;
6240      int prefer_type;
6241 {
6242   return lookup_name_real (name, prefer_type, 0, 0);
6243 }
6244
6245 /* Similar to `lookup_name' but look only in the innermost non-class
6246    binding level.  */
6247
6248 tree
6249 lookup_name_current_level (name)
6250      tree name;
6251 {
6252   struct binding_level *b;
6253   tree t = NULL_TREE;
6254
6255   b = current_binding_level;
6256   while (b->parm_flag == 2)
6257     b = b->level_chain;
6258
6259   if (b->namespace_p)
6260     {
6261       t = IDENTIFIER_NAMESPACE_VALUE (name);
6262
6263       /* extern "C" function() */
6264       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6265         t = TREE_VALUE (t);
6266     }
6267   else if (IDENTIFIER_BINDING (name)
6268            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6269     {
6270       while (1)
6271         {
6272           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6273             return IDENTIFIER_VALUE (name);
6274
6275           if (b->keep == 2)
6276             b = b->level_chain;
6277           else
6278             break;
6279         }
6280     }
6281
6282   return t;
6283 }
6284
6285 /* Like lookup_name_current_level, but for types.  */
6286
6287 tree
6288 lookup_type_current_level (name)
6289      tree name;
6290 {
6291   register tree t = NULL_TREE;
6292
6293   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6294
6295   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6296       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6297     {
6298       struct binding_level *b = current_binding_level;
6299       while (1)
6300         {
6301           if (purpose_member (name, b->type_shadowed))
6302             return REAL_IDENTIFIER_TYPE_VALUE (name);
6303           if (b->keep == 2)
6304             b = b->level_chain;
6305           else
6306             break;
6307         }
6308     }
6309
6310   return t;
6311 }
6312
6313 void
6314 begin_only_namespace_names ()
6315 {
6316   only_namespace_names = 1;
6317 }
6318
6319 void
6320 end_only_namespace_names ()
6321 {
6322   only_namespace_names = 0;
6323 }
6324 \f
6325 /* Push the declarations of builtin types into the namespace.
6326    RID_INDEX is the index of the builtin type
6327    in the array RID_POINTERS.  NAME is the name used when looking
6328    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6329
6330 void
6331 record_builtin_type (rid_index, name, type)
6332      enum rid rid_index;
6333      const char *name;
6334      tree type;
6335 {
6336   tree rname = NULL_TREE, tname = NULL_TREE;
6337   tree tdecl = NULL_TREE;
6338
6339   if ((int) rid_index < (int) RID_MAX)
6340     rname = ridpointers[(int) rid_index];
6341   if (name)
6342     tname = get_identifier (name);
6343
6344   TYPE_BUILT_IN (type) = 1;
6345
6346   if (tname)
6347     {
6348       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6349       set_identifier_type_value (tname, NULL_TREE);
6350       if ((int) rid_index < (int) RID_MAX)
6351         /* Built-in types live in the global namespace. */
6352         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6353     }
6354   if (rname != NULL_TREE)
6355     {
6356       if (tname != NULL_TREE)
6357         {
6358           set_identifier_type_value (rname, NULL_TREE);
6359           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6360         }
6361       else
6362         {
6363           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6364           set_identifier_type_value (rname, NULL_TREE);
6365         }
6366     }
6367 }
6368
6369 /* Record one of the standard Java types.
6370  * Declare it as having the given NAME.
6371  * If SIZE > 0, it is the size of one of the integral types;
6372  * otherwise it is the negative of the size of one of the other types.  */
6373
6374 static tree
6375 record_builtin_java_type (name, size)
6376      const char *name;
6377      int size;
6378 {
6379   tree type, decl;
6380   if (size > 0)
6381     type = make_signed_type (size);
6382   else if (size > -32)
6383     { /* "__java_char" or ""__java_boolean". */
6384       type = make_unsigned_type (-size);
6385       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6386     }
6387   else
6388     { /* "__java_float" or ""__java_double". */
6389       type = make_node (REAL_TYPE);
6390       TYPE_PRECISION (type) = - size;
6391       layout_type (type);
6392     }
6393   record_builtin_type (RID_MAX, name, type);
6394   decl = TYPE_NAME (type);
6395
6396   /* Suppress generate debug symbol entries for these types,
6397      since for normal C++ they are just clutter.
6398      However, push_lang_context undoes this if extern "Java" is seen. */
6399   DECL_IGNORED_P (decl) = 1;
6400
6401   TYPE_FOR_JAVA (type) = 1;
6402   return type;
6403 }
6404
6405 /* Push a type into the namespace so that the back-ends ignore it. */
6406
6407 static void
6408 record_unknown_type (type, name)
6409      tree type;
6410      const char *name;
6411 {
6412   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6413   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6414   DECL_IGNORED_P (decl) = 1;
6415   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6416   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6417   TYPE_ALIGN (type) = 1;
6418   TYPE_USER_ALIGN (type) = 0;
6419   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6420 }
6421
6422 /* An string for which we should create an IDENTIFIER_NODE at
6423    startup.  */
6424
6425 typedef struct predefined_identifier
6426 {
6427   /* The name of the identifier.  */
6428   const char *const name;
6429   /* The place where the IDENTIFIER_NODE should be stored.  */
6430   tree *const node;
6431   /* Non-zero if this is the name of a constructor or destructor.  */
6432   const int ctor_or_dtor_p;
6433 } predefined_identifier;
6434
6435 /* Create all the predefined identifiers.  */
6436
6437 static void
6438 initialize_predefined_identifiers ()
6439 {
6440   const predefined_identifier *pid;
6441
6442   /* A table of identifiers to create at startup.  */
6443   static const predefined_identifier predefined_identifiers[] = {
6444     { "C++", &lang_name_cplusplus, 0 },
6445     { "C", &lang_name_c, 0 },
6446     { "Java", &lang_name_java, 0 },
6447     { CTOR_NAME, &ctor_identifier, 1 },
6448     { "__base_ctor", &base_ctor_identifier, 1 },
6449     { "__comp_ctor", &complete_ctor_identifier, 1 },
6450     { DTOR_NAME, &dtor_identifier, 1 },
6451     { "__comp_dtor", &complete_dtor_identifier, 1 },
6452     { "__base_dtor", &base_dtor_identifier, 1 },
6453     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6454     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6455     { "nelts", &nelts_identifier, 0 },
6456     { THIS_NAME, &this_identifier, 0 },
6457     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6458     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6459     { "_vptr", &vptr_identifier, 0 },
6460     { "__vtt_parm", &vtt_parm_identifier, 0 },
6461     { "std", &std_identifier, 0 },
6462     { NULL, NULL, 0 }
6463   };
6464
6465   for (pid = predefined_identifiers; pid->name; ++pid)
6466     {
6467       *pid->node = get_identifier (pid->name);
6468       if (pid->ctor_or_dtor_p)
6469         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6470     }
6471 }
6472
6473 /* Create the predefined scalar types of C,
6474    and some nodes representing standard constants (0, 1, (void *)0).
6475    Initialize the global binding level.
6476    Make definitions for built-in primitive functions.  */
6477
6478 void
6479 cxx_init_decl_processing ()
6480 {
6481   tree void_ftype;
6482   tree void_ftype_ptr;
6483
6484   /* Create all the identifiers we need.  */
6485   initialize_predefined_identifiers ();
6486
6487   /* Fill in back-end hooks.  */
6488   init_lang_status = &push_cp_function_context;
6489   free_lang_status = &pop_cp_function_context;
6490   mark_lang_status = &mark_cp_function_context;
6491   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6492
6493   cp_parse_init ();
6494   init_decl2 ();
6495   init_pt ();
6496
6497   /* Create the global variables.  */
6498   push_to_top_level ();
6499
6500   /* Enter the global namespace. */
6501   my_friendly_assert (global_namespace == NULL_TREE, 375);
6502   push_namespace (get_identifier ("::"));
6503   global_namespace = current_namespace;
6504   current_lang_name = NULL_TREE;
6505
6506   /* Adjust various flags based on command-line settings.  */
6507   if (! flag_permissive && ! pedantic)
6508     flag_pedantic_errors = 1;
6509   if (!flag_no_inline)
6510     {
6511       flag_inline_trees = 1;
6512       flag_no_inline = 1;
6513     }
6514   if (flag_inline_functions)
6515     {
6516       flag_inline_trees = 2;
6517       flag_inline_functions = 0;
6518     }
6519
6520   /* Force minimum function alignment if using the least significant
6521      bit of function pointers to store the virtual bit.  */
6522   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6523       && force_align_functions_log < 1)
6524     force_align_functions_log = 1;
6525
6526   /* Initially, C.  */
6527   current_lang_name = lang_name_c;
6528
6529   current_function_decl = NULL_TREE;
6530   current_binding_level = NULL_BINDING_LEVEL;
6531   free_binding_level = NULL_BINDING_LEVEL;
6532
6533   build_common_tree_nodes (flag_signed_char);
6534
6535   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6536   TREE_TYPE (error_mark_list) = error_mark_node;
6537
6538   /* Make the binding_level structure for global names.  */
6539   pushlevel (0);
6540   global_binding_level = current_binding_level;
6541   /* The global level is the namespace level of ::.  */
6542   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6543   declare_namespace_level ();
6544
6545   /* Create the `std' namespace.  */
6546   push_namespace (std_identifier);
6547   std_node = current_namespace;
6548   pop_namespace ();
6549
6550   lang_attribute_table = cp_attribute_table;
6551
6552   c_common_nodes_and_builtins ();
6553
6554   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6555   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6556   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6557   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6558   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6559   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6560   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6561   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6562
6563   integer_two_node = build_int_2 (2, 0);
6564   TREE_TYPE (integer_two_node) = integer_type_node;
6565   integer_three_node = build_int_2 (3, 0);
6566   TREE_TYPE (integer_three_node) = integer_type_node;
6567
6568   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6569   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6570   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6571   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6572   TYPE_PRECISION (boolean_type_node) = 1;
6573   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6574   boolean_false_node = build_int_2 (0, 0);
6575   TREE_TYPE (boolean_false_node) = boolean_type_node;
6576   boolean_true_node = build_int_2 (1, 0);
6577   TREE_TYPE (boolean_true_node) = boolean_type_node;
6578
6579   signed_size_zero_node = build_int_2 (0, 0);
6580   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6581
6582   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6583
6584 #if 0
6585   record_builtin_type (RID_MAX, NULL, string_type_node);
6586 #endif
6587
6588   delta_type_node = ptrdiff_type_node;
6589   vtable_index_type = ptrdiff_type_node;
6590
6591   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6592   lang_type_promotes_to = convert_type_from_ellipsis;
6593
6594   void_ftype = build_function_type (void_type_node, void_list_node);
6595   void_ftype_ptr = build_function_type (void_type_node,
6596                                         tree_cons (NULL_TREE,
6597                                                    ptr_type_node,
6598                                                    void_list_node));
6599   void_ftype_ptr
6600     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6601
6602   /* C++ extensions */
6603
6604   unknown_type_node = make_node (UNKNOWN_TYPE);
6605   record_unknown_type (unknown_type_node, "unknown type");
6606
6607   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6608   TREE_TYPE (unknown_type_node) = unknown_type_node;
6609
6610   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6611      result.  */
6612   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6613   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6614
6615   {
6616     /* Make sure we get a unique function type, so we can give
6617        its pointer type a name.  (This wins for gdb.) */
6618     tree vfunc_type = make_node (FUNCTION_TYPE);
6619     TREE_TYPE (vfunc_type) = integer_type_node;
6620     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6621     layout_type (vfunc_type);
6622
6623     vtable_entry_type = build_pointer_type (vfunc_type);
6624   }
6625   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6626
6627   vtbl_type_node
6628     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6629   layout_type (vtbl_type_node);
6630   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6631   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6632   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6633   layout_type (vtbl_ptr_type_node);
6634   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6635
6636   push_namespace (get_identifier ("__cxxabiv1"));
6637   abi_node = current_namespace;
6638   pop_namespace ();
6639
6640   global_type_node = make_node (LANG_TYPE);
6641   record_unknown_type (global_type_node, "global type");
6642
6643   /* Now, C++.  */
6644   current_lang_name = lang_name_cplusplus;
6645
6646   {
6647     tree bad_alloc_type_node, newtype, deltype;
6648     tree ptr_ftype_sizetype;
6649
6650     push_namespace (std_identifier);
6651     bad_alloc_type_node = xref_tag
6652       (class_type_node, get_identifier ("bad_alloc"), 1);
6653     pop_namespace ();
6654     ptr_ftype_sizetype
6655       = build_function_type (ptr_type_node,
6656                              tree_cons (NULL_TREE,
6657                                         c_size_type_node,
6658                                         void_list_node));
6659     newtype = build_exception_variant
6660       (ptr_ftype_sizetype, add_exception_specifier
6661        (NULL_TREE, bad_alloc_type_node, -1));
6662     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6663     push_cp_library_fn (NEW_EXPR, newtype);
6664     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6665     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6666     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6667   }
6668
6669   abort_fndecl
6670     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6671
6672   /* Perform other language dependent initializations.  */
6673   init_class_processing ();
6674   init_init_processing ();
6675   init_search_processing ();
6676   init_rtti_processing ();
6677
6678   if (flag_exceptions)
6679     init_exception_processing ();
6680
6681   if (! supports_one_only ())
6682     flag_weak = 0;
6683
6684   make_fname_decl = cp_make_fname_decl;
6685   start_fname_decls ();
6686
6687   /* Show we use EH for cleanups.  */
6688   using_eh_for_cleanups ();
6689
6690   /* Maintain consistency.  Perhaps we should just complain if they
6691      say -fwritable-strings?  */
6692   if (flag_writable_strings)
6693     flag_const_strings = 0;
6694
6695   /* Add GC roots for all of our global variables.  */
6696   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6697   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6698   ggc_add_tree_root (&integer_three_node, 1);
6699   ggc_add_tree_root (&integer_two_node, 1);
6700   ggc_add_tree_root (&signed_size_zero_node, 1);
6701   ggc_add_tree_root (&size_one_node, 1);
6702   ggc_add_tree_root (&size_zero_node, 1);
6703   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6704                 mark_binding_level);
6705   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6706   ggc_add_tree_root (&static_ctors, 1);
6707   ggc_add_tree_root (&static_dtors, 1);
6708   ggc_add_tree_root (&lastiddecl, 1);
6709
6710   ggc_add_tree_root (&last_function_parms, 1);
6711   ggc_add_tree_root (&error_mark_list, 1);
6712
6713   ggc_add_tree_root (&global_namespace, 1);
6714   ggc_add_tree_root (&global_type_node, 1);
6715   ggc_add_tree_root (&anonymous_namespace_name, 1);
6716
6717   ggc_add_tree_root (&got_object, 1);
6718   ggc_add_tree_root (&got_scope, 1);
6719
6720   ggc_add_tree_root (&current_lang_name, 1);
6721   ggc_add_tree_root (&static_aggregates, 1);
6722   ggc_add_tree_root (&free_bindings, 1);
6723   ggc_add_tree_root (&incomplete_vars, 1);
6724 }
6725
6726 /* Generate an initializer for a function naming variable from
6727    NAME. NAME may be NULL, in which case we generate a special
6728    ERROR_MARK node which should be replaced later. */
6729
6730 tree
6731 cp_fname_init (name)
6732      const char *name;
6733 {
6734   tree domain = NULL_TREE;
6735   tree type;
6736   tree init = NULL_TREE;
6737   size_t length = 0;
6738
6739   if (name)
6740     {
6741       length = strlen (name);
6742       domain = build_index_type (size_int (length));
6743       init = build_string (length + 1, name);
6744     }
6745
6746   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6747   type = build_cplus_array_type (type, domain);
6748
6749   if (init)
6750     TREE_TYPE (init) = type;
6751   else
6752     /* We don't know the value until instantiation time. Make
6753        something which will be digested now, but replaced later. */
6754     init = build (ERROR_MARK, type);
6755
6756   return init;
6757 }
6758
6759 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6760    decl, NAME is the initialization string and TYPE_DEP indicates whether
6761    NAME depended on the type of the function. We make use of that to detect
6762    __PRETTY_FUNCTION__ inside a template fn. This is being done
6763    lazily at the point of first use, so we musn't push the decl now.  */
6764
6765 static tree
6766 cp_make_fname_decl (id, type_dep)
6767      tree id;
6768      int type_dep;
6769 {
6770   const char *const name = (type_dep && processing_template_decl
6771                       ? NULL : fname_as_string (type_dep));
6772   tree init = cp_fname_init (name);
6773   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6774
6775   /* As we don't push the decl here, we must set the context. */
6776   DECL_CONTEXT (decl) = current_function_decl;
6777   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6778
6779   TREE_STATIC (decl) = 1;
6780   TREE_READONLY (decl) = 1;
6781   DECL_ARTIFICIAL (decl) = 1;
6782   DECL_INITIAL (decl) = init;
6783
6784   TREE_USED (decl) = 1;
6785
6786   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6787
6788   return decl;
6789 }
6790
6791 /* Make a definition for a builtin function named NAME in the current
6792    namespace, whose data type is TYPE and whose context is CONTEXT.
6793    TYPE should be a function type with argument types.
6794
6795    CLASS and CODE tell later passes how to compile calls to this function.
6796    See tree.h for possible values.
6797
6798    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6799    the name to be called if we can't opencode the function.  */
6800
6801 static tree
6802 builtin_function_1 (name, type, context, code, class, libname)
6803      const char *name;
6804      tree type;
6805      tree context;
6806      int code;
6807      enum built_in_class class;
6808      const char *libname;
6809 {
6810   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6811   DECL_BUILT_IN_CLASS (decl) = class;
6812   DECL_FUNCTION_CODE (decl) = code;
6813   DECL_CONTEXT (decl) = context;
6814
6815   /* The return builtins leave the current function.  */
6816   if (code == BUILT_IN_RETURN || code == BUILT_IN_EH_RETURN)
6817     TREE_THIS_VOLATILE (decl) = 1;
6818
6819   pushdecl (decl);
6820
6821   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6822      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6823      function in the namespace.  */
6824   if (libname)
6825     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6826   make_decl_rtl (decl, NULL);
6827
6828   /* Warn if a function in the namespace for users
6829      is used without an occasion to consider it declared.  */
6830   if (name[0] != '_' || name[1] != '_')
6831     DECL_ANTICIPATED (decl) = 1;
6832
6833   /* Possibly apply some default attributes to this built-in function.  */
6834   decl_attributes (&decl, NULL_TREE, 0);
6835
6836   return decl;
6837 }
6838
6839 /* Entry point for the benefit of c_common_nodes_and_builtins.
6840
6841    Make a defintion for a builtin function named NAME and whose data type
6842    is TYPE.  TYPE should be a function type with argument types.  This
6843    function places the anticipated declaration in the global namespace
6844    and additionally in the std namespace if appropriate.
6845
6846    CLASS and CODE tell later passes how to compile calls to this function.
6847    See tree.h for possible values.
6848
6849    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6850    the name to be called if we can't opencode the function.  */
6851
6852 tree
6853 builtin_function (name, type, code, class, libname)
6854      const char *name;
6855      tree type;
6856      int code;
6857      enum built_in_class class;
6858      const char *libname;
6859 {
6860   /* All builtins that don't begin with an '_' should additionally
6861      go in the 'std' namespace.  */
6862   if (name[0] != '_')
6863     {
6864       push_namespace (std_identifier);
6865       builtin_function_1 (name, type, std_node, code, class, libname);
6866       pop_namespace ();
6867     }
6868
6869   return builtin_function_1 (name, type, NULL_TREE, code, class, libname);
6870 }
6871
6872 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6873    function.  Not called directly.  */
6874
6875 static tree
6876 build_library_fn_1 (name, operator_code, type)
6877      tree name;
6878      enum tree_code operator_code;
6879      tree type;
6880 {
6881   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6882   DECL_EXTERNAL (fn) = 1;
6883   TREE_PUBLIC (fn) = 1;
6884   DECL_ARTIFICIAL (fn) = 1;
6885   TREE_NOTHROW (fn) = 1;
6886   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6887   SET_DECL_LANGUAGE (fn, lang_c);
6888   return fn;
6889 }
6890
6891 /* Returns the _DECL for a library function with C linkage.
6892    We assume that such functions never throw; if this is incorrect,
6893    callers should unset TREE_NOTHROW.  */
6894
6895 tree
6896 build_library_fn (name, type)
6897      tree name;
6898      tree type;
6899 {
6900   return build_library_fn_1 (name, ERROR_MARK, type);
6901 }
6902
6903 /* Returns the _DECL for a library function with C++ linkage.  */
6904
6905 static tree
6906 build_cp_library_fn (name, operator_code, type)
6907      tree name;
6908      enum tree_code operator_code;
6909      tree type;
6910 {
6911   tree fn = build_library_fn_1 (name, operator_code, type);
6912   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6913   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6914   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6915   set_mangled_name_for_decl (fn);
6916   return fn;
6917 }
6918
6919 /* Like build_library_fn, but takes a C string instead of an
6920    IDENTIFIER_NODE.  */
6921
6922 tree
6923 build_library_fn_ptr (name, type)
6924      const char *name;
6925      tree type;
6926 {
6927   return build_library_fn (get_identifier (name), type);
6928 }
6929
6930 /* Like build_cp_library_fn, but takes a C string instead of an
6931    IDENTIFIER_NODE.  */
6932
6933 tree
6934 build_cp_library_fn_ptr (name, type)
6935      const char *name;
6936      tree type;
6937 {
6938   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6939 }
6940
6941 /* Like build_library_fn, but also pushes the function so that we will
6942    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6943
6944 tree
6945 push_library_fn (name, type)
6946      tree name, type;
6947 {
6948   tree fn = build_library_fn (name, type);
6949   pushdecl_top_level (fn);
6950   return fn;
6951 }
6952
6953 /* Like build_cp_library_fn, but also pushes the function so that it
6954    will be found by normal lookup.  */
6955
6956 static tree
6957 push_cp_library_fn (operator_code, type)
6958      enum tree_code operator_code;
6959      tree type;
6960 {
6961   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6962                                  operator_code,
6963                                  type);
6964   pushdecl (fn);
6965   return fn;
6966 }
6967
6968 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6969    a FUNCTION_TYPE.  */
6970
6971 tree
6972 push_void_library_fn (name, parmtypes)
6973      tree name, parmtypes;
6974 {
6975   tree type = build_function_type (void_type_node, parmtypes);
6976   return push_library_fn (name, type);
6977 }
6978
6979 /* Like push_library_fn, but also note that this function throws
6980    and does not return.  Used for __throw_foo and the like.  */
6981
6982 tree
6983 push_throw_library_fn (name, type)
6984      tree name, type;
6985 {
6986   tree fn = push_library_fn (name, type);
6987   TREE_THIS_VOLATILE (fn) = 1;
6988   TREE_NOTHROW (fn) = 0;
6989   return fn;
6990 }
6991
6992 /* Apply default attributes to a function, if a system function with default
6993    attributes.  */
6994
6995 void
6996 insert_default_attributes (decl)
6997      tree decl;
6998 {
6999   if (!DECL_EXTERN_C_FUNCTION_P (decl))
7000     return;
7001   if (!TREE_PUBLIC (decl))
7002     return;
7003   c_common_insert_default_attributes (decl);
7004 }
7005 \f
7006 /* When we call finish_struct for an anonymous union, we create
7007    default copy constructors and such.  But, an anonymous union
7008    shouldn't have such things; this function undoes the damage to the
7009    anonymous union type T.
7010
7011    (The reason that we create the synthesized methods is that we don't
7012    distinguish `union { int i; }' from `typedef union { int i; } U'.
7013    The first is an anonymous union; the second is just an ordinary
7014    union type.)  */
7015
7016 void
7017 fixup_anonymous_aggr (t)
7018      tree t;
7019 {
7020   tree *q;
7021
7022   /* Wipe out memory of synthesized methods */
7023   TYPE_HAS_CONSTRUCTOR (t) = 0;
7024   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
7025   TYPE_HAS_INIT_REF (t) = 0;
7026   TYPE_HAS_CONST_INIT_REF (t) = 0;
7027   TYPE_HAS_ASSIGN_REF (t) = 0;
7028   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
7029
7030   /* Splice the implicitly generated functions out of the TYPE_METHODS
7031      list.  */
7032   q = &TYPE_METHODS (t);
7033   while (*q)
7034     {
7035       if (DECL_ARTIFICIAL (*q))
7036         *q = TREE_CHAIN (*q);
7037       else
7038         q = &TREE_CHAIN (*q);
7039     }
7040
7041   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
7042   if (TYPE_METHODS (t))
7043     cp_error_at ("an anonymous union cannot have function members", t);
7044
7045   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
7046      assignment operators (because they cannot have these methods themselves).
7047      For anonymous unions this is already checked because they are not allowed
7048      in any union, otherwise we have to check it.  */
7049   if (TREE_CODE (t) != UNION_TYPE)
7050     {
7051       tree field, type;
7052
7053       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
7054         if (TREE_CODE (field) == FIELD_DECL)
7055           {
7056             type = TREE_TYPE (field);
7057             if (CLASS_TYPE_P (type))
7058               {
7059                 if (TYPE_NEEDS_CONSTRUCTING (type))
7060                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
7061                                field);
7062                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7063                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
7064                                field);
7065                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
7066                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
7067                                field);
7068               }
7069           }
7070     }
7071 }
7072
7073 /* Make sure that a declaration with no declarator is well-formed, i.e.
7074    just defines a tagged type or anonymous union.
7075
7076    Returns the type defined, if any.  */
7077
7078 tree
7079 check_tag_decl (declspecs)
7080      tree declspecs;
7081 {
7082   int found_type = 0;
7083   int saw_friend = 0;
7084   int saw_typedef = 0;
7085   tree ob_modifier = NULL_TREE;
7086   register tree link;
7087   register tree t = NULL_TREE;
7088
7089   for (link = declspecs; link; link = TREE_CHAIN (link))
7090     {
7091       register tree value = TREE_VALUE (link);
7092
7093       if (TYPE_P (value)
7094           || TREE_CODE (value) == TYPE_DECL
7095           || (TREE_CODE (value) == IDENTIFIER_NODE
7096               && IDENTIFIER_GLOBAL_VALUE (value)
7097               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
7098         {
7099           ++found_type;
7100
7101           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7102             {
7103               if (! in_system_header)
7104                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7105               return NULL_TREE;
7106             }
7107
7108           if (TYPE_P (value)
7109               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7110                   || TREE_CODE (value) == ENUMERAL_TYPE))
7111             {
7112               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7113               t = value;
7114             }
7115         }
7116       else if (value == ridpointers[(int) RID_TYPEDEF])
7117         saw_typedef = 1;
7118       else if (value == ridpointers[(int) RID_FRIEND])
7119         {
7120           if (current_class_type == NULL_TREE
7121               || current_scope () != current_class_type)
7122             ob_modifier = value;
7123           else
7124             saw_friend = 1;
7125         }
7126       else if (value == ridpointers[(int) RID_STATIC]
7127                || value == ridpointers[(int) RID_EXTERN]
7128                || value == ridpointers[(int) RID_AUTO]
7129                || value == ridpointers[(int) RID_REGISTER]
7130                || value == ridpointers[(int) RID_INLINE]
7131                || value == ridpointers[(int) RID_VIRTUAL]
7132                || value == ridpointers[(int) RID_CONST]
7133                || value == ridpointers[(int) RID_VOLATILE]
7134                || value == ridpointers[(int) RID_EXPLICIT])
7135         ob_modifier = value;
7136     }
7137
7138   if (found_type > 1)
7139     error ("multiple types in one declaration");
7140
7141   if (t == NULL_TREE && ! saw_friend)
7142     pedwarn ("declaration does not declare anything");
7143
7144   /* Check for an anonymous union.  */
7145   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7146            && TYPE_ANONYMOUS_P (t))
7147     {
7148       /* 7/3 In a simple-declaration, the optional init-declarator-list
7149          can be omitted only when declaring a class (clause 9) or
7150          enumeration (7.2), that is, when the decl-specifier-seq contains
7151          either a class-specifier, an elaborated-type-specifier with
7152          a class-key (9.1), or an enum-specifier.  In these cases and
7153          whenever a class-specifier or enum-specifier is present in the
7154          decl-specifier-seq, the identifiers in these specifiers are among
7155          the names being declared by the declaration (as class-name,
7156          enum-names, or enumerators, depending on the syntax).  In such
7157          cases, and except for the declaration of an unnamed bit-field (9.6),
7158          the decl-specifier-seq shall introduce one or more names into the
7159          program, or shall redeclare a name introduced by a previous
7160          declaration.  [Example:
7161              enum { };            // ill-formed
7162              typedef class { };   // ill-formed
7163          --end example]  */
7164       if (saw_typedef)
7165         {
7166           error ("missing type-name in typedef-declaration");
7167           return NULL_TREE;
7168         }
7169       /* Anonymous unions are objects, so they can have specifiers.  */;
7170       SET_ANON_AGGR_TYPE_P (t);
7171
7172       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7173         pedwarn ("ISO C++ prohibits anonymous structs");
7174     }
7175
7176   else if (ob_modifier)
7177     {
7178       if (ob_modifier == ridpointers[(int) RID_INLINE]
7179           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7180         error ("`%D' can only be specified for functions", ob_modifier);
7181       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7182         error ("`%D' can only be specified inside a class", ob_modifier);
7183       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7184         error ("`%D' can only be specified for constructors",
7185                   ob_modifier);
7186       else
7187         error ("`%D' can only be specified for objects and functions",
7188                   ob_modifier);
7189     }
7190
7191   return t;
7192 }
7193
7194 /* Called when a declaration is seen that contains no names to declare.
7195    If its type is a reference to a structure, union or enum inherited
7196    from a containing scope, shadow that tag name for the current scope
7197    with a forward reference.
7198    If its type defines a new named structure or union
7199    or defines an enum, it is valid but we need not do anything here.
7200    Otherwise, it is an error.
7201
7202    C++: may have to grok the declspecs to learn about static,
7203    complain for anonymous unions.  */
7204
7205 void
7206 shadow_tag (declspecs)
7207      tree declspecs;
7208 {
7209   tree t = check_tag_decl (declspecs);
7210
7211   if (t)
7212     maybe_process_partial_specialization (t);
7213
7214   /* This is where the variables in an anonymous union are
7215      declared.  An anonymous union declaration looks like:
7216      union { ... } ;
7217      because there is no declarator after the union, the parser
7218      sends that declaration here.  */
7219   if (t && ANON_AGGR_TYPE_P (t))
7220     {
7221       fixup_anonymous_aggr (t);
7222
7223       if (TYPE_FIELDS (t))
7224         {
7225           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7226                                       NULL);
7227           finish_anon_union (decl);
7228         }
7229     }
7230 }
7231 \f
7232 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7233
7234 tree
7235 groktypename (typename)
7236      tree typename;
7237 {
7238   tree specs, attrs;
7239   tree type;
7240   if (TREE_CODE (typename) != TREE_LIST)
7241     return typename;
7242   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7243   type = grokdeclarator (TREE_VALUE (typename), specs,
7244                          TYPENAME, 0, &attrs);
7245   if (attrs)
7246     cplus_decl_attributes (&type, attrs, 0);
7247   return type;
7248 }
7249
7250 /* Decode a declarator in an ordinary declaration or data definition.
7251    This is called as soon as the type information and variable name
7252    have been parsed, before parsing the initializer if any.
7253    Here we create the ..._DECL node, fill in its type,
7254    and put it on the list of decls for the current context.
7255    The ..._DECL node is returned as the value.
7256
7257    Exception: for arrays where the length is not specified,
7258    the type is left null, to be filled in by `cp_finish_decl'.
7259
7260    Function definitions do not come here; they go to start_function
7261    instead.  However, external and forward declarations of functions
7262    do go through here.  Structure field declarations are done by
7263    grokfield and not through here.  */
7264
7265 tree
7266 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7267      tree declarator, declspecs;
7268      int initialized;
7269      tree attributes, prefix_attributes;
7270 {
7271   tree decl;
7272   register tree type, tem;
7273   tree context;
7274   extern int have_extern_spec;
7275   extern int used_extern_spec;
7276
7277 #if 0
7278   /* See code below that used this.  */
7279   int init_written = initialized;
7280 #endif
7281
7282   /* This should only be done once on the top most decl.  */
7283   if (have_extern_spec && !used_extern_spec)
7284     {
7285       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7286                              declspecs);
7287       used_extern_spec = 1;
7288     }
7289
7290   /* An object declared as __attribute__((deprecated)) suppresses
7291      warnings of uses of other deprecated items.  */
7292   if (lookup_attribute ("deprecated", attributes))
7293     deprecated_state = DEPRECATED_SUPPRESS;
7294
7295   attributes = chainon (attributes, prefix_attributes);
7296
7297   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7298                          &attributes);
7299
7300   deprecated_state = DEPRECATED_NORMAL;
7301
7302   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7303     return NULL_TREE;
7304
7305   type = TREE_TYPE (decl);
7306
7307   if (type == error_mark_node)
7308     return NULL_TREE;
7309
7310   context = DECL_CONTEXT (decl);
7311
7312   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7313       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7314     {
7315       /* When parsing the initializer, lookup should use the object's
7316          namespace. */
7317       push_decl_namespace (context);
7318     }
7319
7320   /* We are only interested in class contexts, later. */
7321   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7322     context = NULL_TREE;
7323
7324   if (initialized)
7325     /* Is it valid for this decl to have an initializer at all?
7326        If not, set INITIALIZED to zero, which will indirectly
7327        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7328     switch (TREE_CODE (decl))
7329       {
7330       case TYPE_DECL:
7331         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7332         initialized = 0;
7333         break;
7334
7335       case FUNCTION_DECL:
7336         error ("function `%#D' is initialized like a variable", decl);
7337         initialized = 0;
7338         break;
7339
7340       default:
7341         break;
7342       }
7343
7344   if (initialized)
7345     {
7346       if (! toplevel_bindings_p ()
7347           && DECL_EXTERNAL (decl))
7348         warning ("declaration of `%#D' has `extern' and is initialized",
7349                     decl);
7350       DECL_EXTERNAL (decl) = 0;
7351       if (toplevel_bindings_p ())
7352         TREE_STATIC (decl) = 1;
7353
7354       /* Tell `pushdecl' this is an initialized decl
7355          even though we don't yet have the initializer expression.
7356          Also tell `cp_finish_decl' it may store the real initializer.  */
7357       DECL_INITIAL (decl) = error_mark_node;
7358     }
7359
7360   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7361   cplus_decl_attributes (&decl, attributes, 0);
7362
7363   /* If #pragma weak was used, mark the decl weak now.  */
7364   if (current_binding_level == global_binding_level)
7365     maybe_apply_pragma_weak (decl);
7366
7367   if (TREE_CODE (decl) == FUNCTION_DECL
7368       && DECL_DECLARED_INLINE_P (decl)
7369       && DECL_UNINLINABLE (decl)
7370       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7371     warning_with_decl (decl,
7372                        "inline function `%s' given attribute noinline");
7373
7374   if (context && COMPLETE_TYPE_P (complete_type (context)))
7375     {
7376       push_nested_class (context, 2);
7377
7378       if (TREE_CODE (decl) == VAR_DECL)
7379         {
7380           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7381           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7382             error ("`%#D' is not a static member of `%#T'", decl, context);
7383           else
7384             {
7385               if (DECL_CONTEXT (field) != context)
7386                 {
7387                   pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7388                               DECL_CONTEXT (field), DECL_NAME (decl),
7389                               context, DECL_NAME (decl));
7390                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7391                 }
7392               /* Static data member are tricky; an in-class initialization
7393                  still doesn't provide a definition, so the in-class
7394                  declaration will have DECL_EXTERNAL set, but will have an
7395                  initialization.  Thus, duplicate_decls won't warn
7396                  about this situation, and so we check here.  */
7397               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7398                 error ("duplicate initialization of %D", decl);
7399               if (duplicate_decls (decl, field))
7400                 decl = field;
7401             }
7402         }
7403       else
7404         {
7405           tree field = check_classfn (context, decl);
7406           if (field && duplicate_decls (decl, field))
7407             decl = field;
7408         }
7409
7410       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7411       DECL_IN_AGGR_P (decl) = 0;
7412       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7413           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7414         {
7415           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7416           /* [temp.expl.spec] An explicit specialization of a static data
7417              member of a template is a definition if the declaration
7418              includes an initializer; otherwise, it is a declaration.
7419
7420              We check for processing_specialization so this only applies
7421              to the new specialization syntax.  */
7422           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7423             DECL_EXTERNAL (decl) = 1;
7424         }
7425
7426       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7427         pedwarn ("declaration of `%#D' outside of class is not definition",
7428                     decl);
7429     }
7430
7431   /* Enter this declaration into the symbol table.  */
7432   tem = maybe_push_decl (decl);
7433
7434   if (processing_template_decl)
7435     tem = push_template_decl (tem);
7436
7437 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7438   /* Tell the back-end to use or not use .common as appropriate.  If we say
7439      -fconserve-space, we want this to save .data space, at the expense of
7440      wrong semantics.  If we say -fno-conserve-space, we want this to
7441      produce errors about redefs; to do this we force variables into the
7442      data segment.  */
7443   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7444 #endif
7445
7446   if (! processing_template_decl)
7447     start_decl_1 (tem);
7448
7449   return tem;
7450 }
7451
7452 void
7453 start_decl_1 (decl)
7454      tree decl;
7455 {
7456   tree type = TREE_TYPE (decl);
7457   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7458
7459   if (type == error_mark_node)
7460     return;
7461
7462   maybe_push_cleanup_level (type);
7463
7464   if (initialized)
7465     /* Is it valid for this decl to have an initializer at all?
7466        If not, set INITIALIZED to zero, which will indirectly
7467        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7468     {
7469       /* Don't allow initializations for incomplete types except for
7470          arrays which might be completed by the initialization.  */
7471       if (COMPLETE_TYPE_P (complete_type (type)))
7472         ;                       /* A complete type is ok.  */
7473       else if (TREE_CODE (type) != ARRAY_TYPE)
7474         {
7475           error ("variable `%#D' has initializer but incomplete type",
7476                     decl);
7477           initialized = 0;
7478           type = TREE_TYPE (decl) = error_mark_node;
7479         }
7480       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7481         {
7482           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7483             error ("elements of array `%#D' have incomplete type", decl);
7484           /* else we already gave an error in start_decl.  */
7485           initialized = 0;
7486         }
7487     }
7488
7489   if (!initialized
7490       && TREE_CODE (decl) != TYPE_DECL
7491       && TREE_CODE (decl) != TEMPLATE_DECL
7492       && type != error_mark_node
7493       && IS_AGGR_TYPE (type)
7494       && ! DECL_EXTERNAL (decl))
7495     {
7496       if ((! processing_template_decl || ! uses_template_parms (type))
7497           && !COMPLETE_TYPE_P (complete_type (type)))
7498         {
7499           error ("aggregate `%#D' has incomplete type and cannot be defined",
7500                  decl);
7501           /* Change the type so that assemble_variable will give
7502              DECL an rtl we can live with: (mem (const_int 0)).  */
7503           type = TREE_TYPE (decl) = error_mark_node;
7504         }
7505       else
7506         {
7507           /* If any base type in the hierarchy of TYPE needs a constructor,
7508              then we set initialized to 1.  This way any nodes which are
7509              created for the purposes of initializing this aggregate
7510              will live as long as it does.  This is necessary for global
7511              aggregates which do not have their initializers processed until
7512              the end of the file.  */
7513           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7514         }
7515     }
7516
7517   if (! initialized)
7518     DECL_INITIAL (decl) = NULL_TREE;
7519 }
7520
7521 /* Handle initialization of references.
7522    These three arguments are from `cp_finish_decl', and have the
7523    same meaning here that they do there.
7524
7525    Quotes on semantics can be found in ARM 8.4.3.  */
7526
7527 static tree
7528 grok_reference_init (decl, type, init)
7529      tree decl, type, init;
7530 {
7531   tree tmp;
7532
7533   if (init == NULL_TREE)
7534     {
7535       if ((DECL_LANG_SPECIFIC (decl) == 0
7536            || DECL_IN_AGGR_P (decl) == 0)
7537           && ! DECL_THIS_EXTERN (decl))
7538         error ("`%D' declared as reference but not initialized", decl);
7539       return NULL_TREE;
7540     }
7541
7542   if (init == error_mark_node)
7543     return NULL_TREE;
7544
7545   if (TREE_CODE (init) == CONSTRUCTOR)
7546     {
7547       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7548       return NULL_TREE;
7549     }
7550
7551   if (TREE_CODE (init) == TREE_LIST)
7552     init = build_compound_expr (init);
7553
7554   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7555     init = convert_from_reference (init);
7556
7557   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7558       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7559     {
7560       /* Note: default conversion is only called in very special cases.  */
7561       init = default_conversion (init);
7562     }
7563
7564   /* Convert INIT to the reference type TYPE.  This may involve the
7565      creation of a temporary, whose lifetime must be the same as that
7566      of the reference.  If so, a DECL_STMT for the temporary will be
7567      added just after the DECL_STMT for DECL.  That's why we don't set
7568      DECL_INITIAL for local references (instead assigning to them
7569      explicitly); we need to allow the temporary to be initialized
7570      first.  */
7571   tmp = convert_to_reference
7572     (type, init, CONV_IMPLICIT,
7573      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7574      decl);
7575
7576   if (tmp == error_mark_node)
7577     return NULL_TREE;
7578   else if (tmp == NULL_TREE)
7579     {
7580       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7581       return NULL_TREE;
7582     }
7583
7584   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7585     return tmp;
7586
7587   DECL_INITIAL (decl) = tmp;
7588
7589   return NULL_TREE;
7590 }
7591
7592 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7593    mucking with forces it does not comprehend (i.e. initialization with a
7594    constructor).  If we are at global scope and won't go into COMMON, fill
7595    it in with a dummy CONSTRUCTOR to force the variable into .data;
7596    otherwise we can use error_mark_node.  */
7597
7598 static tree
7599 obscure_complex_init (decl, init)
7600      tree decl, init;
7601 {
7602   if (! flag_no_inline && TREE_STATIC (decl))
7603     {
7604       if (extract_init (decl, init))
7605         return NULL_TREE;
7606     }
7607
7608 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7609   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7610     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7611                                  NULL_TREE);
7612   else
7613 #endif
7614     {
7615       if (zero_init_p (TREE_TYPE (decl)))
7616         DECL_INITIAL (decl) = error_mark_node;
7617       /* Otherwise, force_store_init_value will have already stored a
7618          zero-init initializer in DECL_INITIAL, that should be
7619          retained.  */
7620     }
7621
7622   return init;
7623 }
7624
7625 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7626    array until we finish parsing the initializer.  If that's the
7627    situation we're in, update DECL accordingly.  */
7628
7629 static void
7630 maybe_deduce_size_from_array_init (decl, init)
7631      tree decl;
7632      tree init;
7633 {
7634   tree type = TREE_TYPE (decl);
7635
7636   if (TREE_CODE (type) == ARRAY_TYPE
7637       && TYPE_DOMAIN (type) == NULL_TREE
7638       && TREE_CODE (decl) != TYPE_DECL)
7639     {
7640       /* do_default is really a C-ism to deal with tentative definitions.
7641          But let's leave it here to ease the eventual merge.  */
7642       int do_default = !DECL_EXTERNAL (decl);
7643       tree initializer = init ? init : DECL_INITIAL (decl);
7644       int failure = complete_array_type (type, initializer, do_default);
7645
7646       if (failure == 1)
7647         error ("initializer fails to determine size of `%D'", decl);
7648
7649       if (failure == 2)
7650         {
7651           if (do_default)
7652             error ("array size missing in `%D'", decl);
7653           /* If a `static' var's size isn't known, make it extern as
7654              well as static, so it does not get allocated.  If it's not
7655              `static', then don't mark it extern; finish_incomplete_decl
7656              will give it a default size and it will get allocated.  */
7657           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7658             DECL_EXTERNAL (decl) = 1;
7659         }
7660
7661       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7662           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7663                               integer_zero_node))
7664         error ("zero-size array `%D'", decl);
7665
7666       layout_decl (decl, 0);
7667     }
7668 }
7669
7670 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7671    any appropriate error messages regarding the layout.  */
7672
7673 static void
7674 layout_var_decl (decl)
7675      tree decl;
7676 {
7677   tree type = TREE_TYPE (decl);
7678 #if 0
7679   tree ttype = target_type (type);
7680 #endif
7681
7682   /* If we haven't already layed out this declaration, do so now.
7683      Note that we must not call complete type for an external object
7684      because it's type might involve templates that we are not
7685      supposed to isntantiate yet.  (And it's perfectly legal to say
7686      `extern X x' for some incomplete type `X'.)  */
7687   if (!DECL_EXTERNAL (decl))
7688     complete_type (type);
7689   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7690     layout_decl (decl, 0);
7691
7692   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7693     {
7694       /* An automatic variable with an incomplete type: that is an error.
7695          Don't talk about array types here, since we took care of that
7696          message in grokdeclarator.  */
7697       error ("storage size of `%D' isn't known", decl);
7698       TREE_TYPE (decl) = error_mark_node;
7699     }
7700 #if 0
7701   /* Keep this code around in case we later want to control debug info
7702      based on whether a type is "used".  (jason 1999-11-11) */
7703
7704   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7705     /* Let debugger know it should output info for this type.  */
7706     note_debug_info_needed (ttype);
7707
7708   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7709     note_debug_info_needed (DECL_CONTEXT (decl));
7710 #endif
7711
7712   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7713       && DECL_SIZE (decl) != NULL_TREE
7714       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7715     {
7716       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7717         constant_expression_warning (DECL_SIZE (decl));
7718       else
7719         error ("storage size of `%D' isn't constant", decl);
7720     }
7721
7722   if (TREE_STATIC (decl)
7723       && !DECL_ARTIFICIAL (decl)
7724       && current_function_decl
7725       && DECL_CONTEXT (decl) == current_function_decl)
7726     push_local_name (decl);
7727 }
7728
7729 /* If a local static variable is declared in an inline function, or if
7730    we have a weak definition, we must endeavor to create only one
7731    instance of the variable at link-time.  */
7732
7733 static void
7734 maybe_commonize_var (decl)
7735      tree decl;
7736 {
7737   /* Static data in a function with comdat linkage also has comdat
7738      linkage.  */
7739   if (TREE_STATIC (decl)
7740       /* Don't mess with __FUNCTION__.  */
7741       && ! DECL_ARTIFICIAL (decl)
7742       && current_function_decl
7743       && DECL_CONTEXT (decl) == current_function_decl
7744       && (DECL_DECLARED_INLINE_P (current_function_decl)
7745           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7746       && TREE_PUBLIC (current_function_decl))
7747     {
7748       /* If flag_weak, we don't need to mess with this, as we can just
7749          make the function weak, and let it refer to its unique local
7750          copy.  This works because we don't allow the function to be
7751          inlined.  */
7752       if (! flag_weak)
7753         {
7754           if (DECL_INTERFACE_KNOWN (current_function_decl))
7755             {
7756               TREE_PUBLIC (decl) = 1;
7757               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7758             }
7759           else if (DECL_INITIAL (decl) == NULL_TREE
7760                    || DECL_INITIAL (decl) == error_mark_node)
7761             {
7762               TREE_PUBLIC (decl) = 1;
7763               DECL_COMMON (decl) = 1;
7764             }
7765           /* else we lose. We can only do this if we can use common,
7766              which we can't if it has been initialized.  */
7767
7768           if (!TREE_PUBLIC (decl))
7769             {
7770               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7771               cp_warning_at ("  you can work around this by removing the initializer", decl);
7772             }
7773         }
7774       else
7775         comdat_linkage (decl);
7776     }
7777   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7778     /* Set it up again; we might have set DECL_INITIAL since the last
7779        time.  */
7780     comdat_linkage (decl);
7781 }
7782
7783 /* Issue an error message if DECL is an uninitialized const variable.  */
7784
7785 static void
7786 check_for_uninitialized_const_var (decl)
7787      tree decl;
7788 {
7789   tree type = TREE_TYPE (decl);
7790
7791   /* ``Unless explicitly declared extern, a const object does not have
7792      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7793      7.1.6 */
7794   if (TREE_CODE (decl) == VAR_DECL
7795       && TREE_CODE (type) != REFERENCE_TYPE
7796       && CP_TYPE_CONST_P (type)
7797       && !TYPE_NEEDS_CONSTRUCTING (type)
7798       && !DECL_INITIAL (decl))
7799     error ("uninitialized const `%D'", decl);
7800 }
7801
7802 /* Verify INIT (the initializer for DECL), and record the
7803    initialization in DECL_INITIAL, if appropriate.  Returns a new
7804    value for INIT.  */
7805
7806 static tree
7807 check_initializer (decl, init)
7808      tree decl;
7809      tree init;
7810 {
7811   tree type;
7812
7813   if (TREE_CODE (decl) == FIELD_DECL)
7814     return init;
7815
7816   type = TREE_TYPE (decl);
7817
7818   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7819   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7820     init = NULL_TREE;
7821
7822   /* Check the initializer.  */
7823   if (init)
7824     {
7825       /* Things that are going to be initialized need to have complete
7826          type.  */
7827       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7828
7829       if (type == error_mark_node)
7830         /* We will have already complained.  */
7831         init = NULL_TREE;
7832       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7833         {
7834           error ("variable-sized object `%D' may not be initialized", decl);
7835           init = NULL_TREE;
7836         }
7837       else if (TREE_CODE (type) == ARRAY_TYPE
7838                && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7839         {
7840           error ("elements of array `%#D' have incomplete type", decl);
7841           init = NULL_TREE;
7842         }
7843       else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7844         {
7845           error ("`%D' has incomplete type", decl);
7846           TREE_TYPE (decl) = error_mark_node;
7847           init = NULL_TREE;
7848         }
7849     }
7850
7851   if (TREE_CODE (decl) == CONST_DECL)
7852     {
7853       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7854
7855       DECL_INITIAL (decl) = init;
7856
7857       my_friendly_assert (init != NULL_TREE, 149);
7858       init = NULL_TREE;
7859     }
7860   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7861     {
7862       init = grok_reference_init (decl, type, init);
7863       if (init)
7864         init = obscure_complex_init (decl, init);
7865     }
7866   else if (!DECL_EXTERNAL (decl) && !zero_init_p (type))
7867     {
7868       force_store_init_value (decl, build_forced_zero_init (type));
7869
7870       if (init)
7871         goto process_init;
7872     }
7873   else if (init)
7874     {
7875     process_init:
7876       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7877         {
7878           if (TREE_CODE (type) == ARRAY_TYPE)
7879             init = digest_init (type, init, (tree *) 0);
7880           else if (TREE_CODE (init) == CONSTRUCTOR
7881                    && TREE_HAS_CONSTRUCTOR (init))
7882             {
7883               if (TYPE_NON_AGGREGATE_CLASS (type))
7884                 {
7885                   error ("`%D' must be initialized by constructor, not by `{...}'",
7886                             decl);
7887                   init = error_mark_node;
7888                 }
7889               else
7890                 goto dont_use_constructor;
7891             }
7892         }
7893       else
7894         {
7895         dont_use_constructor:
7896           if (TREE_CODE (init) != TREE_VEC)
7897             init = store_init_value (decl, init);
7898         }
7899
7900       if (init)
7901         /* We must hide the initializer so that expand_decl
7902            won't try to do something it does not understand.  */
7903         init = obscure_complex_init (decl, init);
7904     }
7905   else if (DECL_EXTERNAL (decl))
7906     ;
7907   else if (TYPE_P (type)
7908            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7909     {
7910       tree core_type = strip_array_types (type);
7911
7912       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7913         {
7914           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7915             error ("structure `%D' with uninitialized const members", decl);
7916           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7917             error ("structure `%D' with uninitialized reference members",
7918                       decl);
7919         }
7920
7921       check_for_uninitialized_const_var (decl);
7922
7923       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7924         init = obscure_complex_init (decl, NULL_TREE);
7925
7926     }
7927   else
7928     check_for_uninitialized_const_var (decl);
7929
7930   return init;
7931 }
7932
7933 /* If DECL is not a local variable, give it RTL.  */
7934
7935 static void
7936 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7937      tree decl;
7938      tree init;
7939      const char *asmspec;
7940 {
7941   int toplev = toplevel_bindings_p ();
7942   int defer_p;
7943
7944   /* Handle non-variables up front.  */
7945   if (TREE_CODE (decl) != VAR_DECL)
7946     {
7947       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7948       return;
7949     }
7950
7951   /* If we see a class member here, it should be a static data
7952      member.  */
7953   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7954     {
7955       my_friendly_assert (TREE_STATIC (decl), 19990828);
7956       /* An in-class declaration of a static data member should be
7957          external; it is only a declaration, and not a definition.  */
7958       if (init == NULL_TREE)
7959         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7960     }
7961
7962   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7963   if (asmspec)
7964     {
7965       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7966       /* The `register' keyword, when used together with an
7967          asm-specification, indicates that the variable should be
7968          placed in a particular register.  */
7969       if (DECL_REGISTER (decl))
7970         DECL_C_HARD_REGISTER (decl) = 1;
7971     }
7972
7973   /* We don't create any RTL for local variables.  */
7974   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7975     return;
7976
7977   /* We defer emission of local statics until the corresponding
7978      DECL_STMT is expanded.  */
7979   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7980
7981   /* We try to defer namespace-scope static constants so that they are
7982      not emitted into the object file unnecessarily.  */
7983   if (!DECL_VIRTUAL_P (decl)
7984       && TREE_READONLY (decl)
7985       && DECL_INITIAL (decl) != NULL_TREE
7986       && DECL_INITIAL (decl) != error_mark_node
7987       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7988       && toplev
7989       && !TREE_PUBLIC (decl))
7990     {
7991       /* Fool with the linkage of static consts according to #pragma
7992          interface.  */
7993       if (!interface_unknown && !TREE_PUBLIC (decl))
7994         {
7995           TREE_PUBLIC (decl) = 1;
7996           DECL_EXTERNAL (decl) = interface_only;
7997         }
7998
7999       defer_p = 1;
8000     }
8001   /* Likewise for template instantiations.  */
8002   else if (DECL_COMDAT (decl))
8003     defer_p = 1;
8004
8005   /* If we're deferring the variable, we only need to make RTL if
8006      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
8007      we need it.  (There's no way to lazily create RTL for things that
8008      have assembly specs because the information about the specifier
8009      isn't stored in the tree, yet)  */
8010   if (defer_p && asmspec)
8011     make_decl_rtl (decl, asmspec);
8012   /* If we're not deferring, go ahead and assemble the variable.  */
8013   else if (!defer_p)
8014     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8015 }
8016
8017 /* The old ARM scoping rules injected variables declared in the
8018    initialization statement of a for-statement into the surrounding
8019    scope.  We support this usage, in order to be backward-compatible.
8020    DECL is a just-declared VAR_DECL; if necessary inject its
8021    declaration into the surrounding scope.  */
8022
8023 void
8024 maybe_inject_for_scope_var (decl)
8025      tree decl;
8026 {
8027   if (!DECL_NAME (decl))
8028     return;
8029
8030   /* Declarations of __FUNCTION__ and its ilk appear magically when
8031      the variable is first used.  If that happens to be inside a
8032      for-loop, we don't want to do anything special.  */
8033   if (DECL_PRETTY_FUNCTION_P (decl))
8034     return;
8035
8036   if (current_binding_level->is_for_scope)
8037     {
8038       struct binding_level *outer
8039         = current_binding_level->level_chain;
8040
8041       /* Check to see if the same name is already bound at the outer
8042          level, either because it was directly declared, or because a
8043          dead for-decl got preserved.  In either case, the code would
8044          not have been valid under the ARM scope rules, so clear
8045          is_for_scope for the current_binding_level.
8046
8047          Otherwise, we need to preserve the temp slot for decl to last
8048          into the outer binding level.  */
8049
8050       tree outer_binding
8051         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8052
8053       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8054           && (TREE_CODE (BINDING_VALUE (outer_binding))
8055               == VAR_DECL)
8056           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8057         {
8058           BINDING_VALUE (outer_binding)
8059             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8060           current_binding_level->is_for_scope = 0;
8061         }
8062       else if (DECL_IN_MEMORY_P (decl))
8063         preserve_temp_slots (DECL_RTL (decl));
8064     }
8065 }
8066
8067 /* Generate code to initialize DECL (a local variable).  */
8068
8069 void
8070 initialize_local_var (decl, init, flags)
8071      tree decl;
8072      tree init;
8073      int flags;
8074 {
8075   tree type = TREE_TYPE (decl);
8076
8077   /* If the type is bogus, don't bother initializing the variable.  */
8078   if (type == error_mark_node)
8079     return;
8080
8081   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
8082     {
8083       /* If we used it already as memory, it must stay in memory.  */
8084       DECL_INITIAL (decl) = NULL_TREE;
8085       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8086     }
8087
8088   /* Local statics are handled differently from ordinary automatic
8089      variables.  */
8090   if (TREE_STATIC (decl))
8091     {
8092       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8093           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8094         expand_static_init (decl, init);
8095       return;
8096     }
8097
8098   if (DECL_SIZE (decl) && type != error_mark_node)
8099     {
8100       int already_used;
8101
8102       /* Compute and store the initial value.  */
8103       already_used = TREE_USED (decl) || TREE_USED (type);
8104
8105       if (init || TYPE_NEEDS_CONSTRUCTING (type))
8106         {
8107           int saved_stmts_are_full_exprs_p;
8108
8109           my_friendly_assert (building_stmt_tree (), 20000906);
8110           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8111           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8112           finish_expr_stmt (build_aggr_init (decl, init, flags));
8113           current_stmt_tree ()->stmts_are_full_exprs_p =
8114             saved_stmts_are_full_exprs_p;
8115         }
8116
8117       /* Set this to 0 so we can tell whether an aggregate which was
8118          initialized was ever used.  Don't do this if it has a
8119          destructor, so we don't complain about the 'resource
8120          allocation is initialization' idiom.  Now set
8121          attribute((unused)) on types so decls of that type will be
8122          marked used. (see TREE_USED, above.)  */
8123       if (TYPE_NEEDS_CONSTRUCTING (type)
8124           && ! already_used
8125           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8126           && DECL_NAME (decl))
8127         TREE_USED (decl) = 0;
8128       else if (already_used)
8129         TREE_USED (decl) = 1;
8130     }
8131 }
8132
8133 /* Generate code to destroy DECL (a local variable).  */
8134
8135 static void
8136 destroy_local_var (decl)
8137      tree decl;
8138 {
8139   tree type = TREE_TYPE (decl);
8140   tree cleanup;
8141
8142   /* Only variables get cleaned up.  */
8143   if (TREE_CODE (decl) != VAR_DECL)
8144     return;
8145
8146   /* And only things with destructors need cleaning up.  */
8147   if (type == error_mark_node
8148       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8149     return;
8150
8151   if (TREE_CODE (decl) == VAR_DECL &&
8152       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8153     /* We don't clean up things that aren't defined in this
8154        translation unit, or that need a static cleanup.  The latter
8155        are handled by finish_file.  */
8156     return;
8157
8158   /* Compute the cleanup.  */
8159   cleanup = maybe_build_cleanup (decl);
8160
8161   /* Record the cleanup required for this declaration.  */
8162   if (DECL_SIZE (decl) && cleanup)
8163     finish_decl_cleanup (decl, cleanup);
8164 }
8165
8166 /* Finish processing of a declaration;
8167    install its line number and initial value.
8168    If the length of an array type is not known before,
8169    it must be determined now, from the initial value, or it is an error.
8170
8171    INIT holds the value of an initializer that should be allowed to escape
8172    the normal rules.
8173
8174    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8175    if the (init) syntax was used.  */
8176
8177 void
8178 cp_finish_decl (decl, init, asmspec_tree, flags)
8179      tree decl, init;
8180      tree asmspec_tree;
8181      int flags;
8182 {
8183   register tree type;
8184   tree ttype = NULL_TREE;
8185   const char *asmspec = NULL;
8186   int was_readonly = 0;
8187
8188   if (! decl)
8189     {
8190       if (init)
8191         error ("assignment (not initialization) in declaration");
8192       return;
8193     }
8194
8195   /* If a name was specified, get the string.  */
8196   if (current_binding_level == global_binding_level)
8197     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8198   if (asmspec_tree)
8199     asmspec = TREE_STRING_POINTER (asmspec_tree);
8200
8201   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8202     {
8203       error ("cannot initialize `%D' to namespace `%D'",
8204                 decl, init);
8205       init = NULL_TREE;
8206     }
8207
8208   if (current_class_type
8209       && CP_DECL_CONTEXT (decl) == current_class_type
8210       && TYPE_BEING_DEFINED (current_class_type)
8211       && (DECL_INITIAL (decl) || init))
8212     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8213
8214   if (TREE_CODE (decl) == VAR_DECL
8215       && DECL_CONTEXT (decl)
8216       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8217       && DECL_CONTEXT (decl) != current_namespace
8218       && init)
8219     {
8220       /* Leave the namespace of the object. */
8221       pop_decl_namespace ();
8222     }
8223
8224   type = TREE_TYPE (decl);
8225
8226   if (type == error_mark_node)
8227     return;
8228
8229   if (TYPE_HAS_MUTABLE_P (type))
8230     TREE_READONLY (decl) = 0;
8231
8232   if (processing_template_decl)
8233     {
8234       /* Add this declaration to the statement-tree.  */
8235       if (at_function_scope_p ()
8236           && TREE_CODE (decl) != RESULT_DECL)
8237         add_decl_stmt (decl);
8238
8239       if (init && DECL_INITIAL (decl))
8240         DECL_INITIAL (decl) = init;
8241       goto finish_end0;
8242     }
8243
8244   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8245   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8246
8247   /* Take care of TYPE_DECLs up front.  */
8248   if (TREE_CODE (decl) == TYPE_DECL)
8249     {
8250       if (type != error_mark_node
8251           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8252         {
8253           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8254             warning ("shadowing previous type declaration of `%#D'", decl);
8255           set_identifier_type_value (DECL_NAME (decl), type);
8256           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8257         }
8258
8259       /* If we have installed this as the canonical typedef for this
8260          type, and that type has not been defined yet, delay emitting
8261          the debug information for it, as we will emit it later.  */
8262       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8263           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8264         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8265
8266       rest_of_decl_compilation (decl, NULL,
8267                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8268       goto finish_end;
8269     }
8270
8271   if (TREE_CODE (decl) != FUNCTION_DECL)
8272     ttype = target_type (type);
8273
8274   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8275       && TYPE_NEEDS_CONSTRUCTING (type))
8276     {
8277       /* Currently, GNU C++ puts constants in text space, making them
8278          impossible to initialize.  In the future, one would hope for
8279          an operating system which understood the difference between
8280          initialization and the running of a program.  */
8281       was_readonly = 1;
8282       TREE_READONLY (decl) = 0;
8283     }
8284
8285   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8286     {
8287       /* This must override the asm specifier which was placed by
8288          grokclassfn.  Lay this out fresh.  */
8289       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8290       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8291       make_decl_rtl (decl, asmspec);
8292     }
8293
8294   /* Deduce size of array from initialization, if not already known.  */
8295   init = check_initializer (decl, init);
8296   maybe_deduce_size_from_array_init (decl, init);
8297
8298   /* Add this declaration to the statement-tree.  This needs to happen
8299      after the call to check_initializer so that the DECL_STMT for a
8300      reference temp is added before the DECL_STMT for the reference itself.  */
8301   if (building_stmt_tree ()
8302       && at_function_scope_p ()
8303       && TREE_CODE (decl) != RESULT_DECL)
8304     add_decl_stmt (decl);
8305
8306   if (TREE_CODE (decl) == VAR_DECL)
8307     layout_var_decl (decl);
8308
8309   /* Output the assembler code and/or RTL code for variables and functions,
8310      unless the type is an undefined structure or union.
8311      If not, it will get done when the type is completed.  */
8312   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8313       || TREE_CODE (decl) == RESULT_DECL)
8314     {
8315       if (TREE_CODE (decl) == VAR_DECL)
8316         maybe_commonize_var (decl);
8317
8318       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8319
8320       if (TREE_CODE (type) == FUNCTION_TYPE
8321           || TREE_CODE (type) == METHOD_TYPE)
8322         abstract_virtuals_error (decl,
8323                                  strip_array_types (TREE_TYPE (type)));
8324       else
8325         abstract_virtuals_error (decl, strip_array_types (type));
8326
8327       if (TREE_CODE (decl) == FUNCTION_DECL)
8328         ;
8329       else if (DECL_EXTERNAL (decl)
8330                && ! (DECL_LANG_SPECIFIC (decl)
8331                      && DECL_NOT_REALLY_EXTERN (decl)))
8332         {
8333           if (init)
8334             DECL_INITIAL (decl) = init;
8335         }
8336       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8337         {
8338           /* This is a local declaration.  */
8339           if (doing_semantic_analysis_p ())
8340             maybe_inject_for_scope_var (decl);
8341           /* Initialize the local variable.  But, if we're building a
8342              statement-tree, we'll do the initialization when we
8343              expand the tree.  */
8344           if (processing_template_decl)
8345             {
8346               if (init || DECL_INITIAL (decl) == error_mark_node)
8347                 DECL_INITIAL (decl) = init;
8348             }
8349           else
8350             {
8351               /* If we're not building RTL, then we need to do so
8352                  now.  */
8353               my_friendly_assert (building_stmt_tree (), 20000906);
8354               /* Initialize the variable.  */
8355               initialize_local_var (decl, init, flags);
8356               /* Clean up the variable.  */
8357               destroy_local_var (decl);
8358             }
8359         }
8360       else if (TREE_STATIC (decl) && type != error_mark_node)
8361         {
8362           /* Cleanups for static variables are handled by `finish_file'.  */
8363           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8364               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8365             expand_static_init (decl, init);
8366         }
8367     finish_end0:
8368
8369       /* Undo call to `pushclass' that was done in `start_decl'
8370          due to initialization of qualified member variable.
8371          I.e., Foo::x = 10;  */
8372       {
8373         tree context = CP_DECL_CONTEXT (decl);
8374         if (context
8375             && TYPE_P (context)
8376             && (TREE_CODE (decl) == VAR_DECL
8377                 /* We also have a pushclass done that we need to undo here
8378                    if we're at top level and declare a method.  */
8379                 || TREE_CODE (decl) == FUNCTION_DECL)
8380             /* If size hasn't been set, we're still defining it,
8381                and therefore inside the class body; don't pop
8382                the binding level..  */
8383             && COMPLETE_TYPE_P (context)
8384             && context == current_class_type)
8385           pop_nested_class ();
8386       }
8387     }
8388
8389  finish_end:
8390
8391   if (was_readonly)
8392     TREE_READONLY (decl) = 1;
8393 }
8394
8395 /* This is here for a midend callback from c-common.c */
8396
8397 void
8398 finish_decl (decl, init, asmspec_tree)
8399      tree decl, init;
8400      tree asmspec_tree;
8401 {
8402   cp_finish_decl (decl, init, asmspec_tree, 0);
8403 }
8404
8405 /* Returns a declaration for a VAR_DECL as if:
8406
8407      extern "C" TYPE NAME;
8408
8409    had been seen.  Used to create compiler-generated global
8410    variables.  */
8411
8412 tree
8413 declare_global_var (name, type)
8414      tree name;
8415      tree type;
8416 {
8417   tree decl;
8418
8419   push_to_top_level ();
8420   decl = build_decl (VAR_DECL, name, type);
8421   TREE_PUBLIC (decl) = 1;
8422   DECL_EXTERNAL (decl) = 1;
8423   DECL_ARTIFICIAL (decl) = 1;
8424   pushdecl (decl);
8425   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8426   pop_from_top_level ();
8427
8428   return decl;
8429 }
8430
8431 /* Returns a pointer to the `atexit' function.  Note that if
8432    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8433    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8434
8435 static tree
8436 get_atexit_node ()
8437 {
8438   tree atexit_fndecl;
8439   tree arg_types;
8440   tree fn_type;
8441   tree fn_ptr_type;
8442   const char *name;
8443
8444   if (atexit_node)
8445     return atexit_node;
8446
8447   if (flag_use_cxa_atexit)
8448     {
8449       /* The declaration for `__cxa_atexit' is:
8450
8451            int __cxa_atexit (void (*)(void *), void *, void *)
8452
8453          We build up the argument types and then then function type
8454          itself.  */
8455
8456       /* First, build the pointer-to-function type for the first
8457          argument.  */
8458       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8459       fn_type = build_function_type (void_type_node, arg_types);
8460       fn_ptr_type = build_pointer_type (fn_type);
8461       /* Then, build the rest of the argument types.  */
8462       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8463       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8464       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8465       /* And the final __cxa_atexit type.  */
8466       fn_type = build_function_type (integer_type_node, arg_types);
8467       fn_ptr_type = build_pointer_type (fn_type);
8468       name = "__cxa_atexit";
8469     }
8470   else
8471     {
8472       /* The declaration for `atexit' is:
8473
8474            int atexit (void (*)());
8475
8476          We build up the argument types and then then function type
8477          itself.  */
8478       fn_type = build_function_type (void_type_node, void_list_node);
8479       fn_ptr_type = build_pointer_type (fn_type);
8480       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8481       /* Build the final atexit type.  */
8482       fn_type = build_function_type (integer_type_node, arg_types);
8483       name = "atexit";
8484     }
8485
8486   /* Now, build the function declaration.  */
8487   push_lang_context (lang_name_c);
8488   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8489   mark_used (atexit_fndecl);
8490   pop_lang_context ();
8491   atexit_node = default_conversion (atexit_fndecl);
8492
8493   return atexit_node;
8494 }
8495
8496 /* Returns the __dso_handle VAR_DECL.  */
8497
8498 static tree
8499 get_dso_handle_node ()
8500 {
8501   if (dso_handle_node)
8502     return dso_handle_node;
8503
8504   /* Declare the variable.  */
8505   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8506                                         ptr_type_node);
8507
8508   return dso_handle_node;
8509 }
8510
8511 /* Begin a new function with internal linkage whose job will be simply
8512    to destroy some particular variable.  */
8513
8514 static tree
8515 start_cleanup_fn ()
8516 {
8517   static int counter = 0;
8518   int old_interface_only = interface_only;
8519   int old_interface_unknown = interface_unknown;
8520   char name[32];
8521   tree parmtypes;
8522   tree fntype;
8523   tree fndecl;
8524
8525   push_to_top_level ();
8526
8527   /* No need to mangle this.  */
8528   push_lang_context (lang_name_c);
8529
8530   interface_only = 0;
8531   interface_unknown = 1;
8532
8533   /* Build the parameter-types.  */
8534   parmtypes = void_list_node;
8535   /* Functions passed to __cxa_atexit take an additional parameter.
8536      We'll just ignore it.  After we implement the new calling
8537      convention for destructors, we can eliminate the use of
8538      additional cleanup functions entirely in the -fnew-abi case.  */
8539   if (flag_use_cxa_atexit)
8540     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8541   /* Build the function type itself.  */
8542   fntype = build_function_type (void_type_node, parmtypes);
8543   /* Build the name of the function.  */
8544   sprintf (name, "__tcf_%d", counter++);
8545   /* Build the function declaration.  */
8546   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8547   /* It's a function with internal linkage, generated by the
8548      compiler.  */
8549   TREE_PUBLIC (fndecl) = 0;
8550   DECL_ARTIFICIAL (fndecl) = 1;
8551   /* Make the function `inline' so that it is only emitted if it is
8552      actually needed.  It is unlikely that it will be inlined, since
8553      it is only called via a function pointer, but we avoid unnecessary
8554      emissions this way.  */
8555   DECL_INLINE (fndecl) = 1;
8556   /* Build the parameter.  */
8557   if (flag_use_cxa_atexit)
8558     {
8559       tree parmdecl;
8560
8561       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8562       DECL_CONTEXT (parmdecl) = fndecl;
8563       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8564       TREE_USED (parmdecl) = 1;
8565       DECL_ARGUMENTS (fndecl) = parmdecl;
8566     }
8567
8568   pushdecl (fndecl);
8569   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8570
8571   interface_unknown = old_interface_unknown;
8572   interface_only = old_interface_only;
8573
8574   pop_lang_context ();
8575
8576   return current_function_decl;
8577 }
8578
8579 /* Finish the cleanup function begun by start_cleanup_fn.  */
8580
8581 static void
8582 end_cleanup_fn ()
8583 {
8584   expand_body (finish_function (0));
8585
8586   pop_from_top_level ();
8587 }
8588
8589 /* Generate code to handle the destruction of DECL, an object with
8590    static storage duration.  */
8591
8592 void
8593 register_dtor_fn (decl)
8594      tree decl;
8595 {
8596   tree cleanup;
8597   tree compound_stmt;
8598   tree args;
8599   tree fcall;
8600
8601   int saved_flag_access_control;
8602
8603   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8604     return;
8605
8606   /* Call build_cleanup before we enter the anonymous function so that
8607      any access checks will be done relative to the current scope,
8608      rather than the scope of the anonymous function.  */
8609   build_cleanup (decl);
8610
8611   /* Now start the function.  */
8612   cleanup = start_cleanup_fn ();
8613
8614   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8615      to the original function, rather than the anonymous one.  That
8616      will make the back-end think that nested functions are in use,
8617      which causes confusion.  */
8618   saved_flag_access_control = flag_access_control;
8619   flag_access_control = 0;
8620   fcall = build_cleanup (decl);
8621   flag_access_control = saved_flag_access_control;
8622
8623   /* Create the body of the anonymous function.  */
8624   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8625   finish_expr_stmt (fcall);
8626   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8627   end_cleanup_fn ();
8628
8629   /* Call atexit with the cleanup function.  */
8630   mark_addressable (cleanup);
8631   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8632   if (flag_use_cxa_atexit)
8633     {
8634       args = tree_cons (NULL_TREE,
8635                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8636                         NULL_TREE);
8637       args = tree_cons (NULL_TREE, null_pointer_node, args);
8638       args = tree_cons (NULL_TREE, cleanup, args);
8639     }
8640   else
8641     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8642   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8643 }
8644
8645 void
8646 expand_static_init (decl, init)
8647      tree decl;
8648      tree init;
8649 {
8650   tree oldstatic = value_member (decl, static_aggregates);
8651
8652   if (oldstatic)
8653     {
8654       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8655         error ("multiple initializations given for `%D'", decl);
8656     }
8657   else if (! toplevel_bindings_p ())
8658     {
8659       /* Emit code to perform this initialization but once.  */
8660       tree if_stmt;
8661       tree then_clause;
8662       tree assignment;
8663       tree guard;
8664       tree guard_init;
8665
8666       /* Emit code to perform this initialization but once.  This code
8667          looks like:
8668
8669            static int guard = 0;
8670            if (!guard) {
8671              // Do initialization.
8672              guard = 1;
8673              // Register variable for destruction at end of program.
8674            }
8675
8676          Note that the `temp' variable is only set to 1 *after* the
8677          initialization is complete.  This ensures that an exception,
8678          thrown during the construction, will cause the variable to
8679          reinitialized when we pass through this code again, as per:
8680
8681            [stmt.dcl]
8682
8683            If the initialization exits by throwing an exception, the
8684            initialization is not complete, so it will be tried again
8685            the next time control enters the declaration.
8686
8687          In theory, this process should be thread-safe, too; multiple
8688          threads should not be able to initialize the variable more
8689          than once.  We don't yet attempt to ensure thread-safety.  */
8690
8691       /* Create the guard variable.  */
8692       guard = get_guard (decl);
8693
8694       /* Begin the conditional initialization.  */
8695       if_stmt = begin_if_stmt ();
8696       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8697       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8698
8699       /* Do the initialization itself.  */
8700       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8701           || (init && TREE_CODE (init) == TREE_LIST))
8702         assignment = build_aggr_init (decl, init, 0);
8703       else if (init)
8704         /* The initialization we're doing here is just a bitwise
8705            copy.  */
8706         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8707       else
8708         assignment = NULL_TREE;
8709
8710       /* Once the assignment is complete, set TEMP to 1.  Since the
8711          construction of the static object is complete at this point,
8712          we want to make sure TEMP is set to 1 even if a temporary
8713          constructed during the initialization throws an exception
8714          when it is destroyed.  So, we combine the initialization and
8715          the assignment to TEMP into a single expression, ensuring
8716          that when we call finish_expr_stmt the cleanups will not be
8717          run until after TEMP is set to 1.  */
8718       guard_init = set_guard (guard);
8719       if (assignment)
8720         {
8721           assignment = tree_cons (NULL_TREE, assignment,
8722                                   build_tree_list (NULL_TREE,
8723                                                    guard_init));
8724           assignment = build_compound_expr (assignment);
8725         }
8726       else
8727         assignment = guard_init;
8728       finish_expr_stmt (assignment);
8729
8730       /* Use atexit to register a function for destroying this static
8731          variable.  */
8732       register_dtor_fn (decl);
8733
8734       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8735       finish_then_clause (if_stmt);
8736       finish_if_stmt ();
8737     }
8738   else
8739     static_aggregates = tree_cons (init, decl, static_aggregates);
8740 }
8741
8742 /* Finish the declaration of a catch-parameter.  */
8743
8744 tree
8745 start_handler_parms (declspecs, declarator)
8746      tree declspecs;
8747      tree declarator;
8748 {
8749   tree decl;
8750   if (declspecs)
8751     {
8752       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8753                              1, NULL);
8754       if (decl == NULL_TREE)
8755         error ("invalid catch parameter");
8756     }
8757   else
8758     decl = NULL_TREE;
8759
8760   return decl;
8761 }
8762
8763 \f
8764 /* Make TYPE a complete type based on INITIAL_VALUE.
8765    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8766    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8767
8768 int
8769 complete_array_type (type, initial_value, do_default)
8770      tree type, initial_value;
8771      int do_default;
8772 {
8773   register tree maxindex = NULL_TREE;
8774   int value = 0;
8775
8776   if (initial_value)
8777     {
8778       /* An array of character type can be initialized from a
8779          brace-enclosed string constant.  */
8780       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8781           && TREE_CODE (initial_value) == CONSTRUCTOR
8782           && CONSTRUCTOR_ELTS (initial_value)
8783           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8784               == STRING_CST)
8785           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8786         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8787
8788       /* Note MAXINDEX is really the maximum index, one less than the
8789          size.  */
8790       if (TREE_CODE (initial_value) == STRING_CST)
8791         {
8792           int eltsize
8793             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8794           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8795                                    / eltsize) - 1, 0);
8796         }
8797       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8798         {
8799           tree elts = CONSTRUCTOR_ELTS (initial_value);
8800
8801           maxindex = ssize_int (-1);
8802           for (; elts; elts = TREE_CHAIN (elts))
8803             {
8804               if (TREE_PURPOSE (elts))
8805                 maxindex = TREE_PURPOSE (elts);
8806               else
8807                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8808             }
8809           maxindex = copy_node (maxindex);
8810         }
8811       else
8812         {
8813           /* Make an error message unless that happened already.  */
8814           if (initial_value != error_mark_node)
8815             value = 1;
8816           else
8817             initial_value = NULL_TREE;
8818
8819           /* Prevent further error messages.  */
8820           maxindex = build_int_2 (0, 0);
8821         }
8822     }
8823
8824   if (!maxindex)
8825     {
8826       if (do_default)
8827         maxindex = build_int_2 (0, 0);
8828       value = 2;
8829     }
8830
8831   if (maxindex)
8832     {
8833       tree itype;
8834       tree domain;
8835
8836       domain = build_index_type (maxindex);
8837       TYPE_DOMAIN (type) = domain;
8838
8839       if (! TREE_TYPE (maxindex))
8840         TREE_TYPE (maxindex) = domain;
8841       if (initial_value)
8842         itype = TREE_TYPE (initial_value);
8843       else
8844         itype = NULL;
8845       if (itype && !TYPE_DOMAIN (itype))
8846         TYPE_DOMAIN (itype) = domain;
8847       /* The type of the main variant should never be used for arrays
8848          of different sizes.  It should only ever be completed with the
8849          size of the array.  */
8850       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8851         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8852     }
8853
8854   /* Lay out the type now that we can get the real answer.  */
8855
8856   layout_type (type);
8857
8858   return value;
8859 }
8860 \f
8861 /* Return zero if something is declared to be a member of type
8862    CTYPE when in the context of CUR_TYPE.  STRING is the error
8863    message to print in that case.  Otherwise, quietly return 1.  */
8864
8865 static int
8866 member_function_or_else (ctype, cur_type, flags)
8867      tree ctype, cur_type;
8868      enum overload_flags flags;
8869 {
8870   if (ctype && ctype != cur_type)
8871     {
8872       if (flags == DTOR_FLAG)
8873         error ("destructor for alien class `%T' cannot be a member",
8874                   ctype);
8875       else
8876         error ("constructor for alien class `%T' cannot be a member",
8877                   ctype);
8878       return 0;
8879     }
8880   return 1;
8881 }
8882 \f
8883 /* Subroutine of `grokdeclarator'.  */
8884
8885 /* Generate errors possibly applicable for a given set of specifiers.
8886    This is for ARM $7.1.2.  */
8887
8888 static void
8889 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8890      tree object;
8891      const char *type;
8892      int virtualp, quals, friendp, raises, inlinep;
8893 {
8894   if (virtualp)
8895     error ("`%D' declared as a `virtual' %s", object, type);
8896   if (inlinep)
8897     error ("`%D' declared as an `inline' %s", object, type);
8898   if (quals)
8899     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8900               object, type);
8901   if (friendp)
8902     cp_error_at ("`%D' declared as a friend", object);
8903   if (raises
8904       && (TREE_CODE (object) == TYPE_DECL
8905           || (!TYPE_PTRFN_P (TREE_TYPE (object))
8906               && !TYPE_REFFN_P (TREE_TYPE (object))
8907               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8908     cp_error_at ("`%D' declared with an exception specification", object);
8909 }
8910
8911 /* CTYPE is class type, or null if non-class.
8912    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8913    or METHOD_TYPE.
8914    DECLARATOR is the function's name.
8915    VIRTUALP is truthvalue of whether the function is virtual or not.
8916    FLAGS are to be passed through to `grokclassfn'.
8917    QUALS are qualifiers indicating whether the function is `const'
8918    or `volatile'.
8919    RAISES is a list of exceptions that this function can raise.
8920    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8921    not look, and -1 if we should not call `grokclassfn' at all.
8922
8923    Returns `NULL_TREE' if something goes wrong, after issuing
8924    applicable error messages.  */
8925
8926 static tree
8927 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8928             raises, check, friendp, publicp, inlinep, funcdef_flag,
8929             template_count, in_namespace)
8930      tree ctype, type;
8931      tree declarator;
8932      tree orig_declarator;
8933      int virtualp;
8934      enum overload_flags flags;
8935      tree quals, raises;
8936      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8937      tree in_namespace;
8938 {
8939   tree decl;
8940   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8941   int has_default_arg = 0;
8942   tree t;
8943
8944   if (raises)
8945     type = build_exception_variant (type, raises);
8946
8947   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8948   /* Propagate volatile out from type to decl. */
8949   if (TYPE_VOLATILE (type))
8950     TREE_THIS_VOLATILE (decl) = 1;
8951
8952   /* If this decl has namespace scope, set that up.  */
8953   if (in_namespace)
8954     set_decl_namespace (decl, in_namespace, friendp);
8955   else if (!ctype)
8956     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8957
8958   /* `main' and builtins have implicit 'C' linkage.  */
8959   if ((MAIN_NAME_P (declarator)
8960        || (IDENTIFIER_LENGTH (declarator) > 10
8961            && IDENTIFIER_POINTER (declarator)[0] == '_'
8962            && IDENTIFIER_POINTER (declarator)[1] == '_'
8963            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8964       && current_lang_name == lang_name_cplusplus
8965       && ctype == NULL_TREE
8966       /* NULL_TREE means global namespace.  */
8967       && DECL_CONTEXT (decl) == NULL_TREE)
8968     SET_DECL_LANGUAGE (decl, lang_c);
8969
8970   /* Should probably propagate const out from type to decl I bet (mrs).  */
8971   if (staticp)
8972     {
8973       DECL_STATIC_FUNCTION_P (decl) = 1;
8974       DECL_CONTEXT (decl) = ctype;
8975     }
8976
8977   if (ctype)
8978     DECL_CONTEXT (decl) = ctype;
8979
8980   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8981     {
8982       if (processing_template_decl)
8983         error ("cannot declare `::main' to be a template");
8984       if (inlinep)
8985         error ("cannot declare `::main' to be inline");
8986       if (!publicp)
8987         error ("cannot declare `::main' to be static");
8988       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8989                         integer_type_node))
8990         error ("`main' must return `int'");
8991       inlinep = 0;
8992       publicp = 1;
8993     }
8994
8995   /* Members of anonymous types and local classes have no linkage; make
8996      them internal.  */
8997   /* FIXME what if it gets a name from typedef?  */
8998   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8999                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
9000     publicp = 0;
9001
9002   if (publicp)
9003     {
9004       /* [basic.link]: A name with no linkage (notably, the name of a class
9005          or enumeration declared in a local scope) shall not be used to
9006          declare an entity with linkage.
9007
9008          Only check this for public decls for now.  */
9009       t = no_linkage_check (TREE_TYPE (decl));
9010       if (t)
9011         {
9012           if (TYPE_ANONYMOUS_P (t))
9013             {
9014               if (DECL_EXTERN_C_P (decl))
9015                 /* Allow this; it's pretty common in C.  */;
9016               else
9017                 {
9018                   pedwarn ("non-local function `%#D' uses anonymous type",
9019                               decl);
9020                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
9021                     cp_pedwarn_at ("\
9022 `%#D' does not refer to the unqualified type, so it is not used for linkage",
9023                                 TYPE_NAME (t));
9024                 }
9025             }
9026           else
9027             pedwarn ("non-local function `%#D' uses local type `%T'",
9028                         decl, t);
9029         }
9030     }
9031
9032   TREE_PUBLIC (decl) = publicp;
9033   if (! publicp)
9034     {
9035       DECL_INTERFACE_KNOWN (decl) = 1;
9036       DECL_NOT_REALLY_EXTERN (decl) = 1;
9037     }
9038
9039   /* If the declaration was declared inline, mark it as such.  */
9040   if (inlinep)
9041     DECL_DECLARED_INLINE_P (decl) = 1;
9042   /* We inline functions that are explicitly declared inline, or, when
9043      the user explicitly asks us to, all functions.  */
9044   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
9045     DECL_INLINE (decl) = 1;
9046
9047   DECL_EXTERNAL (decl) = 1;
9048   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9049     {
9050       error ("%smember function `%D' cannot have `%T' method qualifier",
9051                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9052       quals = NULL_TREE;
9053     }
9054
9055   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9056     grok_op_properties (decl, friendp);
9057
9058   if (ctype && decl_function_context (decl))
9059     DECL_NO_STATIC_CHAIN (decl) = 1;
9060
9061   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9062     if (TREE_PURPOSE (t)
9063         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9064       {
9065         has_default_arg = 1;
9066         break;
9067       }
9068
9069   if (friendp
9070       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9071     {
9072       if (funcdef_flag)
9073         error
9074           ("defining explicit specialization `%D' in friend declaration",
9075            orig_declarator);
9076       else
9077         {
9078           tree fns = TREE_OPERAND (orig_declarator, 0);
9079           tree args = TREE_OPERAND (orig_declarator, 1);
9080
9081           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9082             {
9083               /* Something like `template <class T> friend void f<T>()'.  */
9084               error ("invalid use of template-id `%D' in declaration of primary template",
9085                         orig_declarator);
9086               return NULL_TREE;
9087             }
9088
9089
9090           /* A friend declaration of the form friend void f<>().  Record
9091              the information in the TEMPLATE_ID_EXPR.  */
9092           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9093
9094           if (TREE_CODE (fns) == COMPONENT_REF)
9095             {
9096               /* Due to bison parser ickiness, we will have already looked
9097                  up an operator_name or PFUNCNAME within the current class
9098                  (see template_id in parse.y). If the current class contains
9099                  such a name, we'll get a COMPONENT_REF here. Undo that. */
9100
9101               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9102                                   == current_class_type, 20001120);
9103               fns = TREE_OPERAND (fns, 1);
9104             }
9105           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9106                               || TREE_CODE (fns) == LOOKUP_EXPR
9107                               || TREE_CODE (fns) == OVERLOAD, 20001120);
9108           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9109
9110           if (has_default_arg)
9111             {
9112               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9113                         decl);
9114               return NULL_TREE;
9115             }
9116
9117           if (inlinep)
9118             {
9119               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9120                         decl);
9121               return NULL_TREE;
9122             }
9123         }
9124     }
9125
9126   if (has_default_arg)
9127     add_defarg_fn (decl);
9128
9129   if (funcdef_flag)
9130     /* Make the init_value nonzero so pushdecl knows this is not
9131        tentative.  error_mark_node is replaced later with the BLOCK.  */
9132     DECL_INITIAL (decl) = error_mark_node;
9133
9134   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9135     TREE_NOTHROW (decl) = 1;
9136
9137   /* Caller will do the rest of this.  */
9138   if (check < 0)
9139     return decl;
9140
9141   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
9142     DECL_CONSTRUCTOR_P (decl) = 1;
9143
9144   /* Function gets the ugly name, field gets the nice one.  This call
9145      may change the type of the function (because of default
9146      parameters)!  */
9147   if (ctype != NULL_TREE)
9148     grokclassfn (ctype, decl, flags, quals);
9149
9150   decl = check_explicit_specialization (orig_declarator, decl,
9151                                         template_count,
9152                                         2 * (funcdef_flag != 0) +
9153                                         4 * (friendp != 0));
9154   if (decl == error_mark_node)
9155     return NULL_TREE;
9156
9157   if (ctype != NULL_TREE
9158       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9159       && check)
9160     {
9161       tree old_decl;
9162
9163       old_decl = check_classfn (ctype, decl);
9164
9165       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9166         /* Because grokfndecl is always supposed to return a
9167            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9168            here.  We depend on our callers to figure out that its
9169            really a template that's being returned.  */
9170         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9171
9172       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9173           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9174         {
9175           /* Remove the `this' parm added by grokclassfn.
9176              XXX Isn't this done in start_function, too?  */
9177           revert_static_member_fn (decl);
9178           last_function_parms = TREE_CHAIN (last_function_parms);
9179         }
9180       if (old_decl && DECL_ARTIFICIAL (old_decl))
9181         error ("definition of implicitly-declared `%D'", old_decl);
9182
9183       if (old_decl)
9184         {
9185           /* Since we've smashed OLD_DECL to its
9186              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9187           if (TREE_CODE (decl) == TEMPLATE_DECL)
9188             decl = DECL_TEMPLATE_RESULT (decl);
9189
9190           /* Attempt to merge the declarations.  This can fail, in
9191              the case of some illegal specialization declarations.  */
9192           if (!duplicate_decls (decl, old_decl))
9193             error ("no `%#D' member function declared in class `%T'",
9194                       decl, ctype);
9195           return old_decl;
9196         }
9197     }
9198
9199   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9200     return NULL_TREE;
9201
9202   if (ctype == NULL_TREE || check)
9203     return decl;
9204
9205   if (virtualp)
9206     DECL_VIRTUAL_P (decl) = 1;
9207
9208   return decl;
9209 }
9210
9211 static tree
9212 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9213      tree type;
9214      tree declarator;
9215      RID_BIT_TYPE *specbits_in;
9216      int initialized;
9217      int constp;
9218      tree in_namespace;
9219 {
9220   tree decl;
9221   RID_BIT_TYPE specbits;
9222
9223   specbits = *specbits_in;
9224
9225   if (TREE_CODE (type) == OFFSET_TYPE)
9226     {
9227       /* If you declare a static member so that it
9228          can be initialized, the code will reach here.  */
9229       tree basetype = TYPE_OFFSET_BASETYPE (type);
9230       type = TREE_TYPE (type);
9231       decl = build_lang_decl (VAR_DECL, declarator, type);
9232       DECL_CONTEXT (decl) = basetype;
9233     }
9234   else
9235     {
9236       tree context;
9237
9238       if (in_namespace)
9239         context = in_namespace;
9240       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9241         context = current_namespace;
9242       else
9243         context = NULL_TREE;
9244
9245       /* For namespace-scope variables, declared in a template, we
9246          need the full lang_decl.  The same is true for
9247          namespace-scope variables that do not have C++ language
9248          linkage.  */
9249       if (context
9250           && (processing_template_decl
9251               || current_lang_name != lang_name_cplusplus))
9252         decl = build_lang_decl (VAR_DECL, declarator, type);
9253       else
9254         decl = build_decl (VAR_DECL, declarator, type);
9255
9256       if (context)
9257         set_decl_namespace (decl, context, 0);
9258
9259       context = DECL_CONTEXT (decl);
9260       if (declarator && context && current_lang_name != lang_name_c)
9261         /* We can't mangle lazily here because we don't have any
9262            way to recover whether or not a variable was `extern
9263            "C"' later.  */
9264         mangle_decl (decl);
9265     }
9266
9267   if (in_namespace)
9268     set_decl_namespace (decl, in_namespace, 0);
9269
9270   if (RIDBIT_SETP (RID_EXTERN, specbits))
9271     {
9272       DECL_THIS_EXTERN (decl) = 1;
9273       DECL_EXTERNAL (decl) = !initialized;
9274     }
9275
9276   /* In class context, static means one per class,
9277      public access, and static storage.  */
9278   if (DECL_CLASS_SCOPE_P (decl))
9279     {
9280       TREE_PUBLIC (decl) = 1;
9281       TREE_STATIC (decl) = 1;
9282       DECL_EXTERNAL (decl) = 0;
9283     }
9284   /* At top level, either `static' or no s.c. makes a definition
9285      (perhaps tentative), and absence of `static' makes it public.  */
9286   else if (toplevel_bindings_p ())
9287     {
9288       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9289                             && (DECL_THIS_EXTERN (decl) || ! constp));
9290       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9291     }
9292   /* Not at top level, only `static' makes a static definition.  */
9293   else
9294     {
9295       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9296       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9297     }
9298
9299   if (TREE_PUBLIC (decl))
9300     {
9301       /* [basic.link]: A name with no linkage (notably, the name of a class
9302          or enumeration declared in a local scope) shall not be used to
9303          declare an entity with linkage.
9304
9305          Only check this for public decls for now.  */
9306       tree t = no_linkage_check (TREE_TYPE (decl));
9307       if (t)
9308         {
9309           if (TYPE_ANONYMOUS_P (t))
9310             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9311           else
9312             pedwarn ("non-local variable `%#D' uses local type `%T'",
9313                         decl, t);
9314         }
9315     }
9316
9317   return decl;
9318 }
9319
9320 /* Create and return a canonical pointer to member function type, for
9321    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9322
9323 tree
9324 build_ptrmemfunc_type (type)
9325      tree type;
9326 {
9327   tree fields[4];
9328   tree t;
9329   tree unqualified_variant = NULL_TREE;
9330
9331   if (type == error_mark_node)
9332     return type;
9333
9334   /* If a canonical type already exists for this type, use it.  We use
9335      this method instead of type_hash_canon, because it only does a
9336      simple equality check on the list of field members.  */
9337
9338   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9339     return t;
9340
9341   /* Make sure that we always have the unqualified pointer-to-member
9342      type first.  */
9343   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9344     unqualified_variant
9345       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9346
9347   t = make_aggr_type (RECORD_TYPE);
9348   /* Let the front-end know this is a pointer to member function...  */
9349   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9350   /* ... and not really an aggregate.  */
9351   SET_IS_AGGR_TYPE (t, 0);
9352
9353   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9354   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9355                           delta_type_node);
9356   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9357
9358   /* Zap out the name so that the back-end will give us the debugging
9359      information for this anonymous RECORD_TYPE.  */
9360   TYPE_NAME (t) = NULL_TREE;
9361
9362   /* If this is not the unqualified form of this pointer-to-member
9363      type, set the TYPE_MAIN_VARIANT for this type to be the
9364      unqualified type.  Since they are actually RECORD_TYPEs that are
9365      not variants of each other, we must do this manually.  */
9366   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9367     {
9368       t = build_qualified_type (t, cp_type_quals (type));
9369       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9370       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9371       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9372     }
9373
9374   /* Cache this pointer-to-member type so that we can find it again
9375      later.  */
9376   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9377
9378   /* Seems to be wanted.  */
9379   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9380
9381   return t;
9382 }
9383
9384 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9385    Check to see that the definition is valid.  Issue appropriate error
9386    messages.  Return 1 if the definition is particularly bad, or 0
9387    otherwise.  */
9388
9389 int
9390 check_static_variable_definition (decl, type)
9391      tree decl;
9392      tree type;
9393 {
9394   /* Motion 10 at San Diego: If a static const integral data member is
9395      initialized with an integral constant expression, the initializer
9396      may appear either in the declaration (within the class), or in
9397      the definition, but not both.  If it appears in the class, the
9398      member is a member constant.  The file-scope definition is always
9399      required.  */
9400   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9401     {
9402       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9403                 type);
9404       /* If we just return the declaration, crashes will sometimes
9405          occur.  We therefore return void_type_node, as if this was a
9406          friend declaration, to cause callers to completely ignore
9407          this declaration.  */
9408       return 1;
9409     }
9410   else if (!CP_TYPE_CONST_P (type))
9411     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9412               decl);
9413   else if (pedantic && !INTEGRAL_TYPE_P (type))
9414     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9415
9416   return 0;
9417 }
9418
9419 /* Given the SIZE (i.e., number of elements) in an array, compute an
9420    appropriate index type for the array.  If non-NULL, NAME is the
9421    name of the thing being declared.  */
9422
9423 tree
9424 compute_array_index_type (name, size)
9425      tree name;
9426      tree size;
9427 {
9428   tree itype;
9429
9430   /* If this involves a template parameter, it will be a constant at
9431      instantiation time, but we don't know what the value is yet.
9432      Even if no template parameters are involved, we may an expression
9433      that is not a constant; we don't even simplify `1 + 2' when
9434      processing a template.  */
9435   if (processing_template_decl)
9436     {
9437       /* Resolve a qualified reference to an enumerator or static
9438          const data member of ours.  */
9439       if (TREE_CODE (size) == SCOPE_REF
9440           && TREE_OPERAND (size, 0) == current_class_type)
9441         {
9442           tree t = lookup_field (current_class_type,
9443                                  TREE_OPERAND (size, 1), 0, 0);
9444           if (t)
9445             size = t;
9446         }
9447
9448       return build_index_type (build_min (MINUS_EXPR, sizetype,
9449                                           size, integer_one_node));
9450     }
9451
9452   /* The size might be the result of a cast. */
9453   STRIP_TYPE_NOPS (size);
9454
9455   /* It might be a const variable or enumeration constant.  */
9456   size = decl_constant_value (size);
9457
9458   /* The array bound must be an integer type.  */
9459   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9460       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9461       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9462     {
9463       if (name)
9464         error ("size of array `%D' has non-integer type", name);
9465       else
9466         error ("size of array has non-integer type");
9467       size = integer_one_node;
9468     }
9469
9470   /* Normally, the array-bound will be a constant.  */
9471   if (TREE_CODE (size) == INTEGER_CST)
9472     {
9473       /* Check to see if the array bound overflowed.  Make that an
9474          error, no matter how generous we're being.  */
9475       int old_flag_pedantic_errors = flag_pedantic_errors;
9476       int old_pedantic = pedantic;
9477       pedantic = flag_pedantic_errors = 1;
9478       constant_expression_warning (size);
9479       pedantic = old_pedantic;
9480       flag_pedantic_errors = old_flag_pedantic_errors;
9481
9482       /* An array must have a positive number of elements.  */
9483       if (INT_CST_LT (size, integer_zero_node))
9484         {
9485           if (name)
9486             error ("size of array `%D' is negative", name);
9487           else
9488             error ("size of array is negative");
9489           size = integer_one_node;
9490         }
9491       /* Except that an extension we allow zero-sized arrays.  We
9492          always allow them in system headers because glibc uses
9493          them.  */
9494       else if (integer_zerop (size) && pedantic && !in_system_header)
9495         {
9496           if (name)
9497             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9498           else
9499             pedwarn ("ISO C++ forbids zero-size array");
9500         }
9501     }
9502   else if (TREE_CONSTANT (size))
9503     {
9504       /* `(int) &fn' is not a valid array bound.  */
9505       if (name)
9506         error ("size of array `%D' is not an integral constant-expression",
9507                   name);
9508       else
9509         error ("size of array is not an integral constant-expression");
9510     }
9511
9512   /* Compute the index of the largest element in the array.  It is
9513      one less than the number of elements in the array.  */
9514   itype
9515     = fold (cp_build_binary_op (MINUS_EXPR,
9516                                 cp_convert (ssizetype, size),
9517                                 cp_convert (ssizetype,
9518                                             integer_one_node)));
9519
9520   /* Check for variable-sized arrays.  We allow such things as an
9521      extension, even though they are not allowed in ANSI/ISO C++.  */
9522   if (!TREE_CONSTANT (itype))
9523     {
9524       if (pedantic)
9525         {
9526           if (name)
9527             pedwarn ("ISO C++ forbids variable-size array `%D'",
9528                         name);
9529           else
9530             pedwarn ("ISO C++ forbids variable-size array");
9531         }
9532
9533       /* Create a variable-sized array index type.  */
9534       itype = variable_size (itype);
9535     }
9536   /* Make sure that there was no overflow when creating to a signed
9537      index type.  (For example, on a 32-bit machine, an array with
9538      size 2^32 - 1 is too big.)  */
9539   else if (TREE_OVERFLOW (itype))
9540     {
9541       error ("overflow in array dimension");
9542       TREE_OVERFLOW (itype) = 0;
9543     }
9544
9545   /* Create and return the appropriate index type.  */
9546   return build_index_type (itype);
9547 }
9548
9549 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9550    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9551    with this type.  */
9552
9553 static tree
9554 create_array_type_for_decl (name, type, size)
9555      tree name;
9556      tree type;
9557      tree size;
9558 {
9559   tree itype = NULL_TREE;
9560   const char* error_msg;
9561
9562   /* If things have already gone awry, bail now.  */
9563   if (type == error_mark_node || size == error_mark_node)
9564     return error_mark_node;
9565
9566   /* Assume that everything will go OK.  */
9567   error_msg = NULL;
9568
9569   /* There are some types which cannot be array elements.  */
9570   switch (TREE_CODE (type))
9571     {
9572     case VOID_TYPE:
9573       error_msg = "array of void";
9574       break;
9575
9576     case FUNCTION_TYPE:
9577       error_msg = "array of functions";
9578       break;
9579
9580     case REFERENCE_TYPE:
9581       error_msg = "array of references";
9582       break;
9583
9584     case OFFSET_TYPE:
9585       error_msg = "array of data members";
9586       break;
9587
9588     case METHOD_TYPE:
9589       error_msg = "array of function members";
9590       break;
9591
9592     default:
9593       break;
9594     }
9595
9596   /* If something went wrong, issue an error-message and return.  */
9597   if (error_msg)
9598     {
9599       if (name)
9600         error ("declaration of `%D' as %s", name, error_msg);
9601       else
9602         error ("creating %s", error_msg);
9603
9604       return error_mark_node;
9605     }
9606
9607   /* [dcl.array]
9608
9609      The constant expressions that specify the bounds of the arrays
9610      can be omitted only for the first member of the sequence.  */
9611   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9612     {
9613       if (name)
9614         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9615                   name);
9616       else
9617         error ("multidimensional array must have bounds for all dimensions except the first");
9618
9619       return error_mark_node;
9620     }
9621
9622   /* Figure out the index type for the array.  */
9623   if (size)
9624     itype = compute_array_index_type (name, size);
9625
9626   return build_cplus_array_type (type, itype);
9627 }
9628
9629 /* Check that it's OK to declare a function with the indicated TYPE.
9630    SFK indicates the kind of special function (if any) that this
9631    function is.  OPTYPE is the type given in a conversion operator
9632    declaration.  Returns the actual return type of the function; that
9633    may be different than TYPE if an error occurs, or for certain
9634    special functions.  */
9635
9636 static tree
9637 check_special_function_return_type (sfk, type, optype)
9638      special_function_kind sfk;
9639      tree type;
9640      tree optype;
9641 {
9642   switch (sfk)
9643     {
9644     case sfk_constructor:
9645       if (type)
9646         error ("return type specification for constructor invalid");
9647
9648       type = void_type_node;
9649       break;
9650
9651     case sfk_destructor:
9652       if (type)
9653         error ("return type specification for destructor invalid");
9654       type = void_type_node;
9655       break;
9656
9657     case sfk_conversion:
9658       if (type && !same_type_p (type, optype))
9659         error ("operator `%T' declared to return `%T'", optype, type);
9660       else if (type)
9661         pedwarn ("return type specified for `operator %T'",  optype);
9662       type = optype;
9663       break;
9664
9665     default:
9666       abort ();
9667       break;
9668     }
9669
9670   return type;
9671 }
9672
9673 /* Given declspecs and a declarator,
9674    determine the name and type of the object declared
9675    and construct a ..._DECL node for it.
9676    (In one case we can return a ..._TYPE node instead.
9677     For invalid input we sometimes return 0.)
9678
9679    DECLSPECS is a chain of tree_list nodes whose value fields
9680     are the storage classes and type specifiers.
9681
9682    DECL_CONTEXT says which syntactic context this declaration is in:
9683      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9684      FUNCDEF for a function definition.  Like NORMAL but a few different
9685       error messages in each case.  Return value may be zero meaning
9686       this definition is too screwy to try to parse.
9687      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9688       handle member functions (which have FIELD context).
9689       Return value may be zero meaning this definition is too screwy to
9690       try to parse.
9691      PARM for a parameter declaration (either within a function prototype
9692       or before a function body).  Make a PARM_DECL, or return void_type_node.
9693      CATCHPARM for a parameter declaration before a catch clause.
9694      TYPENAME if for a typename (in a cast or sizeof).
9695       Don't make a DECL node; just return the ..._TYPE node.
9696      FIELD for a struct or union field; make a FIELD_DECL.
9697      BITFIELD for a field with specified width.
9698    INITIALIZED is 1 if the decl has an initializer.
9699
9700    ATTRLIST is a pointer to the list of attributes, which may be NULL
9701    if there are none; *ATTRLIST may be modified if attributes from inside
9702    the declarator should be applied to the declaration.
9703
9704    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9705    It may also be so in the PARM case, for a prototype where the
9706    argument type is specified but not the name.
9707
9708    This function is where the complicated C meanings of `static'
9709    and `extern' are interpreted.
9710
9711    For C++, if there is any monkey business to do, the function which
9712    calls this one must do it, i.e., prepending instance variables,
9713    renaming overloaded function names, etc.
9714
9715    Note that for this C++, it is an error to define a method within a class
9716    which does not belong to that class.
9717
9718    Except in the case where SCOPE_REFs are implicitly known (such as
9719    methods within a class being redundantly qualified),
9720    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9721    (class_name::decl_name).  The caller must also deal with this.
9722
9723    If a constructor or destructor is seen, and the context is FIELD,
9724    then the type gains the attribute TREE_HAS_x.  If such a declaration
9725    is erroneous, NULL_TREE is returned.
9726
9727    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9728    function, these are the qualifiers to give to the `this' pointer. We
9729    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9730
9731    May return void_type_node if the declarator turned out to be a friend.
9732    See grokfield for details.  */
9733
9734 tree
9735 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9736      tree declspecs;
9737      tree declarator;
9738      enum decl_context decl_context;
9739      int initialized;
9740      tree *attrlist;
9741 {
9742   RID_BIT_TYPE specbits;
9743   int nclasses = 0;
9744   tree spec;
9745   tree type = NULL_TREE;
9746   int longlong = 0;
9747   int type_quals;
9748   int virtualp, explicitp, friendp, inlinep, staticp;
9749   int explicit_int = 0;
9750   int explicit_char = 0;
9751   int defaulted_int = 0;
9752   int extern_langp = 0;
9753   tree dependant_name = NULL_TREE;
9754
9755   tree typedef_decl = NULL_TREE;
9756   const char *name;
9757   tree typedef_type = NULL_TREE;
9758   int funcdef_flag = 0;
9759   enum tree_code innermost_code = ERROR_MARK;
9760   int bitfield = 0;
9761 #if 0
9762   /* See the code below that used this.  */
9763   tree decl_attr = NULL_TREE;
9764 #endif
9765   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9766      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9767   tree init = NULL_TREE;
9768
9769   /* Keep track of what sort of function is being processed
9770      so that we can warn about default return values, or explicit
9771      return values which do not match prescribed defaults.  */
9772   special_function_kind sfk = sfk_none;
9773
9774   tree dname = NULL_TREE;
9775   tree ctype = current_class_type;
9776   tree ctor_return_type = NULL_TREE;
9777   enum overload_flags flags = NO_SPECIAL;
9778   tree quals = NULL_TREE;
9779   tree raises = NULL_TREE;
9780   int template_count = 0;
9781   tree in_namespace = NULL_TREE;
9782   tree returned_attrs = NULL_TREE;
9783
9784   RIDBIT_RESET_ALL (specbits);
9785   if (decl_context == FUNCDEF)
9786     funcdef_flag = 1, decl_context = NORMAL;
9787   else if (decl_context == MEMFUNCDEF)
9788     funcdef_flag = -1, decl_context = FIELD;
9789   else if (decl_context == BITFIELD)
9790     bitfield = 1, decl_context = FIELD;
9791
9792   /* Look inside a declarator for the name being declared
9793      and get it as a string, for an error message.  */
9794   {
9795     tree *next = &declarator;
9796     register tree decl;
9797     name = NULL;
9798
9799     while (next && *next)
9800       {
9801         decl = *next;
9802         switch (TREE_CODE (decl))
9803           {
9804           case TREE_LIST:
9805             /* For attributes.  */
9806             next = &TREE_VALUE (decl);
9807             break;
9808
9809           case COND_EXPR:
9810             ctype = NULL_TREE;
9811             next = &TREE_OPERAND (decl, 0);
9812             break;
9813
9814           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9815             {
9816               tree name = TREE_OPERAND (decl, 0);
9817               tree rename = NULL_TREE;
9818
9819               my_friendly_assert (flags == NO_SPECIAL, 152);
9820               flags = DTOR_FLAG;
9821               sfk = sfk_destructor;
9822               if (TREE_CODE (name) == TYPE_DECL)
9823                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9824               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9825               if (ctype == NULL_TREE)
9826                 {
9827                   if (current_class_type == NULL_TREE)
9828                     {
9829                       error ("destructors must be member functions");
9830                       flags = NO_SPECIAL;
9831                     }
9832                   else
9833                     {
9834                       tree t = constructor_name (current_class_name);
9835                       if (t != name)
9836                         rename = t;
9837                     }
9838                 }
9839               else
9840                 {
9841                   tree t = constructor_name (ctype);
9842                   if (t != name)
9843                     rename = t;
9844                 }
9845
9846               if (rename)
9847                 {
9848                   error ("destructor `%T' must match class name `%T'",
9849                             name, rename);
9850                   TREE_OPERAND (decl, 0) = rename;
9851                 }
9852               next = &name;
9853             }
9854             break;
9855
9856           case ADDR_EXPR:       /* C++ reference declaration */
9857             /* Fall through. */
9858           case ARRAY_REF:
9859           case INDIRECT_REF:
9860             ctype = NULL_TREE;
9861             innermost_code = TREE_CODE (decl);
9862             next = &TREE_OPERAND (decl, 0);
9863             break;
9864
9865           case CALL_EXPR:
9866             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9867               {
9868                 /* This is actually a variable declaration using
9869                    constructor syntax.  We need to call start_decl and
9870                    cp_finish_decl so we can get the variable
9871                    initialized...  */
9872
9873                 tree attributes;
9874
9875                 *next = TREE_OPERAND (decl, 0);
9876                 init = CALL_DECLARATOR_PARMS (decl);
9877
9878                 if (attrlist)
9879                   {
9880                     attributes = *attrlist;
9881                   }
9882                 else
9883                   {
9884                     attributes = NULL_TREE;
9885                   }
9886
9887                 decl = start_decl (declarator, declspecs, 1,
9888                                    attributes, NULL_TREE);
9889                 decl_type_access_control (decl);
9890                 if (decl)
9891                   {
9892                     /* Look for __unused__ attribute */
9893                     if (TREE_USED (TREE_TYPE (decl)))
9894                       TREE_USED (decl) = 1;
9895                     finish_decl (decl, init, NULL_TREE);
9896                   }
9897                 else
9898                   error ("invalid declarator");
9899                 return 0;
9900               }
9901             innermost_code = TREE_CODE (decl);
9902             if (decl_context == FIELD && ctype == NULL_TREE)
9903               ctype = current_class_type;
9904             if (ctype
9905                 && TREE_OPERAND (decl, 0)
9906                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9907                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9908                          == constructor_name_full (ctype))
9909                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9910                             == constructor_name (ctype)))))
9911               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9912             next = &TREE_OPERAND (decl, 0);
9913             decl = *next;
9914             if (ctype != NULL_TREE
9915                 && decl != NULL_TREE && flags != DTOR_FLAG
9916                 && decl == constructor_name (ctype))
9917               {
9918                 sfk = sfk_constructor;
9919                 ctor_return_type = ctype;
9920               }
9921             ctype = NULL_TREE;
9922             break;
9923
9924           case TEMPLATE_ID_EXPR:
9925               {
9926                 tree fns = TREE_OPERAND (decl, 0);
9927
9928                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9929                   fns = TREE_OPERAND (fns, 0);
9930
9931                 dname = fns;
9932                 if (TREE_CODE (dname) == COMPONENT_REF)
9933                   dname = TREE_OPERAND (dname, 1);
9934                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9935                   {
9936                     my_friendly_assert (is_overloaded_fn (dname),
9937                                         19990331);
9938                     dname = DECL_NAME (get_first_fn (dname));
9939                   }
9940               }
9941           /* Fall through. */
9942
9943           case IDENTIFIER_NODE:
9944             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9945               dname = decl;
9946
9947             next = 0;
9948
9949             if (C_IS_RESERVED_WORD (dname))
9950               {
9951                 error ("declarator-id missing; using reserved word `%D'",
9952                           dname);
9953                 name = IDENTIFIER_POINTER (dname);
9954               }
9955             else if (!IDENTIFIER_TYPENAME_P (dname))
9956               name = IDENTIFIER_POINTER (dname);
9957             else
9958               {
9959                 my_friendly_assert (flags == NO_SPECIAL, 154);
9960                 flags = TYPENAME_FLAG;
9961                 ctor_return_type = TREE_TYPE (dname);
9962                 sfk = sfk_conversion;
9963                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9964                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9965                         == TYPE_DECL))
9966                   name = IDENTIFIER_POINTER (dname);
9967                 else
9968                   name = "<invalid operator>";
9969               }
9970             break;
9971
9972             /* C++ extension */
9973           case SCOPE_REF:
9974             {
9975               /* Perform error checking, and decide on a ctype.  */
9976               tree cname = TREE_OPERAND (decl, 0);
9977               if (cname == NULL_TREE)
9978                 ctype = NULL_TREE;
9979               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9980                 {
9981                   ctype = NULL_TREE;
9982                   in_namespace = TREE_OPERAND (decl, 0);
9983                   TREE_OPERAND (decl, 0) = NULL_TREE;
9984                 }
9985               else if (! is_aggr_type (cname, 1))
9986                 TREE_OPERAND (decl, 0) = NULL_TREE;
9987               /* Must test TREE_OPERAND (decl, 1), in case user gives
9988                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9989               else if (TREE_OPERAND (decl, 1)
9990                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9991                 ctype = cname;
9992               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9993                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9994                 {
9995                   /* This might be declaring a member of a template
9996                      parm to be a friend.  */
9997                   ctype = cname;
9998                   dependant_name = TREE_OPERAND (decl, 1);
9999                 }
10000               else if (ctype == NULL_TREE)
10001                 ctype = cname;
10002               else if (TREE_COMPLEXITY (decl) == current_class_depth)
10003                 TREE_OPERAND (decl, 0) = ctype;
10004               else
10005                 {
10006                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
10007                     {
10008                       error ("type `%T' is not derived from type `%T'",
10009                                 cname, ctype);
10010                       TREE_OPERAND (decl, 0) = NULL_TREE;
10011                     }
10012                   else
10013                     ctype = cname;
10014                 }
10015
10016               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
10017                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
10018                        == constructor_name_full (ctype))
10019                       || (DECL_NAME (TREE_OPERAND (decl, 1))
10020                           == constructor_name (ctype))))
10021                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
10022               next = &TREE_OPERAND (decl, 1);
10023               decl = *next;
10024               if (ctype)
10025                 {
10026                   if (TREE_CODE (decl) == IDENTIFIER_NODE
10027                       && constructor_name (ctype) == decl)
10028                     {
10029                       sfk = sfk_constructor;
10030                       ctor_return_type = ctype;
10031                     }
10032                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
10033                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
10034                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
10035                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
10036                     {
10037                       sfk = sfk_destructor;
10038                       ctor_return_type = ctype;
10039                       flags = DTOR_FLAG;
10040                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
10041                       next = &TREE_OPERAND (decl, 0);
10042                     }
10043                 }
10044             }
10045             break;
10046
10047           case ERROR_MARK:
10048             next = 0;
10049             break;
10050
10051           case TYPE_DECL:
10052             /* Parse error puts this typespec where
10053                a declarator should go.  */
10054             error ("`%T' specified as declarator-id", DECL_NAME (decl));
10055             if (TREE_TYPE (decl) == current_class_type)
10056               error ("  perhaps you want `%T' for a constructor",
10057                         current_class_name);
10058             dname = DECL_NAME (decl);
10059             name = IDENTIFIER_POINTER (dname);
10060
10061             /* Avoid giving two errors for this.  */
10062             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10063
10064             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10065             *next = dname;
10066             next = 0;
10067             break;
10068
10069           case TEMPLATE_DECL:
10070             /* Sometimes, we see a template-name used as part of a
10071                decl-specifier like in
10072                      std::allocator alloc;
10073                Handle that gracefully.  */
10074             error ("invalid use of template-name '%E' in a declarator",
10075                    decl);
10076             return error_mark_node;
10077             break;
10078
10079           default:
10080             internal_error ("`%D' as declarator", decl);
10081           }
10082       }
10083   }
10084
10085   /* A function definition's declarator must have the form of
10086      a function declarator.  */
10087
10088   if (funcdef_flag && innermost_code != CALL_EXPR)
10089     return 0;
10090
10091   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10092       && innermost_code != CALL_EXPR
10093       && ! (ctype && declspecs == NULL_TREE))
10094     {
10095       error ("declaration of `%D' as non-function", dname);
10096       return void_type_node;
10097     }
10098
10099   /* Anything declared one level down from the top level
10100      must be one of the parameters of a function
10101      (because the body is at least two levels down).  */
10102
10103   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10104      by not allowing C++ class definitions to specify their parameters
10105      with xdecls (must be spec.d in the parmlist).
10106
10107      Since we now wait to push a class scope until we are sure that
10108      we are in a legitimate method context, we must set oldcname
10109      explicitly (since current_class_name is not yet alive).
10110
10111      We also want to avoid calling this a PARM if it is in a namespace.  */
10112
10113   if (decl_context == NORMAL && !toplevel_bindings_p ())
10114     {
10115       struct binding_level *b = current_binding_level;
10116       current_binding_level = b->level_chain;
10117       if (current_binding_level != 0 && toplevel_bindings_p ())
10118         decl_context = PARM;
10119       current_binding_level = b;
10120     }
10121
10122   if (name == NULL)
10123     name = decl_context == PARM ? "parameter" : "type name";
10124
10125   /* Look through the decl specs and record which ones appear.
10126      Some typespecs are defined as built-in typenames.
10127      Others, the ones that are modifiers of other types,
10128      are represented by bits in SPECBITS: set the bits for
10129      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10130
10131      If there is a typedef name or a type, store the type in TYPE.
10132      This includes builtin typedefs such as `int'.
10133
10134      Set EXPLICIT_INT if the type is `int' or `char' and did not
10135      come from a user typedef.
10136
10137      Set LONGLONG if `long' is mentioned twice.
10138
10139      For C++, constructors and destructors have their own fast treatment.  */
10140
10141   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10142     {
10143       register int i;
10144       register tree id;
10145
10146       /* Certain parse errors slip through.  For example,
10147          `int class;' is not caught by the parser. Try
10148          weakly to recover here.  */
10149       if (TREE_CODE (spec) != TREE_LIST)
10150         return 0;
10151
10152       id = TREE_VALUE (spec);
10153
10154       /* If the entire declaration is itself tagged as deprecated then
10155          suppress reports of deprecated items.  */
10156       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10157         {
10158           if (deprecated_state != DEPRECATED_SUPPRESS)
10159             warn_deprecated_use (id);
10160         }
10161
10162       if (TREE_CODE (id) == IDENTIFIER_NODE)
10163         {
10164           if (id == ridpointers[(int) RID_INT]
10165               || id == ridpointers[(int) RID_CHAR]
10166               || id == ridpointers[(int) RID_BOOL]
10167               || id == ridpointers[(int) RID_WCHAR])
10168             {
10169               if (type)
10170                 {
10171                   if (id == ridpointers[(int) RID_BOOL])
10172                     error ("`bool' is now a keyword");
10173                   else
10174                     error ("extraneous `%T' ignored", id);
10175                 }
10176               else
10177                 {
10178                   if (id == ridpointers[(int) RID_INT])
10179                     explicit_int = 1;
10180                   else if (id == ridpointers[(int) RID_CHAR])
10181                     explicit_char = 1;
10182                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10183                 }
10184               goto found;
10185             }
10186           /* C++ aggregate types.  */
10187           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10188             {
10189               if (type)
10190                 error ("multiple declarations `%T' and `%T'", type, id);
10191               else
10192                 type = IDENTIFIER_TYPE_VALUE (id);
10193               goto found;
10194             }
10195
10196           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10197             {
10198               if (ridpointers[i] == id)
10199                 {
10200                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10201                     {
10202                       if (pedantic && ! in_system_header && warn_long_long)
10203                         pedwarn ("ISO C++ does not support `long long'");
10204                       if (longlong)
10205                         error ("`long long long' is too long for GCC");
10206                       else
10207                         longlong = 1;
10208                     }
10209                   else if (RIDBIT_SETP (i, specbits))
10210                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10211                   if (i == (int)RID_EXTERN
10212                       && TREE_PURPOSE (spec) == error_mark_node)
10213                     /* This extern was part of a language linkage.  */
10214                     extern_langp = 1;
10215                   RIDBIT_SET (i, specbits);
10216                   goto found;
10217                 }
10218             }
10219         }
10220       else if (TREE_CODE (id) == TYPE_DECL)
10221         {
10222           if (type)
10223             error ("multiple declarations `%T' and `%T'", type,
10224                       TREE_TYPE (id));
10225           else
10226             {
10227               type = TREE_TYPE (id);
10228               TREE_VALUE (spec) = type;
10229               typedef_decl = id;
10230             }
10231           goto found;
10232         }
10233       if (type)
10234         error ("two or more data types in declaration of `%s'", name);
10235       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10236         {
10237           register tree t = lookup_name (id, 1);
10238           if (!t || TREE_CODE (t) != TYPE_DECL)
10239             error ("`%s' fails to be a typedef or built in type",
10240                    IDENTIFIER_POINTER (id));
10241           else
10242             {
10243               type = TREE_TYPE (t);
10244               typedef_decl = t;
10245             }
10246         }
10247       else if (id != error_mark_node)
10248         /* Can't change CLASS nodes into RECORD nodes here!  */
10249         type = id;
10250
10251     found: ;
10252     }
10253
10254 #if 0
10255   /* See the code below that used this.  */
10256   if (typedef_decl)
10257     decl_attr = DECL_ATTRIBUTES (typedef_decl);
10258 #endif
10259   typedef_type = type;
10260
10261   /* No type at all: default to `int', and set DEFAULTED_INT
10262      because it was not a user-defined typedef.  */
10263
10264   if (type == NULL_TREE
10265       && (RIDBIT_SETP (RID_SIGNED, specbits)
10266           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10267           || RIDBIT_SETP (RID_LONG, specbits)
10268           || RIDBIT_SETP (RID_SHORT, specbits)))
10269     {
10270       /* These imply 'int'.  */
10271       type = integer_type_node;
10272       defaulted_int = 1;
10273     }
10274
10275   if (sfk != sfk_none)
10276     type = check_special_function_return_type (sfk, type,
10277                                                ctor_return_type);
10278   else if (type == NULL_TREE)
10279     {
10280       int is_main;
10281
10282       explicit_int = -1;
10283
10284       /* We handle `main' specially here, because 'main () { }' is so
10285          common.  With no options, it is allowed.  With -Wreturn-type,
10286          it is a warning.  It is only an error with -pedantic-errors.  */
10287       is_main = (funcdef_flag
10288                  && dname && MAIN_NAME_P (dname)
10289                  && ctype == NULL_TREE
10290                  && in_namespace == NULL_TREE
10291                  && current_namespace == global_namespace);
10292
10293       if (in_system_header || flag_ms_extensions)
10294         /* Allow it, sigh.  */;
10295       else if (pedantic || ! is_main)
10296         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10297                     name);
10298       else if (warn_return_type)
10299         warning ("ISO C++ forbids declaration of `%s' with no type",
10300                     name);
10301
10302       type = integer_type_node;
10303     }
10304
10305   if (type && IMPLICIT_TYPENAME_P (type))
10306     {
10307       /* The implicit typename extension is deprecated and will be
10308          removed.  Warn about its use now.  */
10309       warning ("`%T' is implicitly a typename", type);
10310       cp_deprecated ("implicit typename");
10311
10312       /* Now remove its implicitness, so that we don't warn again.
10313          For instance this might be a typedef, and we do not want to
10314          warn on uses of the typedef itself.  Simply clearing the
10315          TREE_TYPE is insufficient.  */
10316       type = copy_node (type);
10317       TREE_TYPE (type) = NULL_TREE;
10318     }
10319
10320   ctype = NULL_TREE;
10321
10322   /* Now process the modifiers that were specified
10323      and check for invalid combinations.  */
10324
10325   /* Long double is a special combination.  */
10326
10327   if (RIDBIT_SETP (RID_LONG, specbits)
10328       && TYPE_MAIN_VARIANT (type) == double_type_node)
10329     {
10330       RIDBIT_RESET (RID_LONG, specbits);
10331       type = build_qualified_type (long_double_type_node,
10332                                    cp_type_quals (type));
10333     }
10334
10335   /* Check all other uses of type modifiers.  */
10336
10337   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10338       || RIDBIT_SETP (RID_SIGNED, specbits)
10339       || RIDBIT_SETP (RID_LONG, specbits)
10340       || RIDBIT_SETP (RID_SHORT, specbits))
10341     {
10342       int ok = 0;
10343
10344       if (TREE_CODE (type) == REAL_TYPE)
10345         error ("short, signed or unsigned invalid for `%s'", name);
10346       else if (TREE_CODE (type) != INTEGER_TYPE)
10347         error ("long, short, signed or unsigned invalid for `%s'", name);
10348       else if (RIDBIT_SETP (RID_LONG, specbits)
10349                && RIDBIT_SETP (RID_SHORT, specbits))
10350         error ("long and short specified together for `%s'", name);
10351       else if ((RIDBIT_SETP (RID_LONG, specbits)
10352                 || RIDBIT_SETP (RID_SHORT, specbits))
10353                && explicit_char)
10354         error ("long or short specified with char for `%s'", name);
10355       else if ((RIDBIT_SETP (RID_LONG, specbits)
10356                 || RIDBIT_SETP (RID_SHORT, specbits))
10357                && TREE_CODE (type) == REAL_TYPE)
10358         error ("long or short specified with floating type for `%s'", name);
10359       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10360                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10361         error ("signed and unsigned given together for `%s'", name);
10362       else
10363         {
10364           ok = 1;
10365           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10366             {
10367               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10368                        name);
10369               if (flag_pedantic_errors)
10370                 ok = 0;
10371             }
10372         }
10373
10374       /* Discard the type modifiers if they are invalid.  */
10375       if (! ok)
10376         {
10377           RIDBIT_RESET (RID_UNSIGNED, specbits);
10378           RIDBIT_RESET (RID_SIGNED, specbits);
10379           RIDBIT_RESET (RID_LONG, specbits);
10380           RIDBIT_RESET (RID_SHORT, specbits);
10381           longlong = 0;
10382         }
10383     }
10384
10385   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10386       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10387     {
10388       error ("complex invalid for `%s'", name);
10389       RIDBIT_RESET (RID_COMPLEX, specbits);
10390     }
10391
10392   /* Decide whether an integer type is signed or not.
10393      Optionally treat bitfields as signed by default.  */
10394   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10395       /* [class.bit]
10396
10397          It is implementation-defined whether a plain (neither
10398          explicitly signed or unsigned) char, short, int, or long
10399          bit-field is signed or unsigned.
10400
10401          Naturally, we extend this to long long as well.  Note that
10402          this does not include wchar_t.  */
10403       || (bitfield && !flag_signed_bitfields
10404           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10405           /* A typedef for plain `int' without `signed' can be
10406              controlled just like plain `int', but a typedef for
10407              `signed int' cannot be so controlled.  */
10408           && !(typedef_decl
10409                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10410           && (TREE_CODE (type) == INTEGER_TYPE
10411               || TREE_CODE (type) == CHAR_TYPE)
10412           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10413     {
10414       if (longlong)
10415         type = long_long_unsigned_type_node;
10416       else if (RIDBIT_SETP (RID_LONG, specbits))
10417         type = long_unsigned_type_node;
10418       else if (RIDBIT_SETP (RID_SHORT, specbits))
10419         type = short_unsigned_type_node;
10420       else if (type == char_type_node)
10421         type = unsigned_char_type_node;
10422       else if (typedef_decl)
10423         type = unsigned_type (type);
10424       else
10425         type = unsigned_type_node;
10426     }
10427   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10428            && type == char_type_node)
10429     type = signed_char_type_node;
10430   else if (longlong)
10431     type = long_long_integer_type_node;
10432   else if (RIDBIT_SETP (RID_LONG, specbits))
10433     type = long_integer_type_node;
10434   else if (RIDBIT_SETP (RID_SHORT, specbits))
10435     type = short_integer_type_node;
10436
10437   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10438     {
10439       /* If we just have "complex", it is equivalent to
10440          "complex double", but if any modifiers at all are specified it is
10441          the complex form of TYPE.  E.g, "complex short" is
10442          "complex short int".  */
10443
10444       if (defaulted_int && ! longlong
10445           && ! (RIDBIT_SETP (RID_LONG, specbits)
10446                 || RIDBIT_SETP (RID_SHORT, specbits)
10447                 || RIDBIT_SETP (RID_SIGNED, specbits)
10448                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10449         type = complex_double_type_node;
10450       else if (type == integer_type_node)
10451         type = complex_integer_type_node;
10452       else if (type == float_type_node)
10453         type = complex_float_type_node;
10454       else if (type == double_type_node)
10455         type = complex_double_type_node;
10456       else if (type == long_double_type_node)
10457         type = complex_long_double_type_node;
10458       else
10459         type = build_complex_type (type);
10460     }
10461
10462   type_quals = TYPE_UNQUALIFIED;
10463   if (RIDBIT_SETP (RID_CONST, specbits))
10464     type_quals |= TYPE_QUAL_CONST;
10465   if (RIDBIT_SETP (RID_VOLATILE, specbits))
10466     type_quals |= TYPE_QUAL_VOLATILE;
10467   if (RIDBIT_SETP (RID_RESTRICT, specbits))
10468     type_quals |= TYPE_QUAL_RESTRICT;
10469   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10470     error ("qualifiers are not allowed on declaration of `operator %T'",
10471               ctor_return_type);
10472
10473   type_quals |= cp_type_quals (type);
10474   type = cp_build_qualified_type_real
10475     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10476                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10477   /* We might have ignored or rejected some of the qualifiers.  */
10478   type_quals = cp_type_quals (type);
10479
10480   staticp = 0;
10481   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10482   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10483   RIDBIT_RESET (RID_VIRTUAL, specbits);
10484   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10485   RIDBIT_RESET (RID_EXPLICIT, specbits);
10486
10487   if (RIDBIT_SETP (RID_STATIC, specbits))
10488     staticp = 1 + (decl_context == FIELD);
10489
10490   if (virtualp && staticp == 2)
10491     {
10492       error ("member `%D' cannot be declared both virtual and static",
10493                 dname);
10494       staticp = 0;
10495     }
10496   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10497   RIDBIT_RESET (RID_FRIEND, specbits);
10498
10499   if (dependant_name && !friendp)
10500     {
10501       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10502       return void_type_node;
10503     }
10504
10505   /* Warn if two storage classes are given. Default to `auto'.  */
10506
10507   if (RIDBIT_ANY_SET (specbits))
10508     {
10509       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10510       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10511       if (decl_context == PARM && nclasses > 0)
10512         error ("storage class specifiers invalid in parameter declarations");
10513       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10514         {
10515           if (decl_context == PARM)
10516             error ("typedef declaration invalid in parameter declaration");
10517           nclasses++;
10518         }
10519       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10520       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10521       if (!nclasses && !friendp && extern_langp)
10522         nclasses++;
10523     }
10524
10525   /* Give error if `virtual' is used outside of class declaration.  */
10526   if (virtualp
10527       && (current_class_name == NULL_TREE || decl_context != FIELD))
10528     {
10529       error ("virtual outside class declaration");
10530       virtualp = 0;
10531     }
10532
10533   /* Static anonymous unions are dealt with here.  */
10534   if (staticp && decl_context == TYPENAME
10535       && TREE_CODE (declspecs) == TREE_LIST
10536       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10537     decl_context = FIELD;
10538
10539   /* Warn about storage classes that are invalid for certain
10540      kinds of declarations (parameters, typenames, etc.).  */
10541
10542   if (nclasses > 1)
10543     error ("multiple storage classes in declaration of `%s'", name);
10544   else if (decl_context != NORMAL && nclasses > 0)
10545     {
10546       if ((decl_context == PARM || decl_context == CATCHPARM)
10547           && (RIDBIT_SETP (RID_REGISTER, specbits)
10548               || RIDBIT_SETP (RID_AUTO, specbits)))
10549         ;
10550       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10551         ;
10552       else if (decl_context == FIELD
10553                /* C++ allows static class elements  */
10554                && RIDBIT_SETP (RID_STATIC, specbits))
10555         /* C++ also allows inlines and signed and unsigned elements,
10556            but in those cases we don't come in here.  */
10557         ;
10558       else
10559         {
10560           if (decl_context == FIELD)
10561             {
10562               tree tmp = NULL_TREE;
10563               register int op = 0;
10564
10565               if (declarator)
10566                 {
10567                   /* Avoid trying to get an operand off an identifier node.  */
10568                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10569                     tmp = declarator;
10570                   else
10571                     tmp = TREE_OPERAND (declarator, 0);
10572                   op = IDENTIFIER_OPNAME_P (tmp);
10573                   if (IDENTIFIER_TYPENAME_P (tmp))
10574                     {
10575                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10576                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10577                               == TYPE_DECL))
10578                         name = IDENTIFIER_POINTER (tmp);
10579                       else
10580                         name = "<invalid operator>";
10581                     }
10582                 }
10583               error ("storage class specified for %s `%s'",
10584                      op ? "member operator" : "field",
10585                      name);
10586             }
10587           else
10588             {
10589               if (decl_context == PARM || decl_context == CATCHPARM)
10590                 error ("storage class specified for parameter `%s'", name);
10591               else
10592                 error ("storage class specified for typename");
10593             }
10594           RIDBIT_RESET (RID_REGISTER, specbits);
10595           RIDBIT_RESET (RID_AUTO, specbits);
10596           RIDBIT_RESET (RID_EXTERN, specbits);
10597         }
10598     }
10599   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10600     {
10601       if (toplevel_bindings_p ())
10602         {
10603           /* It's common practice (and completely valid) to have a const
10604              be initialized and declared extern.  */
10605           if (!(type_quals & TYPE_QUAL_CONST))
10606             warning ("`%s' initialized and declared `extern'", name);
10607         }
10608       else
10609         error ("`%s' has both `extern' and initializer", name);
10610     }
10611   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10612            && ! toplevel_bindings_p ())
10613     error ("nested function `%s' declared `extern'", name);
10614   else if (toplevel_bindings_p ())
10615     {
10616       if (RIDBIT_SETP (RID_AUTO, specbits))
10617         error ("top-level declaration of `%s' specifies `auto'", name);
10618     }
10619
10620   if (nclasses > 0 && friendp)
10621     error ("storage class specifiers invalid in friend function declarations");
10622
10623   /* Now figure out the structure of the declarator proper.
10624      Descend through it, creating more complex types, until we reach
10625      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10626
10627   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10628          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10629     {
10630       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10631          an INDIRECT_REF (for *...),
10632          a CALL_EXPR (for ...(...)),
10633          an identifier (for the name being declared)
10634          or a null pointer (for the place in an absolute declarator
10635          where the name was omitted).
10636          For the last two cases, we have just exited the loop.
10637
10638          For C++ it could also be
10639          a SCOPE_REF (for class :: ...).  In this case, we have converted
10640          sensible names to types, and those are the values we use to
10641          qualify the member name.
10642          an ADDR_EXPR (for &...),
10643          a BIT_NOT_EXPR (for destructors)
10644
10645          At this point, TYPE is the type of elements of an array,
10646          or for a function to return, or for a pointer to point to.
10647          After this sequence of ifs, TYPE is the type of the
10648          array or function or pointer, and DECLARATOR has had its
10649          outermost layer removed.  */
10650
10651       if (type == error_mark_node)
10652         {
10653           if (TREE_CODE (declarator) == SCOPE_REF)
10654             declarator = TREE_OPERAND (declarator, 1);
10655           else
10656             declarator = TREE_OPERAND (declarator, 0);
10657           continue;
10658         }
10659       if (quals != NULL_TREE
10660           && (declarator == NULL_TREE
10661               || TREE_CODE (declarator) != SCOPE_REF))
10662         {
10663           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10664             ctype = TYPE_METHOD_BASETYPE (type);
10665           if (ctype != NULL_TREE)
10666             {
10667               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10668               grok_method_quals (ctype, dummy, quals);
10669               type = TREE_TYPE (dummy);
10670               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10671               quals = NULL_TREE;
10672             }
10673         }
10674
10675       switch (TREE_CODE (declarator))
10676         {
10677         case TREE_LIST:
10678           {
10679             /* We encode a declarator with embedded attributes using
10680                a TREE_LIST.  */
10681             tree attrs = TREE_PURPOSE (declarator);
10682             tree inner_decl;
10683             int attr_flags;
10684
10685             declarator = TREE_VALUE (declarator);
10686             inner_decl = declarator;
10687             while (inner_decl != NULL_TREE
10688                    && TREE_CODE (inner_decl) == TREE_LIST)
10689               inner_decl = TREE_VALUE (inner_decl);
10690             attr_flags = 0;
10691             if (inner_decl == NULL_TREE
10692                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10693               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10694             if (TREE_CODE (inner_decl) == CALL_EXPR)
10695               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10696             if (TREE_CODE (inner_decl) == ARRAY_REF)
10697               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10698             returned_attrs = decl_attributes (&type,
10699                                               chainon (returned_attrs, attrs),
10700                                               attr_flags);
10701           }
10702           break;
10703
10704         case ARRAY_REF:
10705           {
10706             register tree size;
10707
10708             size = TREE_OPERAND (declarator, 1);
10709
10710             /* VC++ spells a zero-sized array with [].  */
10711             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10712                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10713               size = integer_zero_node;
10714
10715             declarator = TREE_OPERAND (declarator, 0);
10716
10717             type = create_array_type_for_decl (dname, type, size);
10718
10719             ctype = NULL_TREE;
10720           }
10721           break;
10722
10723         case CALL_EXPR:
10724           {
10725             tree arg_types;
10726             int funcdecl_p;
10727             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10728             tree inner_decl = TREE_OPERAND (declarator, 0);
10729
10730             /* Declaring a function type.
10731                Make sure we have a valid type for the function to return.  */
10732
10733             /* We now know that the TYPE_QUALS don't apply to the
10734                decl, but to its return type.  */
10735             type_quals = TYPE_UNQUALIFIED;
10736
10737             /* Warn about some types functions can't return.  */
10738
10739             if (TREE_CODE (type) == FUNCTION_TYPE)
10740               {
10741                 error ("`%s' declared as function returning a function", name);
10742                 type = integer_type_node;
10743               }
10744             if (TREE_CODE (type) == ARRAY_TYPE)
10745               {
10746                 error ("`%s' declared as function returning an array", name);
10747                 type = integer_type_node;
10748               }
10749
10750             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10751               inner_decl = TREE_OPERAND (inner_decl, 1);
10752
10753             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10754               inner_decl = dname;
10755
10756             /* Pick up type qualifiers which should be applied to `this'.  */
10757             quals = CALL_DECLARATOR_QUALS (declarator);
10758
10759             /* Pick up the exception specifications.  */
10760             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10761
10762             /* Say it's a definition only for the CALL_EXPR
10763                closest to the identifier.  */
10764             funcdecl_p
10765               = inner_decl
10766               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10767                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10768                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10769
10770             if (ctype == NULL_TREE
10771                 && decl_context == FIELD
10772                 && funcdecl_p
10773                 && (friendp == 0 || dname == current_class_name))
10774               ctype = current_class_type;
10775
10776             if (ctype && sfk == sfk_conversion)
10777               TYPE_HAS_CONVERSION (ctype) = 1;
10778             if (ctype && constructor_name (ctype) == dname)
10779               {
10780                 /* We are within a class's scope. If our declarator name
10781                    is the same as the class name, and we are defining
10782                    a function, then it is a constructor/destructor, and
10783                    therefore returns a void type.  */
10784
10785                 if (flags == DTOR_FLAG)
10786                   {
10787                     /* ISO C++ 12.4/2.  A destructor may not be
10788                        declared const or volatile.  A destructor may
10789                        not be static.  */
10790                     if (staticp == 2)
10791                       error ("destructor cannot be static member function");
10792                     if (quals)
10793                       {
10794                         error ("destructors may not be `%s'",
10795                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10796                         quals = NULL_TREE;
10797                       }
10798                     if (decl_context == FIELD)
10799                       {
10800                         if (! member_function_or_else (ctype,
10801                                                        current_class_type,
10802                                                        flags))
10803                           return void_type_node;
10804                       }
10805                   }
10806                 else            /* It's a constructor.  */
10807                   {
10808                     if (explicitp == 1)
10809                       explicitp = 2;
10810                     /* ISO C++ 12.1.  A constructor may not be
10811                        declared const or volatile.  A constructor may
10812                        not be virtual.  A constructor may not be
10813                        static.  */
10814                     if (staticp == 2)
10815                       error ("constructor cannot be static member function");
10816                     if (virtualp)
10817                       {
10818                         pedwarn ("constructors cannot be declared virtual");
10819                         virtualp = 0;
10820                       }
10821                     if (quals)
10822                       {
10823                         error ("constructors may not be `%s'",
10824                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10825                         quals = NULL_TREE;
10826                       }
10827                     {
10828                       RID_BIT_TYPE tmp_bits;
10829                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10830                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10831                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10832                       if (RIDBIT_ANY_SET (tmp_bits))
10833                         error ("return value type specifier for constructor ignored");
10834                     }
10835                     if (decl_context == FIELD)
10836                       {
10837                         if (! member_function_or_else (ctype,
10838                                                        current_class_type,
10839                                                        flags))
10840                           return void_type_node;
10841                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10842                         if (sfk != sfk_constructor)
10843                           return NULL_TREE;
10844                       }
10845                   }
10846                 if (decl_context == FIELD)
10847                   staticp = 0;
10848               }
10849             else if (friendp)
10850               {
10851                 if (initialized)
10852                   error ("can't initialize friend function `%s'", name);
10853                 if (virtualp)
10854                   {
10855                     /* Cannot be both friend and virtual.  */
10856                     error ("virtual functions cannot be friends");
10857                     RIDBIT_RESET (RID_FRIEND, specbits);
10858                     friendp = 0;
10859                   }
10860                 if (decl_context == NORMAL)
10861                   error ("friend declaration not in class definition");
10862                 if (current_function_decl && funcdef_flag)
10863                   error ("can't define friend function `%s' in a local class definition",
10864                             name);
10865               }
10866
10867             /* Construct the function type and go to the next
10868                inner layer of declarator.  */
10869
10870             declarator = TREE_OPERAND (declarator, 0);
10871
10872             /* FIXME: This is where default args should be fully
10873                processed.  */
10874
10875             arg_types = grokparms (inner_parms);
10876
10877             if (declarator && flags == DTOR_FLAG)
10878               {
10879                 /* A destructor declared in the body of a class will
10880                    be represented as a BIT_NOT_EXPR.  But, we just
10881                    want the underlying IDENTIFIER.  */
10882                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10883                   declarator = TREE_OPERAND (declarator, 0);
10884
10885                 if (arg_types != void_list_node)
10886                   {
10887                     error ("destructors may not have parameters");
10888                     arg_types = void_list_node;
10889                     last_function_parms = NULL_TREE;
10890                   }
10891               }
10892
10893             /* ANSI says that `const int foo ();'
10894                does not make the function foo const.  */
10895             type = build_function_type (type, arg_types);
10896
10897             {
10898               tree t;
10899               for (t = arg_types; t; t = TREE_CHAIN (t))
10900                 if (TREE_PURPOSE (t)
10901                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10902                   {
10903                     add_defarg_fn (type);
10904                     break;
10905                   }
10906             }
10907           }
10908           break;
10909
10910         case ADDR_EXPR:
10911         case INDIRECT_REF:
10912           /* Filter out pointers-to-references and references-to-references.
10913              We can get these if a TYPE_DECL is used.  */
10914
10915           if (TREE_CODE (type) == REFERENCE_TYPE)
10916             {
10917               error ("cannot declare %s to references",
10918                      TREE_CODE (declarator) == ADDR_EXPR
10919                      ? "references" : "pointers");
10920               declarator = TREE_OPERAND (declarator, 0);
10921               continue;
10922             }
10923
10924           if (TREE_CODE (type) == OFFSET_TYPE
10925               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10926                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10927             {
10928               error ("cannot declare pointer to `%#T' member",
10929                         TREE_TYPE (type));
10930               type = TREE_TYPE (type);
10931             }
10932
10933           /* Merge any constancy or volatility into the target type
10934              for the pointer.  */
10935
10936           /* We now know that the TYPE_QUALS don't apply to the decl,
10937              but to the target of the pointer.  */
10938           type_quals = TYPE_UNQUALIFIED;
10939
10940           if (TREE_CODE (declarator) == ADDR_EXPR)
10941             {
10942               if (TREE_CODE (type) == VOID_TYPE)
10943                 error ("invalid type: `void &'");
10944               else
10945                 type = build_reference_type (type);
10946             }
10947           else if (TREE_CODE (type) == METHOD_TYPE)
10948             type = build_ptrmemfunc_type (build_pointer_type (type));
10949           else
10950             type = build_pointer_type (type);
10951
10952           /* Process a list of type modifier keywords (such as
10953              const or volatile) that were given inside the `*' or `&'.  */
10954
10955           if (TREE_TYPE (declarator))
10956             {
10957               register tree typemodlist;
10958               int erred = 0;
10959               int constp = 0;
10960               int volatilep = 0;
10961               int restrictp = 0;
10962
10963               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10964                    typemodlist = TREE_CHAIN (typemodlist))
10965                 {
10966                   tree qualifier = TREE_VALUE (typemodlist);
10967
10968                   if (qualifier == ridpointers[(int) RID_CONST])
10969                     {
10970                       constp++;
10971                       type_quals |= TYPE_QUAL_CONST;
10972                     }
10973                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10974                     {
10975                       volatilep++;
10976                       type_quals |= TYPE_QUAL_VOLATILE;
10977                     }
10978                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10979                     {
10980                       restrictp++;
10981                       type_quals |= TYPE_QUAL_RESTRICT;
10982                     }
10983                   else if (!erred)
10984                     {
10985                       erred = 1;
10986                       error ("invalid type modifier within pointer declarator");
10987                     }
10988                 }
10989               if (constp > 1)
10990                 pedwarn ("duplicate `const'");
10991               if (volatilep > 1)
10992                 pedwarn ("duplicate `volatile'");
10993               if (restrictp > 1)
10994                 pedwarn ("duplicate `restrict'");
10995               type = cp_build_qualified_type (type, type_quals);
10996               type_quals = cp_type_quals (type);
10997             }
10998           declarator = TREE_OPERAND (declarator, 0);
10999           ctype = NULL_TREE;
11000           break;
11001
11002         case SCOPE_REF:
11003           {
11004             /* We have converted type names to NULL_TREE if the
11005                name was bogus, or to a _TYPE node, if not.
11006
11007                The variable CTYPE holds the type we will ultimately
11008                resolve to.  The code here just needs to build
11009                up appropriate member types.  */
11010             tree sname = TREE_OPERAND (declarator, 1);
11011             tree t;
11012
11013             /* Destructors can have their visibilities changed as well.  */
11014             if (TREE_CODE (sname) == BIT_NOT_EXPR)
11015               sname = TREE_OPERAND (sname, 0);
11016
11017             if (TREE_COMPLEXITY (declarator) == 0)
11018               /* This needs to be here, in case we are called
11019                  multiple times.  */ ;
11020             else if (TREE_COMPLEXITY (declarator) == -1)
11021               /* Namespace member. */
11022               pop_decl_namespace ();
11023             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
11024               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
11025             else if (! IS_AGGR_TYPE_CODE
11026                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
11027               ;
11028             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
11029               {
11030                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
11031                    that refer to ctype.  They couldn't be resolved earlier
11032                    because we hadn't pushed into the class yet.
11033                    Example: resolve 'B<T>::type' in
11034                    'B<typename B<T>::type> B<T>::f () { }'.  */
11035                 if (current_template_parms
11036                     && uses_template_parms (type)
11037                     && uses_template_parms (current_class_type))
11038                   {
11039                     tree args = current_template_args ();
11040                     type = tsubst (type, args, tf_error | tf_warning,
11041                                    NULL_TREE);
11042                   }
11043
11044                 /* This pop_nested_class corresponds to the
11045                    push_nested_class used to push into class scope for
11046                    parsing the argument list of a function decl, in
11047                    qualified_id.  */
11048                 pop_nested_class ();
11049                 TREE_COMPLEXITY (declarator) = current_class_depth;
11050               }
11051             else
11052               abort ();
11053
11054             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11055               {
11056                 /* We had a reference to a global decl, or
11057                    perhaps we were given a non-aggregate typedef,
11058                    in which case we cleared this out, and should just
11059                    keep going as though it wasn't there.  */
11060                 declarator = sname;
11061                 continue;
11062               }
11063             ctype = TREE_OPERAND (declarator, 0);
11064
11065             t = ctype;
11066             while (t != NULL_TREE && CLASS_TYPE_P (t))
11067               {
11068                 /* You're supposed to have one `template <...>'
11069                    for every template class, but you don't need one
11070                    for a full specialization.  For example:
11071
11072                      template <class T> struct S{};
11073                      template <> struct S<int> { void f(); };
11074                      void S<int>::f () {}
11075
11076                    is correct; there shouldn't be a `template <>' for
11077                    the definition of `S<int>::f'.  */
11078                 if (CLASSTYPE_TEMPLATE_INFO (t)
11079                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11080                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11081                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11082                   template_count += 1;
11083
11084                 t = TYPE_MAIN_DECL (t);
11085                 t = DECL_CONTEXT (t);
11086               }
11087
11088             if (sname == NULL_TREE)
11089               goto done_scoping;
11090
11091             if (TREE_CODE (sname) == IDENTIFIER_NODE)
11092               {
11093                 /* This is the `standard' use of the scoping operator:
11094                    basetype :: member .  */
11095
11096                 if (ctype == current_class_type)
11097                   {
11098                     /* class A {
11099                          void A::f ();
11100                        };
11101
11102                        Is this ill-formed?  */
11103
11104                     if (pedantic)
11105                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
11106                                   ctype, name);
11107                   }
11108                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11109                   {
11110                     if (current_class_type == NULL_TREE || friendp)
11111                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11112                                                       TYPE_ARG_TYPES (type));
11113                     else
11114                       {
11115                         error ("cannot declare member function `%T::%s' within `%T'",
11116                                   ctype, name, current_class_type);
11117                         return void_type_node;
11118                       }
11119                   }
11120                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11121                          || COMPLETE_TYPE_P (complete_type (ctype)))
11122                   {
11123                     /* Have to move this code elsewhere in this function.
11124                        this code is used for i.e., typedef int A::M; M *pm;
11125
11126                        It is?  How? jason 10/2/94 */
11127
11128                     if (current_class_type)
11129                       {
11130                         error ("cannot declare member `%T::%s' within `%T'",
11131                                   ctype, name, current_class_type);
11132                         return void_type_node;
11133                       }
11134                     type = build_offset_type (ctype, type);
11135                   }
11136                 else
11137                   {
11138                     incomplete_type_error (NULL_TREE, ctype);
11139                     return error_mark_node;
11140                   }
11141
11142                 declarator = sname;
11143               }
11144             else if (TREE_CODE (sname) == SCOPE_REF)
11145               abort ();
11146             else
11147               {
11148               done_scoping:
11149                 declarator = TREE_OPERAND (declarator, 1);
11150                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11151                   /* In this case, we will deal with it later.  */
11152                   ;
11153                 else
11154                   {
11155                     if (TREE_CODE (type) == FUNCTION_TYPE)
11156                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11157                                                       TYPE_ARG_TYPES (type));
11158                     else
11159                       type = build_offset_type (ctype, type);
11160                   }
11161               }
11162           }
11163           break;
11164
11165         case BIT_NOT_EXPR:
11166           declarator = TREE_OPERAND (declarator, 0);
11167           break;
11168
11169         case RECORD_TYPE:
11170         case UNION_TYPE:
11171         case ENUMERAL_TYPE:
11172           declarator = NULL_TREE;
11173           break;
11174
11175         case ERROR_MARK:
11176           declarator = NULL_TREE;
11177           break;
11178
11179         default:
11180           abort ();
11181         }
11182     }
11183
11184   if (returned_attrs)
11185     {
11186       if (attrlist)
11187         *attrlist = chainon (returned_attrs, *attrlist);
11188       else
11189         attrlist = &returned_attrs;
11190     }
11191
11192   /* Now TYPE has the actual type.  */
11193
11194   /* Did array size calculations overflow?  */
11195
11196   if (TREE_CODE (type) == ARRAY_TYPE
11197       && COMPLETE_TYPE_P (type)
11198       && TREE_OVERFLOW (TYPE_SIZE (type)))
11199     {
11200       error ("size of array `%s' is too large", name);
11201       /* If we proceed with the array type as it is, we'll eventually
11202          crash in tree_low_cst().  */
11203       type = error_mark_node;
11204     }
11205
11206   if (decl_context == FIELD
11207       && !processing_template_decl
11208       && variably_modified_type_p (type))
11209     {
11210       error ("data member may not have variably modified type `%T'", type);
11211       type = error_mark_node;
11212     }
11213
11214   if (explicitp == 1 || (explicitp && friendp))
11215     {
11216       /* [dcl.fct.spec] The explicit specifier shall only be used in
11217          declarations of constructors within a class definition.  */
11218       error ("only declarations of constructors can be `explicit'");
11219       explicitp = 0;
11220     }
11221
11222   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11223     {
11224       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11225         {
11226           error ("non-member `%s' cannot be declared `mutable'", name);
11227           RIDBIT_RESET (RID_MUTABLE, specbits);
11228         }
11229       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11230         {
11231           error ("non-object member `%s' cannot be declared `mutable'", name);
11232           RIDBIT_RESET (RID_MUTABLE, specbits);
11233         }
11234       else if (TREE_CODE (type) == FUNCTION_TYPE
11235                || TREE_CODE (type) == METHOD_TYPE)
11236         {
11237           error ("function `%s' cannot be declared `mutable'", name);
11238           RIDBIT_RESET (RID_MUTABLE, specbits);
11239         }
11240       else if (staticp)
11241         {
11242           error ("static `%s' cannot be declared `mutable'", name);
11243           RIDBIT_RESET (RID_MUTABLE, specbits);
11244         }
11245       else if (type_quals & TYPE_QUAL_CONST)
11246         {
11247           error ("const `%s' cannot be declared `mutable'", name);
11248           RIDBIT_RESET (RID_MUTABLE, specbits);
11249         }
11250     }
11251
11252   if (declarator == NULL_TREE
11253       || TREE_CODE (declarator) == IDENTIFIER_NODE
11254       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11255           && (TREE_CODE (type) == FUNCTION_TYPE
11256               || TREE_CODE (type) == METHOD_TYPE)))
11257     /* OK */;
11258   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11259     {
11260       error ("template-id `%D' used as a declarator", declarator);
11261       declarator = dname;
11262     }
11263   else
11264     /* Unexpected declarator format.  */
11265     abort ();
11266
11267   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11268
11269   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11270     {
11271       tree decl;
11272
11273       /* Note that the grammar rejects storage classes
11274          in typenames, fields or parameters.  */
11275       if (current_lang_name == lang_name_java)
11276         TYPE_FOR_JAVA (type) = 1;
11277
11278       if (decl_context == FIELD)
11279         {
11280           if (declarator == constructor_name (current_class_type))
11281             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11282                         declarator);
11283           decl = build_lang_decl (TYPE_DECL, declarator, type);
11284         }
11285       else
11286         {
11287           decl = build_decl (TYPE_DECL, declarator, type);
11288           if (!current_function_decl)
11289             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11290         }
11291
11292       /* If the user declares "typedef struct {...} foo" then the
11293          struct will have an anonymous name.  Fill that name in now.
11294          Nothing can refer to it, so nothing needs know about the name
11295          change.  */
11296       if (type != error_mark_node
11297           && declarator
11298           && TYPE_NAME (type)
11299           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11300           && TYPE_ANONYMOUS_P (type)
11301           /* Don't do this if there are attributes.  */
11302           && (!attrlist || !*attrlist)
11303           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11304         {
11305           tree oldname = TYPE_NAME (type);
11306           tree t;
11307
11308           /* Replace the anonymous name with the real name everywhere.  */
11309           lookup_tag_reverse (type, declarator);
11310           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11311             if (TYPE_NAME (t) == oldname)
11312               TYPE_NAME (t) = decl;
11313
11314           if (TYPE_LANG_SPECIFIC (type))
11315             TYPE_WAS_ANONYMOUS (type) = 1;
11316
11317           /* If this is a typedef within a template class, the nested
11318              type is a (non-primary) template.  The name for the
11319              template needs updating as well.  */
11320           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11321             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11322               = TYPE_IDENTIFIER (type);
11323
11324           /* FIXME remangle member functions; member functions of a
11325              type with external linkage have external linkage.  */
11326         }
11327
11328       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11329         {
11330           cp_error_at ("typedef name may not be class-qualified", decl);
11331           return NULL_TREE;
11332         }
11333       else if (quals)
11334         {
11335           if (ctype == NULL_TREE)
11336             {
11337               if (TREE_CODE (type) != METHOD_TYPE)
11338                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11339               else
11340                 ctype = TYPE_METHOD_BASETYPE (type);
11341             }
11342           if (ctype != NULL_TREE)
11343             grok_method_quals (ctype, decl, quals);
11344         }
11345
11346       if (RIDBIT_SETP (RID_SIGNED, specbits)
11347           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11348         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11349
11350       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11351                       inlinep, friendp, raises != NULL_TREE);
11352
11353       return decl;
11354     }
11355
11356   /* Detect the case of an array type of unspecified size
11357      which came, as such, direct from a typedef name.
11358      We must copy the type, so that the array's domain can be
11359      individually set by the object's initializer.  */
11360
11361   if (type && typedef_type
11362       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11363       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11364     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11365
11366   /* Detect where we're using a typedef of function type to declare a
11367      function. last_function_parms will not be set, so we must create
11368      it now.  */
11369
11370   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11371     {
11372       tree decls = NULL_TREE;
11373       tree args;
11374
11375       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11376         {
11377           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11378
11379           TREE_CHAIN (decl) = decls;
11380           decls = decl;
11381         }
11382
11383       last_function_parms = nreverse (decls);
11384     }
11385
11386   /* If this is a type name (such as, in a cast or sizeof),
11387      compute the type and return it now.  */
11388
11389   if (decl_context == TYPENAME)
11390     {
11391       /* Note that the grammar rejects storage classes
11392          in typenames, fields or parameters.  */
11393       if (type_quals != TYPE_UNQUALIFIED)
11394         type_quals = TYPE_UNQUALIFIED;
11395
11396       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11397       if (friendp)
11398         {
11399           if (type_quals != TYPE_UNQUALIFIED)
11400             {
11401               error ("type qualifiers specified for friend class declaration");
11402               type_quals = TYPE_UNQUALIFIED;
11403             }
11404           if (inlinep)
11405             {
11406               error ("`inline' specified for friend class declaration");
11407               inlinep = 0;
11408             }
11409
11410           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11411              But don't allow implicit typenames except with a class-key.  */
11412           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11413                                 || IMPLICIT_TYPENAME_P (type)))
11414             {
11415               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11416                 pedwarn ("template parameters cannot be friends");
11417               else if (TREE_CODE (type) == TYPENAME_TYPE)
11418                 pedwarn ("\
11419 friend declaration requires class-key, i.e. `friend class %T::%T'",
11420                             constructor_name (current_class_type),
11421                             TYPE_IDENTIFIER (type));
11422               else
11423                 pedwarn ("\
11424 friend declaration requires class-key, i.e. `friend %#T'",
11425                             type);
11426             }
11427
11428           /* Only try to do this stuff if we didn't already give up.  */
11429           if (type != integer_type_node)
11430             {
11431               decl_type_access_control (TYPE_NAME (type));
11432
11433               /* A friendly class?  */
11434               if (current_class_type)
11435                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11436               else
11437                 error ("trying to make class `%T' a friend of global scope",
11438                           type);
11439
11440               type = void_type_node;
11441             }
11442         }
11443       else if (quals)
11444         {
11445           if (ctype == NULL_TREE)
11446             {
11447               if (TREE_CODE (type) != METHOD_TYPE)
11448                 error ("invalid qualifiers on non-member function type");
11449               else
11450                 ctype = TYPE_METHOD_BASETYPE (type);
11451             }
11452           if (ctype)
11453             {
11454               tree dummy = build_decl (TYPE_DECL, declarator, type);
11455               grok_method_quals (ctype, dummy, quals);
11456               type = TREE_TYPE (dummy);
11457             }
11458         }
11459
11460       return type;
11461     }
11462   else if (declarator == NULL_TREE && decl_context != PARM
11463            && decl_context != CATCHPARM
11464            && TREE_CODE (type) != UNION_TYPE
11465            && ! bitfield)
11466     {
11467       error ("abstract declarator `%T' used as declaration", type);
11468       declarator = make_anon_name ();
11469     }
11470
11471   /* `void' at top level (not within pointer)
11472      is allowed only in typedefs or type names.
11473      We don't complain about parms either, but that is because
11474      a better error message can be made later.  */
11475
11476   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11477     {
11478       if (! declarator)
11479         error ("unnamed variable or field declared void");
11480       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11481         {
11482           if (IDENTIFIER_OPNAME_P (declarator))
11483             abort ();
11484           else
11485             error ("variable or field `%s' declared void", name);
11486         }
11487       else
11488         error ("variable or field declared void");
11489       type = integer_type_node;
11490     }
11491
11492   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11493      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11494
11495   if (decl_context == PARM || decl_context == CATCHPARM)
11496     {
11497       if (ctype || in_namespace)
11498         error ("cannot use `::' in parameter declaration");
11499
11500       /* A parameter declared as an array of T is really a pointer to T.
11501          One declared as a function is really a pointer to a function.
11502          One declared as a member is really a pointer to member.  */
11503
11504       if (TREE_CODE (type) == ARRAY_TYPE)
11505         {
11506           /* Transfer const-ness of array into that of type pointed to.  */
11507           type = build_pointer_type (TREE_TYPE (type));
11508           type_quals = TYPE_UNQUALIFIED;
11509         }
11510       else if (TREE_CODE (type) == FUNCTION_TYPE)
11511         type = build_pointer_type (type);
11512       else if (TREE_CODE (type) == OFFSET_TYPE)
11513         type = build_pointer_type (type);
11514     }
11515
11516   {
11517     register tree decl;
11518
11519     if (decl_context == PARM)
11520       {
11521         decl = build_decl (PARM_DECL, declarator, type);
11522
11523         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11524                         inlinep, friendp, raises != NULL_TREE);
11525
11526         /* Compute the type actually passed in the parmlist,
11527            for the case where there is no prototype.
11528            (For example, shorts and chars are passed as ints.)
11529            When there is a prototype, this is overridden later.  */
11530
11531         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11532       }
11533     else if (decl_context == FIELD)
11534       {
11535         if (type == error_mark_node)
11536           {
11537             /* Happens when declaring arrays of sizes which
11538                are error_mark_node, for example.  */
11539             decl = NULL_TREE;
11540           }
11541         else if (in_namespace && !friendp)
11542           {
11543             /* Something like struct S { int N::j; };  */
11544             error ("invalid use of `::'");
11545             decl = NULL_TREE;
11546           }
11547         else if (TREE_CODE (type) == FUNCTION_TYPE)
11548           {
11549             int publicp = 0;
11550             tree function_context;
11551
11552             /* We catch the others as conflicts with the builtin
11553                typedefs.  */
11554             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11555               {
11556                 error ("function `%D' cannot be declared friend",
11557                           declarator);
11558                 friendp = 0;
11559               }
11560
11561             if (friendp == 0)
11562               {
11563                 if (ctype == NULL_TREE)
11564                   ctype = current_class_type;
11565
11566                 if (ctype == NULL_TREE)
11567                   {
11568                     error ("can't make `%D' into a method -- not in a class",
11569                               declarator);
11570                     return void_type_node;
11571                   }
11572
11573                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11574                    ARM 9.5 */
11575                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11576                   {
11577                     error ("function `%D' declared virtual inside a union",
11578                               declarator);
11579                     return void_type_node;
11580                   }
11581
11582                 if (declarator == ansi_opname (NEW_EXPR)
11583                     || declarator == ansi_opname (VEC_NEW_EXPR)
11584                     || declarator == ansi_opname (DELETE_EXPR)
11585                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11586                   {
11587                     if (virtualp)
11588                       {
11589                         error ("`%D' cannot be declared virtual, since it is always static",
11590                                   declarator);
11591                         virtualp = 0;
11592                       }
11593                   }
11594                 else if (staticp < 2)
11595                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11596                                                   TYPE_ARG_TYPES (type));
11597               }
11598
11599             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11600             function_context = (ctype != NULL_TREE) ?
11601               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11602             publicp = (! friendp || ! staticp)
11603               && function_context == NULL_TREE;
11604             decl = grokfndecl (ctype, type,
11605                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11606                                ? declarator : dname,
11607                                declarator,
11608                                virtualp, flags, quals, raises,
11609                                friendp ? -1 : 0, friendp, publicp, inlinep,
11610                                funcdef_flag, template_count, in_namespace);
11611             if (decl == NULL_TREE)
11612               return decl;
11613 #if 0
11614             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11615             /* The decl and setting of decl_attr is also turned off.  */
11616             decl = build_decl_attribute_variant (decl, decl_attr);
11617 #endif
11618
11619             /* [class.conv.ctor]
11620
11621                A constructor declared without the function-specifier
11622                explicit that can be called with a single parameter
11623                specifies a conversion from the type of its first
11624                parameter to the type of its class.  Such a constructor
11625                is called a converting constructor.  */
11626             if (explicitp == 2)
11627               DECL_NONCONVERTING_P (decl) = 1;
11628             else if (DECL_CONSTRUCTOR_P (decl))
11629               {
11630                 /* The constructor can be called with exactly one
11631                    parameter if there is at least one parameter, and
11632                    any subsequent parameters have default arguments.
11633                    Ignore any compiler-added parms.  */
11634                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11635
11636                 if (arg_types == void_list_node
11637                     || (arg_types
11638                         && TREE_CHAIN (arg_types)
11639                         && TREE_CHAIN (arg_types) != void_list_node
11640                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11641                   DECL_NONCONVERTING_P (decl) = 1;
11642               }
11643           }
11644         else if (TREE_CODE (type) == METHOD_TYPE)
11645           {
11646             /* We only get here for friend declarations of
11647                members of other classes.  */
11648             /* All method decls are public, so tell grokfndecl to set
11649                TREE_PUBLIC, also.  */
11650             decl = grokfndecl (ctype, type, declarator, declarator,
11651                                virtualp, flags, quals, raises,
11652                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11653                                template_count, in_namespace);
11654             if (decl == NULL_TREE)
11655               return NULL_TREE;
11656           }
11657         else if (!staticp && ! processing_template_decl
11658                  && !COMPLETE_TYPE_P (complete_type (type))
11659                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11660           {
11661             if (declarator)
11662               error ("field `%D' has incomplete type", declarator);
11663             else
11664               error ("name `%T' has incomplete type", type);
11665
11666             /* If we're instantiating a template, tell them which
11667                instantiation made the field's type be incomplete.  */
11668             if (current_class_type
11669                 && TYPE_NAME (current_class_type)
11670                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11671                 && declspecs && TREE_VALUE (declspecs)
11672                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11673               error ("  in instantiation of template `%T'",
11674                         current_class_type);
11675
11676             type = error_mark_node;
11677             decl = NULL_TREE;
11678           }
11679         else
11680           {
11681             if (friendp)
11682               {
11683                 error ("`%s' is neither function nor member function; cannot be declared friend",
11684                        IDENTIFIER_POINTER (declarator));
11685                 friendp = 0;
11686               }
11687             decl = NULL_TREE;
11688           }
11689
11690         if (friendp)
11691           {
11692             /* Friends are treated specially.  */
11693             if (ctype == current_class_type)
11694               warning ("member functions are implicitly friends of their class");
11695             else
11696               {
11697                 tree t = NULL_TREE;
11698                 if (decl && DECL_NAME (decl))
11699                   {
11700                     if (template_class_depth (current_class_type) == 0)
11701                       {
11702                         decl
11703                           = check_explicit_specialization
11704                           (declarator, decl,
11705                            template_count, 2 * (funcdef_flag != 0) + 4);
11706                         if (decl == error_mark_node)
11707                           return error_mark_node;
11708                       }
11709
11710                     t = do_friend (ctype, declarator, decl,
11711                                    last_function_parms, *attrlist,
11712                                    flags, quals, funcdef_flag);
11713                   }
11714                 if (t && funcdef_flag)
11715                   return t;
11716
11717                 return void_type_node;
11718               }
11719           }
11720
11721         /* Structure field.  It may not be a function, except for C++ */
11722
11723         if (decl == NULL_TREE)
11724           {
11725             if (initialized)
11726               {
11727                 if (!staticp)
11728                   {
11729                     /* An attempt is being made to initialize a non-static
11730                        member.  But, from [class.mem]:
11731
11732                        4 A member-declarator can contain a
11733                        constant-initializer only if it declares a static
11734                        member (_class.static_) of integral or enumeration
11735                        type, see _class.static.data_.
11736
11737                        This used to be relatively common practice, but
11738                        the rest of the compiler does not correctly
11739                        handle the initialization unless the member is
11740                        static so we make it static below.  */
11741                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11742                                 declarator);
11743                     pedwarn ("making `%D' static", declarator);
11744                     staticp = 1;
11745                   }
11746
11747                 if (uses_template_parms (type))
11748                   /* We'll check at instantiation time.  */
11749                   ;
11750                 else if (check_static_variable_definition (declarator,
11751                                                            type))
11752                   /* If we just return the declaration, crashes
11753                      will sometimes occur.  We therefore return
11754                      void_type_node, as if this was a friend
11755                      declaration, to cause callers to completely
11756                      ignore this declaration.  */
11757                   return void_type_node;
11758               }
11759
11760             /* 9.2p13 [class.mem] */
11761             if (declarator == constructor_name (current_class_type)
11762                 /* The standard does not allow non-static data members
11763                    here either, but we agreed at the 10/99 meeting
11764                    to change that in TC 1 so that they are allowed in
11765                    classes with no user-defined constructors.  */
11766                 && staticp)
11767               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11768                           declarator);
11769
11770             if (staticp)
11771               {
11772                 /* C++ allows static class members.  All other work
11773                    for this is done by grokfield.  */
11774                 decl = build_lang_decl (VAR_DECL, declarator, type);
11775                 TREE_STATIC (decl) = 1;
11776                 /* In class context, 'static' means public access.  */
11777                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11778               }
11779             else
11780               {
11781                 decl = build_decl (FIELD_DECL, declarator, type);
11782                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11783                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11784                   {
11785                     DECL_MUTABLE_P (decl) = 1;
11786                     RIDBIT_RESET (RID_MUTABLE, specbits);
11787                   }
11788               }
11789
11790             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11791                             inlinep, friendp, raises != NULL_TREE);
11792           }
11793       }
11794     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11795       {
11796         tree original_name;
11797         int publicp = 0;
11798
11799         if (! declarator)
11800           return NULL_TREE;
11801
11802         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11803           original_name = dname;
11804         else
11805           original_name = declarator;
11806
11807         if (RIDBIT_SETP (RID_AUTO, specbits))
11808           error ("storage class `auto' invalid for function `%s'", name);
11809         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11810           error ("storage class `register' invalid for function `%s'", name);
11811
11812         /* Function declaration not at top level.
11813            Storage classes other than `extern' are not allowed
11814            and `extern' makes no difference.  */
11815         if (! toplevel_bindings_p ()
11816             && (RIDBIT_SETP (RID_STATIC, specbits)
11817                 || RIDBIT_SETP (RID_INLINE, specbits))
11818             && pedantic)
11819           {
11820             if (RIDBIT_SETP (RID_STATIC, specbits))
11821               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11822             else
11823               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11824           }
11825
11826         if (ctype == NULL_TREE)
11827           {
11828             if (virtualp)
11829               {
11830                 error ("virtual non-class function `%s'", name);
11831                 virtualp = 0;
11832               }
11833           }
11834         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11835           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11836                                           TYPE_ARG_TYPES (type));
11837
11838         /* Record presence of `static'.  */
11839         publicp = (ctype != NULL_TREE
11840                    || RIDBIT_SETP (RID_EXTERN, specbits)
11841                    || !RIDBIT_SETP (RID_STATIC, specbits));
11842
11843         decl = grokfndecl (ctype, type, original_name, declarator,
11844                            virtualp, flags, quals, raises,
11845                            1, friendp,
11846                            publicp, inlinep, funcdef_flag,
11847                            template_count, in_namespace);
11848         if (decl == NULL_TREE)
11849           return NULL_TREE;
11850
11851         if (staticp == 1)
11852           {
11853             int illegal_static = 0;
11854
11855             /* Don't allow a static member function in a class, and forbid
11856                declaring main to be static.  */
11857             if (TREE_CODE (type) == METHOD_TYPE)
11858               {
11859                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11860                 illegal_static = 1;
11861               }
11862             else if (current_function_decl)
11863               {
11864                 /* FIXME need arm citation */
11865                 error ("cannot declare static function inside another function");
11866                 illegal_static = 1;
11867               }
11868
11869             if (illegal_static)
11870               {
11871                 staticp = 0;
11872                 RIDBIT_RESET (RID_STATIC, specbits);
11873               }
11874           }
11875       }
11876     else
11877       {
11878         /* It's a variable.  */
11879
11880         /* An uninitialized decl with `extern' is a reference.  */
11881         decl = grokvardecl (type, declarator, &specbits,
11882                             initialized,
11883                             (type_quals & TYPE_QUAL_CONST) != 0,
11884                             in_namespace);
11885         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11886                         inlinep, friendp, raises != NULL_TREE);
11887
11888         if (ctype)
11889           {
11890             DECL_CONTEXT (decl) = ctype;
11891             if (staticp == 1)
11892               {
11893                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11894                 staticp = 0;
11895                 RIDBIT_RESET (RID_STATIC, specbits);
11896               }
11897             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11898               {
11899                 error ("static member `%D' declared `register'", decl);
11900                 RIDBIT_RESET (RID_REGISTER, specbits);
11901               }
11902             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11903               {
11904                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11905                             decl);
11906                 RIDBIT_RESET (RID_EXTERN, specbits);
11907               }
11908           }
11909       }
11910
11911     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11912
11913     /* Record `register' declaration for warnings on &
11914        and in case doing stupid register allocation.  */
11915
11916     if (RIDBIT_SETP (RID_REGISTER, specbits))
11917       DECL_REGISTER (decl) = 1;
11918
11919     if (RIDBIT_SETP (RID_EXTERN, specbits))
11920       DECL_THIS_EXTERN (decl) = 1;
11921
11922     if (RIDBIT_SETP (RID_STATIC, specbits))
11923       DECL_THIS_STATIC (decl) = 1;
11924
11925     /* Record constancy and volatility.  There's no need to do this
11926        when processing a template; we'll do this for the instantiated
11927        declaration based on the type of DECL.  */
11928     if (!processing_template_decl)
11929       c_apply_type_quals_to_decl (type_quals, decl);
11930
11931     return decl;
11932   }
11933 }
11934 \f
11935 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11936    An empty exprlist is a parmlist.  An exprlist which
11937    contains only identifiers at the global level
11938    is a parmlist.  Otherwise, it is an exprlist.  */
11939
11940 int
11941 parmlist_is_exprlist (exprs)
11942      tree exprs;
11943 {
11944   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11945     return 0;
11946
11947   if (toplevel_bindings_p ())
11948     {
11949       /* At the global level, if these are all identifiers,
11950          then it is a parmlist.  */
11951       while (exprs)
11952         {
11953           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11954             return 1;
11955           exprs = TREE_CHAIN (exprs);
11956         }
11957       return 0;
11958     }
11959   return 1;
11960 }
11961
11962 /* Subroutine of start_function.  Ensure that each of the parameter
11963    types (as listed in PARMS) is complete, as is required for a
11964    function definition.  */
11965
11966 static void
11967 require_complete_types_for_parms (parms)
11968      tree parms;
11969 {
11970   for (; parms; parms = TREE_CHAIN (parms))
11971     {
11972       if (VOID_TYPE_P (TREE_TYPE (parms)))
11973         /* grokparms will have already issued an error */
11974         TREE_TYPE (parms) = error_mark_node;
11975       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11976         layout_decl (parms, 0);
11977       else
11978         TREE_TYPE (parms) = error_mark_node;
11979     }
11980 }
11981
11982 /* Returns non-zero if T is a local variable.  */
11983
11984 int
11985 local_variable_p (t)
11986      tree t;
11987 {
11988   if ((TREE_CODE (t) == VAR_DECL
11989        /* A VAR_DECL with a context that is a _TYPE is a static data
11990           member.  */
11991        && !TYPE_P (CP_DECL_CONTEXT (t))
11992        /* Any other non-local variable must be at namespace scope.  */
11993        && !DECL_NAMESPACE_SCOPE_P (t))
11994       || (TREE_CODE (t) == PARM_DECL))
11995     return 1;
11996
11997   return 0;
11998 }
11999
12000 /* Returns non-zero if T is an automatic local variable or a label.
12001    (These are the declarations that need to be remapped when the code
12002    containing them is duplicated.)  */
12003
12004 int
12005 nonstatic_local_decl_p (t)
12006      tree t;
12007 {
12008   return ((local_variable_p (t) && !TREE_STATIC (t))
12009           || TREE_CODE (t) == LABEL_DECL
12010           || TREE_CODE (t) == RESULT_DECL);
12011 }
12012
12013 /* Like local_variable_p, but suitable for use as a tree-walking
12014    function.  */
12015
12016 static tree
12017 local_variable_p_walkfn (tp, walk_subtrees, data)
12018      tree *tp;
12019      int *walk_subtrees ATTRIBUTE_UNUSED;
12020      void *data ATTRIBUTE_UNUSED;
12021 {
12022   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
12023           ? *tp : NULL_TREE);
12024 }
12025
12026 /* Check that ARG, which is a default-argument expression for a
12027    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
12028    something goes wrong.  DECL may also be a _TYPE node, rather than a
12029    DECL, if there is no DECL available.  */
12030
12031 tree
12032 check_default_argument (decl, arg)
12033      tree decl;
12034      tree arg;
12035 {
12036   tree var;
12037   tree decl_type;
12038
12039   if (TREE_CODE (arg) == DEFAULT_ARG)
12040     /* We get a DEFAULT_ARG when looking at an in-class declaration
12041        with a default argument.  Ignore the argument for now; we'll
12042        deal with it after the class is complete.  */
12043     return arg;
12044
12045   if (processing_template_decl || uses_template_parms (arg))
12046     /* We don't do anything checking until instantiation-time.  Note
12047        that there may be uninstantiated arguments even for an
12048        instantiated function, since default arguments are not
12049        instantiated until they are needed.  */
12050     return arg;
12051
12052   if (TYPE_P (decl))
12053     {
12054       decl_type = decl;
12055       decl = NULL_TREE;
12056     }
12057   else
12058     decl_type = TREE_TYPE (decl);
12059
12060   if (arg == error_mark_node
12061       || decl == error_mark_node
12062       || TREE_TYPE (arg) == error_mark_node
12063       || decl_type == error_mark_node)
12064     /* Something already went wrong.  There's no need to check
12065        further.  */
12066     return error_mark_node;
12067
12068   /* [dcl.fct.default]
12069
12070      A default argument expression is implicitly converted to the
12071      parameter type.  */
12072   if (!TREE_TYPE (arg)
12073       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12074     {
12075       if (decl)
12076         error ("default argument for `%#D' has type `%T'",
12077                   decl, TREE_TYPE (arg));
12078       else
12079         error ("default argument for parameter of type `%T' has type `%T'",
12080                   decl_type, TREE_TYPE (arg));
12081
12082       return error_mark_node;
12083     }
12084
12085   /* [dcl.fct.default]
12086
12087      Local variables shall not be used in default argument
12088      expressions.
12089
12090      The keyword `this' shall not be used in a default argument of a
12091      member function.  */
12092   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12093                                       NULL);
12094   if (var)
12095     {
12096       error ("default argument `%E' uses local variable `%D'",
12097                 arg, var);
12098       return error_mark_node;
12099     }
12100
12101   /* All is well.  */
12102   return arg;
12103 }
12104
12105 /* Decode the list of parameter types for a function type.
12106    Given the list of things declared inside the parens,
12107    return a list of types.
12108
12109    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
12110    flag. If unset, we append void_list_node. A parmlist declared
12111    as `(void)' is accepted as the empty parmlist.
12112
12113    Also set last_function_parms to the chain of PARM_DECLs.  */
12114
12115 static tree
12116 grokparms (first_parm)
12117      tree first_parm;
12118 {
12119   tree result = NULL_TREE;
12120   tree decls = NULL_TREE;
12121   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12122   tree parm, chain;
12123   int any_error = 0;
12124
12125   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12126
12127   for (parm = first_parm; parm != NULL_TREE; parm = chain)
12128     {
12129       tree type = NULL_TREE;
12130       tree decl = TREE_VALUE (parm);
12131       tree init = TREE_PURPOSE (parm);
12132       tree specs, attrs;
12133
12134       chain = TREE_CHAIN (parm);
12135       /* @@ weak defense against parse errors.  */
12136       if (TREE_CODE (decl) != VOID_TYPE
12137           && TREE_CODE (decl) != TREE_LIST)
12138         {
12139           /* Give various messages as the need arises.  */
12140           if (TREE_CODE (decl) == STRING_CST)
12141             error ("invalid string constant `%E'", decl);
12142           else if (TREE_CODE (decl) == INTEGER_CST)
12143             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12144           continue;
12145         }
12146
12147       if (parm == void_list_node)
12148         break;
12149
12150       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12151       decl = grokdeclarator (TREE_VALUE (decl), specs,
12152                              PARM, init != NULL_TREE, &attrs);
12153       if (! decl || TREE_TYPE (decl) == error_mark_node)
12154         continue;
12155
12156       if (attrs)
12157         cplus_decl_attributes (&decl, attrs, 0);
12158
12159       type = TREE_TYPE (decl);
12160       if (VOID_TYPE_P (type))
12161         {
12162           if (same_type_p (type, void_type_node)
12163               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12164             /* this is a parmlist of `(void)', which is ok.  */
12165             break;
12166           incomplete_type_error (decl, type);
12167           /* It's not a good idea to actually create parameters of
12168              type `void'; other parts of the compiler assume that a
12169              void type terminates the parameter list.  */
12170           type = error_mark_node;
12171           TREE_TYPE (decl) = error_mark_node;
12172         }
12173
12174       if (type != error_mark_node)
12175         {
12176           /* Top-level qualifiers on the parameters are
12177              ignored for function types.  */
12178           type = TYPE_MAIN_VARIANT (type);
12179           if (TREE_CODE (type) == METHOD_TYPE)
12180             {
12181               error ("parameter `%D' invalidly declared method type", decl);
12182               type = build_pointer_type (type);
12183               TREE_TYPE (decl) = type;
12184             }
12185           else if (TREE_CODE (type) == OFFSET_TYPE)
12186             {
12187               error ("parameter `%D' invalidly declared offset type", decl);
12188               type = build_pointer_type (type);
12189               TREE_TYPE (decl) = type;
12190             }
12191           else if (abstract_virtuals_error (decl, type))
12192             any_error = 1;  /* Seems like a good idea. */
12193           else if (POINTER_TYPE_P (type))
12194             {
12195               /* [dcl.fct]/6, parameter types cannot contain pointers
12196                  (references) to arrays of unknown bound.  */
12197               tree t = TREE_TYPE (type);
12198               int ptr = TYPE_PTR_P (type);
12199
12200               while (1)
12201                 {
12202                   if (TYPE_PTR_P (t))
12203                     ptr = 1;
12204                   else if (TREE_CODE (t) != ARRAY_TYPE)
12205                     break;
12206                   else if (!TYPE_DOMAIN (t))
12207                     break;
12208                   t = TREE_TYPE (t);
12209                 }
12210               if (TREE_CODE (t) == ARRAY_TYPE)
12211                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12212                           decl, ptr ? "pointer" : "reference", t);
12213             }
12214
12215           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12216           if (PROMOTE_PROTOTYPES
12217               && INTEGRAL_TYPE_P (type)
12218               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12219             DECL_ARG_TYPE (decl) = integer_type_node;
12220           if (!any_error && init)
12221             init = check_default_argument (decl, init);
12222           else
12223             init = NULL_TREE;
12224         }
12225
12226       TREE_CHAIN (decl) = decls;
12227       decls = decl;
12228       result = tree_cons (init, type, result);
12229     }
12230   decls = nreverse (decls);
12231   result = nreverse (result);
12232   if (!ellipsis)
12233     result = chainon (result, void_list_node);
12234   last_function_parms = decls;
12235
12236   return result;
12237 }
12238
12239 \f
12240 /* D is a constructor or overloaded `operator='.
12241
12242    Let T be the class in which D is declared. Then, this function
12243    returns:
12244
12245    -1 if D's is an ill-formed constructor or copy assignment operator
12246       whose first parameter is of type `T'.
12247    0  if D is not a copy constructor or copy assignment
12248       operator.
12249    1  if D is a copy constructor or copy assignment operator whose
12250       first parameter is a reference to const qualified T.
12251    2  if D is a copy constructor or copy assignment operator whose
12252       first parameter is a reference to non-const qualified T.
12253
12254    This function can be used as a predicate. Positive values indicate
12255    a copy constructor and non-zero values indicate a copy assignment
12256    operator.  */
12257
12258 int
12259 copy_fn_p (d)
12260      tree d;
12261 {
12262   tree args;
12263   tree arg_type;
12264   int result = 1;
12265
12266   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12267
12268   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12269     /* Instantiations of template member functions are never copy
12270        functions.  Note that member functions of templated classes are
12271        represented as template functions internally, and we must
12272        accept those as copy functions.  */
12273     return 0;
12274
12275   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12276   if (!args)
12277     return 0;
12278
12279   arg_type = TREE_VALUE (args);
12280
12281   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12282     {
12283       /* Pass by value copy assignment operator.  */
12284       result = -1;
12285     }
12286   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12287            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12288     {
12289       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12290         result = 2;
12291     }
12292   else
12293     return 0;
12294
12295   args = TREE_CHAIN (args);
12296
12297   if (args && args != void_list_node && !TREE_PURPOSE (args))
12298     /* There are more non-optional args.  */
12299     return 0;
12300
12301   return result;
12302 }
12303
12304 /* Remember any special properties of member function DECL.  */
12305
12306 void grok_special_member_properties (decl)
12307      tree decl;
12308 {
12309   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12310     ; /* Not special.  */
12311   else if (DECL_CONSTRUCTOR_P (decl))
12312     {
12313       int ctor = copy_fn_p (decl);
12314
12315       if (ctor > 0)
12316         {
12317           /* [class.copy]
12318
12319              A non-template constructor for class X is a copy
12320              constructor if its first parameter is of type X&, const
12321              X&, volatile X& or const volatile X&, and either there
12322              are no other parameters or else all other parameters have
12323              default arguments.  */
12324           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12325           if (ctor > 1)
12326             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12327         }
12328       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12329         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12330     }
12331   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12332     {
12333       /* [class.copy]
12334
12335          A non-template assignment operator for class X is a copy
12336          assignment operator if its parameter is of type X, X&, const
12337          X&, volatile X& or const volatile X&.  */
12338
12339       int assop = copy_fn_p (decl);
12340
12341       if (assop)
12342         {
12343           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12344           if (assop != 1)
12345             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12346           if (DECL_PURE_VIRTUAL_P (decl))
12347             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12348         }
12349     }
12350 }
12351
12352 /* Check a constructor DECL has the correct form.  Complains
12353    if the class has a constructor of the form X(X).  */
12354
12355 int
12356 grok_ctor_properties (ctype, decl)
12357      tree ctype, decl;
12358 {
12359   int ctor_parm = copy_fn_p (decl);
12360
12361   if (ctor_parm < 0)
12362     {
12363       /* [class.copy]
12364
12365          A declaration of a constructor for a class X is ill-formed if
12366          its first parameter is of type (optionally cv-qualified) X
12367          and either there are no other parameters or else all other
12368          parameters have default arguments.
12369
12370          We *don't* complain about member template instantiations that
12371          have this form, though; they can occur as we try to decide
12372          what constructor to use during overload resolution.  Since
12373          overload resolution will never prefer such a constructor to
12374          the non-template copy constructor (which is either explicitly
12375          or implicitly defined), there's no need to worry about their
12376          existence.  Theoretically, they should never even be
12377          instantiated, but that's hard to forestall.  */
12378       error ("invalid constructor; you probably meant `%T (const %T&)'",
12379                 ctype, ctype);
12380       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12381       return 0;
12382     }
12383
12384   return 1;
12385 }
12386
12387 /* An operator with this code is unary, but can also be binary.  */
12388
12389 static int
12390 ambi_op_p (code)
12391      enum tree_code code;
12392 {
12393   return (code == INDIRECT_REF
12394           || code == ADDR_EXPR
12395           || code == CONVERT_EXPR
12396           || code == NEGATE_EXPR
12397           || code == PREINCREMENT_EXPR
12398           || code == PREDECREMENT_EXPR);
12399 }
12400
12401 /* An operator with this name can only be unary.  */
12402
12403 static int
12404 unary_op_p (code)
12405      enum tree_code code;
12406 {
12407   return (code == TRUTH_NOT_EXPR
12408           || code == BIT_NOT_EXPR
12409           || code == COMPONENT_REF
12410           || code == TYPE_EXPR);
12411 }
12412
12413 /* Do a little sanity-checking on how they declared their operator.  */
12414
12415 void
12416 grok_op_properties (decl, friendp)
12417      tree decl;
12418      int friendp;
12419 {
12420   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12421   tree argtype;
12422   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12423   tree name = DECL_NAME (decl);
12424   enum tree_code operator_code;
12425   int arity;
12426
12427   /* Count the number of arguments.  */
12428   for (argtype = argtypes, arity = 0;
12429        argtype && argtype != void_list_node;
12430        argtype = TREE_CHAIN (argtype))
12431     ++arity;
12432
12433   if (current_class_type == NULL_TREE)
12434     friendp = 1;
12435
12436   if (DECL_CONV_FN_P (decl))
12437     operator_code = TYPE_EXPR;
12438   else
12439     do
12440       {
12441 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12442         if (ansi_opname (CODE) == name)                         \
12443           {                                                     \
12444             operator_code = (CODE);                             \
12445             break;                                              \
12446           }                                                     \
12447         else if (ansi_assopname (CODE) == name)                 \
12448           {                                                     \
12449             operator_code = (CODE);                             \
12450             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12451             break;                                              \
12452           }
12453
12454 #include "operators.def"
12455 #undef DEF_OPERATOR
12456
12457         abort ();
12458       }
12459     while (0);
12460   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12461   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12462
12463   if (! friendp)
12464     {
12465       switch (operator_code)
12466         {
12467         case CALL_EXPR:
12468           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12469           break;
12470
12471         case ARRAY_REF:
12472           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12473           break;
12474
12475         case COMPONENT_REF:
12476         case MEMBER_REF:
12477           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12478           break;
12479
12480         case NEW_EXPR:
12481           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12482           break;
12483
12484         case DELETE_EXPR:
12485           TYPE_GETS_DELETE (current_class_type) |= 1;
12486           break;
12487
12488         case VEC_NEW_EXPR:
12489           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12490           break;
12491
12492         case VEC_DELETE_EXPR:
12493           TYPE_GETS_DELETE (current_class_type) |= 2;
12494           break;
12495
12496         default:
12497           break;
12498         }
12499     }
12500
12501   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12502     {
12503       /* When the compiler encounters the definition of A::operator new, it
12504          doesn't look at the class declaration to find out if it's static.  */
12505       if (methodp)
12506         revert_static_member_fn (decl);
12507
12508       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12509     }
12510   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12511     {
12512       if (methodp)
12513         revert_static_member_fn (decl);
12514
12515       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12516     }
12517   else
12518     {
12519       /* An operator function must either be a non-static member function
12520          or have at least one parameter of a class, a reference to a class,
12521          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12522       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12523         {
12524           if (operator_code == TYPE_EXPR
12525               || operator_code == CALL_EXPR
12526               || operator_code == COMPONENT_REF
12527               || operator_code == ARRAY_REF
12528               || operator_code == NOP_EXPR)
12529             error ("`%D' must be a nonstatic member function", decl);
12530           else
12531             {
12532               tree p = argtypes;
12533
12534               if (DECL_STATIC_FUNCTION_P (decl))
12535                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12536
12537               if (p)
12538                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12539                   {
12540                     tree arg = TREE_VALUE (p);
12541                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12542                       arg = TREE_TYPE (arg);
12543
12544                     /* This lets bad template code slip through.  */
12545                     if (IS_AGGR_TYPE (arg)
12546                         || TREE_CODE (arg) == ENUMERAL_TYPE
12547                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12548                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12549                       goto foundaggr;
12550                   }
12551               error
12552                 ("`%D' must have an argument of class or enumerated type",
12553                  decl);
12554             foundaggr:
12555               ;
12556             }
12557         }
12558
12559       if (operator_code == CALL_EXPR)
12560         return;                 /* No restrictions on args. */
12561
12562       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12563         {
12564           tree t = TREE_TYPE (name);
12565           if (! friendp)
12566             {
12567               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12568               const char *what = 0;
12569
12570               if (ref)
12571                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12572
12573               if (TREE_CODE (t) == VOID_TYPE)
12574                 what = "void";
12575               else if (t == current_class_type)
12576                 what = "the same type";
12577               /* Don't force t to be complete here.  */
12578               else if (IS_AGGR_TYPE (t)
12579                        && COMPLETE_TYPE_P (t)
12580                        && DERIVED_FROM_P (t, current_class_type))
12581                 what = "a base class";
12582
12583               if (what)
12584                 warning ("conversion to %s%s will never use a type conversion operator",
12585                          ref ? "a reference to " : "", what);
12586             }
12587         }
12588       if (operator_code == COND_EXPR)
12589         {
12590           /* 13.4.0.3 */
12591           error ("ISO C++ prohibits overloading operator ?:");
12592         }
12593       else if (ambi_op_p (operator_code))
12594         {
12595           if (arity == 1)
12596             /* We pick the one-argument operator codes by default, so
12597                we don't have to change anything.  */
12598             ;
12599           else if (arity == 2)
12600             {
12601               /* If we thought this was a unary operator, we now know
12602                  it to be a binary operator.  */
12603               switch (operator_code)
12604                 {
12605                 case INDIRECT_REF:
12606                   operator_code = MULT_EXPR;
12607                   break;
12608
12609                 case ADDR_EXPR:
12610                   operator_code = BIT_AND_EXPR;
12611                   break;
12612
12613                 case CONVERT_EXPR:
12614                   operator_code = PLUS_EXPR;
12615                   break;
12616
12617                 case NEGATE_EXPR:
12618                   operator_code = MINUS_EXPR;
12619                   break;
12620
12621                 case PREINCREMENT_EXPR:
12622                   operator_code = POSTINCREMENT_EXPR;
12623                   break;
12624
12625                 case PREDECREMENT_EXPR:
12626                   operator_code = POSTDECREMENT_EXPR;
12627                   break;
12628
12629                 default:
12630                   abort ();
12631                 }
12632
12633               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12634
12635               if ((operator_code == POSTINCREMENT_EXPR
12636                    || operator_code == POSTDECREMENT_EXPR)
12637                   && ! processing_template_decl
12638                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12639                 {
12640                   if (methodp)
12641                     error ("postfix `%D' must take `int' as its argument",
12642                               decl);
12643                   else
12644                     error
12645                       ("postfix `%D' must take `int' as its second argument",
12646                        decl);
12647                 }
12648             }
12649           else
12650             {
12651               if (methodp)
12652                 error ("`%D' must take either zero or one argument", decl);
12653               else
12654                 error ("`%D' must take either one or two arguments", decl);
12655             }
12656
12657           /* More Effective C++ rule 6.  */
12658           if (warn_ecpp
12659               && (operator_code == POSTINCREMENT_EXPR
12660                   || operator_code == POSTDECREMENT_EXPR
12661                   || operator_code == PREINCREMENT_EXPR
12662                   || operator_code == PREDECREMENT_EXPR))
12663             {
12664               tree arg = TREE_VALUE (argtypes);
12665               tree ret = TREE_TYPE (TREE_TYPE (decl));
12666               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12667                 arg = TREE_TYPE (arg);
12668               arg = TYPE_MAIN_VARIANT (arg);
12669               if (operator_code == PREINCREMENT_EXPR
12670                   || operator_code == PREDECREMENT_EXPR)
12671                 {
12672                   if (TREE_CODE (ret) != REFERENCE_TYPE
12673                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12674                                        arg))
12675                     warning ("prefix `%D' should return `%T'", decl,
12676                                 build_reference_type (arg));
12677                 }
12678               else
12679                 {
12680                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12681                     warning ("postfix `%D' should return `%T'", decl, arg);
12682                 }
12683             }
12684         }
12685       else if (unary_op_p (operator_code))
12686         {
12687           if (arity != 1)
12688             {
12689               if (methodp)
12690                 error ("`%D' must take `void'", decl);
12691               else
12692                 error ("`%D' must take exactly one argument", decl);
12693             }
12694         }
12695       else /* if (binary_op_p (operator_code)) */
12696         {
12697           if (arity != 2)
12698             {
12699               if (methodp)
12700                 error ("`%D' must take exactly one argument", decl);
12701               else
12702                 error ("`%D' must take exactly two arguments", decl);
12703             }
12704
12705           /* More Effective C++ rule 7.  */
12706           if (warn_ecpp
12707               && (operator_code == TRUTH_ANDIF_EXPR
12708                   || operator_code == TRUTH_ORIF_EXPR
12709                   || operator_code == COMPOUND_EXPR))
12710             warning ("user-defined `%D' always evaluates both arguments",
12711                         decl);
12712         }
12713
12714       /* Effective C++ rule 23.  */
12715       if (warn_ecpp
12716           && arity == 2
12717           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12718           && (operator_code == PLUS_EXPR
12719               || operator_code == MINUS_EXPR
12720               || operator_code == TRUNC_DIV_EXPR
12721               || operator_code == MULT_EXPR
12722               || operator_code == TRUNC_MOD_EXPR)
12723           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12724         warning ("`%D' should return by value", decl);
12725
12726       /* [over.oper]/8 */
12727       for (; argtypes && argtypes != void_list_node;
12728           argtypes = TREE_CHAIN (argtypes))
12729         if (TREE_PURPOSE (argtypes))
12730           {
12731             TREE_PURPOSE (argtypes) = NULL_TREE;
12732             if (operator_code == POSTINCREMENT_EXPR
12733                 || operator_code == POSTDECREMENT_EXPR)
12734               {
12735                 if (pedantic)
12736                   pedwarn ("`%D' cannot have default arguments", decl);
12737               }
12738             else
12739               error ("`%D' cannot have default arguments", decl);
12740           }
12741
12742     }
12743 }
12744 \f
12745 static const char *
12746 tag_name (code)
12747      enum tag_types code;
12748 {
12749   switch (code)
12750     {
12751     case record_type:
12752       return "struct";
12753     case class_type:
12754       return "class";
12755     case union_type:
12756       return "union ";
12757     case enum_type:
12758       return "enum";
12759     default:
12760       abort ();
12761     }
12762 }
12763
12764 /* Get the struct, enum or union (CODE says which) with tag NAME.
12765    Define the tag as a forward-reference if it is not defined.
12766
12767    C++: If a class derivation is given, process it here, and report
12768    an error if multiple derivation declarations are not identical.
12769
12770    If this is a definition, come in through xref_tag and only look in
12771    the current frame for the name (since C++ allows new names in any
12772    scope.)  */
12773
12774 tree
12775 xref_tag (code_type_node, name, globalize)
12776      tree code_type_node;
12777      tree name;
12778      int globalize;
12779 {
12780   enum tag_types tag_code;
12781   enum tree_code code;
12782   register tree ref, t;
12783   struct binding_level *b = current_binding_level;
12784   tree attributes = NULL_TREE;
12785   tree context = NULL_TREE;
12786
12787   /* If we are called from the parser, code_type_node will sometimes be a
12788      TREE_LIST.  This indicates that the user wrote
12789      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12790      use them later.  */
12791   if (TREE_CODE (code_type_node) == TREE_LIST)
12792     {
12793       attributes = TREE_PURPOSE (code_type_node);
12794       code_type_node = TREE_VALUE (code_type_node);
12795     }
12796
12797   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12798   switch (tag_code)
12799     {
12800     case record_type:
12801     case class_type:
12802       code = RECORD_TYPE;
12803       break;
12804     case union_type:
12805       code = UNION_TYPE;
12806       break;
12807     case enum_type:
12808       code = ENUMERAL_TYPE;
12809       break;
12810     default:
12811       abort ();
12812     }
12813
12814   /* If a cross reference is requested, look up the type
12815      already defined for this tag and return it.  */
12816   if (TYPE_P (name))
12817     {
12818       t = name;
12819       name = TYPE_IDENTIFIER (t);
12820     }
12821   else
12822     t = IDENTIFIER_TYPE_VALUE (name);
12823
12824   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12825   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12826     {
12827       static int explained;
12828       tree shadowed;
12829
12830       warning ("`%s %T' declares a new type at namespace scope",
12831                   tag_name (tag_code), name);
12832       if (!explained++)
12833         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12834                     tag_name (tag_code),
12835                     constructor_name (current_class_type),
12836                     TYPE_IDENTIFIER (t));
12837
12838       /* We need to remove the class scope binding for the
12839          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12840       for (shadowed = b->class_shadowed;
12841            shadowed;
12842            shadowed = TREE_CHAIN (shadowed))
12843         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12844           {
12845             TREE_PURPOSE (shadowed) = NULL_TREE;
12846             break;
12847           }
12848     }
12849
12850   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12851       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12852     t = NULL_TREE;
12853
12854   if (! globalize)
12855     {
12856       /* If we know we are defining this tag, only look it up in
12857          this scope and don't try to find it as a type.  */
12858       ref = lookup_tag (code, name, b, 1);
12859     }
12860   else
12861     {
12862       if (t)
12863         {
12864           ref = follow_tag_typedef (t);
12865
12866           /* [dcl.type.elab] If the identifier resolves to a
12867              typedef-name or a template type-parameter, the
12868              elaborated-type-specifier is ill-formed.  */
12869           if (!ref)
12870             {
12871               pedwarn ("using typedef-name `%D' after `%s'",
12872                        TYPE_NAME (t), tag_name (tag_code));
12873               ref = t;
12874             }
12875           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12876             error ("using template type parameter `%T' after `%s'",
12877                    t, tag_name (tag_code));
12878         }
12879       else
12880         ref = lookup_tag (code, name, b, 0);
12881
12882       if (! ref)
12883         {
12884           /* Try finding it as a type declaration.  If that wins,
12885              use it.  */
12886           ref = lookup_name (name, 1);
12887
12888           if (ref != NULL_TREE
12889               && processing_template_decl
12890               && DECL_CLASS_TEMPLATE_P (ref)
12891               && template_class_depth (current_class_type) == 0)
12892             /* Since GLOBALIZE is true, we're declaring a global
12893                template, so we want this type.  */
12894             ref = DECL_TEMPLATE_RESULT (ref);
12895
12896           if (ref && TREE_CODE (ref) == TYPE_DECL
12897               && TREE_CODE (TREE_TYPE (ref)) == code)
12898             ref = TREE_TYPE (ref);
12899           else
12900             ref = NULL_TREE;
12901         }
12902
12903       if (ref && current_class_type
12904           && template_class_depth (current_class_type)
12905           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12906         {
12907           /* Since GLOBALIZE is non-zero, we are not looking at a
12908              definition of this tag.  Since, in addition, we are currently
12909              processing a (member) template declaration of a template
12910              class, we must be very careful; consider:
12911
12912                template <class X>
12913                struct S1
12914
12915                template <class U>
12916                struct S2
12917                { template <class V>
12918                friend struct S1; };
12919
12920              Here, the S2::S1 declaration should not be confused with the
12921              outer declaration.  In particular, the inner version should
12922              have a template parameter of level 2, not level 1.  This
12923              would be particularly important if the member declaration
12924              were instead:
12925
12926                template <class V = U> friend struct S1;
12927
12928              say, when we should tsubst into `U' when instantiating
12929              S2.  On the other hand, when presented with:
12930
12931                  template <class T>
12932                  struct S1 {
12933                    template <class U>
12934                    struct S2 {};
12935                    template <class U>
12936                    friend struct S2;
12937                  };
12938
12939               we must find the inner binding eventually.  We
12940               accomplish this by making sure that the new type we
12941               create to represent this declaration has the right
12942               TYPE_CONTEXT.  */
12943           context = TYPE_CONTEXT (ref);
12944           ref = NULL_TREE;
12945         }
12946     }
12947
12948   if (! ref)
12949     {
12950       /* If no such tag is yet defined, create a forward-reference node
12951          and record it as the "definition".
12952          When a real declaration of this type is found,
12953          the forward-reference will be altered into a real type.  */
12954       if (code == ENUMERAL_TYPE)
12955         {
12956           error ("use of enum `%#D' without previous declaration", name);
12957
12958           ref = make_node (ENUMERAL_TYPE);
12959
12960           /* Give the type a default layout like unsigned int
12961              to avoid crashing if it does not get defined.  */
12962           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12963           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12964           TYPE_USER_ALIGN (ref) = 0;
12965           TREE_UNSIGNED (ref) = 1;
12966           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12967           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12968           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12969
12970           /* Enable us to recognize when a type is created in class context.
12971              To do nested classes correctly, this should probably be cleared
12972              out when we leave this classes scope.  Currently this in only
12973              done in `start_enum'.  */
12974
12975           pushtag (name, ref, globalize);
12976         }
12977       else
12978         {
12979           struct binding_level *old_b = class_binding_level;
12980
12981           ref = make_aggr_type (code);
12982           TYPE_CONTEXT (ref) = context;
12983
12984 #ifdef NONNESTED_CLASSES
12985           /* Class types don't nest the way enums do.  */
12986           class_binding_level = (struct binding_level *)0;
12987 #endif
12988           pushtag (name, ref, globalize);
12989           class_binding_level = old_b;
12990         }
12991     }
12992   else
12993     {
12994       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12995         redeclare_class_template (ref, current_template_parms);
12996     }
12997
12998   TYPE_ATTRIBUTES (ref) = attributes;
12999
13000   return ref;
13001 }
13002
13003 tree
13004 xref_tag_from_type (old, id, globalize)
13005      tree old, id;
13006      int globalize;
13007 {
13008   tree code_type_node;
13009
13010   if (TREE_CODE (old) == RECORD_TYPE)
13011     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
13012                       ? class_type_node : record_type_node);
13013   else
13014     code_type_node = union_type_node;
13015
13016   if (id == NULL_TREE)
13017     id = TYPE_IDENTIFIER (old);
13018
13019   return xref_tag (code_type_node, id, globalize);
13020 }
13021
13022 /* REF is a type (named NAME), for which we have just seen some
13023    baseclasses.  BINFO is a list of those baseclasses; the
13024    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13025    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13026    struct, or union.  */
13027
13028 void
13029 xref_basetypes (code_type_node, name, ref, binfo)
13030      tree code_type_node;
13031      tree name ATTRIBUTE_UNUSED;
13032      tree ref;
13033      tree binfo;
13034 {
13035   /* In the declaration `A : X, Y, ... Z' we mark all the types
13036      (A, X, Y, ..., Z) so we can check for duplicates.  */
13037   tree binfos;
13038   tree base;
13039
13040   int i, len;
13041   enum tag_types tag_code;
13042
13043   /* If we are called from the parser, code_type_node will sometimes be a
13044      TREE_LIST.  This indicates that the user wrote
13045      "class __attribute__ ((foo)) bar".  Extract the attributes so that
13046      tree_low_cst doesn't crash.  */
13047   if (TREE_CODE (code_type_node) == TREE_LIST)
13048     code_type_node = TREE_VALUE (code_type_node);
13049
13050   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
13051
13052   if (tag_code == union_type)
13053     {
13054       error ("derived union `%T' invalid", ref);
13055       return;
13056     }
13057
13058   len = list_length (binfo);
13059
13060   /* First, make sure that any templates in base-classes are
13061      instantiated.  This ensures that if we call ourselves recursively
13062      we do not get confused about which classes are marked and which
13063      are not.  */
13064   for (base = binfo; base; base = TREE_CHAIN (base))
13065     complete_type (TREE_VALUE (base));
13066
13067   SET_CLASSTYPE_MARKED (ref);
13068   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13069
13070   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13071     {
13072       /* The base of a derived struct is public by default.  */
13073       int via_public
13074         = (TREE_PURPOSE (binfo) == access_public_node
13075            || TREE_PURPOSE (binfo) == access_public_virtual_node
13076            || (tag_code != class_type
13077                && (TREE_PURPOSE (binfo) == access_default_node
13078                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13079       int via_protected
13080         = (TREE_PURPOSE (binfo) == access_protected_node
13081            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13082       int via_virtual
13083         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13084            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13085            || TREE_PURPOSE (binfo) == access_public_virtual_node
13086            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13087       tree basetype = TREE_VALUE (binfo);
13088       tree base_binfo;
13089
13090       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13091         basetype = TREE_TYPE (basetype);
13092       if (!basetype
13093           || (TREE_CODE (basetype) != RECORD_TYPE
13094               && TREE_CODE (basetype) != TYPENAME_TYPE
13095               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13096               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13097         {
13098           error ("base type `%T' fails to be a struct or class type",
13099                     TREE_VALUE (binfo));
13100           continue;
13101         }
13102
13103       /* This code replaces similar code in layout_basetypes.
13104          We put the complete_type first for implicit `typename'.  */
13105       if (!COMPLETE_TYPE_P (basetype)
13106           && ! (current_template_parms && uses_template_parms (basetype)))
13107         {
13108           error ("base class `%T' has incomplete type", basetype);
13109           continue;
13110         }
13111       else
13112         {
13113           if (CLASSTYPE_MARKED (basetype))
13114             {
13115               if (basetype == ref)
13116                 error ("recursive type `%T' undefined", basetype);
13117               else
13118                 error ("duplicate base type `%T' invalid", basetype);
13119               continue;
13120             }
13121
13122           if (TYPE_FOR_JAVA (basetype)
13123               && (current_lang_depth () == 0))
13124             TYPE_FOR_JAVA (ref) = 1;
13125
13126           /* Note that the BINFO records which describe individual
13127              inheritances are *not* shared in the lattice!  They
13128              cannot be shared because a given baseclass may be
13129              inherited with different `accessibility' by different
13130              derived classes.  (Each BINFO record describing an
13131              individual inheritance contains flags which say what
13132              the `accessibility' of that particular inheritance is.)  */
13133
13134           base_binfo
13135             = make_binfo (size_zero_node, basetype,
13136                           CLASS_TYPE_P (basetype)
13137                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13138                           CLASS_TYPE_P (basetype)
13139                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13140
13141           TREE_VEC_ELT (binfos, i) = base_binfo;
13142           TREE_VIA_PUBLIC (base_binfo) = via_public;
13143           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13144           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13145           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13146
13147           /* We need to unshare the binfos now so that lookups during class
13148              definition work.  */
13149           unshare_base_binfos (base_binfo);
13150
13151           SET_CLASSTYPE_MARKED (basetype);
13152
13153           /* We are free to modify these bits because they are meaningless
13154              at top level, and BASETYPE is a top-level type.  */
13155           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13156             {
13157               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13158               /* Converting to a virtual base class requires looking
13159                  up the offset of the virtual base.  */
13160               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13161             }
13162
13163           if (CLASS_TYPE_P (basetype))
13164             {
13165               TYPE_HAS_NEW_OPERATOR (ref)
13166                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13167               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13168                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13169               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13170               /* If the base-class uses multiple inheritance, so do we.  */
13171               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13172                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13173               /* Likewise, if converting to a base of the base may require
13174                  code, then we may need to generate code to convert to a
13175                  base as well.  */
13176               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13177                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13178             }
13179
13180           i += 1;
13181         }
13182     }
13183   if (i)
13184     TREE_VEC_LENGTH (binfos) = i;
13185   else
13186     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13187
13188   if (i > 1)
13189     {
13190       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13191       /* If there is more than one non-empty they cannot be at the same
13192          address.  */
13193       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13194     }
13195
13196   /* Unmark all the types.  */
13197   while (--i >= 0)
13198     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13199   CLEAR_CLASSTYPE_MARKED (ref);
13200
13201   /* Now that we know all the base-classes, set up the list of virtual
13202      bases.  */
13203   get_vbase_types (ref);
13204 }
13205
13206 \f
13207 /* Begin compiling the definition of an enumeration type.
13208    NAME is its name (or null if anonymous).
13209    Returns the type object, as yet incomplete.
13210    Also records info about it so that build_enumerator
13211    may be used to declare the individual values as they are read.  */
13212
13213 tree
13214 start_enum (name)
13215      tree name;
13216 {
13217   register tree enumtype = NULL_TREE;
13218   struct binding_level *b = current_binding_level;
13219
13220   /* If this is the real definition for a previous forward reference,
13221      fill in the contents in the same object that used to be the
13222      forward reference.  */
13223
13224   if (name != NULL_TREE)
13225     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13226
13227   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13228     {
13229       error ("multiple definition of `%#T'", enumtype);
13230       cp_error_at ("previous definition here", enumtype);
13231       /* Clear out TYPE_VALUES, and start again.  */
13232       TYPE_VALUES (enumtype) = NULL_TREE;
13233     }
13234   else
13235     {
13236       enumtype = make_node (ENUMERAL_TYPE);
13237       pushtag (name, enumtype, 0);
13238     }
13239
13240   return enumtype;
13241 }
13242
13243 /* After processing and defining all the values of an enumeration type,
13244    install their decls in the enumeration type and finish it off.
13245    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13246
13247 void
13248 finish_enum (enumtype)
13249      tree enumtype;
13250 {
13251   tree pair;
13252   tree minnode;
13253   tree maxnode;
13254   tree t;
13255   bool unsignedp;
13256   int lowprec;
13257   int highprec;
13258   int precision;
13259
13260   /* We built up the VALUES in reverse order.  */
13261   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13262
13263   /* [dcl.enum]
13264
13265      Following the closing brace of an enum-specifier, each
13266      enumerator has the type of its enumeration.  Prior to the
13267      closing brace, the type of each enumerator is the type of
13268      its initializing value.  */
13269   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13270     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13271
13272   /* For a enum defined in a template, all further processing is
13273      postponed until the template is instantiated.  */
13274   if (processing_template_decl)
13275     {
13276       tree scope = current_scope ();
13277       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13278         add_stmt (build_min (TAG_DEFN, enumtype));
13279
13280
13281       return;
13282     }
13283
13284   /* Figure out what the minimum and maximum values of the enumerators
13285      are.  */
13286   if (TYPE_VALUES (enumtype))
13287     {
13288       minnode = maxnode = NULL_TREE;
13289
13290       for (pair = TYPE_VALUES (enumtype);
13291            pair;
13292            pair = TREE_CHAIN (pair))
13293         {
13294           tree value;
13295
13296           value = DECL_INITIAL (TREE_VALUE (pair));
13297
13298           if (!minnode)
13299             minnode = maxnode = value;
13300           else if (tree_int_cst_lt (maxnode, value))
13301             maxnode = value;
13302           else if (tree_int_cst_lt (value, minnode))
13303             minnode = value;
13304         }
13305     }
13306   else
13307     minnode = maxnode = integer_zero_node;
13308
13309   /* Compute the number of bits require to represent all values of the
13310      enumeration.  We must do this before the type of MINNODE and
13311      MAXNODE are transformed, since min_precision relies on the
13312      TREE_TYPE of the value it is passed.  */
13313   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13314   lowprec = min_precision (minnode, unsignedp);
13315   highprec = min_precision (maxnode, unsignedp);
13316   precision = MAX (lowprec, highprec);
13317
13318   /* Set the TREE_TYPE for the values as well.  That's so that when we
13319      call decl_constant_value we get an entity of the right type (but
13320      with the constant value).  In addition, transform the TYPE_VALUES
13321      list to contain the values, rather than the CONST_DECLs for them.  */
13322   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13323     {
13324       tree value = DECL_INITIAL (TREE_VALUE (pair));
13325
13326       TREE_TYPE (value) = enumtype;
13327       TREE_VALUE (pair) = value;
13328     }
13329
13330   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13331   TYPE_SIZE (enumtype) = NULL_TREE;
13332   TYPE_PRECISION (enumtype) = precision;
13333   if (unsignedp)
13334     fixup_unsigned_type (enumtype);
13335   else
13336     fixup_signed_type (enumtype);
13337
13338   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13339     /* Use the width of the narrowest normal C type which is wide
13340        enough.  */
13341     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13342                                                 (precision, 1));
13343   else
13344     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13345
13346   TYPE_SIZE (enumtype) = NULL_TREE;
13347   layout_type (enumtype);
13348
13349   /* Fix up all variant types of this enum type.  */
13350   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13351     {
13352       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13353       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13354       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13355       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13356       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13357       TYPE_MODE (t) = TYPE_MODE (enumtype);
13358       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13359       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13360       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13361       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13362     }
13363
13364   /* Finish debugging output for this type.  */
13365   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13366 }
13367
13368 /* Build and install a CONST_DECL for an enumeration constant of the
13369    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13370    Assignment of sequential values by default is handled here.  */
13371
13372 void
13373 build_enumerator (name, value, enumtype)
13374      tree name;
13375      tree value;
13376      tree enumtype;
13377 {
13378   tree decl;
13379   tree context;
13380   tree type;
13381   tree values;
13382
13383   /* Remove no-op casts from the value.  */
13384   if (value)
13385     STRIP_TYPE_NOPS (value);
13386
13387   if (! processing_template_decl)
13388     {
13389       /* Validate and default VALUE.  */
13390       if (value != NULL_TREE)
13391         {
13392           value = decl_constant_value (value);
13393
13394           if (TREE_CODE (value) == INTEGER_CST)
13395             {
13396               value = default_conversion (value);
13397               constant_expression_warning (value);
13398             }
13399           else
13400             {
13401               error ("enumerator value for `%D' not integer constant", name);
13402               value = NULL_TREE;
13403             }
13404         }
13405
13406       /* Default based on previous value.  */
13407       if (value == NULL_TREE && ! processing_template_decl)
13408         {
13409           tree prev_value;
13410
13411           if (TYPE_VALUES (enumtype))
13412             {
13413               /* The next value is the previous value ... */
13414               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13415               /* ... plus one.  */
13416               value = cp_build_binary_op (PLUS_EXPR,
13417                                           prev_value,
13418                                           integer_one_node);
13419
13420               if (tree_int_cst_lt (value, prev_value))
13421                 error ("overflow in enumeration values at `%D'", name);
13422             }
13423           else
13424             value = integer_zero_node;
13425         }
13426
13427       /* Remove no-op casts from the value.  */
13428       if (value)
13429         STRIP_TYPE_NOPS (value);
13430 #if 0
13431       /* To fix MAX_VAL enum consts. (bkoz)  */
13432       TREE_TYPE (value) = integer_type_node;
13433 #endif
13434     }
13435
13436   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13437      Even in other cases, we will later (in finish_enum) be setting
13438      the type of VALUE.  But, we don't need to make a copy if this
13439      VALUE is one of the enumeration constants for this same
13440      enumeration type.  */
13441   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13442     if (TREE_VALUE (values) == value)
13443       break;
13444   /* If we didn't break out of the loop, then we do need a copy.  */
13445   if (!values && value)
13446     value = copy_node (value);
13447
13448   /* C++ associates enums with global, function, or class declarations.  */
13449   context = current_scope ();
13450
13451   /* Build the actual enumeration constant.  Note that the enumeration
13452     constants have the type of their initializers until the
13453     enumeration is complete:
13454
13455       [ dcl.enum ]
13456
13457       Following the closing brace of an enum-specifier, each enumer-
13458       ator has the type of its enumeration.  Prior to the closing
13459       brace, the type of each enumerator is the type of its
13460       initializing value.
13461
13462     In finish_enum we will reset the type.  Of course, if we're
13463     processing a template, there may be no value.   */
13464   type = value ? TREE_TYPE (value) : NULL_TREE;
13465
13466   if (context && context == current_class_type)
13467     /* This enum declaration is local to the class.  We need the full
13468        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13469     decl = build_lang_decl (CONST_DECL, name, type);
13470   else
13471     /* It's a global enum, or it's local to a function.  (Note local to
13472       a function could mean local to a class method.  */
13473     decl = build_decl (CONST_DECL, name, type);
13474
13475   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13476   DECL_INITIAL (decl) = value;
13477   TREE_READONLY (decl) = 1;
13478
13479   if (context && context == current_class_type)
13480     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13481       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13482       things like `S::i' later.)  */
13483     finish_member_declaration (decl);
13484   else
13485     pushdecl (decl);
13486
13487   /* Add this enumeration constant to the list for this type.  */
13488   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13489 }
13490
13491 \f
13492 /* We're defining DECL.  Make sure that it's type is OK.  */
13493
13494 static void
13495 check_function_type (decl, current_function_parms)
13496      tree decl;
13497      tree current_function_parms;
13498 {
13499   tree fntype = TREE_TYPE (decl);
13500   tree return_type = complete_type (TREE_TYPE (fntype));
13501
13502   /* In a function definition, arg types must be complete.  */
13503   require_complete_types_for_parms (current_function_parms);
13504
13505   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13506     {
13507       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13508
13509       /* Make it return void instead, but don't change the
13510          type of the DECL_RESULT, in case we have a named return value.  */
13511       if (TREE_CODE (fntype) == METHOD_TYPE)
13512         {
13513           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13514           TREE_TYPE (decl)
13515             = build_cplus_method_type (ctype,
13516                                        void_type_node,
13517                                        FUNCTION_ARG_CHAIN (decl));
13518         }
13519       else
13520         TREE_TYPE (decl)
13521           = build_function_type (void_type_node,
13522                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13523       TREE_TYPE (decl)
13524         = build_exception_variant (fntype,
13525                                    TYPE_RAISES_EXCEPTIONS (fntype));
13526     }
13527   else
13528     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13529 }
13530
13531 /* Create the FUNCTION_DECL for a function definition.
13532    DECLSPECS and DECLARATOR are the parts of the declaration;
13533    they describe the function's name and the type it returns,
13534    but twisted together in a fashion that parallels the syntax of C.
13535
13536    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13537    DECLARATOR is really the DECL for the function we are about to
13538    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13539    indicating that the function is an inline defined in-class.
13540
13541    This function creates a binding context for the function body
13542    as well as setting up the FUNCTION_DECL in current_function_decl.
13543
13544    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13545    (it defines a datum instead), we return 0, which tells
13546    yyparse to report a parse error.
13547
13548    For C++, we must first check whether that datum makes any sense.
13549    For example, "class A local_a(1,2);" means that variable local_a
13550    is an aggregate of type A, which should have a constructor
13551    applied to it with the argument list [1, 2].  */
13552
13553 int
13554 start_function (declspecs, declarator, attrs, flags)
13555      tree declspecs, declarator, attrs;
13556      int flags;
13557 {
13558   tree decl1;
13559   tree ctype = NULL_TREE;
13560   tree fntype;
13561   tree restype;
13562   extern int have_extern_spec;
13563   extern int used_extern_spec;
13564   int doing_friend = 0;
13565   struct binding_level *bl;
13566   tree current_function_parms;
13567
13568   /* Sanity check.  */
13569   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13570   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13571
13572   /* This should only be done once on the top most decl.  */
13573   if (have_extern_spec && !used_extern_spec)
13574     {
13575       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13576       used_extern_spec = 1;
13577     }
13578
13579   if (flags & SF_PRE_PARSED)
13580     {
13581       decl1 = declarator;
13582
13583       fntype = TREE_TYPE (decl1);
13584       if (TREE_CODE (fntype) == METHOD_TYPE)
13585         ctype = TYPE_METHOD_BASETYPE (fntype);
13586
13587       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13588          the (lexical) scope of the class in which it is defined.  */
13589       if (!ctype && DECL_FRIEND_P (decl1))
13590         {
13591           ctype = DECL_FRIEND_CONTEXT (decl1);
13592
13593           /* CTYPE could be null here if we're dealing with a template;
13594              for example, `inline friend float foo()' inside a template
13595              will have no CTYPE set.  */
13596           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13597             ctype = NULL_TREE;
13598           else
13599             doing_friend = 1;
13600         }
13601
13602       last_function_parms = DECL_ARGUMENTS (decl1);
13603     }
13604   else
13605     {
13606       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13607       /* If the declarator is not suitable for a function definition,
13608          cause a syntax error.  */
13609       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13610         return 0;
13611
13612       cplus_decl_attributes (&decl1, attrs, 0);
13613
13614       /* If #pragma weak was used, mark the decl weak now.  */
13615       if (current_binding_level == global_binding_level)
13616         maybe_apply_pragma_weak (decl1);
13617
13618       fntype = TREE_TYPE (decl1);
13619
13620       restype = TREE_TYPE (fntype);
13621       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13622         {
13623           error ("semicolon missing after declaration of `%#T'", restype);
13624           shadow_tag (build_tree_list (NULL_TREE, restype));
13625           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13626           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13627             fntype = build_function_type (integer_type_node,
13628                                           TYPE_ARG_TYPES (fntype));
13629           else
13630             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13631                                               integer_type_node,
13632                                               TYPE_ARG_TYPES (fntype));
13633           TREE_TYPE (decl1) = fntype;
13634         }
13635
13636       if (TREE_CODE (fntype) == METHOD_TYPE)
13637         ctype = TYPE_METHOD_BASETYPE (fntype);
13638       else if (DECL_MAIN_P (decl1))
13639         {
13640           /* If this doesn't return integer_type, complain.  */
13641           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13642             {
13643               if (pedantic || warn_return_type)
13644                 pedwarn ("return type for `main' changed to `int'");
13645               TREE_TYPE (decl1) = fntype = default_function_type;
13646             }
13647         }
13648     }
13649
13650   if (DECL_DECLARED_INLINE_P (decl1)
13651       && lookup_attribute ("noinline", attrs))
13652     warning_with_decl (decl1,
13653                        "inline function `%s' given attribute noinline");
13654
13655   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13656     /* This is a constructor, we must ensure that any default args
13657        introduced by this definition are propagated to the clones
13658        now. The clones are used directly in overload resolution.  */
13659     adjust_clone_args (decl1);
13660
13661   /* Sometimes we don't notice that a function is a static member, and
13662      build a METHOD_TYPE for it.  Fix that up now.  */
13663   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13664       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13665     {
13666       revert_static_member_fn (decl1);
13667       last_function_parms = TREE_CHAIN (last_function_parms);
13668       ctype = NULL_TREE;
13669     }
13670
13671   /* Warn if function was previously implicitly declared
13672      (but not if we warned then).  */
13673   if (! warn_implicit
13674       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13675     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13676
13677   /* Set up current_class_type, and enter the scope of the class, if
13678      appropriate.  */
13679   if (ctype)
13680     push_nested_class (ctype, 1);
13681   else if (DECL_STATIC_FUNCTION_P (decl1))
13682     push_nested_class (DECL_CONTEXT (decl1), 2);
13683
13684   /* Now that we have entered the scope of the class, we must restore
13685      the bindings for any template parameters surrounding DECL1, if it
13686      is an inline member template.  (Order is important; consider the
13687      case where a template parameter has the same name as a field of
13688      the class.)  It is not until after this point that
13689      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13690   if (flags & SF_INCLASS_INLINE)
13691     maybe_begin_member_template_processing (decl1);
13692
13693   /* Effective C++ rule 15.  */
13694   if (warn_ecpp
13695       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13696       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13697     warning ("`operator=' should return a reference to `*this'");
13698
13699   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13700      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13701   if (!DECL_INITIAL (decl1))
13702     DECL_INITIAL (decl1) = error_mark_node;
13703
13704   /* This function exists in static storage.
13705      (This does not mean `static' in the C sense!)  */
13706   TREE_STATIC (decl1) = 1;
13707
13708   /* We must call push_template_decl after current_class_type is set
13709      up.  (If we are processing inline definitions after exiting a
13710      class scope, current_class_type will be NULL_TREE until set above
13711      by push_nested_class.)  */
13712   if (processing_template_decl)
13713     decl1 = push_template_decl (decl1);
13714
13715   /* We are now in the scope of the function being defined.  */
13716   current_function_decl = decl1;
13717
13718   /* Save the parm names or decls from this function's declarator
13719      where store_parm_decls will find them.  */
13720   current_function_parms = last_function_parms;
13721
13722   /* Make sure the parameter and return types are reasonable.  When
13723      you declare a function, these types can be incomplete, but they
13724      must be complete when you define the function.  */
13725   if (! processing_template_decl)
13726     check_function_type (decl1, current_function_parms);
13727
13728   /* Build the return declaration for the function.  */
13729   restype = TREE_TYPE (fntype);
13730   /* Promote the value to int before returning it.  */
13731   if (c_promoting_integer_type_p (restype))
13732     restype = type_promotes_to (restype);
13733   if (DECL_RESULT (decl1) == NULL_TREE)
13734     {
13735       DECL_RESULT (decl1)
13736         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13737       c_apply_type_quals_to_decl (cp_type_quals (restype),
13738                                   DECL_RESULT (decl1));
13739     }
13740
13741   /* Initialize RTL machinery.  We cannot do this until
13742      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13743      even when processing a template; this is how we get
13744      CFUN set up, and our per-function variables initialized.
13745      FIXME factor out the non-RTL stuff.  */
13746   bl = current_binding_level;
13747   init_function_start (decl1, input_filename, lineno);
13748   current_binding_level = bl;
13749
13750   /* Even though we're inside a function body, we still don't want to
13751      call expand_expr to calculate the size of a variable-sized array.
13752      We haven't necessarily assigned RTL to all variables yet, so it's
13753      not safe to try to expand expressions involving them.  */
13754   immediate_size_expand = 0;
13755   cfun->x_dont_save_pending_sizes_p = 1;
13756
13757   /* Start the statement-tree, start the tree now.  */
13758   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13759
13760   /* Let the user know we're compiling this function.  */
13761   announce_function (decl1);
13762
13763   /* Record the decl so that the function name is defined.
13764      If we already have a decl for this name, and it is a FUNCTION_DECL,
13765      use the old decl.  */
13766   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13767     {
13768       /* A specialization is not used to guide overload resolution.  */
13769       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13770           && ! DECL_FUNCTION_MEMBER_P (decl1))
13771         decl1 = pushdecl (decl1);
13772       else
13773         {
13774           /* We need to set the DECL_CONTEXT. */
13775           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13776             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13777           /* And make sure we have enough default args.  */
13778           check_default_args (decl1);
13779         }
13780       fntype = TREE_TYPE (decl1);
13781     }
13782
13783   /* Reset these in case the call to pushdecl changed them.  */
13784   current_function_decl = decl1;
13785   cfun->decl = decl1;
13786
13787   /* If we are (erroneously) defining a function that we have already
13788      defined before, wipe out what we knew before.  */
13789   if (!DECL_PENDING_INLINE_P (decl1)
13790       && DECL_SAVED_FUNCTION_DATA (decl1))
13791     {
13792       free (DECL_SAVED_FUNCTION_DATA (decl1));
13793       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13794     }
13795
13796   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13797     {
13798       /* We know that this was set up by `grokclassfn'.  We do not
13799          wait until `store_parm_decls', since evil parse errors may
13800          never get us to that point.  Here we keep the consistency
13801          between `current_class_type' and `current_class_ptr'.  */
13802       tree t = DECL_ARGUMENTS (decl1);
13803
13804       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13805                           162);
13806       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13807                           19990811);
13808
13809       cp_function_chain->x_current_class_ref
13810         = build_indirect_ref (t, NULL);
13811       cp_function_chain->x_current_class_ptr = t;
13812
13813       /* Constructors and destructors need to know whether they're "in
13814          charge" of initializing virtual base classes.  */
13815       t = TREE_CHAIN (t);
13816       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13817         {
13818           current_in_charge_parm = t;
13819           t = TREE_CHAIN (t);
13820         }
13821       if (DECL_HAS_VTT_PARM_P (decl1))
13822         {
13823           if (DECL_NAME (t) != vtt_parm_identifier)
13824             abort ();
13825           current_vtt_parm = t;
13826         }
13827     }
13828
13829   if (DECL_INTERFACE_KNOWN (decl1))
13830     {
13831       tree ctx = decl_function_context (decl1);
13832
13833       if (DECL_NOT_REALLY_EXTERN (decl1))
13834         DECL_EXTERNAL (decl1) = 0;
13835
13836       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13837           && TREE_PUBLIC (ctx))
13838         /* This is a function in a local class in an extern inline
13839            function.  */
13840         comdat_linkage (decl1);
13841     }
13842   /* If this function belongs to an interface, it is public.
13843      If it belongs to someone else's interface, it is also external.
13844      This only affects inlines and template instantiations.  */
13845   else if (interface_unknown == 0
13846            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13847                || flag_alt_external_templates))
13848     {
13849       if (DECL_DECLARED_INLINE_P (decl1)
13850           || DECL_TEMPLATE_INSTANTIATION (decl1)
13851           || processing_template_decl)
13852         {
13853           DECL_EXTERNAL (decl1)
13854             = (interface_only
13855                || (DECL_DECLARED_INLINE_P (decl1)
13856                    && ! flag_implement_inlines
13857                    && !DECL_VINDEX (decl1)));
13858
13859           /* For WIN32 we also want to put these in linkonce sections.  */
13860           maybe_make_one_only (decl1);
13861         }
13862       else
13863         DECL_EXTERNAL (decl1) = 0;
13864       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13865       DECL_INTERFACE_KNOWN (decl1) = 1;
13866     }
13867   else if (interface_unknown && interface_only
13868            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13869                || flag_alt_external_templates))
13870     {
13871       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13872          interface, we will have interface_only set but not
13873          interface_known.  In that case, we don't want to use the normal
13874          heuristics because someone will supply a #pragma implementation
13875          elsewhere, and deducing it here would produce a conflict.  */
13876       comdat_linkage (decl1);
13877       DECL_EXTERNAL (decl1) = 0;
13878       DECL_INTERFACE_KNOWN (decl1) = 1;
13879       DECL_DEFER_OUTPUT (decl1) = 1;
13880     }
13881   else
13882     {
13883       /* This is a definition, not a reference.
13884          So clear DECL_EXTERNAL.  */
13885       DECL_EXTERNAL (decl1) = 0;
13886
13887       if ((DECL_DECLARED_INLINE_P (decl1)
13888            || DECL_TEMPLATE_INSTANTIATION (decl1))
13889           && ! DECL_INTERFACE_KNOWN (decl1)
13890           /* Don't try to defer nested functions for now.  */
13891           && ! decl_function_context (decl1))
13892         DECL_DEFER_OUTPUT (decl1) = 1;
13893       else
13894         DECL_INTERFACE_KNOWN (decl1) = 1;
13895     }
13896
13897   pushlevel (0);
13898   current_binding_level->parm_flag = 1;
13899
13900   ++function_depth;
13901
13902   if (DECL_DESTRUCTOR_P (decl1))
13903     {
13904       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13905       DECL_CONTEXT (dtor_label) = current_function_decl;
13906     }
13907
13908   start_fname_decls ();
13909
13910   store_parm_decls (current_function_parms);
13911
13912   return 1;
13913 }
13914 \f
13915 /* Store the parameter declarations into the current function declaration.
13916    This is called after parsing the parameter declarations, before
13917    digesting the body of the function.
13918
13919    Also install to binding contour return value identifier, if any.  */
13920
13921 static void
13922 store_parm_decls (current_function_parms)
13923      tree current_function_parms;
13924 {
13925   register tree fndecl = current_function_decl;
13926   register tree parm;
13927
13928   /* This is a chain of any other decls that came in among the parm
13929      declarations.  If a parm is declared with  enum {foo, bar} x;
13930      then CONST_DECLs for foo and bar are put here.  */
13931   tree nonparms = NULL_TREE;
13932
13933   if (current_function_parms)
13934     {
13935       /* This case is when the function was defined with an ANSI prototype.
13936          The parms already have decls, so we need not do anything here
13937          except record them as in effect
13938          and complain if any redundant old-style parm decls were written.  */
13939
13940       tree specparms = current_function_parms;
13941       tree next;
13942
13943       /* Must clear this because it might contain TYPE_DECLs declared
13944              at class level.  */
13945       storedecls (NULL_TREE);
13946
13947       /* If we're doing semantic analysis, then we'll call pushdecl
13948              for each of these.  We must do them in reverse order so that
13949              they end in the correct forward order.  */
13950       specparms = nreverse (specparms);
13951
13952       for (parm = specparms; parm; parm = next)
13953         {
13954           next = TREE_CHAIN (parm);
13955           if (TREE_CODE (parm) == PARM_DECL)
13956             {
13957               if (DECL_NAME (parm) == NULL_TREE
13958                   || TREE_CODE (parm) != VOID_TYPE)
13959                 pushdecl (parm);
13960               else
13961                 error ("parameter `%D' declared void", parm);
13962             }
13963           else
13964             {
13965               /* If we find an enum constant or a type tag,
13966                  put it aside for the moment.  */
13967               TREE_CHAIN (parm) = NULL_TREE;
13968               nonparms = chainon (nonparms, parm);
13969             }
13970         }
13971
13972       /* Get the decls in their original chain order and record in the
13973          function.  This is all and only the PARM_DECLs that were
13974          pushed into scope by the loop above.  */
13975       DECL_ARGUMENTS (fndecl) = getdecls ();
13976       storetags (gettags ());
13977     }
13978   else
13979     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13980
13981   /* Now store the final chain of decls for the arguments
13982      as the decl-chain of the current lexical scope.
13983      Put the enumerators in as well, at the front so that
13984      DECL_ARGUMENTS is not modified.  */
13985   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13986
13987   /* Do the starting of the exception specifications, if we have any.  */
13988   if (flag_exceptions && !processing_template_decl
13989       && flag_enforce_eh_specs
13990       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13991     current_eh_spec_block = begin_eh_spec_block ();
13992 }
13993
13994 \f
13995 /* We have finished doing semantic analysis on DECL, but have not yet
13996    generated RTL for its body.  Save away our current state, so that
13997    when we want to generate RTL later we know what to do.  */
13998
13999 static void
14000 save_function_data (decl)
14001      tree decl;
14002 {
14003   struct cp_language_function *f;
14004
14005   /* Save the language-specific per-function data so that we can
14006      get it back when we really expand this function.  */
14007   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14008                       19990908);
14009
14010   /* Make a copy.  */
14011   f = ((struct cp_language_function *)
14012        xmalloc (sizeof (struct cp_language_function)));
14013   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
14014   DECL_SAVED_FUNCTION_DATA (decl) = f;
14015
14016   /* Clear out the bits we don't need.  */
14017   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14018   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14019   f->x_named_label_uses = NULL;
14020   f->bindings = NULL;
14021   f->x_local_names = NULL;
14022
14023   /* When we get back here again, we will be expanding.  */
14024   f->x_expanding_p = 1;
14025
14026   /* If we've already decided that we cannot inline this function, we
14027      must remember that fact when we actually go to expand the
14028      function.  */
14029   if (current_function_cannot_inline)
14030     {
14031       f->cannot_inline = current_function_cannot_inline;
14032       DECL_INLINE (decl) = 0;
14033     }
14034 }
14035
14036 /* Add a note to mark the beginning of the main body of the constructor.
14037    This is used to set up the data structures for the cleanup regions for
14038    fully-constructed bases and members.  */
14039
14040 static void
14041 begin_constructor_body ()
14042 {
14043   tree ctor_stmt = build_stmt (CTOR_STMT);
14044   CTOR_BEGIN_P (ctor_stmt) = 1;
14045   add_stmt (ctor_stmt);
14046 }
14047
14048 /* Add a note to mark the end of the main body of the constructor.  This is
14049    used to end the cleanup regions for fully-constructed bases and
14050    members.  */
14051
14052 static void
14053 finish_constructor_body ()
14054 {
14055   /* Mark the end of the cleanups for a partially constructed object.
14056
14057      ??? These should really be handled automatically by closing the block,
14058      as with the destructor cleanups; the only difference is that these are
14059      only run if an exception is thrown.  */
14060   add_stmt (build_stmt (CTOR_STMT));
14061 }
14062
14063 /* Do all the processing for the beginning of a destructor; set up the
14064    vtable pointers and cleanups for bases and members.  */
14065
14066 static void
14067 begin_destructor_body ()
14068 {
14069   tree if_stmt;
14070   tree compound_stmt;
14071
14072   /* If the dtor is empty, and we know there is not any possible
14073      way we could use any vtable entries, before they are possibly
14074      set by a base class dtor, we don't have to setup the vtables,
14075      as we know that any base class dtor will set up any vtables
14076      it needs.  We avoid MI, because one base class dtor can do a
14077      virtual dispatch to an overridden function that would need to
14078      have a non-related vtable set up, we cannot avoid setting up
14079      vtables in that case.  We could change this to see if there
14080      is just one vtable.
14081
14082      ??? In the destructor for a class, the vtables are set
14083      appropriately for that class.  There will be no non-related
14084      vtables.  jason 2001-12-11.  */
14085   if_stmt = begin_if_stmt ();
14086
14087   /* If it is not safe to avoid setting up the vtables, then
14088      someone will change the condition to be boolean_true_node.
14089      (Actually, for now, we do not have code to set the condition
14090      appropriately, so we just assume that we always need to
14091      initialize the vtables.)  */
14092   finish_if_stmt_cond (boolean_true_node, if_stmt);
14093   current_vcalls_possible_p = &IF_COND (if_stmt);
14094
14095   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14096
14097   /* Make all virtual function table pointers in non-virtual base
14098      classes point to CURRENT_CLASS_TYPE's virtual function
14099      tables.  */
14100   initialize_vtbl_ptrs (current_class_ptr);
14101
14102   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14103   finish_then_clause (if_stmt);
14104   finish_if_stmt ();
14105 }
14106
14107 /* At the end of every destructor we generate code to delete the object if
14108    necessary.  Do that now.  */
14109
14110 static void
14111 finish_destructor_body ()
14112 {
14113   tree exprstmt;
14114
14115   /* And perform cleanups for our bases and members.  */
14116   perform_base_cleanups ();
14117
14118   /* In a virtual destructor, we must call delete.  */
14119   if (DECL_VIRTUAL_P (current_function_decl))
14120     {
14121       tree if_stmt;
14122       tree virtual_size = c_sizeof (current_class_type);
14123
14124       /* [class.dtor]
14125
14126       At the point of definition of a virtual destructor (including
14127       an implicit definition), non-placement operator delete shall
14128       be looked up in the scope of the destructor's class and if
14129       found shall be accessible and unambiguous.  */
14130       exprstmt = build_op_delete_call
14131         (DELETE_EXPR, current_class_ptr, virtual_size,
14132          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14133
14134       if_stmt = begin_if_stmt ();
14135       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14136                                   current_in_charge_parm,
14137                                   integer_one_node),
14138                            if_stmt);
14139       finish_expr_stmt (exprstmt);
14140       finish_then_clause (if_stmt);
14141       finish_if_stmt ();
14142     }
14143 }
14144
14145 /* Do the necessary processing for the beginning of a function body, which
14146    in this case includes member-initializers, but not the catch clauses of
14147    a function-try-block.  Currently, this means opening a binding level
14148    for the member-initializers (in a ctor) and member cleanups (in a dtor).
14149    In other functions, this isn't necessary, but it doesn't hurt.  */
14150
14151 tree
14152 begin_function_body ()
14153 {
14154   tree stmt;
14155
14156   if (processing_template_decl)
14157     /* Do nothing now.  */;
14158   else
14159     /* Always keep the BLOCK node associated with the outermost pair of
14160        curly braces of a function.  These are needed for correct
14161        operation of dwarfout.c.  */
14162     keep_next_level (1);
14163
14164   stmt = begin_compound_stmt (0);
14165   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14166
14167   if (processing_template_decl)
14168     /* Do nothing now.  */;
14169   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14170     begin_constructor_body ();
14171   else if (DECL_DESTRUCTOR_P (current_function_decl))
14172     begin_destructor_body ();
14173
14174   return stmt;
14175 }
14176
14177 /* Do the processing for the end of a function body.  Currently, this means
14178    closing out the cleanups for fully-constructed bases and members, and in
14179    the case of the destructor, deleting the object if desired.  Again, this
14180    is only meaningful for [cd]tors, since they are the only functions where
14181    there is a significant distinction between the main body and any
14182    function catch clauses.  Handling, say, main() return semantics here
14183    would be wrong, as flowing off the end of a function catch clause for
14184    main() would also need to return 0.  */
14185
14186 void
14187 finish_function_body (compstmt)
14188      tree compstmt;
14189 {
14190   if (processing_template_decl)
14191     /* Do nothing now.  */;
14192   else if (DECL_DESTRUCTOR_P (current_function_decl))
14193     /* Any return from a destructor will end up here.  Put it before the
14194        cleanups so that an explicit return doesn't duplicate them.  */
14195     add_stmt (build_stmt (LABEL_STMT, dtor_label));
14196
14197   /* Close the block; in a destructor, run the member cleanups.  */
14198   finish_compound_stmt (0, compstmt);
14199
14200   if (processing_template_decl)
14201     /* Do nothing now.  */;
14202   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14203     finish_constructor_body ();
14204   else if (DECL_DESTRUCTOR_P (current_function_decl))
14205     finish_destructor_body ();
14206 }
14207
14208 /* Finish up a function declaration and compile that function
14209    all the way to assembler language output.  The free the storage
14210    for the function definition.
14211
14212    FLAGS is a bitwise or of the following values:
14213      2 - INCLASS_INLINE
14214        We just finished processing the body of an in-class inline
14215        function definition.  (This processing will have taken place
14216        after the class definition is complete.)  */
14217
14218 tree
14219 finish_function (flags)
14220      int flags;
14221 {
14222   register tree fndecl = current_function_decl;
14223   tree fntype, ctype = NULL_TREE;
14224   int inclass_inline = (flags & 2) != 0;
14225   int nested;
14226
14227   /* When we get some parse errors, we can end up without a
14228      current_function_decl, so cope.  */
14229   if (fndecl == NULL_TREE)
14230     return error_mark_node;
14231
14232   nested = function_depth > 1;
14233   fntype = TREE_TYPE (fndecl);
14234
14235   /*  TREE_READONLY (fndecl) = 1;
14236       This caused &foo to be of type ptr-to-const-function
14237       which then got a warning when stored in a ptr-to-function variable.  */
14238
14239   my_friendly_assert (building_stmt_tree (), 20000911);
14240
14241   finish_fname_decls ();
14242
14243   /* For a cloned function, we've already got all the code we need;
14244      there's no need to add any extra bits.  */
14245   if (!DECL_CLONED_FUNCTION_P (fndecl))
14246     {
14247       if (DECL_MAIN_P (current_function_decl))
14248         {
14249           /* Make it so that `main' always returns 0 by default.  */
14250 #if VMS_TARGET
14251           finish_return_stmt (integer_one_node);
14252 #else
14253           finish_return_stmt (integer_zero_node);
14254 #endif
14255         }
14256
14257       /* Finish dealing with exception specifiers.  */
14258       if (flag_exceptions && !processing_template_decl
14259           && flag_enforce_eh_specs
14260           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14261         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14262                               (TREE_TYPE (current_function_decl)),
14263                               current_eh_spec_block);
14264     }
14265
14266   /* If we're saving up tree structure, tie off the function now.  */
14267   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14268
14269   /* This must come after expand_function_end because cleanups might
14270      have declarations (from inline functions) that need to go into
14271      this function's blocks.  */
14272
14273   /* If the current binding level isn't the outermost binding level
14274      for this function, either there is a bug, or we have experienced
14275      syntax errors and the statement tree is malformed.  */
14276   if (current_binding_level->parm_flag != 1)
14277     {
14278       /* Make sure we have already experienced errors.  */
14279       if (errorcount == 0)
14280         abort ();
14281
14282       /* Throw away the broken statement tree and extra binding
14283          levels.  */
14284       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14285
14286       while (current_binding_level->parm_flag != 1)
14287         {
14288           if (current_binding_level->parm_flag == 2)
14289             pop_nested_class ();
14290           else
14291             poplevel (0, 0, 0);
14292         }
14293     }
14294   poplevel (1, 0, 1);
14295
14296   /* Set up the named return value optimization, if we can.  Here, we
14297      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14298      for the nrv.  genrtl_start_function and declare_return_variable
14299      handle making the nrv and RESULT_DECL share space.  */
14300   if (current_function_return_value)
14301     {
14302       tree r = current_function_return_value;
14303       /* This is only worth doing for fns that return in memory--and
14304          simpler, since we don't have to worry about promoted modes.  */
14305       if (r != error_mark_node
14306           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14307         {
14308           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14309           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14310                                         nullify_returns_r, r);
14311         }
14312       else
14313         /* Clear it so genrtl_start_function and declare_return_variable
14314            know we're not optimizing.  */
14315         current_function_return_value = NULL_TREE;
14316     }
14317
14318   /* Remember that we were in class scope.  */
14319   if (current_class_name)
14320     ctype = current_class_type;
14321
14322   /* Must mark the RESULT_DECL as being in this function.  */
14323   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14324
14325   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14326      to the FUNCTION_DECL node itself.  */
14327   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14328
14329   /* Save away current state, if appropriate.  */
14330   if (!processing_template_decl)
14331     save_function_data (fndecl);
14332
14333   /* If this function calls `setjmp' it cannot be inlined.  When
14334      `longjmp' is called it is not guaranteed to restore the value of
14335      local variables that have been modified since the call to
14336      `setjmp'.  So, if were to inline this function into some caller
14337      `c', then when we `longjmp', we might not restore all variables
14338      in `c'.  (It might seem, at first blush, that there's no way for
14339      this function to modify local variables in `c', but their
14340      addresses may have been stored somewhere accessible to this
14341      function.)  */
14342   if (!processing_template_decl && calls_setjmp_p (fndecl))
14343     DECL_UNINLINABLE (fndecl) = 1;
14344
14345   /* Complain if there's just no return statement.  */
14346   if (warn_return_type
14347       && !processing_template_decl
14348       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14349       && !current_function_returns_value && !current_function_returns_null
14350       /* Don't complain if we abort or throw.  */
14351       && !current_function_returns_abnormally
14352       && !DECL_NAME (DECL_RESULT (fndecl))
14353       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
14354          inline function, as we might never be compiled separately.  */
14355       && DECL_INLINE (fndecl))
14356     warning ("no return statement in function returning non-void");
14357
14358   /* Clear out memory we no longer need.  */
14359   free_after_parsing (cfun);
14360   /* Since we never call rest_of_compilation, we never clear
14361      CFUN.  Do so explicitly.  */
14362   free_after_compilation (cfun);
14363   cfun = NULL;
14364
14365   /* If this is a in-class inline definition, we may have to pop the
14366      bindings for the template parameters that we added in
14367      maybe_begin_member_template_processing when start_function was
14368      called.  */
14369   if (inclass_inline)
14370     maybe_end_member_template_processing ();
14371
14372   /* Leave the scope of the class.  */
14373   if (ctype)
14374     pop_nested_class ();
14375
14376   --function_depth;
14377
14378   /* Clean up.  */
14379   if (! nested)
14380     /* Let the error reporting routines know that we're outside a
14381        function.  For a nested function, this value is used in
14382        pop_cp_function_context and then reset via pop_function_context.  */
14383     current_function_decl = NULL_TREE;
14384
14385   return fndecl;
14386 }
14387 \f
14388 /* Create the FUNCTION_DECL for a function definition.
14389    DECLSPECS and DECLARATOR are the parts of the declaration;
14390    they describe the return type and the name of the function,
14391    but twisted together in a fashion that parallels the syntax of C.
14392
14393    This function creates a binding context for the function body
14394    as well as setting up the FUNCTION_DECL in current_function_decl.
14395
14396    Returns a FUNCTION_DECL on success.
14397
14398    If the DECLARATOR is not suitable for a function (it defines a datum
14399    instead), we return 0, which tells yyparse to report a parse error.
14400
14401    May return void_type_node indicating that this method is actually
14402    a friend.  See grokfield for more details.
14403
14404    Came here with a `.pushlevel' .
14405
14406    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14407    CHANGES TO CODE IN `grokfield'.  */
14408
14409 tree
14410 start_method (declspecs, declarator, attrlist)
14411      tree declarator, declspecs, attrlist;
14412 {
14413   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14414                                 &attrlist);
14415
14416   /* Something too ugly to handle.  */
14417   if (fndecl == NULL_TREE)
14418     return NULL_TREE;
14419
14420   if (attrlist)
14421     cplus_decl_attributes (&fndecl, attrlist, 0);
14422
14423   /* Pass friends other than inline friend functions back.  */
14424   if (fndecl == void_type_node)
14425     return fndecl;
14426
14427   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14428     /* Not a function, tell parser to report parse error.  */
14429     return NULL_TREE;
14430
14431   if (DECL_IN_AGGR_P (fndecl))
14432     {
14433       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14434         {
14435           if (DECL_CONTEXT (fndecl)
14436               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14437             error ("`%D' is already defined in class `%T'", fndecl,
14438                       DECL_CONTEXT (fndecl));
14439         }
14440       return void_type_node;
14441     }
14442
14443   check_template_shadow (fndecl);
14444
14445   DECL_DECLARED_INLINE_P (fndecl) = 1;
14446
14447   if (flag_default_inline)
14448     DECL_INLINE (fndecl) = 1;
14449
14450   /* We process method specializations in finish_struct_1.  */
14451   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14452     fndecl = push_template_decl (fndecl);
14453
14454   if (! DECL_FRIEND_P (fndecl))
14455     {
14456       if (TREE_CHAIN (fndecl))
14457         {
14458           fndecl = copy_node (fndecl);
14459           TREE_CHAIN (fndecl) = NULL_TREE;
14460         }
14461       grok_special_member_properties (fndecl);
14462     }
14463
14464   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14465
14466   /* Make a place for the parms */
14467   pushlevel (0);
14468   current_binding_level->parm_flag = 1;
14469
14470   DECL_IN_AGGR_P (fndecl) = 1;
14471   return fndecl;
14472 }
14473
14474 /* Go through the motions of finishing a function definition.
14475    We don't compile this method until after the whole class has
14476    been processed.
14477
14478    FINISH_METHOD must return something that looks as though it
14479    came from GROKFIELD (since we are defining a method, after all).
14480
14481    This is called after parsing the body of the function definition.
14482    STMTS is the chain of statements that makes up the function body.
14483
14484    DECL is the ..._DECL that `start_method' provided.  */
14485
14486 tree
14487 finish_method (decl)
14488      tree decl;
14489 {
14490   register tree fndecl = decl;
14491   tree old_initial;
14492
14493   register tree link;
14494
14495   if (decl == void_type_node)
14496     return decl;
14497
14498   old_initial = DECL_INITIAL (fndecl);
14499
14500   /* Undo the level for the parms (from start_method).
14501      This is like poplevel, but it causes nothing to be
14502      saved.  Saving information here confuses symbol-table
14503      output routines.  Besides, this information will
14504      be correctly output when this method is actually
14505      compiled.  */
14506
14507   /* Clear out the meanings of the local variables of this level;
14508      also record in each decl which block it belongs to.  */
14509
14510   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14511     {
14512       if (DECL_NAME (link) != NULL_TREE)
14513         pop_binding (DECL_NAME (link), link);
14514       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14515       DECL_CONTEXT (link) = NULL_TREE;
14516     }
14517
14518   poplevel (0, 0, 0);
14519
14520   DECL_INITIAL (fndecl) = old_initial;
14521
14522   /* We used to check if the context of FNDECL was different from
14523      current_class_type as another way to get inside here.  This didn't work
14524      for String.cc in libg++.  */
14525   if (DECL_FRIEND_P (fndecl))
14526     {
14527       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14528         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14529       decl = void_type_node;
14530     }
14531
14532   return decl;
14533 }
14534 \f
14535
14536 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
14537    we can lay it out later, when and if its type becomes complete.  */
14538
14539 void
14540 maybe_register_incomplete_var (var)
14541      tree var;
14542 {
14543   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14544
14545   /* Keep track of variables with incomplete types.  */
14546   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14547       && DECL_EXTERNAL (var))
14548     {
14549       tree inner_type = TREE_TYPE (var);
14550
14551       while (TREE_CODE (inner_type) == ARRAY_TYPE)
14552         inner_type = TREE_TYPE (inner_type);
14553       inner_type = TYPE_MAIN_VARIANT (inner_type);
14554
14555       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14556           /* RTTI TD entries are created while defining the type_info.  */
14557           || (TYPE_LANG_SPECIFIC (inner_type)
14558               && TYPE_BEING_DEFINED (inner_type)))
14559         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14560     }
14561 }
14562
14563 /* Called when a class type (given by TYPE) is defined.  If there are
14564    any existing VAR_DECLs whose type hsa been completed by this
14565    declaration, update them now.  */
14566
14567 void
14568 complete_vars (type)
14569      tree type;
14570 {
14571   tree *list = &incomplete_vars;
14572
14573   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14574   while (*list)
14575     {
14576       if (same_type_p (type, TREE_PURPOSE (*list)))
14577         {
14578           tree var = TREE_VALUE (*list);
14579           /* Complete the type of the variable.  The VAR_DECL itself
14580              will be laid out in expand_expr.  */
14581           complete_type (TREE_TYPE (var));
14582           /* Remove this entry from the list.  */
14583           *list = TREE_CHAIN (*list);
14584         }
14585       else
14586         list = &TREE_CHAIN (*list);
14587     }
14588 }
14589
14590 /* If DECL is of a type which needs a cleanup, build that cleanup
14591    here.  */
14592
14593 tree
14594 maybe_build_cleanup (decl)
14595      tree decl;
14596 {
14597   tree type = TREE_TYPE (decl);
14598
14599   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14600     {
14601       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14602       tree rval;
14603
14604       if (TREE_CODE (type) == ARRAY_TYPE)
14605         rval = decl;
14606       else
14607         {
14608           mark_addressable (decl);
14609           rval = build_unary_op (ADDR_EXPR, decl, 0);
14610         }
14611
14612       /* Optimize for space over speed here.  */
14613       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14614           || flag_expensive_optimizations)
14615         flags |= LOOKUP_NONVIRTUAL;
14616
14617       rval = build_delete (TREE_TYPE (rval), rval,
14618                            sfk_complete_destructor, flags, 0);
14619
14620       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14621           && ! TYPE_HAS_DESTRUCTOR (type))
14622         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14623                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14624
14625       return rval;
14626     }
14627   return NULL_TREE;
14628 }
14629 \f
14630 /* When a stmt has been parsed, this function is called.  */
14631
14632 void
14633 finish_stmt ()
14634 {
14635   /* Always assume this statement was not an expression statement.  If
14636      it actually was an expression statement, its our callers
14637      responsibility to fix this up.  */
14638   last_expr_type = NULL_TREE;
14639 }
14640
14641 /* DECL was originally constructed as a non-static member function,
14642    but turned out to be static.  Update it accordingly.  */
14643
14644 void
14645 revert_static_member_fn (decl)
14646      tree decl;
14647 {
14648   tree tmp;
14649   tree function = TREE_TYPE (decl);
14650   tree args = TYPE_ARG_TYPES (function);
14651
14652   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14653       != TYPE_UNQUALIFIED)
14654     error ("static member function `%#D' declared with type qualifiers",
14655               decl);
14656
14657   args = TREE_CHAIN (args);
14658   tmp = build_function_type (TREE_TYPE (function), args);
14659   tmp = build_qualified_type (tmp, cp_type_quals (function));
14660   tmp = build_exception_variant (tmp,
14661                                  TYPE_RAISES_EXCEPTIONS (function));
14662   TREE_TYPE (decl) = tmp;
14663   if (DECL_ARGUMENTS (decl))
14664     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14665   DECL_STATIC_FUNCTION_P (decl) = 1;
14666 }
14667
14668 /* Initialize the variables used during compilation of a C++
14669    function.  */
14670
14671 static void
14672 push_cp_function_context (f)
14673      struct function *f;
14674 {
14675   struct cp_language_function *p
14676     = ((struct cp_language_function *)
14677        xcalloc (1, sizeof (struct cp_language_function)));
14678   f->language = (struct language_function *) p;
14679
14680   /* It takes an explicit call to expand_body to generate RTL for a
14681      function.  */
14682   expanding_p = 0;
14683
14684   /* Whenever we start a new function, we destroy temporaries in the
14685      usual way.  */
14686   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14687 }
14688
14689 /* Free the language-specific parts of F, now that we've finished
14690    compiling the function.  */
14691
14692 static void
14693 pop_cp_function_context (f)
14694      struct function *f;
14695 {
14696   if (f->language)
14697     {
14698       struct cp_language_function *cp =
14699         (struct cp_language_function *) f->language;
14700       if (cp->x_local_names)
14701         VARRAY_FREE (cp->x_local_names);
14702       free (f->language);
14703     }
14704   f->language = 0;
14705 }
14706
14707 /* Mark P for GC.  */
14708
14709 static void
14710 mark_lang_function (p)
14711      struct cp_language_function *p;
14712 {
14713   if (!p)
14714     return;
14715
14716   mark_c_language_function (&p->base);
14717
14718   ggc_mark_tree (p->x_dtor_label);
14719   ggc_mark_tree (p->x_current_class_ptr);
14720   ggc_mark_tree (p->x_current_class_ref);
14721   ggc_mark_tree (p->x_eh_spec_block);
14722   ggc_mark_tree_varray (p->x_local_names);
14723
14724   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14725   mark_binding_level (&p->bindings);
14726   mark_pending_inlines (&p->unparsed_inlines);
14727 }
14728
14729 /* Mark the language-specific data in F for GC.  */
14730
14731 static void
14732 mark_cp_function_context (f)
14733      struct function *f;
14734 {
14735   mark_lang_function ((struct cp_language_function *) f->language);
14736 }
14737
14738 void
14739 lang_mark_tree (t)
14740      tree t;
14741 {
14742   enum tree_code code = TREE_CODE (t);
14743   if (code == IDENTIFIER_NODE)
14744     {
14745       struct lang_identifier *li = (struct lang_identifier *) t;
14746       struct lang_id2 *li2 = li->x;
14747       ggc_mark_tree (li->namespace_bindings);
14748       ggc_mark_tree (li->bindings);
14749       ggc_mark_tree (li->class_value);
14750       ggc_mark_tree (li->class_template_info);
14751
14752       if (li2)
14753         {
14754           ggc_mark_tree (li2->label_value);
14755           ggc_mark_tree (li2->implicit_decl);
14756           ggc_mark_tree (li2->error_locus);
14757         }
14758     }
14759   else if (code == CPLUS_BINDING)
14760     {
14761       if (BINDING_HAS_LEVEL_P (t))
14762         mark_binding_level (&BINDING_LEVEL (t));
14763       else
14764         ggc_mark_tree (BINDING_SCOPE (t));
14765       ggc_mark_tree (BINDING_VALUE (t));
14766     }
14767   else if (code == OVERLOAD)
14768     ggc_mark_tree (OVL_FUNCTION (t));
14769   else if (code == TEMPLATE_PARM_INDEX)
14770     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14771   else if (TREE_CODE_CLASS (code) == 'd')
14772     {
14773       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14774
14775       if (ld)
14776         {
14777           ggc_mark (ld);
14778           c_mark_lang_decl (&ld->decl_flags.base);
14779           if (!DECL_GLOBAL_CTOR_P (t)
14780               && !DECL_GLOBAL_DTOR_P (t)
14781               && !DECL_THUNK_P (t)
14782               && !DECL_DISCRIMINATOR_P (t))
14783             ggc_mark_tree (ld->decl_flags.u2.access);
14784           else if (DECL_THUNK_P (t))
14785             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14786           if (TREE_CODE (t) != NAMESPACE_DECL)
14787             ggc_mark_tree (ld->decl_flags.u.template_info);
14788           else
14789             mark_binding_level (&NAMESPACE_LEVEL (t));
14790           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14791             {
14792               ggc_mark_tree (ld->befriending_classes);
14793               ggc_mark_tree (ld->context);
14794               ggc_mark_tree (ld->cloned_function);
14795               if (TREE_CODE (t) == TYPE_DECL)
14796                 ggc_mark_tree (ld->u.sorted_fields);
14797               else if (TREE_CODE (t) == FUNCTION_DECL
14798                        && !DECL_PENDING_INLINE_P (t))
14799                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14800             }
14801         }
14802     }
14803   else if (TREE_CODE_CLASS (code) == 't')
14804     {
14805       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14806
14807       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14808                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14809         {
14810           ggc_mark (lt);
14811           ggc_mark_tree (lt->primary_base);
14812           ggc_mark_tree (lt->vfields);
14813           ggc_mark_tree (lt->vbases);
14814           ggc_mark_tree (lt->tags);
14815           ggc_mark_tree (lt->size);
14816           ggc_mark_tree (lt->pure_virtuals);
14817           ggc_mark_tree (lt->friend_classes);
14818           ggc_mark_tree (lt->rtti);
14819           ggc_mark_tree (lt->methods);
14820           ggc_mark_tree (lt->template_info);
14821           ggc_mark_tree (lt->befriending_classes);
14822         }
14823       else if (lt)
14824         /* In the case of pointer-to-member function types, the
14825            TYPE_LANG_SPECIFIC is really just a tree.  */
14826         ggc_mark_tree ((tree) lt);
14827     }
14828 }
14829
14830 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14831    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14832
14833 tree
14834 identifier_global_value (t)
14835      tree t;
14836 {
14837   return IDENTIFIER_GLOBAL_VALUE (t);
14838 }
14839
14840 /* Build the void_list_node (void_type_node having been created).  */
14841 tree
14842 build_void_list_node ()
14843 {
14844   tree t = build_tree_list (NULL_TREE, void_type_node);
14845   TREE_PARMLIST (t) = 1;
14846   return t;
14847 }
14848
14849 static int
14850 cp_missing_noreturn_ok_p (decl)
14851      tree decl;
14852 {
14853   /* A missing noreturn is ok for the `main' function.  */
14854   return DECL_MAIN_P (decl);
14855 }