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  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "output.h"
  41 #include "except.h"
  42 #include "toplev.h"
  43 #include "../hash.h"
  44 #include "ggc.h"
  45 #include "tm_p.h"
  46
  47 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  48
  49 #ifndef BOOL_TYPE_SIZE
  50 /* In the new ABI, `bool' has size and alignment `1', on all
  51    platforms.  */
  52 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  53 #endif
  54
  55 static tree grokparms                           PARAMS ((tree));
  56 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  57
  58 static void push_binding_level PARAMS ((struct binding_level *, int,
  59                                       int));
  60 static void pop_binding_level PARAMS ((void));
  61 static void suspend_binding_level PARAMS ((void));
  62 static void resume_binding_level PARAMS ((struct binding_level *));
  63 static struct binding_level *make_binding_level PARAMS ((void));
  64 static void declare_namespace_level PARAMS ((void));
  65 static int decl_jump_unsafe PARAMS ((tree));
  66 static void storedecls PARAMS ((tree));
  67 static void require_complete_types_for_parms PARAMS ((tree));
  68 static int ambi_op_p PARAMS ((enum tree_code));
  69 static int unary_op_p PARAMS ((enum tree_code));
  70 static tree store_bindings PARAMS ((tree, tree));
  71 static tree lookup_tag_reverse PARAMS ((tree, tree));
  72 static tree obscure_complex_init PARAMS ((tree, tree));
  73 static tree lookup_name_real PARAMS ((tree, int, int, int));
  74 static void push_local_name PARAMS ((tree));
  75 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  76 static tree grok_reference_init PARAMS ((tree, tree, tree));
  77 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  78                               enum overload_flags, tree,
  79                               tree, int, int, int, int, int, int, tree));
  80 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, 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 build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  87 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  88 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  89                                   int));
  90 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  91 static void check_for_uninitialized_const_var PARAMS ((tree));
  92 static unsigned long typename_hash PARAMS ((hash_table_key));
  93 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  94 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  95 static int add_binding PARAMS ((tree, tree));
  96 static void pop_binding PARAMS ((tree, tree));
  97 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
  98 static tree find_binding PARAMS ((tree, tree));
  99 static tree select_decl PARAMS ((tree, int));
 100 static int lookup_flags PARAMS ((int, int));
 101 static tree qualify_lookup PARAMS ((tree, int));
 102 static tree record_builtin_java_type PARAMS ((const char *, int));
 103 static const char *tag_name PARAMS ((enum tag_types code));
 104 static void find_class_binding_level PARAMS ((void));
 105 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 106 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 107 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 108 static int walk_globals_r PARAMS ((tree, void *));
 109 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 110 static tree make_label_decl PARAMS ((tree, int));
 111 static void use_label PARAMS ((tree));
 112 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 113                                            const char *, int));
 114 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 115 static void check_switch_goto PARAMS ((struct binding_level *));
 116 static void check_previous_gotos PARAMS ((tree));
 117 static void pop_label PARAMS ((tree, tree));
 118 static void pop_labels PARAMS ((tree));
 119 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 120 static void layout_var_decl PARAMS ((tree));
 121 static void maybe_commonize_var PARAMS ((tree));
 122 static tree check_initializer PARAMS ((tree, tree));
 123 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 124 static void push_cp_function_context PARAMS ((struct function *));
 125 static void pop_cp_function_context PARAMS ((struct function *));
 126 static void mark_binding_level PARAMS ((void *));
 127 static void mark_named_label_lists PARAMS ((void *, void *));
 128 static void mark_cp_function_context PARAMS ((struct function *));
 129 static void mark_saved_scope PARAMS ((void *));
 130 static void mark_lang_function PARAMS ((struct cp_language_function *));
 131 static void save_function_data PARAMS ((tree));
 132 static void check_function_type PARAMS ((tree, tree));
 133 static void destroy_local_var PARAMS ((tree));
 134 static void finish_constructor_body PARAMS ((void));
 135 static void finish_destructor_body PARAMS ((void));
 136 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 137 static tree get_atexit_node PARAMS ((void));
 138 static tree get_dso_handle_node PARAMS ((void));
 139 static tree start_cleanup_fn PARAMS ((void));
 140 static void end_cleanup_fn PARAMS ((void));
 141 static tree cp_make_fname_decl PARAMS ((tree, int));
 142 static void initialize_predefined_identifiers PARAMS ((void));
 143 static tree check_special_function_return_type
 144   PARAMS ((special_function_kind, tree, tree));
 145 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 146 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 147 static void store_parm_decls PARAMS ((tree));
 148 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 149
 150 #if defined (DEBUG_CP_BINDING_LEVELS)
 151 static void indent PARAMS ((void));
 152 #endif
 153
 154 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 155 tree error_mark_list;
 156
 157 /* The following symbols are subsumed in the cp_global_trees array, and
 158    listed here individually for documentation purposes.
 159
 160    C++ extensions
 161         tree wchar_decl_node;
 162
 163         tree vtable_entry_type;
 164         tree delta_type_node;
 165 #if 0
 166    Old rtti stuff.
 167         tree __baselist_desc_type_node;
 168         tree __i_desc_type_node, __m_desc_type_node;
 169         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 170 #endif
 171         tree __t_desc_type_node;
 172 #if 0
 173         tree __tp_desc_type_node;
 174 #endif
 175         tree ti_desc_type_node;
 176         tree bltn_desc_type_node, ptr_desc_type_node;
 177         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 178         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 179         tree ptm_desc_type_node;
 180         tree base_desc_type_node;
 181 #if 0
 182    Not needed yet?  May be needed one day?
 183         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 184         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 185         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 186 #endif
 187
 188         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 189         tree unknown_type_node;
 190
 191    Array type `vtable_entry_type[]'
 192
 193         tree vtbl_type_node;
 194         tree vtbl_ptr_type_node;
 195
 196    Namespaces,
 197
 198         tree std_node;
 199         tree abi_node;
 200
 201    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 202    one that the user will declare, but sufficient to be called
 203    by routines that want to abort the program.
 204
 205         tree abort_fndecl;
 206
 207    The FUNCTION_DECL for the default `::operator delete'.
 208
 209         tree global_delete_fndecl;
 210
 211    Used by RTTI
 212         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 213         tree tinfo_var_id;
 214
 215 */
 216
 217 tree cp_global_trees[CPTI_MAX];
 218
 219 /* Indicates that there is a type value in some namespace, although
 220    that is not necessarily in scope at the moment.  */
 221
 222 static tree global_type_node;
 223
 224 /* If non-zero, this is the number of times we have entered the `std'
 225    namespace when we are treating that namespace as an alias for the
 226    global namespace.  */
 227 static int in_fake_std;
 228
 229 /* Expect only namespace names now. */
 230 static int only_namespace_names;
 231
 232 /* Used only for jumps to as-yet undefined labels, since jumps to
 233    defined labels can have their validity checked immediately.  */
 234
 235 struct named_label_use_list
 236 {
 237   struct binding_level *binding_level;
 238   tree names_in_scope;
 239   tree label_decl;
 240   const char *filename_o_goto;
 241   int lineno_o_goto;
 242   struct named_label_use_list *next;
 243 };
 244
 245 #define named_label_uses cp_function_chain->x_named_label_uses
 246
 247 #define local_names cp_function_chain->x_local_names
 248
 249 /* A list of objects which have constructors or destructors
 250    which reside in the global scope.  The decl is stored in
 251    the TREE_VALUE slot and the initializer is stored
 252    in the TREE_PURPOSE slot.  */
 253 tree static_aggregates;
 254
 255 /* -- end of C++ */
 256
 257 /* A node for the integer constants 2, and 3.  */
 258
 259 tree integer_two_node, integer_three_node;
 260
 261 /* Parsing a function declarator leaves here a chain of structure
 262    and enum types declared in the parmlist.  */
 263
 264 static tree last_function_parm_tags;
 265
 266 /* Similar, for last_function_parm_tags.  */
 267 tree last_function_parms;
 268 static tree current_function_parm_tags;
 269
 270 /* A list of all LABEL_DECLs in the function that have names.  Here so
 271    we can clear out their names' definitions at the end of the
 272    function, and so we can check the validity of jumps to these labels.  */
 273
 274 struct named_label_list
 275 {
 276   struct binding_level *binding_level;
 277   tree names_in_scope;
 278   tree old_value;
 279   tree label_decl;
 280   tree bad_decls;
 281   struct named_label_list *next;
 282   unsigned int in_try_scope : 1;
 283   unsigned int in_catch_scope : 1;
 284 };
 285
 286 #define named_labels cp_function_chain->x_named_labels
 287
 288 /* Set to 0 at beginning of a function definition, and whenever
 289    a label (case or named) is defined.  Set to value of expression
 290    returned from function when that value can be transformed into
 291    a named return value.  */
 292
 293 tree current_function_return_value;
 294
 295 /* Nonzero means use the ISO C94 dialect of C.  */
 296
 297 int flag_isoc94;
 298
 299 /* Nonzero means use the ISO C99 dialect of C.  */
 300
 301 int flag_isoc99;
 302
 303 /* Nonzero means we are a hosted implementation for code shared with C.  */
 304
 305 int flag_hosted = 1;
 306
 307 /* Nonzero means add default format_arg attributes for functions not
 308    in ISO C.  */
 309
 310 int flag_noniso_default_format_attributes = 1;
 311
 312 /* Nonzero if we want to conserve space in the .o files.  We do this
 313    by putting uninitialized data and runtime initialized data into
 314    .common instead of .data at the expense of not flagging multiple
 315    definitions.  */
 316 extern int flag_conserve_space;
 317 \f
 318 /* C and C++ flags are in decl2.c.  */
 319
 320 /* Flag used when debugging spew.c */
 321
 322 extern int spew_debug;
 323
 324 /* A expression of value 0 with the same precision as a sizetype
 325    node, but signed.  */
 326 tree signed_size_zero_node;
 327
 328 /* The name of the anonymous namespace, throughout this translation
 329    unit.  */
 330 tree anonymous_namespace_name;
 331
 332 /* The number of function bodies which we are currently processing.
 333    (Zero if we are at namespace scope, one inside the body of a
 334    function, two inside the body of a function in a local class, etc.)  */
 335 int function_depth;
 336 \f
 337 /* For each binding contour we allocate a binding_level structure
 338    which records the names defined in that contour.
 339    Contours include:
 340     0) the global one
 341     1) one for each function definition,
 342        where internal declarations of the parameters appear.
 343     2) one for each compound statement,
 344        to record its declarations.
 345
 346    The current meaning of a name can be found by searching the levels
 347    from the current one out to the global one.
 348
 349    Off to the side, may be the class_binding_level.  This exists only
 350    to catch class-local declarations.  It is otherwise nonexistent.
 351
 352    Also there may be binding levels that catch cleanups that must be
 353    run when exceptions occur.  Thus, to see whether a name is bound in
 354    the current scope, it is not enough to look in the
 355    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 356    instead.  */
 357
 358 /* Note that the information in the `names' component of the global contour
 359    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 360
 361 struct binding_level
 362   {
 363     /* A chain of _DECL nodes for all variables, constants, functions,
 364        and typedef types.  These are in the reverse of the order
 365        supplied.  There may be OVERLOADs on this list, too, but they
 366        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 367     tree names;
 368
 369     /* A list of structure, union and enum definitions, for looking up
 370        tag names.
 371        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 372        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 373        or ENUMERAL_TYPE node.
 374
 375        C++: the TREE_VALUE nodes can be simple types for
 376        component_bindings.  */
 377     tree tags;
 378
 379     /* A list of USING_DECL nodes. */
 380     tree usings;
 381
 382     /* A list of used namespaces. PURPOSE is the namespace,
 383        VALUE the common ancestor with this binding_level's namespace. */
 384     tree using_directives;
 385
 386     /* If this binding level is the binding level for a class, then
 387        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 388        is the name of an entity bound in the class.  The TREE_TYPE is
 389        the DECL bound by this name in the class.  */
 390     tree class_shadowed;
 391
 392     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 393        is used for all binding levels. In addition the TREE_VALUE is the
 394        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 395     tree type_shadowed;
 396
 397     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 398        label in this scope.  The TREE_PURPOSE is the previous value of
 399        the IDENTIFIER_LABEL VALUE.  */
 400     tree shadowed_labels;
 401
 402     /* For each level (except not the global one),
 403        a chain of BLOCK nodes for all the levels
 404        that were entered and exited one level down.  */
 405     tree blocks;
 406
 407     /* The _TYPE node for this level, if parm_flag == 2.  */
 408     tree this_class;
 409
 410     /* The binding level which this one is contained in (inherits from).  */
 411     struct binding_level *level_chain;
 412
 413     /* List of decls in `names' that have incomplete
 414        structure or union types.  */
 415     tree incomplete;
 416
 417     /* List of VAR_DECLS saved from a previous for statement.
 418        These would be dead in ISO-conforming code, but might
 419        be referenced in ARM-era code.  These are stored in a
 420        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 421     tree dead_vars_from_for;
 422
 423     /* 1 for the level that holds the parameters of a function.
 424        2 for the level that holds a class declaration.  */
 425     unsigned parm_flag : 2;
 426
 427     /* 1 means make a BLOCK for this level regardless of all else.
 428        2 for temporary binding contours created by the compiler.  */
 429     unsigned keep : 2;
 430
 431     /* Nonzero if this level "doesn't exist" for tags.  */
 432     unsigned tag_transparent : 1;
 433
 434     /* Nonzero if this level can safely have additional
 435        cleanup-needing variables added to it.  */
 436     unsigned more_cleanups_ok : 1;
 437     unsigned have_cleanups : 1;
 438
 439     /* Nonzero if this scope is for storing the decls for template
 440        parameters and generic decls; these decls will be discarded and
 441        replaced with a TEMPLATE_DECL.  */
 442     unsigned template_parms_p : 1;
 443
 444     /* Nonzero if this scope corresponds to the `<>' in a
 445        `template <>' clause.  Whenever this flag is set,
 446        TEMPLATE_PARMS_P will be set as well.  */
 447     unsigned template_spec_p : 1;
 448
 449     /* This is set for a namespace binding level.  */
 450     unsigned namespace_p : 1;
 451
 452     /* True if this level is that of a for-statement where we need to
 453        worry about ambiguous (ARM or ISO) scope rules.  */
 454     unsigned is_for_scope : 1;
 455
 456     /* True if this level corresponds to a TRY block.  Currently this
 457        information is only available while building the tree structure.  */
 458     unsigned is_try_scope : 1;
 459
 460     /* True if this level corresponds to a CATCH block.  Currently this
 461        information is only available while building the tree structure.  */
 462     unsigned is_catch_scope : 1;
 463
 464     /* Three bits left for this word.  */
 465
 466 #if defined(DEBUG_CP_BINDING_LEVELS)
 467     /* Binding depth at which this level began.  */
 468     unsigned binding_depth;
 469 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 470   };
 471
 472 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 473
 474 /* The binding level currently in effect.  */
 475
 476 #define current_binding_level                   \
 477   (cfun && cp_function_chain->bindings          \
 478    ? cp_function_chain->bindings                \
 479    : scope_chain->bindings)
 480
 481 /* The binding level of the current class, if any.  */
 482
 483 #define class_binding_level scope_chain->class_bindings
 484
 485 /* A chain of binding_level structures awaiting reuse.  */
 486
 487 static struct binding_level *free_binding_level;
 488
 489 /* The outermost binding level, for names of file scope.
 490    This is created when the compiler is started and exists
 491    through the entire run.  */
 492
 493 static struct binding_level *global_binding_level;
 494
 495 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 496
 497 static int keep_next_level_flag;
 498
 499 #if defined(DEBUG_CP_BINDING_LEVELS)
 500 static int binding_depth = 0;
 501 static int is_class_level = 0;
 502
 503 static void
 504 indent ()
 505 {
 506   register unsigned i;
 507
 508   for (i = 0; i < binding_depth*2; i++)
 509     putc (' ', stderr);
 510 }
 511 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 512
 513 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 514
 515 static void
 516 push_binding_level (newlevel, tag_transparent, keep)
 517      struct binding_level *newlevel;
 518      int tag_transparent, keep;
 519 {
 520   /* Add this level to the front of the chain (stack) of levels that
 521      are active.  */
 522   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 523   newlevel->level_chain = current_binding_level;
 524   current_binding_level = newlevel;
 525   newlevel->tag_transparent = tag_transparent;
 526   newlevel->more_cleanups_ok = 1;
 527
 528   newlevel->keep = keep;
 529 #if defined(DEBUG_CP_BINDING_LEVELS)
 530   newlevel->binding_depth = binding_depth;
 531   indent ();
 532   fprintf (stderr, "push %s level 0x%08x line %d\n",
 533            (is_class_level) ? "class" : "block", newlevel, lineno);
 534   is_class_level = 0;
 535   binding_depth++;
 536 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 537 }
 538
 539 /* Find the innermost enclosing class scope, and reset
 540    CLASS_BINDING_LEVEL appropriately.  */
 541
 542 static void
 543 find_class_binding_level ()
 544 {
 545   struct binding_level *level = current_binding_level;
 546
 547   while (level && level->parm_flag != 2)
 548     level = level->level_chain;
 549   if (level && level->parm_flag == 2)
 550     class_binding_level = level;
 551   else
 552     class_binding_level = 0;
 553 }
 554
 555 static void
 556 pop_binding_level ()
 557 {
 558   if (global_binding_level)
 559     {
 560       /* Cannot pop a level, if there are none left to pop.  */
 561       if (current_binding_level == global_binding_level)
 562         my_friendly_abort (123);
 563     }
 564   /* Pop the current level, and free the structure for reuse.  */
 565 #if defined(DEBUG_CP_BINDING_LEVELS)
 566   binding_depth--;
 567   indent ();
 568   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 569           (is_class_level) ? "class" : "block",
 570           current_binding_level, lineno);
 571   if (is_class_level != (current_binding_level == class_binding_level))
 572     {
 573       indent ();
 574       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 575     }
 576   is_class_level = 0;
 577 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 578   {
 579     register struct binding_level *level = current_binding_level;
 580     current_binding_level = current_binding_level->level_chain;
 581     level->level_chain = free_binding_level;
 582 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 583     if (level->binding_depth != binding_depth)
 584       abort ();
 585 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 586     free_binding_level = level;
 587     find_class_binding_level ();
 588   }
 589 }
 590
 591 static void
 592 suspend_binding_level ()
 593 {
 594   if (class_binding_level)
 595     current_binding_level = class_binding_level;
 596
 597   if (global_binding_level)
 598     {
 599       /* Cannot suspend a level, if there are none left to suspend.  */
 600       if (current_binding_level == global_binding_level)
 601         my_friendly_abort (123);
 602     }
 603   /* Suspend the current level.  */
 604 #if defined(DEBUG_CP_BINDING_LEVELS)
 605   binding_depth--;
 606   indent ();
 607   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 608           (is_class_level) ? "class" : "block",
 609           current_binding_level, lineno);
 610   if (is_class_level != (current_binding_level == class_binding_level))
 611     {
 612       indent ();
 613       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 614     }
 615   is_class_level = 0;
 616 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 617   current_binding_level = current_binding_level->level_chain;
 618   find_class_binding_level ();
 619 }
 620
 621 static void
 622 resume_binding_level (b)
 623      struct binding_level *b;
 624 {
 625   /* Resuming binding levels is meant only for namespaces,
 626      and those cannot nest into classes. */
 627   my_friendly_assert(!class_binding_level, 386);
 628   /* Also, resuming a non-directly nested namespace is a no-no.  */
 629   my_friendly_assert(b->level_chain == current_binding_level, 386);
 630   current_binding_level = b;
 631 #if defined(DEBUG_CP_BINDING_LEVELS)
 632   b->binding_depth = binding_depth;
 633   indent ();
 634   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 635            (is_class_level) ? "class" : "block", b, lineno);
 636   is_class_level = 0;
 637   binding_depth++;
 638 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 639 }
 640 \f
 641 /* Create a new `struct binding_level'.  */
 642
 643 static
 644 struct binding_level *
 645 make_binding_level ()
 646 {
 647   /* NOSTRICT */
 648   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 649 }
 650
 651 /* Nonzero if we are currently in the global binding level.  */
 652
 653 int
 654 global_bindings_p ()
 655 {
 656   return current_binding_level == global_binding_level;
 657 }
 658
 659 /* Return the innermost binding level that is not for a class scope.  */
 660
 661 static struct binding_level *
 662 innermost_nonclass_level ()
 663 {
 664   struct binding_level *b;
 665
 666   b = current_binding_level;
 667   while (b->parm_flag == 2)
 668     b = b->level_chain;
 669
 670   return b;
 671 }
 672
 673 /* Nonzero if we are currently in a toplevel binding level.  This
 674    means either the global binding level or a namespace in a toplevel
 675    binding level.  Since there are no non-toplevel namespace levels,
 676    this really means any namespace or template parameter level.  We
 677    also include a class whose context is toplevel.  */
 678
 679 int
 680 toplevel_bindings_p ()
 681 {
 682   struct binding_level *b = innermost_nonclass_level ();
 683
 684   return b->namespace_p || b->template_parms_p;
 685 }
 686
 687 /* Nonzero if this is a namespace scope, or if we are defining a class
 688    which is itself at namespace scope, or whose enclosing class is
 689    such a class, etc.  */
 690
 691 int
 692 namespace_bindings_p ()
 693 {
 694   struct binding_level *b = innermost_nonclass_level ();
 695
 696   return b->namespace_p;
 697 }
 698
 699 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 700    unconditionally.  Otherwise, use the normal logic to decide whether
 701    or not to create a BLOCK.  */
 702
 703 void
 704 keep_next_level (keep)
 705      int keep;
 706 {
 707   keep_next_level_flag = keep;
 708 }
 709
 710 /* Nonzero if the current level needs to have a BLOCK made.  */
 711
 712 int
 713 kept_level_p ()
 714 {
 715   return (current_binding_level->blocks != NULL_TREE
 716           || current_binding_level->keep
 717           || current_binding_level->names != NULL_TREE
 718           || (current_binding_level->tags != NULL_TREE
 719               && !current_binding_level->tag_transparent));
 720 }
 721
 722 static void
 723 declare_namespace_level ()
 724 {
 725   current_binding_level->namespace_p = 1;
 726 }
 727
 728 /* Returns non-zero if this scope was created to store template
 729    parameters.  */
 730
 731 int
 732 template_parm_scope_p ()
 733 {
 734   return current_binding_level->template_parms_p;
 735 }
 736
 737 /* Returns the kind of template specialization we are currently
 738    processing, given that it's declaration contained N_CLASS_SCOPES
 739    explicit scope qualifications.  */
 740
 741 tmpl_spec_kind
 742 current_tmpl_spec_kind (n_class_scopes)
 743      int n_class_scopes;
 744 {
 745   int n_template_parm_scopes = 0;
 746   int seen_specialization_p = 0;
 747   int innermost_specialization_p = 0;
 748   struct binding_level *b;
 749
 750   /* Scan through the template parameter scopes.  */
 751   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 752     {
 753       /* If we see a specialization scope inside a parameter scope,
 754          then something is wrong.  That corresponds to a declaration
 755          like:
 756
 757             template <class T> template <> ...
 758
 759          which is always illegal since [temp.expl.spec] forbids the
 760          specialization of a class member template if the enclosing
 761          class templates are not explicitly specialized as well.  */
 762       if (b->template_spec_p)
 763         {
 764           if (n_template_parm_scopes == 0)
 765             innermost_specialization_p = 1;
 766           else
 767             seen_specialization_p = 1;
 768         }
 769       else if (seen_specialization_p == 1)
 770         return tsk_invalid_member_spec;
 771
 772       ++n_template_parm_scopes;
 773     }
 774
 775   /* Handle explicit instantiations.  */
 776   if (processing_explicit_instantiation)
 777     {
 778       if (n_template_parm_scopes != 0)
 779         /* We've seen a template parameter list during an explicit
 780            instantiation.  For example:
 781
 782              template <class T> template void f(int);
 783
 784            This is erroneous.  */
 785         return tsk_invalid_expl_inst;
 786       else
 787         return tsk_expl_inst;
 788     }
 789
 790   if (n_template_parm_scopes < n_class_scopes)
 791     /* We've not seen enough template headers to match all the
 792        specialized classes present.  For example:
 793
 794          template <class T> void R<T>::S<T>::f(int);
 795
 796        This is illegal; there needs to be one set of template
 797        parameters for each class.  */
 798     return tsk_insufficient_parms;
 799   else if (n_template_parm_scopes == n_class_scopes)
 800     /* We're processing a non-template declaration (even though it may
 801        be a member of a template class.)  For example:
 802
 803          template <class T> void S<T>::f(int);
 804
 805        The `class T' maches the `S<T>', leaving no template headers
 806        corresponding to the `f'.  */
 807     return tsk_none;
 808   else if (n_template_parm_scopes > n_class_scopes + 1)
 809     /* We've got too many template headers.  For example:
 810
 811          template <> template <class T> void f (T);
 812
 813        There need to be more enclosing classes.  */
 814     return tsk_excessive_parms;
 815   else
 816     /* This must be a template.  It's of the form:
 817
 818          template <class T> template <class U> void S<T>::f(U);
 819
 820        This is a specialization if the innermost level was a
 821        specialization; otherwise it's just a definition of the
 822        template.  */
 823     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 824 }
 825
 826 void
 827 set_class_shadows (shadows)
 828      tree shadows;
 829 {
 830   class_binding_level->class_shadowed = shadows;
 831 }
 832
 833 /* Enter a new binding level.
 834    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 835    not for that of tags.  */
 836
 837 void
 838 pushlevel (tag_transparent)
 839      int tag_transparent;
 840 {
 841   struct binding_level *newlevel;
 842
 843   if (cfun && !doing_semantic_analysis_p ())
 844     return;
 845
 846   /* Reuse or create a struct for this binding level.  */
 847 #if defined(DEBUG_CP_BINDING_LEVELS)
 848   if (0)
 849 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 850   if (free_binding_level)
 851 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 852     {
 853       newlevel = free_binding_level;
 854       free_binding_level = free_binding_level->level_chain;
 855     }
 856   else
 857     newlevel = make_binding_level ();
 858
 859   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 860   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 861   keep_next_level_flag = 0;
 862 }
 863
 864 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 865    we're not allowed to add any more objects with cleanups to the current
 866    scope, create a new binding level.  */
 867
 868 void
 869 maybe_push_cleanup_level (type)
 870      tree type;
 871 {
 872   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 873       && current_binding_level->more_cleanups_ok == 0)
 874     {
 875       keep_next_level (2);
 876       pushlevel (1);
 877       clear_last_expr ();
 878       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 879     }
 880 }
 881
 882 /* Enter a new scope.  The KIND indicates what kind of scope is being
 883    created.  */
 884
 885 void
 886 begin_scope (sk)
 887      scope_kind sk;
 888 {
 889   pushlevel (0);
 890
 891   switch (sk)
 892     {
 893     case sk_template_spec:
 894       current_binding_level->template_spec_p = 1;
 895       /* Fall through.  */
 896
 897     case sk_template_parms:
 898       current_binding_level->template_parms_p = 1;
 899       break;
 900
 901     default:
 902       my_friendly_abort (20000309);
 903     }
 904 }
 905
 906 /* Exit the current scope.  */
 907
 908 void
 909 finish_scope ()
 910 {
 911   poplevel (0, 0, 0);
 912 }
 913
 914 void
 915 note_level_for_for ()
 916 {
 917   current_binding_level->is_for_scope = 1;
 918 }
 919
 920 /* Record that the current binding level represents a try block.  */
 921
 922 void
 923 note_level_for_try ()
 924 {
 925   current_binding_level->is_try_scope = 1;
 926 }
 927
 928 /* Record that the current binding level represents a catch block.  */
 929
 930 void
 931 note_level_for_catch ()
 932 {
 933   current_binding_level->is_catch_scope = 1;
 934 }
 935
 936 /* For a binding between a name and an entity at a block scope,
 937    this is the `struct binding_level' for the block.  */
 938 #define BINDING_LEVEL(NODE) \
 939    (((struct tree_binding*)NODE)->scope.level)
 940
 941 /* A free list of CPLUS_BINDING nodes, connected by their
 942    TREE_CHAINs.  */
 943
 944 static tree free_bindings;
 945
 946 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 947    level at which this declaration is being bound.  */
 948
 949 static void
 950 push_binding (id, decl, level)
 951      tree id;
 952      tree decl;
 953      struct binding_level* level;
 954 {
 955   tree binding;
 956
 957   if (free_bindings)
 958     {
 959       binding = free_bindings;
 960       free_bindings = TREE_CHAIN (binding);
 961     }
 962   else
 963     binding = make_node (CPLUS_BINDING);
 964
 965   /* Now, fill in the binding information.  */
 966   BINDING_VALUE (binding) = decl;
 967   BINDING_TYPE (binding) = NULL_TREE;
 968   BINDING_LEVEL (binding) = level;
 969   INHERITED_VALUE_BINDING_P (binding) = 0;
 970   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 971   BINDING_HAS_LEVEL_P (binding) = 1;
 972
 973   /* And put it on the front of the list of bindings for ID.  */
 974   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 975   IDENTIFIER_BINDING (id) = binding;
 976 }
 977
 978 /* ID is already bound in the current scope.  But, DECL is an
 979    additional binding for ID in the same scope.  This is the `struct
 980    stat' hack whereby a non-typedef class-name or enum-name can be
 981    bound at the same level as some other kind of entity.  It's the
 982    responsibility of the caller to check that inserting this name is
 983    legal here.  Returns nonzero if the new binding was successful.  */
 984 static int
 985 add_binding (id, decl)
 986      tree id;
 987      tree decl;
 988 {
 989   tree binding = IDENTIFIER_BINDING (id);
 990   int ok = 1;
 991
 992   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 993     /* The new name is the type name.  */
 994     BINDING_TYPE (binding) = decl;
 995   else if (!BINDING_VALUE (binding))
 996     /* This situation arises when push_class_level_binding moves an
 997        inherited type-binding out of the way to make room for a new
 998        value binding.  */
 999     BINDING_VALUE (binding) = decl;
1000   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1001            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1002     {
1003       /* The old binding was a type name.  It was placed in
1004          BINDING_VALUE because it was thought, at the point it was
1005          declared, to be the only entity with such a name.  Move the
1006          type name into the type slot; it is now hidden by the new
1007          binding.  */
1008       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1009       BINDING_VALUE (binding) = decl;
1010       INHERITED_VALUE_BINDING_P (binding) = 0;
1011     }
1012   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1013            && TREE_CODE (decl) == TYPE_DECL
1014            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1015            && same_type_p (TREE_TYPE (decl),
1016                            TREE_TYPE (BINDING_VALUE (binding))))
1017     /* We have two typedef-names, both naming the same type to have
1018        the same name.  This is OK because of:
1019
1020          [dcl.typedef]
1021
1022          In a given scope, a typedef specifier can be used to redefine
1023          the name of any type declared in that scope to refer to the
1024          type to which it already refers.  */
1025     ok = 0;
1026   /* There can be two block-scope declarations of the same variable,
1027      so long as they are `extern' declarations.  */
1028   else if (TREE_CODE (decl) == VAR_DECL
1029            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1030            && DECL_EXTERNAL (decl)
1031            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1032     {
1033       duplicate_decls (decl, BINDING_VALUE (binding));
1034       ok = 0;
1035     }
1036   else
1037     {
1038       cp_error ("declaration of `%#D'", decl);
1039       cp_error_at ("conflicts with previous declaration `%#D'",
1040                    BINDING_VALUE (binding));
1041       ok = 0;
1042     }
1043
1044   return ok;
1045 }
1046
1047 /* Add DECL to the list of things declared in B.  */
1048
1049 static void
1050 add_decl_to_level (decl, b)
1051      tree decl;
1052      struct binding_level *b;
1053 {
1054   /* We build up the list in reverse order, and reverse it later if
1055      necessary.  */
1056   TREE_CHAIN (decl) = b->names;
1057   b->names = decl;
1058 }
1059
1060 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1061    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1062    doesn't really belong to this binding level, that it got here
1063    through a using-declaration.  */
1064
1065 void
1066 push_local_binding (id, decl, flags)
1067      tree id;
1068      tree decl;
1069      int flags;
1070 {
1071   struct binding_level *b;
1072
1073   /* Skip over any local classes.  This makes sense if we call
1074      push_local_binding with a friend decl of a local class.  */
1075   b = current_binding_level;
1076   while (b->parm_flag == 2)
1077     b = b->level_chain;
1078
1079   if (lookup_name_current_level (id))
1080     {
1081       /* Supplement the existing binding.  */
1082       if (!add_binding (id, decl))
1083         /* It didn't work.  Something else must be bound at this
1084            level.  Do not add DECL to the list of things to pop
1085            later.  */
1086         return;
1087     }
1088   else
1089     /* Create a new binding.  */
1090     push_binding (id, decl, b);
1091
1092   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1093     /* We must put the OVERLOAD into a TREE_LIST since the
1094        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1095        decls that got here through a using-declaration.  */
1096     decl = build_tree_list (NULL_TREE, decl);
1097
1098   /* And put DECL on the list of things declared by the current
1099      binding level.  */
1100   add_decl_to_level (decl, b);
1101 }
1102
1103 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1104    binding was successful.  */
1105
1106 int
1107 push_class_binding (id, decl)
1108      tree id;
1109      tree decl;
1110 {
1111   int result = 1;
1112   tree binding = IDENTIFIER_BINDING (id);
1113   tree context;
1114
1115   /* Note that we declared this value so that we can issue an error if
1116      this an illegal redeclaration of a name already used for some
1117      other purpose.  */
1118   note_name_declared_in_class (id, decl);
1119
1120   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1121     /* Supplement the existing binding.  */
1122     result = add_binding (id, decl);
1123   else
1124     /* Create a new binding.  */
1125     push_binding (id, decl, class_binding_level);
1126
1127   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1128      class-level declaration.  Note that we do not use DECL here
1129      because of the possibility of the `struct stat' hack; if DECL is
1130      a class-name or enum-name we might prefer a field-name, or some
1131      such.  */
1132   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1133
1134   /* If this is a binding from a base class, mark it as such.  */
1135   binding = IDENTIFIER_BINDING (id);
1136   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1137     {
1138       /* Any implicit typename must be from a base-class.  The
1139          context for an implicit typename declaration is always
1140          the derived class in which the lookup was done, so the checks
1141          based on the context of DECL below will not trigger.  */
1142       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1143         INHERITED_VALUE_BINDING_P (binding) = 1;
1144       else
1145         {
1146           if (TREE_CODE (decl) == OVERLOAD)
1147             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1148           else
1149             {
1150               my_friendly_assert (DECL_P (decl), 0);
1151               context = context_for_name_lookup (decl);
1152             }
1153
1154           if (is_properly_derived_from (current_class_type, context))
1155             INHERITED_VALUE_BINDING_P (binding) = 1;
1156           else
1157             INHERITED_VALUE_BINDING_P (binding) = 0;
1158         }
1159     }
1160   else if (BINDING_VALUE (binding) == decl)
1161     /* We only encounter a TREE_LIST when push_class_decls detects an
1162        ambiguity.  Such an ambiguity can be overridden by a definition
1163        in this class.  */
1164     INHERITED_VALUE_BINDING_P (binding) = 1;
1165
1166   return result;
1167 }
1168
1169 /* Remove the binding for DECL which should be the innermost binding
1170    for ID.  */
1171
1172 static void
1173 pop_binding (id, decl)
1174      tree id;
1175      tree decl;
1176 {
1177   tree binding;
1178
1179   if (id == NULL_TREE)
1180     /* It's easiest to write the loops that call this function without
1181        checking whether or not the entities involved have names.  We
1182        get here for such an entity.  */
1183     return;
1184
1185   /* Get the innermost binding for ID.  */
1186   binding = IDENTIFIER_BINDING (id);
1187
1188   /* The name should be bound.  */
1189   my_friendly_assert (binding != NULL_TREE, 0);
1190
1191   /* The DECL will be either the ordinary binding or the type
1192      binding for this identifier.  Remove that binding.  */
1193   if (BINDING_VALUE (binding) == decl)
1194     BINDING_VALUE (binding) = NULL_TREE;
1195   else if (BINDING_TYPE (binding) == decl)
1196     BINDING_TYPE (binding) = NULL_TREE;
1197   else
1198     my_friendly_abort (0);
1199
1200   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1201     {
1202       /* We're completely done with the innermost binding for this
1203          identifier.  Unhook it from the list of bindings.  */
1204       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1205
1206       /* Add it to the free list.  */
1207       TREE_CHAIN (binding) = free_bindings;
1208       free_bindings = binding;
1209
1210       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1211          it.  */
1212       BINDING_LEVEL (binding) = NULL;
1213     }
1214 }
1215
1216 /* When a label goes out of scope, check to see if that label was used
1217    in a valid manner, and issue any appropriate warnings or errors.  */
1218
1219 static void
1220 pop_label (label, old_value)
1221      tree label;
1222      tree old_value;
1223 {
1224   if (!processing_template_decl && doing_semantic_analysis_p ())
1225     {
1226       if (DECL_INITIAL (label) == NULL_TREE)
1227         {
1228           cp_error_at ("label `%D' used but not defined", label);
1229           /* Avoid crashing later.  */
1230           define_label (input_filename, 1, DECL_NAME (label));
1231         }
1232       else if (warn_unused_label && !TREE_USED (label))
1233         cp_warning_at ("label `%D' defined but not used", label);
1234     }
1235
1236   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1237 }
1238
1239 /* At the end of a function, all labels declared within the function
1240    go out of scope.  BLOCK is the top-level block for the
1241    function.  */
1242
1243 static void
1244 pop_labels (block)
1245      tree block;
1246 {
1247   struct named_label_list *link;
1248
1249   /* Clear out the definitions of all label names, since their scopes
1250      end here.  */
1251   for (link = named_labels; link; link = link->next)
1252     {
1253       pop_label (link->label_decl, link->old_value);
1254       /* Put the labels into the "variables" of the top-level block,
1255          so debugger can see them.  */
1256       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1257       BLOCK_VARS (block) = link->label_decl;
1258     }
1259
1260   named_labels = NULL;
1261 }
1262
1263 /* Exit a binding level.
1264    Pop the level off, and restore the state of the identifier-decl mappings
1265    that were in effect when this level was entered.
1266
1267    If KEEP == 1, this level had explicit declarations, so
1268    and create a "block" (a BLOCK node) for the level
1269    to record its declarations and subblocks for symbol table output.
1270
1271    If FUNCTIONBODY is nonzero, this level is the body of a function,
1272    so create a block as if KEEP were set and also clear out all
1273    label names.
1274
1275    If REVERSE is nonzero, reverse the order of decls before putting
1276    them into the BLOCK.  */
1277
1278 tree
1279 poplevel (keep, reverse, functionbody)
1280      int keep;
1281      int reverse;
1282      int functionbody;
1283 {
1284   register tree link;
1285   /* The chain of decls was accumulated in reverse order.
1286      Put it into forward order, just for cleanliness.  */
1287   tree decls;
1288   int tmp = functionbody;
1289   int real_functionbody;
1290   tree tags;
1291   tree subblocks;
1292   tree block = NULL_TREE;
1293   tree decl;
1294   int leaving_for_scope;
1295
1296   if (cfun && !doing_semantic_analysis_p ())
1297     return NULL_TREE;
1298
1299   my_friendly_assert (current_binding_level->parm_flag != 2,
1300                       19990916);
1301
1302   real_functionbody = (current_binding_level->keep == 2
1303                        ? ((functionbody = 0), tmp) : functionbody);
1304   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1305   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1306
1307   my_friendly_assert (!current_binding_level->class_shadowed,
1308                       19990414);
1309
1310   /* We used to use KEEP == 2 to indicate that the new block should go
1311      at the beginning of the list of blocks at this binding level,
1312      rather than the end.  This hack is no longer used.  */
1313   my_friendly_assert (keep == 0 || keep == 1, 0);
1314
1315   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1316                       (HOST_WIDE_INT) current_binding_level->level_chain,
1317                       current_binding_level->parm_flag,
1318                       current_binding_level->keep);
1319
1320   if (current_binding_level->keep == 1)
1321     keep = 1;
1322
1323   /* Any uses of undefined labels, and any defined labels, now operate
1324      under constraints of next binding contour.  */
1325   if (cfun && !functionbody)
1326     {
1327       struct binding_level *level_chain;
1328       level_chain = current_binding_level->level_chain;
1329       if (level_chain)
1330         {
1331           struct named_label_use_list *uses;
1332           struct named_label_list *labels;
1333           for (labels = named_labels; labels; labels = labels->next)
1334             if (labels->binding_level == current_binding_level)
1335               {
1336                 tree decl;
1337                 if (current_binding_level->is_try_scope)
1338                   labels->in_try_scope = 1;
1339                 if (current_binding_level->is_catch_scope)
1340                   labels->in_catch_scope = 1;
1341                 for (decl = labels->names_in_scope; decl;
1342                      decl = TREE_CHAIN (decl))
1343                   if (decl_jump_unsafe (decl))
1344                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1345                                                    labels->bad_decls);
1346                 labels->binding_level = level_chain;
1347                 labels->names_in_scope = level_chain->names;
1348               }
1349
1350           for (uses = named_label_uses; uses; uses = uses->next)
1351             if (uses->binding_level == current_binding_level)
1352               {
1353                 uses->binding_level = level_chain;
1354                 uses->names_in_scope = level_chain->names;
1355               }
1356         }
1357     }
1358
1359   /* Get the decls in the order they were written.
1360      Usually current_binding_level->names is in reverse order.
1361      But parameter decls were previously put in forward order.  */
1362
1363   if (reverse)
1364     current_binding_level->names
1365       = decls = nreverse (current_binding_level->names);
1366   else
1367     decls = current_binding_level->names;
1368
1369   /* Output any nested inline functions within this block
1370      if they weren't already output.  */
1371   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1372     if (TREE_CODE (decl) == FUNCTION_DECL
1373         && ! TREE_ASM_WRITTEN (decl)
1374         && DECL_INITIAL (decl) != NULL_TREE
1375         && TREE_ADDRESSABLE (decl)
1376         && decl_function_context (decl) == current_function_decl)
1377       {
1378         /* If this decl was copied from a file-scope decl
1379            on account of a block-scope extern decl,
1380            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1381         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1382           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1383         else
1384           {
1385             push_function_context ();
1386             output_inline_function (decl);
1387             pop_function_context ();
1388           }
1389       }
1390
1391   /* When not in function-at-a-time mode, expand_end_bindings will
1392      warn about unused variables.  But, in function-at-a-time mode
1393      expand_end_bindings is not passed the list of variables in the
1394      current scope, and therefore no warning is emitted.  So, we
1395      explicitly warn here.  */
1396   if (!processing_template_decl)
1397     warn_about_unused_variables (getdecls ());
1398
1399   /* If there were any declarations or structure tags in that level,
1400      or if this level is a function body,
1401      create a BLOCK to record them for the life of this function.  */
1402   block = NULL_TREE;
1403   if (keep == 1 || functionbody)
1404     block = make_node (BLOCK);
1405   if (block != NULL_TREE)
1406     {
1407       BLOCK_VARS (block) = decls;
1408       BLOCK_SUBBLOCKS (block) = subblocks;
1409     }
1410
1411   /* In each subblock, record that this is its superior.  */
1412   if (keep >= 0)
1413     for (link = subblocks; link; link = TREE_CHAIN (link))
1414       BLOCK_SUPERCONTEXT (link) = block;
1415
1416   /* We still support the old for-scope rules, whereby the variables
1417      in a for-init statement were in scope after the for-statement
1418      ended.  We only use the new rules in flag_new_for_scope is
1419      nonzero.  */
1420   leaving_for_scope
1421     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1422
1423   /* Remove declarations for all the DECLs in this level.  */
1424   for (link = decls; link; link = TREE_CHAIN (link))
1425     {
1426       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1427           && DECL_NAME (link))
1428         {
1429           tree outer_binding
1430             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1431           tree ns_binding;
1432
1433           if (!outer_binding)
1434             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1435           else
1436             ns_binding = NULL_TREE;
1437
1438           if (outer_binding
1439               && (BINDING_LEVEL (outer_binding)
1440                   == current_binding_level->level_chain))
1441             /* We have something like:
1442
1443                  int i;
1444                  for (int i; ;);
1445
1446                and we are leaving the `for' scope.  There's no reason to
1447                keep the binding of the inner `i' in this case.  */
1448             pop_binding (DECL_NAME (link), link);
1449           else if ((outer_binding
1450                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1451                         == TYPE_DECL))
1452                    || (ns_binding
1453                        && TREE_CODE (ns_binding) == TYPE_DECL))
1454             /* Here, we have something like:
1455
1456                  typedef int I;
1457
1458                  void f () {
1459                    for (int I; ;);
1460                  }
1461
1462                We must pop the for-scope binding so we know what's a
1463                type and what isn't.  */
1464             pop_binding (DECL_NAME (link), link);
1465           else
1466             {
1467               /* Mark this VAR_DECL as dead so that we can tell we left it
1468                  there only for backward compatibility.  */
1469               DECL_DEAD_FOR_LOCAL (link) = 1;
1470
1471               /* Keep track of what should of have happenned when we
1472                  popped the binding.  */
1473               if (outer_binding && BINDING_VALUE (outer_binding))
1474                 DECL_SHADOWED_FOR_VAR (link)
1475                   = BINDING_VALUE (outer_binding);
1476
1477               /* Add it to the list of dead variables in the next
1478                  outermost binding to that we can remove these when we
1479                  leave that binding.  */
1480               current_binding_level->level_chain->dead_vars_from_for
1481                 = tree_cons (NULL_TREE, link,
1482                              current_binding_level->level_chain->
1483                              dead_vars_from_for);
1484
1485               /* Although we don't pop the CPLUS_BINDING, we do clear
1486                  its BINDING_LEVEL since the level is going away now.  */
1487               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1488                 = 0;
1489             }
1490         }
1491       else
1492         {
1493           /* Remove the binding.  */
1494           decl = link;
1495           if (TREE_CODE (decl) == TREE_LIST)
1496             decl = TREE_VALUE (decl);
1497           if (DECL_P (decl))
1498             pop_binding (DECL_NAME (decl), decl);
1499           else if (TREE_CODE (decl) == OVERLOAD)
1500             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1501           else
1502             my_friendly_abort (0);
1503         }
1504     }
1505
1506   /* Remove declarations for any `for' variables from inner scopes
1507      that we kept around.  */
1508   for (link = current_binding_level->dead_vars_from_for;
1509        link; link = TREE_CHAIN (link))
1510     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1511
1512   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1513   for (link = current_binding_level->type_shadowed;
1514        link; link = TREE_CHAIN (link))
1515     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1516
1517   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1518   for (link = current_binding_level->shadowed_labels;
1519        link;
1520        link = TREE_CHAIN (link))
1521     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1522
1523   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1524      list if a `using' declaration put them there.  The debugging
1525      back-ends won't understand OVERLOAD, so we remove them here.
1526      Because the BLOCK_VARS are (temporarily) shared with
1527      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1528      popped all the bindings.  */
1529   if (block)
1530     {
1531       tree* d;
1532
1533       for (d = &BLOCK_VARS (block); *d; )
1534         {
1535           if (TREE_CODE (*d) == TREE_LIST)
1536             *d = TREE_CHAIN (*d);
1537           else
1538             d = &TREE_CHAIN (*d);
1539         }
1540     }
1541
1542   /* If the level being exited is the top level of a function,
1543      check over all the labels.  */
1544   if (functionbody)
1545     {
1546       /* Since this is the top level block of a function, the vars are
1547          the function's parameters.  Don't leave them in the BLOCK
1548          because they are found in the FUNCTION_DECL instead.  */
1549       BLOCK_VARS (block) = 0;
1550       pop_labels (block);
1551     }
1552
1553   tmp = current_binding_level->keep;
1554
1555   pop_binding_level ();
1556   if (functionbody)
1557     DECL_INITIAL (current_function_decl) = block;
1558   else if (block)
1559     current_binding_level->blocks
1560       = chainon (current_binding_level->blocks, block);
1561
1562   /* If we did not make a block for the level just exited,
1563      any blocks made for inner levels
1564      (since they cannot be recorded as subblocks in that level)
1565      must be carried forward so they will later become subblocks
1566      of something else.  */
1567   else if (subblocks)
1568     current_binding_level->blocks
1569       = chainon (current_binding_level->blocks, subblocks);
1570
1571   /* Each and every BLOCK node created here in `poplevel' is important
1572      (e.g. for proper debugging information) so if we created one
1573      earlier, mark it as "used".  */
1574   if (block)
1575     TREE_USED (block) = 1;
1576
1577   /* Take care of compiler's internal binding structures.  */
1578   if (tmp == 2)
1579     {
1580       tree scope_stmts;
1581
1582       scope_stmts
1583         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1584       if (block)
1585         {
1586           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1587           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1588         }
1589
1590       block = poplevel (keep, reverse, functionbody);
1591     }
1592
1593   return block;
1594 }
1595
1596 /* Delete the node BLOCK from the current binding level.
1597    This is used for the block inside a stmt expr ({...})
1598    so that the block can be reinserted where appropriate.  */
1599
1600 void
1601 delete_block (block)
1602      tree block;
1603 {
1604   tree t;
1605   if (current_binding_level->blocks == block)
1606     current_binding_level->blocks = TREE_CHAIN (block);
1607   for (t = current_binding_level->blocks; t;)
1608     {
1609       if (TREE_CHAIN (t) == block)
1610         TREE_CHAIN (t) = TREE_CHAIN (block);
1611       else
1612         t = TREE_CHAIN (t);
1613     }
1614   TREE_CHAIN (block) = NULL_TREE;
1615   /* Clear TREE_USED which is always set by poplevel.
1616      The flag is set again if insert_block is called.  */
1617   TREE_USED (block) = 0;
1618 }
1619
1620 /* Insert BLOCK at the end of the list of subblocks of the
1621    current binding level.  This is used when a BIND_EXPR is expanded,
1622    to handle the BLOCK node inside the BIND_EXPR.  */
1623
1624 void
1625 insert_block (block)
1626      tree block;
1627 {
1628   TREE_USED (block) = 1;
1629   current_binding_level->blocks
1630     = chainon (current_binding_level->blocks, block);
1631 }
1632
1633 /* Set the BLOCK node for the innermost scope
1634    (the one we are currently in).  */
1635
1636 void
1637 set_block (block)
1638     tree block ATTRIBUTE_UNUSED;
1639 {
1640   /* The RTL expansion machinery requires us to provide this callback,
1641      but it is not applicable in function-at-a-time mode.  */
1642   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1643 }
1644
1645 /* Do a pushlevel for class declarations.  */
1646
1647 void
1648 pushlevel_class ()
1649 {
1650   register struct binding_level *newlevel;
1651
1652   /* Reuse or create a struct for this binding level.  */
1653 #if defined(DEBUG_CP_BINDING_LEVELS)
1654   if (0)
1655 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1656   if (free_binding_level)
1657 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1658     {
1659       newlevel = free_binding_level;
1660       free_binding_level = free_binding_level->level_chain;
1661     }
1662   else
1663     newlevel = make_binding_level ();
1664
1665 #if defined(DEBUG_CP_BINDING_LEVELS)
1666   is_class_level = 1;
1667 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1668
1669   push_binding_level (newlevel, 0, 0);
1670
1671   class_binding_level = current_binding_level;
1672   class_binding_level->parm_flag = 2;
1673   class_binding_level->this_class = current_class_type;
1674 }
1675
1676 /* ...and a poplevel for class declarations.  */
1677
1678 void
1679 poplevel_class ()
1680 {
1681   register struct binding_level *level = class_binding_level;
1682   tree shadowed;
1683
1684   my_friendly_assert (level != 0, 354);
1685
1686   /* If we're leaving a toplevel class, don't bother to do the setting
1687      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1688      shouldn't even be used when current_class_type isn't set, and second,
1689      if we don't touch it here, we're able to use the cache effect if the
1690      next time we're entering a class scope, it is the same class.  */
1691   if (current_class_depth != 1)
1692     {
1693       struct binding_level* b;
1694
1695       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1696       for (shadowed = level->class_shadowed;
1697            shadowed;
1698            shadowed = TREE_CHAIN (shadowed))
1699         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1700
1701       /* Find the next enclosing class, and recreate
1702          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1703       b = level->level_chain;
1704       while (b && b->parm_flag != 2)
1705         b = b->level_chain;
1706
1707       if (b)
1708         for (shadowed = b->class_shadowed;
1709              shadowed;
1710              shadowed = TREE_CHAIN (shadowed))
1711           {
1712             tree t;
1713
1714             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1715             while (t && BINDING_LEVEL (t) != b)
1716               t = TREE_CHAIN (t);
1717
1718             if (t)
1719               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1720                 = BINDING_VALUE (t);
1721           }
1722     }
1723   else
1724     /* Remember to save what IDENTIFIER's were bound in this scope so we
1725        can recover from cache misses.  */
1726     {
1727       previous_class_type = current_class_type;
1728       previous_class_values = class_binding_level->class_shadowed;
1729     }
1730   for (shadowed = level->type_shadowed;
1731        shadowed;
1732        shadowed = TREE_CHAIN (shadowed))
1733     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1734
1735   /* Remove the bindings for all of the class-level declarations.  */
1736   for (shadowed = level->class_shadowed;
1737        shadowed;
1738        shadowed = TREE_CHAIN (shadowed))
1739     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1740
1741   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1742                       (HOST_WIDE_INT) class_binding_level->level_chain,
1743                       class_binding_level->parm_flag,
1744                       class_binding_level->keep);
1745
1746   /* Now, pop out of the binding level which we created up in the
1747      `pushlevel_class' routine.  */
1748 #if defined(DEBUG_CP_BINDING_LEVELS)
1749   is_class_level = 1;
1750 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1751
1752   pop_binding_level ();
1753 }
1754
1755 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1756    for any names in enclosing classes.  */
1757
1758 void
1759 clear_identifier_class_values ()
1760 {
1761   tree t;
1762
1763   if (!class_binding_level)
1764     return;
1765
1766   for (t = class_binding_level->class_shadowed;
1767        t;
1768        t = TREE_CHAIN (t))
1769     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1770 }
1771
1772 /* Returns non-zero if T is a virtual function table.  */
1773
1774 int
1775 vtable_decl_p (t, data)
1776      tree t;
1777      void *data ATTRIBUTE_UNUSED;
1778 {
1779   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1780 }
1781
1782 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1783    functions.  */
1784
1785 int
1786 vtype_decl_p (t, data)
1787      tree t;
1788      void *data ATTRIBUTE_UNUSED;
1789 {
1790   return (TREE_CODE (t) == TYPE_DECL
1791           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1792           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1793 }
1794
1795 /* Return the declarations that are members of the namespace NS.  */
1796
1797 tree
1798 cp_namespace_decls (ns)
1799      tree ns;
1800 {
1801   return NAMESPACE_LEVEL (ns)->names;
1802 }
1803
1804 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1805    itself, calling F for each.  The DATA is passed to F as well.  */
1806
1807 static int
1808 walk_namespaces_r (namespace, f, data)
1809      tree namespace;
1810      walk_namespaces_fn f;
1811      void *data;
1812 {
1813   tree current;
1814   int result = 0;
1815
1816   result |= (*f) (namespace, data);
1817
1818   for (current = cp_namespace_decls (namespace);
1819        current;
1820        current = TREE_CHAIN (current))
1821     {
1822       if (TREE_CODE (current) != NAMESPACE_DECL
1823           || DECL_NAMESPACE_ALIAS (current))
1824         continue;
1825       if (!DECL_LANG_SPECIFIC (current))
1826         {
1827           /* Hmm. std. */
1828           my_friendly_assert (current == fake_std_node, 393);
1829           continue;
1830         }
1831
1832       /* We found a namespace.  */
1833       result |= walk_namespaces_r (current, f, data);
1834     }
1835
1836   return result;
1837 }
1838
1839 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1840    F as well.  */
1841
1842 int
1843 walk_namespaces (f, data)
1844      walk_namespaces_fn f;
1845      void *data;
1846 {
1847   return walk_namespaces_r (global_namespace, f, data);
1848 }
1849
1850 struct walk_globals_data {
1851   walk_globals_pred p;
1852   walk_globals_fn f;
1853   void *data;
1854 };
1855
1856 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1857    for which P returns non-zero, call F with its address.  If any call
1858    to F returns a non-zero value, return a non-zero value.  */
1859
1860 static int
1861 walk_globals_r (namespace, data)
1862      tree namespace;
1863      void *data;
1864 {
1865   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1866   walk_globals_pred p = wgd->p;
1867   walk_globals_fn f = wgd->f;
1868   void *d = wgd->data;
1869   tree *t;
1870   int result = 0;
1871
1872   t = &NAMESPACE_LEVEL (namespace)->names;
1873
1874   while (*t)
1875     {
1876       tree glbl = *t;
1877
1878       if ((*p) (glbl, d))
1879         result |= (*f) (t, d);
1880
1881       /* If F changed *T, then *T still points at the next item to
1882          examine.  */
1883       if (*t == glbl)
1884         t = &TREE_CHAIN (*t);
1885     }
1886
1887   return result;
1888 }
1889
1890 /* Walk the global declarations.  Whenever one is found for which P
1891    returns non-zero, call F with its address.  If any call to F
1892    returns a non-zero value, return a non-zero value.  */
1893
1894 int
1895 walk_globals (p, f, data)
1896      walk_globals_pred p;
1897      walk_globals_fn f;
1898      void *data;
1899 {
1900   struct walk_globals_data wgd;
1901   wgd.p = p;
1902   wgd.f = f;
1903   wgd.data = data;
1904
1905   return walk_namespaces (walk_globals_r, &wgd);
1906 }
1907
1908 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1909    DATA is non-NULL, this is the last time we will call
1910    wrapup_global_declarations for this NAMESPACE.  */
1911
1912 int
1913 wrapup_globals_for_namespace (namespace, data)
1914      tree namespace;
1915      void *data;
1916 {
1917   tree globals = cp_namespace_decls (namespace);
1918   int len = list_length (globals);
1919   tree *vec = (tree *) alloca (sizeof (tree) * len);
1920   int i;
1921   int result;
1922   tree decl;
1923   int last_time = (data != 0);
1924
1925   if (last_time && namespace == global_namespace)
1926     /* Let compile_file handle the global namespace.  */
1927     return 0;
1928
1929   /* Process the decls in reverse order--earliest first.
1930      Put them into VEC from back to front, then take out from front.  */
1931   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1932     vec[len - i - 1] = decl;
1933
1934   if (last_time)
1935     {
1936       check_global_declarations (vec, len);
1937       return 0;
1938     }
1939
1940   /* Temporarily mark vtables as external.  That prevents
1941      wrapup_global_declarations from writing them out; we must process
1942      them ourselves in finish_vtable_vardecl.  */
1943   for (i = 0; i < len; ++i)
1944     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1945       {
1946         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1947         DECL_EXTERNAL (vec[i]) = 1;
1948       }
1949
1950   /* Write out any globals that need to be output.  */
1951   result = wrapup_global_declarations (vec, len);
1952
1953   /* Undo the hack to DECL_EXTERNAL above.  */
1954   for (i = 0; i < len; ++i)
1955     if (vtable_decl_p (vec[i], /*data=*/0)
1956         && DECL_NOT_REALLY_EXTERN (vec[i]))
1957       {
1958         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1959         DECL_EXTERNAL (vec[i]) = 0;
1960       }
1961
1962   return result;
1963 }
1964
1965 \f
1966 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1967
1968 static void
1969 mark_binding_level (arg)
1970      void *arg;
1971 {
1972   struct binding_level *lvl = *(struct binding_level **)arg;
1973
1974   for (; lvl; lvl = lvl->level_chain)
1975     {
1976       ggc_mark_tree (lvl->names);
1977       ggc_mark_tree (lvl->tags);
1978       ggc_mark_tree (lvl->usings);
1979       ggc_mark_tree (lvl->using_directives);
1980       ggc_mark_tree (lvl->class_shadowed);
1981       ggc_mark_tree (lvl->type_shadowed);
1982       ggc_mark_tree (lvl->shadowed_labels);
1983       ggc_mark_tree (lvl->blocks);
1984       ggc_mark_tree (lvl->this_class);
1985       ggc_mark_tree (lvl->incomplete);
1986       ggc_mark_tree (lvl->dead_vars_from_for);
1987     }
1988 }
1989
1990 static void
1991 mark_named_label_lists (labs, uses)
1992      void *labs;
1993      void *uses;
1994 {
1995   struct named_label_list *l = *(struct named_label_list **)labs;
1996   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1997
1998   for (; l; l = l->next)
1999     {
2000       ggc_mark (l);
2001       mark_binding_level (l->binding_level);
2002       ggc_mark_tree (l->old_value);
2003       ggc_mark_tree (l->label_decl);
2004       ggc_mark_tree (l->bad_decls);
2005     }
2006
2007   for (; u; u = u->next)
2008     ggc_mark (u);
2009 }
2010 \f
2011 /* For debugging.  */
2012 static int no_print_functions = 0;
2013 static int no_print_builtins = 0;
2014
2015 void
2016 print_binding_level (lvl)
2017      struct binding_level *lvl;
2018 {
2019   tree t;
2020   int i = 0, len;
2021   fprintf (stderr, " blocks=");
2022   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2023   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2024            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2025   if (lvl->tag_transparent)
2026     fprintf (stderr, " tag-transparent");
2027   if (lvl->more_cleanups_ok)
2028     fprintf (stderr, " more-cleanups-ok");
2029   if (lvl->have_cleanups)
2030     fprintf (stderr, " have-cleanups");
2031   fprintf (stderr, "\n");
2032   if (lvl->names)
2033     {
2034       fprintf (stderr, " names:\t");
2035       /* We can probably fit 3 names to a line?  */
2036       for (t = lvl->names; t; t = TREE_CHAIN (t))
2037         {
2038           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2039             continue;
2040           if (no_print_builtins
2041               && (TREE_CODE (t) == TYPE_DECL)
2042               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2043             continue;
2044
2045           /* Function decls tend to have longer names.  */
2046           if (TREE_CODE (t) == FUNCTION_DECL)
2047             len = 3;
2048           else
2049             len = 2;
2050           i += len;
2051           if (i > 6)
2052             {
2053               fprintf (stderr, "\n\t");
2054               i = len;
2055             }
2056           print_node_brief (stderr, "", t, 0);
2057           if (t == error_mark_node)
2058             break;
2059         }
2060       if (i)
2061         fprintf (stderr, "\n");
2062     }
2063   if (lvl->tags)
2064     {
2065       fprintf (stderr, " tags:\t");
2066       i = 0;
2067       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2068         {
2069           if (TREE_PURPOSE (t) == NULL_TREE)
2070             len = 3;
2071           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2072             len = 2;
2073           else
2074             len = 4;
2075           i += len;
2076           if (i > 5)
2077             {
2078               fprintf (stderr, "\n\t");
2079               i = len;
2080             }
2081           if (TREE_PURPOSE (t) == NULL_TREE)
2082             {
2083               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2084               fprintf (stderr, ">");
2085             }
2086           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2087             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2088           else
2089             {
2090               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2091               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2092               fprintf (stderr, ">");
2093             }
2094         }
2095       if (i)
2096         fprintf (stderr, "\n");
2097     }
2098   if (lvl->class_shadowed)
2099     {
2100       fprintf (stderr, " class-shadowed:");
2101       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2102         {
2103           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2104         }
2105       fprintf (stderr, "\n");
2106     }
2107   if (lvl->type_shadowed)
2108     {
2109       fprintf (stderr, " type-shadowed:");
2110       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2111         {
2112           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2113         }
2114       fprintf (stderr, "\n");
2115     }
2116 }
2117
2118 void
2119 print_other_binding_stack (stack)
2120      struct binding_level *stack;
2121 {
2122   struct binding_level *level;
2123   for (level = stack; level != global_binding_level; level = level->level_chain)
2124     {
2125       fprintf (stderr, "binding level ");
2126       fprintf (stderr, HOST_PTR_PRINTF, level);
2127       fprintf (stderr, "\n");
2128       print_binding_level (level);
2129     }
2130 }
2131
2132 void
2133 print_binding_stack ()
2134 {
2135   struct binding_level *b;
2136   fprintf (stderr, "current_binding_level=");
2137   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2138   fprintf (stderr, "\nclass_binding_level=");
2139   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2140   fprintf (stderr, "\nglobal_binding_level=");
2141   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2142   fprintf (stderr, "\n");
2143   if (class_binding_level)
2144     {
2145       for (b = class_binding_level; b; b = b->level_chain)
2146         if (b == current_binding_level)
2147           break;
2148       if (b)
2149         b = class_binding_level;
2150       else
2151         b = current_binding_level;
2152     }
2153   else
2154     b = current_binding_level;
2155   print_other_binding_stack (b);
2156   fprintf (stderr, "global:\n");
2157   print_binding_level (global_binding_level);
2158 }
2159
2160 /* Namespace binding access routines: The namespace_bindings field of
2161    the identifier is polymorphic, with three possible values:
2162    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2163    indicating the BINDING_VALUE of global_namespace. */
2164
2165 /* Check whether the a binding for the name to scope is known.
2166    Assumes that the bindings of the name are already a list
2167    of bindings. Returns the binding found, or NULL_TREE. */
2168
2169 static tree
2170 find_binding (name, scope)
2171      tree name;
2172      tree scope;
2173 {
2174   tree iter, prev = NULL_TREE;
2175
2176   scope = ORIGINAL_NAMESPACE (scope);
2177
2178   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2179        iter = TREE_CHAIN (iter))
2180     {
2181       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2182       if (BINDING_SCOPE (iter) == scope)
2183         {
2184           /* Move binding found to the front of the list, so
2185              subsequent lookups will find it faster. */
2186           if (prev)
2187             {
2188               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2189               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2190               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2191             }
2192           return iter;
2193         }
2194       prev = iter;
2195     }
2196   return NULL_TREE;
2197 }
2198
2199 /* Always returns a binding for name in scope. If the
2200    namespace_bindings is not a list, convert it to one first.
2201    If no binding is found, make a new one. */
2202
2203 tree
2204 binding_for_name (name, scope)
2205      tree name;
2206      tree scope;
2207 {
2208   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2209   tree result;
2210
2211   scope = ORIGINAL_NAMESPACE (scope);
2212
2213   if (b && TREE_CODE (b) != CPLUS_BINDING)
2214     {
2215       /* Get rid of optimization for global scope. */
2216       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2217       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2218       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2219     }
2220   if (b && (result = find_binding (name, scope)))
2221     return result;
2222   /* Not found, make a new one. */
2223   result = make_node (CPLUS_BINDING);
2224   TREE_CHAIN (result) = b;
2225   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2226   BINDING_SCOPE (result) = scope;
2227   BINDING_TYPE (result) = NULL_TREE;
2228   BINDING_VALUE (result) = NULL_TREE;
2229   return result;
2230 }
2231
2232 /* Return the binding value for name in scope, considering that
2233    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2234
2235 tree
2236 namespace_binding (name, scope)
2237      tree name;
2238      tree scope;
2239 {
2240   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241   if (b == NULL_TREE)
2242     return NULL_TREE;
2243   if (scope == NULL_TREE)
2244     scope = global_namespace;
2245   if (TREE_CODE (b) != CPLUS_BINDING)
2246     return (scope == global_namespace) ? b : NULL_TREE;
2247   name = find_binding (name,scope);
2248   if (name == NULL_TREE)
2249     return name;
2250   return BINDING_VALUE (name);
2251 }
2252
2253 /* Set the binding value for name in scope. If modifying the binding
2254    of global_namespace is attempted, try to optimize it. */
2255
2256 void
2257 set_namespace_binding (name, scope, val)
2258      tree name;
2259      tree scope;
2260      tree val;
2261 {
2262   tree b;
2263
2264   if (scope == NULL_TREE)
2265     scope = global_namespace;
2266
2267   if (scope == global_namespace)
2268     {
2269       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2270       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2271         {
2272           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2273           return;
2274         }
2275     }
2276   b = binding_for_name (name, scope);
2277   BINDING_VALUE (b) = val;
2278 }
2279
2280 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2281    select a name that is unique to this compilation unit.  */
2282
2283 void
2284 push_namespace (name)
2285      tree name;
2286 {
2287   tree d = NULL_TREE;
2288   int need_new = 1;
2289   int implicit_use = 0;
2290   int global = 0;
2291   if (!global_namespace)
2292     {
2293       /* This must be ::. */
2294       my_friendly_assert (name == get_identifier ("::"), 377);
2295       global = 1;
2296     }
2297   else if (!name)
2298     {
2299       /* The name of anonymous namespace is unique for the translation
2300          unit.  */
2301       if (!anonymous_namespace_name)
2302         anonymous_namespace_name = get_file_function_name ('N');
2303       name = anonymous_namespace_name;
2304       d = IDENTIFIER_NAMESPACE_VALUE (name);
2305       if (d)
2306         /* Reopening anonymous namespace.  */
2307         need_new = 0;
2308       implicit_use = 1;
2309     }
2310   else if (current_namespace == global_namespace
2311            && !flag_honor_std
2312            && name == std_identifier)
2313     {
2314       in_fake_std++;
2315       return;
2316     }
2317   else
2318     {
2319       /* Check whether this is an extended namespace definition. */
2320       d = IDENTIFIER_NAMESPACE_VALUE (name);
2321       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2322         {
2323           need_new = 0;
2324           if (DECL_NAMESPACE_ALIAS (d))
2325             {
2326               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2327                         d, DECL_NAMESPACE_ALIAS (d));
2328               d = DECL_NAMESPACE_ALIAS (d);
2329             }
2330         }
2331     }
2332
2333   if (need_new)
2334     {
2335       /* Make a new namespace, binding the name to it. */
2336       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2337       /* The global namespace is not pushed, and the global binding
2338          level is set elsewhere.  */
2339       if (!global)
2340         {
2341           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2342           d = pushdecl (d);
2343           pushlevel (0);
2344           declare_namespace_level ();
2345           NAMESPACE_LEVEL (d) = current_binding_level;
2346         }
2347     }
2348   else
2349     resume_binding_level (NAMESPACE_LEVEL (d));
2350
2351   if (implicit_use)
2352     do_using_directive (d);
2353   /* Enter the name space. */
2354   current_namespace = d;
2355 }
2356
2357 /* Pop from the scope of the current namespace.  */
2358
2359 void
2360 pop_namespace ()
2361 {
2362   if (current_namespace == global_namespace)
2363     {
2364       my_friendly_assert (in_fake_std > 0, 980421);
2365       in_fake_std--;
2366       return;
2367     }
2368   current_namespace = CP_DECL_CONTEXT (current_namespace);
2369   /* The binding level is not popped, as it might be re-opened later.  */
2370   suspend_binding_level ();
2371 }
2372
2373 /* Push into the scope of the namespace NS, even if it is deeply
2374    nested within another namespace.  */
2375
2376 void
2377 push_nested_namespace (ns)
2378      tree ns;
2379 {
2380   if (ns == global_namespace)
2381     push_to_top_level ();
2382   else
2383     {
2384       push_nested_namespace (CP_DECL_CONTEXT (ns));
2385       push_namespace (DECL_NAME (ns));
2386     }
2387 }
2388
2389 /* Pop back from the scope of the namespace NS, which was previously
2390    entered with push_nested_namespace.  */
2391
2392 void
2393 pop_nested_namespace (ns)
2394      tree ns;
2395 {
2396   while (ns != global_namespace)
2397     {
2398       pop_namespace ();
2399       ns = CP_DECL_CONTEXT (ns);
2400     }
2401
2402   pop_from_top_level ();
2403 }
2404
2405 \f
2406 /* Subroutines for reverting temporarily to top-level for instantiation
2407    of templates and such.  We actually need to clear out the class- and
2408    local-value slots of all identifiers, so that only the global values
2409    are at all visible.  Simply setting current_binding_level to the global
2410    scope isn't enough, because more binding levels may be pushed.  */
2411 struct saved_scope *scope_chain;
2412
2413 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2414
2415 static void
2416 mark_saved_scope (arg)
2417      void *arg;
2418 {
2419   struct saved_scope *t = *(struct saved_scope **)arg;
2420   while (t)
2421     {
2422       mark_binding_level (&t->class_bindings);
2423       ggc_mark_tree (t->old_bindings);
2424       ggc_mark_tree (t->old_namespace);
2425       ggc_mark_tree (t->decl_ns_list);
2426       ggc_mark_tree (t->class_name);
2427       ggc_mark_tree (t->class_type);
2428       ggc_mark_tree (t->access_specifier);
2429       ggc_mark_tree (t->function_decl);
2430       if (t->lang_base)
2431         ggc_mark_tree_varray (t->lang_base);
2432       ggc_mark_tree (t->lang_name);
2433       ggc_mark_tree (t->template_parms);
2434       ggc_mark_tree (t->x_previous_class_type);
2435       ggc_mark_tree (t->x_previous_class_values);
2436       ggc_mark_tree (t->x_saved_tree);
2437       ggc_mark_tree (t->incomplete);
2438       ggc_mark_tree (t->lookups);
2439
2440       mark_stmt_tree (&t->x_stmt_tree);
2441       mark_binding_level (&t->bindings);
2442       t = t->prev;
2443     }
2444 }
2445
2446 static tree
2447 store_bindings (names, old_bindings)
2448      tree names, old_bindings;
2449 {
2450   tree t;
2451   tree search_bindings = old_bindings;
2452
2453   for (t = names; t; t = TREE_CHAIN (t))
2454     {
2455       tree binding, t1, id;
2456
2457       if (TREE_CODE (t) == TREE_LIST)
2458         id = TREE_PURPOSE (t);
2459       else
2460         id = DECL_NAME (t);
2461
2462       if (!id
2463           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2464              we have no IDENTIFIER_BINDING if we have left the class
2465              scope, but cached the class-level declarations.  */
2466           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2467         continue;
2468
2469       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2470         if (TREE_VEC_ELT (t1, 0) == id)
2471           goto skip_it;
2472
2473       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2474       binding = make_tree_vec (4);
2475       TREE_VEC_ELT (binding, 0) = id;
2476       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2477       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2478       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2479       IDENTIFIER_BINDING (id) = NULL_TREE;
2480       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2481       TREE_CHAIN (binding) = old_bindings;
2482       old_bindings = binding;
2483     skip_it:
2484       ;
2485     }
2486   return old_bindings;
2487 }
2488
2489 void
2490 maybe_push_to_top_level (pseudo)
2491      int pseudo;
2492 {
2493   struct saved_scope *s;
2494   struct binding_level *b;
2495   tree old_bindings;
2496   int need_pop;
2497
2498   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2499
2500   b = scope_chain ? current_binding_level : 0;
2501
2502   /* If we're in the middle of some function, save our state.  */
2503   if (cfun)
2504     {
2505       need_pop = 1;
2506       push_function_context_to (NULL_TREE);
2507     }
2508   else
2509     need_pop = 0;
2510
2511   old_bindings = NULL_TREE;
2512   if (scope_chain && previous_class_type)
2513     old_bindings = store_bindings (previous_class_values, old_bindings);
2514
2515   /* Have to include global_binding_level, because class-level decls
2516      aren't listed anywhere useful.  */
2517   for (; b; b = b->level_chain)
2518     {
2519       tree t;
2520
2521       /* Template IDs are inserted into the global level. If they were
2522          inserted into namespace level, finish_file wouldn't find them
2523          when doing pending instantiations. Therefore, don't stop at
2524          namespace level, but continue until :: .  */
2525       if (b == global_binding_level || (pseudo && b->template_parms_p))
2526         break;
2527
2528       old_bindings = store_bindings (b->names, old_bindings);
2529       /* We also need to check class_shadowed to save class-level type
2530          bindings, since pushclass doesn't fill in b->names.  */
2531       if (b->parm_flag == 2)
2532         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2533
2534       /* Unwind type-value slots back to top level.  */
2535       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2536         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2537     }
2538   s->prev = scope_chain;
2539   s->old_bindings = old_bindings;
2540   s->bindings = b;
2541   s->need_pop_function_context = need_pop;
2542   s->function_decl = current_function_decl;
2543
2544   scope_chain = s;
2545   current_function_decl = NULL_TREE;
2546   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2547   current_lang_name = lang_name_cplusplus;
2548   current_namespace = global_namespace;
2549 }
2550
2551 void
2552 push_to_top_level ()
2553 {
2554   maybe_push_to_top_level (0);
2555 }
2556
2557 void
2558 pop_from_top_level ()
2559 {
2560   struct saved_scope *s = scope_chain;
2561   tree t;
2562
2563   /* Clear out class-level bindings cache.  */
2564   if (previous_class_type)
2565     invalidate_class_lookup_cache ();
2566
2567   VARRAY_FREE (current_lang_base);
2568
2569   scope_chain = s->prev;
2570   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2571     {
2572       tree id = TREE_VEC_ELT (t, 0);
2573
2574       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2575       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2576       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2577     }
2578
2579   /* If we were in the middle of compiling a function, restore our
2580      state.  */
2581   if (s->need_pop_function_context)
2582     pop_function_context_from (NULL_TREE);
2583   current_function_decl = s->function_decl;
2584
2585   free (s);
2586 }
2587 \f
2588 /* Push a definition of struct, union or enum tag "name".
2589    into binding_level "b".   "type" should be the type node,
2590    We assume that the tag "name" is not already defined.
2591
2592    Note that the definition may really be just a forward reference.
2593    In that case, the TYPE_SIZE will be a NULL_TREE.
2594
2595    C++ gratuitously puts all these tags in the name space.  */
2596
2597 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2598    record the shadowed value for this binding contour.  TYPE is
2599    the type that ID maps to.  */
2600
2601 static void
2602 set_identifier_type_value_with_scope (id, type, b)
2603      tree id;
2604      tree type;
2605      struct binding_level *b;
2606 {
2607   if (!b->namespace_p)
2608     {
2609       /* Shadow the marker, not the real thing, so that the marker
2610          gets restored later. */
2611       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2612       b->type_shadowed
2613         = tree_cons (id, old_type_value, b->type_shadowed);
2614     }
2615   else
2616     {
2617       tree binding = binding_for_name (id, current_namespace);
2618       BINDING_TYPE (binding) = type;
2619       /* Store marker instead of real type. */
2620       type = global_type_node;
2621     }
2622   SET_IDENTIFIER_TYPE_VALUE (id, type);
2623 }
2624
2625 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2626
2627 void
2628 set_identifier_type_value (id, type)
2629      tree id;
2630      tree type;
2631 {
2632   set_identifier_type_value_with_scope (id, type, current_binding_level);
2633 }
2634
2635 /* Return the type associated with id. */
2636
2637 tree
2638 identifier_type_value (id)
2639      tree id;
2640 {
2641   /* There is no type with that name, anywhere. */
2642   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2643     return NULL_TREE;
2644   /* This is not the type marker, but the real thing. */
2645   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2646     return REAL_IDENTIFIER_TYPE_VALUE (id);
2647   /* Have to search for it. It must be on the global level, now.
2648      Ask lookup_name not to return non-types. */
2649   id = lookup_name_real (id, 2, 1, 0);
2650   if (id)
2651     return TREE_TYPE (id);
2652   return NULL_TREE;
2653 }
2654
2655 /* Pop off extraneous binding levels left over due to syntax errors.
2656
2657    We don't pop past namespaces, as they might be valid.  */
2658
2659 void
2660 pop_everything ()
2661 {
2662 #ifdef DEBUG_CP_BINDING_LEVELS
2663   fprintf (stderr, "XXX entering pop_everything ()\n");
2664 #endif
2665   while (!toplevel_bindings_p ())
2666     {
2667       if (current_binding_level->parm_flag == 2)
2668         pop_nested_class ();
2669       else
2670         poplevel (0, 0, 0);
2671     }
2672 #ifdef DEBUG_CP_BINDING_LEVELS
2673   fprintf (stderr, "XXX leaving pop_everything ()\n");
2674 #endif
2675 }
2676
2677 /* The type TYPE is being declared.  If it is a class template, or a
2678    specialization of a class template, do any processing required and
2679    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2680    being declared a friend.  B is the binding level at which this TYPE
2681    should be bound.
2682
2683    Returns the TYPE_DECL for TYPE, which may have been altered by this
2684    processing.  */
2685
2686 static tree
2687 maybe_process_template_type_declaration (type, globalize, b)
2688      tree type;
2689      int globalize;
2690      struct binding_level* b;
2691 {
2692   tree decl = TYPE_NAME (type);
2693
2694   if (processing_template_parmlist)
2695     /* You can't declare a new template type in a template parameter
2696        list.  But, you can declare a non-template type:
2697
2698          template <class A*> struct S;
2699
2700        is a forward-declaration of `A'.  */
2701     ;
2702   else
2703     {
2704       maybe_check_template_type (type);
2705
2706       my_friendly_assert (IS_AGGR_TYPE (type)
2707                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2708
2709
2710       if (processing_template_decl)
2711         {
2712           /* This may change after the call to
2713              push_template_decl_real, but we want the original value.  */
2714           tree name = DECL_NAME (decl);
2715
2716           decl = push_template_decl_real (decl, globalize);
2717           /* If the current binding level is the binding level for the
2718              template parameters (see the comment in
2719              begin_template_parm_list) and the enclosing level is a class
2720              scope, and we're not looking at a friend, push the
2721              declaration of the member class into the class scope.  In the
2722              friend case, push_template_decl will already have put the
2723              friend into global scope, if appropriate.  */
2724           if (TREE_CODE (type) != ENUMERAL_TYPE
2725               && !globalize && b->template_parms_p
2726               && b->level_chain->parm_flag == 2)
2727             {
2728               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2729               /* Put this tag on the list of tags for the class, since
2730                  that won't happen below because B is not the class
2731                  binding level, but is instead the pseudo-global level.  */
2732               b->level_chain->tags =
2733                 tree_cons (name, type, b->level_chain->tags);
2734               if (!COMPLETE_TYPE_P (current_class_type))
2735                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2736             }
2737         }
2738     }
2739
2740   return decl;
2741 }
2742
2743 /* In C++, you don't have to write `struct S' to refer to `S'; you
2744    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2745    if the user had written `typedef struct S S'.  Create and return
2746    the TYPE_DECL for TYPE.  */
2747
2748 tree
2749 create_implicit_typedef (name, type)
2750      tree name;
2751      tree type;
2752 {
2753   tree decl;
2754
2755   decl = build_decl (TYPE_DECL, name, type);
2756   DECL_ARTIFICIAL (decl) = 1;
2757   /* There are other implicit type declarations, like the one *within*
2758      a class that allows you to write `S::S'.  We must distinguish
2759      amongst these.  */
2760   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2761   TYPE_NAME (type) = decl;
2762
2763   return decl;
2764 }
2765
2766 /* Remember a local name for name-mangling purposes.  */
2767
2768 static void
2769 push_local_name (decl)
2770      tree decl;
2771 {
2772   size_t i, nelts;
2773   tree t, name;
2774
2775   if (!local_names)
2776     VARRAY_TREE_INIT (local_names, 8, "local_names");
2777
2778   name = DECL_NAME (decl);
2779
2780   nelts = VARRAY_ACTIVE_SIZE (local_names);
2781   for (i = 0; i < nelts; i++)
2782     {
2783       t = VARRAY_TREE (local_names, i);
2784       if (DECL_NAME (t) == name)
2785         {
2786           if (!DECL_LANG_SPECIFIC (decl))
2787             retrofit_lang_decl (decl);
2788           if (DECL_LANG_SPECIFIC (t))
2789             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2790           else
2791             DECL_DISCRIMINATOR (decl) = 1;
2792
2793           VARRAY_TREE (local_names, i) = decl;
2794           return;
2795         }
2796     }
2797
2798   VARRAY_PUSH_TREE (local_names, decl);
2799 }
2800
2801 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2802    Normally put it into the inner-most non-tag-transparent scope,
2803    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2804    The latter is needed for implicit declarations.  */
2805
2806 void
2807 pushtag (name, type, globalize)
2808      tree name, type;
2809      int globalize;
2810 {
2811   register struct binding_level *b;
2812
2813   b = current_binding_level;
2814   while (b->tag_transparent
2815          || (b->parm_flag == 2
2816              && (globalize
2817                  /* We may be defining a new type in the initializer
2818                     of a static member variable. We allow this when
2819                     not pedantic, and it is particularly useful for
2820                     type punning via an anonymous union. */
2821                  || COMPLETE_TYPE_P (b->this_class))))
2822     b = b->level_chain;
2823
2824   b->tags = tree_cons (name, type, b->tags);
2825
2826   if (name)
2827     {
2828       /* Do C++ gratuitous typedefing.  */
2829       if (IDENTIFIER_TYPE_VALUE (name) != type)
2830         {
2831           register tree d = NULL_TREE;
2832           int in_class = 0;
2833           tree context = TYPE_CONTEXT (type);
2834
2835           if (! context)
2836             {
2837               tree cs = current_scope ();
2838
2839               if (! globalize)
2840                 context = cs;
2841               else if (cs != NULL_TREE && TYPE_P (cs))
2842                 /* When declaring a friend class of a local class, we want
2843                    to inject the newly named class into the scope
2844                    containing the local class, not the namespace scope.  */
2845                 context = decl_function_context (get_type_decl (cs));
2846             }
2847           if (!context)
2848             context = current_namespace;
2849
2850           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2851               || b->parm_flag == 2)
2852             in_class = 1;
2853
2854           if (current_lang_name == lang_name_java)
2855             TYPE_FOR_JAVA (type) = 1;
2856
2857           d = create_implicit_typedef (name, type);
2858           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2859           if (! in_class)
2860             set_identifier_type_value_with_scope (name, type, b);
2861
2862           d = maybe_process_template_type_declaration (type,
2863                                                        globalize, b);
2864
2865           if (b->parm_flag == 2)
2866             {
2867               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2868                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2869                    class.  But if it's a member template class, we
2870                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2871                    is done later.  */
2872                 finish_member_declaration (d);
2873               else
2874                 pushdecl_class_level (d);
2875             }
2876           else
2877             d = pushdecl_with_scope (d, b);
2878
2879           /* FIXME what if it gets a name from typedef?  */
2880           if (ANON_AGGRNAME_P (name))
2881             DECL_IGNORED_P (d) = 1;
2882
2883           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2884
2885           /* If this is a local class, keep track of it.  We need this
2886              information for name-mangling, and so that it is possible to find
2887              all function definitions in a translation unit in a convenient
2888              way.  (It's otherwise tricky to find a member function definition
2889              it's only pointed to from within a local class.)  */
2890           if (TYPE_CONTEXT (type)
2891               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2892               && !processing_template_decl)
2893             VARRAY_PUSH_TREE (local_classes, type);
2894         }
2895       if (b->parm_flag == 2)
2896         {
2897           if (!COMPLETE_TYPE_P (current_class_type))
2898             CLASSTYPE_TAGS (current_class_type) = b->tags;
2899         }
2900     }
2901
2902   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2903     /* Use the canonical TYPE_DECL for this node.  */
2904     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2905   else
2906     {
2907       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2908          will be the tagged type we just added to the current
2909          binding level.  This fake NULL-named TYPE_DECL node helps
2910          dwarfout.c to know when it needs to output a
2911          representation of a tagged type, and it also gives us a
2912          convenient place to record the "scope start" address for
2913          the tagged type.  */
2914
2915       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2916       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2917     }
2918 }
2919
2920 /* Counter used to create anonymous type names.  */
2921
2922 static int anon_cnt = 0;
2923
2924 /* Return an IDENTIFIER which can be used as a name for
2925    anonymous structs and unions.  */
2926
2927 tree
2928 make_anon_name ()
2929 {
2930   char buf[32];
2931
2932   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2933   return get_identifier (buf);
2934 }
2935
2936 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2937    This keeps dbxout from getting confused.  */
2938
2939 void
2940 clear_anon_tags ()
2941 {
2942   register struct binding_level *b;
2943   register tree tags;
2944   static int last_cnt = 0;
2945
2946   /* Fast out if no new anon names were declared.  */
2947   if (last_cnt == anon_cnt)
2948     return;
2949
2950   b = current_binding_level;
2951   while (b->tag_transparent)
2952     b = b->level_chain;
2953   tags = b->tags;
2954   while (tags)
2955     {
2956       /* A NULL purpose means we have already processed all tags
2957          from here to the end of the list.  */
2958       if (TREE_PURPOSE (tags) == NULL_TREE)
2959         break;
2960       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2961         TREE_PURPOSE (tags) = NULL_TREE;
2962       tags = TREE_CHAIN (tags);
2963     }
2964   last_cnt = anon_cnt;
2965 }
2966 \f
2967 /* Subroutine of duplicate_decls: return truthvalue of whether
2968    or not types of these decls match.
2969
2970    For C++, we must compare the parameter list so that `int' can match
2971    `int&' in a parameter position, but `int&' is not confused with
2972    `const int&'.  */
2973
2974 int
2975 decls_match (newdecl, olddecl)
2976      tree newdecl, olddecl;
2977 {
2978   int types_match;
2979
2980   if (newdecl == olddecl)
2981     return 1;
2982
2983   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2984     /* If the two DECLs are not even the same kind of thing, we're not
2985        interested in their types.  */
2986     return 0;
2987
2988   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2989     {
2990       tree f1 = TREE_TYPE (newdecl);
2991       tree f2 = TREE_TYPE (olddecl);
2992       tree p1 = TYPE_ARG_TYPES (f1);
2993       tree p2 = TYPE_ARG_TYPES (f2);
2994
2995       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2996           && ! (DECL_EXTERN_C_P (newdecl)
2997                 && DECL_EXTERN_C_P (olddecl)))
2998         return 0;
2999
3000       if (TREE_CODE (f1) != TREE_CODE (f2))
3001         return 0;
3002
3003       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3004         {
3005           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3006               && (DECL_BUILT_IN (olddecl)
3007 #ifndef NO_IMPLICIT_EXTERN_C
3008                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3009                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3010 #endif
3011               ))
3012             {
3013               types_match = self_promoting_args_p (p1);
3014               if (p1 == void_list_node)
3015                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3016             }
3017 #ifndef NO_IMPLICIT_EXTERN_C
3018           else if (p1 == NULL_TREE
3019                    && (DECL_EXTERN_C_P (olddecl)
3020                        && DECL_IN_SYSTEM_HEADER (olddecl)
3021                        && !DECL_CLASS_SCOPE_P (olddecl))
3022                    && (DECL_EXTERN_C_P (newdecl)
3023                        && DECL_IN_SYSTEM_HEADER (newdecl)
3024                        && !DECL_CLASS_SCOPE_P (newdecl)))
3025             {
3026               types_match = self_promoting_args_p (p2);
3027               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3028             }
3029 #endif
3030           else
3031             types_match = compparms (p1, p2);
3032         }
3033       else
3034         types_match = 0;
3035     }
3036   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3037     {
3038       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3039                                 DECL_TEMPLATE_PARMS (olddecl)))
3040         return 0;
3041
3042       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3043           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3044         return 0;
3045
3046       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3047         types_match = 1;
3048       else
3049         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3050                                    DECL_TEMPLATE_RESULT (newdecl));
3051     }
3052   else
3053     {
3054       if (TREE_TYPE (newdecl) == error_mark_node)
3055         types_match = TREE_TYPE (olddecl) == error_mark_node;
3056       else if (TREE_TYPE (olddecl) == NULL_TREE)
3057         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3058       else if (TREE_TYPE (newdecl) == NULL_TREE)
3059         types_match = 0;
3060       else
3061         types_match = comptypes (TREE_TYPE (newdecl),
3062                                  TREE_TYPE (olddecl),
3063                                  COMPARE_REDECLARATION);
3064     }
3065
3066   return types_match;
3067 }
3068
3069 /* If NEWDECL is `static' and an `extern' was seen previously,
3070    warn about it.  OLDDECL is the previous declaration.
3071
3072    Note that this does not apply to the C++ case of declaring
3073    a variable `extern const' and then later `const'.
3074
3075    Don't complain about built-in functions, since they are beyond
3076    the user's control.  */
3077
3078 static void
3079 warn_extern_redeclared_static (newdecl, olddecl)
3080      tree newdecl, olddecl;
3081 {
3082   static const char *explicit_extern_static_warning
3083     = "`%D' was declared `extern' and later `static'";
3084   static const char *implicit_extern_static_warning
3085     = "`%D' was declared implicitly `extern' and later `static'";
3086
3087   tree name;
3088
3089   if (TREE_CODE (newdecl) == TYPE_DECL
3090       || TREE_CODE (newdecl) == TEMPLATE_DECL
3091       || TREE_CODE (newdecl) == CONST_DECL)
3092     return;
3093
3094   /* Don't get confused by static member functions; that's a different
3095      use of `static'.  */
3096   if (TREE_CODE (newdecl) == FUNCTION_DECL
3097       && DECL_STATIC_FUNCTION_P (newdecl))
3098     return;
3099
3100   /* If the old declaration was `static', or the new one isn't, then
3101      then everything is OK.  */
3102   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3103     return;
3104
3105   /* It's OK to declare a builtin function as `static'.  */
3106   if (TREE_CODE (olddecl) == FUNCTION_DECL
3107       && DECL_ARTIFICIAL (olddecl))
3108     return;
3109
3110   name = DECL_ASSEMBLER_NAME (newdecl);
3111   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3112               ? implicit_extern_static_warning
3113               : explicit_extern_static_warning, newdecl);
3114   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3115 }
3116
3117 /* Handle when a new declaration NEWDECL has the same name as an old
3118    one OLDDECL in the same binding contour.  Prints an error message
3119    if appropriate.
3120
3121    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3122    Otherwise, return 0.  */
3123
3124 int
3125 duplicate_decls (newdecl, olddecl)
3126      tree newdecl, olddecl;
3127 {
3128   unsigned olddecl_uid = DECL_UID (olddecl);
3129   int olddecl_friend = 0, types_match = 0;
3130   int new_defines_function = 0;
3131
3132   if (newdecl == olddecl)
3133     return 1;
3134
3135   types_match = decls_match (newdecl, olddecl);
3136
3137   /* If either the type of the new decl or the type of the old decl is an
3138      error_mark_node, then that implies that we have already issued an
3139      error (earlier) for some bogus type specification, and in that case,
3140      it is rather pointless to harass the user with yet more error message
3141      about the same declaration, so just pretend the types match here.  */
3142   if (TREE_TYPE (newdecl) == error_mark_node
3143       || TREE_TYPE (olddecl) == error_mark_node)
3144     types_match = 1;
3145
3146   /* Check for redeclaration and other discrepancies. */
3147   if (TREE_CODE (olddecl) == FUNCTION_DECL
3148       && DECL_ARTIFICIAL (olddecl))
3149     {
3150       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3151         {
3152           /* If you declare a built-in or predefined function name as static,
3153              the old definition is overridden, but optionally warn this was a
3154              bad choice of name.  */
3155           if (! TREE_PUBLIC (newdecl))
3156             {
3157               if (warn_shadow)
3158                 cp_warning ("shadowing %s function `%#D'",
3159                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3160                             olddecl);
3161               /* Discard the old built-in function.  */
3162               return 0;
3163             }
3164           /* If the built-in is not ansi, then programs can override
3165              it even globally without an error.  */
3166           else if (! DECL_BUILT_IN (olddecl))
3167             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3168                         olddecl, newdecl);
3169           else
3170             {
3171               cp_error ("declaration of `%#D'", newdecl);
3172               cp_error ("conflicts with built-in declaration `%#D'",
3173                         olddecl);
3174             }
3175           return 0;
3176         }
3177       else if (!types_match)
3178         {
3179           if ((DECL_EXTERN_C_P (newdecl)
3180                && DECL_EXTERN_C_P (olddecl))
3181               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3182                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3183             {
3184               /* A near match; override the builtin.  */
3185
3186               if (TREE_PUBLIC (newdecl))
3187                 {
3188                   cp_warning ("new declaration `%#D'", newdecl);
3189                   cp_warning ("ambiguates built-in declaration `%#D'",
3190                               olddecl);
3191                 }
3192               else if (warn_shadow)
3193                 cp_warning ("shadowing %s function `%#D'",
3194                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3195                             olddecl);
3196             }
3197           else
3198             /* Discard the old built-in function.  */
3199             return 0;
3200         }
3201
3202       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3203         {
3204           /* If a builtin function is redeclared as `static', merge
3205              the declarations, but make the original one static.  */
3206           DECL_THIS_STATIC (olddecl) = 1;
3207           TREE_PUBLIC (olddecl) = 0;
3208
3209           /* Make the old declaration consistent with the new one so
3210              that all remnants of the builtin-ness of this function
3211              will be banished.  */
3212           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3213           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3214           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3215           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3216                                        newdecl);
3217         }
3218     }
3219   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3220     {
3221       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3222            && TREE_CODE (newdecl) != TYPE_DECL
3223            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3224                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3225           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3226               && TREE_CODE (olddecl) != TYPE_DECL
3227               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3228                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3229                         == TYPE_DECL))))
3230         {
3231           /* We do nothing special here, because C++ does such nasty
3232              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3233              get shadowed, and know that if we need to find a TYPE_DECL
3234              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3235              slot of the identifier.  */
3236           return 0;
3237         }
3238
3239       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3240            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3241           || (TREE_CODE (olddecl) == FUNCTION_DECL
3242               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3243         return 0;
3244
3245       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3246       if (TREE_CODE (olddecl) == TREE_LIST)
3247         olddecl = TREE_VALUE (olddecl);
3248       cp_error_at ("previous declaration of `%#D'", olddecl);
3249
3250       /* New decl is completely inconsistent with the old one =>
3251          tell caller to replace the old one.  */
3252
3253       return 0;
3254     }
3255   else if (!types_match)
3256     {
3257       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3258         /* These are certainly not duplicate declarations; they're
3259            from different scopes.  */
3260         return 0;
3261
3262       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3263         {
3264           /* The name of a class template may not be declared to refer to
3265              any other template, class, function, object, namespace, value,
3266              or type in the same scope.  */
3267           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3268               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3269             {
3270               cp_error ("declaration of template `%#D'", newdecl);
3271               cp_error_at ("conflicts with previous declaration `%#D'",
3272                            olddecl);
3273             }
3274           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3275                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3276                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3277                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3278                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3279                                            DECL_TEMPLATE_PARMS (olddecl)))
3280             {
3281               cp_error ("new declaration `%#D'", newdecl);
3282               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3283             }
3284           return 0;
3285         }
3286       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3287         {
3288           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3289             {
3290               cp_error ("declaration of C function `%#D' conflicts with",
3291                         newdecl);
3292               cp_error_at ("previous declaration `%#D' here", olddecl);
3293             }
3294           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3295                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3296             {
3297               cp_error ("new declaration `%#D'", newdecl);
3298               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3299             }
3300           else
3301             return 0;
3302         }
3303
3304       /* Already complained about this, so don't do so again.  */
3305       else if (current_class_type == NULL_TREE
3306           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3307         {
3308           cp_error ("conflicting types for `%#D'", newdecl);
3309           cp_error_at ("previous declaration as `%#D'", olddecl);
3310         }
3311     }
3312   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3313             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3314                  && (!DECL_TEMPLATE_INFO (newdecl)
3315                      || (DECL_TI_TEMPLATE (newdecl)
3316                          != DECL_TI_TEMPLATE (olddecl))))
3317                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3318                     && (!DECL_TEMPLATE_INFO (olddecl)
3319                         || (DECL_TI_TEMPLATE (olddecl)
3320                             != DECL_TI_TEMPLATE (newdecl))))))
3321     /* It's OK to have a template specialization and a non-template
3322        with the same type, or to have specializations of two
3323        different templates with the same type.  Note that if one is a
3324        specialization, and the other is an instantiation of the same
3325        template, that we do not exit at this point.  That situation
3326        can occur if we instantiate a template class, and then
3327        specialize one of its methods.  This situation is legal, but
3328        the declarations must be merged in the usual way.  */
3329     return 0;
3330   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3331            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3332                 && !DECL_USE_TEMPLATE (newdecl))
3333                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3334                    && !DECL_USE_TEMPLATE (olddecl))))
3335     /* One of the declarations is a template instantiation, and the
3336        other is not a template at all.  That's OK.  */
3337     return 0;
3338   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3339            && DECL_NAMESPACE_ALIAS (newdecl)
3340            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3341     /* Redeclaration of namespace alias, ignore it. */
3342     return 1;
3343   else
3344     {
3345       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3346       if (errmsg)
3347         {
3348           cp_error (errmsg, newdecl);
3349           if (DECL_NAME (olddecl) != NULL_TREE)
3350             cp_error_at ((DECL_INITIAL (olddecl)
3351                           && namespace_bindings_p ())
3352                          ? "`%#D' previously defined here"
3353                          : "`%#D' previously declared here", olddecl);
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               cp_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                     if (pedantic)
3400                       {
3401                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3402                                     i, newdecl);
3403                         cp_pedwarn_at ("after previous specification in `%#D'",
3404                                        olddecl);
3405                       }
3406                   }
3407                 else
3408                   {
3409                     cp_error ("default argument given for parameter %d of `%#D'",
3410                               i, newdecl);
3411                     cp_error_at ("after previous specification in `%#D'",
3412                                  olddecl);
3413                   }
3414               }
3415
3416           if (DECL_DECLARED_INLINE_P (newdecl)
3417               && ! DECL_DECLARED_INLINE_P (olddecl)
3418               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3419             {
3420               cp_warning ("`%#D' was used before it was declared inline",
3421                           newdecl);
3422               cp_warning_at ("previous non-inline declaration here",
3423                              olddecl);
3424             }
3425         }
3426     }
3427
3428   /* If new decl is `static' and an `extern' was seen previously,
3429      warn about it.  */
3430   warn_extern_redeclared_static (newdecl, olddecl);
3431
3432   /* We have committed to returning 1 at this point.  */
3433   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3434     {
3435       /* Now that functions must hold information normally held
3436          by field decls, there is extra work to do so that
3437          declaration information does not get destroyed during
3438          definition.  */
3439       if (DECL_VINDEX (olddecl))
3440         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3441       if (DECL_VIRTUAL_CONTEXT (olddecl))
3442         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3443       if (DECL_CONTEXT (olddecl))
3444         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3445       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3446         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3447       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3448       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3449       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3450       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3451       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3452       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3453       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3454         SET_OVERLOADED_OPERATOR_CODE
3455           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3456       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3457
3458       /* Optionally warn about more than one declaration for the same
3459          name, but don't warn about a function declaration followed by a
3460          definition.  */
3461       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3462           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3463           /* Don't warn about extern decl followed by definition. */
3464           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3465           /* Don't warn about friends, let add_friend take care of it. */
3466           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3467         {
3468           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3469           cp_warning_at ("previous declaration of `%D'", olddecl);
3470         }
3471     }
3472
3473   /* Deal with C++: must preserve virtual function table size.  */
3474   if (TREE_CODE (olddecl) == TYPE_DECL)
3475     {
3476       register tree newtype = TREE_TYPE (newdecl);
3477       register tree oldtype = TREE_TYPE (olddecl);
3478
3479       if (newtype != error_mark_node && oldtype != error_mark_node
3480           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3481         {
3482           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3483           CLASSTYPE_FRIEND_CLASSES (newtype)
3484             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3485         }
3486
3487       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3488     }
3489
3490   /* Copy all the DECL_... slots specified in the new decl
3491      except for any that we copy here from the old type.  */
3492   DECL_MACHINE_ATTRIBUTES (newdecl)
3493     = merge_machine_decl_attributes (olddecl, newdecl);
3494
3495   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3496     {
3497       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3498       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3499         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3500                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3501
3502       /* If the new declaration is a definition, update the file and
3503          line information on the declaration.  */
3504       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3505           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3506         {
3507           DECL_SOURCE_LINE (olddecl)
3508             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3509             = DECL_SOURCE_LINE (newdecl);
3510           DECL_SOURCE_FILE (olddecl)
3511             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3512             = DECL_SOURCE_FILE (newdecl);
3513         }
3514
3515       return 1;
3516     }
3517
3518   if (types_match)
3519     {
3520       /* Automatically handles default parameters.  */
3521       tree oldtype = TREE_TYPE (olddecl);
3522       tree newtype;
3523
3524       /* Merge the data types specified in the two decls.  */
3525       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3526
3527       /* If common_type produces a non-typedef type, just use the old type.  */
3528       if (TREE_CODE (newdecl) == TYPE_DECL
3529           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3530         newtype = oldtype;
3531
3532       if (TREE_CODE (newdecl) == VAR_DECL)
3533         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3534       /* Do this after calling `common_type' so that default
3535          parameters don't confuse us.  */
3536       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3537           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3538               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3539         {
3540           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3541                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3542           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3543                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3544
3545           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3546               && DECL_SOURCE_LINE (olddecl) != 0
3547               && flag_exceptions
3548               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3549                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3550             {
3551               cp_error ("declaration of `%F' throws different exceptions",
3552                         newdecl);
3553               cp_error_at ("than previous declaration `%F'", olddecl);
3554             }
3555         }
3556       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3557
3558       /* Lay the type out, unless already done.  */
3559       if (! same_type_p (newtype, oldtype)
3560           && TREE_TYPE (newdecl) != error_mark_node
3561           && !(processing_template_decl && uses_template_parms (newdecl)))
3562         layout_type (TREE_TYPE (newdecl));
3563
3564       if ((TREE_CODE (newdecl) == VAR_DECL
3565            || TREE_CODE (newdecl) == PARM_DECL
3566            || TREE_CODE (newdecl) == RESULT_DECL
3567            || TREE_CODE (newdecl) == FIELD_DECL
3568            || TREE_CODE (newdecl) == TYPE_DECL)
3569           && !(processing_template_decl && uses_template_parms (newdecl)))
3570         layout_decl (newdecl, 0);
3571
3572       /* Merge the type qualifiers.  */
3573       if (TREE_READONLY (newdecl))
3574         TREE_READONLY (olddecl) = 1;
3575       if (TREE_THIS_VOLATILE (newdecl))
3576         TREE_THIS_VOLATILE (olddecl) = 1;
3577
3578       /* Merge the initialization information.  */
3579       if (DECL_INITIAL (newdecl) == NULL_TREE
3580           && DECL_INITIAL (olddecl) != NULL_TREE)
3581         {
3582           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3583           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3584           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3585           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3586               && DECL_LANG_SPECIFIC (newdecl)
3587               && DECL_LANG_SPECIFIC (olddecl))
3588             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3589         }
3590
3591       /* Merge the section attribute.
3592          We want to issue an error if the sections conflict but that must be
3593          done later in decl_attributes since we are called before attributes
3594          are assigned.  */
3595       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3596         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3597
3598       /* Keep the old rtl since we can safely use it.  */
3599       COPY_DECL_RTL (olddecl, newdecl);
3600
3601       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3602         {
3603           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3604             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3605           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3606             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3607           DECL_NO_LIMIT_STACK (newdecl)
3608             |= DECL_NO_LIMIT_STACK (olddecl);
3609         }
3610     }
3611   /* If cannot merge, then use the new type and qualifiers,
3612      and don't preserve the old rtl.  */
3613   else
3614     {
3615       /* Clean out any memory we had of the old declaration.  */
3616       tree oldstatic = value_member (olddecl, static_aggregates);
3617       if (oldstatic)
3618         TREE_VALUE (oldstatic) = error_mark_node;
3619
3620       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3621       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3622       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3623       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3624     }
3625
3626   /* Merge the storage class information.  */
3627   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3628   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3629   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3630   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3631   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3632   if (! DECL_EXTERNAL (olddecl))
3633     DECL_EXTERNAL (newdecl) = 0;
3634
3635   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3636     {
3637       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3638       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3639       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3640       DECL_TEMPLATE_INSTANTIATED (newdecl)
3641         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3642       /* Don't really know how much of the language-specific
3643          values we should copy from old to new.  */
3644       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3645       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3646       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3647       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3648       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3649         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3650       olddecl_friend = DECL_FRIEND_P (olddecl);
3651
3652       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3653       if (TREE_CODE (newdecl) == FUNCTION_DECL
3654           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3655         DECL_BEFRIENDING_CLASSES (newdecl)
3656           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3657                      DECL_BEFRIENDING_CLASSES (olddecl));
3658     }
3659
3660   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3661     {
3662       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3663           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3664         {
3665           /* If newdecl is not a specialization, then it is not a
3666              template-related function at all.  And that means that we
3667              shoud have exited above, returning 0.  */
3668           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3669                               0);
3670
3671           if (TREE_USED (olddecl))
3672             /* From [temp.expl.spec]:
3673
3674                If a template, a member template or the member of a class
3675                template is explicitly specialized then that
3676                specialization shall be declared before the first use of
3677                that specialization that would cause an implicit
3678                instantiation to take place, in every translation unit in
3679                which such a use occurs.  */
3680             cp_error ("explicit specialization of %D after first use",
3681                       olddecl);
3682
3683           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3684         }
3685       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3686
3687       /* If either decl says `inline', this fn is inline, unless its
3688          definition was passed already.  */
3689       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3690         DECL_INLINE (olddecl) = 1;
3691       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3692
3693       /* Preserve abstractness on cloned [cd]tors.  */
3694       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3695
3696       if (! types_match)
3697         {
3698           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3699           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3700           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3701         }
3702       if (! types_match || new_defines_function)
3703         {
3704           /* These need to be copied so that the names are available.
3705              Note that if the types do match, we'll preserve inline
3706              info and other bits, but if not, we won't.  */
3707           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3708           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3709         }
3710       if (new_defines_function)
3711         /* If defining a function declared with other language
3712            linkage, use the previously declared language linkage.  */
3713         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3714       else if (types_match)
3715         {
3716           /* If redeclaring a builtin function, and not a definition,
3717              it stays built in.  */
3718           if (DECL_BUILT_IN (olddecl))
3719             {
3720               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3721               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3722               /* If we're keeping the built-in definition, keep the rtl,
3723                  regardless of declaration matches.  */
3724               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3725             }
3726           else
3727             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3728
3729           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3730           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3731             /* Previously saved insns go together with
3732                the function's previous definition.  */
3733             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3734           /* Don't clear out the arguments if we're redefining a function.  */
3735           if (DECL_ARGUMENTS (olddecl))
3736             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3737         }
3738     }
3739   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3740     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3741
3742   /* Now preserve various other info from the definition.  */
3743   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3744   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3745   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3746   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3747
3748   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3749     {
3750       int function_size;
3751
3752       function_size = sizeof (struct tree_decl);
3753
3754       memcpy ((char *) olddecl + sizeof (struct tree_common),
3755               (char *) newdecl + sizeof (struct tree_common),
3756               function_size - sizeof (struct tree_common));
3757
3758       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3759         {
3760           /* If newdecl is a template instantiation, it is possible that
3761              the following sequence of events has occurred:
3762
3763              o A friend function was declared in a class template.  The
3764              class template was instantiated.
3765
3766              o The instantiation of the friend declaration was
3767              recorded on the instantiation list, and is newdecl.
3768
3769              o Later, however, instantiate_class_template called pushdecl
3770              on the newdecl to perform name injection.  But, pushdecl in
3771              turn called duplicate_decls when it discovered that another
3772              declaration of a global function with the same name already
3773              existed.
3774
3775              o Here, in duplicate_decls, we decided to clobber newdecl.
3776
3777              If we're going to do that, we'd better make sure that
3778              olddecl, and not newdecl, is on the list of
3779              instantiations so that if we try to do the instantiation
3780              again we won't get the clobbered declaration.  */
3781
3782           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3783           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3784
3785           for (; decls; decls = TREE_CHAIN (decls))
3786             if (TREE_VALUE (decls) == newdecl)
3787               TREE_VALUE (decls) = olddecl;
3788         }
3789     }
3790   else
3791     {
3792       memcpy ((char *) olddecl + sizeof (struct tree_common),
3793               (char *) newdecl + sizeof (struct tree_common),
3794               sizeof (struct tree_decl) - sizeof (struct tree_common)
3795               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3796     }
3797
3798   DECL_UID (olddecl) = olddecl_uid;
3799   if (olddecl_friend)
3800     DECL_FRIEND_P (olddecl) = 1;
3801
3802   /* NEWDECL contains the merged attribute lists.
3803      Update OLDDECL to be the same.  */
3804   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3805
3806   return 1;
3807 }
3808
3809 /* Record a decl-node X as belonging to the current lexical scope.
3810    Check for errors (such as an incompatible declaration for the same
3811    name already seen in the same scope).
3812
3813    Returns either X or an old decl for the same name.
3814    If an old decl is returned, it may have been smashed
3815    to agree with what X says.  */
3816
3817 tree
3818 pushdecl (x)
3819      tree x;
3820 {
3821   register tree t;
3822   register tree name;
3823   int need_new_binding;
3824
3825   /* We shouldn't be calling pushdecl when we're generating RTL for a
3826      function that we already did semantic analysis on previously.  */
3827   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3828                       19990913);
3829
3830   need_new_binding = 1;
3831
3832   if (DECL_TEMPLATE_PARM_P (x))
3833     /* Template parameters have no context; they are not X::T even
3834        when declared within a class or namespace.  */
3835     ;
3836   else
3837     {
3838       if (current_function_decl && x != current_function_decl
3839           /* A local declaration for a function doesn't constitute
3840              nesting.  */
3841           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3842           /* A local declaration for an `extern' variable is in the
3843              scope of the current namespace, not the current
3844              function.  */
3845           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3846           && !DECL_CONTEXT (x))
3847         DECL_CONTEXT (x) = current_function_decl;
3848
3849       /* If this is the declaration for a namespace-scope function,
3850          but the declaration itself is in a local scope, mark the
3851          declaration.  */
3852       if (TREE_CODE (x) == FUNCTION_DECL
3853           && DECL_NAMESPACE_SCOPE_P (x)
3854           && current_function_decl
3855           && x != current_function_decl)
3856         DECL_LOCAL_FUNCTION_P (x) = 1;
3857     }
3858
3859   name = DECL_NAME (x);
3860   if (name)
3861     {
3862       int different_binding_level = 0;
3863
3864       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3865         name = TREE_OPERAND (name, 0);
3866
3867       /* In case this decl was explicitly namespace-qualified, look it
3868          up in its namespace context.  */
3869       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3870           && namespace_bindings_p ())
3871         t = namespace_binding (name, DECL_CONTEXT (x));
3872       else
3873         t = lookup_name_current_level (name);
3874
3875       /* [basic.link] If there is a visible declaration of an entity
3876          with linkage having the same name and type, ignoring entities
3877          declared outside the innermost enclosing namespace scope, the
3878          block scope declaration declares that same entity and
3879          receives the linkage of the previous declaration.  */
3880       if (! t && current_function_decl && x != current_function_decl
3881           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3882           && DECL_EXTERNAL (x))
3883         {
3884           /* Look in block scope.  */
3885           t = IDENTIFIER_VALUE (name);
3886           /* Or in the innermost namespace.  */
3887           if (! t)
3888             t = namespace_binding (name, DECL_CONTEXT (x));
3889           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3890              OVERLOAD, which is OK.  */
3891           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3892             t = NULL_TREE;
3893           if (t)
3894             different_binding_level = 1;
3895         }
3896
3897       /* If we are declaring a function, and the result of name-lookup
3898          was an OVERLOAD, look for an overloaded instance that is
3899          actually the same as the function we are declaring.  (If
3900          there is one, we have to merge our declaration with the
3901          previous declaration.)  */
3902       if (t && TREE_CODE (t) == OVERLOAD)
3903         {
3904           tree match;
3905
3906           if (TREE_CODE (x) == FUNCTION_DECL)
3907             for (match = t; match; match = OVL_NEXT (match))
3908               {
3909                 if (decls_match (OVL_CURRENT (match), x))
3910                   break;
3911               }
3912           else
3913             /* Just choose one.  */
3914             match = t;
3915
3916           if (match)
3917             t = OVL_CURRENT (match);
3918           else
3919             t = NULL_TREE;
3920         }
3921
3922       if (t == error_mark_node)
3923         {
3924           /* error_mark_node is 0 for a while during initialization!  */
3925           t = NULL_TREE;
3926           cp_error_at ("`%#D' used prior to declaration", x);
3927         }
3928       else if (t != NULL_TREE)
3929         {
3930           if (different_binding_level)
3931             {
3932               if (decls_match (x, t))
3933                 /* The standard only says that the local extern
3934                    inherits linkage from the previous decl; in
3935                    particular, default args are not shared.  It would
3936                    be nice to propagate inlining info, though.  FIXME.  */
3937                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3938             }
3939           else if (TREE_CODE (t) == PARM_DECL)
3940             {
3941               if (DECL_CONTEXT (t) == NULL_TREE)
3942                 /* This is probaby caused by too many errors, but calling
3943                    abort will say that if errors have occurred.  */
3944                 abort ();
3945
3946               /* Check for duplicate params.  */
3947               if (duplicate_decls (x, t))
3948                 return t;
3949             }
3950           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3951                     || DECL_FUNCTION_TEMPLATE_P (x))
3952                    && is_overloaded_fn (t))
3953             /* Don't do anything just yet. */;
3954           else if (t == wchar_decl_node)
3955             {
3956               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3957                 cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
3958                             TREE_TYPE (x));
3959
3960               /* Throw away the redeclaration.  */
3961               return t;
3962             }
3963           else if (TREE_CODE (t) != TREE_CODE (x))
3964             {
3965               if (duplicate_decls (x, t))
3966                 return t;
3967             }
3968           else if (duplicate_decls (x, t))
3969             {
3970               if (TREE_CODE (t) == TYPE_DECL)
3971                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3972               else if (TREE_CODE (t) == FUNCTION_DECL)
3973                 check_default_args (t);
3974
3975               return t;
3976             }
3977           else if (DECL_MAIN_P (x))
3978             {
3979               /* A redeclaration of main, but not a duplicate of the
3980                  previous one.
3981
3982                  [basic.start.main]
3983
3984                  This function shall not be overloaded.  */
3985               cp_error_at ("invalid redeclaration of `%D'", t);
3986               cp_error ("as `%D'", x);
3987               /* We don't try to push this declaration since that
3988                  causes a crash.  */
3989               return x;
3990             }
3991         }
3992
3993       check_template_shadow (x);
3994
3995       /* If this is a function conjured up by the backend, massage it
3996          so it looks friendly.  */
3997       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3998         {
3999           retrofit_lang_decl (x);
4000           SET_DECL_LANGUAGE (x, lang_c);
4001         }
4002
4003       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4004         {
4005           t = push_overloaded_decl (x, PUSH_LOCAL);
4006           if (t != x)
4007             return t;
4008           if (!namespace_bindings_p ())
4009             /* We do not need to create a binding for this name;
4010                push_overloaded_decl will have already done so if
4011                necessary.  */
4012             need_new_binding = 0;
4013         }
4014       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4015         {
4016           t = push_overloaded_decl (x, PUSH_GLOBAL);
4017           if (t == x)
4018             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4019           return t;
4020         }
4021
4022       /* If declaring a type as a typedef, copy the type (unless we're
4023          at line 0), and install this TYPE_DECL as the new type's typedef
4024          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4025       if (TREE_CODE (x) == TYPE_DECL)
4026         {
4027           tree type = TREE_TYPE (x);
4028           if (DECL_SOURCE_LINE (x) == 0)
4029             {
4030               if (TYPE_NAME (type) == 0)
4031                 TYPE_NAME (type) = x;
4032             }
4033           else if (type != error_mark_node && TYPE_NAME (type) != x
4034                    /* We don't want to copy the type when all we're
4035                       doing is making a TYPE_DECL for the purposes of
4036                       inlining.  */
4037                    && (!TYPE_NAME (type)
4038                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4039             {
4040               DECL_ORIGINAL_TYPE (x) = type;
4041               type = build_type_copy (type);
4042               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4043               TYPE_NAME (type) = x;
4044               TREE_TYPE (x) = type;
4045             }
4046
4047           if (type != error_mark_node
4048               && TYPE_NAME (type)
4049               && TYPE_IDENTIFIER (type))
4050             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4051                                                   current_binding_level);
4052
4053         }
4054
4055       /* Multiple external decls of the same identifier ought to match.
4056
4057          We get warnings about inline functions where they are defined.
4058          We get warnings about other functions from push_overloaded_decl.
4059
4060          Avoid duplicate warnings where they are used.  */
4061       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4062         {
4063           tree decl;
4064
4065           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4066           if (decl && TREE_CODE (decl) == OVERLOAD)
4067             decl = OVL_FUNCTION (decl);
4068
4069           if (decl && decl != error_mark_node
4070               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4071               /* If different sort of thing, we already gave an error.  */
4072               && TREE_CODE (decl) == TREE_CODE (x)
4073               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4074             {
4075               cp_pedwarn ("type mismatch with previous external decl", x);
4076               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4077             }
4078         }
4079
4080       /* This name is new in its binding level.
4081          Install the new declaration and return it.  */
4082       if (namespace_bindings_p ())
4083         {
4084           /* Install a global value.  */
4085
4086           /* If the first global decl has external linkage,
4087              warn if we later see static one.  */
4088           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4089             TREE_PUBLIC (name) = 1;
4090
4091           /* Bind the name for the entity.  */
4092           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4093                 && t != NULL_TREE)
4094               && (TREE_CODE (x) == TYPE_DECL
4095                   || TREE_CODE (x) == VAR_DECL
4096                   || TREE_CODE (x) == NAMESPACE_DECL
4097                   || TREE_CODE (x) == CONST_DECL
4098                   || TREE_CODE (x) == TEMPLATE_DECL))
4099             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4100
4101           /* Don't forget if the function was used via an implicit decl.  */
4102           if (IDENTIFIER_IMPLICIT_DECL (name)
4103               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4104             TREE_USED (x) = 1;
4105
4106           /* Don't forget if its address was taken in that way.  */
4107           if (IDENTIFIER_IMPLICIT_DECL (name)
4108               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4109             TREE_ADDRESSABLE (x) = 1;
4110
4111           /* Warn about mismatches against previous implicit decl.  */
4112           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4113               /* If this real decl matches the implicit, don't complain.  */
4114               && ! (TREE_CODE (x) == FUNCTION_DECL
4115                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4116             cp_warning
4117               ("`%D' was previously implicitly declared to return `int'", x);
4118
4119           /* If new decl is `static' and an `extern' was seen previously,
4120              warn about it.  */
4121           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4122             warn_extern_redeclared_static (x, t);
4123         }
4124       else
4125         {
4126           /* Here to install a non-global value.  */
4127           tree oldlocal = IDENTIFIER_VALUE (name);
4128           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4129
4130           if (need_new_binding)
4131             {
4132               push_local_binding (name, x, 0);
4133               /* Because push_local_binding will hook X on to the
4134                  current_binding_level's name list, we don't want to
4135                  do that again below.  */
4136               need_new_binding = 0;
4137             }
4138
4139           /* If this is a TYPE_DECL, push it into the type value slot.  */
4140           if (TREE_CODE (x) == TYPE_DECL)
4141             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4142                                                   current_binding_level);
4143
4144           /* Clear out any TYPE_DECL shadowed by a namespace so that
4145              we won't think this is a type.  The C struct hack doesn't
4146              go through namespaces.  */
4147           if (TREE_CODE (x) == NAMESPACE_DECL)
4148             set_identifier_type_value_with_scope (name, NULL_TREE,
4149                                                   current_binding_level);
4150
4151           if (oldlocal)
4152             {
4153               tree d = oldlocal;
4154
4155               while (oldlocal
4156                      && TREE_CODE (oldlocal) == VAR_DECL
4157                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4158                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4159
4160               if (oldlocal == NULL_TREE)
4161                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4162             }
4163
4164           /* If this is an extern function declaration, see if we
4165              have a global definition or declaration for the function.  */
4166           if (oldlocal == NULL_TREE
4167               && DECL_EXTERNAL (x)
4168               && oldglobal != NULL_TREE
4169               && TREE_CODE (x) == FUNCTION_DECL
4170               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4171             {
4172               /* We have one.  Their types must agree.  */
4173               if (decls_match (x, oldglobal))
4174                 /* OK */;
4175               else
4176                 {
4177                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4178                   cp_warning_at ("global declaration `%#D'", oldglobal);
4179                 }
4180             }
4181           /* If we have a local external declaration,
4182              and no file-scope declaration has yet been seen,
4183              then if we later have a file-scope decl it must not be static.  */
4184           if (oldlocal == NULL_TREE
4185               && oldglobal == NULL_TREE
4186               && DECL_EXTERNAL (x)
4187               && TREE_PUBLIC (x))
4188             TREE_PUBLIC (name) = 1;
4189
4190           /* Warn if shadowing an argument at the top level of the body.  */
4191           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4192               /* Inline decls shadow nothing.  */
4193               && !DECL_FROM_INLINE (x)
4194               && TREE_CODE (oldlocal) == PARM_DECL
4195               /* Don't complain if it's from an enclosing function.  */
4196               && DECL_CONTEXT (oldlocal) == current_function_decl
4197               && TREE_CODE (x) != PARM_DECL)
4198             {
4199               /* Go to where the parms should be and see if we
4200                  find them there.  */
4201               struct binding_level *b = current_binding_level->level_chain;
4202
4203               if (cleanup_label)
4204                 b = b->level_chain;
4205
4206               /* ARM $8.3 */
4207               if (b->parm_flag == 1)
4208                 cp_error ("declaration of `%#D' shadows a parameter", name);
4209             }
4210
4211           /* Maybe warn if shadowing something else.  */
4212           if (warn_shadow && !DECL_EXTERNAL (x)
4213               /* Inline decls shadow nothing.  */
4214               && !DECL_FROM_INLINE (x)
4215               /* No shadow warnings for internally generated vars.  */
4216               && ! DECL_ARTIFICIAL (x)
4217               /* No shadow warnings for vars made for inlining.  */
4218               && ! DECL_FROM_INLINE (x))
4219             {
4220               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4221                 warning ("declaration of `%s' shadows a parameter",
4222                         IDENTIFIER_POINTER (name));
4223               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4224                        && current_class_ptr
4225                        && !TREE_STATIC (name))
4226                 warning ("declaration of `%s' shadows a member of `this'",
4227                         IDENTIFIER_POINTER (name));
4228               else if (oldlocal != NULL_TREE)
4229                 warning ("declaration of `%s' shadows previous local",
4230                         IDENTIFIER_POINTER (name));
4231               else if (oldglobal != NULL_TREE)
4232                 /* XXX shadow warnings in outer-more namespaces */
4233                 warning ("declaration of `%s' shadows global declaration",
4234                         IDENTIFIER_POINTER (name));
4235             }
4236         }
4237
4238       if (TREE_CODE (x) == FUNCTION_DECL)
4239         check_default_args (x);
4240
4241       /* Keep count of variables in this level with incomplete type.  */
4242       if (TREE_CODE (x) == VAR_DECL
4243           && TREE_TYPE (x) != error_mark_node
4244           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4245                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4246               /* RTTI TD entries are created while defining the type_info.  */
4247               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4248                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4249         {
4250           if (namespace_bindings_p ())
4251             namespace_scope_incomplete
4252               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4253           else
4254             current_binding_level->incomplete
4255               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4256         }
4257     }
4258
4259   if (need_new_binding)
4260     add_decl_to_level (x,
4261                        DECL_NAMESPACE_SCOPE_P (x)
4262                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4263                        : current_binding_level);
4264
4265   return x;
4266 }
4267
4268 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4269    caller to set DECL_CONTEXT properly.  */
4270
4271 static tree
4272 pushdecl_with_scope (x, level)
4273      tree x;
4274      struct binding_level *level;
4275 {
4276   register struct binding_level *b;
4277   tree function_decl = current_function_decl;
4278
4279   current_function_decl = NULL_TREE;
4280   if (level->parm_flag == 2)
4281     {
4282       b = class_binding_level;
4283       class_binding_level = level;
4284       pushdecl_class_level (x);
4285       class_binding_level = b;
4286     }
4287   else
4288     {
4289       b = current_binding_level;
4290       current_binding_level = level;
4291       x = pushdecl (x);
4292       current_binding_level = b;
4293     }
4294   current_function_decl = function_decl;
4295   return x;
4296 }
4297
4298 /* Like pushdecl, only it places X in the current namespace,
4299    if appropriate.  */
4300
4301 tree
4302 pushdecl_namespace_level (x)
4303      tree x;
4304 {
4305   register struct binding_level *b = current_binding_level;
4306   register tree t;
4307
4308   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4309
4310   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4311      what we want.  */
4312   if (TREE_CODE (x) == TYPE_DECL)
4313     {
4314       tree name = DECL_NAME (x);
4315       tree newval;
4316       tree *ptr = (tree *)0;
4317       for (; b != global_binding_level; b = b->level_chain)
4318         {
4319           tree shadowed = b->type_shadowed;
4320           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4321             if (TREE_PURPOSE (shadowed) == name)
4322               {
4323                 ptr = &TREE_VALUE (shadowed);
4324                 /* Can't break out of the loop here because sometimes
4325                    a binding level will have duplicate bindings for
4326                    PT names.  It's gross, but I haven't time to fix it.  */
4327               }
4328         }
4329       newval = TREE_TYPE (x);
4330       if (ptr == (tree *)0)
4331         {
4332           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4333              up here if this is changed to an assertion.  --KR  */
4334           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4335         }
4336       else
4337         {
4338           *ptr = newval;
4339         }
4340     }
4341   return t;
4342 }
4343
4344 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4345    if appropriate.  */
4346
4347 tree
4348 pushdecl_top_level (x)
4349      tree x;
4350 {
4351   push_to_top_level ();
4352   x = pushdecl_namespace_level (x);
4353   pop_from_top_level ();
4354   return x;
4355 }
4356
4357 /* Make the declaration of X appear in CLASS scope.  */
4358
4359 void
4360 pushdecl_class_level (x)
4361      tree x;
4362 {
4363   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4364      scope looks for the pre-mangled name.  */
4365   register tree name;
4366
4367   if (TREE_CODE (x) == OVERLOAD)
4368     x = OVL_CURRENT (x);
4369   name = DECL_NAME (x);
4370
4371   if (name)
4372     {
4373       push_class_level_binding (name, x);
4374       if (TREE_CODE (x) == TYPE_DECL)
4375         set_identifier_type_value (name, TREE_TYPE (x));
4376     }
4377   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4378     {
4379       tree f;
4380
4381       for (f = TYPE_FIELDS (TREE_TYPE (x));
4382            f;
4383            f = TREE_CHAIN (f))
4384         pushdecl_class_level (f);
4385     }
4386 }
4387
4388 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4389    DECL, or a modified version thereof.  */
4390
4391 tree
4392 maybe_push_decl (decl)
4393      tree decl;
4394 {
4395   tree type = TREE_TYPE (decl);
4396
4397   /* Add this decl to the current binding level, but not if it comes
4398      from another scope, e.g. a static member variable.  TEM may equal
4399      DECL or it may be a previous decl of the same name.  */
4400   if (decl == error_mark_node
4401       || (TREE_CODE (decl) != PARM_DECL
4402           && DECL_CONTEXT (decl) != NULL_TREE
4403           /* Definitions of namespace members outside their namespace are
4404              possible. */
4405           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4406       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4407       || TREE_CODE (type) == UNKNOWN_TYPE
4408       /* The declaration of a template specialization does not affect
4409          the functions available for overload resolution, so we do not
4410          call pushdecl.  */
4411       || (TREE_CODE (decl) == FUNCTION_DECL
4412           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4413     return decl;
4414   else
4415     return pushdecl (decl);
4416 }
4417
4418 /* Make the declaration(s) of X appear in CLASS scope
4419    under the name NAME.  */
4420
4421 void
4422 push_class_level_binding (name, x)
4423      tree name;
4424      tree x;
4425 {
4426   tree binding;
4427   /* The class_binding_level will be NULL if x is a template
4428      parameter name in a member template.  */
4429   if (!class_binding_level)
4430     return;
4431
4432   /* Make sure that this new member does not have the same name
4433      as a template parameter.  */
4434   if (TYPE_BEING_DEFINED (current_class_type))
4435     check_template_shadow (x);
4436
4437   /* If this declaration shadows a declaration from an enclosing
4438      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4439      we leave this class.  Record the shadowed declaration here.  */
4440   binding = IDENTIFIER_BINDING (name);
4441   if (binding
4442       && ((TREE_CODE (x) == OVERLOAD
4443            && BINDING_VALUE (binding)
4444            && is_overloaded_fn (BINDING_VALUE (binding)))
4445           || INHERITED_VALUE_BINDING_P (binding)))
4446     {
4447       tree shadow;
4448       tree old_decl;
4449
4450       /* If the old binding was from a base class, and was for a tag
4451          name, slide it over to make room for the new binding.  The
4452          old binding is still visible if explicitly qualified with a
4453          class-key.  */
4454       if (INHERITED_VALUE_BINDING_P (binding)
4455           && BINDING_VALUE (binding)
4456           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4457           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4458           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4459         {
4460           old_decl = BINDING_TYPE (binding);
4461           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4462           BINDING_VALUE (binding) = NULL_TREE;
4463           INHERITED_VALUE_BINDING_P (binding) = 0;
4464         }
4465       else
4466         old_decl = BINDING_VALUE (binding);
4467
4468       /* Find the previous binding of name on the class-shadowed
4469          list, and update it.  */
4470       for (shadow = class_binding_level->class_shadowed;
4471            shadow;
4472            shadow = TREE_CHAIN (shadow))
4473         if (TREE_PURPOSE (shadow) == name
4474             && TREE_TYPE (shadow) == old_decl)
4475           {
4476             BINDING_VALUE (binding) = x;
4477             INHERITED_VALUE_BINDING_P (binding) = 0;
4478             TREE_TYPE (shadow) = x;
4479             IDENTIFIER_CLASS_VALUE (name) = x;
4480             return;
4481           }
4482     }
4483
4484   /* If we didn't replace an existing binding, put the binding on the
4485      stack of bindings for the identifier, and update the shadowed list.  */
4486   if (push_class_binding (name, x))
4487     {
4488       class_binding_level->class_shadowed
4489         = tree_cons (name, NULL,
4490                      class_binding_level->class_shadowed);
4491       /* Record the value we are binding NAME to so that we can know
4492          what to pop later.  */
4493       TREE_TYPE (class_binding_level->class_shadowed) = x;
4494     }
4495 }
4496
4497 /* Insert another USING_DECL into the current binding level, returning
4498    this declaration. If this is a redeclaration, do nothing, and
4499    return NULL_TREE if this not in namespace scope (in namespace
4500    scope, a using decl might extend any previous bindings).  */
4501
4502 tree
4503 push_using_decl (scope, name)
4504      tree scope;
4505      tree name;
4506 {
4507   tree decl;
4508
4509   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4510   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4511   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4512     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4513       break;
4514   if (decl)
4515     return namespace_bindings_p () ? decl : NULL_TREE;
4516   decl = build_lang_decl (USING_DECL, name, void_type_node);
4517   DECL_INITIAL (decl) = scope;
4518   TREE_CHAIN (decl) = current_binding_level->usings;
4519   current_binding_level->usings = decl;
4520   return decl;
4521 }
4522
4523 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4524    changed (i.e. there was already a directive), or the fresh
4525    TREE_LIST otherwise.  */
4526
4527 tree
4528 push_using_directive (used)
4529      tree used;
4530 {
4531   tree ud = current_binding_level->using_directives;
4532   tree iter, ancestor;
4533
4534   /* Check if we already have this. */
4535   if (purpose_member (used, ud) != NULL_TREE)
4536     return NULL_TREE;
4537
4538   /* Recursively add all namespaces used. */
4539   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4540     push_using_directive (TREE_PURPOSE (iter));
4541
4542   ancestor = namespace_ancestor (current_decl_namespace (), used);
4543   ud = current_binding_level->using_directives;
4544   ud = tree_cons (used, ancestor, ud);
4545   current_binding_level->using_directives = ud;
4546   return ud;
4547 }
4548
4549 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4550    other definitions already in place.  We get around this by making
4551    the value of the identifier point to a list of all the things that
4552    want to be referenced by that name.  It is then up to the users of
4553    that name to decide what to do with that list.
4554
4555    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4556    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4557
4558    FLAGS is a bitwise-or of the following values:
4559      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4560                  namespace scope.
4561      PUSH_USING: DECL is being pushed as the result of a using
4562                  declaration.
4563
4564    The value returned may be a previous declaration if we guessed wrong
4565    about what language DECL should belong to (C or C++).  Otherwise,
4566    it's always DECL (and never something that's not a _DECL).  */
4567
4568 tree
4569 push_overloaded_decl (decl, flags)
4570      tree decl;
4571      int flags;
4572 {
4573   tree name = DECL_NAME (decl);
4574   tree old;
4575   tree new_binding;
4576   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4577
4578   if (doing_global)
4579     old = namespace_binding (name, DECL_CONTEXT (decl));
4580   else
4581     old = lookup_name_current_level (name);
4582
4583   if (old)
4584     {
4585       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4586         {
4587           tree t = TREE_TYPE (old);
4588           if (IS_AGGR_TYPE (t) && warn_shadow
4589               && (! DECL_IN_SYSTEM_HEADER (decl)
4590                   || ! DECL_IN_SYSTEM_HEADER (old)))
4591             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4592           old = NULL_TREE;
4593         }
4594       else if (is_overloaded_fn (old))
4595         {
4596           tree tmp;
4597
4598           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4599             {
4600               tree fn = OVL_CURRENT (tmp);
4601
4602               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4603                   && !(flags & PUSH_USING)
4604                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4605                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4606                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4607                           decl, fn);
4608
4609               if (duplicate_decls (decl, fn))
4610                 return fn;
4611             }
4612         }
4613       else if (old == error_mark_node)
4614         /* Ignore the undefined symbol marker.  */
4615         old = NULL_TREE;
4616       else
4617         {
4618           cp_error_at ("previous non-function declaration `%#D'", old);
4619           cp_error ("conflicts with function declaration `%#D'", decl);
4620           return decl;
4621         }
4622     }
4623
4624   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4625     {
4626       if (old && TREE_CODE (old) != OVERLOAD)
4627         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4628       else
4629         new_binding = ovl_cons (decl, old);
4630       if (flags & PUSH_USING)
4631         OVL_USED (new_binding) = 1;
4632     }
4633   else
4634     /* NAME is not ambiguous.  */
4635     new_binding = decl;
4636
4637   if (doing_global)
4638     set_namespace_binding (name, current_namespace, new_binding);
4639   else
4640     {
4641       /* We only create an OVERLOAD if there was a previous binding at
4642          this level, or if decl is a template. In the former case, we
4643          need to remove the old binding and replace it with the new
4644          binding.  We must also run through the NAMES on the binding
4645          level where the name was bound to update the chain.  */
4646
4647       if (TREE_CODE (new_binding) == OVERLOAD && old)
4648         {
4649           tree *d;
4650
4651           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4652                *d;
4653                d = &TREE_CHAIN (*d))
4654             if (*d == old
4655                 || (TREE_CODE (*d) == TREE_LIST
4656                     && TREE_VALUE (*d) == old))
4657               {
4658                 if (TREE_CODE (*d) == TREE_LIST)
4659                   /* Just replace the old binding with the new.  */
4660                   TREE_VALUE (*d) = new_binding;
4661                 else
4662                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4663                   *d = tree_cons (NULL_TREE, new_binding,
4664                                   TREE_CHAIN (*d));
4665
4666                 /* And update the CPLUS_BINDING node.  */
4667                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4668                   = new_binding;
4669                 return decl;
4670               }
4671
4672           /* We should always find a previous binding in this case.  */
4673           my_friendly_abort (0);
4674         }
4675
4676       /* Install the new binding.  */
4677       push_local_binding (name, new_binding, flags);
4678     }
4679
4680   return decl;
4681 }
4682 \f
4683 /* Generate an implicit declaration for identifier FUNCTIONID
4684    as a function of type int ().  Print a warning if appropriate.  */
4685
4686 tree
4687 implicitly_declare (functionid)
4688      tree functionid;
4689 {
4690   register tree decl;
4691
4692   /* We used to reuse an old implicit decl here,
4693      but this loses with inline functions because it can clobber
4694      the saved decl chains.  */
4695   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4696
4697   DECL_EXTERNAL (decl) = 1;
4698   TREE_PUBLIC (decl) = 1;
4699
4700   /* ISO standard says implicit declarations are in the innermost block.
4701      So we record the decl in the standard fashion.  */
4702   pushdecl (decl);
4703   rest_of_decl_compilation (decl, NULL, 0, 0);
4704
4705   if (warn_implicit
4706       /* Only one warning per identifier.  */
4707       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4708     {
4709       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4710     }
4711
4712   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4713
4714   return decl;
4715 }
4716
4717 /* Return zero if the declaration NEWDECL is valid
4718    when the declaration OLDDECL (assumed to be for the same name)
4719    has already been seen.
4720    Otherwise return an error message format string with a %s
4721    where the identifier should go.  */
4722
4723 static const char *
4724 redeclaration_error_message (newdecl, olddecl)
4725      tree newdecl, olddecl;
4726 {
4727   if (TREE_CODE (newdecl) == TYPE_DECL)
4728     {
4729       /* Because C++ can put things into name space for free,
4730          constructs like "typedef struct foo { ... } foo"
4731          would look like an erroneous redeclaration.  */
4732       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4733         return 0;
4734       else
4735         return "redefinition of `%#D'";
4736     }
4737   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4738     {
4739       /* If this is a pure function, its olddecl will actually be
4740          the original initialization to `0' (which we force to call
4741          abort()).  Don't complain about redefinition in this case.  */
4742       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4743         return 0;
4744
4745       /* If both functions come from different namespaces, this is not
4746          a redeclaration - this is a conflict with a used function. */
4747       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4748           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4749         return "`%D' conflicts with used function";
4750
4751       /* We'll complain about linkage mismatches in
4752          warn_extern_redeclared_static.  */
4753
4754       /* Defining the same name twice is no good.  */
4755       if (DECL_INITIAL (olddecl) != NULL_TREE
4756           && DECL_INITIAL (newdecl) != NULL_TREE)
4757         {
4758           if (DECL_NAME (olddecl) == NULL_TREE)
4759             return "`%#D' not declared in class";
4760           else
4761             return "redefinition of `%#D'";
4762         }
4763       return 0;
4764     }
4765   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4766     {
4767       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4768            && (DECL_TEMPLATE_RESULT (newdecl)
4769                != DECL_TEMPLATE_RESULT (olddecl))
4770            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4771            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4772           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4773               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4774               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4775         return "redefinition of `%#D'";
4776       return 0;
4777     }
4778   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4779     {
4780       /* Objects declared at top level:  */
4781       /* If at least one is a reference, it's ok.  */
4782       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4783         return 0;
4784       /* Reject two definitions.  */
4785       return "redefinition of `%#D'";
4786     }
4787   else
4788     {
4789       /* Objects declared with block scope:  */
4790       /* Reject two definitions, and reject a definition
4791          together with an external reference.  */
4792       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4793         return "redeclaration of `%#D'";
4794       return 0;
4795     }
4796 }
4797 \f
4798 /* Create a new label, named ID.  */
4799
4800 static tree
4801 make_label_decl (id, local_p)
4802      tree id;
4803      int local_p;
4804 {
4805   tree decl;
4806
4807   decl = build_decl (LABEL_DECL, id, void_type_node);
4808   if (expanding_p)
4809     /* Make sure every label has an rtx.  */
4810     label_rtx (decl);
4811
4812   DECL_CONTEXT (decl) = current_function_decl;
4813   DECL_MODE (decl) = VOIDmode;
4814   C_DECLARED_LABEL_FLAG (decl) = local_p;
4815
4816   /* Say where one reference is to the label, for the sake of the
4817      error if it is not defined.  */
4818   DECL_SOURCE_LINE (decl) = lineno;
4819   DECL_SOURCE_FILE (decl) = input_filename;
4820
4821   /* Record the fact that this identifier is bound to this label.  */
4822   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4823
4824   return decl;
4825 }
4826
4827 /* Record this label on the list of used labels so that we can check
4828    at the end of the function to see whether or not the label was
4829    actually defined, and so we can check when the label is defined whether
4830    this use is valid.  */
4831
4832 static void
4833 use_label (decl)
4834      tree decl;
4835 {
4836   if (named_label_uses == NULL
4837       || named_label_uses->names_in_scope != current_binding_level->names
4838       || named_label_uses->label_decl != decl)
4839     {
4840       struct named_label_use_list *new_ent;
4841       new_ent = ((struct named_label_use_list *)
4842                  ggc_alloc (sizeof (struct named_label_use_list)));
4843       new_ent->label_decl = decl;
4844       new_ent->names_in_scope = current_binding_level->names;
4845       new_ent->binding_level = current_binding_level;
4846       new_ent->lineno_o_goto = lineno;
4847       new_ent->filename_o_goto = input_filename;
4848       new_ent->next = named_label_uses;
4849       named_label_uses = new_ent;
4850     }
4851 }
4852
4853 /* Look for a label named ID in the current function.  If one cannot
4854    be found, create one.  (We keep track of used, but undefined,
4855    labels, and complain about them at the end of a function.)  */
4856
4857 tree
4858 lookup_label (id)
4859      tree id;
4860 {
4861   tree decl;
4862   struct named_label_list *ent;
4863
4864   /* You can't use labels at global scope.  */
4865   if (current_function_decl == NULL_TREE)
4866     {
4867       error ("label `%s' referenced outside of any function",
4868              IDENTIFIER_POINTER (id));
4869       return NULL_TREE;
4870     }
4871
4872   /* See if we've already got this label.  */
4873   decl = IDENTIFIER_LABEL_VALUE (id);
4874   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4875     return decl;
4876
4877   /* Record this label on the list of labels used in this function.
4878      We do this before calling make_label_decl so that we get the
4879      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4880   ent = ((struct named_label_list *)
4881          ggc_alloc_cleared (sizeof (struct named_label_list)));
4882   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4883   ent->next = named_labels;
4884   named_labels = ent;
4885
4886   /* We need a new label.  */
4887   decl = make_label_decl (id, /*local_p=*/0);
4888
4889   /* Now fill in the information we didn't have before.  */
4890   ent->label_decl = decl;
4891
4892   return decl;
4893 }
4894
4895 /* Declare a local label named ID.  */
4896
4897 tree
4898 declare_local_label (id)
4899      tree id;
4900 {
4901   tree decl;
4902
4903   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4904      this scope we can restore the old value of
4905      IDENTIFIER_TYPE_VALUE.  */
4906   current_binding_level->shadowed_labels
4907     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4908                  current_binding_level->shadowed_labels);
4909   /* Look for the label.  */
4910   decl = make_label_decl (id, /*local_p=*/1);
4911   /* Now fill in the information we didn't have before.  */
4912   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4913
4914   return decl;
4915 }
4916
4917 /* Returns nonzero if it is ill-formed to jump past the declaration of
4918    DECL.  Returns 2 if it's also a real problem.  */
4919
4920 static int
4921 decl_jump_unsafe (decl)
4922      tree decl;
4923 {
4924   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4925     return 0;
4926
4927   if (DECL_INITIAL (decl) == NULL_TREE
4928       && pod_type_p (TREE_TYPE (decl)))
4929     return 0;
4930
4931   /* This is really only important if we're crossing an initialization.
4932      The POD stuff is just pedantry; why should it matter if the class
4933      contains a field of pointer to member type?  */
4934   if (DECL_INITIAL (decl)
4935       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4936     return 2;
4937   return 1;
4938 }
4939
4940 /* Check that a single previously seen jump to a newly defined label
4941    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4942    the jump context; NAMES are the names in scope in LEVEL at the jump
4943    context; FILE and LINE are the source position of the jump or 0.  */
4944
4945 static void
4946 check_previous_goto_1 (decl, level, names, file, line)
4947      tree decl;
4948      struct binding_level *level;
4949      tree names;
4950      const char *file;
4951      int line;
4952 {
4953   int identified = 0;
4954   int saw_eh = 0;
4955   struct binding_level *b = current_binding_level;
4956   for (; b; b = b->level_chain)
4957     {
4958       tree new_decls = b->names;
4959       tree old_decls = (b == level ? names : NULL_TREE);
4960       for (; new_decls != old_decls;
4961            new_decls = TREE_CHAIN (new_decls))
4962         {
4963           int problem = decl_jump_unsafe (new_decls);
4964           if (! problem)
4965             continue;
4966
4967           if (! identified)
4968             {
4969               if (decl)
4970                 cp_pedwarn ("jump to label `%D'", decl);
4971               else
4972                 pedwarn ("jump to case label");
4973
4974               if (file)
4975                 pedwarn_with_file_and_line (file, line, "  from here");
4976               identified = 1;
4977             }
4978
4979           if (problem > 1)
4980             cp_error_at ("  crosses initialization of `%#D'",
4981                          new_decls);
4982           else
4983             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4984                            new_decls);
4985         }
4986
4987       if (b == level)
4988         break;
4989       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4990         {
4991           if (! identified)
4992             {
4993               if (decl)
4994                 cp_pedwarn ("jump to label `%D'", decl);
4995               else
4996                 pedwarn ("jump to case label");
4997
4998               if (file)
4999                 pedwarn_with_file_and_line (file, line, "  from here");
5000               identified = 1;
5001             }
5002           if (b->is_try_scope)
5003             error ("  enters try block");
5004           else
5005             error ("  enters catch block");
5006           saw_eh = 1;
5007         }
5008     }
5009 }
5010
5011 static void
5012 check_previous_goto (use)
5013      struct named_label_use_list *use;
5014 {
5015   check_previous_goto_1 (use->label_decl, use->binding_level,
5016                          use->names_in_scope, use->filename_o_goto,
5017                          use->lineno_o_goto);
5018 }
5019
5020 static void
5021 check_switch_goto (level)
5022      struct binding_level *level;
5023 {
5024   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5025 }
5026
5027 /* Check that any previously seen jumps to a newly defined label DECL
5028    are OK.  Called by define_label.  */
5029
5030 static void
5031 check_previous_gotos (decl)
5032      tree decl;
5033 {
5034   struct named_label_use_list **usep;
5035
5036   if (! TREE_USED (decl))
5037     return;
5038
5039   for (usep = &named_label_uses; *usep; )
5040     {
5041       struct named_label_use_list *use = *usep;
5042       if (use->label_decl == decl)
5043         {
5044           check_previous_goto (use);
5045           *usep = use->next;
5046         }
5047       else
5048         usep = &(use->next);
5049     }
5050 }
5051
5052 /* Check that a new jump to a label DECL is OK.  Called by
5053    finish_goto_stmt.  */
5054
5055 void
5056 check_goto (decl)
5057      tree decl;
5058 {
5059   int identified = 0;
5060   tree bad;
5061   struct named_label_list *lab;
5062
5063   /* We can't know where a computed goto is jumping.  So we assume
5064      that it's OK.  */
5065   if (! DECL_P (decl))
5066     return;
5067
5068   /* If the label hasn't been defined yet, defer checking.  */
5069   if (! DECL_INITIAL (decl))
5070     {
5071       use_label (decl);
5072       return;
5073     }
5074
5075   for (lab = named_labels; lab; lab = lab->next)
5076     if (decl == lab->label_decl)
5077       break;
5078
5079   /* If the label is not on named_labels it's a gcc local label, so
5080      it must be in an outer scope, so jumping to it is always OK.  */
5081   if (lab == 0)
5082     return;
5083
5084   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5085       && !identified)
5086     {
5087       cp_pedwarn_at ("jump to label `%D'", decl);
5088       pedwarn ("  from here");
5089       identified = 1;
5090     }
5091
5092   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5093     {
5094       tree b = TREE_VALUE (bad);
5095       int u = decl_jump_unsafe (b);
5096
5097       if (u > 1 && DECL_ARTIFICIAL (b))
5098         /* Can't skip init of __exception_info.  */
5099         cp_error_at ("  enters catch block", b);
5100       else if (u > 1)
5101         cp_error_at ("  skips initialization of `%#D'", b);
5102       else
5103         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5104     }
5105
5106   if (lab->in_try_scope)
5107     error ("  enters try block");
5108   else if (lab->in_catch_scope)
5109     error ("  enters catch block");
5110 }
5111
5112 /* Define a label, specifying the location in the source file.
5113    Return the LABEL_DECL node for the label, if the definition is valid.
5114    Otherwise return 0.  */
5115
5116 tree
5117 define_label (filename, line, name)
5118      const char *filename;
5119      int line;
5120      tree name;
5121 {
5122   tree decl = lookup_label (name);
5123   struct named_label_list *ent;
5124   register struct binding_level *p;
5125
5126   for (ent = named_labels; ent; ent = ent->next)
5127     if (ent->label_decl == decl)
5128       break;
5129
5130   /* After labels, make any new cleanups in the function go into their
5131      own new (temporary) binding contour.  */
5132   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5133     p->more_cleanups_ok = 0;
5134
5135   if (name == get_identifier ("wchar_t"))
5136     cp_pedwarn ("label named wchar_t");
5137
5138   if (DECL_INITIAL (decl) != NULL_TREE)
5139     {
5140       cp_error ("duplicate label `%D'", decl);
5141       return 0;
5142     }
5143   else
5144     {
5145       /* Mark label as having been defined.  */
5146       DECL_INITIAL (decl) = error_mark_node;
5147       /* Say where in the source.  */
5148       DECL_SOURCE_FILE (decl) = filename;
5149       DECL_SOURCE_LINE (decl) = line;
5150       if (ent)
5151         {
5152           ent->names_in_scope = current_binding_level->names;
5153           ent->binding_level = current_binding_level;
5154         }
5155       check_previous_gotos (decl);
5156       current_function_return_value = NULL_TREE;
5157       return decl;
5158     }
5159 }
5160
5161 struct cp_switch
5162 {
5163   struct binding_level *level;
5164   struct cp_switch *next;
5165   /* The SWITCH_STMT being built.  */
5166   tree switch_stmt;
5167   /* A splay-tree mapping the low element of a case range to the high
5168      element, or NULL_TREE if there is no high element.  Used to
5169      determine whether or not a new case label duplicates an old case
5170      label.  We need a tree, rather than simply a hash table, because
5171      of the GNU case range extension.  */
5172   splay_tree cases;
5173 };
5174
5175 /* A stack of the currently active switch statements.  The innermost
5176    switch statement is on the top of the stack.  There is no need to
5177    mark the stack for garbage collection because it is only active
5178    during the processing of the body of a function, and we never
5179    collect at that point.  */
5180
5181 static struct cp_switch *switch_stack;
5182
5183 /* Called right after a switch-statement condition is parsed.
5184    SWITCH_STMT is the switch statement being parsed.  */
5185
5186 void
5187 push_switch (switch_stmt)
5188      tree switch_stmt;
5189 {
5190   struct cp_switch *p
5191     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5192   p->level = current_binding_level;
5193   p->next = switch_stack;
5194   p->switch_stmt = switch_stmt;
5195   p->cases = splay_tree_new (case_compare, NULL, NULL);
5196   switch_stack = p;
5197 }
5198
5199 void
5200 pop_switch ()
5201 {
5202   struct cp_switch *cs;
5203
5204   cs = switch_stack;
5205   splay_tree_delete (cs->cases);
5206   switch_stack = switch_stack->next;
5207   free (cs);
5208 }
5209
5210 /* Note that we've seen a definition of a case label, and complain if this
5211    is a bad place for one.  */
5212
5213 tree
5214 finish_case_label (low_value, high_value)
5215      tree low_value;
5216      tree high_value;
5217 {
5218   tree cond, r;
5219   register struct binding_level *p;
5220
5221   if (! switch_stack)
5222     {
5223       if (high_value)
5224         error ("case label not within a switch statement");
5225       else if (low_value)
5226         cp_error ("case label `%E' not within a switch statement",
5227                   low_value);
5228       else
5229         error ("`default' label not within a switch statement");
5230       return NULL_TREE;
5231     }
5232
5233   if (processing_template_decl)
5234     {
5235       tree label;
5236
5237       /* For templates, just add the case label; we'll do semantic
5238          analysis at instantiation-time.  */
5239       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5240       return add_stmt (build_case_label (low_value, high_value, label));
5241     }
5242
5243   /* Find the condition on which this switch statement depends.  */
5244   cond = SWITCH_COND (switch_stack->switch_stmt);
5245   if (cond && TREE_CODE (cond) == TREE_LIST)
5246     cond = TREE_VALUE (cond);
5247
5248   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5249   if (r == error_mark_node)
5250     r = NULL_TREE;
5251
5252   check_switch_goto (switch_stack->level);
5253
5254   /* After labels, make any new cleanups in the function go into their
5255      own new (temporary) binding contour.  */
5256   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5257     p->more_cleanups_ok = 0;
5258   current_function_return_value = NULL_TREE;
5259
5260   return r;
5261 }
5262 \f
5263 /* Return the list of declarations of the current level.
5264    Note that this list is in reverse order unless/until
5265    you nreverse it; and when you do nreverse it, you must
5266    store the result back using `storedecls' or you will lose.  */
5267
5268 tree
5269 getdecls ()
5270 {
5271   return current_binding_level->names;
5272 }
5273
5274 /* Return the list of type-tags (for structs, etc) of the current level.  */
5275
5276 tree
5277 gettags ()
5278 {
5279   return current_binding_level->tags;
5280 }
5281
5282 /* Store the list of declarations of the current level.
5283    This is done for the parameter declarations of a function being defined,
5284    after they are modified in the light of any missing parameters.  */
5285
5286 static void
5287 storedecls (decls)
5288      tree decls;
5289 {
5290   current_binding_level->names = decls;
5291 }
5292
5293 /* Similarly, store the list of tags of the current level.  */
5294
5295 void
5296 storetags (tags)
5297      tree tags;
5298 {
5299   current_binding_level->tags = tags;
5300 }
5301 \f
5302 /* Given NAME, an IDENTIFIER_NODE,
5303    return the structure (or union or enum) definition for that name.
5304    Searches binding levels from BINDING_LEVEL up to the global level.
5305    If THISLEVEL_ONLY is nonzero, searches only the specified context
5306    (but skips any tag-transparent contexts to find one that is
5307    meaningful for tags).
5308    FORM says which kind of type the caller wants;
5309    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5310    If the wrong kind of type is found, and it's not a template, an error is
5311    reported.  */
5312
5313 static tree
5314 lookup_tag (form, name, binding_level, thislevel_only)
5315      enum tree_code form;
5316      tree name;
5317      struct binding_level *binding_level;
5318      int thislevel_only;
5319 {
5320   register struct binding_level *level;
5321   /* Non-zero if, we should look past a template parameter level, even
5322      if THISLEVEL_ONLY.  */
5323   int allow_template_parms_p = 1;
5324
5325   for (level = binding_level; level; level = level->level_chain)
5326     {
5327       register tree tail;
5328       if (ANON_AGGRNAME_P (name))
5329         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5330           {
5331             /* There's no need for error checking here, because
5332                anon names are unique throughout the compilation.  */
5333             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5334               return TREE_VALUE (tail);
5335           }
5336       else if (level->namespace_p)
5337         /* Do namespace lookup. */
5338         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5339           {
5340             tree old = binding_for_name (name, tail);
5341
5342             /* If we just skipped past a template parameter level,
5343                even though THISLEVEL_ONLY, and we find a template
5344                class declaration, then we use the _TYPE node for the
5345                template.  See the example below.  */
5346             if (thislevel_only && !allow_template_parms_p
5347                 && old && BINDING_VALUE (old)
5348                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5349               old = TREE_TYPE (BINDING_VALUE (old));
5350             else
5351               old = BINDING_TYPE (old);
5352
5353             /* If it has an original type, it is a typedef, and we
5354                should not return it.  */
5355             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5356               old = NULL_TREE;
5357             if (old && TREE_CODE (old) != form
5358                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5359               {
5360                 cp_error ("`%#D' redeclared as %C", old, form);
5361                 return NULL_TREE;
5362               }
5363             if (old)
5364               return old;
5365             if (thislevel_only || tail == global_namespace)
5366               return NULL_TREE;
5367           }
5368       else
5369         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5370           {
5371             if (TREE_PURPOSE (tail) == name)
5372               {
5373                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5374                 /* Should tighten this up; it'll probably permit
5375                    UNION_TYPE and a struct template, for example.  */
5376                 if (code != form
5377                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5378                   {
5379                     /* Definition isn't the kind we were looking for.  */
5380                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5381                               form);
5382                     return NULL_TREE;
5383                   }
5384                 return TREE_VALUE (tail);
5385               }
5386           }
5387       if (thislevel_only && ! level->tag_transparent)
5388         {
5389           if (level->template_parms_p && allow_template_parms_p)
5390             {
5391               /* We must deal with cases like this:
5392
5393                    template <class T> struct S;
5394                    template <class T> struct S {};
5395
5396                  When looking up `S', for the second declaration, we
5397                  would like to find the first declaration.  But, we
5398                  are in the pseudo-global level created for the
5399                  template parameters, rather than the (surrounding)
5400                  namespace level.  Thus, we keep going one more level,
5401                  even though THISLEVEL_ONLY is non-zero.  */
5402               allow_template_parms_p = 0;
5403               continue;
5404             }
5405           else
5406             return NULL_TREE;
5407         }
5408     }
5409   return NULL_TREE;
5410 }
5411
5412 #if 0
5413 void
5414 set_current_level_tags_transparency (tags_transparent)
5415      int tags_transparent;
5416 {
5417   current_binding_level->tag_transparent = tags_transparent;
5418 }
5419 #endif
5420
5421 /* Given a type, find the tag that was defined for it and return the tag name.
5422    Otherwise return 0.  However, the value can never be 0
5423    in the cases in which this is used.
5424
5425    C++: If NAME is non-zero, this is the new name to install.  This is
5426    done when replacing anonymous tags with real tag names.  */
5427
5428 static tree
5429 lookup_tag_reverse (type, name)
5430      tree type;
5431      tree name;
5432 {
5433   register struct binding_level *level;
5434
5435   for (level = current_binding_level; level; level = level->level_chain)
5436     {
5437       register tree tail;
5438       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5439         {
5440           if (TREE_VALUE (tail) == type)
5441             {
5442               if (name)
5443                 TREE_PURPOSE (tail) = name;
5444               return TREE_PURPOSE (tail);
5445             }
5446         }
5447     }
5448   return NULL_TREE;
5449 }
5450 \f
5451 /* Look up NAME in the NAMESPACE.  */
5452
5453 tree
5454 lookup_namespace_name (namespace, name)
5455      tree namespace, name;
5456 {
5457   tree val;
5458   tree template_id = NULL_TREE;
5459
5460   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5461
5462   if (TREE_CODE (name) == NAMESPACE_DECL)
5463     /* This happens for A::B<int> when B is a namespace. */
5464     return name;
5465   else if (TREE_CODE (name) == TEMPLATE_DECL)
5466     {
5467       /* This happens for A::B where B is a template, and there are no
5468          template arguments.  */
5469       cp_error ("invalid use of `%D'", name);
5470       return error_mark_node;
5471     }
5472
5473   namespace = ORIGINAL_NAMESPACE (namespace);
5474
5475   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5476     {
5477       template_id = name;
5478       name = TREE_OPERAND (name, 0);
5479       if (TREE_CODE (name) == OVERLOAD)
5480         name = DECL_NAME (OVL_CURRENT (name));
5481       else if (DECL_P (name))
5482         name = DECL_NAME (name);
5483     }
5484
5485   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5486
5487   val = make_node (CPLUS_BINDING);
5488   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5489     return error_mark_node;
5490
5491   if (BINDING_VALUE (val))
5492     {
5493       val = BINDING_VALUE (val);
5494
5495       if (template_id)
5496         {
5497           if (DECL_CLASS_TEMPLATE_P (val))
5498             val = lookup_template_class (val,
5499                                          TREE_OPERAND (template_id, 1),
5500                                          /*in_decl=*/NULL_TREE,
5501                                          /*context=*/NULL_TREE,
5502                                          /*entering_scope=*/0,
5503                                          /*complain=*/1);
5504           else if (DECL_FUNCTION_TEMPLATE_P (val)
5505                    || TREE_CODE (val) == OVERLOAD)
5506             val = lookup_template_function (val,
5507                                             TREE_OPERAND (template_id, 1));
5508           else
5509             {
5510               cp_error ("`%D::%D' is not a template",
5511                         namespace, name);
5512               return error_mark_node;
5513             }
5514         }
5515
5516       /* If we have a single function from a using decl, pull it out.  */
5517       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5518         val = OVL_FUNCTION (val);
5519       return val;
5520     }
5521
5522   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5523   return error_mark_node;
5524 }
5525
5526 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5527
5528 static unsigned long
5529 typename_hash (k)
5530      hash_table_key k;
5531 {
5532   unsigned long hash;
5533   tree t;
5534
5535   t = (tree) k;
5536   hash = (((unsigned long) TYPE_CONTEXT (t))
5537           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5538
5539   return hash;
5540 }
5541
5542 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5543
5544 static bool
5545 typename_compare (k1, k2)
5546      hash_table_key k1;
5547      hash_table_key k2;
5548 {
5549   tree t1;
5550   tree t2;
5551   tree d1;
5552   tree d2;
5553
5554   t1 = (tree) k1;
5555   t2 = (tree) k2;
5556   d1 = TYPE_NAME (t1);
5557   d2 = TYPE_NAME (t2);
5558
5559   return (DECL_NAME (d1) == DECL_NAME (d2)
5560           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5561           && ((TREE_TYPE (t1) != NULL_TREE)
5562               == (TREE_TYPE (t2) != NULL_TREE))
5563           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5564           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5565 }
5566
5567 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5568    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5569    is non-NULL, this type is being created by the implicit typename
5570    extension, and BASE_TYPE is a type named `t' in some base class of
5571    `T' which depends on template parameters.
5572
5573    Returns the new TYPENAME_TYPE.  */
5574
5575 tree
5576 build_typename_type (context, name, fullname, base_type)
5577      tree context;
5578      tree name;
5579      tree fullname;
5580      tree base_type;
5581 {
5582   tree t;
5583   tree d;
5584   struct hash_entry *e;
5585
5586   static struct hash_table ht;
5587
5588   if (!ht.table)
5589     {
5590       static struct hash_table *h = &ht;
5591
5592       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5593       ggc_add_tree_hash_table_root (&h, 1);
5594     }
5595
5596   /* Build the TYPENAME_TYPE.  */
5597   t = make_aggr_type (TYPENAME_TYPE);
5598   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5599   TYPENAME_TYPE_FULLNAME (t) = fullname;
5600   TREE_TYPE (t) = base_type;
5601
5602   /* Build the corresponding TYPE_DECL.  */
5603   d = build_decl (TYPE_DECL, name, t);
5604   TYPE_NAME (TREE_TYPE (d)) = d;
5605   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5606   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5607   DECL_ARTIFICIAL (d) = 1;
5608
5609   /* See if we already have this type.  */
5610   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5611   if (e)
5612     t = (tree) e->key;
5613   else
5614     /* Insert the type into the table.  */
5615     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5616
5617   return t;
5618 }
5619
5620 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5621    unless an error occurs, in which case error_mark_node is returned.
5622    If COMPLAIN zero, don't complain about any errors that occur.  */
5623
5624 tree
5625 make_typename_type (context, name, complain)
5626      tree context, name;
5627      int complain;
5628 {
5629   tree fullname;
5630
5631   if (TYPE_P (name))
5632     {
5633       if (!(TYPE_LANG_SPECIFIC (name)
5634             && (CLASSTYPE_IS_TEMPLATE (name)
5635                 || CLASSTYPE_USE_TEMPLATE (name))))
5636         name = TYPE_IDENTIFIER (name);
5637       else
5638         /* Create a TEMPLATE_ID_EXPR for the type.  */
5639         name = build_nt (TEMPLATE_ID_EXPR,
5640                          CLASSTYPE_TI_TEMPLATE (name),
5641                          CLASSTYPE_TI_ARGS (name));
5642     }
5643   else if (TREE_CODE (name) == TYPE_DECL)
5644     name = DECL_NAME (name);
5645
5646   fullname = name;
5647
5648   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5649     {
5650       name = TREE_OPERAND (name, 0);
5651       if (TREE_CODE (name) == TEMPLATE_DECL)
5652         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5653     }
5654   if (TREE_CODE (name) != IDENTIFIER_NODE)
5655     my_friendly_abort (2000);
5656
5657   if (TREE_CODE (context) == NAMESPACE_DECL)
5658     {
5659       /* We can get here from typename_sub0 in the explicit_template_type
5660          expansion.  Just fail.  */
5661       if (complain)
5662         cp_error ("no class template named `%#T' in `%#T'",
5663                   name, context);
5664       return error_mark_node;
5665     }
5666
5667   if (! uses_template_parms (context)
5668       || currently_open_class (context))
5669     {
5670       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5671         {
5672           tree tmpl = NULL_TREE;
5673           if (IS_AGGR_TYPE (context))
5674             tmpl = lookup_field (context, name, 0, 0);
5675           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5676             {
5677               if (complain)
5678                 cp_error ("no class template named `%#T' in `%#T'",
5679                           name, context);
5680               return error_mark_node;
5681             }
5682
5683           return lookup_template_class (tmpl,
5684                                         TREE_OPERAND (fullname, 1),
5685                                         NULL_TREE, context,
5686                                         /*entering_scope=*/0,
5687                                         /*complain=*/1);
5688         }
5689       else
5690         {
5691           tree t;
5692
5693           if (!IS_AGGR_TYPE (context))
5694             {
5695               if (complain)
5696                 cp_error ("no type named `%#T' in `%#T'", name, context);
5697               return error_mark_node;
5698             }
5699
5700           t = lookup_field (context, name, 0, 1);
5701           if (t)
5702             return TREE_TYPE (t);
5703         }
5704     }
5705
5706   /* If the CONTEXT is not a template type, then either the field is
5707      there now or its never going to be.  */
5708   if (!uses_template_parms (context))
5709     {
5710       if (complain)
5711         cp_error ("no type named `%#T' in `%#T'", name, context);
5712       return error_mark_node;
5713     }
5714
5715
5716   return build_typename_type (context, name, fullname,  NULL_TREE);
5717 }
5718
5719 /* Select the right _DECL from multiple choices. */
5720
5721 static tree
5722 select_decl (binding, flags)
5723      tree binding;
5724      int flags;
5725 {
5726   tree val;
5727   val = BINDING_VALUE (binding);
5728
5729   /* When we implicitly declare some builtin entity, we mark it
5730      DECL_ANTICIPATED, so that we know to ignore it until it is
5731      really declared.  */
5732   if (val && DECL_P (val)
5733       && DECL_LANG_SPECIFIC (val)
5734       && DECL_ANTICIPATED (val))
5735     return NULL_TREE;
5736
5737   if (LOOKUP_NAMESPACES_ONLY (flags))
5738     {
5739       /* We are not interested in types. */
5740       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5741         return val;
5742       return NULL_TREE;
5743     }
5744
5745   /* If we could have a type and
5746      we have nothing or we need a type and have none.  */
5747   if (BINDING_TYPE (binding)
5748       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5749                    && TREE_CODE (val) != TYPE_DECL)))
5750     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5751   /* Don't return non-types if we really prefer types. */
5752   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5753            && (TREE_CODE (val) != TEMPLATE_DECL
5754                || !DECL_CLASS_TEMPLATE_P (val)))
5755     val = NULL_TREE;
5756
5757   return val;
5758 }
5759
5760 /* Unscoped lookup of a global: iterate over current namespaces,
5761    considering using-directives.  If SPACESP is non-NULL, store a list
5762    of the namespaces we've considered in it.  */
5763
5764 tree
5765 unqualified_namespace_lookup (name, flags, spacesp)
5766      tree name;
5767      int flags;
5768      tree *spacesp;
5769 {
5770   tree b = make_node (CPLUS_BINDING);
5771   tree initial = current_decl_namespace ();
5772   tree scope = initial;
5773   tree siter;
5774   struct binding_level *level;
5775   tree val = NULL_TREE;
5776
5777   if (spacesp)
5778     *spacesp = NULL_TREE;
5779
5780   for (; !val; scope = CP_DECL_CONTEXT (scope))
5781     {
5782       if (spacesp)
5783         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5784       val = binding_for_name (name, scope);
5785
5786       /* Initialize binding for this context. */
5787       BINDING_VALUE (b) = BINDING_VALUE (val);
5788       BINDING_TYPE (b) = BINDING_TYPE (val);
5789
5790       /* Add all _DECLs seen through local using-directives. */
5791       for (level = current_binding_level;
5792            !level->namespace_p;
5793            level = level->level_chain)
5794         if (!lookup_using_namespace (name, b, level->using_directives,
5795                                      scope, flags, spacesp))
5796           /* Give up because of error. */
5797           return error_mark_node;
5798
5799       /* Add all _DECLs seen through global using-directives. */
5800       /* XXX local and global using lists should work equally. */
5801       siter = initial;
5802       while (1)
5803         {
5804           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5805                                        scope, flags, spacesp))
5806             /* Give up because of error. */
5807             return error_mark_node;
5808           if (siter == scope) break;
5809           siter = CP_DECL_CONTEXT (siter);
5810         }
5811
5812       val = select_decl (b, flags);
5813       if (scope == global_namespace)
5814         break;
5815     }
5816   return val;
5817 }
5818
5819 /* Combine prefer_type and namespaces_only into flags.  */
5820
5821 static int
5822 lookup_flags (prefer_type, namespaces_only)
5823   int prefer_type, namespaces_only;
5824 {
5825   if (namespaces_only)
5826     return LOOKUP_PREFER_NAMESPACES;
5827   if (prefer_type > 1)
5828     return LOOKUP_PREFER_TYPES;
5829   if (prefer_type > 0)
5830     return LOOKUP_PREFER_BOTH;
5831   return 0;
5832 }
5833
5834 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5835    ignore it or not.  Subroutine of lookup_name_real.  */
5836
5837 static tree
5838 qualify_lookup (val, flags)
5839      tree val;
5840      int flags;
5841 {
5842   if (val == NULL_TREE)
5843     return val;
5844   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5845     return val;
5846   if ((flags & LOOKUP_PREFER_TYPES)
5847       && (TREE_CODE (val) == TYPE_DECL
5848           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5849               && DECL_CLASS_TEMPLATE_P (val))))
5850     return val;
5851   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5852     return NULL_TREE;
5853   return val;
5854 }
5855
5856 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5857    that.  */
5858
5859 static void
5860 warn_about_implicit_typename_lookup (typename, binding)
5861      tree typename;
5862      tree binding;
5863 {
5864   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5865   tree name = DECL_NAME (typename);
5866
5867   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5868          && CLASSTYPE_TEMPLATE_INFO (subtype)
5869          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5870       && ! (TREE_CODE (binding) == TYPE_DECL
5871             && same_type_p (TREE_TYPE (binding), subtype)))
5872     {
5873       cp_warning ("lookup of `%D' finds `%#D'",
5874                   name, binding);
5875       cp_warning ("  instead of `%D' from dependent base class",
5876                   typename);
5877       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5878                   constructor_name (current_class_type), name);
5879     }
5880 }
5881
5882 /* Look up NAME in the current binding level and its superiors in the
5883    namespace of variables, functions and typedefs.  Return a ..._DECL
5884    node of some kind representing its definition if there is only one
5885    such declaration, or return a TREE_LIST with all the overloaded
5886    definitions if there are many, or return 0 if it is undefined.
5887
5888    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5889    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5890    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5891    Otherwise we prefer non-TYPE_DECLs.
5892
5893    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5894    using IDENTIFIER_CLASS_VALUE.  */
5895
5896 static tree
5897 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5898      tree name;
5899      int prefer_type, nonclass, namespaces_only;
5900 {
5901   tree t;
5902   tree val = NULL_TREE;
5903   int yylex = 0;
5904   tree from_obj = NULL_TREE;
5905   int flags;
5906   int val_is_implicit_typename = 0;
5907
5908   /* Hack: copy flag set by parser, if set. */
5909   if (only_namespace_names)
5910     namespaces_only = 1;
5911
5912   if (prefer_type == -2)
5913     {
5914       extern int looking_for_typename;
5915       tree type = NULL_TREE;
5916
5917       yylex = 1;
5918       prefer_type = looking_for_typename;
5919
5920       flags = lookup_flags (prefer_type, namespaces_only);
5921       /* If the next thing is '<', class templates are types. */
5922       if (looking_for_template)
5923         flags |= LOOKUP_TEMPLATES_EXPECTED;
5924
5925       /* std:: becomes :: for now.  */
5926       if (got_scope && got_scope == fake_std_node)
5927         got_scope = void_type_node;
5928
5929       if (got_scope)
5930         type = got_scope;
5931       else if (got_object != error_mark_node)
5932         type = got_object;
5933
5934       if (type)
5935         {
5936           if (type == error_mark_node)
5937             return error_mark_node;
5938           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5939             type = TREE_TYPE (type);
5940
5941           if (TYPE_P (type))
5942             type = complete_type (type);
5943
5944           if (TREE_CODE (type) == VOID_TYPE)
5945             type = global_namespace;
5946           if (TREE_CODE (type) == NAMESPACE_DECL)
5947             {
5948               val = make_node (CPLUS_BINDING);
5949               flags |= LOOKUP_COMPLAIN;
5950               if (!qualified_lookup_using_namespace (name, type, val, flags))
5951                 return NULL_TREE;
5952               val = select_decl (val, flags);
5953             }
5954           else if (! IS_AGGR_TYPE (type)
5955                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5956                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5957                    || TREE_CODE (type) == TYPENAME_TYPE)
5958             /* Someone else will give an error about this if needed.  */
5959             val = NULL_TREE;
5960           else if (type == current_class_type)
5961             val = IDENTIFIER_CLASS_VALUE (name);
5962           else
5963             {
5964               val = lookup_member (type, name, 0, prefer_type);
5965               type_access_control (type, val);
5966
5967               /* Restore the containing TYPENAME_TYPE if we looked
5968                  through it before.  */
5969               if (got_scope && got_scope != type
5970                   && val && TREE_CODE (val) == TYPE_DECL
5971                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5972                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5973             }
5974         }
5975       else
5976         val = NULL_TREE;
5977
5978       if (got_scope)
5979         goto done;
5980       else if (got_object && val)
5981         {
5982           from_obj = val;
5983           val = NULL_TREE;
5984         }
5985     }
5986   else
5987     {
5988       flags = lookup_flags (prefer_type, namespaces_only);
5989       /* If we're not parsing, we need to complain. */
5990       flags |= LOOKUP_COMPLAIN;
5991     }
5992
5993   /* First, look in non-namespace scopes.  */
5994
5995   if (current_class_type == NULL_TREE)
5996     nonclass = 1;
5997
5998   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5999     {
6000       tree binding;
6001
6002       if (!LOCAL_BINDING_P (t) && nonclass)
6003         /* We're not looking for class-scoped bindings, so keep going.  */
6004         continue;
6005
6006       /* If this is the kind of thing we're looking for, we're done.  */
6007       if (qualify_lookup (BINDING_VALUE (t), flags))
6008         binding = BINDING_VALUE (t);
6009       else if ((flags & LOOKUP_PREFER_TYPES)
6010                && qualify_lookup (BINDING_TYPE (t), flags))
6011         binding = BINDING_TYPE (t);
6012       else
6013         binding = NULL_TREE;
6014
6015       /* Handle access control on types from enclosing or base classes.  */
6016       if (binding && ! yylex
6017           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6018         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6019
6020       if (binding
6021           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6022         {
6023           if (val_is_implicit_typename && !yylex)
6024             warn_about_implicit_typename_lookup (val, binding);
6025           val = binding;
6026           val_is_implicit_typename
6027             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6028           if (!val_is_implicit_typename)
6029             break;
6030         }
6031     }
6032
6033   /* Now lookup in namespace scopes.  */
6034   if (!val || val_is_implicit_typename)
6035     {
6036       t = unqualified_namespace_lookup (name, flags, 0);
6037       if (t)
6038         {
6039           if (val_is_implicit_typename && !yylex)
6040             warn_about_implicit_typename_lookup (val, t);
6041           val = t;
6042         }
6043     }
6044
6045  done:
6046   if (val)
6047     {
6048       /* This should only warn about types used in qualified-ids.  */
6049       if (from_obj && from_obj != val)
6050         {
6051           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6052               && TREE_CODE (val) == TYPE_DECL
6053               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6054             cp_pedwarn ("\
6055 lookup of `%D' in the scope of `%#T' (`%#D') \
6056 does not match lookup in the current scope (`%#D')",
6057                         name, got_object, from_obj, val);
6058
6059           /* We don't change val to from_obj if got_object depends on
6060              template parms because that breaks implicit typename for
6061              destructor calls.  */
6062           if (! uses_template_parms (got_object))
6063             val = from_obj;
6064         }
6065
6066       /* If we have a single function from a using decl, pull it out.  */
6067       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6068         val = OVL_FUNCTION (val);
6069     }
6070   else if (from_obj)
6071     val = from_obj;
6072
6073   return val;
6074 }
6075
6076 tree
6077 lookup_name_nonclass (name)
6078      tree name;
6079 {
6080   return lookup_name_real (name, 0, 1, 0);
6081 }
6082
6083 tree
6084 lookup_function_nonclass (name, args)
6085      tree name;
6086      tree args;
6087 {
6088   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6089 }
6090
6091 tree
6092 lookup_name_namespace_only (name)
6093      tree name;
6094 {
6095   /* type-or-namespace, nonclass, namespace_only */
6096   return lookup_name_real (name, 1, 1, 1);
6097 }
6098
6099 tree
6100 lookup_name (name, prefer_type)
6101      tree name;
6102      int prefer_type;
6103 {
6104   return lookup_name_real (name, prefer_type, 0, 0);
6105 }
6106
6107 /* Similar to `lookup_name' but look only in the innermost non-class
6108    binding level.  */
6109
6110 tree
6111 lookup_name_current_level (name)
6112      tree name;
6113 {
6114   struct binding_level *b;
6115   tree t = NULL_TREE;
6116
6117   b = current_binding_level;
6118   while (b->parm_flag == 2)
6119     b = b->level_chain;
6120
6121   if (b->namespace_p)
6122     {
6123       t = IDENTIFIER_NAMESPACE_VALUE (name);
6124
6125       /* extern "C" function() */
6126       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6127         t = TREE_VALUE (t);
6128     }
6129   else if (IDENTIFIER_BINDING (name)
6130            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6131     {
6132       while (1)
6133         {
6134           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6135             return IDENTIFIER_VALUE (name);
6136
6137           if (b->keep == 2)
6138             b = b->level_chain;
6139           else
6140             break;
6141         }
6142     }
6143
6144   return t;
6145 }
6146
6147 /* Like lookup_name_current_level, but for types.  */
6148
6149 tree
6150 lookup_type_current_level (name)
6151      tree name;
6152 {
6153   register tree t = NULL_TREE;
6154
6155   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6156
6157   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6158       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6159     {
6160       struct binding_level *b = current_binding_level;
6161       while (1)
6162         {
6163           if (purpose_member (name, b->type_shadowed))
6164             return REAL_IDENTIFIER_TYPE_VALUE (name);
6165           if (b->keep == 2)
6166             b = b->level_chain;
6167           else
6168             break;
6169         }
6170     }
6171
6172   return t;
6173 }
6174
6175 void
6176 begin_only_namespace_names ()
6177 {
6178   only_namespace_names = 1;
6179 }
6180
6181 void
6182 end_only_namespace_names ()
6183 {
6184   only_namespace_names = 0;
6185 }
6186 \f
6187 /* Push the declarations of builtin types into the namespace.
6188    RID_INDEX is the index of the builtin type
6189    in the array RID_POINTERS.  NAME is the name used when looking
6190    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6191
6192 void
6193 record_builtin_type (rid_index, name, type)
6194      enum rid rid_index;
6195      const char *name;
6196      tree type;
6197 {
6198   tree rname = NULL_TREE, tname = NULL_TREE;
6199   tree tdecl = NULL_TREE;
6200
6201   if ((int) rid_index < (int) RID_MAX)
6202     rname = ridpointers[(int) rid_index];
6203   if (name)
6204     tname = get_identifier (name);
6205
6206   TYPE_BUILT_IN (type) = 1;
6207
6208   if (tname)
6209     {
6210       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6211       set_identifier_type_value (tname, NULL_TREE);
6212       if ((int) rid_index < (int) RID_MAX)
6213         /* Built-in types live in the global namespace. */
6214         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6215     }
6216   if (rname != NULL_TREE)
6217     {
6218       if (tname != NULL_TREE)
6219         {
6220           set_identifier_type_value (rname, NULL_TREE);
6221           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6222         }
6223       else
6224         {
6225           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6226           set_identifier_type_value (rname, NULL_TREE);
6227         }
6228     }
6229 }
6230
6231 /* Record one of the standard Java types.
6232  * Declare it as having the given NAME.
6233  * If SIZE > 0, it is the size of one of the integral types;
6234  * otherwise it is the negative of the size of one of the other types.  */
6235
6236 static tree
6237 record_builtin_java_type (name, size)
6238      const char *name;
6239      int size;
6240 {
6241   tree type, decl;
6242   if (size > 0)
6243     type = make_signed_type (size);
6244   else if (size > -32)
6245     { /* "__java_char" or ""__java_boolean". */
6246       type = make_unsigned_type (-size);
6247       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6248     }
6249   else
6250     { /* "__java_float" or ""__java_double". */
6251       type = make_node (REAL_TYPE);
6252       TYPE_PRECISION (type) = - size;
6253       layout_type (type);
6254     }
6255   record_builtin_type (RID_MAX, name, type);
6256   decl = TYPE_NAME (type);
6257
6258   /* Suppress generate debug symbol entries for these types,
6259      since for normal C++ they are just clutter.
6260      However, push_lang_context undoes this if extern "Java" is seen. */
6261   DECL_IGNORED_P (decl) = 1;
6262
6263   TYPE_FOR_JAVA (type) = 1;
6264   return type;
6265 }
6266
6267 /* Push a type into the namespace so that the back-ends ignore it. */
6268
6269 static void
6270 record_unknown_type (type, name)
6271      tree type;
6272      const char *name;
6273 {
6274   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6275   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6276   DECL_IGNORED_P (decl) = 1;
6277   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6278   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6279   TYPE_ALIGN (type) = 1;
6280   TYPE_USER_ALIGN (type) = 0;
6281   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6282 }
6283
6284 /* An string for which we should create an IDENTIFIER_NODE at
6285    startup.  */
6286
6287 typedef struct predefined_identifier
6288 {
6289   /* The name of the identifier.  */
6290   const char *name;
6291   /* The place where the IDENTIFIER_NODE should be stored.  */
6292   tree *node;
6293   /* Non-zero if this is the name of a constructor or destructor.  */
6294   int ctor_or_dtor_p;
6295 } predefined_identifier;
6296
6297 /* Create all the predefined identifiers.  */
6298
6299 static void
6300 initialize_predefined_identifiers ()
6301 {
6302   struct predefined_identifier *pid;
6303
6304   /* A table of identifiers to create at startup.  */
6305   static predefined_identifier predefined_identifiers[] = {
6306     { "C++", &lang_name_cplusplus, 0 },
6307     { "C", &lang_name_c, 0 },
6308     { "Java", &lang_name_java, 0 },
6309     { CTOR_NAME, &ctor_identifier, 1 },
6310     { "__base_ctor", &base_ctor_identifier, 1 },
6311     { "__comp_ctor", &complete_ctor_identifier, 1 },
6312     { DTOR_NAME, &dtor_identifier, 1 },
6313     { "__comp_dtor", &complete_dtor_identifier, 1 },
6314     { "__base_dtor", &base_dtor_identifier, 1 },
6315     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6316     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6317     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6318     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6319     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6320     { "nelts", &nelts_identifier, 0 },
6321     { THIS_NAME, &this_identifier, 0 },
6322     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6323     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6324     { "_vptr", &vptr_identifier, 0 },
6325     { "__vtt_parm", &vtt_parm_identifier, 0 },
6326     { "std", &std_identifier, 0 },
6327     { NULL, NULL, 0 }
6328   };
6329
6330   for (pid = predefined_identifiers; pid->name; ++pid)
6331     {
6332       *pid->node = get_identifier (pid->name);
6333       if (pid->ctor_or_dtor_p)
6334         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6335     }
6336 }
6337
6338 /* Create the predefined scalar types of C,
6339    and some nodes representing standard constants (0, 1, (void *)0).
6340    Initialize the global binding level.
6341    Make definitions for built-in primitive functions.  */
6342
6343 void
6344 init_decl_processing ()
6345 {
6346   tree fields[20];
6347   tree void_ftype;
6348   tree void_ftype_ptr;
6349
6350   /* Check to see that the user did not specify an invalid combination
6351      of command-line options.  */
6352   if (!flag_vtable_thunks)
6353     error ("the ABI requires vtable thunks");
6354
6355   /* Create all the identifiers we need.  */
6356   initialize_predefined_identifiers ();
6357
6358   /* Fill in back-end hooks.  */
6359   init_lang_status = &push_cp_function_context;
6360   free_lang_status = &pop_cp_function_context;
6361   mark_lang_status = &mark_cp_function_context;
6362   lang_safe_from_p = &c_safe_from_p;
6363   lang_dump_tree = &cp_dump_tree;
6364   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6365
6366   cp_parse_init ();
6367   init_decl2 ();
6368   init_pt ();
6369
6370   /* Create the global variables.  */
6371   push_to_top_level ();
6372
6373   /* Enter the global namespace. */
6374   my_friendly_assert (global_namespace == NULL_TREE, 375);
6375   push_namespace (get_identifier ("::"));
6376   global_namespace = current_namespace;
6377   current_lang_name = NULL_TREE;
6378
6379   /* Adjust various flags based on command-line settings.  */
6380   if (! flag_permissive && ! pedantic)
6381     flag_pedantic_errors = 1;
6382   if (!flag_no_inline)
6383     {
6384       flag_inline_trees = 1;
6385       flag_no_inline = 1;
6386     }
6387   if (flag_inline_functions)
6388     {
6389       flag_inline_trees = 2;
6390       flag_inline_functions = 0;
6391     }
6392
6393   /* In C++, we never create builtin functions whose name does not
6394      begin with `__'.  Users should be using headers to get prototypes
6395      in C++.  It would be nice if we could warn when `-fbuiltin' is
6396      used explicitly, but we do not have that information.  */
6397   flag_no_builtin = 1;
6398
6399   /* Initially, C.  */
6400   current_lang_name = lang_name_c;
6401
6402   current_function_decl = NULL_TREE;
6403   current_binding_level = NULL_BINDING_LEVEL;
6404   free_binding_level = NULL_BINDING_LEVEL;
6405
6406   build_common_tree_nodes (flag_signed_char);
6407
6408   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6409   TREE_TYPE (error_mark_list) = error_mark_node;
6410
6411   /* Make the binding_level structure for global names.  */
6412   pushlevel (0);
6413   global_binding_level = current_binding_level;
6414   /* The global level is the namespace level of ::.  */
6415   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6416   declare_namespace_level ();
6417
6418   /* Create the `std' namespace.  */
6419   if (flag_honor_std)
6420     {
6421       push_namespace (std_identifier);
6422       std_node = current_namespace;
6423       pop_namespace ();
6424       fake_std_node = error_mark_node;
6425     }
6426   else
6427     {
6428       fake_std_node = build_decl (NAMESPACE_DECL,
6429                                   std_identifier,
6430                                   void_type_node);
6431       pushdecl (fake_std_node);
6432     }
6433
6434   c_common_nodes_and_builtins ();
6435
6436   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6437   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6438   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6439   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6440   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6441   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6442   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6443   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6444
6445   integer_two_node = build_int_2 (2, 0);
6446   TREE_TYPE (integer_two_node) = integer_type_node;
6447   integer_three_node = build_int_2 (3, 0);
6448   TREE_TYPE (integer_three_node) = integer_type_node;
6449
6450   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6451   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6452   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6453   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6454   TYPE_PRECISION (boolean_type_node) = 1;
6455   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6456   boolean_false_node = build_int_2 (0, 0);
6457   TREE_TYPE (boolean_false_node) = boolean_type_node;
6458   boolean_true_node = build_int_2 (1, 0);
6459   TREE_TYPE (boolean_true_node) = boolean_type_node;
6460
6461   signed_size_zero_node = build_int_2 (0, 0);
6462   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6463
6464   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6465
6466 #if 0
6467   record_builtin_type (RID_MAX, NULL, string_type_node);
6468 #endif
6469
6470   delta_type_node = ptrdiff_type_node;
6471   vtable_index_type = ptrdiff_type_node;
6472
6473   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6474   lang_type_promotes_to = convert_type_from_ellipsis;
6475
6476   void_ftype = build_function_type (void_type_node, void_list_node);
6477   void_ftype_ptr = build_function_type (void_type_node,
6478                                         tree_cons (NULL_TREE,
6479                                                    ptr_type_node,
6480                                                    void_list_node));
6481   void_ftype_ptr
6482     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6483
6484   /* C++ extensions */
6485
6486   unknown_type_node = make_node (UNKNOWN_TYPE);
6487   record_unknown_type (unknown_type_node, "unknown type");
6488
6489   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6490   TREE_TYPE (unknown_type_node) = unknown_type_node;
6491
6492   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6493
6494   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6495      result.  */
6496   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6497   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6498
6499   if (flag_vtable_thunks)
6500     {
6501       /* Make sure we get a unique function type, so we can give
6502          its pointer type a name.  (This wins for gdb.) */
6503       tree vfunc_type = make_node (FUNCTION_TYPE);
6504       TREE_TYPE (vfunc_type) = integer_type_node;
6505       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6506       layout_type (vfunc_type);
6507
6508       vtable_entry_type = build_pointer_type (vfunc_type);
6509     }
6510   else
6511     {
6512       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6513       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6514                               delta_type_node);
6515       fields[1] = build_decl (FIELD_DECL, index_identifier,
6516                               delta_type_node);
6517       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6518                               ptr_type_node);
6519       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6520                            double_type_node);
6521
6522       /* Make this part of an invisible union.  */
6523       fields[3] = copy_node (fields[2]);
6524       TREE_TYPE (fields[3]) = delta_type_node;
6525       DECL_NAME (fields[3]) = delta2_identifier;
6526       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6527       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6528       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6529       TREE_UNSIGNED (fields[3]) = 0;
6530       TREE_CHAIN (fields[2]) = fields[3];
6531       vtable_entry_type = build_qualified_type (vtable_entry_type,
6532                                                 TYPE_QUAL_CONST);
6533     }
6534   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6535
6536   vtbl_type_node
6537     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6538   layout_type (vtbl_type_node);
6539   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6540   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6541   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6542   layout_type (vtbl_ptr_type_node);
6543   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6544
6545   push_namespace (get_identifier ("__cxxabiv1"));
6546   abi_node = current_namespace;
6547   pop_namespace ();
6548
6549   global_type_node = make_node (LANG_TYPE);
6550   record_unknown_type (global_type_node, "global type");
6551
6552   /* Now, C++.  */
6553   current_lang_name = lang_name_cplusplus;
6554
6555   {
6556     tree bad_alloc_type_node, newtype, deltype;
6557     tree ptr_ftype_sizetype;
6558
6559     if (flag_honor_std)
6560       push_namespace (std_identifier);
6561     bad_alloc_type_node = xref_tag
6562       (class_type_node, get_identifier ("bad_alloc"), 1);
6563     if (flag_honor_std)
6564       pop_namespace ();
6565     ptr_ftype_sizetype
6566       = build_function_type (ptr_type_node,
6567                              tree_cons (NULL_TREE,
6568                                         c_size_type_node,
6569                                         void_list_node));
6570     newtype = build_exception_variant
6571       (ptr_ftype_sizetype, add_exception_specifier
6572        (NULL_TREE, bad_alloc_type_node, -1));
6573     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6574     push_cp_library_fn (NEW_EXPR, newtype);
6575     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6576     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6577     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6578   }
6579
6580   abort_fndecl
6581     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6582
6583   /* Perform other language dependent initializations.  */
6584   init_class_processing ();
6585   init_init_processing ();
6586   init_search_processing ();
6587   init_rtti_processing ();
6588
6589   if (flag_exceptions)
6590     init_exception_processing ();
6591
6592   if (! supports_one_only ())
6593     flag_weak = 0;
6594
6595   make_fname_decl = cp_make_fname_decl;
6596   start_fname_decls ();
6597
6598   /* Prepare to check format strings against argument lists.  */
6599   init_function_format_info ();
6600
6601   /* Show we use EH for cleanups.  */
6602   using_eh_for_cleanups ();
6603
6604   valid_lang_attribute = cp_valid_lang_attribute;
6605
6606   /* Maintain consistency.  Perhaps we should just complain if they
6607      say -fwritable-strings?  */
6608   if (flag_writable_strings)
6609     flag_const_strings = 0;
6610
6611   /* Add GC roots for all of our global variables.  */
6612   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6613   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6614   ggc_add_tree_root (&integer_three_node, 1);
6615   ggc_add_tree_root (&integer_two_node, 1);
6616   ggc_add_tree_root (&signed_size_zero_node, 1);
6617   ggc_add_tree_root (&size_one_node, 1);
6618   ggc_add_tree_root (&size_zero_node, 1);
6619   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6620                 mark_binding_level);
6621   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6622   ggc_add_tree_root (&static_ctors, 1);
6623   ggc_add_tree_root (&static_dtors, 1);
6624   ggc_add_tree_root (&lastiddecl, 1);
6625
6626   ggc_add_tree_root (&last_function_parm_tags, 1);
6627   ggc_add_tree_root (&current_function_return_value, 1);
6628   ggc_add_tree_root (&current_function_parm_tags, 1);
6629   ggc_add_tree_root (&last_function_parms, 1);
6630   ggc_add_tree_root (&error_mark_list, 1);
6631
6632   ggc_add_tree_root (&global_namespace, 1);
6633   ggc_add_tree_root (&global_type_node, 1);
6634   ggc_add_tree_root (&anonymous_namespace_name, 1);
6635
6636   ggc_add_tree_root (&got_object, 1);
6637   ggc_add_tree_root (&got_scope, 1);
6638
6639   ggc_add_tree_root (&current_lang_name, 1);
6640   ggc_add_tree_root (&static_aggregates, 1);
6641   ggc_add_tree_root (&free_bindings, 1);
6642 }
6643
6644 /* Generate an initializer for a function naming variable from
6645    NAME. NAME may be NULL, in which case we generate a special
6646    ERROR_MARK node which should be replaced later. */
6647
6648 tree
6649 cp_fname_init (name)
6650      const char *name;
6651 {
6652   tree domain = NULL_TREE;
6653   tree type;
6654   tree init = NULL_TREE;
6655   size_t length = 0;
6656
6657   if (name)
6658     {
6659       length = strlen (name);
6660       domain = build_index_type (size_int (length));
6661       init = build_string (length + 1, name);
6662     }
6663
6664   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6665   type = build_cplus_array_type (type, domain);
6666
6667   if (init)
6668     TREE_TYPE (init) = type;
6669   else
6670     /* We don't know the value until instantiation time. Make
6671        something which will be digested now, but replaced later. */
6672     init = build (ERROR_MARK, type);
6673
6674   return init;
6675 }
6676
6677 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6678    decl, NAME is the initialization string and TYPE_DEP indicates whether
6679    NAME depended on the type of the function. We make use of that to detect
6680    __PRETTY_FUNCTION__ inside a template fn. This is being done
6681    lazily at the point of first use, so we musn't push the decl now.  */
6682
6683 static tree
6684 cp_make_fname_decl (id, type_dep)
6685      tree id;
6686      int type_dep;
6687 {
6688   const char *name = (type_dep && processing_template_decl
6689                       ? NULL : fname_as_string (type_dep));
6690   tree init = cp_fname_init (name);
6691   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6692
6693   /* As we don't push the decl here, we must set the context. */
6694   DECL_CONTEXT (decl) = current_function_decl;
6695   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6696
6697   TREE_STATIC (decl) = 1;
6698   TREE_READONLY (decl) = 1;
6699   DECL_ARTIFICIAL (decl) = 1;
6700   DECL_INITIAL (decl) = init;
6701
6702   TREE_USED (decl) = 1;
6703
6704   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6705
6706   return decl;
6707 }
6708
6709 /* Entry point for the benefit of c_common_nodes_and_builtins.
6710
6711    Make a definition for a builtin function named NAME and whose data type
6712    is TYPE.  TYPE should be a function type with argument types.
6713
6714    CLASS and CODE tell later passes how to compile calls to this function.
6715    See tree.h for possible values.
6716
6717    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6718    the name to be called if we can't opencode the function.  */
6719
6720 tree
6721 builtin_function (name, type, code, class, libname)
6722      const char *name;
6723      tree type;
6724      int code;
6725      enum built_in_class class;
6726      const char *libname;
6727 {
6728   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6729   DECL_BUILT_IN_CLASS (decl) = class;
6730   DECL_FUNCTION_CODE (decl) = code;
6731
6732   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6733
6734   /* All builtins that don't begin with an `_' should go in the `std'
6735      namespace.  */
6736   if (flag_honor_std && name[0] != '_')
6737     {
6738       push_namespace (std_identifier);
6739       DECL_CONTEXT (decl) = std_node;
6740     }
6741   pushdecl (decl);
6742   if (flag_honor_std && name[0] != '_')
6743     pop_namespace ();
6744
6745   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6746      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6747      function in the namespace.  */
6748   if (libname)
6749     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6750   make_decl_rtl (decl, NULL);
6751
6752   /* Warn if a function in the namespace for users
6753      is used without an occasion to consider it declared.  */
6754   if (name[0] != '_' || name[1] != '_')
6755     DECL_ANTICIPATED (decl) = 1;
6756
6757   return decl;
6758 }
6759
6760 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6761    function.  Not called directly.  */
6762
6763 static tree
6764 build_library_fn_1 (name, operator_code, type)
6765      tree name;
6766      enum tree_code operator_code;
6767      tree type;
6768 {
6769   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6770   DECL_EXTERNAL (fn) = 1;
6771   TREE_PUBLIC (fn) = 1;
6772   DECL_ARTIFICIAL (fn) = 1;
6773   TREE_NOTHROW (fn) = 1;
6774   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6775   SET_DECL_LANGUAGE (fn, lang_c);
6776   return fn;
6777 }
6778
6779 /* Returns the _DECL for a library function with C linkage.
6780    We assume that such functions never throw; if this is incorrect,
6781    callers should unset TREE_NOTHROW.  */
6782
6783 tree
6784 build_library_fn (name, type)
6785      tree name;
6786      tree type;
6787 {
6788   return build_library_fn_1 (name, ERROR_MARK, type);
6789 }
6790
6791 /* Returns the _DECL for a library function with C++ linkage.  */
6792
6793 static tree
6794 build_cp_library_fn (name, operator_code, type)
6795      tree name;
6796      enum tree_code operator_code;
6797      tree type;
6798 {
6799   tree fn = build_library_fn_1 (name, operator_code, type);
6800   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6801   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6802   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6803   set_mangled_name_for_decl (fn);
6804   return fn;
6805 }
6806
6807 /* Like build_library_fn, but takes a C string instead of an
6808    IDENTIFIER_NODE.  */
6809
6810 tree
6811 build_library_fn_ptr (name, type)
6812      const char *name;
6813      tree type;
6814 {
6815   return build_library_fn (get_identifier (name), type);
6816 }
6817
6818 /* Like build_cp_library_fn, but takes a C string instead of an
6819    IDENTIFIER_NODE.  */
6820
6821 tree
6822 build_cp_library_fn_ptr (name, type)
6823      const char *name;
6824      tree type;
6825 {
6826   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6827 }
6828
6829 /* Like build_library_fn, but also pushes the function so that we will
6830    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6831
6832 tree
6833 push_library_fn (name, type)
6834      tree name, type;
6835 {
6836   tree fn = build_library_fn (name, type);
6837   pushdecl_top_level (fn);
6838   return fn;
6839 }
6840
6841 /* Like build_cp_library_fn, but also pushes the function so that it
6842    will be found by normal lookup.  */
6843
6844 static tree
6845 push_cp_library_fn (operator_code, type)
6846      enum tree_code operator_code;
6847      tree type;
6848 {
6849   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6850                                  operator_code,
6851                                  type);
6852   pushdecl (fn);
6853   return fn;
6854 }
6855
6856 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6857    a FUNCTION_TYPE.  */
6858
6859 tree
6860 push_void_library_fn (name, parmtypes)
6861      tree name, parmtypes;
6862 {
6863   tree type = build_function_type (void_type_node, parmtypes);
6864   return push_library_fn (name, type);
6865 }
6866
6867 /* Like push_library_fn, but also note that this function throws
6868    and does not return.  Used for __throw_foo and the like.  */
6869
6870 tree
6871 push_throw_library_fn (name, type)
6872      tree name, type;
6873 {
6874   tree fn = push_library_fn (name, type);
6875   TREE_THIS_VOLATILE (fn) = 1;
6876   TREE_NOTHROW (fn) = 0;
6877   return fn;
6878 }
6879 \f
6880 /* When we call finish_struct for an anonymous union, we create
6881    default copy constructors and such.  But, an anonymous union
6882    shouldn't have such things; this function undoes the damage to the
6883    anonymous union type T.
6884
6885    (The reason that we create the synthesized methods is that we don't
6886    distinguish `union { int i; }' from `typedef union { int i; } U'.
6887    The first is an anonymous union; the second is just an ordinary
6888    union type.)  */
6889
6890 void
6891 fixup_anonymous_aggr (t)
6892      tree t;
6893 {
6894   tree *q;
6895
6896   /* Wipe out memory of synthesized methods */
6897   TYPE_HAS_CONSTRUCTOR (t) = 0;
6898   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6899   TYPE_HAS_INIT_REF (t) = 0;
6900   TYPE_HAS_CONST_INIT_REF (t) = 0;
6901   TYPE_HAS_ASSIGN_REF (t) = 0;
6902   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6903
6904   /* Splice the implicitly generated functions out of the TYPE_METHODS
6905      list.  */
6906   q = &TYPE_METHODS (t);
6907   while (*q)
6908     {
6909       if (DECL_ARTIFICIAL (*q))
6910         *q = TREE_CHAIN (*q);
6911       else
6912         q = &TREE_CHAIN (*q);
6913     }
6914
6915   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6916   if (TYPE_METHODS (t))
6917     cp_error_at ("an anonymous union cannot have function members", t);
6918
6919   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6920      assignment operators (because they cannot have these methods themselves).
6921      For anonymous unions this is already checked because they are not allowed
6922      in any union, otherwise we have to check it.  */
6923   if (TREE_CODE (t) != UNION_TYPE)
6924     {
6925       tree field, type;
6926
6927       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6928         if (TREE_CODE (field) == FIELD_DECL)
6929           {
6930             type = TREE_TYPE (field);
6931             if (CLASS_TYPE_P (type))
6932               {
6933                 if (TYPE_NEEDS_CONSTRUCTING (type))
6934                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6935                                field);
6936                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6937                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6938                                field);
6939                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6940                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6941                                field);
6942               }
6943           }
6944     }
6945 }
6946
6947 /* Make sure that a declaration with no declarator is well-formed, i.e.
6948    just defines a tagged type or anonymous union.
6949
6950    Returns the type defined, if any.  */
6951
6952 tree
6953 check_tag_decl (declspecs)
6954      tree declspecs;
6955 {
6956   int found_type = 0;
6957   int saw_friend = 0;
6958   int saw_typedef = 0;
6959   tree ob_modifier = NULL_TREE;
6960   register tree link;
6961   register tree t = NULL_TREE;
6962
6963   for (link = declspecs; link; link = TREE_CHAIN (link))
6964     {
6965       register tree value = TREE_VALUE (link);
6966
6967       if (TYPE_P (value)
6968           || TREE_CODE (value) == TYPE_DECL
6969           || (TREE_CODE (value) == IDENTIFIER_NODE
6970               && IDENTIFIER_GLOBAL_VALUE (value)
6971               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6972         {
6973           ++found_type;
6974
6975           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6976             {
6977               if (! in_system_header)
6978                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6979               return NULL_TREE;
6980             }
6981
6982           if (TYPE_P (value)
6983               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6984                   || TREE_CODE (value) == ENUMERAL_TYPE))
6985             {
6986               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6987               t = value;
6988             }
6989         }
6990       else if (value == ridpointers[(int) RID_TYPEDEF])
6991         saw_typedef = 1;
6992       else if (value == ridpointers[(int) RID_FRIEND])
6993         {
6994           if (current_class_type == NULL_TREE
6995               || current_scope () != current_class_type)
6996             ob_modifier = value;
6997           else
6998             saw_friend = 1;
6999         }
7000       else if (value == ridpointers[(int) RID_STATIC]
7001                || value == ridpointers[(int) RID_EXTERN]
7002                || value == ridpointers[(int) RID_AUTO]
7003                || value == ridpointers[(int) RID_REGISTER]
7004                || value == ridpointers[(int) RID_INLINE]
7005                || value == ridpointers[(int) RID_VIRTUAL]
7006                || value == ridpointers[(int) RID_CONST]
7007                || value == ridpointers[(int) RID_VOLATILE]
7008                || value == ridpointers[(int) RID_EXPLICIT])
7009         ob_modifier = value;
7010     }
7011
7012   if (found_type > 1)
7013     error ("multiple types in one declaration");
7014
7015   if (t == NULL_TREE && ! saw_friend)
7016     pedwarn ("declaration does not declare anything");
7017
7018   /* Check for an anonymous union.  */
7019   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7020            && TYPE_ANONYMOUS_P (t))
7021     {
7022       /* 7/3 In a simple-declaration, the optional init-declarator-list
7023          can be omitted only when declaring a class (clause 9) or
7024          enumeration (7.2), that is, when the decl-specifier-seq contains
7025          either a class-specifier, an elaborated-type-specifier with
7026          a class-key (9.1), or an enum-specifier.  In these cases and
7027          whenever a class-specifier or enum-specifier is present in the
7028          decl-specifier-seq, the identifiers in these specifiers are among
7029          the names being declared by the declaration (as class-name,
7030          enum-names, or enumerators, depending on the syntax).  In such
7031          cases, and except for the declaration of an unnamed bit-field (9.6),
7032          the decl-specifier-seq shall introduce one or more names into the
7033          program, or shall redeclare a name introduced by a previous
7034          declaration.  [Example:
7035              enum { };            // ill-formed
7036              typedef class { };   // ill-formed
7037          --end example]  */
7038       if (saw_typedef)
7039         {
7040           error ("Missing type-name in typedef-declaration.");
7041           return NULL_TREE;
7042         }
7043       /* Anonymous unions are objects, so they can have specifiers.  */;
7044       SET_ANON_AGGR_TYPE_P (t);
7045
7046       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7047         pedwarn ("ISO C++ prohibits anonymous structs");
7048     }
7049
7050   else if (ob_modifier)
7051     {
7052       if (ob_modifier == ridpointers[(int) RID_INLINE]
7053           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7054         cp_error ("`%D' can only be specified for functions", ob_modifier);
7055       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7056         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7057       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7058         cp_error ("`%D' can only be specified for constructors",
7059                   ob_modifier);
7060       else
7061         cp_error ("`%D' can only be specified for objects and functions",
7062                   ob_modifier);
7063     }
7064
7065   return t;
7066 }
7067
7068 /* Called when a declaration is seen that contains no names to declare.
7069    If its type is a reference to a structure, union or enum inherited
7070    from a containing scope, shadow that tag name for the current scope
7071    with a forward reference.
7072    If its type defines a new named structure or union
7073    or defines an enum, it is valid but we need not do anything here.
7074    Otherwise, it is an error.
7075
7076    C++: may have to grok the declspecs to learn about static,
7077    complain for anonymous unions.  */
7078
7079 void
7080 shadow_tag (declspecs)
7081      tree declspecs;
7082 {
7083   tree t = check_tag_decl (declspecs);
7084
7085   if (t)
7086     maybe_process_partial_specialization (t);
7087
7088   /* This is where the variables in an anonymous union are
7089      declared.  An anonymous union declaration looks like:
7090      union { ... } ;
7091      because there is no declarator after the union, the parser
7092      sends that declaration here.  */
7093   if (t && ANON_AGGR_TYPE_P (t))
7094     {
7095       fixup_anonymous_aggr (t);
7096
7097       if (TYPE_FIELDS (t))
7098         {
7099           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7100                                       NULL_TREE);
7101           finish_anon_union (decl);
7102         }
7103     }
7104 }
7105 \f
7106 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7107
7108 tree
7109 groktypename (typename)
7110      tree typename;
7111 {
7112   if (TREE_CODE (typename) != TREE_LIST)
7113     return typename;
7114   return grokdeclarator (TREE_VALUE (typename),
7115                          TREE_PURPOSE (typename),
7116                          TYPENAME, 0, NULL_TREE);
7117 }
7118
7119 /* Decode a declarator in an ordinary declaration or data definition.
7120    This is called as soon as the type information and variable name
7121    have been parsed, before parsing the initializer if any.
7122    Here we create the ..._DECL node, fill in its type,
7123    and put it on the list of decls for the current context.
7124    The ..._DECL node is returned as the value.
7125
7126    Exception: for arrays where the length is not specified,
7127    the type is left null, to be filled in by `cp_finish_decl'.
7128
7129    Function definitions do not come here; they go to start_function
7130    instead.  However, external and forward declarations of functions
7131    do go through here.  Structure field declarations are done by
7132    grokfield and not through here.  */
7133
7134 tree
7135 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7136      tree declarator, declspecs;
7137      int initialized;
7138      tree attributes, prefix_attributes;
7139 {
7140   register tree decl;
7141   register tree type, tem;
7142   tree context;
7143   extern int have_extern_spec;
7144   extern int used_extern_spec;
7145   tree attrlist;
7146
7147 #if 0
7148   /* See code below that used this.  */
7149   int init_written = initialized;
7150 #endif
7151
7152   /* This should only be done once on the top most decl.  */
7153   if (have_extern_spec && !used_extern_spec)
7154     {
7155       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7156                              declspecs);
7157       used_extern_spec = 1;
7158     }
7159
7160   if (attributes || prefix_attributes)
7161     attrlist = build_tree_list (attributes, prefix_attributes);
7162   else
7163     attrlist = NULL_TREE;
7164
7165   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7166                          attrlist);
7167
7168   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7169     return NULL_TREE;
7170
7171   type = TREE_TYPE (decl);
7172
7173   if (type == error_mark_node)
7174     return NULL_TREE;
7175
7176   context = DECL_CONTEXT (decl);
7177
7178   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7179       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7180     {
7181       /* When parsing the initializer, lookup should use the object's
7182          namespace. */
7183       push_decl_namespace (context);
7184     }
7185
7186   /* We are only interested in class contexts, later. */
7187   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7188     context = NULL_TREE;
7189
7190   if (initialized)
7191     /* Is it valid for this decl to have an initializer at all?
7192        If not, set INITIALIZED to zero, which will indirectly
7193        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7194     switch (TREE_CODE (decl))
7195       {
7196       case TYPE_DECL:
7197         /* typedef foo = bar  means give foo the same type as bar.
7198            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7199            Any other case of an initialization in a TYPE_DECL is an error.  */
7200         if (pedantic || list_length (declspecs) > 1)
7201           {
7202             cp_error ("typedef `%D' is initialized", decl);
7203             initialized = 0;
7204           }
7205         break;
7206
7207       case FUNCTION_DECL:
7208         cp_error ("function `%#D' is initialized like a variable", decl);
7209         initialized = 0;
7210         break;
7211
7212       default:
7213         break;
7214       }
7215
7216   if (initialized)
7217     {
7218       if (! toplevel_bindings_p ()
7219           && DECL_EXTERNAL (decl))
7220         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7221                     decl);
7222       DECL_EXTERNAL (decl) = 0;
7223       if (toplevel_bindings_p ())
7224         TREE_STATIC (decl) = 1;
7225
7226       /* Tell `pushdecl' this is an initialized decl
7227          even though we don't yet have the initializer expression.
7228          Also tell `cp_finish_decl' it may store the real initializer.  */
7229       DECL_INITIAL (decl) = error_mark_node;
7230     }
7231
7232 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7233   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7234 #endif
7235
7236   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7237   cplus_decl_attributes (decl, attributes, prefix_attributes);
7238
7239   if (context && COMPLETE_TYPE_P (complete_type (context)))
7240     {
7241       push_nested_class (context, 2);
7242
7243       if (TREE_CODE (decl) == VAR_DECL)
7244         {
7245           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7246           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7247             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7248           else
7249             {
7250               if (DECL_CONTEXT (field) != context)
7251                 {
7252                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7253                               DECL_CONTEXT (field), DECL_NAME (decl),
7254                               context, DECL_NAME (decl));
7255                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7256                 }
7257               /* Static data member are tricky; an in-class initialization
7258                  still doesn't provide a definition, so the in-class
7259                  declaration will have DECL_EXTERNAL set, but will have an
7260                  initialization.  Thus, duplicate_decls won't warn
7261                  about this situation, and so we check here.  */
7262               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7263                 cp_error ("duplicate initialization of %D", decl);
7264               if (duplicate_decls (decl, field))
7265                 decl = field;
7266             }
7267         }
7268       else
7269         {
7270           tree field = check_classfn (context, decl);
7271           if (field && duplicate_decls (decl, field))
7272             decl = field;
7273         }
7274
7275       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7276       DECL_IN_AGGR_P (decl) = 0;
7277       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7278           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7279         {
7280           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7281           /* [temp.expl.spec] An explicit specialization of a static data
7282              member of a template is a definition if the declaration
7283              includes an initializer; otherwise, it is a declaration.
7284
7285              We check for processing_specialization so this only applies
7286              to the new specialization syntax.  */
7287           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7288             DECL_EXTERNAL (decl) = 1;
7289         }
7290
7291       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7292         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7293                     decl);
7294     }
7295
7296   /* Enter this declaration into the symbol table.  */
7297   tem = maybe_push_decl (decl);
7298
7299   if (processing_template_decl)
7300     tem = push_template_decl (tem);
7301
7302 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7303   /* Tell the back-end to use or not use .common as appropriate.  If we say
7304      -fconserve-space, we want this to save .data space, at the expense of
7305      wrong semantics.  If we say -fno-conserve-space, we want this to
7306      produce errors about redefs; to do this we force variables into the
7307      data segment.  */
7308   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7309 #endif
7310
7311   if (! processing_template_decl)
7312     start_decl_1 (tem);
7313
7314   return tem;
7315 }
7316
7317 void
7318 start_decl_1 (decl)
7319      tree decl;
7320 {
7321   tree type = TREE_TYPE (decl);
7322   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7323
7324   if (type == error_mark_node)
7325     return;
7326
7327   maybe_push_cleanup_level (type);
7328
7329   if (initialized)
7330     /* Is it valid for this decl to have an initializer at all?
7331        If not, set INITIALIZED to zero, which will indirectly
7332        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7333     {
7334       /* Don't allow initializations for incomplete types except for
7335          arrays which might be completed by the initialization.  */
7336       if (COMPLETE_TYPE_P (complete_type (type)))
7337         ;                       /* A complete type is ok.  */
7338       else if (TREE_CODE (type) != ARRAY_TYPE)
7339         {
7340           cp_error ("variable `%#D' has initializer but incomplete type",
7341                     decl);
7342           initialized = 0;
7343           type = TREE_TYPE (decl) = error_mark_node;
7344         }
7345       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7346         {
7347           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7348             cp_error ("elements of array `%#D' have incomplete type", decl);
7349           /* else we already gave an error in start_decl.  */
7350           initialized = 0;
7351         }
7352     }
7353
7354   if (!initialized
7355       && TREE_CODE (decl) != TYPE_DECL
7356       && TREE_CODE (decl) != TEMPLATE_DECL
7357       && type != error_mark_node
7358       && IS_AGGR_TYPE (type)
7359       && ! DECL_EXTERNAL (decl))
7360     {
7361       if ((! processing_template_decl || ! uses_template_parms (type))
7362           && !COMPLETE_TYPE_P (complete_type (type)))
7363         {
7364           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7365                  decl);
7366           /* Change the type so that assemble_variable will give
7367              DECL an rtl we can live with: (mem (const_int 0)).  */
7368           type = TREE_TYPE (decl) = error_mark_node;
7369         }
7370       else
7371         {
7372           /* If any base type in the hierarchy of TYPE needs a constructor,
7373              then we set initialized to 1.  This way any nodes which are
7374              created for the purposes of initializing this aggregate
7375              will live as long as it does.  This is necessary for global
7376              aggregates which do not have their initializers processed until
7377              the end of the file.  */
7378           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7379         }
7380     }
7381
7382   if (! initialized)
7383     DECL_INITIAL (decl) = NULL_TREE;
7384 }
7385
7386 /* Handle initialization of references.
7387    These three arguments are from `cp_finish_decl', and have the
7388    same meaning here that they do there.
7389
7390    Quotes on semantics can be found in ARM 8.4.3.  */
7391
7392 static tree
7393 grok_reference_init (decl, type, init)
7394      tree decl, type, init;
7395 {
7396   tree tmp;
7397
7398   if (init == NULL_TREE)
7399     {
7400       if ((DECL_LANG_SPECIFIC (decl) == 0
7401            || DECL_IN_AGGR_P (decl) == 0)
7402           && ! DECL_THIS_EXTERN (decl))
7403         cp_error ("`%D' declared as reference but not initialized", decl);
7404       return NULL_TREE;
7405     }
7406
7407   if (init == error_mark_node)
7408     return NULL_TREE;
7409
7410   if (TREE_CODE (init) == CONSTRUCTOR)
7411     {
7412       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7413       return NULL_TREE;
7414     }
7415
7416   if (TREE_CODE (init) == TREE_LIST)
7417     init = build_compound_expr (init);
7418
7419   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7420     init = convert_from_reference (init);
7421
7422   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7423       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7424     {
7425       /* Note: default conversion is only called in very special cases.  */
7426       init = default_conversion (init);
7427     }
7428
7429   /* Convert INIT to the reference type TYPE.  This may involve the
7430      creation of a temporary, whose lifetime must be the same as that
7431      of the reference.  If so, a DECL_STMT for the temporary will be
7432      added just after the DECL_STMT for DECL.  That's why we don't set
7433      DECL_INITIAL for local references (instead assigning to them
7434      explicitly); we need to allow the temporary to be initialized
7435      first.  */
7436   tmp = convert_to_reference
7437     (type, init, CONV_IMPLICIT,
7438      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7439      decl);
7440
7441   if (tmp == error_mark_node)
7442     return NULL_TREE;
7443   else if (tmp == NULL_TREE)
7444     {
7445       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7446       return NULL_TREE;
7447     }
7448
7449   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7450     return tmp;
7451
7452   if (building_stmt_tree ())
7453     {
7454       /* Initialize the declaration.  */
7455       tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7456       finish_expr_stmt (tmp);
7457     }
7458   else
7459     DECL_INITIAL (decl) = tmp;
7460
7461   return NULL_TREE;
7462 }
7463
7464 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7465    mucking with forces it does not comprehend (i.e. initialization with a
7466    constructor).  If we are at global scope and won't go into COMMON, fill
7467    it in with a dummy CONSTRUCTOR to force the variable into .data;
7468    otherwise we can use error_mark_node.  */
7469
7470 static tree
7471 obscure_complex_init (decl, init)
7472      tree decl, init;
7473 {
7474   if (! flag_no_inline && TREE_STATIC (decl))
7475     {
7476       if (extract_init (decl, init))
7477         return NULL_TREE;
7478     }
7479
7480 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7481   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7482     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7483                                  NULL_TREE);
7484   else
7485 #endif
7486     DECL_INITIAL (decl) = error_mark_node;
7487
7488   return init;
7489 }
7490
7491 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7492    array until we finish parsing the initializer.  If that's the
7493    situation we're in, update DECL accordingly.  */
7494
7495 static void
7496 maybe_deduce_size_from_array_init (decl, init)
7497      tree decl;
7498      tree init;
7499 {
7500   tree type = TREE_TYPE (decl);
7501
7502   if (TREE_CODE (type) == ARRAY_TYPE
7503       && TYPE_DOMAIN (type) == NULL_TREE
7504       && TREE_CODE (decl) != TYPE_DECL)
7505     {
7506       /* do_default is really a C-ism to deal with tentative definitions.
7507          But let's leave it here to ease the eventual merge.  */
7508       int do_default = !DECL_EXTERNAL (decl);
7509       tree initializer = init ? init : DECL_INITIAL (decl);
7510       int failure = complete_array_type (type, initializer, do_default);
7511
7512       if (failure == 1)
7513         cp_error ("initializer fails to determine size of `%D'", decl);
7514
7515       if (failure == 2)
7516         {
7517           if (do_default)
7518             cp_error ("array size missing in `%D'", decl);
7519           /* If a `static' var's size isn't known, make it extern as
7520              well as static, so it does not get allocated.  If it's not
7521              `static', then don't mark it extern; finish_incomplete_decl
7522              will give it a default size and it will get allocated.  */
7523           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7524             DECL_EXTERNAL (decl) = 1;
7525         }
7526
7527       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7528           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7529                               integer_zero_node))
7530         cp_error ("zero-size array `%D'", decl);
7531
7532       layout_decl (decl, 0);
7533     }
7534 }
7535
7536 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7537    any appropriate error messages regarding the layout.  */
7538
7539 static void
7540 layout_var_decl (decl)
7541      tree decl;
7542 {
7543   tree type = TREE_TYPE (decl);
7544 #if 0
7545   tree ttype = target_type (type);
7546 #endif
7547
7548   /* If we haven't already layed out this declaration, do so now.
7549      Note that we must not call complete type for an external object
7550      because it's type might involve templates that we are not
7551      supposed to isntantiate yet.  (And it's perfectly legal to say
7552      `extern X x' for some incomplete type `X'.)  */
7553   if (!DECL_EXTERNAL (decl))
7554     complete_type (type);
7555   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7556     layout_decl (decl, 0);
7557
7558   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7559     {
7560       /* An automatic variable with an incomplete type: that is an error.
7561          Don't talk about array types here, since we took care of that
7562          message in grokdeclarator.  */
7563       cp_error ("storage size of `%D' isn't known", decl);
7564       TREE_TYPE (decl) = error_mark_node;
7565     }
7566 #if 0
7567   /* Keep this code around in case we later want to control debug info
7568      based on whether a type is "used".  (jason 1999-11-11) */
7569
7570   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7571     /* Let debugger know it should output info for this type.  */
7572     note_debug_info_needed (ttype);
7573
7574   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7575     note_debug_info_needed (DECL_CONTEXT (decl));
7576 #endif
7577
7578   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7579       && DECL_SIZE (decl) != NULL_TREE
7580       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7581     {
7582       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7583         constant_expression_warning (DECL_SIZE (decl));
7584       else
7585         cp_error ("storage size of `%D' isn't constant", decl);
7586     }
7587
7588   if (TREE_STATIC (decl)
7589       && !DECL_ARTIFICIAL (decl)
7590       && current_function_decl
7591       && DECL_CONTEXT (decl) == current_function_decl)
7592     push_local_name (decl);
7593 }
7594
7595 /* If a local static variable is declared in an inline function, or if
7596    we have a weak definition, we must endeavor to create only one
7597    instance of the variable at link-time.  */
7598
7599 static void
7600 maybe_commonize_var (decl)
7601      tree decl;
7602 {
7603   /* Static data in a function with comdat linkage also has comdat
7604      linkage.  */
7605   if (TREE_STATIC (decl)
7606       /* Don't mess with __FUNCTION__.  */
7607       && ! DECL_ARTIFICIAL (decl)
7608       && current_function_decl
7609       && DECL_CONTEXT (decl) == current_function_decl
7610       && (DECL_DECLARED_INLINE_P (current_function_decl)
7611           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7612       && TREE_PUBLIC (current_function_decl))
7613     {
7614       /* If flag_weak, we don't need to mess with this, as we can just
7615          make the function weak, and let it refer to its unique local
7616          copy.  This works because we don't allow the function to be
7617          inlined.  */
7618       if (! flag_weak)
7619         {
7620           if (DECL_INTERFACE_KNOWN (current_function_decl))
7621             {
7622               TREE_PUBLIC (decl) = 1;
7623               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7624             }
7625           else if (DECL_INITIAL (decl) == NULL_TREE
7626                    || DECL_INITIAL (decl) == error_mark_node)
7627             {
7628               TREE_PUBLIC (decl) = 1;
7629               DECL_COMMON (decl) = 1;
7630             }
7631           /* else we lose. We can only do this if we can use common,
7632              which we can't if it has been initialized.  */
7633
7634           if (!TREE_PUBLIC (decl))
7635             {
7636               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7637               cp_warning_at ("  you can work around this by removing the initializer", decl);
7638             }
7639         }
7640       else
7641         comdat_linkage (decl);
7642     }
7643   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7644     /* Set it up again; we might have set DECL_INITIAL since the last
7645        time.  */
7646     comdat_linkage (decl);
7647 }
7648
7649 /* Issue an error message if DECL is an uninitialized const variable.  */
7650
7651 static void
7652 check_for_uninitialized_const_var (decl)
7653      tree decl;
7654 {
7655   tree type = TREE_TYPE (decl);
7656
7657   /* ``Unless explicitly declared extern, a const object does not have
7658      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7659      7.1.6 */
7660   if (TREE_CODE (decl) == VAR_DECL
7661       && TREE_CODE (type) != REFERENCE_TYPE
7662       && CP_TYPE_CONST_P (type)
7663       && !TYPE_NEEDS_CONSTRUCTING (type)
7664       && !DECL_INITIAL (decl))
7665     cp_error ("uninitialized const `%D'", decl);
7666 }
7667
7668 /* Verify INIT (the initializer for DECL), and record the
7669    initialization in DECL_INITIAL, if appropriate.  Returns a new
7670    value for INIT.  */
7671
7672 static tree
7673 check_initializer (decl, init)
7674      tree decl;
7675      tree init;
7676 {
7677   tree type;
7678
7679   if (TREE_CODE (decl) == FIELD_DECL)
7680     return init;
7681
7682   type = TREE_TYPE (decl);
7683
7684   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7685   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7686     init = NULL_TREE;
7687
7688   /* Check the initializer.  */
7689   if (init)
7690     {
7691       /* Things that are going to be initialized need to have complete
7692          type.  */
7693       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7694
7695       if (type == error_mark_node)
7696         /* We will have already complained.  */
7697         init = NULL_TREE;
7698       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7699         {
7700           cp_error ("variable-sized object `%D' may not be initialized", decl);
7701           init = NULL_TREE;
7702         }
7703       else if (TREE_CODE (type) == ARRAY_TYPE
7704                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7705         {
7706           cp_error ("elements of array `%#D' have incomplete type", decl);
7707           init = NULL_TREE;
7708         }
7709       else if (!COMPLETE_TYPE_P (type))
7710         {
7711           cp_error ("`%D' has incomplete type", decl);
7712           TREE_TYPE (decl) = error_mark_node;
7713           init = NULL_TREE;
7714         }
7715     }
7716
7717   if (TREE_CODE (decl) == CONST_DECL)
7718     {
7719       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7720
7721       DECL_INITIAL (decl) = init;
7722
7723       my_friendly_assert (init != NULL_TREE, 149);
7724       init = NULL_TREE;
7725     }
7726   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7727     {
7728       init = grok_reference_init (decl, type, init);
7729       if (init)
7730         init = obscure_complex_init (decl, init);
7731     }
7732   else if (init)
7733     {
7734       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7735         {
7736           if (TREE_CODE (type) == ARRAY_TYPE)
7737             init = digest_init (type, init, (tree *) 0);
7738           else if (TREE_CODE (init) == CONSTRUCTOR
7739                    && TREE_HAS_CONSTRUCTOR (init))
7740             {
7741               if (TYPE_NON_AGGREGATE_CLASS (type))
7742                 {
7743                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7744                             decl);
7745                   init = error_mark_node;
7746                 }
7747               else
7748                 goto dont_use_constructor;
7749             }
7750         }
7751       else
7752         {
7753         dont_use_constructor:
7754           if (TREE_CODE (init) != TREE_VEC)
7755             init = store_init_value (decl, init);
7756         }
7757
7758       if (init)
7759         /* We must hide the initializer so that expand_decl
7760            won't try to do something it does not understand.  */
7761         init = obscure_complex_init (decl, init);
7762     }
7763   else if (DECL_EXTERNAL (decl))
7764     ;
7765   else if (TYPE_P (type)
7766            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7767     {
7768       tree core_type = strip_array_types (type);
7769
7770       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7771         {
7772           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7773             cp_error ("structure `%D' with uninitialized const members", decl);
7774           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7775             cp_error ("structure `%D' with uninitialized reference members",
7776                       decl);
7777         }
7778
7779       check_for_uninitialized_const_var (decl);
7780
7781       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7782         init = obscure_complex_init (decl, NULL_TREE);
7783
7784     }
7785   else
7786     check_for_uninitialized_const_var (decl);
7787
7788   return init;
7789 }
7790
7791 /* If DECL is not a local variable, give it RTL.  */
7792
7793 static void
7794 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7795      tree decl;
7796      tree init;
7797      const char *asmspec;
7798 {
7799   int toplev = toplevel_bindings_p ();
7800   int defer_p;
7801
7802   /* Handle non-variables up front.  */
7803   if (TREE_CODE (decl) != VAR_DECL)
7804     {
7805       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7806       return;
7807     }
7808
7809   /* If we see a class member here, it should be a static data
7810      member.  */
7811   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7812     {
7813       my_friendly_assert (TREE_STATIC (decl), 19990828);
7814       /* An in-class declaration of a static data member should be
7815          external; it is only a declaration, and not a definition.  */
7816       if (init == NULL_TREE)
7817         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7818     }
7819
7820   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7821   if (asmspec)
7822     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7823
7824   /* We don't create any RTL for local variables.  */
7825   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7826     return;
7827
7828   /* We defer emission of local statics until the corresponding
7829      DECL_STMT is expanded.  */
7830   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7831
7832   /* We try to defer namespace-scope static constants so that they are
7833      not emitted into the object file unncessarily.  */
7834   if (!DECL_VIRTUAL_P (decl)
7835       && TREE_READONLY (decl)
7836       && DECL_INITIAL (decl) != NULL_TREE
7837       && DECL_INITIAL (decl) != error_mark_node
7838       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7839       && toplev
7840       && !TREE_PUBLIC (decl))
7841     {
7842       /* Fool with the linkage according to #pragma interface.  */
7843       if (!interface_unknown)
7844         {
7845           TREE_PUBLIC (decl) = 1;
7846           DECL_EXTERNAL (decl) = interface_only;
7847         }
7848
7849       defer_p = 1;
7850     }
7851
7852   /* If we're deferring the variable, we only need to make RTL if
7853      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7854      we need it.  (There's no way to lazily create RTL for things that
7855      have assembly specs because the information about the specifier
7856      isn't stored in the tree, yet)  */
7857   if (defer_p && asmspec)
7858     make_decl_rtl (decl, asmspec);
7859   /* If we're not deferring, go ahead and assemble the variable.  */
7860   else if (!defer_p)
7861     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7862 }
7863
7864 /* The old ARM scoping rules injected variables declared in the
7865    initialization statement of a for-statement into the surrounding
7866    scope.  We support this usage, in order to be backward-compatible.
7867    DECL is a just-declared VAR_DECL; if necessary inject its
7868    declaration into the surrounding scope.  */
7869
7870 void
7871 maybe_inject_for_scope_var (decl)
7872      tree decl;
7873 {
7874   if (!DECL_NAME (decl))
7875     return;
7876
7877   if (current_binding_level->is_for_scope)
7878     {
7879       struct binding_level *outer
7880         = current_binding_level->level_chain;
7881
7882       /* Check to see if the same name is already bound at the outer
7883          level, either because it was directly declared, or because a
7884          dead for-decl got preserved.  In either case, the code would
7885          not have been valid under the ARM scope rules, so clear
7886          is_for_scope for the current_binding_level.
7887
7888          Otherwise, we need to preserve the temp slot for decl to last
7889          into the outer binding level.  */
7890
7891       tree outer_binding
7892         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7893
7894       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7895           && (TREE_CODE (BINDING_VALUE (outer_binding))
7896               == VAR_DECL)
7897           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7898         {
7899           BINDING_VALUE (outer_binding)
7900             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7901           current_binding_level->is_for_scope = 0;
7902         }
7903       else if (DECL_IN_MEMORY_P (decl))
7904         preserve_temp_slots (DECL_RTL (decl));
7905     }
7906 }
7907
7908 /* Generate code to initialize DECL (a local variable).  */
7909
7910 void
7911 initialize_local_var (decl, init, flags)
7912      tree decl;
7913      tree init;
7914      int flags;
7915 {
7916   tree type = TREE_TYPE (decl);
7917
7918   /* If the type is bogus, don't bother initializing the variable.  */
7919   if (type == error_mark_node)
7920     return;
7921
7922   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7923     {
7924       /* If we used it already as memory, it must stay in memory.  */
7925       DECL_INITIAL (decl) = NULL_TREE;
7926       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7927     }
7928
7929   /* Local statics are handled differently from ordinary automatic
7930      variables.  */
7931   if (TREE_STATIC (decl))
7932     {
7933       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7934           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7935         expand_static_init (decl, init);
7936       return;
7937     }
7938
7939   if (DECL_SIZE (decl) && type != error_mark_node)
7940     {
7941       int already_used;
7942
7943       /* Compute and store the initial value.  */
7944       already_used = TREE_USED (decl) || TREE_USED (type);
7945
7946       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7947         {
7948           int saved_stmts_are_full_exprs_p;
7949
7950           my_friendly_assert (building_stmt_tree (), 20000906);
7951           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7952           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7953           finish_expr_stmt (build_aggr_init (decl, init, flags));
7954           current_stmt_tree ()->stmts_are_full_exprs_p =
7955             saved_stmts_are_full_exprs_p;
7956         }
7957
7958       /* Set this to 0 so we can tell whether an aggregate which was
7959          initialized was ever used.  Don't do this if it has a
7960          destructor, so we don't complain about the 'resource
7961          allocation is initialization' idiom.  Now set
7962          attribute((unused)) on types so decls of that type will be
7963          marked used. (see TREE_USED, above.)  */
7964       if (TYPE_NEEDS_CONSTRUCTING (type)
7965           && ! already_used
7966           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7967           && DECL_NAME (decl))
7968         TREE_USED (decl) = 0;
7969       else if (already_used)
7970         TREE_USED (decl) = 1;
7971     }
7972 }
7973
7974 /* Generate code to destroy DECL (a local variable).  */
7975
7976 static void
7977 destroy_local_var (decl)
7978      tree decl;
7979 {
7980   tree type = TREE_TYPE (decl);
7981   tree cleanup;
7982
7983   /* Only variables get cleaned up.  */
7984   if (TREE_CODE (decl) != VAR_DECL)
7985     return;
7986
7987   /* And only things with destructors need cleaning up.  */
7988   if (type == error_mark_node
7989       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7990     return;
7991
7992   if (TREE_CODE (decl) == VAR_DECL &&
7993       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7994     /* We don't clean up things that aren't defined in this
7995        translation unit, or that need a static cleanup.  The latter
7996        are handled by finish_file.  */
7997     return;
7998
7999   /* Compute the cleanup.  */
8000   cleanup = maybe_build_cleanup (decl);
8001
8002   /* Record the cleanup required for this declaration.  */
8003   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8004       && cleanup)
8005     finish_decl_cleanup (decl, cleanup);
8006 }
8007
8008 /* Finish processing of a declaration;
8009    install its line number and initial value.
8010    If the length of an array type is not known before,
8011    it must be determined now, from the initial value, or it is an error.
8012
8013    INIT holds the value of an initializer that should be allowed to escape
8014    the normal rules.
8015
8016    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8017    if the (init) syntax was used.  */
8018
8019 void
8020 cp_finish_decl (decl, init, asmspec_tree, flags)
8021      tree decl, init;
8022      tree asmspec_tree;
8023      int flags;
8024 {
8025   register tree type;
8026   tree ttype = NULL_TREE;
8027   const char *asmspec = NULL;
8028   int was_readonly = 0;
8029
8030   if (! decl)
8031     {
8032       if (init)
8033         error ("assignment (not initialization) in declaration");
8034       return;
8035     }
8036
8037   /* If a name was specified, get the string.  */
8038   if (asmspec_tree)
8039       asmspec = TREE_STRING_POINTER (asmspec_tree);
8040
8041   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8042     {
8043       cp_error ("cannot initialize `%D' to namespace `%D'",
8044                 decl, init);
8045       init = NULL_TREE;
8046     }
8047
8048   if (current_class_type
8049       && CP_DECL_CONTEXT (decl) == current_class_type
8050       && TYPE_BEING_DEFINED (current_class_type)
8051       && (DECL_INITIAL (decl) || init))
8052     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8053
8054   if (TREE_CODE (decl) == VAR_DECL
8055       && DECL_CONTEXT (decl)
8056       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8057       && DECL_CONTEXT (decl) != current_namespace
8058       && init)
8059     {
8060       /* Leave the namespace of the object. */
8061       pop_decl_namespace ();
8062     }
8063
8064   type = TREE_TYPE (decl);
8065
8066   if (type == error_mark_node)
8067     return;
8068
8069   /* Add this declaration to the statement-tree.  */
8070   if (building_stmt_tree ()
8071       && at_function_scope_p ()
8072       && TREE_CODE (decl) != RESULT_DECL)
8073     add_decl_stmt (decl);
8074
8075   if (TYPE_HAS_MUTABLE_P (type))
8076     TREE_READONLY (decl) = 0;
8077
8078   if (processing_template_decl)
8079     {
8080       if (init && DECL_INITIAL (decl))
8081         DECL_INITIAL (decl) = init;
8082       goto finish_end0;
8083     }
8084
8085   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8086   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8087
8088   /* Take care of TYPE_DECLs up front.  */
8089   if (TREE_CODE (decl) == TYPE_DECL)
8090     {
8091       if (init && DECL_INITIAL (decl))
8092         {
8093           /* typedef foo = bar; store the type of bar as the type of foo.  */
8094           TREE_TYPE (decl) = type = TREE_TYPE (init);
8095           DECL_INITIAL (decl) = init = NULL_TREE;
8096         }
8097       if (type != error_mark_node
8098           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8099         {
8100           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8101             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8102           set_identifier_type_value (DECL_NAME (decl), type);
8103           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8104         }
8105       GNU_xref_decl (current_function_decl, decl);
8106
8107       /* If we have installed this as the canonical typedef for this
8108          type, and that type has not been defined yet, delay emitting
8109          the debug information for it, as we will emit it later.  */
8110       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8111           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8112         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8113
8114       rest_of_decl_compilation (decl, NULL,
8115                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8116       goto finish_end;
8117     }
8118
8119   if (TREE_CODE (decl) != FUNCTION_DECL)
8120     ttype = target_type (type);
8121
8122   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8123       && TYPE_NEEDS_CONSTRUCTING (type))
8124     {
8125       /* Currently, GNU C++ puts constants in text space, making them
8126          impossible to initialize.  In the future, one would hope for
8127          an operating system which understood the difference between
8128          initialization and the running of a program.  */
8129       was_readonly = 1;
8130       TREE_READONLY (decl) = 0;
8131     }
8132
8133   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8134     {
8135       /* This must override the asm specifier which was placed by
8136          grokclassfn.  Lay this out fresh.  */
8137       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8138       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8139       make_decl_rtl (decl, asmspec);
8140     }
8141
8142   /* Deduce size of array from initialization, if not already known.  */
8143   maybe_deduce_size_from_array_init (decl, init);
8144   init = check_initializer (decl, init);
8145
8146   GNU_xref_decl (current_function_decl, decl);
8147
8148   if (TREE_CODE (decl) == VAR_DECL)
8149     layout_var_decl (decl);
8150
8151   /* Output the assembler code and/or RTL code for variables and functions,
8152      unless the type is an undefined structure or union.
8153      If not, it will get done when the type is completed.  */
8154   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8155       || TREE_CODE (decl) == RESULT_DECL)
8156     {
8157       if (TREE_CODE (decl) == VAR_DECL)
8158         maybe_commonize_var (decl);
8159
8160       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8161
8162       if (TREE_CODE (type) == FUNCTION_TYPE
8163           || TREE_CODE (type) == METHOD_TYPE)
8164         abstract_virtuals_error (decl,
8165                                  strip_array_types (TREE_TYPE (type)));
8166       else
8167         abstract_virtuals_error (decl, strip_array_types (type));
8168
8169       if (TREE_CODE (decl) == FUNCTION_DECL)
8170         ;
8171       else if (DECL_EXTERNAL (decl)
8172                && ! (DECL_LANG_SPECIFIC (decl)
8173                      && DECL_NOT_REALLY_EXTERN (decl)))
8174         {
8175           if (init)
8176             DECL_INITIAL (decl) = init;
8177         }
8178       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8179         {
8180           /* This is a local declaration.  */
8181           if (doing_semantic_analysis_p ())
8182             maybe_inject_for_scope_var (decl);
8183           /* Initialize the local variable.  But, if we're building a
8184              statement-tree, we'll do the initialization when we
8185              expand the tree.  */
8186           if (processing_template_decl)
8187             {
8188               if (init || DECL_INITIAL (decl) == error_mark_node)
8189                 DECL_INITIAL (decl) = init;
8190             }
8191           else
8192             {
8193               /* If we're not building RTL, then we need to do so
8194                  now.  */
8195               my_friendly_assert (building_stmt_tree (), 20000906);
8196               /* Initialize the variable.  */
8197               initialize_local_var (decl, init, flags);
8198               /* Clean up the variable.  */
8199               destroy_local_var (decl);
8200             }
8201         }
8202       else if (TREE_STATIC (decl) && type != error_mark_node)
8203         {
8204           /* Cleanups for static variables are handled by `finish_file'.  */
8205           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8206               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8207             expand_static_init (decl, init);
8208         }
8209     finish_end0:
8210
8211       /* Undo call to `pushclass' that was done in `start_decl'
8212          due to initialization of qualified member variable.
8213          I.e., Foo::x = 10;  */
8214       {
8215         tree context = CP_DECL_CONTEXT (decl);
8216         if (context
8217             && TYPE_P (context)
8218             && (TREE_CODE (decl) == VAR_DECL
8219                 /* We also have a pushclass done that we need to undo here
8220                    if we're at top level and declare a method.  */
8221                 || TREE_CODE (decl) == FUNCTION_DECL)
8222             /* If size hasn't been set, we're still defining it,
8223                and therefore inside the class body; don't pop
8224                the binding level..  */
8225             && COMPLETE_TYPE_P (context)
8226             && context == current_class_type)
8227           pop_nested_class ();
8228       }
8229     }
8230
8231  finish_end:
8232
8233   if (was_readonly)
8234     TREE_READONLY (decl) = 1;
8235 }
8236
8237 /* This is here for a midend callback from c-common.c */
8238
8239 void
8240 finish_decl (decl, init, asmspec_tree)
8241      tree decl, init;
8242      tree asmspec_tree;
8243 {
8244   cp_finish_decl (decl, init, asmspec_tree, 0);
8245 }
8246
8247 /* Returns a declaration for a VAR_DECL as if:
8248
8249      extern "C" TYPE NAME;
8250
8251    had been seen.  Used to create compiler-generated global
8252    variables.  */
8253
8254 tree
8255 declare_global_var (name, type)
8256      tree name;
8257      tree type;
8258 {
8259   tree decl;
8260
8261   push_to_top_level ();
8262   decl = build_decl (VAR_DECL, name, type);
8263   TREE_PUBLIC (decl) = 1;
8264   DECL_EXTERNAL (decl) = 1;
8265   DECL_ARTIFICIAL (decl) = 1;
8266   pushdecl (decl);
8267   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8268   pop_from_top_level ();
8269
8270   return decl;
8271 }
8272
8273 /* Returns a pointer to the `atexit' function.  Note that if
8274    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8275    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8276
8277 static tree
8278 get_atexit_node ()
8279 {
8280   tree atexit_fndecl;
8281   tree arg_types;
8282   tree fn_type;
8283   tree fn_ptr_type;
8284   const char *name;
8285
8286   if (atexit_node)
8287     return atexit_node;
8288
8289   if (flag_use_cxa_atexit)
8290     {
8291       /* The declaration for `__cxa_atexit' is:
8292
8293            int __cxa_atexit (void (*)(void *), void *, void *)
8294
8295          We build up the argument types and then then function type
8296          itself.  */
8297
8298       /* First, build the pointer-to-function type for the first
8299          argument.  */
8300       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8301       fn_type = build_function_type (void_type_node, arg_types);
8302       fn_ptr_type = build_pointer_type (fn_type);
8303       /* Then, build the rest of the argument types.  */
8304       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8305       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8306       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8307       /* And the final __cxa_atexit type.  */
8308       fn_type = build_function_type (integer_type_node, arg_types);
8309       fn_ptr_type = build_pointer_type (fn_type);
8310       name = "__cxa_atexit";
8311     }
8312   else
8313     {
8314       /* The declaration for `atexit' is:
8315
8316            int atexit (void (*)());
8317
8318          We build up the argument types and then then function type
8319          itself.  */
8320       fn_type = build_function_type (void_type_node, void_list_node);
8321       fn_ptr_type = build_pointer_type (fn_type);
8322       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8323       /* Build the final atexit type.  */
8324       fn_type = build_function_type (integer_type_node, arg_types);
8325       name = "atexit";
8326     }
8327
8328   /* Now, build the function declaration.  */
8329   push_lang_context (lang_name_c);
8330   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8331   mark_used (atexit_fndecl);
8332   pop_lang_context ();
8333   atexit_node = default_conversion (atexit_fndecl);
8334
8335   return atexit_node;
8336 }
8337
8338 /* Returns the __dso_handle VAR_DECL.  */
8339
8340 static tree
8341 get_dso_handle_node ()
8342 {
8343   if (dso_handle_node)
8344     return dso_handle_node;
8345
8346   /* Declare the variable.  */
8347   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8348                                         ptr_type_node);
8349
8350   return dso_handle_node;
8351 }
8352
8353 /* Begin a new function with internal linkage whose job will be simply
8354    to destroy some particular variable.  */
8355
8356 static tree
8357 start_cleanup_fn ()
8358 {
8359   static int counter = 0;
8360   int old_interface_unknown = interface_unknown;
8361   char name[32];
8362   tree parmtypes;
8363   tree fntype;
8364   tree fndecl;
8365
8366   push_to_top_level ();
8367
8368   /* No need to mangle this.  */
8369   push_lang_context (lang_name_c);
8370
8371   interface_unknown = 1;
8372
8373   /* Build the parameter-types.  */
8374   parmtypes = void_list_node;
8375   /* Functions passed to __cxa_atexit take an additional parameter.
8376      We'll just ignore it.  After we implement the new calling
8377      convention for destructors, we can eliminate the use of
8378      additional cleanup functions entirely in the -fnew-abi case.  */
8379   if (flag_use_cxa_atexit)
8380     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8381   /* Build the function type itself.  */
8382   fntype = build_function_type (void_type_node, parmtypes);
8383   /* Build the name of the function.  */
8384   sprintf (name, "__tcf_%d", counter++);
8385   /* Build the function declaration.  */
8386   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8387   /* It's a function with internal linkage, generated by the
8388      compiler.  */
8389   TREE_PUBLIC (fndecl) = 0;
8390   DECL_ARTIFICIAL (fndecl) = 1;
8391   /* Make the function `inline' so that it is only emitted if it is
8392      actually needed.  It is unlikely that it will be inlined, since
8393      it is only called via a function pointer, but we avoid unncessary
8394      emissions this way.  */
8395   DECL_INLINE (fndecl) = 1;
8396   /* Build the parameter.  */
8397   if (flag_use_cxa_atexit)
8398     {
8399       tree parmdecl;
8400
8401       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8402       DECL_CONTEXT (parmdecl) = fndecl;
8403       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8404       TREE_USED (parmdecl) = 1;
8405       DECL_ARGUMENTS (fndecl) = parmdecl;
8406     }
8407
8408   pushdecl (fndecl);
8409   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8410   do_pushlevel ();
8411
8412   interface_unknown = old_interface_unknown;
8413
8414   pop_lang_context ();
8415
8416   return current_function_decl;
8417 }
8418
8419 /* Finish the cleanup function begun by start_cleanup_fn.  */
8420
8421 static void
8422 end_cleanup_fn ()
8423 {
8424   do_poplevel ();
8425
8426   expand_body (finish_function (0));
8427
8428   pop_from_top_level ();
8429 }
8430
8431 /* Generate code to handle the destruction of DECL, an object with
8432    static storage duration.  */
8433
8434 void
8435 register_dtor_fn (decl)
8436      tree decl;
8437 {
8438   tree cleanup;
8439   tree compound_stmt;
8440   tree args;
8441   tree fcall;
8442
8443   int saved_flag_access_control;
8444
8445   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8446     return;
8447
8448   /* Call build_cleanup before we enter the anonymous function so that
8449      any access checks will be done relative to the current scope,
8450      rather than the scope of the anonymous function.  */
8451   build_cleanup (decl);
8452
8453   /* Now start the function.  */
8454   cleanup = start_cleanup_fn ();
8455
8456   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8457      to the original function, rather than the anonymous one.  That
8458      will make the back-end think that nested functions are in use,
8459      which causes confusion.  */
8460   saved_flag_access_control = flag_access_control;
8461   flag_access_control = 0;
8462   fcall = build_cleanup (decl);
8463   flag_access_control = saved_flag_access_control;
8464
8465   /* Create the body of the anonymous function.  */
8466   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8467   finish_expr_stmt (fcall);
8468   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8469   end_cleanup_fn ();
8470
8471   /* Call atexit with the cleanup function.  */
8472   mark_addressable (cleanup);
8473   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8474   if (flag_use_cxa_atexit)
8475     {
8476       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8477       args = tree_cons (NULL_TREE, null_pointer_node, args);
8478       args = tree_cons (NULL_TREE, cleanup, args);
8479     }
8480   else
8481     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8482   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8483 }
8484
8485 void
8486 expand_static_init (decl, init)
8487      tree decl;
8488      tree init;
8489 {
8490   tree oldstatic = value_member (decl, static_aggregates);
8491
8492   if (oldstatic)
8493     {
8494       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8495         cp_error ("multiple initializations given for `%D'", decl);
8496     }
8497   else if (! toplevel_bindings_p ())
8498     {
8499       /* Emit code to perform this initialization but once.  */
8500       tree if_stmt;
8501       tree then_clause;
8502       tree assignment;
8503       tree guard;
8504       tree guard_init;
8505
8506       /* Emit code to perform this initialization but once.  This code
8507          looks like:
8508
8509            static int guard = 0;
8510            if (!guard) {
8511              // Do initialization.
8512              guard = 1;
8513              // Register variable for destruction at end of program.
8514            }
8515
8516          Note that the `temp' variable is only set to 1 *after* the
8517          initialization is complete.  This ensures that an exception,
8518          thrown during the construction, will cause the variable to
8519          reinitialized when we pass through this code again, as per:
8520
8521            [stmt.dcl]
8522
8523            If the initialization exits by throwing an exception, the
8524            initialization is not complete, so it will be tried again
8525            the next time control enters the declaration.
8526
8527          In theory, this process should be thread-safe, too; multiple
8528          threads should not be able to initialize the variable more
8529          than once.  We don't yet attempt to ensure thread-safety.  */
8530
8531       /* Create the guard variable.  */
8532       guard = get_guard (decl);
8533
8534       /* Begin the conditional initialization.  */
8535       if_stmt = begin_if_stmt ();
8536       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8537       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8538
8539       /* Do the initialization itself.  */
8540       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8541           || (init && TREE_CODE (init) == TREE_LIST))
8542         assignment = build_aggr_init (decl, init, 0);
8543       else if (init)
8544         /* The initialization we're doing here is just a bitwise
8545            copy.  */
8546         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8547       else
8548         assignment = NULL_TREE;
8549
8550       /* Once the assignment is complete, set TEMP to 1.  Since the
8551          construction of the static object is complete at this point,
8552          we want to make sure TEMP is set to 1 even if a temporary
8553          constructed during the initialization throws an exception
8554          when it is destroyed.  So, we combine the initialization and
8555          the assignment to TEMP into a single expression, ensuring
8556          that when we call finish_expr_stmt the cleanups will not be
8557          run until after TEMP is set to 1.  */
8558       guard_init = set_guard (guard);
8559       if (assignment)
8560         {
8561           assignment = tree_cons (NULL_TREE, assignment,
8562                                   build_tree_list (NULL_TREE,
8563                                                    guard_init));
8564           assignment = build_compound_expr (assignment);
8565         }
8566       else
8567         assignment = guard_init;
8568       finish_expr_stmt (assignment);
8569
8570       /* Use atexit to register a function for destroying this static
8571          variable.  */
8572       register_dtor_fn (decl);
8573
8574       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8575       finish_then_clause (if_stmt);
8576       finish_if_stmt ();
8577     }
8578   else
8579     static_aggregates = tree_cons (init, decl, static_aggregates);
8580 }
8581
8582 /* Finish the declaration of a catch-parameter.  */
8583
8584 tree
8585 start_handler_parms (declspecs, declarator)
8586      tree declspecs;
8587      tree declarator;
8588 {
8589   tree decl;
8590   if (declspecs)
8591     {
8592       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8593                              1, NULL_TREE);
8594       if (decl == NULL_TREE)
8595         error ("invalid catch parameter");
8596     }
8597   else
8598     decl = NULL_TREE;
8599
8600   return decl;
8601 }
8602
8603 \f
8604 /* Make TYPE a complete type based on INITIAL_VALUE.
8605    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8606    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8607
8608 int
8609 complete_array_type (type, initial_value, do_default)
8610      tree type, initial_value;
8611      int do_default;
8612 {
8613   register tree maxindex = NULL_TREE;
8614   int value = 0;
8615
8616   if (initial_value)
8617     {
8618       /* An array of character type can be initialized from a
8619          brace-enclosed string constant.  */
8620       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8621           && TREE_CODE (initial_value) == CONSTRUCTOR
8622           && CONSTRUCTOR_ELTS (initial_value)
8623           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8624               == STRING_CST)
8625           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8626         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8627
8628       /* Note MAXINDEX is really the maximum index, one less than the
8629          size.  */
8630       if (TREE_CODE (initial_value) == STRING_CST)
8631         {
8632           int eltsize
8633             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8634           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8635                                    / eltsize) - 1, 0);
8636         }
8637       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8638         {
8639           tree elts = CONSTRUCTOR_ELTS (initial_value);
8640
8641           maxindex = ssize_int (-1);
8642           for (; elts; elts = TREE_CHAIN (elts))
8643             {
8644               if (TREE_PURPOSE (elts))
8645                 maxindex = TREE_PURPOSE (elts);
8646               else
8647                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8648             }
8649           maxindex = copy_node (maxindex);
8650         }
8651       else
8652         {
8653           /* Make an error message unless that happened already.  */
8654           if (initial_value != error_mark_node)
8655             value = 1;
8656           else
8657             initial_value = NULL_TREE;
8658
8659           /* Prevent further error messages.  */
8660           maxindex = build_int_2 (0, 0);
8661         }
8662     }
8663
8664   if (!maxindex)
8665     {
8666       if (do_default)
8667         maxindex = build_int_2 (0, 0);
8668       value = 2;
8669     }
8670
8671   if (maxindex)
8672     {
8673       tree itype;
8674       tree domain;
8675
8676       domain = build_index_type (maxindex);
8677       TYPE_DOMAIN (type) = domain;
8678
8679       if (! TREE_TYPE (maxindex))
8680         TREE_TYPE (maxindex) = domain;
8681       if (initial_value)
8682         itype = TREE_TYPE (initial_value);
8683       else
8684         itype = NULL;
8685       if (itype && !TYPE_DOMAIN (itype))
8686         TYPE_DOMAIN (itype) = domain;
8687       /* The type of the main variant should never be used for arrays
8688          of different sizes.  It should only ever be completed with the
8689          size of the array.  */
8690       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8691         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8692     }
8693
8694   /* Lay out the type now that we can get the real answer.  */
8695
8696   layout_type (type);
8697
8698   return value;
8699 }
8700 \f
8701 /* Return zero if something is declared to be a member of type
8702    CTYPE when in the context of CUR_TYPE.  STRING is the error
8703    message to print in that case.  Otherwise, quietly return 1.  */
8704
8705 static int
8706 member_function_or_else (ctype, cur_type, flags)
8707      tree ctype, cur_type;
8708      enum overload_flags flags;
8709 {
8710   if (ctype && ctype != cur_type)
8711     {
8712       if (flags == DTOR_FLAG)
8713         cp_error ("destructor for alien class `%T' cannot be a member",
8714                   ctype);
8715       else
8716         cp_error ("constructor for alien class `%T' cannot be a member",
8717                   ctype);
8718       return 0;
8719     }
8720   return 1;
8721 }
8722 \f
8723 /* Subroutine of `grokdeclarator'.  */
8724
8725 /* Generate errors possibly applicable for a given set of specifiers.
8726    This is for ARM $7.1.2.  */
8727
8728 static void
8729 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8730      tree object;
8731      const char *type;
8732      int virtualp, quals, friendp, raises, inlinep;
8733 {
8734   if (virtualp)
8735     cp_error ("`%D' declared as a `virtual' %s", object, type);
8736   if (inlinep)
8737     cp_error ("`%D' declared as an `inline' %s", object, type);
8738   if (quals)
8739     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8740               object, type);
8741   if (friendp)
8742     cp_error_at ("`%D' declared as a friend", object);
8743   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8744       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8745     cp_error_at ("`%D' declared with an exception specification", object);
8746 }
8747
8748 /* CTYPE is class type, or null if non-class.
8749    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8750    or METHOD_TYPE.
8751    DECLARATOR is the function's name.
8752    VIRTUALP is truthvalue of whether the function is virtual or not.
8753    FLAGS are to be passed through to `grokclassfn'.
8754    QUALS are qualifiers indicating whether the function is `const'
8755    or `volatile'.
8756    RAISES is a list of exceptions that this function can raise.
8757    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8758    not look, and -1 if we should not call `grokclassfn' at all.
8759
8760    Returns `NULL_TREE' if something goes wrong, after issuing
8761    applicable error messages.  */
8762
8763 static tree
8764 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8765             raises, check, friendp, publicp, inlinep, funcdef_flag,
8766             template_count, in_namespace)
8767      tree ctype, type;
8768      tree declarator;
8769      tree orig_declarator;
8770      int virtualp;
8771      enum overload_flags flags;
8772      tree quals, raises;
8773      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8774      tree in_namespace;
8775 {
8776   tree decl;
8777   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8778   int has_default_arg = 0;
8779   tree t;
8780
8781   if (raises)
8782     {
8783       type = build_exception_variant (type, raises);
8784     }
8785
8786   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8787   /* Propagate volatile out from type to decl. */
8788   if (TYPE_VOLATILE (type))
8789     TREE_THIS_VOLATILE (decl) = 1;
8790
8791   /* If this decl has namespace scope, set that up.  */
8792   if (in_namespace)
8793     set_decl_namespace (decl, in_namespace, friendp);
8794   else if (!ctype)
8795     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8796
8797   /* `main' and builtins have implicit 'C' linkage.  */
8798   if ((MAIN_NAME_P (declarator)
8799        || (IDENTIFIER_LENGTH (declarator) > 10
8800            && IDENTIFIER_POINTER (declarator)[0] == '_'
8801            && IDENTIFIER_POINTER (declarator)[1] == '_'
8802            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8803       && current_lang_name == lang_name_cplusplus
8804       && ctype == NULL_TREE
8805       /* NULL_TREE means global namespace.  */
8806       && DECL_CONTEXT (decl) == NULL_TREE)
8807     SET_DECL_LANGUAGE (decl, lang_c);
8808
8809   /* Should probably propagate const out from type to decl I bet (mrs).  */
8810   if (staticp)
8811     {
8812       DECL_STATIC_FUNCTION_P (decl) = 1;
8813       DECL_CONTEXT (decl) = ctype;
8814     }
8815
8816   if (ctype)
8817     DECL_CONTEXT (decl) = ctype;
8818
8819   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8820     {
8821       if (processing_template_decl)
8822         error ("cannot declare `::main' to be a template");
8823       if (inlinep)
8824         error ("cannot declare `::main' to be inline");
8825       if (!publicp)
8826         error ("cannot declare `::main' to be static");
8827       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8828                         integer_type_node))
8829         error ("`main' must return `int'");
8830       inlinep = 0;
8831       publicp = 1;
8832     }
8833
8834   /* Members of anonymous types and local classes have no linkage; make
8835      them internal.  */
8836   /* FIXME what if it gets a name from typedef?  */
8837   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8838                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8839     publicp = 0;
8840
8841   if (publicp)
8842     {
8843       /* [basic.link]: A name with no linkage (notably, the name of a class
8844          or enumeration declared in a local scope) shall not be used to
8845          declare an entity with linkage.
8846
8847          Only check this for public decls for now.  */
8848       t = no_linkage_check (TREE_TYPE (decl));
8849       if (t)
8850         {
8851           if (TYPE_ANONYMOUS_P (t))
8852             {
8853               if (DECL_EXTERN_C_P (decl))
8854                 /* Allow this; it's pretty common in C.  */;
8855               else
8856                 {
8857                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8858                               decl);
8859                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8860                     cp_pedwarn_at ("\
8861 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8862                                 TYPE_NAME (t));
8863                 }
8864             }
8865           else
8866             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8867                         decl, t);
8868         }
8869     }
8870
8871   TREE_PUBLIC (decl) = publicp;
8872   if (! publicp)
8873     {
8874       DECL_INTERFACE_KNOWN (decl) = 1;
8875       DECL_NOT_REALLY_EXTERN (decl) = 1;
8876     }
8877
8878   /* If the declaration was declared inline, mark it as such.  */
8879   if (inlinep)
8880     DECL_DECLARED_INLINE_P (decl) = 1;
8881   /* We inline functions that are explicitly declared inline, or, when
8882      the user explicitly asks us to, all functions.  */
8883   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8884     DECL_INLINE (decl) = 1;
8885
8886   DECL_EXTERNAL (decl) = 1;
8887   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8888     {
8889       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8890                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8891       quals = NULL_TREE;
8892     }
8893
8894   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8895     grok_op_properties (decl, virtualp, check < 0);
8896
8897   if (ctype && decl_function_context (decl))
8898     DECL_NO_STATIC_CHAIN (decl) = 1;
8899
8900   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8901     if (TREE_PURPOSE (t)
8902         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8903       {
8904         has_default_arg = 1;
8905         break;
8906       }
8907
8908   if (friendp
8909       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8910     {
8911       if (funcdef_flag)
8912         cp_error
8913           ("defining explicit specialization `%D' in friend declaration",
8914            orig_declarator);
8915       else
8916         {
8917           tree fns = TREE_OPERAND (orig_declarator, 0);
8918           tree args = TREE_OPERAND (orig_declarator, 1);
8919
8920           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8921             {
8922               /* Something like `template <class T> friend void f<T>()'.  */
8923               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8924                         orig_declarator);
8925               return NULL_TREE;
8926             }
8927
8928
8929           /* A friend declaration of the form friend void f<>().  Record
8930              the information in the TEMPLATE_ID_EXPR.  */
8931           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8932
8933           if (TREE_CODE (fns) == COMPONENT_REF)
8934             {
8935               /* Due to bison parser ickiness, we will have already looked
8936                  up an operator_name or PFUNCNAME within the current class
8937                  (see template_id in parse.y). If the current class contains
8938                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8939
8940               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8941                                   == current_class_type, 20001120);
8942               fns = TREE_OPERAND (fns, 1);
8943             }
8944           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8945                               || TREE_CODE (fns) == LOOKUP_EXPR
8946                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8947           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8948
8949           if (has_default_arg)
8950             {
8951               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8952                         decl);
8953               return NULL_TREE;
8954             }
8955
8956           if (inlinep)
8957             {
8958               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8959                         decl);
8960               return NULL_TREE;
8961             }
8962         }
8963     }
8964
8965   if (has_default_arg)
8966     add_defarg_fn (decl);
8967
8968   if (funcdef_flag)
8969     /* Make the init_value nonzero so pushdecl knows this is not
8970        tentative.  error_mark_node is replaced later with the BLOCK.  */
8971     DECL_INITIAL (decl) = error_mark_node;
8972
8973   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8974     TREE_NOTHROW (decl) = 1;
8975
8976   /* Caller will do the rest of this.  */
8977   if (check < 0)
8978     return decl;
8979
8980   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8981     DECL_CONSTRUCTOR_P (decl) = 1;
8982
8983   /* Function gets the ugly name, field gets the nice one.  This call
8984      may change the type of the function (because of default
8985      parameters)!  */
8986   if (ctype != NULL_TREE)
8987     grokclassfn (ctype, decl, flags, quals);
8988
8989   decl = check_explicit_specialization (orig_declarator, decl,
8990                                         template_count,
8991                                         2 * (funcdef_flag != 0) +
8992                                         4 * (friendp != 0));
8993   if (decl == error_mark_node)
8994     return NULL_TREE;
8995
8996   if (ctype != NULL_TREE
8997       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8998       && check)
8999     {
9000       tree old_decl;
9001
9002       old_decl = check_classfn (ctype, decl);
9003
9004       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9005         /* Because grokfndecl is always supposed to return a
9006            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9007            here.  We depend on our callers to figure out that its
9008            really a template that's being returned.  */
9009         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9010
9011       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9012           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9013         {
9014           /* Remove the `this' parm added by grokclassfn.
9015              XXX Isn't this done in start_function, too?  */
9016           revert_static_member_fn (decl);
9017           last_function_parms = TREE_CHAIN (last_function_parms);
9018         }
9019       if (old_decl && DECL_ARTIFICIAL (old_decl))
9020         cp_error ("definition of implicitly-declared `%D'", old_decl);
9021
9022       if (old_decl)
9023         {
9024           /* Since we've smashed OLD_DECL to its
9025              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9026           if (TREE_CODE (decl) == TEMPLATE_DECL)
9027             decl = DECL_TEMPLATE_RESULT (decl);
9028
9029           /* Attempt to merge the declarations.  This can fail, in
9030              the case of some illegal specialization declarations.  */
9031           if (!duplicate_decls (decl, old_decl))
9032             cp_error ("no `%#D' member function declared in class `%T'",
9033                       decl, ctype);
9034           return old_decl;
9035         }
9036     }
9037
9038   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9039     return NULL_TREE;
9040
9041   if (ctype == NULL_TREE || check)
9042     return decl;
9043
9044   if (virtualp)
9045     DECL_VIRTUAL_P (decl) = 1;
9046
9047   return decl;
9048 }
9049
9050 static tree
9051 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9052      tree type;
9053      tree declarator;
9054      RID_BIT_TYPE *specbits_in;
9055      int initialized;
9056      int constp;
9057      tree in_namespace;
9058 {
9059   tree decl;
9060   RID_BIT_TYPE specbits;
9061
9062   specbits = *specbits_in;
9063
9064   if (TREE_CODE (type) == OFFSET_TYPE)
9065     {
9066       /* If you declare a static member so that it
9067          can be initialized, the code will reach here.  */
9068       tree basetype = TYPE_OFFSET_BASETYPE (type);
9069       type = TREE_TYPE (type);
9070       decl = build_lang_decl (VAR_DECL, declarator, type);
9071       DECL_CONTEXT (decl) = basetype;
9072     }
9073   else
9074     {
9075       tree context;
9076
9077       if (in_namespace)
9078         context = in_namespace;
9079       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9080         context = current_namespace;
9081       else
9082         context = NULL_TREE;
9083
9084       /* For namespace-scope variables, declared in a template, we
9085          need the full lang_decl.  The same is true for
9086          namespace-scope variables that do not have C++ language
9087          linkage.  */
9088       if (context
9089           && (processing_template_decl
9090               || current_lang_name != lang_name_cplusplus))
9091         decl = build_lang_decl (VAR_DECL, declarator, type);
9092       else
9093         decl = build_decl (VAR_DECL, declarator, type);
9094
9095       if (context)
9096         set_decl_namespace (decl, context, 0);
9097
9098       context = DECL_CONTEXT (decl);
9099       if (declarator && context && current_lang_name != lang_name_c)
9100         /* We can't mangle lazily here because we don't have any
9101            way to recover whether or not a variable was `extern
9102            "C"' later.  */
9103         mangle_decl (decl);
9104     }
9105
9106   if (in_namespace)
9107     set_decl_namespace (decl, in_namespace, 0);
9108
9109   if (RIDBIT_SETP (RID_EXTERN, specbits))
9110     {
9111       DECL_THIS_EXTERN (decl) = 1;
9112       DECL_EXTERNAL (decl) = !initialized;
9113     }
9114
9115   /* In class context, static means one per class,
9116      public access, and static storage.  */
9117   if (DECL_CLASS_SCOPE_P (decl))
9118     {
9119       TREE_PUBLIC (decl) = 1;
9120       TREE_STATIC (decl) = 1;
9121       DECL_EXTERNAL (decl) = 0;
9122     }
9123   /* At top level, either `static' or no s.c. makes a definition
9124      (perhaps tentative), and absence of `static' makes it public.  */
9125   else if (toplevel_bindings_p ())
9126     {
9127       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9128                             && (DECL_THIS_EXTERN (decl) || ! constp));
9129       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9130     }
9131   /* Not at top level, only `static' makes a static definition.  */
9132   else
9133     {
9134       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9135       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9136     }
9137
9138   if (TREE_PUBLIC (decl))
9139     {
9140       /* [basic.link]: A name with no linkage (notably, the name of a class
9141          or enumeration declared in a local scope) shall not be used to
9142          declare an entity with linkage.
9143
9144          Only check this for public decls for now.  */
9145       tree t = no_linkage_check (TREE_TYPE (decl));
9146       if (t)
9147         {
9148           if (TYPE_ANONYMOUS_P (t))
9149             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9150           else
9151             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9152                         decl, t);
9153         }
9154     }
9155
9156   return decl;
9157 }
9158
9159 /* Create and return a canonical pointer to member function type, for
9160    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9161
9162 tree
9163 build_ptrmemfunc_type (type)
9164      tree type;
9165 {
9166   tree fields[4];
9167   tree t;
9168   tree unqualified_variant = NULL_TREE;
9169
9170   if (type == error_mark_node)
9171     return type;
9172
9173   /* If a canonical type already exists for this type, use it.  We use
9174      this method instead of type_hash_canon, because it only does a
9175      simple equality check on the list of field members.  */
9176
9177   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9178     return t;
9179
9180   /* Make sure that we always have the unqualified pointer-to-member
9181      type first.  */
9182   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9183     unqualified_variant
9184       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9185
9186   t = make_aggr_type (RECORD_TYPE);
9187   /* Let the front-end know this is a pointer to member function...  */
9188   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9189   /* ... and not really an aggregate.  */
9190   SET_IS_AGGR_TYPE (t, 0);
9191
9192   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9193   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9194                           delta_type_node);
9195   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9196
9197   /* Zap out the name so that the back-end will give us the debugging
9198      information for this anonymous RECORD_TYPE.  */
9199   TYPE_NAME (t) = NULL_TREE;
9200
9201   /* If this is not the unqualified form of this pointer-to-member
9202      type, set the TYPE_MAIN_VARIANT for this type to be the
9203      unqualified type.  Since they are actually RECORD_TYPEs that are
9204      not variants of each other, we must do this manually.  */
9205   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9206     {
9207       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9208       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9209       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9210       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9211     }
9212
9213   /* Cache this pointer-to-member type so that we can find it again
9214      later.  */
9215   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9216
9217   /* Seems to be wanted.  */
9218   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9219
9220   return t;
9221 }
9222
9223 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9224    Check to see that the definition is valid.  Issue appropriate error
9225    messages.  Return 1 if the definition is particularly bad, or 0
9226    otherwise.  */
9227
9228 int
9229 check_static_variable_definition (decl, type)
9230      tree decl;
9231      tree type;
9232 {
9233   /* Motion 10 at San Diego: If a static const integral data member is
9234      initialized with an integral constant expression, the initializer
9235      may appear either in the declaration (within the class), or in
9236      the definition, but not both.  If it appears in the class, the
9237      member is a member constant.  The file-scope definition is always
9238      required.  */
9239   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9240     {
9241       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9242                 type);
9243       /* If we just return the declaration, crashes will sometimes
9244          occur.  We therefore return void_type_node, as if this was a
9245          friend declaration, to cause callers to completely ignore
9246          this declaration.  */
9247       return 1;
9248     }
9249   else if (!CP_TYPE_CONST_P (type))
9250     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9251               decl);
9252   else if (pedantic && !INTEGRAL_TYPE_P (type))
9253     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9254
9255   return 0;
9256 }
9257
9258 /* Given the SIZE (i.e., number of elements) in an array, compute an
9259    appropriate index type for the array.  If non-NULL, NAME is the
9260    name of the thing being declared.  */
9261
9262 tree
9263 compute_array_index_type (name, size)
9264      tree name;
9265      tree size;
9266 {
9267   tree itype;
9268
9269   /* If this involves a template parameter, it will be a constant at
9270      instantiation time, but we don't know what the value is yet.
9271      Even if no template parameters are involved, we may an expression
9272      that is not a constant; we don't even simplify `1 + 2' when
9273      processing a template.  */
9274   if (processing_template_decl)
9275     {
9276       /* Resolve a qualified reference to an enumerator or static
9277          const data member of ours.  */
9278       if (TREE_CODE (size) == SCOPE_REF
9279           && TREE_OPERAND (size, 0) == current_class_type)
9280         {
9281           tree t = lookup_field (current_class_type,
9282                                  TREE_OPERAND (size, 1), 0, 0);
9283           if (t)
9284             size = t;
9285         }
9286
9287       return build_index_type (build_min (MINUS_EXPR, sizetype,
9288                                           size, integer_one_node));
9289     }
9290
9291   /* The size might be the result of a cast. */
9292   STRIP_TYPE_NOPS (size);
9293
9294   /* It might be a const variable or enumeration constant.  */
9295   size = decl_constant_value (size);
9296
9297   /* The array bound must be an integer type.  */
9298   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9299       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9300       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9301     {
9302       if (name)
9303         cp_error ("size of array `%D' has non-integer type", name);
9304       else
9305         cp_error ("size of array has non-integer type");
9306       size = integer_one_node;
9307     }
9308
9309   /* Normally, the array-bound will be a constant.  */
9310   if (TREE_CODE (size) == INTEGER_CST)
9311     {
9312       /* Check to see if the array bound overflowed.  Make that an
9313          error, no matter how generous we're being.  */
9314       int old_flag_pedantic_errors = flag_pedantic_errors;
9315       int old_pedantic = pedantic;
9316       pedantic = flag_pedantic_errors = 1;
9317       constant_expression_warning (size);
9318       pedantic = old_pedantic;
9319       flag_pedantic_errors = old_flag_pedantic_errors;
9320
9321       /* An array must have a positive number of elements.  */
9322       if (INT_CST_LT (size, integer_zero_node))
9323         {
9324           if (name)
9325             cp_error ("size of array `%D' is negative", name);
9326           else
9327             cp_error ("size of array is negative");
9328           size = integer_one_node;
9329         }
9330       /* Except that an extension we allow zero-sized arrays.  We
9331          always allow them in system headers because glibc uses
9332          them.  */
9333       else if (integer_zerop (size) && pedantic && !in_system_header)
9334         {
9335           if (name)
9336             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9337           else
9338             cp_pedwarn ("ISO C++ forbids zero-size array");
9339         }
9340     }
9341   else if (TREE_CONSTANT (size))
9342     {
9343       /* `(int) &fn' is not a valid array bound.  */
9344       if (name)
9345         cp_error ("size of array `%D' is not an integral constant-expression",
9346                   name);
9347       else
9348         cp_error ("size of array is not an integral constant-expression");
9349     }
9350
9351   /* Compute the index of the largest element in the array.  It is
9352      one less than the number of elements in the array.  */
9353   itype
9354     = fold (cp_build_binary_op (MINUS_EXPR,
9355                                 cp_convert (ssizetype, size),
9356                                 cp_convert (ssizetype,
9357                                             integer_one_node)));
9358
9359   /* Check for variable-sized arrays.  We allow such things as an
9360      extension, even though they are not allowed in ANSI/ISO C++.  */
9361   if (!TREE_CONSTANT (itype))
9362     {
9363       if (pedantic)
9364         {
9365           if (name)
9366             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9367                         name);
9368           else
9369             cp_pedwarn ("ISO C++ forbids variable-size array");
9370         }
9371
9372       /* Create a variable-sized array index type.  */
9373       itype = variable_size (itype);
9374     }
9375   /* Make sure that there was no overflow when creating to a signed
9376      index type.  (For example, on a 32-bit machine, an array with
9377      size 2^32 - 1 is too big.)  */
9378   else if (TREE_OVERFLOW (itype))
9379     {
9380       error ("overflow in array dimension");
9381       TREE_OVERFLOW (itype) = 0;
9382     }
9383
9384   /* Create and return the appropriate index type.  */
9385   return build_index_type (itype);
9386 }
9387
9388 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9389    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9390    with this type.  */
9391
9392 static tree
9393 create_array_type_for_decl (name, type, size)
9394      tree name;
9395      tree type;
9396      tree size;
9397 {
9398   tree itype = NULL_TREE;
9399   const char* error_msg;
9400
9401   /* If things have already gone awry, bail now.  */
9402   if (type == error_mark_node || size == error_mark_node)
9403     return error_mark_node;
9404
9405   /* Assume that everything will go OK.  */
9406   error_msg = NULL;
9407
9408   /* There are some types which cannot be array elements.  */
9409   switch (TREE_CODE (type))
9410     {
9411     case VOID_TYPE:
9412       error_msg = "array of void";
9413       break;
9414
9415     case FUNCTION_TYPE:
9416       error_msg = "array of functions";
9417       break;
9418
9419     case REFERENCE_TYPE:
9420       error_msg = "array of references";
9421       break;
9422
9423     case OFFSET_TYPE:
9424       error_msg = "array of data members";
9425       break;
9426
9427     case METHOD_TYPE:
9428       error_msg = "array of function members";
9429       break;
9430
9431     default:
9432       break;
9433     }
9434
9435   /* If something went wrong, issue an error-message and return.  */
9436   if (error_msg)
9437     {
9438       if (name)
9439         cp_error ("declaration of `%D' as %s", name, error_msg);
9440       else
9441         cp_error ("creating %s", error_msg);
9442
9443       return error_mark_node;
9444     }
9445
9446   /* [dcl.array]
9447
9448      The constant expressions that specify the bounds of the arrays
9449      can be omitted only for the first member of the sequence.  */
9450   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9451     {
9452       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9453                 name);
9454
9455       return error_mark_node;
9456     }
9457
9458   /* Figure out the index type for the array.  */
9459   if (size)
9460     itype = compute_array_index_type (name, size);
9461
9462   return build_cplus_array_type (type, itype);
9463 }
9464
9465 /* Check that it's OK to declare a function with the indicated TYPE.
9466    SFK indicates the kind of special function (if any) that this
9467    function is.  OPTYPE is the type given in a conversion operator
9468    declaration.  Returns the actual return type of the function; that
9469    may be different than TYPE if an error occurs, or for certain
9470    special functions.  */
9471
9472 static tree
9473 check_special_function_return_type (sfk, type, optype)
9474      special_function_kind sfk;
9475      tree type;
9476      tree optype;
9477 {
9478   switch (sfk)
9479     {
9480     case sfk_constructor:
9481       if (type)
9482         cp_error ("return type specification for constructor invalid");
9483
9484       /* In the new ABI constructors do not return a value.  */
9485       type = void_type_node;
9486       break;
9487
9488     case sfk_destructor:
9489       if (type)
9490         cp_error ("return type specification for destructor invalid");
9491       type = void_type_node;
9492       break;
9493
9494     case sfk_conversion:
9495       if (type && !same_type_p (type, optype))
9496         cp_error ("operator `%T' declared to return `%T'", optype, type);
9497       else if (type)
9498         cp_pedwarn ("return type specified for `operator %T'",  optype);
9499       type = optype;
9500       break;
9501
9502     default:
9503       my_friendly_abort (20000408);
9504       break;
9505     }
9506
9507   return type;
9508 }
9509
9510 /* Given declspecs and a declarator,
9511    determine the name and type of the object declared
9512    and construct a ..._DECL node for it.
9513    (In one case we can return a ..._TYPE node instead.
9514     For invalid input we sometimes return 0.)
9515
9516    DECLSPECS is a chain of tree_list nodes whose value fields
9517     are the storage classes and type specifiers.
9518
9519    DECL_CONTEXT says which syntactic context this declaration is in:
9520      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9521      FUNCDEF for a function definition.  Like NORMAL but a few different
9522       error messages in each case.  Return value may be zero meaning
9523       this definition is too screwy to try to parse.
9524      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9525       handle member functions (which have FIELD context).
9526       Return value may be zero meaning this definition is too screwy to
9527       try to parse.
9528      PARM for a parameter declaration (either within a function prototype
9529       or before a function body).  Make a PARM_DECL, or return void_type_node.
9530      CATCHPARM for a parameter declaration before a catch clause.
9531      TYPENAME if for a typename (in a cast or sizeof).
9532       Don't make a DECL node; just return the ..._TYPE node.
9533      FIELD for a struct or union field; make a FIELD_DECL.
9534      BITFIELD for a field with specified width.
9535    INITIALIZED is 1 if the decl has an initializer.
9536
9537    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9538    normal attributes in TREE_PURPOSE, or NULL_TREE.
9539
9540    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9541    It may also be so in the PARM case, for a prototype where the
9542    argument type is specified but not the name.
9543
9544    This function is where the complicated C meanings of `static'
9545    and `extern' are interpreted.
9546
9547    For C++, if there is any monkey business to do, the function which
9548    calls this one must do it, i.e., prepending instance variables,
9549    renaming overloaded function names, etc.
9550
9551    Note that for this C++, it is an error to define a method within a class
9552    which does not belong to that class.
9553
9554    Except in the case where SCOPE_REFs are implicitly known (such as
9555    methods within a class being redundantly qualified),
9556    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9557    (class_name::decl_name).  The caller must also deal with this.
9558
9559    If a constructor or destructor is seen, and the context is FIELD,
9560    then the type gains the attribute TREE_HAS_x.  If such a declaration
9561    is erroneous, NULL_TREE is returned.
9562
9563    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9564    function, these are the qualifiers to give to the `this' pointer. We
9565    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9566
9567    May return void_type_node if the declarator turned out to be a friend.
9568    See grokfield for details.  */
9569
9570 tree
9571 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9572      tree declspecs;
9573      tree declarator;
9574      enum decl_context decl_context;
9575      int initialized;
9576      tree attrlist;
9577 {
9578   RID_BIT_TYPE specbits;
9579   int nclasses = 0;
9580   tree spec;
9581   tree type = NULL_TREE;
9582   int longlong = 0;
9583   int constp;
9584   int restrictp;
9585   int volatilep;
9586   int type_quals;
9587   int virtualp, explicitp, friendp, inlinep, staticp;
9588   int explicit_int = 0;
9589   int explicit_char = 0;
9590   int defaulted_int = 0;
9591   tree typedef_decl = NULL_TREE;
9592   const char *name;
9593   tree typedef_type = NULL_TREE;
9594   int funcdef_flag = 0;
9595   enum tree_code innermost_code = ERROR_MARK;
9596   int bitfield = 0;
9597 #if 0
9598   /* See the code below that used this.  */
9599   tree decl_machine_attr = NULL_TREE;
9600 #endif
9601   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9602      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9603   tree init = NULL_TREE;
9604
9605   /* Keep track of what sort of function is being processed
9606      so that we can warn about default return values, or explicit
9607      return values which do not match prescribed defaults.  */
9608   special_function_kind sfk = sfk_none;
9609
9610   tree dname = NULL_TREE;
9611   tree ctype = current_class_type;
9612   tree ctor_return_type = NULL_TREE;
9613   enum overload_flags flags = NO_SPECIAL;
9614   tree quals = NULL_TREE;
9615   tree raises = NULL_TREE;
9616   int template_count = 0;
9617   tree in_namespace = NULL_TREE;
9618   tree inner_attrs;
9619   int ignore_attrs;
9620
9621   RIDBIT_RESET_ALL (specbits);
9622   if (decl_context == FUNCDEF)
9623     funcdef_flag = 1, decl_context = NORMAL;
9624   else if (decl_context == MEMFUNCDEF)
9625     funcdef_flag = -1, decl_context = FIELD;
9626   else if (decl_context == BITFIELD)
9627     bitfield = 1, decl_context = FIELD;
9628
9629   /* Look inside a declarator for the name being declared
9630      and get it as a string, for an error message.  */
9631   {
9632     tree *next = &declarator;
9633     register tree decl;
9634     name = NULL;
9635
9636     while (next && *next)
9637       {
9638         decl = *next;
9639         switch (TREE_CODE (decl))
9640           {
9641           case TREE_LIST:
9642             /* For attributes.  */
9643             next = &TREE_VALUE (decl);
9644             break;
9645
9646           case COND_EXPR:
9647             ctype = NULL_TREE;
9648             next = &TREE_OPERAND (decl, 0);
9649             break;
9650
9651           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9652             {
9653               tree name = TREE_OPERAND (decl, 0);
9654               tree rename = NULL_TREE;
9655
9656               my_friendly_assert (flags == NO_SPECIAL, 152);
9657               flags = DTOR_FLAG;
9658               sfk = sfk_destructor;
9659               if (TREE_CODE (name) == TYPE_DECL)
9660                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9661               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9662               if (ctype == NULL_TREE)
9663                 {
9664                   if (current_class_type == NULL_TREE)
9665                     {
9666                       error ("destructors must be member functions");
9667                       flags = NO_SPECIAL;
9668                     }
9669                   else
9670                     {
9671                       tree t = constructor_name (current_class_name);
9672                       if (t != name)
9673                         rename = t;
9674                     }
9675                 }
9676               else
9677                 {
9678                   tree t = constructor_name (ctype);
9679                   if (t != name)
9680                     rename = t;
9681                 }
9682
9683               if (rename)
9684                 {
9685                   cp_error ("destructor `%T' must match class name `%T'",
9686                             name, rename);
9687                   TREE_OPERAND (decl, 0) = rename;
9688                 }
9689               next = &name;
9690             }
9691             break;
9692
9693           case ADDR_EXPR:       /* C++ reference declaration */
9694             /* Fall through. */
9695           case ARRAY_REF:
9696           case INDIRECT_REF:
9697             ctype = NULL_TREE;
9698             innermost_code = TREE_CODE (decl);
9699             next = &TREE_OPERAND (decl, 0);
9700             break;
9701
9702           case CALL_EXPR:
9703             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9704               {
9705                 /* This is actually a variable declaration using
9706                    constructor syntax.  We need to call start_decl and
9707                    cp_finish_decl so we can get the variable
9708                    initialized...  */
9709
9710                 tree attributes, prefix_attributes;
9711
9712                 *next = TREE_OPERAND (decl, 0);
9713                 init = CALL_DECLARATOR_PARMS (decl);
9714
9715                 if (attrlist)
9716                   {
9717                     attributes = TREE_PURPOSE (attrlist);
9718                     prefix_attributes = TREE_VALUE (attrlist);
9719                   }
9720                 else
9721                   {
9722                     attributes = NULL_TREE;
9723                     prefix_attributes = NULL_TREE;
9724                   }
9725
9726                 decl = start_decl (declarator, declspecs, 1,
9727                                    attributes, prefix_attributes);
9728                 decl_type_access_control (decl);
9729                 if (decl)
9730                   {
9731                     /* Look for __unused__ attribute */
9732                     if (TREE_USED (TREE_TYPE (decl)))
9733                       TREE_USED (decl) = 1;
9734                     finish_decl (decl, init, NULL_TREE);
9735                   }
9736                 else
9737                   cp_error ("invalid declarator");
9738                 return 0;
9739               }
9740             innermost_code = TREE_CODE (decl);
9741             if (decl_context == FIELD && ctype == NULL_TREE)
9742               ctype = current_class_type;
9743             if (ctype
9744                 && TREE_OPERAND (decl, 0)
9745                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9746                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9747                          == constructor_name_full (ctype))
9748                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9749                             == constructor_name (ctype)))))
9750               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9751             next = &TREE_OPERAND (decl, 0);
9752             decl = *next;
9753             if (ctype != NULL_TREE
9754                 && decl != NULL_TREE && flags != DTOR_FLAG
9755                 && decl == constructor_name (ctype))
9756               {
9757                 sfk = sfk_constructor;
9758                 ctor_return_type = ctype;
9759               }
9760             ctype = NULL_TREE;
9761             break;
9762
9763           case TEMPLATE_ID_EXPR:
9764               {
9765                 tree fns = TREE_OPERAND (decl, 0);
9766
9767                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9768                   fns = TREE_OPERAND (fns, 0);
9769
9770                 dname = fns;
9771                 if (TREE_CODE (dname) == COMPONENT_REF)
9772                   dname = TREE_OPERAND (dname, 1);
9773                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9774                   {
9775                     my_friendly_assert (is_overloaded_fn (dname),
9776                                         19990331);
9777                     dname = DECL_NAME (get_first_fn (dname));
9778                   }
9779               }
9780           /* Fall through. */
9781
9782           case IDENTIFIER_NODE:
9783             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9784               dname = decl;
9785
9786             next = 0;
9787
9788             if (C_IS_RESERVED_WORD (dname))
9789               {
9790                 cp_error ("declarator-id missing; using reserved word `%D'",
9791                           dname);
9792                 name = IDENTIFIER_POINTER (dname);
9793               }
9794             else if (!IDENTIFIER_TYPENAME_P (dname))
9795               name = IDENTIFIER_POINTER (dname);
9796             else
9797               {
9798                 my_friendly_assert (flags == NO_SPECIAL, 154);
9799                 flags = TYPENAME_FLAG;
9800                 ctor_return_type = TREE_TYPE (dname);
9801                 sfk = sfk_conversion;
9802                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9803                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9804                         == TYPE_DECL))
9805                   name = IDENTIFIER_POINTER (dname);
9806                 else
9807                   name = "<invalid operator>";
9808               }
9809             break;
9810
9811             /* C++ extension */
9812           case SCOPE_REF:
9813             {
9814               /* Perform error checking, and decide on a ctype.  */
9815               tree cname = TREE_OPERAND (decl, 0);
9816               if (cname == NULL_TREE)
9817                 ctype = NULL_TREE;
9818               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9819                 {
9820                   ctype = NULL_TREE;
9821                   in_namespace = TREE_OPERAND (decl, 0);
9822                   TREE_OPERAND (decl, 0) = NULL_TREE;
9823                 }
9824               else if (! is_aggr_type (cname, 1))
9825                 TREE_OPERAND (decl, 0) = NULL_TREE;
9826               /* Must test TREE_OPERAND (decl, 1), in case user gives
9827                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9828               else if (TREE_OPERAND (decl, 1)
9829                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9830                 ctype = cname;
9831               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9832                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9833                 {
9834                   cp_error ("`%T::%D' is not a valid declarator", cname,
9835                             TREE_OPERAND (decl, 1));
9836                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9837                             cname, TREE_OPERAND (decl, 1));
9838                   return void_type_node;
9839                 }
9840               else if (ctype == NULL_TREE)
9841                 ctype = cname;
9842               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9843                 TREE_OPERAND (decl, 0) = ctype;
9844               else
9845                 {
9846                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9847                     {
9848                       cp_error ("type `%T' is not derived from type `%T'",
9849                                 cname, ctype);
9850                       TREE_OPERAND (decl, 0) = NULL_TREE;
9851                     }
9852                   else
9853                     ctype = cname;
9854                 }
9855
9856               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9857                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9858                        == constructor_name_full (ctype))
9859                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9860                           == constructor_name (ctype))))
9861                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9862               next = &TREE_OPERAND (decl, 1);
9863               decl = *next;
9864               if (ctype)
9865                 {
9866                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9867                       && constructor_name (ctype) == decl)
9868                     {
9869                       sfk = sfk_constructor;
9870                       ctor_return_type = ctype;
9871                     }
9872                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9873                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9874                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9875                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9876                     {
9877                       sfk = sfk_destructor;
9878                       ctor_return_type = ctype;
9879                       flags = DTOR_FLAG;
9880                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9881                       next = &TREE_OPERAND (decl, 0);
9882                     }
9883                 }
9884             }
9885             break;
9886
9887           case ERROR_MARK:
9888             next = 0;
9889             break;
9890
9891           case TYPE_DECL:
9892             /* Parse error puts this typespec where
9893                a declarator should go.  */
9894             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9895             if (TREE_TYPE (decl) == current_class_type)
9896               cp_error ("  perhaps you want `%T' for a constructor",
9897                         current_class_name);
9898             dname = DECL_NAME (decl);
9899             name = IDENTIFIER_POINTER (dname);
9900
9901             /* Avoid giving two errors for this.  */
9902             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9903
9904             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9905             *next = dname;
9906             next = 0;
9907             break;
9908
9909           default:
9910             cp_compiler_error ("`%D' as declarator", decl);
9911             return 0; /* We used to do a 155 abort here.  */
9912           }
9913       }
9914   }
9915
9916   /* A function definition's declarator must have the form of
9917      a function declarator.  */
9918
9919   if (funcdef_flag && innermost_code != CALL_EXPR)
9920     return 0;
9921
9922   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9923       && innermost_code != CALL_EXPR
9924       && ! (ctype && declspecs == NULL_TREE))
9925     {
9926       cp_error ("declaration of `%D' as non-function", dname);
9927       return void_type_node;
9928     }
9929
9930   /* Anything declared one level down from the top level
9931      must be one of the parameters of a function
9932      (because the body is at least two levels down).  */
9933
9934   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9935      by not allowing C++ class definitions to specify their parameters
9936      with xdecls (must be spec.d in the parmlist).
9937
9938      Since we now wait to push a class scope until we are sure that
9939      we are in a legitimate method context, we must set oldcname
9940      explicitly (since current_class_name is not yet alive).
9941
9942      We also want to avoid calling this a PARM if it is in a namespace.  */
9943
9944   if (decl_context == NORMAL && !toplevel_bindings_p ())
9945     {
9946       struct binding_level *b = current_binding_level;
9947       current_binding_level = b->level_chain;
9948       if (current_binding_level != 0 && toplevel_bindings_p ())
9949         decl_context = PARM;
9950       current_binding_level = b;
9951     }
9952
9953   if (name == NULL)
9954     name = decl_context == PARM ? "parameter" : "type name";
9955
9956   /* Look through the decl specs and record which ones appear.
9957      Some typespecs are defined as built-in typenames.
9958      Others, the ones that are modifiers of other types,
9959      are represented by bits in SPECBITS: set the bits for
9960      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9961
9962      If there is a typedef name or a type, store the type in TYPE.
9963      This includes builtin typedefs such as `int'.
9964
9965      Set EXPLICIT_INT if the type is `int' or `char' and did not
9966      come from a user typedef.
9967
9968      Set LONGLONG if `long' is mentioned twice.
9969
9970      For C++, constructors and destructors have their own fast treatment.  */
9971
9972   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9973     {
9974       register int i;
9975       register tree id;
9976
9977       /* Certain parse errors slip through.  For example,
9978          `int class;' is not caught by the parser. Try
9979          weakly to recover here.  */
9980       if (TREE_CODE (spec) != TREE_LIST)
9981         return 0;
9982
9983       id = TREE_VALUE (spec);
9984
9985       if (TREE_CODE (id) == IDENTIFIER_NODE)
9986         {
9987           if (id == ridpointers[(int) RID_INT]
9988               || id == ridpointers[(int) RID_CHAR]
9989               || id == ridpointers[(int) RID_BOOL]
9990               || id == ridpointers[(int) RID_WCHAR])
9991             {
9992               if (type)
9993                 {
9994                   if (id == ridpointers[(int) RID_BOOL])
9995                     error ("`bool' is now a keyword");
9996                   else
9997                     cp_error ("extraneous `%T' ignored", id);
9998                 }
9999               else
10000                 {
10001                   if (id == ridpointers[(int) RID_INT])
10002                     explicit_int = 1;
10003                   else if (id == ridpointers[(int) RID_CHAR])
10004                     explicit_char = 1;
10005                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10006                 }
10007               goto found;
10008             }
10009           /* C++ aggregate types.  */
10010           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10011             {
10012               if (type)
10013                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10014               else
10015                 type = IDENTIFIER_TYPE_VALUE (id);
10016               goto found;
10017             }
10018
10019           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10020             {
10021               if (ridpointers[i] == id)
10022                 {
10023                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10024                     {
10025                       if (pedantic && ! in_system_header && warn_long_long)
10026                         pedwarn ("ISO C++ does not support `long long'");
10027                       if (longlong)
10028                         error ("`long long long' is too long for GCC");
10029                       else
10030                         longlong = 1;
10031                     }
10032                   else if (RIDBIT_SETP (i, specbits))
10033                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10034                   RIDBIT_SET (i, specbits);
10035                   goto found;
10036                 }
10037             }
10038         }
10039       /* C++ aggregate types.  */
10040       else if (TREE_CODE (id) == TYPE_DECL)
10041         {
10042           if (type)
10043             cp_error ("multiple declarations `%T' and `%T'", type,
10044                       TREE_TYPE (id));
10045           else
10046             {
10047               type = TREE_TYPE (id);
10048               TREE_VALUE (spec) = type;
10049             }
10050           goto found;
10051         }
10052       if (type)
10053         error ("two or more data types in declaration of `%s'", name);
10054       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10055         {
10056           register tree t = lookup_name (id, 1);
10057           if (!t || TREE_CODE (t) != TYPE_DECL)
10058             error ("`%s' fails to be a typedef or built in type",
10059                    IDENTIFIER_POINTER (id));
10060           else
10061             {
10062               type = TREE_TYPE (t);
10063 #if 0
10064               /* See the code below that used this.  */
10065               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10066 #endif
10067               typedef_decl = t;
10068             }
10069         }
10070       else if (id != error_mark_node)
10071         /* Can't change CLASS nodes into RECORD nodes here!  */
10072         type = id;
10073
10074     found: ;
10075     }
10076
10077   typedef_type = type;
10078
10079   /* No type at all: default to `int', and set DEFAULTED_INT
10080      because it was not a user-defined typedef.  */
10081
10082   if (type == NULL_TREE
10083       && (RIDBIT_SETP (RID_SIGNED, specbits)
10084           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10085           || RIDBIT_SETP (RID_LONG, specbits)
10086           || RIDBIT_SETP (RID_SHORT, specbits)))
10087     {
10088       /* These imply 'int'.  */
10089       type = integer_type_node;
10090       defaulted_int = 1;
10091     }
10092
10093   if (sfk != sfk_none)
10094     type = check_special_function_return_type (sfk, type,
10095                                                ctor_return_type);
10096   else if (type == NULL_TREE)
10097     {
10098       int is_main;
10099
10100       explicit_int = -1;
10101
10102       /* We handle `main' specially here, because 'main () { }' is so
10103          common.  With no options, it is allowed.  With -Wreturn-type,
10104          it is a warning.  It is only an error with -pedantic-errors.  */
10105       is_main = (funcdef_flag
10106                  && MAIN_NAME_P (dname)
10107                  && ctype == NULL_TREE
10108                  && in_namespace == NULL_TREE
10109                  && current_namespace == global_namespace);
10110
10111       if (in_system_header || flag_ms_extensions)
10112         /* Allow it, sigh.  */;
10113       else if (pedantic || ! is_main)
10114         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10115                     name);
10116       else if (warn_return_type)
10117         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10118                     name);
10119
10120       type = integer_type_node;
10121     }
10122
10123   ctype = NULL_TREE;
10124
10125   /* Now process the modifiers that were specified
10126      and check for invalid combinations.  */
10127
10128   /* Long double is a special combination.  */
10129
10130   if (RIDBIT_SETP (RID_LONG, specbits)
10131       && TYPE_MAIN_VARIANT (type) == double_type_node)
10132     {
10133       RIDBIT_RESET (RID_LONG, specbits);
10134       type = build_qualified_type (long_double_type_node,
10135                                    CP_TYPE_QUALS (type));
10136     }
10137
10138   /* Check all other uses of type modifiers.  */
10139
10140   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10141       || RIDBIT_SETP (RID_SIGNED, specbits)
10142       || RIDBIT_SETP (RID_LONG, specbits)
10143       || RIDBIT_SETP (RID_SHORT, specbits))
10144     {
10145       int ok = 0;
10146
10147       if (TREE_CODE (type) == REAL_TYPE)
10148         error ("short, signed or unsigned invalid for `%s'", name);
10149       else if (TREE_CODE (type) != INTEGER_TYPE)
10150         error ("long, short, signed or unsigned invalid for `%s'", name);
10151       else if (RIDBIT_SETP (RID_LONG, specbits)
10152                && RIDBIT_SETP (RID_SHORT, specbits))
10153         error ("long and short specified together for `%s'", name);
10154       else if ((RIDBIT_SETP (RID_LONG, specbits)
10155                 || RIDBIT_SETP (RID_SHORT, specbits))
10156                && explicit_char)
10157         error ("long or short specified with char for `%s'", name);
10158       else if ((RIDBIT_SETP (RID_LONG, specbits)
10159                 || RIDBIT_SETP (RID_SHORT, specbits))
10160                && TREE_CODE (type) == REAL_TYPE)
10161         error ("long or short specified with floating type for `%s'", name);
10162       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10163                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10164         error ("signed and unsigned given together for `%s'", name);
10165       else
10166         {
10167           ok = 1;
10168           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10169             {
10170               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10171                        name);
10172               if (flag_pedantic_errors)
10173                 ok = 0;
10174             }
10175         }
10176
10177       /* Discard the type modifiers if they are invalid.  */
10178       if (! ok)
10179         {
10180           RIDBIT_RESET (RID_UNSIGNED, specbits);
10181           RIDBIT_RESET (RID_SIGNED, specbits);
10182           RIDBIT_RESET (RID_LONG, specbits);
10183           RIDBIT_RESET (RID_SHORT, specbits);
10184           longlong = 0;
10185         }
10186     }
10187
10188   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10189       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10190     {
10191       error ("complex invalid for `%s'", name);
10192       RIDBIT_RESET (RID_COMPLEX, specbits);
10193     }
10194
10195   /* Decide whether an integer type is signed or not.
10196      Optionally treat bitfields as signed by default.  */
10197   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10198       /* [class.bit]
10199
10200          It is implementation-defined whether a plain (neither
10201          explicitly signed or unsigned) char, short, int, or long
10202          bit-field is signed or unsigned.
10203
10204          Naturally, we extend this to long long as well.  Note that
10205          this does not include wchar_t.  */
10206       || (bitfield && !flag_signed_bitfields
10207           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10208           /* A typedef for plain `int' without `signed' can be
10209              controlled just like plain `int', but a typedef for
10210              `signed int' cannot be so controlled.  */
10211           && !(typedef_decl
10212                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10213           && (TREE_CODE (type) == INTEGER_TYPE
10214               || TREE_CODE (type) == CHAR_TYPE)
10215           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10216     {
10217       if (longlong)
10218         type = long_long_unsigned_type_node;
10219       else if (RIDBIT_SETP (RID_LONG, specbits))
10220         type = long_unsigned_type_node;
10221       else if (RIDBIT_SETP (RID_SHORT, specbits))
10222         type = short_unsigned_type_node;
10223       else if (type == char_type_node)
10224         type = unsigned_char_type_node;
10225       else if (typedef_decl)
10226         type = unsigned_type (type);
10227       else
10228         type = unsigned_type_node;
10229     }
10230   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10231            && type == char_type_node)
10232     type = signed_char_type_node;
10233   else if (longlong)
10234     type = long_long_integer_type_node;
10235   else if (RIDBIT_SETP (RID_LONG, specbits))
10236     type = long_integer_type_node;
10237   else if (RIDBIT_SETP (RID_SHORT, specbits))
10238     type = short_integer_type_node;
10239
10240   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10241     {
10242       /* If we just have "complex", it is equivalent to
10243          "complex double", but if any modifiers at all are specified it is
10244          the complex form of TYPE.  E.g, "complex short" is
10245          "complex short int".  */
10246
10247       if (defaulted_int && ! longlong
10248           && ! (RIDBIT_SETP (RID_LONG, specbits)
10249                 || RIDBIT_SETP (RID_SHORT, specbits)
10250                 || RIDBIT_SETP (RID_SIGNED, specbits)
10251                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10252         type = complex_double_type_node;
10253       else if (type == integer_type_node)
10254         type = complex_integer_type_node;
10255       else if (type == float_type_node)
10256         type = complex_float_type_node;
10257       else if (type == double_type_node)
10258         type = complex_double_type_node;
10259       else if (type == long_double_type_node)
10260         type = complex_long_double_type_node;
10261       else
10262         type = build_complex_type (type);
10263     }
10264
10265   if (sfk == sfk_conversion
10266       && (RIDBIT_SETP (RID_CONST, specbits)
10267           || RIDBIT_SETP (RID_VOLATILE, specbits)
10268           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10269     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10270               ctor_return_type);
10271
10272   /* Set CONSTP if this declaration is `const', whether by
10273      explicit specification or via a typedef.
10274      Likewise for VOLATILEP.  */
10275
10276   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10277   restrictp =
10278     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10279   volatilep =
10280     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10281   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10282                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10283                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10284   type = cp_build_qualified_type (type, type_quals);
10285   staticp = 0;
10286   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10287   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10288   RIDBIT_RESET (RID_VIRTUAL, specbits);
10289   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10290   RIDBIT_RESET (RID_EXPLICIT, specbits);
10291
10292   if (RIDBIT_SETP (RID_STATIC, specbits))
10293     staticp = 1 + (decl_context == FIELD);
10294
10295   if (virtualp && staticp == 2)
10296     {
10297       cp_error ("member `%D' cannot be declared both virtual and static",
10298                 dname);
10299       staticp = 0;
10300     }
10301   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10302   RIDBIT_RESET (RID_FRIEND, specbits);
10303
10304   /* Warn if two storage classes are given. Default to `auto'.  */
10305
10306   if (RIDBIT_ANY_SET (specbits))
10307     {
10308       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10309       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10310       if (decl_context == PARM && nclasses > 0)
10311         error ("storage class specifiers invalid in parameter declarations");
10312       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10313         {
10314           if (decl_context == PARM)
10315             error ("typedef declaration invalid in parameter declaration");
10316           nclasses++;
10317         }
10318       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10319       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10320     }
10321
10322   /* Give error if `virtual' is used outside of class declaration.  */
10323   if (virtualp
10324       && (current_class_name == NULL_TREE || decl_context != FIELD))
10325     {
10326       error ("virtual outside class declaration");
10327       virtualp = 0;
10328     }
10329
10330   /* Static anonymous unions are dealt with here.  */
10331   if (staticp && decl_context == TYPENAME
10332       && TREE_CODE (declspecs) == TREE_LIST
10333       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10334     decl_context = FIELD;
10335
10336   /* Warn about storage classes that are invalid for certain
10337      kinds of declarations (parameters, typenames, etc.).  */
10338
10339   if (nclasses > 1)
10340     error ("multiple storage classes in declaration of `%s'", name);
10341   else if (decl_context != NORMAL && nclasses > 0)
10342     {
10343       if ((decl_context == PARM || decl_context == CATCHPARM)
10344           && (RIDBIT_SETP (RID_REGISTER, specbits)
10345               || RIDBIT_SETP (RID_AUTO, specbits)))
10346         ;
10347       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10348         ;
10349       else if (decl_context == FIELD
10350                /* C++ allows static class elements  */
10351                && RIDBIT_SETP (RID_STATIC, specbits))
10352         /* C++ also allows inlines and signed and unsigned elements,
10353            but in those cases we don't come in here.  */
10354         ;
10355       else
10356         {
10357           if (decl_context == FIELD)
10358             {
10359               tree tmp = NULL_TREE;
10360               register int op = 0;
10361
10362               if (declarator)
10363                 {
10364                   /* Avoid trying to get an operand off an identifier node.  */
10365                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10366                     tmp = declarator;
10367                   else
10368                     tmp = TREE_OPERAND (declarator, 0);
10369                   op = IDENTIFIER_OPNAME_P (tmp);
10370                   if (IDENTIFIER_TYPENAME_P (tmp))
10371                     {
10372                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10373                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10374                               == TYPE_DECL))
10375                         name = IDENTIFIER_POINTER (tmp);
10376                       else
10377                         name = "<invalid operator>";
10378                     }
10379                 }
10380               error ("storage class specified for %s `%s'",
10381                      op ? "member operator" : "field",
10382                      name);
10383             }
10384           else
10385             {
10386               if (decl_context == PARM || decl_context == CATCHPARM)
10387                 error ("storage class specified for parameter `%s'", name);
10388               else
10389                 error ("storage class specified for typename");
10390             }
10391           RIDBIT_RESET (RID_REGISTER, specbits);
10392           RIDBIT_RESET (RID_AUTO, specbits);
10393           RIDBIT_RESET (RID_EXTERN, specbits);
10394         }
10395     }
10396   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10397     {
10398       if (toplevel_bindings_p ())
10399         {
10400           /* It's common practice (and completely valid) to have a const
10401              be initialized and declared extern.  */
10402           if (!(type_quals & TYPE_QUAL_CONST))
10403             warning ("`%s' initialized and declared `extern'", name);
10404         }
10405       else
10406         error ("`%s' has both `extern' and initializer", name);
10407     }
10408   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10409            && ! toplevel_bindings_p ())
10410     error ("nested function `%s' declared `extern'", name);
10411   else if (toplevel_bindings_p ())
10412     {
10413       if (RIDBIT_SETP (RID_AUTO, specbits))
10414         error ("top-level declaration of `%s' specifies `auto'", name);
10415     }
10416
10417   if (nclasses > 0 && friendp)
10418     error ("storage class specifiers invalid in friend function declarations");
10419
10420   /* Now figure out the structure of the declarator proper.
10421      Descend through it, creating more complex types, until we reach
10422      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10423
10424   inner_attrs = NULL_TREE;
10425   ignore_attrs = 0;
10426
10427   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10428          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10429     {
10430       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10431          an INDIRECT_REF (for *...),
10432          a CALL_EXPR (for ...(...)),
10433          an identifier (for the name being declared)
10434          or a null pointer (for the place in an absolute declarator
10435          where the name was omitted).
10436          For the last two cases, we have just exited the loop.
10437
10438          For C++ it could also be
10439          a SCOPE_REF (for class :: ...).  In this case, we have converted
10440          sensible names to types, and those are the values we use to
10441          qualify the member name.
10442          an ADDR_EXPR (for &...),
10443          a BIT_NOT_EXPR (for destructors)
10444
10445          At this point, TYPE is the type of elements of an array,
10446          or for a function to return, or for a pointer to point to.
10447          After this sequence of ifs, TYPE is the type of the
10448          array or function or pointer, and DECLARATOR has had its
10449          outermost layer removed.  */
10450
10451       if (type == error_mark_node)
10452         {
10453           if (TREE_CODE (declarator) == SCOPE_REF)
10454             declarator = TREE_OPERAND (declarator, 1);
10455           else
10456             declarator = TREE_OPERAND (declarator, 0);
10457           continue;
10458         }
10459       if (quals != NULL_TREE
10460           && (declarator == NULL_TREE
10461               || TREE_CODE (declarator) != SCOPE_REF))
10462         {
10463           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10464             ctype = TYPE_METHOD_BASETYPE (type);
10465           if (ctype != NULL_TREE)
10466             {
10467               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10468               grok_method_quals (ctype, dummy, quals);
10469               type = TREE_TYPE (dummy);
10470               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10471               quals = NULL_TREE;
10472             }
10473         }
10474
10475       /* See the comment for the TREE_LIST case, below.  */
10476       if (ignore_attrs)
10477         ignore_attrs = 0;
10478       else if (inner_attrs)
10479         {
10480           decl_attributes (type, inner_attrs, NULL_TREE);
10481           inner_attrs = NULL_TREE;
10482         }
10483
10484       switch (TREE_CODE (declarator))
10485         {
10486         case TREE_LIST:
10487           {
10488             /* We encode a declarator with embedded attributes using
10489                a TREE_LIST.  The attributes apply to the declarator
10490                directly inside them, so we have to skip an iteration
10491                before applying them to the type.  If the declarator just
10492                inside is the declarator-id, we apply the attrs to the
10493                decl itself.  */
10494             inner_attrs = TREE_PURPOSE (declarator);
10495             ignore_attrs = 1;
10496             declarator = TREE_VALUE (declarator);
10497           }
10498           break;
10499
10500         case ARRAY_REF:
10501           {
10502             register tree size;
10503
10504             size = TREE_OPERAND (declarator, 1);
10505
10506             /* VC++ spells a zero-sized array with [].  */
10507             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10508                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10509               size = integer_zero_node;
10510
10511             declarator = TREE_OPERAND (declarator, 0);
10512
10513             type = create_array_type_for_decl (dname, type, size);
10514
10515             /* VLAs never work as fields. */
10516             if (decl_context == FIELD && !processing_template_decl
10517                 && TREE_CODE (type) == ARRAY_TYPE
10518                 && TYPE_DOMAIN (type) != NULL_TREE
10519                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10520               {
10521                 cp_error ("size of member `%D' is not constant", dname);
10522                 /* Proceed with arbitrary constant size, so that offset
10523                    computations don't get confused. */
10524                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10525                                                    integer_one_node);
10526               }
10527
10528             ctype = NULL_TREE;
10529           }
10530           break;
10531
10532         case CALL_EXPR:
10533           {
10534             tree arg_types;
10535             int funcdecl_p;
10536             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10537             tree inner_decl = TREE_OPERAND (declarator, 0);
10538
10539             /* Declaring a function type.
10540                Make sure we have a valid type for the function to return.  */
10541
10542             /* We now know that the TYPE_QUALS don't apply to the
10543                decl, but to its return type.  */
10544             type_quals = TYPE_UNQUALIFIED;
10545
10546             /* Warn about some types functions can't return.  */
10547
10548             if (TREE_CODE (type) == FUNCTION_TYPE)
10549               {
10550                 error ("`%s' declared as function returning a function", name);
10551                 type = integer_type_node;
10552               }
10553             if (TREE_CODE (type) == ARRAY_TYPE)
10554               {
10555                 error ("`%s' declared as function returning an array", name);
10556                 type = integer_type_node;
10557               }
10558
10559             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10560               inner_decl = TREE_OPERAND (inner_decl, 1);
10561
10562             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10563               inner_decl = dname;
10564
10565             /* Pick up type qualifiers which should be applied to `this'.  */
10566             quals = CALL_DECLARATOR_QUALS (declarator);
10567
10568             /* Pick up the exception specifications.  */
10569             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10570
10571             /* Say it's a definition only for the CALL_EXPR
10572                closest to the identifier.  */
10573             funcdecl_p
10574               = inner_decl
10575               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10576                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10577                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10578
10579             if (ctype == NULL_TREE
10580                 && decl_context == FIELD
10581                 && funcdecl_p
10582                 && (friendp == 0 || dname == current_class_name))
10583               ctype = current_class_type;
10584
10585             if (ctype && sfk == sfk_conversion)
10586               TYPE_HAS_CONVERSION (ctype) = 1;
10587             if (ctype && constructor_name (ctype) == dname)
10588               {
10589                 /* We are within a class's scope. If our declarator name
10590                    is the same as the class name, and we are defining
10591                    a function, then it is a constructor/destructor, and
10592                    therefore returns a void type.  */
10593
10594                 if (flags == DTOR_FLAG)
10595                   {
10596                     /* ISO C++ 12.4/2.  A destructor may not be
10597                        declared const or volatile.  A destructor may
10598                        not be static.  */
10599                     if (staticp == 2)
10600                       error ("destructor cannot be static member function");
10601                     if (quals)
10602                       {
10603                         cp_error ("destructors may not be `%s'",
10604                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10605                         quals = NULL_TREE;
10606                       }
10607                     if (decl_context == FIELD)
10608                       {
10609                         if (! member_function_or_else (ctype,
10610                                                        current_class_type,
10611                                                        flags))
10612                           return void_type_node;
10613                       }
10614                   }
10615                 else            /* It's a constructor.  */
10616                   {
10617                     if (explicitp == 1)
10618                       explicitp = 2;
10619                     /* ISO C++ 12.1.  A constructor may not be
10620                        declared const or volatile.  A constructor may
10621                        not be virtual.  A constructor may not be
10622                        static.  */
10623                     if (staticp == 2)
10624                       error ("constructor cannot be static member function");
10625                     if (virtualp)
10626                       {
10627                         pedwarn ("constructors cannot be declared virtual");
10628                         virtualp = 0;
10629                       }
10630                     if (quals)
10631                       {
10632                         cp_error ("constructors may not be `%s'",
10633                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10634                         quals = NULL_TREE;
10635                       }
10636                     {
10637                       RID_BIT_TYPE tmp_bits;
10638                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10639                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10640                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10641                       if (RIDBIT_ANY_SET (tmp_bits))
10642                         error ("return value type specifier for constructor ignored");
10643                     }
10644                     if (decl_context == FIELD)
10645                       {
10646                         if (! member_function_or_else (ctype,
10647                                                        current_class_type,
10648                                                        flags))
10649                           return void_type_node;
10650                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10651                         if (sfk != sfk_constructor)
10652                           return NULL_TREE;
10653                       }
10654                   }
10655                 if (decl_context == FIELD)
10656                   staticp = 0;
10657               }
10658             else if (friendp)
10659               {
10660                 if (initialized)
10661                   error ("can't initialize friend function `%s'", name);
10662                 if (virtualp)
10663                   {
10664                     /* Cannot be both friend and virtual.  */
10665                     error ("virtual functions cannot be friends");
10666                     RIDBIT_RESET (RID_FRIEND, specbits);
10667                     friendp = 0;
10668                   }
10669                 if (decl_context == NORMAL)
10670                   error ("friend declaration not in class definition");
10671                 if (current_function_decl && funcdef_flag)
10672                   cp_error ("can't define friend function `%s' in a local class definition",
10673                             name);
10674               }
10675
10676             /* Construct the function type and go to the next
10677                inner layer of declarator.  */
10678
10679             declarator = TREE_OPERAND (declarator, 0);
10680
10681             /* FIXME: This is where default args should be fully
10682                processed.  */
10683
10684             arg_types = grokparms (inner_parms);
10685
10686             if (declarator && flags == DTOR_FLAG)
10687               {
10688                 /* A destructor declared in the body of a class will
10689                    be represented as a BIT_NOT_EXPR.  But, we just
10690                    want the underlying IDENTIFIER.  */
10691                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10692                   declarator = TREE_OPERAND (declarator, 0);
10693
10694                 if (arg_types != void_list_node)
10695                   {
10696                     cp_error ("destructors may not have parameters");
10697                     arg_types = void_list_node;
10698                     last_function_parms = NULL_TREE;
10699                   }
10700               }
10701
10702             /* ANSI says that `const int foo ();'
10703                does not make the function foo const.  */
10704             type = build_function_type (type, arg_types);
10705
10706             {
10707               tree t;
10708               for (t = arg_types; t; t = TREE_CHAIN (t))
10709                 if (TREE_PURPOSE (t)
10710                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10711                   {
10712                     add_defarg_fn (type);
10713                     break;
10714                   }
10715             }
10716           }
10717           break;
10718
10719         case ADDR_EXPR:
10720         case INDIRECT_REF:
10721           /* Filter out pointers-to-references and references-to-references.
10722              We can get these if a TYPE_DECL is used.  */
10723
10724           if (TREE_CODE (type) == REFERENCE_TYPE)
10725             {
10726               error ("cannot declare %s to references",
10727                      TREE_CODE (declarator) == ADDR_EXPR
10728                      ? "references" : "pointers");
10729               declarator = TREE_OPERAND (declarator, 0);
10730               continue;
10731             }
10732
10733           if (TREE_CODE (type) == OFFSET_TYPE
10734               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10735                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10736             {
10737               cp_error ("cannot declare pointer to `%#T' member",
10738                         TREE_TYPE (type));
10739               type = TREE_TYPE (type);
10740             }
10741
10742           /* Merge any constancy or volatility into the target type
10743              for the pointer.  */
10744
10745           /* We now know that the TYPE_QUALS don't apply to the decl,
10746              but to the target of the pointer.  */
10747           type_quals = TYPE_UNQUALIFIED;
10748
10749           if (TREE_CODE (declarator) == ADDR_EXPR)
10750             {
10751               if (TREE_CODE (type) == VOID_TYPE)
10752                 error ("invalid type: `void &'");
10753               else
10754                 type = build_reference_type (type);
10755             }
10756           else if (TREE_CODE (type) == METHOD_TYPE)
10757             type = build_ptrmemfunc_type (build_pointer_type (type));
10758           else
10759             type = build_pointer_type (type);
10760
10761           /* Process a list of type modifier keywords (such as
10762              const or volatile) that were given inside the `*' or `&'.  */
10763
10764           if (TREE_TYPE (declarator))
10765             {
10766               register tree typemodlist;
10767               int erred = 0;
10768
10769               constp = 0;
10770               volatilep = 0;
10771               restrictp = 0;
10772               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10773                    typemodlist = TREE_CHAIN (typemodlist))
10774                 {
10775                   tree qualifier = TREE_VALUE (typemodlist);
10776
10777                   if (qualifier == ridpointers[(int) RID_CONST])
10778                     constp++;
10779                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10780                     volatilep++;
10781                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10782                     restrictp++;
10783                   else if (!erred)
10784                     {
10785                       erred = 1;
10786                       error ("invalid type modifier within pointer declarator");
10787                     }
10788                 }
10789               if (constp > 1)
10790                 pedwarn ("duplicate `const'");
10791               if (volatilep > 1)
10792                 pedwarn ("duplicate `volatile'");
10793               if (restrictp > 1)
10794                 pedwarn ("duplicate `restrict'");
10795
10796               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10797                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10798                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10799               if (TREE_CODE (declarator) == ADDR_EXPR
10800                   && (constp || volatilep))
10801                 {
10802                   if (constp)
10803                     pedwarn ("discarding `const' applied to a reference");
10804                   if (volatilep)
10805                     pedwarn ("discarding `volatile' applied to a reference");
10806                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10807                 }
10808               type = cp_build_qualified_type (type, type_quals);
10809             }
10810           declarator = TREE_OPERAND (declarator, 0);
10811           ctype = NULL_TREE;
10812           break;
10813
10814         case SCOPE_REF:
10815           {
10816             /* We have converted type names to NULL_TREE if the
10817                name was bogus, or to a _TYPE node, if not.
10818
10819                The variable CTYPE holds the type we will ultimately
10820                resolve to.  The code here just needs to build
10821                up appropriate member types.  */
10822             tree sname = TREE_OPERAND (declarator, 1);
10823             tree t;
10824
10825             /* Destructors can have their visibilities changed as well.  */
10826             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10827               sname = TREE_OPERAND (sname, 0);
10828
10829             if (TREE_COMPLEXITY (declarator) == 0)
10830               /* This needs to be here, in case we are called
10831                  multiple times.  */ ;
10832             else if (TREE_COMPLEXITY (declarator) == -1)
10833               /* Namespace member. */
10834               pop_decl_namespace ();
10835             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10836               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10837             else if (! IS_AGGR_TYPE_CODE
10838                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10839               ;
10840             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10841               {
10842                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10843                    that refer to ctype.  They couldn't be resolved earlier
10844                    because we hadn't pushed into the class yet.
10845                    Example: resolve 'B<T>::type' in
10846                    'B<typename B<T>::type> B<T>::f () { }'.  */
10847                 if (current_template_parms
10848                     && uses_template_parms (type)
10849                     && uses_template_parms (current_class_type))
10850                   {
10851                     tree args = current_template_args ();
10852                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10853                   }
10854
10855                 /* This pop_nested_class corresponds to the
10856                    push_nested_class used to push into class scope for
10857                    parsing the argument list of a function decl, in
10858                    qualified_id.  */
10859                 pop_nested_class ();
10860                 TREE_COMPLEXITY (declarator) = current_class_depth;
10861               }
10862             else
10863               my_friendly_abort (16);
10864
10865             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10866               {
10867                 /* We had a reference to a global decl, or
10868                    perhaps we were given a non-aggregate typedef,
10869                    in which case we cleared this out, and should just
10870                    keep going as though it wasn't there.  */
10871                 declarator = sname;
10872                 continue;
10873               }
10874             ctype = TREE_OPERAND (declarator, 0);
10875
10876             t = ctype;
10877             while (t != NULL_TREE && CLASS_TYPE_P (t))
10878               {
10879                 /* You're supposed to have one `template <...>'
10880                    for every template class, but you don't need one
10881                    for a full specialization.  For example:
10882
10883                      template <class T> struct S{};
10884                      template <> struct S<int> { void f(); };
10885                      void S<int>::f () {}
10886
10887                    is correct; there shouldn't be a `template <>' for
10888                    the definition of `S<int>::f'.  */
10889                 if (CLASSTYPE_TEMPLATE_INFO (t)
10890                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10891                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10892                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10893                   template_count += 1;
10894
10895                 t = TYPE_MAIN_DECL (t);
10896                 t = DECL_CONTEXT (t);
10897               }
10898
10899             if (sname == NULL_TREE)
10900               goto done_scoping;
10901
10902             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10903               {
10904                 /* This is the `standard' use of the scoping operator:
10905                    basetype :: member .  */
10906
10907                 if (ctype == current_class_type)
10908                   {
10909                     /* class A {
10910                          void A::f ();
10911                        };
10912
10913                        Is this ill-formed?  */
10914
10915                     if (pedantic)
10916                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10917                                   ctype, name);
10918                   }
10919                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10920                   {
10921                     if (current_class_type == NULL_TREE || friendp)
10922                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10923                                                       TYPE_ARG_TYPES (type));
10924                     else
10925                       {
10926                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10927                                   ctype, name, current_class_type);
10928                         return void_type_node;
10929                       }
10930                   }
10931                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10932                          || COMPLETE_TYPE_P (complete_type (ctype)))
10933                   {
10934                     /* Have to move this code elsewhere in this function.
10935                        this code is used for i.e., typedef int A::M; M *pm;
10936
10937                        It is?  How? jason 10/2/94 */
10938
10939                     if (current_class_type)
10940                       {
10941                         cp_error ("cannot declare member `%T::%s' within `%T'",
10942                                   ctype, name, current_class_type);
10943                         return void_type_node;
10944                       }
10945                     type = build_offset_type (ctype, type);
10946                   }
10947                 else
10948                   {
10949                     incomplete_type_error (NULL_TREE, ctype);
10950                     return error_mark_node;
10951                   }
10952
10953                 declarator = sname;
10954               }
10955             else if (TREE_CODE (sname) == SCOPE_REF)
10956               my_friendly_abort (17);
10957             else
10958               {
10959               done_scoping:
10960                 declarator = TREE_OPERAND (declarator, 1);
10961                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10962                   /* In this case, we will deal with it later.  */
10963                   ;
10964                 else
10965                   {
10966                     if (TREE_CODE (type) == FUNCTION_TYPE)
10967                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10968                                                       TYPE_ARG_TYPES (type));
10969                     else
10970                       type = build_offset_type (ctype, type);
10971                   }
10972               }
10973           }
10974           break;
10975
10976         case BIT_NOT_EXPR:
10977           declarator = TREE_OPERAND (declarator, 0);
10978           break;
10979
10980         case RECORD_TYPE:
10981         case UNION_TYPE:
10982         case ENUMERAL_TYPE:
10983           declarator = NULL_TREE;
10984           break;
10985
10986         case ERROR_MARK:
10987           declarator = NULL_TREE;
10988           break;
10989
10990         default:
10991           my_friendly_abort (158);
10992         }
10993     }
10994
10995   /* See the comment for the TREE_LIST case, above.  */
10996   if (inner_attrs)
10997     {
10998       if (! ignore_attrs)
10999         decl_attributes (type, inner_attrs, NULL_TREE);
11000       else if (attrlist)
11001         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11002       else
11003         attrlist = build_tree_list (NULL_TREE, inner_attrs);
11004     }
11005
11006   /* Now TYPE has the actual type.  */
11007
11008   if (explicitp == 1 || (explicitp && friendp))
11009     {
11010       /* [dcl.fct.spec] The explicit specifier shall only be used in
11011          declarations of constructors within a class definition.  */
11012       error ("only declarations of constructors can be `explicit'");
11013       explicitp = 0;
11014     }
11015
11016   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11017     {
11018       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11019         {
11020           error ("non-member `%s' cannot be declared `mutable'", name);
11021           RIDBIT_RESET (RID_MUTABLE, specbits);
11022         }
11023       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11024         {
11025           error ("non-object member `%s' cannot be declared `mutable'", name);
11026           RIDBIT_RESET (RID_MUTABLE, specbits);
11027         }
11028       else if (TREE_CODE (type) == FUNCTION_TYPE
11029                || TREE_CODE (type) == METHOD_TYPE)
11030         {
11031           error ("function `%s' cannot be declared `mutable'", name);
11032           RIDBIT_RESET (RID_MUTABLE, specbits);
11033         }
11034       else if (staticp)
11035         {
11036           error ("static `%s' cannot be declared `mutable'", name);
11037           RIDBIT_RESET (RID_MUTABLE, specbits);
11038         }
11039       else if (type_quals & TYPE_QUAL_CONST)
11040         {
11041           error ("const `%s' cannot be declared `mutable'", name);
11042           RIDBIT_RESET (RID_MUTABLE, specbits);
11043         }
11044     }
11045
11046   if (declarator == NULL_TREE
11047       || TREE_CODE (declarator) == IDENTIFIER_NODE
11048       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11049           && (TREE_CODE (type) == FUNCTION_TYPE
11050               || TREE_CODE (type) == METHOD_TYPE)))
11051     /* OK */;
11052   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11053     {
11054       cp_error ("template-id `%D' used as a declarator", declarator);
11055       declarator = dname;
11056     }
11057   else
11058     /* Unexpected declarator format.  */
11059     my_friendly_abort (990210);
11060
11061   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11062
11063   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11064     {
11065       tree decl;
11066
11067       /* Note that the grammar rejects storage classes
11068          in typenames, fields or parameters.  */
11069       if (current_lang_name == lang_name_java)
11070         TYPE_FOR_JAVA (type) = 1;
11071
11072       if (decl_context == FIELD)
11073         {
11074           if (declarator == constructor_name (current_class_type))
11075             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11076                         declarator);
11077           decl = build_lang_decl (TYPE_DECL, declarator, type);
11078         }
11079       else
11080         {
11081           decl = build_decl (TYPE_DECL, declarator, type);
11082           if (!current_function_decl)
11083             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11084         }
11085
11086       /* If the user declares "typedef struct {...} foo" then the
11087          struct will have an anonymous name.  Fill that name in now.
11088          Nothing can refer to it, so nothing needs know about the name
11089          change.  */
11090       if (type != error_mark_node
11091           && declarator
11092           && TYPE_NAME (type)
11093           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11094           && TYPE_ANONYMOUS_P (type)
11095           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11096         {
11097           tree oldname = TYPE_NAME (type);
11098           tree t;
11099
11100           /* Replace the anonymous name with the real name everywhere.  */
11101           lookup_tag_reverse (type, declarator);
11102           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11103             if (TYPE_NAME (t) == oldname)
11104               TYPE_NAME (t) = decl;
11105
11106           if (TYPE_LANG_SPECIFIC (type))
11107             TYPE_WAS_ANONYMOUS (type) = 1;
11108
11109           /* If this is a typedef within a template class, the nested
11110              type is a (non-primary) template.  The name for the
11111              template needs updating as well.  */
11112           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11113             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11114               = TYPE_IDENTIFIER (type);
11115
11116           /* FIXME remangle member functions; member functions of a
11117              type with external linkage have external linkage.  */
11118         }
11119
11120       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11121         {
11122           cp_error_at ("typedef name may not be class-qualified", decl);
11123           return NULL_TREE;
11124         }
11125       else if (quals)
11126         {
11127           if (ctype == NULL_TREE)
11128             {
11129               if (TREE_CODE (type) != METHOD_TYPE)
11130                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11131               else
11132                 ctype = TYPE_METHOD_BASETYPE (type);
11133             }
11134           if (ctype != NULL_TREE)
11135             grok_method_quals (ctype, decl, quals);
11136         }
11137
11138       if (RIDBIT_SETP (RID_SIGNED, specbits)
11139           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11140         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11141
11142       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11143                       inlinep, friendp, raises != NULL_TREE);
11144
11145       if (initialized)
11146         error ("typedef declaration includes an initializer");
11147
11148       return decl;
11149     }
11150
11151   /* Detect the case of an array type of unspecified size
11152      which came, as such, direct from a typedef name.
11153      We must copy the type, so that each identifier gets
11154      a distinct type, so that each identifier's size can be
11155      controlled separately by its own initializer.  */
11156
11157   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11158       && TYPE_DOMAIN (type) == NULL_TREE)
11159     {
11160       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11161     }
11162
11163   /* If this is a type name (such as, in a cast or sizeof),
11164      compute the type and return it now.  */
11165
11166   if (decl_context == TYPENAME)
11167     {
11168       /* Note that the grammar rejects storage classes
11169          in typenames, fields or parameters.  */
11170       if (type_quals != TYPE_UNQUALIFIED)
11171         type_quals = TYPE_UNQUALIFIED;
11172
11173       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11174       if (friendp)
11175         {
11176           if (type_quals != TYPE_UNQUALIFIED)
11177             {
11178               cp_error ("type qualifiers specified for friend class declaration");
11179               type_quals = TYPE_UNQUALIFIED;
11180             }
11181           if (inlinep)
11182             {
11183               cp_error ("`inline' specified for friend class declaration");
11184               inlinep = 0;
11185             }
11186
11187           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11188              But don't allow implicit typenames except with a class-key.  */
11189           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11190                                 || IMPLICIT_TYPENAME_P (type)))
11191             {
11192               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11193                 cp_pedwarn ("template parameters cannot be friends");
11194               else if (TREE_CODE (type) == TYPENAME_TYPE)
11195                 cp_pedwarn ("\
11196 friend declaration requires class-key, i.e. `friend class %T::%T'",
11197                             constructor_name (current_class_type),
11198                             TYPE_IDENTIFIER (type));
11199               else
11200                 cp_pedwarn ("\
11201 friend declaration requires class-key, i.e. `friend %#T'",
11202                             type);
11203             }
11204
11205           /* Only try to do this stuff if we didn't already give up.  */
11206           if (type != integer_type_node)
11207             {
11208               /* DR 209. The friendly class does not need to be accessible
11209                  in the scope of the class granting friendship. */
11210               skip_type_access_control ();
11211
11212               /* A friendly class?  */
11213               if (current_class_type)
11214                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11215               else
11216                 cp_error ("trying to make class `%T' a friend of global scope",
11217                           type);
11218
11219               type = void_type_node;
11220             }
11221         }
11222       else if (quals)
11223         {
11224           if (ctype == NULL_TREE)
11225             {
11226               if (TREE_CODE (type) != METHOD_TYPE)
11227                 cp_error ("invalid qualifiers on non-member function type");
11228               else
11229                 ctype = TYPE_METHOD_BASETYPE (type);
11230             }
11231           if (ctype)
11232             {
11233               tree dummy = build_decl (TYPE_DECL, declarator, type);
11234               grok_method_quals (ctype, dummy, quals);
11235               type = TREE_TYPE (dummy);
11236             }
11237         }
11238
11239       return type;
11240     }
11241   else if (declarator == NULL_TREE && decl_context != PARM
11242            && decl_context != CATCHPARM
11243            && TREE_CODE (type) != UNION_TYPE
11244            && ! bitfield)
11245     {
11246       cp_error ("abstract declarator `%T' used as declaration", type);
11247       declarator = make_anon_name ();
11248     }
11249
11250   /* `void' at top level (not within pointer)
11251      is allowed only in typedefs or type names.
11252      We don't complain about parms either, but that is because
11253      a better error message can be made later.  */
11254
11255   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11256     {
11257       if (! declarator)
11258         error ("unnamed variable or field declared void");
11259       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11260         {
11261           if (IDENTIFIER_OPNAME_P (declarator))
11262             my_friendly_abort (356);
11263           else
11264             error ("variable or field `%s' declared void", name);
11265         }
11266       else
11267         error ("variable or field declared void");
11268       type = integer_type_node;
11269     }
11270
11271   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11272      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11273
11274   if (decl_context == PARM || decl_context == CATCHPARM)
11275     {
11276       if (ctype || in_namespace)
11277         error ("cannot use `::' in parameter declaration");
11278
11279       /* A parameter declared as an array of T is really a pointer to T.
11280          One declared as a function is really a pointer to a function.
11281          One declared as a member is really a pointer to member.  */
11282
11283       if (TREE_CODE (type) == ARRAY_TYPE)
11284         {
11285           /* Transfer const-ness of array into that of type pointed to.  */
11286           type = build_pointer_type (TREE_TYPE (type));
11287           type_quals = TYPE_UNQUALIFIED;
11288         }
11289       else if (TREE_CODE (type) == FUNCTION_TYPE)
11290         type = build_pointer_type (type);
11291       else if (TREE_CODE (type) == OFFSET_TYPE)
11292         type = build_pointer_type (type);
11293     }
11294
11295   {
11296     register tree decl;
11297
11298     if (decl_context == PARM)
11299       {
11300         decl = build_decl (PARM_DECL, declarator, type);
11301
11302         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11303                         inlinep, friendp, raises != NULL_TREE);
11304
11305         /* Compute the type actually passed in the parmlist,
11306            for the case where there is no prototype.
11307            (For example, shorts and chars are passed as ints.)
11308            When there is a prototype, this is overridden later.  */
11309
11310         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11311       }
11312     else if (decl_context == FIELD)
11313       {
11314         if (type == error_mark_node)
11315           {
11316             /* Happens when declaring arrays of sizes which
11317                are error_mark_node, for example.  */
11318             decl = NULL_TREE;
11319           }
11320         else if (in_namespace && !friendp)
11321           {
11322             /* Something like struct S { int N::j; };  */
11323             cp_error ("invalid use of `::'");
11324             decl = NULL_TREE;
11325           }
11326         else if (TREE_CODE (type) == FUNCTION_TYPE)
11327           {
11328             int publicp = 0;
11329             tree function_context;
11330
11331             /* We catch the others as conflicts with the builtin
11332                typedefs.  */
11333             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11334               {
11335                 cp_error ("function `%D' cannot be declared friend",
11336                           declarator);
11337                 friendp = 0;
11338               }
11339
11340             if (friendp == 0)
11341               {
11342                 if (ctype == NULL_TREE)
11343                   ctype = current_class_type;
11344
11345                 if (ctype == NULL_TREE)
11346                   {
11347                     cp_error ("can't make `%D' into a method -- not in a class",
11348                               declarator);
11349                     return void_type_node;
11350                   }
11351
11352                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11353                    ARM 9.5 */
11354                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11355                   {
11356                     cp_error ("function `%D' declared virtual inside a union",
11357                               declarator);
11358                     return void_type_node;
11359                   }
11360
11361                 if (declarator == ansi_opname (NEW_EXPR)
11362                     || declarator == ansi_opname (VEC_NEW_EXPR)
11363                     || declarator == ansi_opname (DELETE_EXPR)
11364                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11365                   {
11366                     if (virtualp)
11367                       {
11368                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11369                                   declarator);
11370                         virtualp = 0;
11371                       }
11372                   }
11373                 else if (staticp < 2)
11374                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11375                                                   TYPE_ARG_TYPES (type));
11376               }
11377
11378             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11379             function_context = (ctype != NULL_TREE) ?
11380               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11381             publicp = (! friendp || ! staticp)
11382               && function_context == NULL_TREE;
11383             decl = grokfndecl (ctype, type,
11384                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11385                                ? declarator : dname,
11386                                declarator,
11387                                virtualp, flags, quals, raises,
11388                                friendp ? -1 : 0, friendp, publicp, inlinep,
11389                                funcdef_flag, template_count, in_namespace);
11390             if (decl == NULL_TREE)
11391               return decl;
11392 #if 0
11393             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11394             /* The decl and setting of decl_machine_attr is also turned off.  */
11395             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11396 #endif
11397
11398             /* [class.conv.ctor]
11399
11400                A constructor declared without the function-specifier
11401                explicit that can be called with a single parameter
11402                specifies a conversion from the type of its first
11403                parameter to the type of its class.  Such a constructor
11404                is called a converting constructor.  */
11405             if (explicitp == 2)
11406               DECL_NONCONVERTING_P (decl) = 1;
11407             else if (DECL_CONSTRUCTOR_P (decl))
11408               {
11409                 /* The constructor can be called with exactly one
11410                    parameter if there is at least one parameter, and
11411                    any subsequent parameters have default arguments.
11412                    Ignore any compiler-added parms.  */
11413                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11414
11415                 if (arg_types == void_list_node
11416                     || (arg_types
11417                         && TREE_CHAIN (arg_types)
11418                         && TREE_CHAIN (arg_types) != void_list_node
11419                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11420                   DECL_NONCONVERTING_P (decl) = 1;
11421               }
11422           }
11423         else if (TREE_CODE (type) == METHOD_TYPE)
11424           {
11425             /* We only get here for friend declarations of
11426                members of other classes.  */
11427             /* All method decls are public, so tell grokfndecl to set
11428                TREE_PUBLIC, also.  */
11429             decl = grokfndecl (ctype, type, declarator, declarator,
11430                                virtualp, flags, quals, raises,
11431                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11432                                template_count, in_namespace);
11433             if (decl == NULL_TREE)
11434               return NULL_TREE;
11435           }
11436         else if (!staticp && ! processing_template_decl
11437                  && !COMPLETE_TYPE_P (complete_type (type))
11438                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11439           {
11440             if (declarator)
11441               cp_error ("field `%D' has incomplete type", declarator);
11442             else
11443               cp_error ("name `%T' has incomplete type", type);
11444
11445             /* If we're instantiating a template, tell them which
11446                instantiation made the field's type be incomplete.  */
11447             if (current_class_type
11448                 && TYPE_NAME (current_class_type)
11449                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11450                 && declspecs && TREE_VALUE (declspecs)
11451                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11452               cp_error ("  in instantiation of template `%T'",
11453                         current_class_type);
11454
11455             type = error_mark_node;
11456             decl = NULL_TREE;
11457           }
11458         else
11459           {
11460             if (friendp)
11461               {
11462                 error ("`%s' is neither function nor member function; cannot be declared friend",
11463                        IDENTIFIER_POINTER (declarator));
11464                 friendp = 0;
11465               }
11466             decl = NULL_TREE;
11467           }
11468
11469         if (friendp)
11470           {
11471             /* Friends are treated specially.  */
11472             tree t = NULL_TREE;
11473
11474             /* DR 209. The friend does not need to be accessible at this
11475                point. */
11476             skip_type_access_control ();
11477
11478             if (ctype == current_class_type)
11479               warning ("member functions are implicitly friends of their class");
11480
11481             if (decl && DECL_NAME (decl))
11482               {
11483                 if (template_class_depth (current_class_type) == 0)
11484                   {
11485                     decl = check_explicit_specialization
11486                             (declarator, decl,
11487                              template_count, 2 * (funcdef_flag != 0) + 4);
11488                     if (decl == error_mark_node)
11489                       return error_mark_node;
11490                   }
11491
11492                 t = do_friend (ctype, declarator, decl,
11493                                last_function_parms, attrlist, flags, quals,
11494                                funcdef_flag);
11495               }
11496             if (t && funcdef_flag)
11497               return t;
11498             return void_type_node;
11499           }
11500
11501         /* Structure field.  It may not be a function, except for C++ */
11502
11503         if (decl == NULL_TREE)
11504           {
11505             if (initialized)
11506               {
11507                 if (!staticp)
11508                   {
11509                     /* An attempt is being made to initialize a non-static
11510                        member.  But, from [class.mem]:
11511
11512                        4 A member-declarator can contain a
11513                        constant-initializer only if it declares a static
11514                        member (_class.static_) of integral or enumeration
11515                        type, see _class.static.data_.
11516
11517                        This used to be relatively common practice, but
11518                        the rest of the compiler does not correctly
11519                        handle the initialization unless the member is
11520                        static so we make it static below.  */
11521                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11522                                 declarator);
11523                     cp_pedwarn ("making `%D' static", declarator);
11524                     staticp = 1;
11525                   }
11526
11527                 if (uses_template_parms (type))
11528                   /* We'll check at instantiation time.  */
11529                   ;
11530                 else if (check_static_variable_definition (declarator,
11531                                                            type))
11532                   /* If we just return the declaration, crashes
11533                      will sometimes occur.  We therefore return
11534                      void_type_node, as if this was a friend
11535                      declaration, to cause callers to completely
11536                      ignore this declaration.  */
11537                   return void_type_node;
11538               }
11539
11540             /* 9.2p13 [class.mem] */
11541             if (declarator == constructor_name (current_class_type)
11542                 /* The standard does not allow non-static data members
11543                    here either, but we agreed at the 10/99 meeting
11544                    to change that in TC 1 so that they are allowed in
11545                    classes with no user-defined constructors.  */
11546                 && staticp)
11547               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11548                           declarator);
11549
11550             if (staticp)
11551               {
11552                 /* C++ allows static class members.  All other work
11553                    for this is done by grokfield.  */
11554                 decl = build_lang_decl (VAR_DECL, declarator, type);
11555                 TREE_STATIC (decl) = 1;
11556                 /* In class context, 'static' means public access.  */
11557                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11558               }
11559             else
11560               {
11561                 decl = build_decl (FIELD_DECL, declarator, type);
11562                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11563                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11564                   {
11565                     DECL_MUTABLE_P (decl) = 1;
11566                     RIDBIT_RESET (RID_MUTABLE, specbits);
11567                   }
11568               }
11569
11570             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11571                             inlinep, friendp, raises != NULL_TREE);
11572           }
11573       }
11574     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11575       {
11576         tree original_name;
11577         int publicp = 0;
11578
11579         if (! declarator)
11580           return NULL_TREE;
11581
11582         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11583           original_name = dname;
11584         else
11585           original_name = declarator;
11586
11587         if (RIDBIT_SETP (RID_AUTO, specbits))
11588           error ("storage class `auto' invalid for function `%s'", name);
11589         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11590           error ("storage class `register' invalid for function `%s'", name);
11591
11592         /* Function declaration not at top level.
11593            Storage classes other than `extern' are not allowed
11594            and `extern' makes no difference.  */
11595         if (! toplevel_bindings_p ()
11596             && (RIDBIT_SETP (RID_STATIC, specbits)
11597                 || RIDBIT_SETP (RID_INLINE, specbits))
11598             && pedantic)
11599           {
11600             if (RIDBIT_SETP (RID_STATIC, specbits))
11601               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11602             else
11603               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11604           }
11605
11606         if (ctype == NULL_TREE)
11607           {
11608             if (virtualp)
11609               {
11610                 error ("virtual non-class function `%s'", name);
11611                 virtualp = 0;
11612               }
11613           }
11614         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11615           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11616                                           TYPE_ARG_TYPES (type));
11617
11618         /* Record presence of `static'.  */
11619         publicp = (ctype != NULL_TREE
11620                    || RIDBIT_SETP (RID_EXTERN, specbits)
11621                    || !RIDBIT_SETP (RID_STATIC, specbits));
11622
11623         decl = grokfndecl (ctype, type, original_name, declarator,
11624                            virtualp, flags, quals, raises,
11625                            1, friendp,
11626                            publicp, inlinep, funcdef_flag,
11627                            template_count, in_namespace);
11628         if (decl == NULL_TREE)
11629           return NULL_TREE;
11630
11631         if (staticp == 1)
11632           {
11633             int illegal_static = 0;
11634
11635             /* Don't allow a static member function in a class, and forbid
11636                declaring main to be static.  */
11637             if (TREE_CODE (type) == METHOD_TYPE)
11638               {
11639                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11640                 illegal_static = 1;
11641               }
11642             else if (current_function_decl)
11643               {
11644                 /* FIXME need arm citation */
11645                 error ("cannot declare static function inside another function");
11646                 illegal_static = 1;
11647               }
11648
11649             if (illegal_static)
11650               {
11651                 staticp = 0;
11652                 RIDBIT_RESET (RID_STATIC, specbits);
11653               }
11654           }
11655       }
11656     else
11657       {
11658         /* It's a variable.  */
11659
11660         /* An uninitialized decl with `extern' is a reference.  */
11661         decl = grokvardecl (type, declarator, &specbits,
11662                             initialized,
11663                             (type_quals & TYPE_QUAL_CONST) != 0,
11664                             in_namespace);
11665         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11666                         inlinep, friendp, raises != NULL_TREE);
11667
11668         if (ctype)
11669           {
11670             DECL_CONTEXT (decl) = ctype;
11671             if (staticp == 1)
11672               {
11673                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11674                 staticp = 0;
11675                 RIDBIT_RESET (RID_STATIC, specbits);
11676               }
11677             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11678               {
11679                 cp_error ("static member `%D' declared `register'", decl);
11680                 RIDBIT_RESET (RID_REGISTER, specbits);
11681               }
11682             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11683               {
11684                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11685                             decl);
11686                 RIDBIT_RESET (RID_EXTERN, specbits);
11687               }
11688           }
11689       }
11690
11691     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11692
11693     /* Record `register' declaration for warnings on &
11694        and in case doing stupid register allocation.  */
11695
11696     if (RIDBIT_SETP (RID_REGISTER, specbits))
11697       DECL_REGISTER (decl) = 1;
11698
11699     if (RIDBIT_SETP (RID_EXTERN, specbits))
11700       DECL_THIS_EXTERN (decl) = 1;
11701
11702     if (RIDBIT_SETP (RID_STATIC, specbits))
11703       DECL_THIS_STATIC (decl) = 1;
11704
11705     /* Record constancy and volatility.  There's no need to do this
11706        when processing a template; we'll do this for the instantiated
11707        declaration based on the type of DECL.  */
11708     if (!processing_template_decl)
11709       c_apply_type_quals_to_decl (type_quals, decl);
11710
11711     return decl;
11712   }
11713 }
11714 \f
11715 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11716    An empty exprlist is a parmlist.  An exprlist which
11717    contains only identifiers at the global level
11718    is a parmlist.  Otherwise, it is an exprlist.  */
11719
11720 int
11721 parmlist_is_exprlist (exprs)
11722      tree exprs;
11723 {
11724   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11725     return 0;
11726
11727   if (toplevel_bindings_p ())
11728     {
11729       /* At the global level, if these are all identifiers,
11730          then it is a parmlist.  */
11731       while (exprs)
11732         {
11733           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11734             return 1;
11735           exprs = TREE_CHAIN (exprs);
11736         }
11737       return 0;
11738     }
11739   return 1;
11740 }
11741
11742 /* Subroutine of start_function.  Ensure that each of the parameter
11743    types (as listed in PARMS) is complete, as is required for a
11744    function definition.  */
11745
11746 static void
11747 require_complete_types_for_parms (parms)
11748      tree parms;
11749 {
11750   for (; parms; parms = TREE_CHAIN (parms))
11751     {
11752       if (VOID_TYPE_P (TREE_TYPE (parms)))
11753         /* grokparms will have already issued an error */
11754         TREE_TYPE (parms) = error_mark_node;
11755       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11756         layout_decl (parms, 0);
11757       else
11758         TREE_TYPE (parms) = error_mark_node;
11759     }
11760 }
11761
11762 /* Returns non-zero if T is a local variable.  */
11763
11764 int
11765 local_variable_p (t)
11766      tree t;
11767 {
11768   if ((TREE_CODE (t) == VAR_DECL
11769        /* A VAR_DECL with a context that is a _TYPE is a static data
11770           member.  */
11771        && !TYPE_P (CP_DECL_CONTEXT (t))
11772        /* Any other non-local variable must be at namespace scope.  */
11773        && !DECL_NAMESPACE_SCOPE_P (t))
11774       || (TREE_CODE (t) == PARM_DECL))
11775     return 1;
11776
11777   return 0;
11778 }
11779
11780 /* Returns non-zero if T is an automatic local variable or a label.
11781    (These are the declarations that need to be remapped when the code
11782    containing them is duplicated.)  */
11783
11784 int
11785 nonstatic_local_decl_p (t)
11786      tree t;
11787 {
11788   return ((local_variable_p (t) && !TREE_STATIC (t))
11789           || TREE_CODE (t) == LABEL_DECL
11790           || TREE_CODE (t) == RESULT_DECL);
11791 }
11792
11793 /* Like local_variable_p, but suitable for use as a tree-walking
11794    function.  */
11795
11796 static tree
11797 local_variable_p_walkfn (tp, walk_subtrees, data)
11798      tree *tp;
11799      int *walk_subtrees ATTRIBUTE_UNUSED;
11800      void *data ATTRIBUTE_UNUSED;
11801 {
11802   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11803           ? *tp : NULL_TREE);
11804 }
11805
11806 /* Check that ARG, which is a default-argument expression for a
11807    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11808    something goes wrong.  DECL may also be a _TYPE node, rather than a
11809    DECL, if there is no DECL available.  */
11810
11811 tree
11812 check_default_argument (decl, arg)
11813      tree decl;
11814      tree arg;
11815 {
11816   tree var;
11817   tree decl_type;
11818
11819   if (TREE_CODE (arg) == DEFAULT_ARG)
11820     /* We get a DEFAULT_ARG when looking at an in-class declaration
11821        with a default argument.  Ignore the argument for now; we'll
11822        deal with it after the class is complete.  */
11823     return arg;
11824
11825   if (processing_template_decl || uses_template_parms (arg))
11826     /* We don't do anything checking until instantiation-time.  Note
11827        that there may be uninstantiated arguments even for an
11828        instantiated function, since default arguments are not
11829        instantiated until they are needed.  */
11830     return arg;
11831
11832   if (TYPE_P (decl))
11833     {
11834       decl_type = decl;
11835       decl = NULL_TREE;
11836     }
11837   else
11838     decl_type = TREE_TYPE (decl);
11839
11840   if (arg == error_mark_node
11841       || decl == error_mark_node
11842       || TREE_TYPE (arg) == error_mark_node
11843       || decl_type == error_mark_node)
11844     /* Something already went wrong.  There's no need to check
11845        further.  */
11846     return error_mark_node;
11847
11848   /* [dcl.fct.default]
11849
11850      A default argument expression is implicitly converted to the
11851      parameter type.  */
11852   if (!TREE_TYPE (arg)
11853       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11854     {
11855       if (decl)
11856         cp_error ("default argument for `%#D' has type `%T'",
11857                   decl, TREE_TYPE (arg));
11858       else
11859         cp_error ("default argument for parameter of type `%T' has type `%T'",
11860                   decl_type, TREE_TYPE (arg));
11861
11862       return error_mark_node;
11863     }
11864
11865   /* [dcl.fct.default]
11866
11867      Local variables shall not be used in default argument
11868      expressions.
11869
11870      The keyword `this' shall not be used in a default argument of a
11871      member function.  */
11872   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11873                                       NULL);
11874   if (var)
11875     {
11876       cp_error ("default argument `%E' uses local variable `%D'",
11877                 arg, var);
11878       return error_mark_node;
11879     }
11880
11881   /* All is well.  */
11882   return arg;
11883 }
11884
11885 /* Decode the list of parameter types for a function type.
11886    Given the list of things declared inside the parens,
11887    return a list of types.
11888
11889    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11890    flag. If unset, we append void_list_node. A parmlist declared
11891    as `(void)' is accepted as the empty parmlist.
11892
11893    Also set last_function_parms to the chain of PARM_DECLs.  */
11894
11895 static tree
11896 grokparms (first_parm)
11897      tree first_parm;
11898 {
11899   tree result = NULL_TREE;
11900   tree decls = NULL_TREE;
11901   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11902   tree parm, chain;
11903   int any_error = 0;
11904
11905   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11906
11907   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11908     {
11909       tree type = NULL_TREE;
11910       register tree decl = TREE_VALUE (parm);
11911       tree init = TREE_PURPOSE (parm);
11912
11913       chain = TREE_CHAIN (parm);
11914       /* @@ weak defense against parse errors.  */
11915       if (TREE_CODE (decl) != VOID_TYPE
11916           && TREE_CODE (decl) != TREE_LIST)
11917         {
11918           /* Give various messages as the need arises.  */
11919           if (TREE_CODE (decl) == STRING_CST)
11920             cp_error ("invalid string constant `%E'", decl);
11921           else if (TREE_CODE (decl) == INTEGER_CST)
11922             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11923           continue;
11924         }
11925
11926       if (parm == void_list_node)
11927         break;
11928
11929       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11930                      PARM, init != NULL_TREE, NULL_TREE);
11931       if (! decl || TREE_TYPE (decl) == error_mark_node)
11932         continue;
11933
11934       type = TREE_TYPE (decl);
11935       if (VOID_TYPE_P (type))
11936         {
11937           if (same_type_p (type, void_type_node)
11938               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11939             /* this is a parmlist of `(void)', which is ok.  */
11940             break;
11941           incomplete_type_error (decl, type);
11942           /* It's not a good idea to actually create parameters of
11943              type `void'; other parts of the compiler assume that a
11944              void type terminates the parameter list.  */
11945           type = error_mark_node;
11946           TREE_TYPE (decl) = error_mark_node;
11947         }
11948
11949       if (type != error_mark_node)
11950         {
11951           /* Top-level qualifiers on the parameters are
11952              ignored for function types.  */
11953           type = TYPE_MAIN_VARIANT (type);
11954           if (TREE_CODE (type) == METHOD_TYPE)
11955             {
11956               cp_error ("parameter `%D' invalidly declared method type", decl);
11957               type = build_pointer_type (type);
11958               TREE_TYPE (decl) = type;
11959             }
11960           else if (TREE_CODE (type) == OFFSET_TYPE)
11961             {
11962               cp_error ("parameter `%D' invalidly declared offset type", decl);
11963               type = build_pointer_type (type);
11964               TREE_TYPE (decl) = type;
11965             }
11966           else if (abstract_virtuals_error (decl, type))
11967             any_error = 1;  /* Seems like a good idea. */
11968           else if (POINTER_TYPE_P (type))
11969             {
11970               /* [dcl.fct]/6, parameter types cannot contain pointers
11971                  (references) to arrays of unknown bound.  */
11972               tree t = TREE_TYPE (type);
11973               int ptr = TYPE_PTR_P (type);
11974
11975               while (1)
11976                 {
11977                   if (TYPE_PTR_P (t))
11978                     ptr = 1;
11979                   else if (TREE_CODE (t) != ARRAY_TYPE)
11980                     break;
11981                   else if (!TYPE_DOMAIN (t))
11982                     break;
11983                   t = TREE_TYPE (t);
11984                 }
11985               if (TREE_CODE (t) == ARRAY_TYPE)
11986                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11987                           decl, ptr ? "pointer" : "reference", t);
11988             }
11989
11990           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11991           if (PROMOTE_PROTOTYPES
11992               && INTEGRAL_TYPE_P (type)
11993               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11994             DECL_ARG_TYPE (decl) = integer_type_node;
11995           if (!any_error && init)
11996             init = check_default_argument (decl, init);
11997           else
11998             init = NULL_TREE;
11999         }
12000
12001       TREE_CHAIN (decl) = decls;
12002       decls = decl;
12003       result = tree_cons (init, type, result);
12004     }
12005   decls = nreverse (decls);
12006   result = nreverse (result);
12007   if (!ellipsis)
12008     result = chainon (result, void_list_node);
12009   last_function_parms = decls;
12010
12011   return result;
12012 }
12013
12014 \f
12015 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12016    D's arguments allow it to be a copy constructor, or copy assignment
12017    operator.  */
12018
12019 int
12020 copy_args_p (d)
12021      tree d;
12022 {
12023   tree t;
12024
12025   if (!DECL_FUNCTION_MEMBER_P (d))
12026     return 0;
12027
12028   t = FUNCTION_FIRST_USER_PARMTYPE (d);
12029   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12030       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12031           == DECL_CONTEXT (d))
12032       && (TREE_CHAIN (t) == NULL_TREE
12033           || TREE_CHAIN (t) == void_list_node
12034           || TREE_PURPOSE (TREE_CHAIN (t))))
12035     return 1;
12036   return 0;
12037 }
12038
12039 /* These memoizing functions keep track of special properties which
12040    a class may have.  `grok_ctor_properties' notices whether a class
12041    has a constructor of the form X(X&), and also complains
12042    if the class has a constructor of the form X(X).
12043    `grok_op_properties' takes notice of the various forms of
12044    operator= which are defined, as well as what sorts of type conversion
12045    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12046
12047 int
12048 grok_ctor_properties (ctype, decl)
12049      tree ctype, decl;
12050 {
12051   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
12052   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12053
12054   /* [class.copy]
12055
12056      A non-template constructor for class X is a copy constructor if
12057      its first parameter is of type X&, const X&, volatile X& or const
12058      volatile X&, and either there are no other parameters or else all
12059      other parameters have default arguments.  */
12060   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12061       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12062       && sufficient_parms_p (TREE_CHAIN (parmtypes))
12063       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12064            && is_member_template (DECL_TI_TEMPLATE (decl))))
12065     {
12066       TYPE_HAS_INIT_REF (ctype) = 1;
12067       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12068         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12069     }
12070   /* [class.copy]
12071
12072      A declaration of a constructor for a class X is ill-formed if its
12073      first parameter is of type (optionally cv-qualified) X and either
12074      there are no other parameters or else all other parameters have
12075      default arguments.
12076
12077      We *don't* complain about member template instantiations that
12078      have this form, though; they can occur as we try to decide what
12079      constructor to use during overload resolution.  Since overload
12080      resolution will never prefer such a constructor to the
12081      non-template copy constructor (which is either explicitly or
12082      implicitly defined), there's no need to worry about their
12083      existence.  Theoretically, they should never even be
12084      instantiated, but that's hard to forestall.  */
12085   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12086            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12087            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12088                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12089     {
12090       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12091                 ctype, ctype);
12092       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12093       return 0;
12094     }
12095   else if (TREE_CODE (parmtype) == VOID_TYPE
12096            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12097     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12098
12099   return 1;
12100 }
12101
12102 /* An operator with this code is unary, but can also be binary.  */
12103
12104 static int
12105 ambi_op_p (code)
12106      enum tree_code code;
12107 {
12108   return (code == INDIRECT_REF
12109           || code == ADDR_EXPR
12110           || code == CONVERT_EXPR
12111           || code == NEGATE_EXPR
12112           || code == PREINCREMENT_EXPR
12113           || code == PREDECREMENT_EXPR);
12114 }
12115
12116 /* An operator with this name can only be unary.  */
12117
12118 static int
12119 unary_op_p (code)
12120      enum tree_code code;
12121 {
12122   return (code == TRUTH_NOT_EXPR
12123           || code == BIT_NOT_EXPR
12124           || code == COMPONENT_REF
12125           || code == TYPE_EXPR);
12126 }
12127
12128 /* Do a little sanity-checking on how they declared their operator.  */
12129
12130 void
12131 grok_op_properties (decl, virtualp, friendp)
12132      tree decl;
12133      int virtualp, friendp;
12134 {
12135   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12136   tree argtype;
12137   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12138   tree name = DECL_NAME (decl);
12139   enum tree_code operator_code;
12140   int arity;
12141
12142   /* Count the number of arguments.  */
12143   for (argtype = argtypes, arity = 0;
12144        argtype && argtype != void_list_node;
12145        argtype = TREE_CHAIN (argtype))
12146     ++arity;
12147
12148   if (current_class_type == NULL_TREE)
12149     friendp = 1;
12150
12151   if (DECL_CONV_FN_P (decl))
12152     operator_code = TYPE_EXPR;
12153   else
12154     do
12155       {
12156 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12157         if (ansi_opname (CODE) == name)                         \
12158           {                                                     \
12159             operator_code = CODE;                               \
12160             break;                                              \
12161           }                                                     \
12162         else if (ansi_assopname (CODE) == name)                 \
12163           {                                                     \
12164             operator_code = CODE;                               \
12165             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12166             break;                                              \
12167           }
12168
12169 #include "operators.def"
12170 #undef DEF_OPERATOR
12171
12172         my_friendly_abort (20000527);
12173       }
12174     while (0);
12175   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12176   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12177
12178   if (! friendp)
12179     {
12180       switch (operator_code)
12181         {
12182         case CALL_EXPR:
12183           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12184           break;
12185
12186         case ARRAY_REF:
12187           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12188           break;
12189
12190         case COMPONENT_REF:
12191         case MEMBER_REF:
12192           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12193           break;
12194
12195         case NEW_EXPR:
12196           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12197           break;
12198
12199         case DELETE_EXPR:
12200           TYPE_GETS_DELETE (current_class_type) |= 1;
12201           break;
12202
12203         case VEC_NEW_EXPR:
12204           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12205           break;
12206
12207         case VEC_DELETE_EXPR:
12208           TYPE_GETS_DELETE (current_class_type) |= 2;
12209           break;
12210
12211         default:
12212           break;
12213         }
12214     }
12215
12216   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12217     {
12218       /* When the compiler encounters the definition of A::operator new, it
12219          doesn't look at the class declaration to find out if it's static.  */
12220       if (methodp)
12221         revert_static_member_fn (decl);
12222
12223       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12224     }
12225   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12226     {
12227       if (methodp)
12228         revert_static_member_fn (decl);
12229
12230       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12231     }
12232   else
12233     {
12234       /* An operator function must either be a non-static member function
12235          or have at least one parameter of a class, a reference to a class,
12236          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12237       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12238         {
12239           if (operator_code == TYPE_EXPR
12240               || operator_code == CALL_EXPR
12241               || operator_code == COMPONENT_REF
12242               || operator_code == ARRAY_REF
12243               || operator_code == NOP_EXPR)
12244             cp_error ("`%D' must be a nonstatic member function", decl);
12245           else
12246             {
12247               tree p = argtypes;
12248
12249               if (DECL_STATIC_FUNCTION_P (decl))
12250                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12251
12252               if (p)
12253                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12254                   {
12255                     tree arg = TREE_VALUE (p);
12256                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12257                       arg = TREE_TYPE (arg);
12258
12259                     /* This lets bad template code slip through.  */
12260                     if (IS_AGGR_TYPE (arg)
12261                         || TREE_CODE (arg) == ENUMERAL_TYPE
12262                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12263                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12264                       goto foundaggr;
12265                   }
12266               cp_error
12267                 ("`%D' must have an argument of class or enumerated type",
12268                  decl);
12269             foundaggr:
12270               ;
12271             }
12272         }
12273
12274       if (operator_code == CALL_EXPR)
12275         return;                 /* No restrictions on args. */
12276
12277       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12278         {
12279           tree t = TREE_TYPE (name);
12280           if (! friendp)
12281             {
12282               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12283               const char *what = 0;
12284
12285               if (ref)
12286                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12287
12288               if (TREE_CODE (t) == VOID_TYPE)
12289                 what = "void";
12290               else if (t == current_class_type)
12291                 what = "the same type";
12292               /* Don't force t to be complete here.  */
12293               else if (IS_AGGR_TYPE (t)
12294                        && COMPLETE_TYPE_P (t)
12295                        && DERIVED_FROM_P (t, current_class_type))
12296                 what = "a base class";
12297
12298               if (what)
12299                 warning ("conversion to %s%s will never use a type conversion operator",
12300                          ref ? "a reference to " : "", what);
12301             }
12302         }
12303
12304       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12305           && operator_code == NOP_EXPR)
12306         {
12307           tree parmtype;
12308
12309           if (arity != 2 && methodp)
12310             {
12311               cp_error ("`%D' must take exactly one argument", decl);
12312               return;
12313             }
12314           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12315
12316           /* [class.copy]
12317
12318              A user-declared copy assignment operator X::operator= is
12319              a non-static non-template member function of class X with
12320              exactly one parameter of type X, X&, const X&, volatile
12321              X& or const volatile X&.  */
12322           if (copy_assignment_arg_p (parmtype, virtualp)
12323               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12324                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12325               && ! friendp)
12326             {
12327               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12328               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12329                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12330                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12331             }
12332         }
12333       else if (operator_code == COND_EXPR)
12334         {
12335           /* 13.4.0.3 */
12336           cp_error ("ISO C++ prohibits overloading operator ?:");
12337         }
12338       else if (ambi_op_p (operator_code))
12339         {
12340           if (arity == 1)
12341             /* We pick the one-argument operator codes by default, so
12342                we don't have to change anything.  */
12343             ;
12344           else if (arity == 2)
12345             {
12346               /* If we thought this was a unary operator, we now know
12347                  it to be a binary operator.  */
12348               switch (operator_code)
12349                 {
12350                 case INDIRECT_REF:
12351                   operator_code = MULT_EXPR;
12352                   break;
12353
12354                 case ADDR_EXPR:
12355                   operator_code = BIT_AND_EXPR;
12356                   break;
12357
12358                 case CONVERT_EXPR:
12359                   operator_code = PLUS_EXPR;
12360                   break;
12361
12362                 case NEGATE_EXPR:
12363                   operator_code = MINUS_EXPR;
12364                   break;
12365
12366                 case PREINCREMENT_EXPR:
12367                   operator_code = POSTINCREMENT_EXPR;
12368                   break;
12369
12370                 case PREDECREMENT_EXPR:
12371                   operator_code = POSTDECREMENT_EXPR;
12372                   break;
12373
12374                 default:
12375                   my_friendly_abort (20000527);
12376                 }
12377
12378               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12379
12380               if ((operator_code == POSTINCREMENT_EXPR
12381                    || operator_code == POSTDECREMENT_EXPR)
12382                   && ! processing_template_decl
12383                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12384                 {
12385                   if (methodp)
12386                     cp_error ("postfix `%D' must take `int' as its argument",
12387                               decl);
12388                   else
12389                     cp_error
12390                       ("postfix `%D' must take `int' as its second argument",
12391                        decl);
12392                 }
12393             }
12394           else
12395             {
12396               if (methodp)
12397                 cp_error ("`%D' must take either zero or one argument", decl);
12398               else
12399                 cp_error ("`%D' must take either one or two arguments", decl);
12400             }
12401
12402           /* More Effective C++ rule 6.  */
12403           if (warn_ecpp
12404               && (operator_code == POSTINCREMENT_EXPR
12405                   || operator_code == POSTDECREMENT_EXPR
12406                   || operator_code == PREINCREMENT_EXPR
12407                   || operator_code == PREDECREMENT_EXPR))
12408             {
12409               tree arg = TREE_VALUE (argtypes);
12410               tree ret = TREE_TYPE (TREE_TYPE (decl));
12411               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12412                 arg = TREE_TYPE (arg);
12413               arg = TYPE_MAIN_VARIANT (arg);
12414               if (operator_code == PREINCREMENT_EXPR
12415                   || operator_code == PREDECREMENT_EXPR)
12416                 {
12417                   if (TREE_CODE (ret) != REFERENCE_TYPE
12418                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12419                                        arg))
12420                     cp_warning ("prefix `%D' should return `%T'", decl,
12421                                 build_reference_type (arg));
12422                 }
12423               else
12424                 {
12425                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12426                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12427                 }
12428             }
12429         }
12430       else if (unary_op_p (operator_code))
12431         {
12432           if (arity != 1)
12433             {
12434               if (methodp)
12435                 cp_error ("`%D' must take `void'", decl);
12436               else
12437                 cp_error ("`%D' must take exactly one argument", decl);
12438             }
12439         }
12440       else /* if (binary_op_p (operator_code)) */
12441         {
12442           if (arity != 2)
12443             {
12444               if (methodp)
12445                 cp_error ("`%D' must take exactly one argument", decl);
12446               else
12447                 cp_error ("`%D' must take exactly two arguments", decl);
12448             }
12449
12450           /* More Effective C++ rule 7.  */
12451           if (warn_ecpp
12452               && (operator_code == TRUTH_ANDIF_EXPR
12453                   || operator_code == TRUTH_ORIF_EXPR
12454                   || operator_code == COMPOUND_EXPR))
12455             cp_warning ("user-defined `%D' always evaluates both arguments",
12456                         decl);
12457         }
12458
12459       /* Effective C++ rule 23.  */
12460       if (warn_ecpp
12461           && arity == 2
12462           && (operator_code == PLUS_EXPR
12463               || operator_code == MINUS_EXPR
12464               || operator_code == TRUNC_DIV_EXPR
12465               || operator_code == MULT_EXPR)
12466           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12467         cp_warning ("`%D' should return by value", decl);
12468
12469       /* 13.4.0.8 */
12470       for (; argtypes && argtypes != void_list_node;
12471           argtypes = TREE_CHAIN (argtypes))
12472         if (TREE_PURPOSE (argtypes))
12473           {
12474             TREE_PURPOSE (argtypes) = NULL_TREE;
12475             if (operator_code == POSTINCREMENT_EXPR
12476                 || operator_code == POSTDECREMENT_EXPR)
12477               {
12478                 if (pedantic)
12479                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12480               }
12481             else
12482               cp_error ("`%D' cannot have default arguments", decl);
12483           }
12484
12485     }
12486 }
12487 \f
12488 static const char *
12489 tag_name (code)
12490      enum tag_types code;
12491 {
12492   switch (code)
12493     {
12494     case record_type:
12495       return "struct";
12496     case class_type:
12497       return "class";
12498     case union_type:
12499       return "union ";
12500     case enum_type:
12501       return "enum";
12502     default:
12503       my_friendly_abort (981122);
12504     }
12505 }
12506
12507 /* Get the struct, enum or union (CODE says which) with tag NAME.
12508    Define the tag as a forward-reference if it is not defined.
12509
12510    C++: If a class derivation is given, process it here, and report
12511    an error if multiple derivation declarations are not identical.
12512
12513    If this is a definition, come in through xref_tag and only look in
12514    the current frame for the name (since C++ allows new names in any
12515    scope.)  */
12516
12517 tree
12518 xref_tag (code_type_node, name, globalize)
12519      tree code_type_node;
12520      tree name;
12521      int globalize;
12522 {
12523   enum tag_types tag_code;
12524   enum tree_code code;
12525   register tree ref, t;
12526   struct binding_level *b = current_binding_level;
12527   int got_type = 0;
12528   tree attributes = NULL_TREE;
12529   tree context = NULL_TREE;
12530
12531   /* If we are called from the parser, code_type_node will sometimes be a
12532      TREE_LIST.  This indicates that the user wrote
12533      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12534      use them later.  */
12535   if (TREE_CODE (code_type_node) == TREE_LIST)
12536     {
12537       attributes = TREE_PURPOSE (code_type_node);
12538       code_type_node = TREE_VALUE (code_type_node);
12539     }
12540
12541   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12542   switch (tag_code)
12543     {
12544     case record_type:
12545     case class_type:
12546       code = RECORD_TYPE;
12547       break;
12548     case union_type:
12549       code = UNION_TYPE;
12550       break;
12551     case enum_type:
12552       code = ENUMERAL_TYPE;
12553       break;
12554     default:
12555       my_friendly_abort (18);
12556     }
12557
12558   /* If a cross reference is requested, look up the type
12559      already defined for this tag and return it.  */
12560   if (TYPE_P (name))
12561     {
12562       t = name;
12563       name = TYPE_IDENTIFIER (t);
12564       got_type = 1;
12565     }
12566   else
12567     t = IDENTIFIER_TYPE_VALUE (name);
12568
12569   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12570   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12571     {
12572       static int explained;
12573       tree shadowed;
12574
12575       cp_warning ("`%s %T' declares a new type at namespace scope",
12576                   tag_name (tag_code), name);
12577       if (!explained++)
12578         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12579                     tag_name (tag_code),
12580                     constructor_name (current_class_type),
12581                     TYPE_IDENTIFIER (t));
12582
12583       /* We need to remove the class scope binding for the
12584          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12585       for (shadowed = b->class_shadowed;
12586            shadowed;
12587            shadowed = TREE_CHAIN (shadowed))
12588         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12589           {
12590             TREE_PURPOSE (shadowed) = NULL_TREE;
12591             break;
12592           }
12593     }
12594
12595   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12596       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12597     t = NULL_TREE;
12598
12599   if (! globalize)
12600     {
12601       /* If we know we are defining this tag, only look it up in
12602          this scope and don't try to find it as a type.  */
12603       ref = lookup_tag (code, name, b, 1);
12604     }
12605   else
12606     {
12607       if (t)
12608         {
12609           /* [dcl.type.elab] If the identifier resolves to a
12610              typedef-name or a template type-parameter, the
12611              elaborated-type-specifier is ill-formed.  */
12612           if (t != TYPE_MAIN_VARIANT (t)
12613               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12614             cp_pedwarn ("using typedef-name `%D' after `%s'",
12615                         TYPE_NAME (t), tag_name (tag_code));
12616           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12617             cp_error ("using template type parameter `%T' after `%s'",
12618                       t, tag_name (tag_code));
12619
12620           ref = t;
12621         }
12622       else
12623         ref = lookup_tag (code, name, b, 0);
12624
12625       if (! ref)
12626         {
12627           /* Try finding it as a type declaration.  If that wins,
12628              use it.  */
12629           ref = lookup_name (name, 1);
12630
12631           if (ref != NULL_TREE
12632               && processing_template_decl
12633               && DECL_CLASS_TEMPLATE_P (ref)
12634               && template_class_depth (current_class_type) == 0)
12635             /* Since GLOBALIZE is true, we're declaring a global
12636                template, so we want this type.  */
12637             ref = DECL_TEMPLATE_RESULT (ref);
12638
12639           if (ref && TREE_CODE (ref) == TYPE_DECL
12640               && TREE_CODE (TREE_TYPE (ref)) == code)
12641             ref = TREE_TYPE (ref);
12642           else
12643             ref = NULL_TREE;
12644         }
12645
12646       if (ref && current_class_type
12647           && template_class_depth (current_class_type)
12648           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12649         {
12650           /* Since GLOBALIZE is non-zero, we are not looking at a
12651              definition of this tag.  Since, in addition, we are currently
12652              processing a (member) template declaration of a template
12653              class, we must be very careful; consider:
12654
12655                template <class X>
12656                struct S1
12657
12658                template <class U>
12659                struct S2
12660                { template <class V>
12661                friend struct S1; };
12662
12663              Here, the S2::S1 declaration should not be confused with the
12664              outer declaration.  In particular, the inner version should
12665              have a template parameter of level 2, not level 1.  This
12666              would be particularly important if the member declaration
12667              were instead:
12668
12669                template <class V = U> friend struct S1;
12670
12671              say, when we should tsubst into `U' when instantiating
12672              S2.  On the other hand, when presented with:
12673
12674                  template <class T>
12675                  struct S1 {
12676                    template <class U>
12677                    struct S2 {};
12678                    template <class U>
12679                    friend struct S2;
12680                  };
12681
12682               we must find the inner binding eventually.  We
12683               accomplish this by making sure that the new type we
12684               create to represent this declaration has the right
12685               TYPE_CONTEXT.  */
12686           context = TYPE_CONTEXT (ref);
12687           ref = NULL_TREE;
12688         }
12689     }
12690
12691   if (! ref)
12692     {
12693       /* If no such tag is yet defined, create a forward-reference node
12694          and record it as the "definition".
12695          When a real declaration of this type is found,
12696          the forward-reference will be altered into a real type.  */
12697       if (code == ENUMERAL_TYPE)
12698         {
12699           cp_error ("use of enum `%#D' without previous declaration", name);
12700
12701           ref = make_node (ENUMERAL_TYPE);
12702
12703           /* Give the type a default layout like unsigned int
12704              to avoid crashing if it does not get defined.  */
12705           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12706           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12707           TYPE_USER_ALIGN (ref) = 0;
12708           TREE_UNSIGNED (ref) = 1;
12709           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12710           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12711           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12712
12713           /* Enable us to recognize when a type is created in class context.
12714              To do nested classes correctly, this should probably be cleared
12715              out when we leave this classes scope.  Currently this in only
12716              done in `start_enum'.  */
12717
12718           pushtag (name, ref, globalize);
12719         }
12720       else
12721         {
12722           struct binding_level *old_b = class_binding_level;
12723
12724           ref = make_aggr_type (code);
12725           TYPE_CONTEXT (ref) = context;
12726
12727 #ifdef NONNESTED_CLASSES
12728           /* Class types don't nest the way enums do.  */
12729           class_binding_level = (struct binding_level *)0;
12730 #endif
12731           pushtag (name, ref, globalize);
12732           class_binding_level = old_b;
12733         }
12734     }
12735   else
12736     {
12737       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12738         redeclare_class_template (ref, current_template_parms);
12739     }
12740
12741   /* Until the type is defined, tentatively accept whatever
12742      structure tag the user hands us.  */
12743   if (!COMPLETE_TYPE_P (ref)
12744       && ref != current_class_type
12745       /* Have to check this, in case we have contradictory tag info.  */
12746       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12747     {
12748       if (tag_code == class_type)
12749         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12750       else if (tag_code == record_type)
12751         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12752     }
12753
12754   TREE_TYPE (ref) = attributes;
12755
12756   return ref;
12757 }
12758
12759 tree
12760 xref_tag_from_type (old, id, globalize)
12761      tree old, id;
12762      int globalize;
12763 {
12764   tree code_type_node;
12765
12766   if (TREE_CODE (old) == RECORD_TYPE)
12767     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12768                       ? class_type_node : record_type_node);
12769   else
12770     code_type_node = union_type_node;
12771
12772   if (id == NULL_TREE)
12773     id = TYPE_IDENTIFIER (old);
12774
12775   return xref_tag (code_type_node, id, globalize);
12776 }
12777
12778 /* REF is a type (named NAME), for which we have just seen some
12779    baseclasses.  BINFO is a list of those baseclasses; the
12780    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12781    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12782    struct, or union.  */
12783
12784 void
12785 xref_basetypes (code_type_node, name, ref, binfo)
12786      tree code_type_node;
12787      tree name, ref;
12788      tree binfo;
12789 {
12790   /* In the declaration `A : X, Y, ... Z' we mark all the types
12791      (A, X, Y, ..., Z) so we can check for duplicates.  */
12792   tree binfos;
12793   tree base;
12794
12795   int i, len;
12796   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12797
12798   if (tag_code == union_type)
12799     {
12800       cp_error ("derived union `%T' invalid", ref);
12801       return;
12802     }
12803
12804   len = list_length (binfo);
12805
12806   /* First, make sure that any templates in base-classes are
12807      instantiated.  This ensures that if we call ourselves recursively
12808      we do not get confused about which classes are marked and which
12809      are not.  */
12810   for (base = binfo; base; base = TREE_CHAIN (base))
12811     complete_type (TREE_VALUE (base));
12812
12813   SET_CLASSTYPE_MARKED (ref);
12814   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12815
12816   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12817     {
12818       /* The base of a derived struct is public by default.  */
12819       int via_public
12820         = (TREE_PURPOSE (binfo) == access_public_node
12821            || TREE_PURPOSE (binfo) == access_public_virtual_node
12822            || (tag_code != class_type
12823                && (TREE_PURPOSE (binfo) == access_default_node
12824                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12825       int via_protected
12826         = (TREE_PURPOSE (binfo) == access_protected_node
12827            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12828       int via_virtual
12829         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12830            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12831            || TREE_PURPOSE (binfo) == access_public_virtual_node
12832            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12833       tree basetype = TREE_VALUE (binfo);
12834       tree base_binfo;
12835
12836       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12837         basetype = TREE_TYPE (basetype);
12838       if (!basetype
12839           || (TREE_CODE (basetype) != RECORD_TYPE
12840               && TREE_CODE (basetype) != TYPENAME_TYPE
12841               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12842               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12843         {
12844           cp_error ("base type `%T' fails to be a struct or class type",
12845                     TREE_VALUE (binfo));
12846           continue;
12847         }
12848
12849       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12850
12851       /* This code replaces similar code in layout_basetypes.
12852          We put the complete_type first for implicit `typename'.  */
12853       if (!COMPLETE_TYPE_P (basetype)
12854           && ! (current_template_parms && uses_template_parms (basetype)))
12855         {
12856           cp_error ("base class `%T' has incomplete type", basetype);
12857           continue;
12858         }
12859       else
12860         {
12861           if (CLASSTYPE_MARKED (basetype))
12862             {
12863               if (basetype == ref)
12864                 cp_error ("recursive type `%T' undefined", basetype);
12865               else
12866                 cp_error ("duplicate base type `%T' invalid", basetype);
12867               continue;
12868             }
12869
12870           if (TYPE_FOR_JAVA (basetype)
12871               && (current_lang_depth () == 0))
12872             TYPE_FOR_JAVA (ref) = 1;
12873
12874           /* Note that the BINFO records which describe individual
12875              inheritances are *not* shared in the lattice!  They
12876              cannot be shared because a given baseclass may be
12877              inherited with different `accessibility' by different
12878              derived classes.  (Each BINFO record describing an
12879              individual inheritance contains flags which say what
12880              the `accessibility' of that particular inheritance is.)  */
12881
12882           base_binfo
12883             = make_binfo (size_zero_node, basetype,
12884                           CLASS_TYPE_P (basetype)
12885                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12886                           CLASS_TYPE_P (basetype)
12887                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12888
12889           TREE_VEC_ELT (binfos, i) = base_binfo;
12890           TREE_VIA_PUBLIC (base_binfo) = via_public;
12891           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12892           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12893           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12894
12895           /* We need to unshare the binfos now so that lookups during class
12896              definition work.  */
12897           unshare_base_binfos (base_binfo);
12898
12899           SET_CLASSTYPE_MARKED (basetype);
12900
12901           /* We are free to modify these bits because they are meaningless
12902              at top level, and BASETYPE is a top-level type.  */
12903           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12904             {
12905               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12906               /* Converting to a virtual base class requires looking
12907                  up the offset of the virtual base.  */
12908               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12909             }
12910
12911           if (CLASS_TYPE_P (basetype))
12912             {
12913               TYPE_HAS_NEW_OPERATOR (ref)
12914                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12915               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12916                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12917               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12918               /* If the base-class uses multiple inheritance, so do we.  */
12919               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12920                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12921               /* Likewise, if converting to a base of the base may require
12922                  code, then we may need to generate code to convert to a
12923                  base as well.  */
12924               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12925                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12926             }
12927
12928           i += 1;
12929         }
12930     }
12931   if (i)
12932     TREE_VEC_LENGTH (binfos) = i;
12933   else
12934     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12935
12936   if (i > 1)
12937     {
12938       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12939       /* If there is more than one non-empty they cannot be at the same
12940          address.  */
12941       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12942     }
12943
12944   /* Unmark all the types.  */
12945   while (--i >= 0)
12946     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12947   CLEAR_CLASSTYPE_MARKED (ref);
12948
12949   /* Now that we know all the base-classes, set up the list of virtual
12950      bases.  */
12951   get_vbase_types (ref);
12952 }
12953
12954 \f
12955 /* Begin compiling the definition of an enumeration type.
12956    NAME is its name (or null if anonymous).
12957    Returns the type object, as yet incomplete.
12958    Also records info about it so that build_enumerator
12959    may be used to declare the individual values as they are read.  */
12960
12961 tree
12962 start_enum (name)
12963      tree name;
12964 {
12965   register tree enumtype = NULL_TREE;
12966   struct binding_level *b = current_binding_level;
12967
12968   /* If this is the real definition for a previous forward reference,
12969      fill in the contents in the same object that used to be the
12970      forward reference.  */
12971
12972   if (name != NULL_TREE)
12973     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12974
12975   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12976     {
12977       cp_error ("multiple definition of `%#T'", enumtype);
12978       cp_error_at ("previous definition here", enumtype);
12979       /* Clear out TYPE_VALUES, and start again.  */
12980       TYPE_VALUES (enumtype) = NULL_TREE;
12981     }
12982   else
12983     {
12984       enumtype = make_node (ENUMERAL_TYPE);
12985       pushtag (name, enumtype, 0);
12986     }
12987
12988   if (current_class_type)
12989     TREE_ADDRESSABLE (b->tags) = 1;
12990
12991   GNU_xref_decl (current_function_decl, enumtype);
12992   return enumtype;
12993 }
12994
12995 /* After processing and defining all the values of an enumeration type,
12996    install their decls in the enumeration type and finish it off.
12997    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12998
12999 void
13000 finish_enum (enumtype)
13001      tree enumtype;
13002 {
13003   tree pair;
13004   tree minnode;
13005   tree maxnode;
13006   tree t;
13007   bool unsignedp;
13008   int lowprec;
13009   int highprec;
13010   int precision;
13011
13012   /* We built up the VALUES in reverse order.  */
13013   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13014
13015   /* [dcl.enum]
13016
13017      Following the closing brace of an enum-specifier, each
13018      enumerator has the type of its enumeration.  Prior to the
13019      closing brace, the type of each enumerator is the type of
13020      its initializing value.  */
13021   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13022     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13023
13024   /* For a enum defined in a template, all further processing is
13025      postponed until the template is instantiated.  */
13026   if (processing_template_decl)
13027     {
13028       tree scope = current_scope ();
13029       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13030         add_stmt (build_min (TAG_DEFN, enumtype));
13031
13032
13033       return;
13034     }
13035
13036   /* Figure out what the minimum and maximum values of the enumerators
13037      are.  */
13038   if (TYPE_VALUES (enumtype))
13039     {
13040       minnode = maxnode = NULL_TREE;
13041
13042       for (pair = TYPE_VALUES (enumtype);
13043            pair;
13044            pair = TREE_CHAIN (pair))
13045         {
13046           tree value;
13047
13048           value = DECL_INITIAL (TREE_VALUE (pair));
13049
13050           if (!minnode)
13051             minnode = maxnode = value;
13052           else if (tree_int_cst_lt (maxnode, value))
13053             maxnode = value;
13054           else if (tree_int_cst_lt (value, minnode))
13055             minnode = value;
13056         }
13057     }
13058   else
13059     minnode = maxnode = integer_zero_node;
13060
13061   /* Compute the number of bits require to represent all values of the
13062      enumeration.  We must do this before the type of MINNODE and
13063      MAXNODE are transformed, since min_precision relies on the
13064      TREE_TYPE of the value it is passed.  */
13065   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13066   lowprec = min_precision (minnode, unsignedp);
13067   highprec = min_precision (maxnode, unsignedp);
13068   precision = MAX (lowprec, highprec);
13069
13070   /* Set the TREE_TYPE for the values as well.  That's so that when we
13071      call decl_constant_value we get an entity of the right type (but
13072      with the constant value).  In addition, transform the TYPE_VALUES
13073      list to contain the values, rather than the CONST_DECLs for them.  */
13074   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13075     {
13076       tree value = DECL_INITIAL (TREE_VALUE (pair));
13077
13078       TREE_TYPE (value) = enumtype;
13079       TREE_VALUE (pair) = value;
13080     }
13081
13082   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13083   TYPE_SIZE (enumtype) = NULL_TREE;
13084   TYPE_PRECISION (enumtype) = precision;
13085   if (unsignedp)
13086     fixup_unsigned_type (enumtype);
13087   else
13088     fixup_signed_type (enumtype);
13089
13090   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13091     /* Use the width of the narrowest normal C type which is wide
13092        enough.  */
13093     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13094                                                 (precision, 1));
13095   else
13096     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13097
13098   TYPE_SIZE (enumtype) = NULL_TREE;
13099   layout_type (enumtype);
13100
13101   /* Fix up all variant types of this enum type.  */
13102   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13103     {
13104       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13105       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13106       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13107       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13108       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13109       TYPE_MODE (t) = TYPE_MODE (enumtype);
13110       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13111       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13112       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13113       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13114     }
13115
13116   /* Finish debugging output for this type.  */
13117   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13118 }
13119
13120 /* Build and install a CONST_DECL for an enumeration constant of the
13121    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13122    Assignment of sequential values by default is handled here.  */
13123
13124 void
13125 build_enumerator (name, value, enumtype)
13126      tree name;
13127      tree value;
13128      tree enumtype;
13129 {
13130   tree decl;
13131   tree context;
13132   tree type;
13133   tree values;
13134
13135   /* Remove no-op casts from the value.  */
13136   if (value)
13137     STRIP_TYPE_NOPS (value);
13138
13139   if (! processing_template_decl)
13140     {
13141       /* Validate and default VALUE.  */
13142       if (value != NULL_TREE)
13143         {
13144           value = decl_constant_value (value);
13145
13146           if (TREE_CODE (value) == INTEGER_CST)
13147             {
13148               value = default_conversion (value);
13149               constant_expression_warning (value);
13150             }
13151           else
13152             {
13153               cp_error ("enumerator value for `%D' not integer constant", name);
13154               value = NULL_TREE;
13155             }
13156         }
13157
13158       /* Default based on previous value.  */
13159       if (value == NULL_TREE && ! processing_template_decl)
13160         {
13161           tree prev_value;
13162
13163           if (TYPE_VALUES (enumtype))
13164             {
13165               /* The next value is the previous value ... */
13166               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13167               /* ... plus one.  */
13168               value = cp_build_binary_op (PLUS_EXPR,
13169                                           prev_value,
13170                                           integer_one_node);
13171
13172               if (tree_int_cst_lt (value, prev_value))
13173                 cp_error ("overflow in enumeration values at `%D'", name);
13174             }
13175           else
13176             value = integer_zero_node;
13177         }
13178
13179       /* Remove no-op casts from the value.  */
13180       if (value)
13181         STRIP_TYPE_NOPS (value);
13182 #if 0
13183       /* To fix MAX_VAL enum consts. (bkoz)  */
13184       TREE_TYPE (value) = integer_type_node;
13185 #endif
13186     }
13187
13188   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13189      Even in other cases, we will later (in finish_enum) be setting
13190      the type of VALUE.  But, we don't need to make a copy if this
13191      VALUE is one of the enumeration constants for this same
13192      enumeration type.  */
13193   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13194     if (TREE_VALUE (values) == value)
13195       break;
13196   /* If we didn't break out of the loop, then we do need a copy.  */
13197   if (!values && value)
13198     value = copy_node (value);
13199
13200   /* C++ associates enums with global, function, or class declarations.  */
13201   context = current_scope ();
13202
13203   /* Build the actual enumeration constant.  Note that the enumeration
13204     constants have the type of their initializers until the
13205     enumeration is complete:
13206
13207       [ dcl.enum ]
13208
13209       Following the closing brace of an enum-specifier, each enumer-
13210       ator has the type of its enumeration.  Prior to the closing
13211       brace, the type of each enumerator is the type of its
13212       initializing value.
13213
13214     In finish_enum we will reset the type.  Of course, if we're
13215     processing a template, there may be no value.   */
13216   type = value ? TREE_TYPE (value) : NULL_TREE;
13217
13218   if (context && context == current_class_type)
13219     /* This enum declaration is local to the class.  We need the full
13220        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13221     decl = build_lang_decl (CONST_DECL, name, type);
13222   else
13223     /* It's a global enum, or it's local to a function.  (Note local to
13224       a function could mean local to a class method.  */
13225     decl = build_decl (CONST_DECL, name, type);
13226
13227   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13228   DECL_INITIAL (decl) = value;
13229   TREE_READONLY (decl) = 1;
13230
13231   if (context && context == current_class_type)
13232     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13233       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13234       things like `S::i' later.)  */
13235     finish_member_declaration (decl);
13236   else
13237     {
13238       pushdecl (decl);
13239       GNU_xref_decl (current_function_decl, decl);
13240     }
13241
13242   /* Add this enumeration constant to the list for this type.  */
13243   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13244 }
13245
13246 \f
13247 /* We're defining DECL.  Make sure that it's type is OK.  */
13248
13249 static void
13250 check_function_type (decl, current_function_parms)
13251      tree decl;
13252      tree current_function_parms;
13253 {
13254   tree fntype = TREE_TYPE (decl);
13255   tree return_type = complete_type (TREE_TYPE (fntype));
13256
13257   /* In a function definition, arg types must be complete.  */
13258   require_complete_types_for_parms (current_function_parms);
13259
13260   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13261     {
13262       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13263
13264       /* Make it return void instead, but don't change the
13265          type of the DECL_RESULT, in case we have a named return value.  */
13266       if (TREE_CODE (fntype) == METHOD_TYPE)
13267         {
13268           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13269           TREE_TYPE (decl)
13270             = build_cplus_method_type (ctype,
13271                                        void_type_node,
13272                                        FUNCTION_ARG_CHAIN (decl));
13273         }
13274       else
13275         TREE_TYPE (decl)
13276           = build_function_type (void_type_node,
13277                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13278       TREE_TYPE (decl)
13279         = build_exception_variant (fntype,
13280                                    TYPE_RAISES_EXCEPTIONS (fntype));
13281     }
13282   else
13283     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13284 }
13285
13286 /* Create the FUNCTION_DECL for a function definition.
13287    DECLSPECS and DECLARATOR are the parts of the declaration;
13288    they describe the function's name and the type it returns,
13289    but twisted together in a fashion that parallels the syntax of C.
13290
13291    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13292    DECLARATOR is really the DECL for the function we are about to
13293    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13294    indicating that the function is an inline defined in-class.
13295
13296    This function creates a binding context for the function body
13297    as well as setting up the FUNCTION_DECL in current_function_decl.
13298
13299    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13300    (it defines a datum instead), we return 0, which tells
13301    yyparse to report a parse error.
13302
13303    For C++, we must first check whether that datum makes any sense.
13304    For example, "class A local_a(1,2);" means that variable local_a
13305    is an aggregate of type A, which should have a constructor
13306    applied to it with the argument list [1, 2].  */
13307
13308 int
13309 start_function (declspecs, declarator, attrs, flags)
13310      tree declspecs, declarator, attrs;
13311      int flags;
13312 {
13313   tree decl1;
13314   tree ctype = NULL_TREE;
13315   tree fntype;
13316   tree restype;
13317   extern int have_extern_spec;
13318   extern int used_extern_spec;
13319   int doing_friend = 0;
13320   struct binding_level *bl;
13321   tree current_function_parms;
13322
13323   /* Sanity check.  */
13324   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13325   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13326
13327   /* This should only be done once on the top most decl.  */
13328   if (have_extern_spec && !used_extern_spec)
13329     {
13330       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13331       used_extern_spec = 1;
13332     }
13333
13334   if (flags & SF_PRE_PARSED)
13335     {
13336       decl1 = declarator;
13337
13338       fntype = TREE_TYPE (decl1);
13339       if (TREE_CODE (fntype) == METHOD_TYPE)
13340         ctype = TYPE_METHOD_BASETYPE (fntype);
13341
13342       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13343          the (lexical) scope of the class in which it is defined.  */
13344       if (!ctype && DECL_FRIEND_P (decl1))
13345         {
13346           ctype = DECL_FRIEND_CONTEXT (decl1);
13347
13348           /* CTYPE could be null here if we're dealing with a template;
13349              for example, `inline friend float foo()' inside a template
13350              will have no CTYPE set.  */
13351           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13352             ctype = NULL_TREE;
13353           else
13354             doing_friend = 1;
13355         }
13356
13357       last_function_parms = DECL_ARGUMENTS (decl1);
13358       last_function_parm_tags = NULL_TREE;
13359     }
13360   else
13361     {
13362       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13363       /* If the declarator is not suitable for a function definition,
13364          cause a syntax error.  */
13365       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13366
13367       fntype = TREE_TYPE (decl1);
13368
13369       restype = TREE_TYPE (fntype);
13370       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13371         {
13372           cp_error ("semicolon missing after declaration of `%#T'", restype);
13373           shadow_tag (build_tree_list (NULL_TREE, restype));
13374           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13375           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13376             fntype = build_function_type (integer_type_node,
13377                                           TYPE_ARG_TYPES (fntype));
13378           else
13379             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13380                                               integer_type_node,
13381                                               TYPE_ARG_TYPES (fntype));
13382           TREE_TYPE (decl1) = fntype;
13383         }
13384
13385       if (TREE_CODE (fntype) == METHOD_TYPE)
13386         ctype = TYPE_METHOD_BASETYPE (fntype);
13387       else if (DECL_MAIN_P (decl1))
13388         {
13389           /* If this doesn't return integer_type, complain.  */
13390           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13391             {
13392               if (pedantic || warn_return_type)
13393                 pedwarn ("return type for `main' changed to `int'");
13394               TREE_TYPE (decl1) = fntype = default_function_type;
13395             }
13396         }
13397     }
13398
13399   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13400     /* This is a constructor, we must ensure that any default args
13401        introduced by this definition are propagated to the clones
13402        now. The clones are used directly in overload resolution.  */
13403     adjust_clone_args (decl1);
13404
13405   /* Sometimes we don't notice that a function is a static member, and
13406      build a METHOD_TYPE for it.  Fix that up now.  */
13407   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13408       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13409     {
13410       revert_static_member_fn (decl1);
13411       last_function_parms = TREE_CHAIN (last_function_parms);
13412       ctype = NULL_TREE;
13413     }
13414
13415   /* Warn if function was previously implicitly declared
13416      (but not if we warned then).  */
13417   if (! warn_implicit
13418       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13419     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13420
13421   /* Set up current_class_type, and enter the scope of the class, if
13422      appropriate.  */
13423   if (ctype)
13424     push_nested_class (ctype, 1);
13425   else if (DECL_STATIC_FUNCTION_P (decl1))
13426     push_nested_class (DECL_CONTEXT (decl1), 2);
13427
13428   /* Now that we have entered the scope of the class, we must restore
13429      the bindings for any template parameters surrounding DECL1, if it
13430      is an inline member template.  (Order is important; consider the
13431      case where a template parameter has the same name as a field of
13432      the class.)  It is not until after this point that
13433      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13434   if (flags & SF_INCLASS_INLINE)
13435     maybe_begin_member_template_processing (decl1);
13436
13437   /* Effective C++ rule 15.  */
13438   if (warn_ecpp
13439       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13440       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13441     cp_warning ("`operator=' should return a reference to `*this'");
13442
13443   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13444      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13445   if (!DECL_INITIAL (decl1))
13446     DECL_INITIAL (decl1) = error_mark_node;
13447
13448 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13449   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13450 #endif
13451
13452   /* This function exists in static storage.
13453      (This does not mean `static' in the C sense!)  */
13454   TREE_STATIC (decl1) = 1;
13455
13456   /* We must call push_template_decl after current_class_type is set
13457      up.  (If we are processing inline definitions after exiting a
13458      class scope, current_class_type will be NULL_TREE until set above
13459      by push_nested_class.)  */
13460   if (processing_template_decl)
13461     decl1 = push_template_decl (decl1);
13462
13463   /* We are now in the scope of the function being defined.  */
13464   current_function_decl = decl1;
13465
13466   /* Save the parm names or decls from this function's declarator
13467      where store_parm_decls will find them.  */
13468   current_function_parms = last_function_parms;
13469   current_function_parm_tags = last_function_parm_tags;
13470
13471   /* Make sure the parameter and return types are reasonable.  When
13472      you declare a function, these types can be incomplete, but they
13473      must be complete when you define the function.  */
13474   if (! processing_template_decl)
13475     check_function_type (decl1, current_function_parms);
13476
13477   /* Build the return declaration for the function.  */
13478   restype = TREE_TYPE (fntype);
13479   if (!processing_template_decl)
13480     {
13481       if (!DECL_RESULT (decl1))
13482         {
13483           DECL_RESULT (decl1)
13484             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13485           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13486                                       DECL_RESULT (decl1));
13487         }
13488     }
13489   else
13490     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13491     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13492
13493   /* Initialize RTL machinery.  We cannot do this until
13494      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13495      even when processing a template; this is how we get
13496      CFUN set up, and our per-function variables initialized.
13497      FIXME factor out the non-RTL stuff.  */
13498   bl = current_binding_level;
13499   init_function_start (decl1, input_filename, lineno);
13500   current_binding_level = bl;
13501
13502   /* Even though we're inside a function body, we still don't want to
13503      call expand_expr to calculate the size of a variable-sized array.
13504      We haven't necessarily assigned RTL to all variables yet, so it's
13505      not safe to try to expand expressions involving them.  */
13506   immediate_size_expand = 0;
13507   cfun->x_dont_save_pending_sizes_p = 1;
13508
13509   /* Start the statement-tree, start the tree now.  */
13510   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13511
13512   /* Let the user know we're compiling this function.  */
13513   announce_function (decl1);
13514
13515   /* Record the decl so that the function name is defined.
13516      If we already have a decl for this name, and it is a FUNCTION_DECL,
13517      use the old decl.  */
13518   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13519     {
13520       /* A specialization is not used to guide overload resolution.  */
13521       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13522           && ! DECL_FUNCTION_MEMBER_P (decl1))
13523         decl1 = pushdecl (decl1);
13524       else
13525         {
13526           /* We need to set the DECL_CONTEXT. */
13527           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13528             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13529           /* And make sure we have enough default args.  */
13530           check_default_args (decl1);
13531         }
13532       fntype = TREE_TYPE (decl1);
13533     }
13534
13535   /* Reset these in case the call to pushdecl changed them.  */
13536   current_function_decl = decl1;
13537   cfun->decl = decl1;
13538
13539   /* If we are (erroneously) defining a function that we have already
13540      defined before, wipe out what we knew before.  */
13541   if (!DECL_PENDING_INLINE_P (decl1)
13542       && DECL_SAVED_FUNCTION_DATA (decl1))
13543     {
13544       free (DECL_SAVED_FUNCTION_DATA (decl1));
13545       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13546     }
13547
13548   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13549     {
13550       /* We know that this was set up by `grokclassfn'.  We do not
13551          wait until `store_parm_decls', since evil parse errors may
13552          never get us to that point.  Here we keep the consistency
13553          between `current_class_type' and `current_class_ptr'.  */
13554       tree t = DECL_ARGUMENTS (decl1);
13555
13556       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13557                           162);
13558       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13559                           19990811);
13560
13561       cp_function_chain->x_current_class_ref
13562         = build_indirect_ref (t, NULL);
13563       cp_function_chain->x_current_class_ptr = t;
13564
13565       /* Constructors and destructors need to know whether they're "in
13566          charge" of initializing virtual base classes.  */
13567       t = TREE_CHAIN (t);
13568       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13569         {
13570           current_in_charge_parm = t;
13571           t = TREE_CHAIN (t);
13572         }
13573       if (DECL_HAS_VTT_PARM_P (decl1))
13574         {
13575           if (DECL_NAME (t) != vtt_parm_identifier)
13576             abort ();
13577           current_vtt_parm = t;
13578         }
13579     }
13580
13581   if (DECL_INTERFACE_KNOWN (decl1))
13582     {
13583       tree ctx = decl_function_context (decl1);
13584
13585       if (DECL_NOT_REALLY_EXTERN (decl1))
13586         DECL_EXTERNAL (decl1) = 0;
13587
13588       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13589           && TREE_PUBLIC (ctx))
13590         /* This is a function in a local class in an extern inline
13591            function.  */
13592         comdat_linkage (decl1);
13593     }
13594   /* If this function belongs to an interface, it is public.
13595      If it belongs to someone else's interface, it is also external.
13596      This only affects inlines and template instantiations.  */
13597   else if (interface_unknown == 0
13598            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13599                || flag_alt_external_templates))
13600     {
13601       if (DECL_DECLARED_INLINE_P (decl1)
13602           || DECL_TEMPLATE_INSTANTIATION (decl1)
13603           || processing_template_decl)
13604         {
13605           DECL_EXTERNAL (decl1)
13606             = (interface_only
13607                || (DECL_DECLARED_INLINE_P (decl1)
13608                    && ! flag_implement_inlines
13609                    && !DECL_VINDEX (decl1)));
13610
13611           /* For WIN32 we also want to put these in linkonce sections.  */
13612           maybe_make_one_only (decl1);
13613         }
13614       else
13615         DECL_EXTERNAL (decl1) = 0;
13616       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13617       DECL_INTERFACE_KNOWN (decl1) = 1;
13618     }
13619   else if (interface_unknown && interface_only
13620            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13621                || flag_alt_external_templates))
13622     {
13623       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13624          interface, we will have interface_only set but not
13625          interface_known.  In that case, we don't want to use the normal
13626          heuristics because someone will supply a #pragma implementation
13627          elsewhere, and deducing it here would produce a conflict.  */
13628       comdat_linkage (decl1);
13629       DECL_EXTERNAL (decl1) = 0;
13630       DECL_INTERFACE_KNOWN (decl1) = 1;
13631       DECL_DEFER_OUTPUT (decl1) = 1;
13632     }
13633   else
13634     {
13635       /* This is a definition, not a reference.
13636          So clear DECL_EXTERNAL.  */
13637       DECL_EXTERNAL (decl1) = 0;
13638
13639       if ((DECL_DECLARED_INLINE_P (decl1)
13640            || DECL_TEMPLATE_INSTANTIATION (decl1))
13641           && ! DECL_INTERFACE_KNOWN (decl1)
13642           /* Don't try to defer nested functions for now.  */
13643           && ! decl_function_context (decl1))
13644         DECL_DEFER_OUTPUT (decl1) = 1;
13645       else
13646         DECL_INTERFACE_KNOWN (decl1) = 1;
13647     }
13648
13649   pushlevel (0);
13650   current_binding_level->parm_flag = 1;
13651
13652   if (attrs)
13653     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13654
13655   /* Promote the value to int before returning it.  */
13656   if (c_promoting_integer_type_p (restype))
13657     restype = type_promotes_to (restype);
13658
13659   if (DECL_RESULT (decl1) == NULL_TREE)
13660     {
13661       DECL_RESULT (decl1)
13662         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13663       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13664       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13665     }
13666
13667   ++function_depth;
13668
13669   if (DECL_DESTRUCTOR_P (decl1))
13670     {
13671       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13672       DECL_CONTEXT (dtor_label) = current_function_decl;
13673     }
13674
13675   start_fname_decls ();
13676
13677   store_parm_decls (current_function_parms);
13678
13679   return 1;
13680 }
13681 \f
13682 /* Store the parameter declarations into the current function declaration.
13683    This is called after parsing the parameter declarations, before
13684    digesting the body of the function.
13685
13686    Also install to binding contour return value identifier, if any.  */
13687
13688 static void
13689 store_parm_decls (current_function_parms)
13690      tree current_function_parms;
13691 {
13692   register tree fndecl = current_function_decl;
13693   register tree parm;
13694   int parms_have_cleanups = 0;
13695   tree cleanups = NULL_TREE;
13696
13697   /* This is a list of types declared among parms in a prototype.  */
13698   tree parmtags = current_function_parm_tags;
13699
13700   /* This is a chain of any other decls that came in among the parm
13701      declarations.  If a parm is declared with  enum {foo, bar} x;
13702      then CONST_DECLs for foo and bar are put here.  */
13703   tree nonparms = NULL_TREE;
13704
13705   if (current_function_parms)
13706     {
13707       /* This case is when the function was defined with an ANSI prototype.
13708          The parms already have decls, so we need not do anything here
13709          except record them as in effect
13710          and complain if any redundant old-style parm decls were written.  */
13711
13712       tree specparms = current_function_parms;
13713       tree next;
13714
13715       /* Must clear this because it might contain TYPE_DECLs declared
13716              at class level.  */
13717       storedecls (NULL_TREE);
13718
13719       /* If we're doing semantic analysis, then we'll call pushdecl
13720              for each of these.  We must do them in reverse order so that
13721              they end in the correct forward order.  */
13722       specparms = nreverse (specparms);
13723
13724       for (parm = specparms; parm; parm = next)
13725         {
13726           next = TREE_CHAIN (parm);
13727           if (TREE_CODE (parm) == PARM_DECL)
13728             {
13729               tree cleanup;
13730
13731               if (DECL_NAME (parm) == NULL_TREE
13732                   || TREE_CODE (parm) != VOID_TYPE)
13733                 pushdecl (parm);
13734               else
13735                 cp_error ("parameter `%D' declared void", parm);
13736
13737               cleanup = (processing_template_decl
13738                          ? NULL_TREE
13739                          : maybe_build_cleanup (parm));
13740
13741               if (cleanup)
13742                 cleanups = tree_cons (parm, cleanup, cleanups);
13743             }
13744           else
13745             {
13746               /* If we find an enum constant or a type tag,
13747                  put it aside for the moment.  */
13748               TREE_CHAIN (parm) = NULL_TREE;
13749               nonparms = chainon (nonparms, parm);
13750             }
13751         }
13752
13753       /* Get the decls in their original chain order and record in the
13754          function.  This is all and only the PARM_DECLs that were
13755          pushed into scope by the loop above.  */
13756       DECL_ARGUMENTS (fndecl) = getdecls ();
13757       storetags (chainon (parmtags, gettags ()));
13758     }
13759   else
13760     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13761
13762   /* Now store the final chain of decls for the arguments
13763      as the decl-chain of the current lexical scope.
13764      Put the enumerators in as well, at the front so that
13765      DECL_ARGUMENTS is not modified.  */
13766   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13767
13768   /* Now that we have initialized the parms, we can start their
13769      cleanups.  We cannot do this before, since expand_decl_cleanup
13770      should not be called before the parm can be used.  */
13771   while (cleanups)
13772     {
13773       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13774                            TREE_VALUE (cleanups));
13775       cleanups = TREE_CHAIN (cleanups);
13776     }
13777
13778   /* Create a binding contour which can be used to catch
13779      cleanup-generated temporaries.  */
13780   if (parms_have_cleanups)
13781     pushlevel (0);
13782
13783   /* Do the starting of the exception specifications, if we have any.  */
13784   if (flag_exceptions && !processing_template_decl
13785       && flag_enforce_eh_specs
13786       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13787     current_eh_spec_block = begin_eh_spec_block ();
13788 }
13789
13790 \f
13791 /* We have finished doing semantic analysis on DECL, but have not yet
13792    generated RTL for its body.  Save away our current state, so that
13793    when we want to generate RTL later we know what to do.  */
13794
13795 static void
13796 save_function_data (decl)
13797      tree decl;
13798 {
13799   struct cp_language_function *f;
13800
13801   /* Save the language-specific per-function data so that we can
13802      get it back when we really expand this function.  */
13803   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13804                       19990908);
13805
13806   /* Make a copy.  */
13807   f = ((struct cp_language_function *)
13808        xmalloc (sizeof (struct cp_language_function)));
13809   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13810   DECL_SAVED_FUNCTION_DATA (decl) = f;
13811
13812   /* Clear out the bits we don't need.  */
13813   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13814   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13815   f->x_named_label_uses = NULL;
13816   f->bindings = NULL;
13817   f->x_local_names = NULL;
13818
13819   /* When we get back here again, we will be expanding.  */
13820   f->x_expanding_p = 1;
13821
13822   /* If we've already decided that we cannot inline this function, we
13823      must remember that fact when we actually go to expand the
13824      function.  */
13825   if (current_function_cannot_inline)
13826     {
13827       f->cannot_inline = current_function_cannot_inline;
13828       DECL_INLINE (decl) = 0;
13829     }
13830 }
13831
13832 /* At the end of every constructor we generate to code to return
13833    `this'.  Do that now.  */
13834
13835 static void
13836 finish_constructor_body ()
13837 {
13838   /* Any return from a constructor will end up here.  */
13839   if (ctor_label)
13840     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13841
13842   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13843      generate the return, rather than a goto to CTOR_LABEL.  */
13844   ctor_label = NULL_TREE;
13845   /* In check_return_expr we translate an empty return from a
13846      constructor to a return of `this'.  */
13847   finish_return_stmt (NULL_TREE);
13848   /* Mark the end of the constructor.  */
13849   add_stmt (build_stmt (CTOR_STMT));
13850 }
13851
13852 /* At the end of every destructor we generate code to restore virtual
13853    function tables to the values desired by base classes and to call
13854    to base class destructors.  Do that now.  */
13855
13856 static void
13857 finish_destructor_body ()
13858 {
13859   tree compound_stmt;
13860   tree exprstmt;
13861
13862   /* Create a block to contain all the extra code.  */
13863   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13864
13865   /* Any return from a destructor will end up here.  */
13866   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13867
13868   /* Generate the code to call destructor on base class.  If this
13869      destructor belongs to a class with virtual functions, then set
13870      the virtual function table pointer to represent the type of our
13871      base class.  */
13872
13873   /* This side-effect makes call to `build_delete' generate the code
13874      we have to have at the end of this destructor.  `build_delete'
13875      will set the flag again.  */
13876   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13877
13878   exprstmt = build_delete (current_class_type,
13879                            current_class_ref,
13880                            sfk_base_destructor,
13881                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13882                            0);
13883
13884   if (exprstmt != error_mark_node
13885       && (TREE_CODE (exprstmt) != NOP_EXPR
13886           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13887           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13888     {
13889       if (exprstmt != void_zero_node)
13890         /* Don't call `expand_expr_stmt' if we're not going to do
13891            anything, since -Wall will give a diagnostic.  */
13892         finish_expr_stmt (exprstmt);
13893
13894       /* Run destructors for all virtual baseclasses.  */
13895       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13896         {
13897           tree vbases;
13898           tree if_stmt;
13899
13900           if_stmt = begin_if_stmt ();
13901           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13902                                       current_in_charge_parm,
13903                                       integer_two_node),
13904                                if_stmt);
13905
13906           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13907           /* The CLASSTYPE_VBASECLASSES list is in initialization
13908              order, so we have to march through it in reverse order.  */
13909           for (vbases = nreverse (copy_list (vbases));
13910                vbases;
13911                vbases = TREE_CHAIN (vbases))
13912             {
13913               tree vbase = TREE_VALUE (vbases);
13914               tree base_type = BINFO_TYPE (vbase);
13915
13916               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13917                 {
13918                   tree base_ptr_type = build_pointer_type (base_type);
13919                   tree expr = current_class_ptr;
13920
13921                   /* Convert to the basetype here, as we know the layout is
13922                      fixed. What is more, if we let build_method_call do it,
13923                      it will use the vtable, which may have been clobbered
13924                      by the deletion of our primary base.  */
13925
13926                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13927                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13928                                 BINFO_OFFSET (vbase));
13929                   expr = build_indirect_ref (expr, NULL);
13930                   expr = build_method_call (expr, base_dtor_identifier,
13931                                             NULL_TREE, vbase,
13932                                             LOOKUP_NORMAL);
13933                   finish_expr_stmt (expr);
13934                 }
13935             }
13936
13937           finish_then_clause (if_stmt);
13938           finish_if_stmt ();
13939         }
13940     }
13941
13942   /* In a virtual destructor, we must call delete.  */
13943   if (DECL_VIRTUAL_P (current_function_decl))
13944     {
13945       tree if_stmt;
13946       tree virtual_size = c_sizeof (current_class_type);
13947
13948       /* [class.dtor]
13949
13950          At the point of definition of a virtual destructor (including
13951          an implicit definition), non-placement operator delete shall
13952          be looked up in the scope of the destructor's class and if
13953          found shall be accessible and unambiguous.  */
13954       exprstmt = build_op_delete_call
13955         (DELETE_EXPR, current_class_ptr, virtual_size,
13956          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13957
13958       if_stmt = begin_if_stmt ();
13959       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13960                                   current_in_charge_parm,
13961                                   integer_one_node),
13962                            if_stmt);
13963       finish_expr_stmt (exprstmt);
13964       finish_then_clause (if_stmt);
13965       finish_if_stmt ();
13966     }
13967
13968   /* Close the block we started above.  */
13969   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13970 }
13971
13972 /* Finish up a function declaration and compile that function
13973    all the way to assembler language output.  The free the storage
13974    for the function definition.
13975
13976    FLAGS is a bitwise or of the following values:
13977      1 - CALL_POPLEVEL
13978        An extra call to poplevel (and expand_end_bindings) must be
13979        made to take care of the binding contour for the base
13980        initializers.  This is only relevant for constructors.
13981      2 - INCLASS_INLINE
13982        We just finished processing the body of an in-class inline
13983        function definition.  (This processing will have taken place
13984        after the class definition is complete.)  */
13985
13986 tree
13987 finish_function (flags)
13988      int flags;
13989 {
13990   register tree fndecl = current_function_decl;
13991   tree fntype, ctype = NULL_TREE;
13992   int call_poplevel = (flags & 1) != 0;
13993   int inclass_inline = (flags & 2) != 0;
13994   int nested;
13995
13996   /* When we get some parse errors, we can end up without a
13997      current_function_decl, so cope.  */
13998   if (fndecl == NULL_TREE)
13999     return error_mark_node;
14000
14001   nested = function_depth > 1;
14002   fntype = TREE_TYPE (fndecl);
14003
14004   /*  TREE_READONLY (fndecl) = 1;
14005       This caused &foo to be of type ptr-to-const-function
14006       which then got a warning when stored in a ptr-to-function variable.  */
14007
14008   my_friendly_assert (building_stmt_tree (), 20000911);
14009
14010   finish_fname_decls ();
14011
14012   /* For a cloned function, we've already got all the code we need;
14013      there's no need to add any extra bits.  */
14014   if (!DECL_CLONED_FUNCTION_P (fndecl))
14015     {
14016       if (DECL_CONSTRUCTOR_P (fndecl))
14017         {
14018           finish_constructor_body ();
14019           if (call_poplevel)
14020             do_poplevel ();
14021         }
14022       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14023         finish_destructor_body ();
14024       else if (DECL_MAIN_P (fndecl))
14025         {
14026           /* Make it so that `main' always returns 0 by default.  */
14027 #ifdef VMS
14028           finish_return_stmt (integer_one_node);
14029 #else
14030           finish_return_stmt (integer_zero_node);
14031 #endif
14032         }
14033
14034       /* Finish dealing with exception specifiers.  */
14035       if (flag_exceptions && !processing_template_decl
14036           && flag_enforce_eh_specs
14037           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14038         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14039                               (TREE_TYPE (current_function_decl)),
14040                               current_eh_spec_block);
14041     }
14042
14043   /* If we're saving up tree structure, tie off the function now.  */
14044   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14045
14046   /* This must come after expand_function_end because cleanups might
14047      have declarations (from inline functions) that need to go into
14048      this function's blocks.  */
14049   if (current_binding_level->parm_flag != 1)
14050     my_friendly_abort (122);
14051   poplevel (1, 0, 1);
14052
14053   /* Remember that we were in class scope.  */
14054   if (current_class_name)
14055     ctype = current_class_type;
14056
14057   /* Must mark the RESULT_DECL as being in this function.  */
14058   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14059
14060   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14061      to the FUNCTION_DECL node itself.  */
14062   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14063
14064   /* Save away current state, if appropriate.  */
14065   if (!processing_template_decl)
14066     save_function_data (fndecl);
14067
14068   /* If this function calls `setjmp' it cannot be inlined.  When
14069      `longjmp' is called it is not guaranteed to restore the value of
14070      local variables that have been modified since the call to
14071      `setjmp'.  So, if were to inline this function into some caller
14072      `c', then when we `longjmp', we might not restore all variables
14073      in `c'.  (It might seem, at first blush, that there's no way for
14074      this function to modify local variables in `c', but their
14075      addresses may have been stored somewhere accessible to this
14076      function.)  */
14077   if (!processing_template_decl && calls_setjmp_p (fndecl))
14078     DECL_UNINLINABLE (fndecl) = 1;
14079
14080   /* Clear out memory we no longer need.  */
14081   free_after_parsing (cfun);
14082   /* Since we never call rest_of_compilation, we never clear
14083      CFUN.  Do so explicitly.  */
14084   free_after_compilation (cfun);
14085   cfun = NULL;
14086
14087   /* If this is a in-class inline definition, we may have to pop the
14088      bindings for the template parameters that we added in
14089      maybe_begin_member_template_processing when start_function was
14090      called.  */
14091   if (inclass_inline)
14092     maybe_end_member_template_processing ();
14093
14094   /* Leave the scope of the class.  */
14095   if (ctype)
14096     pop_nested_class ();
14097
14098   --function_depth;
14099
14100   /* Clean up.  */
14101   if (! nested)
14102     /* Let the error reporting routines know that we're outside a
14103        function.  For a nested function, this value is used in
14104        pop_cp_function_context and then reset via pop_function_context.  */
14105     current_function_decl = NULL_TREE;
14106
14107   return fndecl;
14108 }
14109 \f
14110 /* Create the FUNCTION_DECL for a function definition.
14111    DECLSPECS and DECLARATOR are the parts of the declaration;
14112    they describe the return type and the name of the function,
14113    but twisted together in a fashion that parallels the syntax of C.
14114
14115    This function creates a binding context for the function body
14116    as well as setting up the FUNCTION_DECL in current_function_decl.
14117
14118    Returns a FUNCTION_DECL on success.
14119
14120    If the DECLARATOR is not suitable for a function (it defines a datum
14121    instead), we return 0, which tells yyparse to report a parse error.
14122
14123    May return void_type_node indicating that this method is actually
14124    a friend.  See grokfield for more details.
14125
14126    Came here with a `.pushlevel' .
14127
14128    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14129    CHANGES TO CODE IN `grokfield'.  */
14130
14131 tree
14132 start_method (declspecs, declarator, attrlist)
14133      tree declarator, declspecs, attrlist;
14134 {
14135   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14136                                 attrlist);
14137
14138   /* Something too ugly to handle.  */
14139   if (fndecl == NULL_TREE)
14140     return NULL_TREE;
14141
14142   /* Pass friends other than inline friend functions back.  */
14143   if (fndecl == void_type_node)
14144     return fndecl;
14145
14146   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14147     /* Not a function, tell parser to report parse error.  */
14148     return NULL_TREE;
14149
14150   if (DECL_IN_AGGR_P (fndecl))
14151     {
14152       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14153         {
14154           if (DECL_CONTEXT (fndecl)
14155               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14156             cp_error ("`%D' is already defined in class `%T'", fndecl,
14157                       DECL_CONTEXT (fndecl));
14158         }
14159       return void_type_node;
14160     }
14161
14162   check_template_shadow (fndecl);
14163
14164   DECL_DECLARED_INLINE_P (fndecl) = 1;
14165
14166   if (flag_default_inline)
14167     DECL_INLINE (fndecl) = 1;
14168
14169   /* We process method specializations in finish_struct_1.  */
14170   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14171     fndecl = push_template_decl (fndecl);
14172
14173   if (! DECL_FRIEND_P (fndecl))
14174     {
14175       if (TREE_CHAIN (fndecl))
14176         {
14177           fndecl = copy_node (fndecl);
14178           TREE_CHAIN (fndecl) = NULL_TREE;
14179         }
14180
14181       if (DECL_CONSTRUCTOR_P (fndecl))
14182         {
14183           if (! grok_ctor_properties (current_class_type, fndecl))
14184             return void_type_node;
14185         }
14186       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14187         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14188     }
14189
14190   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14191
14192   /* Make a place for the parms */
14193   pushlevel (0);
14194   current_binding_level->parm_flag = 1;
14195
14196   DECL_IN_AGGR_P (fndecl) = 1;
14197   return fndecl;
14198 }
14199
14200 /* Go through the motions of finishing a function definition.
14201    We don't compile this method until after the whole class has
14202    been processed.
14203
14204    FINISH_METHOD must return something that looks as though it
14205    came from GROKFIELD (since we are defining a method, after all).
14206
14207    This is called after parsing the body of the function definition.
14208    STMTS is the chain of statements that makes up the function body.
14209
14210    DECL is the ..._DECL that `start_method' provided.  */
14211
14212 tree
14213 finish_method (decl)
14214      tree decl;
14215 {
14216   register tree fndecl = decl;
14217   tree old_initial;
14218
14219   register tree link;
14220
14221   if (decl == void_type_node)
14222     return decl;
14223
14224   old_initial = DECL_INITIAL (fndecl);
14225
14226   /* Undo the level for the parms (from start_method).
14227      This is like poplevel, but it causes nothing to be
14228      saved.  Saving information here confuses symbol-table
14229      output routines.  Besides, this information will
14230      be correctly output when this method is actually
14231      compiled.  */
14232
14233   /* Clear out the meanings of the local variables of this level;
14234      also record in each decl which block it belongs to.  */
14235
14236   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14237     {
14238       if (DECL_NAME (link) != NULL_TREE)
14239         pop_binding (DECL_NAME (link), link);
14240       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14241       DECL_CONTEXT (link) = NULL_TREE;
14242     }
14243
14244   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14245                       (HOST_WIDE_INT) current_binding_level->level_chain,
14246                       current_binding_level->parm_flag,
14247                       current_binding_level->keep);
14248
14249   poplevel (0, 0, 0);
14250
14251   DECL_INITIAL (fndecl) = old_initial;
14252
14253   /* We used to check if the context of FNDECL was different from
14254      current_class_type as another way to get inside here.  This didn't work
14255      for String.cc in libg++.  */
14256   if (DECL_FRIEND_P (fndecl))
14257     {
14258       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14259         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14260       decl = void_type_node;
14261     }
14262
14263   return decl;
14264 }
14265 \f
14266 /* Called when a new struct TYPE is defined.
14267    If this structure or union completes the type of any previous
14268    variable declaration, lay it out and output its rtl.  */
14269
14270 void
14271 hack_incomplete_structures (type)
14272      tree type;
14273 {
14274   tree *list;
14275   struct binding_level *level;
14276
14277   if (!type) /* Don't do this for class templates.  */
14278     return;
14279
14280   if (namespace_bindings_p ())
14281     {
14282       level = 0;
14283       list = &namespace_scope_incomplete;
14284     }
14285   else
14286     {
14287       level = innermost_nonclass_level ();
14288       list = &level->incomplete;
14289     }
14290
14291   while (1)
14292     {
14293       while (*list)
14294         {
14295           tree decl = TREE_VALUE (*list);
14296           if ((decl && TREE_TYPE (decl) == type)
14297               || (TREE_TYPE (decl)
14298                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14299                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14300             {
14301               int toplevel = toplevel_bindings_p ();
14302               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14303                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14304                 layout_type (TREE_TYPE (decl));
14305               layout_decl (decl, 0);
14306               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14307               if (! toplevel)
14308                 {
14309                   tree cleanup;
14310                   expand_decl (decl);
14311                   cleanup = maybe_build_cleanup (decl);
14312                   expand_decl_init (decl);
14313                   if (! expand_decl_cleanup (decl, cleanup))
14314                     cp_error ("parser lost in parsing declaration of `%D'",
14315                               decl);
14316                 }
14317               *list = TREE_CHAIN (*list);
14318             }
14319           else
14320             list = &TREE_CHAIN (*list);
14321         }
14322
14323       /* Keep looking through artificial binding levels generated
14324          for local variables.  */
14325       if (level && level->keep == 2)
14326         {
14327           level = level->level_chain;
14328           list = &level->incomplete;
14329         }
14330       else
14331         break;
14332     }
14333 }
14334
14335 /* If DECL is of a type which needs a cleanup, build that cleanup
14336    here.  */
14337
14338 tree
14339 maybe_build_cleanup (decl)
14340      tree decl;
14341 {
14342   tree type = TREE_TYPE (decl);
14343
14344   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14345     {
14346       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14347       tree rval;
14348
14349       if (TREE_CODE (type) == ARRAY_TYPE)
14350         rval = decl;
14351       else
14352         {
14353           mark_addressable (decl);
14354           rval = build_unary_op (ADDR_EXPR, decl, 0);
14355         }
14356
14357       /* Optimize for space over speed here.  */
14358       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14359           || flag_expensive_optimizations)
14360         flags |= LOOKUP_NONVIRTUAL;
14361
14362       rval = build_delete (TREE_TYPE (rval), rval,
14363                            sfk_complete_destructor, flags, 0);
14364
14365       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14366           && ! TYPE_HAS_DESTRUCTOR (type))
14367         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14368                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14369
14370       return rval;
14371     }
14372   return 0;
14373 }
14374 \f
14375 /* When a stmt has been parsed, this function is called.  */
14376
14377 void
14378 finish_stmt ()
14379 {
14380   /* Always assume this statement was not an expression statement.  If
14381      it actually was an expression statement, its our callers
14382      responsibility to fix this up.  */
14383   last_expr_type = NULL_TREE;
14384 }
14385
14386 /* DECL was originally constructed as a non-static member function,
14387    but turned out to be static.  Update it accordingly.  */
14388
14389 void
14390 revert_static_member_fn (decl)
14391      tree decl;
14392 {
14393   tree tmp;
14394   tree function = TREE_TYPE (decl);
14395   tree args = TYPE_ARG_TYPES (function);
14396
14397   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14398       != TYPE_UNQUALIFIED)
14399     cp_error ("static member function `%#D' declared with type qualifiers",
14400               decl);
14401
14402   args = TREE_CHAIN (args);
14403   tmp = build_function_type (TREE_TYPE (function), args);
14404   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14405   tmp = build_exception_variant (tmp,
14406                                  TYPE_RAISES_EXCEPTIONS (function));
14407   TREE_TYPE (decl) = tmp;
14408   if (DECL_ARGUMENTS (decl))
14409     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14410   DECL_STATIC_FUNCTION_P (decl) = 1;
14411 }
14412
14413 /* Initialize the variables used during compilation of a C++
14414    function.  */
14415
14416 static void
14417 push_cp_function_context (f)
14418      struct function *f;
14419 {
14420   struct cp_language_function *p
14421     = ((struct cp_language_function *)
14422        xcalloc (1, sizeof (struct cp_language_function)));
14423   f->language = (struct language_function *) p;
14424
14425   /* It takes an explicit call to expand_body to generate RTL for a
14426      function.  */
14427   expanding_p = 0;
14428
14429   /* Whenever we start a new function, we destroy temporaries in the
14430      usual way.  */
14431   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14432 }
14433
14434 /* Free the language-specific parts of F, now that we've finished
14435    compiling the function.  */
14436
14437 static void
14438 pop_cp_function_context (f)
14439      struct function *f;
14440 {
14441   if (f->language)
14442     {
14443       struct cp_language_function *cp =
14444         (struct cp_language_function *) f->language;
14445       if (cp->x_local_names)
14446         VARRAY_FREE (cp->x_local_names);
14447       free (f->language);
14448     }
14449   f->language = 0;
14450 }
14451
14452 /* Mark P for GC.  */
14453
14454 static void
14455 mark_lang_function (p)
14456      struct cp_language_function *p;
14457 {
14458   if (!p)
14459     return;
14460
14461   mark_c_language_function (&p->base);
14462
14463   ggc_mark_tree (p->x_ctor_label);
14464   ggc_mark_tree (p->x_dtor_label);
14465   ggc_mark_tree (p->x_current_class_ptr);
14466   ggc_mark_tree (p->x_current_class_ref);
14467   ggc_mark_tree (p->x_eh_spec_block);
14468   ggc_mark_tree_varray (p->x_local_names);
14469
14470   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14471   mark_binding_level (&p->bindings);
14472 }
14473
14474 /* Mark the language-specific data in F for GC.  */
14475
14476 static void
14477 mark_cp_function_context (f)
14478      struct function *f;
14479 {
14480   mark_lang_function ((struct cp_language_function *) f->language);
14481 }
14482
14483 void
14484 lang_mark_tree (t)
14485      tree t;
14486 {
14487   enum tree_code code = TREE_CODE (t);
14488   if (code == IDENTIFIER_NODE)
14489     {
14490       struct lang_identifier *li = (struct lang_identifier *) t;
14491       struct lang_id2 *li2 = li->x;
14492       ggc_mark_tree (li->namespace_bindings);
14493       ggc_mark_tree (li->bindings);
14494       ggc_mark_tree (li->class_value);
14495       ggc_mark_tree (li->class_template_info);
14496
14497       if (li2)
14498         {
14499           ggc_mark_tree (li2->label_value);
14500           ggc_mark_tree (li2->implicit_decl);
14501           ggc_mark_tree (li2->error_locus);
14502         }
14503     }
14504   else if (code == CPLUS_BINDING)
14505     {
14506       if (BINDING_HAS_LEVEL_P (t))
14507         mark_binding_level (&BINDING_LEVEL (t));
14508       else
14509         ggc_mark_tree (BINDING_SCOPE (t));
14510       ggc_mark_tree (BINDING_VALUE (t));
14511     }
14512   else if (code == OVERLOAD)
14513     ggc_mark_tree (OVL_FUNCTION (t));
14514   else if (code == TEMPLATE_PARM_INDEX)
14515     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14516   else if (TREE_CODE_CLASS (code) == 'd')
14517     {
14518       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14519
14520       if (ld)
14521         {
14522           ggc_mark (ld);
14523           c_mark_lang_decl (&ld->decl_flags.base);
14524           if (!DECL_GLOBAL_CTOR_P (t)
14525               && !DECL_GLOBAL_DTOR_P (t)
14526               && !DECL_THUNK_P (t)
14527               && !DECL_DISCRIMINATOR_P (t))
14528             ggc_mark_tree (ld->decl_flags.u2.access);
14529           else if (DECL_THUNK_P (t))
14530             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14531           if (TREE_CODE (t) != NAMESPACE_DECL)
14532             ggc_mark_tree (ld->decl_flags.u.template_info);
14533           else
14534             mark_binding_level (&NAMESPACE_LEVEL (t));
14535           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14536             {
14537               ggc_mark_tree (ld->befriending_classes);
14538               ggc_mark_tree (ld->context);
14539               ggc_mark_tree (ld->cloned_function);
14540               ggc_mark_tree (ld->inlined_fns);
14541               if (TREE_CODE (t) == TYPE_DECL)
14542                 ggc_mark_tree (ld->u.sorted_fields);
14543               else if (TREE_CODE (t) == FUNCTION_DECL
14544                        && !DECL_PENDING_INLINE_P (t))
14545                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14546             }
14547         }
14548     }
14549   else if (TREE_CODE_CLASS (code) == 't')
14550     {
14551       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14552
14553       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14554                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14555         {
14556           ggc_mark (lt);
14557           ggc_mark_tree (lt->primary_base);
14558           ggc_mark_tree (lt->vfields);
14559           ggc_mark_tree (lt->vbases);
14560           ggc_mark_tree (lt->tags);
14561           ggc_mark_tree (lt->size);
14562           ggc_mark_tree (lt->pure_virtuals);
14563           ggc_mark_tree (lt->friend_classes);
14564           ggc_mark_tree (lt->rtti);
14565           ggc_mark_tree (lt->methods);
14566           ggc_mark_tree (lt->template_info);
14567           ggc_mark_tree (lt->befriending_classes);
14568         }
14569       else if (lt)
14570         /* In the case of pointer-to-member function types, the
14571            TYPE_LANG_SPECIFIC is really just a tree.  */
14572         ggc_mark_tree ((tree) lt);
14573     }
14574 }
14575
14576 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14577    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14578
14579 tree
14580 identifier_global_value (t)
14581      tree t;
14582 {
14583   return IDENTIFIER_GLOBAL_VALUE (t);
14584 }
14585
14586 /* Build the void_list_node (void_type_node having been created).  */
14587 tree
14588 build_void_list_node ()
14589 {
14590   tree t = build_tree_list (NULL_TREE, void_type_node);
14591   TREE_PARMLIST (t) = 1;
14592   return t;
14593 }
14594
14595 static int
14596 cp_missing_noreturn_ok_p (decl)
14597      tree decl;
14598 {
14599   /* A missing noreturn is ok for the `main' function.  */
14600   return DECL_MAIN_P (decl);
14601 }